public IActionResult Query(string id)
{
var roles = new RoleMenuDto();
if (id.IsEmpty())
{
return(View(roles));
}
else
{
var role = _roleServices.QueryableToEntity(c => c.RoleId == SqlFunc.ToInt64(id));
var list = _rolemenuServices.QueryableToList(c => c.RoleId == SqlFunc.ToInt64(id));
roles = new RoleMenuDto()
{
RoleId = role?.RoleId.ToString(),
RoleName = role?.RoleName,
RoleType = role?.RoleType,
Remark = role?.Remark,
Children = list.Select(x => new RoleMenuItemDto()
{
MenuId = x.MenuId.ToString(),
RoleId = x.RoleId.ToString(),
WarehouseId = x.WarehouseId.ToString()
}).ToList()
};
return(View(roles));
}
}
public async Task AddRoleMenuAsync(RoleMenuDto dto)
{
try
{
var existMenus = _roleMenuDbSet.Where(c => c.RoleId == dto.RoleId);
_roleMenuDbSet.RemoveRange(existMenus);
foreach (var item in dto.MenuIds)
{
if (!existMenus.Any(c => c.RoleId == dto.RoleId && c.MenuId == item))
{
var roleMenu = new RoleMenuItem
{
RoleId = dto.RoleId,
MenuId = item,
};
await _roleMenuDbSet.AddAsync(roleMenu);
}
}
}
catch (Exception ex)
{
throw;
}
}
public async Task <Role_Menu> AddAsync(RoleMenuDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
var role = await db.Role_Menus.Where(x => x.MenuId == dto.MenuId && x.RolesId == dto.RoleId && x.IsDeleted == false).FirstOrDefaultAsync(token);
if (role != null)
{
role.LastOperationTime = dto.OperationTime;
role.LastOperationUserId = dto.OperationUserId;
await db.SaveChangesAsync(token);
return(role);
}
role = new Role_Menu
{
MenuId = dto.MenuId,
RolesId = dto.RoleId,
CreateOperationTime = dto.OperationTime,
CreateOperationUserId = dto.OperationUserId,
IsDeleted = false
};
db.Role_Menus.Add(role);
await db.SaveChangesAsync(token);
return(role);
}
}
public async Task <RoleMenuDto> AddRoleMenuAsync(RoleMenuDto model)
{
try
{
var existingMenu = await _roleMenuRepository.ExistsAsync(x => x.RoleId == model.RoleId && x.MenuId == model.MenuId);
if (!existingMenu)
{
var dbEntity = model.ToEntity <RoleMenu>(_mapper);
await _roleMenuRepository.InsertAsync(dbEntity);
await _unitOfWork.SaveChangesAsync();
model.RoleMenuId = dbEntity.RoleMenuId;
}
else
{
throw new ApplicationException("RoleMenu already exist.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
throw ex;
}
return(model);
}
/// <summary>
/// 转换为角色菜单实体
/// </summary>
/// <param name="dto">角色菜单数据传输对象</param>
public static RoleMenu ToEntity(this RoleMenuDto dto)
{
if (dto == null)
{
return(new RoleMenu());
}
return(dto.MapTo(new RoleMenu(dto.Id.ToGuid())));
}
public IHttpActionResult SetMenus([FromBody] RoleMenuDto menuDto, [UserId] int userId)
{
bool bl = _roleService.SetMenus(menuDto.RoleID, userId, menuDto.MenuList);
if (bl)
{
return(Ok());
}
return(InternalServerError());
}
private void BuildMeunsRecursiveTree(List <RoleMenuDto> list, RoleMenuDto currentTree)
{
list.ForEach(item =>
{
if (item.ParentId == currentTree.Id)
{
currentTree.Children.Add(item);
}
});
}
public async Task <ActionResult> PatchRoleMenu([FromBody] RoleMenuDto model)
{
if (model == null)
{
return(BadRequest());
}
await _roleManagementService.UpdateRoleMenuAsync(model);
return(NoContent());
}
/// <summary>
/// 编辑rolemenu
/// </summary>
/// <param name="dto">实体</param>
/// <returns></returns>
public bool Update(RoleMenuDto dto)
{
using (var scope = _dbScopeFactory.Create())
{
var db = GetDb(scope);
var dbSet = GetDbSet(db);
var entity = Mapper.Map <RoleMenuDto, RoleMenuEntity>(dto);
dbSet.AddOrUpdate(entity);
return(db.SaveChanges() > 0);
}
}
public async Task <IActionResult> Item(Guid?id)
{
var menu = MenuConfigSingle.CreatInstance().GetMenu();
var roleMenuDto = new RoleMenuDto();
if (id.HasValue)
{
roleMenuDto = await _roleAppService.Get(id.Value);
}
ViewBag.Menu = menu;
return(View(roleMenuDto));
}
//private readonly IDbContextScopeFactory _dbScopeFactory;
//public RoleMenuService(IDbContextScopeFactory dbScopeFactory)
//{
// _dbScopeFactory = dbScopeFactory;
//}
#endregion
#region IRoleMenuService 接口实现
/// <summary>
/// 添加rolemenu
/// </summary>
/// <param name="dto">rolemenu实体</param>
/// <returns></returns>
public string Add(RoleMenuDto dto)
{
using (var scope = _dbScopeFactory.Create())
{
var db = GetDb(scope);
var dbSet = GetDbSet(db);
var entity = Mapper.Map <RoleMenuDto, RoleMenuEntity>(dto);
entity.Create();
dbSet.Add(entity);
scope.SaveChanges();
return(entity.Id);
}
}
//private readonly IDbContextScopeFactory _dbScopeFactory;
//public RoleMenuService(IDbContextScopeFactory dbScopeFactory)
//{
// _dbScopeFactory = dbScopeFactory;
//}
#endregion
#region IRoleMenuService 接口实现
/// <summary>
/// 添加rolemenu
/// </summary>
/// <param name="dto">rolemenu实体</param>
/// <returns></returns>
public bool Add(RoleMenuDto dto)
{
using (var scope = _dbScopeFactory.Create())
{
var db = GetDb(scope);
var dbSet = GetDbSet(db);
//var entity = Mapper.Map<RoleMenuDto, RoleMenuEntity>(dto);
var entity = dto.MapTo <RoleMenuEntity>();
dbSet.Add(entity);
var count = db.SaveChanges();
return(count > 0);
}
}
/// <summary>
/// 转换为角色菜单实体
/// </summary>
/// <param name="dto">角色菜单数据传输对象</param>
public static RoleMenu ToEntity2(this RoleMenuDto dto)
{
if (dto == null)
{
return(new RoleMenu());
}
return(new RoleMenu(dto.Id.ToGuid())
{
MenuId = dto.MenuId,
RoleId = dto.RoleId,
Half = dto.Half,
Version = dto.Version,
});
}
/// <summary>
/// 转换为角色菜单实体
/// </summary>
/// <param name="dto">角色菜单数据传输对象</param>
public static RoleMenu ToEntity3(this RoleMenuDto dto)
{
if (dto == null)
{
return(new RoleMenu());
}
return(RoleMenuFactory.Create(
roleMenuId: dto.Id.ToGuid(),
menuId: dto.MenuId,
roleId: dto.RoleId,
half: dto.Half,
version: dto.Version
));
}
//根据角色获取功能
public List <RoleMenuDto> GetMenusByRole(int roleID)
{
List <RoleMenuDto> roleMenuDtos = new List <RoleMenuDto>();
var roleMenus = _roleMenuRepository.GetMenusByRole(roleID);
foreach (var roleMenu in roleMenus)
{
RoleMenuDto roleMenuDto = new RoleMenuDto();
roleMenuDto.RoleID = roleMenu.RoleID;
roleMenuDto.MenuID = roleMenu.MenuID;
roleMenuDtos.Add(roleMenuDto);
}
return(roleMenuDtos);
}
public async Task <ActionResult> PostMenu([FromBody] RoleMenuDto model)
{
if (model == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _roleManagementService.AddRoleMenuAsync(model);
return(this.Ok(result));
}
private static RoleMenuDto ConvertFromBllEntity(RoleMenu menu)
{
if (menu == null)
{
return(null);
}
var accountDto = new RoleMenuDto()
{
Menu_id = menu.Menu_id.Value,
Menu_pid = menu.Menu_pid.Value,
RoleID = menu.RoleID
};
return(accountDto);
}
private static RoleMenu ConvertFromDto(RoleMenuDto menuDto)
{
if (menuDto == null)
{
return(null);
}
var user = new RoleMenu()
{
Menu_id = menuDto.Menu_id,
Menu_pid = menuDto.Menu_pid,
RoleID = menuDto.RoleID
};
return(user);
}
public async Task DeleteRoleMenuAsync(RoleMenuDto model)
{
try
{
var dbEntity = await _roleMenuRepository.FindAsync(model.RoleMenuId);
_roleMenuRepository.Delete(dbEntity);
await _unitOfWork.SaveChangesAsync();
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
throw ex;
}
}
private static RoleMenu ConvertFromDto(RoleMenuDto roleMenuDto)
{
if (roleMenuDto == null)
{
return(null);
}
var roleMenu = new RoleMenu
{
HotelID = roleMenuDto.HotelID,
RoleID = roleMenuDto.RoleID,
Menu_id = roleMenuDto.Menu_id,
Menu_pid = roleMenuDto.Menu_pid
};
return(roleMenu);
}
private static RoleMenuDto ConvertFromRepositoryEntity(RoleMenu roleMenu)
{
if (roleMenu == null)
{
return(null);
}
var roleMenuDto = new RoleMenuDto
{
HotelID = roleMenu.HotelID,
RoleID = roleMenu.RoleID,
Menu_id = roleMenu.Menu_id.Value,
Menu_pid = roleMenu.Menu_pid.Value
};
return(roleMenuDto);
}
public async Task DeleteAsync(RoleMenuDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
var roleMenu = await db.Role_Menus.Where(x => x.MenuId == dto.MenuId && x.RolesId == dto.RoleId && x.IsDeleted == false).FirstOrDefaultAsync(token);
if (roleMenu == null)
{
throw new NotImplementedException("该菜单权限信息不存在！");
}
roleMenu.LastOperationTime = dto.OperationTime;
roleMenu.LastOperationUserId = dto.OperationUserId;
roleMenu.DeletedTime = dto.OperationTime;
roleMenu.IsDeleted = true;
await db.SaveChangesAsync(token);
}
}
public IActionResult GetMenuTreeData(Guid id)
{
var menus = _menuAppService.GetAllList();
var roleMenus = _service.GetRoleMenus(id);
List <TreeCheckBoxModel> treeModels = new List <TreeCheckBoxModel>();
menus.ForEach((menu) =>
{
RoleMenuDto tempt = roleMenus.Find((roleMenu) => menu.Id == roleMenu.MenuId);
treeModels.Add(new TreeCheckBoxModel()
{
Id = menu.Id.ToString(), Text = menu.Name, Parent = menu.ParentId == Guid.Empty ? "#" : menu.ParentId.ToString(), Checked = tempt != null?"1":"0"
});
});
return(Ok(treeModels));
}
/// <summary>
/// 角色授权
/// </summary>
public async Task <bool> SaveRoleMenu(RoleMenuDto input)
{
await _dbContext.Deleteable <Permissions>()
.Where(m => m.RoleId == input.RoleId && m.Types == input.Types)
.ExecuteCommandAsync();
var list = new List <Permissions>();
foreach (var item in input.MenuIds)
{
list.Add(new Permissions
{
RoleId = input.RoleId,
MenuId = item,
Types = input.Types,
CreateTime = DateTime.Now
});
}
await _dbContext.Insertable(list).ExecuteCommandAsync();
return(true);
}
public Task UpdateAsync(RoleMenuDto dto, CancellationToken token = default)
{
throw new NotImplementedException();
}
public async Task <ObjectResult> SaveRoleMenuAsync([FromBody] RoleMenuDto input)
{
var result = await _perBusiness.SaveRoleMenu(input);
return(Ok(result));
}
public async Task <ActionResult> DeleteRoleMenu([FromBody] RoleMenuDto model)
{
await _roleManagementService.DeleteRoleMenuAsync(model);
return(NoContent());
}
public Task <List <Role_Menu> > GetListAsync(RoleMenuDto dto, CancellationToken token = default)
{
throw new NotImplementedException();
}
public async Task <ApiRequestResult> AddRoleMenuAsync(RoleMenuDto dto)
{
await _roleRepository.AddRoleMenuAsync(dto);
return(ApiRequestResult.Success("权限设置成功"));
}
