private Task <Either <ProcessFailedResult, AniListSeriesData> > FindSingleMatchingSeries(string title,
ProcessResultContext resultContext)
{
return(this.aniListClient.FindSeriesAsync(title, resultContext)
.BindAsync(aniListSeriesData => FailUnlessOneResult(aniListSeriesData, resultContext)));
}
public Task <Either <FailedRequest, string> > GetToken(IJsonConnection jsonConnection,
IAnilistConfiguration anilistConfiguration, ProcessResultContext resultContext)
{
return(anilistConfiguration.AccessToken.MapAsync(Right <FailedRequest, string>)
.IfNone(() => GetTokenFromCacheOrRequest(jsonConnection, anilistConfiguration)));
}
private Either <ProcessFailedResult, ISourceData> CreateSourceDataWithTitle(IMediaItem mediaItem,
AniListSeriesData seriesData, ProcessResultContext resultContext)
{
return(this.sources.AniList.SelectTitle(seriesData.Title, mediaItem.EmbyData.Language, resultContext)
.Map(t => this.CreateSourceData(seriesData, t)));
}
public Task <Either <ProcessFailedResult, AniDbSeriesData> > GetSeriesData(int aniDbSeriesId,
ProcessResultContext resultContext)
{
return(this.aniDbClient.GetSeriesAsync(aniDbSeriesId)
.ToEitherAsync(resultContext.Failed($"Failed to load series with AniDb Id '{aniDbSeriesId}'")));
}
private Task <Either <ProcessFailedResult, AniDbEpisodeData> > MapEpisodeDataAsync(int aniDbSeriesId,
TvDbSeriesData tvDbSeriesData, TvDbEpisodeData tvDbEpisodeData, ProcessResultContext resultContext)
{
var seriesMapping = this.mappingList.GetSeriesMappingsFromTvDb(tvDbSeriesData.Id, resultContext)
.BindAsync(sm => sm.Where(m => m.Ids.AniDbSeriesId == aniDbSeriesId)
.Match(
() => resultContext.Failed(
$"No series mapping between TvDb series Id '{tvDbSeriesData.Id}' and AniDb series id '{aniDbSeriesId}'"),
Prelude.Right <ProcessFailedResult, ISeriesMapping>,
(head, tail) =>
resultContext.Failed(
$"Multiple series mappings found between TvDb series Id '{tvDbSeriesData.Id}' and AniDb series Id '{aniDbSeriesId}'")));
return(seriesMapping.BindAsync(sm =>
{
var episodeGroupMapping = sm.GetEpisodeGroupMapping(tvDbEpisodeData.AiredEpisodeNumber,
tvDbEpisodeData.AiredSeason);
var aniDbEpisodeData = this.episodeMapper.MapTvDbEpisodeAsync(tvDbEpisodeData.AiredEpisodeNumber,
sm, episodeGroupMapping);
return aniDbEpisodeData.ToEither(resultContext.Failed(
$"Failed to find a corresponding AniDb episode in AniDb series id '{aniDbSeriesId}'"));
}));
}
public Either <ProcessFailedResult, string> SelectTitle(AniListTitleData titleData,
string metadataLanguage, ProcessResultContext resultContext)
{
return(this.aniListNameSelector
.SelectTitle(titleData, this.titlePreferenceConfiguration.TitlePreference, metadataLanguage)
.ToEither(resultContext.Failed("Failed to find a title")));
}
public Either <ProcessFailedResult, string> SelectTitle(IEnumerable <ItemTitleData> titles,
string metadataLanguage, ProcessResultContext resultContext)
{
return(this.titleSelector.SelectTitle(titles, this.titlePreferenceConfiguration.TitlePreference, metadataLanguage)
.Map(t => t.Title)
.ToEither(resultContext.Failed("Failed to find a title")));
}
private Task <Either <ProcessFailedResult, TvDbEpisodeData> > MapEpisodeDataAsync(AniDbSeriesData aniDbSeriesData,
AniDbEpisodeData aniDbEpisodeData, ProcessResultContext resultContext)
{
var seriesMapping = _mappingList.GetSeriesMappingFromAniDb(aniDbSeriesData.Id, resultContext);
return(seriesMapping.BindAsync(sm =>
{
var episodeGroupMapping = sm.GetEpisodeGroupMapping(aniDbEpisodeData.EpisodeNumber);
var tvDbEpisodeData = _episodeMapper.MapAniDbEpisodeAsync(aniDbEpisodeData.EpisodeNumber.Number,
sm, episodeGroupMapping);
return tvDbEpisodeData.Match(
d => Right <ProcessFailedResult, TvDbEpisodeData>(d),
() => resultContext.Failed("Found a series mapping but failed to map the episode to TvDb"));
}));
}
public Task <Either <ProcessFailedResult, IEnumerable <AniListSeriesData> > > FindSeriesAsync(string title,
ProcessResultContext resultContext)
{
var token = _aniListToken.GetToken(_jsonConnection, _anilistConfiguration, resultContext);
var request = new FindSeriesRequest(title);
return(token.Map(e => e.MapLeft(FailedRequest.ToFailedResult(resultContext)))
.BindAsync(t =>
{
return _jsonConnection.PostAsync(request, t)
.MapAsync(r => r.Data.Data.Page.Media)
.Map(e => e.MapLeft(FailedRequest.ToFailedResult(resultContext)));
}));
}
private Task <Either <ProcessFailedResult, TvDbEpisodeData> > FindEpisode(IEnumerable <TvDbEpisodeData> episodes,
string title, Option <int> episodeIndex, Option <int> seasonIndex, ProcessResultContext resultContext)
{
var normalisedTitle = this.titleNormaliser.GetNormalisedTitle(title);
var episodeByIndexes = episodeIndex.Bind(i =>
seasonIndex.Bind(si => episodes.Find(e => e.AiredEpisodeNumber == i && e.AiredSeason == si))
.Match(e => e, () => episodes.Find(e => e.AiredEpisodeNumber == i && e.AiredSeason == 1)));
return(episodeByIndexes.Match(Right <ProcessFailedResult, TvDbEpisodeData>,
() => Option <TvDbEpisodeData>
.Some(episodes.FirstOrDefault(e =>
this.titleNormaliser.GetNormalisedTitle(e.EpisodeName) == normalisedTitle))
.ToEither(resultContext.Failed(
$"Failed to find TvDb episode")))
.AsTask());
}
public static Func <FailedRequest, ProcessFailedResult> ToFailedResult(ProcessResultContext resultContext)
{
return(r => resultContext.Failed($"Request failed with {r.StatusCode}: {r.ResponseContent}"));
}
public Task <Either <ProcessFailedResult, ISeriesMapping> > GetSeriesMappingFromAniDb(int aniDbSeriesId,
ProcessResultContext resultContext)
{
return(_mappingListTaskLazy.Value
.Map(seriesMappings => seriesMappings.Where(m => m.Ids.AniDbSeriesId == aniDbSeriesId).ToList())
.Map(matchingSeriesMappings =>
{
switch (matchingSeriesMappings.Count)
{
case 0:
return Left <ProcessFailedResult, ISeriesMapping>(
resultContext.Failed($"No series mapping for AniDb series Id '{aniDbSeriesId}'"));
case 1:
return Right <ProcessFailedResult, ISeriesMapping>(matchingSeriesMappings.Single());
default:
return Left <ProcessFailedResult, ISeriesMapping>(
resultContext.Failed(
$"Multiple series mappings match AniDb series Id '{aniDbSeriesId}'"));
}
}));
}
public Task <Either <ProcessFailedResult, TvDbSeriesData> > GetSeriesData(int tvDbSeriesId,
ProcessResultContext resultContext)
{
return(_tvDbClient.GetSeriesAsync(tvDbSeriesId)
.ToEitherAsync(resultContext.Failed($"Failed to load parent series with TvDb Id '{tvDbSeriesId}'")));
}
public async Task <Either <ProcessFailedResult, ISeriesMapping> > GetSeriesMappingFromAniDb(int aniDbSeriesId,
ProcessResultContext resultContext)
{
var result = await this.mappingListTaskLazy.Value
.Map(seriesMappings => seriesMappings.Where(m => m.Ids.AniDbSeriesId == aniDbSeriesId).ToList())
.Map(matchingSeriesMappings =>
{
switch (matchingSeriesMappings.Count)
{
case 0:
return(GetFallbackSeriesMappingFromAniDb(aniDbSeriesId, resultContext).GetAwaiter().GetResult());
case 1:
return(Right <ProcessFailedResult, ISeriesMapping>(matchingSeriesMappings.Single()));
default:
return(GetFallbackSeriesMappingFromAniDb(aniDbSeriesId, resultContext).GetAwaiter().GetResult());
}
});
return(result);
}
private async Task <Either <ProcessFailedResult, IEnumerable <ISeriesMapping> > > GetFallbackSeriesMappingFromTvDb(int tvDbSeriesId,
ProcessResultContext resultContext)
{
return(await this.xemTvDbMappingListTaskLazy.Value
.Map(seriesMappings => seriesMappings.Where(m => m.Ids.TvDbSeriesId == tvDbSeriesId).ToList())
.Map(matchingSeriesMappings =>
{
switch (matchingSeriesMappings.Count)
{
case 0:
return Left <ProcessFailedResult, IEnumerable <ISeriesMapping> >(
resultContext.Failed($"No series mapping for TvDb series Id '{tvDbSeriesId}'"));
case 1:
return Right <ProcessFailedResult, IEnumerable <ISeriesMapping> >(matchingSeriesMappings);
default:
return Left <ProcessFailedResult, IEnumerable <ISeriesMapping> >(
resultContext.Failed(
$"Multiple series mappings match TvDb series Id '{tvDbSeriesId}'"));
}
}));
}
private Task <Either <ProcessFailedResult, int> > MapSeriesDataAsync(int tvDbSeriesId, IdentifierOnlySourceData identifierData, ProcessResultContext resultContext)
{
var seriesMapping = this.mappingList.GetSeriesMappingsFromTvDb(tvDbSeriesId, resultContext)
.BindAsync(sm => sm.Where(m => m.DefaultTvDbSeason.Exists(s => s.Index == identifierData.Identifier.Index))
.Match(
() => resultContext.Failed(
$"No series mapping between TvDb series Id '{tvDbSeriesId}', season '{identifierData.Identifier.Index}'' and AniDb series"),
Prelude.Right <ProcessFailedResult, ISeriesMapping>,
(head, tail) =>
resultContext.Failed(
$"Multiple series mappings found between TvDb series Id '{tvDbSeriesId}', season '{identifierData.Identifier.Index}'' and AniDb series")));
return(seriesMapping.MapAsync(sm => sm.Ids.AniDbSeriesId));
}
