public async Task <IActionResult> ModifyUserRoles(UserRolesModel userRoles)
{
if (userRoles != null)
{
User user = await userManager.FindByIdAsync(userRoles.UserId).ConfigureAwait(false);
if (user != null)
{
List <String> rolesToDelete = userRoles.Roles.Where(x => x.Value == false).Select(x => x.Key).ToList();
List <String> rolesToAdd = userRoles.Roles.Where(x => x.Value == true).Select(x => x.Key).ToList();
foreach (var role in rolesToDelete)
{
if (await userManager.IsInRoleAsync(user, role).ConfigureAwait(false))
{
await userManager.RemoveFromRoleAsync(user, role).ConfigureAwait(false);
}
}
foreach (var role in rolesToAdd)
{
if (!await userManager.IsInRoleAsync(user, role).ConfigureAwait(false))
{
await userManager.AddToRoleAsync(user, role).ConfigureAwait(false);
}
}
}
}
return(RedirectToAction("UserList"));
}
public async Task <IActionResult> ModifyUserRoles(string id)
{
User user = await userManager.FindByIdAsync(id).ConfigureAwait(false);
if (user != null)
{
SortedDictionary <string, bool> roles = new SortedDictionary <string, bool>();
var userRoles = await userManager.GetRolesAsync(user).ConfigureAwait(false);
foreach (var item in userRoles)
{
roles.Add(item, true);
}
var notUserRoles = roleManager.Roles.ToList().Select(x => x.Name).Except(userRoles);
foreach (var item in notUserRoles)
{
roles.Add(item, false);
}
UserRolesModel userRolesModel = new UserRolesModel()
{
UserId = user.Id,
UserName = user.NormalizedUserName,
Roles = roles
};
return(View(userRolesModel));
}
return(RedirectToAction("UserList"));
}
public UserRolesModel GetUserRole(string userId)
{
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
SqlCommand cmd = new SqlCommand(@"SELECT * FROM UserRoles
WHERE UserId = @userId", conn);
cmd.Parameters.AddWithValue("@userId", userId);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
UserRolesModel user = new UserRolesModel();
user.Role = Convert.ToString(reader["Role"]);
return(user);
}
}
}
catch (SqlException ex)
{
Console.WriteLine(ex);
}
return(null);
}
public async Task<IActionResult> Index()
{
UserRolesModel model = null;
List<UserRolesModel> userRoles = new List<UserRolesModel>();
foreach (ApplicationUser user in userAccountPresentationService.Users)
{
model = new UserRolesModel
{
User = new List<ApplicationUser>(),
Roles = new List<IdentityRole>()
};
model.User.Add(user);
foreach (IdentityRole role in rolePresentationService.Roles)
{
if (await userAccountPresentationService.IsInRole(user, role.Name))
{
model.Roles.Add(role);
}
}
userRoles.Add(model);
}
return View(userRoles);
}
// GET: /User/ManageRole/5
public ActionResult ManageRole(String id)
{
UserRolesModel userRoles = new UserRolesModel();
// Get the User object.
User user = DirectoryService.users.Where(it => (it.objectId == id)).SingleOrDefault();
if (user == null)
{
return(HttpNotFound());
}
userRoles.User = user;
// Get all Roles and divide them into the ones who belong to this group
// and those who don't. We will show these differently in the View.
List <Role> unassingedRoles = new List <Role>();
DirectoryService.LoadProperty(user, "memberOf");
List <Role> currentRoles = user.memberOf.OfType <Role>().ToList();
var roles = DirectoryService.roles;
foreach (Role role in roles)
{
if (!currentRoles.Exists(it => it.objectId.Equals(role.objectId)))
{
unassingedRoles.Add(role);
}
}
userRoles.UnassignedRoles = unassingedRoles;
userRoles.CurrentRoles = currentRoles;
return(View(userRoles));
}
public ActionResult EditRolesForUser(string id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
UserRolesModel urm = new UserRolesModel();
var user = UserManager.Users.Where(u => u.Id == id).FirstOrDefault();
if (user == null)
{
return HttpNotFound();
}
urm.UserId = id;
urm.UserName = user.UserName;
urm.UserRolesList = RoleManager.Roles.ToList();
IList<string> userRoleNames = UserManager.GetRoles(urm.UserId);
urm.CurrentRoles = new List<IdentityRole>();
// Add identity roles to a new list and return view
foreach (var role in RoleManager.Roles)
{
foreach (string userRoleName in userRoleNames)
{
if (role.Name == userRoleName)
{
urm.CurrentRoles.Add(role);
}
}
}
return View(urm);
}
public async Task <IActionResult> RemoveRole(string id)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var userModel = new UserRolesModel
{
Id = id,
Email = user.Email,
RolesName = new List <string>(),
NewRole = null
};
foreach (var item in _roleManager.Roles)
{
if (_userManager.IsInRoleAsync(user, item.Name).Result)
{
userModel.RolesName.Add(item.Name);
}
}
return(View(userModel));
}
public async Task <bool> ChangeUserRole(int id, bool add, int[] currentRoles, int[] roles)
{
try
{
foreach (var role in roles)
{
if (!currentRoles.Contains(role) && add)
{
UserRolesModel userRoles = new UserRolesModel();
userRoles.RoleId = role;
userRoles.UserId = id;
_context.UserRoles.Add(userRoles);
await _context.SaveChangesAsync();
}
else if (currentRoles.Contains(role) && !add)
{
var unrequiredRole = await _context.UserRoles.Where(x => x.UserId == id && x.RoleId == role).FirstOrDefaultAsync();
_context.UserRoles.Remove(unrequiredRole);
await _context.SaveChangesAsync();
}
}
return(true);
}
catch (Exception e)
{
return(false);
}
}
public async Task <IEnumerable <UserRolesModel> > GetUserRoles()
{
var query = await(
from userRole in _db.UserRoles
join users in _db.Users
on userRole.UserId equals users.Id
join roles in _db.Roles
on userRole.RoleId equals roles.Id
select new
{
userRole.UserId,
userRole.RoleId,
users.UserName,
roles.Name
}).ToListAsync();
List <UserRolesModel> userRolesModels = new List <UserRolesModel>();
if (query.Count > 0)
{
for (int i = 0; i < query.Count; i++)
{
var model = new UserRolesModel
{
UserId = query[i].UserId,
UserName = query[i].UserName,
RoleId = query[i].RoleId,
RoleName = query[i].Name
};
userRolesModels.Add(model);
}
}
return(userRolesModels);
}
public async Task <JsonResult> GetUserRolesUserInfo(string id)
{
UserRolesModel response = new UserRolesModel();
UserModel user = await _userManager.FindByIdAsync(id);
if (user != null)
{
var roles = _roleManger.Roles.OrderBy(r => r.Name);
var userRoles = await _userManager.GetRolesAsync(user);
if (roles.Count() > 0)
{
foreach (var role in roles)
{
response.Roles.Add(new RoleBelongingModel()
{
RoleName = role.Name,
UserBelongs = userRoles.Contains(role.Name) ? true : false,
});
}
response.ValidUser = true;
response.UserId = user.Id;
response.UserName = user.UserName;
}
}
return(Json(response));
}
public async Task <IActionResult> AddRoleToUser(UserRolesModel userModel)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(userModel.Id);
if (user == null)
{
return(View(userModel));
}
var newRole = await _roleManager.FindByNameAsync(userModel.NewRole);
if (newRole == null)
{
return(View(userModel));
}
if (userModel.RolesName == null)
{
await _userManager.AddToRoleAsync(user, newRole.Name);
userModel.RolesName = new List <string>();
userModel.RolesName.Add(newRole.Name);
return(RedirectToAction("Index", _userManager.Users.ToList()));
}
if (!userModel.RolesName.Contains(newRole.Name))
{
userModel.RolesName.Add(newRole.Name);
await _userManager.AddToRoleAsync(user, newRole.Name);
return(RedirectToAction("Index", _userManager.Users.ToList()));
}
}
return(View(userModel));
}
public async Task <IActionResult> EditRoles(string id)
{
List <string> roles = new List <string>();
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var userModel = new UserRolesModel
{
Id = id,
Email = user.Email,
RolesName = new List <string>(),
NewRole = null
};
foreach (var item in _roleManager.Roles.ToList())
{
if (_userManager.IsInRoleAsync(user, item.Name).Result)
{
userModel.RolesName.Add(item.Name);
}
else
{
roles.Add(item.Name);
}
}
ViewBag.roles = roles;
return(View(userModel));
}
private void CheckRoles()
{
UserRoles = Singleton.UserRoles;
UserRoles.Cpo = UserRoles.Cpo == "Visible" && Singleton.Setting.EnableCpoTransaction ? "Visible" : "Collapsed";
UserRoles.ItemBorrows = UserRoles.ItemBorrows == "Visible" && Singleton.Setting.EnableCpoTransaction ? "Visible" : "Collapsed";
UserRoles.Admin = UserRoles.Settings == "Visible" ||
UserRoles.UsersMgmt == "Visible" ||
UserRoles.BackupRestore == "Visible" ||
UserRoles.ClientProfile == "Visible" ||
UserRoles.OrganizationProfile == "Visible" ||
UserRoles.AddStores == "Visible" ||
UserRoles.UpdateStores == "Visible"
? "Visible" : "Collapsed";
UserRoles.Settings = UserRoles.GeneralSettings == "Visible" ||
UserRoles.TaxSettings == "Visible" ||
UserRoles.AdvancedSettings == "Visible"
? "Visible"
: "Collapsed";
UserRoles.Sales = UserRoles.ViewSales == "Visible" ||
UserRoles.AddSales == "Visible" ||
UserRoles.PostSales == "Visible" ||
UserRoles.UnPostSales == "Visible" ||
UserRoles.SalesLineHistory == "Visible" ||
UserRoles.DeleteSales == "Visible" ||
UserRoles.SalesPayments == "Visible"
? "Visible" : "Collapsed";
//UserRoles.ClientProfile = "Visible";// "Collapsed";
}
public UserController(UserManager <ApplicationUser> userManager, RoleManager <IdentityRole> roleManager, IConfiguration configuration)
{
this.userManager = userManager;
this.roleManager = roleManager;
_configuration = configuration;
_userService = new UserServices();
_Commonservice = new CommonServices();
UserRolesModel = new UserRolesModel();
}
/// <summary>
/// A basic add example
/// </summary>
/// <param name="user">User ID. You can include a comma delimited list of User ID's or Role ID's, but not both. Example: "BILLW,ALEXY"</param>
/// <param name="role">Role ID. You can include a comma delimited list of User ID's or Role ID's, but not both.</param>
/// <returns>A message for how many UserRole relationships were created.</returns>
public string Add(string user, string role)
{
var myUserRole = new UserRolesModel
{
User = user,
Role = role
};
return(APIUtil.AddUserRole(USISDKClient, myUserRole));
}
public ActionResult UserRoles(int userId)
{
var model = new UserRolesModel
{
UserId = userId,
ListUserRoles = new UserRoles().GetListByUserId(userId)
};
return(View(model));
}
/// <summary>
/// 添加用户角色
/// </summary>
/// <param name="userrole"></param>
/// <returns>是否添加成功</returns>
public UserRolesModel AddUserRole(UserRolesModel userrole)
{
using (var dbContext = new MissionskyOAEntities())
{
var userroleEntity = userrole.ToEntity();
dbContext.UserRoles.Add(userroleEntity);
dbContext.SaveChanges();
return(userroleEntity.ToModel());
}
}
public static UserRole ToEntity(this UserRolesModel model)
{
var entity = new UserRole()
{
Id = model.Id,
RoleId = model.RoleId,
UserId = model.UserId,
};
return(entity);
}
public async Task UserRolesSave(UserRolesModel model)
{
if (model.Id == 0)
{
await AddEntity <UserRolesEntity, UserRolesModel>(model);
}
else
{
await this.SaveEntity <UserRolesEntity, UserRolesModel>(model);
}
}
public IHttpActionResult RemoveRoles([FromBody] UserRolesModel model)
{
var script = _powershellScriptLoader.LoadScript(PowershellScripts.RemoveUserRoles);
_powerShellUtility.AttachOffice365Credentials(_powerShellManager);
_powerShellManager.AttachParameters(model.MapPropertiesToOffice365Parameters());
_powerShellManager.ExecuteScript(script);
return(Ok());
}
public virtual ActionResult UserRoles(string userName)
{
var userroles = new UserRolesModel
{
UserRoles = GetUserRoles(userName).OrderBy(o => o.SortOrder).ToArray()
};
Session["Roles"] = userroles;
Session["UserName"] = userName;
return(PartialView("Users/UserRoles", userroles));
}
public ActionResult View(string id)
{
if (string.IsNullOrEmpty(id))
{
using (var context = new AttendanceTrackerDatabaseConnection())
{
var aspUserId = User.Identity.GetUserId();
id = context.Users.FirstOrDefault(x => x.AspNetUsersId == aspUserId).Id.ToString();
}
}
return(View(UserViewModel.ViewUser(id, UserRolesModel.IsAdmin(User.Identity.GetUserId()))));
}
//public ActionResult AddRowUserRolePermissions()
//{
// ParentUserRolesModel parentUserRolesModel = (ParentUserRolesModel)Session["UserRolesModelList"];
// int urpId = 0;
// urpId = parentUserRolesModel.UserRoleModelList.Count == 0 ? urpId : (parentUserRolesModel.UserRoleModelList.Last().UserRolePermissionId);
// UserRolesModel newUserRolesModel = new UserRolesModel();
// newUserRolesModel.UserRolePermissionId = ++urpId;
// parentUserRolesModel.UserRoleModelList.Add(newUserRolesModel);
// return View("UserRoles", parentUserRolesModel);
//}
public IList <UserRolesModel> AddRowToUserRolePermissions(string username)
{
//string username = Request.Params["username"];
IList <UserRolesModel> userRoleModelList = (IList <UserRolesModel>)Session["UserRolesModelList" + username];
int urpId = 0;
urpId = userRoleModelList.Count == 0 ? urpId : (userRoleModelList.Last().UserRolePermissionId);
UserRolesModel newUserRolesModel = new UserRolesModel();
newUserRolesModel.UserRolePermissionId = ++urpId;
userRoleModelList.Add(newUserRolesModel);
return(userRoleModelList);
}
public IHttpActionResult GetUserRoles([FromBody] UserRolesModel model)
{
var script = _powershellScriptLoader.LoadScript(PowershellScripts.GetUserRoles);
_powerShellUtility.AttachOffice365Credentials(_powerShellManager);
_powerShellManager.AttachParameters(model.MapPropertiesToOffice365Parameters());
var roles = _powerShellManager.ExecuteScript <string>(script);
var removedEmptyRoles = roles.Where(r => r.Length > 0);
return(Ok(removedEmptyRoles));
}
public ActionResult Edit(string id)
{
var userId = User.Identity.GetUserId();
if (UserRolesModel.IsTeacher(userId) || UserRolesModel.IsAdmin(userId))
{
return(View(CourseEditModel.CourseEdit(id)));
}
else
{
return(RedirectToAction("Unauthorized", "User"));
}
}
// GET: Course
public ActionResult Index()
{
var userId = User.Identity.GetUserId();
if (userId != null && UserRolesModel.IsStudent(userId) || UserRolesModel.IsTeacher(userId) || UserRolesModel.IsAdmin(userId))
{
return(View());
}
else
{
return(RedirectToAction("Unauthorized", "User"));
}
}
private void CheckRoles()
{
UserRoles = Singleton.UserRoles;
UserRoles.Settings = UserRoles.GeneralSettings == "Visible" ||
UserRoles.TaxSettings == "Visible" ||
UserRoles.AdvancedSettings == "Visible"
? "Visible" : "Collapsed";
UserRoles.Admin = UserRoles.Company == "Visible" ||
UserRoles.Settings == "Visible" ||
UserRoles.UsersMgmt == "Visible" ||
UserRoles.BackupRestore == "Visible"
? "Visible" : "Collapsed";
}
public async Task <IActionResult> EditAdmin(string id)
{
var model = new UserRolesModel();
model.User = _dbContext.Users.Single(a => a.Id == id);
model.IsAdmin = await _userManager.IsInRoleAsync(model.User, RoleCodes.Admin);
model.IsLabUser = await _userManager.IsInRoleAsync(model.User, RoleCodes.LabUser);
model.IsReports = await _userManager.IsInRoleAsync(model.User, RoleCodes.Reports);
return(View(model));
}
public async Task <IActionResult> GetUserRoles(string userId)
{
try
{
UserRolesModel userRolesResult = await GetUserRolesAsync(userId);
return(Ok(new { allRoles = userRolesResult.AllRoles, userRoles = userRolesResult.UserRoles }));
}
catch (Exception ex)
{
return(Ok(CommonUtility.GetExResponse <Exception>(ex)));
}
}
public async Task <ActionResult> UserRoles(string ID)
{
UserRolesModel model = new UserRolesModel();
model.UserID = ID;
var user = await UserManager.FindByIdAsync(ID);
var userRoleIDs = user.Roles.Select(x => x.RoleId).ToList();
model.UserRoles = RoleManager.Roles.Where(x => userRoleIDs.Contains(x.Id)).ToList();
model.Roles = RoleManager.Roles.Where(x => !userRoleIDs.Contains(x.Id)).ToList();
return(PartialView("_UserRoles", model));
}
public AdministrationModel()
{
UsersModel = new UsersModel();
UserRolesModel = new UserRolesModel();
}
public ActionResult UserRolesData(UserRolesModel model)
{
FillUserRolesModel(model);
return View(model);
}
private void FillUserRolesModel(UserRolesModel model)
{
var users = Execute(() => _accountService.GetUsers(model.RoleType, model.Term, model.Pager.PageId, model.Pager.PageSize, CurrentUser.Role));
model.CopyFrom(users);
}
public ActionResult ChangeRole(int? userId, int? roleId, UserRolesModel model)
{
Execute(() => _accountService.UpdateRole(roleId.GetValueOrDefault(), userId.GetValueOrDefault()));
FillUserRolesModel(model);
return ModelIsValid
? (ActionResult)View("UserRolesData", model)
: JsonErrorResult();
}
