public IEnumerable <RoleMenuModel> RoleMenuGetByRoleId(Guid roleId)
{
Guid userId = this.GetCurrentUserId();
var data = this._repoRoleMenu.Query()
.Filter(x => x.roleId == roleId)
.Include(x => x.sys_Menu)
.Get()
.ToList();
List <RoleMenuModel> result = new List <RoleMenuModel>();
var parents = data.Where(x => !x.parentRoleMenuId.HasValue).OrderBy(x => x.displayOrder).ThenBy(x => x.description);
foreach (var p in parents)
{
var m = new RoleMenuModel()
{
description = string.IsNullOrEmpty(p.description) ? p.sys_Menu.description : p.description,
actionName = p.sys_Menu.actionName,
controllerName = p.sys_Menu.controllerName,
parameter = p.sys_Menu.parameter,
areaName = p.sys_Menu.areaName,
menuId = p.sourceMenuId,
displayOrder = p.displayOrder,
//parentMenuId = p.parentRoleMenuId,
mainMenu = true,
};
m.Childs = _RoleMenuGetChilds(data, p.id).ToList();
result.Add(m);
}
return(result);
}
public ActionResult RoleMenu(RoleMenuModel model)
{
var result = new Result();
try
{
if (model.RoleId == Guid.Empty)
{
result.Msg = "角色Id不能为空";
return(Json(result));
}
var isSuceess = new RoleBLL().Authorize(model);
if (isSuceess)
{
result.Msg = "授权成功！";
result.Success = true;
}
else
{
result.Msg = "授权失败！";
}
return(Json(result));
}
catch (Exception ex)
{
result.Msg = string.Format("授权失败！{0}", ex.Message);
return(Json(result));
}
}
public ActionResult RoleMenuEdit(int RoleId)
{
UserRoleInfo userRoleInfo = UserRoles.GetUserRoleById(RoleId);
List <RoleMenuItem> rolemenulist = new List <RoleMenuItem>();
List <ArticleClassInfo> menulist = Services.ArticleClass.AdminGetArticleClassTreeList();
foreach (ArticleClassInfo list in menulist)
{
RoleMenuItem item = new RoleMenuItem()
{
isSels = Services.UserRoles.ExistsRoleMenu(RoleId, list.ArticleClassID),
MenuIDs = list.ArticleClassID,
MenuNames = list.ClassName
};
rolemenulist.Add(item);
}
RoleMenuModel model = new RoleMenuModel()
{
UserRoleInfo = userRoleInfo,
RoleMenuList = rolemenulist
};
return(View(model));
}
public async Task <Tuple <bool, string> > CreateRoleMenu(RoleMenuModel obj)
{
Tuple <bool, string> result = null;
int insertStatus = -1;
try
{
var parameters = new DynamicParameters();
using (SqlConnection cxn = new SqlConnection(_dcDb))
{
parameters.Add("@MenuID", obj.MenuID, DbType.Int32);
parameters.Add("@RoleID", obj.RoleID, DbType.String);
insertStatus = await cxn.ExecuteScalarAsync <int>("dbo.Insert_RoleMenu", parameters, commandType : CommandType.StoredProcedure);
}
if (insertStatus == 0)
{
result = Tuple.Create(true, "Screen and Role mapped successfully");
}
else
{
result = Tuple.Create(false, "Screen and Role mapping failed");
}
}
catch (Exception ex)
{
ErrorLog.Write(ex);
result = Tuple.Create(false, ex.Message);
}
return(result);
}
public int CreateRoleMenu(RoleMenuModel role)
{
using (var connection = DataBase.GetOpenConnection(GetConnectionString))
{
var count = connection.Insert <RoleMenuModel>(role);
return((int)count);
}
}
public ApiResult GetRoleMenu(string access_token)
{
result = AccessToken.Check(access_token, "api/role/get");
if (result == null)
{
#region 参数验证
#endregion
#region 逻辑操作
var roleList = from T_Role in db.T_Role orderby T_Role.RoleID select T_Role;
if (roleList.Any())
{
//定义返回 数据 Data
Return_GetList <RoleMenuModel> data = new Return_GetList <RoleMenuModel>();
data.count = roleList.Count();
data.list = new System.Collections.Generic.List <RoleMenuModel>();
//遍历角色列表
foreach (var item in roleList.ToList())
{
RoleMenuModel roleMenuModel = new RoleMenuModel();
roleMenuModel.RoleID = item.RoleID;
roleMenuModel.RoleName = item.Name;
var menuList = from vw_Role in db.vw_Role where (vw_Role.RoleID == item.RoleID) select vw_Role;
if (menuList.Any())
{
roleMenuModel.count = menuList.Count();
foreach (var _item in menuList.ToList())
{
MenuModel menuModel = new MenuModel();
menuModel.ApiID = _item.MenuID;
menuModel.ApiName = _item.MenuName;
menuModel.ApiUrl = _item.Url;
roleMenuModel.MenuList.Add(menuModel);
}
}
else
{
roleMenuModel.count = 0;
roleMenuModel.MenuList = null;
}
data.list.Add(roleMenuModel);
}
return(Success("获取角色功能列表", data));
}
else
{
return(Error("尚未设定角色列表"));
}
#endregion
}
return(result);
}
public async Task <ReturnObj> RoleMenu(RoleMenuModel rpm)
{
var token = await GetUserTokenAsync();
var response = await _apiClient.PutAsync(API.Auth.RoleMenu(_remoteServiceBaseUrl), rpm, token);
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <ReturnObj>(result));
}
public ActionResult <RoleMenuModel> GetById(int id)
{
try
{
RoleMenuModel record = _roleMenu.GetById(id);
return(Ok(record));
}catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <Tuple <bool, string> > CreateRoleMenu(RoleMenuModel obj)
{
Tuple <bool, string> result = null;
try
{
result = await _repo.CreateRoleMenu(obj);
}
catch (Exception ex)
{
ErrorLog.Write(ex);
}
return(result);
}
/// <summary>
/// 添加角色的权限信息
/// </summary>
/// <param name="menuIds">新设置的权限的信息</param>
/// <param name="roleId">角色的编号</param>
/// <returns></returns>
public bool AddRoleMenu(string menuIds, string roleId)
{
List <RoleMenuModel> roleMenus = new List <RoleMenuModel>();
string[] menuIdArray = menuIds.Split(';');
foreach (string menuId in menuIdArray)
{
RoleMenuModel userRole = new RoleMenuModel()
{
F_Id = Utility.GuId(),
F_RoleId = roleId,
F_MenuId = menuId
};
roleMenus.Add(userRole);
}
return(roleDal.AddRoleMenu(roleMenus, roleId));
}
public ActionResult <RoleMenuModel> Update([FromBody] RoleMenuModel model)
{
try
{
if (ModelState.IsValid)
{
RoleMenuModel record = _roleMenu.Update(model);
return(Ok(record));
}
else
{
return(ValidationProblem());
}
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
private void _RoleMenuModelToEntity(Guid userId, Guid roleId, RoleMenuModel model, sys_RoleMenu entity)
{
if (model.Childs.Any())
{
foreach (var item in model.Childs)
{
var rm = new sys_RoleMenu()
{
roleId = roleId,
sourceMenuId = item.menuId,
description = item.description,
displayOrder = item.displayOrder,
updatedBy = userId,
parentRoleMenuId = entity.id,
};
this._repoRoleMenu.Insert(rm);
this._unitOfWork.Save();
_RoleMenuModelToEntity(userId, roleId, item, rm);
}
}
}
public IActionResult RoleMenu([FromBody] RoleMenuModel rpm)
{
if (!ModelState.IsValid)
{
return(Ok(new
{
Result = "Faild",
Message = GetModelStateError()
}));
}
try
{
List <Guid> dto = GetList(rpm.menuIDs, '_');
_service.UpdateRoleMenus(rpm.roleMenuId, dto);
return(Ok(new { Result = "Success" }));
}
catch (Exception ex)
{
return(Ok(new { Result = "Faild", Message = ex.Message }));
}
}
public bool SaveRoleMenu(IEnumerable <MenuModel> rolelist, string roleCode, string userName, string displayName)
{
var success = true;
try
{
_menuRepository.RemoveRoleMenu(roleCode); //删除所有关系
foreach (var item in rolelist)
{
var model = new RoleMenuModel();
model.MenuCode = item.MenuGuid;
model.RoleCode = roleCode;
model.CreateDate = DateTime.Now;
model.CreateUserName = userName;
model.CreateDisplayName = displayName;
_menuRepository.CreateRoleMenu(model); //新增关系
foreach (var child in item.Children)
{
model = new RoleMenuModel();
model.MenuCode = child.MenuGuid;
model.RoleCode = roleCode;
model.CreateDate = DateTime.Now;
model.CreateUserName = userName;
model.CreateDisplayName = displayName;
_menuRepository.CreateRoleMenu(model); //新增关系
}
}
}
catch (Exception)
{
success = false;
}
return(success);
}
/// <summary>
/// 保存权限信息
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public Result Save(RoleMenuModel p)
{
// 先获取该角色所有权限
var query = Restrictions.Eq("Role.ID", p.RoleID);
var list = dal.List(query);
// 原来没有、现在有，则添加该权限
foreach (var i in p.MenuIDs)
{
if (list.Where(o => o.Menu != null && o.Menu.ID == i).Count() == 0)
{
var model = new RoleMenu
{
ID = 0,
Role = new Role {
ID = p.RoleID
},
Menu = new Menu {
ID = i
}
};
dal.Save(model);
}
;
}
// 原来有，现在没有，则删除该权限
foreach (var i in list)
{
if (p.MenuIDs.Where(o => o == i.Menu.ID).Count() == 0)
{
dal.Delete(i.ID);
}
}
return(new Result(200, "保存成功！"));
}
public bool Authorize(RoleMenuModel model)
{
try
{
var isDel = dal.DelRoleMenuButtonByRoleId(model.RoleId);
if (isDel)
{
if (model.MenuButtonIds != null)
{
foreach (var item in model.MenuButtonIds)
{
var roleMenuButton = new RoleMenuButton
{
Id = Guid.NewGuid(),
RoleId = model.RoleId,
ButtonId = item.buttonid,
MenuId = item.menuid
};
var roleMenuButtons = dal.Authorize(roleMenuButton);
if (roleMenuButtons == null)
{
throw new Exception("循环添加出现程序错误,请联系管理员！");
}
}
}
}
else
{
return(false);
}
return(true);
}
catch (Exception)
{
throw new Exception("出现程序错误,请联系管理员！");
}
}
public JsonResult Save(RoleMenuModel p)
{
var result = bll.Save(p);
return(Json(result));
}
public async Task <IActionResult> RoleMenu(RoleMenuModel rpm)
{
var res = await _service.RoleMenu(rpm);
return(Json(res));
}
public RoleMenuModel Update(RoleMenuModel model)
{
return(_mapper.Map <RoleMenuModel>(_roleMenuRepository.Update(_mapper.Map <RoleMenu>(model))));
}
