public async Task <HttpResponseMessage> Post()
{
Request.RegisterForDispose((IDisposable)_userManager);
HttpContent requestContent = Request.Content;
string jsonContent = await requestContent.ReadAsStringAsync();
RegistrationCredentials credentials = JsonConvert.DeserializeObject <RegistrationCredentials>(jsonContent);
if (!credentials.Username.IsUsernameValid() ||
!credentials.Password.IsPasswordValid() ||
!credentials.Email.IsEmailValid())
{
return(HelperClass.JsonHttpResponse <Object>(null));
}
if (_userManager.FindByUsername(credentials.Username, false) != null ||
_userManager.FindByUsername(credentials.Username, true) != null)
{
return(HelperClass.JsonHttpResponse <Object>(null));
}
if (_userManager.FindByEmail(credentials.Email, false) != null ||
_userManager.FindByEmail(credentials.Email, true) != null)
{
return(HelperClass.JsonHttpResponse <Object>(null));
}
_userManager.RegisterNewUser(credentials);
return(HelperClass.JsonHttpResponse(true));
}
public void RegisterNewUser(RegistrationCredentials credentials)
{
AddUser(new User()
{
Username = credentials.Username.ToLower(),
Password = credentials.Password.Encrypt(),
Email = credentials.Email.ToLower(),
Fullname = credentials.Fullname
});
}
public async Task <IActionResult> Register(RegistrationCredentials creds)
{
if (await _userRepo.UserExists(creds.UserName))
{
return(BadRequest(new { CustomErrorMessage = "Username already exists" }));
}
var userResult = await _userRepo.RegisterAsync(creds);
return(StatusCode(201, userResult));
}
private async Task <User> CreateEncryptedUser(RegistrationCredentials newUser)
{
User encryptedUser = new User()
{
UserName = newUser.UserName,
Email = newUser.Email,
FirstName = newUser.FirstName,
LastName = newUser.LastName,
};
await encryptedUser.CreatePasswordHashAsync(newUser.PassWord);
return(encryptedUser);
}
public async Task <User> RegisterAsync(RegistrationCredentials newUser)
{
Contract.Requires(newUser != null);
var encryptedUser = await CreateEncryptedUser(newUser);
var userExists = await UserExists(encryptedUser.UserName);
if (userExists)
{
return(null);
}
else
{
await AddNewUserAsync(encryptedUser);
return(encryptedUser);
}
}
public async Task <IActionResult> Register([FromBody] RegistrationCredentials request)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(new AuthFailResponse
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage))
}));
}
var authResponse = await _identityService.RegisterAsync(request.Email, request.Password, request.Name);
if (!authResponse.Success)
{
return(new BadRequestObjectResult(new AuthFailResponse
{
Errors = authResponse.Errors
}));
}
return(new OkObjectResult(new
{
token = authResponse.Token
}));
}
