public async Task<IdentityResult> RegisterUser(UserModel userModel, string roleName)
        {
            IdentityUser user = new IdentityUser
            {
                UserName = userModel.UserName,
                Email = userModel.UserName
            };

            var result = await _userManager.CreateAsync(user, userModel.Password);

            if (result == IdentityResult.Success)
            {
                var role = await _roleManager.FindByNameAsync(roleName);
                if (role == null)
                {
                    role = new IdentityRole(roleName);
                    var roleresult = await _roleManager.CreateAsync(role);
                }

                var userFromDb = await _userManager.FindByNameAsync(user.UserName);

                if (userFromDb != null)
                {
                    await _userManager.AddToRoleAsync(userFromDb.Id, roleName);
                }
            }

            return result;
        }

 /// <summary>
 /// Inserts a new Role in the Roles table
 /// </summary>
 /// <param name="roleName">The role's name</param>
 /// <returns></returns>
 public int Insert(IdentityRole role)
 {
     using (var db = _database.Open())
     {
         return (int)db.Insert<IdentityRole>(role);
     }
 }

        public void IdentityRoleSet_Id()
        {
            var role = new IdentityRole();
            role.Id = Guid.NewGuid().ToString();

            role.Id = null;
        }

        protected void Page_Load(object sender, EventArgs e) {
            Feedback.Visible = false;
            
            Guid roleId;
            if (!Request.QueryString["id"].TryParseGuid(out roleId)) {
                ShowError(Feedback, "The parameter for id is not in the correct format!");
                SaveButton.Visible = false;
                FormFields.Visible = false;
                return;
            }

            _roleManager = IdentityRoleManager.GetManager();
            _role = _roleManager.FindById(roleId);

            if (_role == null) {
                ShowError(Feedback, "No role was found for the given id!");
                SaveButton.Visible = false;
                FormFields.Visible = false;
                return;
            }

            SaveButton.Click += SaveButton_Click;

            if (!IsPostBack) {
                RoleId.Value = roleId.ToString();
                RoleName.Text = _role.Name;

                if (Request.QueryString["message"] == "created") {
                    ShowMessage(Feedback, "Role has been created!");
                }
            }

            RenderUsersInRole();
        }

        public JsonResult Delete(IdentityRole role)
        {
            _context.Entry(role).State = EntityState.Deleted;
            _context.SaveChanges();

            return Json(_context.Roles.ToList(), JsonRequestBehavior.AllowGet);
        }

        public JsonResult Create(IdentityRole role)
        {
            _context.Roles.Add(role);
            _context.SaveChanges();

            return Json(_context.Roles.ToList(), JsonRequestBehavior.AllowGet);
        }

        public async Task<IdentityResult> RegisterCustomerAsync(UserModel userModel, AppRole appRole = AppRole.customer)
        {
            var addToRoleResult = new IdentityResult();
            // Add generate username to the model
            IdentityUser user = new IdentityUser
            {
                UserName = userModel.UserName,
                Email = userModel.EmailAddress,
                EmailConfirmed = true,
                PhoneNumber = userModel.PhoneNumber,
                PhoneNumberConfirmed = true,
            };

            var result = await _userManager.CreateAsync(user, userModel.Password);

            //Role-user combination is managed as Contact-Role combination in ContactRole table
            //Create Role Admin if it does not exist
            var _role = await _roleManager.FindByNameAsync(appRole.ToString());
            if (_role == null)
            {
                _role = new IdentityRole(appRole.ToString());
                var roleresult = await _roleManager.CreateAsync(_role);
            }
            var rolesForUser = await _userManager.GetRolesAsync(user.Id);
            if (!rolesForUser.Contains(_role.Name))
            {
                addToRoleResult = await _userManager.AddToRoleAsync(user.Id, _role.Name);
            }

            return addToRoleResult;
        }

 public RoleViewModel(IdentityRole role)
 {
     this.Id = role.Id;
     this.Name = role.Name;
     this.ConcurrencyStamp = role.ConcurrencyStamp;
     //this.Description = role.Description;
 }

        public void GetRolesForUserShouldRetrieveCorrectRoles()
        {
            var role1 = new IdentityRole(GetNewRandomName());
            var role2 = new IdentityRole(GetNewRandomName());

            _roleManager.Create<IdentityRole>(role1);
            _roleManager.Create<IdentityRole>(role2);

            var user1 = new IdentityUser(GetNewRandomName());
            var user2 = new IdentityUser(GetNewRandomName());
            var user3 = new IdentityUser(GetNewRandomName());

            _userManager.Create(user1, _password);
            _userManager.Create(user2, _password);
            _userManager.Create(user3, _password);
            _userManager.AddToRole(user1.Id, role1.Name);
            _userManager.AddToRole(user1.Id, role2.Name);
            _userManager.AddToRole(user2.Id, role1.Name);
            _userManager.AddToRole(user3.Id, role2.Name);

            var user1RoleNames = _userManager.GetRoles(user1.Id);
            var user2RoleNames = _userManager.GetRoles(user2.Id);
            var user3RoleNames = _userManager.GetRoles(user3.Id);

            Assert.AreEqual(2, user1RoleNames.Count);
            Assert.AreEqual(1, user2RoleNames.Count);
            Assert.AreEqual(1, user3RoleNames.Count);

            Assert.IsTrue(user1RoleNames.Any(r => r == role1.Name));
            Assert.IsTrue(user1RoleNames.Any(r => r == role2.Name));
            Assert.IsTrue(user2RoleNames.Any(r => r == role1.Name));
            Assert.IsTrue(user3RoleNames.Any(r => r == role2.Name));
        }

        public ActionResult Add(IdentityRole model)
        {
            try
            {
                db.Roles.Add(model);
                db.SaveChanges();
                var Projectdb = new ProjectMvcDbContext();
                foreach (var p in Projectdb.WebActions)
                {
                    var perm = new Permission
                    {
                        Allow = false,
                        RoleId = model.Id,
                        WebActionId = p.Id
                    };
                    Projectdb.Permissions.Add(perm);
                }

                Projectdb.SaveChanges();
                return RedirectToAction("Index");
            }
            catch (Exception Ex)
            {
                ModelState.AddModelError("", Ex.Message);
                ViewBag.Role = db.Roles;
                return View("Index", model);
            }
        }

        internal static void SeedAdmin(HotelSystemDbContext context)
        {
            const string adminEmail = "[email protected]";
            const string adminPassword = "adminadmin";

            if (context.Users.Any(u => u.Email == adminEmail))
            {
                return;
            }

            var admin = new User()
            {
                Email = adminEmail,
                UserName = adminEmail,
                PasswordHash = new PasswordHasher().HashPassword(adminPassword),
                FirstName = "Admin",
                LastName = "Admin",
                BirthDate = new DateTime(1950, 2, 20),
                PhoneNumber = "0888888888888",
                SecurityStamp = Guid.NewGuid().ToString()
            };

            var adminRole = new IdentityRole { Name = GlobalConstants.AdministratorRole, Id = Guid.NewGuid().ToString() };
            context.Roles.AddOrUpdate(adminRole);

            admin.Roles.Add(new IdentityUserRole { RoleId = adminRole.Id, UserId = admin.Id });
            context.Users.Add(admin);
            context.SaveChanges();
        }

 public ActionResult Create(IdentityRole Role)
 {
     
     context.Roles.Add(Role);
     context.SaveChanges();
     return RedirectToAction("Index");
 }

        public JsonData Insert(IdentityRole entity, string userId)
        {
            try
            {
                using (var db = new DataContext())
                {
                    if (entity == null) throw new ArgumentNullException("The new" + " record is null");

                    var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(db));

                    //Create Roles if they do not exist
                    if (!roleManager.RoleExists(entity.Name))
                    {
                        roleManager.Create(new IdentityRole(entity.Name));
                    }
                    db.SaveChanges();

                    return DataHelpers.ReturnJsonData(entity, true, "Saved successfully", 1);
                }
            }
            catch (Exception e)
            {
                return DataHelpers.ExceptionProcessor(e);
            }
        }

        private async Task CreateAdminUser()
        {
          var username = "admin";//ConfigurationManager.AppSettings["DefaultAdminUsername"];
          var password = "password123";//ConfigurationManager.AppSettings["DefaultAdminPassword"];

          using (var context = new ApplicationDbContext())
          {
            var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
            var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));

            var role = new IdentityRole(RoleName);

            var result = await roleManager.RoleExistsAsync(RoleName);
            if (!result)
            {
              await roleManager.CreateAsync(role);
            }

            var user = await userManager.FindByNameAsync(username);
            if (user == null)
            {
              user = new ApplicationUser { UserName = username, Email = "[email protected]", First = "Big", Last="Admin Person" };
              await userManager.CreateAsync(user, password);
              await userManager.AddToRoleAsync(user.Id, RoleName);
            }
          }
        }

        public void AddRoleToUser(string userName, string roleName)
        {
            var role = this.roles.All()
                .FirstOrDefault(r => r.Name == roleName);

            if (role == null)
            {
                role = new IdentityRole
                {
                    Name = roleName
                };

                this.roles.Add(role);
                this.roles.SaveChanges();
            }

            var user = this.users.All().FirstOrDefault(u => u.UserName == userName);

            var userRole = this.userRoles.All()
                .FirstOrDefault(r => r.UserId == user.Id && r.RoleId == role.Id);

            if (userRole == null)
            {
                user.Roles.Add(new IdentityUserRole
                {
                    UserId = user.Id,
                    RoleId = role.Id
                });

                this.users.Update(user);

                this.users.SaveChanges();
            }
        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);

            // Tạo role sẵn
            var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(new ApplicationDbContext()));

            List<string> roleNameList = new List<string> { "Admin"
                                                         , "Designer"
                                                         , "Mod"
                                                         , "Uploader"
                                                         , "Subteam"
                                                         , "Subber"
                                                         , "VIP"
                                                         , "Member" };
            foreach (string roleName in roleNameList)
            {
                if (!roleManager.RoleExists(roleName))
                {
                    var newRole = new IdentityRole();
                    newRole.Name = roleName;
                    roleManager.Create(newRole);
                }
            }
        }

 public async Task<IActionResult> Editar(IdentityRole role)
 {
     var r = await _roleManager.FindByIdAsync(role.Id);
     r.Name = role.Name;
     await _roleManager.UpdateAsync(r);
     return Redirect();
 }

        public ActionResult Users()
        {
            var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(db));
            if (!roleManager.RoleExists("user"))
            {
                var nRole = new IdentityRole("user");
                roleManager.Create(nRole);
            }
            if (!roleManager.RoleExists("admin"))
            {
                var nRole = new IdentityRole("admin");
                roleManager.Create(nRole);
            }
            if (!roleManager.RoleExists("moderator"))
            {
                var nRole = new IdentityRole("moderator");
                roleManager.Create(nRole);
            }
            if (!roleManager.RoleExists("journalist"))
            {
                var nRole = new IdentityRole("journalist");
                roleManager.Create(nRole);
            }

            var vm = new AdminUsersViewModel();

            vm.Users = db.Users.OrderBy(x => x.UserName).ToList();
            vm.Roles = db.Roles.ToList();

            return View(vm);
        }

        public override void Up()
        {
            ApplicationDbContext context = new ApplicationDbContext();

            var adminUser = new ApplicationUser()
            {
                Id = Guid.NewGuid().ToString(),
                EmailConfirmed = false,
                PhoneNumberConfirmed = false,
                TwoFactorEnabled = false,
                LockoutEnabled = false,
                AccessFailedCount = 0,
                Email = "[email protected]",
                UserName = "[email protected]"
            };

            if (!context.Roles.Any(r => r.Name == "Admin"))
            {
                var store = new RoleStore<IdentityRole>(context);
                var manager = new RoleManager<IdentityRole>(store);
                var role = new IdentityRole { Name = "Admin" };

                manager.Create(role);
            }

            if (!context.Users.Any(u => u.UserName == "TheGaffer"))
            {
                var store = new UserStore<ApplicationUser>(context);
                var manager = new UserManager<ApplicationUser>(store);

                manager.Create(adminUser, "Seisen1!");
                manager.AddToRole(adminUser.Id, "Admin");
            }
        }

        public JsonData Update(IdentityRole entity, string userId)
        {
            try
            {
                using (var db = new DataContext())
                {
                    if (entity == null) throw new ArgumentNullException("The new" + " record is null");

                    //var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(db));

                    //Update Role Roles if they do not exist
                    var role = db.Roles.FirstOrDefault(x => x.Id == entity.Id);
                    if (role != null)
                    {
                        role.Name = entity.Name;
                        //roleManager.Update(role);
                    }
                    db.SaveChanges();

                    return DataHelpers.ReturnJsonData(entity, true, "Updated successfully", 1);
                }
            }
            catch (Exception e)
            {
                return DataHelpers.ExceptionProcessor(e);
            }
        }