private async Task <Either <BaseError, Unit> > ScanEpisodes(
PlexLibrary plexMediaSourceLibrary,
PlexSeason season,
PlexConnection connection,
PlexServerAuthToken token)
{
Either <BaseError, List <PlexEpisode> > entries = await _plexServerApiClient.GetSeasonEpisodes(
plexMediaSourceLibrary,
season,
connection,
token);
return(await entries.Match <Task <Either <BaseError, Unit> > >(
async episodeEntries =>
{
foreach (PlexEpisode incoming in episodeEntries)
{
incoming.SeasonId = season.Id;
// TODO: figure out how to rebuild playlists
Either <BaseError, PlexEpisode> maybeEpisode = await _televisionRepository
.GetOrAddPlexEpisode(plexMediaSourceLibrary, incoming)
.BindT(existing => UpdateStatistics(existing, incoming, connection, token))
.BindT(existing => UpdateArtwork(existing, incoming));
maybeEpisode.IfLeft(
error => _logger.LogWarning(
"Error processing plex episode at {Key}: {Error}",
incoming.Key,
error.Value));
}
var episodeKeys = episodeEntries.Map(s => s.Key).ToList();
await _televisionRepository.RemoveMissingPlexEpisodes(season.Key, episodeKeys);
return Unit.Default;
},
error =>
{
_logger.LogWarning(
"Error synchronizing plex library {Path}: {Error}",
plexMediaSourceLibrary.Name,
error.Value);
return Left <BaseError, Unit>(error).AsTask();
}));
}
private async Task <Either <BaseError, Unit> > ScanEpisodes(
PlexLibrary library,
List <PlexPathReplacement> pathReplacements,
PlexSeason season,
PlexConnection connection,
PlexServerAuthToken token,
string ffmpegPath,
string ffprobePath,
bool deepScan,
CancellationToken cancellationToken)
{
List <PlexItemEtag> existingEpisodes = await _plexTelevisionRepository.GetExistingPlexEpisodes(library, season);
Either <BaseError, List <PlexEpisode> > entries = await _plexServerApiClient.GetSeasonEpisodes(
library,
season,
connection,
token);
foreach (BaseError error in entries.LeftToSeq())
{
return(error);
}
var episodeEntries = entries.RightToSeq().Flatten().ToList();
foreach (PlexEpisode incoming in episodeEntries)
{
if (cancellationToken.IsCancellationRequested)
{
return(new ScanCanceled());
}
if (await ShouldScanItem(library, pathReplacements, existingEpisodes, incoming, deepScan) == false)
{
continue;
}
incoming.SeasonId = season.Id;
// TODO: figure out how to rebuild playlists
Either <BaseError, MediaItemScanResult <PlexEpisode> > maybeEpisode = await _televisionRepository
.GetOrAddPlexEpisode(library, incoming)
.BindT(existing => UpdateMetadata(existing, incoming))
.BindT(
existing => UpdateStatistics(
pathReplacements,
existing,
incoming,
library,
connection,
token,
ffmpegPath,
ffprobePath,
deepScan))
.BindT(existing => UpdateSubtitles(pathReplacements, existing, incoming))
.BindT(existing => UpdateArtwork(existing, incoming));
foreach (BaseError error in maybeEpisode.LeftToSeq())
{
switch (error)
{
case ScanCanceled:
return(error);
default:
_logger.LogWarning(
"Error processing plex episode at {Key}: {Error}",
incoming.Key,
error.Value);
break;
}
}
foreach (MediaItemScanResult <PlexEpisode> result in maybeEpisode.RightToSeq())
{
await _plexTelevisionRepository.SetPlexEtag(result.Item, incoming.Etag);
string plexPath = incoming.MediaVersions.Head().MediaFiles.Head().Path;
string localPath = _plexPathReplacementService.GetReplacementPlexPath(
pathReplacements,
plexPath,
false);
if (_localFileSystem.FileExists(localPath))
{
await _plexTelevisionRepository.FlagNormal(library, result.Item);
}
else
{
await _plexTelevisionRepository.FlagUnavailable(library, result.Item);
}
if (result.IsAdded)
{
await _searchIndex.AddItems(_searchRepository, new List <MediaItem> {
result.Item
});
}
else
{
await _searchIndex.UpdateItems(_searchRepository, new List <MediaItem> {
result.Item
});
}
}
}
var fileNotFoundKeys = existingEpisodes.Map(m => m.Key).Except(episodeEntries.Map(m => m.Key)).ToList();
List <int> ids = await _plexTelevisionRepository.FlagFileNotFoundEpisodes(library, fileNotFoundKeys);
await _searchIndex.RebuildItems(_searchRepository, ids);
_searchIndex.Commit();
return(Unit.Default);
}