/// <summary>
/// Checks for the three roles - Admin, Employee and Complainant and
/// creates them if not present
/// </summary>
public static void InitializeRoles()
{ // Access the application context and create result variables.
ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdUserResult;
// Create a RoleStore object by using the ApplicationDbContext object.
// The RoleStore is only allowed to contain IdentityRole objects.
var roleStore = new RoleStore<IdentityRole>(context);
RoleManager roleMgr = new RoleManager();
if (!roleMgr.RoleExists("Administrator"))
{
roleMgr.Create(new ApplicationRole { Name = "Administrator" });
}
if (!roleMgr.RoleExists("Employee"))
{
roleMgr.Create(new ApplicationRole { Name = "Employee" });
}
if (!roleMgr.RoleExists("Complainant"))
{
roleMgr.Create(new ApplicationRole { Name = "Complainant" });
}
if (!roleMgr.RoleExists("Auditor"))
{
roleMgr.Create(new ApplicationRole { Name = "Auditor" });
}
// Create a UserManager object based on the UserStore object and the ApplicationDbContext
// object. Note that you can create new objects and use them as parameters in
// a single line of code, rather than using multiple lines of code, as you did
// for the RoleManager object.
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Admin123");
// If the new "canEdit" user was successfully created,
// add the "canEdit" user to the "canEdit" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "Administrator"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "Administrator");
}
appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Auditor123");
// If the new "canEdit" user was successfully created,
// add the "canEdit" user to the "canEdit" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "Auditor"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "Auditor");
}
}
// GET: AspNetUsers/Details/5
public async Task<ActionResult> Details(string id)
{
AspNetUserDetailsViewModel mdl = new AspNetUserDetailsViewModel();
if(id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
mdl.User = await db.AspNetUsers.FindAsync(id);
if(mdl.User == null)
{
return HttpNotFound();
}
mdl.Roles = await db.AspNetRoles.ToListAsync();
var ctx = new ApplicationDbContext();
var RoleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(ctx));
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(ctx));
if(userManager.IsInRole(mdl.User.Id, "NetUser"))
{
mdl.RoleId = RoleManager.FindByName("NetUser")?.Id;
}
if(userManager.IsInRole(mdl.User.Id, "Admin"))
{
mdl.RoleId = RoleManager.FindByName("Admin")?.Id;
}
return View(mdl);
}
private void AddPermisionToADM(ApplicationDbContext db)
{
var userManarge = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(db));
var user = userManarge.FindByName("*****@*****.**");
if (!userManarge.IsInRole(user.Id, "View"))
{
userManarge.AddToRole(user.Id, "View");
}
if (!userManarge.IsInRole(user.Id, "Create"))
{
userManarge.AddToRole(user.Id, "Create");
}
if (!userManarge.IsInRole(user.Id, "Edit"))
{
userManarge.AddToRole(user.Id, "Edit");
}
if (!userManarge.IsInRole(user.Id, "Delete"))
{
userManarge.AddToRole(user.Id, "Delete");
}
if (!userManarge.IsInRole(user.Id, "Adm"))
{
userManarge.AddToRole(user.Id, "Adm");
}
}
public ActionResult Index()
{
MyIdentityDbContext db = new MyIdentityDbContext();
UserStore<MyIdentityUser> userStore = new UserStore<MyIdentityUser>(db);
UserManager<MyIdentityUser> userManager = new UserManager<MyIdentityUser>(userStore);
MyIdentityUser user = userManager.FindByName(HttpContext.User.Identity.Name);
NorthWindEntities northwindDb = new NorthWindEntities();
List<Customer> customers = null;
if (userManager.IsInRole(user.Id, "Administrator"))
{
customers = northwindDb.Customers.ToList();
}
if (userManager.IsInRole(user.Id, "Operator"))
{
customers = northwindDb.Customers.Where(m => m.City == "USA").ToList();
}
ViewBag.FullName = user.FullName + " (" + user.UserName + ") !";
return View(customers);
}
public ActionResult Menu()
{
ApplicationDbContext userscontext = new ApplicationDbContext();
var userStore = new UserStore<ApplicationUser>(userscontext);
var userManager = new UserManager<ApplicationUser>(userStore);
var roleStore = new RoleStore<IdentityRole>(userscontext);
var roleManager = new RoleManager<IdentityRole>(roleStore);
if (User.Identity.IsAuthenticated)
{
if (userManager.IsInRole(this.User.Identity.GetUserId(), "Admin"))
{
return PartialView("_AdminMenuView");
}
else if (userManager.IsInRole(this.User.Identity.GetUserId(), "Principal"))
{
return PartialView("_PrincipalenuView");
}
else
{
return PartialView("_Student");
}
}
return PartialView("_Empty");
}
public EnumHelper.Roles GetCurrentUserRoleById(string userId)
{
var store = new UserStore<ApplicationUser>(_context);
var manager = new UserManager<ApplicationUser>(store);
EnumHelper.Roles userRole = EnumHelper.Roles.Viewer;
if (manager.IsInRole(userId, EnumHelper.Roles.Admin.ToString()))
{
return EnumHelper.Roles.Admin;
}
else if (manager.IsInRole(userId, EnumHelper.Roles.Author.ToString()))
{
return EnumHelper.Roles.Author;
}
return userRole;
}
internal void AddUserAndRole()
{
Models.ApplicationDbContext db = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
var roleStore = new RoleStore<IdentityRole>(db);
var roleMgr = new RoleManager<IdentityRole>(roleStore);
if (!roleMgr.RoleExists("canEdit"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "canEdit" });
}
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "NhatSinh123*");
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit");
}
}
// GET: Maintenance/UserRoleMaintenance
public ActionResult Index()
{
if (Request.IsAuthenticated)
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
if (!userManager.IsInRole(User.Identity.GetUserId(), "System Admin"))
{
return RedirectToAction("AccessBlock", "Account", new { area = "" });
}
else
{
// prepopulat roles for the view dropdown
var list = context.Roles.OrderBy(r => r.Name).ToList().Select(rr => new SelectListItem { Value = rr.Name.ToString(), Text = rr.Name }).ToList();
var schemeList = db.Schemes.Select(m => new { Value = m.Name, Text = m.Name }).Distinct().ToList();
ViewBag.Roles = list;
var listUsers = context.Users.OrderBy(r => r.UserName).ToList().Select(rr => new SelectListItem { Value = rr.UserName.ToString(), Text = rr.UserName }).ToList();
ViewBag.Users = listUsers;
ViewBag.SchemeList = new MultiSelectList(schemeList, "Value", "Text");
return View();
}
}
else
{
return RedirectToAction("Login", "Account", new { area = "" });
}
}
internal void AddUserAndRole()
{
// Access the application context and create result variable.
Models.ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
// Create a RoleStore object by using the ApplicationDbContext object.
// The RoleStore is only allowed to contain IdentityRole Objects.
var roleStore = new RoleStore<IdentityRole>(context);
// Create a RoleManager object that is only allowed to contain IdentityRole objects.
// When creating the RoleManager object, you pass in (as a parameter) a new RoleStore object.
var roleMgr = new RoleManager<IdentityRole>(roleStore);
// Then, you create the "canEdit" role if it doesn't already exist.
if (!roleMgr.RoleExists("canEdit"))
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "canEdit" });
// Create a UserManager object based on the UserStore objcet and the ApplicationDbContext objcet.
// Note that you can create new objects and use them as parameters in a single line of code, rather than using multiple lines of code, as you did for the RoleManager object.
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Pa$$word1");
// If the new "canEdit" user was successfully created, add the "canEdit" user to the "canEdit" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit"))
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit");
}
internal void AddUserAndRole()
{
ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
var roleStore = new RoleStore<IdentityRole>(context);
var roleMgr = new RoleManager<IdentityRole>(roleStore);
if (!roleMgr.RoleExists("Admin"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "Admin" });
}
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "adminA123...");
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "Admin"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "canEdit");
}
}
internal void AddUserAndRole()
{
Models.ApplicationDbContext context = new Models.ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
var roleStore = new RoleStore<IdentityRole>(context);
var roleMgr = new RoleManager<IdentityRole>(roleStore);
if (!roleMgr.RoleExists("administrator"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "administrator" });
}
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
UserName = "******",
ImgUrl = "user2-160x160.jpg",
Description = "High Level",
SinceDate = new DateTime(2016, 1, 1)
};
IdUserResult = userMgr.Create(appUser, "1qaz2wsxE");
var user = userMgr.FindByName("administrator");
if (!userMgr.IsInRole(user.Id, "administrator"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByName("administrator").Id, "administrator");
}
}
internal void AddUserAndRole()
{
ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
RoleStore<IdentityRole> roleStore = new RoleStore<IdentityRole>(context);
RoleManager<IdentityRole> roleMgr = new RoleManager<IdentityRole>(roleStore);
//create admin role
if(!roleMgr.RoleExists("admin")) {
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "admin" });
}
//create master user
UserManager<ApplicationUser> userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
ApplicationUser appUser = new ApplicationUser {
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Baseball1!");
//add to admin role
if(!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "admin")) {
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "admin");
}
}
protected void btnRegister_Click(object sender, EventArgs e)
{
var userMgr = new UserManager();
var employee = new Employee()
{
UserName = UserName.Text,
FirstName = FirstName.Text,
LastName = LastName.Text,
PhoneNumber = PhoneNumber.Text,
Email = Email.Text,
Department = (Grievance.GrievanceTypes)Convert.ToInt32(Department.SelectedValue)
};
IdentityResult IdUserResult = userMgr.Create(employee, Password.Text);
if (IdUserResult.Succeeded)
{
if (!userMgr.IsInRole(employee.Id, "Employee")) // Only users of type "Employee" can be created from the "Register Employee" page.
{
IdUserResult = userMgr.AddToRole(employee.Id, "Employee");
}
SuccessMessage.Text = "Employee created successfully";
SuccessMessage.Visible = true;
ErrorMessage.Visible = false;
UserName.Text = FirstName.Text = LastName.Text = PhoneNumber.Text = Email.Text = Password.Text = ConfirmPassword.Text = string.Empty;
}
else
{
ErrorMessage.Text = IdUserResult.Errors.FirstOrDefault();
ErrorMessage.Visible = true;
SuccessMessage.Visible = false;
}
}
public static void AddUserRole(string userName, string roleName)
{
using (var context = new ApplicationDbContext())
{
try
{
if (!context.Roles.Any(r => r.Name == roleName)) return;
var roleStore = new RoleStore<IdentityRole>(context);
var roleManager = new RoleManager<IdentityRole>(roleStore);
var store = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(store);
var user = userManager.FindByName(userName);
var role = roleManager.FindByName(roleName);
if (userManager.IsInRole(user.Id, role.Name)) return;
userManager.AddToRole(user.Id, role.Name);
context.SaveChanges();
}
catch (DbEntityValidationException ex)
{
// Retrieve the error messages as a list of strings.
// ReSharper disable once UnusedVariable
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
throw;
}
}
}
internal void AddUserAndRole()
{
Models.ApplicationDbContext context = new Models.ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
var roleStore = new RoleStore<IdentityRole>(context);
var roleMgr = new RoleManager<IdentityRole>(roleStore);
if (!roleMgr.RoleExists("administrator"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "administrator" });
}
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
UserName = "******",
};
IdUserResult = userMgr.Create(appUser, "1qaz2wsxE");
var user = userMgr.FindByName("administrator");
if (!userMgr.IsInRole(user.Id, "administrator"))
{
//userMgr.RemoveFromRoles(user.Id, "read", "edit");
IdUserResult = userMgr.AddToRole(userMgr.FindByName("administrator").Id, "administrator");
}
}
internal void AddUserAndRole()
{
// access the application context and create result variables.
Models.ApplicationDbContext context = new ApplicationDbContext();
IdentityResult IdRoleResult;
IdentityResult IdUserResult;
// create roleStore object that can only contain IdentityRole objects by using the ApplicationDbContext object.
var roleStore = new RoleStore<IdentityRole>(context);
var roleMgr = new RoleManager<IdentityRole>(roleStore);
// create admin role if it doesn't already exist
if (!roleMgr.RoleExists("admin"))
{
IdRoleResult = roleMgr.Create(new IdentityRole { Name = "admin" });
}
// create a UserManager object based on the UserStore object and the ApplicationDbContext object.
// defines admin email account
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var appUser = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**"
};
IdUserResult = userMgr.Create(appUser, "Pa$$word1");
// If the new admin user was successfully created, add the new user to the "admin" role.
if (!userMgr.IsInRole(userMgr.FindByEmail("*****@*****.**").Id, "admin"))
{
IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("*****@*****.**").Id, "admin");
}
}
public ActionResult Create([Bind(Include = "ID,Code,Name")] Scheme scheme)
{
if (Request.IsAuthenticated)
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
if (!userManager.IsInRole(User.Identity.GetUserId(), "System Admin"))
{
return RedirectToAction("AccessBlock", "Account", new { area = "" });
}
else
{
if (ModelState.IsValid)
{
db.Schemes.Add(scheme);
db.SaveChanges();
return RedirectToAction("Index");
}
return View(scheme);
}
}
else
{
return RedirectToAction("Login", "Account", new { area = "" });
}
}
internal bool UpdateUser(string username, string realUsername, string permission)
{
IdentityResult result = null;
Models.ApplicationDbContext context = new Models.ApplicationDbContext();
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var user = userMgr.FindByName(username);
if (!string.IsNullOrEmpty(realUsername))
{
user.RealUserName = realUsername;
result = userMgr.Update(user);
}
if (!string.IsNullOrEmpty(permission) && !userMgr.IsInRole(user.Id, permission))
{
userMgr.RemoveFromRoles(user.Id, "read", "edit", "administrator");
switch (permission)
{
case "administrator":
result = userMgr.AddToRole(user.Id, "administrator");
break;
case "edit":
result = userMgr.AddToRole(user.Id, "edit");
break;
default:
result = userMgr.AddToRole(user.Id, "read");
break;
}
}
if (result == IdentityResult.Success) return true; else return false;
}
public ActionResult DeleteRoleForUser(string UserName, string RoleName)
{
var account = new AccountController();
ApplicationUser user = context.Users.Where(u => u.UserName.Equals(UserName, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
if (UserManager.IsInRole(user.Id, RoleName))
{
UserManager.RemoveFromRole(user.Id, RoleName);
var employee = context.Employees.Single(x => x.employeeFirstName == user.FirstName && x.employeeLastName ==user.LastName);
var role = context.RolesForEmployees.Single(x => x.roleName == RoleName);
var tmp = context.EmployeeRoles.Single(x => x.role == role && x.employee == employee);
context.EmployeeRoles.Remove(tmp);
context.SaveChanges();
ViewBag.ResultMessage = "Role removed from this user successfully !";
}
else
{
ViewBag.ResultMessage = "This user doesn't belong to selected role.";
}
// prepopulat roles for the view dropdown
var list = context.Roles.OrderBy(r => r.Name).ToList().Select(rr => new SelectListItem { Value = rr.Name.ToString(), Text = rr.Name }).ToList();
ViewBag.Roles = list;
return View("ManageUserRoles");
}
public ActionResult DeleteRoleForUser(string UserName, string RoleName)
{
if (ModelState.IsValid)
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));
ApplicationUser user = context.Users.Where(u => u.UserName.Equals(UserName, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
ViewBag.Token = "2";
if (userManager.IsInRole(user.Id, RoleName))
{
userManager.RemoveFromRole(user.Id, RoleName);
ViewBag.ResultMessage = "Role removed from this user successfully !";
}
else
{
ViewBag.ResultMessage = "This user doesn't belong to selected role.";
}
// prepopulat roles for the view dropdown
var list = context.Roles.OrderBy(r => r.Name).ToList().Select(rr => new SelectListItem { Value = rr.Name.ToString(), Text = rr.Name }).ToList();
ViewBag.Roles = list;
var userList = context.Users.OrderBy(r => r.Email).ToList().Select(rr => new SelectListItem { Value = rr.Email.ToString(), Text = rr.Email }).ToList();
ViewBag.userNames = userList;
ViewBag.RolesForThisUser = userManager.GetRoles(user.Id);
}
return View("ManageUserRoles");
}
public static bool IsAdmin(this AspNetUser user)
{
using (var context = new ApplicationDbContext())
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));
return userManager.IsInRole(user.Id, "admin");
}
}
internal void AddToNormalUserRole(ApplicationUser user)
{
Models.ApplicationDbContext context = new ApplicationDbContext();
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
if (!userMgr.IsInRole(userMgr.FindByEmail(user.Email).Id, "Normal"))
{
userMgr.AddToRole(userMgr.FindByEmail(user.Email).Id, "Normal");
}
}
private void AddPermissionToSuperUser(ApplicationDbContext db)
{
//Variable que nos permiter manipular los usuarios, crear, elimina y mas:
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
// Aquí ya el usuario existe:
var user = userManager.FindByName("*****@*****.**");
//Verifico si el usuario ya tienes roles asignados, si no, se lo asigno :
if (!userManager.IsInRole(user.Id, "View"))
{
userManager.AddToRole(user.Id, "View");
}
if (!userManager.IsInRole(user.Id, "Edit"))
{
userManager.AddToRole(user.Id, "Edit");
}
if (!userManager.IsInRole(user.Id, "Create"))
{
userManager.AddToRole(user.Id, "Create");
}
if (!userManager.IsInRole(user.Id, "Delete"))
{
userManager.AddToRole(user.Id, "Delete");
}
if (!userManager.IsInRole(user.Id, "Details"))
{
userManager.AddToRole(user.Id, "Details");
}
if (!userManager.IsInRole(user.Id, "Orders"))
{
userManager.AddToRole(user.Id, "Orders");
}
if (!userManager.IsInRole(user.Id, "Admin"))
{
userManager.AddToRole(user.Id, "Admin");
}
if (!userManager.IsInRole(user.Id, "Inventories"))
{
userManager.AddToRole(user.Id, "Inventories");
}
if (!userManager.IsInRole(user.Id, "Shopping"))
{
userManager.AddToRole(user.Id, "Shopping");
}
}
public ActionResult Config(int id)
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
if (Request.IsAuthenticated)
{
if (!userManager.IsInRole(User.Identity.GetUserId(), "Configuration") && !userManager.IsInRole(User.Identity.GetUserId(), "System Admin"))
{
return RedirectToAction("AccessBlock", "Account", new { area = "" });
}
else
{
CalcConfiguration ProjectBoard = db.CalcConfiguration.Find(Convert.ToInt32(id));
var List = db.UserSession.Where(i => i.Record == id);
if (List.Count() == 0)
{
UserSession UsersessionAdd = new UserSession();
UsersessionAdd.Section = "Calculation";
UsersessionAdd.Record = id;
UsersessionAdd.StartTime = DateTime.Now;
UsersessionAdd.Username = HttpContext.User.Identity.Name.ToString();
db.UserSession.Add(UsersessionAdd);
db.SaveChanges();
}
try
{
ViewData["SchemeName"] = ProjectBoard.Scheme;
ViewData["CalcName"] = ProjectBoard.Name;
}
catch
{
}
return View();
}
}
else
{
return RedirectToAction("Login", "Account", new { area = "" });
}
}
public ActionResult Index()
{
var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(db));
var allusers = db.Users.OrderBy(r => r.UserName).ToList().Select(rr => new SelectListItem { Value = rr.UserName.ToString(), Text = rr.UserName }).ToList();
//var workers = allusers.Where(x => x.Equals("a720143e-25b2-47fc-a642-5487304d173a")).ToList();
var workers = db.Users.ToList().Where(x => UserManager.IsInRole(x.Id, "Worker")).ToList();
ViewBag.Workers = workers;
return View();
}
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
using (var ctx = new ApplicationDbContext())
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(ctx));
if (!httpContext.User.Identity.IsAuthenticated) return false;
var userId = httpContext.User.Identity.GetUserId();
var isInRole = userManager.IsInRole(userId, Roles);
return isInRole;
}
}
public ActionResult Index()
{
var userId = User.Identity.GetUserId();
var userManager = new UserManager<AppUser>(new UserStore<AppUser>(new ApplicationDbContext()));
if(userId == null)
{
return View();
}
else if(userManager.IsInRole(userId, Role.Student.ToString()))
{
return RedirectToAction("StudentIndex","Home");
}
else if(userManager.IsInRole(userId, Role.Tutor.ToString()))
{
return RedirectToAction("TutorIndex","Home");
}
else if(userManager.IsInRole(userId, "Admin"))
{
return RedirectToAction("AdminIndex","Home");
}
return View();
}
public static SupplierViewModel ToViewModel(this Supplier supplier)
{
var isAccountActivated = true;
if (!string.IsNullOrEmpty(supplier.AspNetUserId))
{
var context = ServiceLocator.Current.Resolve<IApplicationDbContext>();
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context as ApplicationDbContext));
isAccountActivated = userManager.IsInRole(supplier.AspNetUserId, Role.Supplier.ToString());
}
var vm = new SupplierViewModel
{
Id = supplier.Id,
Name = supplier.Name,
Address = supplier.Address,
VATStatus = supplier.VATStatus,
RC = supplier.RC,
Email = supplier.Email,
IsActive = supplier.IsActive,
IsAcceptingPayment = supplier.IsAcceptingPayment,
Iban = supplier.Iban,
Bank = supplier.Bank,
Fax = supplier.Fax,
Company = supplier.Company,
PostalCode = supplier.PostalCode,
CIF = supplier.CIF,
BrandLogo = supplier.BrandLogo,
BrandText = supplier.BrandText,
AspNetUserId = supplier.AspNetUserId,
IsAccountActivated = isAccountActivated
};
if (supplier.IsNew)
{
vm.Contact = new ContactViewModel() { Type = ContactType.Contact };
vm.Admin = new ContactViewModel() { Type = ContactType.Admin };
vm.ActivityPackages = new List<ActivityPackageViewModel>();
}
else
{
vm.Contact = (supplier.Contact ?? new Domain.Contact()).ToViewModel();
vm.Contact.Type = ContactType.Contact;
vm.Admin = (supplier.Admin ?? new Domain.Contact()).ToViewModel();
vm.Admin.Type = ContactType.Admin;
vm.ActivityPackages = new List<ActivityPackageViewModel>(supplier.ActivityPackages.ToViewModel());
}
return vm;
}
/// <summary>
/// Fixes the navbar login view.
/// </summary>
private void FixNavbarLoginView()
{
//Rolemanager
var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>());
var userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>());
//find controls from master page
var adminView = (LoginView) Master.FindControl("lvAdminContent");
var employeeView = (LoginView) Master.FindControl("lvEmployeeContent");
var userStatus = (LoginView) Master.FindControl("lvUserStatus");
//find user from list
//IdentityUser user = userManager.FindByName(listBoxAllUsers.SelectedValue);
if (User.Identity.IsAuthenticated)
{
IdentityUser user = userManager.FindByName(User.Identity.Name);
if (userManager.IsInRole(user.Id, "Admin"))
{
adminView.Visible = true;
employeeView.Visible = false;
userStatus.Visible = false;
}
else if (userManager.IsInRole(user.Id, "Employee"))
{
adminView.Visible = false;
employeeView.Visible = true;
userStatus.Visible = false;
}
else
{
adminView.Visible = false;
employeeView.Visible = false;
userStatus.Visible = true;
}
}
}
protected void LogIn(object sender, EventArgs e)
{
if (IsValid)
{
// Validate the user password
var userMgr = new UserManager();
var thisUsers = userMgr.Users;
ApplicationUser user = userMgr.Find(UserName.Text, Password.Text);
if (user != null)
{
if (!userMgr.IsInRole(user.Id, rdUserRole.Text))
{
FailureText.Text = "Invalid username or password";
ErrorMessage.Visible = true;
return;
}
IdentityHelper.SignIn(userMgr, user, RememberMe.Checked);
//ApplicationDbContext dbcon = new ApplicationDbContext();
//Grievance gr = new Grievance();
//gr.GrievanceDescription ="hello";
//gr.DateLogged = DateTime.Now;
//gr.TargetCompletionDate = DateTime.Now;
//gr.ResolutionStatus = Grievance.ResolutionStatuses.Created;
////gr.DateLogged = DateTime.Now;
//dbcon.Grievances.Add(gr);
//dbcon.SaveChanges();
if (rdUserRole.Text == "Auditor")
{
Response.Redirect("~/AuditorPortal/Complaints.aspx");
}
else if (rdUserRole.Text == "Administrator")
{
Response.Redirect("~/AdministratorPortal/Complaints.aspx");
}
else if (rdUserRole.Text == "Employee")
{
Response.Redirect("~/EmployeePortal/Tasks.aspx");
}
IdentityHelper.RedirectToReturnUrl(Request.QueryString["ReturnUrl"], Response);
}
else
{
FailureText.Text = "Invalid username or password.";
ErrorMessage.Visible = true;
}
}
}
protected override void Seed(Superhero.Data.SuperheroDBContext context)
{
IOrgRepo orgrepo = OrgRepoFactory.Create();
IHeroRepo herorepo = HeroRepoFactory.Create();
ILocationRepo locorepo = LocationRepoFactory.Create();
ISightingRepo sightingrepo = SightingRepoFactory.Create();
var userMgr = new UserManager <IdentityUser>(new UserStore <IdentityUser>(context));
var roleMgr = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
if (!roleMgr.RoleExists("User"))
{
var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
role.Name = "User";
roleMgr.Create(role);
}
if (!userMgr.Users.Any(u => u.UserName == "user"))
{
var user = new IdentityUser()
{
UserName = "******"
};
userMgr.Create(user, "testing");
}
var findmanager = userMgr.FindByName("user");
// create the user with the manager class
if (!userMgr.IsInRole(findmanager.Id, "user"))
{
userMgr.AddToRole(findmanager.Id, "user");
}
if (!roleMgr.RoleExists("admin"))
{
roleMgr.Create(new IdentityRole()
{
Name = "admin"
});
}
if (!userMgr.Users.Any(u => u.UserName == "admin"))
{
var user = new IdentityUser()
{
UserName = "******"
};
userMgr.Create(user, "testing");
}
var finduser = userMgr.FindByName("admin");
// create the user with the manager class
if (!userMgr.IsInRole(finduser.Id, "admin"))
{
userMgr.AddToRole(finduser.Id, "admin");
}
if (!context.Locations.Any(l => l.LocationName == "Minneapolis"))
{
var firstlocation = new Location
{
LocationName = "Minneapolis",
LocationAddress = "The Twin Cities",
LocationDescription = "A lovely city",
LatitudeCoordinate = 100,
LongitudeCoordinate = 100,
};
context.Locations.Add(firstlocation);
context.SaveChanges();
}
var location = context.Locations.First(l => l.LocationName == "Minneapolis");
if (!context.Organizations.Any(o => o.OrganizationName == "Minneapolis Hero Squad"))
{
var firstorg = new Organization
{
OrganizationName = "Minneapolis Hero Squad",
OganizationAddress = "S 5th street Minneapolis",
OrganizationLocation = location,
Phone = "123-456-7899",
};
context.Organizations.Add(firstorg);
context.SaveChanges();
}
var org = context.Organizations.First(l => l.OrganizationName == "Minneapolis Hero Squad");
if (!context.Heroes.Any(h => h.HeroName == "The Flash"))
{
var firsthero = new Hero
{
HeroName = "The Flash",
Organizations = new Collection <Organization>()
{
org
},
Description = "Wears a red/yellow suit",
Superpower = "Runs really fast",
};
context.Heroes.Add(firsthero);
context.SaveChanges();
}
var hero = context.Heroes.First(l => l.HeroName == "The Flash");
if (!context.Sightings.Any(s => s.SightingDescription == "We saw the Flash in Minneapolis"))
{
var firstsighting = new Sighting
{
SightingLocation = location,
SightingHeroes = new Collection <Hero>()
{
hero
},
Date = DateTime.Today,
SightingDescription = "We saw the Flash in Minneapolis",
IsDeleted = false,
Ispublished = true,
};
context.Sightings.Add(firstsighting);
}
context.SaveChanges();
}
// Wrapper method
public bool IsUserInRole(string userId, string roleName)
{
return(userManager.IsInRole(userId, roleName));
}
public ActionResult AssignRoles(string id, FormCollection form)
{
var db = new ApplicationDbContext();
var user = db.Users.Find(id);
var RoleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
var UserManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
//if (form["isInIT"] != null)
//{
// if (!UserManager.IsInRole(id, "IT"))
// {
// UserManager.AddToRole(id, "IT");
// }
//}
//else
//{
// if (UserManager.IsInRole(id, "IT"))
// {
// UserManager.RemoveFromRole(id, "IT");
// }
//}
//if (form["isInAdmin"] != null)
//{
// if (!UserManager.IsInRole(id, "admin"))
// {
// UserManager.AddToRole(id, "admin");
// }
//}
//else
//{
// if (UserManager.IsInRole(id, "admin"))
// {
// UserManager.RemoveFromRole(id, "admin");
// }
//}
if (form["isInStudent"] != null)
{
if (!UserManager.IsInRole(id, "student"))
{
UserManager.AddToRole(id, "student");
}
}
else
{
if (UserManager.IsInRole(id, "student"))
{
UserManager.RemoveFromRole(id, "student");
}
}
if (form["isInTA"] != null)
{
if (!UserManager.IsInRole(id, "ta"))
{
UserManager.AddToRole(id, "ta");
}
}
else
{
if (UserManager.IsInRole(id, "ta"))
{
UserManager.RemoveFromRole(id, "ta");
}
}
if (form["isInProfessor"] != null)
{
if (!UserManager.IsInRole(id, "Professor"))
{
UserManager.AddToRole(id, "Professor");
}
}
else
{
if (UserManager.IsInRole(id, "Professor"))
{
UserManager.RemoveFromRole(id, "Professor");
}
}
return(RedirectToAction("Users", "Manage"));
}
protected override void Seed(BugTracker_V2.Models.ApplicationDbContext context)
{
//Create Admin Role
var roleManager = new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
if (!context.Roles.Any(r => r.Name == "Admin"))
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
}
//Create Default Admin
var userManager = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context));
var adminEmail = ConfigurationManager.AppSettings["AdminEmail"];
if (!context.Users.Any(u => u.Email == adminEmail))
{
userManager.Create(new ApplicationUser
{
UserName = ConfigurationManager.AppSettings["AdminEmail"],
Email = ConfigurationManager.AppSettings["AdminEmail"],
FirstName = ConfigurationManager.AppSettings["AdminFirstName"],
LastName = ConfigurationManager.AppSettings["AdminLastName"],
DisplayName = ConfigurationManager.AppSettings["AdminDisplayName"]
}, ConfigurationManager.AppSettings["AdminPassword"]);
}
//Add Default Admin to Admin Role
var userId = userManager.FindByEmail(adminEmail).Id;
if (!userManager.IsInRole(userId, "Admin"))
{
userManager.AddToRole(userId, "Admin");
}
//Create Project Manager Role
var roleManager2 = new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
if (!context.Roles.Any(r => r.Name == "ProjectManager"))
{
roleManager2.Create(new IdentityRole {
Name = "ProjectManager"
});
}
//Create Default Project Manager
var userManger2 = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context));
var pManagerEmail = ConfigurationManager.AppSettings["PMEmail"];
if (!context.Users.Any(u => u.Email == pManagerEmail))
{
userManger2.Create(new ApplicationUser
{
UserName = ConfigurationManager.AppSettings["PMEmail"],
Email = ConfigurationManager.AppSettings["PMEmail"],
FirstName = ConfigurationManager.AppSettings["PMFirstName"],
LastName = ConfigurationManager.AppSettings["PMLastName"],
DisplayName = ConfigurationManager.AppSettings["PMDisplayName"]
}, ConfigurationManager.AppSettings["PMPassword"]);
}
//Add Default Project Manager to Project Manger Role
var pmId = userManger2.FindByEmail(pManagerEmail).Id;
userManger2.AddToRole(pmId, "ProjectManager");
//Create Developer Role
var roleManager3 = new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
if (!context.Roles.Any(r => r.Name == "Developer"))
{
roleManager3.Create(new IdentityRole {
Name = "Developer"
});
}
//Create Default Developer
var userManger3 = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context));
var developerEmail = ConfigurationManager.AppSettings["DVEmail"];
if (!context.Users.Any(u => u.Email == developerEmail))
{
userManger3.Create(new ApplicationUser
{
UserName = ConfigurationManager.AppSettings["DVEmail"],
Email = ConfigurationManager.AppSettings["DVEmail"],
FirstName = ConfigurationManager.AppSettings["DVFirstName"],
LastName = ConfigurationManager.AppSettings["DVLastName"],
DisplayName = ConfigurationManager.AppSettings["DVDisplayName"]
}, ConfigurationManager.AppSettings["DVPassword"]);
}
//Add Default Developer to Developer Role
var dvId = userManger3.FindByEmail(developerEmail).Id;
userManger3.AddToRole(dvId, "Developer");
//Create Default Submitter Role
var roleManager4 = new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
if (!context.Roles.Any(r => r.Name == "Submitter"))
{
roleManager4.Create(new IdentityRole {
Name = "Submitter"
});
}
//Create Default Submitter
var userManager4 = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context));
var submitterEmail = ConfigurationManager.AppSettings["SMEmail"];
if (!context.Users.Any(u => u.Email == submitterEmail))
{
userManager4.Create(new ApplicationUser
{
UserName = ConfigurationManager.AppSettings["SMEmail"],
Email = ConfigurationManager.AppSettings["SMEmail"],
FirstName = ConfigurationManager.AppSettings["SMFirstName"],
LastName = ConfigurationManager.AppSettings["SMLastName"],
DisplayName = ConfigurationManager.AppSettings["SMDisplayName"]
}, ConfigurationManager.AppSettings["SMPassword"]);
}
//Add Default Submitter to Submitter Role
var smId = userManager4.FindByEmail(submitterEmail).Id;
userManager4.AddToRole(smId, "Submitter");
}
public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
{
if (error != null)
{
return(Redirect(Url.Content("~/") + "#error=" + Uri.EscapeDataString(error)));
}
if (!User.Identity.IsAuthenticated)
{
return(new ChallengeResult(provider, this));
}
ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
if (externalLogin == null)
{
return(InternalServerError());
}
if (externalLogin.LoginProvider != provider)
{
Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
return(new ChallengeResult(provider, this));
}
ApplicationUser user = await UserManager.FindAsync(new UserLoginInfo(externalLogin.LoginProvider,
externalLogin.ProviderKey));
bool hasRegistered = user != null;
if (hasRegistered)
{
Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(UserManager,
OAuthDefaults.AuthenticationType);
ClaimsIdentity cookieIdentity = await user.GenerateUserIdentityAsync(UserManager,
CookieAuthenticationDefaults.AuthenticationType);
string loginPath = "";
if (UserManager.IsInRole(user.Id, "Teacher"))
{
loginPath = "/Teacher/Details/";
}
else if (UserManager.IsInRole(user.Id, "Student"))
{
loginPath = "/Student/Details/";
}
else if (UserManager.IsInRole(user.Id, "Admin"))
{
loginPath = "/Admin/Details/";
}
AuthenticationProperties properties = ApplicationOAuthProvider.CreateProperties(user.UserName, user.Id, loginPath);
Authentication.SignIn(properties, oAuthIdentity, cookieIdentity);
}
else
{
IEnumerable <Claim> claims = externalLogin.GetClaims();
ClaimsIdentity identity = new ClaimsIdentity(claims, OAuthDefaults.AuthenticationType);
Authentication.SignIn(identity);
}
return(Ok());
}
/// <summary>
/// Handles the ItemDataBound event of the AttachmentsDataGrid control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Web.UI.WebControls.DataGridItemEventArgs"/> instance containing the event data.</param>
protected void AttachmentsDataGridItemDataBound(object sender, DataGridItemEventArgs e)
{
if (e.Item.ItemType != ListItemType.Item && e.Item.ItemType != ListItemType.AlternatingItem) return;
var currentAttachment = (IssueAttachment)e.Item.DataItem;
var lnkAttachment = e.Item.FindControl("lnkAttachment") as HtmlAnchor;
if (lnkAttachment != null)
{
if (HostSettingManager.Get(HostSettingNames.AttachmentStorageType, 0) == (int)IssueAttachmentStorageTypes.FileSystem)
{
lnkAttachment.InnerText = IssueAttachmentManager.StripGuidFromFileName(currentAttachment.FileName);
}
else
{
lnkAttachment.InnerText = currentAttachment.FileName;
}
lnkAttachment.HRef = string.Concat("DownloadAttachment.axd?id=", currentAttachment.Id.ToString());
}
var lblSize = e.Item.FindControl("lblSize") as Label;
if (lblSize == null) return;
float size;
string label;
if (currentAttachment.Size > 1000)
{
size = currentAttachment.Size / 1000f;
label = string.Format("{0} kb", size.ToString("##,##"));
}
else
{
size = currentAttachment.Size;
label = string.Format("{0} b", size.ToString("##,##"));
}
lblSize.Text = label;
var cmdDelete = e.Item.FindControl("cmdDelete") as ImageButton;
// Check if the current user is Authenticated and has the permission to delete a comment
if (!Page.User.Identity.IsAuthenticated || !UserManager.HasPermission(ProjectId, Common.Permission.DeleteAttachment.ToString())) return;
if (cmdDelete == null) return;
cmdDelete.Attributes.Add("onclick", string.Format("return confirm('{0}');", GetLocalResourceObject("DeleteAttachment").ToString().Trim().JsEncode()));
cmdDelete.Visible = false;
// Check if it is the original user, the project admin or a super user trying to delete the comment.
if (currentAttachment.CreatorUserName.ToLower() == Context.User.Identity.Name.ToLower() || UserManager.IsSuperUser() || UserManager.IsInRole(ProjectId, Globals.ProjectAdminRole))
{
cmdDelete.Visible = true;
}
}
protected override void Seed(UowMVC.Repository.DefaultDataContext context)
{
var userStore = new UserStore <ApplicationUser, ApplicationRole, string, IdentityUserLogin, IdentityUserRole, IdentityUserClaim>(context);
var userManager = new UserManager <ApplicationUser, string>(userStore);
context.Roles.AddOrUpdate(x => x.Name, new ApplicationRole
{
Name = ApplicationRoleTypeEnum.Administrator.ToDescription(),
CreateAt = DateTime.Now,
Type = ApplicationRoleTypeEnum.Administrator,
});
context.Roles.AddOrUpdate(x => x.Name, new ApplicationRole
{
Name = ApplicationRoleTypeEnum.Admin.ToDescription(),
CreateAt = DateTime.Now,
Type = ApplicationRoleTypeEnum.Admin,
});
context.Roles.AddOrUpdate(x => x.Name, new ApplicationRole
{
Name = ApplicationRoleTypeEnum.User.ToDescription(),
CreateAt = DateTime.Now,
Type = ApplicationRoleTypeEnum.User,
});
context.SaveChanges();
var superadmin = userManager.FindByName("superadmin");
if (superadmin == null)
{
superadmin = new ApplicationUser
{
Num = "00001",
UserName = "******",
Name = "超级管理员",
IsSuperAdmin = true,
Type = ApplicationUserTypeEnum.Administrator,
CreateAt = DateTime.Now,
};
userManager.Create(superadmin, "123456");
userManager.AddToRole(superadmin.Id, ApplicationRoleTypeEnum.Administrator.ToDescription());
}
else
{
superadmin.IsSuperAdmin = true;
context.Entry(superadmin).State = EntityState.Modified;
}
if (userManager.IsInRole(superadmin.Id, ApplicationRoleTypeEnum.Administrator.ToDescription()) == false)
{
userManager.AddToRole(superadmin.Id, ApplicationRoleTypeEnum.Administrator.ToDescription());
}
var admin = userManager.FindByName("admin");
if (admin == null)
{
admin = new ApplicationUser
{
Num = "00001",
UserName = "******",
Name = "管理员",
IsSuperAdmin = false,
Type = ApplicationUserTypeEnum.Administrator,
CreateAt = DateTime.Now,
};
userManager.Create(admin, "123456");
userManager.AddToRole(admin.Id, ApplicationRoleTypeEnum.Admin.ToDescription());
}
if (userManager.IsInRole(admin.Id, ApplicationRoleTypeEnum.Admin.ToDescription()) == false)
{
userManager.AddToRole(admin.Id, ApplicationRoleTypeEnum.Admin.ToDescription());
}
var user = userManager.FindByName("user");
if (user == null)
{
user = new ApplicationUser
{
Num = "00002",
UserName = "******",
Name = "smaple-user",
Type = ApplicationUserTypeEnum.User,
CreateAt = DateTime.Now,
};
userManager.Create(user, "123456");
}
if (!context.Configurations.Any(x => x.Key == ConfigKeys.Site_Name_Key))
{
context.Configurations.Add(new Domain.Configuration
{
Key = ConfigKeys.Site_Name_Key,
No = 1,
Type = ConfigurationTypeEnum.String,
Value = "Uow MVC"
});
}
if (!context.Configurations.Any(x => x.Key == ConfigKeys.Site_Logo_Key))
{
context.Configurations.Add(new Domain.Configuration
{
Key = ConfigKeys.Site_Logo_Key,
No = 2,
Type = ConfigurationTypeEnum.Image,
Value = "/images/logo.png"
});
}
if (!context.Configurations.Any(x => x.Key == ConfigKeys.Log_IsLog_Key))
{
context.Configurations.Add(new Domain.Configuration
{
Key = ConfigKeys.Log_IsLog_Key,
No = 3,
Type = ConfigurationTypeEnum.Bool,
Value = "是"
});
}
if (!context.Configurations.Any(x => x.Key == ConfigKeys.User_Default_Avater_Key))
{
context.Configurations.Add(new Domain.Configuration
{
Key = ConfigKeys.User_Default_Avater_Key,
No = 4,
Type = ConfigurationTypeEnum.Image,
Value = "/images/default-avatar.png"
});
}
var superadminRole = context.Roles.FirstOrDefault(x => x.Type == ApplicationRoleTypeEnum.Administrator);
var superadminRolePermissions = context.RolePermissions.Where(x => x.Role.Id == superadminRole.Id);
if (!superadminRolePermissions.Any())
{
var menus = context.Menus.ToList();
foreach (var m in menus)
{
var permission = new RolePermission
{
Menu = m,
Role = superadminRole,
};
context.RolePermissions.Add(permission);
}
}
var adminRole = context.Roles.FirstOrDefault(x => x.Type == ApplicationRoleTypeEnum.Admin);
var adminRolePermissions = context.RolePermissions.Where(x => x.Role.Id == adminRole.Id);
if (!adminRolePermissions.Any())
{
var menus = context.Menus.Where(x => x.IsControlPanel == false).ToList();
foreach (var m in menus)
{
var permission = new RolePermission
{
Menu = m,
Role = superadminRole,
};
context.RolePermissions.Add(permission);
}
}
context.SaveChanges();
}
protected override void Seed(ApplicationDbContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));
context.TicketTypes.AddOrUpdate(p => p.Id,
new TicketType()
{
Id = 1, Title = "Software Update"
},
new TicketType()
{
Id = 2, Title = "Database Eror"
},
new TicketType()
{
Id = 3, Title = "Bug fixes"
},
new TicketType()
{
Id = 4, Title = "Adding Helpers"
});
context.TicketPriorities.AddOrUpdate(p => p.Id,
new TicketPriority()
{
Id = 1, Title = "Low"
},
new TicketPriority()
{
Id = 2, Title = "Medium"
},
new TicketPriority()
{
Id = 3, Title = "High"
},
new TicketPriority()
{
Id = 4, Title = "Urgent"
});
context.TicketStatus.AddOrUpdate(p => p.Id,
new TicketStatus()
{
Id = 1, Title = "started"
},
new TicketStatus()
{
Id = 2, Title = "finished"
},
new TicketStatus()
{
Id = 3, Title = "completed"
},
new TicketStatus()
{
Id = 4, Title = "incomplete"
});
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
//Check if Roles already exist on the database/
//If not, create them.
if (!context.Roles.Any(r => r.Name == "Admin"))
{
var role = new IdentityRole("Admin");
roleManager.Create(role);
}
if (!context.Roles.Any(r => r.Name == "Project Manager"))
{
roleManager.Create(new IdentityRole {
Name = "Project Manager"
});
}
if (!context.Roles.Any(r => r.Name == "Developer"))
{
roleManager.Create(new IdentityRole {
Name = "Developer"
});
}
if (!context.Roles.Any(r => r.Name == "Submitter"))
{
roleManager.Create(new IdentityRole {
Name = "Submitter"
});
}
ApplicationUser adminUser = null;
ApplicationUser SubmitterUser = null;
ApplicationUser DeveloperUser = null;
ApplicationUser ProjectManager = null;
//Check if user exists on the database.
//If not, create it.
if (!context.Users.Any(p => p.UserName == "*****@*****.**"))
{
adminUser = new ApplicationUser();
adminUser.UserName = "******";
adminUser.Email = "*****@*****.**";
adminUser.FirstName = "Admin";
adminUser.LastName = "User";
adminUser.DisplayName = "Admin";
userManager.Create(adminUser, "Deep211@");
}
else
{
//Get user from the database
adminUser = context.Users.Where(p => p.UserName == "*****@*****.**")
.FirstOrDefault();
}
if (!context.Users.Any(p => p.UserName == "*****@*****.**"))
{
SubmitterUser = new ApplicationUser();
SubmitterUser.UserName = "******";
SubmitterUser.Email = "*****@*****.**";
SubmitterUser.FirstName = "Submitter";
SubmitterUser.LastName = "User";
SubmitterUser.DisplayName = "Submitter";
userManager.Create(SubmitterUser, "Deep23@");
}
else
{
//Get user from the database
SubmitterUser = context.Users.Where(p => p.UserName == "*****@*****.**")
.FirstOrDefault();
}
if (!context.Users.Any(p => p.UserName == "*****@*****.**"))
{
DeveloperUser = new ApplicationUser();
DeveloperUser.UserName = "******";
DeveloperUser.Email = "*****@*****.**";
DeveloperUser.FirstName = "Developer";
DeveloperUser.LastName = "User";
DeveloperUser.DisplayName = "Developer";
userManager.Create(DeveloperUser, "Deep1@");
}
else
{
//Get user from the database
DeveloperUser = context.Users.Where(p => p.UserName == "*****@*****.**")
.FirstOrDefault();
}
if (!context.Users.Any(p => p.UserName == "*****@*****.**"))
{
ProjectManager = new ApplicationUser();
ProjectManager.UserName = "******";
ProjectManager.Email = "*****@*****.**";
ProjectManager.FirstName = "ProjectManager";
ProjectManager.LastName = "User";
ProjectManager.DisplayName = "ProjectManager";
userManager.Create(ProjectManager, "Deep2@");
}
else
{
//Get user from the database
ProjectManager = context.Users.Where(p => p.UserName == "*****@*****.**")
.FirstOrDefault();
}
//Check if the adminUser is already on the Admin role
//If not, add it.
if (!userManager.IsInRole(adminUser.Id, "Admin"))
{
userManager.AddToRole(adminUser.Id, "Admin");
}
if (!userManager.IsInRole(DeveloperUser.Id, "Developer"))
{
userManager.AddToRole(DeveloperUser.Id, "Developer");
}
if (!userManager.IsInRole(ProjectManager.Id, "Project Manager"))
{
userManager.AddToRole(ProjectManager.Id, "Project Manager");
}
if (!userManager.IsInRole(SubmitterUser.Id, "Submitter"))
{
userManager.AddToRole(SubmitterUser.Id, "Submitter");
}
}
internal bool CurrentUserIsInRole(Roles role)
{
return(UserManager.IsInRole(CurrentUser.Id, role.ToString()));
}
protected override void Seed(Restaurant.Models.ApplicationDbContext context)
{
var roleManager =
new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
var userManager =
new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context));
if (!context.Roles.Any(p => p.Name == "Admin"))
{
var adminRole = new IdentityRole("Admin");
roleManager.Create(adminRole);
}
if (!context.Roles.Any(p => p.Name == "Moderator"))
{
var moderatorRole = new IdentityRole("Moderator");
roleManager.Create(moderatorRole);
}
ApplicationUser adminUser;
ApplicationUser moderatorUser;
if (!context.Users.Any(p => p.UserName == "*****@*****.**"))
{
adminUser = new ApplicationUser();
adminUser.UserName = "******";
adminUser.Email = "*****@*****.**";
userManager.Create(adminUser, "Password-1");
}
else
{
adminUser = context.Users.First(p => p.UserName == "*****@*****.**");
}
if (!context.Users.Any(p => p.UserName == "*****@*****.**"))
{
moderatorUser = new ApplicationUser();
moderatorUser.Email = "*****@*****.**";
moderatorUser.UserName = "******";
userManager.Create(moderatorUser, "Password-1`");
}
else
{
moderatorUser = context.Users.First(p => p.UserName == "*****@*****.**");
}
if (!userManager.IsInRole(adminUser.Id, "Admin"))
{
userManager.AddToRole(adminUser.Id, "Admin");
}
if (!userManager.IsInRole(moderatorUser.Id, "Moderator"))
{
userManager.AddToRole(moderatorUser.Id, "Moderator");
}
}
protected override void Seed(BugTracker.Models.ApplicationDbContext context)
{
RoleManager <IdentityRole> roleManager =
new RoleManager <IdentityRole>(
new RoleStore <Microsoft.AspNet.Identity.EntityFramework.IdentityRole>(context));
var userManager =
new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(context));
if (!context.Roles.Any(p => p.Name == "Admin"))
{
var adminRole = new IdentityRole("Admin");
roleManager.Create(adminRole);
}
if (!context.Roles.Any(p => p.Name == "Project Manager"))
{
var managerRole = new IdentityRole("Project Manager");
roleManager.Create(managerRole);
}
if (!context.Roles.Any(p => p.Name == "Developer"))
{
var developerRole = new IdentityRole("Developer");
roleManager.Create(developerRole);
}
if (!context.Roles.Any(p => p.Name == "Submitter"))
{
var submitterRole = new IdentityRole("Submitter");
roleManager.Create(submitterRole);
}
ApplicationUser adminUser;
if (!context.Users.Any(
p => p.UserName == "*****@*****.**"))
{
adminUser = new ApplicationUser();
adminUser.UserName = "******";
adminUser.Email = "*****@*****.**";
adminUser.EmailConfirmed = true;
adminUser.DisplayName = "admin";
userManager.Create(adminUser, "Password-1");
}
else
{
adminUser = context
.Users
.First(p => p.UserName == "*****@*****.**");
}
if (!userManager.IsInRole(adminUser.Id, "Admin"))
{
userManager.AddToRole(adminUser.Id, "Admin");
}
ApplicationUser demoAdmin;
if (!context.Users.Any(
p => p.UserName == "*****@*****.**"))
{
demoAdmin = new ApplicationUser();
demoAdmin.UserName = "******";
demoAdmin.Email = "*****@*****.**";
demoAdmin.EmailConfirmed = true;
demoAdmin.DisplayName = "Demo-Admin";
userManager.Create(demoAdmin, "Password-1");
}
else
{
demoAdmin = context
.Users
.First(p => p.UserName == "*****@*****.**");
}
if (!userManager.IsInRole(demoAdmin.Id, "Admin"))
{
userManager.AddToRole(demoAdmin.Id, "Admin");
}
ApplicationUser demoDeveloper;
if (!context.Users.Any(
p => p.UserName == "*****@*****.**"))
{
demoDeveloper = new ApplicationUser();
demoDeveloper.UserName = "******";
demoDeveloper.Email = "*****@*****.**";
demoDeveloper.EmailConfirmed = true;
demoDeveloper.DisplayName = "Demo-Developer";
userManager.Create(demoDeveloper, "Password-1");
}
else
{
demoDeveloper = context
.Users
.First(p => p.UserName == "*****@*****.**");
}
if (!userManager.IsInRole(demoDeveloper.Id, "Developer"))
{
userManager.AddToRole(demoDeveloper.Id, "Developer");
}
ApplicationUser demoProjectManager;
if (!context.Users.Any(
p => p.UserName == "*****@*****.**"))
{
demoProjectManager = new ApplicationUser();
demoProjectManager.UserName = "******";
demoProjectManager.Email = "*****@*****.**";
demoProjectManager.EmailConfirmed = true;
demoProjectManager.DisplayName = "Demo-ProjectManager";
userManager.Create(demoProjectManager, "Password-1");
}
else
{
demoProjectManager = context
.Users
.First(p => p.UserName == "*****@*****.**");
}
if (!userManager.IsInRole(demoProjectManager.Id, "Project Manager"))
{
userManager.AddToRole(demoProjectManager.Id, "Project Manager");
}
ApplicationUser demoSubmitter;
if (!context.Users.Any(
p => p.UserName == "*****@*****.**"))
{
demoSubmitter = new ApplicationUser();
demoSubmitter.UserName = "******";
demoSubmitter.Email = "*****@*****.**";
demoSubmitter.EmailConfirmed = true;
demoSubmitter.DisplayName = "Demo-Submitter";
userManager.Create(demoSubmitter, "Password-1");
}
else
{
demoSubmitter = context
.Users
.First(p => p.UserName == "*****@*****.**");
}
if (!userManager.IsInRole(demoSubmitter.Id, "Submitter"))
{
userManager.AddToRole(demoSubmitter.Id, "Submitter");
}
context.TicketTypes.AddOrUpdate(x => x.Id,
new Models.Domain.Tickets.TicketType()
{
Id = 1, Name = "Bug"
},
new Models.Domain.Tickets.TicketType()
{
Id = 2, Name = "Feature"
},
new Models.Domain.Tickets.TicketType()
{
Id = 3, Name = "Database"
},
new Models.Domain.Tickets.TicketType()
{
Id = 4, Name = "Support"
});
context.TicketPriorities.AddOrUpdate(x => x.Id,
new Models.Domain.Tickets.TicketPriority()
{
Id = 1, Name = "Low"
},
new Models.Domain.Tickets.TicketPriority()
{
Id = 2, Name = "Medium"
},
new Models.Domain.Tickets.TicketPriority()
{
Id = 3, Name = "High"
});
context.TicketStatus.AddOrUpdate(x => x.Id,
new Models.Domain.Tickets.TicketStatus()
{
Id = 1, Name = "Open"
},
new Models.Domain.Tickets.TicketStatus()
{
Id = 2, Name = "Resolved"
},
new Models.Domain.Tickets.TicketStatus()
{
Id = 3, Name = "Rejected"
});
context.SaveChanges();
}
protected override void Seed(LearningSystemContext context)
{
var roleStore = new RoleStore <IdentityRole>(context);
var roleManager = new RoleManager <IdentityRole>(roleStore);
foreach (var roleName in Constants.Roles)
{
if (!roleManager.Roles.Any(r => r.Name == roleName))
{
var role = new IdentityRole(roleName);
roleManager.Create(role);
}
}
var userStore = new UserStore <ApplicationUser>(context);
var userManager = new UserManager <ApplicationUser>(userStore);
var user = new ApplicationUser {
CUsername = "******", Email = "*****@*****.**", UserName = "******"
};
if (!userManager.Users.Any(u => u.Email == user.Email && u.UserName == user.UserName))
{
var result = userManager.Create(user, "Administrator123#");
if (!result.Succeeded)
{
throw new Exception("Could not create administrator account");
}
}
var adminId = userManager.Users.FirstOrDefault(u => u.Email == user.Email && u.UserName == user.UserName).Id;
if (!userManager.IsInRole(adminId, "Administrator"))
{
userManager.AddToRole(adminId, "Administrator");
}
if (!userManager.IsInRole(adminId, "BlogAuthor"))
{
userManager.AddToRole(adminId, "BlogAuthor");
}
if (!userManager.IsInRole(adminId, "Trainer"))
{
userManager.AddToRole(adminId, "Trainer");
}
if (!userManager.IsInRole(adminId, "Student"))
{
userManager.AddToRole(adminId, "Student");
}
if (!context.Students.Any(i => i.Id == adminId))
{
context.Students.Add(new Student()
{
Id = adminId
});
context.SaveChanges();
}
context.Courses.Add(new Course()
{
Name = "Probaaa1",
Description = "Description1",
StartDate = DateTime.Now.AddDays(5),
EndDate = DateTime.Now.AddDays(15)
});
context.Courses.Add(new Course()
{
Name = "Probaaa2",
Description = "Description1",
StartDate = DateTime.Now.AddDays(5),
EndDate = DateTime.Now.AddDays(15)
});
context.Courses.Add(new Course()
{
Name = "Probaaa3",
Description = "Description1",
StartDate = DateTime.Now.AddDays(5),
EndDate = DateTime.Now.AddDays(15)
});
context.Courses.Add(new Course()
{
Name = "Probaaa4",
Description = "Description1",
StartDate = DateTime.Now.AddDays(5),
EndDate = DateTime.Now.AddDays(15)
});
}
/// <summary>
/// Initializes a new instance of the <see cref="SuckerFishMenuHelper"/> class.
/// </summary>
/// <param name="projectId">The project id.</param>
public SuckerFishMenuHelper(int projectId)
{
//Setup menu...
Items.Add(new SuckerMenuItem("~/Default", Resources.SharedResources.Home, this));
if (HttpContext.Current.User.Identity.IsAuthenticated)
{
Items.Add(new SuckerMenuItem("~/Issues/MyIssues", Resources.SharedResources.MyIssues, this));
}
if (projectId > Globals.NEW_ID)
{
var oItemProject = new SuckerMenuItem("#", Resources.SharedResources.Project, this, "dropdown");
Items.Insert(1, oItemProject);
oItemProject.Items.Add(new SuckerMenuItem(string.Format("~/Projects/ProjectSummary/{0}", projectId), Resources.SharedResources.ProjectSummary, this));
oItemProject.Items.Add(new SuckerMenuItem(string.Format("~/Projects/Roadmap/{0}", projectId), Resources.SharedResources.Roadmap, this));
oItemProject.Items.Add(new SuckerMenuItem(string.Format("~/Projects/ChangeLog/{0}", projectId), Resources.SharedResources.ChangeLog, this));
oItemProject.Items.Add(new SuckerMenuItem(string.Format("~/Projects/ProjectCalendar.aspx?pid={0}", projectId), Resources.SharedResources.Calendar, this));
if (!string.IsNullOrEmpty(ProjectManager.GetById(projectId).SvnRepositoryUrl))
{
oItemProject.Items.Add(new SuckerMenuItem(string.Format("~/SvnBrowse/SubversionBrowser.aspx?pid={0}", projectId), Resources.SharedResources.Repository, this));
}
var oItemIssues = new SuckerMenuItem("#", Resources.SharedResources.Issues, this, "dropdown");
oItemIssues.Items.Add(new SuckerMenuItem(string.Format("~/Issues/IssueList.aspx?pid={0}", projectId), Resources.SharedResources.Issues, this));
oItemIssues.Items.Add(new SuckerMenuItem(string.Format("~/Queries/QueryList.aspx?pid={0}", projectId), Resources.SharedResources.Queries, this));
Items.Insert(2, oItemIssues);
if (HttpContext.Current.User.Identity.IsAuthenticated)
{
//check add issue permission
if (UserManager.HasPermission(projectId, Common.Permission.AddIssue.ToString()))
{
Items.Add(new SuckerMenuItem(string.Format("~/Issues/CreateIssue/{0}", projectId), Resources.SharedResources.NewIssue, this));
}
}
}
if (!HttpContext.Current.User.Identity.IsAuthenticated)
{
return;
}
var oItemAdmin = new SuckerMenuItem("#", Resources.SharedResources.Admin, this, "navbar-admin");
if (projectId > Globals.NEW_ID && (UserManager.IsInRole(projectId, Globals.ProjectAdminRole) || UserManager.IsSuperUser()))
{
oItemAdmin.Items.Add(new SuckerMenuItem(string.Format("~/Administration/Projects/EditProject/{0}", projectId), Resources.SharedResources.EditProject, this, "admin"));
}
if (UserManager.IsSuperUser())
{
oItemAdmin.Items.Add(new SuckerMenuItem("~/Administration/Projects/ProjectList", Resources.SharedResources.Projects, this));
oItemAdmin.Items.Add(new SuckerMenuItem("~/Administration/Users/UserList", Resources.SharedResources.UserAccounts, this));
oItemAdmin.Items.Add(new SuckerMenuItem("~/Administration/Host/Settings", Resources.SharedResources.ApplicationConfiguration, this));
oItemAdmin.Items.Add(new SuckerMenuItem("~/Administration/Host/LogViewer", Resources.SharedResources.LogViewer, this));
}
if (oItemAdmin.Items.Count > 0)
{
Items.Add(oItemAdmin);
}
}
public ActionResult AddRole(string userId, FormCollection form)
{
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var users = userManager.Users.ToList();
var user = users.Find(x => x.Id == userId);
var userView = new UserView {
Email = user.Email, Nome = user.UserName, UserId = user.Id
};
//guarda informações que vem via metodo post. Se seleciono algo no combo eu seleciono um RoleId que vem pra cá via post
var roleId = Request["RoleId"];
//se o roleId que vier via post for vazio, é que vc não selecionou nada na combo permissões
if (string.IsNullOrEmpty(roleId))
{
//limpar a lista
var list = roleManager.Roles.ToList();
list.Add(new IdentityRole {
Id = "", Name = "[Selecione uma permissão!]"
});
list = list.OrderBy(c => c.Name).ToList();
ViewBag.RoleId = new SelectList(list, "Id", "Name");
//gera um ViewBag com erro, colocado na View
ViewBag.Error = "Você precisa selecionar uma permissão.";
return(View(userView));
}
var roles = roleManager.Roles.ToList();
var role = roles.Find(x => x.Id == roleId);
if (!userManager.IsInRole(userId, role.Name))
{
userManager.AddToRole(userId, role.Name);
}
//Agora que adicionou a role, recrie a visão, tanto de usuario quanto de roles.
//var que guardará as roles do meu usuario no for logo abaixo
var rolesViews = new List <RoleView>();
//pegue o codigo de cada User.Rolers (porque elas não são roleViews que ai sim são recebida em uma userView).
//Resumo: Pegue uma role que (não é viewTipada e não pode ser vista).Isole e jogue e uma Viewrole (ViwTipada). Adicione em uma Lista de ViewRoles
foreach (var item in user.Roles)
{
//isole o item role do user.Role (ele não é um model ou ViewModel, portanto não poderá ser visto em uma ViewTipada.
role = roles.Find(x => x.Id == item.RoleId); //erro: comparar com = e não com "=="
//roleView sim podem ser vistas porque é ViewModel. Pegue os dados da role acima e jogue numa roleView
var roleView = new RoleView {
RoleId = role.Id, Name = role.Name
};
rolesViews.Add(roleView);
}
/*
* var roles2 = new List<RoleView>();
* foreach (var item in user.Roles)
* {
* role = roles.Find(x => x.Id == item.RoleId);
* var roleView2 = new RoleView { RoleId = role.Id, Name = role.Name };
* roles2.Add(roleView2);
* userView = new UserView { UserId = user.Id, Nome = user.UserName, Roles = roles2 };
* }
*/
userView = new UserView {
Roles = rolesViews, Email = user.Email, Nome = user.UserName, UserId = user.Id
};
return(View("Roles", userView));
}
public async Task <ActionResult> Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
ApplicationUser user = await UserManager.FindAsync(model.Email, model.Password);
if (user == null)
{
ModelState.AddModelError("", "Невірний логін або пароль.");
}
else
{
ClaimsIdentity claim = await UserManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claim);
ApplicationContext userscontext = new ApplicationContext();
var userStore = new UserStore <ApplicationUser>(userscontext);
var userManager = new UserManager <ApplicationUser>(userStore);
var roleStore = new RoleStore <IdentityRole>(userscontext);
var roleManager = new RoleManager <IdentityRole>(roleStore);
if (!roleManager.RoleExists("Admin"))
{
roleManager.Create(new IdentityRole("Admin"));
}
if (!roleManager.RoleExists("Student"))
{
roleManager.Create(new IdentityRole("Student"));
}
if (!roleManager.RoleExists("Teacher"))
{
roleManager.Create(new IdentityRole("Teacher"));
}
if (!userManager.IsInRole("7ceba0d4-09a5-4adc-b090-97a020022cfe", "Admin"))
{
userManager.AddToRole("7ceba0d4-09a5-4adc-b090-97a020022cfe", "Admin");
}
if (userManager.IsInRole(user.Id, "Admin") == false && userManager.IsInRole(user.Id, "Student") == false &&
userManager.IsInRole(user.Id, "Teacher"))
{
userManager.AddToRole(user.Id, "Student");
}
if (String.IsNullOrEmpty(returnUrl) && UserManager.IsInRole(user.Id, "Student"))
{
return(RedirectToAction("List", "Themes"));
}
else
{
if (String.IsNullOrEmpty(returnUrl) && UserManager.IsInRole(user.Id, "Admin"))
{
return(RedirectToAction("Index", "Roles"));
}
else
{
if (String.IsNullOrEmpty(returnUrl) && UserManager.IsInRole(user.Id, "Teacher"))
{
return(RedirectToAction("List", "Article"));
}
}
}
return(RedirectToAction("List", "Article"));
}
}
ViewBag.returnUrl = returnUrl;
return(View(model));
}
private ApplicationUser CreateUser(
BugTracker.Models.ApplicationDbContext context,
RoleManager <IdentityRole> roleManager,
UserManager <ApplicationUser> userManager,
string displayName,
string userName,
string userEmail,
string userPassword = "******",
string userRole = null
)
{
/// <summary>
/// Adding new role if it doesn't exist.
/// </summary>
if (!string.IsNullOrEmpty(userRole) && !string.IsNullOrWhiteSpace(userRole) && !context.Roles.Any(role => role.Name == userRole))
{
IdentityRole newRole = new IdentityRole(userRole);
roleManager.Create(newRole);
}
// Creating the newUser
ApplicationUser newUser;
/// <summary>
/// new User will be made if userName doesn't exist on the DB
/// and if no role was passed in the user won't be added to a role
/// </summary>
if (!context.Users.Any(user => user.UserName == userName))
{
newUser = new ApplicationUser()
{
DisplayName = displayName,
UserName = userName,
Email = userEmail
};
newUser.EmailConfirmed = true;
userManager.Create(newUser, userPassword);
}
else
{
/// <summary>
/// I'm using ".First()" and not ".FirstOrDefault()" because
/// the if statement above this will generate the user if
/// the user doesn't already exist in the database
/// (I'm 100% expecting this user to be in the database)
/// </summary>
newUser = context.Users.First(user => user.UserName == userName);
}
context.Users.AddOrUpdate(user => user.Email, newUser);
context.SaveChanges();
// Make sure the user is on the passed in role
if (!string.IsNullOrEmpty(userRole) && !string.IsNullOrWhiteSpace(userRole) && !userManager.IsInRole(newUser.Id, userRole))
{
userManager.AddToRole(newUser.Id, userRole);
}
return(newUser);
}
//public IEnumerable<SelectListItem> ReadRoles()
//{
// IList<SelectListItem> result = new List<SelectListItem>
// {
// new SelectListItem
// {
// Text = RoleType.Company.GetEnumDescription(),
// Value = RoleType.Company.ToString()
// },
// new SelectListItem
// {
// Text = RoleType.Supervise.GetEnumDescription(),
// Value = RoleType.Supervise.ToString()
// },
// new SelectListItem
// {
// Text = RoleType.Guidance.GetEnumDescription(),
// Value = RoleType.Guidance.ToString()
// }
// };
// return result;
//}
public bool?Update(UserManager <ApplicationUser> userManager, string key, UserViewModel model)
{
bool allSuccess = true;
var user = userManager.Users.Where(u => u.Id == key).SingleOrDefault();
if (user == null)
{
return(null);
}
// Role
if (!string.IsNullOrEmpty(model.Role.Value))
{
if (!userManager.IsInRole(key, model.Role.Value))
{
var roles = userManager.GetRoles(key).ToArray();
IdentityResult result = userManager.RemoveFromRoles(key, roles);
if (result.Succeeded)
{
result = userManager.AddToRole(key, model.Role.Value);
}
allSuccess &= result.Succeeded;
}
}
// Consultant
//if (!string.IsNullOrEmpty(model.Consultant.Value))
//{
// var customer = this.DbContext.Customers.Where(c => c.UserId == key).SingleOrDefault();
// if (customer == null)
// return null;
// customer.ConsultantId = model.Consultant.Value;
// try
// {
// this.DbContext.SaveChanges();
// }
// catch
// {
// allSuccess = false;
// }
//}
var customer = this.DbContext.Customers.Where(c => c.UserId == key).SingleOrDefault();
if (customer == null)
{
return(null);
}
customer.ConsultantId = model.Consultant.Value;
try
{
this.DbContext.SaveChanges();
}
catch
{
allSuccess = false;
}
// LockedOut
if (userManager.IsLockedOut(key) != model.LockedOut)
{
IdentityResult result;
if (model.LockedOut)
{
result = userManager.SetLockoutEnabled(key, true);
if (result.Succeeded)
{
result = userManager.SetLockoutEndDate(key, DateTimeOffset.MaxValue);
}
}
else
{
result = userManager.SetLockoutEnabled(key, false);
if (result.Succeeded)
{
result = userManager.ResetAccessFailedCount(key);
}
}
allSuccess &= result.Succeeded;
}
return(allSuccess);
}
public bool IsInRole(string userId, string role)
{
return(_identityManager.IsInRole(userId, role));
}
protected void Page_Load(object sender, EventArgs e)
{
// Homepage menu items.
liShowFanClubs.Visible = true;
liShowEvents.Visible = true;
// Hide other menu items.
// Fan club menu items.
liFanClubDropDown.Visible = false;
liJoinInitialFanClub.Visible = false;
liFanClubsJoined.Visible = false;
liJoinFanClubs.Visible = false;
liSubmitFanClubRemark.Visible = false;
liViewFanClubRemarks.Visible = false;
liCreateFanClub.Visible = false;
liModifyFanClub.Visible = false;
liProcessFanClubRemarks.Visible = false;
// Event menu items.
liEventDropDown.Visible = false;
liCurrentEventsJoined.Visible = false;
liPastEventsJoined.Visible = false;
liJoinEvents.Visible = false;
liSubmitEventRemark.Visible = false;
liViewEventRemarks.Visible = false;
liCreateEvent.Visible = false;
liModifyEvent.Visible = false;
liProcessEventRemarks.Visible = false;
liRecordEventAttendance.Visible = false;
// Manage own information.
liManageInformation.Visible = false;
string userId = HttpContext.Current.User.Identity.GetUserId();
var manager = new UserManager();
if (userId != null)
{
if (manager.IsInRole(userId, "Employee"))
{
// Hide homepage menu items.
liShowFanClubs.Visible = false;
liShowEvents.Visible = false;
// Fan club menu items.
liFanClubDropDown.Visible = true;
liCreateFanClub.Visible = true;
liModifyFanClub.Visible = true;
liProcessFanClubRemarks.Visible = true;
// Event menu items.
liEventDropDown.Visible = true;
liCreateEvent.Visible = true;
liModifyEvent.Visible = true;
liProcessEventRemarks.Visible = true;
liRecordEventAttendance.Visible = true;
}
if (manager.IsInRole(userId, "Registered User"))
{
// Hide homepage menu items.
liShowFanClubs.Visible = false;
liShowEvents.Visible = false;
// Fan clubr menu items.
liFanClubDropDown.Visible = true;
liJoinInitialFanClub.Visible = true;
// Event menu items
liEventDropDown.Visible = true;
liCurrentEventsJoined.Visible = true;
liPastEventsJoined.Visible = true;
liJoinEvents.Visible = true;
// Manage own information
liManageInformation.Visible = true;
}
if (manager.IsInRole(userId, "Club Member"))
{
// Hide homepage menu items.
liShowFanClubs.Visible = false;
liShowEvents.Visible = false;
// Fan club menu items.
liFanClubDropDown.Visible = true;
liJoinFanClubs.Visible = true;
liSubmitFanClubRemark.Visible = true;
liViewFanClubRemarks.Visible = true;
// Event menu items.
liEventDropDown.Visible = true;
liCurrentEventsJoined.Visible = true;
liPastEventsJoined.Visible = true;
liJoinEvents.Visible = true;
liSubmitEventRemark.Visible = true;
liViewEventRemarks.Visible = true;
// Manage own information.
liManageInformation.Visible = true;
}
}
}
public static void Seed(ApplicationDbContext db)
{
// generic Identity - Store the users
UserStore <ApplicationUser> userStore = new UserStore <ApplicationUser>(db);
UserManager <ApplicationUser> userManager = new UserManager <ApplicationUser>(userStore);
// generic Identity - roles
RoleStore <Role> roleStore = new RoleStore <Role>(db);
RoleManager <Role> roleManager = new RoleManager <Role>(roleStore);
// seed data users...
ApplicationUser userOne = null;
userOne = userManager.FindByName("*****@*****.**");
// if USER_ONE does not exist, do create them
if (userOne == null)
{
userManager.Create(new ApplicationUser
{
Email = "*****@*****.**",
FirstName = "julio",
LastName = "r",
UserName = "******"
}, "123456");
userOne = userManager.FindByName("*****@*****.**");
}
ApplicationUser userTwo = null;
userTwo = userManager.FindByName("*****@*****.**");
// if USER_TWO does not exist, do create them
if (userTwo == null)
{
userManager.Create(new ApplicationUser
{
Email = "*****@*****.**",
FirstName = "Rick",
LastName = "J",
UserName = "******"
}, "123456");
userTwo = userManager.FindByName("*****@*****.**");
}
// if ROLES does not exist, do create them
if (!roleManager.Roles.Any())
{
roleManager.Create(new Role {
Name = "Admin"
});
roleManager.Create(new Role {
Name = "General"
});
}
// assign the userOne into a role
if (!userManager.IsInRole(userOne.Id, "Admin"))
{
userManager.AddToRole(userOne.Id, "Admin");
}
// assign the userOne into a role
if (!userManager.IsInRole(userTwo.Id, "General"))
{
userManager.AddToRole(userTwo.Id, "General");
}
}
protected override void Seed(CashCard.Models.ApplicationDbContext context)
{
if (!context.Branches.Any(p => p.Name == "Pusat"))
{
var b = new Branch {
Name = "Pusat", PengeluaranRegular = 1000
};
context.Branches.Add(b);
context.SaveChanges();
}
//Role Management
var roleStore = new RoleStore <IdentityRole>(context);
var roleManager = new RoleManager <IdentityRole>(roleStore);
if (!context.Roles.Any(p => p.Name == "User"))
{
var role = new IdentityRole {
Name = "User"
};
roleManager.Create(role);
}
if (!context.Roles.Any(p => p.Name == "Supervisor"))
{
var role = new IdentityRole {
Name = "Supervisor"
};
roleManager.Create(role);
}
if (!context.Roles.Any(p => p.Name == "Admin"))
{
var role = new IdentityRole {
Name = "Admin"
};
roleManager.Create(role);
}
if (!context.Roles.Any(p => p.Name == "Officer"))
{
var role = new IdentityRole {
Name = "Officer"
};
roleManager.Create(role);
}
var store = new UserStore <ApplicationUser>(context);
var manager = new UserManager <ApplicationUser>(store);
if (!context.Users.Any(p => p.UserName == "Tanto"))
{
var user = new ApplicationUser {
UserName = "******", BranchId = 1
};
manager.Create(user, "123456");
}
var userx = manager.FindByName("Tanto");
if (!manager.IsInRole(userx.Id, "Admin"))
{
manager.AddToRole(userx.Id, "Admin");
}
}
public ActionResult AddRole(string userID, FormCollection form)
{
var roleID = Request["RoleID"];
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var users = userManager.Users.ToList();
var user = users.Find(u => u.Id == userID);
var userView = new UserView
{
Email = user.Email,
Name = user.UserName,
UserID = user.Id,
Roles = new List <RoleView>() //+Diff
};
if (string.IsNullOrEmpty(roleID))
{
ViewBag.Error = "Tem de selecionar uma permissão";
ViewBag.RoleID = new SelectList(CombosHelper.GetRoles(), "Id", "Name");
return(View(userView));
}
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
var roles = roleManager.Roles.ToList();
var role = roles.Find(r => r.Id == roleID);
if (!userManager.IsInRole(userID, role.Name))
{
userManager.AddToRole(userID, role.Name);
}
//var rolesView = new List<RoleView>();
foreach (var item in user.Roles)
{
role = roles.Find(r => r.Id == item.RoleId);
var roleView = new RoleView
{
Name = role.Name,
RoleID = role.Id
};
//rolesView.Add(roleView);
userView.Roles.Add(roleView); //Diff
}
//userView = new UserView
//{
// Email = user.Email,
// Name = user.UserName,
// Roles = rolesView,
// UserID = user.Id
//};
return(View("Roles", userView));
}
public async Task <ActionResult> Compromisos()
{
//bUSCA LA EMPRESA
var idEmpresaInt = 0;
try
{
var userWithClaims = (ClaimsPrincipal)User;
var idEmpresa = userWithClaims.Claims.First(c => c.Type == Constantes.Empresa).Value;
idEmpresaInt = Convert.ToInt32(idEmpresa);
}
catch (Exception ex)
{
InicializarMensaje(Mensaje.ErrorIdEmpresa);
return(View());
}
//FIN
SupervisorRequest supervisorRequest = new SupervisorRequest();
ApplicationDbContext db = new ApplicationDbContext();
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var idUsuarioActual = User.Identity.GetUserId();
supervisorRequest.IdUsuario = idUsuarioActual;
supervisorRequest.IdEmpresa = idEmpresaInt;
if (userManager.IsInRole(idUsuarioActual, "Supervisor"))
{
Response response = await ApiServicio.InsertarAsync(supervisorRequest,
new Uri(WebApp.BaseAddress),
"api/Vendedores/obtenerSupervisorPorIdUsuario");
supervisorRequest = JsonConvert.DeserializeObject <SupervisorRequest>(response.Resultado.ToString());
var userWithClaims = (ClaimsPrincipal)User;
try
{
var lista = await ApiServicio.ObtenerElementoAsync1 <SupervisorRequest>(supervisorRequest, new Uri(WebApp.BaseAddress)
, "api/Vendedores/ListarVendedoresGerente");
//var objeto = JsonConvert.DeserializeObject<SupervisorRequest>(lista.ListaVendedores.ToString());
ViewBag.IdVendedor = new SelectList(lista.ListaVendedores, "IdVendedor", "NombreApellido");
var vista1 = new SupervisorRequest {
FechaInicio = DateTime.Now, FechaFin = DateTime.Now, Listarcompromiso = new List <CompromisoRequest>()
};
return(View(vista1));
}
catch (Exception ex)
{
ex.ToString();
return(View());
}
;
}
var vista = new SupervisorRequest {
FechaInicio = DateTime.Now, FechaFin = DateTime.Now, Listarcompromiso = new List <CompromisoRequest>()
};
return(View(vista));
}
private bool needAddRole(UserManager <ApplicationUser> userManager, SelectionUserEditorViewModel user, SelectionRoleEditorViewModel role)
{
return(!userManager.IsInRole(user.Id, role.Name) && role.Selected);
}
protected override void Seed(BlogApp.Models.ApplicationDbContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
RoleManager <IdentityRole> roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
if (!context.Roles.Any(r => r.Name == "Admin"))
{
roleManager.Create(new IdentityRole {
Name = "Admin"
});
}
if (!context.Roles.Any(r => r.Name == "Moderator"))
{
roleManager.Create(new IdentityRole {
Name = "Moderator"
});
}
UserManager <ApplicationUser> userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
ApplicationUser adminUser = null;
var adminUserName = WebConfigurationManager.AppSettings["admin-username"];
if (!context.Users.Any(p => p.UserName == adminUserName))
{
adminUser = new ApplicationUser();
adminUser.UserName = adminUserName;
adminUser.Email = adminUserName;
adminUser.FirstName = WebConfigurationManager.AppSettings["admin-firstname"];
adminUser.LastName = WebConfigurationManager.AppSettings["admin-lastname"];
adminUser.DisplayName = WebConfigurationManager.AppSettings["admin-displayname"];
userManager.Create(adminUser, WebConfigurationManager.AppSettings["admin-password"]);
}
else
{
adminUser = context.Users.Where(p => p.UserName == adminUserName)
.FirstOrDefault();
}
if (!userManager.IsInRole(adminUser.Id, "Admin"))
{
userManager.AddToRole(adminUser.Id, "Admin");
}
ApplicationUser moderatorUser = null;
var modUserName = WebConfigurationManager.AppSettings["moderator-username"];
if (!context.Users.Any(p => p.UserName == modUserName))
{
moderatorUser = new ApplicationUser();
moderatorUser.UserName = modUserName;
moderatorUser.Email = modUserName;
moderatorUser.FirstName = WebConfigurationManager.AppSettings["moderator-firstname"];
moderatorUser.LastName = WebConfigurationManager.AppSettings["moderator-lastname"];
moderatorUser.DisplayName = WebConfigurationManager.AppSettings["moderator-displayname"];
userManager.Create(moderatorUser, WebConfigurationManager.AppSettings["moderator-password"]);
}
else
{
moderatorUser = context.Users.Where(p => p.UserName == modUserName)
.FirstOrDefault();
}
if (!userManager.IsInRole(moderatorUser.Id, "Moderator"))
{
userManager.AddToRole(moderatorUser.Id, "Moderator");
}
}
public async Task <ActionResult> _LoginHomeForm(LoginViewModel model, string returnUrl)
{
var modelParent = new HomeLoginViewModel();
modelParent.LoginHomeViewModel = model;
modelParent.RegisterHomeViewModel = new RegisterHomeViewModel();
if (!ModelState.IsValid)
{
return(View(modelParent));
}
// 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 user = await UserManager.FindAsync(model.Email, model.Password);
if (UserManager.IsInRole(user.Id, "CustomerUser") || UserManager.IsInRole(user.Id, "CustomerAdminUser"))
{
base.CurrentUserEmail = ((CustomerUser)user).Email;
base.CurrentUserId = ((CustomerUser)user).Id;
base.CurrentUserFullName = ((CustomerUser)user).FullName;
base.CurrentCustomerID = ((CustomerUser)user).CustomerID;
base.CurrentCustomerCompany = GetCustomer(((CustomerUser)user).CustomerID).Company;
base.CurrentUserIsSellerUser = false;
base.CurrentUserEditGlobalVariables = false;
base.CurrentUserEditMarginOrPrice = false;
base.CurrentUserSeeCosting = false;
var log = new LogRecord
{
LogLevel = LogLevel.Information,
ShortMessage = "Login Usuario - (Usuario Cliente: " + model.Email + ")",
//CreatedOnUtc = DateTime.UtcNow
CreatedOnUtc = DateTime.Now
};
await logRecordRepository.CreateAsync(log);
}
if (UserManager.IsInRole(user.Id, "AdminUser"))
{
base.CurrentUserEmail = ((AdminUser)user).Email;
base.CurrentUserId = ((AdminUser)user).Id;
base.CurrentUserFullName = ((AdminUser)user).FullName;
base.CurrentUserIsSellerUser = true;
base.CurrentUserEditGlobalVariables = true;
base.CurrentUserEditMarginOrPrice = true;
base.CurrentUserSeeCosting = true;
var log = new LogRecord
{
LogLevel = LogLevel.Information,
ShortMessage = "Login Usuario - (Usuario Admin: " + model.Email + ")",
//CreatedOnUtc = DateTime.UtcNow
CreatedOnUtc = DateTime.Now
};
await logRecordRepository.CreateAsync(log);
}
if ((UserManager.IsInRole(user.Id, "SellerUser")) && !UserManager.IsInRole(user.Id, "AdminUser"))
{
base.CurrentUserEmail = ((SellerUser)user).Email;
base.CurrentUserId = ((SellerUser)user).Id;
base.CurrentUserFullName = ((SellerUser)user).FullName;
base.CurrentCustomerCompany = "";
base.CurrentUserIsSellerUser = true;
base.CurrentUserEditGlobalVariables = ((SellerUser)user).EditGlobalVariables;
base.CurrentUserEditMarginOrPrice = ((SellerUser)user).EditMarginOrPrice;
base.CurrentUserSeeCosting = ((SellerUser)user).SeeCosting;
var log = new LogRecord
{
LogLevel = LogLevel.Information,
ShortMessage = "Login Usuario - (Usuario Vendedor: " + model.Email + ")",
//CreatedOnUtc = DateTime.UtcNow
CreatedOnUtc = DateTime.Now
};
await logRecordRepository.CreateAsync(log);
}
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Usuario o contraseña incorrectos.");
return(View(modelParent));
}
}
public ActionResult AddRole(string userID, FormCollection form)
{
var roleID = Request["RoleID"];
ViewBag.descAdmin = "Posee todos los permisos y además cuenta con la posibilidad de Agregar/Eliminar usuarios y Asignar/Quitar los permisos que tendrán con el sistema.";
ViewBag.ViewProd = "Permite al usuario acceder a todas las listas de Productos";
ViewBag.CreateProd = "Permite al usuario agregar un nuevo Producto a su Stock";
ViewBag.EditProd = "Permite al usuario modificar la información de un Producto";
ViewBag.DeleteProd = "Permite al usuario eliminar un Producto de su Stock";
ViewBag.ViewCateg = "Permite al usuario acceder a la lista de Rubros";
ViewBag.CreateCateg = "Permite al usuario agregar un nuevo Rubro";
ViewBag.EditCateg = "Permite al usuario modificar un Rubro";
ViewBag.DeleteCateg = "Permite al usuario eliminar un Rubro";
ViewBag.ViewPurch = "Permite al usuario acceder a la lista de Compras y al detalle de cada una";
ViewBag.CreatePurch = "Permite al usuario registrar una Compra";
ViewBag.EditPurch = "Permite al usuario modificar tanto la información de una Compra, como su detalle";
ViewBag.DeletePurch = "Permite al usuario eliminar una Compra";
ViewBag.ViewSale = "Permite al usuario acceder a todas las listas de Ventas y al detalle de cada una";
ViewBag.CreateSale = "Permite al usuario registrar una Venta";
ViewBag.EditSale = "Permite al usuario modificar la información de una Venta, modificar el detalle de Venta y finalizar una Venta";
ViewBag.DeleteSale = "Permite al usuario eliminar una Venta";
ViewBag.ViewCust = "Permite al usuario acceder a la lista de Clientes y a la información de cada uno";
ViewBag.CreateCust = "Permite al usuario agregar un nuevo Cliente al sistema";
ViewBag.EditCust = "Permite al usuario modificar la información de un Cliente";
ViewBag.DeleteCust = "Permite al usuario eliminar un Cliente del sistema";
ViewBag.ViewProv = "Permite al usuario acceder a la lista de Proveedores y a la información de cada uno";
ViewBag.CreateProv = "Permite al usuario agregar un nuevo Proveedor al sistema";
ViewBag.EditProv = "Permite al usuario modificar la información de un Proveedor";
ViewBag.DeleteProv = "Permite al usuario eliminar un Proveedor del sistema";
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
var users = userManager.Users.ToList();
var user = users.Find(u => u.Id == userID);
var userView = new UserView
{
Email = user.Email,
Name = user.UserName,
UserID = user.Id
};
if (string.IsNullOrEmpty(roleID))
{
ViewBag.Error = "Debe Seleccionar un permiso";
var list = roleManager.Roles.ToList();
list.Add(new IdentityRole {
Id = "", Name = "[Seleccione un permiso...]"
});
list = list.OrderBy(r => r.Name).ToList();
ViewBag.RoleID = new SelectList(list, "Id", "Name");
return(View(userView));
}
var roles = roleManager.Roles.ToList();
var role = roles.Find(r => r.Id == roleID);
if (!userManager.IsInRole(userID, role.Name))
{
userManager.AddToRole(userID, role.Name);
db.SaveChanges();
}
var rolesView = new List <RoleView>();
foreach (var item in user.Roles)
{
role = roles.Find(r => r.Id == item.RoleId);
var roleView = new RoleView
{
Name = role.Name,
RoleID = role.Id
};
rolesView.Add(roleView);
}
userView = new UserView
{
Email = user.Email,
Name = user.UserName,
Roles = rolesView,
UserID = user.Id
};
return(View("Roles", userView));
}
public ActionResult AddRole(string userID, FormCollection form)
{
var roleID = Request["RoleID"];
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
var roles = roleManager.Roles.ToList();
var users = userManager.Users.ToList();
var user = users.Find(u => u.Id == userID);
var userView = new UserView
{
Email = user.Email,
Name = user.UserName,
UserID = user.Id
};
// verifico si selecciono rol
if (string.IsNullOrEmpty(roleID))
{
ViewBag.Error = "You must select a role.";
var list = roles;
list.Add(new IdentityRole {
Id = "", Name = "[Select a Role]"
});
list = list.OrderBy(r => r.Name).ToList();
ViewBag.RoleID = new SelectList(list, "Id", "Name");
return(View(userView));
}
var role = roles.Find(r => r.Id == roleID);
if (!userManager.IsInRole(user.Id, role.Name))
{
userManager.AddToRole(userID, role.Name);
}
var rolesView = new List <RoleView>();
foreach (var item in user.Roles)
{
role = roles.Find(r => r.Id == item.RoleId);
var roleView = new RoleView
{
RoleID = role.Id,
Name = role.Name
};
rolesView.Add(roleView);
}
userView = new UserView
{
Email = user.Email,
Name = user.UserName,
UserID = user.Id,
Roles = rolesView
};
return(View("Roles", userView));
}
public bool IsAdmin(string userId)
{
return(_userManager.IsInRole(userId, "Admin"));
}
public ActionResult AddRole(string userID, FormCollection form, string identificador)
{
identificador = "1";
var roleID = Request["RoleID"];
ViewBag.dadministrador = "Superusuario del sistema. Todas las funciones habilitadas.";
ViewBag.dmoderador = "Agentes del call center.";
ViewBag.dinvitado = "Sólo posee permisos de lectura";
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(db));
var users = userManager.Users.ToList();
var user = users.Find(u => u.Id == userID);
var userView = new UserView
{
Email = user.Email,
Name = user.UserName,
UserID = user.Id
};
if (string.IsNullOrEmpty(roleID))
{
ViewBag.Error = "Debe Seleccionar un permiso";
var list = roleManager.Roles.ToList();
list.Add(new IdentityRole {
Id = "", Name = "[Seleccione un permiso...]"
});
list = list.OrderBy(r => r.Name).ToList();
ViewBag.RoleID = new SelectList(list, "Id", "Name");
return(View(userView));
}
var roles = roleManager.Roles.ToList();
var role = roles.Find(r => r.Id == roleID);
if (!userManager.IsInRole(userID, role.Name))
{
userManager.AddToRole(userID, role.Name);
var a = new ApplicationUser();
if (role.Name == "Distribuidor")
{
a = users.Find(x => x.Id == userID);
a.Identificador = identificador;
userManager.Update(a);
}
db.SaveChanges();
}
var rolesView = new List <RoleView>();
foreach (var item in user.Roles)
{
role = roles.Find(r => r.Id == item.RoleId);
var roleView = new RoleView
{
Name = role.Name,
RoleID = role.Id
};
rolesView.Add(roleView);
}
userView = new UserView
{
Email = user.Email,
Name = user.UserName,
Roles = rolesView,
UserID = user.Id
};
return(View("Roles", userView));
}
