public async Task <IDataResult <Int64> > AddAsync(AddUserModel addUserModel)
{
if (addUserModel is null)
{
throw new ArgumentNullException(nameof(addUserModel));
}
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.IsError)
{
return(DataResult <Int64> .Error(validation.Message));
}
addUserModel.SignIn = _signInService.CreateSignIn(addUserModel.SignIn);
var userEntity = UserFactory.Create(addUserModel);
userEntity.Add();
await _userRepository.AddAsync(userEntity).ConfigureAwait(false);
await _unitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(DataResult <Int64> .Success(userEntity.Id));
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Valid(addUserModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
addUserModel.Login = UserDomainService.GenerateHash(addUserModel.Login);
addUserModel.Password = UserDomainService.GenerateHash(addUserModel.Password);
var userDomain = UserDomainFactory.Create(addUserModel);
userDomain.Add();
var userEntity = userDomain.Map <UserEntity>();
await UserRepository.AddAsync(userEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
return(new SuccessDataResult <long>(userEntity.UserId));
}
public void ShouldNotAddUserIfRequiredFieldsEmpty()
{
var newUser = new AddUserModel();
var validator = new AddUserModelValidator();
var validationResults = validator.Validate(newUser);
validationResults.IsValid.ShouldBe(false);
validationResults.Errors.Select(x => x.ErrorMessage).ShouldBe(new List <string>
{
"'Email' must not be empty.",
"'Password' must not be empty.",
"'Confirm Password' must not be empty."
}, false);
}
public void ShouldNotAddUserIfPasswordsDoNotMatch()
{
var newUser = new AddUserModel
{
Email = "*****@*****.**",
Password = "******",
ConfirmPassword = "******"
};
var validator = new AddUserModelValidator();
var validationResults = validator.Validate(newUser);
validationResults.IsValid.ShouldBe(false);
validationResults.Errors.Select(x => x.ErrorMessage).ShouldContain("The password and confirmation password do not match.");
}
public void ShouldNotAddUserIfEmailNotValid()
{
var newUser = new AddUserModel
{
Email = "not-a-valid-email",
Password = "******",
ConfirmPassword = "******"
};
var validator = new AddUserModelValidator();
var validationResults = validator.Validate(newUser);
validationResults.IsValid.ShouldBe(false);
validationResults.Errors.Select(x => x.ErrorMessage).ShouldContain("'Email' is not a valid email address.");
}
public void ShouldNotAddUserIfPasswordLengthNotValid(string testPassword)
{
var newUser = new AddUserModel
{
Email = "*****@*****.**",
Password = testPassword,
ConfirmPassword = testPassword
};
var validator = new AddUserModelValidator();
var validationResults = validator.Validate(newUser);
validationResults.IsValid.ShouldBe(false);
validationResults.Errors.Single().ErrorMessage.ShouldContain($"'Password' must be between 6 and 100 characters. You entered {testPassword.Length} characters.");
}
public void ShouldNotAddUserIfEmailNotUnique()
{
ResetUsers();
var existingUser = SetupUsers(1).Single();
var newUser = new AddUserModel
{
Email = existingUser.Email,
Password = "******",
ConfirmPassword = "******"
};
var validator = new AddUserModelValidator();
var validationResults = validator.Validate(newUser);
validationResults.IsValid.ShouldBe(false);
validationResults.Errors.Select(x => x.ErrorMessage).ShouldContain("A user with this email address already exists in the database.");
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.IsError)
{
return(DataResult <long> .Error(validation.Message));
}
addUserModel.SignIn = SignInService.CreateSignIn(addUserModel.SignIn);
var userEntity = UserFactory.Create(addUserModel);
userEntity.Add();
await UserRepository.AddAsync(userEntity);
await UnitOfWork.SaveChangesAsync();
return(DataResult <long> .Success(userEntity.Id));
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Valid(addUserModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
var userDomain = UserDomainFactory.Create(addUserModel);
userDomain.Add();
var userEntity = userDomain.Map <UserEntity>();
await UserRepository.AddAsync(userEntity).ConfigureAwait(false);
await DatabaseUnitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(new SuccessDataResult <long>(userEntity.UserId));
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Valid(addUserModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
addUserModel.SignIn = UserDomainService.CreateSignInHash(addUserModel.SignIn);
var userEntity = UserEntityFactory.Create(addUserModel);
userEntity.Add();
await UserRepository.AddAsync(userEntity);
await UnitOfWork.SaveChangesAsync();
return(new SuccessDataResult <long>(userEntity.UserId));
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.Failed)
{
return(DataResult <long> .Fail(validation.Message));
}
var authModel = _authService.CreateAuth(addUserModel.SignIn);
var userEntity = UserFactory.Create(addUserModel, authModel);
userEntity.Add();
await _userRepository.AddAsync(userEntity);
await _unitOfWork.SaveChangesAsync();
return(DataResult <long> .Success(userEntity.Id));
}
public Task <IResult <long> > AddAsync(AddUserModel addUserModel)
{
var validationResult = new AddUserModelValidator().Valid(addUserModel);
if (!validationResult.Success)
{
return(new ErrorResult <long>(validationResult.Message).ToTask());
}
var signInModel = new SignInModel(addUserModel.Login, addUserModel.Password);
addUserModel.Login = signInModel.LoginHash();
addUserModel.Password = signInModel.PasswordHash();
var userEntity = addUserModel.Map <UserEntity>();
UserRepository.Add(userEntity);
DatabaseUnitOfWork.SaveChanges();
return(new SuccessResult <long>(userEntity.UserId).ToTask());
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.Failed)
{
return(DataResult <long> .Fail(validation.Message));
}
var authEntityResult = await _authApplicationService.AddAsync(addUserModel.Auth);
if (authEntityResult.Failed)
{
return(DataResult <long> .Fail(authEntityResult.Message));
}
var userEntity = UserFactory.Create(addUserModel, authEntityResult.Data);
await _userRepository.AddAsync(userEntity);
await _unitOfWork.SaveChangesAsync();
return(DataResult <long> .Success(userEntity.Id));
}
public async Task <IResult <long> > AddAsync(UserModel model)
{
var validation = new AddUserModelValidator().Validation(model);
if (validation.Failed)
{
return(validation.Fail <long>());
}
var auth = await _authService.AddAsync(model.Auth);
if (auth.Failed)
{
return(auth.Fail <long>());
}
var user = _userFactory.Create(model, auth.Data);
await _userRepository.AddAsync(user);
await _unitOfWork.SaveChangesAsync();
return(user.Id.Success());
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.Failed)
{
return(DataResult <long> .Fail(validation.Message));
}
addUserModel.SignIn = _signInService.CreateSignIn(addUserModel.SignIn);
var userEntity = UserFactory.Create(addUserModel);
userEntity.Add();
await _userRepository.AddAsync(userEntity);
var country = _countryRepository.FirstOrDefault(country => country.Id == addUserModel.CountryId);
userEntity.Country = country;
await _unitOfWork.SaveChangesAsync();
return(DataResult <long> .Success(userEntity.Id));
}
public ResponseModel CreateUserFromModel(AddUserModel model, List <Roles> roles)
{
ResponseModel resp = new ResponseModel();
try
{
User userExist = _userRepository.GetByEmail(model.Email);
if (userExist == null)
{
// validate user
ValidationResult validateUser = new AddUserModelValidator().Validate(model);
if (validateUser.IsValid)
{
if (model.Locations != null && model.Locations.Count > 0)
{
ResponseModel validLocations = _locationService.ValidateAddLocations(model.Locations);
if (!validLocations.Success)
{
return(validLocations);
}
}
if (model.PhoneNumbers != null && model.PhoneNumbers.Count > 0)
{
ResponseModel validPhoneNumbers = _phoneNumberService.ValidateAddPhoneNumbers(model.PhoneNumbers);
if (!validPhoneNumbers.Success)
{
return(validPhoneNumbers);
}
}
Guid userId = Guid.NewGuid();
string img = null;
if (model.Imagem != null)
{
ResponseModel resultImg = DownloadImage(model.Imagem, userId.ToString()).Result;
if (resultImg.Success)
{
img = resultImg.Result.ToString();
}
}
User newUser = new User
{
UserId = userId,
Email = model.Email,
Password = Encrypt.EncryptString(model.Password, userId.ToString()),
Name = model.Name,
Image = img,
Locations = _locationService.CreateLocationsFromModel(model.Locations, userId),
PhoneNumbers = _phoneNumberService.CreatePhoneNumbersFromModel(model.PhoneNumbers, userId),
CreatedAt = Domain.Utils.DateTimeUtil.UtcToBrasilia(),
LastUpdatedAt = Domain.Utils.DateTimeUtil.UtcToBrasilia(),
Roles = GenerateUserRoles(roles, userId)
};
//_userRepository.Add(newUser);
resp.Success = true;
resp.Message = "Usuário adicionado com sucesso!";
resp.Result = newUser;
}
else
{
resp.Message = validateUser.Errors.FirstOrDefault().ErrorMessage;
}
}
else
{
resp.Message = "Já existe um usuário utilizando este E-mail, por favor escolha outro E-mail.";
}
}
catch (Exception e)
{
resp.Message = "Não foi possível adicionar o usuário";
}
return(resp);
}
