Пример #1
0
        public async Task <Channel> AddChannel(Channel channel, params ChannelMember[] members)
        {
            bool saved = false;

            do
            {
                try
                {
                    long id = SkynetRandom.Id();
                    channel.ChannelId = id;
                    Channels.Add(channel);

                    foreach (ChannelMember member in members)
                    {
                        member.ChannelId = id;
                    }

                    ChannelMembers.AddRange(members);

                    await SaveChangesAsync().ConfigureAwait(false);

                    saved = true;
                }
                catch (DbUpdateException ex) when(ex?.InnerException is MySqlException mex && mex.Number == 1062)
                {
                }
            } while (!saved);
            return(channel);
        }

        #endregion
    }
Пример #2
0
        public async Task CheckIfUserExistInChannelAsyncTest()
        {
            // Arrange
            var channel = new Channel
            {
                Id             = Guid.NewGuid(),
                IsClosed       = true,
                CreatorId      = _memberId,
                Created        = DateTimeOffset.UtcNow,
                Name           = "test",
                Type           = ChannelType.Public,
                Description    = "test",
                WelcomeMessage = "test",
                MembersCount   = 10
            };

            var channel2 = new Channel
            {
                Id             = Guid.NewGuid(),
                IsClosed       = true,
                CreatorId      = _memberId2,
                Created        = DateTimeOffset.UtcNow,
                Name           = "test2",
                Type           = ChannelType.Public,
                Description    = "test",
                WelcomeMessage = "test",
                MembersCount   = 10
            };

            var channelMember = new ChannelMembers
            {
                ChannelId         = channel.Id,
                MemberId          = _memberId,
                LastReadMessageId = null
            };


            // Act
            await UnitOfWork.ChannelRepository.AddChannelAsync(channel);

            await UnitOfWork.ChannelRepository.AddChannelAsync(channel2);

            await UnitOfWork.ChannelMemberRepository.AddChannelMemberAsync(channelMember);

            var ensureExist = await UnitOfWork.ChannelRepository.CheckIfMemberExistInChannelAsync(_memberId, channel.Id);

            var ensureNonExist = await UnitOfWork.ChannelRepository.CheckIfMemberExistInChannelAsync(_memberId, channel2.Id);

            // Assert
            Assert.True(ensureExist);
            Assert.False(ensureNonExist);
        }
Пример #3
0
        public async Task AddChannelMemberAsync(ChannelMembers channelMember)
        {
            using (var connection = _sqlConnectionFactory.CreateConnection())
            {
                await connection.OpenAsync();

                var sqlQuery = @"
                    INSERT INTO ChannelMembers(ChannelId, MemberId, LastReadMessageId, IsMuted) 
                    VALUES (@ChannelId, @MemberId, @LastReadMessageId, @IsMuted)";

                await connection.ExecuteScalarAsync(sqlQuery, channelMember);
            }
        }
Пример #4
0
        public static ChannelMemberResponse ToChannelMemberResponse(this ChannelMembers channelMember)
        {
            var channelMemberResponse = new ChannelMemberResponse();

            if (channelMember != null)
            {
                channelMemberResponse.MemberId          = channelMember.MemberId;
                channelMemberResponse.ChannelId         = channelMember.ChannelId;
                channelMemberResponse.IsMuted           = channelMember.IsMuted;
                channelMemberResponse.LastReadMessageId = channelMember.LastReadMessageId;
            }
            return(channelMemberResponse);
        }
Пример #5
0
        public async Task UpdateChannelMemberAsync(ChannelMembers channelMember)
        {
            using (var connection = _sqlConnectionFactory.CreateConnection())
            {
                await connection.OpenAsync();

                var sqlQuery = @"UPDATE ChannelMembers 
                                 SET ChannelId = @ChannelId, 
                                     MemberId = @MemberId, 
                                     LastReadMessageId = @LastReadMessageId, 
                                     IsMuted = @IsMuted
                                 WHERE ChannelId = @ChannelId AND MemberId = @MemberId";

                await connection.ExecuteAsync(sqlQuery, channelMember);
            }
        }
