public void Handle(ISession session)
        {
            if (TargetID.Equals(Guid.Empty))
            {
                return;
            }

            ChatUser targetUser = ChatUserManager.LoadUser(TargetID);

            if (targetUser == null)
            {
                return;
            }

            ChatSession chatSession = session as ChatSession;

            ConversationStore store = new ConversationStore();

            Guid resultID = Guid.NewGuid();
            bool flag     = true;

            var CommonConversation = targetUser.ConversationID.Intersect(chatSession.Owner.ConversationID);

            foreach (Guid conversationID in CommonConversation)
            {
                AbstractConversation conversation = store.Load(conversationID);
                if (conversation is SingleConversation)
                {
                    resultID = conversation.ID;
                    flag     = false;
                    break;
                }
            }

            if (flag)
            {
                chatSession.Owner.ConversationID.Add(resultID);
                targetUser.ConversationID.Add(resultID);

                store.Save(new SingleConversation()
                {
                    ID      = resultID,
                    Members = new HashSet <Guid>()
                    {
                        chatSession.Owner.ID, targetUser.ID
                    },
                    ConversationName = "~"
                });

                chatSession.Owner.Save();
                targetUser.Save();
            }

            SingleConversationFrUserIDResponse response = new SingleConversationFrUserIDResponse();

            response.UserID     = TargetID;
            response.ResponseID = resultID;

            chatSession.Send(response);
        }
Example #2
0
        private AbstractConversation GrabCurrentConversation()
        {
            AbstractConversation c = ((AbstractConversation)CurrentConversation);

            if (c == null)
            {
                throw new ConversationUnavailableException();
            }
            return(c);
        }
        public void Handle(ISession session)
        {
            Guid converID = Guid.Parse(ConversationID);
            AbstractConversation conversation = ConversationManager.GetConversation(converID);

            if (conversation == null)
            {
                return;
            }
            conversation.UpdateColor(Color, (session as ChatSession).Owner);
        }
Example #4
0
 public void Save(AbstractConversation conversation)
 {
     lock (_lock)
     {
         Mongo.Instance.Set <AbstractConversation>(conversation.ID.ToString(), (collection) =>
         {
             var condition = Builders <AbstractConversation> .Filter.Eq(p => p.ID, conversation.ID);
             collection.ReplaceOneAsync(condition, conversation, new UpdateOptions()
             {
                 IsUpsert = true
             });
         });
     }
 }
Example #5
0
        public void Handle(ISession session)
        {
            ChatSession chatSession = session as ChatSession;

            if (!chatSession.Owner.ConversationID.Contains(ConversationID))
            {
                return;
            }

            AbstractConversation conversation = ConversationManager.GetConversation(ConversationID);

            if (conversation == null || conversation is GroupConversation)
            {
                return;
            }

            if (chatSession.Owner.LastBuzz.ContainsKey(ConversationID))
            {
                chatSession.Owner.LastBuzz.TryGetValue(ConversationID, out var lastBuzz);
                if (DateTime.Now.Ticks - lastBuzz < 10000000 * 10)
                {
                    return;
                }
            }
            chatSession.Owner.LastBuzz.TryRemove(ConversationID, out var lastz);
            chatSession.Owner.LastBuzz.TryAdd(ConversationID, DateTime.Now.Ticks);

            BuzzResponse message = new BuzzResponse()
            {
                SenderID       = chatSession.Owner.ID.ToString(),
                ConversationID = this.ConversationID.ToString()
            };

            foreach (Guid guid in conversation.Members)
            {
                if (ChatUserManager.IsOnline(guid) && guid != chatSession.Owner.ID)
                {
                    chatSession.Owner.Relationship.TryGetValue(guid, out var relationID);
                    Relation relation = Relation.Get(relationID);
                    if (relation == null || relation.RelationType != Relation.Type.Friend)
                    {
                        continue;
                    }
                    ChatUserManager.LoadUser(guid).Send(message);
                }
            }
        }
