public async Task <User> Register(string email, string username, string password)
{
var user = User.Create(email, username);
if (await EmailExists(email))
{
Alertify.Push("Email address already exists", AlertType.Error);
return(null);
}
if (await UsernameExists(username))
{
Alertify.Push("Username already exists", AlertType.Error);
return(null);
}
if ((await userManager.CreateAsync(user, password)).Succeeded)
{
await rolesService.AdmitRole(RoleName.User, user);
var confirmAccountToken = await userManager.GenerateEmailConfirmationTokenAsync(user);
confirmAccountToken = cryptoService.Encrypt(confirmAccountToken);
string callbackUrl =
$"{Configuration.GetValue<string>(AppSettingsKeys.ServerAddress)}/Auth/ConfirmAccount?email={user.Email}&token={confirmAccountToken}";
await emailSender.Send(EmailMessages.ActivationAccountEmail(email, callbackUrl));
return(user);
}
Alertify.Push("Creating account failed", AlertType.Error);
return(null);
}
public async Task <SendChangeEmailEmailResponse> Handle(SendChangeEmailEmailRequest request,
CancellationToken cancellationToken)
{
if (await authValidationService.EmailExists(request.NewEmail))
{
throw new DuplicateException("Account with this email already exists");
}
var result = await userTokenGenerator.GenerateChangeEmailToken();
var(encryptedToken, encryptedEmail, encryptedNewEmail) =
(cryptoService.Encrypt(result.Token), cryptoService.Encrypt(result.Email),
cryptoService.Encrypt(request.NewEmail));
string callbackUrl =
$"{Configuration.GetValue<string>(AppSettingsKeys.ServerAddress)}api/account/changeEmail?email={encryptedEmail}&token={encryptedToken}&newEmail={encryptedNewEmail}";
var emailTemplate =
(await emailTemplateGenerator.FindEmailTemplate(EmailTemplateDictionary.RegisterTemplate))
.ReplaceParameters(new EmailTemplateParameter("{{username}}", result.Username),
new EmailTemplateParameter("{{callbackUrl}}", callbackUrl));
await emailSender.Send(EmailMessages.ActivationAccountEmail(result.Email, emailTemplate));
return(new SendChangeEmailEmailResponse());
}
public async Task <SendAddSerialEmailResponse> Handle(SendAddSerialEmailRequest request,
CancellationToken cancellationToken)
{
var user = await userService.GetUserWithSerials(httpContextReader.CurrentUserId);
if (!(await userService.GetUserWithSerials(httpContextReader.CurrentUserId)).HasEmptySerialSlot())
{
throw new PremiumOperationException("Account has no more serial slots");
}
if (await serialService.SerialExists(request.Serial, httpContextReader.CurrentUserId))
{
throw new DuplicateException("Serial already exists");
}
var result = await userTokenGenerator.GenerateAddSerialToken();
var(encryptedSerial, encryptedEmail, encryptedToken) = (cryptoService.Encrypt(request.Serial),
cryptoService.Encrypt(result.Email),
cryptoService.Encrypt(result.Token));
string callbackUrl =
$"{Configuration.GetValue<string>(AppSettingsKeys.ServerAddress)}api/account/serial/add?email={encryptedEmail}&token={encryptedToken}&serial={encryptedSerial}";
var emailTemplate =
(await emailTemplateGenerator.FindEmailTemplate(EmailTemplateDictionary.RegisterTemplate))
.ReplaceParameters(new EmailTemplateParameter("{{username}}", result.Username),
new EmailTemplateParameter("{{callbackUrl}}", callbackUrl));
await emailSender.Send(EmailMessages.ActivationAccountEmail(result.Email, emailTemplate));
return(new SendAddSerialEmailResponse());
}
public async Task <RegisterResponse> Handle(RegisterRequest request, CancellationToken cancellationToken)
{
if (await authValidationService.EmailExists(request.Email))
{
throw new DuplicateException("Email already exists", ErrorCodes.EmailExists);
}
if (await authValidationService.UsernameExists(request.Username))
{
throw new DuplicateException("Username already exists", ErrorCodes.UsernameExists);
}
var signUpResult = await authService.SignUp(request.Email, request.Password, request.Username);
if (signUpResult != null)
{
var registerToken = signUpResult.User?.Tokens.SingleOrDefault(t => t.Code == signUpResult.Token) ??
throw new TokenException("Register token was not created",
ErrorCodes.CannotGenerateToken);
return(await emailSender.Send(EmailMessages.ActivationAccountEmail(signUpResult.User?.Email,
signUpResult.User?.Username,
$"{Configuration.GetValue<string>(AppSettingsKeys.ClientAddress)}account/confirm?userId={signUpResult.User?.Id}&token={registerToken.Code}"))
? new RegisterResponse()
: throw new ServiceException("Some error occurred during sending an email message",
ErrorCodes.SendEmailFailed));
}
throw new AuthException("Error occurred during signing up");
}
public async Task <SendActivationEmailResponse> Handle(SendActivationEmailRequest request,
CancellationToken cancellationToken)
{
var result = await authService.GenerateActivationEmailToken(request.Email);
if (result == null)
{
return(new SendActivationEmailResponse());
}
var(encryptedToken, encryptedEmail) =
(cryptoService.Encrypt(result.Token), cryptoService.Encrypt(result.Email));
string callbackUrl =
$"{Configuration.GetValue<string>(AppSettingsKeys.ServerAddress)}api/auth/confirm?email={encryptedEmail}&token={encryptedToken}";
var emailTemplate =
(await emailTemplateGenerator.FindEmailTemplate(EmailTemplateDictionary.RegisterTemplate))
.ReplaceParameters(new EmailTemplateParameter("{{username}}", result.Username),
new EmailTemplateParameter("{{callbackUrl}}", callbackUrl));
return(await emailSender.Send(EmailMessages.ActivationAccountEmail(result.Email, emailTemplate))
? new SendActivationEmailResponse
{
Token = encryptedToken, Email = result.Email
}
: new SendActivationEmailResponse());
}
public async Task <SignUpResponse> Handle(SignUpRequest request, CancellationToken cancellationToken)
{
if (await authValidationService.EmailExists(request.Email))
{
throw new DuplicateException("Email address already exists", ErrorCodes.EmailExists);
}
if (await authValidationService.UsernameExists(request.Username))
{
throw new DuplicateException("Username already exists", ErrorCodes.UsernameExists);
}
var user = await identityService.SignUp(request.Email, request.Username, request.Password);
if (user != null)
{
await balanceService.CreateBalanceAccount(user.Id);
var confirmAccountToken = await identityService.GenerateConfirmAccountToken(user);
string callbackUrl = $"{Configuration.GetValue<string>(AppSettingsKeys.ClientAddress)}register/confirm?email={user.Email}&token={confirmAccountToken}";
return(await emailSender.Send(EmailMessages.ActivationAccountEmail(user.Email, user.UserName, callbackUrl))
? new SignUpResponse
{
Token = confirmAccountToken, User = mapper.Map <UserAuthDto>(user)
}
: throw new ServiceException("Account confirmation email sending failed"));
}
throw new AuthException("Error occurred during signing up");
}
public async Task <SendResetPasswordResponse> Handle(SendResetPasswordRequest request,
CancellationToken cancellationToken)
{
if (!await captchaService.VerifyCaptcha(request.CaptchaResponse))
{
throw new CaptchaException();
}
var result = await userTokenGenerator.GenerateResetPasswordToken(request.Login);
if (result == null)
{
return(new SendResetPasswordResponse());
}
var(encryptedToken, encryptedEmail) =
(cryptoService.Encrypt(result.Token), cryptoService.Encrypt(result.Email));
string callbackUrl =
$"{Configuration.GetValue<string>(AppSettingsKeys.ServerAddress)}api/auth/resetPassword/verify?email={encryptedEmail}&token={encryptedToken}";
var emailTemplate =
(await emailTemplateGenerator.FindEmailTemplate(EmailTemplateDictionary.RegisterTemplate))
.ReplaceParameters(new EmailTemplateParameter("{{username}}", result.Username),
new EmailTemplateParameter("{{callbackUrl}}", callbackUrl));
await emailSender.Send(EmailMessages.ActivationAccountEmail(result.Email, emailTemplate));
return(new SendResetPasswordResponse());
}
public async Task <SignUpResponse> Handle(SignUpRequest request, CancellationToken cancellationToken)
{
if (!await captchaService.VerifyCaptcha(request.CaptchaResponse))
{
throw new CaptchaException();
}
if (await authValidationService.UsernameExists(request.Username) ||
await authValidationService.EmailExists(request.Email))
{
throw new DuplicateException("Account already exists");
}
if (await serialService.SerialExists(request.Serial))
{
throw new DuplicateException("Serial already exists");
}
User referrer = default;
if (!string.IsNullOrEmpty(request.Referrer))
{
referrer = await userService.FindUserByUsername(request.Referrer);
}
var response = await authService.SignUp(request.Username, request.Email, request.Password, request.Serial,
referrer == null? 0 : referrer.Id);
var(encryptedToken, encryptedEmail) = (cryptoService.Encrypt(response.TokenCode),
cryptoService.Encrypt(response.User.Email));
//TODO:Change it on ClientAddress
string callbackUrl =
$"{Configuration.GetValue<string>(AppSettingsKeys.ServerAddress)}api/auth/confirm?email={encryptedEmail}&token={encryptedToken}";
var emailTemplate =
(await emailTemplateGenerator.FindEmailTemplate(EmailTemplateDictionary.RegisterTemplate))
.ReplaceParameters(new EmailTemplateParameter("{{username}}", response.User.Username),
new EmailTemplateParameter("{{callbackUrl}}", callbackUrl));
return(await emailSender.Send(EmailMessages.ActivationAccountEmail(response.User.Email, emailTemplate))
? (SignUpResponse) new SignUpResponse
{
TokenCode = encryptedToken, User = mapper.Map <UserAuthDto>(response.User)
}
.LogInformation($"User {request.Username} with email {request.Email} signed up")
: throw new ServiceException("Sending confirmation email failed"));
}
public async Task <SendChangePasswordEmailResponse> Handle(SendChangePasswordEmailRequest request,
CancellationToken cancellationToken)
{
var result = await userTokenGenerator.GenerateChangePasswordToken(request.OldPassword);
var(encryptedToken, encryptedEmail, encryptedPassword) =
(cryptoService.Encrypt(result.Token), cryptoService.Encrypt(result.Email),
cryptoService.Encrypt(request.NewPassword));
string callbackUrl =
$"{Configuration.GetValue<string>(AppSettingsKeys.ServerAddress)}api/account/changePassword?email={encryptedEmail}&token={encryptedToken}&newPassword={encryptedPassword}";
var emailTemplate =
(await emailTemplateGenerator.FindEmailTemplate(EmailTemplateDictionary.RegisterTemplate))
.ReplaceParameters(new EmailTemplateParameter("{{username}}", result.Username),
new EmailTemplateParameter("{{callbackUrl}}", callbackUrl));
await emailSender.Send(EmailMessages.ActivationAccountEmail(result.Email, emailTemplate));
return(new SendChangePasswordEmailResponse());
}
