Beispiel #1
0
        public void ProcessNewMessage(Message message) {

            logger.info("process new message: {0}", message);
            MessageModelDelivered messageModel = new MessageModelDelivered(message);
            Peer targetPeer = messageModel.Peer;

            DialogModel targetDialogModel = null;

            foreach(DialogModel dialogModel in dialogs) {
                if (!dialogModel.IsEncrypted && TLStuff.PeerEquals(dialogModel.Peer, targetPeer)) {
                    targetDialogModel = dialogModel;
                    break;
                }
            }

            if(targetDialogModel == null) {
                logger.info("target dialog not found, creating new...");
                targetDialogModel = new DialogModelPlain(messageModel, session);
                    dialogs.Insert(0, targetDialogModel);
            } else {
                logger.info("target dialog found, rearrange...");
                UpDialog(targetDialogModel);
            }

            targetDialogModel.ProcessNewMessage(messageModel);

            if(targetDialogModel == TelegramSession.Instance.Dialogs.OpenedDialog) {
                targetDialogModel.OpenedRead();
            }
        }
Beispiel #2
0
        public DialogModelPlain(MessageModelDelivered topMessage, TelegramSession session) : base(session)
        {
            this.dialog = (DialogConstructor)TL.dialog(topMessage.Peer, topMessage.Id, 1);
            this.messages.Add(topMessage);

            SubscribeToDialog();
        }
Beispiel #3
0
        public int ProcessDialogs(messages_Dialogs dialogsObject)
        {
            List <Dialog>  dialogsList;
            List <Message> messagesList;
            List <Chat>    chatsList;
            List <User>    usersList;

            switch (dialogsObject.Constructor)
            {
            case Constructor.messages_dialogs:
                dialogsList  = ((Messages_dialogsConstructor)dialogsObject).dialogs;
                messagesList = ((Messages_dialogsConstructor)dialogsObject).messages;
                chatsList    = ((Messages_dialogsConstructor)dialogsObject).chats;
                usersList    = ((Messages_dialogsConstructor)dialogsObject).users;
                break;

            case Constructor.messages_dialogsSlice:
                dialogsList  = ((Messages_dialogsSliceConstructor)dialogsObject).dialogs;
                messagesList = ((Messages_dialogsSliceConstructor)dialogsObject).messages;
                chatsList    = ((Messages_dialogsSliceConstructor)dialogsObject).chats;
                usersList    = ((Messages_dialogsSliceConstructor)dialogsObject).users;
                break;

            default:
                return(0);
            }

            logger.info("process dialogs: {0} dialogs, {1} messages, {2} chats, {3} users", dialogsList.Count, messagesList.Count, chatsList.Count, usersList.Count);

            foreach (var user in usersList)
            {
                session.SaveUser(user);
            }

            foreach (var chat in chatsList)
            {
                session.SaveChat(chat);
            }

            Dictionary <int, MessageModel> messagesMap = new Dictionary <int, MessageModel>();

            foreach (var message in messagesList)
            {
                // FIXME: review
                var messageModel = new MessageModelDelivered(message);
                messagesMap.Add(messageModel.Id, messageModel);
            }

            foreach (Dialog dialog in dialogsList)
            {
                dialogs.Add(new DialogModelPlain(dialog, session, messagesMap));
            }

            return(dialogsList.Count);
        }
Beispiel #4
0
        public int ProcessDialogs(messages_Dialogs dialogsObject) {
            List<Dialog> dialogsList;
            List<Message> messagesList;
            List<Chat> chatsList;
            List<User> usersList;
            switch (dialogsObject.Constructor) {
                case Constructor.messages_dialogs:
                    dialogsList = ((Messages_dialogsConstructor)dialogsObject).dialogs;
                    messagesList = ((Messages_dialogsConstructor)dialogsObject).messages;
                    chatsList = ((Messages_dialogsConstructor)dialogsObject).chats;
                    usersList = ((Messages_dialogsConstructor)dialogsObject).users;
                    break;
                case Constructor.messages_dialogsSlice:
                    dialogsList = ((Messages_dialogsSliceConstructor)dialogsObject).dialogs;
                    messagesList = ((Messages_dialogsSliceConstructor)dialogsObject).messages;
                    chatsList = ((Messages_dialogsSliceConstructor)dialogsObject).chats;
                    usersList = ((Messages_dialogsSliceConstructor)dialogsObject).users;
                    break;
                default:
                    return 0;
            }

            logger.info("process dialogs: {0} dialogs, {1} messages, {2} chats, {3} users", dialogsList.Count, messagesList.Count, chatsList.Count, usersList.Count);

            foreach (var user in usersList) {
                session.SaveUser(user);
            }

            foreach (var chat in chatsList) {
                session.SaveChat(chat);
            }

            Dictionary<int, MessageModel> messagesMap = new Dictionary<int, MessageModel>();

            foreach (var message in messagesList) {
                // FIXME: review
                var messageModel = new MessageModelDelivered(message);
                messagesMap.Add(messageModel.Id, messageModel);
            }

            foreach (Dialog dialog in dialogsList) {
                dialogs.Add(new DialogModelPlain(dialog, session, messagesMap));
            }

            return dialogsList.Count;
        }
