public async Task <IActionResult> ManageClaims(UserCliamsViewModel 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> ResetPasswordConfirm(PasswordVM model)
{
string token = TempData["token"].ToString();
string id = TempData["userid"].ToString();
AppUser user = await Usermanager.FindByIdAsync(id);
if (user != null)
{
IdentityResult result = await Usermanager.ResetPasswordAsync(user, token, model.Password);
if (result.Succeeded)
{
await Usermanager.UpdateSecurityStampAsync(user);
TempData["passwordResetInfo"] = "sifreniz basariyla yenilendi";
}
else
{
AddErrors(result);
}
}
else
{
ModelState.AddModelError("", "boyle biri yok");
}
return(View());
}
public async Task <IActionResult> ManageRoles(List <UserRoles> model, string userId)
{
var user = await Usermanager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
var roles = await Usermanager.GetRolesAsync(user);
var result = await Usermanager.RemoveFromRolesAsync(user, roles);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing roles");
return(View(model));
}
result = await Usermanager.AddToRolesAsync(user,
model.Where(x => x.isSelected).Select(y => y.RoleName));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot add selected roles to user");
return(View(model));
}
return(RedirectToAction("EditUser", new { id = userId }));
}
public async Task <IActionResult> ManageClaims(string userId)
{
var user = await Usermanager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
var model = new UserCliamsViewModel()
{
userId = userId
};
var existingUserClaims = await Usermanager.GetClaimsAsync(user);
foreach (Claim claim in ClaimStore.claimstore)
{
UserClaims userclaim = new UserClaims()
{
ClaimType = claim.Type,
Value = claim.Value
};
// If the user has the claim, set IsSelected property to true, so the checkbox
// next to the claim is checked on 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> DeleteUser(string id)
{
var user = await Usermanager.FindByIdAsync(id);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {id} cannot be found";
return(View("NotFound"));
}
else
{
if (await Usermanager.IsInRoleAsync(user, "Admin") || await Usermanager.IsInRoleAsync(user, "Employee"))
{
var claims = await Usermanager.GetClaimsAsync(user);
var claimResult = await Usermanager.RemoveClaimsAsync(user, claims);
if (!claimResult.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing claims");
return(View("ListUsers"));
}
var roles = await Usermanager.GetRolesAsync(user);
var RolesResult = await Usermanager.RemoveFromRolesAsync(user, roles);
if (!RolesResult.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing roles");
return(View("ListUsers"));
}
user.isactive = false;
var result1 = await Usermanager.UpdateAsync(user);
if (result1.Succeeded)
{
return(RedirectToAction("ListUsers"));
}
foreach (var error in result1.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View("ListUsers"));
}
var result = await Usermanager.DeleteAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("ListUsers"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View("ListUsers"));
}
}
public async Task <IActionResult> ConfirmEmail(string userId, string token)
{
if (userId == null || token == null)
{
return(RedirectToAction("index", "Home"));
}
var user = await Usermanager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"The User ID {userId} is invalid";
return(View("NotFound"));
}
var result = await Usermanager.ConfirmEmailAsync(user, token);
if (result.Succeeded)
{
string str = await ViewToStringRenderer.RenderViewToStringAsync(HttpContext.RequestServices, $"~/Views/Template/Welcome.cshtml", user.FullName);
await _emailSender.SendEmailAsync(user.Email, "Welcome To Mobile Store", str);
return(View("EmailConfirmed"));
}
ViewBag.ErrorTitle = "Email cannot be confirmed";
return(View("Error"));
}
public async Task <IActionResult> RoleVer(RoleViewModel model)
{
if (ModelState.IsValid)
{
//var val = ViewBag.User;
AppUser user = await Usermanager.FindByIdAsync(model.Name);
//AppRole role = RoleManager.GetRoleIdAsync().Result;
AppRole role = RoleManager.FindByIdAsync(model.ID).Result;
IdentityResult res = Usermanager.AddToRoleAsync(user, role.Name.ToString()).Result;
//IdentityResult res = RoleManager.SetRoleNameAsync(role, user.Id).Result;
if (res.Succeeded)
{
return(RedirectToAction("Index", "Admin"));
}
else
{
AddErrors(res);
return(View());
}
}
else
{
return(View());
}
}
public IActionResult UserRoleAtttemption(string UserId)
{
AppUser appUser = Usermanager.FindByIdAsync(UserId).Result;
ViewBag.UserName = appUser.UserName;
IQueryable <AppRole> roles = RoleManager.Roles;
List <string> UserRoles = Usermanager.GetRolesAsync(appUser).Result as List <string>;
List <UserRoleViewModel> roleViewModels = new List <UserRoleViewModel>();
foreach (var role in roles)
{
UserRoleViewModel usrvm = new UserRoleViewModel();
usrvm.RoleID = role.Id;
usrvm.RoleName = role.Name;
if (UserRoles.Contains(role.Name))
{
usrvm.exist = true;
}
else
{
usrvm.exist = false;
}
roleViewModels.Add(usrvm);
}
//List<string> Roles=RoleManager.GetRoleIdAsync(RoleId).Result as List<string>();
return(View(roleViewModels));
}
public async Task <IActionResult> EditUser(EditUserViewModel model)
{
var user = await Usermanager.FindByIdAsync(model.Id);
if (User.IsInRole("Admin") || User.IsInRole("Super Admin"))
{
var LoginUser = await Usermanager.GetUserAsync(User);
if (!User.HasClaim("Edit User", "true") && LoginUser.Id != model.Id)
{
return(Forbid());
}
}
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {model.Id} cannot be found";
return(View("NotFound"));
}
else
{
user.Email = model.Email;
user.FullName = model.FullName;
user.PhoneNumber = model.PhoneNumber;
user.StreetAdress = model.StreetAdress;
user.store_id = model.store_id;
user.City = model.cityId;
if (model.Photo != null)
{
if (model.Existingphotopath != null)
{
string filepath = Path.Combine(hostingEnvironment.WebRootPath, "Image", model.Existingphotopath);
System.IO.File.Delete(filepath);
}
user.Photopath = util.ProcessPhotoproperty(model.Photo);
}
var result = await Usermanager.UpdateAsync(user);
if (result.Succeeded)
{
if (User.IsInRole("Admin") || User.IsInRole("Super Admin") || User.IsInRole("Employee"))
{
return(RedirectToAction("GetUserById", new { id = user.Id }));
}
else
{
return(RedirectToAction("~/Views/Home/Profile.cshtml"));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
public async Task <IActionResult> GetUserById(string id)
{
var user = await Usermanager.FindByIdAsync(id);
if (user != null)
{
RegisterEmployeeViewModel r = new RegisterEmployeeViewModel()
{
id = user.Id,
FullName = user.FullName,
Email = user.Email,
City = util.getCities().FirstOrDefault(x => x.id == user.City).city,
PhoneNumber = user.PhoneNumber,
Photopath = user.Photopath,
StreetAdress = user.StreetAdress,
};
if (user.store_id != null)
{
r.store_id = (int)user.store_id;
}
if (User.IsInRole("Super Admin") || User.IsInRole("Admin"))
{
var userClaims = await Usermanager.GetClaimsAsync(user);
var userRoles = await Usermanager.GetRolesAsync(user);
if (user.store_id != null)
{
r.StoreName = util.GetAllStores().FirstOrDefault(x => x.store_id == user.store_id).StoreName;
}
r.addedBy = user.addedBy;
foreach (var claim in userClaims)
{
UserClaim u = new UserClaim()
{
ClaimType = claim.Type,
ClaimValue = claim.Value
};
r.Claims.Add(u);
}
foreach (var role in userRoles)
{
UserRoles ro = new UserRoles()
{
RoleName = role
};
r.Roles.Add(ro);
}
}
return(View("~/Views/Home/Profile.cshtml", r));
}
//not Found
ViewBag.Name = "User";
return(View("ProductNotFound", id));
}
public async Task <IActionResult> EditUsersInRole(List <UserRoleViewModel> model, string roleId)
{
var role = await Rolemanager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {roleId} cannot be found";
return(View("NotFound"));
}
for (int i = 0; i < model.Count; i++)
{
var user = await Usermanager.FindByIdAsync(model[i].UserId);
IdentityResult result = null;
if (model[i].IsSelected && !(await Usermanager.IsInRoleAsync(user, role.Name)))
{
result = await Usermanager.AddToRoleAsync(user, role.Name);
}
else if (!model[i].IsSelected && await Usermanager.IsInRoleAsync(user, role.Name))
{
result = await Usermanager.RemoveFromRoleAsync(user, role.Name);
}
else
{
continue;
}
if (result.Succeeded)
{
if (i < (model.Count - 1))
{
continue;
}
else
{
return(RedirectToAction("EditRole", new { Id = roleId }));
}
}
}
return(RedirectToAction("EditRole", new { Id = roleId }));
}
public async Task <IActionResult> ChangePassword(ChangePasswordViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser();
if (User.IsInRole("Super Admin"))
{
user = await Usermanager.FindByIdAsync(model.Id);
}
else
{
user = await Usermanager.GetUserAsync(User);
}
if (user == null)
{
return(RedirectToAction("Login"));
}
// ChangePasswordAsync changes the user password
var result = await Usermanager.ChangePasswordAsync(user,
model.CurrentPassword, model.NewPassword);
// The new password did not meet the complexity rules or
// the current password is incorrect. Add these errors to
// the ModelState and rerender ChangePassword view
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View());
}
// Upon successfully changing the password refresh sign-in cookie
if (!User.IsInRole("Super Admin"))
{
await Signinmanager.RefreshSignInAsync(user);
}
return(View("ChangePasswordConfirmation"));
}
return(View(model));
}
public async Task <IActionResult> EditUser(string id)
{
var user = await Usermanager.FindByIdAsync(id);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {id} cannot be found";
return(View("NotFound"));
}
if (User.IsInRole("Admin"))
{
var LoginUser = await Usermanager.GetUserAsync(User);
if (!User.HasClaim("Edit User", "true") && LoginUser.Id != id)
{
return(Forbid());
}
}
ViewBag.Stores = util.GetAllStores();
// GetClaimsAsync retunrs the list of user Claims
var userClaims = await Usermanager.GetClaimsAsync(user);
// GetRolesAsync returns the list of user Roles
var userRoles = await Usermanager.GetRolesAsync(user);
var model = new EditUserViewModel
{
Id = user.Id,
Email = user.Email,
FullName = user.FullName,
cityId = user.City,
PhoneNumber = user.PhoneNumber,
StreetAdress = user.StreetAdress,
store_id = user.store_id,
Existingphotopath = user.Photopath,
Claims = userClaims.Select(c => c.Type + ":" + c.Value).ToList(),
Roles = userRoles
};
ViewBag.cities = util.getCities();
return(View(model));
}
public async Task <IActionResult> ManageRoles(string userId)
{
ViewBag.userId = userId;
string loggedInAdminId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value;
var user = await Usermanager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
var model = new List <UserRoles>();
foreach (var role in Rolemanager.Roles)
{
if (User.IsInRole("Super Admin") || User.IsInRole("Admin") && role.Name != "Admin" && role.Name != "Super Admin")
{
var Eachuserviewmodel = new UserRoles
{
RoleId = role.Id,
RoleName = role.Name
};
if (await Usermanager.IsInRoleAsync(user, role.Name))
{
Eachuserviewmodel.isSelected = true;
}
else
{
Eachuserviewmodel.isSelected = false;
}
model.Add(Eachuserviewmodel);
}
}
return(View(model));
}
public async Task <IActionResult> ChangePassword(string id)
{
var user = new ApplicationUser();
if (id != null)
{
if (User.IsInRole("Super Admin"))
{
user = await Usermanager.FindByIdAsync(id);
if (user == null)
{
ViewBag.ErrorMessage = $"The User ID {id} is invalid";
return(View("NotFound"));
}
}
else
{
return(Forbid());
}
}
else
{
user = await Usermanager.GetUserAsync(User);
}
var userHasPassword = await Usermanager.HasPasswordAsync(user);
if (!userHasPassword)
{
return(RedirectToAction("AddPassword"));
}
ChangePasswordViewModel c = new ChangePasswordViewModel()
{
Id = user.Id
};
return(View());
}
