public async Task <AuthenticationResult> RegisterAsync(UserRegistrationCommand request)
{
var existingUser = await _userManager.FindByEmailAsync(request.Email);
if (existingUser != null)
{
return(new AuthenticationResult
{
ErrorMessages = new[] { "User with this email address already exists" }
});
}
var newUser = new User(ValidateIsAdmin(request))
{
Email = request.Email,
UserName = request.Email,
};
var createdUser = await _userManager.CreateAsync(newUser, request.Password);
if (!createdUser.Succeeded)
{
return(new AuthenticationResult
{
ErrorMessages = createdUser.Errors.Select(x => x.Description)
});
}
return(GenerateAuthResult(newUser));
}
public async Task <IActionResult> Register([FromBody] UserRegistrationCommand request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailureResponse
{
ErrorMessages = ModelState.Values.SelectMany(x => x.Errors.Select(y => y.ErrorMessage))
}));
}
var authResponse = await _identityService.RegisterAsync(request);
if (!authResponse.Success)
{
return(BadRequest(new AuthFailureResponse
{
ErrorMessages = authResponse.ErrorMessages
}));
}
return(Ok(new AuthSuccessResponse
{
Token = authResponse.Token
}));
}
public async Task <ActionResult> Registration(UserRegistrationCommand appUserCommand)
{
var response = await _mediator.Send(appUserCommand);
if ((bool)response.isValid)
{
Session["user-id"] = response.Id;
}
return(RedirectToAction("Verification"));
}
public static async Task SeedEssentialsAsync(IMediator mediator, IIdentityService userService, RoleManager <IdentityRole> roleManager)
{
// Seeding roles
foreach (var role in Enum.GetNames(typeof(Roles)))
{
if (!await roleManager.RoleExistsAsync(role))
{
await roleManager.CreateAsync(new IdentityRole(role));
}
}
var defaultAdminRegCmd = new UserRegistrationCommand()
{
FirstName = "Default",
LastName = "Admin",
Password = "******",
UserName = "******"
};
// Seeding default admin
await mediator.Send(defaultAdminRegCmd);
var changeRoleRequest = new ChangeRoleRequest()
{
Role = Roles.Admin.ToString(),
UserName = defaultAdminRegCmd.UserName
};
// Adding Admin role
await userService.ChangeRoleAsync(changeRoleRequest, RoleActions.Add);
var defaultReaderRegCmd = new UserRegistrationCommand()
{
FirstName = "Default",
LastName = "Reader",
Password = "******",
UserName = "******"
};
// Seeding default user
await mediator.Send(defaultReaderRegCmd);
}
public async Task <RequestResult> RegisterAsync(UserRegistrationCommand data)
{
var username = await _userManager.FindByNameAsync(data.UserName);
if (username != null)
{
return(RequestResult.Fail(RequestError.AlreadyExists, $"User with username {data.UserName} already registered"));
}
var user = _mapper.Map <UserRegistrationCommand, AppUser>(data);
var result = await _userManager.CreateAsync(user, data.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, Roles.Reader.ToString());
return(RequestResult.Success());
}
else
{
return(RequestResult.Fail(RequestError.ValidationError, result.Errors.Select(e => e.Description)));
}
}
public async Task <ActionResult> Register(UserRegistrationCommand data) // Ok
{
var result = await Mediator.Send(data);
return(result.Succeeded ? NoContent() : (ActionResult)BadRequest(result.ErrorsToString()));
}
public UserRegistrationViewModel()
{
UserRegistrationCommand = new UserRegistrationCommand(this);
UserLoginPageShowCommand = new UserLoginPageShowCommand(this);
}
public async Task <IActionResult> SignUp([FromBody] UserRegistrationCommand command)
{
return(Ok(await _mediator.Send(command)));
}
private bool ValidateIsAdmin(UserRegistrationCommand request)
=> request.AdminKey != null &&
_configuration.GetValue <string>("AdminKey").Equals(request.AdminKey);
