xiaowei/DMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor:完成变量表的重构添加，删除，更新

Browse Source
This commit is contained in:
David P.G
2025-10-23 16:25:22 +08:00
parent 54d040b45f
commit 125348486a
15 changed files with 329 additions and 419 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
DMS.Application/DTOs/CreateVariableTableWithMenuDto.cs
View File

@@ -6,7 +6,6 @@ namespace DMS.Application.DTOs
public class CreateVariableTableWithMenuDto
{
public VariableTable VariableTable { get; set; }
public int DeviceId { get; set; }
public MenuBean Menu { get; set; }
}
}

6
DMS.Application/Interfaces/Database/IVariableTableAppService.cs
View File

@@ -8,8 +8,8 @@ namespace DMS.Application.Interfaces.Database
{
Task<VariableTable> GetVariableTableByIdAsync(int id);
Task<List<VariableTable>> GetAllVariableTablesAsync();
Task<CreateVariableTableWithMenuDto> CreateVariableTableAsync(CreateVariableTableWithMenuDto createDto);
Task<int> UpdateVariableTableAsync(VariableTable variableTableDto);
Task<bool> DeleteVariableTableAsync(int id);
Task<CreateVariableTableWithMenuDto> AddAsync(CreateVariableTableWithMenuDto createDto);
Task<int> UpdateAsync(VariableTable variableTableDto);
Task<bool> DeleteAsync(VariableTable variableTable);
}
}

6
DMS.Application/Interfaces/Management/IVariableTableManagementService.cs
View File

@@ -19,17 +19,17 @@ public interface IVariableTableManagementService
/// <summary>
/// 异步创建一个新变量表及其关联菜单（事务性操作）。
/// </summary>
Task<CreateVariableTableWithMenuDto> CreateVariableTableAsync(CreateVariableTableWithMenuDto dto);
Task<CreateVariableTableWithMenuDto> AddAsync(CreateVariableTableWithMenuDto dto);
/// <summary>
/// 异步更新一个已存在的变量表。
/// </summary>
Task<int> UpdateVariableTableAsync(VariableTable variableTableDto);
Task<int> UpdateAsync(VariableTable variableTableDto);
/// <summary>
/// 异步删除一个变量表。
/// </summary>
Task<bool> DeleteVariableTableAsync(int id);
Task<bool> DeleteAsync(VariableTable variableTable);
/// <summary>
/// 异步加载所有变量表数据到内存中。

94
DMS.Application/Services/Database/VariableTableAppService.cs
View File

