public async Task DeleteAsync(params string[] ids)
        {
            var roleUpdateMessageDto = new RoleUpdateMessageDto {
                Roles = new List <string>()
            };

            var permissionConfigs = await _dataContext.GetDocumentsAsync <PermissionConfig, PermissionConfig>(q => q.Where(pc => ids.Contains(pc.Id)));

            foreach (var permissionConfig in permissionConfigs)
            {
                if (permissionConfig != null && !permissionConfig.IsDeleted)
                {
                    permissionConfig.IsDeleted = true;
                    await _dataContext.ReplaceDocumentAsync(permissionConfig);

                    if (permissionConfig.GroupId != "*" && permissionConfig.Permissions.Any(p => p.StartsWith("DEV_CAB")))
                    {
                        roleUpdateMessageDto.GroupId = permissionConfig.GroupId;

                        if (permissionConfig.Role == "*")
                        {
                            roleUpdateMessageDto.Roles.Clear();
                            roleUpdateMessageDto.Roles.AddRange(await GetRolesForGroup());
                        }
                        else if (!roleUpdateMessageDto.Roles.Contains(permissionConfig.Role))
                        {
                            roleUpdateMessageDto.Roles.Add(permissionConfig.Role);
                        }
                    }
                }
            }

            if (roleUpdateMessageDto.Roles.Any())
            {
                await _platformServiceBusService.TriggerPodAccessDefinitionGenerationAsync(roleUpdateMessageDto);
            }
        }
Exemple #2
0
        public async Task <DocumentUpdateResultDto> UpdateAsync(UserDto userDto, bool isBulkImport = false)
        {
            ValidateUser(userDto);
            await CheckForDuplicatesAsync(userDto.Email, userDto.AlternateId, userDto.Id);

            var user = await _systemDataContext.GetDocumentAsync <User>(userDto.Id);

            //Validate access
            await CheckAccessToUserAsync(user, isBulkImport?BulkData.PermissionKey : Permission_Update);

            var previousRoles       = user.GroupRoles;
            var previousPIN         = user.PIN;
            var previousFirstName   = user.FirstName;
            var previousLastName    = user.LastName;
            var previousAlternateId = user.AlternateId;

            await ValidatePINAsync(userDto.PIN, user.GroupRoles.Select(cr => cr.Group).ToList());

            var roleAssignments = await GetGroupRolesToUpdateUserAsync(user.GroupRoles, userDto.GroupRoles, isBulkImport);

            ValidateUserRoles(roleAssignments);

            user.FirstName = userDto.FirstName;
            user.LastName  = userDto.LastName;
            user.FullName  = string.Format("{0} {1}", userDto.FirstName, userDto.LastName);
            user.Culture   = userDto.Culture;
            if (!string.IsNullOrEmpty(userDto.PIN))
            {
                user.PIN = CryptographicProvider.GenerateUserPINHash(userDto.PIN);
            }

            user.TimeZone     = userDto.TimeZone;
            user.MobileNumber = new MobileNumber
            {
                IddCode = userDto.MobileNumber?.IddCode,
                Number  = userDto.MobileNumber?.Number
            };
            user.AlternateId      = userDto.AlternateId;
            user.Email            = userDto.Email;
            user.AccessExpiryDate = userDto.AccessExpiryDate;
            user.IsDeleted        = userDto.IsDeleted;
            user.GroupRoles       = roleAssignments;
            user.ETag             = userDto.ETag;
            user.ImageBlobId      = userDto.ImageBlobId;
            if (userDto.Purposes != null && userDto.Purposes.Count > 0)
            {
                user.Purposes = new List <string>();
                user.Purposes.AddRange(userDto.Purposes);
            }

            var result = await _systemDataContext.ReplaceDocumentAsync(user);

            var addedRoles   = user.GroupRoles.Where(cr => !previousRoles.Any(r => r.Group == cr.Group && r.Role == cr.Role));
            var deletedRoles = previousRoles.Where(cr => !user.GroupRoles.Any(r => r.Group == cr.Group && r.Role == cr.Role));

            bool normalizationRequired =
                userDto.PIN != previousPIN ||
                userDto.FirstName != previousFirstName ||
                userDto.LastName != previousLastName ||
                userDto.AlternateId != previousAlternateId ||
                addedRoles.Any() ||
                deletedRoles.Any();

            if (normalizationRequired)
            {
                var userUpdateMessageDto = new UserUpdateMessageDto
                {
                    UserId     = user.Id,
                    GroupRoles = new List <UserGroupRoleDto>()
                };

                if (userDto.PIN != previousPIN || userDto.FirstName != previousFirstName || userDto.LastName != previousLastName || userDto.AlternateId != previousAlternateId)
                {
                    userUpdateMessageDto.GroupRoles.AddRange(user.GroupRoles.Select(cr => new UserGroupRoleDto {
                        GroupId = cr.Group, Role = cr.Role
                    }));
                }

                else if (addedRoles.Any())
                {
                    userUpdateMessageDto.GroupRoles.AddRange(addedRoles.Select(cr => new UserGroupRoleDto {
                        GroupId = cr.Group, Role = cr.Role
                    }));
                }

                if (deletedRoles.Any())
                {
                    userUpdateMessageDto.GroupRoles.AddRange(deletedRoles.Select(cr => new UserGroupRoleDto {
                        GroupId = cr.Group, Role = cr.Role
                    }));
                }

                await _platformServiceBusService.TriggerPodAccessDefinitionGenerationAsync(userUpdateMessageDto);
            }

            return(result);
        }