Update icons; Use separate VM for music section

Author: justcoding121

src/Bible.Alarm.Shared/Models/Schedule/AlarmSchedule.cs

@@ -404,6 +404,9 @@ int GetPublicationSortPriority(string code)
                 throw new InvalidOperationException($"No tracks found in section {randomSection.SectionCode} for melody music publication {sample.Music.PublicationCode}");
             }
 
+            // Set the section code for the selected section
+            sample.Music.SectionCode = randomSection.SectionCode;
+            
             // Select a random track from the selected section
             var randomTrack = randomSection.Tracks[Random.Shared.Next(randomSection.Tracks.Count)];
             sample.Music.TrackNumber = randomTrack.Number;

src/Bible.Alarm.Shared/Services/Media/BiblePublicationSectionService.cs

@@ -107,6 +107,76 @@ public async Task<SortedDictionary<int, BiblePublicationSection>> GetSectionsByP
         }
     }
 
+    public async Task<SortedDictionary<int, BiblePublicationSection>> GetMusicSectionsByPublicationAsync(string publicationCode, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var scope = scopeFactory.CreateScope();
+            var dbContext = scope.ServiceProvider.GetRequiredService<MediaDbContext>();
+
+            // Load sections for music publications (Category=Music, LanguageId=null)
+            var sections = await dbContext.BiblePublications
+                .AsNoTracking()
+                .Include(x => x.Category)
+                .Include(x => x.Sections)
+                    .ThenInclude(s => s.UrlParams)
+                .Where(x => x.Category.CategoryName == "Music"
+                    && x.LanguageId == null
+                    && x.PublicationCode == publicationCode)
+                .SelectMany(x => x.Sections)
+                .ToListAsync(cancellationToken);
+
+            // Filter sections that have numeric SectionCode and order by it
+            // For music sections like "iam-1", "iam-2", we need to handle both numeric and non-numeric codes
+            var sectionsByNumber = new Dictionary<int, BiblePublicationSection>();
+            foreach (var section in sections)
+            {
+                // Try to parse SectionCode as int (for numeric codes)
+                if (int.TryParse(section.SectionCode, out var sectionNumber))
+                {
+                    if (!sectionsByNumber.ContainsKey(sectionNumber))
+                    {
+                        sectionsByNumber[sectionNumber] = section;
+                    }
+                }
+                else
+                {
+                    // For non-numeric codes like "iam-1", extract the number part
+                    // e.g., "iam-1" -> 1, "iam-2" -> 2
+                    var parts = section.SectionCode.Split('-');
+                    if (parts.Length > 1 && int.TryParse(parts[parts.Length - 1], out var extractedNumber))
+                    {
+                        if (!sectionsByNumber.ContainsKey(extractedNumber))
+                        {
+                            sectionsByNumber[extractedNumber] = section;
+                        }
+                    }
+                    else
+                    {
+                        // If we can't extract a number, use 0 as a fallback (will be sorted last)
+                        if (!sectionsByNumber.ContainsKey(0))
+                        {
+                            sectionsByNumber[0] = section;
+                        }
+                    }
+                }
+            }
+
+            // Sort by the extracted number
+            var sortedSections = sectionsByNumber
+                .OrderBy(kvp => kvp.Key)
+                .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+
+            return new SortedDictionary<int, BiblePublicationSection>(sortedSections);
+        }
+        catch (Exception ex)
+        {
+            logger.Error(ex, "Error getting Music sections by publication. PublicationCode={PublicationCode}",
+                publicationCode);
+            throw;
+        }
+    }
+
     public void Dispose()
     {
         if (isDisposed)

src/Bible.Alarm.Shared/Services/Media/Interfaces/IBiblePublicationSectionService.cs

@@ -21,6 +21,12 @@ public interface IBiblePublicationSectionService : IDisposable
     /// Gets all BiblePublicationSections for a given publication (by language code and publication code).
     /// </summary>
     Task<SortedDictionary<int, BiblePublicationSection>> GetSectionsByPublicationAsync(string languageCode, string publicationCode, CancellationToken cancellationToken = default);
+    
+    /// <summary>
+    /// Gets sections for music publications (Category=Music, LanguageId=null).
+    /// Used for instrumental music like Kingdom Melodies.
+    /// </summary>
+    Task<SortedDictionary<int, BiblePublicationSection>> GetMusicSectionsByPublicationAsync(string publicationCode, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Gets a BiblePublicationSection by language code, publication code, and section number.

src/Bible.Alarm.Shared/Services/Media/Interfaces/IMelodyMusicService.cs

@@ -26,6 +26,11 @@ public interface IMelodyMusicService : IDisposable
     /// Gets all tracks for a MelodyMusic release by publication code, with Source included.
     /// </summary>
     Task<SortedDictionary<int, MusicTrack>> GetTracksByCodeAsync(string publicationCode, CancellationToken cancellationToken = default);
+    
+    /// <summary>
+    /// Gets tracks for a specific section in a music publication (e.g., "iam-1" section in Kingdom Melodies).
+    /// </summary>
+    Task<SortedDictionary<int, MusicTrack>> GetTracksBySectionCodeAsync(string publicationCode, string sectionCode, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Updates the URL for a MelodyMusic track's audio source.

src/Bible.Alarm.Shared/Services/Media/MelodyMusicService.cs

@@ -72,7 +72,7 @@ public sealed class MelodyMusicService(IServiceScopeFactory scopeFactory, ILogge
                 allTracks.AddRange(publication.Tracks);
             }
 
-            // Create a new publication object with all tracks combined
+            // Create a new publication object with all tracks combined AND sections
             var publicationWithTracks = new BiblePublication
             {
                 Id = publication.Id,
@@ -82,7 +82,8 @@ public sealed class MelodyMusicService(IServiceScopeFactory scopeFactory, ILogge
                 CategoryId = publication.CategoryId,
                 IsVideo = publication.IsVideo,
                 Category = publication.Category,
-                Tracks = allTracks
+                Tracks = allTracks,
+                Sections = publication.Sections // Include sections so GetSampleSchedule can select a section
             };
 
             // MelodyMusic is a subclass of BiblePublication, so we can return the publication directly
@@ -202,6 +203,63 @@ public async Task<SortedDictionary<int, MusicTrack>> GetTracksByCodeAsync(string
         }
     }
 
+    public async Task<SortedDictionary<int, MusicTrack>> GetTracksBySectionCodeAsync(string publicationCode, string sectionCode, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var scope = scopeFactory.CreateScope();
+            var dbContext = scope.ServiceProvider.GetRequiredService<MediaDbContext>();
+
+            // Get the publication with sections
+            var publication = await dbContext.BiblePublications
+                .AsNoTracking()
+                .Include(x => x.Category)
+                .Include(x => x.Sections)
+                    .ThenInclude(s => s.Tracks)
+                .Where(x => x.Category.CategoryName == MusicCategoryName 
+                    && x.LanguageId == null 
+                    && x.PublicationCode == publicationCode)
+                .FirstOrDefaultAsync(cancellationToken);
+
+            if (publication == null)
+            {
+                return new SortedDictionary<int, MusicTrack>();
+            }
+
+            // Find the section by section code
+            var section = publication.Sections?.FirstOrDefault(s => 
+                s.SectionCode != null && 
+                s.SectionCode.Equals(sectionCode, StringComparison.OrdinalIgnoreCase));
+
+            if (section == null || section.Tracks == null || section.Tracks.Count == 0)
+            {
+                return new SortedDictionary<int, MusicTrack>();
+            }
+
+            // Map BiblePublicationTrack to MusicTrack
+            var musicTracks = section.Tracks
+                .OrderBy(t => t.Number)
+                .Select(t => new MusicTrack
+                {
+                    Number = t.Number,
+                    Title = t.Title,
+                    Url = string.Empty, // URLs are computed on-demand
+                    LookUpPath = string.Empty,
+                    DownloadCode = null,
+                    OriginalTrackNumber = null
+                })
+                .ToDictionary(x => x.Number, x => x);
+
+            return new SortedDictionary<int, MusicTrack>(musicTracks);
+        }
+        catch (Exception ex)
+        {
+            logger.Error(ex, "Error getting MelodyMusic tracks by section. PublicationCode={PublicationCode}, SectionCode={SectionCode}", 
+                publicationCode, sectionCode);
+            throw;
+        }
+    }
+
     public async Task UpdateTrackUrlAsync(string publicationCode, int trackNumber, string url, CancellationToken cancellationToken = default)
     {
         // URLs are now computed on-demand, no need to store them

src/Bible.Alarm/Common/Helpers/ServiceRegistrationHelper.cs

@@ -306,6 +306,7 @@ private static void RegisterViewModels(IServiceCollection services)
         services.AddTransient<CategorySelectionViewModel>();
         services.AddTransient<SectionSelectionViewModel>();
         services.AddTransient<ViewModels.BiblePublications.TrackSelectionViewModel>();
+        services.AddTransient<ViewModels.Music.MusicSectionSelectionViewModel>();
         services.AddTransient<AlarmViewModel>();
         services.AddTransient<BiblePublicationSelectionContainerViewModel>();
         services.AddTransient<MusicSelectionContainerViewModel>();
@@ -344,6 +345,7 @@ private static void RegisterUiComponents(IServiceCollection services)
         services.AddTransient<BiblePublicationSelectionModal>();
         services.AddTransient<SectionSelectionModal>();
         services.AddTransient<Views.Music.TrackSelectionModal>();
+        services.AddTransient<Views.Music.MusicSectionSelectionModal>();
         services.AddTransient<MusicSelectionModal>();
         services.AddTransient<SongPublicationSelectionModal>();
         services.AddTransient<Views.Bible.TrackSelectionModal>();

src/Bible.Alarm/Services/Database/ScheduleMigrationService.cs

@@ -1,13 +1,11 @@
 using Bible.Alarm.Services.Database.Interfaces;
 using Bible.Alarm.Shared.Helpers;
-using Bible.Alarm.Shared.Services.Schedule.Interfaces;
 using Serilog;
 
 namespace Bible.Alarm.Services.Database;
 
 public sealed class ScheduleMigrationService(
-    ILogger logger,
-    IAlarmScheduleService alarmScheduleService)
+    ILogger logger)
     : IScheduleMigrationService, IDisposable
 {
     private readonly CancellationTokenSource cancellationTokenSource = new();

src/Bible.Alarm/Services/Media/BiblePublicationNavigationService.cs

@@ -1,3 +1,4 @@
+#nullable enable
 using Bible.Alarm.Services.Media.Interfaces;
 using Bible.Alarm.Shared.Models.Schedule;
 using Serilog;
@@ -30,12 +31,6 @@ private async Task<int> ConvertSectionCodeToIntAsync(string? sectionCode, string
         // If parsing fails, SectionCode is not numeric (e.g., "gen" for Genesis)
         // For non-numeric section codes, return 0
         return 0;
-        {
-            logger.Warning(ex, "Error converting SectionCode {SectionCode} to int for {LanguageCode}/{PublicationCode}",
-                sectionCode, languageCode, publicationCode);
-        }
-
-        return 0;
     }
 
     public async Task<bool> MoveToPreviousSectionAsync(BiblePublicationSchedule schedule)

src/Bible.Alarm/Services/Media/Interfaces/IMediaService.cs

@@ -9,11 +9,13 @@ public interface IMediaService : IDisposable
     Task<Dictionary<string, Language>> GetBiblePublicationLanguages();
     Task<Dictionary<string, BiblePublication>> GetBiblePublications(string languageCode);
     Task<SortedDictionary<int, BiblePublicationSection>> GetBiblePublicationSections(string languageCode, string versionCode);
+    Task<SortedDictionary<int, BiblePublicationSection>> GetMusicSections(string publicationCode);
     Task<BiblePublicationSection> GetBiblePublicationSection(string languageCode, string versionCode, int sectionNumber);
     Task<SortedDictionary<int, BiblePublicationTrack>> GetBiblePublicationTracks(string languageCode, string versionCode, int sectionNumber);
     Task<BiblePublicationTrack> GetBiblePublicationTrack(string languageCode, string versionCode, int sectionNumber, int trackNumber);
     Task<Dictionary<string, MelodyMusic>> GetMelodyMusicReleases();
     Task<SortedDictionary<int, MusicTrack>> GetMelodyMusicTracks(string publicationCode);
+    Task<SortedDictionary<int, MusicTrack>> GetMelodyMusicTracksBySection(string publicationCode, string sectionCode);
     Task<Dictionary<string, Language>> GetVocalMusicLanguages();
     Task<Dictionary<string, VocalMusic>> GetVocalMusicReleases(string languageCode);
     Task<SortedDictionary<int, MusicTrack>> GetVocalMusicTracks(string languageCode, string publicationCode);

src/Bible.Alarm/Services/Media/MediaService.cs

@@ -45,6 +45,12 @@ public async Task<SortedDictionary<int, BiblePublicationSection>> GetBiblePublic
         return await biblePublicationSectionService.GetSectionsByPublicationAsync(languageCode, versionCode, cancellationTokenSource.Token);
     }
 
+    public async Task<SortedDictionary<int, BiblePublicationSection>> GetMusicSections(string publicationCode)
+    {
+        await mediaIndexService.Verify();
+        return await biblePublicationSectionService.GetMusicSectionsByPublicationAsync(publicationCode, cancellationTokenSource.Token);
+    }
+
     public async Task<BiblePublicationSection> GetBiblePublicationSection(string languageCode, string versionCode, int sectionNumber)
     {
         await mediaIndexService.Verify();
@@ -78,6 +84,12 @@ public async Task<SortedDictionary<int, MusicTrack>>
         return await melodyMusicService.GetTracksByCodeAsync(publicationCode, cancellationTokenSource.Token);
     }
 
+    public async Task<SortedDictionary<int, MusicTrack>> GetMelodyMusicTracksBySection(string publicationCode, string sectionCode)
+    {
+        await mediaIndexService.Verify();
+        return await melodyMusicService.GetTracksBySectionCodeAsync(publicationCode, sectionCode, cancellationTokenSource.Token);
+    }
+
     public async Task<Dictionary<string, Language>> GetVocalMusicLanguages()
     {
         await mediaIndexService.Verify();