コード例 #1
0
        private async Task <Unit> ScanSeasons(
            LibraryPath libraryPath,
            string ffprobePath,
            Show show,
            string showFolder)
        {
            foreach (string seasonFolder in _localFileSystem.ListSubdirectories(showFolder).Filter(ShouldIncludeFolder)
                     .OrderBy(identity))
            {
                Option <int> maybeSeasonNumber = SeasonNumberForFolder(seasonFolder);
                await maybeSeasonNumber.IfSomeAsync(
                    async seasonNumber =>
                {
                    Either <BaseError, Season> maybeSeason = await _televisionRepository
                                                             .GetOrAddSeason(show, libraryPath.Id, seasonNumber)
                                                             .BindT(season => UpdatePoster(season, seasonFolder));

                    await maybeSeason.Match(
                        season => ScanEpisodes(libraryPath, ffprobePath, season, seasonFolder),
                        _ => Task.FromResult(Unit.Default));
                });
            }

            return(Unit.Default);
        }
コード例 #2
0
    private async Task <Either <BaseError, Unit> > ScanSeasons(
        LibraryPath libraryPath,
        string ffmpegPath,
        string ffprobePath,
        Show show,
        string showFolder,
        CancellationToken cancellationToken)
    {
        foreach (string seasonFolder in _localFileSystem.ListSubdirectories(showFolder).Filter(ShouldIncludeFolder)
                 .OrderBy(identity))
        {
            if (cancellationToken.IsCancellationRequested)
            {
                return(new ScanCanceled());
            }

            string etag = FolderEtag.CalculateWithSubfolders(seasonFolder, _localFileSystem);
            Option <LibraryFolder> knownFolder = libraryPath.LibraryFolders
                                                 .Filter(f => f.Path == seasonFolder)
                                                 .HeadOrNone();

            // skip folder if etag matches
            if (await knownFolder.Map(f => f.Etag ?? string.Empty).IfNoneAsync(string.Empty) == etag)
            {
                continue;
            }

            Option <int> maybeSeasonNumber = SeasonNumberForFolder(seasonFolder);
            foreach (int seasonNumber in maybeSeasonNumber)
            {
                Either <BaseError, Season> maybeSeason = await _televisionRepository
                                                         .GetOrAddSeason(show, libraryPath.Id, seasonNumber)
                                                         .BindT(EnsureMetadataExists)
                                                         .BindT(season => UpdatePoster(season, seasonFolder, cancellationToken));

                foreach (BaseError error in maybeSeason.LeftToSeq())
                {
                    _logger.LogWarning(
                        "Error processing season in folder {Folder}: {Error}",
                        seasonFolder,
                        error.Value);
                }

                foreach (Season season in maybeSeason.RightToSeq())
                {
                    Either <BaseError, Unit> scanResult = await ScanEpisodes(
                        libraryPath,
                        ffmpegPath,
                        ffprobePath,
                        season,
                        seasonFolder,
                        cancellationToken);

                    foreach (ScanCanceled error in scanResult.LeftToSeq().OfType <ScanCanceled>())
                    {
                        return(error);
                    }

                    await _libraryRepository.SetEtag(libraryPath, knownFolder, seasonFolder, etag);

                    season.Show = show;
                    await _searchIndex.UpdateItems(_searchRepository, new List <MediaItem> {
                        season
                    });
                }
            }
        }

        return(Unit.Default);
    }