public TvShowRequestBuilderV2 CreateTvList(TvRequestViewModelV2 tv)
{
TvRequests = new List <SeasonsViewModel>();
// Only have the TV requests we actually requested and not everything
foreach (var season in tv.Seasons)
{
if (season.Episodes.Any())
{
TvRequests.Add(season);
}
}
return(this);
}
public async Task <RequestEngineResult> RequestTv([FromBody] TvRequestViewModelV2 tv)
{
tv.RequestedByAlias = GetApiAlias();
var result = await _tvRequestEngine.RequestTvShow(tv);
if (result.Result)
{
var voteResult = await _voteEngine.UpVote(result.RequestId, RequestType.TvShow);
if (voteResult.IsError)
{
_logger.LogError("Couldn't automatically add the vote for the tv {0} because {1}", tv.TheMovieDbId, voteResult.ErrorMessage);
}
}
return(result);
}
public TvShowRequestBuilderV2 CreateChild(TvRequestViewModelV2 model, string userId)
{
var animationGenre = TheMovieDbRecord.genres?.Any(s => s.name.Equals("Animation", StringComparison.InvariantCultureIgnoreCase)) ?? false;
var animeKeyword = TheMovieDbRecord.Keywords?.KeywordsValue?.Any(s => s.Name.Equals("Anime", StringComparison.InvariantCultureIgnoreCase)) ?? false;
ChildRequest = new ChildRequests
{
Id = model.TheMovieDbId, // This is set to 0 after the request rules have run, the request rules needs it to identify the request
RequestType = RequestType.TvShow,
RequestedDate = DateTime.UtcNow,
Approved = false,
RequestedUserId = userId,
SeasonRequests = new List <SeasonRequests>(),
Title = TheMovieDbRecord.name,
ReleaseYear = FirstAir,
RequestedByAlias = model.RequestedByAlias,
SeriesType = animationGenre && animeKeyword ? SeriesType.Anime : SeriesType.Standard
};
return(this);
}
public TvShowRequestBuilderV2 CreateNewRequest(TvRequestViewModelV2 tv, int rootPathOverride, int qualityOverride, int langProfile)
{
int.TryParse(TheMovieDbRecord.ExternalIds?.TvDbId, out var tvdbId);
NewRequest = new TvRequests
{
Overview = TheMovieDbRecord.overview,
PosterPath = PosterPath,
Title = TheMovieDbRecord.name,
ReleaseDate = FirstAir,
ExternalProviderId = TheMovieDbRecord.id,
Status = TheMovieDbRecord.status,
ImdbId = TheMovieDbRecord.ExternalIds?.ImdbId ?? string.Empty,
TvDbId = tvdbId,
ChildRequests = new List <ChildRequests>(),
TotalSeasons = tv.Seasons.Count(),
Background = BackdropPath,
RootFolder = rootPathOverride,
QualityOverride = qualityOverride,
LanguageProfile = langProfile
};
NewRequest.ChildRequests.Add(ChildRequest);
return(this);
}
public async Task <RequestEngineResult> RequestTvShow(TvRequestViewModelV2 tv)
{
var user = await GetUser();
var canRequestOnBehalf = tv.RequestOnBehalf.HasValue();
var isAdmin = await UserManager.IsInRoleAsync(user, OmbiRoles.PowerUser) || await UserManager.IsInRoleAsync(user, OmbiRoles.Admin);
if (tv.RequestOnBehalf.HasValue() && !isAdmin)
{
return(new RequestEngineResult
{
Result = false,
ErrorCode = ErrorCode.NoPermissionsOnBehalf,
Message = "You do not have the correct permissions to request on behalf of users!",
ErrorMessage = $"You do not have the correct permissions to request on behalf of users!"
});
}
if ((tv.RootFolderOverride.HasValue || tv.QualityPathOverride.HasValue || tv.LanguageProfile.HasValue) && !isAdmin)
{
return(new RequestEngineResult
{
Result = false,
ErrorCode = ErrorCode.NoPermissions,
Message = "You do not have the correct permissions!",
ErrorMessage = $"You do not have the correct permissions!"
});
}
var tvBuilder = new TvShowRequestBuilderV2(MovieDbApi);
(await tvBuilder
.GetShowInfo(tv.TheMovieDbId, tv.languageCode))
.CreateTvList(tv)
.CreateChild(tv, canRequestOnBehalf ? tv.RequestOnBehalf : user.Id, tv.Source);
await tvBuilder.BuildEpisodes(tv);
var ruleResults = await RunRequestRules(tvBuilder.ChildRequest);
var results = ruleResults as RuleResult[] ?? ruleResults.ToArray();
if (results.Any(x => !x.Success))
{
return(new RequestEngineResult
{
ErrorMessage = results.FirstOrDefault(x => !string.IsNullOrEmpty(x.Message)).Message
});
}
// Check if we have auto approved the request, if we have then mark the episodes as approved
if (tvBuilder.ChildRequest.Approved)
{
foreach (var seasons in tvBuilder.ChildRequest.SeasonRequests)
{
foreach (var ep in seasons.Episodes)
{
ep.Approved = true;
ep.Requested = true;
}
}
}
var existingRequest = await TvRepository.Get().FirstOrDefaultAsync(x => x.ExternalProviderId == tv.TheMovieDbId);
if (existingRequest != null)
{
// Remove requests we already have, we just want new ones
foreach (var existingSeason in existingRequest.ChildRequests)
{
foreach (var existing in existingSeason.SeasonRequests)
{
var newChild = tvBuilder.ChildRequest.SeasonRequests.FirstOrDefault(x => x.SeasonNumber == existing.SeasonNumber);
if (newChild != null)
{
// We have some requests in this season...
// Let's find the episodes.
foreach (var existingEp in existing.Episodes)
{
var duplicateEpisode = newChild.Episodes.FirstOrDefault(x => x.EpisodeNumber == existingEp.EpisodeNumber);
if (duplicateEpisode != null)
{
// Remove it.
newChild.Episodes.Remove(duplicateEpisode);
}
}
if (!newChild.Episodes.Any())
{
// We may have removed all episodes
tvBuilder.ChildRequest.SeasonRequests.Remove(newChild);
}
}
}
}
// Remove the ID since this is a new child
// This was a TVDBID for the request rules to run
tvBuilder.ChildRequest.Id = 0;
if (!tvBuilder.ChildRequest.SeasonRequests.Any())
{
// Looks like we have removed them all! They were all duplicates...
return(new RequestEngineResult
{
Result = false,
ErrorCode = ErrorCode.AlreadyRequested,
ErrorMessage = "This has already been requested"
});
}
return(await AddExistingRequest(tvBuilder.ChildRequest, existingRequest, tv.RequestOnBehalf, tv.RootFolderOverride.GetValueOrDefault(), tv.QualityPathOverride.GetValueOrDefault()));
}
// This is a new request
var newRequest = tvBuilder.CreateNewRequest(tv, tv.RootFolderOverride.GetValueOrDefault(), tv.QualityPathOverride.GetValueOrDefault(), tv.LanguageProfile.GetValueOrDefault());
return(await AddRequest(newRequest.NewRequest, tv.RequestOnBehalf));
}
public async Task <TvShowRequestBuilderV2> BuildEpisodes(TvRequestViewModelV2 tv)
{
var allEpisodes = new List <Episode>();
foreach (var season in TheMovieDbRecord.seasons)
{
var seasonEpisodes = await MovieDbApi.GetSeasonEpisodes(TheMovieDbRecord.id, season.season_number, CancellationToken.None);
allEpisodes.AddRange(seasonEpisodes.episodes);
}
if (tv.RequestAll)
{
foreach (var ep in allEpisodes)
{
var season = ChildRequest.SeasonRequests.FirstOrDefault(x => x.SeasonNumber == ep.season_number);
if (season == null)
{
ChildRequest.SeasonRequests.Add(new SeasonRequests
{
Episodes = new List <EpisodeRequests> {
new EpisodeRequests
{
EpisodeNumber = ep.episode_number,
AirDate = FormatDate(ep.air_date),
Title = ep.name,
}
},
SeasonNumber = ep.season_number,
});
}
else
{
season.Episodes.Add(new EpisodeRequests
{
EpisodeNumber = ep.episode_number,
AirDate = FormatDate(ep.air_date),
Title = ep.name,
});
}
}
}
else if (tv.LatestSeason)
{
var latest = allEpisodes.OrderByDescending(x => x.season_number).FirstOrDefault();
var episodesRequests = new List <EpisodeRequests>();
foreach (var ep in allEpisodes)
{
if (ep.season_number == latest.season_number)
{
episodesRequests.Add(new EpisodeRequests
{
EpisodeNumber = ep.episode_number,
AirDate = FormatDate(ep.air_date),
Title = ep.name,
});
}
}
ChildRequest.SeasonRequests.Add(new SeasonRequests
{
Episodes = episodesRequests,
SeasonNumber = latest.season_number,
});
}
else if (tv.FirstSeason)
{
var first = allEpisodes.OrderBy(x => x.season_number).FirstOrDefault();
var episodesRequests = new List <EpisodeRequests>();
foreach (var ep in allEpisodes)
{
if (ep.season_number == first.season_number)
{
episodesRequests.Add(new EpisodeRequests
{
EpisodeNumber = ep.episode_number,
AirDate = FormatDate(ep.air_date),
Title = ep.name,
});
}
}
ChildRequest.SeasonRequests.Add(new SeasonRequests
{
Episodes = episodesRequests,
SeasonNumber = first.season_number,
});
}
else
{
// It's a custom request
var seasonRequests = new List <SeasonRequests>();
foreach (var ep in allEpisodes)
{
var existingSeasonRequest = seasonRequests.FirstOrDefault(x => x.SeasonNumber == ep.season_number);
if (existingSeasonRequest != null)
{
var requestedSeason = tv.Seasons.FirstOrDefault(x => x.SeasonNumber == ep.season_number);
var requestedEpisode = requestedSeason?.Episodes?.Any(x => x.EpisodeNumber == ep.episode_number) ?? false;
if (requestedSeason != null && requestedEpisode)
{
// We already have this, let's just add the episodes to it
existingSeasonRequest.Episodes.Add(new EpisodeRequests
{
EpisodeNumber = ep.episode_number,
AirDate = FormatDate(ep.air_date),
Title = ep.name,
});
}
}
else
{
var newRequest = new SeasonRequests {
SeasonNumber = ep.season_number
};
var requestedSeason = tv.Seasons.FirstOrDefault(x => x.SeasonNumber == ep.season_number);
var requestedEpisode = requestedSeason?.Episodes?.Any(x => x.EpisodeNumber == ep.episode_number) ?? false;
if (requestedSeason != null && requestedEpisode)
{
newRequest.Episodes.Add(new EpisodeRequests
{
EpisodeNumber = ep.episode_number,
AirDate = FormatDate(ep.air_date),
Title = ep.name,
});
seasonRequests.Add(newRequest);
}
}
}
foreach (var s in seasonRequests)
{
ChildRequest.SeasonRequests.Add(s);
}
}
return(this);
}
