public async Task <IActionResult> Register(RegisterUserRequestDTO registerUserRequestDTO)
{
RegisterUserValidator validator = new RegisterUserValidator();
var validationResult = validator.Validate(registerUserRequestDTO);
if (!validationResult.IsValid)
{
_logger.LogInformation("Not valid input.");
ValidatorError validatorError = new ValidatorError();
return(BadRequest(new {
message = validatorError.GetErrorMessagesAsString(validationResult.Errors)
}));
}
var user = await _userRepo.CreateUser(registerUserRequestDTO.User, registerUserRequestDTO.Password);
if (user == null)
{
return(BadRequest(new {
message = "User with given email already exists."
}));
}
return(Ok(user));
}
public TokenDTO RegisterUser(UserDTO userData)
{
var validator = new RegisterUserValidator(_userRepository);
var validationResult = validator.Validate(userData);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.Errors);
}
var user = new User
{
Name = userData.Name,
Email = userData.Email,
Password = _cryptoService.Encrypt(userData.Password)
};
_userRepository.Insert(user);
var auth = new AuthDTO
{
Email = userData.Email,
Password = userData.Password
};
return(_authService.Authenticate(auth));
}
public IList <ValidationError> Register(RegisterUserViewModel registerUserViewModel)
{
ValidationResult validation = _registerUserValidator.Validate(registerUserViewModel);
IList <ValidationError> validationErrors = validation.GetValidationResultErrors();
if (validationErrors.Count > 0)
{
return(validationErrors);
}
if (_userRepository.Get().FirstOrDefault(user => user.Name == registerUserViewModel.Name) != null)
{
validationErrors.Add(new ValidationError {
PropertyName = "name", Errors = new List <string> {
"Já existe um usuário cadastrado com esse nome."
}
});
return(validationErrors);
}
var user = _mapper.Map <User>(registerUserViewModel);
_userRepository.Add(user);
_userRepository.SaveChanges();
return(validationErrors);
}
public void ShouldAcceptValidUserDataForRegister()
{
Mock <IUserRepository> userRepositoryMock = new Mock <IUserRepository>();
userRepositoryMock.Setup(x => x.GetByEmail(It.IsAny <string>())).Returns(() => null);
var userData = new UserDTO
{
Name = "Test1",
Email = "*****@*****.**",
Password = "******",
PasswordConfirmation = "pwd"
};
var sut = new RegisterUserValidator(userRepositoryMock.Object);
var result = sut.Validate(userData);
Assert.True(result.IsValid);
}
public void ShouldNotAcceptInvalidUserDataForRegister()
{
Mock <IUserRepository> userRepositoryMock = new Mock <IUserRepository>();
userRepositoryMock.Setup(x => x.GetByEmail(It.IsAny <string>())).Returns(() => null);
var userData = new UserDTO
{
Name = "",
Email = "",
Password = "******",
PasswordConfirmation = "pwdd"
};
var sut = new RegisterUserValidator(userRepositoryMock.Object);
var result = sut.Validate(userData);
Assert.False(result.IsValid);
Assert.NotEmpty(result.Errors);
}
public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return RedirectToAction("Index", "Manage");
}
if (ModelState.IsValid)
{
// validation
var validator = new RegisterUserValidator();
ValidationResult valResult = validator.Validate(model);
if (!valResult.IsValid)
{
AddErrors(valResult);
ViewBag.ReturnUrl = returnUrl;
return View(model);
}
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return View("ExternalLoginFailure");
}
// changed email as username
var user = new ApplicationUser { UserName = model.UserName, Email = model.Email };
//var result = await UserManager.CreateAsync(user);
// create user and profile
var result = _profileService.CreateUserProfile(new Profile
{
UserName = model.UserName,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Locations = model.Location,
ProfileStyle = ProfileStyle.GetDefault(),
}, user, null);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
return RedirectToLocal(returnUrl);
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return View(model);
}
public async Task<ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
// validation
var validator = new RegisterUserValidator();
ValidationResult valResult = validator.Validate(model);
if (!valResult.IsValid)
{
AddErrors(valResult);
return View(model);
}
// create user
var user = new ApplicationUser { UserName = model.UserName, Email = model.Email };
//var result = await UserManager.CreateAsync(user, model.Password);
// create profile
var result = _profileService.CreateUserProfile(new Profile
{
UserName = model.UserName,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Locations = model.Location,
ProfileStyle = ProfileStyle.GetDefault(),
}, user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
