public override async void Execute(object parameter)
{
if (string.IsNullOrEmpty(Locator.ViewModels.MessagesVm.FriendSearch))
{
return;
}
var friendFinderManager = new FriendFinderManager();
var friendResult =
await
friendFinderManager.SearchForFriends(Locator.ViewModels.MessagesVm.FriendSearch, Locator.ViewModels.MainPageVm.CurrentTokens,
Locator.ViewModels.MainPageVm.CurrentUser.Region,
Locator.ViewModels.MainPageVm.CurrentUser.Language);
var result = await ResultChecker.CheckSuccess(friendResult);
if (!result)
{
return;
}
var friendFinderResult = JsonConvert.DeserializeObject <FriendFinderResponse>(friendResult.ResultJson);
if (friendFinderResult.SearchResults != null)
{
Locator.ViewModels.MessagesVm.FriendSearchResults = friendFinderResult.SearchResults.ToList();
}
}
private async Task SetNicoDougaElements(bool interactive = false, string query = "")
{
var nicoNicoResultEntity =
await _liveStreamManager.GetNicoFeed("onair", "PS4", interactive, 0, 80, "view", query, Locator.ViewModels.MainPageVm.CurrentTokens);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, nicoNicoResultEntity);
var result = await ResultChecker.CheckSuccess(nicoNicoResultEntity);
if (!result)
{
return;
}
var nicoNicoEntity = JsonConvert.DeserializeObject <NicoNicoEntity>(nicoNicoResultEntity.ResultJson);
if (nicoNicoEntity?.programs == null)
{
return;
}
foreach (NicoNicoEntity.Program program in nicoNicoEntity.programs)
{
var entity = new LiveBroadcastEntity();
entity.ParseFromNicoNico(program);
LiveBroadcastCollection.Add(entity);
}
}
private async Task <bool> LoginTest(AccountUser user)
{
IsLoading = true;
Result result = new Result();
try
{
result = await _authManager.RefreshAccessToken(user.RefreshToken);
var tokenResult = JsonConvert.DeserializeObject <Tokens>(result.Tokens);
result = await _userManager.GetUser(user.Username,
new UserAuthenticationEntity(tokenResult.AccessToken, tokenResult.RefreshToken, tokenResult.ExpiresIn),
user.Region, user.Language);
var userResult = JsonConvert.DeserializeObject <User>(result.ResultJson);
var didUpdate = await AccountAuthHelpers.UpdateUserAccount(user, tokenResult, null, userResult);
result.IsSuccess = didUpdate;
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Error = ex.Message;
}
await ResultChecker.CheckSuccess(result);
IsLoading = false;
return(result.IsSuccess);
}
private async Task SetUstreamElements(bool interactive = false, string query = "")
{
var filterList = new Dictionary <string, string>
{
{ "platform", "PS4" },
{ "type", "live" },
{ "interactive", interactive ? "true" : "false" }
};
var ustreamResultList =
await
_liveStreamManager.GetUstreamFeed(0, 80, "compact", filterList, "views", query,
Locator.ViewModels.MainPageVm.CurrentTokens);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, ustreamResultList);
var result = await ResultChecker.CheckSuccess(ustreamResultList);
if (!result)
{
return;
}
var ustreamList = JsonConvert.DeserializeObject <UstreamEntity>(ustreamResultList.ResultJson);
if (ustreamList?.items == null)
{
return;
}
foreach (UstreamEntity.Item ustream in ustreamList.items)
{
var entity = new LiveBroadcastEntity();
entity.ParseFromUstream(ustream);
LiveBroadcastCollection.Add(entity);
}
}
private async Task SetTwitchElements(bool interactive = false, string query = "")
{
var twitchResult =
await _liveStreamManager.GetTwitchFeed(0, 80, "PS4", interactive, query, Locator.ViewModels.MainPageVm.CurrentTokens);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, twitchResult);
var result = await ResultChecker.CheckSuccess(twitchResult);
if (!result)
{
return;
}
var twitchList = JsonConvert.DeserializeObject <TwitchEntity>(twitchResult.ResultJson);
if (twitchList?.streams == null)
{
return;
}
foreach (TwitchEntity.Stream twitch in twitchList.streams)
{
var entity = new LiveBroadcastEntity();
entity.ParseFromTwitch(twitch);
LiveBroadcastCollection.Add(entity);
}
}
private async Task <string> GetAvatarUrl(string username)
{
var userResult =
await
_userManager.GetUserAvatar(username, Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region,
Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, userResult);
var result = await ResultChecker.CheckSuccess(userResult);
if (!result)
{
return(string.Empty);
}
if (string.IsNullOrEmpty(userResult.ResultJson))
{
return(string.Empty);
}
var user = JsonConvert.DeserializeObject <User>(userResult.ResultJson);
if (user?.AvatarUrls != null)
{
return(user.AvatarUrls.First().AvatarUrlLink);
}
return(string.Empty);
}
public async Task RemoveMessageGroup(MessageGroupItem messageGroupItem)
{
try
{
var result =
await
_messageManager.DeleteMessageThread(messageGroupItem.MessageGroup.MessageGroupId,
Locator.ViewModels.MainPageVm.CurrentUser.Username,
Locator.ViewModels.MainPageVm.CurrentTokens,
Locator.ViewModels.MainPageVm.CurrentUser.Region);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, result);
var resultCheck = await ResultChecker.CheckSuccess(result);
if (!resultCheck)
{
return;
}
if (SelectedMessageGroup != null && SelectedMessageGroup.MessageGroupId == messageGroupItem.MessageGroup.MessageGroupId)
{
GroupMemberSeperatedList = string.Empty;
SelectedMessageGroup = null;
MessageCollection.Clear();
IsSelected = false;
}
MessageGroupCollection.Remove(messageGroupItem);
}
catch (Exception ex)
{
// TODO: Proper Error handling if deleting fails :\
}
}
private async Task <bool> LoadFeed(ObservableCollection <Feed> testFeed)
{
var feedResultEntity =
await _recentActivityManager.GetActivityFeed(Locator.ViewModels.MainPageVm.CurrentUser.Username, _page, true, true, Locator.ViewModels.MainPageVm.CurrentTokens, Locator.ViewModels.MainPageVm.CurrentUser.Region, Locator.ViewModels.MainPageVm.CurrentUser.Language);
var result = await ResultChecker.CheckSuccess(feedResultEntity);
if (!result)
{
return(false);
}
if (string.IsNullOrEmpty(feedResultEntity.ResultJson))
{
// No Items, return false.
return(false);
}
var feedEntity = JsonConvert.DeserializeObject <RecentActivityResponse>(feedResultEntity.ResultJson);
foreach (var feed in feedEntity.Feed)
{
testFeed.Add(feed);
}
_page++;
return(true);
}
private async Task <bool> LoadFeed(ObservableCollection <Feed> testFeed)
{
await Shell.Instance.ViewModel.UpdateTokens();
var feedResultEntity =
await _recentActivityManager.GetActivityFeed(Shell.Instance.ViewModel.CurrentUser.Username, _page, true, true, Shell.Instance.ViewModel.CurrentTokens, Shell.Instance.ViewModel.CurrentUser.Region, Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, feedResultEntity);
var result = await ResultChecker.CheckSuccess(feedResultEntity);
if (!result)
{
return(false);
}
if (string.IsNullOrEmpty(feedResultEntity.ResultJson))
{
// No Items, return false.
return(false);
}
var feedEntity = JsonConvert.DeserializeObject <RecentActivityResponse>(feedResultEntity.ResultJson);
foreach (var feed in feedEntity.Feed)
{
testFeed.Add(feed);
}
_page++;
return(true);
}
public async Task GetMessageGroups(string userName)
{
Username = userName;
IsLoading = true;
MessageGroupCollection = new ObservableCollection <MessageGroupItem>();
try
{
await Shell.Instance.ViewModel.UpdateTokens();
var messageResult =
await
_messageManager.GetMessageGroup(userName, Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region,
Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, messageResult);
var result = await ResultChecker.CheckSuccess(messageResult);
if (!result)
{
return;
}
_messageGroupEntity = JsonConvert.DeserializeObject <MessageGroupResponse>(messageResult.ResultJson);
var avatarOnlineId = new Dictionary <string, string>();
var avatarOnlinelist = _messageGroupEntity.MessageGroups.Select(node => node.LatestMessage);
foreach (var member in avatarOnlinelist)
{
var avatar = await GetAvatarUrl(member.SenderOnlineId);
if (avatarOnlineId.All(node => node.Key != member.SenderOnlineId))
{
avatarOnlineId.Add(member.SenderOnlineId, avatar);
}
}
foreach (
var newMessage in
_messageGroupEntity.MessageGroups.Select(
message => new MessageGroupItem {
MessageGroup = message
}))
{
newMessage.AvatarUrl =
avatarOnlineId.FirstOrDefault(
node => node.Key == newMessage.MessageGroup.LatestMessage.SenderOnlineId).Value;
MessageGroupCollection.Add(newMessage);
}
}
catch (Exception ex)
{
//Insights.Report(ex);
}
if (MessageGroupCollection.Count <= 0)
{
MessageGroupEmpty = true;
}
IsLoading = false;
}
public async Task <bool> LoadTrophies(string username)
{
Offset = Offset + MaxCount;
IsLoading = true;
await Shell.Instance.ViewModel.UpdateTokens();
var trophyManager = new TrophyManager();
var trophyResultList = await trophyManager.GetTrophyList(username, CompareUsername, Offset, Shell.Instance.ViewModel.CurrentTokens, Shell.Instance.ViewModel.CurrentUser.Region, Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, trophyResultList);
var result = await ResultChecker.CheckSuccess(trophyResultList, false);
if (!result)
{
HasMoreItems = false;
if (Count <= 0)
{
IsEmpty = true;
}
IsLoading = false;
return(false);
}
var trophyList = JsonConvert.DeserializeObject <TrophyDetailResponse>(trophyResultList.ResultJson);
if (trophyList == null)
{
//HasMoreItems = false;
IsEmpty = true;
IsLoading = false;
return(false);
}
foreach (var trophy in trophyList.TrophyTitles)
{
Add(trophy);
}
if (trophyList.TrophyTitles.Any())
{
HasMoreItems = true;
MaxCount += 64;
}
else
{
if (Count <= 0)
{
IsEmpty = true;
}
HasMoreItems = false;
}
IsLoading = false;
return(true);
}
public async Task SendSticker(StickerSelection stickerSelection)
{
string error;
try
{
var result = new Result();
if (GroupMembers.Any() && IsNewMessage)
{
result =
await
_messageManager.CreateStickerPostWithNewGroupMessage(GroupMembers.ToArray(),
stickerSelection.ManifestUrl,
stickerSelection.Number.ToString(), stickerSelection.ImageUrl, stickerSelection.PackageId,
stickerSelection.Type, Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region);
}
else
{
result =
await
_messageManager.CreateStickerPost(SelectedMessageGroup.MessageGroupId,
stickerSelection.ManifestUrl,
stickerSelection.Number.ToString(), stickerSelection.ImageUrl, stickerSelection.PackageId,
stickerSelection.Type, Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region);
}
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, result);
var resultCheck = await ResultChecker.CheckSuccess(result);
if (resultCheck)
{
SelectedMessageGroup = JsonConvert.DeserializeObject <MessageGroup>(result.ResultJson);
await GetMessages(SelectedMessageGroup);
//await GetMessageGroups(Shell.Instance.ViewModel.CurrentUser.Username);
IsNewMessage = false;
}
return;
}
catch (Exception ex)
{
error = ex.Message;
}
await ResultChecker.SendMessageDialogAsync(error, false);
}
public async Task <string> CreateFriendLink()
{
var result = await _friendManager.GetFriendLink(Locator.ViewModels.MainPageVm.CurrentTokens);
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, result);
var resultCheck = await ResultChecker.CheckSuccess(result);
if (!resultCheck)
{
return(string.Empty);
}
var tokenEntity = JsonConvert.DeserializeObject <TokenResponse>(result.ResultJson);
return(tokenEntity.Token);
}
private async Task SendMessageWithMedia()
{
var realImage = await ConvertToJpeg(AttachedImage);
var result = new Result();
if (GroupMembers.Any() && IsNewMessage)
{
result =
await _messageManager.CreateNewGroupMessageWithMedia(GroupMembers.ToArray(), Message, ImagePath,
realImage,
Shell.Instance.ViewModel.CurrentTokens, Shell.Instance.ViewModel.CurrentUser.Region);
}
else
{
if (SelectedMessageGroup == null)
{
await ResultChecker.SendMessageDialogAsync("Selected Message Group Null!", false);
}
else
{
result =
await
_messageManager.CreatePostWithMedia(SelectedMessageGroup.MessageGroupId, Message, ImagePath,
realImage,
Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region);
}
}
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, result);
var resultCheck = await ResultChecker.CheckSuccess(result);
if (resultCheck)
{
IsImageAttached = false;
AttachedImage = null;
SelectedMessageGroup = JsonConvert.DeserializeObject <MessageGroup>(result.ResultJson);
await GetMessages(SelectedMessageGroup);
//await GetMessageGroups(Shell.Instance.ViewModel.CurrentUser.Username);
IsNewMessage = false;
}
}
public async Task <bool> DeleteUserAccount(AccountUser user)
{
var result = new Result();
try
{
result.IsSuccess = await AccountAuthHelpers.DeleteUserAccount(user);
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Error = "Failed to delete user";
}
var resultCheck = await ResultChecker.CheckSuccess(result);
if (resultCheck)
{
AccountUsers.Remove(user);
if (Shell.Instance.ViewModel.CurrentUser != null && Shell.Instance.ViewModel.CurrentUser.Username == user.Username)
{
Shell.Instance.ViewModel.CurrentUser = null;
Shell.Instance.ViewModel.IsLoggedIn = false;
try
{
var pages = App.Frame.BackStack;
foreach (var page in pages)
{
App.Frame.BackStack.Remove(page);
}
}
catch (Exception)
{
// Failed to delete backstack :\
}
}
if (!AccountUsers.Any())
{
NavigationService.Navigate(typeof(LoginPage));
}
}
return(resultCheck);
}
public async Task GetFeatureEvents()
{
var feedResultEntity =
await
_eventManager.GetFeaturedEvents(Locator.ViewModels.MainPageVm.CurrentTokens, "recommendInGame",
Locator.ViewModels.MainPageVm.CurrentUser.Region);
var result = await ResultChecker.CheckSuccess(feedResultEntity);
if (!result)
{
return;
}
var feedEntity = JsonConvert.DeserializeObject <EventsResponse>(feedResultEntity.ResultJson);
foreach (var feed in feedEntity.Events)
{
FeatureEvents.Add(feed);
}
}
public async Task LoadNextPages()
{
IsLoading = true;
var result = new Result();
try
{
await LoadPage();
result.IsSuccess = true;
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Error = ex.Message;
}
await ResultChecker.CheckSuccess(result);
IsLoading = false;
}
public override async void Execute(object parameter)
{
var args = parameter as SearchBoxSuggestionsRequestedEventArgs;
var deferral = args.Request.GetDeferral();
string queryText = args?.QueryText;
if (string.IsNullOrEmpty(queryText))
{
return;
}
var friendFinderManager = new FriendFinderManager();
var friendResult =
await
friendFinderManager.SearchForFriends(queryText, Locator.ViewModels.MainPageVm.CurrentTokens,
Locator.ViewModels.MainPageVm.CurrentUser.Region,
Locator.ViewModels.MainPageVm.CurrentUser.Language);
var result = await ResultChecker.CheckSuccess(friendResult);
if (!result)
{
return;
}
var friendFinderResult = JsonConvert.DeserializeObject <FriendFinderResponse>(friendResult.ResultJson);
var suggestionCollection = args.Request.SearchSuggestionCollection;
if (friendFinderResult.SearchResults != null)
{
Locator.ViewModels.MessagesVm.FriendSearchResults = friendFinderResult.SearchResults.ToList();
foreach (var friend in friendFinderResult.SearchResults.Take(5))
{
suggestionCollection.AppendQuerySuggestion(friend.OnlineId);
}
}
deferral.Complete();
}
public async Task SetUser(string userName)
{
var isCurrentUser = Shell.Instance.ViewModel.CurrentUser.Username.Equals(userName);
var userManager = new UserManager();
await Shell.Instance.ViewModel.UpdateTokens();
var userResult = await userManager.GetUser(userName, Shell.Instance.ViewModel.CurrentTokens, Shell.Instance.ViewModel.CurrentUser.Region, Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, userResult);
var result = await ResultChecker.CheckSuccess(userResult);
if (!result)
{
return;
}
if (string.IsNullOrEmpty(userResult.ResultJson))
{
return;
}
var user = JsonConvert.DeserializeObject <User>(userResult.ResultJson);
if (user == null)
{
return;
}
var list = user.TrophySummary.EarnedTrophies;
user.TrophySummary.TotalTrophies = list.Bronze + list.Gold + list.Platinum + list.Silver;
List <string> languageList = user.LanguagesUsed.Select(ParseLanguageVariable).ToList();
string language = string.Join("," + Environment.NewLine, languageList);
UserModel = new UserViewModel
{
Language = language,
User = user,
IsNotCurrentUser = !isCurrentUser,
CurrentUserOnlineId = Shell.Instance.ViewModel.CurrentUser.Username
};
}
public async Task <bool> DeleteUserAccount(AccountUser user)
{
Locator.ViewModels.MainPageVm.MenuItems = new List <MenuItem>();
try
{
var pages = App.RootFrame.BackStack;
foreach (var page in pages)
{
App.RootFrame.BackStack.Remove(page);
}
}
catch (Exception)
{
// Failed to delete backstack :\
}
var result = new Result();
try
{
result.IsSuccess = await AccountAuthHelpers.DeleteUserAccount(user);
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Error = "Failed to delete user";
}
var resultCheck = await ResultChecker.CheckSuccess(result);
if (resultCheck)
{
AccountUsers.Remove(user);
if (AccountUsers.Any())
{
OnPropertyChanged("AccountUsers");
return(true);
}
App.RootFrame.Navigate(typeof(LoginPage));
}
return(resultCheck);
}
public async Task GetStickers(StickerResponse stickerPack)
{
IsLoading = true;
try
{
var manifestResult = await _stickerManager.GetStickerAndManifestPack(stickerPack.ManifestUrl);
var resultCheck = await ResultChecker.CheckSuccess(manifestResult);
if (!resultCheck)
{
return;
}
var manifest = JsonConvert.DeserializeObject <StickerResponse>(manifestResult.ResultJson);
var newList = SizetypeConverter.ConvertStringToSizeProperty(manifestResult.ResultJson);
if (newList.Any())
{
StickerCollection = new ObservableCollection <StickerSelection>();
var stickerUrls = newList.First().Urls.ToList();
for (int index = 0; index < stickerUrls.Count; index++)
{
StickerCollection.Add(new StickerSelection()
{
Number = index + 1,
ManifestUrl = stickerPack.ManifestUrl,
PackageId = stickerPack.StickerPackageId,
Type = stickerPack.Type,
ImageUrl = stickerUrls[index]
});
}
}
}
catch (Exception ex)
{
// TODO: Throw error to user.
}
IsLoading = false;
}
public async Task SendSticker(StickerSelection stickerSelection)
{
var result = new Result();
if (GroupMembers.Any() && IsNewMessage)
{
result =
await
_messageManager.CreateStickerPostWithNewGroupMessage(GroupMembers.ToArray(),
stickerSelection.ManifestUrl,
stickerSelection.Number.ToString(), stickerSelection.ImageUrl, stickerSelection.PackageId,
stickerSelection.Type, Locator.ViewModels.MainPageVm.CurrentTokens,
Locator.ViewModels.MainPageVm.CurrentUser.Region);
}
else
{
result =
await
_messageManager.CreateStickerPost(SelectedMessageGroup.MessageGroupId,
stickerSelection.ManifestUrl,
stickerSelection.Number.ToString(), stickerSelection.ImageUrl, stickerSelection.PackageId,
stickerSelection.Type, Locator.ViewModels.MainPageVm.CurrentTokens,
Locator.ViewModels.MainPageVm.CurrentUser.Region);
}
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, result);
var resultCheck = await ResultChecker.CheckSuccess(result);
if (resultCheck)
{
SelectedMessageGroup = JsonConvert.DeserializeObject <MessageGroup>(result.ResultJson);
await GetMessages(SelectedMessageGroup);
await GetMessageGroups(Locator.ViewModels.MainPageVm.CurrentUser.Username);
IsNewMessage = false;
}
}
public override async void Execute(object parameter)
{
var args = parameter as SearchBoxQuerySubmittedEventArgs;
string queryText = args?.QueryText;
if (string.IsNullOrEmpty(queryText))
{
return;
}
var friendFinderManager = new FriendFinderManager();
var friendResult =
await
friendFinderManager.SearchForFriends(queryText, Locator.ViewModels.MainPageVm.CurrentTokens,
Locator.ViewModels.MainPageVm.CurrentUser.Region,
Locator.ViewModels.MainPageVm.CurrentUser.Language);
var result = await ResultChecker.CheckSuccess(friendResult);
if (!result)
{
return;
}
var friendFinderResult = JsonConvert.DeserializeObject <FriendFinderResponse>(friendResult.ResultJson);
if (!friendFinderResult.SearchResults.Any())
{
return;
}
Locator.ViewModels.MessagesVm.GroupMembers = new List <string>
{
friendFinderResult.SearchResults.First().OnlineId
};
Locator.ViewModels.MessagesVm.IsNewMessage = true;
}
private async Task SendMessageWithoutMedia()
{
var result = new Result();
if (GroupMembers.Any() && IsNewMessage)
{
result = await _messageManager.CreateNewGroupMessage(GroupMembers.ToArray(), Message,
Locator.ViewModels.MainPageVm.CurrentTokens, Locator.ViewModels.MainPageVm.CurrentUser.Region);
}
else
{
if (SelectedMessageGroup == null)
{
await ResultChecker.SendMessageDialogAsync("Selected Message Group Null!", false);
}
else
{
result = await
_messageManager.CreatePost(SelectedMessageGroup.MessageGroupId, Message,
Locator.ViewModels.MainPageVm.CurrentTokens,
Locator.ViewModels.MainPageVm.CurrentUser.Region);
}
}
await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.CurrentUser, result);
var resultCheck = await ResultChecker.CheckSuccess(result);
if (resultCheck)
{
SelectedMessageGroup = JsonConvert.DeserializeObject <MessageGroup>(result.ResultJson);
await GetMessages(SelectedMessageGroup);
await GetMessageGroups(Locator.ViewModels.MainPageVm.CurrentUser.Username);
IsNewMessage = false;
}
}
public async Task GetMessages(MessageGroup messageGroup)
{
IsSelected = false;
//MessageCollection.Clear();
IsLoading = true;
try
{
SelectedMessageGroup = messageGroup;
await Shell.Instance.ViewModel.UpdateTokens();
var messageResult =
await
_messageManager.GetGroupConversation(messageGroup.MessageGroupId,
Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region,
Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, messageResult);
var result = await ResultChecker.CheckSuccess(messageResult);
if (!result)
{
return;
}
_messageResponse = JsonConvert.DeserializeObject <MessageResponse>(messageResult.ResultJson);
var avatarOnlineId = new Dictionary <string, string>();
foreach (var member in _messageResponse.MessageGroup.MessageGroupDetail.Members)
{
var avatar = await GetAvatarUrl(member.OnlineId);
if (avatarOnlineId.All(node => node.Key != member.OnlineId))
{
avatarOnlineId.Add(member.OnlineId, avatar);
}
}
var newList =
avatarOnlineId.Where(node => node.Key != Shell.Instance.ViewModel.CurrentUser.Username)
.Select(node => node.Key);
GroupMemberSeperatedList = string.Join(", ", newList);
foreach (
var newMessage in
_messageResponse.Messages.Where(node => !MessageCollection.Select(test => test.Message.MessageUid).Contains(node.MessageUid)).Reverse().Select(message => new MessageGroupItem {
Message = message
}))
{
newMessage.AvatarUrl =
avatarOnlineId.First(node => node.Key == newMessage.Message.SenderOnlineId).Value;
if (newMessage.Message.StickerDetail != null)
{
newMessage.Message.Body = string.Empty;
}
newMessage.ImageAvailable = newMessage.Message.ContentKeys.Contains("image-data-0");
try
{
if (newMessage.ImageAvailable)
{
//var imageBytes =
// await
// _messageManager.GetMessageContent(SelectedMessageGroup.MessageGroupId,
// newMessage.Message.SentMessageId,
// Shell.Instance.ViewModel.CurrentTokens,
// Shell.Instance.ViewModel.CurrentUser.Region,
// Shell.Instance.ViewModel.CurrentUser.Language);
//newMessage.Image = await DecodeImage(imageBytes);
}
}
catch (Exception ex)
{
//Insights.Report(ex);
}
MessageCollection.Add(newMessage);
}
ScrollToBottom();
}
catch (Exception ex)
{
//Insights.Report(ex);
}
var newMessages = _messageResponse?.Messages.Where(node => !node.SeenFlag);
if (newMessages != null)
{
await Shell.Instance.ViewModel.UpdateTokens();
var messageUids = newMessages.Select(node => node.MessageUid).ToList();
await
_messageManager.ClearMessages(_messageResponse.MessageGroup.MessageGroupId, messageUids,
Shell.Instance.ViewModel.CurrentTokens,
Shell.Instance.ViewModel.CurrentUser.Region);
}
IsLoading = false;
IsSelected = true;
}
public async Task Login()
{
Result loginResult = new Result();
IsLoading = true;
try
{
loginResult = await _authManager.SendLoginData(UserName, Password);
}
catch (Exception ex)
{
loginResult.IsSuccess = false;
loginResult.ResultJson = ex.Message;
}
var loader = new Windows.ApplicationModel.Resources.ResourceLoader();
if (!loginResult.IsSuccess)
{
loginResult.ResultJson = loader.GetString("LoginError/Text");
}
else if (loginResult.IsSuccess)
{
try
{
var authTokens = JsonConvert.DeserializeObject <Tokens>(loginResult.Tokens);
var expiresInDate = AuthHelpers.GetUnixTime(DateTime.Now) + authTokens.ExpiresIn;
if (!string.IsNullOrEmpty(authTokens.AccessToken) && !string.IsNullOrEmpty(authTokens.RefreshToken))
{
var loginUserResult =
await
_authManager.GetUserEntity(new UserAuthenticationEntity(authTokens.AccessToken, authTokens.RefreshToken, expiresInDate), "ja");
var loginUser = JsonConvert.DeserializeObject <LogInUser>(loginUserResult.ResultJson);
var userResult =
await
_userManager.GetUser(loginUser.OnlineId,
new UserAuthenticationEntity(authTokens.AccessToken, authTokens.RefreshToken,
expiresInDate), loginUser.Region, loginUser.Language);
var user = JsonConvert.DeserializeObject <User>(userResult.ResultJson);
var newAccountResult = await AccountAuthHelpers.CreateUserAccount(authTokens, loginUser, user);
if (!newAccountResult)
{
loginResult.IsSuccess = false;
loginResult.Error = "Failed to create new user in database.";
}
}
}
catch (Exception ex)
{
loginResult.IsSuccess = false;
loginResult.ResultJson = ex.Message;
}
}
// Check if the result was good. If not, show error.
await ResultChecker.CheckSuccess(loginResult);
IsLoading = false;
if (loginResult.IsSuccess)
{
NavigationService.Navigate(typeof(AccountPage));
}
}
public async Task GetStickerPacks()
{
IsLoading = true;
try
{
var stickerList = await _stickersDatabase.GetStickers();
if (stickerList.Any())
{
foreach (var item in stickerList)
{
StickerList.Add(item);
}
IsLoading = false;
return;
}
var initialResult =
await
_stickerManager.GetStickerPackList(Locator.ViewModels.MainPageVm.CurrentUser.Region);
var resultCheck = await ResultChecker.CheckSuccess(initialResult);
if (!resultCheck)
{
return;
}
var packageList = JsonConvert.DeserializeObject <StickerPresetPackageListResponse>(initialResult.ResultJson);
foreach (var item in packageList.PresetPackageList)
{
var manifestResult = await _stickerManager.GetStickerAndManifestPack(item.ManifestUrl);
resultCheck = await ResultChecker.CheckSuccess(manifestResult);
if (!resultCheck)
{
return;
}
var manifest = JsonConvert.DeserializeObject <StickerResponse>(manifestResult.ResultJson);
var metadataResponse = await _stickerManager.GetStickerAndManifestPack(manifest.MetadataUrl);
resultCheck = await ResultChecker.CheckSuccess(metadataResponse);
if (!resultCheck)
{
return;
}
var metadata = JsonConvert.DeserializeObject <MetadataResponse>(metadataResponse.ResultJson);
manifest.Copyright = metadata.Copyright;
manifest.Description = metadata.Description;
manifest.Publisher = metadata.Publisher;
manifest.Title = metadata.Title;
manifest.ManifestUrl = item.ManifestUrl;
stickerList.Add(manifest);
}
foreach (var item in stickerList)
{
StickerList.Add(item);
}
await _stickersDatabase.InsertStickers(stickerList);
}
catch (Exception ex)
{
// TODO: Throw error to user.
}
IsLoading = false;
}
public async void LoadFeedList(string username)
{
IsLoading = true;
await Shell.Instance.ViewModel.UpdateTokens();
var feedResultEntity =
await _recentActivityManager.GetActivityFeed(username, PageCount, StorePromo, IsNews, Shell.Instance.ViewModel.CurrentTokens, Shell.Instance.ViewModel.CurrentUser.Region, Shell.Instance.ViewModel.CurrentUser.Language);
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, feedResultEntity);
var result = await ResultChecker.CheckSuccess(feedResultEntity, false);
if (!result)
{
HasMoreItems = false;
if (Count <= 0)
{
IsEmpty = true;
}
IsLoading = false;
return;
}
var feedEntity = JsonConvert.DeserializeObject <RecentActivityResponse>(feedResultEntity.ResultJson);
if (feedEntity == null)
{
if (Count <= 0)
{
IsEmpty = true;
}
HasMoreItems = false;
IsLoading = false;
return;
}
if (feedEntity.Feed == null)
{
if (Count <= 0)
{
IsEmpty = true;
}
HasMoreItems = false;
IsLoading = false;
return;
}
foreach (var feed in feedEntity.Feed)
{
Add(feed);
}
if (feedEntity.Feed.Any())
{
HasMoreItems = true;
PageCount++;
}
else
{
if (Count <= 0)
{
IsEmpty = true;
}
HasMoreItems = false;
}
IsLoading = false;
}
private async Task <LoadMoreItemsResult> LoadFriends(uint count)
{
IsLoading = true;
try
{
var friendManager = new FriendManager();
await Shell.Instance.ViewModel.UpdateTokens();
var friendResultEntity =
await
friendManager.GetFriendsList(Username, Offset, BlockedPlayer, RecentlyPlayed, PersonalDetailSharing,
FriendStatus, Requesting, Requested, OnlineFilter, Shell.Instance.ViewModel.CurrentTokens, Shell.Instance.ViewModel.CurrentUser.Region, Shell.Instance.ViewModel.CurrentUser.Language);
var result = await ResultChecker.CheckSuccess(friendResultEntity, false);
if (!result)
{
HasMoreItems = false;
if (Count <= 0)
{
IsEmpty = true;
}
IsLoading = false;
return(new LoadMoreItemsResult {
Count = 0
});
}
await AccountAuthHelpers.UpdateTokens(Shell.Instance.ViewModel.CurrentUser, friendResultEntity);
var friendEntity = JsonConvert.DeserializeObject <FriendListResponse>(friendResultEntity.ResultJson);
if (friendEntity == null)
{
HasMoreItems = false;
if (Count <= 0)
{
IsEmpty = true;
}
IsLoading = false;
return(new LoadMoreItemsResult {
Count = count
});
}
if (friendEntity.Friend == null)
{
HasMoreItems = false;
if (Count <= 0)
{
IsEmpty = true;
}
IsLoading = false;
return(new LoadMoreItemsResult {
Count = count
});
}
foreach (var friend in friendEntity.Friend)
{
Add(friend);
}
if (friendEntity.Friend.Any())
{
HasMoreItems = true;
Offset = Offset += 32;
}
else
{
HasMoreItems = false;
if (Count <= 0)
{
IsEmpty = true;
}
}
}
catch (Exception ex)
{
HasMoreItems = false;
}
IsLoading = false;
return(new LoadMoreItemsResult {
Count = count
});
}