Пример #1
0
        private async Task <Either <BaseError, MediaItemScanResult <Movie> > > UpdateMetadata(
            MediaItemScanResult <Movie> result)
        {
            try
            {
                Movie movie = result.Item;
                await LocateNfoFile(movie).Match(
                    async nfoFile =>
                {
                    bool shouldUpdate = Optional(movie.MovieMetadata).Flatten().HeadOrNone().Match(
                        m => m.MetadataKind == MetadataKind.Fallback ||
                        m.DateUpdated < _localFileSystem.GetLastWriteTime(nfoFile),
                        true);

                    if (shouldUpdate)
                    {
                        _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
                        if (await _localMetadataProvider.RefreshSidecarMetadata(movie, nfoFile))
                        {
                            result.IsUpdated = true;
                        }
                    }
                },
                    async() =>
                {
                    if (!Optional(movie.MovieMetadata).Flatten().Any())
                    {
                        string path = movie.MediaVersions.Head().MediaFiles.Head().Path;
                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", path);
                        if (await _localMetadataProvider.RefreshFallbackMetadata(movie))
                        {
                            result.IsUpdated = true;
                        }
                    }
                });

                return(result);
            }
            catch (Exception ex)
            {
                return(BaseError.New(ex.ToString()));
            }
        }
        private async Task <Either <BaseError, MediaItemScanResult <Show> > > UpdateMetadataForShow(
            MediaItemScanResult <Show> result,
            string showFolder)
        {
            try
            {
                Show show = result.Item;
                await LocateNfoFileForShow(showFolder).Match(
                    async nfoFile =>
                {
                    bool shouldUpdate = Optional(show.ShowMetadata).Flatten().HeadOrNone().Match(
                        m => m.MetadataKind == MetadataKind.Fallback ||
                        m.DateUpdated < _localFileSystem.GetLastWriteTime(nfoFile),
                        true);

                    if (shouldUpdate)
                    {
                        _logger.LogDebug("Refreshing {Attribute} from {Path}", "Sidecar Metadata", nfoFile);
                        if (await _localMetadataProvider.RefreshSidecarMetadata(show, nfoFile))
                        {
                            result.IsUpdated = true;
                        }
                    }
                },
                    async() =>
                {
                    if (!Optional(show.ShowMetadata).Flatten().Any())
                    {
                        _logger.LogDebug("Refreshing {Attribute} for {Path}", "Fallback Metadata", showFolder);
                        if (await _localMetadataProvider.RefreshFallbackMetadata(show, showFolder))
                        {
                            result.IsUpdated = true;
                        }
                    }
                });

                return(result);
            }
            catch (Exception ex)
            {
                return(BaseError.New(ex.ToString()));
            }
        }
Пример #3
0
        private async Task <Either <BaseError, MediaItemScanResult <Movie> > > UpdateArtwork(
            MediaItemScanResult <Movie> result,
            ArtworkKind artworkKind)
        {
            try
            {
                Movie movie = result.Item;
                await LocateArtwork(movie, artworkKind).IfSomeAsync(
                    async posterFile =>
                {
                    MovieMetadata metadata = movie.MovieMetadata.Head();
                    await RefreshArtwork(posterFile, metadata, artworkKind);
                });

                return(result);
            }
            catch (Exception ex)
            {
                return(BaseError.New(ex.ToString()));
            }
        }
        private async Task <Either <BaseError, MediaItemScanResult <Show> > > UpdateArtworkForShow(
            MediaItemScanResult <Show> result,
            string showFolder,
            ArtworkKind artworkKind)
        {
            try
            {
                Show show = result.Item;
                await LocateArtworkForShow(showFolder, artworkKind).IfSomeAsync(
                    async posterFile =>
                {
                    ShowMetadata metadata = show.ShowMetadata.Head();
                    await RefreshArtwork(posterFile, metadata, artworkKind);
                });

                return(result);
            }
            catch (Exception ex)
            {
                return(BaseError.New(ex.ToString()));
            }
        }