Beispiel #5
0
        public void ProcessNewMessage(MessageModel messageModel)
        {
            logger.info("processing message and adding to observable collection");
            if (messageModel is MessageModelDelivered)
            {
                MessageModelDelivered newMessage = (MessageModelDelivered)messageModel;
                var selectedMessages             = from message in messages
                                                   where message is MessageModelDelivered && ((MessageModelDelivered)message).Id == messageModel.Id
                                                   select message;
                if (selectedMessages.Any())
                {
                    logger.info("message with this ID already in list");
                    return;
                }
            }

            messages.Add(messageModel);
            Peer peer = Peer;

            if (peer.Constructor == Constructor.peerUser)
            {
                if (userTyping != null)
                {
                    userTyping = null;
                }
            }
            else if (peer.Constructor == Constructor.peerChat)
            {
                if (chatTyping.Count != 0)
                {
                    chatTyping.Clear();
                }
            }

            OnPropertyChanged("PreviewOrAction");
            OnPropertyChanged("StatusOrAction");
            OnPropertyChanged("MessageDeliveryStateProperty");
        }
Beispiel #6
0
        public void ProcessNewMessage(Message message)
        {
            logger.info("process new message: {0}", message);
            MessageModelDelivered messageModel = new MessageModelDelivered(message);
            Peer targetPeer = messageModel.Peer;

            DialogModel targetDialogModel = null;

            foreach (DialogModel dialogModel in dialogs)
            {
                if (!dialogModel.IsEncrypted && TLStuff.PeerEquals(dialogModel.Peer, targetPeer))
                {
                    targetDialogModel = dialogModel;
                    break;
                }
            }

            if (targetDialogModel == null)
            {
                logger.info("target dialog not found, creating new...");
                targetDialogModel = new DialogModelPlain(messageModel, session);
                dialogs.Insert(0, targetDialogModel);
            }
            else
            {
                logger.info("target dialog found, rearrange...");
                UpDialog(targetDialogModel);
            }

            targetDialogModel.ProcessNewMessage(messageModel);

            if (targetDialogModel == TelegramSession.Instance.Dialogs.OpenedDialog)
            {
                targetDialogModel.OpenedRead();
            }
        }
Beispiel #7
0
        public override async Task <bool> SendMessage(string message)
        {
            try {
                long randomId = Helpers.GenerateRandomLong();

                MessageModelUndelivered undeliveredMessage = new MessageModelUndelivered()
                {
                    MessageType = MessageModelUndelivered.Type.Text,
                    Text        = message,
                    Timestamp   = DateTime.Now,
                    RandomId    = randomId
                };

                ProcessNewMessage(undeliveredMessage);

                // TODO: npe?
                messages_SentMessage sentMessage =
                    await session.Api.messages_sendMessage(InputPeer, message, randomId);

                int date, id, pts, seq;
                if (sentMessage.Constructor == Constructor.messages_sentMessage)
                {
                    Messages_sentMessageConstructor sent = (Messages_sentMessageConstructor)sentMessage;
                    id   = sent.id;
                    pts  = sent.pts;
                    seq  = sent.seq;
                    date = sent.date;
                }
                else if (sentMessage.Constructor == Constructor.messages_sentMessageLink)
                {
                    Messages_sentMessageLinkConstructor sent = (Messages_sentMessageLinkConstructor)sentMessage;
                    id   = sent.id;
                    pts  = sent.pts;
                    seq  = sent.seq;
                    date = sent.date;
                    List <contacts_Link> links = sent.links;
                    // TODO: process links
                }
                else
                {
                    logger.error("unknown sentMessage constructor");
                    return(false);
                }

                if (session.Updates.processUpdatePtsSeqDate(pts, seq, date) == false)
                {
                    messages.Remove(undeliveredMessage);
                    return(false);
                }
                ;

                int messageIndex = messages.IndexOf(undeliveredMessage);
                if (messageIndex != -1)
                {
                    messages[messageIndex] =
                        new MessageModelDelivered(TL.message(id, session.SelfId, dialog.peer, true, true, date, message,
                                                             TL.messageMediaEmpty()));
                }
                else
                {
                    logger.error("not found undelivered message to confirmation");
                }

                TelegramSession.Instance.Dialogs.Model.UpDialog(this);

                return(true);
            }
            catch (Exception ex) {
                logger.error("exception {0}", ex);
                return(false);
            }
        }
