public IActionResult ConfirmEmail(ConfirmEmailRequest confirmEmailRequest)
{
var user = _userService.GetByEmail(confirmEmailRequest.Email);
if (user == null)
{
return(emailNotFound());
}
if (!_userService.ConfirmEmail(user, confirmEmailRequest.ConfirmationToken))
{
return(BadRequest(new { message = "Confirmation token not valid" }));
}
return(Ok(new { message = "email confirmed" }));
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmEmailRequest request)
{
try
{
var reqestObject = new AuthorizedRequestObject <ConfirmEmailRequest, ConfirmEmailReply>(request)
{
UserId = User.GetUserId()
};
ConfirmEmailReply reply = await mediator.Send(reqestObject).ConfigureAwait(false);
return(Ok(reply));
}
catch (ArgumentNullException e)
{
return(BadRequest(e.Message));
}
}
protected virtual IActionResult ConfirmEmail(ConfirmEmailRequest confirmEmailRequest)
{
if (confirmEmailRequest == null || confirmEmailRequest.Code == null)
{
return(BadRequest());
}
try
{
var login = AccountServices.ConfirmEmail(confirmEmailRequest.Code);
return(Ok(new { jwt = GenerateToken(login.Email), data = login }));
}
catch (ArgumentException)
{
return(BadRequest(new { error = "Email could not be confirmed." }));
}
}
// GET
public async Task <IActionResult> IndexAsync(ConfirmEmailRequest model, CancellationToken token)
{
if (!ModelState.IsValid)
{
return(Redirect("/"));
}
if (User.Identity.IsAuthenticated)
{
return(Redirect("/"));
}
model.Code = System.Net.WebUtility.UrlDecode(model.Code);
var user = await _userManager.FindByIdAsync(model.Id.ToString());
if (user is null)
{
throw new ApplicationException($"Unable to load user with ID '{model.Id}'.");
}
if (user.PhoneNumberConfirmed)
{
return(RedirectToRoute(RegisterController.Signin));
}
if (user.EmailConfirmed)
{
return(await GoToStepAsync(user, RegistrationStep.RegisterSetPhone, model.ReturnUrl));
}
var result = await _userManager.ConfirmEmailAsync(user, model.Code);
if (!result.Succeeded)
{
_logger.Error($"Error confirming email for user with ID '{model.Id}': {result}, User: {user}");
return(RedirectToRoute(RegisterController.RegisterRouteName,
new
{
//There was an extra step in here
page = RegistrationStep.RegisterSetEmailPassword
}));
}
TempData[HomeController.Referral] = model.Referral;
return(await GoToStepAsync(user,
RegistrationStep.RegisterSetPhone,
model.ReturnUrl));
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmEmailRequest request)
{
var confirmation = await _identityService.ConfirmEmail(request.Email, request.Token);
if (!confirmation.Succeeded)
{
return(BadRequest(new IdentityFailedResponse
{
Errors = confirmation.Errors
}));
}
return(Ok(new IdentitySuccessResponse
{
Message = "Email Confirmed"
}));
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmEmailRequest request)
{
var user = await _userManager.FindByIdAsync(request.UserID);
if (user == null)
{
return(BadRequest());
}
var result = await _userManager.ConfirmEmailAsync(user, request.Code);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> ConfirmEmailAsync([FromBody] ConfirmEmailRequest request)
{
var user = await _userService.FindByIdAsync(request.UserId);
if (user == null)
{
return(BadRequest(ErrorHelper.CreateErrorRespose("Invalid confirmation code.")));
}
var result = await _authService.ConfirmEmailAsync(user, request.Code);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest(ErrorHelper.CreateErrorRespose(result.Errors)));
}
public string _GenerateConfirmLink(string login)
{
var receiverStrings = login.Split('@');
var xmppLogin = receiverStrings[0];
using (var context = new InnostarModelsContext())
{
var repository = new ChatUserRepository(context);
var users = repository._Get(e => e.XmppLogin == xmppLogin).ToList();
if (users.Any())
{
var user = users.FirstOrDefault();
var confirmRepository = new ConfirmEmailRequestRepository(context);
var rnd = new Random();
var requestKey = rnd.Next(99).ToString(CultureInfo.InvariantCulture)
+ Guid.NewGuid().ToString().Replace("-", string.Empty)
+ rnd.Next(99).ToString(CultureInfo.InvariantCulture)
+ Guid.NewGuid().ToString().Replace("-", string.Empty);
//user.Disabled = true;
//repository._Update(user);
//repository._Save();
var request = new ConfirmEmailRequest
{
IsActive = true,
RequestAcceptedTime = DateTime.Now,
RequestKey = requestKey,
User = user
};
confirmRepository._Insert(request);
confirmRepository._Save();
}
}
return(string.Empty);
}
public void ConfirmEmail_Call_FindByIdAsync_ConfirmEmailAsync_Methods()
{
var accountsController = new AccountsController(
_applicationUserManager.Object,
_emailSendingServiceMock.Object,
_inviteServiceMock.Object);
var confirmEmail = new ConfirmEmailRequest
{
Code = "code",
UserId = "userIdId"
};
var confirmResult = IdentityResult.Success;
_applicationUserManager.Setup(um => um.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(_registerUser);
_applicationUserManager.Setup(um => um.ConfirmEmailAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(confirmResult);
var actionResult = accountsController.ConfirmEmail(confirmEmail);
_applicationUserManager.Verify(um => um.FindByIdAsync(It.IsAny <string>()), Times.Once());
_applicationUserManager.Verify(um => um.ConfirmEmailAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Once());
}
public async Task <IHttpActionResult> ConfirmEmail([FromBody] ConfirmEmailRequest confirm)
{
if (confirm == null)
{
return(BadRequest());
}
try
{
confirm.UserId = FromBase64(confirm.UserId);
confirm.Code = FromBase64(confirm.Code);
}
catch (Exception)
{
return(BadRequest());
}
if (await _userManager.FindByIdAsync(confirm.UserId) == null)
{
return(BadRequest());
}
try
{
var result = await _userManager.ConfirmEmailAsync(confirm.UserId, confirm.Code);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
}
catch (Exception)
{
return(InternalServerError());
}
return(Ok());
}
public new IActionResult ConfirmEmail([FromBody] ConfirmEmailRequest confirmEmailRequest)
{
return(base.ConfirmEmail(confirmEmailRequest));
}
public async Task <EmptyResponse> ConfrimEmailAsync([FromBody] ConfirmEmailRequest request)
{
await _authenticationService.ConfirmEmailAsync(request.Token);
return(new EmptyResponse());
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmEmailRequest model)
{
await _userProvider.ConfirmEmailAsync(model.Id, model.Token);
return(Ok());
}
protected virtual IActionResult ConfirmEmail(ConfirmEmailRequest confirmEmailRequest)
{
var loginResponse = UserBusiness.ConfirmEmail(confirmEmailRequest.Code);
return(Ok(new { logged = true, jwt = GenerateToken(loginResponse.Email), data = loginResponse }));
}
public async Task <IActionResult> ConfirmEmail(ConfirmEmailRequest request)
{
var response = await _authRepo.ConfirmEmail(request.Token, request.Email);
return(HandleServiceResponse(response));
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmEmailRequest request)
{
OperationResult result = await accountService.ConfirmEmail(request.UserId, request.Token);
return(ToActionResult(result));
}
public async Task <IActionResult> ConfirmEmail([FromBody] ConfirmEmailRequest request) => await mediator.AuthorizeHandlerActionResult <ConfirmEmailRequest, ConfirmEmailReply>(request, User).ConfigureAwait(false);
public Task <ApiResponse> ConfirmEmailAsync(ConfirmEmailRequest model)
{
throw new System.NotImplementedException();
}
public async Task<IHttpActionResult> ConfirmEmail(ConfirmEmailRequest model)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// Confirm the email address
var result = await UserManager.ConfirmEmailAsync(model.UserId, model.Code);
// Return OK if the account was confirmed successfully
if (result.Succeeded)
{
return Ok();
}
else
{
return BadRequest();
}
}
public async Task <bool> Execute(string code)
{
ConfirmEmailRequest request = null;
string codeHashed = null;
try
{
codeHashed = _codeHashHelper.GenerateHash(code);
DateTime maxDate = DateTime.Now.AddDays(-_daysToExpire);
request = (await _emailConfirmCollection.FindAsync(x => x.Code == codeHashed && x.Status == ConfirmEmailRequestStatus.NotResolved && x.CreateDate > maxDate)).SingleOrDefault();
if (request == null)
{
return(false);
}
var account = (await _accountRepo.FindAsync(x => x.AccountId == request.AccountId)).SingleOrDefault();
if (request.Email != account.Email)
{
await _logger.LogInfoAsync("ConfirmEmailCommand.ConfirmEmail", "Request email and account email are different", new
{
RequestEmail = request.Email,
AccountEmail = account.Email
});
return(false);
}
if (account.EmailStatus == EmailStatus.Confirmed)
{
return(false);
}
//update account and save
_accountRepo.UpdateOne(x => x.AccountId == account.AccountId, Builders <Account> .Update.Set(x => x.EmailStatus, EmailStatus.Confirmed));
//update request and save
var updDef = Builders <ConfirmEmailRequest> .Update.Set(x => x.Status, ConfirmEmailRequestStatus.Resolved)
.Set(x => x.ResolveDate, DateTime.Now);
await _emailConfirmCollection.UpdateOneAsync(x => x.Id == request.Id, updDef);
//log and return
await _logger.LogEventAsync("ConfirmEmailCommand.ConfirmEmail", "Successfully confirmed", new
{
CodeHashed = codeHashed,
ConfirmEmailRequest = request
});
return(true);
}
catch (Exception ex)
{
await _logger.LogErrorAsync("ConfirmEmailCommand.ConfirmEmail", "Exception occurred", new
{
Exception = ex,
CodeHashed = codeHashed,
ConfirmEmailRequest = request
});
throw;
}
}
public async Task <ActionResult> SendConfirmEmail([FromBody] ConfirmEmailRequest request)
{
await _authenticationService.SendConfirmEmailAsync(request);
return(Ok());
}
