public ActionResult RegisterAdmin(CreateUserRoleViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var salt = CreateSHAHash(model.Password);
model.Password = salt;
model.ConfirmPassword = salt;
if (ModelState.IsValid)
{
using (ContactsDbContext db = new ContactsDbContext())
{
var user = db.RoleModel.FirstOrDefault(u => u.UserName == model.UserName || u.FullName == model.FullName || u.Email == model.Email);
if (user != null)
{
ModelState.AddModelError("", "Username or email already exists");
}
else
{
db.RoleModel.Add(model);
db.SaveChanges();
ModelState.Clear();
}
}
}
return(View());
}
public async Task <IActionResult> Create(CreateUserRoleViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var _user = await _userManager.FindByIdAsync(model.UserId);
var _role = _roleRepository.EntityItems.Where(x => x.Id == model.RoleSelect).FirstOrDefault().Name;
//若该角色不存在
if (!(await _roleManager.RoleExistsAsync(_role)))
{
//TODO:StatusMessage 该角色不存在
return(RedirectToAction(nameof(Create), new { model.UserId }));
}
IdentityResult result = null;
//判断用户是否已经属于指定角色
if (!(await _userManager.IsInRoleAsync(_user, _role)))
{
StatusMessage = $"您已成功将该用户加入角色{_role}";
result = await _userManager.AddToRoleAsync(_user, _role);
}
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First().ToString());
return(RedirectToAction(nameof(Create), new { model.UserId }));
}
return(RedirectToAction(nameof(Create), new { model.UserId }));
}
public ActionResult RemoveConfirmed(int?id)
{
CreateUserRoleViewModel userLogin = db.RoleModel.Find(id);
db.RoleModel.Remove(userLogin);
db.SaveChanges();
return(RedirectToAction("RegisteredUsers", "Account"));
}
public async Task <IActionResult> Create(CreateUserRoleViewModel userRoleViewModel)
{
var user = new ApplicationUser();
user.UserName = userRoleViewModel.Email;
user.Email = userRoleViewModel.Email;
user.isFirstLogin = true;
user.TwoFactorEnabled = false;
// user.EmailConfirmed = true;
string password = userRoleViewModel.Password;
IdentityResult chkUser = await _userManager.CreateAsync(user, password);
if (chkUser.Succeeded)
{
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationLink = Url.Page("/Account/ConfirmEmail", pageHandler: null, values: new { area = "Identity", userId = user.Id, token }, protocol: Request.Scheme);
if (userRoleViewModel.IsSuperAdmin)
{
var addToRole = await _userManager.AddToRoleAsync(user, UserRolesConst.SuperAdmin);
}
else
{
var addToRole = await _userManager.AddToRoleAsync(user, UserRolesConst.ContentManager);
}
await _emailSender.SendEmailAsync(user.Email, user.UserName, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(confirmationLink)}'>clicking here</a>.");
await _emailSender.SendEmailAsync(user.Email, user.UserName,
"Email Account", "Please Check Your Email Confirmation Credential <br><br>" + "Email: "
+ user.Email + "<br><br>" + "Password: <b>" + password + "</b>" + "<br><br> <b>Please Reset Your Password</b><br> Thanks");
_logger.LogInformation(user.Email + " Was Created" + " by Super Admin" + " and two emails sent to " + user.Email);
_toastNotification.AddSuccessToastMessage(user.Email + " Created Successfully");
_eventLogger.LogInfoEvent(HttpContext.User.Identity.Name, Common.ActivityEnum.Add, "Super Admin > User Managment > Add", user.Email + " Created Successfully");
if (!userRoleViewModel.IsSuperAdmin)
{
AddDefaultConfig(user.Id);
}
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (IdentityError error in chkUser.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
ViewBag.Roles = _roleManager.Roles.ToList();
return(View());
}
public async Task <UserManagerResponse> CreateUserRoleAsync(CreateUserRoleViewModel model)
{
var role = await roleManager.FindByIdAsync(model.RoleId);
if (role == null)
{
return(new UserManagerResponse
{
Message = "Role does not exist",
IsSuccess = false
});
}
var user = await userManager.FindByIdAsync(model.UserId);
if (role == null)
{
return(new UserManagerResponse
{
Message = "user does not exist",
IsSuccess = false
});
}
if (await userManager.IsInRoleAsync(user, role.Name))
{
return(new UserManagerResponse
{
Message = "user has role already",
IsSuccess = false
});
}
var result = await userManager.AddToRoleAsync(user, role.Name);
if (result.Succeeded)
{
return(new UserManagerResponse
{
Message = "Role assigned",
IsSuccess = true
});
}
return(new UserManagerResponse
{
Message = "something went wrong",
IsSuccess = false
});
}
public async Task <IActionResult> CreateUserRolenAsync([FromBody] CreateUserRoleViewModel model)
{
if (ModelState.IsValid)
{
var result = await userService.CreateUserRoleAsync(model);
if (result.IsSuccess)
{
return(Ok(result));
}
return(BadRequest(result));
}
return(BadRequest("Some properties are not valid"));
}
public async Task <UserManagerResponse> CreateUserRoleAsync(CreateUserRoleViewModel model)
{
var role = await roleManager.FindByIdAsync(model.RoleId);
if (role == null)
{
return(new UserManagerResponse
{
Message = "Rol no existe",
IsSuccess = false
});
}
var user = await userManager.FindByIdAsync(model.UserId);
if (role == null)
{
return(new UserManagerResponse
{
Message = "Usuario no existe",
IsSuccess = false
});
}
if (await userManager.IsInRoleAsync(user, role.Name))
{
return(new UserManagerResponse
{
Message = "El usuario ya cuenta con un rol",
IsSuccess = false
});
}
var result = await userManager.AddToRoleAsync(user, role.Name);
if (result.Succeeded)
{
return(new UserManagerResponse
{
Message = "rol asignado exitosamente",
IsSuccess = true
});
}
return(new UserManagerResponse
{
Message = "algo salio mal",
IsSuccess = false
});
}
public IActionResult Create(string UserId)
{
var model = new CreateUserRoleViewModel
{
StatusMessage = StatusMessage,
UserId = UserId,
RoleSelectViewModels = _roleRepository.EntityItems.Select(x => new RoleSelectViewModel
{
Id = x.Id,
Name = x.Name,
Description = x.Description
}).ToList()
};
return(View(model));
}
// GET: Account/Delete/5
public ActionResult Remove(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CreateUserRoleViewModel usersLogin = db.RoleModel.Find(id);
if (usersLogin == null)
{
return(HttpNotFound());
}
return(View(usersLogin));
}
public ActionResult Create(CreateUserRoleViewModel userRoleModel)
{
var model = userRoleModel.UserModel;
var selectedRoles = userRoleModel.Roles;
if (ModelState.IsValid)
{
// Attempt to register the user
MembershipCreateStatus createStatus;
var user = MembershipUserExtended.CreateUser(model.UserName, model.Password, model.Email, model.FirstName, model.LastName, model.Title, model.HourlyRate, model.Address, model.City, model.State, model.Zip, model.Phone, out createStatus);
if (createStatus == MembershipCreateStatus.Success)
{
//Assign Users to Roles
if (selectedRoles.Any())
{
Roles.AddUserToRoles(user.UserName, selectedRoles.ToArray());
}
else
{
Roles.AddUserToRole(user.UserName, Roles.GetAllRoles().FirstOrDefault(c => c.ToLower().Equals("user")));
}
userRoleModel.UserModel = new CreateUserModel(user);
userRoleModel.Roles = Roles.GetAllRoles().ToList();
//FormsAuthentication.SetAuthCookie(model.UserName, createPersistentCookie: false);
//return RedirectToAction("Index", "TimeTrack");
ModelState.AddModelError("", string.Format("User {0} created successfully", model.UserName));
return(View(userRoleModel));
}
else
{
userRoleModel.Roles = Roles.GetAllRoles().ToList();
ModelState.AddModelError("", ErrorCodeToString(createStatus));
}
}
else
{
userRoleModel.Roles = Roles.GetAllRoles().ToList();
}
// If we got this far, something failed, redisplay form
return(View(userRoleModel));
}
// GET: UserRoles/Create
public ActionResult Create()
{
var model = new CreateUserRoleViewModel();
model.userList = db.Users.ToList().OrderBy(item => item.UserName).Select(m => new SelectListItem
{
Value = m.Id.ToString(),
Text = m.UserName
});
model.rolesList = db.Roles.ToList().OrderBy(item => item.Name).Select(m => new SelectListItem
{
Value = m.Id.ToString(),
Text = m.Name
});
return(View(model));
}
public ActionResult Create([Bind(Include = "UserId,RoleId")] CreateUserRoleViewModel cUserRoles)
{
if (ModelState.IsValid)
{
if (cUserRoles.RoleId == null)
{
return(RedirectToAction("Index", new { Message = UserRolesMessageId.CreateRoleFail }));
}
UserRoles ur = null;
foreach (var item in db.IdentityUserRoles.ToList())
{
if (cUserRoles.UserId == item.UserId)
{
ur = new UserRoles
{
UserId = cUserRoles.UserId,
RoleId = cUserRoles.RoleId
};
break;
}
}
if (ur == null)
{
ur = new UserRoles
{
UserId = cUserRoles.UserId,
RoleId = cUserRoles.RoleId
};
db.IdentityUserRoles.Add(ur);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index", new { Message = UserRolesMessageId.CreateUserRoleFail }));
}
return(View(cUserRoles));
}
public async Task <IActionResult> CreateRole(CreateUserRoleViewModel model)
{
if (ModelState.IsValid)
{
IdentityRole identityRole = new IdentityRole
{
Name = model.RoleName
};
IdentityResult result = await roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles", "Administration"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
//this method creates a role
public async Task <IActionResult> CreateRole(CreateUserRoleViewModel roleVm)
{
if (ModelState.IsValid)
{
var role = new IdentityRole()
{
Name = roleVm.RoleName
};
var result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("ListOfRoles", "Admin"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(roleVm));
}
//
// GET: /User/
//
// GET: /Account/Register
//[Authorize(Roles = "SuperAdmin, Admin")]
public ActionResult Create()
{
var model = new CreateUserRoleViewModel();
return(View(model));
}