public async Task<IActionResult> RemoveLogin(RemoveLoginViewModel account)
{
ManageMessageId? message = ManageMessageId.Error;
var user = await GetCurrentUserAsync();
if (user != null)
{
var result = await _userManager.RemoveLoginAsync(user, account.LoginProvider, account.ProviderKey);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent: false);
message = ManageMessageId.RemoveLoginSuccess;
}
}
return RedirectToAction(nameof(ManageLogins), new { Message = message });
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
if (!result.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred removing external login for user with ID '{user.Id}'.");
}
await _signInManager.SignInAsync(user, isPersistent : false);
StatusMessage = "The external login was removed.";
return(RedirectToAction(nameof(ExternalLogins)));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(_localizer["UserNotFound", _userManager.GetUserId(User)]));
}
var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
if (!result.Succeeded)
{
throw new ApplicationException(_localizer["ErrorRemovingExternalLogin", user.Id]);
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = _localizer["ExternalLoginRemoved"];
return(RedirectToAction(nameof(ExternalLogins)));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
{
Users user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
user.IdVk = 0;
IdentityResult result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
if (!result.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred removing external login for user with ID '{user.Id}'.");
}
await _signInManager.SignInAsync(user, isPersistent : false);
StatusMessage = "Аккаунт успешно отвязан";
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
_logger.LogError("Unable to load user with ID '{UserId}'.", _userManager.GetUserId(User));
return(RedirectToAction(nameof(Login)));
}
var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
if (!result.Succeeded)
{
_logger.LogError("Unexpected error occurred adding external login info for user '{UserName}'.", user.UserName);
return(RedirectToAction(nameof(Login)));
}
await _signInManager.SignInAsync(user, isPersistent : false);
//StatusMessage = "The external login was removed.";
return(RedirectToAction(nameof(ExternalLogins)));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
{
ViewData["AlleCategorien"] = _categorieRepository.GetAll().ToList();
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
if (!result.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred removing external login for user with ID '{user.Id}'.");
}
await _signInManager.SignInAsync(user, isPersistent : false);
StatusMessage = "De externe login werd succesvol verwijderd.";
return(RedirectToAction(nameof(ExternalLogins)));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel account)
{
if (!ModelState.IsValid)
{
return(View("/Error"));
}
ManageMessageId?message = ManageMessageId.Error;
var user = await GetCurrentUserAsync();
if (user != null)
{
var result = await _userManager.RemoveLoginAsync(user, account.LoginProvider, account.ProviderKey);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
message = ManageMessageId.RemoveLoginSuccess;
}
}
return(RedirectToAction(nameof(ManageLogins), new { Message = message }));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException(
$"Não é possível carregar o usuário com o ID '{_userManager.GetUserId(User)}'.");
}
var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
if (!result.Succeeded)
{
throw new ApplicationException(
$"Ocorreu um erro inesperado ao remover o login externo do usuário com o ID '{user.Id}'.");
}
await _signInManager.SignInAsync(user, false);
StatusMessage = "O login externo foi removido.";
return(RedirectToAction(nameof(ExternalLogins)));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel account)
{
ViewBag.ManageNavigationKey = "Logins";
var user = await GetCurrentUserAsync();
if (user != null)
{
var result = await _userManager.RemoveLoginAsync(user, account.LoginProvider, account.ProviderKey);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
AddSuccessMessage("The external login was removed.");
}
else
{
AddErrorMessage("An error has occurred.");
}
}
return(RedirectToAction(nameof(ManageLogins)));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel account)
{
ManageMessageId?message = ManageMessageId.Error;
var user = await GetCurrentUserAsync();
if (user == null)
{
return(RedirectToAction(nameof(ManageLogins), new { Message = message }));
}
var result = await _userManager.RemoveLoginAsync(user, account.LoginProvider, account.ProviderKey);
if (!result.Succeeded)
{
return(RedirectToAction(nameof(ManageLogins), new { Message = message }));
}
await _signInManager.SignInAsync(user, isPersistent : false);
message = ManageMessageId.RemoveLoginSuccess;
return(RedirectToAction(nameof(ManageLogins), new { Message = message }));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
{
ViewData["AllCategories"] = _categoryRepository.GetAll().ToList();
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Không thể lấy thông tin người dùng '{_userManager.GetUserId(User)}'.");
}
var result = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
if (!result.Succeeded)
{
throw new ApplicationException(
$"Xảy ra lỗi không mong muốn khi xóa đăng nhập bên ngoài cho người dùng '{user.Id}'.");
}
await _signInManager.SignInAsync(user, isPersistent : false);
StatusMessage = "Đăng nhập bên ngoài đã được xóa thành công.";
return(RedirectToAction(nameof(ExternalLogins)));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel account)
{
var user = await GetCurrentUserAsync();
if (user != null)
{
var result = await _userManager.RemoveLoginAsync(user, account.LoginProvider, account.ProviderKey);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
TempData.Put <ManageMessage>(nameof(ManageMessage), new ManageMessage {
AlertType = SiteAlertTagHelper.AlertType.Success, MessageId = MessageId.RemoveLoginSuccess
});
return(JsonAjaxRedirectForModal(Url.Action(nameof(Index), nameof(Manage), new { Organization = _siteContext.UrlSegmentValue })));
}
}
TempData.Put <ManageMessage>(nameof(ManageMessage), new ManageMessage {
AlertType = SiteAlertTagHelper.AlertType.Danger, MessageId = MessageId.RemoveLoginFailure
});
return(JsonAjaxRedirectForModal(Url.Action(nameof(Index), nameof(Manage), new { Organization = _siteContext.UrlSegmentValue })));
}
public async Task <IActionResult> RemoveLogin(RemoveLoginViewModel model)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
await _signInManager.SignOutAsync();
_notice.AddErrors(ModelState);
return(View(model));
}
// If user is removing last/only login or
// if user is trying to remove thier only confirmed email,
// then delete account.
// This prevents users from ever "unconfirming" themselves.
// Why: there should always be atleast 1 other confirmed
// email to fallback to as the confirmed email when deleting the other
// This is also checked for in the view.
var userLogins = await _userManager.GetLoginsAsync(user);
if (userLogins.Count == 1 ||
(userLogins.Where(l => l.LoginProvider == "Email").Count() == 1 && model.LoginProvider == "Email"))
{
//await _events.AddEvent(AuthEventType.Delete,
// JsonConvert.SerializeObject(model), user);
var deleteResult = await _userManager.DeleteAsync(user);
if (deleteResult.Succeeded)
{
await _signInManager.SignOutAsync();
return(_notice.Success(this, "Your account has been successfully deleted.")); // TODO: keep account for n days feature
}
else
{
_notice.AddErrors(ModelState);
return(View(model));
}
}
// If user trying to remove their primary email then find another one.
if (model.LoginProvider == "Email" && (user.NormalizedEmail == _userManager.NormalizeKey(model.ProviderKey)))
{
var fallbackPrimaryEmailLogin = userLogins.FirstOrDefault(l => l.LoginProvider == "Email" && l.ProviderKey != model.ProviderKey);
if (fallbackPrimaryEmailLogin == null) // This should never happen thanks to the check above.
{
_notice.AddErrors(ModelState);
return(View(model));
}
user.Email = fallbackPrimaryEmailLogin.ProviderKey;
var updateResult = await _userManager.UpdateAsync(user);
if (!updateResult.Succeeded)
{
_notice.AddErrors(ModelState);
return(View(model));
}
}
await _events.AddEvent(AuthEventType.RemoveLogin,
JsonConvert.SerializeObject(model), user);
var removeLoginResult = await _userManager.RemoveLoginAsync(user, model.LoginProvider, model.ProviderKey);
if (!removeLoginResult.Succeeded)
{
_notice.AddErrors(ModelState);
return(View(model));
}
await _userManager.UpdateSecurityStampAsync(user);
await _signInManager.RefreshSignInAsync(user);
return(_notice.Success(this, "Login successfully removed."));
}
public IActionResult RemoveLogin(RemoveLoginViewModel account)
{
ManageMessageId?message = ManageMessageId.Error;
return(RedirectToAction(nameof(ManageLogins), new { Message = message }));
}
public async void RemoveLogin(RemoveLoginViewModel model)
{
/* change return type to Task<IActionResult> after method definition*/
}
