On Deck + Misc Fixes and Changes (#1215)

* Added playwright and started writing e2e tests.

* To make things easy, disabled other browsers while I get confortable. Added a login flow (assumes my dev env)

* More tests on login page

* Lots more testing code, trying to figure out auth code.

* Ensure we don't track DBs inside config

* Added a new date property for when chapters are added to a series which helps with OnDeck calculations. Changed a lot of heavy api calls to use IEnumerable to stream repsonse to UI.

* Fixed OnDeck with a new field for when last chapter was added on Series. This is a streamlined way to query.

Updated Reading List with NormalizedTitle, CoverImage, CoverImageLocked.

* Implemented the ability to read a random item in the reading list and for the reading list to be intact for order.

* Tweaked the style for webtoon to not span the whole width, but use max width

* When we update a cover image just send an event so we don't need to have logic for when updates occur

* Fixed a bad name for entity type on cover updates

* Aligned the edit collection tag modal to align with new tab design

* Rewrote code for picking the first file for metadata to ensure it always picks the correct file, esp if the first chapter of a series starts with a float (1.1)

* Refactored setting LastChapterAdded to ensure we do it on the Series.

* Updated Chapter updating in scan loop to avoid nested for loop and an additional loop.

* Fixed a bug where locked person fields wouldn't persist between scans.

* Updated Contributing to reflect how to view the swagger api

API/Controllers/UploadController.cs

@@ -5,6 +5,7 @@ using API.Data;
 using API.DTOs.Uploads;
 using API.Extensions;
 using API.Services;
+using API.SignalR;
 using Flurl.Http;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
@@ -24,16 +25,18 @@ namespace API.Controllers
         private readonly ILogger<UploadController> _logger;
         private readonly ITaskScheduler _taskScheduler;
         private readonly IDirectoryService _directoryService;
+        private readonly IEventHub _eventHub;
 
         /// <inheritdoc />
         public UploadController(IUnitOfWork unitOfWork, IImageService imageService, ILogger<UploadController> logger,
-            ITaskScheduler taskScheduler, IDirectoryService directoryService)
+            ITaskScheduler taskScheduler, IDirectoryService directoryService, IEventHub eventHub)
         {
             _unitOfWork = unitOfWork;
             _imageService = imageService;
             _logger = logger;
             _taskScheduler = taskScheduler;
             _directoryService = directoryService;
+            _eventHub = eventHub;
         }
 
         /// <summary>
@@ -145,6 +148,8 @@ namespace API.Controllers
                 if (_unitOfWork.HasChanges())
                 {
                     await _unitOfWork.CommitAsync();
+                    await _eventHub.SendMessageAsync(MessageFactory.CoverUpdate,
+                        MessageFactory.CoverUpdateEvent(tag.Id, "collection"), false);
                     return Ok();
                 }
 
@@ -158,6 +163,53 @@ namespace API.Controllers
             return BadRequest("Unable to save cover image to Collection Tag");
         }
 
+        /// <summary>
+        /// Replaces reading list cover image and locks it with a base64 encoded image
+        /// </summary>
+        /// <param name="uploadFileDto"></param>
+        /// <returns></returns>
+        [Authorize(Policy = "RequireAdminRole")]
+        [RequestSizeLimit(8_000_000)]
+        [HttpPost("reading-list")]
+        public async Task<ActionResult> UploadReadingListCoverImageFromUrl(UploadFileDto uploadFileDto)
+        {
+            // Check if Url is non empty, request the image and place in temp, then ask image service to handle it.
+            // See if we can do this all in memory without touching underlying system
+            if (string.IsNullOrEmpty(uploadFileDto.Url))
+            {
+                return BadRequest("You must pass a url to use");
+            }
+
+            try
+            {
+                var filePath = _imageService.CreateThumbnailFromBase64(uploadFileDto.Url, $"{ImageService.GetReadingListFormat(uploadFileDto.Id)}");
+                var readingList = await _unitOfWork.ReadingListRepository.GetReadingListByIdAsync(uploadFileDto.Id);
+
+                if (!string.IsNullOrEmpty(filePath))
+                {
+                    readingList.CoverImage = filePath;
+                    readingList.CoverImageLocked = true;
+                    _unitOfWork.ReadingListRepository.Update(readingList);
+                }
+
+                if (_unitOfWork.HasChanges())
+                {
+                    await _unitOfWork.CommitAsync();
+                    await _eventHub.SendMessageAsync(MessageFactory.CoverUpdate,
+                        MessageFactory.CoverUpdateEvent(readingList.Id, "readingList"), false);
+                    return Ok();
+                }
+
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(e, "There was an issue uploading cover image for Reading List {Id}", uploadFileDto.Id);
+                await _unitOfWork.RollbackAsync();
+            }
+
+            return BadRequest("Unable to save cover image to Reading List");
+        }
+
         /// <summary>
         /// Replaces chapter cover image and locks it with a base64 encoded image. This will update the parent volume's cover image.
         /// </summary>