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

1 feat: 实现触发器-菜单联动功能和事件系统

Browse Source 
2
    3 - 实现触发器与菜单联动功能，现在可以同时创建触发器及其关联的菜单项
    4 - 添加触发器更改事件系统，用于通知UI和其他组件触发器状态的变化
    5 - 优化触发器管理服务，改进了添加、修改和删除触发器的逻辑
    6 - 将CreateTriggerAsync方法重命名为AddTriggerAsync，使其语义更准确
    7 - 修改UpdateTriggerAsync方法的参数和返回值类型，提高一致性
    8 - 添加CreateTriggerWithMenuAsync方法用于同时创建触发器和菜单
    9 - 在应用层重构触发器管理逻辑，增加事务支持确保数据一致性
   10 - 更新菜单管理服务，改进并发安全处理
   11 - 调整数据存储服务，使其同步触发器和菜单更新
   12 - 更新触发器对话框和列表视图模型，提升用户体验
   13 - 在依赖注入容器中注册触发器服务
   14 - 修复设备数据服务中的异步调用问题，确保菜单项的正确处理
   15 - 添加缺失的触发器项映射配置
   16 - 创建TriggerChangedEventArgs类处理触发器更改事件
This commit is contained in:
David P.G
2025-10-19 20:34:20 +08:00
parent 0007235171
commit 958593b35d
17 changed files with 362 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
DMS.Application/Events/TriggerChangedEventArgs.cs Normal file
View File

@@ -0,0 +1,26 @@
using DMS.Core.Enums;
using DMS.Core.Models.Triggers;
namespace DMS.Application.Events
{
/// <summary>
/// 触发器更改事件参数
/// </summary>
public class TriggerChangedEventArgs : DataChangedEventArgs
{
/// <summary>
/// 更改的触发器
/// </summary>
public Trigger Trigger { get; }
/// <summary>
/// 构造函数
/// </summary>
/// <param name="changeType">更改类型</param>
/// <param name="trigger">触发器</param>
public TriggerChangedEventArgs(DataChangeType changeType, Trigger trigger) : base(changeType)
{
Trigger = trigger;
}
}
}

10
DMS.Application/Interfaces/Database/ITriggerAppService.cs
View File

@@ -1,3 +1,4 @@
using DMS.Application.DTOs;
using DMS.Core.Models.Triggers;
using System.Collections.Generic;
using System.Threading.Tasks;
@@ -27,7 +28,14 @@ namespace DMS.Application.Interfaces.Database
/// </summary>
/// <param name="trigger">要创建的触发器定义。</param>
/// <returns>新创建的触发器定义。</returns>
Task<Trigger> CreateTriggerAsync(Trigger trigger);
Task<Trigger> AddTriggerAsync(Trigger trigger);
/// <summary>
/// 异步创建触发器及其关联菜单。
/// </summary>
/// <param name="dto">包含触发器和菜单信息的数据传输对象。</param>
/// <returns>包含新创建触发器和菜单信息的数据传输对象。</returns>
Task<CreateTriggerWithMenuDto> CreateTriggerWithMenuAsync(CreateTriggerWithMenuDto dto);
/// <summary>
/// 异步更新一个已存在的触发器定义及其关联的变量ID。

16
DMS.Application/Interfaces/IEventService.cs
View File

@@ -164,4 +164,20 @@ public interface IEventService
void RaiseTriggerVariableChanged(object sender, TriggerVariableChangedEventArgs e);
#endregion
#region 触发器事件
/// <summary>
/// 触发器改变事件
/// </summary>
event EventHandler<TriggerChangedEventArgs> OnTriggerChanged;
/// <summary>
/// 触发触发器改变事件
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">触发器改变事件参数</param>
void RaiseTriggerChanged(object sender, TriggerChangedEventArgs e);
#endregion
}

11
DMS.Application/Interfaces/Management/ITriggerManagementService.cs
View File

