public IActionResult ChangeMyPassword(PasswordChangeModel model)
{
if (ModelState.IsValid)
{
AppUser user = CurrentUser;
if (user != null)
{
bool exist = Usermanager.CheckPasswordAsync(user, model.PasswordOld).Result;
if (exist)
{
IdentityResult result = Usermanager.ChangePasswordAsync(user, model.PasswordOld, model.PasswordNew
).Result;
if (result.Succeeded)
{
Usermanager.UpdateSecurityStampAsync(user);
SignInManager.SignOutAsync();
SignInManager.PasswordSignInAsync(user, model.PasswordNew, false, false);
ViewBag.success = true;
}
else
{
AddErrors(result);
}
}
}
}
return(View(model));
}
public async Task <IActionResult> ResetPassword(ResetPasswordViewModel model)
{
if (ModelState.IsValid)
{
// Find the user by email
var user = await Usermanager.FindByEmailAsync(model.Email);
if (user != null)
{
// reset the user password
var result = await Usermanager.ResetPasswordAsync(user, model.Token, model.Password);
if (result.Succeeded)
{
return(View("ResetPasswordConfirmation"));
}
// Display validation errors. For example, password reset token already
// used to change the password or password complexity rules not met
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
// To avoid account enumeration and brute force attacks, don't
// reveal that the user does not exist
return(View("ResetPasswordConfirmation"));
}
// Display validation errors if model state is not valid
return(View(model));
}
public async Task <ActionResult> Register(RegisterModel model)
{
if (ModelState.IsValid)
{
SmsServiceUser user = new SmsServiceUser
{
UserName = model.Nickname,
Email = model.Email
};
IdentityResult result = await Usermanager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var role = RoleManager.FindByName("admin");
Usermanager.AddToRole(user.Id, role.Name);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(String.Empty, error);
}
}
return(View(model));
}
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> 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> 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> EditRole(string id)
{
// Find the role by Role ID
var role = await Rolemanager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {id} cannot be found";
return(View("NotFound"));
}
var model = new EditRoleViewModel
{
Id = role.Id,
RoleName = role.Name
};
// Retrieve all the Users
foreach (var user in Usermanager.Users)
{
// If the user is in this role, add the username to
// Users property of EditRoleViewModel. This model
// object is then passed to the view for display
if (await Usermanager.IsInRoleAsync(user, role.Name))
{
model.Users.Add(user.UserName);
}
}
return(View(model));
}
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> 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 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 GameUserController(IGameService service, IMapper map)
{
gameService = service;
mapper = map;
_context = new ApplicationDbContext();
user = new Usermanager();
}
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 <ActionResult> Login(LoginModel model)
{
if (ModelState.IsValid)
{
SmsServiceUser user = await Usermanager.FindAsync(model.Login, model.Password);
if (user == null)
{
ModelState.AddModelError(String.Empty, "Неверный логин или пароль");
}
else
{
ClaimsIdentity claims =
await Usermanager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claims);
//if (Request.UrlReferrer != null) return Redirect(Request.UrlReferrer.ToString());
return(RedirectToAction("Index", "Home"));
}
}
return(View(model));
}
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> 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> Login(LoginViewModel model)
{
if (ModelState.IsValid)
{
AppUser user = await Usermanager.FindByEmailAsync(model.Email);
//AppUser user = CurrentUser;
if (user != null)
{
if (await Usermanager.IsLockedOutAsync(user))
{
ModelState.AddModelError("", "hesap kilitli");
}
await SignInManager.SignOutAsync();
Microsoft.AspNetCore.Identity.SignInResult result = await SignInManager.PasswordSignInAsync(user, model.Password, false, false);
if (result.Succeeded)
{
await Usermanager.ResetAccessFailedCountAsync(user);
if (TempData["ReturnUrl"] != null)
{
return(Redirect(TempData["ReturnUrl"].ToString()));
}
return(RedirectToAction("Index", "Member"));
}
else
{
await Usermanager.AccessFailedAsync(user);
int fail = await Usermanager.GetAccessFailedCountAsync(user);
ModelState.AddModelError("", $"{fail} kez basarisiz giris");
if (fail == 3)
{
await Usermanager.SetLockoutEndDateAsync(user, new System.DateTimeOffset(DateTime.Now.AddMinutes(20)));
ModelState.AddModelError("", "ban for 20 minutes");
}
else
{
ModelState.AddModelError(nameof(model.Email), "gecersiz mail veya sifre");
}
}
}
else
{
//return RedirectToAction()
ModelState.AddModelError(nameof(model.Email), "gecersiz mail veya sifre");
}
}
return(View());
}
public async Task <IActionResult> AddPassword()
{
var user = await Usermanager.GetUserAsync(User);
var userHasPassword = await Usermanager.HasPasswordAsync(user);
if (userHasPassword)
{
return(RedirectToAction("ChangePassword"));
}
return(View());
}
public async Task <IActionResult> IsEmailexist(string email)
{
var user = await Usermanager.FindByEmailAsync(email);
if (user == null)
{
return(Json(true));
}
else
{
return(Json($"Email {email} is already in Use"));
}
}
public async Task <IActionResult> ExchangeRouting()
{
bool result = User.HasClaim(x => x.Type == "ExpireChangeDate");
if (!result)
{
Claim ExpireDateExchange = new Claim("ExpireChangeDate", DateTime.Now.AddDays(30).Date.ToShortDateString(), ClaimValueTypes.String, "Internal");
await Usermanager.AddClaimAsync(CurrentUser, ExpireDateExchange);
await SignInManager.SignOutAsync();
await SignInManager.SignInAsync(CurrentUser, true);
}
return(RedirectToAction("Exchange"));
}
public async Task <IActionResult> ForgotPassword(string Email)
{
if (Email == null)
{
ModelState.AddModelError("", "Email Can't be null");
return(View());
}
if (ModelState.IsValid)
{
// Find the user by email
var user = await Usermanager.FindByEmailAsync(Email);
// If the user is found AND Email is confirmed
if (user != null && await Usermanager.IsEmailConfirmedAsync(user))
{
// Generate the reset password token
var token = await Usermanager.GeneratePasswordResetTokenAsync(user);
// Build the password reset link
var passwordResetLink = Url.Action("ResetPassword", "Account",
new { email = Email, token = token }, Request.Scheme);
string str = await ViewToStringRenderer.RenderViewToStringAsync(HttpContext.RequestServices, $"~/Views/Template/ResetPassword.cshtml", passwordResetLink);
//util.sendemail(user.Email, "Reset Account Password", str);
//await _emailSender.SendEmailAsync(user.Email, "Reset Account Password", $"<h2>Here is the Reset Password Confirmation Link</h2></br> <a href ={passwordResetLink}>{passwordResetLink}</a>");
await _emailSender.SendEmailAsync(user.Email, "Reset Account Password", str);
ViewBag.PageTitle = "Email Confirmation";
ViewBag.Title = "Password Reset Success";
ViewBag.Message = "Before you can Login, please Reset your " +
"Password, by clicking on the Reset Password link we have emailed you";
return(View("EmailConfirmation"));
}
// To avoid account enumeration and brute force attacks, don't
// reveal that the user does not exist or is not confirmed
ViewBag.PageTitle = "Email Confirmation";
ViewBag.Title = "Password Reset Success";
ViewBag.Message = "Before you can Login, please Reset your " +
"Password, by clicking on the Reset Password link we have emailed you";
return(View("EmailConfirmation"));
}
return(View());
}
//protected void DataList1_ItemDataBound(object sender, DataListItemEventArgs e)
//{
// ThemeManager tm = new ThemeManager();
// //string UserId = DataList1.DataKeys[e.Item.ItemIndex].ToString();
// DataList1.DataSource = tm.GetTheme();
// DataList1.DataBind();
//}
protected void Button1_Click(object sender, EventArgs e)
{
Userinfo user;
Usermanager um = new Usermanager();
if (um.Login(this.TextBox1.Text, this.TextBox2.Text, out user))
{
//Session["CurrentUser"] = user;
//this.Label1.Text = user.NickName.ToString() + " 欢迎您！";
//this.pnLongin.Visible = true;
Response.Redirect("~/Default.aspx");
}
else
{
Response.Write("<script>alert('用户名或密码不正确，请重新填写')</script>");
}
}
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 <ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
var userId = _context.Users.FirstOrDefault(t => t.Email == model.Email).Id;
var adminId = _context.Roles.FirstOrDefault(x => x.Name == "Admin").Id;
var statusrole = _context.Set <IdentityUserRole>().FirstOrDefault(x => x.RoleId == adminId && x.UserId == userId);
if (statusrole != null)
{
return(RedirectToAction("Index", "Game", new { area = "Admin" }));
}
else
{
Usermanager userManager = new Usermanager();
userId = User.Identity.GetUserId();
gameService.AddUser(userManager);
return(RedirectToAction("Index", "Home"));
}
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public async Task <IActionResult> Login(LoginViewModel model, string returnUrl)
{
model.ExternalLogins =
(await Signinmanager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = await Usermanager.FindByEmailAsync(model.Email);
if (user != null && !user.EmailConfirmed &&
(await Usermanager.CheckPasswordAsync(user, model.Password)))
{
ModelState.AddModelError(string.Empty, "Email not confirmed yet");
return(View(model));
}
var result = await Signinmanager.PasswordSignInAsync(
user, model.Password, model.RememberMe, false);
if (result.Succeeded)
{
if (!String.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl))
{
//LocalRedirect(returnUrl);
return(Redirect(returnUrl));
}
else
{
if (User.IsInRole("Admin") || User.IsInRole("Super Admin") || User.IsInRole("Employee"))
{
return(RedirectToAction("Admin", "Home"));
}
else
{
return(RedirectToAction("index", "Home"));
}
}
}
ModelState.AddModelError(string.Empty, "Invalid Login Attempt");
}
return(View(model));
}
public ActionResult GetRoles(string UserName)
{
if (!string.IsNullOrEmpty(UserName))
{
ApplicationUser user = db.Users.FirstOrDefault(n => n.UserName.Equals(UserName));
this.Usermanager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(this.db));
ViewBag.RolesForThisUser = Usermanager.GetRoles(user.Id);
var userList = db.Users.OrderBy(n => n.UserName).ToList().Select(e => new SelectListItem()
{
Text = e.UserName,
Value = e.UserName
});
ViewBag.Users = userList;
}
return(View());
}
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 static ActorMeth UserDb()
{
var userManager = new Usermanager(new EditorContext());
ActorMeth behaviour = (rt, self, _, msg) =>
{
DbMail mail = msg.content;
switch (mail.Action)
{
case DbAction.Create:
//if()
break;
default:
break;
}
return(null);
};
return(behaviour);
}
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));
}
