private User CreateNewUser(CreateUserAccountViewModel viewModel)
{
var user = new User();
user.Created = VirtualDateTime.Now;
user.Modified = user.Created;
user.Firstname = viewModel.FirstName;
user.Lastname = viewModel.LastName;
user.JobTitle = viewModel.JobTitle;
user.EmailAddress = viewModel.EmailAddress;
user.AllowContact = viewModel.AllowContact;
user.SendUpdates = viewModel.SendUpdates;
byte[] salt = Crypto.GetSalt();
user.Salt = Convert.ToBase64String(salt);
user.PasswordHash = Crypto.GetPBKDF2(viewModel.Password, salt);
user.HashingAlgorithm = HashingAlgorithm.PBKDF2;
user.EmailVerifySendDate = null;
user.EmailVerifiedDate = null;
user.EmailVerifyHash = null;
user.SetStatus(UserStatuses.New, user);
user.Status = UserStatuses.New;
return(user);
}
public IActionResult UserAccountCreate(string userId)
{
CreateUserAccountViewModel model = new CreateUserAccountViewModel
{
Limits = selectListService.GetLimits(),
Currencies = selectListService.GetCurrencies(),
UserId = userId
};
return(View(model));
}
public async Task <IActionResult> UserAccountCreate(CreateUserAccountViewModel model)
{
if (ModelState.IsValid)
{
User user = await userManager.FindByIdAsync(model.UserId);
Currency currency = await context.Currencies.FirstOrDefaultAsync(c => c.Id == model.CurrencyId);
Account account = accountService.CreateAccount(user, currency);
accountService.AddAccount(account);
userService.UserAccountLimit(account, model.UserId, model.LimitId);
return(RedirectToAction("UserAccounts", "Account", new { userId = model.UserId }));
}
model.Limits = selectListService.GetLimits();
model.Currencies = selectListService.GetCurrencies();
return(View(model));
}
public async Task <ActionResult> SkipRegistration()
{
var request = new CreateUserAccountViewModel
{
UserId = GetUserId(),
OrganisationName = "MY ACCOUNT"
};
var response = await _employerAccountOrchestrator.CreateMinimalUserAccountForSkipJourney(request, HttpContext);
var returnUrlCookie = _returnUrlCookieStorageService.Get(ReturnUrlCookieName);
_returnUrlCookieStorageService.Delete(ReturnUrlCookieName);
if (returnUrlCookie != null && !returnUrlCookie.Value.IsNullOrWhiteSpace())
{
return(Redirect(returnUrlCookie.Value));
}
return(RedirectToAction(ControllerConstants.IndexActionName, ControllerConstants.EmployerTeamControllerName, new { hashedAccountId = response.Data.HashedId }));
}
public IActionResult CreateUserAccountPost(CreateUserAccountViewModel viewModel)
{
viewModel.ParseAndValidateParameters(Request, m => m.EmailAddress);
viewModel.ParseAndValidateParameters(Request, m => m.ConfirmEmailAddress);
viewModel.ParseAndValidateParameters(Request, m => m.FirstName);
viewModel.ParseAndValidateParameters(Request, m => m.LastName);
viewModel.ParseAndValidateParameters(Request, m => m.JobTitle);
viewModel.ParseAndValidateParameters(Request, m => m.Password);
viewModel.ParseAndValidateParameters(Request, m => m.ConfirmPassword);
if (viewModel.HasSuccessfullyParsedValueFor(m => m.EmailAddress) &&
viewModel.HasSuccessfullyParsedValueFor(m => m.ConfirmEmailAddress) &&
viewModel.EmailAddress != viewModel.ConfirmEmailAddress)
{
viewModel.AddErrorFor(
m => m.ConfirmEmailAddress,
"The email address and confirmation do not match.");
}
if (viewModel.HasSuccessfullyParsedValueFor(m => m.Password) &&
viewModel.HasSuccessfullyParsedValueFor(m => m.ConfirmPassword) &&
viewModel.Password != viewModel.ConfirmPassword)
{
viewModel.AddErrorFor(
m => m.ConfirmPassword,
"The password and confirmation do not match.");
}
User existingUser = CheckForExistingUserForGivenEmailAddress(viewModel.EmailAddress);
if (existingUser?.EmailVerifySendDate != null)
{
if (existingUser.EmailVerifiedDate != null)
{
viewModel.AddErrorFor(
m => m.EmailAddress,
"This email address has already been registered. Please sign in or enter a different email "
+ "address.");
}
else
{
viewModel.AddErrorFor(
m => m.EmailAddress,
"This email address is awaiting confirmation. Please check your email inbox or enter a different email"
+ " address");
}
}
if (viewModel.HasAnyErrors())
{
return(View("CreateUserAccount", viewModel));
}
User newUser = CreateNewUser(viewModel);
dataRepository.Insert(newUser);
dataRepository.SaveChanges();
GenerateAndSendAccountVerificationEmail(newUser);
var confirmEmailAddressViewModel = new ConfirmEmailAddressViewModel {
EmailAddress = viewModel.EmailAddress
};
return(View("ConfirmEmailAddress", confirmEmailAddressViewModel));
}
public virtual async Task <OrchestratorResponse <EmployerAccountViewModel> > CreateMinimalUserAccountForSkipJourney(CreateUserAccountViewModel viewModel, HttpContextBase context)
{
try
{
var existingUserAccounts =
await Mediator.SendAsync(new GetUserAccountsQuery { UserRef = viewModel.UserId });
if (existingUserAccounts?.Accounts?.AccountList?.Any() == true)
{
return new OrchestratorResponse <EmployerAccountViewModel>
{
Data = new EmployerAccountViewModel
{
HashedId = existingUserAccounts.Accounts.AccountList.First().HashedId
},
Status = HttpStatusCode.OK
}
}
;
var result = await Mediator.SendAsync(new CreateUserAccountCommand
{
ExternalUserId = viewModel.UserId,
OrganisationName = viewModel.OrganisationName
});
return(new OrchestratorResponse <EmployerAccountViewModel>
{
Data = new EmployerAccountViewModel
{
HashedId = result.HashedAccountId
},
Status = HttpStatusCode.OK
});
}
catch (InvalidRequestException ex)
{
_logger.Error(ex, $"Create User Account Validation Error: {ex.Message}");
return(new OrchestratorResponse <EmployerAccountViewModel>
{
Data = new EmployerAccountViewModel(),
Status = HttpStatusCode.BadRequest,
Exception = ex,
FlashMessage = new FlashMessageViewModel()
});
}
}
