public async Task <SignInUserResponse> SignUp(SignUpUserViewModel signUpUserViewModel)
{
var registerContent = GetContent(signUpUserViewModel);
var response = await _httpClient.PostAsync($"/api/auth/sign-up", registerContent);
if (!TreateErrorsResponse(response))
{
return(new SignInUserResponse
{
ResponseResult = await DeserializeObjectResponse <ResponseResult>(response)
});
}
return(await DeserializeObjectResponse <SignInUserResponse>(response));
}
public async Task <IActionResult> Signup(SignUpUserViewModel usermodel)
{
if (ModelState.IsValid)
{
var result = await _accountRepository.CreateUserAsync(usermodel);
if (!result.Succeeded)
{
foreach (var errorMessage in result.Errors)
{
ModelState.AddModelError("", errorMessage.Description);
}
}
return(View(usermodel));
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> SignUp(SignUpUserViewModel signUpUserViewModel)
{
if (!ModelState.IsValid)
{
return(View(signUpUserViewModel));
}
var response = await _authService.SignUp(signUpUserViewModel);
if (ResponseHaveErrors(response.ResponseResult))
{
return(View(signUpUserViewModel));
}
await SignIn(response);
return(RedirectToAction("Index", "Catalog"));
}
private async Task <ResponseMessage> ClientRegister(SignUpUserViewModel signUpUserViewModel)
{
var user = await _userManager.FindByEmailAsync(signUpUserViewModel.Email);
var registeredUser = new UserRegisteredIntegrationEvent(
Guid.Parse(user.Id), signUpUserViewModel.Name, signUpUserViewModel.Email, signUpUserViewModel.CPF);
try
{
return(await _bus.RequestAsync <UserRegisteredIntegrationEvent, ResponseMessage>(registeredUser));
}
catch (Exception)
{
await _userManager.DeleteAsync(user);
throw;
}
}
public async Task <IdentityResult> CreateUserAsync(SignUpUserViewModel UserModel)
{
var NewUser = new ApplicationUser()
{
UserName = UserModel.Email,
Email = UserModel.Email,
FirstName = UserModel.FirstName,
LastName = UserModel.LastName,
Address = UserModel.Address,
BirthDate = UserModel.BirthDate
};
var result = await _userManager.CreateAsync(NewUser, UserModel.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(NewUser, "Customer");
}
return(result);
}
public async Task <ActionResult> SignUp(SignUpUserViewModel model)
{
if (this.User.Identity.IsAuthenticated)
{
return(View("Error"));
}
if (ModelState.IsValid)
{
var user = new User {
UserName = model.Name, Email = model.Email, PhoneNumber = model.Phone
};
IdentityResult resultCreate = await UserManager.CreateAsync(user, model.Password);
if (RoleManager.RoleExists("user"))
{
if (resultCreate.Succeeded)
{
IdentityResult resultRole = await UserManager.AddToRoleAsync((await UserManager.FindAsync(model.Name, model.Password)).Id, "user");
if (resultRole.Succeeded)
{
return(RedirectToAction("SignIn"));
}
else
{
ModelState.AddModelError("", string.Join(", ", resultRole.Errors));
}
}
else
{
ModelState.AddModelError("", string.Join(", ", resultCreate.Errors));
}
}
else
{
return(View("Error"));
}
}
return(View(model));
}
public async Task <IActionResult> SignUp([FromBody] SignUpUserViewModel signUpUserViewModel)
{
var signUpUser = signUpUserViewModel.ConvertToEntity();
if (!signUpUser.IsValid())
{
return(CustomResponse(signUpUser));
}
var user = new IdentityUser
{
UserName = signUpUser.Email,
Email = signUpUser.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, signUpUser.Password);
if (result.Succeeded)
{
var clientResult = await ClientRegister(signUpUserViewModel);
if (!clientResult.ValidationResult.IsValid)
{
await _userManager.DeleteAsync(user);
return(CustomResponse(clientResult.ValidationResult));
}
return(CustomResponse(await GenerateJWT(user.Email)));
}
foreach (var erro in result.Errors)
{
AdicionarErroProcessamento(erro.Description);
}
return(CustomResponse());
}
public static SignUpUser ConvertToEntity(this SignUpUserViewModel model) => new SignUpUser(model.Email, model.Password, model.ConfirmPassword);
