Adds admin page for approving and rejecting album submissions.

Author: JudahGabriel

Chavah.NetCore/Common/Extensions/EmailSenderExtensions.cs

@@ -63,9 +63,9 @@ public static void QueueAlbumSubmissionEmail(this IEmailService emailSender, Alb
                 <p>Uploaded by {userName ?? "unknown user"} {album.ArtistEmail}</p>
                 <p><img src='{album.AlbumArt.Url}' style='max-width: 500px; max-height: auto' /></p>
                 <ol>
-                    {album.Songs.Select(s => $"<li><a href='{s.Url}'>{s.Name}</a> <audio controls src='{s.Url}'></audio></li>")}
+                    {string.Join(' ', album.Songs.Select(s => $"<li><a href='{s.Url}'>{s.Name}</a> <audio controls src='{s.Url}'></audio></li>"))}
                 </ol>
-                <p>Please visit <a href='https://messianicradio.com/#/admin/albums'>Chavah admin></a> to approve or reject.</p>
+                <p>Please visit <a href='https://messianicradio.com/#/admin/albums/submissions'>Chavah admin</a> to approve or reject.</p>
             ";
             emailSender.QueueSendEmail(recipient, subject, body);
         }

Chavah.NetCore/Controllers/AlbumsController.cs

@@ -76,6 +76,142 @@ public async Task<PagedList<Album>> GetAll(int skip, int take, string search)
             };
         }
 