Beispiel #8
0
        public async Task SendMedia(InputMedia media)
        {
            try {
                long randomId = Helpers.GenerateRandomLong();

                // PHOTO IS HERE
                MessageModelUndelivered undeliveredMessage = new MessageModelUndelivered()
                {
                    MessageType = MessageModelUndelivered.Type.Text,
                    Text        = "",
                    Timestamp   = DateTime.Now,
                    RandomId    = randomId
                };

                ProcessNewMessage(undeliveredMessage);

                messages_StatedMessage sentMessage =
                    await session.Api.messages_sendMedia(InputPeer, media, randomId);

                Message message;
                int     pts, seq;
                if (sentMessage.Constructor == Constructor.messages_statedMessage)
                {
                    Messages_statedMessageConstructor sentMessageConstructor =
                        (Messages_statedMessageConstructor)sentMessage;

                    session.Updates.ProcessChats(sentMessageConstructor.chats);
                    session.Updates.ProcessUsers(sentMessageConstructor.users);

                    pts     = sentMessageConstructor.pts;
                    seq     = sentMessageConstructor.seq;
                    message = sentMessageConstructor.message;
                }
                else if (sentMessage.Constructor == Constructor.messages_statedMessageLink)
                {
                    Messages_statedMessageLinkConstructor statedMessageLink =
                        (Messages_statedMessageLinkConstructor)sentMessage;

                    session.Updates.ProcessChats(statedMessageLink.chats);
                    session.Updates.ProcessUsers(statedMessageLink.users);
                    // TODO: process links

                    pts     = statedMessageLink.pts;
                    seq     = statedMessageLink.seq;
                    message = statedMessageLink.message;
                }
                else
                {
                    logger.error("unknown messages_StatedMessage constructor");
                    return;
                }

                if (!session.Updates.processUpdatePtsSeq(pts, seq))
                {
                    logger.error("send media process updates failed");
                    messages.Remove(undeliveredMessage);
                    return;
                }

                TelegramSession.Instance.Dialogs.Model.UpDialog(this);

                int messageIndex = messages.IndexOf(undeliveredMessage);
                if (messageIndex != -1)
                {
                    MessageModel          messageModel = new MessageModelDelivered(message);
                    MessageModelDelivered newMessage   = (MessageModelDelivered)messageModel;
                    var selectedMessages = from msg in messages
                                           where msg is MessageModelDelivered && ((MessageModelDelivered)msg).Id == messageModel.Id
                                           select msg;
                    if (selectedMessages.Any())
                    {
                        messages.RemoveAt(messageIndex);
                    }
                    else
                    {
                        messages[messageIndex] =
                            new MessageModelDelivered(message);
                    }
                }
                else
                {
                    logger.error("not found undelivered message to confirmation");
                }
            }
            catch (Exception ex) {
                logger.error("Error sending media {0}", ex);
            }
        }
 public DialogModelPlain(MessageModelDelivered topMessage, TelegramSession session) : base(session) {
     this.dialog = (DialogConstructor) TL.dialog(topMessage.Peer, topMessage.Id, 1);
     this.messages.Add(topMessage);
     
     SubscribeToDialog();
 }
