public virtual bool Update(RoleDetails _role)
{
try
{
RoleDetails.Attach(_role);
_context.Entry(_role).State = EntityState.Modified;
return(true);
}
catch (Exception)
{
return(false);
throw;
}
}
public ActionResult Details(int id)
{
RoleDetails details = _roleRepository.GetRoleDetails(UserContext.User.Id, UserContext.User.OrganizationId, id);
if (details.Detail == null)
{
return(NotFoundResult());
}
RoleDetailsViewModel viewModel = Mapper.Map <RoleDetailsViewModel>(details);
InitDetailsViewModel(viewModel, details);
return(View(Mvc.View.Role.Details, viewModel));
}
public ActionResult Edit([Bind(Include = "Id_Role,RoleName,RoleDescription,IsSysAdmin")] RoleDetails roleDetails)
{
if (ModelState.IsValid)
{
var auxrole = new IdentityRole
{
Id = roleDetails.Id_Role.ToString(),
Name = roleDetails.RoleName
};
_context.Entry(auxrole).State = EntityState.Modified;
_context.Entry(roleDetails).State = EntityState.Modified;
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(roleDetails));
}
public virtual bool DeleteRole(IdentityRole _role)
{
if (_role != null)
{
RoleDetails roleDetails = RoleDetails.FirstOrDefault(p => p.RoleName == _role.Name);
_role.Users.Clear();
roleDetails.Permissions.Clear();
_context.Entry(_role).State = EntityState.Deleted;
_context.Entry(roleDetails).State = EntityState.Deleted;
return(true);
}
return(false);
}
/// <summary>
/// Maps an EF Role record from the db into an RoleDetails
/// object. If the db record is null then null is returned.
/// </summary>
/// <param name="dbRole">Role record from the database.</param>
public virtual RoleDetails Map(Role dbRole)
{
if (dbRole == null)
{
return(null);
}
var role = new RoleDetails()
{
IsAnonymousRole = dbRole.RoleCode == AnonymousRole.AnonymousRoleCode,
IsSuperAdministrator = dbRole.RoleCode == SuperAdminRole.SuperAdminRoleCode,
RoleId = dbRole.RoleId,
RoleCode = dbRole.RoleCode,
Title = dbRole.Title
};
var userArea = _userAreaRepository.GetByCode(dbRole.UserAreaCode);
role.UserArea = new UserAreaMicroSummary()
{
UserAreaCode = dbRole.UserAreaCode,
Name = userArea.Name
};
if (role.IsSuperAdministrator)
{
// Grant super users all permissions
role.Permissions = _permissionRepository.GetAll().ToArray();
}
else
{
var permissions = new List <IPermission>(dbRole.RolePermissions.Count);
foreach (var dbPermission in dbRole.RolePermissions.Select(rp => rp.Permission))
{
var permission = _permissionRepository.GetByCode(dbPermission.PermissionCode, dbPermission.EntityDefinitionCode);
if (permission != null)
{
permissions.Add(permission);
}
}
role.Permissions = permissions.ToArray();
}
return(role);
}
public bool UpdateRole(RoleDetails roleDetails)
{
bool res = false;
using (var context = new AdminAppEntities())
{
Role roleDet = new Role
{
Name = roleDetails.Name,
Active = true,
RoleId = roleDetails.RoleId
};
Role updateRole = context.Roles.Where(x => x.RoleId == roleDetails.RoleId).FirstOrDefault();
context.Entry(updateRole).CurrentValues.SetValues(roleDet);
context.SaveChanges();
res = true;
}
return(res);
}
public bool SaveRole(RoleDetails roleDetails)
{
bool res = false;
using (var context = new AdminAppEntities())
{
Role roleDet = new Role
{
Name = roleDetails.Name,
Active = true,
RoleId = roleDetails.RoleId
};
context.Roles.Add(roleDet);
context.SaveChanges();
res = true;
}
return(res);
}
public async Task <RoleDetails> GetRole(Guid roleId,
CancellationToken cancellationToken)
{
IdentityRole identityRole = await this.RoleManager.FindByIdAsync(roleId.ToString());
if (identityRole == null)
{
throw new NotFoundException($"No role found with Id {roleId}");
}
// Role has been found
RoleDetails response = new RoleDetails
{
RoleId = Guid.Parse(identityRole.Id),
RoleName = identityRole.Name
};
return(response);
}
public PostResult <int> Post(RoleDetails model)
{
var result = GetDefault <PostResult <int> >();
if (isExisted(model.Name, model.Id))
{
result.Message = "当前角色名称已经存在";
return(result);
}
UserRole role = new UserRole()
{
RoleName = model.Name
};
DbEntities.UserRoles.Add(role);
DbEntities.SaveChanges();
result.Id = role.ID;
result.isCreated = true;
return(result);
}
public PutResult Put(RoleDetails role)
{
var result = GetDefault <PutResult>();
var model = DbEntities.UserRoles.FirstOrDefault(x => x.ID == role.Id);
if (model == null)
{
result.Message = "当前角色已经不存在";
return(result);
}
if (isExisted(role.Name, role.Id))
{
result.Message = "当前角色名称已经存在";
return(result);
}
model.RoleName = role.Name;
DbEntities.SaveChanges();
result.isSaved = true;
return(result);
}
public PutResult Put(RoleDetails role)
{
var result = GetDefault <PutResult>();
var model = DbEntities.UserRoles.FirstOrDefault(x => x.ID == role.Id);
if (model == null)
{
result.Message = "ROLE_NOT_EXIST";
return(result);
}
if (isExisted(role.Name, role.Id))
{
result.Message = "ROLE_NAME_HAS_EXIST";
return(result);
}
if (role.Funs != null && role.Funs.Count() > 0)
{
var list = model.UserPermissions.ToList();
foreach (var item in list)
{
if (!role.Funs.Exists(x => x.Id == item.FunctionalityId))
{
DbEntities.UserPermissions.Remove(item);
}
}
foreach (var item in role.Funs)
{
if (!list.Exists(x => x.FunctionalityId == item.Id))
{
model.UserPermissions.Add(new UserPermission()
{
FunctionalityId = item.Id, UserRoleId = role.Id
});
}
}
}
model.RoleName = role.Name;
DbEntities.SaveChanges();
result.IsSaved = true;
return(result);
}
public void RoleCommandService_UpdateRole()
{
RoleDetails roleDetails = MockObjects.NewRoleDetails;
roleReference = Utils.GetRoles().FirstOrDefault();
using (var roleCommandService = DependencyContainer.Resolve <IRoleCommandService>())
{
Assert.IsInstanceOfType(roleCommandService.Instance, typeof(IRoleCommandService));
roleCommandService.Instance.UpdateRole(roleReference.RoleId, roleDetails);
var updatedRole = Utils.GetRole(roleReference.RoleId);
Assert.IsNotNull(updatedRole);
RoleDetails roleDetailsPostUpdate = new RoleDetails
{
Description = updatedRole.Description,
Name = updatedRole.Name,
AgencyPermissions = updatedRole.AgencyPermissions
};
Assert.IsTrue(Utils.ReflectiveEquals(roleDetails, roleDetailsPostUpdate));
}
}
public ActionResult Create([Bind(Include = "Id_Role,RoleName,RoleDescription,IsSysAdmin")] RoleDetails roleDetails)
{
if (ModelState.IsValid)
{
_context.RoleDetails.Add(roleDetails);
_context.SaveChanges();
var auxrole = new IdentityRole
{
Id = _context.RoleDetails.FirstOrDefault(p => p.RoleName == roleDetails.RoleName).Id_Role.ToString(),
Name = roleDetails.RoleName
};
_context.Roles.Add(auxrole);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(roleDetails));
}
public ActionResult RoleCreate(RoleDetails _role)
{
if (_role.RoleDescription == null)
{
ModelState.AddModelError("Role Description", "Role Description must be entered");
}
IdentityUser User = UnitOfWork.UserRepository.GetUserByUserName(this.User.Identity.Name);
if (ModelState.IsValid)
{
if (UnitOfWork.RolesRepository.CreateRol(_role))
{
UnitOfWork.Save();
}
;
return(RedirectToAction("RoleIndex"));
}
ViewBag.List_boolNullYesNo = this.List_boolNullYesNo();
return(View(_role));
}
public bool CreateRol(RoleDetails _role)
{
IdentityRole role = new IdentityRole
{
Id = _role.Id_Role.ToString(),
Name = _role.RoleName
};
try
{
Roles.Add(role);
RoleDetails.Add(_role);
return(true);
}
catch (Exception)
{
return(false);
throw;
}
}
public async Task <IActionResult> Edit(string id)
{
IdentityRole role = await roleManager.FindByIdAsync(id);
var members = new List <ApplicationUser>();
var nonmembers = new List <ApplicationUser>();
foreach (var user in userManager.Users)
{
var list = await userManager.IsInRoleAsync(user, role.Name) ? members : nonmembers;
list.Add(user);
}
var model = new RoleDetails()
{
Role = role,
Members = members,
NonMembers = nonmembers
};
return(View(model));
}
public async Task <IActionResult> RoleEdit(string id)
{
var role = await _roleManager.FindByIdAsync(id);
var members = new List <User>();
var nonMembers = new List <User>();
foreach (var user in _userManager.Users.ToList())
{
var list = await _userManager.IsInRoleAsync(user, role.Name) ? members : nonMembers;
list.Add(user);
}
var model = new RoleDetails()
{
Role = role,
Members = members,
NonMembers = nonMembers
};
return(View(model));
}
//-----------------------Do nooooooooooooooooooooot change role name
//public async Task<IActionResult> Update(string id)
//{
// IdentityRole role = await roleManager.FindByIdAsync(id);
// if (role != null)
// return View(role);
// else
// return RedirectToAction("List");
//}
//[HttpPost]
//public async Task<IActionResult> Update(IdentityRole model)
//{
// if (ModelState.IsValid)
// {
// IdentityRole role = await roleManager.FindByIdAsync(model.Id);
// if (role != null)
// {
// role.Name = model.Name;
// IdentityResult result = await roleManager.UpdateAsync(role);
// if (result.Succeeded)
// {
// TempData["message"] = $"{role.Name} updated !";
// return RedirectToAction("List");
// }
// else
// foreach (var item in result.Errors)
// {
// ModelState.AddModelError(item.Code, item.Description);
// }
// }
// }
// return View(model);
//}
public async Task <IActionResult> Edit(string id)
{
/*
* find role
* find its members
* find non members
* fill data
* return view
*/
IdentityRole role = await roleManager.FindByIdAsync(id);
if (role != null)
{
var members = new List <ApplicationUser>();
var nonMembers = new List <ApplicationUser>();
foreach (var user in userManager.Users)
{
if (await userManager.IsInRoleAsync(user, role.Name))
{
members.Add(user);
}
else
{
nonMembers.Add(user);
}
}
var model = new RoleDetails()
{
Role = role,
Members = members,
NonMembers = nonMembers
};
return(View(model));
}
return(RedirectToAction("List"));
}
public async Task <IActionResult> RoleEdit(string Id)
{
var role = await _roleManager.FindByIdAsync(Id);
var members = new List <User>();
var nonmembers = new List <User>();
foreach (var user in _userManager.Users) // bütün kullanıcıları gezdik
{
var list = await _userManager.IsInRoleAsync(user, role.Name)?members:nonmembers; // kullanıcı o roldemi kontrol eder true false deger döner
list.Add(user); // nonmembers yada members ekler
}
var model = new RoleDetails()
{
Members = members,
NonMembers = nonmembers,
Role = role
};
return(View(model));
}
public async Task <IActionResult> Edit(string id)
{
IdentityRole role = await roleManager.FindByIdAsync(id);
var members = new List <ApplicationUser>();
var nonmembers = new List <ApplicationUser>();
foreach (var user in userManager.Users)
{
var list = await userManager.IsInRoleAsync(user, role.Id) ? members : nonmembers; //Eğer ki true ise "list" değişkleni member olacak,
//false ise nonmembers olacak ve=
list.Add(user);//buradan o kişi o gruba eklenecek
}
var model = new RoleDetails()
{
Role = role,
Members = members,
NonMembers = nonmembers
};
return(View(model));
}
public bool AddAllPermissions2Role(string id)
{
RoleDetails _role = RoleDetails.Where(p => p.Id_Role.ToString() == id).Include("Permissions").FirstOrDefault();
IEnumerable <Permission> _permissions = Permission.ToList();
try
{
foreach (Permission _permission in _permissions)
{
if (!_role.Permissions.Contains(_permission))
{
_role.Permissions.Add(_permission);
}
}
return(true);
}
catch (Exception)
{
return(false);
throw;
}
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
CheckValidation objIsValid = new CheckValidation();
RoleDetails objRole = new RoleDetails();
if (btnSubmit.Visible == true)
{
if (objRole.AddRoleDetails(txtRoleName.Text, txtDescription.Text))
{
lblMessage.ForeColor = System.Drawing.Color.Black;
lblMessage.Text = "Information has been saved successfully";
Utility ObjUtility = new Utility();
ObjUtility.ResetFormControl(pageDiv);
}
else
{
lblMessage.ForeColor = System.Drawing.Color.Red;
lblMessage.Text = "Sorry Unable to Save";
}
}
else if (btnUpdate.Visible == true)
{
if (objRole.EditRoleDetails(int.Parse(lblRoleID.Text), txtRoleName.Text, txtDescription.Text))
{
lblMessage.ForeColor = System.Drawing.Color.Black;
lblMessage.Text = "Information has been Updated successfully";
txtDescription.Text = "";
txtRoleName.Text = "";
}
else
{
lblMessage.ForeColor = System.Drawing.Color.Red;
lblMessage.Text = "Sorry Unable to Update";
}
}
}
public async Task <IActionResult> Edit(string id)
{
IdentityRole role = await roleManager.FindByIdAsync(id); //rolu id ye göre buluoz
var members = new List <ApplicationUser>(); //role göre kullanıcı varsa
var nonmembers = new List <ApplicationUser>(); //role göre kullanıcı yoksa
foreach (var user in userManager.Users) //kullanıcıları gez
{
var list = await userManager.IsInRoleAsync(user, role.Name) //role ıcındeki kullanıcı varsa nmembers a yoksa nomembers a
? members : nonmembers;
list.Add(user);
}
var model = new RoleDetails()//modelle tasımak icin
{
Role = role,
Members = members,
NonMembers = nonmembers
};
return(View(model));
}
public PutResult PermissionPut(RoleDetails role)
{
var result = GetDefault <PutResult>();
var model = DbEntities.UserRoles.FirstOrDefault(x => x.ID == role.Id);
if (model == null)
{
result.Message = string.Format("当前编辑的角色“{0}”已经不存在", role.Name);
return(result);
}
var list = model.UserPermissions.ToList();
DbEntities.UserPermissions.RemoveRange(list.Where(x => !role.Funs.Exists(z => z.Id == x.FunctionalityId)));
var appends = role.Funs.Where(x => !list.Exists(z => z.FunctionalityId == x.Id));
DbEntities.UserPermissions.AddRange(appends.Select(x => new UserPermission()
{
FunctionalityId = x.Id,
UserRoleId = role.Id
}));
DbEntities.SaveChanges();
result.isSaved = true;
return(result);
}
public ActionResult RoleEdit(RoleDetails _role)
{
if (string.IsNullOrEmpty(_role.RoleDescription))
{
ModelState.AddModelError("Role Description", "Role Description must be entered");
}
IdentityUser User = UnitOfWork.UserRepository.GetUserByUserName(this.User.Identity.Name);
if (ModelState.IsValid)
{
if (UnitOfWork.RolesRepository.Update(_role))
{
UnitOfWork.Save();
}
return(RedirectToAction("RoleDetails", new RouteValueDictionary(new { id = _role.Id_Role })));
}
var auxuserlist = UnitOfWork.UserRepository.GetUserDetails(filter: r => r.Inactive == false || r.Inactive == null);
List <IdentityUser> UserList = new List <IdentityUser>();
foreach (var item in auxuserlist)
{
var auxuser = UnitOfWork.UserRepository.GetUserByUserName(item.UserName);
UserList.Add(auxuser);
}
// Users combo-
ViewBag.UserList = new SelectList(UserList, "Id", "UserName");
// Rights combo
ViewBag.PermissionId = new SelectList(UnitOfWork.PermissionRepository.Get(orderBy: p => p.OrderBy(a => a.Id_Permission)), "Id_Permission", "PermissionDescription");
ViewBag.List_boolNullYesNo = this.List_boolNullYesNo();
return(View(_role));
}
private async Task ValidateRoleDeAssignmentAsync(int?oldRoleId, Role newUserRole, RoleDetails executorRole)
{
if (oldRoleId.HasValue &&
!executorRole.IsSuperAdminRole &&
newUserRole.RoleCode != SuperAdminRole.Code)
{
var oldRole = await _dbContext
.Roles
.FilterById(oldRoleId.Value)
.SingleOrDefaultAsync();
if (oldRole.RoleCode == SuperAdminRole.Code)
{
throw new NotPermittedException("Only Super Administrator users can de-assign the Super Administrator role");
}
}
}
/// <summary>
/// Returns array of all roles.
/// </summary>
/// <returns>Array of all roles.</returns>
public override RoleDetails[] GetAllRoles()
{
RoleDetails[] roles = new RoleDetails[m_IDToRoleMap.Count];
m_IDToRoleMap.Values.CopyTo(roles, 0);
return roles;
}
/// <summary>
/// Creates new role.
/// </summary>
/// <param name="role">Role.</param>
/// <returns>ID of new role.</returns>
public override int CreateRole(RoleDetails role)
{
if (m_RoleIDToRoleMap.ContainsKey(role.RoleID))
throw new ArgumentException(
string.Format("Role with ID '{0}' already exists.", role.RoleID));
int id = -1;
using (SqlConnection connection = new SqlConnection(this.ConnectionString))
{
connection.Open();
SqlTransaction transaction = connection.BeginTransaction();
SqlCommand command = connection.CreateCommand();
command.Transaction = transaction;
command.CommandText =
string.Format(
"INSERT INTO {0} (GroupID, Name, Description) VALUES (@GroupID, @Name, @Description) SELECT @@IDENTITY",
DBRolesTableName);
command.Parameters.Add("@GroupID", SqlDbType.NVarChar).Value =
role.RoleID;
command.Parameters.Add("@Name", SqlDbType.NVarChar).Value =
role.Name;
command.Parameters.Add("@Description", SqlDbType.NVarChar).Value =
role.Description;
try
{
id = Convert.ToInt32(ExecuteScalar(command));
transaction.Commit();
role.ID = id;
m_IDToRoleMap[id] = role;
m_RoleIDToRoleMap[role.RoleID] = role;
}
catch
{ transaction.Rollback(); }
}
return id;
}
private void ValidateCustomPermissions(User user, IExecutionContext executionContext, RoleDetails executorRole)
{
if (user.IsSystemAccount)
{
throw new NotPermittedException("You cannot delete the system account.");
}
if (user.UserAreaCode == CofoundryAdminUserArea.AreaCode)
{
_permissionValidationService.EnforcePermission(new CofoundryUserUpdatePermission(), executionContext.UserContext);
}
else
{
_permissionValidationService.EnforcePermission(new NonCofoundryUserUpdatePermission(), executionContext.UserContext);
}
if (user.UserId == executionContext.UserContext.UserId)
{
throw new NotPermittedException("You cannot delete your own user account via this api.");
}
// Only super admins can delete super admin
if (user.Role.RoleCode == SuperAdminRole.SuperAdminRoleCode && !executorRole.IsSuperAdministrator)
{
throw new NotPermittedException("Only Super Administrator users can delete other users with the Super Administrator role");
}
}
private static void SetRoleValues(Role role, RoleDetails details)
{
role.Name = details.Name;
role.NormalizedName = details.NormalizedName;
role.ConcurrencyStamp = details.ConcurrencyStamp;
}
/// <summary>
/// Returns role information from reader.
/// </summary>
/// <param name="reader">Data reader.</param>
/// <returns>Role information from reader.</returns>
protected virtual RoleDetails GetRoleDetailsFromReader(IDataReader reader)
{
RoleDetails details = new RoleDetails();
details.ID = (int)reader["ID"];
details.RoleID = (string)reader["GroupID"];
details.Name = (string)reader["Name"];
details.Description = (string)reader["Description"];
return details;
}
/// <summary>
/// Updates new role.
/// </summary>
/// <param name="role">Role.</param>
/// <returns>True if role was successfully updated; false, otherwise.</returns>
public override bool UpdateRole(RoleDetails role)
{
using (SqlConnection connection = new SqlConnection(this.ConnectionString))
{
SqlCommand command = connection.CreateCommand();
command.CommandText =
string.Format(
"UPDATE {0} SET GroupID=@GroupID, Name=@Name, Description=@Description WHERE ID=@ID",
DBRolesTableName);
command.Parameters.Add("@ID", SqlDbType.Int).Value = role.ID;
command.Parameters.Add("@GroupID", SqlDbType.NVarChar).Value =
role.RoleID;
command.Parameters.Add("@Name", SqlDbType.NVarChar).Value =
role.Name;
command.Parameters.Add("@Description", SqlDbType.NVarChar).Value =
role.Description;
connection.Open();
return (ExecuteNonQuery(command) == 1);
}
}
/// <summary>
/// Creates new role.
/// </summary>
/// <param name="role">Role.</param>
/// <returns>ID of new role.</returns>
/// <exception cref="ArgumentNullException">Role is null.</exception>
/// <exception cref="ArgumentException">Role already exists.</exception>
public override int CreateRole(RoleDetails role)
{
if (role == null)
throw new ArgumentNullException("role");
if (RoleExists(role.RoleID))
return -1;
int id = -1;
using (SqlConnection connection = new SqlConnection(this.ConnectionString))
{
connection.Open();
SqlCommand command = connection.CreateCommand();
command.CommandText =
string.Format(
"INSERT INTO {0} (GroupID, Name, Description) VALUES (@GroupID, @Name, @Description) SELECT @@IDENTITY",
DBRolesTableName);
command.Parameters.Add("@GroupID", SqlDbType.NVarChar).Value =
role.RoleID;
command.Parameters.Add("@Name", SqlDbType.NVarChar).Value =
role.Name;
command.Parameters.Add("@Description", SqlDbType.NVarChar).Value =
role.Description;
id = Convert.ToInt32(ExecuteScalar(command));
role.ID = id;
}
return id;
}
/// <summary>
/// Creates new role.
/// </summary>
/// <param name="role">Role.</param>
/// <returns>ID of new role.</returns>
public override int CreateRole(RoleDetails role)
{
return m_Provider.CreateRole(role);
}
public ResultBase PermissionPut(RoleDetails model)
{
return(Service.PermissionPut(model));
}
public bool UpdateRole(RoleDetails roleDetails)
{
throw new NotImplementedException();
}
/// <summary>
/// Updates new role.
/// </summary>
/// <param name="role">Role.</param>
/// <returns>True if role was successfully updated; false, otherwise.</returns>
public override bool UpdateRole(RoleDetails role)
{
if (!m_IDToRoleMap.ContainsKey(role.ID))
throw new ArgumentException(string.Format("Role with ID {0} is not in database.", role.ID));
RoleDetails oldRole = m_IDToRoleMap[role.ID];
// check if another role with the same roleID exists.
foreach (RoleDetails roleDetails in GetAllRoles())
{
if (roleDetails.ID == oldRole.ID)
continue;
if (roleDetails.RoleID == role.RoleID)
throw new Exception(string.Format("Role with RoleID '{0}' already exists.", role.RoleID));
}
using (SqlConnection connection = new SqlConnection(this.ConnectionString))
{
SqlCommand command = connection.CreateCommand();
command.CommandText =
string.Format(
"UPDATE {0} SET GroupID=@GroupID, Name=@Name, Description=@Description WHERE ID=@ID",
DBRolesTableName);
command.Parameters.Add("@ID", SqlDbType.Int).Value = role.ID;
command.Parameters.Add("@GroupID", SqlDbType.NVarChar).Value =
role.RoleID;
command.Parameters.Add("@Name", SqlDbType.NVarChar).Value =
role.Name;
command.Parameters.Add("@Description", SqlDbType.NVarChar).Value =
role.Description;
connection.Open();
bool result = (ExecuteNonQuery(command) == 1);
// Update cache.
m_IDToRoleMap[role.ID] = role;
m_RoleIDToRoleMap.Remove(oldRole.RoleID);
m_RoleIDToRoleMap[role.RoleID] = role;
return result;
}
}
/// <summary>
/// Updates new role.
/// </summary>
/// <param name="role">Role.</param>
/// <returns>True if role was successfully updated; false, otherwise.</returns>
public override bool UpdateRole(RoleDetails role)
{
return m_Provider.UpdateRole(role);
}
