public void ResendActivationCode(string username)
{
var user = _userReadRepository.Get(username, false);
if (user == null)
{
throw new CustomException("Unknown username", UserErrorCodes.UnknownUserError);
}
user.AssertState("Resend activate code", UserStatuses.PendingActivation);
var candidate = _candidateReadRepository.Get(user.EntityId);
var currentDateTime = DateTime.Now;
var expiry = currentDateTime.AddDays(_activationCodeExpiryDays);
if (!string.IsNullOrEmpty(user.ActivationCode) && (user.ActivateCodeExpiry > currentDateTime))
{
// Reuse existing token and set new expiry date
user.PasswordResetCodeExpiry = expiry;
}
else
{
// generate new code and set expiry date
var activationCode = _codeGenerator.GenerateAlphaNumeric();
user.SetStatePendingActivation(activationCode, expiry);
}
_userWriteRepository.Save(user);
SendActivationCode(candidate, user.ActivationCode);
}
public void SendPasswordResetCode(string username)
{
var user = _userReadRepository.Get(username, false);
if (user == null)
{
_logger.Info(string.Format("Cannot send password reset code, username not found: \"{0}\".", username));
return;
}
var candidate = _candidateReadRepository.Get(user.EntityId);
var currentDateTime = DateTime.Now;
var expiry = currentDateTime.AddDays(_passwordResetCodeExpiryDays);
string passwordResetCode;
if (!string.IsNullOrEmpty(user.PasswordResetCode) && (user.PasswordResetCodeExpiry > currentDateTime))
{
// Reuse existing token and set new expiry date
passwordResetCode = user.PasswordResetCode;
}
else
{
// generate new code and send
passwordResetCode = _codeGenerator.GenerateAlphaNumeric();
}
user.SetStatePasswordResetCode(passwordResetCode, expiry);
_userWriteRepository.Save(user);
// Send Password Reset Code
SendPasswordResetCodeViaCommunicationService(candidate, user.PasswordResetCode);
}
public Candidate RegisterCandidate(Candidate newCandidate, string password)
{
var username = newCandidate.RegistrationDetails.EmailAddress;
var activationCode = _codeGenerator.GenerateAlphaNumeric();
var user = _userReadRepository.Get(username, false);
if (user == null)
{
// Process registration for brand new username
var newCandidateId = Guid.NewGuid();
_authenticationService.CreateUser(newCandidateId, password);
_userAccountService.Register(username, newCandidateId, activationCode, UserRoles.Candidate);
return(SaveAndNotifyCandidate(newCandidateId, newCandidate, activationCode));
}
user.AssertState("Register candidate", UserStatuses.PendingActivation);
if (user.ActivateCodeExpiry != null && user.ActivateCodeExpiry > DateTime.Now)
{
// Process existing username in unexpired pending activation status
return(SaveAndNotifyCandidate(user.EntityId, newCandidate, user.ActivationCode));
}
// Process existing username in an expired pending activation status
_authenticationService.ResetUserPassword(user.EntityId, password);
_userAccountService.Register(username, user.EntityId, activationCode, UserRoles.Candidate);
return(SaveAndNotifyCandidate(user.EntityId, newCandidate, activationCode));
}
public void UpdateUsername(Guid userId, string newUsername)
{
var user = _userReadRepository.Get(userId);
user.PendingUsername = newUsername;
user.PendingUsernameCode = _codeGenerator.GenerateAlphaNumeric();
_userWriteRepository.Save(user);
}
public void LockUser(User user)
{
// Create and set an unlock code, set code expiry, save user, send email containing unlock code.
var unlockCodeExpiryDays = _userAccountConfiguration.UnlockCodeExpiryDays;
var accountUnlockCode = _codeGenerator.GenerateAlphaNumeric();
var expiry = DateTime.UtcNow.AddDays(unlockCodeExpiryDays);
user.SetStateLocked(accountUnlockCode, expiry);
_userWriteRepository.Save(user);
}
private void SendPendingUsernameCodeViaCommunicationService(User user, Candidate candidate)
{
// Pending username code never expires: if user has one, use it.
var pendingUsernameCode = string.IsNullOrEmpty(user.PendingUsernameCode)
? _codeGenerator.GenerateAlphaNumeric()
: user.PendingUsernameCode;
_communicationService.SendMessageToCandidate(candidate.EntityId, MessageTypes.SendPendingUsernameCode,
new[]
{
new CommunicationToken(CommunicationTokens.CandidateFirstName, candidate.RegistrationDetails.FirstName),
new CommunicationToken(CommunicationTokens.UserPendingUsername, user.PendingUsername),
new CommunicationToken(CommunicationTokens.UserPendingUsernameCode, pendingUsernameCode)
});
}
public void SendEmailVerificationCode(string username)
{
var providerUser = _providerUserReadRepository.GetByUsername(username);
if (providerUser == null)
{
throw new CustomException("Unknown username", ErrorCodes.UnknownUserError);
}
// ReSharper disable once RedundantArgumentDefaultValue
providerUser.EmailVerificationCode = _codeGenerator.GenerateAlphaNumeric(EmailVerificationCodeLength);
_providerUserWriteRepository.Update(providerUser);
_communicationService.SendMessageToProviderUser(username, MessageTypes.SendProviderUserEmailVerificationCode,
new[]
{
new CommunicationToken(CommunicationTokens.ProviderUserUsername, providerUser.Username),
new CommunicationToken(CommunicationTokens.ProviderUserEmailVerificationCode, providerUser.EmailVerificationCode)
});
}
protected override async Task HandleCore(ResendActivationCodeCommand message)
{
_logger.Debug($"Received ResendActivationCodeCommand for user '{message.UserId}'");
var validationResult = await _commandValidator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
var user = await _userRepository.GetById(message.UserId);
if (user == null)
{
throw new InvalidRequestException(new Dictionary <string, string> {
{ "UserNotFound", "User not found" }
});
}
if (!user.IsActive)
{
if (!user.SecurityCodes.Any(sc => sc.CodeType == Domain.SecurityCodeType.AccessCode && sc.ExpiryTime >= DateTime.Now))
{
user.AddSecurityCode(new Domain.SecurityCode
{
Code = _codeGenerator.GenerateAlphaNumeric(),
CodeType = Domain.SecurityCodeType.AccessCode,
ExpiryTime = DateTime.Today.AddDays(8).AddSeconds(-1),
ReturnUrl = user.SecurityCodes.OrderByDescending(sc => sc.ExpiryTime).FirstOrDefault(sc => sc.CodeType == Domain.SecurityCodeType.AccessCode)?.ReturnUrl
});
await _userRepository.Update(user);
}
await _auditService.WriteAudit(new ResendActivationCodeAuditMessage(user));
await _communicationService.ResendActivationCodeMessage(user, Guid.NewGuid().ToString());
}
}
public async Task <RequestChangeEmailCommandResponse> Handle(RequestChangeEmailCommand message)
{
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
var user = await _userRepository.GetById(message.UserId);
if (user == null)
{
throw new InvalidRequestException(new Dictionary <string, string> {
{ "", "Cannot find user" }
});
}
var securityCode = new Domain.SecurityCode
{
Code = _codeGenerator.GenerateAlphaNumeric(),
CodeType = Domain.SecurityCodeType.ConfirmEmailCode,
ExpiryTime = DateTime.UtcNow.AddDays(1),
ReturnUrl = message.ReturnUrl,
PendingValue = message.NewEmailAddress
};
user.AddSecurityCode(securityCode);
await _userRepository.Update(user);
await _communicationService.SendConfirmEmailChangeMessage(user, Guid.NewGuid().ToString());
await _auditService.WriteAudit(new RequestChangeEmailAuditMessage(user, securityCode));
return(new RequestChangeEmailCommandResponse()
{
SecurityCode = securityCode.Code
});
}
private User Create(RegisterUserCommand message, SecuredPassword securedPassword)
{
var user = new User
{
Id = message.Id,
Email = message.Email,
SecurityCodes = new[]
{
new SecurityCode
{
Code = _codeGenerator.GenerateAlphaNumeric(),
CodeType = SecurityCodeType.AccessCode,
ExpiryTime = DateTime.Today.AddDays(8).AddSeconds(-1),
ReturnUrl = message.ReturnUrl
}
}
};
Update(user, message, securedPassword);
return(user);
}
protected override async Task HandleCore(RequestPasswordResetCodeCommand message)
{
_logger.Debug($"Received RequestPasswordResetCodeCommand for user '{message.Email}'");
var validationResult = await _validator.ValidateAsync(message);
if (!validationResult.IsValid())
{
throw new InvalidRequestException(validationResult.ValidationDictionary);
}
var existingUser = await _userRepository.GetByEmailAddress(message.Email);
if (existingUser == null)
{
_logger.Info($"Request to reset email for unknown email address : '{message.Email}'");
return;
}
if (RequiresPasswordResetCode(existingUser))
{
existingUser.AddSecurityCode(new SecurityCode
{
Code = _codeGenerator.GenerateAlphaNumeric(),
CodeType = SecurityCodeType.PasswordResetCode,
ExpiryTime = DateTimeProvider.Current.UtcNow.AddDays(1),
ReturnUrl = message.ReturnUrl
});
await _userRepository.Update(existingUser);
}
await _auditService.WriteAudit(new PasswordResetCodeAuditMessage(existingUser));
await _communicationService.SendPasswordResetCodeMessage(existingUser, Guid.NewGuid().ToString(), _linkBuilder.GetForgottenPasswordUrl(_hashingService.HashValue(Guid.Parse(existingUser.Id))));
}
private async Task <string> GenerateCode()
{
var codeLength = (await GetConfig())?.UnlockCodeLength ?? 6;
return(_codeGenerator.GenerateAlphaNumeric(codeLength));
}
