public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Validate(updateUserModel);
if (validation.IsError)
{
return(Result.Error(validation.Message));
}
var userEntity = await UserRepository.SelectAsync(updateUserModel.Id);
if (userEntity == default)
{
return(Result.Success());
}
userEntity.ChangeEmail(updateUserModel.Email);
userEntity.ChangeFullName(updateUserModel.FullName.Name, updateUserModel.FullName.Surname);
await UserRepository.UpdateAsync(userEntity.Id, userEntity);
await UnitOfWork.SaveChangesAsync();
return(Result.Success());
}
public async Task <IResult> UpdateAsync(long userId, UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validation.Success)
{
return(new ErrorResult(validation.Message));
}
var userEntity = await UserRepository.SelectAsync(userId);
var nullObjectValidation = new NullObjectValidation <UserEntity>().Valid(userEntity);
if (!nullObjectValidation.Success)
{
return(new ErrorResult(nullObjectValidation.Message));
}
var userDomain = UserDomainFactory.Create(userEntity);
userDomain.Update(updateUserModel);
userEntity = userDomain.Map <UserEntity>();
userEntity.UserId = userId;
await UserRepository.UpdateAsync(userEntity, userEntity.UserId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validation.Success)
{
return(new ErrorResult(validation.Message));
}
var userEntityDatabase = await UserRepository.SelectAsync(updateUserModel.UserId).ConfigureAwait(false);
var userDomain = UserDomainFactory.Create(updateUserModel);
userDomain.SetLogin(userEntityDatabase.Login);
userDomain.SetPassword(userEntityDatabase.Password);
var userEntity = userDomain.Map <UserEntity>();
await UserRepository.UpdateAsync(userEntity, userEntity.UserId).ConfigureAwait(false);
await DatabaseUnitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(new SuccessResult());
}
public async Task <IResult> UpdateAsync(UserModel model)
{
var validation = new UpdateUserModelValidator().Validation(model);
if (validation.Failed)
{
return(validation);
}
var user = await _userRepository.GetAsync(model.Id);
if (user is null)
{
return(Result.Success());
}
user.UpdateName(model.FirstName, model.LastName);
user.UpdateEmail(model.Email);
await _userRepository.UpdateAsync(user.Id, user);
await _unitOfWork.SaveChangesAsync();
return(Result.Success());
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
if (updateUserModel is null)
{
throw new ArgumentNullException(nameof(updateUserModel));
}
var validation = new UpdateUserModelValidator().Validate(updateUserModel);
if (validation.IsError)
{
return(Result.Error(validation.Message));
}
var userEntity = await _userRepository.SelectAsync(updateUserModel.Id).ConfigureAwait(false);
if (userEntity == default)
{
return(Result.Success());
}
userEntity.ChangeEmail(updateUserModel.Email);
userEntity.ChangeFullName(updateUserModel.FullName.Name, updateUserModel.FullName.Surname);
await _userRepository.UpdateAsync(userEntity.Id, userEntity).ConfigureAwait(false);
await _unitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(Result.Success());
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validation.Success)
{
return(ErrorResult(validation.Message));
}
var userEntity = await UserRepository.SelectAsync(updateUserModel.UserId);
if (userEntity == default)
{
return(SuccessResult());
}
userEntity.UpdateEmail(updateUserModel.Email);
userEntity.UpdateFullName(updateUserModel.FullName.Name, updateUserModel.FullName.Surname);
await UserRepository.UpdateAsync(userEntity.UserId, userEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
return(SuccessResult());
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Validate(updateUserModel);
if (validation.Failed)
{
return(Result.Fail(validation.Message));
}
var userEntity = await _userRepository.SelectAsync(updateUserModel.Id);
if (userEntity == default)
{
return(Result.Success());
}
userEntity.ChangeUsername(updateUserModel.Username);
userEntity.ChangeEmail(updateUserModel.Email);
userEntity.ChangePhone(updateUserModel.Phone);
userEntity.ChangeGender(updateUserModel.Gender);
userEntity.ChangeAbout(updateUserModel.About);
userEntity.Country = _countryRepository.FirstOrDefault(country => country.Id == updateUserModel.CountryId);
await _userRepository.UpdateAsync(userEntity.Id, userEntity);
await _unitOfWork.SaveChangesAsync();
return(Result.Success());
}
public async Task <IActionResult> Save(UserRequestModel request)
{
if (request.Id == null)
{
var serviceModel = new CreateUserServiceModel
{
Name = request.Name,
Email = request.Email,
CommunicationsLanguage = request.CommunicationLanguage,
ReturnUrl = request.ReturnUrl,
Scheme = this.HttpContext.Request.Scheme,
Host = this.HttpContext.Request.Host
};
var validator = new CreateUserModelValidator();
var validationResult = await validator.ValidateAsync(serviceModel);
if (validationResult != null)
{
var response = await this.userService.CreateAsync(serviceModel);
return(this.StatusCode((int)HttpStatusCode.Created, new { response.Id }));
}
throw new CustomException(string.Join(ErrorConstants.ErrorMessagesSeparator, validationResult.Errors.Select(x => x.ErrorMessage)), (int)HttpStatusCode.UnprocessableEntity);
}
else
{
var serviceModel = new UpdateUserServiceModel
{
Id = request.Id,
PhoneNumber = request.PhoneNumber,
FirstName = request.FirstName,
LastName = request.LastName,
TwoFactorEnabled = request.TwoFactorEnabled,
AccessFailedCount = request.AccessFailedCount,
LockoutEnd = request.LockoutEnd,
ReturnUrl = request.ReturnUrl,
Scheme = this.HttpContext.Request.Scheme,
Host = this.HttpContext.Request.Host
};
var validator = new UpdateUserModelValidator();
var validationResult = await validator.ValidateAsync(serviceModel);
if (validationResult != null)
{
var response = await this.userService.UpdateAsync(serviceModel);
return(this.StatusCode((int)HttpStatusCode.OK, new { response.Id }));
}
throw new CustomException(string.Join(ErrorConstants.ErrorMessagesSeparator, validationResult.Errors.Select(x => x.ErrorMessage)), (int)HttpStatusCode.UnprocessableEntity);
}
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validationResult = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validationResult.Success)
{
return(validationResult);
}
var userEntity = updateUserModel.Map <UserEntity>();
var userEntityDatabase = await UserRepository.SelectAsync(userEntity.UserId);
userEntity = userEntityDatabase.Map(userEntity);
await UserRepository.UpdateAsync(userEntity, userEntity.UserId);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessResult());
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validation.Success)
{
return(ErrorResult(validation.Message));
}
var userEntity = await UserRepository.SelectAsync(updateUserModel.UserId);
var userDomain = UserDomainFactory.Create(userEntity);
userDomain.Update(updateUserModel);
userEntity = UserEntityFactory.Create(userDomain);
await UserRepository.UpdateAsync(userEntity.UserId, userEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
return(SuccessResult());
}
public Task <IResult <string> > UpdateAsync(UpdateUserModel updateUserModel)
{
var validationResult = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validationResult.Success)
{
return(Task.FromResult(validationResult));
}
var userEntity = updateUserModel.Map <UserEntity>();
var userEntityDatabase = UserRepository.Select(userEntity.UserId);
userEntity.Login = userEntityDatabase.Login;
userEntity.Password = userEntityDatabase.Password;
UserRepository.Update(userEntity, userEntity.UserId);
DatabaseUnitOfWork.SaveChanges();
return(new SuccessResult <string>().ToTask());
}
public UserController(IMyUser user,
IMyFiles myFiles,
UserModelValidator userModelValidator,
UpdateUserModelValidator updateUserModelValidator,
SendEmailConfirmationValidator sendEmailConfirmationValidator,
ConfirmEmailValidator confirmEmailValidator,
ChangePasswordValidator changePasswordValidator,
ForgotPasswordValidator forgotPasswordValidator,
ResetPasswordValidator resetPasswordValidator,
ResponseBadRequest badRequest)
{
_user = user;
_myFiles = myFiles;
_badRequest = badRequest;
_userModelValidator = userModelValidator;
_updateUserModelValidator = updateUserModelValidator;
_sendEmailConfirmationValidator = sendEmailConfirmationValidator;
_confirmEmailValidator = confirmEmailValidator;
_changePasswordValidator = changePasswordValidator;
_forgotPasswordValidator = forgotPasswordValidator;
_resetPasswordValidator = resetPasswordValidator;
}
