private void CreateNotification(FavoritedAnime favoritedAnime, string notificationChannelId) { if (!(favoritedAnime.Anime.Airing && IsTVSeries(favoritedAnime))) { return; } var notification = new Notification { Android = new AndroidOptions { ChannelId = notificationChannelId, Channel = "Today Animes", ChannelDescription = "General", AutoCancel = true, }, Id = favoritedAnime.UniqueNotificationID, Title = favoritedAnime.Anime.Title, Message = Lang.Lang.EpisodeToday, Sound = NotificationSound.None, }; _notificationManager.Send(notification); }
public static bool HasNotStartedAiring(FavoritedAnime favoriteAnime) { return(favoriteAnime.Anime.Aired?.From != null && favoriteAnime.Anime.Aired.From > DateTime.Today && !favoriteAnime.Anime.Airing && !favoriteAnime.IsArchived); }
public static Task <bool> HasAnyDayOfWeekAsync(this FavoritedAnime favoriteAnime, params DayOfWeekFilterDate[] dayOfWeekFilterDates) { return(Task.Run(() => { List <bool> hasAnyDayOfWeek = new List <bool>(); if (dayOfWeekFilterDates.Length == 0) { return true; } foreach (var dayOfWeek in dayOfWeekFilterDates) { if (favoriteAnime.NextStreamDate != null && favoriteAnime.Anime.Airing && !favoriteAnime.IsArchived) { bool hasWeekDay = favoriteAnime.NextStreamDate.Value.DayOfWeek.ToString() == dayOfWeek.TodayDayOfWeek.ToString(); bool hasToday = false; if (dayOfWeek.TodayDayOfWeek == TodayDayOfWeek.Today) { hasToday = favoriteAnime.NextStreamDate.Value.DayOfWeek == DateTime.Today.DayOfWeek; } if (hasWeekDay || hasToday) { hasAnyDayOfWeek.Add(hasWeekDay | hasToday); } } else if (favoriteAnime.IsArchived && dayOfWeek.TodayDayOfWeek == TodayDayOfWeek.Archived) { hasAnyDayOfWeek.Add(true); break; } else if (HasNotStartedAiring(favoriteAnime) && dayOfWeek.TodayDayOfWeek == TodayDayOfWeek.NotStarted) { hasAnyDayOfWeek.Add(true); } else if (HasFinishedAiring(favoriteAnime) && dayOfWeek.TodayDayOfWeek == TodayDayOfWeek.FinishedAiring) { hasAnyDayOfWeek.Add(true); } else if (IsUnknownAiring(favoriteAnime) && dayOfWeek.TodayDayOfWeek == TodayDayOfWeek.Unknown) { hasAnyDayOfWeek.Add(true); } } return hasAnyDayOfWeek.Any(p => p); })); }
public static bool HasFinishedAiring(FavoritedAnime favoriteAnime) { return(!favoriteAnime.Anime.Airing && favoriteAnime.Anime.Aired != null && favoriteAnime.Anime.Aired.From.HasValue && favoriteAnime.Anime.Aired.To.HasValue && favoriteAnime.Anime.Aired.From < DateTime.Today && favoriteAnime.Anime.Aired.To < DateTime.Today && !favoriteAnime.IsArchived); }
private Task AddOrUpdateRecentAnimeAsync(FavoritedAnime recentFavoritedAnime) { return(Task.Run(() => { if (_cancellationToken.IsCancellationRequested) { _cancellationToken.Token.ThrowIfCancellationRequested(); } var recentCollection = App.liteDB.GetCollection <RecentVisualized>(); var favoritedSubEntry = recentCollection.FindById(recentFavoritedAnime.Anime.MalId); if (favoritedSubEntry != null) { recentCollection.Upsert(recentFavoritedAnime.Anime.MalId, new RecentVisualized(recentFavoritedAnime)); } else { if (recentCollection.Count() == 10) { var settings = App.liteDB.GetCollection <SettingsPreferences>().FindById(0); DateTimeOffset mostAntiqueDate = default; var minDate = recentCollection.Min(p => p.Date); var nsfwCollection = recentCollection.Find(p => p.FavoritedAnime.IsNSFW); if (settings.ShowNSFW) { mostAntiqueDate = minDate; } else { if (nsfwCollection != null && nsfwCollection.Count() > 0) { mostAntiqueDate = nsfwCollection.Min(p => p.Date); } else if (nsfwCollection == null || nsfwCollection.Count() == 0) { mostAntiqueDate = minDate; } } RecentVisualized mostAntiqueVisualized = recentCollection.FindOne(p => p.Date == mostAntiqueDate); recentCollection.Delete(mostAntiqueVisualized.FavoritedAnime.Anime.MalId); recentCollection.Upsert(recentFavoritedAnime.Anime.MalId, new RecentVisualized(recentFavoritedAnime)); } else if (recentCollection.Count() < 10) { recentCollection.Upsert(recentFavoritedAnime.Anime.MalId, new RecentVisualized(recentFavoritedAnime)); } } }, _cancellationToken.Token)); }
private async Task OnApplyFilter() { var checkedGenres = FilterData.Genres.Where(p => p.IsChecked).Select(p => p.Genre).ToList(); var checkedDaysOfWeek = FilterData.DayOfWeekOrder.Where(p => p.IsChecked).ToList(); MessagingCenter.Send(this, "CloseFilterView"); await Task.Delay(TimeSpan.FromMilliseconds(500)); // usado para impedir que seja visto um leve engasto na filtragem var animeToRemove = new List <FavoritedAnime>(); // meio encontrado de não ter a originalCollection filtrada, não está bom, mas é a correção por hora _originalCollection = await ConstructGroupedCollectionAsync(); var groupAnimes = new List <GroupedFavoriteAnimeByWeekDay>(_originalCollection); //TODO:contar a quantidade de animes cadastrados e ver se todos estão aparecendo apenas uma única vez //TODO:olhar aqui em conjunto com o HasAnyDayOfWeek for (int i = 0; i < groupAnimes.Count; i++) { GroupedFavoriteAnimeByWeekDay favoritedAnimeGroup = groupAnimes[i]; for (int j = 0; j < favoritedAnimeGroup.Count; j++) { FavoritedAnime favoritedAnime = favoritedAnimeGroup[j]; var hasAllGenresTask = favoritedAnime.HasAllSpecifiedGenresAsync(checkedGenres.ToArray()); var hasAnyDaysOfWeekTask = favoritedAnime.HasAnyDayOfWeekAsync(checkedDaysOfWeek.ToArray()); if (!await hasAllGenresTask || !await hasAnyDaysOfWeekTask) { animeToRemove.Add(favoritedAnime); } } } if (animeToRemove.Count > 0) { foreach (var item in animeToRemove) { foreach (var group in groupAnimes) { if (group.Contains(item)) { group.Remove(item); } } } } var groupsWithAnimes = groupAnimes.Where(p => p.Count > 0); GroupedFavoriteByWeekList.ReplaceRange(groupsWithAnimes); }
public async static Task <IList <FavoritedAnime> > ConvertCatalogueAnimesToFavoritedAsync(this ICollection <AnimeSubEntry> animeSubEntries, bool showNSFW) { var animeSubs = animeSubEntries.ToList(); var favoritedAnimeSubsEntries = new List <FavoritedAnime>(); for (int i = 0; i < animeSubs.Count; i++) { var anime = animeSubs[i]; var animeSub = new FavoritedAnime { Anime = new Anime { MalId = anime.MalId, Title = anime.Title, ImageURL = anime.ImageURL, Genres = anime.Genres, LinkCanonical = anime.URL, Score = anime.Score, Aired = new TimePeriod() { From = anime.AiringStart, }, }, }; if (!showNSFW && animeSub.Anime.Genres != null) { bool hasNSFWGenres = await HasAnySpecifiedGenresAsync(animeSub, FillNSFWGenres().Select(p => p.Genre).ToArray()); animeSub.IsNSFW = hasNSFWGenres; if (hasNSFWGenres) { continue; } } if (App.liteDB.GetCollection <FavoritedAnime>().Exists(p => p.Anime.MalId == anime.MalId)) { animeSub.IsFavorited = true; } favoritedAnimeSubsEntries.Add(animeSub); } return(favoritedAnimeSubsEntries); }
private void OnStepper(FavoritedAnime favoritedAnime) { var favoriteds = App.liteDB.GetCollection <FavoritedAnime>(); FavoritedAnime favorited = favoriteds.FindById(favoritedAnime.Anime.MalId); if (favorited == null) { return; } if (favorited.LastEpisodeSeen != favoritedAnime.LastEpisodeSeen) { favoriteds.Update(favoritedAnime.Anime.MalId, favoritedAnime); } }
private void OnSwitch(FavoritedAnime favoritedAnime) { var favoriteds = App.liteDB.GetCollection <FavoritedAnime>(); FavoritedAnime favorited = favoriteds.FindById(favoritedAnime.Anime.MalId); if (favorited == null) { return; } if (favorited.CanGenerateNotifications != favoritedAnime.CanGenerateNotifications) { favoriteds.Update(favoritedAnime.Anime.MalId, favoritedAnime); } }
public static Task <bool> HasAnySpecifiedGenresAsync(this FavoritedAnime favoriteAnime, params GenreSearch[] genres) { return(Task.Run(() => { List <bool> hasAnyGenres = new List <bool>(); foreach (var genre in genres) { bool result = favoriteAnime.Anime.Genres.Any(p => p.Name.ToLowerInvariant().RemoveOcurrencesFromString(new[] { '-', ' ' }) == genre.ToString().ToLowerInvariant().RemoveOcurrencesFromString(new[] { '-', ' ' })); hasAnyGenres.Add(result); } return hasAnyGenres.Any(p => p); })); }
public async Task LoadAsync(object param) { IsLoading = true; CanEnable = false; try { long id = (long)param; _favoritedAnime = App.liteDB.GetCollection <FavoritedAnime>().FindById(id); if (_favoritedAnime == null) { await App.DelayRequest(); var anime = await App.Jikan.GetAnime(id); anime.RequestCached = true; _favoritedAnime = new FavoritedAnime(anime); } AnimeGenres = _favoritedAnime.Anime.Genres.ToList(); IsLoadingNews = true; await App.DelayRequest(2); var loadAnimeNewsTask = Task.Run(async() => { if (_cancellationToken.IsCancellationRequested) { _cancellationToken.Token.ThrowIfCancellationRequested(); } AnimeNews animeNews = await App.Jikan.GetAnimeNews(_favoritedAnime.Anime.MalId); News = animeNews.News.ToList(); }, _cancellationToken.Token); await AddOrUpdateRecentAnimeAsync(_favoritedAnime); AnimeContext = _favoritedAnime; CanEnable = true; IsLoading = false; IsLoadingCharacters = true; await App.DelayRequest(2); var loadCharactersTask = Task.Run(async() => { if (_cancellationToken.IsCancellationRequested) { _cancellationToken.Token.ThrowIfCancellationRequested(); } AnimeCharactersStaff animeCharactersStaff = await App.Jikan.GetAnimeCharactersStaff(_favoritedAnime.Anime.MalId); Characters = animeCharactersStaff.Characters.ToList(); }, _cancellationToken.Token); IsLoadingRelated = true; var relatedAnimeTask = Task.Run(() => { if (_cancellationToken.IsCancellationRequested) { _cancellationToken.Token.ThrowIfCancellationRequested(); } var relatedAnimes = new List <Model.RelatedAnime>(); if (_favoritedAnime.Anime.Related.ParentStories != null) { relatedAnimes.AddRange(_favoritedAnime.Anime.Related.ParentStories .ConvertMalSubItemToRelatedAnime(Lang.Lang.Parent)); } if (_favoritedAnime.Anime.Related.Prequels != null) { relatedAnimes.AddRange(_favoritedAnime.Anime.Related.Prequels .ConvertMalSubItemToRelatedAnime(Lang.Lang.Prequels)); } if (_favoritedAnime.Anime.Related.Sequels != null) { relatedAnimes.AddRange(_favoritedAnime.Anime.Related.Sequels .ConvertMalSubItemToRelatedAnime(Lang.Lang.Sequels)); } if (_favoritedAnime.Anime.Related.SideStories != null) { relatedAnimes.AddRange(_favoritedAnime.Anime.Related.SideStories .ConvertMalSubItemToRelatedAnime(Lang.Lang.SideStory)); } if (_favoritedAnime.Anime.Related.SpinOffs != null) { relatedAnimes.AddRange(_favoritedAnime.Anime.Related.SpinOffs .ConvertMalSubItemToRelatedAnime(Lang.Lang.SpinOffs)); } if (_favoritedAnime.Anime.Related.Others != null) { relatedAnimes.AddRange(_favoritedAnime.Anime.Related.Others .ConvertMalSubItemToRelatedAnime(Lang.Lang.Others)); } if (_favoritedAnime.Anime.Related.AlternativeVersions != null) { relatedAnimes.AddRange(_favoritedAnime.Anime.Related.AlternativeVersions .ConvertMalSubItemToRelatedAnime(Lang.Lang.AlternativeVersions)); } //TODO: por aqui todos os outros dados que estão dentro de Anime.Related _favoritedAnime.RelatedAnimes = relatedAnimes; var groupedRelatedAnime = new List <GroupedRelatedAnime>(); foreach (var item in _favoritedAnime.RelatedAnimes.GroupBy(p => p.GroupName)) { groupedRelatedAnime.Add(new GroupedRelatedAnime(item.Key, item.ToList())); } GroupedRelatedAnimeList = groupedRelatedAnime; }, _cancellationToken.Token); if (_favoritedAnime.Episodes == null) { IsLoadingEpisodes = true; _favoritedAnime.Episodes = await _favoritedAnime.Anime.GetAllEpisodesAsync(_cancellationToken); } Episodes = _favoritedAnime.Episodes; IsLoadingEpisodes = false; await loadCharactersTask; IsLoadingCharacters = false; await loadAnimeNewsTask; IsLoadingNews = false; await relatedAnimeTask; IsLoadingRelated = false; await Task.Run(async() => { foreach (var group in GroupedRelatedAnimeList) { foreach (var relatedAnime in group) { foreach (var item in _favoritedAnime.RelatedAnimes) { if (relatedAnime.Anime.MalId == item.Anime.MalId) { if (_cancellationToken.IsCancellationRequested) { _cancellationToken.Token.ThrowIfCancellationRequested(); } await App.DelayRequest(4); var anime = await App.Jikan.GetAnime(item.Anime.MalId); relatedAnime.ImageURL = anime.ImageURL; } } } } }, _cancellationToken.Token); } catch (JikanRequestException ex) { ex.SaveExceptionData(); _cancellationToken.Cancel(); } catch (OperationCanceledException ex) { Console.WriteLine($"Tasks canceladas {Environment.NewLine} " + $"{ex.Message}"); } catch (Exception ex) { ex.SaveExceptionData(); _cancellationToken.Cancel(); } finally { } }
private async Task UpdateAnimesFromFavorited() { //TODO: https://github.com/JaoHundred/ANT/issues/80 //TODO:testar mais algumas vezes, na primeira tentativa no dispositivo real //foram feitas trocas de aplicativo enquanto essa função continuava funcionando //ao terminar não foi completado todos as atualizações da lista, mas o processamento não parou //depois que terminou, ao clicar mais vezes em atualizar o restante que não tinha sido atualizado foi atualizando try { var db = App.liteDB.GetCollection <FavoritedAnime>(); var animes = _collection as List <FavoritedAnime>; double total = animes.Count; for (int i = 0; i < animes.Count; i++) { double result = (double)i / total; MessagingCenter.Send <ProgressPopupViewModel, double>(this, string.Empty, result); if (_cancelationToken != null && _cancelationToken.IsCancellationRequested) { _cancelationToken.Token.ThrowIfCancellationRequested(); } var favoriteAnime = animes[i]; if ((favoriteAnime.LastUpdateDate == null) || (favoriteAnime.LastUpdateDate != null && favoriteAnime.LastUpdateDate != DateTime.Today)) { await App.DelayRequest(4); Anime anime = await App.Jikan.GetAnime(favoriteAnime.Anime.MalId); anime.RequestCached = true; int lastEpisode = favoriteAnime.LastEpisodeSeen; bool hasNotification = favoriteAnime.CanGenerateNotifications; //TODO:linha dos episódios comentados pelo motivo do MAL estar instável e isso gerar uma carga desnecessária //a informação importante é apenas os dados do anime favoriteAnime = new FavoritedAnime(anime /*, await anime.GetAllEpisodesAsync(_cancelationToken)*/); favoriteAnime.LastUpdateDate = DateTime.Today; favoriteAnime.IsFavorited = true; favoriteAnime.LastEpisodeSeen = lastEpisode; favoriteAnime.NextStreamDate = await favoriteAnime.NextEpisodeDateAsync(); //TODO:linha abaixo de testes, remover quando conseguir corrigir o problema da https://github.com/JaoHundred/ANT/issues/80 //favoriteAnime.Anime.Airing = false; //se está exibindo e possui data de estreia favoriteAnime.CanGenerateNotifications = favoriteAnime.Anime.Airing && favoriteAnime.NextStreamDate != null ? hasNotification : false; db.Update(favoriteAnime.Anime.MalId, favoriteAnime); } } } catch (JikanRequestException ex) { ex.SaveExceptionData(); } catch (OperationCanceledException ex) { } catch (Exception ex) { ex.SaveExceptionData(); } finally { App.liteDB.Checkpoint(); } }
private async Task FavoriteAnimesFromCatalogue() { try { var favoriteCollection = App.liteDB.GetCollection <FavoritedAnime>(); var collection = _collection as IList <FavoritedAnime>; for (int i = 0; i < collection.Count; i++) { double result = (double)i / collection.Count; MessagingCenter.Send <ProgressPopupViewModel, double>(this, string.Empty, result); if (favoriteCollection.FindById(collection[i].Anime.MalId) != null) { continue; } await App.DelayRequest(4); if (_cancelationToken != null && _cancelationToken.IsCancellationRequested) { _cancelationToken.Token.ThrowIfCancellationRequested(); } Anime anime = await App.Jikan.GetAnime(collection[i].Anime.MalId); anime.RequestCached = true; var favoritedAnime = new FavoritedAnime(anime /*, await anime.GetAllEpisodesAsync(_cancelationToken)*/); favoritedAnime.IsFavorited = true; favoritedAnime.LastUpdateDate = DateTime.Today; favoritedAnime.NextStreamDate = await favoritedAnime.NextEpisodeDateAsync(); int uniqueId = 0; if (favoriteCollection.Count() > 0) { uniqueId = favoriteCollection.Max(p => p.UniqueNotificationID); if (uniqueId == int.MaxValue) { uniqueId = 0; } else if (uniqueId < int.MaxValue) { uniqueId += 1; } } favoritedAnime.UniqueNotificationID = uniqueId; favoritedAnime.CanGenerateNotifications = favoritedAnime.Anime.Airing && favoritedAnime.NextStreamDate != null; collection[i].IsFavorited = true; favoriteCollection.Upsert(favoritedAnime.Anime.MalId, favoritedAnime); } } catch (JikanRequestException ex) { ex.SaveExceptionData(); } catch (OperationCanceledException ex) { } catch (Exception ex) { ex.SaveExceptionData(); } }
public async Task LoadAsync() { while (App.liteDB == null) { await Task.Delay(TimeSpan.FromMilliseconds(100)); } _cancellationTokenSource = new CancellationTokenSource(); var settings = App.liteDB.GetCollection <SettingsPreferences>().FindById(0); try { var loadTodayAnimesTask = Task.Run(async() => { if (_cancellationTokenSource.IsCancellationRequested) { _cancellationTokenSource.Token.ThrowIfCancellationRequested(); } var todayAnimeCollection = App.liteDB.GetCollection <TodayAnimes>(); var todayAnimes = todayAnimeCollection.FindById(0); if (todayAnimes?.DayOfWeek != DateTime.Today.DayOfWeek || todayAnimes?.ShowNSFW != settings.ShowNSFW) { IsLoadingTodayAnimes = true; await App.DelayRequest(2); Schedule schedule = await App.Jikan.GetSchedule(DateTime.Today.DayOfWeek.ConvertDayOfWeekToScheduleDay()); var animes = await schedule.GetCurrentScheduleDay().ConvertCatalogueAnimesToFavoritedAsync(settings.ShowNSFW); var tdayAnimes = new TodayAnimes { DayOfWeek = DateTime.Today.DayOfWeek, FavoritedAnimes = animes, ShowNSFW = settings.ShowNSFW, }; TodayAnimes = tdayAnimes; todayAnimeCollection.Upsert(0, tdayAnimes); IsLoadingTodayAnimes = false; } else if (TodayAnimes == null || todayAnimes?.DayOfWeek != DateTime.Today.DayOfWeek) { TodayAnimes = todayAnimes; } }, _cancellationTokenSource.Token); var loadRecommendationsTask = Task.Run(async() => { var recommendationAnimesCollection = App.liteDB.GetCollection <RecommendationAnimes>(); var recommendationsCache = recommendationAnimesCollection.FindById(0); var animeCollection = settings.ShowNSFW ? App.liteDB.GetCollection <FavoritedAnime>().FindAll().ToList() : App.liteDB.GetCollection <FavoritedAnime>().Find(p => !p.IsNSFW).ToList(); int collectionCount = animeCollection.Count; if (collectionCount == 0) { return; } if (recommendationsCache == null || recommendationsCache != null && DateTime.Now.Subtract(recommendationsCache.LastRecommendationDate).TotalHours >= 1 || settings.ShowNSFW != recommendationsCache.ShowNSFW) { var rand = new Random(); int indexPick = rand.Next(collectionCount); FavoritedAnime animeAsRecommend = animeCollection[indexPick]; if (_cancellationTokenSource.IsCancellationRequested) { _cancellationTokenSource.Token.ThrowIfCancellationRequested(); } await App.DelayRequest(2); Recommendations recommendations = await App.Jikan.GetAnimeRecommendations(animeAsRecommend.Anime.MalId); var recommendationAnimes = recommendations.RecommendationCollection .Where(recommendation => !animeCollection.Exists(favoritedAnime => recommendation.MalId == favoritedAnime.Anime.MalId)) .ToList(); if (recommendationAnimes.Count == 0) { if (recommendationsCache != null) { LoadRecommendationFromCache(settings, recommendationAnimesCollection, recommendationsCache); } return; } var recomendationsList = new HashSet <Recommendation>(); for (int i = 0; i < 5; i++) { await Task.Delay(TimeSpan.FromMilliseconds(50)); indexPick = rand.Next(recommendationAnimes.Count); recomendationsList.Add(recommendationAnimes[indexPick]); } var recommendationAnimesCache = new RecommendationAnimes { Recommendations = recomendationsList .Where(recommendation => !App.liteDB.GetCollection <FavoritedAnime>() .Exists(favoritedAnime => recommendation.MalId == favoritedAnime.Anime.MalId)) .ToList(), LastRecommendationDate = DateTime.Now, ShowNSFW = settings.ShowNSFW, }; RecommendationAnimes = recommendationAnimesCache; HasRecommendations = RecommendationAnimes.Recommendations.Count() != 0; recommendationAnimesCollection.Upsert(0, recommendationAnimesCache); } else if (DateTime.Now.Subtract(recommendationsCache.LastRecommendationDate).TotalHours < 1) { LoadRecommendationFromCache(settings, recommendationAnimesCollection, recommendationsCache); } }, _cancellationTokenSource.Token); await Task.WhenAny(loadRecommendationsTask, loadTodayAnimesTask); } catch (JikanDotNet.Exceptions.JikanRequestException ex) { ex.SaveExceptionData(); } catch (OperationCanceledException ex) { } catch (ObjectDisposedException ex) { } catch (Exception ex) { ex.SaveExceptionData(); } finally { IsLoadingTodayAnimes = false; } }
/// <summary> /// Retorna a data do próximo dia de semana que o anime irá passar, se não houver data, retorna null /// </summary> /// <param name="favoritedAnime"></param> /// <returns></returns> public static Task <DateTime?> NextEpisodeDateAsync(this FavoritedAnime favoritedAnime) { return(Task.Run(() => { if (string.IsNullOrEmpty(favoritedAnime.Anime.Broadcast)) { return null; } var daysOfWeek = Enum.GetNames(typeof(DayOfWeek)).Select(p => new string(p.Append('s').ToArray()).ToString().ToLowerInvariant()).ToList(); DayOfWeek?nextEpisodeDay = null; string[] broadCastVector = favoritedAnime.Anime.Broadcast.Split(' '); foreach (var day in daysOfWeek) { string broadCastDay = broadCastVector.FirstOrDefault(p => p.ToLowerInvariant() == day); if (string.IsNullOrWhiteSpace(broadCastDay)) { continue; } broadCastDay = broadCastDay.ToLowerInvariant(); switch (broadCastDay) { case "sundays": nextEpisodeDay = DayOfWeek.Sunday; break; case "mondays": nextEpisodeDay = DayOfWeek.Monday; break; case "tuesdays": nextEpisodeDay = DayOfWeek.Tuesday; break; case "wednesdays": nextEpisodeDay = DayOfWeek.Wednesday; break; case "thursdays": nextEpisodeDay = DayOfWeek.Thursday; break; case "fridays": nextEpisodeDay = DayOfWeek.Friday; break; case "saturdays": nextEpisodeDay = DayOfWeek.Saturday; break; } } if (nextEpisodeDay == null) { return null; } int daysToSchedule = 0; if (nextEpisodeDay > DateTime.Today.DayOfWeek) { daysToSchedule = (int)nextEpisodeDay - (int)DateTime.Today.DayOfWeek; } else if (nextEpisodeDay <= DateTime.Today.DayOfWeek) { daysToSchedule = ((int)nextEpisodeDay + 7) - (int)DateTime.Today.DayOfWeek; } // TODO: ficar de olho nessa condição, suspeito que se acontecer do dia de atualização coincidir com o mesmo dia que passa o anime, nenhuma notificação será gerada para a próxima semana DateTime?nextEpisodeDate = DateTime.Today.AddDays(daysToSchedule).AddHours(12); return nextEpisodeDate; })); }
private static bool IsTVSeries(FavoritedAnime favoritedAnime) { return(favoritedAnime.Anime.Type == "TV"); }
private async Task OnApplyFilter() { var selectedGenres = FilterData.Genres.Where(p => p.IsChecked).Select(p => p.Genre).ToList(); var selectedOrder = FilterData.Orders.Where(p => p.IsChecked).First(); var selectedSort = FilterData.SortDirections.Where(p => p.IsChecked).First(); _animeSearchConfig.OrderBy = selectedOrder.OrderBy; _animeSearchConfig.SortDirection = selectedSort.SortDirection; _animeSearchConfig.Genres = selectedGenres; _animeSearchConfig.GenreIncluded = true; if (!_settingsPreferences.ShowNSFW && selectedGenres.Count == 0) { _animeSearchConfig.Genres = UTIL.AnimeExtension.FillNSFWGenres().Select(p => p.Genre).ToList(); _animeSearchConfig.GenreIncluded = false; } MessagingCenter.Send(this, "CloseFilterView"); switch (_catalogueMode) { case CatalogueModeEnum.Season: Loading = true; await Task.Delay(TimeSpan.FromMilliseconds(500)); // usado para impedir que seja visto um leve engasto na filtragem _animesWithSpecifiedFilters = new List <FavoritedAnime>(); switch (_animeSearchConfig.OrderBy) { case AnimeSearchSortable.Title: if (_animeSearchConfig.SortDirection == SortDirection.Ascending) { _animesWithSpecifiedFilters.AddRange(_originalCollection.OrderBy(p => p.Anime.Title)); } else { _animesWithSpecifiedFilters.AddRange(_originalCollection.OrderByDescending(p => p.Anime.Title)); } break; case AnimeSearchSortable.StartDate: //TODO: existem alguns animes da temporada que não estão refletindo corretamente a data crescente, investigar e tentar descobrir //o que pode ser if (_animeSearchConfig.SortDirection == SortDirection.Ascending) { _animesWithSpecifiedFilters.AddRange(_originalCollection.OrderBy(p => p.Anime.Aired.From)); } else { _animesWithSpecifiedFilters.AddRange(_originalCollection.OrderByDescending(p => p.Anime.Aired.From)); } break; case AnimeSearchSortable.Score: if (_animeSearchConfig.SortDirection == SortDirection.Ascending) { _animesWithSpecifiedFilters.AddRange(_originalCollection.OrderBy(p => p.Anime.Score)); } else { _animesWithSpecifiedFilters.AddRange(_originalCollection.OrderByDescending(p => p.Anime.Score)); } break; } var animeToRemove = new List <FavoritedAnime>(); for (int i = 0; i < _animesWithSpecifiedFilters.Count; i++) { FavoritedAnime favoritedAnime = _animesWithSpecifiedFilters[i]; bool hasAllGenres = await favoritedAnime.HasAllSpecifiedGenresAsync(selectedGenres.ToArray()); if (!hasAllGenres) { animeToRemove.Add(favoritedAnime); } } if (animeToRemove.Count > 0) { foreach (var item in animeToRemove) { _animesWithSpecifiedFilters.Remove(item); } } Animes.ReplaceRange(_animesWithSpecifiedFilters); Loading = false; break; case CatalogueModeEnum.Global: await ResetAndLoadGlobalAsync(); break; } }
public static bool IsUnknownAiring(FavoritedAnime favoriteAnime) { return(!HasFinishedAiring(favoriteAnime) && !HasNotStartedAiring(favoriteAnime) && !favoriteAnime.IsArchived); }