diff --git a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs index 1b23a3b3f..e3bf8080f 100644 --- a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs +++ b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinApiClient.cs @@ -13,6 +13,11 @@ public interface IJellyfinApiClient string authorizationHeader, JellyfinLibrary library); + IAsyncEnumerable> GetMusicVideoLibraryItems( + string address, + string authorizationHeader, + JellyfinLibrary library); + IAsyncEnumerable> GetShowLibraryItemsWithoutPeople( string address, string authorizationHeader, diff --git a/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinMusicVideoLibraryScanner.cs b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinMusicVideoLibraryScanner.cs new file mode 100644 index 000000000..5a0019eb1 --- /dev/null +++ b/ErsatzTV.Core/Interfaces/Jellyfin/IJellyfinMusicVideoLibraryScanner.cs @@ -0,0 +1,13 @@ +using ErsatzTV.Core.Domain; +using ErsatzTV.Core.Jellyfin; + +namespace ErsatzTV.Core.Interfaces.Jellyfin; + +public interface IJellyfinMusicVideoLibraryScanner +{ + Task> ScanLibrary( + JellyfinConnectionParameters connectionParameters, + JellyfinLibrary library, + bool deepScan, + CancellationToken cancellationToken); +} diff --git a/ErsatzTV.Infrastructure.Tests/Jellyfin/JellyfinApiClientTests.cs b/ErsatzTV.Infrastructure.Tests/Jellyfin/JellyfinApiClientTests.cs new file mode 100644 index 000000000..a369015da --- /dev/null +++ b/ErsatzTV.Infrastructure.Tests/Jellyfin/JellyfinApiClientTests.cs @@ -0,0 +1,73 @@ +using System.Net; +using ErsatzTV.Core; +using ErsatzTV.Core.Domain; +using ErsatzTV.Core.Interfaces.Jellyfin; +using ErsatzTV.Core.Interfaces.Metadata; +using ErsatzTV.Infrastructure.Jellyfin; +using LanguageExt; +using Microsoft.Extensions.Caching.Memory; +using Microsoft.Extensions.Logging; +using NSubstitute; +using NUnit.Framework; +using Shouldly; + +namespace ErsatzTV.Infrastructure.Tests.Jellyfin; + +public class JellyfinApiClientTests +{ + [TestFixture] + public class GetLibraries + { + [Test] + public async Task Should_Project_MusicVideo_Libraries() + { + const string response = """ + [ + { + "Name": "Concerts", + "CollectionType": "musicvideos", + "ItemId": "library-1", + "LibraryOptions": { + "PathInfos": [] + } + } + ] + """; + + var client = new JellyfinApiClient( + new MemoryCache(new MemoryCacheOptions()), + Substitute.For(), + Substitute.For(), + new SingleResponseHttpClientFactory(response), + Substitute.For>()); + + Either> result = + await client.GetLibraries("http://jellyfin.example", "MediaBrowser Token=abc"); + + result.IsRight.ShouldBeTrue(); + List libraries = result.RightToSeq().Single(); + libraries.Count.ShouldBe(1); + libraries[0].Name.ShouldBe("Concerts"); + libraries[0].ItemId.ShouldBe("library-1"); + libraries[0].MediaKind.ShouldBe(LibraryMediaKind.MusicVideos); + libraries[0].ShouldSyncItems.ShouldBeFalse(); + libraries[0].Paths.Single().Path.ShouldBe("jellyfin://library-1"); + } + } + + private sealed class SingleResponseHttpClientFactory(string response) : IHttpClientFactory + { + public HttpClient CreateClient(string name) => new(new SingleResponseHttpMessageHandler(response)); + } + + private sealed class SingleResponseHttpMessageHandler(string response) : HttpMessageHandler + { + protected override Task SendAsync( + HttpRequestMessage request, + CancellationToken cancellationToken) => + Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(response) + }); + } +} diff --git a/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs b/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs index 1a895271f..ccb5f56f9 100644 --- a/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs +++ b/ErsatzTV.Infrastructure/Jellyfin/IJellyfinApi.cs @@ -42,6 +42,26 @@ public interface IJellyfinApi [Query] int limit = 0); + [Get("/Items?sortOrder=Ascending&sortBy=SortName")] + Task GetMusicVideoLibraryItems( + [Header("Authorization")] + string authorizationHeader, + [Query] + string parentId, + [Query] + string fields = + "Path,Genres,Artists,Tags,DateCreated,Etag,Overview,Studios,People,OfficialRating,ProviderIds,Chapters", + [Query] + string includeItemTypes = "MusicVideo", + [Query] + bool recursive = true, + [Query] + string filters = "IsNotFolder", + [Query] + int startIndex = 0, + [Query] + int limit = 0); + [Get("/Items?sortOrder=Ascending&sortBy=SortName")] Task GetShowLibraryItemsWithoutPeople( [Header("Authorization")] diff --git a/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs b/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs index a1a8a6118..5df85c91d 100644 --- a/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs +++ b/ErsatzTV.Infrastructure/Jellyfin/JellyfinApiClient.cs @@ -93,6 +93,23 @@ public class JellyfinApiClient : IJellyfinApiClient limit: pageSize), (maybeLibrary, item) => maybeLibrary.Map(lib => ProjectToMovie(lib, item)).Flatten()); + public IAsyncEnumerable> GetMusicVideoLibraryItems( + string address, + string authorizationHeader, + JellyfinLibrary library) => + GetPagedLibraryItems( + "JF Music Videos", + address, + library, + library.MediaSourceId, + library.ItemId, + (service, itemId, skip, pageSize) => service.GetMusicVideoLibraryItems( + authorizationHeader, + itemId, + startIndex: skip, + limit: pageSize), + (maybeLibrary, item) => maybeLibrary.Map(lib => ProjectToMusicVideo(lib, item)).Flatten()); + public IAsyncEnumerable> GetShowLibraryItemsWithoutPeople( string address, string authorizationHeader, @@ -438,6 +455,15 @@ public class JellyfinApiClient : IJellyfinApiClient Paths = new List { new() { Path = $"jellyfin://{response.ItemId}" } }, PathInfos = GetPathInfos(response) }, + "musicvideos" => new JellyfinLibrary + { + ItemId = response.ItemId, + Name = response.Name, + MediaKind = LibraryMediaKind.MusicVideos, + ShouldSyncItems = false, + Paths = new List { new() { Path = $"jellyfin://{response.ItemId}" } }, + PathInfos = GetPathInfos(response) + }, // TODO: ??? for music libraries "boxsets" => CacheCollectionLibraryId(response.ItemId), _ => None @@ -484,7 +510,7 @@ public class JellyfinApiClient : IJellyfinApiClient } string path = item.Path ?? string.Empty; - foreach (JellyfinPathInfo pathInfo in library.PathInfos.Filter(pi => + foreach (JellyfinPathInfo pathInfo in Optional(library.PathInfos).Flatten().Filter(pi => !string.IsNullOrWhiteSpace(pi.NetworkPath))) { if (path.StartsWith(pathInfo.NetworkPath, StringComparison.Ordinal)) @@ -620,6 +646,139 @@ public class JellyfinApiClient : IJellyfinApiClient return metadata; } + private Option ProjectToMusicVideo(JellyfinLibrary library, JellyfinLibraryItemResponse item) + { + try + { + if (item.LocationType != "FileSystem") + { + return None; + } + + if (Path.GetExtension(item.Path)?.ToLowerInvariant() == ".strm") + { + _logger.LogInformation("STRM files are not supported; skipping {Path}", item.Path); + return None; + } + + string path = item.Path ?? string.Empty; + foreach (JellyfinPathInfo pathInfo in Optional(library.PathInfos).Flatten().Filter(pi => + !string.IsNullOrWhiteSpace(pi.NetworkPath))) + { + if (path.StartsWith(pathInfo.NetworkPath, StringComparison.Ordinal)) + { + path = _jellyfinPathReplacementService.ReplaceNetworkPath( + (JellyfinMediaSource)library.MediaSource, + path, + pathInfo.NetworkPath, + pathInfo.Path); + } + } + + var duration = TimeSpan.FromTicks(item.RunTimeTicks); + var version = new MediaVersion + { + Name = "Main", + Duration = duration, + DateAdded = item.DateCreated.UtcDateTime, + MediaFiles = + [ + new MediaFile + { + Path = path, + PathHash = PathUtils.GetPathHash(path) + } + ], + Streams = [], + Chapters = ProjectToModel(Optional(item.Chapters).Flatten(), duration) + }; + + MusicVideoMetadata metadata = ProjectToMusicVideoMetadata(item); + + var musicVideo = new MusicVideo + { + MediaVersions = [version], + MusicVideoMetadata = [metadata], + TraktListItems = [] + }; + + return musicVideo; + } + catch (Exception ex) + { + _logger.LogWarning(ex, "Error projecting Jellyfin music video"); + return None; + } + } + + private static MusicVideoMetadata ProjectToMusicVideoMetadata(JellyfinLibraryItemResponse item) + { + DateTime dateAdded = item.DateCreated.UtcDateTime; + var metadata = new MusicVideoMetadata + { + MetadataKind = MetadataKind.External, + Title = item.Name, + SortTitle = SortTitle.GetSortTitle(item.Name), + Plot = item.Overview, + Year = item.ProductionYear, + DateAdded = dateAdded, + Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(), + Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(), + Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(), + Artists = MusicVideoArtists(item) + .ToList(), + Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(), + Artwork = new List(), + Guids = GuidsFromProviderIds(item.ProviderIds), + Subtitles = new List() + }; + + if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate)) + { + metadata.ReleaseDate = releaseDate; + } + + if (!string.IsNullOrWhiteSpace(item.ImageTags?.Primary)) + { + var poster = new Artwork + { + ArtworkKind = ArtworkKind.Poster, + Path = $"jellyfin://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}", + DateAdded = dateAdded + }; + metadata.Artwork.Add(poster); + } + + if (item.BackdropImageTags?.Count > 0) + { + var fanArt = new Artwork + { + ArtworkKind = ArtworkKind.FanArt, + Path = $"jellyfin://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}", + DateAdded = dateAdded + }; + metadata.Artwork.Add(fanArt); + } + + return metadata; + } + + private static IEnumerable MusicVideoArtists(JellyfinLibraryItemResponse item) + { + List artists = Optional(item.Artists).Flatten().ToList(); + if (artists.Count == 0) + { + artists = Optional(item.People).Flatten() + .Filter(p => p.Type is "Artist") + .Map(p => p.Name) + .ToList(); + } + + return artists.Filter(name => !string.IsNullOrWhiteSpace(name)) + .Distinct() + .Map(name => new MusicVideoArtist { Name = name }); + } + private static Option ProjectToActor(JellyfinPersonResponse person, DateTime dateAdded) { if (person.Type?.ToLowerInvariant() != "actor") diff --git a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemResponse.cs b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemResponse.cs index e1725c7a1..7babac1eb 100644 --- a/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemResponse.cs +++ b/ErsatzTV.Infrastructure/Jellyfin/Models/JellyfinLibraryItemResponse.cs @@ -10,6 +10,7 @@ public class JellyfinLibraryItemResponse public DateTimeOffset DateCreated { get; set; } public long RunTimeTicks { get; set; } public List Genres { get; set; } + public List Artists { get; set; } public List Tags { get; set; } public int ProductionYear { get; set; } public JellyfinProviderIdsResponse ProviderIds { get; set; } diff --git a/ErsatzTV.Scanner.Tests/Application/Jellyfin/SynchronizeJellyfinLibraryByIdHandlerTests.cs b/ErsatzTV.Scanner.Tests/Application/Jellyfin/SynchronizeJellyfinLibraryByIdHandlerTests.cs new file mode 100644 index 000000000..79163189e --- /dev/null +++ b/ErsatzTV.Scanner.Tests/Application/Jellyfin/SynchronizeJellyfinLibraryByIdHandlerTests.cs @@ -0,0 +1,99 @@ +using ErsatzTV.Core; +using ErsatzTV.Core.Domain; +using ErsatzTV.Core.Interfaces.Jellyfin; +using ErsatzTV.Core.Interfaces.Repositories; +using ErsatzTV.Core.Jellyfin; +using ErsatzTV.Scanner.Application.Jellyfin; +using ErsatzTV.Scanner.Core.Interfaces; +using Microsoft.Extensions.Logging; +using NSubstitute; +using NUnit.Framework; +using Shouldly; + +namespace ErsatzTV.Scanner.Tests.Application.Jellyfin; + +public class SynchronizeJellyfinLibraryByIdHandlerTests +{ + [TestFixture] + public class Handle + { + [Test] + public async Task Should_Scan_MusicVideo_Libraries() + { + var scannerProxy = Substitute.For(); + var mediaSourceRepository = Substitute.For(); + var jellyfinSecretStore = Substitute.For(); + var jellyfinMovieLibraryScanner = Substitute.For(); + var jellyfinTelevisionLibraryScanner = Substitute.For(); + var jellyfinMusicVideoLibraryScanner = Substitute.For(); + var libraryRepository = Substitute.For(); + var configElementRepository = Substitute.For(); + + var library = new JellyfinLibrary + { + Id = 42, + Name = "Concerts", + MediaKind = LibraryMediaKind.MusicVideos, + MediaSourceId = 7 + }; + var mediaSource = new JellyfinMediaSource + { + Id = 7, + Connections = + [ + new JellyfinConnection + { + Address = "http://jellyfin.example", + JellyfinMediaSourceId = 7 + } + ] + }; + + mediaSourceRepository.GetJellyfinByLibraryId(library.Id).Returns(Some(mediaSource).AsTask()); + mediaSourceRepository.GetJellyfinLibrary(library.Id).Returns(Some(library).AsTask()); + jellyfinSecretStore.ReadSecrets().Returns(new JellyfinSecrets + { + Address = "http://jellyfin.example", + ApiKey = "abc" + }); + configElementRepository.GetValue( + Arg.Is(key => key.Key == ConfigElementKey.LibraryRefreshInterval.Key), + Arg.Any()) + .Returns(Task.FromResult>(Some(0))); + jellyfinMusicVideoLibraryScanner.ScanLibrary( + Arg.Any(), + library, + true, + Arg.Any()) + .Returns(Right(Unit.Default).AsTask()); + + var handler = new SynchronizeJellyfinLibraryByIdHandler( + scannerProxy, + mediaSourceRepository, + jellyfinSecretStore, + jellyfinMovieLibraryScanner, + jellyfinTelevisionLibraryScanner, + jellyfinMusicVideoLibraryScanner, + libraryRepository, + configElementRepository, + Substitute.For>()); + + Either result = await handler.Handle( + new SynchronizeJellyfinLibraryById("http://ersatztv.example", library.Id, true, true), + CancellationToken.None); + + result.LeftToSeq().ShouldBeEmpty(); + result.IsRight.ShouldBeTrue(); + result.RightToSeq().Single().ShouldBe("Concerts"); + await jellyfinMusicVideoLibraryScanner.Received(1).ScanLibrary( + Arg.Is(cp => + cp.Address == "http://jellyfin.example" && + cp.ApiKey == "abc" && + cp.MediaSourceId == 7), + library, + true, + Arg.Any()); + await libraryRepository.Received(1).UpdateLastScan(library); + } + } +} diff --git a/ErsatzTV.Scanner/Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs b/ErsatzTV.Scanner/Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs index 1bcc2abc2..6e14a2b69 100644 --- a/ErsatzTV.Scanner/Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs +++ b/ErsatzTV.Scanner/Application/Jellyfin/Commands/SynchronizeJellyfinLibraryByIdHandler.cs @@ -14,6 +14,7 @@ public class private readonly IConfigElementRepository _configElementRepository; private readonly IJellyfinMovieLibraryScanner _jellyfinMovieLibraryScanner; + private readonly IJellyfinMusicVideoLibraryScanner _jellyfinMusicVideoLibraryScanner; private readonly IJellyfinSecretStore _jellyfinSecretStore; private readonly IJellyfinTelevisionLibraryScanner _jellyfinTelevisionLibraryScanner; @@ -28,6 +29,7 @@ public class IJellyfinSecretStore jellyfinSecretStore, IJellyfinMovieLibraryScanner jellyfinMovieLibraryScanner, IJellyfinTelevisionLibraryScanner jellyfinTelevisionLibraryScanner, + IJellyfinMusicVideoLibraryScanner jellyfinMusicVideoLibraryScanner, ILibraryRepository libraryRepository, IConfigElementRepository configElementRepository, ILogger logger) @@ -37,6 +39,7 @@ public class _jellyfinSecretStore = jellyfinSecretStore; _jellyfinMovieLibraryScanner = jellyfinMovieLibraryScanner; _jellyfinTelevisionLibraryScanner = jellyfinTelevisionLibraryScanner; + _jellyfinMusicVideoLibraryScanner = jellyfinMusicVideoLibraryScanner; _libraryRepository = libraryRepository; _configElementRepository = configElementRepository; _logger = logger; @@ -75,6 +78,12 @@ public class parameters.Library, parameters.DeepScan, cancellationToken), + LibraryMediaKind.MusicVideos => + await _jellyfinMusicVideoLibraryScanner.ScanLibrary( + parameters.ConnectionParameters, + parameters.Library, + parameters.DeepScan, + cancellationToken), _ => Unit.Default }; diff --git a/ErsatzTV.Scanner/Core/Jellyfin/JellyfinMusicVideoLibraryScanner.cs b/ErsatzTV.Scanner/Core/Jellyfin/JellyfinMusicVideoLibraryScanner.cs new file mode 100644 index 000000000..94705a0b1 --- /dev/null +++ b/ErsatzTV.Scanner/Core/Jellyfin/JellyfinMusicVideoLibraryScanner.cs @@ -0,0 +1,216 @@ +using ErsatzTV.Core; +using ErsatzTV.Core.Domain; +using ErsatzTV.Core.Errors; +using ErsatzTV.Core.Extensions; +using ErsatzTV.Core.Interfaces.Jellyfin; +using ErsatzTV.Core.Interfaces.Repositories; +using ErsatzTV.Core.Jellyfin; +using ErsatzTV.Core.Metadata; +using ErsatzTV.Scanner.Core.Interfaces; +using Microsoft.Extensions.Logging; + +namespace ErsatzTV.Scanner.Core.Jellyfin; + +public class JellyfinMusicVideoLibraryScanner : IJellyfinMusicVideoLibraryScanner +{ + private const string UnknownArtist = "Unknown Artist"; + + private readonly IArtistRepository _artistRepository; + private readonly IJellyfinApiClient _jellyfinApiClient; + private readonly IJellyfinPathReplacementService _pathReplacementService; + private readonly ILibraryRepository _libraryRepository; + private readonly ILogger _logger; + private readonly IMediaSourceRepository _mediaSourceRepository; + private readonly IMetadataRepository _metadataRepository; + private readonly IMusicVideoRepository _musicVideoRepository; + private readonly IScannerProxy _scannerProxy; + + public JellyfinMusicVideoLibraryScanner( + IScannerProxy scannerProxy, + IJellyfinApiClient jellyfinApiClient, + IJellyfinPathReplacementService pathReplacementService, + IMediaSourceRepository mediaSourceRepository, + IArtistRepository artistRepository, + IMusicVideoRepository musicVideoRepository, + ILibraryRepository libraryRepository, + IMetadataRepository metadataRepository, + ILogger logger) + { + _scannerProxy = scannerProxy; + _jellyfinApiClient = jellyfinApiClient; + _pathReplacementService = pathReplacementService; + _mediaSourceRepository = mediaSourceRepository; + _artistRepository = artistRepository; + _musicVideoRepository = musicVideoRepository; + _libraryRepository = libraryRepository; + _metadataRepository = metadataRepository; + _logger = logger; + } + + public async Task> ScanLibrary( + JellyfinConnectionParameters connectionParameters, + JellyfinLibrary library, + bool deepScan, + CancellationToken cancellationToken) + { + try + { + Option maybeLibraryPath = Optional(library.Paths).Flatten().HeadOrNone(); + return await maybeLibraryPath.Match( + libraryPath => ScanLibrary(connectionParameters, library, libraryPath, cancellationToken), + () => Task.FromResult>( + BaseError.New($"Jellyfin library {library.Id} has no library path"))); + } + catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException) + { + return new ScanCanceled(); + } + } + + private async Task> ScanLibrary( + JellyfinConnectionParameters connectionParameters, + JellyfinLibrary library, + LibraryPath libraryPath, + CancellationToken cancellationToken) + { + List pathReplacements = + await _mediaSourceRepository.GetJellyfinPathReplacements(library.MediaSourceId); + + var processed = 0; + await foreach ((MusicVideo incoming, int totalCount) in _jellyfinApiClient + .GetMusicVideoLibraryItems( + connectionParameters.Address, + connectionParameters.AuthorizationHeader, + library) + .WithCancellation(cancellationToken)) + { + if (cancellationToken.IsCancellationRequested) + { + return new ScanCanceled(); + } + + processed++; + decimal percentCompletion = totalCount == 0 ? 1 : Math.Clamp((decimal)processed / totalCount, 0, 1); + if (!await _scannerProxy.UpdateProgress(percentCompletion, cancellationToken)) + { + return new ScanCanceled(); + } + + Either> maybeMusicVideo = + await ProcessMusicVideo(library, libraryPath, pathReplacements, incoming, cancellationToken); + + foreach (BaseError error in maybeMusicVideo.LeftToSeq()) + { + _logger.LogWarning("Error processing Jellyfin music video: {Error}", error.Value); + } + + foreach (MediaItemScanResult result in maybeMusicVideo.RightToSeq() + .Filter(result => result.IsAdded || result.IsUpdated)) + { + if (!await _scannerProxy.ReindexMediaItems([result.Item.Id], cancellationToken)) + { + _logger.LogWarning("Failed to reindex media items from scanner process"); + } + } + } + + return Unit.Default; + } + + private async Task>> ProcessMusicVideo( + JellyfinLibrary library, + LibraryPath libraryPath, + List pathReplacements, + MusicVideo incoming, + CancellationToken cancellationToken) + { + string localPath = GetLocalPath(pathReplacements, incoming); + string folder = Path.GetDirectoryName(localPath) ?? libraryPath.Path; + Option maybeParentFolder = await _libraryRepository.GetParentFolderId(libraryPath, folder, cancellationToken); + LibraryFolder libraryFolder = await _libraryRepository.GetOrAddFolder(libraryPath, maybeParentFolder, folder); + + return await GetOrAddArtist(libraryPath, incoming) + .BindT(artist => _musicVideoRepository.GetOrAdd(artist, libraryPath, libraryFolder, localPath)) + .BindT(result => UpdateMusicVideo(result, incoming, localPath, cancellationToken)); + } + + private string GetLocalPath(List pathReplacements, MusicVideo musicVideo) => + _pathReplacementService.GetReplacementJellyfinPath( + pathReplacements, + musicVideo.GetHeadVersion().MediaFiles.Head().Path, + false); + + private async Task> GetOrAddArtist(LibraryPath libraryPath, MusicVideo musicVideo) + { + string artistName = musicVideo.MusicVideoMetadata + .HeadOrNone() + .Bind(metadata => Optional(metadata.Artists).Flatten().HeadOrNone()) + .Map(artist => artist.Name) + .IfNone(UnknownArtist); + + var metadata = new ArtistMetadata + { + MetadataKind = MetadataKind.External, + Title = artistName, + SortTitle = SortTitle.GetSortTitle(artistName), + DateAdded = DateTime.UtcNow, + Genres = [], + Styles = [], + Moods = [], + Artwork = [], + Guids = [], + Subtitles = [] + }; + + Option maybeArtist = await _artistRepository.GetArtistByMetadata(libraryPath.Id, metadata); + foreach (Artist artist in maybeArtist) + { + return artist; + } + + Either> result = + await _artistRepository.AddArtist(libraryPath.Id, artistName, metadata); + return result.Map(scanResult => scanResult.Item); + } + + private async Task>> UpdateMusicVideo( + MediaItemScanResult result, + MusicVideo incoming, + string localPath, + CancellationToken cancellationToken) + { + result.LocalPath = localPath; + MusicVideoMetadata incomingMetadata = incoming.MusicVideoMetadata.Head(); + + bool updated = await UpdateMetadata(result.Item, incomingMetadata); + updated = await _metadataRepository.UpdateStatistics(result.Item, incoming.GetHeadVersion()) || updated; + + if (updated) + { + result.IsUpdated = true; + } + + return result; + } + + private async Task UpdateMetadata(MusicVideo musicVideo, MusicVideoMetadata incoming) + { + Option maybeExisting = Optional(musicVideo.MusicVideoMetadata).Flatten().HeadOrNone(); + foreach (MusicVideoMetadata existing in maybeExisting) + { + existing.Title = incoming.Title; + existing.SortTitle = incoming.SortTitle; + existing.Plot = incoming.Plot; + existing.Year = incoming.Year; + existing.ReleaseDate = incoming.ReleaseDate; + existing.DateUpdated = DateTime.UtcNow; + existing.MetadataKind = MetadataKind.External; + + return await _metadataRepository.Update(existing); + } + + incoming.MusicVideoId = musicVideo.Id; + musicVideo.MusicVideoMetadata = [incoming]; + return await _metadataRepository.Add(incoming); + } +} diff --git a/ErsatzTV.Scanner/Program.cs b/ErsatzTV.Scanner/Program.cs index b0aa3a450..7fad0e835 100644 --- a/ErsatzTV.Scanner/Program.cs +++ b/ErsatzTV.Scanner/Program.cs @@ -236,6 +236,7 @@ public class Program services.AddScoped(); services.AddScoped(); + services.AddScoped(); services.AddScoped(); services.AddScoped(); services.AddScoped();