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); }