public async Task <IActionResult> ExternalLoginAsync(ExternalLoginInputModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ResultData <RetrospectorUser> result = await _accountsService.LogInUserAsync(model.Email, UserRoleName);
if (!result.Success)
{
return(BadRequest(new { message = result.Message }));
}
ResultData <IList <string> > rolesResult = await _accountsService.GetUserRolesAsync(result.Data);
if (!rolesResult.Success)
{
return(BadRequest(new { message = rolesResult.Message }));
}
string role = rolesResult.Data[0];
UserModel viewModel = new UserModel
{
Email = result.Data.Email,
Id = result.Data.Id,
Role = role
};
return(Ok(viewModel));
}
public async Task <(SignInResult, IExternalLoginModel)> SignInWithExternalProvider(string remoteError = null)
{
if (remoteError != null)
{
return(
SignInResult.Failed,
new ExternalLoginDto($"Error from external provider: {remoteError}"));
}
var info = await signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(
SignInResult.Failed,
new ExternalLoginDto("Error loading external login information."));
}
// Sign in the user with this external login provider if the user already has a login.
var result = await signInManager.ExternalLoginSignInAsync(
info.LoginProvider,
info.ProviderKey,
isPersistent : false,
bypassTwoFactor : true);
if (result.Succeeded)
{
logger.LogInformation(
"{Name} logged in with {LoginProvider} provider.",
info.Principal.Identity.Name,
info.LoginProvider);
return(result, null);
}
if (result.IsLockedOut)
{
return(result, null);
}
// If the user does not have an account, then ask the user to create an account.
ExternalLoginInputModel input = null;
if (info.Principal.HasClaim(c => c.Type == ClaimTypes.Email))
{
input = new ExternalLoginInputModel
{
Email = info.Principal.FindFirstValue(ClaimTypes.Email)
};
}
return(
SignInResult.NotAllowed,
new ExternalLoginDto {
LoginProvider = info.LoginProvider, Input = input
});
}
public async Task <IActionResult> ExternalFacebookLoginCallback(string returnUrl = null, string remoteError = null)
{
returnUrl ??= this.Url.Content("~/");
if (remoteError != null)
{
this.ErrorMessage = $"Error from external provider: {remoteError}";
return(this.RedirectToPage("/Login", new { ReturnUrl = returnUrl }));
}
var info = await this.signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
this.ErrorMessage = "Error loading external login information.";
return(this.RedirectToPage("/Login", new { ReturnUrl = returnUrl }));
}
var result = await this.signInManager
.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent : false, bypassTwoFactor : true);
if (result.Succeeded)
{
this.logger.LogInformation("{Name} logged in with {LoginProvider} provider.", info.Principal.Identity.Name, info.LoginProvider);
return(this.LocalRedirect(returnUrl));
}
if (result.IsLockedOut)
{
return(this.RedirectToPage("/Lockout"));
}
else
{
this.ReturnUrl = returnUrl;
this.LoginProvider = info.LoginProvider;
if (info.Principal.HasClaim(c => c.Type == ClaimTypes.Email))
{
var inputModel = new ExternalLoginInputModel
{
Email = info.Principal.FindFirstValue(ClaimTypes.Email),
FullName = info.Principal.FindFirstValue(ClaimTypes.Name),
LoginProvider = this.LoginProvider,
ReturnUrl = this.ReturnUrl,
};
return(this.View(inputModel));
}
return(this.RedirectToAction(this.ReturnUrl));
}
}
public async Task <IActionResult> Confirmation(ExternalLoginInputModel inputModel, string returnUrl = null)
{
returnUrl = returnUrl ?? this.Url.Content("~/");
var info = await this.signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
this.ErrorMessage = "Error loading external login information during confirmation.";
return(this.RedirectToPage("/Login", new { ReturnUrl = returnUrl }));
}
if (this.ModelState.IsValid)
{
Enum.TryParse <Gender>(inputModel.SelectedGender, out Gender gender);
var user = new CinemaWorldUser
{
UserName = inputModel.Username,
Email = inputModel.Email,
Gender = gender,
FullName = inputModel.FullName,
};
var result = await this.userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await this.userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
this.logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
await this.userManager.AddToRoleAsync(user, GlobalConstants.UserRoleName);
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (this.userManager.Options.SignIn.RequireConfirmedAccount)
{
return(this.RedirectToPage("/RegisterConfirmation", new { Email = inputModel.Email }));
}
await this.signInManager.SignInAsync(user, isPersistent : false);
var userId = await this.userManager.GetUserIdAsync(user);
var code = await this.userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = this.Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: this.Request.Scheme);
await this.emailSender.SendEmailAsync(
inputModel.Email,
"Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
return(this.LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
this.ModelState.AddModelError(string.Empty, error.Description);
}
}
this.LoginProvider = info.LoginProvider;
this.ReturnUrl = returnUrl;
return(this.View("ExternalFacebookLoginCallback", inputModel));
}
