예제 #1
0
        public async Task <ChannelSummaryResponse> CreateDirectChannelAsync(CreateDirectChannelRequest request)
        {
            return(await ValidateAndExecuteAsync(request, new CreateDirectChannelRequestValidator(), new TaskReference <ChannelSummaryResponse>(async() =>
            {
                var createChannelRequest =
                    new DomainRequest.Channel.CreateDirectChannelRequest(Context.GetSaasUserId(), request.MemberId);

                return await _channelSocketService.CreateDirectChannelAsync(createChannelRequest);
            }),
                                                 request.RequestId));
        }
예제 #2
0
        public Task <ChatSummaryModel> CreateDirectChatAsync(string memberId)
        {
            var dto = new CreateDirectChannelRequest
            {
                MemberId = new Guid(memberId)
            };

            var request = new PostCreateDirectChatRequest(_chatConfig.ApiUrl, _jsonSerializer, dto);

            return(_httpClient.GetModelAsync <ChatSummaryModel, ChannelSummaryResponse>(request, _logger, Mapper.DtoToChatSummary));
        }
예제 #3
0
        public async Task <ChannelSummaryResponse> CreateDirectChannelAsync(CreateDirectChannelRequest request)
        {
            var channel = await _channelService.CreateDirectChannelAsync(request);

            // subscribe creator on channel
            await _pushNotificationService.SubscribeUserOnTagAsync(request.SaasUserId, PushNotificationsTagTemplates.GetChatChannelTag(channel.Id.ToString()));

            var member = await _memberService.GetMemberByIdAsync(request.MemberId);

            // subscribe member on channel
            await _pushNotificationService.SubscribeUserOnTagAsync(member.SaasUserId, PushNotificationsTagTemplates.GetChatChannelTag(channel.Id.ToString()));

            await _channelNotificationService.OnAddChannel(channel);

            //todo filter creator connection id on join channel
            await _channelNotificationService.OnJoinChannel(member, channel);

            return(channel);
        }
예제 #4
0
        public static async Task <ChannelSummaryResponse> CreateDirectChannelAsync(SignalRClient client, Guid memberId)
        {
            string groupName = Guid.NewGuid() + "test";

            // Create a direct channel called test
            var createDirectChannelRequest = new CreateDirectChannelRequest
            {
                MemberId  = memberId,
                RequestId = Guid.NewGuid().ToString(),
            };

            Console.WriteLine("Creating a direct channel.");
            var createdChannel = await client.CreateDirectChannelAsync(createDirectChannelRequest);

            Console.WriteLine("Direct channel was created.");
            Console.WriteLine();

            return(createdChannel);
        }
예제 #5
0
 public Task <ChannelSummaryResponse> CreateDirectChannelAsync(CreateDirectChannelRequest request)
 {
     return(SendAndHandleExceptionsAsync <ChannelSummaryResponse>(ServerMethods.CreateDirectChannelAsync, request));
 }
예제 #6
0
        public async Task <ChannelSummaryResponse> CreateDirectChannelAsync(CreateDirectChannelRequest request)
        {
            var creator = await UnitOfWork.MemberRepository.GetMemberBySaasUserIdAsync(request.SaasUserId);

            if (creator == null)
            {
                throw new NetKitChatNotFoundException($"Unable to create channel. Member with {nameof(request.SaasUserId)}:{request.SaasUserId} is not found.");
            }
            var member = await UnitOfWork.MemberRepository.GetMemberByIdAsync(request.MemberId);

            if (member == null)
            {
                throw new NetKitChatNotFoundException($"Unable to create channel. Member with {nameof(request.MemberId)}:{request.MemberId} is not found.");
            }

            var exitingChannelId = await UnitOfWork.ChannelRepository.GetDirectChannelForMembersAsync(creator.Id, member.Id);

            if (exitingChannelId != default(Guid))
            {
                // open existing direct channel
                var existingDirectChannel = await UnitOfWork.ChannelRepository.GetChannelAsync(exitingChannelId);

                existingDirectChannel.Messages = (await UnitOfWork.MessageRepository.GetAllChannelMessagesWithOwnersAsync(exitingChannelId)).ToList();

                existingDirectChannel.IsClosed = false;
                await UnitOfWork.ChannelRepository.UpdateChannelAsync(existingDirectChannel);

                var channelSummary = DomainModelsMapper.MapToDirectChannelSummaryResponse(existingDirectChannel, creator, member);

                //TODO need to send channel summary specific for every user
                channelSummary.LastMessage = null;
                return(channelSummary);
            }

            var newChannel = new Channel
            {
                Id      = Guid.NewGuid(),
                Created = _dateTimeProvider.GetUtcNow(),
                Type    = ChannelType.Direct,
                //TODO: [ek] do not use creator for direct channels
                CreatorId    = creator.Id,
                Creator      = creator,
                Members      = new List <ChannelMember>(),
                MembersCount = 2,
            };
            //TODO: [ek] Make creator as nullable. Do not set creator for direct chat. Disable close functionality
            var creatorChannelMember = new ChannelMember
            {
                ChannelId         = newChannel.Id,
                MemberId          = creator.Id,
                LastReadMessageId = null,
                IsMuted           = false
            };

            newChannel.Members.Add(creatorChannelMember);
            newChannel.Members.Add(new ChannelMember
            {
                ChannelId         = newChannel.Id,
                MemberId          = member.Id,
                LastReadMessageId = null,
                IsMuted           = false
            });

            await UnitOfWork.ExecuteTransactionAsync(async() =>
            {
                await UnitOfWork.ChannelRepository.AddChannelAsync(newChannel);

                foreach (var channelMember in newChannel.Members)
                {
                    await UnitOfWork.ChannelMemberRepository.AddChannelMemberAsync(channelMember);
                }
            });

            var channel = await UnitOfWork.ChannelRepository.GetChannelWithCreatorAsync(newChannel.Id);

            return(DomainModelsMapper.MapToDirectChannelSummaryResponse(channel, creator, member));
        }
예제 #7
0
 public async Task <ChannelSummaryResponse> CreateDirectChannelAsync(CreateDirectChannelRequest model)
 {
     return(await _connection.InvokeAsync <ChannelSummaryResponse>(CreateDirectChannelCommandName, model));
 }
예제 #8
0
        public async Task <IActionResult> CreateDirectChannelAsync([FromBody] CreateDirectChannelRequest request)
        {
            var channel = await _channelSocketService.CreateDirectChannelAsync(new CreateDirectChannelRequest(GetCurrentSaasUserId(), request.MemberId));

            return(Ok(channel));
        }