diff --git a/ErsatzTV.Application/Artworks/Commands/UploadArtwork.cs b/ErsatzTV.Application/Artworks/Commands/UploadArtwork.cs new file mode 100644 index 000000000..e27c60b37 --- /dev/null +++ b/ErsatzTV.Application/Artworks/Commands/UploadArtwork.cs @@ -0,0 +1,13 @@ +using ErsatzTV.Core; +using ErsatzTV.Core.Api.Artwork; +using ErsatzTV.Core.Domain; + +namespace ErsatzTV.Application.Artworks; + +/// +/// Validates and stores an uploaded image as channel logo or watermark artwork, +/// landing it in the same on-disk cache the Blazor UI uses (via IImageCache), +/// so the returned path is equivalent to a Blazor-uploaded image. +/// +public record UploadArtwork(Stream Stream, string ContentType, ArtworkKind ArtworkKind) + : IRequest>; diff --git a/ErsatzTV.Application/Artworks/Commands/UploadArtworkHandler.cs b/ErsatzTV.Application/Artworks/Commands/UploadArtworkHandler.cs new file mode 100644 index 000000000..0133c9c39 --- /dev/null +++ b/ErsatzTV.Application/Artworks/Commands/UploadArtworkHandler.cs @@ -0,0 +1,53 @@ +using ErsatzTV.Core; +using ErsatzTV.Core.Api.Artwork; +using ErsatzTV.Core.Domain; +using ErsatzTV.Core.Interfaces.Images; + +namespace ErsatzTV.Application.Artworks; + +public class UploadArtworkHandler : IRequestHandler> +{ + // png/jpeg/gif/webp are all decoded by SkiaSharp and read by FFmpeg, matching the + // formats the Blazor logo/watermark upload already accepts. Format expansion is ersatztv#66. + private static readonly HashSet AcceptedContentTypes = new(StringComparer.OrdinalIgnoreCase) + { + "image/png", + "image/jpeg", + "image/gif", + "image/webp" + }; + + private readonly IImageCache _imageCache; + + public UploadArtworkHandler(IImageCache imageCache) => _imageCache = imageCache; + + public async Task> Handle( + UploadArtwork request, + CancellationToken cancellationToken) + { + string contentType = (request.ContentType ?? string.Empty).Trim(); + if (!AcceptedContentTypes.Contains(contentType)) + { + return BaseError.New( + $"Unsupported image content type '{contentType}'; supported types are: {string.Join(", ", AcceptedContentTypes)}"); + } + + Either maybeFileName = await _imageCache.SaveArtworkToCache( + request.Stream, + request.ArtworkKind); + + return maybeFileName.Map(fileName => new ArtworkUploadResponseModel( + BuildPath(request.ArtworkKind, fileName), + contentType)); + } + + // Mirror the on-disk conventions the Blazor editors use so the returned path is a drop-in + // for ArtworkContentTypeModel.Path: channel logos are addressed as "iptv/logos/{file}" + // (see ChannelEditor.UploadLogo), watermarks by the bare cache file name (see WatermarkEditor). + private static string BuildPath(ArtworkKind artworkKind, string fileName) => + artworkKind switch + { + ArtworkKind.Logo => $"iptv/logos/{fileName}", + _ => fileName + }; +} diff --git a/ErsatzTV.Core/Api/Artwork/ArtworkUploadResponseModel.cs b/ErsatzTV.Core/Api/Artwork/ArtworkUploadResponseModel.cs new file mode 100644 index 000000000..c743408a9 --- /dev/null +++ b/ErsatzTV.Core/Api/Artwork/ArtworkUploadResponseModel.cs @@ -0,0 +1,9 @@ +namespace ErsatzTV.Core.Api.Artwork; + +/// +/// Result of uploading channel logo / watermark artwork via the REST API. +/// is directly consumable as the Path of an +/// ArtworkContentTypeModel (e.g. CreateChannel.Logo / channel update), +/// and carries the stored MIME type. +/// +public record ArtworkUploadResponseModel(string Path, string ContentType); diff --git a/ErsatzTV/Controllers/Api/ArtworkUploadController.cs b/ErsatzTV/Controllers/Api/ArtworkUploadController.cs new file mode 100644 index 000000000..396e81026 --- /dev/null +++ b/ErsatzTV/Controllers/Api/ArtworkUploadController.cs @@ -0,0 +1,79 @@ +using ErsatzTV.Application.Artworks; +using ErsatzTV.Core; +using ErsatzTV.Core.Api.Artwork; +using ErsatzTV.Core.Domain; +using ErsatzTV.Extensions; +using MediatR; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Mvc; + +namespace ErsatzTV.Controllers.Api; + +[ApiController] +public class ArtworkUploadController(IMediator mediator) +{ + [HttpPost("/api/artwork/uploads")] + [Consumes("multipart/form-data")] + [Tags("Artwork")] + [EndpointSummary("Upload channel logo or watermark artwork")] + [EndpointGroupName("general")] + [ProducesResponseType(typeof(ArtworkUploadResponseModel), StatusCodes.Status201Created)] + [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)] + public async Task Upload( + IFormFile file, + [FromForm] string target, + CancellationToken cancellationToken) + { + if (file is null || file.Length == 0) + { + return BaseError.New("A non-empty image file is required").ToErrorResult(); + } + + long maxBytes = (long)SystemEnvironment.MaximumUploadMb * 1024 * 1024; + if (file.Length > maxBytes) + { + return BaseError.New($"Image exceeds the maximum allowed size of {SystemEnvironment.MaximumUploadMb} MB") + .ToErrorResult(); + } + + if (!TryParseTarget(target, out ArtworkKind artworkKind)) + { + return BaseError.New($"Unknown upload target '{target}'; expected 'logo' or 'watermark'").ToErrorResult(); + } + + await using Stream stream = file.OpenReadStream(); + Either result = await mediator.Send( + new UploadArtwork(stream, file.ContentType, artworkKind), + cancellationToken); + + return result.ToCreatedResult( + value => LocationFor(artworkKind, value.Path), + value => value); + } + + // "logo" (default) and "watermark" are the two channel-artwork surfaces the API exposes today. + private static bool TryParseTarget(string target, out ArtworkKind artworkKind) + { + switch ((target ?? string.Empty).Trim().ToLowerInvariant()) + { + case "": + case "logo": + artworkKind = ArtworkKind.Logo; + return true; + case "watermark": + artworkKind = ArtworkKind.Watermark; + return true; + default: + artworkKind = ArtworkKind.Logo; + return false; + } + } + + private static string LocationFor(ArtworkKind artworkKind, string path) => + artworkKind switch + { + // logo paths already carry the servable prefix ("iptv/logos/{file}") + ArtworkKind.Logo => $"/{path}", + _ => $"/artwork/watermarks/{path}" + }; +}