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-22 14:06:16 +08:00
parent e995ec7207
commit 54d040b45f
76 changed files with 1028 additions and 1161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
DMS.Application/Services/Database/DeviceAppService.cs
View File

@@ -16,6 +16,7 @@ namespace DMS.Application.Services.Database;
public class DeviceAppService : IDeviceAppService
{
private readonly IRepositoryManager _repoManager;
private readonly IAppDataService _appDataService;
private readonly IMapper _mapper;
/// <summary>
@@ -23,9 +24,10 @@ public class DeviceAppService : IDeviceAppService
/// </summary>
/// <param name="repoManager">仓储管理器实例。</param>
/// <param name="mapper">AutoMapper 实例。</param>
public DeviceAppService(IRepositoryManager repoManager, IMapper mapper)
public DeviceAppService(IRepositoryManager repoManager, IAppDataService appStorageService, IMapper mapper)
{
_repoManager = repoManager;
_appDataService = appStorageService;
_mapper = mapper;
}
@@ -39,7 +41,6 @@ public class DeviceAppService : IDeviceAppService
var device = await _repoManager.Devices.GetByIdAsync(id);
return device;
}
/// <summary>
/// 异步获取所有设备数据传输对象列表。
/// </summary>
@@ -86,7 +87,6 @@ public class DeviceAppService : IDeviceAppService
$"添加设备变量表失败,设备：{dto.Device.Name},变量表：{dto?.VariableTable?.Name}");
}
dto.VariableTable.Device = dto.Device;
// 假设有设备菜单
if (dto.VariableTableMenu is not null && dto.VariableTableMenu is not null)
@@ -94,11 +94,6 @@ public class DeviceAppService : IDeviceAppService
dto.VariableTableMenu.ParentId = dto.DeviceMenu.Id; // 关联设备菜单作为父级
dto.VariableTableMenu.TargetId = dto.VariableTable.Id;
dto.VariableTableMenu = await _repoManager.Menus.AddAsync(dto.VariableTableMenu);
if (dto.VariableTableMenu == null || dto.VariableTableMenu.Id == 0)
{
throw new InvalidOperationException(
$"添加设备变量表菜单失败,变量表：{dto.VariableTable.Name},变量表菜单：{dto.VariableTableMenu.Header}");
}
}
}
@@ -123,16 +118,10 @@ public class DeviceAppService : IDeviceAppService
public async Task<int> UpdateDeviceAsync(Device device)
{
await _repoManager.BeginTranAsync();
var existingDevice = await _repoManager.Devices.GetByIdAsync(device.Id);
if (existingDevice == null)
{
throw new ApplicationException($"Device with ID {device.Id} not found.");
}
_mapper.Map(device, existingDevice);
int res = await _repoManager.Devices.UpdateAsync(existingDevice);
var menu = await _repoManager.Menus.GetMenuByTargetIdAsync(MenuType.DeviceMenu, device.Id);
if (menu != null)
int res = await _repoManager.Devices.UpdateAsync(device);
//获取到设备对应的菜单
var menu = _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
if (menu is not null && menu.Header!=device.Name)
{
menu.Header = device.Name;
await _repoManager.Menus.UpdateAsync(menu);
@@ -156,19 +145,17 @@ public class DeviceAppService : IDeviceAppService
{
await _repoManager.BeginTranAsync();
var delRes = await _repoManager.Devices.DeleteAsync(device);
if (delRes == 0)
{
throw new InvalidOperationException($"删除设备失败：设备ID:{device.Id}，请检查设备Id是否存在");
}
// 删除关联的变量
await _repoManager.Variables.DeleteByVariableTableIdAsync(device.Id);
// 删除关联的变量表
await _repoManager.VariableTables.DeleteAsync(device.VariableTables);
// 删除关联的菜单树
await _repoManager.Menus.DeleteMenuTreeByTargetIdAsync(MenuType.DeviceMenu, device.Id);
var menu= _appDataService.Menus.Values.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
if (menu is not null)
{
// 删除关联的菜单树
await _repoManager.Menus.DeleteAsync(menu);
}
await _repoManager.CommitAsync();
return true;

65
DMS.Application/Services/Database/MenuAppService.cs
View File

@@ -1,8 +1,7 @@
using AutoMapper;
using DMS.Application.Interfaces;
using DMS.Core.Interfaces;
using DMS.Core.Models;
using DMS.Application.Interfaces.Database;
using DMS.Application.Interfaces;
namespace DMS.Application.Services.Database;
@@ -53,20 +52,9 @@ public class MenuAppService : IMenuAppService
/// <param name="menu">要创建的菜单。</param>
/// <returns>新创建菜单的ID。</returns>
/// <exception cref="ApplicationException">如果创建菜单时发生错误。</exception>
public async Task<int> CreateMenuAsync(MenuBean menu)
public async Task<MenuBean> AddAsync(MenuBean menu)
{
try
{
await _repoManager.BeginTranAsync();
await _repoManager.Menus.AddAsync(menu);
await _repoManager.CommitAsync();
return menu.Id;
}
catch (Exception ex)
{
await _repoManager.RollbackAsync();
throw new ApplicationException("创建菜单时发生错误，操作已回滚。", ex);
}
return await _repoManager.Menus.AddAsync(menu);
}
/// <summary>
@@ -75,57 +63,20 @@ public class MenuAppService : IMenuAppService
/// <param name="menu">要更新的菜单。</param>
/// <returns>受影响的行数。</returns>
/// <exception cref="ApplicationException">如果找不到菜单或更新菜单时发生错误。</exception>
public async Task<int> UpdateMenuAsync(MenuBean menu)
public async Task<int> UpdateAsync(MenuBean menu)
{
try
{
await _repoManager.BeginTranAsync();
var dbmenu = await _repoManager.Menus.GetByIdAsync(menu.Id);
if (dbmenu == null)
{
throw new ApplicationException($"Menu with ID {menu.Id} not found.");
}
_mapper.Map(menu, dbmenu);
int res = await _repoManager.Menus.UpdateAsync(dbmenu);
await _repoManager.CommitAsync();
return res;
}
catch (Exception ex)
{
await _repoManager.RollbackAsync();
throw new ApplicationException("更新菜单时发生错误，操作已回滚。", ex);
}
return await _repoManager.Menus.UpdateAsync(menu);
}
/// <summary>
/// 异步删除一个菜单（事务性操作）。
/// </summary>
/// <param name="id">要删除菜单的ID。</param>
/// <returns>如果删除成功则为 true，否则为 false。</returns>
/// <exception cref="InvalidOperationException">如果删除菜单失败。</exception>
/// <exception cref="ApplicationException">如果删除菜单时发生其他错误。</exception>
public async Task<bool> DeleteMenuAsync(int id)
public async Task<bool> DeleteAsync(MenuBean menu)
{
try
{
await _repoManager.BeginTranAsync();
var menu = await _repoManager.Menus.GetByIdAsync(id);
if (menu == null)
{
throw new InvalidOperationException($"删除菜单失败：菜单ID:{id}，请检查菜单Id是否存在");
}
var delRes = await _repoManager.Menus.DeleteAsync(menu);
if (delRes == 0)
{
throw new InvalidOperationException($"删除菜单失败：菜单ID:{id}，请检查菜单Id是否存在");
}
await _repoManager.CommitAsync();
return true;
}
catch (Exception ex)
{
await _repoManager.RollbackAsync();
throw new ApplicationException("删除菜单时发生错误，操作已回滚。", ex);
}
var delRes = await _repoManager.Menus.DeleteAsync(menu);
return delRes > 0;
}
}

6
DMS.Application/Services/Database/MqttAliasAppService.cs
View File

@@ -12,16 +12,16 @@ namespace DMS.Application.Services.Database;
public class MqttAliasAppService : IMqttAliasAppService
{
private readonly IRepositoryManager _repoManager;
private readonly IAppStorageService _appStorageService;
private readonly IAppDataService _appDataService;
private readonly IMapper _mapper;
/// <summary>
/// 构造函数。
/// </summary>
public MqttAliasAppService(IRepositoryManager repoManager,IAppStorageService appStorageService, IMapper mapper)
public MqttAliasAppService(IRepositoryManager repoManager,IAppDataService appStorageService, IMapper mapper)
{
_repoManager = repoManager;
_appStorageService = appStorageService;
_appDataService = appStorageService;
_mapper = mapper;
}

32
DMS.Application/Services/Database/TriggerAppService.cs
View File

@@ -107,24 +107,24 @@ namespace DMS.Application.Services.Database
if (dto.TriggerMenu != null)
{
// 使用现有的菜单查找逻辑来获取父菜单
var parentMenu = await _repositoryManager.Menus.GetMenuByTargetIdAsync(Core.Enums.MenuType.TriggerMenu, 0);
if (parentMenu != null)
{
// 设置菜单的关联信息
dto.TriggerMenu.ParentId = parentMenu.Id;
dto.TriggerMenu.MenuType = Core.Enums.MenuType.TriggerMenu;
dto.TriggerMenu.TargetId = createdTrigger.Id;
//var parentMenu = await _repositoryManager.Menus.GetMenuByTargetIdAsync(Core.Enums.MenuType.TriggerMenu, 0);
//if (parentMenu != null)
//{
// // 设置菜单的关联信息
// dto.TriggerMenu.ParentId = parentMenu.Id;
// dto.TriggerMenu.MenuType = Core.Enums.MenuType.TriggerMenu;
// dto.TriggerMenu.TargetId = createdTrigger.Id;
// 添加菜单到数据库
var addMenu = await _repositoryManager.Menus.AddAsync(dto.TriggerMenu);
if (addMenu == null || addMenu.Id == 0)
{
throw new InvalidOperationException($"添加触发器菜单失败：{addMenu}");
}
// // 添加菜单到数据库
// var addMenu = await _repositoryManager.Menus.AddAsync(dto.TriggerMenu);
// if (addMenu == null || addMenu.Id == 0)
// {
// throw new InvalidOperationException($"添加触发器菜单失败：{addMenu}");
// }
// 更新dto中的菜单对象
dto.TriggerMenu = addMenu;
}
// // 更新dto中的菜单对象
// dto.TriggerMenu = addMenu;
//}
}
await _repositoryManager.CommitAsync();

137
DMS.Application/Services/Database/VariableAppService.cs
View File

@@ -38,27 +38,7 @@ public class VariableAppService : IVariableAppService
return variable;
}
/// <summary>
/// 异步根据OPC UA NodeId获取变量数据传输对象。
/// </summary>
/// <param name="opcUaNodeId">OPC UA NodeId。</param>
/// <returns>变量数据传输对象。</returns>
public async Task<Variable?> GetVariableByOpcUaNodeIdAsync(string opcUaNodeId)
{
var variable = await _repoManager.Variables.GetByOpcUaNodeIdAsync(opcUaNodeId);
return variable ;
}
/// <summary>
/// 异步根据OPC UA NodeId列表获取变量数据传输对象列表。
/// </summary>
/// <param name="opcUaNodeIds">OPC UA NodeId列表。</param>
/// <returns>变量数据传输对象列表。</returns>
public async Task<List<Variable>> GetVariableByOpcUaNodeIdsAsync(List<string> opcUaNodeIds)
{
var variables = await _repoManager.Variables.GetByOpcUaNodeIdsAsync(opcUaNodeIds);
return variables;
}
/// <summary>
/// 异步获取所有变量数据传输对象列表。
@@ -73,13 +53,13 @@ public class VariableAppService : IVariableAppService
/// <summary>
/// 异步创建一个新变量（事务性操作）。
/// </summary>
/// <param name="variable">要创建的变量数据传输对象。</param>
public async Task<Variable> CreateVariableAsync(Variable variable)
/// <param name="variable">要创建的变量数据传输对象。</param>
public async Task<Variable> AddAsync(Variable variable)
{
try
{
await _repoManager.BeginTranAsync();
var addedVariable = await _repoManager.Variables.AddAsync(variable); await _repoManager.CommitAsync();
var addedVariable = await _repoManager.Variables.AddAsync(variable); await _repoManager.CommitAsync();
return _mapper.Map<Variable>(addedVariable);
}
catch (Exception ex)
@@ -92,8 +72,8 @@ public class VariableAppService : IVariableAppService
/// <summary>
/// 异步更新一个已存在的变量（事务性操作）。
/// </summary>
/// <param name="variable">要更新的变量数据传输对象。</param>
public async Task<int> UpdateVariableAsync(Variable variable)
/// <param name="variable">要更新的变量数据传输对象。</param>
public async Task<int> UpdateAsync(Variable variable)
{
try
{
@@ -121,13 +101,13 @@ public class VariableAppService : IVariableAppService
/// <param name="variables">要更新的变量数据传输对象列表。</param>
/// <returns>受影响的行数。</returns>
/// <exception cref="ApplicationException">如果更新变量时发生错误。</exception>
public async Task<int> UpdateVariablesAsync(List<Variable> variables)
public async Task<int> UpdateAsync(List<Variable> variables)
{
try
{
await _repoManager.BeginTranAsync();
int totalAffected = 0;
foreach (var variable in variables)
{
var existingVariable = await _repoManager.Variables.GetByIdAsync(variable.Id);
@@ -139,7 +119,7 @@ public class VariableAppService : IVariableAppService
int res = await _repoManager.Variables.UpdateAsync(existingVariable);
totalAffected += res;
}
await _repoManager.CommitAsync();
return totalAffected;
}
@@ -153,24 +133,19 @@ public class VariableAppService : IVariableAppService
/// <summary>
/// 异步删除一个变量（事务性操作）。
/// </summary>
/// <param name="id">要删除变量的ID。</param>
/// <param name="variable1"></param>
/// <returns>如果删除成功则为 true，否则为 false。</returns>
/// <exception cref="InvalidOperationException">如果删除变量失败。</exception>
/// <exception cref="ApplicationException">如果删除变量时发生其他错误。</exception>
public async Task<bool> DeleteVariableAsync(int id)
public async Task<bool> DeleteAsync(Variable variable)
{
try
{
await _repoManager.BeginTranAsync();
var variable = await _repoManager.Variables.GetByIdAsync(id);
if (variable == null)
{
throw new InvalidOperationException($"删除变量失败：变量ID:{id}，请检查变量Id是否存在");
}
var delRes = await _repoManager.Variables.DeleteAsync(variable);
if (delRes == 0)
{
throw new InvalidOperationException($"删除变量失败：变量ID:{id}，请检查变量Id是否存在");
throw new InvalidOperationException($"删除变量失败：变量ID:{variable.Id}，请检查变量Id是否存在");
}
await _repoManager.CommitAsync();
return true;
@@ -185,30 +160,26 @@ public class VariableAppService : IVariableAppService
/// <summary>
/// 异步批量删除变量（事务性操作）。
/// </summary>
/// <param name="ids">要删除的变量ID列表。</param>
/// <param name="variables"></param>
/// <returns>如果删除成功则为 true，否则为 false。</returns>
/// <exception cref="ArgumentException">如果ID列表为空或null。</exception>
/// <exception cref="ApplicationException">如果删除变量时发生错误。</exception>
public async Task<bool> DeleteVariablesAsync(List<int> ids)
public async Task<bool> DeleteAsync(List<Variable> variables)
{
if (ids == null || !ids.Any())
{
throw new ArgumentException("变量ID列表不能为空", nameof(ids));
}
try
{
await _repoManager.BeginTranAsync();
// 批量删除变量
// var deletedCount = await _repoManager.Variables.DeleteByIdsAsync(ids);
//
// // 检查是否所有变量都被成功删除
// if (deletedCount != ids.Count)
// {
// throw new InvalidOperationException($"删除变量失败：请求删除 {ids.Count} 个变量，实际删除 {deletedCount} 个变量");
// }
var deletedCount = await _repoManager.Variables.DeleteAsync(variables);
// 检查是否所有变量都被成功删除
if (deletedCount != variables.Count)
{
throw new InvalidOperationException($"删除变量失败：请求删除 {variables.Count} 个变量，实际删除 {deletedCount} 个变量");
}
await _repoManager.CommitAsync();
return true;
}
@@ -219,68 +190,8 @@ public class VariableAppService : IVariableAppService
}
}
public async Task<List<Variable>> BatchImportVariablesAsync(List<Variable> variables)
public async Task<List<Variable>> AddAsync(List<Variable> variables)
{
try
{
var variableModels = _mapper.Map<List<Variable>>(variables);
var addedVariables = await _repoManager.Variables.AddAsync(variableModels);
return _mapper.Map<List<Variable>>(addedVariables);
}
catch (Exception ex)
{
throw new ApplicationException($"批量导入变量时发生错误,错误信息:{ex.Message}", ex);
}
}
public async Task<List<Variable>> FindExistingVariablesAsync(IEnumerable<Variable> variablesToCheck)
{
if (variablesToCheck == null || !variablesToCheck.Any())
{
return new List<Variable>();
}
var names = variablesToCheck.Select(v => v.Name).Where(n => !string.IsNullOrEmpty(n)).Distinct().ToList();
var s7Addresses = variablesToCheck.Select(v => v.S7Address).Where(a => !string.IsNullOrEmpty(a)).Distinct().ToList();
var opcUaNodeIds = variablesToCheck.Select(v => v.OpcUaNodeId).Where(id => !string.IsNullOrEmpty(id)).Distinct().ToList();
var allVariables = await _repoManager.Variables.GetAllAsync();
var existingVariablesFromDb = allVariables.Where(v =>
(names.Any() && !string.IsNullOrEmpty(v.Name) && names.Contains(v.Name)) ||
(s7Addresses.Any() && !string.IsNullOrEmpty(v.S7Address) && s7Addresses.Contains(v.S7Address)) ||
(opcUaNodeIds.Any() && !string.IsNullOrEmpty(v.OpcUaNodeId) && opcUaNodeIds.Contains(v.OpcUaNodeId)))
.ToList();
if (existingVariablesFromDb == null || !existingVariablesFromDb.Any())
{
return new List<Variable>();
}
var existingNames = new HashSet<string>(existingVariablesFromDb.Select(v => v.Name).Where(n => !string.IsNullOrEmpty(n)));
var existingS7Addresses = new HashSet<string>(existingVariablesFromDb.Select(v => v.S7Address).Where(a => !string.IsNullOrEmpty(a)));
var existingOpcUaNodeIds = new HashSet<string>(existingVariablesFromDb.Select(v => v.OpcUaNodeId).Where(id => !string.IsNullOrEmpty(id)));
var result = existingVariablesFromDb.Where(v =>
(names.Any() && !string.IsNullOrEmpty(v.Name) && names.Contains(v.Name)) ||
(s7Addresses.Any() && !string.IsNullOrEmpty(v.S7Address) && s7Addresses.Contains(v.S7Address)) ||
(opcUaNodeIds.Any() && !string.IsNullOrEmpty(v.OpcUaNodeId) && opcUaNodeIds.Contains(v.OpcUaNodeId)))
.ToList();
return result;
}
public async Task<Variable?> FindExistingVariableAsync(Variable variableToCheck)
{
if (variableToCheck == null)
{
return null;
}
// 创建一个包含单个元素的列表以便复用现有的逻辑
var variablesToCheck = new List<Variable> { variableToCheck };
var existingVariables = await FindExistingVariablesAsync(variablesToCheck);
// 如果找到了匹配的变量，返回第一个（也是唯一一个）
return existingVariables.FirstOrDefault();
return await _repoManager.Variables.AddAsync(variables);
}
}

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

@@ -74,21 +74,21 @@ namespace DMS.Application.Services.Database
if (createDto.Menu!=null)
{
// 获取设备菜单，作为变量表菜单的父级
var deviceMenu
= await _repositoryManager.Menus.GetMenuByTargetIdAsync(
MenuType.DeviceMenu, createDto.DeviceId);
if (deviceMenu == null)
{
throw new ApplicationException($"添加变量表菜单时，找不到设备ID:{createDto.DeviceId},请检查。");
}
//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);
// 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);
}
@@ -164,7 +164,7 @@ namespace DMS.Application.Services.Database
// await _repositoryManager.MqttAlias.DeleteByVariableTableIdAsync(id);
// 删除关联的菜单树
await _repositoryManager.Menus.DeleteMenuTreeByTargetIdAsync(MenuType.VariableTableMenu, id);
//await _repositoryManager.Menus.DeleteMenuTreeByTargetIdAsync(MenuType.VariableTableMenu, id);
await _repositoryManager.CommitAsync();
return true;