AGSSbackend/AGSS/Services/MenuService.cs

327 lines
9.6 KiB
C#
Raw Normal View History

2025-07-14 15:10:13 +08:00
using AGSS.DbSet;
using AGSS.Models.DTOs;
using AGSS.Models.Entities;
using AGSS.Models.Template;
using Microsoft.EntityFrameworkCore;
namespace AGSS.Services;
public class MenuService
{
private readonly ApplicationDbContext _context;
public MenuService(ApplicationDbContext context)
{
_context = context;
}
/// <summary>
/// 新增父级菜单
/// </summary>
public async Task<ReturnTemplate> CreateParentMenu(MenuRequest request)
{
try
{
var menu = new MenuModel
{
Uuid = Guid.NewGuid().ToString(),
ParentId = null,
Path = request.Path,
Label = request.Label,
Icon = request.Icon,
MenuCode = request.MenuCode,
Adaptability = request.Adaptability,
Component = request.Component,
Sort = request.Sort,
Status = request.Status,
Query = request.Query,
CreateTime = DateTime.Now
};
_context.Menus.Add(menu);
await _context.SaveChangesAsync();
return new ReturnTemplate(200, "父级菜单创建成功", menu);
}
catch (Exception ex)
{
return new ReturnTemplate(500, $"创建父级菜单失败: {ex.Message}", null);
}
}
/// <summary>
/// 编辑父级菜单
/// </summary>
public async Task<ReturnTemplate> UpdateParentMenu(MenuRequest request)
{
try
{
if (string.IsNullOrEmpty(request.Uuid))
{
return new ReturnTemplate(400, "UUID不能为空", null);
}
var menu = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == request.Uuid);
if (menu == null)
{
return new ReturnTemplate(404, "菜单不存在", null);
}
// 确保是父级菜单
if (!string.IsNullOrEmpty(menu.ParentId))
{
return new ReturnTemplate(400, "只能编辑父级菜单", null);
}
menu.Path = request.Path;
menu.Label = request.Label;
menu.Icon = request.Icon;
menu.MenuCode = request.MenuCode;
menu.Adaptability = request.Adaptability;
menu.Component = request.Component;
menu.Sort = request.Sort;
menu.Status = request.Status;
menu.Query = request.Query;
menu.UpdateTime = DateTime.Now;
await _context.SaveChangesAsync();
return new ReturnTemplate(200, "父级菜单更新成功", menu);
}
catch (Exception ex)
{
return new ReturnTemplate(500, $"更新父级菜单失败: {ex.Message}", null);
}
}
/// <summary>
/// 新增子级菜单
/// </summary>
public async Task<ReturnTemplate> CreateChildMenu(MenuRequest request)
{
try
{
if (string.IsNullOrEmpty(request.ParentId))
{
return new ReturnTemplate(400, "父级ID不能为空", null);
}
// 验证父级菜单是否存在
var parentMenu = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == request.ParentId);
if (parentMenu == null)
{
return new ReturnTemplate(404, "父级菜单不存在", null);
}
var menu = new MenuModel
{
Uuid = Guid.NewGuid().ToString(),
ParentId = request.ParentId,
Path = request.Path,
Label = request.Label,
Icon = request.Icon,
MenuCode = request.MenuCode,
Adaptability = request.Adaptability,
Component = request.Component,
Sort = request.Sort,
Status = request.Status,
Query = request.Query,
CreateTime = DateTime.Now
};
_context.Menus.Add(menu);
await _context.SaveChangesAsync();
return new ReturnTemplate(200, "子级菜单创建成功", menu);
}
catch (Exception ex)
{
return new ReturnTemplate(500, $"创建子级菜单失败: {ex.Message}", null);
}
}
/// <summary>
/// 编辑子级菜单
/// </summary>
public async Task<ReturnTemplate> UpdateChildMenu(MenuRequest request)
{
try
{
if (string.IsNullOrEmpty(request.Uuid))
{
return new ReturnTemplate(400, "UUID不能为空", null);
}
var menu = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == request.Uuid);
if (menu == null)
{
return new ReturnTemplate(404, "菜单不存在", null);
}
// 确保是子级菜单
if (string.IsNullOrEmpty(menu.ParentId))
{
return new ReturnTemplate(400, "只能编辑子级菜单", null);
}
menu.Path = request.Path;
menu.Label = request.Label;
menu.Icon = request.Icon;
menu.MenuCode = request.MenuCode;
menu.Adaptability = request.Adaptability;
menu.Component = request.Component;
menu.Sort = request.Sort;
menu.Status = request.Status;
menu.Query = request.Query;
menu.UpdateTime = DateTime.Now;
await _context.SaveChangesAsync();
return new ReturnTemplate(200, "子级菜单更新成功", menu);
}
catch (Exception ex)
{
return new ReturnTemplate(500, $"更新子级菜单失败: {ex.Message}", null);
}
}
/// <summary>
/// 查询菜单全量返回(树形结构)
/// </summary>
public async Task<ReturnTemplate> GetAllMenus()
{
try
{
var allMenus = await _context.Menus
.OrderBy(m => m.Sort)
.ToListAsync();
var menuTree = BuildMenuTree(allMenus);
return new ReturnTemplate(200, "成功", menuTree);
}
catch (Exception ex)
{
return new ReturnTemplate(500, $"查询菜单失败: {ex.Message}", null);
}
}
/// <summary>
/// 删除菜单(递归删除)
/// </summary>
public async Task<ReturnTemplate> DeleteMenu(string uuid)
{
try
{
if (string.IsNullOrEmpty(uuid))
{
return new ReturnTemplate(400, "UUID不能为空", null);
}
var menuToDelete = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == uuid);
if (menuToDelete == null)
{
return new ReturnTemplate(404, "菜单不存在", null);
}
// 递归删除所有子菜单
await DeleteMenuRecursive(uuid);
return new ReturnTemplate(200, "菜单删除成功", null);
}
catch (Exception ex)
{
return new ReturnTemplate(500, $"删除菜单失败: {ex.Message}", null);
}
}
/// <summary>
/// 递归删除菜单及其子菜单
/// </summary>
private async Task DeleteMenuRecursive(string parentUuid)
{
var children = await _context.Menus.Where(m => m.ParentId == parentUuid).ToListAsync();
foreach (var child in children)
{
await DeleteMenuRecursive(child.Uuid);
}
var menu = await _context.Menus.FirstOrDefaultAsync(m => m.Uuid == parentUuid);
if (menu != null)
{
_context.Menus.Remove(menu);
}
}
/// <summary>
/// 构建菜单树形结构
/// </summary>
private List<MenuResponse> BuildMenuTree(List<MenuModel> allMenus)
{
var menuDict = allMenus.ToDictionary(m => m.Uuid);
var rootMenus = new List<MenuResponse>();
foreach (var menu in allMenus)
{
var menuResponse = new MenuResponse
{
Uuid = menu.Uuid,
ParentId = menu.ParentId,
Path = menu.Path,
Label = menu.Label,
Icon = menu.Icon,
MenuCode = menu.MenuCode,
Adaptability = menu.Adaptability,
Component = menu.Component,
Sort = menu.Sort,
Status = menu.Status,
Query = menu.Query,
CreateTime = menu.CreateTime,
UpdateTime = menu.UpdateTime
};
if (string.IsNullOrEmpty(menu.ParentId))
{
// 根菜单
rootMenus.Add(menuResponse);
}
else
{
// 子菜单
if (menuDict.TryGetValue(menu.ParentId, out var parentMenu))
{
var parentResponse = FindMenuResponse(rootMenus, menu.ParentId);
if (parentResponse != null)
{
parentResponse.Children.Add(menuResponse);
}
}
}
}
return rootMenus;
}
/// <summary>
/// 在菜单树中查找指定UUID的菜单响应对象
/// </summary>
private MenuResponse? FindMenuResponse(List<MenuResponse> menus, string uuid)
{
foreach (var menu in menus)
{
if (menu.Uuid == uuid)
{
return menu;
}
var found = FindMenuResponse(menu.Children, uuid);
if (found != null)
{
return found;
}
}
return null;
}
}