Пример #6
0
        public async Task GetOnlineMembersInChannelAsyncTest()
        {
            // Arrange
            var member = new Member
            {
                Id           = _memberId2,
                Email        = "test",
                Role         = UserRole.Admin,
                IsAfk        = true,
                IsBanned     = true,
                LastNudged   = DateTimeOffset.UtcNow,
                LastActivity = DateTimeOffset.UtcNow,
                Name         = "test2",
                SaasUserId   = "test",
                Status       = UserStatus.Active
            };

            var channelMember = new ChannelMembers
            {
                MemberId          = member.Id,
                ChannelId         = _channelId,
                LastReadMessageId = null
            };

            // Act
            await UnitOfWork.MemberRepository.AddMemberAsync(member);

            await UnitOfWork.ChannelMemberRepository.AddChannelMemberAsync(channelMember);

            var members = await UnitOfWork.MemberRepository.GetOnlineMembersInChannelAsync(_channelId);

            // Assert
            Assert.NotNull(members);
            Assert.NotEmpty(members);
            Assert.True(members.Count == 1);
            Assert.Equal(member.Id, members.First().Id);
            Assert.Equal(member.Email, members.First().Email);
            Assert.Equal(member.Role, members.First().Role);
            Assert.Equal(member.IsAfk, members.First().IsAfk);
            Assert.Equal(member.IsBanned, members.First().IsBanned);
            Assert.Equal(member.Name, members.First().Name);
            Assert.Equal(member.SaasUserId, members.First().SaasUserId);
            Assert.Equal(member.Status, members.First().Status);
        }
Пример #7
0
        public async Task DeleteChannelMemberAsyncTest()
        {
            // Arrange
            var channelMember = new ChannelMembers
            {
                MemberId          = _memberId,
                ChannelId         = _channelId,
                LastReadMessageId = null
            };

            // Act
            await UnitOfWork.ChannelMemberRepository.AddChannelMemberAsync(channelMember);

            await UnitOfWork.ChannelMemberRepository.DeleteChannelMemberAsync(channelMember.MemberId, channelMember.ChannelId);

            var newChannelMembers = await UnitOfWork.ChannelMemberRepository.GetChannelMembersAsync(channelMember.ChannelId);

            // Assert
            Assert.Empty(newChannelMembers);
        }
        public async Task JoinToChannelAsync(JoinToChannelRequest request)
        {
            var channel = await UnitOfWork.ChannelRepository.GetChannelByIdAsync(request.ChannelId);

            Ensure.That(channel)
            .WithException(x => new NotFoundException(new ErrorDto(ErrorCode.NotFound, "Channel does not exist.")))
            .IsNotNull();
            var member = await UnitOfWork.MemberRepository.GetMemberBySaasUserIdAsync(request.SaasUserId);

            Ensure.That(member)
            .WithException(x => new ServiceException(new ErrorDto(ErrorCode.NotFound, "Member does not exist.")))
            .IsNotNull();

            var members = await _channelMemberService.GetChannelMembersAsync(new ChannelRequest(request.SaasUserId, request.ChannelId));

            if (members.Any(x => x.MemberId == member.Id))
            {
                throw new ConflictException(new ErrorDto(ErrorCode.ConflictError, "You have been already joined to the channel."));
            }
            // Throw if the channel is private but the user isn't allowed
            if (channel.Type == ChannelType.Private && channel.CreatorId != member.Id)
            {
                throw new ConflictException(new ErrorDto(ErrorCode.ConflictError, "This channel is not available for you."));
            }

            var channelMember = new ChannelMembers
            {
                ChannelId         = channel.Id,
                MemberId          = member.Id,
                LastReadMessageId = null
            };

            using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
            {
                await UnitOfWork.ChannelMemberRepository.AddChannelMemberAsync(channelMember);

                await UnitOfWork.ChannelRepository.IncrementChannelMembersCount(channel.Id);

                transactionScope.Complete();
            }
        }
Пример #9
0
        public async Task GetChannelMemberByIdAsync()
        {
            // Arrange
            var channelMember = new ChannelMembers
            {
                MemberId          = _memberId,
                ChannelId         = _channelId,
                LastReadMessageId = null
            };

            // Act
            await UnitOfWork.ChannelMemberRepository.AddChannelMemberAsync(channelMember);

            var newChannelMember = await UnitOfWork.ChannelMemberRepository.GetChannelMemberAsync(channelMember.MemberId, channelMember.ChannelId);

            // Assert
            Assert.NotNull(newChannelMember);
            Assert.Equal(channelMember.MemberId, newChannelMember.MemberId);
            Assert.Equal(channelMember.ChannelId, newChannelMember.ChannelId);
            Assert.Equal(channelMember.IsMuted, newChannelMember.IsMuted);
        }