+        /// <summary>
+        /// Gets the list of album submissions.
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet]
+        [Authorize(Roles = AppUser.AdminRole)]
+        public async Task<List<AlbumSubmissionByArtist>> GetSubmissions()
+        {
+            return await DbSession.Query<AlbumSubmissionByArtist>()
+                .Where(s => s.Status == ApprovalStatus.Pending)
+                .Take(100)
+                .ToListAsync();
+        }
+
+        /// <summary>
+        /// Approves an album submission, converting it to a permanent album with songs live on Chavah.
+        /// </summary>
+        /// <param name="submission"></param>
+        /// <returns>The ID of the new album.</returns>
+        [HttpPost]
+        [Authorize(Roles = AppUser.AdminRole)]
+        public async Task<string> ApproveSubmission([FromBody] AlbumSubmissionByArtist submission)
+        {
+            // Put the album art on the CDN with the correct file name containing the album name, artist name, etc.
+            // Then Delete the temporary album art file.
+            var albumArtUriCdn = await cdnManagerService.UploadAlbumArtAsync(submission.AlbumArt.Url, submission.Artist, submission.Name, System.IO.Path.GetExtension(submission.AlbumArt.CdnId));
+            await cdnManagerService.DeleteTempFileAsync(submission.AlbumArt.CdnId);
+
+            // Store the new album
+            var newAlbum = new Album
+            {
+                AlbumArtUri = albumArtUriCdn,
+                Artist = submission.Artist,
+                BackgroundColor = submission.BackColor,
+                ForegroundColor = submission.ForeColor,
+                IsVariousArtists = submission.Artist == "Various Artists",
+                MutedColor = submission.MutedColor,
+                Name = submission.Name,
+                SongCount = submission.Songs.Count,
+                TextShadowColor = submission.TextShadowColor,
+            };
+            await DbSession.StoreAsync(newAlbum);
+
+            // Store the Artist as well if we don't already have an artist for them.
+            Artist? existingArtist = null;
+            if (submission.Artist != "Various Artists")
+            {
+                // Grab the existing artist only if we're not the special case "Various Artists"
+                existingArtist = await DbSession.Query<Artist>()
+                    .FirstOrDefaultAsync(a => a.Name == submission.Artist);
+            }
+
+            // Create the artist if necessary.
+            if (existingArtist == null)
+            {
+                existingArtist = new Artist
+                {
+                    Bio = "",
+                    Name = submission.Artist,
+                    Contact = submission.ArtistEmail,
+                    Disambiguation = submission.Artist == "Various Artists" ? submission.Name : null,
+                    DonationUrl = string.IsNullOrWhiteSpace(submission.ArtistPayPalEmail) ? null : new Uri($"paypal:?email={Uri.EscapeDataString(submission.ArtistPayPalEmail)}")
+                };
+                await DbSession.StoreAsync(existingArtist);
+            }
+
+            // Store the songs in the DB.
+            var songNumber = 1;
+            var songsWithTempFiles = new Dictionary<Song, TempFile>(submission.Songs.Count);
+            foreach (var tempFile in submission.Songs)
+            {
+                var (english, hebrew) = tempFile.Name.GetEnglishAndHebrew();
+                var song = new Song
+                {
+                    Album = submission.Name,
+                    AlbumHebrewName = null,
+                    Artist = submission.Artist,
+                    AlbumArtUri = albumArtUriCdn,
+                    CommunityRankStanding = CommunityRankStanding.Normal,
+                    ContributingArtists = [.. english.GetFeaturedArtistsFromSongName()],
+                    Genres = [],
+                    Name = english,
+                    HebrewName = hebrew,
+                    Number = songNumber,
+                    PurchaseUri = submission.PurchaseUrl,
+                    UploadDate = DateTime.UtcNow,
+                    AlbumId = newAlbum.Id,
+                    ArtistId = existingArtist.Id,
+                    AlbumColors = new AlbumColors
+                    {
+                        Background = newAlbum.BackgroundColor,
+                        Foreground = newAlbum.ForegroundColor,
+                        Muted = newAlbum.MutedColor,
+                        TextShadow = newAlbum.TextShadowColor
+                    },
+                    Uri = tempFile.Url
+                };
+                await DbSession.StoreAsync(song);
+
+                songsWithTempFiles.Add(song, tempFile);
+                songNumber++;
+            }
+
+            // Finally, we can mark the submission as approved.
+            submission.Status = ApprovalStatus.Approved;
+            await DbSession.SaveChangesAsync();
+
+            // Now that the songs are saved in the database, migrate their URIs from temp file to
+            // a final file name that includes song, artist, album, etc.ccting 
+            foreach (var (song, tempFile) in songsWithTempFiles)
+            {
+                songUploadService.MoveSongUriFromTemporaryToFinal(tempFile, submission, song.Number, song.Id!);
+            }
+
+            return newAlbum.Id!;
+        }
+
+        /// <summary>
+        /// Rejects an album submission. The album won't be converted to a permanent album on the station. The song uploads and album art upload will be deleted.
+        /// </summary>
+        /// <param name="submission">The album submission to reject.</param>
+        /// <returns></returns>
+        [HttpPost]
+        [Authorize(Roles = AppUser.AdminRole)]
+        public async Task RejectSubmission([FromBody] AlbumSubmissionByArtist submission)
+        {
+            var existingSubmission = await DbSession.LoadAsync<AlbumSubmissionByArtist>(submission.Id);
+            if (existingSubmission == null)
+            {
+                throw new ArgumentException($"Could not find album submission with ID {submission.Id}");
+            }
+
+            // Mark it as rejected. The submission and its temp files will be deleted at a later date during a background task; see AlbumSubmissionCleanup.cs
+            existingSubmission.Status = ApprovalStatus.Rejected;
+        }
+
         [HttpGet]
         public async Task<IActionResult> GetAlbumArtBySongId(string songId)
         {
@@ -194,32 +330,22 @@ public async Task<TempFile> UploadTempFile([FromForm] IFormFile file)
                 throw new InvalidOperationException($"Cannot upload temp file because there have been too many temp files uploaded recently.");
             }
 
-            // Clean up any old temp files.
-            var tempFilesReadyForDeletion = await DbSession.Query<TempFile>()
-                .Where(t => t.CreatedAt < DateTimeOffset.UtcNow.AddDays(30))
-                .ToListAsync();
-            if (tempFilesReadyForDeletion.Count > 0)
-            {
-                foreach (var tempFileToDelete in tempFilesReadyForDeletion)
-                {
-                    await cdnManagerService.DeleteTempFileAsync(tempFileToDelete.CdnId);
-                    DbSession.Delete(tempFileToDelete);
-                }
-                await DbSession.SaveChangesAsync();
-            }
-
             // OK, we're cool to upload it to our CDN.
             using var mediaFileStream = file.OpenReadStream();
             var fileExtension = isMp3 ? ".mp3" : isPng ? ".png" : isWebp ? ".webp" : ".jpg";
             var fileName = Guid.NewGuid().ToString() + fileExtension;
             var tempFileUri = await cdnManagerService.UploadTempFileAsync(mediaFileStream, fileName);
