public EfCreateUserCommand(ProjectForumContext context, IMapper mapper, CreateUserValidator validator, IEmailSender sender)
{
_context = context;
_mapper = mapper;
_validator = validator;
_sender = sender;
}
public RegisterUser(CoursesContext context, CreateUserValidator validator, IEmailSender sender, IMapper mapper)
{
this.context = context;
this.validator = validator;
this.sender = sender;
this.mapper = mapper;
}
public frmCreateUser()
{
InitializeComponent();
createUserValidator = new CreateUserValidator();
comboUserType.DataSource = Enum.GetValues(typeof(TypeUtilisateur));
comboUserType.SelectedItem = TypeUtilisateur.Utilisateur; // Default choice
}
public EfCreateUserCommand(BlogContext context, IMapper mapper, CreateUserValidator validator, IEmailSender email)
{
this.context = context;
this.mapper = mapper;
this.validator = validator;
this.email = email;
}
public async Task <UserDto> Handle(CreateUser request, CancellationToken cancellationToken)
{
CreateUserValidator validator = new CreateUserValidator();
ValidationResult validationResult = await validator.ValidateAsync(request, cancellationToken);
if (!validationResult.IsValid)
{
throw new EntityValidationException(nameof(User), request, validationResult.Errors);
}
FilterDefinition <User> filterDefinition = Builders <User> .Filter
.Or(new[]
{
Builders <User> .Filter.Eq(x => x.Email, request.Email),
Builders <User> .Filter.Eq(x => x.Username, request.Username)
});
User userAlreadyExists = await _userRepository.Get(filterDefinition, cancellationToken);
if (userAlreadyExists != null)
{
throw new EntityAlreadyExistsException(nameof(User), request.Email);
}
User user = _mapper.Map <User>(request);
user.Password = await _securityService.HashPassword(request.Password);
await _userRepository.Add(user, cancellationToken);
return(_mapper.Map <UserDto>(user));
}
public async Task <UserDto> Handle(CreateUser request, CancellationToken cancellationToken)
{
CreateUserValidator validator = new CreateUserValidator();
ValidationResult validationResult = await validator.ValidateAsync(request, cancellationToken);
if (!validationResult.IsValid)
{
throw new EntityValidationException(nameof(CreateUser), request, validationResult.Errors);
}
User currentUser = await _mainDbContext.Users
.AsNoTracking()
.Where(u => u.Email == request.Email && !u.IsDeleted)
.FirstOrDefaultAsync(cancellationToken);
if (currentUser != null)
{
throw new EntityAlreadyExists(nameof(User), request.Email);
}
User newUser = _mapper.Map <User>(request);
newUser.Password = BCrypt.Net.BCrypt.HashPassword(request.Password);
await _mainDbContext.Users.AddAsync(newUser, cancellationToken);
await _mainDbContext.SaveChangesAsync(cancellationToken);
_logger.LogDebug($"Created user: {request.Email}");
return(_mapper.Map <UserDto>(newUser));
}
public UsersController(ILogger <UsersController> logger, IMediator mediator, CreateUserValidator createValidator, UpdateUserValidator updateValidator)
{
_logger = logger;
_mediator = mediator;
_createValidator = createValidator;
_updateValidator = updateValidator;
}
public void Should_have_validation_error_when_email_is_not_valid()
{
var command = Fixture.Build <CreateUser>().With(x => x.Email, "email").Create();
var userRules = new Mock <IUserRules>();
var sut = new CreateUserValidator(userRules.Object);
sut.ShouldHaveValidationErrorFor(x => x.Email, command);
}
public void Should_have_validation_error_when_user_id_is_empty()
{
var command = Fixture.Build <CreateUser>().With(x => x.IdentityUserId, string.Empty).Create();
var userRules = new Mock <IUserRules>();
var sut = new CreateUserValidator(userRules.Object);
sut.ShouldHaveValidationErrorFor(x => x.IdentityUserId, command);
}
public async Task ReturnSuccessForValidData()
{
var repoMock = CreateRepositoryMock();
var validator = new CreateUserValidator(repoMock);
var request = GetRequest();
var result = await validator.Validate(request);
Assert.True(result.IsSuccessful);
}
public void PositiveCreateUserValidatorTest()
{
var ufwMock = GetMockedUfw();
var user = GetNewUser();
var settings = GetMockedAppSettings();
var validator = new CreateUserValidator(ufwMock.Object, Helper.GetValidationLocalizer(), settings, null);
var validationResult = validator.Validate(user);
Assert.True(validationResult.IsValid);
}
public UserService(IMapper mapper, ICompanyRepository repository, UserManager <User> userManager, IHttpContextAccessor httpContextAccessor, ICacheService cache)
{
_userManager = userManager;
_companyRepository = repository;
_httpContextAccessor = httpContextAccessor;
_cache = cache;
_createValidationRules = new CreateUserValidator();
_passwordValidationRules = new UserPasswordValidator();
_mapper = mapper;
_userListCacheKey = "userList";
}
public async Task ReturnFailureForDuplicatedName()
{
var repoMock = CreateRepositoryMock(isDuplicatedName: true);
var validator = new CreateUserValidator(repoMock);
var request = GetRequest();
var result = await validator.Validate(request);
Assert.False(result.IsSuccessful);
Assert.Equal(ValidatorErrors.Users.DuplicatedUserName, result.Error);
}
public async Task ReturnFailureForMissingPassword()
{
var repoMock = CreateRepositoryMock();
var validator = new CreateUserValidator(repoMock);
var request = GetRequest(password: "");
var result = await validator.Validate(request);
Assert.False(result.IsSuccessful);
Assert.Equal(ValidatorErrors.Users.UserPasswordRequired, result.Error);
}
public void Should_have_error_when_user_email_is_empty()
{
var command = new CreateUser
{
Id = Guid.NewGuid(),
Email = "",
UserName = "******"
};
var userRules = new Mock <IUserRules>();
var validator = new CreateUserValidator(userRules.Object);
validator.ShouldHaveValidationErrorFor(x => x.Email, command);
}
public void DataMustBeSavedToDatabaseOnceSuccessfulPassValidation()
{
var fakeUserRepo = A.Fake <IUserRepository>();
var fakeValidator = new CreateUserValidator(fakeUserRepo);
var testMessage = new CreateUserMessage
{
Username = "******",
Password = "******",
Role = UserRole.Admin
};
var handler = new CreateUserHandler(fakeUserRepo, fakeValidator);
handler.Handle(testMessage);
A.CallTo(() => fakeUserRepo.Create(testMessage)).MustHaveHappened();
}
public void Should_have_error_when_user_email_already_exists()
{
var command = new CreateUser
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
UserName = "******"
};
var userRules = new Mock <IUserRules>();
userRules.Setup(x => x.IsUserEmailUnique(command.Email, new Guid())).Returns(false);
var validator = new CreateUserValidator(userRules.Object);
validator.ShouldHaveValidationErrorFor(x => x.Email, command);
}
public void Should_have_error_when_user_email_is_too_long()
{
var email = "";
for (int i = 0; i < 251; i++)
{
email += i;
}
var command = new CreateUser
{
Id = Guid.NewGuid(),
Email = email,
UserName = "******"
};
var userRules = new Mock <IUserRules>();
var validator = new CreateUserValidator(userRules.Object);
validator.ShouldHaveValidationErrorFor(x => x.Email, command);
}
public async Task <IActionResult> Registration(CreateUserCommand command)
{
if (!ModelState.IsValid)
{
ViewBag.ShowMessage = true;
ViewBag.Message = "Something went wrong";
return(View());
}
if (string.IsNullOrEmpty(command.Answer) || command.Answer.ToLowerInvariant() != "martha")
{
ViewBag.ShowMessage = true;
ViewBag.Message = "Answer isn't correct. Try again!";
return(View());
}
try
{
CreateUserValidator.CommandValidation(command);
await _userService.RegisterUserAsync(command);
TempData["Registered"] = true;
return(RedirectToAction("Index", "Home"));
}
catch (InternalSystemException ex)
{
ViewBag.ShowMessage = true;
ViewBag.Message = ex.Message;
return(View());
}
catch (Exception)
{
ViewBag.ShowMessage = true;
ViewBag.Message = "Something went wrong";
return(View());
}
}
public CreateUserValidatorTests()
{
this.validator = new CreateUserValidator();
}
public CreateUserHandler(IUserRepository userRepo, CreateUserValidator validator)
{
_userRepo = userRepo;
_validator = validator;
}
public EFAddUser(BlogContext context, CreateUserValidator validator)
{
_context = context;
_validator = validator;
}
public CreateUserValidatorTest()
{
_validator = new CreateUserValidator();
}
public EFCreateUserCommand(EstoreContext context, CreateUserValidator validator, IEmailSender sender)
{
_context = context;
_validator = validator;
_sender = sender;
}
public EfCreateUserCommand(DentaCareContext context, CreateUserValidator validator, IEmailSender sender)
{
this._context = context;
this._validator = validator;
this._sender = sender;
}
public CreateUserCommand(CoursesContext context, CreateUserValidator validator, IMapper mapper)
{
_context = context;
_validator = validator;
_mapper = mapper;
}
public EfCreateUserCommand(PhoTexBlogContext context, CreateUserValidator validator, IEmailSender sender)
{
_context = context;
_validator = validator;
_sender = sender;
}
public EfCreateUserCommand(BlogContext context, IApplicationActor actor, CreateUserValidator validator)
{
_context = context;
_actor = actor;
_validator = validator;
}
public EfCreateUserCommand(ArtsContext context, IMapper mapper, CreateUserValidator validator)
{
this.context = context;
this.mapper = mapper;
this.validator = validator;
}