@@ -15,6 +15,7 @@ namespace DMS.Application.Services.Database
public class VariableTableAppService : IVariableTableAppService
{
private readonly IRepositoryManager _repositoryManager;
private readonly IAppDataService _appDataService;
private readonly IMapper _mapper;
/// <summary>
@@ -22,9 +23,10 @@ namespace DMS.Application.Services.Database
/// </summary>
/// <param name="repositoryManager">仓储管理器实例。</param>
/// <param name="mapper">AutoMapper 实例。</param>
public VariableTableAppService(IRepositoryManager repositoryManager, IMapper mapper)
public VariableTableAppService(IRepositoryManager repositoryManager, IAppDataService appDataService, IMapper mapper)
{
_repositoryManager = repositoryManager;
_appDataService = appDataService;
_mapper = mapper;
}
@@ -55,43 +57,24 @@ namespace DMS.Application.Services.Database
/// <param name="createDto">包含变量表和菜单信息的创建数据传输对象。</param>
/// <returns>创建后的变量表数据传输对象。</returns>
/// <exception cref="ApplicationException">如果添加变量表失败或找不到设备菜单。</exception>
public async Task<CreateVariableTableWithMenuDto> CreateVariableTableAsync(CreateVariableTableWithMenuDto createDto)
public async Task<CreateVariableTableWithMenuDto> AddAsync(CreateVariableTableWithMenuDto createDto)
{
await _repositoryManager.BeginTranAsync();
try
{
var variableTable = _mapper.Map<VariableTable>(createDto.VariableTable);
variableTable.DeviceId = createDto.DeviceId;
var createdVariableTable = await _repositoryManager.VariableTables.AddAsync(variableTable);
if (createdVariableTable.Id == 0)
createDto.VariableTable = await _repositoryManager.VariableTables.AddAsync(createDto.VariableTable);
if (createDto.VariableTable.Id == 0)
{
throw new ApplicationException($"添加变量表失败，设备ID:{createDto.DeviceId},请检查。");
throw new ApplicationException($"添加变量表失败，设备ID:{createDto.VariableTable.DeviceId},请检查。");
}
_mapper.Map(createdVariableTable, createDto.VariableTable);
if (createDto.Menu!=null)
if (createDto.Menu is not null)
{
// 获取设备菜单，作为变量表菜单的父级
//var deviceMenu
// = await _repositoryManager.Menus.GetMenuByTargetIdAsync(
// MenuType.DeviceMenu, createDto.DeviceId);
//if (deviceMenu == null)
//{
// throw new ApplicationException($"添加变量表菜单时，找不到设备ID:{createDto.DeviceId},请检查。");
//}
// 映射菜单实体并设置关联信息
// var menu = _mapper.Map<MenuBean>(createDto.Menu);
// menu.ParentId = deviceMenu.Id;
// menu.TargetId = createdVariableTable.Id;
// menu.MenuType = MenuType.VariableTableMenu;
//var addMenu= await _repositoryManager.Menus.AddAsync(menu);
//_mapper.Map(addMenu, createDto.Menu);
createDto.Menu.TargetId = createDto.VariableTable.Id;
//映射菜单实体并设置关联信息
createDto.Menu = await _repositoryManager.Menus.AddAsync(createDto.Menu);
}
await _repositoryManager.CommitAsync();
@@ -110,28 +93,21 @@ namespace DMS.Application.Services.Database
/// <param name="variableTable">要更新的变量表数据传输对象。</param>
/// <returns>受影响的行数。</returns>
/// <exception cref="ApplicationException">如果找不到变量表。</exception>
public async Task<int> UpdateVariableTableAsync(VariableTable variableTableDto)
public async Task<int> UpdateAsync(VariableTable variableTable)
{
try
{
await _repositoryManager.BeginTranAsync();
var variableTable = await _repositoryManager.VariableTables.GetByIdAsync(variableTableDto.Id);
if (variableTable == null)
{
throw new ApplicationException($"VariableTable with ID {variableTableDto.Id} not found.");
}
_mapper.Map(variableTableDto, variableTable);
int res = await _repositoryManager.VariableTables.UpdateAsync(variableTable);
await _repositoryManager.CommitAsync();
return res;
}
catch (Exception ex)
int res = await _repositoryManager.VariableTables.UpdateAsync(variableTable);
// 更新关联的菜单树
var menu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.VariableTableMenu && m.TargetId == variableTable.Id);
if (menu is not null && variableTable.Name!= menu.Header)
{
await _repositoryManager.RollbackAsync();
// 可以在此记录日志
throw new ApplicationException($"更新变量表时发生错误，操作已回滚,错误信息:{ex.Message}", ex);
menu.Header = variableTable.Name;
// 更新关联的菜单树
await _repositoryManager.Menus.UpdateAsync(menu);
}
return res;
}
/// <summary>
@@ -141,30 +117,20 @@ namespace DMS.Application.Services.Database
/// <returns>如果删除成功则为 true，否则为 false。</returns>
/// <exception cref="InvalidOperationException">如果删除变量表失败。</exception>
/// <exception cref="ApplicationException">如果删除变量表时发生其他错误。</exception>
public async Task<bool> DeleteVariableTableAsync(int id)
public async Task<bool> DeleteAsync(VariableTable variableTable)
{
try
{
await _repositoryManager.BeginTranAsync();
var variableTable = await _repositoryManager.VariableTables.GetByIdAsync(id);
if (variableTable == null)
{
throw new InvalidOperationException($"删除变量表失败：变量表ID:{id}，请检查变量表Id是否存在");
}
var delRes = await _repositoryManager.VariableTables.DeleteAsync(variableTable);
if (delRes == 0)
{
throw new InvalidOperationException($"删除变量表失败：变量表ID:{id}，请检查变量表Id是否存在");
}
// 删除关联的变量
await _repositoryManager.Variables.DeleteByVariableTableIdAsync(id);
// 删除关联的MQTT别名
// await _repositoryManager.MqttAlias.DeleteByVariableTableIdAsync(id);
// 删除关联的菜单树
//await _repositoryManager.Menus.DeleteMenuTreeByTargetIdAsync(MenuType.VariableTableMenu, id);
var menu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.VariableTableMenu && m.TargetId == variableTable.Id);
if (menu is not null)
{
// 删除关联的菜单树
await _repositoryManager.Menus.DeleteAsync(menu);
}
await _repositoryManager.CommitAsync();
return true;

44
DMS.Application/Services/Management/DeviceManagementService.cs
View File

@@ -49,8 +49,6 @@ public class DeviceManagementService : IDeviceManagementService
public async Task<CreateDeviceWithDetailsDto> CreateDeviceWithDetailsAsync(CreateDeviceWithDetailsDto dto)
{
var result = await _deviceAppService.CreateDeviceWithDetailsAsync(dto);
// 创建成功后，将设备添加到内存中
@@ -71,29 +69,31 @@ public class DeviceManagementService : IDeviceManagementService
}
}
//关联菜单
if (result.DeviceMenu is not null)
{
var deviceRootMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.TargetViewKey == "DevicesViewModel" && m.TargetId == 0);
if (deviceRootMenu is not null)
{
_appDataService.Menus.TryAdd(result.DeviceMenu.Id, result.DeviceMenu);
//将设备菜单添加到根菜单中
deviceRootMenu.Children.Add(result.DeviceMenu);
if (result.VariableTableMenu is not null)
{
_appDataService.Menus.TryAdd(result.VariableTableMenu.Id, result.VariableTableMenu);
//将变量表菜单添加到设备菜单中
result.DeviceMenu.Children.Add(result.VariableTableMenu);
}
}
}
_eventService.RaiseDeviceChanged(this, new DeviceChangedEventArgs(DataChangeType.Added, result.Device));
}
//关联菜单
if (result.DeviceMenu is not null)
{
var deviceRootMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.TargetViewKey == "DevicesViewModel" && m.TargetId == 0);
if (deviceRootMenu is not null)
{
_appDataService.Menus.TryAdd(result.DeviceMenu.Id, result.DeviceMenu);
//将设备菜单添加到根菜单中
deviceRootMenu.Children.Add(result.DeviceMenu);
if (result.VariableTableMenu is not null)
{
_appDataService.Menus.TryAdd(result.VariableTableMenu.Id, result.VariableTableMenu);
//将变量表菜单添加到设备菜单中
result.DeviceMenu.Children.Add(result.VariableTableMenu);
}
}
}

