Esempio n. 1
0
        public async Task <IdentityResult> UpdateAsync(TRole role, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();


            if (role == null)
            {
                throw new ArgumentNullException(nameof(role));
            }

            await _dataContext.ReplaceDocumentAsync(role);

            return(IdentityResult.Success);
        }
Esempio n. 2
0
        public async Task UpdateAsync(BulkDataOperationDto bulkDataOperationDto)
        {
            var bulkData = await GetAsync(bulkDataOperationDto.Id);

            if (bulkData != null)
            {
                if (!string.IsNullOrWhiteSpace(bulkDataOperationDto.OperationStatusCode))
                {
                    bulkData.OperationStatusCode = bulkDataOperationDto.OperationStatusCode;
                }
                if (!string.IsNullOrWhiteSpace(bulkDataOperationDto.BlobReference))
                {
                    bulkData.BlobReference = bulkDataOperationDto.BlobReference;
                }
                if (!string.IsNullOrWhiteSpace(bulkDataOperationDto.LogBlobReference))
                {
                    bulkData.LogBlobReference = bulkDataOperationDto.LogBlobReference;
                }
            }

            await _systemDataContext.ReplaceDocumentAsync(bulkData);
        }
Esempio n. 3
0
        public async Task <DocumentUpdateResultDto> UpdateAsync(GroupDto groupDto)
        {
            ValidateGroup(groupDto);

            var group = await _systemDataContext.GetDocumentAsync <Group>(groupDto.Id);

            group.Name         = groupDto.Name;
            group.FirstName    = groupDto.FirstName;
            group.LastName     = groupDto.LastName;
            group.FullName     = string.Format("{0} {1}", groupDto.FirstName, groupDto.LastName);
            group.MobileNumber = new MobileNumber
            {
                IddCode = groupDto.MobileNumber?.IddCode,
                Number  = groupDto.MobileNumber?.Number
            };
            group.Email = groupDto.Email;
            group.ETag  = groupDto.ETag;

            var result = await _systemDataContext.ReplaceDocumentAsync(group);

            return(result);
        }
Esempio n. 4
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);
        }