public IActionResult Update([FromBody] RolePermissionModel itemDto)
{
return(new ControllerHelper <RolePermission, RolePermissionModel>(this, _mapper)
.Update(itemDto, (session, item) =>
{
var itemEx = session.Get <RolePermission>(item.ID);
if (itemEx == null)
{
throw new AppException("Record not found");
}
session.Evict(itemEx);
var exists = session.CreateCriteria <RolePermission>()
.Add(Restrictions.Eq("Name", item.Name))
.Add(!Restrictions.Eq("ID", item.ID))
.List <RolePermission>().Any();
if (exists)
{
throw new AppException($"RolePermission name {item.Name} already exists!");
}
TrackModification(item);
}, (session, item) =>
{
item = session.Get <RolePermission>(item.ID);
return _mapper.Map <RolePermissionModel>(item);
}));
}
/// <summary>
/// 根据项目编码和停车场编码获取所有用户列表
/// </summary>
/// <param name="projectGuid">项目编码</param>
/// <param name="parkingCode">车场编码</param>
/// <returns></returns>
public List <UserAccountModel> GetUserList(string projectGuid, string parkingCode)
{
//该项目下所有用户列表
List <UserAccountModel> userList = databaseoperate.GetMostFromDataBase(projectGuid) as List <UserAccountModel>;
//该项目下所有角色列表
List <RolePermissionModel> roleList = _roleManager.GetRoleList(projectGuid);
//创建一个新的用户列表
List <UserAccountModel> newUserList = new List <UserAccountModel>();
if (userList != null && roleList != null)
{
foreach (var userItem in userList)
{
//查找当前用户所属的角色
RolePermissionModel tempRoleModel = roleList.Find(m => m.Guid == userItem.RoleGuid);
if (tempRoleModel != null)
{
if (!string.IsNullOrEmpty(tempRoleModel.ParkingCodeList))
{
//当前角色是否拥有当前停车场的权限
foreach (var parkingCodeItem in tempRoleModel.ParkingCodeList.Split(new string[] { "," }, System.StringSplitOptions.RemoveEmptyEntries))
{
if (parkingCodeItem == parkingCode)
{
//拥有当前车场的权限，则将当前用户添加到新用户列表集合中
newUserList.Add(userItem);
}
}
}
}
}
}
return(newUserList);
}
public ActionResult EditPermission(string roleId)
{
var role = this.roleService.Get(g => g.SystemRoleId == roleId);
var model = new RolePermissionModel()
{
RoleName = role.RoleName,
SystemRoleId = role.SystemRoleId,
Permissions = role.Permissions.IsNullOrEmpty() ? new string[0] : role.Permissions.Split(',')
};
#region 权限数据
var groupList = this.permissionService.GetPermissionGroup(g => true).OrderByDescending(g => g.CreateTime).ToList();
// 已分组权限
var grouped = groupList.Where(g => !g.Permissions.IsNullOrEmpty())
.Select(g => g.Permissions).SelectMany(s => s.Split(',')).Distinct();
// 全部权限
var all = PermissionUtil.PermissionUrls.Select(p => p.Value).Distinct();
// 未分组权限
var ungrouped = all.Except(grouped);
groupList.Add(new SYS_PermissionGroup
{
GroupName = "未分组",
Permissions = string.Join(",", ungrouped)
});
ViewBag.GroupList = groupList;
#endregion
return(View(model));
}
public async Task <IActionResult> Add(RoleRequest roleDto)
{
try
{
if (roleDto == null)
{
return(BadRequest());
}
var roleModel = new RolePermissionModel()
{
Name = roleDto.Name,
Permissions = roleDto.Permissions,
RoleId = roleDto.RoleId
};
var role = await _roleService.AddRole(roleModel);
if (role != null)
{
var roleResponseDto = new RoleResponse {
Name = role.Name, Permissions = role.Permissions, RoleId = role.RoleId
};
return(CreatedAtAction(nameof(GetRole), new { id = role.RoleId }, roleResponseDto));
}
return(StatusCode(StatusCodes.Status404NotFound));
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
/// <summary>
/// 获取某角色
/// </summary>
/// <param name="projectGuid"></param>
/// <returns></returns>
public RolePermissionModel GetRole(string guid)
{
RolePermissionModel model = null;
redisoperate.model = new RolePermissionModel()
{
Guid = guid
};
model = redisoperate.GetFromRedis();
//从数据库读
if (model == null)
{
model = databaseoperate.GetFromDataBase(guid);
//缓存到redis
if (model != null)
{
redisoperate.model = model;
redisoperate.SaveToRedis();
}
else
{
LastErrorDescribe = "未找到该角色";
}
}
return(model);
}
public async Task <IActionResult> UpdateRole([FromBody] RoleRequest roleDto)
{
try
{
if (roleDto == null)
{
return(BadRequest());
}
var role = new RolePermissionModel()
{
Name = roleDto.Name,
Permissions = roleDto.Permissions,
RoleId = roleDto.RoleId
};
var result = await _roleService.UpdateRole(role);
if (result)
{
return(Ok(roleDto));
}
return(UnprocessableEntity(new { message = $"Unable to update role", key = "restrict" }));
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <IActionResult> AddPermmission([FromBody] RolePermissionModel newPermission)
{
if (!ModelState.IsValid)
{
var modelErrors = new List <string>();
foreach (var modelState in ModelState.Values)
{
foreach (var modelError in modelState.Errors)
{
modelErrors.Add(modelError.ErrorMessage);
}
}
return(BadRequest(new AddingResult {
Successful = false, Errors = modelErrors
}));
}
var permission = new RolePermission
{
Id = Guid.NewGuid(),
EmployeeId = newPermission.EmployeeId,
EmplyoeeRoleId = newPermission.RoleId,
ExpiringTime = newPermission.ExpiringDate
};
var successful = await _permissionService.AddPermissionAsync(permission);
if (!successful)
{
return(BadRequest("Could not add role."));
}
return(Ok("Added permission: " + permission.Id));
}
public async Task <RolePermissionModel> AddRole(RolePermissionModel role)
{
var response = await _client.PostAsJsonAsync <RolePermissionModel>("/roles", role);
var json = await response.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <RolePermissionModel>(json));
}
private void UpdateRolePermissionFromModel(RolePermission target, RolePermissionModel source)
{
target.RolePermissionId = 0;
target.RoleInfoId = Convert.ToInt32(source.RoleInfoId ?? "0");
target.ScreenId = source.ScreenId;
target.OptionId = source.OptionId;
target.CanView = source.CanView;
target.ScreenName = source.ScreenName;
}
/// <summary>
/// Create api model from service model
/// </summary>
/// <param name="model"></param>
public RolePermissionApiModel(RolePermissionModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
RoleId = model.RoleId;
Permissions = model.Permissions;
}
public async Task Change(string id)
{
roleRequest = roles.Where(r => r.RoleId == id).Select(r => new RolePermissionModel()
{
RoleId = r.RoleId,
Name = r.Name,
Permissions = r.Permissions
}).FirstOrDefault();
modal.Open();
}
public IHttpActionResult GetRolePermission(string Guid)
{
RolePermissionResponse response = new RolePermissionResponse()
{
IsSuccess = true,
MessageCode = (int)ApiBaseErrorCode.API_SUCCESS,
MessageContent = ApiBaseErrorCode.API_SUCCESS.ToString(),
OpenUpMenuSerial = new List <string>()
};
if (string.IsNullOrWhiteSpace(Guid))
{
response.IsSuccess = false;
response.MessageCode = (int)ApiBaseErrorCode.API_PARAM_ERROR;
response.MessageContent = "角色标识不能为空,请检查";
return(Ok(response));
}
RolePermissionModel rolemodel = rolemanager.GetRole(Guid);
if (rolemodel != null)
{
string privilegeStr = rolemodel.ContentDetial;
for (int i = 1; i <= privilegeStr.Length / 4; i++)
{
try
{
string flag = privilegeStr.Substring(i * 4 - 1, 1);
string menuserial = privilegeStr.Substring((i - 1) * 4, 3);
if (flag == "1")
{
response.OpenUpMenuSerial.Add(menuserial);
}
}
catch (Exception ex)
{
Logger.LogFatal(LoggerLogicEnum.Interface, "", "", "", rolemodel.ProjectGuid, "获取角色权限时发生异常", ex.ToString());
}
}
if (!string.IsNullOrEmpty(rolemodel.ParkingCodeList))
{
response.ParkingCodeList = rolemodel.ParkingCodeList.Split(',').ToList();
}
response.IsAdmin = rolemodel.IsAdmin;
}
else
{
response.IsSuccess = false;
response.MessageCode = (int)ApiPersonnelErrorCode.API_DATA_NULL_ERROR;
response.MessageContent = ApiPersonnelErrorCode.API_DATA_NULL_ERROR.ToString();
}
return(Ok(response));
}
/// <summary>
/// 添加角色
/// </summary>
/// <param name=""></param>
/// <returns></returns>
public bool AddRole(RolePermissionModel model)
{
redisoperate.model = model;
bool flag = databaseoperate.SaveToDataBase(model);
if (!flag)
{
return(false); //数据库不成功就不要往下执行了
}
return(redisoperate.SaveToRedis());
}
public async Task <int> DeleteRolePermissionAsync(RolePermissionModel model)
{
var rolePermission = new RolePermission {
RolePermissionId = model.RolePermissionId
};
using (var dataService = DataServiceFactory.CreateDataService())
{
return(await dataService.DeleteRolePermissionAsync(rolePermission));
}
}
public async Task <IActionResult> UpdateAssignPermissionToRole([FromBody] RolePermissionModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
int companyId = int.Parse(HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.NameIdentifier).FirstOrDefault().Value);
var update = await _permissionService.Update(model, companyId);
return(Ok(new { Success = true, result = update }));
}
public IHttpActionResult ModifyOperator(ModifyUserRequest model)
{
ResponseBaseCommon response = new ResponseBaseCommon()
{
IsSuccess = true,
MessageCode = (int)ApiBaseErrorCode.API_SUCCESS,
MessageContent = ApiBaseErrorCode.API_SUCCESS.ToString()
};
if (string.IsNullOrWhiteSpace(model.UserName) ||
string.IsNullOrWhiteSpace(model.UserPswd) ||
string.IsNullOrWhiteSpace(model.Guid) ||
string.IsNullOrWhiteSpace(model.ProjectGuid))
{
response.IsSuccess = false;
response.MessageCode = (int)ApiBaseErrorCode.API_PARAM_ERROR;
response.MessageContent = "必要参数缺失,请检查";
return(Ok(response));
}
UserAccountModel content = usermanager.GetUser(model.Guid);
if (content != null)
{
if (content.ProjectGuid == model.ProjectGuid)
{
RolePermissionModel rolemodel = rolemanager.GetRole(model.RoleGuid);
content.UserName = model.UserName;
content.UserPswd = BitConverter.ToString(new MD5CryptoServiceProvider().ComputeHash(Encoding.UTF8.GetBytes(model.UserPswd))).Replace("-", "");
content.Mobile = model.Mobile;
content.Privilege = rolemodel.ContentDetial;
content.RoleGuid = model.RoleGuid;
if (!usermanager.ModifyUser(content))
{
response.IsSuccess = false;
response.MessageCode = (int)ApiBaseErrorCode.API_FAIL;
response.MessageContent = usermanager.LastErrorDescribe;// ApiBaseErrorCode.API_FAIL.ToString();
}
}
else
{
response.IsSuccess = false;
response.MessageCode = (int)ApiBaseErrorCode.API_INTERFACENAME_ERROR;
response.MessageContent = ApiBaseErrorCode.API_INTERFACENAME_ERROR.ToString();
}
}
else
{
response.IsSuccess = false;
response.MessageCode = (int)ApiPersonnelErrorCode.API_DATA_NULL_ERROR;
response.MessageContent = ApiPersonnelErrorCode.API_DATA_NULL_ERROR.ToString();
}
return(Ok(response));
}
/// <summary>
/// Create api model from service model
/// </summary>
/// <param name="model"></param>
public static RolePermissionApiModel ToApiModel(
this RolePermissionModel model)
{
if (model == null)
{
return(null);
}
return(new RolePermissionApiModel {
RoleId = model.RoleId,
Permissions = (IIoT.OpcUa.Api.Twin.Models.RolePermissions?)model.Permissions
});
}
public void Merge(RolePermissionModel source)
{
if (source != null)
{
RolePermissionId = source.RolePermissionId;
RoleInfoId = source.RoleInfoId;
ScreenId = source.ScreenId;
OptionId = source.OptionId;
CanView = source.CanView;
ScreenName = source.ScreenName;
}
}
/// <summary>
/// Convert service model to role permission type
/// </summary>
/// <param name="model"></param>
/// <param name="context"></param>
/// <returns></returns>
public static RolePermissionType ToStackModel(this RolePermissionModel model,
ServiceMessageContext context)
{
if (model == null)
{
return(null);
}
return(new RolePermissionType {
RoleId = model.RoleId.ToNodeId(context),
Permissions = /*(uint)*/ model.Permissions.ToStackType()
});
}
public async Task <IActionResult> EditPermission(string id, [FromBody] RolePermissionModel updatedRole)
{
var successful = await _permissionService
.UpdatePermissionAsync(id, updatedRole);
if (!successful)
{
return(BadRequest("Could not update employee."));
}
return(Ok("Updated employee of id: " + id));
}
public ActionResult EditPermissionForAjax(RolePermissionModel model)
{
if (ModelState.IsValid)
{
var role = roleService.Get(x => x.SystemRoleId == model.SystemRoleId);
role.Permissions = string.Join(",", model.Permissions ?? new string[0]).TrimEnd(',');
return(Json(this.roleService.Update(role)));
}
return(Json(new ServiceResult(GetModelStateMessage())));
}
public ActionResult Permission(int id)
{
var roleModules = _roleManagementAppService.GetRoleModules(id);
RolePermissionModel model = new RolePermissionModel {
RoleId = id,
RoleName = _roleManagementAppService.GetRole(id).RoleName,
PermissionModules = roleModules,
AllPermissionModules = _permissionModuleAppService.GetPermissionModuleList()
};
return(View(model));
}
/// <summary>
/// 修改角色
/// </summary>
/// <param name=""></param>
/// <returns></returns>
public bool ModifyRole(RolePermissionModel model)
{
redisoperate.model = model;
bool flag = databaseoperate.SaveToDataBase(model);
if (!flag)
{
return(false); //数据库不成功就不要往下执行了
}
//此时不需要判断redis是否成功，因为修改时redis一定会返回false
redisoperate.SaveToRedis();
return(true);
}
public IActionResult Index(int?webRoleId)
{
_iCommonService.GetPageWiseRoleRigths("RolePermission");
RolePermissionModel rolePermissionModel = new RolePermissionModel();
rolePermissionModel.WebRoleList = _iDropDownService.GetWebRoleList();
if (webRoleId != null)
{
rolePermissionModel.WebRolePages = _iRolePermissionService.GetWebRolePermissionList(Convert.ToInt32(webRoleId));
rolePermissionModel.WebRolesId = Convert.ToInt32(webRoleId);
}
return(View(rolePermissionModel));
}
public ActionResult AddRolePermission(RolePermissionModel rolePermissionModel)
{
int count = roleMapping.DeleteAndInsertMany(rolePermissionModel.Role, rolePermissionModel.Names);
if (count > 0)
{
return(new ResponseModel <string>(ErrorCode.success, "", count));
}
else
{
return(new ResponseModel <string>(ErrorCode.server_exception, "", count));
}
}
private void Save()
{
RolePermissionModel rolePermissionModel = new RolePermissionModel()
{
RoleId = role.Id,
Name = role.Name,
Permissions = this.Permissions.Where(p => p.IsSelected).Select(p => p.Name).ToArray()
};
securityService.UpdateRole(rolePermissionModel);
toastService.ShowInfo("Role Updated Successfully.");
Refresh.InvokeAsync();
}
//[Authorize(Policy = PermissionsList.PermissionsRolesRemove)]
public async Task <IActionResult> Remove([FromBody] RolePermissionModel permissionModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
Roles roleToChange = await _rolesRepository.GetRole(permissionModel.Role);
FieldInfo validPermission = typeof(PermissionsList)
.GetFields()
.Where(f => f.GetValue(null).ToString() == permissionModel.Permission)
.FirstOrDefault();
if (validPermission == null)
{
return(BadRequest());
}
List <RolesPermission> rolePermissions = roleToChange.Permissions.ToList();
if (rolePermissions.Find(e => e.Permission.Name == permissionModel.Permission) == null)
{
return(BadRequest());
}
var permissions = await _permissionRepository.GetAll();
Permission permission = permissions.Where(p => p.Name == permissionModel.Permission)
.FirstOrDefault();
RolesPermission permissionToAdd = new RolesPermission()
{
Id = Guid.NewGuid(),
Permission = permission,
Role = roleToChange
};
_rolesPermissionRepository.Delete(permissionToAdd);
rolePermissions.Remove(permissionToAdd);
roleToChange.Permissions = rolePermissions;
_rolesRepository.Update(roleToChange);
return(Ok(String.Format("Added permission {0} to {1} role",
permissionModel.Permission,
permissionModel.Role)));
}
static public async Task <RolePermissionModel> CreateRolePermissionModelAsync(RolePermission source, bool includeAllFields)
{
var model = new RolePermissionModel()
{
RolePermissionId = source.RolePermissionId,
RoleInfoId = source.RoleInfoId.ToString(),
ScreenId = source.ScreenId,
OptionId = source.OptionId,
CanView = source.CanView,
ScreenName = source.ScreenName
};
return(model);
}
public ActionResult RolePermission(Guid id)
{
RolePermissionModel model = new RolePermissionModel();
model.CategoryList = _categoryService.getAll();
var roleList = _sysRoleService.getAllRoles();
if (roleList != null && roleList.Any())
{
model.Role = roleList.FirstOrDefault(o => o.Id == id);
model.RoleList = roleList;
model.Permissions = _sysPermissionService.getByRoleId(id);
}
return(View(model));
}
/// <summary>
/// 给角色增加新的授权车场
/// </summary>
/// <param name="guid"></param>
/// <param name="parkingCode"></param>
/// <returns></returns>
public bool ModifyRoleAddParkingCode(string guid, string parkingCode)
{
RolePermissionModel roleModel = GetRole(guid);
if (roleModel == null)
{
return(false);
}
//角色的车场权限编号，不进行重复增加
if (roleModel.ParkingCodeList.IndexOf(parkingCode) > 0)
{
return(true);
}
roleModel.ParkingCodeList += "," + parkingCode;
return(ModifyRole(roleModel));
}
