public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await _usermanager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound());
}
var ExistingUserClaim = await _usermanager.GetClaimsAsync(user);
var model = new UserClaimViewModel {
UserId = userId
};
foreach (Claim claim in ClaimsStore.AllClaims)
{
UserClaim userClaim = new UserClaim {
ClaimType = claim.Type
};
if (ExistingUserClaim.Any(c => c.Type == claim.Type))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(UserClaimViewModel 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.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 = model.UserId }));
}
public async Task <IActionResult> ManageClaims(string id)
{
List <UserClaimViewModel> claimList = new List <UserClaimViewModel>();
var userClaimViewModel = new UserClaimViewModel
{
user_id = id,
claims = new List <UserClaimViewModel>()
};
var configBlob = AzureService.GetBlob("cdn", "private", null, null, $"user/{id}", WebUIConfig.membershipFile);
var json = await configBlob.DownloadGenericObjectAsync();
var accounts = JsonUtils.GetJToken(Constants.JsontagAccount, json);
if (accounts == null)
{
return(View(userClaimViewModel));
}
var AccountObj = accounts as JArray;
foreach (var account in AccountObj)
{
var name = await AzureService.FindAccountName(account.ToString());
if (name != null)
{
claimList.Add(new UserClaimViewModel()
{
Name = name, GUid = account.ToString()
});
}
}
userClaimViewModel.claims = claimList;
return(View(userClaimViewModel));
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} not found in the System";
return(View("NotFound"));
}
var existingUserClaims = await userManager.GetClaimsAsync(user);
var model = new UserClaimViewModel
{
UserId = user.Id,
};
foreach (Claim claim in ClaimStore.AllClaims)
{
UserClaim uClaim = new UserClaim
{
ClaimType = claim.Type
};
if (existingUserClaims.Any(c => c.Type == claim.Type))
{
uClaim.IsSelected = true;
}
model.Claims.Add(uClaim);
}
return(View(model));
}
public async Task <IActionResult> Edit(UserClaimViewModel vm)
{
if (vm == null)
{
return(BadRequest());
}
if (ModelState.IsValid)
{
var claim = await _dbContext.UserClaims.FindAsync(vm.Id);
if (claim == null)
{
return(BadRequest());
}
claim.ClaimType = vm.ClaimType;
claim.ClaimValue = vm.ClaimValue;
try
{
await _dbContext.SaveChangesAsync();
_logger.LogInformation($"User claim Id {claim.Id} updated by {User?.Identity?.Name}.");
}
catch (DbException ex)
{
_logger.LogError(ex.GetBaseException()?.Message ?? ex.Message);
throw;
}
}
return(RedirectToAction("Edit", "Users", new { id = vm.UserId }));
}
public async Task <IActionResult> Delete(UserClaimViewModel vm)
{
if (vm == null)
{
return(BadRequest());
}
var claim = await _dbContext.UserClaims.FindAsync(vm.Id);
if (claim == null)
{
return(BadRequest());
}
_dbContext.UserClaims.Remove(claim);
try
{
await _dbContext.SaveChangesAsync();
_logger.LogInformation($"User claim Id {vm.Id} removed by {User?.Identity?.Name}.");
}
catch (DbException ex)
{
_logger.LogError(ex.GetBaseException()?.Message ?? ex.Message);
throw;
}
return(RedirectToAction("Edit", "Users", new { id = vm.UserId }));
}
public async Task <IActionResult> Index()
{
List <UserClaimViewModel> listUserClaims = new List <UserClaimViewModel>();
var UserClaimList = await(from uc in _context.UserClaims
join u in _context.Users on uc.UserId equals u.Id
select new
{
uc.Id,
uc.UserId,
uc.ClaimType,
uc.ClaimValue,
u.UserName,
}).ToListAsync();
foreach (var item in UserClaimList)
{
UserClaimViewModel dataList = new UserClaimViewModel
{
Id = item.Id,
UserId = item.UserId,
UserName = item.UserName,
ClaimType = item.ClaimType,
ClaimValue = item.ClaimValue
};
listUserClaims.Add(dataList);
}
return(View(listUserClaims));
}
public async Task <IActionResult> ManageUserClaims(UserClaimViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {model.UserId} found in the System";
return(View("NotFound"));
}
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot Remove user Claims");
}
result = await userManager
.AddClaimsAsync(user, model.Claims.Where(c => c.IsSelected).Select(c => new Claim(c.ClaimType, c.ClaimType)));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot Add Selected user Claims");
}
return(RedirectToAction("EditUser", new { id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaim(UserClaimViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User id={model.UserId} is not found";
return(View("NotFound"));
}
var claim = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claim);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Can not remove user's Existing Claims");
return(View(model));
}
//result = await userManager.AddClaimsAsync(user, model.Claims.Where(c => c.IsSelected)
// .Select(d => new Claim(d.ClaimType,d.ClaimType)));
////Boolean type access claim
result = await userManager.AddClaimsAsync(user, model.Claims.Select(d => new Claim(d.ClaimType, d.IsSelected?"true":"false")));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Can not add selected Claims to user");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.UserId }));
}
public UserClaimItemModel()
: base()
{
UserClaim = new UserClaimViewModel();
OnConstructor();
}
public async Task <IActionResult> ManageUserClaim(UserClaimViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id: {model.UserId} cannot be found!";
return(View("Error"));
}
var claims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError(string.Empty, "Cannot remove existing claims in the user!");
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(string.Empty, "Cannot add new claims to the user!");
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 = $"Role with Id = {userId} cannot be found";
return(View("NotFound"));
}
var existingClaims = await _userManager.GetClaimsAsync(user);
UserClaimViewModel model = new UserClaimViewModel()
{
UserId = userId
};
foreach (var claim in ClaimRepo.AllClaims)
{
UserClaim userClaim = new UserClaim()
{
ClaimType = claim.Type
};
//If the user has the claim, set is selected property to true, so the checkbox
//next to the claim is checked on the UI aka UserInterface...lol
if (existingClaims.Any(c => c.Type == claim.Type && c.Value == "true"))
{
userClaim.isSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(UserClaimViewModel userClaimViewModel)
{
var user = await UserManager.FindByIdAsync(userClaimViewModel.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with id {userClaimViewModel.UserId} cannot be found from post";
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(userClaimViewModel));
}
result = await UserManager.AddClaimsAsync(user, userClaimViewModel.Claims.Where(c => c.IsSelected).Select(c => new Claim(c.ClaimType, c.ClaimType)));
if (!result.Succeeded)
{
ModelState.AddModelError("", "cannot add selected claimsto user");
return(View(userClaimViewModel));
}
return(RedirectToAction("EditUser", new { id = userClaimViewModel.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 from post";
return(View("NotFound"));
}
var existingUserClaims = await UserManager.GetClaimsAsync(user);
var model = new UserClaimViewModel
{
UserId = userId
};
foreach (Claim claim in ClaimsStore.AllClaims)
{
UserClaim userClaim = new UserClaim()
{
ClaimType = claim.Type,
IsSelected = false
};
// check if the current claim is selected for the user
if (existingUserClaims.Any(c => c.Type == claim.Type))
{
userClaim.IsSelected = true;
}
model.Claims.Add(userClaim);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaim(UserClaimViewModel model)
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id: {model.UserId} can not found!";
return(View("NotFound"));
}
var claims = await _userManager.GetClaimsAsync(user);
var result = await _userManager.RemoveClaimsAsync(user, claims);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Can not remove Existing Claims!");
return(View(model));
}
result = await _userManager.AddClaimsAsync(user,
model.Cliams.Where(c => c.IsSelected).Select(d => new Claim(d.ClaimType, d.ClaimType)));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Can not add to selected claim to user");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = model.UserId }));
}
public async Task <IActionResult> ManageUserClaim(string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User With id {userId} Can not found!";
return(View("NotFound"));
}
var existingclaims = await _userManager.GetClaimsAsync(user);
var model = new UserClaimViewModel
{
UserId = userId
};
foreach (var claim in ClaimStore.AllClaims)
{
UserCliam userCliam = new UserCliam
{
ClaimType = claim.Type
};
//if the user has the claim, set isSelect Property is true,so the checkbox
//next to the claim is checked on the other UI
if (existingclaims.Any(c => c.Type == claim.Type))
{
userCliam.IsSelected = true;
}
model.Cliams.Add(userCliam);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaim(string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("ErrorPageShowMessage"));
}
var existingUserClaim = await _userManager.GetClaimsAsync(user);
var model = new UserClaimViewModel
{
UserId = userId
};
foreach (Claim claim in ClaimStore.AllClaims)
{
UserClaim userClaim = new UserClaim
{
ClaimType = claim.Type,
};
if (existingUserClaim.Any(x => x.Type == claim.Type && x.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 = $"The Id {userId} can not be found";
return(View("NotFound"));
}
var existingUserClaims = await userManager.GetClaimsAsync(user);
var model = new UserClaimViewModel
{
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 userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with id = {userId} cannot be found";
return(View("NotFound"));
}
var userClaims = await userManager.GetClaimsAsync(user);
UserClaimViewModel model = new UserClaimViewModel()
{
UserId = userId
};
foreach (var claim in ClaimStore.AllClaims)
{
UserClaim uClaim = new UserClaim()
{
ClaimType = claim.Value
};
if (userClaims.Any(c => c.Type == claim.Type))
{
uClaim.IsSelected = true;
}
model.UserClaims.Add(uClaim);
}
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(RedirectToAction("NotFound"));
}
var existingClaims = await _userManager.GetClaimsAsync(user);
var model = new UserClaimViewModel()
{
UserId = userId
};
foreach (Claim claim in ClaimsStore.ListOfUserClaims)
{
UserClaims userClaims = new UserClaims()
{
ClaimType = claim.Type
};
if (existingClaims.Any(x => x.Type == claim.Type && x.Value == "true"))
{
userClaims.IsSelected = true;
}
model.UserClaims.Add(userClaims);
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaims(UserClaimViewModel model)
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"Role 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 role");
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 remove user existing role");
return(View(model));
}
return(RedirectToAction("EditUser", new { id = model.UserId }));
}
public async Task<IActionResult> ManageUserClaim(UserClaimViewModel userClaimViewModel)
{
var user = await userManager.FindByIdAsync(userClaimViewModel.UserId);
if (user == null)
{
ViewBag.ErrorMessage = $"User Id {user.Id} is not here";
return View("NotFound");
}
var existingUserClaims = await userManager.GetClaimsAsync(user);
var result = await userManager.RemoveClaimsAsync(user, existingUserClaims);
if(result.Succeeded==false)
{
ViewBag.ErrorMessage = $"We can not Delete the existing User Claims";
return View("NotFound");
}
result = await userManager.AddClaimsAsync(user, userClaimViewModel.Claims.Where(s => s.IsSelected).Select(x => new Claim(x.ClaimTyope, x.ClaimTyope)));
if (result.Succeeded == false)
{
ViewBag.ErrorMessage = $"Cannot add selected Claims to the USER!";
return View("NotFound");
}
return RedirectToAction("EditUser", new { ID = userClaimViewModel.UserId });
}
public UserClaimItemModel(ZActivityOperations activityOperations, string controllerAction, string masterEntity = null, string masterKey = null, UserClaimViewModel userClaim = null)
: this()
{
ActivityOperations = activityOperations;
ControllerAction = controllerAction;
MasterEntity = masterEntity;
MasterKey = masterKey;
UserClaim = userClaim ?? UserClaim;
}
public static List <UserClaimViewModel> ConvertToViewModelList(this List <bx_claim_detail> details)
{
List <UserClaimViewModel> viewModels = new List <UserClaimViewModel>();
foreach (bx_claim_detail detail in details)
{
UserClaimViewModel vm = detail.ConverToViewModel();
viewModels.Add(vm);
}
return(viewModels);
}
public async Task <UserClaimViewModel> GetUserInfos()
{
var user = HttpContext.User;
var dbUser = await _userManager.GetUserAsync(user);
UserClaimViewModel userClaimViewModel = new UserClaimViewModel()
{
Email = dbUser.Email,
UserName = dbUser.UserName,
UserId = dbUser.Id
};
return(userClaimViewModel);
}
public async Task <IActionResult> ManageUserClaims(string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with {userId} can't be found";
return(View("NotFound"));
}
var existingUserClaims = await _userManager.GetClaimsAsync(user);
//ClaimIdentity--> UserClaimModel
var dataModel = new UserClaimModel
{
UserId = userId,
};
foreach (Claim claim in ClaimsStore.AllClaims)
{
var userClaim = new DataAccess.Models.UserClaim
{
ClaimType = claim.Type,
};
if (existingUserClaims.Any(x => x.Type == claim.Type && x.Value == "true"))
{
userClaim.IsSelected = true;
}
dataModel.Claims.Add(userClaim);
}
//UserClaimModel --> UserClaimViewModel
var model = new UserClaimViewModel
{
UserId = dataModel.UserId,
};
foreach (var item in dataModel.Claims)
{
var userclaim = new PicGallery.ViewModels.UserClaim
{
ClaimType = item.ClaimType,
IsSelected = item.IsSelected
};
model.Claims.Add(userclaim);
}
return(View(model));
}
public async Task <IActionResult> AssignClaims(UserClaimViewModel model)
{
var user = await userManager.FindByIdAsync(model.UserId);
var claim = new Claim(model.Claim, model.Claim);
var result = await userManager.AddClaimAsync(user, claim);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
return(View(model));
}
public async Task <IActionResult> ManageUserClaim(string id)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
ViewBag.ErrorMessage = $"I cant find this user with id {id}";
return(RedirectToAction("NotFound", "Administration"));
}
var claims = await _userManager.GetClaimsAsync(user);
UserClaimViewModel userClaim = new UserClaimViewModel
{
Id = id
};
if (!claims.Any())
{
foreach (var claim in ListClaims.claims)
{
userClaim.Claims.Add(new UserClaim {
ClaimType = claim.Type,
});
}
}
else
{
bool isSelected;
foreach (var claim in ListClaims.claims)
{
isSelected = false;
foreach (var item in claims)
{
if (claim.Type == item.Type)
{
isSelected = true;
break;
}
}
userClaim.Claims.Add(new UserClaim {
ClaimType = claim.Type, IsSelected = isSelected
});
}
}
return(View(userClaim));
}
public static UserClaimViewModel ConverToViewModel(this bx_claim_detail detail)
{
UserClaimViewModel vm = new UserClaimViewModel();
if (detail.endcase_time.HasValue)
{
vm.EndcaseTime = detail.endcase_time.Value.ToString("yyyy-MM-dd");
}
if (detail.loss_time.HasValue)
{
vm.LossTime = detail.loss_time.Value.ToString("yyyy-MM-dd");
}
vm.PayAmount = detail.pay_amount ?? 0;
vm.PayCompanyName = detail.pay_company_name;
return(vm);
}
public async Task <IActionResult> AssignClaims(string userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user == null)
{
return(Content("User Not found"));
}
var model = new UserClaimViewModel()
{
UserId = userId,
AssignedClaims = await userManager.GetClaimsAsync(user),
Claims = TestClaims.Claims
};
return(View(model));
}
