Esempio n. 1
0
 public void AddMessage(Tags.jabber.client.message message)
 {
     foreach (var body in message.bodyElements) // Add all body elements
     {
         Messages.Add(new ConversationMessage(message.Timestamp, body.Value));
     }
 }
Esempio n. 2
0
        public static Tags.jabber.client.message SendMessage(string from, string to, string content)
        {
            try
            {
                var account = Frontend.Accounts[from];
                if (account != null)
                {
                    var message = new Tags.jabber.client.message();
                    message.to   = to;
                    message.from = account.CurrentJID;
                    message.type = Tags.jabber.client.message.typeEnum.chat;

                    var body = new Tags.jabber.client.body();
                    body.Value = content;
                    message.Add(body);

                    message.Timestamp = DateTime.Now;
                    message.Account   = from;

                    Frontend.Backend.SendTag(from, message);
                    return(message);
                }
            }
            catch (Exception uiEx) { Frontend.UIError(uiEx); }

            return(null);
        }
Esempio n. 3
0
        public static string GetErrorMessage(Tags.jabber.client.message message)
        {
            var error = message.Element <Tags.jabber.client.error>(Tags.jabber.client.Namespace.error);

            if (error != null)
            {
                return(GetErrorMessage(error));
            }

            return(Translate("UnknownError"));
        }
Esempio n. 4
0
        public void AddMessage(Tags.jabber.client.message message)
        {
            JID    senderJid = new JID(message.from);
            string sender    = null;

            // Get the contact the message is from
            if (senderJid.Bare == Self)
            {
                sender = Self;
            }
            else if (senderJid.Bare == Other)
            {
                sender = Other;
            }
            else
            {
                return;
            }

            // The conversationitem we will be adding items to
            ConversationItem current = null;

            // Look if we have to add a new item or reuse an old one
            if (Items.Count > 0)
            {
                ConversationItem last = Items.First();
                if (last != null && last.Identifier == senderJid) // The last item is from the same sender as this item
                {
                    if (last.Messages.Count > 0)                  // It has messages
                    {
                        ConversationMessage lastMessage = last.Messages.Last();
                        if ((message.Timestamp - lastMessage.Timestamp).Minutes < 1) // The last messag is no older than two minutes
                        {
                            current = last;
                        }
                    }
                    else // It has no messages, we don't know why but we should add our items to it because an emtpy item looks bad
                    {
                        current = last;
                    }
                }
            }

            if (current == null)
            {
                current = new ConversationItem(new ConversationSender(Self, sender), senderJid, message.Timestamp);
                Items.Insert(0, current);
            }

            current.AddMessage(message);
        }
Esempio n. 5
0
        private bool Process(Tags.jabber.client.message message)
        {
            if (message.type == Tags.jabber.client.message.typeEnum.error)
            {
                var errorMessage = Helper.GetErrorMessage(message);
                NotifyError(XMPP.ErrorPolicyType.Informative, Helper.Translate("ErrorTagMessage") + ": " + errorMessage);
            }
            else if (message.type == Tags.jabber.client.message.typeEnum.chat || message.type == Tags.jabber.client.message.typeEnum.normal)
            {
                if (message.bodyElements.Count() > 0)
                {
                    var from     = new XMPP.JID(message.from);
                    var bodytext = string.Join(" ", (from body in message.bodyElements select body.Value));
                    Notify(message.Account, from.Bare, bodytext);
                    return(true);
                }
            }

            return(false);
        }
Esempio n. 6
0
        private bool Process(Tags.jabber.client.message message)
        {
            var settings = Frontend.Settings;

            try
            {
                if (message.type == Tags.jabber.client.message.typeEnum.error)
                {
                    var errorMessage = Helper.Translate("ErrorTagMessage") + ": " + Helper.GetErrorMessage(message);
                    Frontend.Notifications.CreateError(ErrorPolicyType.Informative, message.Account, errorMessage);
                    return(false);
                }

                if (message.type == Tags.jabber.client.message.typeEnum.chat || message.type == Tags.jabber.client.message.typeEnum.normal)
                {
                    if (message.bodyElements.Count() > 0)
                    {
                        JID from = message.from;

                        // The rest of the application only accepts to = jid
                        JID to = message.Account;

                        Account account = Frontend.Accounts[message.Account];
                        if (account != null)
                        {
                            Backend.Data.Contact contact = account.Roster[from.Bare];

                            if (contact == null && settings.allowUnknownSenders)
                            {
                                contact = account.Roster.CreateContact(account.jid, from.Bare);
                            }

                            if (contact == null)
                            {
                                return(false);
                            }

                            contact.SetLastSender(from.Resource);

                            if (account.OwnContact != null && contact != null)
                            {
                                if (!account.CurrentConversations.Keys.Contains(from.Bare))
                                {
                                    account.CurrentConversations[from.Bare] = new Conversation(account.OwnContact.jid, contact.jid);
                                }

                                account.CurrentConversations[from.Bare].AddMessage(message);
                            }

                            contact.LockUpdates();
                            contact.UnreadMessageCount++;
                            contact.UnlockUpdates();

                            Frontend.Events.MessageReceived();
                            Frontend.Events.ContactsChanged();

                            return(true);
                        }
                    }
                }
                return(false);
            }
            catch (Exception uiEx) { Frontend.UIError(uiEx); }

            return(false);
        }
Esempio n. 7
0
        public static Tags.jabber.client.message SendMessage(string from, string to, string content)
        {
            try
            {
                var account = Frontend.Accounts[from];
                if (account != null)
                {
                    var message = new Tags.jabber.client.message();
                    message.to = to;
                    message.from = account.CurrentJID;
                    message.type = Tags.jabber.client.message.typeEnum.chat;

                    var body = new Tags.jabber.client.body();
                    body.Value = content;
                    message.Add(body);

                    message.Timestamp = DateTime.Now;
                    message.Account = from;

                    Frontend.Backend.SendTag(from, message);
                    return message;
                }
            }
            catch (Exception uiEx) { Frontend.UIError(uiEx); }

            return null;
        }