-            return new TempFile
+            var tempFile = new TempFile
             {
                 Url = tempFileUri,
                 Name = fileName,
                 CdnId = fileName,
-                Id = $"TempFiles/{fileName}/{DateTime.UtcNow:O}"
+                Id = $"TempFiles/{fileName}/{DateTime.UtcNow:O}",
+                CreatedAt = DateTimeOffset.UtcNow
             };
+
+            await DbSession.StoreAsync(tempFile);
+            return tempFile;
         }
 
         [HttpPost]
@@ -343,6 +469,8 @@ public async Task<string> UploadAlbumSubmissionByArtist([FromBody] AlbumSubmissi
 
             // Save it in the database.
             album.Id = $"AlbumSubmissionsByArtist/{album.Artist}/{album.Name}/{DateTime.UtcNow:O}";
+            album.Status = ApprovalStatus.Pending;
+            album.CreatedAt = DateTimeOffset.UtcNow;
             await DbSession.StoreAsync(album);
 
             // Notify admins.

Chavah.NetCore/Models/AlbumSubmissionByArtist.cs

@@ -1,4 +1,6 @@
-namespace BitShuva.Chavah.Models
+using System;
+
+namespace BitShuva.Chavah.Models
 {
     /// <summary>
     /// An album submitted by an end user, usually the artist themselves.
@@ -19,5 +21,15 @@ public class AlbumSubmissionByArtist : AlbumUpload
         /// The PayPal email of the artist. This is used to pay the artist Messiah's Music Fund disbursements.
         /// </summary>
         public required string ArtistPayPalEmail { get; set; }
+
+        /// <summary>
+        /// The status of the album submission.
+        /// </summary>
+        public ApprovalStatus Status { get; set; } = ApprovalStatus.Pending;
+
+        /// <summary>
+        /// The date and time when the album submission was uploaded.
+        /// </summary>
+        public DateTimeOffset CreatedAt { get; set; } = DateTimeOffset.UtcNow;
     }
 }

Chavah.NetCore/Models/ApprovalStatus.cs

@@ -0,0 +1,9 @@
+namespace BitShuva.Chavah.Models
+{
+    public enum ApprovalStatus
+    {
+        Pending,
+        Approved,
+        Rejected
+    }
+}

Chavah.NetCore/Models/Artist.cs

@@ -33,6 +33,11 @@ public class Artist
         /// </summary>
         public bool HasDeclinedDonations { get; set; }
 
+        /// <summary>
+        /// Gets the contact for the artist.
+        /// </summary>
+        public string Contact { get; set; }
+
         /// <summary>
         /// Gets the name of the artist including any disambiguation.
         /// </summary>