4
DMS.Application/Services/Management/MenuManagementService.cs
View File

@@ -56,7 +56,7 @@ public class MenuManagementService : IMenuManagementService
if (_appDataService.Menus.TryAdd(resMenu.Id, resMenu))
{
MenuBean parentMenu = null;
if (resMenu.ParentId > 0 && _appDataService.Menus.TryGetValue(resMenu.ParentId.Value, out var parent))
if (resMenu.ParentId > 0 && _appDataService.Menus.TryGetValue(resMenu.ParentId, out var parent))
{
parentMenu = parent;
parent.Children.Add(resMenu);
@@ -103,7 +103,7 @@ public class MenuManagementService : IMenuManagementService
if (_appDataService.Menus.TryRemove(menu.Id, out var menuData))
{
// 从父菜单中移除子菜单
if (menuData.ParentId > 0 && _appDataService.Menus.TryGetValue(menuData.ParentId.Value, out var parentMenu))
if (menuData.ParentId > 0 && _appDataService.Menus.TryGetValue(menuData.ParentId, out var parentMenu))
{
parentMenu.Children.Remove(menuData);
}

93
DMS.Application/Services/Management/VariableTableManagementService.cs
View File

@@ -50,36 +50,49 @@ public class VariableTableManagementService : IVariableTableManagementService
/// <summary>
/// 异步创建一个新变量表及其关联菜单（事务性操作）。
/// </summary>
public async Task<CreateVariableTableWithMenuDto> CreateVariableTableAsync(CreateVariableTableWithMenuDto dto)
public async Task<CreateVariableTableWithMenuDto> AddAsync(CreateVariableTableWithMenuDto dto)
{
var result = await _variableTableAppService.CreateVariableTableAsync(dto);
// 创建成功后，将变量表添加到内存中
if (result?.VariableTable != null)
var result = await _variableTableAppService.AddAsync(dto);
// 检查结果是否为空
if (result?.VariableTable is null)
{
// 添加null检查
if (_appDataService.Devices != null &&
_appDataService.Devices.TryGetValue(result.VariableTable.DeviceId, out var device))
{
// 确保VariableTables不为null
if (device.VariableTables == null)
device.VariableTables = new List<VariableTable>();
return null;
}
device.VariableTables.Add(result.VariableTable);
// 获取设备对象
if (!_appDataService.Devices.TryGetValue(result.VariableTable.DeviceId, out var device))
{
return null;
}
// 确保Device属性不为null
if (result.VariableTable != null)
result.VariableTable.Device = device;
}
// 将变量表添加到设备列表并设置设备引用
device.VariableTables.Add(result.VariableTable);
result.VariableTable.Device = device;
// 确保_variableTables和result.VariableTable不为null
if (_appDataService.VariableTables.TryAdd(result.VariableTable.Id, result.VariableTable))
{
_eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(
// 尝试将变量表添加到内存中
if (!_appDataService.VariableTables.TryAdd(result.VariableTable.Id, result.VariableTable))
{
return null;
}
// 如果有菜单对象，则处理菜单相关逻辑
if (result.Menu is null) return null;
var deviceMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
if (deviceMenu is not null)
{
_appDataService.Menus.TryAdd(result.Menu.Id, result.Menu);
//将设备菜单添加到根菜单中
deviceMenu.Children.Add(result.Menu);
}
// 触发变量表变化事件
_eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(
DataChangeType.Added,
result.VariableTable));
}
}
return result;
}
@@ -87,9 +100,9 @@ public class VariableTableManagementService : IVariableTableManagementService
/// <summary>
/// 异步更新一个已存在的变量表。
/// </summary>
public async Task<int> UpdateVariableTableAsync(VariableTable variableTable)
public async Task<int> UpdateAsync(VariableTable variableTable)
{
var result = await _variableTableAppService.UpdateVariableTableAsync(variableTable);
var result = await _variableTableAppService.UpdateAsync(variableTable);
// 更新成功后，更新内存中的变量表
if (result > 0 && variableTable != null)
@@ -106,25 +119,37 @@ public class VariableTableManagementService : IVariableTableManagementService
/// <summary>
/// 异步删除一个变量表。
/// </summary>
public async Task<bool> DeleteVariableTableAsync(int id)
public async Task<bool> DeleteAsync(VariableTable variableTable)
{
var result = await _variableTableAppService.DeleteVariableTableAsync(id);
var result = await _variableTableAppService.DeleteAsync(variableTable);
// 删除成功后，从内存中移除变量表
if (result )
if (result)
{
if (_appDataService.VariableTables.TryRemove(id, out var variableTable))
if (_appDataService.Devices.TryGetValue(variableTable.DeviceId, out var device))
{
if (variableTable != null && _appDataService.Devices.TryGetValue(variableTable.DeviceId, out var device))
device.VariableTables.Remove(variableTable);
_appDataService.VariableTables.TryRemove(variableTable.Id, out _);
//删除菜单
var variableTableMenu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.VariableTableMenu && m.TargetId == variableTable.Id);
if (variableTableMenu is not null)
{
if (device.VariableTables != null)
device.VariableTables.Remove(variableTable);
if (_appDataService.Menus.TryGetValue(variableTableMenu.ParentId, out var deviceMenu))
{
deviceMenu.Children.Remove(variableTableMenu);
}
_appDataService.Menus.TryRemove(variableTableMenu.Id, out _);
}
_eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(
DataChangeType.Deleted,
variableTable));
}
_eventService.RaiseVariableTableChanged(this, new VariableTableChangedEventArgs(
DataChangeType.Deleted,
variableTable));
}
return result;