/// <summary>
/// 安装模块之后，安装菜单
/// </summary>
/// <param name="register"></param>
/// <returns></returns>
public async Task InstallMenuAsync(IXscfRegister register, InstallOrUpdate installOrUpdate)
{
var topMenu = await _sysMenuService.Value.GetObjectAsync(z => z.MenuName == "扩展模块").ConfigureAwait(false);
var currentMenu = await _sysMenuService.Value.GetObjectAsync(z => z.ParentId == topMenu.Id && z.MenuName == register.MenuName).ConfigureAwait(false);
SysMenuDto menuDto;
if (installOrUpdate == InstallOrUpdate.Update && currentMenu != null)
{
//更新菜单
menuDto = _sysMenuService.Value.Mapper.Map <SysMenuDto>(currentMenu);
menuDto.MenuName = register.MenuName; //更新菜单名称
menuDto.Icon = register.Icon; //更新菜单图标
}
else
{
//新建菜单
var icon = register.Icon.IsNullOrEmpty() ? "fa fa-bars" : register.Icon;
var order = register.Uid == SiteConfig.SYSTEM_XSCF_MODULE_UID ? 150 : 20;
menuDto = new SysMenuDto(true, null, register.MenuName, topMenu.Id, $"/Admin/XscfModule/Start/?uid={register.Uid}", icon, order, true, null);
}
var sysMemu = await _sysMenuService.Value.CreateOrUpdateAsync(menuDto).ConfigureAwait(false);
if (installOrUpdate == InstallOrUpdate.Install)
{
//更新菜单信息
var updateMenuDto = new UpdateMenuId_XscfModuleDto(register.Uid, sysMemu.Id);
await base.UpdateMenuId(updateMenuDto).ConfigureAwait(false);
}
}
/// <summary>
/// TODO...重建菜单角色缓存
/// </summary>
/// <param name="sysMenuDto"></param>
/// <param name="buttons"></param>
/// <returns></returns>
public virtual async Task <SysMenu> CreateOrUpdateAsync(SysMenuDto sysMenuDto)
{
SysMenu menu;
ICollection <SysButton> sysButtons = new List <SysButton>();
bool isRepeat;
if (!string.IsNullOrEmpty(sysMenuDto.Id))
{
menu = await GetObjectAsync(_ => _.Id == sysMenuDto.Id);
if (menu.IsLocked)
{
return(menu);//TODO：需要给出提示
}
isRepeat = await _serviceProvider.GetService <SenparcEntitiesBase>().SysMenus.AnyAsync(_ => _.ResourceCode == sysMenuDto.ResourceCode && _.Id != sysMenuDto.Id);
menu.Update(sysMenuDto);
}
else
{
menu = new SysMenu(sysMenuDto);
isRepeat = await _serviceProvider.GetService <SenparcEntitiesBase>().SysMenus.AnyAsync(_ => _.ResourceCode == sysMenuDto.ResourceCode);
}
if (isRepeat && sysMenuDto.MenuType == MenuType.钮)
{
throw new SCFExceptionBase($"ResourceCode：{sysMenuDto.ResourceCode}已重复");
}
menu.ResourceCode = sysMenuDto.MenuType == MenuType.钮 ? menu.ResourceCode : string.Empty;
await SaveObjectAsync(menu);
await GetMenuDtoByCacheAsync(true);
return(menu);
}
/// <summary>
/// 注销
/// </summary>
/// <returns></returns>
//public ResponseBase Logout()
//{
// var rp = new ResponseBase();
// rp.IsLogin = false;
// rp.IsSuccess = false;
// rp.OperationDesc = "退出登录";
// WriteLogInfo("用户:" + GetCurrentUser().UserName + ", 退出系统");
// PerRequestManager.RemoveValue("CurrentUserID");
// return rp;
//}
#endregion
#region 菜单
/// <summary>
/// 创建一个新的菜单
/// </summary>
/// <param name="sysMenuDto"></param>
/// <returns></returns>
public ResponseBase CreateSysMenu(SysMenuDto sysMenuDto)
{
var response = ValidationMenu(sysMenuDto);
if (response.IsSuccess)
{
try
{
using (var transactionScope = new TransactionScope())
{
var sysMenu = new SysMenu();
sysMenu.Inject(sysMenuDto);
var result = SystemRepo.CreateSysMenu(sysMenuDto);
transactionScope.Complete();
response.IsSuccess = true;
}
}
catch (Exception ex)
{
response.IsSuccess = false;
WriteLogException(ex);
}
}
response.OperationDesc = "添加菜单" + (response.IsSuccess ? "成功" : "失败");
return(response);
}
/// <summary>
/// 安装模块之后，安装菜单
/// </summary>
/// <param name="register"></param>
/// <returns></returns>
public async Task InstallMenuAsync(IXncfRegister register, InstallOrUpdate installOrUpdate)
{
var topMenu = await _sysMenuService.Value.GetObjectAsync(z => z.MenuName == "扩展模块").ConfigureAwait(false);
var currentMenu = await _sysMenuService.Value.GetObjectAsync(z => z.ParentId == topMenu.Id && z.MenuName == register.MenuName).ConfigureAwait(false);
SysMenuDto menuDto;
if (installOrUpdate == InstallOrUpdate.Update && currentMenu != null)
{
//更新菜单
menuDto = _sysMenuService.Value.Mapper.Map <SysMenuDto>(currentMenu);
menuDto.MenuName = register.MenuName; //更新菜单名称
menuDto.Icon = register.Icon; //更新菜单图标
}
else
{
//新建菜单
var icon = register.Icon.IsNullOrEmpty() ? "fa fa-bars" : register.Icon;
var order = 20;
switch (register.Uid)
{
case SiteConfig.SYSTEM_XNCF_MODULE_SERVICE_UID:
order = 160;
break;
case SiteConfig.SYSTEM_XNCF_MODULE_AREAS_ADMIN_UID:
order = 150;
break;
default:
break;
}
menuDto = new SysMenuDto(true, null, register.MenuName, topMenu.Id, $"/Admin/XncfModule/Start/?uid={register.Uid}", icon, order, true, null);
}
var sysMemu = await _sysMenuService.Value.CreateOrUpdateAsync(menuDto).ConfigureAwait(false);
if (installOrUpdate == InstallOrUpdate.Install)
{
//更新菜单信息
SysPermissionDto sysPermissionDto = new SysPermissionDto()
{
IsMenu = true,
ResourceCode = sysMemu.ResourceCode,
RoleId = "1",
RoleCode = "administrator",
PermissionId = sysMemu.Id
};
SenparcEntities db = _serviceProvider.GetService <SenparcEntities>();
db.SysPermission.Add(new SysPermission(sysPermissionDto));
await db.SaveChangesAsync();
var updateMenuDto = new UpdateMenuId_XncfModuleDto(register.Uid, sysMemu.Id);
await base.UpdateMenuIdAsync(updateMenuDto).ConfigureAwait(false);
}
}
/// <summary>
/// TODO...重建菜单角色缓存
/// </summary>
/// <param name="sysMenuDto"></param>
/// <param name="buttons"></param>
/// <returns></returns>
public async Task CreateOrUpdateAsync(SysMenuDto sysMenuDto, IEnumerable <SysButtonDto> buttons)
{
SysMenu menu;
ICollection <SysButton> sysButtons = new List <SysButton>();
if (!string.IsNullOrEmpty(sysMenuDto.Id))
{
menu = await GetObjectAsync(_ => _.Id == sysMenuDto.Id);
menu.Update(sysMenuDto);
}
else
{
menu = new SysMenu(sysMenuDto);
}
IEnumerable <string> modifySysButtons = buttons.Where(_ => !string.IsNullOrEmpty(_.Id)).Select(_ => _.Id);
IEnumerable <SysButton> updateBUttons;
if (modifySysButtons.Any())
{
updateBUttons = await _sysButtonService.GetFullListAsync(_ => modifySysButtons.Contains(_.Id));
}
else
{
updateBUttons = new List <SysButton>();
}
foreach (var item in buttons)
{
if (string.IsNullOrEmpty(item.ButtonName))
{
continue;
}
SysButton sysButton;
if (string.IsNullOrEmpty(item.Id))
{
sysButton = new SysButton(item);
sysButton.MenuId = menu.Id;
}
else
{
sysButton = updateBUttons.FirstOrDefault(_ => _.Id == item.Id);
sysButton.Update(item);
}
sysButtons.Add(sysButton);
}
await BeginTransactionAsync(async() =>
{
if (sysButtons.Any())
{
await _sysButtonService.SaveObjectListAsync(sysButtons);
}
await SaveObjectAsync(menu);
});
await GetMenuDtoByCacheAsync(true);
}
public async Task <IActionResult> OnPostAddMenuAsync(SysMenuDto sysMenu)
{
if (string.IsNullOrEmpty(sysMenu.MenuName))
{
return(Ok("菜单名称不能为空", false, "菜单名称不能为空"));
}
var entity = await _sysMenuService.CreateOrUpdateAsync(sysMenu);
return(Ok(entity.Id));
}
/// <summary>
/// 递归添加
/// </summary>
/// <param name="list"></param>
/// <param name="smd"></param>
private void Add(List <SysMenuDto> list, SysMenuDto smd)
{
List <SysMenuDto> nextList = list.Where(w => w.FatherID == smd.ID).ToList();
smd.Children = nextList;
foreach (SysMenuDto item in nextList)
{
Add(list, item);
}
}
/// <summary>
/// 扫描新模块
/// </summary>
/// <returns></returns>
public async Task <IActionResult> OnGetScanAsync(string uid)
{
if (uid.IsNullOrEmpty())
{
throw new Exception("模块不存在！");
}
var xscfRegister = Senparc.Scf.XscfBase.Register.RegisterList.FirstOrDefault(z => z.Uid == z.Uid);
if (xscfRegister == null)
{
throw new Exception("模块不存在！");
}
var xscfModule = await _xscfModuleService.GetObjectAsync(z => z.Uid == z.Uid && z.Version == xscfRegister.Version);
if (xscfModule != null)
{
throw new Exception("相同版本模块已安装，无需重复安装！");
}
XscfModules = await _xscfModuleService.GetObjectListAsync(PageIndex, 10, _ => true, _ => _.AddTime, Scf.Core.Enums.OrderingType.Descending).ConfigureAwait(false);
var dto = XscfModules.Select(z => new CreateOrUpdate_XscfModuleDto(z.Name, z.Uid, z.MenuName, z.Version, z.Description, z.UpdateLog, z.AllowRemove, z.State)).ToList();
//进行模块扫描
var result = await Senparc.Scf.XscfBase.Register.ScanAndInstall(dto, _serviceProvider, async (register, installOrUpdate) =>
{
var sysMenuService = _serviceProvider.GetService <SysMenuService>();
var topMenu = await sysMenuService.GetObjectAsync(z => z.MenuName == "扩展模块").ConfigureAwait(false);
var currentMenu = await sysMenuService.GetObjectAsync(z => z.ParentId == topMenu.Id && z.MenuName == register.MenuName).ConfigureAwait(false); //TODO: menu 还需要加一个锁定Uid的扩展属性
SysMenuDto menuDto;
if (installOrUpdate == InstallOrUpdate.Update && currentMenu != null)
{
//更新菜单
menuDto = sysMenuService.Mapper.Map <SysMenuDto>(currentMenu);
menuDto.MenuName = register.MenuName; //更新菜单名称
}
else
{
//新建菜单
menuDto = new SysMenuDto(true, null, register.MenuName, topMenu.Id, $"/Admin/XscfModule/Start/?uid={register.Uid}", "fa fa-bars", 5, true, null);
}
await sysMenuService.CreateOrUpdateAsync(menuDto).ConfigureAwait(false);
}).ConfigureAwait(false);
base.SetMessager(Scf.Core.Enums.MessageType.info, result, true);
//if (backpage=="Start")
return(RedirectToPage("Start", new { uid = uid }));//始终到详情页
//return RedirectToPage("Index");
}
public async Task <IActionResult> OnPostAsync([FromBody] SysMenuDto sysMenuDto)
{
if (!ModelState.IsValid)
{
return(Ok(false, "模型验证未通过"));
}
await _sysMenuService.CreateOrUpdateAsync(sysMenuDto);
return(Ok(new { sysMenuDto }));
}
public async Task <IActionResult> OnPostAsync(SysMenuDto sysMenuDto, IEnumerable <SysButtonDto> buttons)
{
if (!ModelState.IsValid)
{
return(Ok("模型验证未通过", false, "模型验证未通过"));
}
await _sysMenuService.CreateOrUpdateAsync(sysMenuDto, buttons);
return(Ok(new { buttons, sysMenuDto }));
}
public ApiResult <string> InsertMenu(SysMenuDto sysMenuDto)
{
_logger.Info("開始呼叫MenuService.InsertMenu");
ApiResult <string> apiResult = new ApiResult <string>();
apiResult.State = false;
try
{
apiResult.State = _menuService.InsertMenu(sysMenuDto);
}
catch (Exception ex)
{
apiResult.Message = ex.ToString();
}
return(apiResult);
}
/// <summary>
/// 查询菜单
/// </summary>
/// <param name="parentId">父类Id</param>
/// <param name="pageNumber">显示数量</param>
/// <param name="pageIndex">页面索引（每页下标-1，mysql分页索引从0开始）</param>
/// <returns></returns>
public ResponseBase <List <SysMenuDto> > GetMenus(Guid?parentId, int?pageNumber, int?pageIndex)
{
var response = new ResponseBase <List <SysMenuDto> >();
var list = new List <SysMenuDto>();
var result = SystemRepo.GetMenus(parentId, pageNumber, pageIndex);
foreach (var item in result)
{
var obj = new SysMenuDto();
obj.Inject(item);
list.Add(obj);
}
response.Result = list;
response.IsSuccess = true;
return(response);
}
public async Task <bool> HasPermissionByButtonCodeAsync(string code, string url)
{
if (string.IsNullOrEmpty(code))
{
return(false);
}
IEnumerable <string> roleIds = _adminWorkContextProvider.GetAdminWorkContext().RoleCodes;
string str = await _distributedCache.GetStringAsync(PermissionKey);
IEnumerable <SysPermissionDto> permissions;
if (string.IsNullOrEmpty(str))
{
permissions = await DbToCacheAsync();
}
else
{
permissions = Newtonsoft.Json.JsonConvert.DeserializeObject <IEnumerable <SysPermissionDto> >(str);
}
permissions.Where(_ => roleIds.Contains(_.RoleCode));
if (!permissions.Any())
{
return(false);
}
IEnumerable <SysMenuDto> sysMenus = await _sysMenuService.GetMenuDtoByCacheAsync();
var resourceCodes = from menu in sysMenus
join permission in permissions on menu.Id equals permission.PermissionId
where !string.IsNullOrEmpty(menu.ResourceCode) && !permission.IsMenu
select menu.ResourceCode;
IEnumerable <SysMenuDto> sysMenuDtos = await _sysMenuService.GetMenuDtoByCacheAsync();
SysMenuDto sysMenuDto = sysMenuDtos.FirstOrDefault(_ => _.Url?.ToLower() == url.ToLower() && _.IsMenu);
if (sysMenuDto == null)
{
return(false);
}
bool isInUrl = sysMenuDtos.Any(_ => _.ParentId == sysMenuDto.Id && !_.IsMenu);
bool has = resourceCodes.Any(_ => _ == code);
return(has && isInUrl);
}
private void QueryLevelMenus(List <SysMenu> sysMenus, SysMenuDto menuDto)
{
var order = 1;
List <SysMenuDto> menuDtos = sysMenus.Where(f => f.ParentId == menuDto.Key).OrderBy(f => f.ShowOrder).Select(f =>
{
var m = new SysMenuDto()
{
Group = true, Key = f.Id, Order = order++
};
m.CopyFrom(f);
return(m);
}).ToList();
menuDtos.ForEach(f =>
{
QueryLevelMenus(sysMenus, f);
});
menuDto.Children = menuDtos;
}
public async Task SaveMenu(SysMenuDto menuDto)
{
if (menuDto.ID < 1)
{
if (await _menuRepository.ExistAsync(x => x.Code == menuDto.Code))
{
throw new BusinessException((int)ErrorCode.Forbidden, "同名菜单已存在");
}
menuDto.Status = true;
}
if (string.IsNullOrWhiteSpace(menuDto.PCode) || string.Equals(menuDto.PCode, "0"))
{
menuDto.PCode = "0";
menuDto.PCodes = "[0],";
menuDto.Levels = 1;
}
else
{
var parentMenu = await _menuRepository.FetchAsync(x => x.Code == menuDto.PCode);
menuDto.PCode = parentMenu.Code;
if (string.Equals(menuDto.Code, menuDto.PCode))
{
throw new BusinessException((int)ErrorCode.Forbidden, "菜单编码冲突");
}
menuDto.Levels = parentMenu.Levels + 1;
menuDto.PCodes = $"{parentMenu.PCodes}[{parentMenu.Code}]";
}
var menu = _mapper.Map <SysMenu>(menuDto);
if (menu.ID == 0)
{
await _menuRepository.InsertAsync(menu);
}
else
{
await _menuRepository.UpdateAsync(menu);
}
}
/// <summary>
/// 组装菜单层级数据
/// </summary>
/// <param name="sysMenus"></param>
private List <SysMenuDto> QueryLevelMenus(List <SysMenu> sysMenus)
{
List <SysMenuDto> menuDtos = sysMenus.Where(f => f.ParentId == 0).Select(f =>
{
var m = new SysMenuDto()
{
Group = true, Key = f.Id
};
m.CopyFrom(f);
return(m);
}
).OrderBy(f => f.ShowOrder).ToList();
menuDtos.ForEach(f =>
{
QueryLevelMenus(sysMenus, f);
});
return(menuDtos);
}
/// <summary>
/// TODO...重建菜单角色缓存
/// </summary>
/// <param name="sysMenuDto"></param>
/// <param name="buttons"></param>
/// <returns></returns>
public async Task <SysMenu> CreateOrUpdateAsync(SysMenuDto sysMenuDto)
{
SysMenu menu;
ICollection <SysButton> sysButtons = new List <SysButton>();
if (!string.IsNullOrEmpty(sysMenuDto.Id))
{
menu = await GetObjectAsync(_ => _.Id == sysMenuDto.Id);
menu.Update(sysMenuDto);
}
else
{
menu = new SysMenu(sysMenuDto);
}
await SaveObjectAsync(menu);
await GetMenuDtoByCacheAsync(true);
return(menu);
}
private ResponseBase ValidationMenu(SysMenuDto model)
{
var response = new ResponseBase();
response.IsSuccess = false;
if (string.IsNullOrEmpty(model.MenuName))
{
response.OperationDesc = "菜单名不能为空";
}
if (SystemRepo.IsExisMenu(model))
{
response.OperationDesc = "菜单名已存在";
}
else
{
response.IsSuccess = true;
}
return(response);
}
public async Task OnGetAsync()
{
if (!string.IsNullOrEmpty(Id))
{
var entity = await _sysMenuService.GetObjectAsync(_ => _.Id == Id);
SysButtons = await _sysButtonService.GetFullListAsync(_ => _.MenuId == Id);
SysMenuDto = _sysMenuService.Mapper.Map <SysMenuDto>(entity);
}
else
{
SysMenuDto = new SysMenuDto()
{
Visible = true
};
SysButtons = new List <SysButton>()
{
new SysButton()
};
}
}
public List <SysMenuDto> GetSysMenusByParent(Guid parentId)
{
List <SysMenuDto> result = new List <SysMenuDto>();
var menus = _menuRepository.GetAllList(it => it.ParentId == parentId).OrderBy(it => it.SerialNumber);
foreach (var menu in menus)
{
SysMenuDto sysMenu = new SysMenuDto
{
Id = menu.Id,
ParentId = menu.ParentId,
SerialNumber = menu.SerialNumber,
Text = menu.Text,
Code = menu.Code,
Url = menu.Url,
Type = menu.Type,
Icon = menu.Icon,
Remarks = menu.Remarks,
Children = GetSysMenusByParent(menu.Id)
};
result.Add(sysMenu);
}
return(result);
}
/// <summary>
/// 编辑菜单
/// </summary>
/// <param name="model">菜单信息</param>
/// <returns>是否成功</returns>
public ResponseBase EditSysMenu(SysMenuDto model)
{
ResponseBase response = new ResponseBase();
try
{
var result = SystemRepo.EditSysMenu(model);
if (result > 0)
{
response.IsSuccess = true;
}
else
{
response.IsSuccess = false;
}
}
catch (Exception ex)
{
response.IsSuccess = false;
WriteLogException(ex);
}
response.OperationDesc = "编辑菜单" + (response.IsSuccess ? "成功" : "失败");
return(response);
}
public Task <ApiResult <long> > UpdateAsync(SysMenuDto model)
{
throw new NotImplementedException();
}
/// <summary>
/// 添加/修改 一个菜单
/// </summary>
/// <param name="menuDto"></param>
/// <returns></returns>
public IActionResult AddOrEditMenu(SysMenuDto menuDto)
{
bool bResult = false;
int menuCount = _sysMenuBLL.GetCount(t => t.MenuId.Equals(menuDto.MenuId));
var user = _userAccount.GetUserInfo();
//添加
if (menuCount == 0)
{
var AuthorityId = Guid.NewGuid();
using (var tran = _zhouLiContext.Database.BeginTransaction())
{
int i = 0;
//添加权限
bResult = _sysAuthorityBLL.Add(new SysAuthority
{
AuthorityType = (int)AuthorityType.Type_Menu,
AuthorityId = AuthorityId.ToString(),
CreateUserId = user.UserId,
CreateTime = DateTime.Now
});
if (bResult)
{
i++;
}
bResult = _sysAmRelatedBLL.Add(new SysAmRelated
{
AuthorityId = AuthorityId.ToString(),
MenuId = menuDto.MenuId.ToString(),
});
if (bResult)
{
i++;
}
var menu = AutoMapper.Mapper.Map <SysMenu>(menuDto);
menu.CreateTime = DateTime.Now;
menu.CreateUserId = user.UserId;
bResult = _sysMenuBLL.Add(menu);
if (bResult)
{
i++;
}
if (i == 3)
{
tran.Commit();
}
else
{
tran.Rollback();
bResult = false;
}
}
}
else
{
var menu = _sysMenuBLL.GetModels(t => t.MenuId.Equals(menuDto.MenuId)).SingleOrDefault();
menu.MenuName = menuDto.MenuName;
menu.MenuIcon = menuDto.MenuIcon;
menu.MenuSort = menuDto.MenuSort;
menu.Note = menuDto.Note;
menu.MenuUrl = menuDto.MenuUrl;
menu.ParentMenuId = menuDto.ParentMenuId.ToString();
menu.EditTime = DateTime.Now;
bResult = _sysMenuBLL.Update(menu);
}
return(Ok(new ResponseModel
{
RetCode = bResult ? StatesCode.success : StatesCode.failure,
RetMsg = bResult ? "操作成功" : "操作失败"
}));
}
public async Task SaveMenu(SysMenuDto menuDto)
{
await _menuService.SaveMenu(menuDto);
}
/// <summary>
/// 添加/修改 一个菜单
/// </summary>
/// <param name="menuDto"></param>
/// <returns></returns>
public string AddOrEditMenu(SysMenuDto menuDto)
{
bool bResult = false;
int menuCount = injection.GetT <ISysMenuBLL>().GetCount(t => t.MenuId.Equals(menuDto.MenuId));
//添加
if (menuCount == 0)
{
var AuthorityId = Guid.NewGuid().ToString();
using (var tran = injection.GetT <MyEFContext>().Database.BeginTransaction())
{
int i = 0;
//添加权限
bResult = injection.GetT <ISysAuthorityBLL>().Add(new SysAuthority
{
AuthorityType = (int)SysEnum.Enum_AuthorityType.Type_Menu,
AuthorityId = AuthorityId
});
if (bResult)
{
i++;
}
bResult = injection.GetT <ISysAmRelatedBLL>().Add(new SysAmRelated
{
AmRelatedId = Guid.NewGuid().ToString(),
AuthorityId = AuthorityId,
MenuId = menuDto.MenuId
});
if (bResult)
{
i++;
}
menuDto.CreateTime = DateTime.Now;
bResult = injection.GetT <ISysMenuBLL>().Add(AutoMapper.Mapper.Map <SysMenu>(menuDto));
if (bResult)
{
i++;
}
if (i == 3)
{
tran.Commit();
}
else
{
tran.Rollback();
bResult = false;
}
}
}
else
{
var menu = injection.GetT <ISysMenuBLL>().GetModels(t => t.MenuId.Equals(menuDto.MenuId)).SingleOrDefault();
menu.MenuName = menuDto.MenuName;
menu.MenuIcon = menuDto.MenuIcon;
menu.MenuSort = menuDto.MenuSort;
menu.MenuType = menuDto.MenuType;
menu.Note = menuDto.Note;
menu.MenuUrl = menuDto.MenuUrl;
menu.ParentMenuId = menuDto.ParentMenuId;
bResult = injection.GetT <ISysMenuBLL>().Update(menu);
}
return(JsonHelper.ObjectToJson(new ResponseModel
{
StateCode = bResult ? StatesCode.success : StatesCode.failure,
Messages = bResult ? "添加成功" : "添加失败"
}));
}
/// <summary>
/// 递归
/// </summary>
/// <param name="menu"></param>
/// <returns></returns>
private MenuInfo Builder(SysMenuDto menu)
{
//如果是顶级菜单,并且没有子集,需要单独构造,把当前菜单写在 Children 里面
if (menu.FatherID == 0 && (menu.Children == null || menu.Children.Count == 0))
{
return(new MenuInfo
{
Path = GetRoutePath(menu.Url),
Component = "Layout",
Redirect = string.Empty,
Children = new List <MenuInfo>
{
new MenuInfo
{
Path = PinyinHelper.GetFirstPinyin(menu.Name),
Name = menu.Name,
Component = menu.Url,
Meta = new Meta
{
Icon = menu.Icon,
Title = menu.Name,
MenuID = menu.ID,
},
}
}
});
}
MenuInfo result = new MenuInfo
{
Component = menu.Url,
Name = menu.Name,
Redirect = string.Empty,
Meta = new Meta
{
Icon = menu.Icon,
Title = menu.Name,
MenuID = menu.ID,
},
Path = menu.Path
};
List <MenuInfo> childrenList = new List <MenuInfo>();
if (menu.Children.CheckNotEmpty() == true)
{
foreach (SysMenuDto menuChild in menu.Children)
{
childrenList.Add(Builder(menuChild));
}
}
result.Children = childrenList;
//if (result.Children.Count == 0)
//{
// result.Path = PinyinHelper.GetFirstPinyin(result.Name);
//}
//else
//{
// result.Component = "Layout";
// result.Path = GetRoutePath(menu.Url);
//}
if (result.Children.Count > 0)
{
result.Component = "Layout";
result.Path = GetRoutePath(menu.Url);
}
return(result);
}
