Example #1
0
        public static async Task JoinChatAsync()
        {
            await ExecuteProtected(async() =>
            {
                ChatDto chat         = await CHAT_CLIENT.GetChatInfo(ReadChatName());
                (int publ, int priv) = DIFFIE.GetKeys(chat.P, chat.G);

                JoinChatDto joinDto = new JoinChatDto();
                joinDto.ChatName    = chat.Name;
                joinDto.Member      = ME;

                chat = await CHAT_CLIENT.JoinChat(joinDto);
                ConsoleWriteLine($"Joined {chat.Name}, public: {publ}, private: {priv}\n");

                ChatData chatData = new ChatData(chat, publ, priv);
                USER_CHAT_KEYS.Add(chat.Name, chatData);
                CURRENT_CHAT = chat;

                foreach (MemberDto member in CURRENT_CHAT.Members)
                {
                    if (!member.Equals(ME))
                    {
                        ConnectTo(member);
                    }
                }
                StartChatting();
            }, ex => PrintMenu());
        }
Example #2
0
        public HttpResponseMessage Join([FromBody] JoinChatDto joinDto)
        {
            return(ProtectedExecuteAndWrapResult(() =>
            {
                Chat chat = GetChatByName(joinDto.ChatName);

                if (GetChatMemberByName(chat, joinDto.Member.Name) != null)
                {
                    throw new ConflictException("chat member");
                }

                Member chatMember = new Member(joinDto);
                MemberDto chatMemberDto = new MemberDto(chatMember);

                Notifier joinedNotifier = new Notifier(chatMember.Endpoint, chatMember.Port);
                chat.Members.Add(chatMember, joinedNotifier);

                foreach (KeyValuePair <Member, Notifier> pair in chat.Members)
                {
                    SocketActionBase action = new JoinChatSocketAction(chatMemberDto);

                    try { pair.Value.Send(action); }
                    catch (SocketException ex) { chat.Members.Remove(pair.Key); }
                }

                return new ChatDto(chat);
            }, joinDto));
        }
Example #3
0
        public static async Task JoinChatAsync()
        {
            await ExecuteProtected(async() =>
            {
                ChatInfoDto chat = await CHAT_CLIENT.GetChatInfo(ReadChatName());

                (int publ, int priv) = DIFFIE.GetKeys(chat.P, chat.G);
                JoinChatDto joinDto  = new JoinChatDto(chat.Name, LOGIN, publ);
                ChatInfoDto chatInfo = await CHAT_CLIENT.JoinChat(joinDto);

                Console.WriteLine($"Joined {chat.Name}, public: {publ}, private: {priv}\n");
                USER_CHAT_KEYS.Add(chat.Name, new UserChatKeys(chat, publ, priv));

                await OpenChatAsync(chat.Name);
            });
        }
        public HttpResponseMessage Join([FromBody] JoinChatDto joinDto)
        {
            return(ProtectedExecuteAndWrapResult(() =>
            {
                Chat chat = GetChatByName(joinDto.ChatName);

                if (GetChatMemberByName(chat, joinDto.MemberName) != null)
                {
                    throw new ConflictException("chat member");
                }

                Member chatMember = new Member(joinDto.MemberName, joinDto.PublicKey.Value);
                chat.Members.Add(chatMember);

                return new ChatInfoDto(chat);
            }, joinDto));
        }
 public async Task <ChatInfoDto> JoinChat(JoinChatDto joinDto)
 {
     return(await Connector.SendPost <JoinChatDto, ChatInfoDto>(
                ServerUrl + JOIN_CHAT_ENDPOINT, joinDto
                ));
 }
Example #6
0
 public Member(JoinChatDto dto)
 {
     Name     = dto.Member.Name;
     Endpoint = dto.Member.Endpoint;
     Port     = dto.Member.Port;
 }