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