@@ -26,7 +26,14 @@ namespace DMS.Application.Interfaces.Management
/// </summary>
/// <param name="triggerDto">要创建的触发器定义 DTO</param>
/// <returns>创建成功的触发器定义 DTO</returns>
Task<Trigger> CreateTriggerAsync(Trigger triggerDto);
Task<Trigger> AddTriggerAsync(Trigger triggerDto);
/// <summary>
/// 创建触发器及其关联菜单
/// </summary>
/// <param name="dto">包含触发器和菜单信息的数据传输对象</param>
/// <returns>包含新创建触发器和菜单信息的数据传输对象</returns>
Task<CreateTriggerWithMenuDto> CreateTriggerWithMenuAsync(CreateTriggerWithMenuDto dto);
/// <summary>
/// 更新一个已存在的触发器定义
@@ -34,7 +41,7 @@ namespace DMS.Application.Interfaces.Management
/// <param name="id">要更新的触发器 ID</param>
/// <param name="triggerDto">包含更新信息的触发器定义 DTO</param>
/// <returns>更新后的触发器定义 DTO，如果未找到则返回 null</returns>
Task<Trigger?> UpdateTriggerAsync(int id, Trigger triggerDto);
Task<int> UpdateTriggerAsync( Trigger trigger);
/// <summary>
/// 删除一个触发器定义

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

@@ -7,6 +7,7 @@ using System.Threading.Tasks;
using System.Linq;
using System.Diagnostics;
using DMS.Application.Interfaces;
using DMS.Application.DTOs;
namespace DMS.Application.Services.Database
{
@@ -62,7 +63,7 @@ namespace DMS.Application.Services.Database
/// </summary>
/// <param name="trigger">要创建的触发器定义。</param>
/// <returns>新创建的触发器定义。</returns>
public async Task<Trigger> CreateTriggerAsync(Trigger trigger)
public async Task<Trigger> AddTriggerAsync(Trigger trigger)
{
try
{
@@ -71,19 +72,6 @@ namespace DMS.Application.Services.Database
// 添加触发器定义
var addedTrigger = await _repositoryManager.Triggers.AddAsync(trigger);
// // 添加关联的变量ID
// if (trigger.Variables != null && trigger.Variables.Any())
// {
// var triggerVariables = trigger.Variables.Select(variableId => new DbTriggerVariable
// {
// TriggerDefinitionId = addedTrigger.Id,
// VariableId = variableId
// })
// .ToList();
//
// await _repositoryManager.AddTriggerVariablesAsync(triggerVariables);
// }
await _repositoryManager.CommitAsync();
return addedTrigger;
}
@@ -94,6 +82,62 @@ namespace DMS.Application.Services.Database
}
}
/// <summary>
/// 异步创建触发器及其关联菜单。
/// </summary>
/// <param name="dto">包含触发器和菜单信息的数据传输对象。</param>
/// <returns>包含新创建触发器和菜单信息的数据传输对象。</returns>
public async Task<CreateTriggerWithMenuDto> CreateTriggerWithMenuAsync(CreateTriggerWithMenuDto dto)
{
try
{
await _repositoryManager.BeginTranAsync();
// 创建触发器
var createdTrigger = await _repositoryManager.Triggers.AddAsync(dto.Trigger);
if (createdTrigger == null || createdTrigger.Id == 0)
{
throw new InvalidOperationException($"添加触发器失败：{createdTrigger}");
}
// 确保DTO中的触发器对象也更新为新创建的触发器
dto.Trigger = createdTrigger;
// 创建菜单
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 addMenu = await _repositoryManager.Menus.AddAsync(dto.TriggerMenu);
if (addMenu == null || addMenu.Id == 0)
{
throw new InvalidOperationException($"添加触发器菜单失败：{addMenu}");
}
// 更新dto中的菜单对象
dto.TriggerMenu = addMenu;
}
}
await _repositoryManager.CommitAsync();
return dto;
}
catch (Exception ex)
{
await _repositoryManager.RollbackAsync();
throw new ApplicationException($"创建触发器及其菜单时发生错误，操作已回滚，错误信息：{ex.Message}", ex);
}
}
/// <summary>
/// 异步更新一个已存在的触发器定义及其关联的变量ID。
/// </summary>
@@ -108,25 +152,6 @@ namespace DMS.Application.Services.Database
// 更新触发器定义
var rowsAffected = await _repositoryManager.Triggers.UpdateAsync(trigger);
// if (rowsAffected > 0)
// {
// // 删除旧的关联关系
// await _repositoryManager.DeleteTriggerVariablesByTriggerIdAsync(trigger.Id);
//
// // 插入新的关联关系
// if (trigger.Variables != null && trigger.Variables.Any())
// {
// var triggerVariables = trigger.Variables.Select(variableId => new DbTriggerVariable
// {
// TriggerDefinitionId = trigger.Id,
// VariableId = variableId
// })
// .ToList();
//
// await _repositoryManager.AddTriggerVariablesAsync(triggerVariables);
// }
// }
await _repositoryManager.CommitAsync();
return rowsAffected;
}
@@ -148,9 +173,6 @@ namespace DMS.Application.Services.Database
{
await _repositoryManager.BeginTranAsync();
// // 删除关联的变量关系
// await _repositoryManager.DeleteTriggerVariablesByTriggerIdAsync(id);
// 删除触发器本身
var rowsAffected = await _repositoryManager.Triggers.DeleteByIdAsync(id);

19
DMS.Application/Services/EventService.cs
View File

@@ -207,4 +207,23 @@ public class EventService : IEventService
}
#endregion
#region 触发器事件
/// <summary>
/// 触发器改变事件
/// </summary>
public event EventHandler<TriggerChangedEventArgs> OnTriggerChanged;
/// <summary>
/// 触发触发器改变事件
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">触发器改变事件参数</param>
public void RaiseTriggerChanged(object sender, TriggerChangedEventArgs e)
{
OnTriggerChanged?.Invoke(sender, e);
}
#endregion
}

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

