public async Task CreateStatusActivity(string text)
{
var postResp = await AniListService.SaveTextActivity(text, null, default);
postResp.Switch((IAniListError error) => View.DisplaySnackbarMessage("Error occurred while posting status", Snackbar.LengthLong))
.Switch(activity => View.RefreshActivity());
}
public void SearchAniList(string searchType, string searchTerm)
{
switch (searchType)
{
case SearchResultsActivity.AniListSearchTypes.Anime:
View.ShowMediaSearchResults(AniListService.SearchMedia(searchTerm, MediaType.Anime,
PageSize));
break;
case SearchResultsActivity.AniListSearchTypes.Manga:
View.ShowMediaSearchResults(AniListService.SearchMedia(searchTerm, MediaType.Manga,
PageSize));
break;
case SearchResultsActivity.AniListSearchTypes.Characters:
View.ShowCharacterSearchResults(AniListService.SearchCharacters(searchTerm, PageSize));
break;
case SearchResultsActivity.AniListSearchTypes.Staff:
View.ShowStaffSearchResults(AniListService.SearchStaff(searchTerm, PageSize));
break;
case SearchResultsActivity.AniListSearchTypes.Studios:
View.ShowStudioSearchResults(AniListService.SearchStudios(searchTerm, PageSize));
break;
case SearchResultsActivity.AniListSearchTypes.Users:
View.ShowUserSearchResults(AniListService.SearchUsers(searchTerm, PageSize));
break;
case SearchResultsActivity.AniListSearchTypes.Forum:
View.ShowForumThreadSearchResults(AniListService.SearchForumThreads(searchTerm, PageSize));
break;
}
}
public async Task PostActivityReplyAsync(AniListActivity activity, int activityPosition, string text)
{
var postResp = await AniListService.PostActivityReply(activity.Id, text, default);
postResp.Switch((IAniListError error) =>
{
View.UpdateActivity(activityPosition, activity);
View.DisplaySnackbarMessage("Error occurred while posting reply", Snackbar.LengthLong);
})
.Switch(async reply =>
{
var refreshResp = await AniListService.GetAniListActivityById(activity.Id, default);
refreshResp.Switch((IAniListError error) =>
{
View.UpdateActivity(activityPosition, activity);
View.DisplaySnackbarMessage("Error occurred while refreshing activity", Snackbar.LengthLong);
})
.Switch(activityResp =>
{
View.UpdateActivity(activityPosition, activityResp);
View.DisplaySnackbarMessage("Reply posted successfully", Snackbar.LengthShort);
});
});
}
public async Task UpdateActivityAsync(AniListActivity activity, int activityPosition)
{
var activityResp = await AniListService.GetAniListActivityById(activity.Id, default);
activityResp.Switch((IAniListError error) => View.DisplaySnackbarMessage("Error occurred while refreshing activity", Snackbar.LengthLong))
.Switch(updatedAct => View.UpdateActivity(activityPosition, updatedAct));
}
public IAsyncEnumerable <OneOf <IPagedData <AniListActivity>, IAniListError> > GetAniListActivity(bool isFollowingOnly)
{
AniDroidSettings.ShowAllAniListActivity = !isFollowingOnly;
return(AniListService.GetAniListActivity(new AniListActivityDto {
IsFollowing = isFollowingOnly
}, 20));
}
public override async Task Init()
{
View.SetLoadingShown();
var userId = View.GetUserId();
var userName = View.GetUserName();
Logger.Debug("UserPresenter", $"Init started (userId: {userId}, userName: {userName})");
var userResp = await AniListService.GetUser(userName, userId, default(CancellationToken));
userResp.Switch(user =>
{
if (AniDroidSettings.IsUserAuthenticated && user.Id != AniDroidSettings.LoggedInUser.Id)
{
View.SetCanFollow();
View.SetCanMessage();
View.SetIsFollowing(user.IsFollowing, false);
}
View.SetShareText(user.Name, user.SiteUrl);
View.SetContentShown(false); // TODO: change this to switch based on banner presence
View.SetupToolbar(user.Name);
View.SetupUserView(user);
})
.Switch(error => View.OnError(error));
}
public async Task Login(CancellationToken token)
{
AniDroidSettings.ClearUserAuthentication();
var authCode = View.GetAuthCode();
if (string.IsNullOrWhiteSpace(authCode))
{
View.OnErrorAuthorizing();
return;
}
var authResp = await AniListService.AuthenticateUser(_authConfig, authCode, token);
authResp.Switch((IAniListError error) => View.OnErrorAuthorizing())
.Switch(async auth =>
{
AniDroidSettings.UserAccessCode = auth.AccessToken;
var currentUser = await AniListService.GetCurrentUser(token);
currentUser.Switch((IAniListError error) =>
{
AniDroidSettings.ClearUserAuthentication();
View.OnErrorAuthorizing();
}).Switch(user =>
{
AniDroidSettings.LoggedInUser = user;
View.OnAuthorized();
});
});
}
public async Task EditStatusActivityAsync(AniListActivity activity, int activityPosition, string updateText)
{
var postResp = await AniListService.SaveTextActivity(updateText, activity.Id, default);
postResp.Switch((IAniListError error) => View.DisplaySnackbarMessage("Error occurred while saving status", Snackbar.LengthLong))
.Switch(updatedAct => View.UpdateActivity(activityPosition, updatedAct));
}
public async Task ToggleFollowUser(int userId)
{
var toggleResp = await AniListService.ToggleFollowUser(userId, default(CancellationToken));
toggleResp.Switch((IAniListError error) =>
View.DisplaySnackbarMessage("Error occurred while trying to toggle following status",
Snackbar.LengthLong))
.Switch(user => View.SetIsFollowing(user.IsFollowing, true));
}
public async Task ToggleFavorite()
{
var characterId = View.GetCharacterId();
var favResp = await AniListService.ToggleFavorite(new FavoriteDto { CharacterId = characterId },
default(CancellationToken));
favResp.Switch(error => View.OnError(error))
.Switch(favorites => View.SetIsFavorite(favorites.Characters?.Nodes?.Any(x => x.Id == characterId) == true, true));
}
public async Task SaveMediaListEntry(MediaListEditDto editDto, Action onSuccess, Action onError)
{
var mediaUpdateResp = await AniListService.UpdateMediaListEntry(editDto, default);
mediaUpdateResp.Switch(mediaList =>
{
onSuccess();
View.DisplaySnackbarMessage("Saved", Snackbar.LengthShort);
View.UpdateMediaListItem(mediaList);
}).Switch(error => onError());
}
public async Task DeleteMediaListEntry(int mediaListId, Action onSuccess, Action onError)
{
var mediaDeleteResp = await AniListService.DeleteMediaListEntry(mediaListId, default);
mediaDeleteResp.Switch((bool success) =>
{
onSuccess();
View.DisplaySnackbarMessage("Deleted", Snackbar.LengthShort);
View.RemoveMediaListItem(mediaListId);
}).Switch(error =>
onError());
}
public async Task PostUserMessage(int userId, string message)
{
var postResp = await AniListService.PostUserMessage(userId, message, default(CancellationToken));
postResp.Switch((IAniListError error) =>
View.DisplaySnackbarMessage("Error occurred while posting message", Snackbar.LengthLong))
.Switch(activity =>
{
View.RefreshUserActivity();
View.DisplaySnackbarMessage("Message posted successfully", Snackbar.LengthShort);
});
}
public async Task <bool> DeleteActivityReplyAsync(ActivityReply activityReply,
int activityPosition)
{
var editResp = await AniListService.DeleteActivityReply(activityReply.Id, default);
return(editResp.Match((IAniListError error) =>
{
View.DisplaySnackbarMessage("Error occurred while deleting reply", Snackbar.LengthLong);
return false;
})
.Match(deletedResponse => deletedResponse.Deleted));
}
public async Task ToggleActivityReplyLikeAsync(ActivityReply activityReply, int activityPosition)
{
var toggleResp = await AniListService.ToggleLike(activityReply.Id, LikeableType.ActivityReply, default);
toggleResp.Switch((IAniListError error) =>
{
View.DisplaySnackbarMessage("Error occurred while toggling like", Snackbar.LengthLong);
})
.Switch(userLikes =>
{
activityReply.Likes = userLikes;
});
}
public void GetCurrentSeasonLists()
{
View.ShowCurrentTv(AniListService.BrowseMedia(new BrowseMediaDto
{
Season = MediaSeason.Fall,
SeasonYear = 2018,
Type = MediaType.Anime,
Format = MediaFormat.Tv,
Sort = new List <MediaSort> {
_sortType
}
}, 5));
}
public async Task EditActivityReplyAsync(ActivityReply activityReply, int activityPosition, string updateText)
{
var editResp = await AniListService.SaveActivityReply(activityReply.Id, updateText, default);
editResp.Switch((IAniListError error) =>
{
View.DisplaySnackbarMessage("Error occurred while updating reply", Snackbar.LengthLong);
})
.Switch(retReply =>
{
activityReply.Text = retReply.Text;
activityReply.Likes = retReply.Likes;
});
}
public async Task DeleteActivityAsync(int activityId, int activityPosition)
{
var deleteResp = await AniListService.DeleteActivity(activityId, default);
deleteResp.Switch((IAniListError error) => View.DisplaySnackbarMessage("Error occurred while deleting activity", Snackbar.LengthLong))
.Switch(deleted => {
if (deleted?.Deleted == true)
{
View.RemoveActivity(activityPosition);
}
else
{
View.DisplaySnackbarMessage("Error occurred while deleting activity", Snackbar.LengthLong);
}
});
}
public override async Task Init()
{
View.SetLoadingShown();
var staffId = View.GetStaffId();
var staffResp = await AniListService.GetStaffById(staffId, default(CancellationToken));
staffResp.Switch(staff =>
{
View.SetIsFavorite(staff.IsFavourite);
View.SetShareText(staff.Name?.GetFormattedName(), staff.SiteUrl);
View.SetContentShown(false);
View.SetupToolbar($"{staff.Name?.First} {staff.Name?.Last}".Trim());
View.SetupStaffView(staff);
})
.Switch(error => View.OnError(error));
}
public override async Task Init()
{
View.SetLoadingShown();
var studioId = View.GetStudioId();
var studioResp = await AniListService.GetStudioById(studioId, default(CancellationToken));
studioResp.Switch(studio =>
{
View.SetIsFavorite(studio.IsFavourite);
View.SetShareText(studio.Name, studio.SiteUrl);
View.SetContentShown(false);
View.SetupToolbar(studio.Name);
View.SetupStudioView(studio);
})
.Switch(error => View.OnError(error));
}
public override async Task Init()
{
View.SetLoadingShown();
var characterId = View.GetCharacterId();
var characterResp = await AniListService.GetCharacterById(characterId, default(CancellationToken));
characterResp.Switch(character =>
{
View.SetIsFavorite(character.IsFavourite);
View.SetShareText(character.Name?.GetFormattedName(), character.SiteUrl);
View.SetContentShown(false);
View.SetupToolbar($"{character.Name?.First} {character.Name?.Last}".Trim());
View.SetupCharacterView(character);
})
.Switch(error => View.OnError(error));
}
public async Task GetMediaLists(int userId)
{
var mediaListResp = await AniListService.GetUserMediaList(userId,
View.GetMediaType(), AniDroidSettings.GroupCompletedLists, default);
mediaListResp.Switch(error => View.OnError(error))
.Switch(mediaLists =>
{
if (userId == AniDroidSettings.LoggedInUser?.Id)
{
AniDroidSettings.UpdateLoggedInUser(mediaLists.User);
}
View.SetCollection(mediaLists);
});
}
public void GetDiscoverLists()
{
View.ShowCurrentlyAiringResults(AniListService.BrowseMedia(new BrowseMediaDto
{
Season = MediaSeason.GetFromDate(DateTime.Now),
SeasonYear = DateTime.Now.Year,
Type = MediaType.Anime,
Sort = new List <MediaSort> {
MediaSort.PopularityDesc
}
}, 5));
View.ShowTrendingAnimeResults(AniListService.BrowseMedia(new BrowseMediaDto
{
Type = MediaType.Anime,
Sort = new List <MediaSort> {
MediaSort.TrendingDesc
}
}, 5));
View.ShowTrendingMangaResults(AniListService.BrowseMedia(new BrowseMediaDto
{
Type = MediaType.Manga,
Sort = new List <MediaSort> {
MediaSort.TrendingDesc
}
}, 5));
View.ShowNewAnimeResults(AniListService.BrowseMedia(
new BrowseMediaDto
{
Type = MediaType.Anime,
Sort = new List <MediaSort> {
MediaSort.IdDesc
}
}, 5));
View.ShowNewMangaResults(AniListService.BrowseMedia(
new BrowseMediaDto
{
Type = MediaType.Manga,
Sort = new List <MediaSort> {
MediaSort.IdDesc
}
}, 5));
}
public async Task IncreaseMediaProgress(AniList.Models.MediaModels.MediaList mediaListToUpdate)
{
var editDto = new MediaListEditDto
{
MediaId = mediaListToUpdate.Media.Id,
Progress = (mediaListToUpdate.Progress ?? 0) + 1
};
var mediaUpdateResp = await AniListService.UpdateMediaListEntry(editDto, default);
mediaUpdateResp.Switch(mediaList =>
{
View.DisplaySnackbarMessage($"Updated progress for {mediaList.Media.Title.UserPreferred}", Snackbar.LengthShort);
View.UpdateMediaListItem(mediaList);
})
.Switch(error =>
{
View.DisplaySnackbarMessage("Error occurred while saving list entry", Snackbar.LengthLong);
View.ResetMediaListItem(mediaListToUpdate.Media.Id);
});
}
public async Task CompleteMedia(AniList.Models.MediaModels.MediaList mediaListToComplete)
{
var editDto = new MediaListEditDto
{
MediaId = mediaListToComplete.Media.Id,
Progress = mediaListToComplete.Media.Episodes,
Status = MediaListStatus.Completed
};
var mediaUpdateResp = await AniListService.UpdateMediaListEntry(editDto, default);
mediaUpdateResp.Switch(mediaList =>
{
View.DisplaySnackbarMessage($"Completed {mediaList.Media.Title.UserPreferred}", Snackbar.LengthShort);
View.UpdateMediaListItem(mediaList);
})
.Switch(error =>
{
View.DisplaySnackbarMessage("Error occurred while saving list entry", Snackbar.LengthLong);
View.ResetMediaListItem(mediaListToComplete.Media.Id);
});
}
public IAsyncEnumerable <OneOf <IPagedData <MediaEdge>, IAniListError> > GetCharacterMediaEnumerable(int characterId, MediaType mediaType, int perPage)
{
return(AniListService.GetCharacterMedia(characterId, mediaType, perPage));
}
public IAsyncEnumerable <OneOf <IPagedData <Review>, IAniListError> > GetUserReviewsEnumerable(int userId,
int perPage)
{
return(AniListService.GetUserReviews(userId, perPage));
}
public IAsyncEnumerable <OneOf <IPagedData <MediaEdge>, IAniListError> > GetStudioMediaEnumerable(int studioId, int perPage)
{
return(AniListService.GetStudioMedia(studioId, perPage));
}
public IAsyncEnumerable <OneOf <IPagedData <AniList.Models.UserModels.User>, IAniListError> > GetUserFollowingEnumerable(int userId, int count)
{
return(AniListService.GetUserFollowing(userId, UserSort.Username, count));
}
public void BrowseAniListMedia(BrowseMediaDto browseDto)
{
_browseDto = browseDto;
View.ShowMediaSearchResults(AniListService.BrowseMedia(browseDto, 20));
}