Beispiel #10
0
        public override async Task<bool> SendMessage(string message) {
            try {
                long randomId = Helpers.GenerateRandomLong();

                MessageModelUndelivered undeliveredMessage = new MessageModelUndelivered() {
                    MessageType = MessageModelUndelivered.Type.Text,
                    Text = message,
                    Timestamp = DateTime.Now,
                    RandomId = randomId
                };

                ProcessNewMessage(undeliveredMessage);

                // TODO: npe? 
                messages_SentMessage sentMessage =
                    await session.Api.messages_sendMessage(InputPeer, message, randomId);
                int date, id, pts, seq;
                if (sentMessage.Constructor == Constructor.messages_sentMessage) {
                    Messages_sentMessageConstructor sent = (Messages_sentMessageConstructor) sentMessage;
                    id = sent.id;
                    pts = sent.pts;
                    seq = sent.seq;
                    date = sent.date;
                }
                else if (sentMessage.Constructor == Constructor.messages_sentMessageLink) {
                    Messages_sentMessageLinkConstructor sent = (Messages_sentMessageLinkConstructor) sentMessage;
                    id = sent.id;
                    pts = sent.pts;
                    seq = sent.seq;
                    date = sent.date;
                    List<contacts_Link> links = sent.links;
                    // TODO: process links
                }
                else {
                    logger.error("unknown sentMessage constructor");
                    return false;
                }

                if (session.Updates.processUpdatePtsSeqDate(pts, seq, date) == false) {
                    messages.Remove(undeliveredMessage);
                    return false;
                };

                int messageIndex = messages.IndexOf(undeliveredMessage);
                if (messageIndex != -1) {
                    messages[messageIndex] =
                        new MessageModelDelivered(TL.message(id, session.SelfId, dialog.peer, true, true, date, message,
                            TL.messageMediaEmpty()));
                }
                else {
                    logger.error("not found undelivered message to confirmation");
                }

                TelegramSession.Instance.Dialogs.Model.UpDialog(this);

                return true;
            }
            catch (Exception ex) {
                logger.error("exception {0}", ex);
                return false;
            }
        }
Beispiel #11
0
        public async Task SendMedia(InputMedia media) {
            try {
                long randomId = Helpers.GenerateRandomLong();

                // PHOTO IS HERE
                MessageModelUndelivered undeliveredMessage = new MessageModelUndelivered() {
                    MessageType = MessageModelUndelivered.Type.Text,
                    Text = "",
                    Timestamp = DateTime.Now,
                    RandomId = randomId
                };

                ProcessNewMessage(undeliveredMessage);

                messages_StatedMessage sentMessage =
                    await session.Api.messages_sendMedia(InputPeer, media, randomId);

                Message message;
                int pts, seq;
                if (sentMessage.Constructor == Constructor.messages_statedMessage) {
                    Messages_statedMessageConstructor sentMessageConstructor =
        (Messages_statedMessageConstructor)sentMessage;

                    session.Updates.ProcessChats(sentMessageConstructor.chats);
                    session.Updates.ProcessUsers(sentMessageConstructor.users);

                    pts = sentMessageConstructor.pts;
                    seq = sentMessageConstructor.seq;
                    message = sentMessageConstructor.message;
                    
                } else if (sentMessage.Constructor == Constructor.messages_statedMessageLink) {
                    Messages_statedMessageLinkConstructor statedMessageLink =
                        (Messages_statedMessageLinkConstructor) sentMessage;

                    session.Updates.ProcessChats(statedMessageLink.chats);
                    session.Updates.ProcessUsers(statedMessageLink.users);
                    // TODO: process links

                    pts = statedMessageLink.pts;
                    seq = statedMessageLink.seq;
                    message = statedMessageLink.message;
                }
                else {
                    logger.error("unknown messages_StatedMessage constructor");
                    return;
                }

                if (!session.Updates.processUpdatePtsSeq(pts, seq)) {
                    logger.error("send media process updates failed");
                    messages.Remove(undeliveredMessage);
                    return;
                }

                TelegramSession.Instance.Dialogs.Model.UpDialog(this);

                int messageIndex = messages.IndexOf(undeliveredMessage);
                if (messageIndex != -1) {
                    MessageModel messageModel = new MessageModelDelivered(message);
                    MessageModelDelivered newMessage = (MessageModelDelivered)messageModel;
                    var selectedMessages = from msg in messages
                                            where msg is MessageModelDelivered && ((MessageModelDelivered)msg).Id == messageModel.Id
                                            select msg;
                    if (selectedMessages.Any()) {
                        messages.RemoveAt(messageIndex);
                    } else { 
                        messages[messageIndex] =
                            new MessageModelDelivered(message);
                    }
                } else {
                    logger.error("not found undelivered message to confirmation");
                }

            }
            catch (Exception ex) {
                logger.error("Error sending media {0}", ex);
            }
        }