Chavah.NetCore/Services/AlbumSubmissionCleanup.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+using BitShuva.Chavah.Models;
+
+using Microsoft.Extensions.Logging;
+
+using Raven.Client.Documents;
+using Raven.Client.Documents.Linq;
+
+namespace BitShuva.Chavah.Services;
+
+/// <summary>
+/// Background service that periodically checks for old album submissions that have been are no longer in the pending state. When it finds them, it will delete it and all of its temporary file uploads.
+/// It also cleans up any TemporaryFile documents that are older than a certain amount of time.
+/// </summary>
+public class AlbumSubmissionCleanup : TimedBackgroundServiceBase
+{
+    private readonly ICdnManagerService cdn;
+    private readonly IDocumentStore db;
+
+    private readonly TimeSpan rejectedSubmissionMaxAge = TimeSpan.FromDays(30 * 3); // 3 months
+    private readonly TimeSpan tempFileMaxAge = TimeSpan.FromDays(30 * 6); // 6 months
+
+    public AlbumSubmissionCleanup(
+        ICdnManagerService cdn,
+        IDocumentStore db,
+        ILogger<AlbumSubmissionCleanup> logger)
+        : base(dueTime: TimeSpan.FromHours(24), intervalTime: TimeSpan.FromDays(7), logger)
+    {
+        this.cdn = cdn;
+        this.db = db;
+    }
+
+    public override async Task DoWorkAsync(CancellationToken cancelToken)
+    {
+        await DeleteCompletedAlbumSubmissions();
+        await DeleteOldTempFiles();
+    }
+
+    private async Task DeleteOldTempFiles()
+    {
+        using var dbSession = db.OpenAsyncSession();
+        var oldTempFiles = await dbSession.Query<TempFile>()
+            .Where(t => t.CreatedAt < DateTime.UtcNow.Subtract(tempFileMaxAge))
+            .Take(100)
+            .ToListAsync();
+        foreach (var tempFile in oldTempFiles)
+        {
+            await cdn.DeleteTempFileAsync(tempFile.CdnId);
+            dbSession.Delete(tempFile);
+        }
+    }
+
+    private async Task DeleteCompletedAlbumSubmissions()
+    {
+        using var dbSession = db.OpenAsyncSession();
+        var completedSubmissions = await dbSession.Query<AlbumSubmissionByArtist>()
+            .Where(a => a.Status != ApprovalStatus.Pending && a.CreatedAt < DateTime.UtcNow.Subtract(rejectedSubmissionMaxAge))
+            .Take(10)
+            .ToListAsync();
+        foreach (var submission in completedSubmissions)
+        {
+            try
+            {
+                // Delete the album submission document.
+                dbSession.Delete(submission);
+
+                // Delete the temporary media files from the CDN.
+                var tempFilesToDelete = submission.Songs.Concat([submission.AlbumArt]);
+                foreach (var tempFile in tempFilesToDelete)
+                {
+                    await cdn.DeleteTempFileAsync(tempFile.CdnId);
+                }
+
+                await dbSession.SaveChangesAsync();
+            }
+            catch (Exception error)
+            {
+                logger.LogError(error, "Unable to delete rejected album submission with ID {submissionId}. You may want to manually delete this submission and its temporary media files. Album name {albumName} by artist {artist}", submission.Id, submission.Name, submission.Artist);
+            }
+        }
+    }
+}

Chavah.NetCore/Startup.cs

@@ -73,6 +73,7 @@ public void ConfigureServices(IServiceCollection services)
             services.AddBackgroundQueueWithLogging(1, TimeSpan.FromSeconds(5));
             services.AddHostedService<BlogPostNotificationCreator>();
             services.AddHostedService<EmailRetryService>();
+            services.AddHostedService<AlbumSubmissionCleanup>();
             services.AddCacheBustedAngularViews("/views");
 
             // Add RavenDB document store, session, and migrations.
@@ -97,7 +98,9 @@ public void ConfigureServices(IServiceCollection services)
                 .AddDefaultTokenProviders()
                 .AddRavenDbIdentityStores<AppUser>(); // Use Raven for users and roles.
 
+#if !DEBUG
             services.InstallIndexes();
+#endif
             services.AddMemoryCache();
 
             services.AddApiVersioning(v =>

Chavah.NetCore/compilerconfig.json

@@ -110,5 +110,13 @@
   {
     "outputFile": "wwwroot/css/app/musicSubmission.css",
     "inputFile": "wwwroot/css/app/musicSubmission.less"
+  },
+  {
+    "outputFile": "wwwroot/css/app/adminAlbumSubmissions.css",
+    "inputFile": "wwwroot/css/app/adminAlbumSubmissions.less"
+  },
+  {
+    "outputFile": "wwwroot/css/app/albumPreviewer.css",
+    "inputFile": "wwwroot/css/app/albumPreviewer.less"
   }
-]
+]

Chavah.NetCore/wwwroot/css/app/adminAlbumSubmissions.less

@@ -0,0 +1,25 @@
+.admin-album-submissions-page {
+    .submissions-list-container {
+        margin-top: 20px;
+    }
+
+    .submissions-list {
+        overflow: auto;
+        max-height: 700px;
+    }
+
+    .songs-container {
+        margin-top: 16px;
+        gap: 16px;
+
+        .song-container {
+            gap: 4px;
+            align-items: baseline;
+        }
+    }
+
+    .footer-buttons {
+        margin-top: 20px;
+        gap: 8px;
+    }
+}