public async Task <ResponsesDto <CategoryResponse> > GetTvShowsCategories(int tvShowId)
{
var response = new ResponsesDto <CategoryResponse>();
var tvShowExists = await _tvShowRepository.ExistAsync(x => x.Id == tvShowId);
if (!tvShowExists)
{
response.AddError(Model.TvShow, Error.tvShow_NotFound);
return(response);
}
var assignments = _tvShowCategoryAssignemtsRepository.GetAllBy(x => x.TvShow.Id == tvShowId, x => x.Category);
var assignmentsMapped = new List <CategoryResponse>();
foreach (var assignment in assignments)
{
var category = await _categoryRepository.GetByAsync(x => x.Id == assignment.Category.Id);
var categoryMapped = _mapper.Map <CategoryResponse>(category);
assignmentsMapped.Add(categoryMapped);
}
response.DtoObject = assignmentsMapped;
return(response);
}
public async Task <ResponsesDto <WatchedEpisodesDto> > GetLastWatchedEpisodes(string userId, int numberOfEpisodes)
{
var response = new ResponsesDto <WatchedEpisodesDto>();
var watchedEpisodesList = _userWatchedEpisodeRepository
.GetAllBy(x => x.UserId == userId, x => x.Episode.Season.TvShow)
.OrderByDescending(x => x.CreateDateTime)
.Take(numberOfEpisodes);
List <WatchedEpisodesDto> mappedWatchedEpisodes = new List <WatchedEpisodesDto>();
foreach (var episode in watchedEpisodesList)
{
mappedWatchedEpisodes.Add(new WatchedEpisodesDto
{
EpisodeName = episode.Episode.EpisodeName,
Network = episode.Episode.Season.TvShow.Network,
PhotoName = episode.Episode.Season.TvShow.PhotoName,
Id = episode.Episode.Season.TvShowId,
TvShowName = episode.Episode.Season.TvShow.Name
});
}
response.DtoObject = mappedWatchedEpisodes;
return(response);
}
public async Task <ResponsesDto <GetTvSeriesCommentsDto> > GetTvSeriesComments(int tvSeriesId)
{
var response = new ResponsesDto <GetTvSeriesCommentsDto>();
var tvSeriesExists = await _tvSeriesRepository.ExistAsync(x => x.Id == tvSeriesId);
if (!tvSeriesExists)
{
response.AddError(Model.TvShow, Error.tvShow_NotFound);
return(response);
}
var comments = _commentRepository.GetAllBy(x => x.TvSeriesId == tvSeriesId, x => x.User).OrderByDescending(x => x.CreateDateTime);
if (comments.Any())
{
List <GetTvSeriesCommentsDto> tvSeriesComments = new List <GetTvSeriesCommentsDto>();
foreach (var comment in comments)
{
var user = await _userManager.FindByIdAsync(comment.UserId);
var mappedComment = _mapper.Map <GetTvSeriesCommentsDto>(comment);
mappedComment.Avatar = user.Avatar;
tvSeriesComments.Add(mappedComment);
}
response.DtoObject = tvSeriesComments;
}
return(response);
}
public async Task <ResponsesDto <GetNotificationsDto> > GetNotifications(string userId)
{
var response = new ResponsesDto <GetNotificationsDto>();
if (userId == null)
{
response.AddError(Model.Account, Error.account_Login);
return(response);
}
var notifications = _notificationRepository.GetAllBy(x => x.UserId == userId, x => x.TvShow).OrderByDescending(x => x.CreateDateTime);
var notificationsMapped = new List <GetNotificationsDto>();
if (notifications.Any())
{
foreach (var notification in notifications)
{
notificationsMapped.Add(new GetNotificationsDto
{
Type = notification.Type,
CreateDateTime = notification.CreateDateTime,
Id = notification.Id,
FirstPart = notification.FirstPart,
SecondPart = notification.SecondPart,
TvShowName = notification.TvShow.Name,
TvShowId = notification.TvShowId
});
}
response.DtoObject = notificationsMapped;
}
return(response);
}
public async Task <ResponsesDto <ActorAssignmentsResponseDto> > GetActorAssignments(int actorId)
{
var response = new ResponsesDto <ActorAssignmentsResponseDto>();
var actorExists = await _actorRepository.ExistAsync(x => x.Id == actorId);
if (!actorExists)
{
response.AddError(Model.Actor, Error.actor_NotExists);
return(response);
}
var assignments = _actorsAssignmentsRepository.GetAllBy(x => x.Actor.Id == actorId, x => x.TvShow);
var assignmentsMapped = new List <ActorAssignmentsResponseDto>();
foreach (var assignment in assignments)
{
var tvShow = await _tvShowRepository.GetByAsync(x => x.Id == assignment.TvShow.Id);
var tvShowMapped = _mapper.Map <TvShowResponse>(tvShow);
ActorAssignmentsResponseDto tmpAssignment = new ActorAssignmentsResponseDto();
tmpAssignment.TvShow = tvShowMapped;
tmpAssignment.CharacterName = assignment.CharacterName;
tmpAssignment.Id = assignment.Id;
assignmentsMapped.Add(tmpAssignment);
}
response.DtoObject = assignmentsMapped;
return(response);
}
public async Task <ResponsesDto <TvSeriesAssignmensResponseDto> > GetTvShowAssignments(int tvShowId)
{
var response = new ResponsesDto <TvSeriesAssignmensResponseDto>();
var tvShowExists = await _tvShowRepository.ExistAsync(x => x.Id == tvShowId);
if (!tvShowExists)
{
response.AddError(Model.TvShow, Error.tvShow_NotFound);
return(response);
}
var assignments = _actorsAssignmentsRepository.GetAllBy(x => x.TvShow.Id == tvShowId, x => x.Actor);
var assignmentsMapped = new List <TvSeriesAssignmensResponseDto>();
foreach (var assignment in assignments)
{
var actor = await _actorRepository.GetByAsync(x => x.Id == assignment.Actor.Id);
var actorMapped = _mapper.Map <ActorDto>(actor);
TvSeriesAssignmensResponseDto tmpAssignment = new TvSeriesAssignmensResponseDto();
tmpAssignment.ActorDto = actorMapped;
tmpAssignment.CharacterName = assignment.CharacterName;
tmpAssignment.Id = assignment.Id;
assignmentsMapped.Add(tmpAssignment);
}
response.DtoObject = assignmentsMapped;
return(response);
}
public async Task <ResponsesDto <TvShowDto> > GetPropositions(string userId)
{
var response = new ResponsesDto <TvShowDto>();
var watchedTvShow = _userWatchedEpisodeRepository
.GetAllBy(x => x.UserId == userId, x => x.Episode.Season.TvShow.Categories).GroupBy(x => x.Episode.Season.TvShow.Id).Select(x => x.Key);
List <CategoryResponse> categoryList = new List <CategoryResponse>();
foreach (var tvShowId in watchedTvShow)
{
var categories = await _tvShowCategoriesAssignmentsService.GetTvShowsCategories(tvShowId);
foreach (var category in categories.DtoObject)
{
categoryList.Add(category);
}
}
var sortedCategoryList = categoryList.GroupBy(x => x.Name).OrderByDescending(x => x.Count()).Take(4).Select(x => x.Key).ToArray();
List <int> tvShowsPropositions = new List <int>();
foreach (var category in sortedCategoryList)
{
var bestTvShows = _tvShowCategoryAssignemtsRepository.GetAllBy(x => x.Category.Name == category)
.GroupBy(x => x.TvShow.Id)
.OrderByDescending(x => x.Count())
.Select(x => x.Key)
.ToList();
foreach (var tvShow in watchedTvShow)
{
bestTvShows.Remove(tvShow);
}
bestTvShows = bestTvShows.Take(5).ToList();
tvShowsPropositions.AddRange(bestTvShows);
}
tvShowsPropositions = tvShowsPropositions.GroupBy(x => x).Select(x => x.Key).Take(15).ToList();
List <TvShowDto> finalTvShowList = new List <TvShowDto>();
foreach (var tvShowId in tvShowsPropositions)
{
var tvShow = await _tvShowRepository.GetByAsync(x => x.Id == tvShowId);
finalTvShowList.Add(_mapper.Map <TvShowDto>(tvShow));
}
response.DtoObject = finalTvShowList;
return(response);
}
public async Task <ResponsesDto <TvShowResponse> > GetUserFavouriteTvSeries(string userId)
{
var response = new ResponsesDto <TvShowResponse>();
var favouriteTvSeriesList = _userFavouriteTvShowsRepository.GetAllBy(x => x.UserId == userId, x => x.TvShow);
var mappedFavouriteTvSeries = new List <TvShowResponse>();
foreach (var favouriteTvSeries in favouriteTvSeriesList)
{
mappedFavouriteTvSeries.Add(_mapper.Map <TvShowResponse>(favouriteTvSeries));
}
response.DtoObject = mappedFavouriteTvSeries;
return(response);
}
public async Task <ResponsesDto <ActorDto> > GetActors()
{
var response = new ResponsesDto <ActorDto>();
var actors = _actorRepository.GetAll();
var mappedActors = new List <ActorDto>();
foreach (var actor in actors)
{
mappedActors.Add(_mapper.Map <ActorDto>(actor));
}
response.DtoObject = mappedActors;
return(response);
}
public async Task <ResponsesDto <WatchedEpisodesResponseDto> > GetUserWatchedEpisodes(string userId)
{
var response = new ResponsesDto <WatchedEpisodesResponseDto>();
var watchedEpisodesList = _userWatchedEpisodeRepository.GetAllBy(x => x.UserId == userId, x => x.Episode.Season.TvShow);
List <WatchedEpisodesResponseDto> mappedEpisodesList = new List <WatchedEpisodesResponseDto>();
foreach (var watchedEpisode in watchedEpisodesList)
{
mappedEpisodesList.Add(_mapper.Map <WatchedEpisodesResponseDto>(watchedEpisode));
}
response.DtoObject = mappedEpisodesList;
return(response);
}
public async Task <ResponsesDto <CategoryResponse> > GetCategories()
{
var response = new ResponsesDto <CategoryResponse>();
var categories = _categoryRepository.GetAll();
var categoriesMapped = new List <CategoryResponse>();
foreach (var category in categories)
{
categoriesMapped.Add(_mapper.Map <CategoryResponse>(category));
}
response.DtoObject = categoriesMapped;
return(response);
}
public async Task <ResponsesDto <ReturnEpisodeDto> > GetWeekEpisodes(GetWeekEpisodesBindingModel getWeekEpisodesBindingModel)
{
var response = new ResponsesDto <ReturnEpisodeDto>();
var episodes = _episodeRepository.GetAllBy(x => x.AiringDate >= getWeekEpisodesBindingModel.dateFrom && x.AiringDate <= getWeekEpisodesBindingModel.dateTo,
x => x.Season, x => x.Season.TvShow, x => x.Season.TvShow.TvSeriesRatings);
var mappedEpisodes = new List <ReturnEpisodeDto>();
foreach (var episode in episodes)
{
mappedEpisodes.Add(_mapper.Map <ReturnEpisodeDto>(episode));
}
response.DtoObject = mappedEpisodes;
return(response);
}
public async Task <ResponsesDto <SeasonDto> > GetWeatchedSeasons(int tvSeriesId, string userId)
{
var response = new ResponsesDto <SeasonDto>();
var seasons = _seasonRepository.GetAllBy(x => x.TvShowId == tvSeriesId, x => x.Episodes);
var mappedSeasons = new List <SeasonDto>();
foreach (var season in seasons)
{
mappedSeasons.Add(_mapper.Map <SeasonDto>(season));
}
response.DtoObject = mappedSeasons;
if (mappedSeasons.Count > 0 && userId != null)
{
foreach (var season in mappedSeasons)
{
var seasonWatched = true;
foreach (var episode in season.Episodes)
{
if (await CheckIfEpisodeWatched(episode.Id, userId))
{
episode.Watched = true;
}
else
{
seasonWatched = false;
}
}
season.Watched = seasonWatched;
}
response.DtoObject = mappedSeasons;
}
return(response);
}
public async Task <ResponsesDto <SeasonResponseDto> > GetAllSeasons(int tvSeriesId)
{
var response = new ResponsesDto <SeasonResponseDto>();
var tvSeriesExists = await _tvShowRepository.ExistAsync(x => x.Id == tvSeriesId);
if (!tvSeriesExists)
{
response.AddError(Model.TvShow, Error.tvShow_NotFound);
}
var seasons = _seasonRepository.GetAllBy(x => x.TvShowId == tvSeriesId, x => x.Episodes);
var mappedSeasons = new List <SeasonResponseDto>();
foreach (var season in seasons)
{
mappedSeasons.Add(_mapper.Map <SeasonResponseDto>(season));
}
response.DtoObject = mappedSeasons;
return(response);
}
public async Task <ResponsesDto <EpisodeDto> > GetEpisodes(int seasonId)
{
var response = new ResponsesDto <EpisodeDto>();
var seasonExists = await _seasonRepository.ExistAsync(x => x.Id == seasonId);
if (!seasonExists)
{
response.AddError(Model.Season, Error.season_NotFound);
return(response);
}
var episodes = _episodeRepository.GetAllBy(x => x.SeasonId == seasonId);
var mappedEpisodes = new List <EpisodeDto>();
foreach (var episode in episodes)
{
mappedEpisodes.Add(_mapper.Map <EpisodeDto>(episode));
}
response.DtoObject = mappedEpisodes;
return(response);
}
public async Task <ResponsesDto <ReturnEpisodeDto> > GetMonthEpisodes(int monthNumber)
{
var response = new ResponsesDto <ReturnEpisodeDto>();
if (monthNumber > 12 || monthNumber < 1)
{
response.AddError(Model.Calendar, Error.calendar_Wrong_Month);
return(response);
}
var episodes = _episodeRepository.GetAllBy(x => x.AiringDate.Month == monthNumber, x => x.Season, x => x.Season.TvShow, x => x.Season.TvShow.TvSeriesRatings);
var mappedEpisodes = new List <ReturnEpisodeDto>();
foreach (var episode in episodes)
{
mappedEpisodes.Add(_mapper.Map <ReturnEpisodeDto>(episode));
}
response.DtoObject = mappedEpisodes;
return(response);
}
