Esempio n. 1
0
        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 :\
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Reads Xml from given stream and retrieves incoming messages or delivery reports
        /// within the XML document. The Messages or DeliveryReport are stored in the IncomingMessages
        /// or DeliveryReports collection.
        /// </summary>
        /// <param name="inStream"></param>
        /// <param name="outStream"></param>
        public void HandleIncomingMessages(Stream inStream, Stream outStream)
        {
            ReceivedMessages.Clear();
            DeliveryReports.Clear();
            XmlDocument docRequest          = new XmlDocument();
            XmlEmbeddedResourceResolver res = new XmlEmbeddedResourceResolver();

            docRequest.XmlResolver = res;
            docRequest.Load(inStream);
            XmlDocument  docResponse = CheckRequest(docRequest);
            string       sResponse   = "<?xml version=\"1.0\"?>\n" + docResponse.OuterXml;
            StreamWriter sw          = new StreamWriter(outStream, System.Text.Encoding.GetEncoding("ISO-8859-1"));

            sw.Write(sResponse);
            sw.Flush();
            outStream.Flush();
        }
        public async Task SelectMessageGroup(object sender, ItemClickEventArgs e)
        {
            var    selectedMessageGroup = e.ClickedItem as MessageGroupItem;
            string error;

            try
            {
                MessageCollection.Clear();
                await GetMessages(selectedMessageGroup.MessageGroup);

                return;
            }
            catch (Exception ex)
            {
                error = ex.Message;
            }

            await ResultChecker.SendMessageDialogAsync(error, false);
        }
Esempio n. 4
0
        public async Task GetMessages(MessageGroup messageGroup)
        {
            IsSelected = false;
            MessageCollection.Clear();
            IsLoading = true;
            try
            {
                SelectedMessageGroup = messageGroup;
                var messageResult =
                    await
                    _messageManager.GetGroupConversation(messageGroup.MessageGroupId,
                                                         Locator.ViewModels.MainPageVm.CurrentTokens,
                                                         Locator.ViewModels.MainPageVm.CurrentUser.Region,
                                                         Locator.ViewModels.MainPageVm.CurrentUser.Language);

                await AccountAuthHelpers.UpdateTokens(Locator.ViewModels.MainPageVm.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 != Locator.ViewModels.MainPageVm.CurrentUser.Username)
                    .Select(node => node.Key);
                GroupMemberSeperatedList = string.Join(", ", newList);
                foreach (
                    var newMessage in
                    _messageResponse.Messages.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,
                            //            Locator.ViewModels.MainPageVm.CurrentTokens,
                            //            Locator.ViewModels.MainPageVm.CurrentUser.Region,
                            //            Locator.ViewModels.MainPageVm.CurrentUser.Language);
                            //newMessage.Image = await DecodeImage(imageBytes);
                        }
                    }
                    catch (Exception ex)
                    {
                        //Insights.Report(ex);
                    }
                    MessageCollection.Add(newMessage);
                }
            }
            catch (Exception ex)
            {
                //Insights.Report(ex);
            }
            var newMessages = _messageResponse?.Messages.Where(node => !node.SeenFlag);

            if (newMessages != null)
            {
                var messageUids = newMessages.Select(node => node.MessageUid).ToList();
                await
                _messageManager.ClearMessages(_messageResponse.MessageGroup.MessageGroupId, messageUids,
                                              Locator.ViewModels.MainPageVm.CurrentTokens,
                                              Locator.ViewModels.MainPageVm.CurrentUser.Region);
            }

            IsLoading  = false;
            IsSelected = true;
        }