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/BiblePublicationService.cs

@@ -74,18 +74,25 @@ public sealed class BiblePublicationService(IServiceScopeFactory scopeFactory, I
         }
     }
 
-    public async Task<Dictionary<string, BiblePublication>> GetByLanguageCodeAsync(string languageCode, CancellationToken cancellationToken = default)
+    public async Task<Dictionary<string, BiblePublication>> GetByLanguageCodeAsync(string languageCode, string? categoryName = null, CancellationToken cancellationToken = default)
     {
         try
         {
             using var scope = scopeFactory.CreateScope();
             var dbContext = scope.ServiceProvider.GetRequiredService<MediaDbContext>();
 
-            var publicationsList = await dbContext.BiblePublications
+            var query = dbContext.BiblePublications
                 .AsNoTracking()
                 .Include(x => x.Category)
-                .Where(x => x.Language != null && x.Language.LanguageCode == languageCode)
-                .ToListAsync(cancellationToken);
+                .Where(x => x.Language != null && x.Language.LanguageCode == languageCode);
+
+            // Filter by category if provided
+            if (!string.IsNullOrWhiteSpace(categoryName))
+            {
+                query = query.Where(x => x.Category != null && x.Category.CategoryName == categoryName);
+            }
+
+            var publicationsList = await query.ToListAsync(cancellationToken);
 
             logger.Debug("GetByLanguageCodeAsync: Found {PublicationCount} publications for language={LanguageCode}",
                 publicationsList.Count, languageCode);
@@ -114,17 +121,25 @@ public async Task<Dictionary<string, BiblePublication>> GetByLanguageCodeAsync(s
         }
     }
 
-    public async Task<Dictionary<string, Language>> GetDistinctLanguagesAsync(CancellationToken cancellationToken = default)
+    public async Task<Dictionary<string, Language>> GetDistinctLanguagesAsync(string? categoryName = null, CancellationToken cancellationToken = default)
     {
         try
         {
             using var scope = scopeFactory.CreateScope();
             var dbContext = scope.ServiceProvider.GetRequiredService<MediaDbContext>();
 
-            var biblePublicationsCount = await dbContext.BiblePublications.CountAsync(cancellationToken);
-            var distinctLanguages = await dbContext.BiblePublications
+            var query = dbContext.BiblePublications
                 .AsNoTracking()
-                .Where(x => x.Language != null)
+                .Where(x => x.Language != null);
+
+            // Filter by category if provided
+            if (!string.IsNullOrWhiteSpace(categoryName))
+            {
+                query = query.Where(x => x.Category != null && x.Category.CategoryName == categoryName);
+            }
+
+            var biblePublicationsCount = await query.CountAsync(cancellationToken);
+            var distinctLanguages = await query
                 .Select(x => x.Language!)
                 .Distinct()
                 .ToListAsync(cancellationToken);

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/IBiblePublicationService.cs

@@ -24,13 +24,13 @@ public interface IBiblePublicationService : IDisposable
     Task<BiblePublication?> GetByLanguageAndCodeWithTracksAsync(string languageCode, string publicationCode, CancellationToken cancellationToken = default);
 
     /// <summary>
-    /// Gets all BiblePublications for a given language code.
+    /// Gets all BiblePublications for a given language code, optionally filtered by category.
     /// </summary>
-    Task<Dictionary<string, BiblePublication>> GetByLanguageCodeAsync(string languageCode, CancellationToken cancellationToken = default);
+    Task<Dictionary<string, BiblePublication>> GetByLanguageCodeAsync(string languageCode, string? categoryName = null, CancellationToken cancellationToken = default);
 
     /// <summary>
-    /// Gets all distinct Languages from BiblePublications.
+    /// Gets all distinct Languages from BiblePublications, optionally filtered by category.
     /// </summary>
-    Task<Dictionary<string, Language>> GetDistinctLanguagesAsync(CancellationToken cancellationToken = default);
+    Task<Dictionary<string, Language>> GetDistinctLanguagesAsync(string? categoryName = null, CancellationToken cancellationToken = default);
 }
 

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)