Ejemplo n.º 1
0
        public async Task RemoveUsersFromGroups()
        {
            var user  = fillTestDbHelper.Users.Skip(1).FirstOrDefault();
            var group = GroupConverter.GetGroupDto(user.Groups.FirstOrDefault());
            await groupsService.RemoveUsersFromGroupsAsync(group.UsersId, group.GroupId, user.Id);

            var actualGroup = GroupConverter.GetGroupDto(fillTestDbHelper.Groups.FirstOrDefault(opt => opt.GroupId == group.GroupId));

            Assert.True(actualGroup.UsersId.IsNullOrEmpty());
        }
        public async Task <Response> CreateResponseAsync()
        {
            try
            {
                var groupDto = await groupsService.CreateOrEditGroupAsync(GroupConverter.GetGroupDto(request.Group, clientConnection.UserId.GetValueOrDefault())).ConfigureAwait(false);

                return(new GroupsResponse(request.RequestId, GroupConverter.GetGroupVm(groupDto)));
            }
            catch (ObjectDoesNotExistsException ex)
            {
                Logger.WriteLog(ex);
                return(new ResultResponse(request.RequestId, "User not found.", ObjectsLibrary.Enums.ErrorCode.ObjectDoesNotExists));
            }
        }
Ejemplo n.º 3
0
        public async Task <GroupDto> CreateOrEditGroupAsync(GroupDto groupDto)
        {
            try
            {
                using (MessengerDbContext context = contextFactory.Create())
                {
                    Group result;
                    var   group = await context.Groups
                                  .Include(opt => opt.ContactGroups)
                                  .ThenInclude(opt => opt.Contact)
                                  .FirstOrDefaultAsync(opt => opt.UserId == groupDto.UserId && opt.GroupId == groupDto.GroupId)
                                  .ConfigureAwait(false);

                    if (group == null)
                    {
                        Group newGroup = new Group
                        {
                            PrivacySettings = groupDto.PrivacySettings,
                            Title           = groupDto.Title,
                            UserId          = groupDto.UserId,
                            GroupId         = groupDto.GroupId
                        };
                        if (groupDto.UsersId != null && groupDto.UsersId.Any())
                        {
                            var contacts = await context.Contacts
                                           .Where(opt => opt.UserId == groupDto.UserId && groupDto.UsersId.Contains(opt.ContactUserId))
                                           .ToListAsync()
                                           .ConfigureAwait(false);

                            HashSet <ContactGroup> contactGroups = contacts
                                                                   .Select(opt => new ContactGroup {
                                ContactId = opt.ContactId
                            })
                                                                   .ToHashSet();
                            newGroup.ContactGroups = contactGroups;
                        }
                        await context.Groups.AddAsync(newGroup).ConfigureAwait(false);

                        result = newGroup;
                    }
                    else
                    {
                        group.PrivacySettings = groupDto.PrivacySettings;
                        group.Title           = groupDto.Title;
                        context.Update(group);
                        result = group;
                    }
                    await context.SaveChangesAsync().ConfigureAwait(false);

                    return(GroupConverter.GetGroupDto(result));
                }
            }
            catch (PostgresException ex)
            {
                if (ex.SqlState == "23503")
                {
                    throw new ObjectDoesNotExistsException("User is not exists.", ex);
                }
                throw new InternalErrorException("Database error.", ex);
            }
        }