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

添加中文注释

Browse Source
This commit is contained in:
David P.G
2025-07-24 19:58:34 +08:00
parent 4e26685560
commit 556c09f1c5
11 changed files with 495 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
DMS.Infrastructure/Repositories/BaseRepository.cs
View File

@@ -8,7 +8,7 @@ using SqlSugar;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// 通用仓储基类，封装了对实体对象的常用 CRUD 操作。
/// 通用仓储基类，封装了对实体对象的常用 CRUD 操作。
/// </summary>
/// <typeparam name="TEntity">实体类型，必须是引用类型且具有无参构造函数。</typeparam>
public abstract class BaseRepository<TEntity>
@@ -18,16 +18,16 @@ public abstract class BaseRepository<TEntity>
/// <summary>
/// 初始化 BaseRepository 的新实例。
/// 初始化 BaseRepository 的新实例。
/// </summary>
/// <param name="dbContext">事务管理对象，通过依赖注入提供。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
protected BaseRepository(SqlSugarDbContext dbContext)
{
_dbContext = dbContext;
}
/// <summary>
/// 获取当前事务的 SqlSugarClient 实例，用于数据库操作。
/// 获取当前事务的 SqlSugarClient 实例，用于数据库操作。
/// </summary>
protected SqlSugarClient Db
{
@@ -35,7 +35,7 @@ public abstract class BaseRepository<TEntity>
}
/// <summary>
/// 异步添加一个新实体。
/// 异步添加一个新实体。
/// </summary>
/// <param name="entity">要添加的实体对象。</param>
/// <returns>返回已添加的实体对象（可能包含数据库生成的主键等信息）。</returns>
@@ -51,7 +51,7 @@ public abstract class BaseRepository<TEntity>
}
/// <summary>
/// 异步更新一个现有实体。
/// 异步更新一个现有实体。
/// </summary>
/// <param name="entity">要更新的实体对象。</param>
/// <returns>返回受影响的行数。</returns>
@@ -67,7 +67,7 @@ public abstract class BaseRepository<TEntity>
}
/// <summary>
/// 异步删除一个实体。
/// 异步删除一个实体。
/// </summary>
/// <param name="entity">要删除的实体对象。</param>
/// <returns>返回受影响的行数。</returns>
@@ -84,7 +84,7 @@ public abstract class BaseRepository<TEntity>
/// <summary>
/// 异步获取所有实体。
/// 异步获取所有实体。
/// </summary>
/// <returns>返回包含所有实体的列表。</returns>
public virtual async Task<List<TEntity>> GetAllAsync()
@@ -100,7 +100,7 @@ public abstract class BaseRepository<TEntity>
/// <summary>
/// 异步根据主键 ID 获取单个实体。
/// 异步根据主键 ID 获取单个实体。
/// </summary>
/// <param name="id">实体的主键 ID。</param>
/// <returns>返回找到的实体，如果未找到则返回 null。</returns>
@@ -117,7 +117,7 @@ public abstract class BaseRepository<TEntity>
}
/// <summary>
/// 异步根据指定条件获取单个实体。
/// 异步根据指定条件获取单个实体。
/// </summary>
/// <param name="expression">查询条件的 Lambda 表达式。</param>
/// <returns>返回满足条件的第一个实体，如果未找到则返回 null。</returns>
@@ -133,7 +133,7 @@ public abstract class BaseRepository<TEntity>
}
/// <summary>
/// 异步判断是否存在满足条件的实体。
/// 异步判断是否存在满足条件的实体。
/// </summary>
/// <param name="expression">查询条件的 Lambda 表达式。</param>
/// <returns>如果存在则返回 true，否则返回 false。</returns>
@@ -148,22 +148,39 @@ public abstract class BaseRepository<TEntity>
return result;
}
/// <summary>
/// 异步开始数据库事务。
/// </summary>
/// <returns>表示异步操作的任务。</returns>
public async Task BeginTranAsync()
{
await Db.BeginTranAsync();
}
/// <summary>
/// 异步提交数据库事务。
/// </summary>
/// <returns>表示异步操作的任务。</returns>
public async Task CommitTranAsync()
{
await Db.CommitTranAsync();
}
/// <summary>
/// 异步回滚数据库事务。
/// </summary>
/// <returns>表示异步操作的任务。</returns>
public async Task RollbackTranAsync()
{
await Db.RollbackTranAsync();
}
/// <summary>
/// 异步获取指定数量的实体。
/// </summary>
/// <param name="number">要获取的实体数量。</param>
/// <returns>包含指定数量实体对象的列表。</returns>
protected async Task<List<TEntity>> TakeAsync(int number)
{
var stopwatch = new Stopwatch();

43
DMS.Infrastructure/Repositories/DeviceRepository.cs
View File

@@ -8,39 +8,77 @@ using DMS.Infrastructure.Entities;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// 设备仓储实现类，负责设备数据的持久化操作。
/// 继承自 <see cref="BaseRepository{DbDevice}"/> 并实现 <see cref="IDeviceRepository"/> 接口。
/// </summary>
public class DeviceRepository : BaseRepository<DbDevice>, IDeviceRepository
{
private readonly IMapper _mapper;
/// <summary>
/// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
/// </summary>
/// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public DeviceRepository(IMapper mapper, SqlSugarDbContext dbContext)
: base(dbContext)
{
_mapper = mapper;
}
/// <summary>
/// 异步获取所有设备。
/// </summary>
/// <returns>包含所有设备实体的列表。</returns>
public async Task<List<Core.Models.Device>> GetAllAsync()
{
var dbList = await base.GetAllAsync();
return _mapper.Map<List<Core.Models.Device>>(dbList);
}
/// <summary>
/// 异步根据ID获取单个设备。
/// </summary>
/// <param name="id">设备的唯一标识符。</param>
/// <returns>对应的设备实体，如果不存在则为null。</returns>
public async Task<Core.Models.Device> GetByIdAsync(int id)
{
var dbDevice = await base.GetByIdAsync(id);
return _mapper.Map<Core.Models.Device>(dbDevice);
}
/// <summary>
/// 异步添加新设备。
/// </summary>
/// <param name="model">要添加的设备实体。</param>
/// <returns>添加成功后的设备实体（包含数据库生成的ID等信息）。</returns>
public async Task<Core.Models.Device> AddAsync(Core.Models.Device model)
{
var dbDevice = await base.AddAsync(_mapper.Map<DbDevice>(model));
return _mapper.Map(dbDevice, model);
}
/// <summary>
/// 异步更新现有设备。
/// </summary>
/// <param name="model">要更新的设备实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> UpdateAsync(Core.Models.Device model) => await base.UpdateAsync(_mapper.Map<DbDevice>(model));
/// <summary>
/// 异步删除设备。
/// </summary>
/// <param name="model">要删除的设备实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteAsync(Core.Models.Device model) => await base.DeleteAsync(_mapper.Map<DbDevice>(model));
/// <summary>
/// 异步根据ID删除设备。
/// </summary>
/// <param name="id">要删除设备的唯一标识符。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteByIdAsync(int id)
{
var stopwatch = new Stopwatch();
@@ -52,6 +90,11 @@ public class DeviceRepository : BaseRepository<DbDevice>, IDeviceRepository
return result;
}
/// <summary>
/// 异步获取指定数量的设备。
/// </summary>
/// <param name="number">要获取的设备数量。</param>
/// <returns>包含指定数量设备实体的列表。</returns>
public new async Task<List<Core.Models.Device>> TakeAsync(int number)
{
var dbList = await base.TakeAsync(number);

40
DMS.Infrastructure/Repositories/InitializeRepository.cs
View File

@@ -7,20 +7,32 @@ using SqlSugar;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// 初始化仓储实现类，负责数据库表和索引的初始化以及默认菜单的创建。
/// 实现 <see cref="IInitializeRepository"/> 接口。
/// </summary>
public class InitializeRepository : IInitializeRepository
{
private readonly SqlSugarDbContext _dbContext;
private readonly SqlSugarClient _db;
/// <summary>
/// 构造函数，注入 SqlSugarDbContext。
/// </summary>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public InitializeRepository(SqlSugarDbContext dbContext)
{
_dbContext = dbContext;
_db = _dbContext.GetInstance();
}
/// <summary>
/// 初始化所有数据库表。
/// 如果表不存在，则会创建。
/// </summary>
public void InitializeTables()
{
_db.DbMaintenance.CreateDatabase();
_db.DbMaintenance.CreateDatabase(); // 创建数据库（如果不存在）
_db.CodeFirst.InitTables<DbNlog>();
_db.CodeFirst.InitTables<DbDevice>();
_db.CodeFirst.InitTables<DbVariableTable>();
@@ -32,42 +44,64 @@ public class InitializeRepository : IInitializeRepository
_db.CodeFirst.InitTables<DbMenu>();
}
/// <summary>
/// 初始化数据库表索引。
/// 为特定表的列创建唯一索引，以提高查询效率和数据完整性。
/// </summary>
public void InitializeTableIndex()
{
// 为 DbDevice 表创建索引
_db.DbMaintenance.CreateIndex(nameof(DbDevice),new []
{
nameof(DbDevice.Name),
nameof(DbDevice.OpcUaServerUrl),
},true);
// 为 DbVariable 表创建索引
_db.DbMaintenance.CreateIndex(nameof(DbVariable),new []
{
nameof(DbVariable.OpcUaNodeId)
},true);
// 为 DbMqttServer 表创建索引
_db.DbMaintenance.CreateIndex(nameof(DbMqttServer),new []
{
nameof(DbMqttServer.ServerName)
},true);
}
/// <summary>
/// 检查数据库中是否存在指定的表。
/// </summary>
/// <param name="tableName">要检查的表名。</param>
/// <returns>如果表存在则为 true，否则为 false。</returns>
public bool IsAnyTable(string tableName)
{
return _db.DbMaintenance.IsAnyTable(tableName, false);
}
/// <summary>
/// 检查数据库中是否存在指定的索引。
/// </summary>
/// <param name="indexName">要检查的索引名。</param>
/// <returns>如果索引存在则为 true，否则为 false。</returns>
public bool IsAnyIndex(string indexName)
{
return _db.DbMaintenance.IsAnyIndex(indexName);
}
/// <summary>
/// 初始化默认菜单。
/// 如果配置文件中没有菜单，则添加一组默认菜单项。
/// </summary>
public void InitializeMenus()
{
var settings = AppSettings.Load();
if (settings.Menus.Any())
{
return ;
return ; // 如果已经有菜单，则不进行初始化
}
// 添加默认菜单项
settings.Menus.Add(new MenuBean() { Id=1, Header = "主页", Icon = "Home", ParentId = 0 });
settings.Menus.Add(new MenuBean() { Id = 2, Header = "设备", Icon = "Devices3", ParentId = 0 });
settings.Menus.Add(new MenuBean() { Id = 3, Header = "数据转换", Icon = "ChromeSwitch", ParentId = 0 });
@@ -75,7 +109,7 @@ public class InitializeRepository : IInitializeRepository
settings.Menus.Add(new MenuBean() { Id = 5, Header = "设置", Icon = "Settings", ParentId = 0 });
settings.Menus.Add(new MenuBean() { Id = 6, Header = "关于", Icon = "Info", ParentId = 0 });
settings.Save();
settings.Save(); // 保存菜单到配置文件
return ;
}

69
DMS.Infrastructure/Repositories/MenuRepository.cs
View File

@@ -9,17 +9,29 @@ using DMS.Infrastructure.Entities;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// 菜单仓储实现类，负责菜单数据的持久化操作。
/// 继承自 <see cref="BaseRepository{DbMenu}"/> 并实现 <see cref="IMenuRepository"/> 接口。
/// </summary>
public class MenuRepository : BaseRepository<DbMenu>, IMenuRepository
{
private readonly IMapper _mapper;
/// <summary>
/// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
/// </summary>
/// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public MenuRepository(IMapper mapper, SqlSugarDbContext dbContext)
: base(dbContext)
{
_mapper = mapper;
}
/// <summary>
/// 异步获取所有菜单树结构。
/// </summary>
/// <returns>包含所有菜单树结构的列表。</returns>
public async Task<List<MenuBean>> GetMenuTreesAsync()
{
var stopwatch = new Stopwatch();
@@ -31,30 +43,57 @@ public class MenuRepository : BaseRepository<DbMenu>, IMenuRepository
return _mapper.Map<List<MenuBean>>(dbMenuTree);
}
/// <summary>
/// 异步根据ID获取单个菜单。
/// </summary>
/// <param name="id">菜单的唯一标识符。</param>
/// <returns>对应的菜单实体，如果不存在则为null。</returns>
public async Task<MenuBean> GetByIdAsync(int id)
{
var dbMenu = await base.GetByIdAsync(id);
return _mapper.Map<MenuBean>(dbMenu);
}
/// <summary>
/// 异步获取所有菜单。
/// </summary>
/// <returns>包含所有菜单实体的列表。</returns>
public async Task<List<MenuBean>> GetAllAsync()
{
var dbList = await base.GetAllAsync();
return _mapper.Map<List<MenuBean>>(dbList);
}
/// <summary>
/// 异步添加新菜单。
/// </summary>
/// <param name="entity">要添加的菜单实体。</param>
/// <returns>添加成功后的菜单实体（包含数据库生成的ID等信息）。</returns>
public async Task<MenuBean> AddAsync(MenuBean entity)
{
var dbMenu = await base.AddAsync(_mapper.Map<DbMenu>(entity));
return _mapper.Map(dbMenu, entity);
}
/// <summary>
/// 异步更新现有菜单。
/// </summary>
/// <param name="entity">要更新的菜单实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> UpdateAsync(MenuBean entity) => await base.UpdateAsync(_mapper.Map<DbMenu>(entity));
/// <summary>
/// 异步删除菜单。
/// </summary>
/// <param name="entity">要删除的菜单实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteAsync(MenuBean entity) => await base.DeleteAsync(_mapper.Map<DbMenu>(entity));
/// <summary>
/// 异步根据ID删除菜单。
/// </summary>
/// <param name="id">要删除菜单的唯一标识符。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteByIdAsync(int id)
{
var stopwatch = new Stopwatch();
@@ -66,6 +105,11 @@ public class MenuRepository : BaseRepository<DbMenu>, IMenuRepository
return result;
}
/// <summary>
/// 异步根据菜单ID删除菜单树（包括子菜单）。
/// </summary>
/// <param name="id">要删除菜单树的根菜单ID。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteMenuTreeByIdAsync(int id)
{
var stopwatch = new Stopwatch();
@@ -83,6 +127,12 @@ public class MenuRepository : BaseRepository<DbMenu>, IMenuRepository
return delConut;
}
/// <summary>
/// 异步根据菜单类型和目标ID删除菜单树。
/// </summary>
/// <param name="menuType">菜单类型。</param>
/// <param name="targetId">目标ID。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteMenuTreeByTargetIdAsync(MenuType menuType, int targetId)
{
var stopwatch = new Stopwatch();
@@ -101,15 +151,26 @@ public class MenuRepository : BaseRepository<DbMenu>, IMenuRepository
return delConut;
}
/// <summary>
/// 异步根据菜单类型和目标ID获取菜单。
/// </summary>
/// <param name="menuType">菜单类型。</param>
/// <param name="targetId">目标ID。</param>
/// <returns>对应的菜单实体，如果不存在则为null。</returns>
public async Task<MenuBean> GetMenuByTargetIdAsync(MenuType menuType, int targetId)
{
var dbMenu = await Db.Queryable<DbMenu>().FirstAsync(m => m.MenuType == menuType && m.TargetId == targetId);
return _mapper.Map<MenuBean>(dbMenu);
}
/// <summary>
/// 异步获取指定数量的菜单。
/// </summary>
/// <param name="number">要获取的菜单数量。</param>
/// <returns>包含指定数量菜单实体的列表。</returns>
public new async Task<List<MenuBean>> TakeAsync(int number)
{
var dbList = await base.TakeAsync(number);
return _mapper.Map<List<MenuBean>>(dbList);
}
}
}

46
DMS.Infrastructure/Repositories/MqttServerRepository.cs
View File

@@ -9,51 +9,91 @@ using DMS.Infrastructure.Entities;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// Mqtt仓储类，用于操作DbMqtt实体
/// MQTT服务器仓储实现类，负责MQTT服务器数据的持久化操作。
/// 继承自 <see cref="BaseRepository{DbMqttServer}"/> 并实现 <see cref="IMqttServerRepository"/> 接口。
/// </summary>
public class MqttServerRepository : BaseRepository<DbMqttServer>, IMqttServerRepository
{
private readonly IMapper _mapper;
/// <summary>
/// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
/// </summary>
/// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public MqttServerRepository(IMapper mapper, SqlSugarDbContext dbContext)
: base(dbContext)
{
_mapper = mapper;
}
/// <summary>
/// 异步根据ID获取单个MQTT服务器。
/// </summary>
/// <param name="id">MQTT服务器的唯一标识符。</param>
/// <returns>对应的MQTT服务器实体，如果不存在则为null。</returns>
public async Task<MqttServer> GetByIdAsync(int id)
{
var dbMqttServer = await base.GetByIdAsync(id);
return _mapper.Map<MqttServer>(dbMqttServer);
}
/// <summary>
/// 异步获取所有MQTT服务器。
/// </summary>
/// <returns>包含所有MQTT服务器实体的列表。</returns>
public async Task<List<MqttServer>> GetAllAsync()
{
var dbList = await base.GetAllAsync();
return _mapper.Map<List<MqttServer>>(dbList);
}
/// <summary>
/// 异步添加新MQTT服务器。
/// </summary>
/// <param name="entity">要添加的MQTT服务器实体。</param>
/// <returns>添加成功后的MQTT服务器实体（包含数据库生成的ID等信息）。</returns>
public async Task<MqttServer> AddAsync(MqttServer entity)
{
var dbMqttServer = await base.AddAsync(_mapper.Map<DbMqttServer>(entity));
return _mapper.Map(dbMqttServer, entity);
}
/// <summary>
/// 异步更新现有MQTT服务器。
/// </summary>
/// <param name="entity">要更新的MQTT服务器实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> UpdateAsync(MqttServer entity) => await base.UpdateAsync(_mapper.Map<DbMqttServer>(entity));
/// <summary>
/// 异步删除MQTT服务器。
/// </summary>
/// <param name="entity">要删除的MQTT服务器实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteAsync(MqttServer entity) => await base.DeleteAsync(_mapper.Map<DbMqttServer>(entity));
/// <summary>
/// 异步根据ID删除MQTT服务器。
/// </summary>
/// <param name="id">要删除MQTT服务器的唯一标识符。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteByIdAsync(int id)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = await Db.Deleteable(new MqttServer() { Id = id })
var result = await Db.Deleteable(new DbMqttServer() { Id = id })
.ExecuteCommandAsync();
stopwatch.Stop();
NlogHelper.Info($"Delete {typeof(MqttServer)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
NlogHelper.Info($"Delete {typeof(DbMqttServer)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
return result;
}
/// <summary>
/// 异步获取指定数量的MQTT服务器。
/// </summary>
/// <param name="number">要获取的MQTT服务器数量。</param>
/// <returns>包含指定数量MQTT服务器实体的列表。</returns>
public new async Task<List<MqttServer>> TakeAsync(int number)
{
var dbList = await base.TakeAsync(number);

54
DMS.Infrastructure/Repositories/RepositoryManager.cs
View File

@@ -6,18 +6,29 @@ using SqlSugar;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// 仓储管理器实现类，负责管理所有具体的仓储实例，并提供事务管理功能。
/// 实现 <see cref="IRepositoryManager"/> 接口。
/// </summary>
public class RepositoryManager : IRepositoryManager
{
private readonly SqlSugarClient _db;
private readonly IMapper _mapper;
private readonly SqlSugarDbContext _dbContext;
/// <summary>
/// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
/// 在此初始化所有具体的仓储实例。
/// </summary>
/// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public RepositoryManager(IMapper mapper, SqlSugarDbContext dbContext)
{
_mapper = mapper;
_dbContext = dbContext;
_db = dbContext.GetInstance();
// 初始化各个仓储实例
InitializeRepository=new InitializeRepository(dbContext);
Devices = new DeviceRepository(mapper, dbContext);
VariableTables = new VariableTableRepository(mapper, dbContext);
@@ -29,23 +40,66 @@ public class RepositoryManager : IRepositoryManager
Users = new UserRepository(mapper, dbContext);
}
/// <summary>
/// 释放数据库连接资源。
/// </summary>
public void Dispose()
{
_db.Close();
}
/// <summary>
/// 获取设备仓储实例。
/// </summary>
public IDeviceRepository Devices { get; set; }
/// <summary>
/// 获取变量表仓储实例。
/// </summary>
public IVariableTableRepository VariableTables { get; set; }
/// <summary>
/// 获取变量仓储实例。
/// </summary>
public IVariableRepository Variables { get; set; }
/// <summary>
/// 获取MQTT服务器仓储实例。
/// </summary>
public IMqttServerRepository MqttServers { get; set; }
/// <summary>
/// 获取变量MQTT别名仓储实例。
/// </summary>
public IVariableMqttAliasRepository VariableMqttAliases { get; set; }
/// <summary>
/// 获取菜单仓储实例。
/// </summary>
public IMenuRepository Menus { get; set; }
/// <summary>
/// 获取变量历史仓储实例。
/// </summary>
public IVariableHistoryRepository VariableHistories { get; set; }
/// <summary>
/// 获取用户仓储实例。
/// </summary>
public IUserRepository Users { get; set; }
/// <summary>
/// 获取初始化仓储实例。
/// </summary>
public IInitializeRepository InitializeRepository { get; set; }
/// <summary>
/// 异步开始数据库事务。
/// </summary>
/// <returns>表示异步操作的任务。</returns>
public async Task BeginTranAsync() => await _db.BeginTranAsync();
/// <summary>
/// 异步提交数据库事务。
/// </summary>
/// <returns>表示异步操作的任务。</returns>
public async Task CommitAsync() => await _db.CommitTranAsync();
/// <summary>
/// 异步回滚数据库事务。
/// </summary>
/// <returns>表示异步操作的任务。</returns>
public async Task RollbackAsync() => await _db.RollbackTranAsync();
}

54
DMS.Infrastructure/Repositories/UserRepository.cs
View File

@@ -6,65 +6,97 @@ using DMS.Infrastructure.Data;
using DMS.Infrastructure.Entities;
/// <summary>
/// 用户仓储类，用于操作DbUser实体
/// </summary>
using AutoMapper;
using DMS.Core.Helper;
using DMS.Core.Interfaces;
using DMS.Core.Interfaces.Repositories;
using DMS.Core.Models;
using DMS.Infrastructure.Data;
using DMS.Infrastructure.Entities;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// 用户仓储类，用于操作DbUser实体
/// 用户仓储实现类，负责用户数据的持久化操作。
/// 继承自 <see cref="BaseRepository{DbUser}"/> 并实现 <see cref="IUserRepository"/> 接口。
/// </summary>
public class UserRepository : BaseRepository<DbUser>, IUserRepository
{
private readonly IMapper _mapper;
/// <summary>
/// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
/// </summary>
/// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public UserRepository(IMapper mapper, SqlSugarDbContext dbContext)
: base(dbContext)
{
_mapper = mapper;
}
/// <summary>
/// 异步根据ID获取单个用户。
/// </summary>
/// <param name="id">用户的唯一标识符。</param>
/// <returns>对应的用户实体，如果不存在则为null。</returns>
public async Task<User> GetByIdAsync(int id)
{
var dbUser = await base.GetByIdAsync(id);
return _mapper.Map<User>(dbUser);
}
/// <summary>
/// 异步获取所有用户。
/// </summary>
/// <returns>包含所有用户实体的列表。</returns>
public async Task<List<User>> GetAllAsync()
{
var dbList = await base.GetAllAsync();
return _mapper.Map<List<User>>(dbList);
}
/// <summary>
/// 异步添加新用户。
/// </summary>
/// <param name="entity">要添加的用户实体。</param>
/// <returns>添加成功后的用户实体（包含数据库生成的ID等信息）。</returns>
public async Task<User> AddAsync(User entity)
{
var dbUser = await base.AddAsync(_mapper.Map<DbUser>(entity));
return _mapper.Map(dbUser, entity);
}
/// <summary>
/// 异步更新现有用户。
/// </summary>
/// <param name="entity">要更新的用户实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> UpdateAsync(User entity) => await base.UpdateAsync(_mapper.Map<DbUser>(entity));
/// <summary>
/// 异步删除用户。
/// </summary>
/// <param name="entity">要删除的用户实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteAsync(User entity) => await base.DeleteAsync(_mapper.Map<DbUser>(entity));
/// <summary>
/// 异步根据ID删除用户。
/// </summary>
/// <param name="id">要删除用户的唯一标识符。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteByIdAsync(int id)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = await Db.Deleteable(new User() { Id = id })
var result = await Db.Deleteable(new DbUser() { Id = id })
.ExecuteCommandAsync();
stopwatch.Stop();
NlogHelper.Info($"Delete {typeof(DbMenu)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
NlogHelper.Info($"Delete {typeof(DbUser)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
return result;
}
/// <summary>
/// 异步获取指定数量的用户。
/// </summary>
/// <param name="number">要获取的用户数量。</param>
/// <returns>包含指定数量用户实体的列表。</returns>
public new async Task<List<User>> TakeAsync(int number)
{
var dbList = await base.TakeAsync(number);

52
DMS.Infrastructure/Repositories/VariableHistoryRepository.cs
View File

@@ -7,57 +7,95 @@ using DMS.Infrastructure.Entities;
using AutoMapper;
using DMS.Core.Helper;
using DMS.Core.Interfaces.Repositories;
using DMS.Core.Models;
using DMS.Infrastructure.Data;
using DMS.Infrastructure.Entities;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// 变量历史仓储实现类，负责变量历史数据的持久化操作。
/// 继承自 <see cref="BaseRepository{DbVariableHistory}"/> 并实现 <see cref="IVariableHistoryRepository"/> 接口。
/// </summary>
public class VariableHistoryRepository : BaseRepository<DbVariableHistory>, IVariableHistoryRepository
{
private readonly IMapper _mapper;
/// <summary>
/// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
/// </summary>
/// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public VariableHistoryRepository(IMapper mapper, SqlSugarDbContext dbContext)
: base(dbContext)
{
_mapper = mapper;
}
/// <summary>
/// 异步根据ID获取单个变量历史记录。
/// </summary>
/// <param name="id">变量历史记录的唯一标识符。</param>
/// <returns>对应的变量历史实体，如果不存在则为null。</returns>
public async Task<VariableHistory> GetByIdAsync(int id)
{
var dbVariableHistory = await base.GetByIdAsync(id);
return _mapper.Map<VariableHistory>(dbVariableHistory);
}
/// <summary>
/// 异步获取所有变量历史记录。
/// </summary>
/// <returns>包含所有变量历史实体的列表。</returns>
public async Task<List<VariableHistory>> GetAllAsync()
{
var dbList = await base.GetAllAsync();
return _mapper.Map<List<VariableHistory>>(dbList);
}
/// <summary>
/// 异步添加新变量历史记录。
/// </summary>
/// <param name="entity">要添加的变量历史实体。</param>
/// <returns>添加成功后的变量历史实体（包含数据库生成的ID等信息）。</returns>
public async Task<VariableHistory> AddAsync(VariableHistory entity)
{
var dbVariableHistory = await base.AddAsync(_mapper.Map<DbVariableHistory>(entity));
return _mapper.Map(dbVariableHistory, entity);
}
/// <summary>
/// 异步更新现有变量历史记录。
/// </summary>
/// <param name="entity">要更新的变量历史实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> UpdateAsync(VariableHistory entity) => await base.UpdateAsync(_mapper.Map<DbVariableHistory>(entity));
/// <summary>
/// 异步删除变量历史记录。
/// </summary>
/// <param name="entity">要删除的变量历史实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteAsync(VariableHistory entity) => await base.DeleteAsync(_mapper.Map<DbVariableHistory>(entity));
/// <summary>
/// 异步根据ID删除变量历史记录。
/// </summary>
/// <param name="id">要删除变量历史记录的唯一标识符。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteByIdAsync(int id)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = await Db.Deleteable(new Variable() { Id = id })
var result = await Db.Deleteable(new DbVariableHistory() { Id = id })
.ExecuteCommandAsync();
stopwatch.Stop();
NlogHelper.Info($"Delete {typeof(DbMenu)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
NlogHelper.Info($"Delete {typeof(DbVariableHistory)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
return result;
}
/// <summary>
/// 异步获取指定数量的变量历史记录。
/// </summary>
/// <param name="number">要获取的变量历史记录数量。</param>
/// <returns>包含指定数量变量历史实体的列表。</returns>
public new async Task<List<VariableHistory>> TakeAsync(int number)
{
var dbList = await base.TakeAsync(number);

52
DMS.Infrastructure/Repositories/VariableMqttAliasRepository.cs
View File

@@ -4,64 +4,98 @@ using DMS.Infrastructure.Data;
using DMS.Infrastructure.Entities;
/// <summary>
/// 变量与MQTT服务器别名关联的数据仓库。
/// </summary>
using AutoMapper;
using DMS.Core.Helper;
using DMS.Core.Interfaces.Repositories;
using DMS.Core.Models;
using DMS.Infrastructure.Data;
using DMS.Infrastructure.Entities;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// 变量与MQTT服务器别名关联的数据仓库。
/// 变量与MQTT别名关联仓储实现类，负责变量与MQTT别名关联数据的持久化操作。
/// 继承自 <see cref="BaseRepository{DbVariableMqttAlias}"/> 并实现 <see cref="IVariableMqttAliasRepository"/> 接口。
/// </summary>
public class VariableMqttAliasRepository : BaseRepository<DbVariableMqttAlias>, IVariableMqttAliasRepository
{
private readonly IMapper _mapper;
/// <summary>
/// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
/// </summary>
/// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public VariableMqttAliasRepository(IMapper mapper, SqlSugarDbContext dbContext)
: base(dbContext)
{
_mapper = mapper;
}
/// <summary>
/// 异步根据ID获取单个变量与MQTT别名关联。
/// </summary>
/// <param name="id">变量与MQTT别名关联的唯一标识符。</param>
/// <returns>对应的变量与MQTT别名关联实体，如果不存在则为null。</returns>
public async Task<VariableMqttAlias> GetByIdAsync(int id)
{
var dbVariableMqttAlias = await base.GetByIdAsync(id);
return _mapper.Map<VariableMqttAlias>(dbVariableMqttAlias);
}
/// <summary>
/// 异步获取所有变量与MQTT别名关联。
/// </summary>
/// <returns>包含所有变量与MQTT别名关联实体的列表。</returns>
public async Task<List<VariableMqttAlias>> GetAllAsync()
{
var dbList = await base.GetAllAsync();
return _mapper.Map<List<VariableMqttAlias>>(dbList);
}
/// <summary>
/// 异步添加新变量与MQTT别名关联。
/// </summary>
/// <param name="entity">要添加的变量与MQTT别名关联实体。</param>
/// <returns>添加成功后的变量与MQTT别名关联实体（包含数据库生成的ID等信息）。</returns>
public async Task<VariableMqttAlias> AddAsync(VariableMqttAlias entity)
{
var dbVariableMqttAlias = await base.AddAsync(_mapper.Map<DbVariableMqttAlias>(entity));
return _mapper.Map(dbVariableMqttAlias, entity);
}
/// <summary>
/// 异步更新现有变量与MQTT别名关联。
/// </summary>
/// <param name="entity">要更新的变量与MQTT别名关联实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> UpdateAsync(VariableMqttAlias entity) => await base.UpdateAsync(_mapper.Map<DbVariableMqttAlias>(entity));
/// <summary>
/// 异步删除变量与MQTT别名关联。
/// </summary>
/// <param name="entity">要删除的变量与MQTT别名关联实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteAsync(VariableMqttAlias entity) => await base.DeleteAsync(_mapper.Map<DbVariableMqttAlias>(entity));
/// <summary>
/// 异步根据ID删除变量与MQTT别名关联。
/// </summary>
/// <param name="id">要删除变量与MQTT别名关联的唯一标识符。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteByIdAsync(int id)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = await Db.Deleteable(new VariableMqttAlias() { Id = id })
var result = await Db.Deleteable(new DbVariableMqttAlias() { Id = id })
.ExecuteCommandAsync();
stopwatch.Stop();
NlogHelper.Info($"Delete {typeof(DbMenu)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
NlogHelper.Info($"Delete {typeof(DbVariableMqttAlias)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
return result;
}
/// <summary>
/// 异步获取指定数量的变量与MQTT别名关联。
/// </summary>
/// <param name="number">要获取的变量与MQTT别名关联数量。</param>
/// <returns>包含指定数量变量与MQTT别名关联实体的列表。</returns>
public new async Task<List<VariableMqttAlias>> TakeAsync(int number)
{
var dbList = await base.TakeAsync(number);

48
DMS.Infrastructure/Repositories/VariableRepository.cs
View File

@@ -9,12 +9,18 @@ using DMS.Infrastructure.Entities;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// VariableData仓储类，用于操作DbVariableData实体
/// 变量仓储实现类，负责变量数据的持久化操作。
/// 继承自 <see cref="BaseRepository{DbVariable}"/> 并实现 <see cref="IVariableRepository"/> 接口。
/// </summary>
public class VariableRepository : BaseRepository<DbVariable>, IVariableRepository
{
private readonly IMapper _mapper;
/// <summary>
/// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
/// </summary>
/// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public VariableRepository(IMapper mapper, SqlSugarDbContext dbContext)
: base(dbContext)
{
@@ -24,7 +30,7 @@ public class VariableRepository : BaseRepository<DbVariable>, IVariableRepositor
/*
/// <summary>
/// 为变量添加MQTT服务器关联，并指定别名。
/// 为变量添加MQTT服务器关联，并指定别名。（此方法当前被注释，可能为待实现或废弃功能）
/// </summary>
/// <param name="variableMqttList"></param>
/// <param name="variableDatas">要添加MQTT服务器的变量数据列表。</param>
@@ -104,40 +110,74 @@ public class VariableRepository : BaseRepository<DbVariable>, IVariableRepositor
}
}
*/
/// <summary>
/// 异步根据ID获取单个变量。
/// </summary>
/// <param name="id">变量的唯一标识符。</param>
/// <returns>对应的变量实体，如果不存在则为null。</returns>
public async Task<Variable> GetByIdAsync(int id)
{
var dbVariable = await base.GetByIdAsync(id);
return _mapper.Map<Variable>(dbVariable);
}
/// <summary>
/// 异步获取所有变量。
/// </summary>
/// <returns>包含所有变量实体的列表。</returns>
public async Task<List<Variable>> GetAllAsync()
{
var dbList = await base.GetAllAsync();
return _mapper.Map<List<Variable>>(dbList);
}
/// <summary>
/// 异步添加新变量。
/// </summary>
/// <param name="entity">要添加的变量实体。</param>
/// <returns>添加成功后的变量实体（包含数据库生成的ID等信息）。</returns>
public async Task<Variable> AddAsync(Variable entity)
{
var dbVariable = await base.AddAsync(_mapper.Map<DbVariable>(entity));
return _mapper.Map(dbVariable, entity);
}
/// <summary>
/// 异步更新现有变量。
/// </summary>
/// <param name="entity">要更新的变量实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> UpdateAsync(Variable entity) => await base.UpdateAsync(_mapper.Map<DbVariable>(entity));
/// <summary>
/// 异步删除变量。
/// </summary>
/// <param name="entity">要删除的变量实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteAsync(Variable entity) => await base.DeleteAsync(_mapper.Map<DbVariable>(entity));
/// <summary>
/// 异步根据ID删除变量。
/// </summary>
/// <param name="id">要删除变量的唯一标识符。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteByIdAsync(int id)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = await Db.Deleteable(new Variable() { Id = id })
var result = await Db.Deleteable(new DbVariable() { Id = id })
.ExecuteCommandAsync();
stopwatch.Stop();
NlogHelper.Info($"Delete {typeof(DbMenu)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
NlogHelper.Info($"Delete {typeof(DbVariable)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
return result;
}
/// <summary>
/// 异步获取指定数量的变量。
/// </summary>
/// <param name="number">要获取的变量数量。</param>
/// <returns>包含指定数量变量实体的列表。</returns>
public new async Task<List<Variable>> TakeAsync(int number)
{
var dbList = await base.TakeAsync(number);

56
DMS.Infrastructure/Repositories/VariableTableRepository.cs
View File

@@ -7,56 +7,95 @@ using DMS.Infrastructure.Entities;
using AutoMapper;
using DMS.Core.Helper;
using DMS.Core.Interfaces.Repositories;
using DMS.Core.Models;
using DMS.Infrastructure.Data;
using DMS.Infrastructure.Entities;
namespace DMS.Infrastructure.Repositories;
/// <summary>
/// 变量表仓储实现类，负责变量表数据的持久化操作。
/// 继承自 <see cref="BaseRepository{DbVariableTable}"/> 并实现 <see cref="IVariableTableRepository"/> 接口。
/// </summary>
public class VariableTableRepository : BaseRepository<DbVariableTable>, IVariableTableRepository
{
private readonly IMapper _mapper;
/// <summary>
/// 构造函数，注入 AutoMapper 和 SqlSugarDbContext。
/// </summary>
/// <param name="mapper">AutoMapper 实例，用于实体模型和数据库模型之间的映射。</param>
/// <param name="dbContext">SqlSugar 数据库上下文，用于数据库操作。</param>
public VariableTableRepository(IMapper mapper, SqlSugarDbContext dbContext)
: base(dbContext)
{
_mapper = mapper;
}
/// <summary>
/// 异步根据ID获取单个变量表。
/// </summary>
/// <param name="id">变量表的唯一标识符。</param>
/// <returns>对应的变量表实体，如果不存在则为null。</returns>
public async Task<VariableTable> GetByIdAsync(int id)
{
var dbVariableTable = await base.GetByIdAsync(id);
return _mapper.Map<VariableTable>(dbVariableTable);
}
/// <summary>
/// 异步获取所有变量表。
/// </summary>
/// <returns>包含所有变量表实体的列表。</returns>
public async Task<List<VariableTable>> GetAllAsync()
{
var dbList = await base.GetAllAsync();
return _mapper.Map<List<VariableTable>>(dbList);
}
/// <summary>
/// 异步添加新变量表。
/// </summary>
/// <param name="entity">要添加的变量表实体。</param>
/// <returns>添加成功后的变量表实体（包含数据库生成的ID等信息）。</returns>
public async Task<VariableTable> AddAsync(VariableTable entity)
{
var dbVariableTable = await base.AddAsync(_mapper.Map<DbVariableTable>(entity));
return _mapper.Map(dbVariableTable, entity);
}
/// <summary>
/// 异步更新现有变量表。
/// </summary>
/// <param name="entity">要更新的变量表实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> UpdateAsync(VariableTable entity) => await base.UpdateAsync(_mapper.Map<DbVariableTable>(entity));
/// <summary>
/// 异步删除变量表。
/// </summary>
/// <param name="entity">要删除的变量表实体。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteAsync(VariableTable entity) => await base.DeleteAsync(_mapper.Map<DbVariableTable>(entity));
/// <summary>
/// 异步根据ID删除变量表。
/// </summary>
/// <param name="id">要删除变量表的唯一标识符。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteByIdAsync(int id)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = await Db.Deleteable(new VariableTable() { Id = id })
var result = await Db.Deleteable(new DbVariableTable() { Id = id })
.ExecuteCommandAsync();
stopwatch.Stop();
NlogHelper.Info($"Delete {typeof(DbMenu)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
NlogHelper.Info($"Delete {typeof(DbVariableTable)},ID={id},耗时：{stopwatch.ElapsedMilliseconds}ms");
return result;
}
/// <summary>
/// 异步获取指定数量的变量表。
/// </summary>
/// <param name="number">要获取的变量表数量。</param>
/// <returns>包含指定数量变量表实体的列表。</returns>
public new async Task<List<VariableTable>> TakeAsync(int number)
{
var dbList = await base.TakeAsync(number);
@@ -64,6 +103,11 @@ public class VariableTableRepository : BaseRepository<DbVariableTable>, IVariabl
}
/// <summary>
/// 异步根据设备ID删除所有关联的变量表。
/// </summary>
/// <param name="deviceId">设备的唯一标识符。</param>
/// <returns>受影响的行数。</returns>
public async Task<int> DeleteByDeviceIdAsync(int deviceId)
{
var stopwatch = new Stopwatch();