Example #6
0
 public void UpdateMessagesList(AbstractConversation conversation)
 {
     lock (_lock)
     {
         Mongo.Instance.Set <AbstractConversation>(conversation.ID.ToString(), collection =>
         {
             var condition = Builders <AbstractConversation> .Filter.Eq(p => p.ID, conversation.ID);
             var update    = Builders <AbstractConversation> .Update
                             .Set(p => p.MessagesID, conversation.MessagesID)
                             .Set(p => p.MediaID, conversation.MediaID)
                             .Set(p => p.AttachmentID, conversation.AttachmentID);
             collection.UpdateOneAsync(condition, update, new UpdateOptions()
             {
                 IsUpsert = true
             });
         });
     }
 }
Example #7
0
        public void Handle(ISession session)
        {
            if (MessagePosition == -1)
            {
                return;
            }

            ChatSession       chatSession = session as ChatSession;
            ConversationStore store       = new ConversationStore();

            AbstractConversation conversation = store.Load(ConversationID);

            MessageFromConversationResponse packet = new MessageFromConversationResponse();

            var messages = conversation.MessagesID;

            if (messages.Count == 0)
            {
                return;
            }
            MessageStore messageStore = new MessageStore();

            for (int i = MessagePosition; i >= Math.Max(0, MessagePosition - Quantity + 1); --i)
            {
                AbstractMessage mess = new MessageStore().Load(messages[i], ConversationID);

                if (mess != null)
                {
                    packet.SenderID.Add(mess.Author.ToString());
                    packet.Content.Add(mess);
                }
            }

            packet.LoadConversation = LoadConversation;

            chatSession.Owner.SendOnly(packet, chatSession);
        }
Example #8
0
 /// <summary>
 /// Send our message.
 /// </summary>
 private async Task SendMessage()
 {
     //If we have tried to send a zero length string we just return
     if (string.IsNullOrWhiteSpace(messageText.Text) || messageText.IsReadOnly)
     {
         return;
     }
     messageText.IsReadOnly = true;
     //We write our own message to the chatBox
     AppendLineToChatBox($"[You] - " + messageText.Text);
     try
     {
         _conversationState = await _conversationState.HandleUserInput(messageText.Text);
     }
     catch (FaceAPIException ex) when("RateLimitExceeded".Equals(ex.ErrorCode))
     {
         ReplyAsBot($"My brain is overloaded with your questions.");
         ReplyAsBot("Please hold on for a while because I can only do a limited amount of requests per minute..");
         Thread.Sleep(3000);
     }
     //We clear the text within the messageText box.
     messageText.Text       = "";
     messageText.IsReadOnly = false;
 }
Example #9
0
        public void Handle(ISession session)
        {
            ChatSession chatSession = session as ChatSession;

            AbstractConversation conversation = ConversationManager.GetConversation(ConversationID);

            if (conversation == null)
            {
                return;
            }

            conversation.SendMessage(Message, chatSession);

            /*
             * if (ChatUserManager.OnlineUsers.TryGetValue(Guid.Parse(ReceiverID), out user))
             * {
             *  SendMessageResponse packet = new SendMessageResponse();
             *  packet.ConversationID = ConversationID;
             *  packet.Message = Message;
             *  packet.SenderID = chatSession.Owner.ID.ToString();
             *  user.Send(packet);
             * }
             */
        }
Example #10
0
        public AbstractConversation Load(Guid id)
        {
            AbstractConversation conversation = null;

            try
            {
                conversation = Mongo.Instance.Get <AbstractConversation>(id.ToString(), (collection) =>
                {
                    var condition = Builders <AbstractConversation> .Filter.Eq(p => p.ID, id);
                    var result    = collection.Find(condition).Limit(1).ToList();
                    if (result.Count > 0)
                    {
                        return(result[0]);
                    }
                    return(null);
                });
            }
            catch (Exception e)
            {
                PacChatServer.GetServer().Logger.Error(e);
            }

            return(conversation);
        }
Example #11
0
 public MainWindow(IFaceApiHelper faceApiHelper)
 {
     InitializeComponent();
     FaceApiHelper      = faceApiHelper;
     _conversationState = new StartConversation(this);
 }
