public async Task <IActionResult> Activate([FromBody] ActivateAccountRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _usersService.ActivateAccountConfirm(request);
if (!result.Success)
{
return(BadRequest(result));
}
return(Ok());
}
public async Task ActivateAccount(ActivateAccountRequest request)
{
var sqlStoredProc = "sp_user_activate";
var response = await DapperAdapter.GetFromStoredProcAsync <int>
(
storedProcedureName : sqlStoredProc,
parameters : request,
dbconnectionString : DefaultConnectionString,
sqltimeout : DefaultTimeOut,
dbconnection : _connection,
dbtransaction : _transaction);
if (response == null || response.First() == 0)
{
throw new Exception("No items have been updated");
}
}
public async Task <UserModelResult> ActivateAccountConfirm(ActivateAccountRequest request)
{
var user = await _db.Users.FirstOrDefaultAsync(x => x.Id == request.Id);
if (user == null)
{
return(new UserModelResult("Invalid request"));
}
if (user.Active)
{
return(new UserModelResult("Account already activated"));
}
var aspNetUser = await _userManager.FindByIdAsync(user.AspNetUserId);
var tokenResult = await _userManager.ConfirmEmailAsync(aspNetUser, request.Token);
if (!tokenResult.Succeeded)
{
return(Convert(tokenResult));
}
////TODO: check if explicit password validation is actually required
//var passwordValidationResult = await GetPasswordErrros(aspNetUser, request.Password);
//if (!passwordValidationResult.Success)
//{
// return passwordValidationResult;
//}
var passwordResult = await _userManager.AddPasswordAsync(aspNetUser, request.Password);
if (!passwordResult.Succeeded)
{
_logger.LogWarning("account activation failed: {0}", passwordResult.Errors);
}
else
{
user.Active = true;
await _db.SaveChangesAsync();
}
return(Convert(passwordResult));
}
public async Task <Response <UserModel> > ActivateAccountConfirm(ActivateAccountRequest request)
{
if (!request.Id.HasValue)
{
return(Response.ForError("Request id is required."));
}
var user = await _usersRepository.GetById(request.Id.Value);
if (user == null)
{
return(Response.ForError("Associated user not found."));
}
if (user.Active)
{
return(Response.ForError("Account already activated."));
}
var aspNetUser = await _userManager.FindByIdAsync(user.AspNetUserId);
var tokenResult = await _userManager.ConfirmEmailAsync(aspNetUser, request.Token);
if (!tokenResult.Succeeded)
{
return(ConvertToResponse(tokenResult));
}
var passwordResult = await _userManager.AddPasswordAsync(aspNetUser, request.Password);
if (!passwordResult.Succeeded)
{
_logger.LogWarning("account activation failed: {0}", passwordResult.Errors);
}
else
{
user.Active = true;
await _usersRepository.Save();
}
return(ConvertToResponse(passwordResult));
}
// GET: /account/activate
public ActionResult Activate(string activationToken)
{
var request = new ActivateAccountRequest();
var response = this.accountService.ActivateAccount(new ActivateAccountRequest
{
ActivateAccountToken = activationToken
});
if (response.Success)
{
this.TempData["SuccessMessage"] = "Your account has been successfully activated."; // response.Message???
return(this.RedirectToAction("LogIn"));
}
else
{
this.ModelState.AddModelError(string.Empty, response.Message);
}
return(this.View());
}
public async Task <ActivateAccountResponse> ActivateAccount(ActivateAccountRequest request)
{
var response = new ActivateAccountResponse();
using (var uow = _uowFactory.GetUnitOfWork())
{
var userToken = await uow.UserRepo.GetUserTokenByGuid(new Infrastructure.Repositories.UserRepo.Models.GetUserTokenByGuidRequest()
{
Guid = new Guid(request.Token)
});
if (userToken == null)
{
response.Notifications.AddError("Token does not exist");
return(response);
}
if (userToken.Type_Id != TokenTypeEnum.AccountActivation)
{
response.Notifications.AddError("Invalid token provided");
return(response);
}
if (userToken.Processed)
{
response.Notifications.AddError($"This account has already been activated");
return(response);
}
await uow.UserRepo.ActivateAccount(new Infrastructure.Repositories.UserRepo.Models.ActivateAccountRequest()
{
User_Id = userToken.User_Id,
Updated_By = ApplicationConstants.SystemUserId
});
uow.Commit();
}
response.Notifications.Add($"Your account has been activated", NotificationTypeEnum.Success);
return(response);
}
public ActivateAccountResponse ActivateAccount(ActivateAccountRequest request)
{
var response = new ActivateAccountResponse();
try
{
if (WebSecurity.ConfirmAccount(request.ActivateAccountToken))
{
response.Success = true;
}
else
{
response.Message = Resources.Account.InvalidToken;
}
}
catch (Exception ex)
{
this.exceptionHandler.HandleException(ex);
response.Message = Resources.Common.InternalServerError;
}
return(response);
}
public async Task <ActionResult> Activate([FromBody] ActivateAccountRequest request)
{
var response = await _identityService.ActivateAccountConfirm(request);
return(FromResponse(response));
}
public ActivateAccountResponse ActivateAccount(ActivateAccountRequest request)
{
var response = new ActivateAccountResponse();
try
{
if (WebSecurity.ConfirmAccount(request.ActivateAccountToken))
{
response.Status = StatusCode.OK;
}
else
{
response.Status = StatusCode.Unauthorized;
}
}
catch (Exception ex)
{
response.Status = StatusCode.InternalServerError;
this.exceptionHandler.HandleException(ex);
}
return response;
}
public Task <Response <UserModel> > ActivateAccountConfirm(ActivateAccountRequest request)
{
Response <UserModel> response = Response.ForError("");
return(Task.FromResult(response));
}
public async Task <IActionResult> ActivateAccount([FromBody] ActivateAccountRequest request) => await ExcecuteAsync(async() => await _userService.ActivateAccountAsync(request.Email, request.Token));
