public async Task <IActionResult> AddRemoveClaims(UserClaimsViewModel userClaimsViewModel)
{
ApplicationUser applicationUser = await userManager.FindByIdAsync(userClaimsViewModel.UserId);
if (applicationUser == null)
{
ViewBag.Message = $"The user with the id:{userClaimsViewModel.UserId} is not available.";
return(View("PageNotFound"));
}
else
{
var userClaims = await userManager.GetClaimsAsync(applicationUser);
var result = await userManager.RemoveClaimsAsync(applicationUser, ClaimsStore.AllClaims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user claims");
return(View(userClaimsViewModel));
}
result = await userManager.AddClaimsAsync(applicationUser,
userClaimsViewModel.Claims.Where(c => c.IsSelected).Select(c => new Claim(c.ClaimType, c.ClaimType)));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Error in adding claims to user");
return(View(userClaimsViewModel));
}
return(RedirectToAction("UpdateUser", "Administrator", new { userid = userClaimsViewModel.UserId }));
}
return(View());
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {model.UserId} cannot be found";
return(View("NotFound"));
}
// Get all the user existing claims and delete them
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing claims");
return(View(model));
}
// Add all the claims that are selected on the UI
result = await userManager.AddClaimsAsync(user,
model.Cliams.Where(c => c.IsSelected).Select(c => new Claim(c.ClaimType, c.ClaimType)));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot add selected claims to user");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {model.UserId} cannot be found";
return(View("NotFound"));
}
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError(string.Empty, "Cannot remove user existing claims");
return(View(model));
}
result = await userManager.AddClaimsAsync(user,
model.Claims.Select(c => new Claim(c.ClaimType, c.IsSelected ? "true" : "false")));
if (!result.Succeeded)
{
ModelState.AddModelError(string.Empty, "Cannot add selected claims to user");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"The User with Id = {model.UserId} cannot be found";
return(View("NotFoundError"));
}
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (result.Succeeded)
{
var addClaimResult = await userManager.AddClaimsAsync(user, model.Claims.Where(
c => c.IsSelected).Select(c => new Claim(c.ClaimType, c.ClaimType)));
if (addClaimResult.Succeeded)
{
return(RedirectToAction("EditUser", new { id = model.UserId }));
}
}
ViewBag.ErrorMessage = $" Error Occured While Modiying User Claims for the user with Id = {model.UserId}";
return(View("NotFoundError"));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
return(View("_Error"));
}
var existingUserClaims = await userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel
{
UserId = userId
};
foreach (Claim claim in ClaimsStore.AllClaims)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type
};
if (existingUserClaims.Any(x => x.Type == claim.Type && x.Value == "true"))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel userClaimsViewModel)
{
IdentityUser user = await _userManager.FindByIdAsync(userClaimsViewModel.UserId);
if (user == null)
{
return(NotFound());
}
var claims = await _userManager.GetClaimsAsync(user);
var result = await _userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
TempData[SD.Error] = "Error while removing claims";
return(View(userClaimsViewModel));
}
result = await _userManager.AddClaimsAsync(user,
userClaimsViewModel.Claims.Where(c => c.IsSelected).Select(c => new Claim(c.ClaimType, c.IsSelected.ToString()))
);
if (!result.Succeeded)
{
TempData[SD.Error] = "Error while adding claims";
return(View(userClaimsViewModel));
}
TempData[SD.Success] = "Claims updated successfully";
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
ViewBag.userId = userId;
ApplicationUser user = await userManager.FindByIdAsync(userId);
var existingUserClaims = await userManager.GetClaimsAsync(user);
UserClaimsViewModel model = new UserClaimsViewModel
{
UserId = userId
};
foreach (Claim claim in AdminClaims.AllClaims)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type
};
if (existingUserClaims.Any(c => c.Type == claim.Type && c.Value == "true"))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
// UserManager service GetClaimsAsync method gets all the current claims of the user
var existingUserClaims = await userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel
{
UserId = userId
};
// Loop through each claim we have in our application
foreach (Claim claim in ClaimsStore.AllClaims)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type
};
if (existingUserClaims.Any(c => c.Type == claim.Type))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.Message = $"Korisnik nije pronađen!";
return(View("PageNotFound"));
}
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Nije moguće ukloniti dozvolu za korisnika.");
return(View(model));
}
result = await userManager.AddClaimsAsync(user,
model.Claims.Select(c => new Claim(c.ClaimType, c.IsSelected ? "true" : "false")));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Nije moguće dodeliti dozvolu korisniku.");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"Usuário com Id = {userId} não foi encontrado";
return(View("NotFound"));
}
// o método GetClaimsAsync obtém todas as claims atuais do usuário
var existingUserClaims = await userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel
{
UserId = userId
};
// Percorre cada claim existente
foreach (Claim claim in ClaimsStore.AllClaims)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type
};
// Se o usuário tem uma claim define a propriedade IsSelected
// como true para marcar o checkbox
if (existingUserClaims.Any(c => c.Type == claim.Type))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"Usuário com Id = {model.UserId} não foi encontrado";
return(View("NotFound"));
}
// Obtém todas as claims existentes e as remove
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Não foi possível remover as claims do usuário");
return(View(model));
}
// Adiciona todas as claims que foram selecionadas
result = await userManager.AddClaimsAsync(user, model.Claims
.Where(c => c.IsSelected)
.Select(c => new Claim(c.ClaimType, c.ClaimType)));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Não foi possível adicionar as claims selecionadas");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model, string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"使用者Id:{userId}不存在";
return(View("NotFound"));
}
var claims = await _userManager.GetClaimsAsync(user);
//與其寫一堆if else,倒不如先移除再新增即可
var result = await _userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "無法移除已存在的使用者權力");
return(View(model));
}
result = await _userManager.AddClaimsAsync(user,
model.Claims.Select(c => new Claim(c.ClaimType, c.IsSelected ? "true" : "false")));
if (!result.Succeeded)
{
ModelState.AddModelError("", "無法加入已選擇的使用者權力");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = userId }));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"使用者Id:{userId}不存在";
return(View("NotFound"));
}
var existingUserClaims = await _userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel
{
UserId = userId
};
foreach (var claim in ClaimsStore.AllClaims)
{
var userClaim = new UserClaim
{
ClaimType = claim.Type
};
if (existingUserClaims.Any(c => c.Type.Equals(claim.Type) && c.Value.Equals("true")))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
//// GET: UserClaims
//public async Task<IActionResult> Index()
//{
// //var index = _context.UsersClaims.Include(p => p.UserId);
// //return View(await index.ToListAsync());
// return View(await _context.ApplicationUserClaims.ToListAsync());
//}
public IActionResult Index()
{
List <UserClaimsViewModel> listUserClaims = new List <UserClaimsViewModel>();
var UserClaimsList = (from uc in _context.UserClaims
join us in _context.Users on uc.UserId equals us.Id
select new
{
uc.Id,
uc.UserId,
us.UserName,
uc.ClaimType,
uc.ClaimValue,
}).ToList();
foreach (var item in UserClaimsList)
{
UserClaimsViewModel listClaims = new UserClaimsViewModel
{
UserClaimId = item.Id,
UserId = item.UserId,
UserName = item.UserName,
ClaimType = item.ClaimType,
ClaimValue = item.ClaimValue,
};
listUserClaims.Add(listClaims);
}
return(View(listUserClaims));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with id = {userId} cannot be found";
return(View("NotFound"));
}
var existingUserClaims = await userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel
{
UserId = userId
};
foreach (Claim claim in ClaimStore.AllClaims)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type
};
//if user have any previus claim the make isselected property true so check box show selected
if (existingUserClaims.Any(c => c.Type == claim.Type))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model, string userid)
{
var user = await userManager.FindByIdAsync(userid);
if (user == null)
{
ViewBag.ErrorMessage = $"User with id = {user.Id} was not found";
return(View("NotFound"));
}
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "problem with removing claims");
return(View(model));
}
//if we go with the claimtype = claimvalue
//result = await userManager.AddClaimsAsync(user, model.Claims.Where(x => x.IsSelected).Select(y => new Claim (y.ClaimType , y.ClaimType)));
//claim value is string
result = await userManager.AddClaimsAsync(user, model.Claims.Select(y => new Claim(y.ClaimType, y.IsSelected ? "true" : "false")));
if (!result.Succeeded)
{
ModelState.AddModelError("", "problem with adding claims");
return(View(model));
}
return(RedirectToAction("EditUser", "administration", new { Id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
IdentityUser user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound());
}
var existingUserClaims = await _userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel()
{
UserId = userId
};
foreach (Claim claim in ClaimStore.claimsList)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type
};
if (existingUserClaims.Any(c => c.Type == claim.Type))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"无法找到ID为{model.UserId}的用户";
return(View("NotFound"));
}
// //获取所有用户现有的声明并删除它们
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "无法删除当前用户的声明");
return(View(model));
}
// 添加界面上选中的所有声明信息
result = await userManager.AddClaimsAsync(user,
model.Cliams.Select(c => new Claim(c.ClaimType, c.IsSelected?"true":"false")));
if (!result.Succeeded)
{
ModelState.AddModelError("", "无法向用户添加选定的声明");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.UserId }));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ClaimType,ClaimValue,UserId")] UserClaimsViewModel userclaims)
{
if (id != userclaims.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var _claim = await _context.UserClaims.SingleOrDefaultAsync(m => m.Id == id);
var _claimOld = new Claim(_claim.ClaimType, _claim.ClaimValue);
var _user = await _userManager.FindByIdAsync(userclaims.UserId);
var _claimNew = new Claim(userclaims.ClaimType, userclaims.ClaimValue);
//await _userManager.AddClaimAsync(user, _claim);
await _userManager.ReplaceClaimAsync(_user, _claimOld, _claimNew);
}
catch (DbUpdateConcurrencyException)
{
}
return(RedirectToAction(nameof(Index)));
}
return(View(userclaims));
}
public async Task <IActionResult> ManageClaims(UserClaimsViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with id ={model.UserId} is NOT FOUND";
return(View("notfound"));
}
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "can't remove existing user claims");
return(View(model));
}
result = await userManager.AddClaimsAsync(user, model.Claims.Where(c => c.IsSelected)
.Select(c => new Claim(c.ClaimType, c.ClaimType)));
if (!result.Succeeded)
{
ModelState.AddModelError("", "can't add existing user claims");
return(View(model));
}
return(RedirectToAction("Edituser", new { Id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model, string userId)
{
ApplicationUser user = await userManager.FindByIdAsync(userId);
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing claims");
return(View(model));
}
result = await userManager.AddClaimsAsync(user,
model.Claims.Select(c => new Claim(c.ClaimType, c.IsSelected ? "true":"false")));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot Add Selected Claims to User");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = userId }));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model)
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.Error = $"User with Id {model.UserId} cannot be found.";
return(View("NotFound"));
}
var claims = await _userManager.GetClaimsAsync(user);
var result = await _userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing claims.");
return(View(model));
}
result = await _userManager.AddClaimsAsync(user, model.Claims.Where(x => x.IsSelected).Select(x => new Claim(x.ClaimType, x.IsSelected ? "true" : "false")));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing claims.");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
var existingUserClaims = await userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel
{
UserId = userId
};
foreach (Claim claim in ClaimStore.AllClaims)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type
};
//if the user has the claim,set IsSelected property to true,so the checkbox
//next to the claim is chocked in the UI
if (existingUserClaims.Any(c => c.Type == claim.Type && c.Value == "true"))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.errormessage = $"user with id: {userId} cannot be found";
return(View("notfound"));
}
var userClaims = await userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel
{
userId = userId
};
foreach (Claim claim in ClaimsStore.AllClaims)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type
};
userClaim.IsSelected = userClaims
.Any(usrClaim => usrClaim.Type == claim.Type);
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model, string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
return(View("_Eroor"));
}
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Var olan izinler kaldırılamaz");
return(View(model));
}
var result2 = await userManager.AddClaimsAsync(user, model.Claims.Where(x => x.IsSelected).Select(x => new Claim(x.ClaimType, x.IsSelected ? "true":"false")));
if (!result2.Succeeded)
{
ModelState.AddModelError("", "Seçili izinler tanımlı kullanıcı için eklenemez.");
return(View(model));
}
return(RedirectToAction("EditUser", new { id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaims(UserClaimsViewModel model)
{
var user = await userManager.FindByIdAsync(model.userId);
if (user == null)
{
ViewBag.ErrorMessage = $"user with id: {model.userId} cannot be found";
return(View("NotFound"));
}
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user from claims");
return(View(model));
}
result = await userManager.AddClaimsAsync(user, model.Claims
.Where(claim => claim.IsSelected)
.Select(c => new Claim(c.ClaimType, c.ClaimType)));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot add user to selected claims");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.userId }));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
var existingUserClaims = await userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel()
{
UserId = userId
};
foreach (Claim claim in ClaimsStore.AllClaims)
{
UserClaim userClaim = new UserClaim()
{
ClaimType = claim.Type
};
if (existingUserClaims.Any(c => c.Type == claim.Type && c.Value == "true"))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await this.userManager.FindByIdAsync(userId);
if (user == null)
{
return(this.RedirectToNotFound($"User with Id = {userId} cannot be found"));
}
else
{
var existingUserClaims = await this.userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel
{
UserId = userId
};
foreach (Claim claim in ClaimsStore.AllClaims)
{
// If the user has the claim, set IsSelected property to true, so the CheckBox
// next to the claim is checked on the UI
model.Claims.Add(new UserClaim
{
ClaimType = claim.Type,
IsSelected = existingUserClaims.Any(c => c.Type == claim.Type && c.Value == "true")
});
}
return(this.View(model));
}
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"无法找到ID为{userId}的用户";
return(View("NotFound"));
}
var existingUserClaims = await _userManager.GetClaimsAsync(user);
var model = new UserClaimsViewModel
{
UserId = userId
};
foreach (Claim claim in ClaimsStore.AllClaims)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type
};
if (existingUserClaims.Any(c => c.Type == claim.Type))
{
userClaim.IsSelected = Boolean.Parse(existingUserClaims.Where(c => c.Type == claim.Type).FirstOrDefault().Value);
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(string Id)
{
ViewBag.userId = Id;
var user = await userManager.FindByIdAsync(Id);
if (user == null)
{
ErrorViewModel mo = new ErrorViewModel();
mo.ErrorTitle = $"User id {Id} not found";
mo.ErrorMessage = $"Introduce a new user";
return(View("Error", mo));
}
var existingUserClaims = await userManager.GetClaimsAsync(user);
var model = new List <UserClaimsViewModel>();
foreach (Claim claim in ClaimsStore.AllClaims)
{
UserClaimsViewModel userClaim = new UserClaimsViewModel
{
ClaimType = claim.Type
};
if (existingUserClaims.Any(x => x.Type == claim.Type && x.Value == "true"))
{
userClaim.IsSelected = true;
}
model.Add(userClaim);
}
return(View(model));
}