Пример #10
0
        public async Task <ChannelResponse> InviteMemberAsync(InviteMemberRequest request)
        {
            var channel = await UnitOfWork.ChannelRepository.GetChannelByIdAsync(request.ChannelId);

            Ensure.That(channel).WithException(x => new NotFoundException(new ErrorDto(ErrorCode.NotFound, "Channel does not exist."))).IsNotNull();
            var member = await UnitOfWork.MemberRepository.GetMemberByIdAsync(request.MemberId);

            Ensure.That(member).WithException(x => new ServiceException(new ErrorDto(ErrorCode.NotFound, "Member does not exist."))).IsNotNull();

            var channelMembers = await GetChannelMembersAsync(new ChannelRequest(member.SaasUserId, channel.Id));

            if (channelMembers.Any(x => x.Id == request.MemberId))
            {
                throw new ConflictException(new ErrorDto(ErrorCode.ConflictError, "User already exists in channel."));
            }

            var channelMember = new ChannelMembers
            {
                ChannelId         = request.ChannelId,
                MemberId          = request.MemberId,
                LastReadMessageId = null
            };

            using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
            {
                await UnitOfWork.ChannelMemberRepository.AddChannelMemberAsync(channelMember);

                await UnitOfWork.ChannelRepository.IncrementChannelMembersCount(channel.Id);

                transactionScope.Complete();
            }

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

            return(newChannel.ToChannelResponse(_configuration));
        }
Пример #11
0
        public async Task <ChannelSummaryResponse> CreateChannelAsync(CreateChannelRequest request)
        {
            var profile = await UnitOfWork.MemberRepository.GetMemberBySaasUserIdAsync(request.SaasUserId);

            Ensure.That(profile)
            .WithException(x => new NotFoundException(new ErrorDto(ErrorCode.NotFound, "Member does not exist.")))
            .IsNotNull();

            string permanentChannelImageUrl = await CopyImageToDestinationContainerAsync(request.PhotoUrl);

            var newChannel = new Domain.Channel.Channel
            {
                Id             = Guid.NewGuid(),
                Created        = DateTimeOffset.UtcNow,
                Name           = request.Name,
                Description    = request.Description,
                WelcomeMessage = request.WelcomeMessage,
                Type           = request.Type,
                Members        = new List <ChannelMembers>(),
                CreatorId      = profile.Id,
                Creator        = profile,
                MembersCount   = 0,
                PhotoUrl       = permanentChannelImageUrl
            };

            var creator = new ChannelMembers
            {
                ChannelId         = newChannel.Id,
                MemberId          = profile.Id,
                LastReadMessageId = null,
                IsMuted           = false
            };

            newChannel.Members.Add(creator);

            if (request.Type == ChannelType.Private && request.AllowedMembers.Any())
            {
                foreach (var saasUserId in request.AllowedMembers)
                {
                    var member = await UnitOfWork.MemberRepository.GetMemberBySaasUserIdAsync(saasUserId);

                    Ensure.That(member).WithException(x => new NotFoundException(new ErrorDto(ErrorCode.NotFound, "Member does not exist."))).IsNotNull();
                    var model = new ChannelMembers
                    {
                        ChannelId         = newChannel.Id,
                        MemberId          = member.Id,
                        LastReadMessageId = null
                    };

                    newChannel.Members.Add(model);
                }
            }

            var channelMembers = newChannel.Members.DistinctBy(x => x.MemberId);

            using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
            {
                await UnitOfWork.ChannelRepository.AddChannelAsync(newChannel);

                foreach (var member in channelMembers)
                {
                    await UnitOfWork.ChannelMemberRepository.AddChannelMemberAsync(member);

                    await UnitOfWork.ChannelRepository.IncrementChannelMembersCount(newChannel.Id);
                }

                transactionScope.Complete();
            }

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

            return(channel.ToChannelSummaryResponse(creator.IsMuted, null, null, _configuration));
        }