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); }