public async Task <IActionResult> ExternalRegistration(ExternalRegisterViewModel externalRegisterViewModel)
{
if (!ModelState.IsValid)
{
return(View(externalRegisterViewModel));
}
var userModel = _mapper.Map <UserDTO>(externalRegisterViewModel);
try
{
await _accountService.ExternalRegisterAsync(userModel);
var confirmToken = await _accountService.GenerateEmailConfirmationAsync(userModel.Email);
var callbackUrl = Url.Action("ConfirmEmail", "Account",
new { userModel.Email, confirmToken, externalRegisterViewModel.ReturnUrl }, HttpContext.Request.Scheme);
await _emailService.SendEmailAsync(userModel.Email, "Confirm your action",
$"Для подтверждения привязки стороннего сервиса к учетной записи {userModel.Email} - перейдите по <a href='{callbackUrl}'>ссылке</a>");
return(View("Notification", "Check your email"));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(View(externalRegisterViewModel));
}
}
public async Task <ActionResult> ExternalLoginCallback(string returnUrl)
{
var loginInfo = Request.GetOwinContext().Authentication.GetExternalLoginInfo();
ExternalRegisterViewModel exrvm = new ExternalRegisterViewModel();
if (loginInfo == null)
{
return(RedirectToAction("Login"));
}
UserLoginInfo lg = loginInfo == null ? null : new UserLoginInfo(loginInfo.Login.LoginProvider, loginInfo.Login.ProviderKey);
if (lg != null)
{
var user = await userManager.FindAsync(lg);
if (user == null)
{
ViewBag.LoginProvider = loginInfo.Login.LoginProvider;
if (loginInfo.Login.LoginProvider == "Google")
{
var Email = loginInfo.ExternalIdentity.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Email).Value;
var FirstName = loginInfo.ExternalIdentity.Claims.FirstOrDefault(c => c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname").Value;
var LastName = loginInfo.ExternalIdentity.Claims.FirstOrDefault(c => c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname").Value;
exrvm.UserName = Email;
exrvm.FirstName = FirstName;
exrvm.LastName = LastName;
exrvm.Picture = string.Empty;
}
else if (loginInfo.Login.LoginProvider == "Facebook")
{
var identity = Request.GetOwinContext().Authentication.GetExternalIdentity(DefaultAuthenticationTypes.ExternalCookie);
var AccessToken = identity.FindFirstValue("FacebookAccessToken");
var FbClient = new FacebookClient(AccessToken);
dynamic Email = FbClient.Get("/me?fields=email");
dynamic FirstName = FbClient.Get("/me?fields=first_name");
dynamic LastName = FbClient.Get("/me?fields=last_name");
dynamic Picture = FbClient.Get("/me?fields=picture");
string picture = Picture.picture.data.url;
string firstname = FirstName.first_name;
string lastname = LastName.last_name;
exrvm.UserName = Email.email;
exrvm.FirstName = firstname;
exrvm.LastName = lastname;
exrvm.Picture = picture;
}
}
else
{
var identity = await userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ExternalCookie);
Request.GetOwinContext().Authentication.SignIn(identity);
}
}
//RedirectToAction("Index","Admin");
return(View("ExternalRegister", exrvm));
}
public async Task <IActionResult> ExternalRegister(ExternalRegisterViewModel registerViewModel)
{
if (ModelState.IsValid)
{
ExternalLoginInfo info = await _signInManager.GetExternalLoginInfoAsync();
var user = new ApplicationUser
{
Email = registerViewModel.Email,
UserName = registerViewModel.Email,
FirstName = registerViewModel.FirstName,
LastName = registerViewModel.LastName,
PhoneNumber = registerViewModel.PhoneNumber
};
IdentityResult identityResult = await _userManager.CreateAsync(user);
if (identityResult.Succeeded)
{
await AddUserToUsersRoleAsync(user.Email);
identityResult = await _userManager.AddLoginAsync(user, info);
if (identityResult.Succeeded)
{
await _signInManager.SignInAsync(user, true);
//log success
return(LocalRedirect(registerViewModel.ReturnUrl ?? "/"));
}
}
}
return(View(registerViewModel));
}
public async Task <IActionResult> ExternalLoginCallback(string returnUrl = null)
{
var externalPrincipal = await HttpContext.Authentication.AuthenticateAsync("ExternalTemp");
var externalId = externalPrincipal.FindFirst(ClaimTypes.NameIdentifier).Value;
var existingUser = await _userManager.FindByIdAsync(externalId);
if (existingUser == null)
{
var registerViewModel = new ExternalRegisterViewModel()
{
Email = externalPrincipal.FindFirst(ClaimTypes.Email).Value,
FirstName = externalPrincipal.FindFirst(ClaimTypes.GivenName).Value,
LastName = externalPrincipal.FindFirst(ClaimTypes.Surname).Value,
Country = externalPrincipal.FindFirst(ClaimTypes.Country)?.Value,
ExternalLoginId = externalId
};
ViewBag.PaymentClientToken = _paymentService.GetClientToken();
return(View("RegisterExternal", registerViewModel));
}
await _signInManager.SignInAsync(existingUser, true);
await HttpContext.Authentication.SignOutAsync("ExternalTemp");
return(Redirect("/"));
}
public async Task <IActionResult> ExternalRegister(ExternalRegisterViewModel vm)
{
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(RedirectToAction("Login"));
}
var user = new IdentityUser(vm.Username);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
return(View(vm));
}
result = await _userManager.AddLoginAsync(user, info);
if (!result.Succeeded)
{
return(View(vm));
}
await _signInManager.SignInAsync(user, false);
return(Redirect(vm.ReturnUrl));
}
public async Task <IActionResult> ExternalRegister(ExternalRegisterViewModel vm)
{
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(RedirectToAction("Login"));
}
var user = new SPUser {
UserName = vm.Username
};
if (!(await _userManager.CreateAsync(user)).Succeeded)
{
return(View(vm));
}
await _userManager.AddClaimAsync(user, new Claim(JwtClaimTypes.Role, IdentityData.Student));
if (!(await _userManager.AddLoginAsync(user, info)).Succeeded)
{
return(View(vm));
}
await _signInManager.SignInAsync(user, false);
return(Redirect(vm.ReturnUrl));
}
public async Task <IActionResult> ExternalRegister(ExternalRegisterViewModel vm)
{
var info = await signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(Redirect(urls.LoginPage));
}
var user = new IdentityUser(vm.Username)
{
Id = Guid.NewGuid().ToString(),
Email = info.Principal.Claims.First(x => x.Type == ClaimTypes.Email).Value,
EmailConfirmed = true,
};
var registerResult = await userManager.CreateAsync(user);
if (!registerResult.Succeeded)
{
return(View(new ExternalRegisterViewModel
{
ReturnUrl = vm.ReturnUrl,
Username = vm.Username,
Errors = Strings.Join(registerResult.Errors.Select(x => x.Description).ToArray()),
}));
}
var loginResult = await userManager.AddLoginAsync(user, info);
if (!loginResult.Succeeded)
{
return(View(new ExternalRegisterViewModel
{
ReturnUrl = vm.ReturnUrl,
Username = vm.Username,
Errors = Strings.Join(loginResult.Errors.Select(x => x.Description).ToArray()),
}));
}
eventBus.Publish(new NewUserEvent
{
Username = vm.Username,
Id = user.Id,
}, nameof(NewUserEvent));
await userManager.AddClaimAsync(user, new Claim("user.id", user.Id));
await signInManager.SignInAsync(user, true);
return(Redirect(vm.ReturnUrl ?? urls.DefaultRedirect));
}
public async Task <ActionResult> ExternalLoginRegister(ExternalRegisterViewModel evm)
{
var loginInfo = Request.GetOwinContext().Authentication.GetExternalLoginInfo();
if (ModelState.IsValid)
{
if (loginInfo == null)
{
return(View("ExternalLoginFailure"));
}
var user = new User
{
Email = evm.UserName,
UserName = evm.UserName
};
string role = "User";
var result = await userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await userManager.AddLoginAsync(user.Id, loginInfo.Login);
if (result.Succeeded)
{
var identity = await userManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ExternalCookie);
Request.GetOwinContext().Authentication.SignIn(identity);
return(RedirectToAction("Index", "Admin"));
}
}
if (result.Errors.Any())
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
return(View("ExternalRegister", evm));
}
public async Task <IActionResult> RegisterExternal(ExternalRegisterViewModel model, string payment_method_nonce)
{
if (ModelState.IsValid)
{
var externalPrincipal = await HttpContext.Authentication.AuthenticateAsync("ExternalTemp");
var user = new IdentityUser
{
UserName = model.Email,
Email = model.Email,
Id = model.ExternalLoginId
};
var result = await _userManager.CreateAsync(user);
var consultant = new Consultant()
{
UserId = user.Id,
FirstName = model.FirstName,
LastName = model.LastName,
EmailAddress = user.Email,
Country = model.Country,
ConsultantId = model.ConsultantId,
ExternalLoginId = model.ExternalLoginId
};
_userService.ConfirmRegistration(consultant);
_userService.SubscribeNewUser(consultant, payment_method_nonce);
var claimsIdentity = new ClaimsIdentity();
claimsIdentity.AddClaim(new Claim(ClaimTypes.NameIdentifier, model.ExternalLoginId));
claimsIdentity.AddClaim(new Claim(ClaimTypes.GivenName, model.FirstName));
claimsIdentity.AddClaim(new Claim(ClaimTypes.Surname, model.LastName));
claimsIdentity.AddClaim(new Claim(ClaimTypes.Email, model.Email));
await _signInManager.SignInAsync(user, true);
// await HttpContext.Authentication.SignInAsync("Cookies", new ClaimsPrincipal(claimsIdentity));
await HttpContext.Authentication.SignOutAsync("ExternalTemp");
}
return(Redirect("/"));
}
private ExternalRegisterViewModel ExternalRegisterClaims(ExternalLoginInfo info, string returnUrl)
{
var email = info.Principal.FindFirst(ClaimTypes.Email).Value;
var firstName = info.Principal.FindFirst(ClaimTypes.GivenName).Value;
var lastName = info.Principal.FindFirst(ClaimTypes.Surname).Value;
if (email != null)
{
var externalRegister = new ExternalRegisterViewModel
{
Email = email,
FirstName = firstName,
LastName = lastName,
ReturnUrl = returnUrl
};
return(externalRegister);
}
return(new ExternalRegisterViewModel());
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalRegisterViewModel model, int n)
{
if (ModelState.IsValid)
{
// Register
IdentityResult result = await m_userManager.ExternalRegister(model.DisplayName, model.Email, model.Provider);
// Checking result
if (result.Succeeded)
{
// Find user
var user = await m_userManager.GetExternalUser(model.Email, model.Provider);
// login
await this.SignInAsync(user, false);
// create exp
//Add registed Successfully exp reward for user
await m_expService.AddExpForRegisterAsync(user.Id);
//Init currency amount
await m_currencyUserService.CreateAsync(EntityFactory.CreateCurrency_UserObject(user.Id, Constraint.CurrencySystem.DIAMOND));
await m_currencyUserService.CreateAsync(EntityFactory.CreateCurrency_UserObject(user.Id, Constraint.CurrencySystem.STARFISH));
await m_currencyUserService.CreateAsync(EntityFactory.CreateCurrency_UserObject(user.Id, Constraint.CurrencySystem.HEART));
// success
// redirect to galasy gate
return(RedirectToAction("Index", "Home", new { area = "galaxygate" }));
}
else // failure
{
ViewBag.ErrorMessage = result.Errors.First();
return(View("Error"));
}
}
return(View());
}
public async Task <ActionResult> ExternalLoginCallback()
{
// get login info
var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
// if notfound info, return index
if (loginInfo == null)
{
return(RedirectToAction("Index", "Home"));
}
else
{
// Sign in the user with this external login provider if the user already has a login
var user = await m_userManager.GetExternalUser(loginInfo.Email, loginInfo.Login.LoginProvider);
if (user != null)
{
// login
await this.SignInAsync(user, false);
// redirect to galaxy-gate
return(RedirectToAction("Index", "Home", new { area = "galaxygate" }));
}
else
{
// If the user does not have an account, then prompt the user to create an account
// Basic info based on email and username in social networks
// Get login info
ExternalRegisterViewModel model =
new ExternalRegisterViewModel(loginInfo.ExternalIdentity.Name, // Default display name
loginInfo.Email, // External email address
loginInfo.Login.LoginProvider); // Login provider (facebook, google,...)
// Return to confirm page
return(RedirectToAction("ExternalLoginConfirmation", "Account", model));
}
}
// Create signin manager
}
public async Task <ActionResult> ExternalRegister(ExternalRegisterViewModel model)
{
var userInfo = await _authManager.GetExternalLoginInfoAsync();
if (userInfo == null || !ModelState.IsValid)
{
ModelState.AddModelError("Erro de registro", "Ocorreu um erro ao registrar o novo usuário.");
return(RedirectToAction("Index", "Home"));
}
var user = Mapper.Map <ExternalRegisterViewModel, RocamAppUser>(model);
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
var claim = await _userManager.AddLoginAsync(user.Id, userInfo.Login);
await SendConfirmationEmail(user.Email);
return(RedirectToAction("Overview", "Manage"));
}
ModelState.AddModelError("Erro de registro", "Ocorreu um erro ao registrar o novo usuário.");
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> CommitExternalRegister(ExternalRegisterViewModel ervm)
{
if (ModelState.IsValid)
{
ApplicationUser user = new ApplicationUser()
{
Email = ervm.Email,
NormalizedEmail = ervm.Email.ToLower(),
UserName = ervm.Email,
NormalizedUserName = ervm.Email.ToLower(),
EmailConfirmed = true, // Skip e-mail verification for external logins
FirstName = ervm.FirstName,
LastName = ervm.LastName,
GrillingPreference = ervm.GrillingPreference,
HomeState = ervm.HomeState,
ConcurrencyStamp = Guid.NewGuid().ToString(),
};
// Try to create the new user (with no password)
IdentityResult result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
// Add default claims and member role to the new user
await _userManager.AddClaimsAsync(user, GetDefaultClaimsListForUser(user));
await _userManager.AddToRoleAsync(user, ApplicationRoles.Member);
// Sign the user in and redirect them back to whence they came
await _signInManager.SignInAsync(user, isPersistent : false);
// Try to get the user's external login provider information
var info = await _signInManager.GetExternalLoginInfoAsync();
// Could not get the external login info
if (info is null)
{
return(RedirectToAction(nameof(Login)));
}
// Add the user's external login provider
await _userManager.AddLoginAsync(user, info);
// If the user is an administrator, take them to the product administration
// dashboard; otherwise, take the user to the products landing page
if (await _userManager.IsInRoleAsync(user, ApplicationRoles.Admin))
{
return(RedirectToAction("Index", "Products"));
}
return(RedirectToAction("Index", "Shop"));
}
// Something went wrong. Accumulate all errors into the model state.
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// Something went wrong. Allow the user to try again
return(View(ervm));
}
public ActionResult ExternalLoginConfirmation(ExternalRegisterViewModel model)
{
return(View(model));
}