@@ -78,10 +78,12 @@ public class MenuManagementService : IMenuManagementService
var result = await _menuService.UpdateMenuAsync(menu);
// 更新成功后，更新内存中的菜单
if (result > 0 && menu != null)
if (result > 0)
{
_appStorageService.Menus.AddOrUpdate(menu.Id, menu, (key, oldValue) => menu);
if (_appStorageService.Menus.TryGetValue(menu.Id,out var mMenu))
{
mMenu.Header = menu.Header;
}
_eventService.RaiseMenuChanged(this, new MenuChangedEventArgs(DataChangeType.Updated, menu));
}

124
DMS.Application/Services/Management/TriggerManagementService.cs
View File

@@ -1,8 +1,12 @@
using AutoMapper;
using DMS.Application.DTOs;
using DMS.Application.Events;
using DMS.Application.Interfaces;
using DMS.Application.Interfaces.Database;
using DMS.Application.Interfaces.Management;
using DMS.Application.Services.Triggers;
using DMS.Core.Enums;
using DMS.Core.Events;
using DMS.Core.Interfaces;
using DMS.Core.Models.Triggers;
@@ -14,22 +18,24 @@ namespace DMS.Application.Services.Management
public class TriggerManagementService : ITriggerManagementService
{
private readonly IAppStorageService _appStorageService;
private readonly IRepositoryManager _repositoryManager;
private readonly ITriggerAppService _triggerAppService;
private readonly IMapper _mapper;
private readonly IEventService _eventService;
public TriggerManagementService(IAppStorageService appStorageService,IRepositoryManager repositoryManager, IMapper mapper)
public TriggerManagementService(IAppStorageService appStorageService, ITriggerAppService triggerAppService, IMapper mapper, IEventService eventService)
{
_appStorageService = appStorageService;
_repositoryManager = repositoryManager;
_triggerAppService = triggerAppService;
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_eventService = eventService;
}
/// <summary>
/// 获取所有触发器定义
/// </summary>
public List<Trigger> GetAllTriggersAsync()
public List<Trigger> GetAllTriggersAsync()
{
var triggers = _appStorageService.Triggers.Values.ToList();
var triggers = _appStorageService.Triggers.Values.ToList();
return _mapper.Map<List<Trigger>>(triggers);
}
@@ -41,76 +47,92 @@ namespace DMS.Application.Services.Management
_appStorageService.Triggers.TryGetValue(id, out var trigger);
return trigger;
}
/// <summary>
/// 创建一个新的触发器定义
/// </summary>
public async Task<Trigger> CreateTriggerAsync(Trigger triggerDto)
public async Task<Trigger> AddTriggerAsync(Trigger trigger)
{
// 1. 验证 DTO (可以在应用层或领域层做)
// ValidateTriggerDto(triggerDto);
var createdTrigger = await _triggerAppService.AddTriggerAsync(trigger);
// 2. 转换 DTO 到实体
var triggerEntity = _mapper.Map<Trigger>(triggerDto);
triggerEntity.CreatedAt = DateTime.UtcNow;
triggerEntity.UpdatedAt = DateTime.UtcNow;
// 3. 调用仓储保存实体
var createdTrigger = await _repositoryManager.Triggers.AddAsync(triggerEntity);
// 5. 同步更新AppDataStorageService中的Triggers字典
_appStorageService.Triggers[createdTrigger.Id] = createdTrigger;
// 创建成功后，将触发器添加到内存中
if (createdTrigger != null)
{
if (_appStorageService.Triggers.TryAdd(createdTrigger.Id, createdTrigger))
{
_eventService.RaiseTriggerChanged(this, new TriggerChangedEventArgs(DataChangeType.Added, createdTrigger));
}
}
return createdTrigger;
}
/// <summary>
/// 更新一个已存在的触发器定义
/// 创建触发器及其关联菜单
/// </summary>
public async Task<Trigger?> UpdateTriggerAsync(int id, Trigger triggerDto)
public async Task<CreateTriggerWithMenuDto> CreateTriggerWithMenuAsync(CreateTriggerWithMenuDto dto)
{
// 1. 获取现有实体
var existingTrigger = await _repositoryManager.Triggers.GetByIdAsync(id);
if (existingTrigger == null)
var result = await _triggerAppService.CreateTriggerWithMenuAsync(dto);
// 创建成功后，将触发器添加到内存中
if (result is null || result.Trigger is null)
{
return null;
}
// 2. 验证 DTO
ValidateTriggerDto(triggerDto);
if (_appStorageService.Triggers.TryAdd(result.Trigger.Id, result.Trigger))
{
_eventService.RaiseTriggerChanged(this, new TriggerChangedEventArgs(DataChangeType.Added, result.Trigger));
}
// 3. 将 DTO 映射到现有实体 (排除不可变字段如 Id, CreatedAt)
_mapper.Map(triggerDto, existingTrigger, opts => opts.Items["IgnoreIdAndCreatedAt"] = true);
existingTrigger.UpdatedAt = DateTime.UtcNow;
if (_appStorageService.Menus.TryAdd(result.TriggerMenu.Id, result.TriggerMenu))
{
_eventService.RaiseMenuChanged(this, new MenuChangedEventArgs(DataChangeType.Added, result.TriggerMenu));
}
// 4. 调用仓储更新实体
var updatedTrigger = await _repositoryManager.Triggers.UpdateAsync(existingTrigger);
if (updatedTrigger == null)
return null;
// 5. 转换回 DTO 并返回
var result = _mapper.Map<Trigger>(updatedTrigger);
// 6. 同步更新AppDataStorageService中的Triggers字典
_appStorageService.Triggers[result.Id] = result;
return result;
}
/// <summary>
/// 更新一个已存在的触发器定义
/// </summary>
public async Task<int> UpdateTriggerAsync(Trigger trigger)
{
// 4. 调用仓储更新实体
var res = await _triggerAppService.UpdateTriggerAsync(trigger);
if (res == 0)
return res;
// 6. 同步更新AppDataStorageService中的Triggers字典
if (_appStorageService.Triggers.TryGetValue(trigger.Id, out var memTrigger))
{
_mapper.Map(trigger, memTrigger);
}
return res;
}
/// <summary>
/// 删除一个触发器定义
/// </summary>
public async Task<bool> DeleteTriggerAsync(int id)
{
// var result = await _repositoryManager.Triggers.DeleteAsync(id);
//
// // 如果删除成功，也从AppDataStorageService中的Triggers字典中移除
// if (result)
// {
// _appStorageService.Triggers.TryRemove(id, out _);
// }
//
// return result;
return false;
// 如果删除成功，也从AppDataStorageService中的Triggers字典中移除
if (await _triggerAppService.DeleteTriggerByIdAsync(id))
{
_appStorageService.Triggers.TryRemove(id, out _);
return true;
}
else
{
return false;
}
}
/// <summary>
@@ -129,7 +151,7 @@ namespace DMS.Application.Services.Management
public async Task LoadAllTriggersAsync()
{
_appStorageService.Triggers.Clear();
var triggerDefinitions = await _repositoryManager.Triggers.GetAllAsync();
var triggerDefinitions = await _triggerAppService.GetAllTriggersAsync();
foreach (var triggerDefinition in triggerDefinitions)
{
_appStorageService.Triggers.TryAdd(triggerDefinition.Id, triggerDefinition);

1
DMS.WPF/App.xaml.cs
View File

@@ -268,6 +268,7 @@ public partial class App : System.Windows.Application
services.AddSingleton<IMqttAliasAppService, MqttAliasAppService>();
services.AddSingleton<IMqttAliasManagementService, MqttAliasManagementService>();
services.AddSingleton<ILogManagementService, LogManagementService>();
services.AddSingleton<ITriggerAppService, TriggerAppService>(); // 注册触发器应用服务
services.AddSingleton<ITriggerManagementService, TriggerManagementService>(); // 注册触发器管理服务
services.AddSingleton<ITriggerEvaluationService, TriggerEvaluationService>(); // 注册触发器评估服务
services.AddSingleton<ITriggerActionExecutor, TriggerActionExecutor>(); // 注册触发器动作执行器

2
DMS.WPF/Interfaces/IMenuDataService.cs
View File

@@ -21,5 +21,5 @@ public interface IMenuDataService
Task DeleteMenuItem(MenuItem? MenuItem);
void LoadAllMenus();
Task UpdateMenuItem(MenuItem MenuItem);
}

2
DMS.WPF/Interfaces/ITriggerDataService.cs
View File

@@ -22,7 +22,7 @@ public interface ITriggerDataService
/// <summary>
/// 添加触发器及其关联菜单。
/// </summary>
Task<CreateTriggerWithMenuDto> AddTriggerWithMenu(CreateTriggerWithMenuDto dto);
Task<CreateTriggerWithMenuDto> CreateTriggerWithMenu(CreateTriggerWithMenuDto dto);
/// <summary>
/// 删除触发器。

1
DMS.WPF/Profiles/MappingProfile.cs
View File

@@ -38,6 +38,7 @@ namespace DMS.WPF.Profiles
CreateMap<Variable, VariableItem>()
.ReverseMap();
CreateMap<NlogDto, NlogItem>().ReverseMap();
CreateMap<TriggerItem, TriggerItem>().ReverseMap();
// 添加触发器相关映射
CreateMap<TriggerItem, Core.Models.Triggers.Trigger>()

6
DMS.WPF/Services/DeviceDataService.cs
View File

@@ -111,7 +111,7 @@ public class DeviceDataService : IDeviceDataService
// 给界面添加设备菜单
if (addDto.DeviceMenu != null)
{
_menuDataService.AddMenuItem(_mapper.Map<MenuItem>(addDto.DeviceMenu));
await _menuDataService.AddMenuItem(_mapper.Map<MenuItem>(addDto.DeviceMenu));
}
@@ -124,7 +124,7 @@ public class DeviceDataService : IDeviceDataService
if (addDto.VariableTable != null && addDto.VariableTableMenu != null)
{
_menuDataService.AddMenuItem(_mapper.Map<MenuItem>(addDto.VariableTableMenu));
await _menuDataService.AddMenuItem(_mapper.Map<MenuItem>(addDto.VariableTableMenu));
}
@@ -158,7 +158,7 @@ public class DeviceDataService : IDeviceDataService
var deviceMenu= _dataStorageService.Menus.FirstOrDefault(m => m.MenuType == MenuType.DeviceMenu && m.TargetId == device.Id);
if (deviceMenu != null)
{
_menuDataService.DeleteMenuItem(deviceMenu);
await _menuDataService.DeleteMenuItem(deviceMenu);
}
_dataStorageService.Devices.Remove(device.Id);

32
DMS.WPF/Services/MenuDataService.cs
View File

@@ -27,7 +27,7 @@ public class MenuDataService : IMenuDataService
/// </summary>
/// <param name="mapper">AutoMapper 实例。</param>
/// <param name="appStorageService">数据服务中心实例。</param>
public MenuDataService(IMapper mapper,IDataStorageService dataStorageService, IAppStorageService appStorageService,IMenuManagementService menuManagementService)
public MenuDataService(IMapper mapper, IDataStorageService dataStorageService, IAppStorageService appStorageService, IMenuManagementService menuManagementService)
{
_mapper = mapper;
_dataStorageService = dataStorageService;
@@ -79,15 +79,35 @@ public class MenuDataService : IMenuDataService
if (deviceMenu is not null)
{
var menuId= await _menuManagementService.CreateMenuAsync(_mapper.Map<MenuBean>(MenuItem));
if (menuId>0)
var menuId = await _menuManagementService.CreateMenuAsync(_mapper.Map<MenuBean>(MenuItem));
if (menuId > 0)
{
MenuItem.Id = menuId;
deviceMenu.Children.Add(MenuItem);
_dataStorageService.Menus.Add(MenuItem);
BuildMenuTrees();
}
}
}
/// <summary>
/// 更新菜单项。
/// </summary>
public async Task UpdateMenuItem(MenuItem MenuItem)
{
if (MenuItem is null) return;
var menu = _dataStorageService.Menus.FirstOrDefault(m => m.Id == MenuItem.Id);
if (menu is not null)
{
var res = await _menuManagementService.UpdateMenuAsync(_mapper.Map<MenuBean>(MenuItem));
if (res > 0)
{
menu.Header = MenuItem.Header;
}
}
}
@@ -99,8 +119,8 @@ public class MenuDataService : IMenuDataService
{
if (MenuItem is null) return;
await _menuManagementService.DeleteMenuAsync(MenuItem.Id);
await _menuManagementService.DeleteMenuAsync(MenuItem.Id);
// 从扁平菜单列表中移除
_dataStorageService.Menus.Remove(MenuItem);

119
DMS.WPF/Services/TriggerDataService.cs
View File

@@ -4,10 +4,15 @@ using DMS.Application.Interfaces;
using DMS.Application.Services;
using DMS.Core.Enums;
using DMS.Core.Events;
using DMS.Core.Models;
using DMS.Core.Models.Triggers;
using DMS.WPF.Interfaces;
using DMS.WPF.ItemViewModel;
using DMS.WPF.ViewModels;
using HandyControl.Data;
using Opc.Ua;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Threading;
namespace DMS.WPF.Services;
@@ -19,6 +24,7 @@ public class TriggerDataService : ITriggerDataService
{
private readonly IMapper _mapper;
private readonly IAppCenterService _appCenterService;
private readonly IMenuDataService _menuDataService;
private readonly IAppStorageService _appStorageService;
private readonly IDataStorageService _dataStorageService;
private readonly IEventService _eventService;
@@ -35,11 +41,13 @@ public class TriggerDataService : ITriggerDataService
/// <param name="eventService">事件服务实例。</param>
/// <param name="notificationService">通知服务实例。</param>
public TriggerDataService(IMapper mapper, IAppCenterService appCenterService,
IMenuDataService menuDataService,
IAppStorageService appStorageService, IDataStorageService dataStorageService,
IEventService eventService, INotificationService notificationService)
{
_mapper = mapper;
_appCenterService = appCenterService;
_menuDataService = menuDataService;
_appStorageService = appStorageService;
_dataStorageService = dataStorageService;
_eventService = eventService;
@@ -65,22 +73,39 @@ public class TriggerDataService : ITriggerDataService
public async Task<TriggerItem> AddTrigger(TriggerItem triggerItem)
{
// 添加null检查
if (triggerItem == null)
return null;
if (triggerItem is null) return null;
var addDto
= await _appCenterService.TriggerManagementService.CreateTriggerAsync(
_mapper.Map<Trigger>(triggerItem));
= await _appCenterService.TriggerManagementService.AddTriggerAsync(
_mapper.Map<Core.Models.Triggers.Trigger>(triggerItem));
// 添加null检查
if (addDto == null)
{
return null;
}
if (addDto is null) return null;
// 给界面添加触发器
var addItem = _mapper.Map<TriggerItem>(addDto);
_dataStorageService.Triggers.Add(addDto.Id, addItem);
var addItem = _mapper.Map(addDto, triggerItem);
_dataStorageService.Triggers.Add(triggerItem.Id, triggerItem);
//添加菜单
var parentMenu=_dataStorageService.Menus.FirstOrDefault(m => m.TargetViewKey == nameof(TriggersViewModel) && m.TargetId == 0);
if (parentMenu is not null)
{
var menuItem = new ItemViewModel.MenuItem()
{
Header = triggerItem.Name,
ParentId=parentMenu.Id,
MenuType=MenuType.TriggerMenu,
TargetId=addItem.Id,
Icon = "\uE945", // 使用触发器图标
TargetViewKey = nameof(TriggerDetailViewModel),
};
await _menuDataService.AddMenuItem(menuItem);
}
return addItem;
}
@@ -91,21 +116,27 @@ public class TriggerDataService : ITriggerDataService
public async Task<bool> DeleteTrigger(TriggerItem trigger)
{
// 从数据库删除触发器数据
if (!await _appCenterService.TriggerManagementService.DeleteTriggerAsync(trigger.Id))
if (await _appCenterService.TriggerManagementService.DeleteTriggerAsync(trigger.Id))
{
return false;
//删除菜单
var menu=_dataStorageService.Menus.FirstOrDefault(m => m.MenuType == MenuType.TriggerMenu && m.TargetId == trigger.Id);
if (menu is not null)
{
await _menuDataService.DeleteMenuItem(menu);
}
// 从界面删除触发器
_dataStorageService.Triggers.Remove(trigger.Id);
return true;
}
// 从界面删除触发器
_dataStorageService.Triggers.Remove(trigger.Id);
return true;
return false;
}
/// <summary>
/// 添加触发器及其关联菜单。
/// </summary>
public async Task<CreateTriggerWithMenuDto> AddTriggerWithMenu(CreateTriggerWithMenuDto dto)
public async Task<CreateTriggerWithMenuDto> CreateTriggerWithMenu(CreateTriggerWithMenuDto dto)
{
// 添加null检查
if (dto == null || dto.Trigger == null)
@@ -114,26 +145,16 @@ public class TriggerDataService : ITriggerDataService
try
{
// 首先添加触发器
var createdTrigger = await _appCenterService.TriggerManagementService.CreateTriggerAsync(dto.Trigger);
var createdTrigger = await _appCenterService.TriggerManagementService.CreateTriggerWithMenuAsync(dto);
if (createdTrigger == null)
return null;
var parentMenu=_appStorageService.Menus.Values.OrderBy(m=>m.Id).FirstOrDefault(m=>m.MenuType==MenuType.TriggerMenu);
if (parentMenu is not null)
{
// 将菜单关联到触发器
dto.TriggerMenu.TargetId = createdTrigger.Id;
dto.TriggerMenu.MenuType = MenuType.TriggerMenu;
}
// 添加到UI数据存储
var addItem = _mapper.Map<TriggerItem>(createdTrigger);
_dataStorageService.Triggers.Add(createdTrigger.Id, addItem);
var addItem = _mapper.Map<TriggerItem>(createdTrigger.Trigger);
_dataStorageService.Triggers.Add(addItem.Id, addItem);
return dto;
}
@@ -147,18 +168,34 @@ public class TriggerDataService : ITriggerDataService
/// <summary>
/// 更新触发器。
/// </summary>
public async Task<bool> UpdateTrigger(TriggerItem trigger)
public async Task<bool> UpdateTrigger(TriggerItem triggerItem)
{
if (!_appStorageService.Triggers.TryGetValue(trigger.Id, out var triggerDto))
if (_appStorageService.Triggers.TryGetValue(triggerItem.Id, out var triggerDto))
{
return false;
_mapper.Map(triggerItem, triggerDto);
if (await _appCenterService.TriggerManagementService.UpdateTriggerAsync(triggerDto) > 0)
{
if (_dataStorageService.Triggers.TryGetValue(triggerItem.Id,out var mTrigger))
{
_mapper.Map(triggerItem,mTrigger);
//菜单
var menuItem = _dataStorageService.Menus.FirstOrDefault(m => m.MenuType == MenuType.TriggerMenu && m.TargetId == triggerItem.Id);
if (menuItem is not null)
{
menuItem.Header = triggerItem.Name;
await _menuDataService.UpdateMenuItem(menuItem);
}
return true;
}
}
}
_mapper.Map(trigger, triggerDto);
if (await _appCenterService.TriggerManagementService.UpdateTriggerAsync(trigger.Id, triggerDto) != null)
{
return true;
}
return false;
}

4
DMS.WPF/ViewModels/Dialogs/TriggerDialogViewModel.cs
View File

@@ -145,10 +145,10 @@ namespace DMS.WPF.ViewModels.Dialogs
}
// Set timestamps
Trigger.UpdatedAt = DateTime.UtcNow;
Trigger.UpdatedAt = DateTime.Now;
if (Trigger.Id == default(int))
{
Trigger.CreatedAt = DateTime.UtcNow;
Trigger.CreatedAt = DateTime.Now;
Trigger.Id = 0; // 对于自增ID，设置为0让数据库自动生成
}

86
DMS.WPF/ViewModels/TriggersViewModel.cs
View File

@@ -30,7 +30,7 @@ namespace DMS.WPF.ViewModels
public NotifyCollectionChangedSynchronizedViewList<TriggerItem> TriggerItemListView { get; }
[ObservableProperty]
private ObservableDictionary<int, TriggerItem> _triggers ;
private ObservableDictionary<int, TriggerItem> _triggers;
[ObservableProperty]
private TriggerItem? _selectedTrigger;
@@ -51,14 +51,14 @@ namespace DMS.WPF.ViewModels
_navigationService = navigationService ?? throw new ArgumentNullException(nameof(navigationService));
// 初始化时加载触发器数据
_synchronizedView = _dataStorageService.Triggers.CreateView(v=>v.Value);
TriggerItemListView= _synchronizedView.ToNotifyCollectionChanged();
_synchronizedView = _dataStorageService.Triggers.CreateView(v => v.Value);
TriggerItemListView = _synchronizedView.ToNotifyCollectionChanged();
}
/// <summary>
/// 添加新触发器
@@ -67,59 +67,40 @@ namespace DMS.WPF.ViewModels
private async Task AddTriggerAsync()
{
var newTrigger = new TriggerItem()
{
IsActive = true,
Action = Core.Models.Triggers.ActionType.SendEmail,
Description = "新建触发器",
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
{
IsActive = true,
Action = Core.Models.Triggers.ActionType.SendEmail,
Name = "新建触发器",
Description = "新建触发器",
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now
};
TriggerDialogViewModel viewModel = App.Current.Services.GetRequiredService<TriggerDialogViewModel>();
await viewModel.OnInitializedAsync(newTrigger);
var result = await _dialogService.ShowDialogAsync(viewModel);
if (result != null)
if (result is null) return;
try
{
try
{
// 创建包含菜单信息的 DTO
CreateTriggerWithMenuDto dto = new CreateTriggerWithMenuDto();
if (_mapper != null)
{
dto.Trigger = _mapper.Map<Trigger>(result);
}
else
{
_notificationService?.ShowError("映射服务未初始化");
return;
}
// 创建菜单项
dto.TriggerMenu = new MenuBean()
{
Header = result.Name ?? result.Description,
Icon = "\uE945", // 使用触发器图标
TargetViewKey = nameof(TriggerDetailViewModel),
};
// 使用TriggerDataService添加触发器和菜单
var resTriggerItem = await _triggerDataService.AddTrigger(result);
// 使用TriggerDataService添加触发器和菜单
var createdTriggerDto = await _triggerDataService.AddTriggerWithMenu(dto);
if (createdTriggerDto != null && createdTriggerDto.Trigger != null)
{
// 更新UI显示
_notificationService.ShowSuccess($"触发器创建成功：{createdTriggerDto.Trigger.Name ?? createdTriggerDto.Trigger.Description}");
}
else
{
_notificationService.ShowError("触发器创建失败");
}
}
catch (Exception ex)
if (resTriggerItem is not null)
{
_notificationService.ShowError($"创建触发器失败: {ex.Message}");
// 更新UI显示
_notificationService.ShowSuccess($"触发器创建成功：{resTriggerItem.Name}");
}
else
{
_notificationService.ShowError("触发器创建失败");
}
}
catch (Exception ex)
{
_notificationService.ShowError($"创建触发器失败: {ex.Message},");
}
}
@@ -136,10 +117,11 @@ namespace DMS.WPF.ViewModels
}
// 传递副本以避免直接修改原始对象
var triggerToEdit = _mapper.Map<Trigger>(SelectedTrigger);
TriggerItem triggerItemToEdit = new TriggerItem();
_mapper.Map(SelectedTrigger, triggerItemToEdit);
TriggerDialogViewModel viewModel = App.Current.Services.GetRequiredService<TriggerDialogViewModel>();
await viewModel.OnInitializedAsync(triggerToEdit);
await viewModel.OnInitializedAsync(triggerItemToEdit);
var result = await _dialogService.ShowDialogAsync(viewModel);
if (result != null)
@@ -147,7 +129,7 @@ namespace DMS.WPF.ViewModels
try
{
// 使用TriggerDataService更新触发器
var updatedTrigger = await _triggerDataService.UpdateTrigger(SelectedTrigger);
var updatedTrigger = await _triggerDataService.UpdateTrigger(result);
if (updatedTrigger)
{
_notificationService.ShowSuccess("触发器更新成功");
@@ -176,7 +158,7 @@ namespace DMS.WPF.ViewModels
return;
}
var confirm = await _dialogService.ShowDialogAsync(new ConfirmDialogViewModel("确认删除", $"确定要删除触发器 '{SelectedTrigger.Description}' 吗？","删除"));
var confirm = await _dialogService.ShowDialogAsync(new ConfirmDialogViewModel("确认删除", $"确定要删除触发器 '{SelectedTrigger.Description}' 吗？", "删除"));
if (confirm)
{
try