public async Task <IActionResult> ConfirmEmail([FromBody] EmailConfirmationDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var account = await _authRepo.GetAccount(model.UserId);
if (account == null)
{
return(NotFound());
}
var result = await _userManager.ConfirmEmailAsync(account, model.Code);
if (result.Succeeded)
{
var loginResult = await loginAndCreateToken(account);
return(Ok(loginResult));
}
return(BadRequest("Eメール認証に失敗しました"));
}
public async Task <IActionResult> ConfirmEmailAsync(EmailConfirmationDto email)
{
var user = await _userManager.FindByIdAsync(email.UserId)
.ConfigureAwait(false);
if (user is null)
{
return(NotFound("User was not found."));
}
if (user.EmailConfirmed)
{
return(BadRequest("Email is already confirmed."));
}
var result = await _userManager.ConfirmEmailAsync(user, email.Token)
.ConfigureAwait(false);
if (!result.Succeeded)
{
return(Problem("Email cannot be confirmed."));
}
return(NoContent());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new User {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var addToRole = await _userManager.AddToRoleAsync(user, Roles.Customer);
if (addToRole.Succeeded)
{
_logger.LogInformation($"User {0} added to role {1}.", user.Id, Roles.Customer);
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
/*await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
* $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");*/
var model = new EmailConfirmationDto(user.Name ?? user.UserName, callbackUrl);
const string view = "/Views/Emails/ConfirmAccountEmail";
var body = await _render.RenderViewToStringAsync($"{view}Html.cshtml", model);
QueueEmailMessage queueEmail = new QueueEmailMessage(Input.Email, "", body, "Reset Password");
await _cloudStorageService.SendMessage(queueEmail);
//await _emailSender.SendEmailAsync(Input.Email, "Confirm your email", body);
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task ConfirmEmailAsync(EmailConfirmationDto emailConfirmationDto)
{
using (var response = await _httpClient.PostAsJsonAsync($"api/users/{emailConfirmationDto.Id}/confirm-email", emailConfirmationDto))
{
if (response.IsSuccessStatusCode)
{
return;
}
throw await ApiException.FromHttpResponse(response);
}
}
public async Task <IActionResult> ConfirmEmail([FromBody] EmailConfirmationDto emailConfirmation)
{
try
{
await _authService.ConfirmEmail(emailConfirmation.Email, emailConfirmation.EncodedToken);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task ConfirmEmail(EmailConfirmationDto confirmation, Func <object, string> emailConfirmationUrlBuilder)
{
if (string.IsNullOrWhiteSpace(confirmation.UserEmail))
{
throw new BadRequestException("L'adresse email fourni est invalide");
}
var user = await userManager.FindByEmailAsync(confirmation.UserEmail);
if (user is null)
{
throw new NotFoundException("L'adresse email fourni ne correspond à aucun utilisateur!");
}
var result = await userManager.ConfirmEmailAsync(user, confirmation.ConfirmationToken);
if (!result.Succeeded)
{
var didTokenExpire = result.Errors
.Select(e => e.Code)
.Contains(errorDescriber.InvalidToken().Code);
if (didTokenExpire)
{
var confirmationToken = await userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationUrl = emailConfirmationUrlBuilder(new EmailConfirmationDto
{
ConfirmationToken = confirmationToken,
UserEmail = user.Email,
});
try
{
await emailService.ReSendEmailConfirmationMail(user.Email, confirmationUrl);
}
catch (System.Exception)
{
throw new ApplicationException("Le serveur n'a pas pu envoyer le lien de confirmation à l'e-mail fourni. Veuillez réessayer plus tard ou contacter le support.");
}
}
else
{
throw new ApplicationException("L'adresse email n'a pas pu être confirmé!");
}
}
}
public async Task <IActionResult> ConfirmEmail([FromQuery] EmailConfirmationDto confirmation)
{
try
{
await accountService.ConfirmEmail(confirmation, p => Url.Action(
"ConfirmEmail",
"User",
p,
Request.Scheme
));
}
catch (System.Exception)
{
return(BadRequest());
}
return(Redirect("/app/SignIn/"));
}
public async Task <IActionResult> ConfirmEmail([FromBody] EmailConfirmationDto model)
{
// Check model state
if (!ModelState.IsValid)
{
return(BadRequest(new RequestMessageResponse()
{
Success = false, Message = "Invalid data model"
}));
}
// Get user
var user = await _userService.GetUserById(model.UserId);
if (user == null)
{
return(BadRequest(new RequestMessageResponse()
{
Success = false, Message = "Invalid user"
}));
}
if (await _userManager.IsEmailConfirmedAsync(user))
{
return(BadRequest(new RequestMessageResponse()
{
Success = false, Message = "Email already confirmed"
}));
}
// Activate email
var result = await _userManager.ConfirmEmailAsync(user, model.Token);
if (result.Succeeded)
{
return(new OkObjectResult(new RequestMessageResponse()
{
Success = true, Message = "Email succesfully activated"
}));
}
// Email activation failed
return(BadRequest(new RequestMessageResponse()
{
Success = false, Message = result.Errors.FirstOrDefault()?.Description
}));
}
public async Task <IActionResult> OnPostSendVerificationEmailAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(_localizer["USER_NOTFOUND", _userManager.GetUserId(User)]));
//return NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var userId = await _userManager.GetUserIdAsync(user);
var email = await _userManager.GetEmailAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = userId, code = code },
protocol: Request.Scheme);
/*await _emailSender.SendEmailAsync(email, "Confirm your email",
* $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");*/
var model = new EmailConfirmationDto(user.Name ?? user.UserName, callbackUrl);
const string view = "/Views/Emails/ConfirmAccountEmail";
var body = await _render.RenderViewToStringAsync($"{view}Html.cshtml", model);
QueueEmailMessage queueEmail = new QueueEmailMessage(Input.Email, "", body, "Reset Password");
await _cloudStorageService.SendMessage(queueEmail);
//await _emailSender.SendEmailAsync(Input.Email, "Reset Password", body);
//StatusMessage = "Verification email sent. Please check your email.";
StatusMessage = _localizer["STATUS_UPDATE_PROFILE_EMAIL_SEND"];
return(RedirectToPage());
}
public async Task <IActionResult> ConfirmEmailGet([FromQuery] EmailConfirmationDto emailConfirmationDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
await _accountClient.ConfirmEmailAsync(emailConfirmationDto);
return(RedirectToAction(nameof(ConfirmEmailConfirmationGet)));
}
catch (ApiException)
{
return(RedirectToAction(nameof(ConfirmEmailFailureGet)));
}
}
public IActionResult Get([FromRoute] string id)
{
if (string.IsNullOrWhiteSpace(id))
{
return(NoContent());
}
else
{
EmailConfirmationDto emailObtained = _userBussinesLogic.GetEmailConfirmationById(id);
if (emailObtained != null)
{
UserDto user = new UserDto()
{
Email = emailObtained.Email,
Role = (Core.Entities.RoleUserEnum)emailObtained.RoleId
};
_userBussinesLogic.ConsumeEmailConfirmation(emailObtained.Email, emailObtained.RoleId, id);
var userFound = _userBussinesLogic.GetExistingFullInfoByUserId(user);
if (userFound != null)
{
return(Ok(userFound));
}
else
{
return(new GeneralError(404)
{
ErrorMessage = "The user cannot be obtained."
});
}
}
else
{
return(new GeneralError(403)
{
ErrorMessage = "The email cannot be obtained."
});
}
}
}
public async Task <IActionResult> OnPostAsync()
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(Input.Email);
if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
{
// Don't reveal that the user does not exist or is not confirmed
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
// For more information on how to enable account confirmation and password reset please
// visit https://go.microsoft.com/fwlink/?LinkID=532713
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ResetPassword",
pageHandler: null,
values: new { code },
protocol: Request.Scheme);
/*await _emailSender.SendEmailAsync(Input.Email, "Reset Password",
* $"Please reset your password by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");*/
var model = new EmailConfirmationDto(user.Name ?? user.UserName, HtmlEncoder.Default.Encode(callbackUrl));
const string view = "/Views/Emails/ForgotPasswordEmail";
var body = await _render.RenderViewToStringAsync($"{view}Html.cshtml", model);
QueueEmailMessage queueEmail = new QueueEmailMessage(Input.Email, "", body, "Reset Password");
await _cloudStorageService.SendMessage(queueEmail);
//await _emailSender.SendEmailAsync(Input.Email, "Reset Password", body);
return(RedirectToPage("./ForgotPasswordConfirmation"));
}
return(Page());
}