Example #12
0
        public void Handle(ISession session)
        {
            ChatSession chatSession = session as ChatSession;

            UserSearchResponse response = new UserSearchResponse();
            List <String>      UserIDs  = new ChatUserStore().SearchUserIDByEmail(Email, (session as ChatSession).Owner);

            ConversationStore store = new ConversationStore();

            foreach (var item in UserIDs)
            {
                Guid         userId     = Guid.Parse(item);
                ChatUser     targetUser = ChatUserManager.LoadUser(userId);
                SearchResult result     = new SearchResult();

                result.ID         = targetUser.ID.ToString();
                result.FirstName  = targetUser.FirstName;
                result.LastName   = targetUser.LastName;
                result.IsOnline   = targetUser.IsOnline();
                result.LastLogout = targetUser.LastLogoff;


                result.PreviewCode    = -1;
                result.ConversationID = "~";

                var CommonConversation = targetUser.ConversationID.Intersect(chatSession.Owner.ConversationID);

                foreach (Guid id in CommonConversation)
                {
                    AbstractConversation conversation = store.Load(id);
                    if (conversation is SingleConversation)
                    {
                        result.ConversationID = conversation.ID.ToString();

                        AbstractMessage message =
                            conversation.MessagesID.Count > 0 ?
                            new MessageStore().Load(conversation.MessagesID.Last(), conversation.ID) :
                            null;
                        if (message == null)
                        {
                            break;
                        }

                        if (!message.Showable(chatSession.Owner.ID))
                        {
                            result.PreviewCode = 0;
                            break;
                        }

                        result.PreviewCode = message.GetPreviewCode();

                        if (message.GetPreviewCode() == 4)
                        {
                            result.LastMessage = (message as TextMessage).Message;
                        }

                        break;
                    }
                }

                if (chatSession.Owner.Relationship.ContainsKey(targetUser.ID))
                {
                    result.Relationship = (int)Relation.Get(chatSession.Owner.Relationship[targetUser.ID]).RelationType;
                }
                else
                {
                    result.Relationship = (int)Relation.Type.None;
                }

                response.Results.Add(result);
            }

            session.Send(response);
        }
Example #13
0
        public void Handle(ISession session)
        {
            ChatSession chatSession = session as ChatSession;

            ChatUser targetUser = ChatUserManager.LoadUser(TargetID);

            if (targetUser == null)
            {
                return;
            }

            ShortProfileResponse response = new ShortProfileResponse();

            response.ID         = targetUser.ID.ToString();
            response.FirstName  = targetUser.FirstName;
            response.LastName   = targetUser.LastName;
            response.IsOnline   = targetUser.IsOnline();
            response.LastLogout = targetUser.LastLogoff;

            ConversationStore store = new ConversationStore();

            response.PreviewCode    = -1;
            response.ConversationID = "~";

            var CommonConversation = targetUser.ConversationID.Intersect(chatSession.Owner.ConversationID);

            foreach (Guid id in CommonConversation)
            {
                AbstractConversation conversation = store.Load(id);
                if (conversation is SingleConversation)
                {
                    response.ConversationID = conversation.ID.ToString();

                    AbstractMessage message =
                        conversation.MessagesID.Count > 0 ?
                        new MessageStore().Load(conversation.MessagesID.Last(), conversation.ID) :
                        null;
                    if (message == null)
                    {
                        break;
                    }

                    if (!message.Showable(chatSession.Owner.ID))
                    {
                        response.PreviewCode = 0;
                        break;
                    }

                    response.PreviewCode = message.GetPreviewCode();

                    if (message.GetPreviewCode() == 4)
                    {
                        response.LastMess = (message as TextMessage).Message;
                    }

                    break;
                }
            }

            if (chatSession.Owner.Relationship.ContainsKey(targetUser.ID))
            {
                response.RelationshipType = (int)Relation.Get(chatSession.Owner.Relationship[targetUser.ID]).RelationType;
            }
            else
            {
                response.RelationshipType = (int)Relation.Type.None;
            }

            chatSession.Send(response);
        }