lingyun/NetAdmin
Template
7
0
Fork 0
mirror of https://github.com/nsnail/NetAdmin.git synced 2025-06-21 03:08:16 +08:00
Code Issues 1 Packages Projects Releases Wiki Activity

feat: ✨ 基础模块

Browse Source 
注册登录
用户管理
角色管理
部门管理
消息管理
接口管理
菜单管理
字典管理
缓存管理
请求日志
系统设置
版本信息
代码生成
This commit is contained in:
tk
2023-11-17 18:54:31 +08:00
parent 18b4d7547a
commit d26e4c77cc
755 changed files with 30416 additions and 42743 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
src/backend/NetAdmin.SysComponent.Application/Services/Sys/ApiService.cs
View File

@ -8,107 +8,61 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IApiService" />
public sealed class ApiService : RepositoryService<Sys_Api, IApiService>, IApiService
public sealed class ApiService(DefaultRepository<Sys_Api> rpo //
, XmlCommentReader xmlCommentReader //
, IActionDescriptorCollectionProvider actionDescriptorCollectionProvider) //
: RepositoryService<Sys_Api, IApiService>(rpo), IApiService
{
private readonly IActionDescriptorCollectionProvider _actionDescriptorCollectionProvider;
private readonly XmlCommentReader _xmlCommentReader;
/// <summary>
/// Initializes a new instance of the <see cref="ApiService" /> class.
/// </summary>
public ApiService(Repository<Sys_Api> rpo, XmlCommentReader xmlCommentReader
, IActionDescriptorCollectionProvider actionDescriptorCollectionProvider) //
: base(rpo)
{
_xmlCommentReader = xmlCommentReader;
_actionDescriptorCollectionProvider = actionDescriptorCollectionProvider;
}
/// <summary>
/// 批量删除接口
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
throw new NotImplementedException();
}
/// <summary>
/// 创建接口
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<QueryApiRsp> CreateAsync(CreateApiReq req)
{
throw new NotImplementedException();
}
/// <summary>
/// 删除接口
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
throw new NotImplementedException();
}
/// <summary>
/// 判断接口是否存在
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryApiReq> req)
{
throw new NotImplementedException();
}
/// <summary>
/// 获取单个接口
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<QueryApiRsp> GetAsync(QueryApiReq req)
{
throw new NotImplementedException();
}
/// <summary>
/// 分页查询接口
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<PagedQueryRsp<QueryApiRsp>> PagedQueryAsync(PagedQueryReq<QueryApiReq> req)
{
throw new NotImplementedException();
}
/// <summary>
/// 查询接口
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryApiRsp>> QueryAsync(QueryReq<QueryApiReq> req)
{
var ret = await Rpo.Select.WhereDynamicFilter(req.DynamicFilter).WhereDynamic(req.Filter).ToTreeListAsync();
return ret.Adapt<IEnumerable<QueryApiRsp>>();
}
/// <summary>
/// 反射接口列表
/// </summary>
/// <inheritdoc />
public IEnumerable<QueryApiRsp> ReflectionList(bool excludeAnonymous = true)
{
var regex = new Regex(@"\.(\w+)$", RegexOptions.Compiled);
QueryApiRsp SelectQueryApiRsp(IGrouping<TypeInfo, ControllerActionDescriptor> group)
{
var first = group.First()!;
return new QueryApiRsp {
Summary = _xmlCommentReader.GetComments(group.Key)
, Name = first.ControllerName
, Id = Regex.Replace( //
first.AttributeRouteInfo!.Template!, $"/{first.ActionName}$", string.Empty)
, Children = GetChildren(group)
, Namespace = regex.Match(group.Key.Namespace!).Groups[1].Value.ToLowerInvariant()
};
}
var actionDescriptors //
= _actionDescriptorCollectionProvider.ActionDescriptors.Items.Cast<ControllerActionDescriptor>();
= actionDescriptorCollectionProvider.ActionDescriptors.Items.Cast<ControllerActionDescriptor>();
if (excludeAnonymous) {
actionDescriptors = actionDescriptors.Where(x => x.EndpointMetadata.All(y => y is AllowAnonymousAttribute));
@ -118,11 +72,22 @@ public sealed class ApiService : RepositoryService<Sys_Api, IApiService>, IApiSe
= actionDescriptors.GroupBy(x => x.ControllerTypeInfo);
return actionGroup.Select(SelectQueryApiRsp);
QueryApiRsp SelectQueryApiRsp(IGrouping<TypeInfo, ControllerActionDescriptor> group)
{
var first = group.First()!;
return new QueryApiRsp {
Summary = xmlCommentReader.GetComments(group.Key)
, Name = first.ControllerName
, Id = Regex.Replace( //
first.AttributeRouteInfo!.Template!, $"/{first.ActionName}$", string.Empty)
, Children = GetChildren(group)
, Namespace = regex.Match(group.Key.Namespace!).Groups[1].Value.ToLowerInvariant()
};
}
}
/// <summary>
/// 同步接口
/// </summary>
/// <inheritdoc />
public async Task SyncAsync()
{
_ = await Rpo.DeleteAsync(_ => true);
@ -136,20 +101,23 @@ public sealed class ApiService : RepositoryService<Sys_Api, IApiService>, IApiSe
}
}
/// <summary>
/// 更新接口
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<NopReq> UpdateAsync(NopReq req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
protected override Task<Sys_Api> UpdateForSqliteAsync(Sys_Api req)
{
throw new NotImplementedException();
}
private IEnumerable<QueryApiRsp> GetChildren(IEnumerable<ControllerActionDescriptor> actionDescriptors)
{
return actionDescriptors //
.Select(x => new QueryApiRsp {
Summary = _xmlCommentReader.GetComments(x.MethodInfo)
Summary = xmlCommentReader.GetComments(x.MethodInfo)
, Name = x.ActionName
, Id = x.AttributeRouteInfo!.Template
, Method = x.ActionConstraints?.OfType<HttpMethodActionConstraint>()

25
src/backend/NetAdmin.SysComponent.Application/Services/Sys/CacheService.cs
View File

@ -7,32 +7,21 @@ using StackExchange.Redis;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="ICacheService" />
public sealed class CacheService : ServiceBase<ICacheService>, ICacheService
public sealed class CacheService(IConnectionMultiplexer connectionMultiplexer) //
: ServiceBase<ICacheService>, ICacheService
{
private readonly IConnectionMultiplexer _connectionMultiplexer;
/// <summary>
/// Initializes a new instance of the <see cref="CacheService" /> class.
/// </summary>
public CacheService(IConnectionMultiplexer connectionMultiplexer)
{
_connectionMultiplexer = connectionMultiplexer;
}
/// <summary>
/// 缓存统计
/// </summary>
/// <inheritdoc />
public Task<CacheStatisticsRsp> CacheStatisticsAsync()
{
var database = _connectionMultiplexer.GetDatabase();
var database = connectionMultiplexer.GetDatabase();
return Task.FromResult(
new CacheStatisticsRsp((string)database.Execute("info")) { DbSize = (long)database.Execute("dbSize") });
}
/// <inheritdoc />
public PagedQueryRsp<GetAllEntriesRsp> GetAllEntries(PagedQueryReq<GetAllEntriesReq> req)
public Task<PagedQueryRsp<GetAllEntriesRsp>> GetAllEntriesAsync(PagedQueryReq<GetAllEntriesReq> req)
{
var database = _connectionMultiplexer.GetDatabase((int?)req.Filter?.DbIndex ?? 0);
var database = connectionMultiplexer.GetDatabase((int?)req.Filter?.DbIndex ?? 0);
var redisResults
= (RedisResult[])database.Execute("scan", (req.Page - 1) * req.PageSize, "count", req.PageSize);
@ -44,6 +33,6 @@ public sealed class CacheService : ServiceBase<ICacheService>, ICacheService
.ToList()
.ConvertAll(x => x.Adapt<GetAllEntriesRsp>());
return new PagedQueryRsp<GetAllEntriesRsp>(req.Page, req.PageSize, 10000, list);
return Task.FromResult(new PagedQueryRsp<GetAllEntriesRsp>(req.Page, req.PageSize, 10000, list));
}
}

8
src/backend/NetAdmin.SysComponent.Application/Services/Sys/CaptchaService.cs
View File

@ -17,9 +17,7 @@ public sealed class CaptchaService : ServiceBase<ICaptchaService>, ICaptchaServi
/// </summary>
public CaptchaService() { }
/// <summary>
/// 获取人机校验图
/// </summary>
/// <inheritdoc />
public async Task<GetCaptchaRsp> GetCaptchaImageAsync()
{
var (backgroundImage, sliderImage, offsetSaw) = await CaptchaImageHelper.CreateSawSliderImageAsync(
@ -35,9 +33,7 @@ public sealed class CaptchaService : ServiceBase<ICaptchaService>, ICaptchaServi
};
}
/// <summary>
/// 完成人机校验
/// </summary>
/// <inheritdoc />
public Task<bool> VerifyCaptchaAsync(VerifyCaptchaReq req)
{
if (req.SawOffsetX == null) {

83
src/backend/NetAdmin.SysComponent.Application/Services/Sys/ConfigService.cs
View File

@ -9,17 +9,10 @@ using DataType = FreeSql.DataType;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IConfigService" />
public sealed class ConfigService : RepositoryService<Sys_Config, IConfigService>, IConfigService
public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
: RepositoryService<Sys_Config, IConfigService>(rpo), IConfigService
{
/// <summary>
/// Initializes a new instance of the <see cref="ConfigService" /> class.
/// </summary>
public ConfigService(Repository<Sys_Config> rpo) //
: base(rpo) { }
/// <summary>
/// 批量删除配置
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -30,45 +23,33 @@ public sealed class ConfigService : RepositoryService<Sys_Config, IConfigService
return sum;
}
/// <summary>
/// 创建配置
/// </summary>
/// <inheritdoc />
public async Task<QueryConfigRsp> CreateAsync(CreateConfigReq req)
{
var ret = await Rpo.InsertAsync(req);
return ret.Adapt<QueryConfigRsp>();
}
/// <summary>
/// 删除配置
/// </summary>
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <summary>
/// 判断配置是否存在
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryConfigReq> req)
{
throw new NotImplementedException();
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个配置
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public async Task<QueryConfigRsp> GetAsync(QueryConfigReq req)
{
var ret = await QueryInternal(new QueryReq<QueryConfigReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryConfigRsp>();
}
/// <summary>
/// 获取最新有效配置
/// </summary>
/// <inheritdoc />
public async Task<QueryConfigRsp> GetLatestConfigAsync()
{
var ret = await QueryAsync(
@ -76,9 +57,7 @@ public sealed class ConfigService : RepositoryService<Sys_Config, IConfigService
return ret.FirstOrDefault();
}
/// <summary>
/// 分页查询配置
/// </summary>
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryConfigRsp>> PagedQueryAsync(PagedQueryReq<QueryConfigReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
@ -87,46 +66,44 @@ public sealed class ConfigService : RepositoryService<Sys_Config, IConfigService
, list.Adapt<IEnumerable<QueryConfigRsp>>());
}
/// <summary>
/// 查询配置
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryConfigRsp>> QueryAsync(QueryReq<QueryConfigReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
return ret.Adapt<IEnumerable<QueryConfigRsp>>();
}
/// <summary>
/// 更新配置
/// </summary>
/// <inheritdoc />
public async Task<QueryConfigRsp> UpdateAsync(UpdateConfigReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req);
return await UpdateForSqliteAsync(req) as QueryConfigRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
return ret.FirstOrDefault()?.Adapt<QueryConfigRsp>();
}
private ISelect<Sys_Config> QueryInternal(QueryReq<QueryConfigReq> req)
{
return Rpo.Select.Include(a => a.UserRegisterDept)
.Include(a => a.UserRegisterRole)
.WhereDynamicFilter(req.DynamicFilter)
.WhereIf( //
req.Filter?.Enabled.HasValue ?? false, a => a.Enabled == req.Filter.Enabled.Value)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending)
.OrderByDescending(a => a.Id);
}
/// <summary>
/// 非sqlite数据库请删掉
/// </summary>
private async Task<QueryConfigRsp> UpdateForSqliteAsync(Sys_Config req)
/// <inheritdoc />
protected override async Task<Sys_Config> UpdateForSqliteAsync(Sys_Config req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QueryConfigReq { Id = req.Id });
}
private ISelect<Sys_Config> QueryInternal(QueryReq<QueryConfigReq> req)
{
var ret = Rpo.Select.Include(a => a.UserRegisterDept)
.Include(a => a.UserRegisterRole)
.WhereDynamicFilter(req.DynamicFilter)
.WhereIf( //
req.Filter?.Enabled.HasValue ?? false, a => a.Enabled == req.Filter.Enabled.Value)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
}

16
src/backend/NetAdmin.SysComponent.Application/Services/Sys/ConstantService.cs
View File

@ -6,9 +6,7 @@ namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IConstantService" />
public sealed class ConstantService : ServiceBase<IConstantService>, IConstantService
{
/// <summary>
/// 获得常量字符串
/// </summary>
/// <inheritdoc />
public IDictionary<string, string> GetCharsDic()
{
return typeof(Chars).GetFields(BindingFlags.Public | BindingFlags.Static)
@ -17,9 +15,7 @@ public sealed class ConstantService : ServiceBase<IConstantService>, IConstantSe
x => x.Name, x => x.GetValue(null)?.ToString());
}
/// <summary>
/// 获得公共枚举值
/// </summary>
/// <inheritdoc />
public IDictionary<string, Dictionary<string, string[]>> GetEnums()
{
return App.EffectiveTypes.Where(x => x.IsEnum && x.GetCustomAttribute<ExportAttribute>(false) != null)
@ -35,9 +31,7 @@ public sealed class ConstantService : ServiceBase<IConstantService>, IConstantSe
}));
}
/// <summary>
/// 获得本地化字符串
/// </summary>
/// <inheritdoc />
public IDictionary<string, string> GetLocalizedStrings()
{
return typeof(Ln).GetProperties(BindingFlags.Public | BindingFlags.Static)
@ -45,9 +39,7 @@ public sealed class ConstantService : ServiceBase<IConstantService>, IConstantSe
.ToImmutableSortedDictionary(x => x.Name, x => x.GetValue(null)?.ToString());
}
/// <summary>
/// 获得数字常量表
/// </summary>
/// <inheritdoc />
public IDictionary<string, long> GetNumbersDic()
{
return typeof(Numbers).GetFields(BindingFlags.Public | BindingFlags.Static)

9
src/backend/NetAdmin.SysComponent.Application/Services/Sys/Dependency/ISiteMsgDeptService.cs Normal file
View File

@ -0,0 +1,9 @@
using NetAdmin.Application.Services;
using NetAdmin.SysComponent.Application.Modules.Sys;
namespace NetAdmin.SysComponent.Application.Services.Sys.Dependency;
/// <summary>
/// 站内信-部门映射服务
/// </summary>
public interface ISiteMsgDeptService : IService, ISiteMsgDeptModule { }

9
src/backend/NetAdmin.SysComponent.Application/Services/Sys/Dependency/ISiteMsgFlagService.cs Normal file
View File

@ -0,0 +1,9 @@
using NetAdmin.Application.Services;
using NetAdmin.SysComponent.Application.Modules.Sys;
namespace NetAdmin.SysComponent.Application.Services.Sys.Dependency;
/// <summary>
/// 站内信标记服务
/// </summary>
public interface ISiteMsgFlagService : IService, ISiteMsgFlagModule { }

9
src/backend/NetAdmin.SysComponent.Application/Services/Sys/Dependency/ISiteMsgRoleService.cs Normal file
View File

@ -0,0 +1,9 @@
using NetAdmin.Application.Services;
using NetAdmin.SysComponent.Application.Modules.Sys;
namespace NetAdmin.SysComponent.Application.Services.Sys.Dependency;
/// <summary>
/// 站内信-角色映射服务
/// </summary>
public interface ISiteMsgRoleService : IService, ISiteMsgRoleModule { }

9
src/backend/NetAdmin.SysComponent.Application/Services/Sys/Dependency/ISiteMsgService.cs Normal file
View File

@ -0,0 +1,9 @@
using NetAdmin.Application.Services;
using NetAdmin.SysComponent.Application.Modules.Sys;
namespace NetAdmin.SysComponent.Application.Services.Sys.Dependency;
/// <summary>
/// 站内信服务
/// </summary>
public interface ISiteMsgService : IService, ISiteMsgModule { }

9
src/backend/NetAdmin.SysComponent.Application/Services/Sys/Dependency/ISiteMsgUserService.cs Normal file
View File

@ -0,0 +1,9 @@
using NetAdmin.Application.Services;
using NetAdmin.SysComponent.Application.Modules.Sys;
namespace NetAdmin.SysComponent.Application.Services.Sys.Dependency;
/// <summary>
/// 站内信-用户映射服务
/// </summary>
public interface ISiteMsgUserService : IService, ISiteMsgUserModule { }

61
src/backend/NetAdmin.SysComponent.Application/Services/Sys/DeptService.cs
View File

@ -8,17 +8,10 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IDeptService" />
public sealed class DeptService : RepositoryService<Sys_Dept, IDeptService>, IDeptService
public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
: RepositoryService<Sys_Dept, IDeptService>(rpo), IDeptService
{
/// <summary>
/// Initializes a new instance of the <see cref="DeptService" /> class.
/// </summary>
public DeptService(Repository<Sys_Dept> rpo) //
: base(rpo) { }
/// <summary>
/// 批量删除部门
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -29,9 +22,7 @@ public sealed class DeptService : RepositoryService<Sys_Dept, IDeptService>, IDe
return sum;
}
/// <summary>
/// 创建部门
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">Parent_department_does_not_exist</exception>
public async Task<QueryDeptRsp> CreateAsync(CreateDeptReq req)
{
@ -44,9 +35,7 @@ public sealed class DeptService : RepositoryService<Sys_Dept, IDeptService>, IDe
return ret.Adapt<QueryDeptRsp>();
}
/// <summary>
/// 删除部门
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">该部门下存在用户</exception>
/// <exception cref="NetAdminInvalidOperationException">该部门下存在子部门</exception>
public async Task<int> DeleteAsync(DelReq req)
@ -64,44 +53,32 @@ public sealed class DeptService : RepositoryService<Sys_Dept, IDeptService>, IDe
return await Rpo.DeleteAsync(x => x.Id == req.Id);
}
/// <summary>
/// 判断部门是否存在
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryDeptReq> req)
{
throw new NotImplementedException();
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个部门
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
public Task<QueryDeptRsp> GetAsync(QueryDeptReq req)
/// <inheritdoc />
public async Task<QueryDeptRsp> GetAsync(QueryDeptReq req)
{
throw new NotImplementedException();
var ret = await QueryInternal(new QueryReq<QueryDeptReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryDeptRsp>();
}
/// <summary>
/// 分页查询部门
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<PagedQueryRsp<QueryDeptRsp>> PagedQueryAsync(PagedQueryReq<QueryDeptReq> req)
{
throw new NotImplementedException();
}
/// <summary>
/// 查询部门
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryDeptRsp>> QueryAsync(QueryReq<QueryDeptReq> req)
{
return (await QueryInternal(req).ToTreeListAsync()).Adapt<IEnumerable<QueryDeptRsp>>();
}
/// <summary>
/// 更新部门
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryDeptRsp> UpdateAsync(UpdateDeptReq req)
{
@ -112,14 +89,20 @@ public sealed class DeptService : RepositoryService<Sys_Dept, IDeptService>, IDe
.Adapt<QueryDeptRsp>();
}
/// <inheritdoc />
protected override Task<Sys_Dept> UpdateForSqliteAsync(Sys_Dept req)
{
throw new NotImplementedException();
}
private ISelect<Sys_Dept> QueryInternal(QueryReq<QueryDeptReq> req, bool asTreeCte = false)
{
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.WhereIf( //
req.Keywords?.Length > 0
, a => a.Name.Contains(req.Keywords) || a.Summary.Contains(req.Keywords) ||
a.Id == req.Keywords.Int64Try(0));
, a => a.Id == req.Keywords.Int64Try(0) || a.Name.Contains(req.Keywords) ||
a.Summary.Contains(req.Keywords));
if (asTreeCte) {
ret = ret.AsTreeCte();
}

57
src/backend/NetAdmin.SysComponent.Application/Services/Sys/DevService.cs
View File

@ -6,7 +6,7 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IDevService" />
public sealed class DevService : ServiceBase<DevService>, IDevService
public sealed class DevService(IApiService apiService) : ServiceBase<DevService>, IDevService
{
private const string _REPLACE_TO_EMPTY = "//~";
@ -16,19 +16,10 @@ public sealed class DevService : ServiceBase<DevService>, IDevService
private static readonly string[] _projectDirs
= Directory.GetDirectories(Path.Combine(Environment.CurrentDirectory, "../"));
private readonly IApiService _apiService;
private static readonly Regex _regex = new(@"\.(\w)");
private static readonly Regex _regex2 = new("([a-zA-Z]+):");
/// <summary>
/// Initializes a new instance of the <see cref="DevService" /> class.
/// </summary>
public DevService(IApiService apiService)
{
_apiService = apiService;
}
/// <summary>
/// 生成后端代码
/// </summary>
/// <inheritdoc />
public async Task GenerateCsCodeAsync(GenerateCsCodeReq req)
{
// 模块类型（Sys、Biz、等）
@ -106,9 +97,7 @@ public sealed class DevService : ServiceBase<DevService>, IDevService
, Path.Combine(entityDir, $"{moduleType[..3]}_{req.ModuleName}.cs"));
}
/// <summary>
/// 生成图标代码
/// </summary>
/// <inheritdoc />
public async Task GenerateIconCodeAsync(GenerateIconCodeReq req)
{
var tplSvg = await File.ReadAllTextAsync(
@ -138,7 +127,7 @@ public sealed class DevService : ServiceBase<DevService>, IDevService
var iconSelectFile = Path.Combine(_clientProjectPath, "src", "config", "iconSelect.js");
var iconSelectContent = await File.ReadAllTextAsync(iconSelectFile);
iconSelectContent = iconSelectContent.Replace("export default", "exportDefault:").Replace("'", "\"");
iconSelectContent = Regex.Replace(iconSelectContent, "([a-zA-Z]+):", "\"$1\":");
iconSelectContent = _regex2.Replace(iconSelectContent, "\"$1\":");
iconSelectContent = "{" + iconSelectContent + "}";
var iconExportJsInfo = iconSelectContent.ToObject<IconExportJsInfo>();
iconExportJsInfo.ExportDefault.Icons.Last().Icons.Add($"sc-icon-{req.IconName.ToLowerInvariant()}");
@ -147,29 +136,14 @@ public sealed class DevService : ServiceBase<DevService>, IDevService
await File.WriteAllTextAsync(iconSelectFile, newContent);
}
/// <summary>
/// 生成接口代码
/// </summary>
/// <inheritdoc />
public async Task GenerateJsCodeAsync()
{
// 模板文件
var tplOuter = await File.ReadAllTextAsync(Path.Combine(_clientProjectPath, "src", "api", "tpl", "outer.js"));
var tplInner = await File.ReadAllTextAsync(Path.Combine(_clientProjectPath, "src", "api", "tpl", "inner.js"));
IEnumerable<string> Select(QueryApiRsp item)
{
return item.Children.Select(x => tplInner.Replace("$actionDesc$", x.Summary)
.Replace( //
"$actionName$"
, Regex.Replace(x.Name, @"\.(\w)"
, y => y.Groups[1].Value.ToUpperInvariant()))
.Replace("$actionPath$", x.Id)
.Replace( //
"$actionMethod$", x.Method?.ToLowerInvariant())
.Replace(_REPLACE_TO_EMPTY, string.Empty)); //
}
foreach (var item in _apiService.ReflectionList(false)) {
foreach (var item in apiService.ReflectionList(false)) {
var dir = Path.Combine(_clientProjectPath, "src", "api", item.Namespace);
if (!Directory.Exists(dir)) {
_ = Directory.CreateDirectory(dir);
@ -186,13 +160,26 @@ public sealed class DevService : ServiceBase<DevService>, IDevService
await File.WriteAllTextAsync(file, content);
}
IEnumerable<string> Select(QueryApiRsp item)
{
return item.Children.Select(x => tplInner.Replace("$actionDesc$", x.Summary)
.Replace( //
"$actionName$"
, _regex.Replace(
x.Name, y => y.Groups[1].Value.ToUpperInvariant()))
.Replace("$actionPath$", x.Id)
.Replace( //
"$actionMethod$", x.Method?.ToLowerInvariant())
.Replace(_REPLACE_TO_EMPTY, string.Empty)); //
}
}
private static void CreateDir(params string[] dirs)
{
foreach (var dir in dirs) {
if (!Directory.Exists(dir)) {
_ = Directory.CreateDirectory(dir);
_ = Directory.CreateDirectory(dir!);
}
}
}

74
src/backend/NetAdmin.SysComponent.Application/Services/Sys/DicCatalogService.cs
View File

@ -8,17 +8,10 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IDicCatalogService" />
public sealed class DicCatalogService : RepositoryService<Sys_DicCatalog, IDicCatalogService>, IDicCatalogService
public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
: RepositoryService<Sys_DicCatalog, IDicCatalogService>(rpo), IDicCatalogService
{
/// <summary>
/// Initializes a new instance of the <see cref="DicCatalogService" /> class.
/// </summary>
public DicCatalogService(Repository<Sys_DicCatalog> rpo) //
: base(rpo) { }
/// <summary>
/// 批量删除字典目录
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -29,13 +22,11 @@ public sealed class DicCatalogService : RepositoryService<Sys_DicCatalog, IDicCa
return sum;
}
/// <summary>
/// 创建字典目录
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">The_parent_node_does_not_exist</exception>
public async Task<QueryDicCatalogRsp> CreateAsync(CreateDicCatalogReq req)
{
if (req.ParentId != 0 && !await Rpo.Select.Where(a => a.Id == req.ParentId).ForUpdate().AnyAsync()) {
if (req.ParentId != 0 && !await Rpo.Where(a => a.Id == req.ParentId).ForUpdate().AnyAsync()) {
throw new NetAdminInvalidOperationException(Ln.父节点不存在);
}
@ -43,36 +34,27 @@ public sealed class DicCatalogService : RepositoryService<Sys_DicCatalog, IDicCa
return ret.Adapt<QueryDicCatalogRsp>();
}
/// <summary>
/// 删除字典目录
/// </summary>
/// <inheritdoc />
public async Task<int> DeleteAsync(DelReq req)
{
var ret = await Rpo.DeleteCascadeByDatabaseAsync(a => a.Id == req.Id);
return ret.Count;
}
/// <summary>
/// 判断字典目录是否存在
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryDicCatalogReq> req)
{
throw new NotImplementedException();
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个字典目录
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
public Task<QueryDicCatalogRsp> GetAsync(QueryDicCatalogReq req)
/// <inheritdoc />
public async Task<QueryDicCatalogRsp> GetAsync(QueryDicCatalogReq req)
{
throw new NotImplementedException();
var ret = await QueryInternal(new QueryReq<QueryDicCatalogReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryDicCatalogRsp>();
}
/// <summary>
/// 分页查询字典目录
/// </summary>
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryDicCatalogRsp>> PagedQueryAsync(PagedQueryReq<QueryDicCatalogReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
@ -81,23 +63,19 @@ public sealed class DicCatalogService : RepositoryService<Sys_DicCatalog, IDicCa
, list.Adapt<IEnumerable<QueryDicCatalogRsp>>());
}
/// <summary>
/// 查询字典目录
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryDicCatalogRsp>> QueryAsync(QueryReq<QueryDicCatalogReq> req)
{
var ret = await QueryInternal(req).ToTreeListAsync();
return ret.Adapt<IEnumerable<QueryDicCatalogRsp>>();
}
/// <summary>
/// 更新字典目录
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">The_parent_node_does_not_exist</exception>
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryDicCatalogRsp> UpdateAsync(UpdateDicCatalogReq req)
{
if (req.ParentId != 0 && !await Rpo.Select.Where(a => a.Id == req.ParentId).ForUpdate().AnyAsync()) {
if (req.ParentId != 0 && !await Rpo.Where(a => a.Id == req.ParentId).ForUpdate().AnyAsync()) {
throw new NetAdminInvalidOperationException(Ln.父节点不存在);
}
@ -105,15 +83,25 @@ public sealed class DicCatalogService : RepositoryService<Sys_DicCatalog, IDicCa
throw new NetAdminUnexpectedException();
}
var ret = await Rpo.Select.Where(a => a.Id == req.Id).ToOneAsync();
var ret = await Rpo.Where(a => a.Id == req.Id).ToOneAsync();
return ret.Adapt<QueryDicCatalogRsp>();
}
/// <inheritdoc />
protected override Task<Sys_DicCatalog> UpdateForSqliteAsync(Sys_DicCatalog req)
{
throw new NotImplementedException();
}
private ISelect<Sys_DicCatalog> QueryInternal(QueryReq<QueryDicCatalogReq> req)
{
return Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending)
.OrderByDescending(a => a.Id);
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
}

58
src/backend/NetAdmin.SysComponent.Application/Services/Sys/DicContentService.cs
View File

@ -8,17 +8,10 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IDicContentService" />
public sealed class DicContentService : RepositoryService<Sys_DicContent, IDicContentService>, IDicContentService
public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
: RepositoryService<Sys_DicContent, IDicContentService>(rpo), IDicContentService
{
/// <summary>
/// Initializes a new instance of the <see cref="DicContentService" /> class.
/// </summary>
public DicContentService(Repository<Sys_DicContent> rpo) //
: base(rpo) { }
/// <summary>
/// 批量删除字典内容
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -29,9 +22,7 @@ public sealed class DicContentService : RepositoryService<Sys_DicContent, IDicCo
return sum;
}
/// <summary>
/// 创建字典内容
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">Dictionary_directory_does_not_exist</exception>
public async Task<QueryDicContentRsp> CreateAsync(CreateDicContentReq req)
{
@ -43,35 +34,26 @@ public sealed class DicContentService : RepositoryService<Sys_DicContent, IDicCo
return ret.Adapt<QueryDicContentRsp>();
}
/// <summary>
/// 删除字典内容
/// </summary>
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <summary>
/// 判断字典是否存在
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryDicContentReq> req)
{
throw new NotImplementedException();
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个字典
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
public Task<QueryDicContentRsp> GetAsync(QueryDicContentReq req)
/// <inheritdoc />
public async Task<QueryDicContentRsp> GetAsync(QueryDicContentReq req)
{
throw new NotImplementedException();
var ret = await QueryInternal(new QueryReq<QueryDicContentReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryDicContentRsp>();
}
/// <summary>
/// 分页查询字典内容
/// </summary>
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryDicContentRsp>> PagedQueryAsync(PagedQueryReq<QueryDicContentReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
@ -80,18 +62,14 @@ public sealed class DicContentService : RepositoryService<Sys_DicContent, IDicCo
, list.Adapt<IEnumerable<QueryDicContentRsp>>());
}
/// <summary>
/// 查询字典内容
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryDicContentRsp>> QueryAsync(QueryReq<QueryDicContentReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
return ret.Adapt<IEnumerable<QueryDicContentRsp>>();
}
/// <summary>
/// 更新字典内容
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">Dictionary_directory_does_not_exist</exception>
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryDicContentRsp> UpdateAsync(UpdateDicContentReq req)
@ -104,10 +82,16 @@ public sealed class DicContentService : RepositoryService<Sys_DicContent, IDicCo
throw new NetAdminUnexpectedException();
}
var ret = await Rpo.Select.Where(a => a.Id == req.Id).ToOneAsync();
var ret = await Rpo.Where(a => a.Id == req.Id).ToOneAsync();
return ret.Adapt<QueryDicContentRsp>();
}
/// <inheritdoc />
protected override Task<Sys_DicContent> UpdateForSqliteAsync(Sys_DicContent req)
{
throw new NotImplementedException();
}
private ISelect<Sys_DicContent> QueryInternal(QueryReq<QueryDicContentReq> req)
{
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)

99
src/backend/NetAdmin.SysComponent.Application/Services/Sys/DicService.cs
View File

@ -7,113 +7,90 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IDicService" />
public sealed class DicService : ServiceBase<IDicService>, IDicService
public sealed class DicService(IDicCatalogService catalogService, IDicContentService contentService) //
: ServiceBase<IDicService>, IDicService
{
private readonly IDicCatalogService _catalogService;
private readonly IDicContentService _contentService;
/// <summary>
/// Initializes a new instance of the <see cref="DicService" /> class.
/// </summary>
public DicService(IDicCatalogService catalogService, IDicContentService contentService)
{
_catalogService = catalogService;
_contentService = contentService;
}
/// <summary>
/// 批量删除字典目录
/// </summary>
/// <inheritdoc />
public Task<int> BulkDeleteCatalogAsync(BulkReq<DelReq> req)
{
return _catalogService.BulkDeleteAsync(req);
return catalogService.BulkDeleteAsync(req);
}
/// <summary>
/// 批量删除字典内容
/// </summary>
/// <inheritdoc />
public Task<int> BulkDeleteContentAsync(BulkReq<DelReq> req)
{
return _contentService.BulkDeleteAsync(req);
return contentService.BulkDeleteAsync(req);
}
/// <summary>
/// 创建字典目录
/// </summary>
/// <inheritdoc />
public Task<QueryDicCatalogRsp> CreateCatalogAsync(CreateDicCatalogReq req)
{
return _catalogService.CreateAsync(req);
return catalogService.CreateAsync(req);
}
/// <summary>
/// 创建字典内容
/// </summary>
/// <inheritdoc />
public Task<QueryDicContentRsp> CreateContentAsync(CreateDicContentReq req)
{
return _contentService.CreateAsync(req);
return contentService.CreateAsync(req);
}
/// <summary>
/// 删除字典目录
/// </summary>
/// <inheritdoc />
public Task<int> DeleteCatalogAsync(DelReq req)
{
return _catalogService.DeleteAsync(req);
return catalogService.DeleteAsync(req);
}
/// <summary>
/// 删除字典内容
/// </summary>
/// <inheritdoc />
public Task<int> DeleteContentAsync(DelReq req)
{
return _contentService.DeleteAsync(req);
return contentService.DeleteAsync(req);
}
/// <summary>
/// 分页查询字典目录
/// </summary>
/// <inheritdoc />
public Task<QueryDicCatalogRsp> GetCatalogAsync(QueryDicCatalogReq req)
{
return catalogService.GetAsync(req);
}
/// <inheritdoc />
public Task<QueryDicContentRsp> GetContentAsync(QueryDicContentReq req)
{
return contentService.GetAsync(req);
}
/// <inheritdoc />
public Task<PagedQueryRsp<QueryDicCatalogRsp>> PagedQueryCatalogAsync(PagedQueryReq<QueryDicCatalogReq> req)
{
return _catalogService.PagedQueryAsync(req);
return catalogService.PagedQueryAsync(req);
}
/// <summary>
/// 分页查询字典内容
/// </summary>
/// <inheritdoc />
public Task<PagedQueryRsp<QueryDicContentRsp>> PagedQueryContentAsync(PagedQueryReq<QueryDicContentReq> req)
{
return _contentService.PagedQueryAsync(req);
return contentService.PagedQueryAsync(req);
}
/// <summary>
/// 查询字典目录
/// </summary>
/// <inheritdoc />
public Task<IEnumerable<QueryDicCatalogRsp>> QueryCatalogAsync(QueryReq<QueryDicCatalogReq> req)
{
return _catalogService.QueryAsync(req);
return catalogService.QueryAsync(req);
}
/// <summary>
/// 查询字典内容
/// </summary>
/// <inheritdoc />
public Task<IEnumerable<QueryDicContentRsp>> QueryContentAsync(QueryReq<QueryDicContentReq> req)
{
return _contentService.QueryAsync(req);
return contentService.QueryAsync(req);
}
/// <summary>
/// 更新字典目录
/// </summary>
/// <inheritdoc />
public Task<QueryDicCatalogRsp> UpdateCatalogAsync(UpdateDicCatalogReq req)
{
return _catalogService.UpdateAsync(req);
return catalogService.UpdateAsync(req);
}
/// <summary>
/// 更新字典内容
/// </summary>
/// <inheritdoc />
public Task<QueryDicContentRsp> UpdateContentAsync(UpdateDicContentReq req)
{
return _contentService.UpdateAsync(req);
return contentService.UpdateAsync(req);
}
}

29
src/backend/NetAdmin.SysComponent.Application/Services/Sys/FileService.cs
View File

@ -4,23 +4,10 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IFileService" />
public sealed class FileService : ServiceBase<IFileService>, IFileService
public sealed class FileService(IOptions<UploadOptions> uploadOptions, MinioHelper minioHelper) //
: ServiceBase<IFileService>, IFileService
{
private readonly MinioHelper _minioHelper;
private readonly UploadOptions _uploadOptions;
/// <summary>
/// Initializes a new instance of the <see cref="FileService" /> class.
/// </summary>
public FileService(IOptions<UploadOptions> uploadOptions, MinioHelper minioHelper) //
{
_minioHelper = minioHelper;
_uploadOptions = uploadOptions.Value;
}
/// <summary>
/// 文件上传
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">文件不能为空</exception>
/// <exception cref="NetAdminInvalidOperationException">允许上传的文件格式</exception>
/// <exception cref="NetAdminInvalidOperationException">允许的文件大小</exception>
@ -30,18 +17,18 @@ public sealed class FileService : ServiceBase<IFileService>, IFileService
throw new NetAdminInvalidOperationException(Ln.文件不能为空);
}
if (!_uploadOptions.ContentTypes.Contains(file.ContentType)) {
if (!uploadOptions.Value.ContentTypes.Contains(file.ContentType)) {
throw new NetAdminInvalidOperationException(
$"{Ln.允许的文件格式} {string.Join(",", _uploadOptions.ContentTypes)}");
$"{Ln.允许的文件格式} {string.Join(",", uploadOptions.Value.ContentTypes)}");
}
if (file.Length > _uploadOptions.MaxSize) {
throw new NetAdminInvalidOperationException($"{Ln.允许的文件大小} {_uploadOptions.MaxSize}");
if (file.Length > uploadOptions.Value.MaxSize) {
throw new NetAdminInvalidOperationException($"{Ln.允许的文件大小} {uploadOptions.Value.MaxSize}");
}
var fileName = $"{Guid.NewGuid()}{Path.GetExtension(file.FileName)}";
var objectName = $"{UserToken.Id}/{fileName}";
await using var fs = file.OpenReadStream();
return await _minioHelper.UploadAsync(objectName, fs, file.ContentType, file.Length);
return await minioHelper.UploadAsync(objectName, fs, file.ContentType, file.Length);
}
}

83
src/backend/NetAdmin.SysComponent.Application/Services/Sys/MenuService.cs
View File

@ -8,22 +8,10 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IMenuService" />
public sealed class MenuService : RepositoryService<Sys_Menu, IMenuService>, IMenuService
public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService userService) //
: RepositoryService<Sys_Menu, IMenuService>(rpo), IMenuService
{
private readonly IUserService _userService;
/// <summary>
/// Initializes a new instance of the <see cref="MenuService" /> class.
/// </summary>
public MenuService(Repository<Sys_Menu> rpo, IUserService userService) //
: base(rpo)
{
_userService = userService;
}
/// <summary>
/// 批量删除菜单
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -34,62 +22,46 @@ public sealed class MenuService : RepositoryService<Sys_Menu, IMenuService>, IMe
return sum;
}
/// <summary>
/// 创建菜单
/// </summary>
/// <inheritdoc />
public async Task<QueryMenuRsp> CreateAsync(CreateMenuReq req)
{
var ret = await Rpo.InsertAsync(req);
return ret.Adapt<QueryMenuRsp>();
}
/// <summary>
/// 删除菜单
/// </summary>
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <summary>
/// 判断菜单是否存在
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryMenuReq> req)
{
throw new NotImplementedException();
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个菜单
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
public Task<QueryMenuRsp> GetAsync(QueryMenuReq req)
/// <inheritdoc />
public async Task<QueryMenuRsp> GetAsync(QueryMenuReq req)
{
throw new NotImplementedException();
var ret = await QueryInternal(new QueryReq<QueryMenuReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryMenuRsp>();
}
/// <summary>
/// 分页查询菜单
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<PagedQueryRsp<QueryMenuRsp>> PagedQueryAsync(PagedQueryReq<QueryMenuReq> req)
{
throw new NotImplementedException();
}
/// <summary>
/// 查询菜单
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryMenuRsp>> QueryAsync(QueryReq<QueryMenuReq> req)
{
var ret = await QueryInternal(req).ToTreeListAsync();
return ret.Adapt<IEnumerable<QueryMenuRsp>>();
}
/// <summary>
/// 更新菜单
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryMenuRsp> UpdateAsync(UpdateMenuReq req)
{
@ -97,16 +69,14 @@ public sealed class MenuService : RepositoryService<Sys_Menu, IMenuService>, IMe
throw new NetAdminUnexpectedException();
}
var ret = await Rpo.Select.Where(a => a.Id == req.Id).ToOneAsync();
var ret = await Rpo.Where(a => a.Id == req.Id).ToOneAsync();
return ret.Adapt<QueryMenuRsp>();
}
/// <summary>
/// 当前用户菜单
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryMenuRsp>> UserMenusAsync()
{
var userInfo = await _userService.UserInfoAsync();
var userInfo = await userService.UserInfoAsync();
Task<IEnumerable<QueryMenuRsp>> ret;
var req = new QueryReq<QueryMenuReq>();
@ -120,18 +90,23 @@ public sealed class MenuService : RepositoryService<Sys_Menu, IMenuService>, IMe
ownedMenuIds = new[] { 0L };
}
ret = QueryAsync(req with {
DynamicFilter = new DynamicFilterInfo {
Field = nameof(QueryMenuReq.Id)
, Operator = DynamicFilterOperator.Any
, Value = ownedMenuIds
}
});
var df = new DynamicFilterInfo {
Field = nameof(QueryMenuReq.Id)
, Operator = DynamicFilterOperators.Any
, Value = ownedMenuIds
};
ret = QueryAsync(req with { DynamicFilter = df });
}
return await ret;
}
/// <inheritdoc />
protected override Task<Sys_Menu> UpdateForSqliteAsync(Sys_Menu req)
{
throw new NotImplementedException();
}
private ISelect<Sys_Menu> QueryInternal(QueryReq<QueryMenuReq> req)
{
return Rpo.Select.WhereDynamicFilter(req.DynamicFilter)

58
src/backend/NetAdmin.SysComponent.Application/Services/Sys/RequestLogService.cs
View File

@ -8,17 +8,10 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IRequestLogService" />
public sealed class RequestLogService : RepositoryService<Sys_RequestLog, IRequestLogService>, IRequestLogService
public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
: RepositoryService<Sys_RequestLog, IRequestLogService>(rpo), IRequestLogService
{
/// <summary>
/// Initializes a new instance of the <see cref="RequestLogService" /> class.
/// </summary>
public RequestLogService(Repository<Sys_RequestLog> rpo) //
: base(rpo) { }
/// <summary>
/// 批量删除请求日志
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -29,45 +22,33 @@ public sealed class RequestLogService : RepositoryService<Sys_RequestLog, IReque
return sum;
}
/// <summary>
/// 创建请求日志
/// </summary>
/// <inheritdoc />
public async Task<QueryRequestLogRsp> CreateAsync(CreateRequestLogReq req)
{
var ret = await Rpo.InsertAsync(req);
return ret.Adapt<QueryRequestLogRsp>();
}
/// <summary>
/// 删除请求日志
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
throw new NotImplementedException();
}
/// <summary>
/// 判断请求日志是否存在
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryRequestLogReq> req)
{
throw new NotImplementedException();
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个请求日志
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
public Task<QueryRequestLogRsp> GetAsync(QueryRequestLogReq req)
/// <inheritdoc />
public async Task<QueryRequestLogRsp> GetAsync(QueryRequestLogReq req)
{
throw new NotImplementedException();
var ret = await QueryInternal(new QueryReq<QueryRequestLogReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryRequestLogRsp>();
}
/// <summary>
/// 分页查询请求日志
/// </summary>
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryRequestLogRsp>> PagedQueryAsync(PagedQueryReq<QueryRequestLogReq> req)
{
var list = await QueryInternal(req)
@ -91,24 +72,25 @@ public sealed class RequestLogService : RepositoryService<Sys_RequestLog, IReque
, list.Adapt<IEnumerable<QueryRequestLogRsp>>());
}
/// <summary>
/// 查询请求日志
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryRequestLogRsp>> QueryAsync(QueryReq<QueryRequestLogReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
return ret.Adapt<IEnumerable<QueryRequestLogRsp>>();
}
/// <summary>
/// 更新请求日志
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<NopReq> UpdateAsync(NopReq req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
protected override Task<Sys_RequestLog> UpdateForSqliteAsync(Sys_RequestLog req)
{
throw new NotImplementedException();
}
private ISelect<Sys_RequestLog> QueryInternal(QueryReq<QueryRequestLogReq> req)
{
var ret = Rpo.Select.Include(a => a.Api)

60
src/backend/NetAdmin.SysComponent.Application/Services/Sys/RoleService.cs
View File

@ -8,17 +8,10 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IRoleService" />
public sealed class RoleService : RepositoryService<Sys_Role, IRoleService>, IRoleService
public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
: RepositoryService<Sys_Role, IRoleService>(rpo), IRoleService
{
/// <summary>
/// Initializes a new instance of the <see cref="RoleService" /> class.
/// </summary>
public RoleService(Repository<Sys_Role> rpo) //
: base(rpo) { }
/// <summary>
/// 批量删除角色
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -29,9 +22,7 @@ public sealed class RoleService : RepositoryService<Sys_Role, IRoleService>, IRo
return sum;
}
/// <summary>
/// 创建角色
/// </summary>
/// <inheritdoc />
public async Task<QueryRoleRsp> CreateAsync(CreateRoleReq req)
{
var entity = req.Adapt<Sys_Role>();
@ -45,9 +36,7 @@ public sealed class RoleService : RepositoryService<Sys_Role, IRoleService>, IRo
return entity.Adapt<QueryRoleRsp>();
}
/// <summary>
/// 删除角色
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">Users_exist_under_this_role_and_deletion_is_not_allowed</exception>
public async Task<int> DeleteAsync(DelReq req)
{
@ -56,27 +45,20 @@ public sealed class RoleService : RepositoryService<Sys_Role, IRoleService>, IRo
: await Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <summary>
/// 判断角色是否存在
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryRoleReq> req)
{
throw new NotImplementedException();
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个角色
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
public Task<QueryRoleRsp> GetAsync(QueryRoleReq req)
/// <inheritdoc />
public async Task<QueryRoleRsp> GetAsync(QueryRoleReq req)
{
throw new NotImplementedException();
var ret = await QueryInternal(new QueryReq<QueryRoleReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryRoleRsp>();
}
/// <summary>
/// 分页查询角色
/// </summary>
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryRoleRsp>> PagedQueryAsync(PagedQueryReq<QueryRoleReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
@ -84,18 +66,14 @@ public sealed class RoleService : RepositoryService<Sys_Role, IRoleService>, IRo
return new PagedQueryRsp<QueryRoleRsp>(req.Page, req.PageSize, total, list.Adapt<IEnumerable<QueryRoleRsp>>());
}
/// <summary>
/// 查询角色
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryRoleRsp>> QueryAsync(QueryReq<QueryRoleReq> req)
{
var ret = await QueryInternal(req).ToListAsync();
return ret.Adapt<IEnumerable<QueryRoleRsp>>();
}
/// <summary>
/// 更新角色
/// </summary>
/// <inheritdoc />
public async Task<QueryRoleRsp> UpdateAsync(UpdateRoleReq req)
{
var entity = req.Adapt<Sys_Role>();
@ -107,6 +85,12 @@ public sealed class RoleService : RepositoryService<Sys_Role, IRoleService>, IRo
return (await QueryAsync(new QueryReq<QueryRoleReq> { Filter = new QueryRoleReq { Id = req.Id } })).First();
}
/// <inheritdoc />
protected override Task<Sys_Role> UpdateForSqliteAsync(Sys_Role req)
{
throw new NotImplementedException();
}
private ISelect<Sys_Role> QueryInternal(QueryReq<QueryRoleReq> req)
{
var ret = Rpo.Select.IncludeMany(a => a.Depts.Select(b => new Sys_Dept { Id = b.Id }))
@ -116,8 +100,8 @@ public sealed class RoleService : RepositoryService<Sys_Role, IRoleService>, IRo
.WhereDynamic(req.Filter)
.WhereIf( //
req.Keywords?.Length > 0
, a => a.Name.Contains(req.Keywords) || a.Summary.Contains(req.Keywords) ||
a.Id == req.Keywords.Int64Try(0))
, a => a.Id == req.Keywords.Int64Try(0) || a.Name.Contains(req.Keywords) ||
a.Summary.Contains(req.Keywords))
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Sort), StringComparison.OrdinalIgnoreCase) ?? true) {

98
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgDeptService.cs Normal file
View File

@ -0,0 +1,98 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsgDept;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
using DataType = FreeSql.DataType;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="ISiteMsgDeptService" />
public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) //
: RepositoryService<Sys_SiteMsgDept, ISiteMsgDeptService>(rpo), ISiteMsgDeptService
{
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
}
return sum;
}
/// <inheritdoc />
public async Task<QuerySiteMsgDeptRsp> CreateAsync(CreateSiteMsgDeptReq req)
{
var ret = await Rpo.InsertAsync(req);
return ret.Adapt<QuerySiteMsgDeptRsp>();
}
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QuerySiteMsgDeptReq> req)
{
return QueryInternal(req).AnyAsync();
}
/// <inheritdoc />
public async Task<QuerySiteMsgDeptRsp> GetAsync(QuerySiteMsgDeptReq req)
{
var ret = await QueryInternal(new QueryReq<QuerySiteMsgDeptReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QuerySiteMsgDeptRsp>();
}
/// <inheritdoc />
public async Task<PagedQueryRsp<QuerySiteMsgDeptRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgDeptReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
return new PagedQueryRsp<QuerySiteMsgDeptRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgDeptRsp>>());
}
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgDeptRsp>> QueryAsync(QueryReq<QuerySiteMsgDeptReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
return ret.Adapt<IEnumerable<QuerySiteMsgDeptRsp>>();
}
/// <inheritdoc />
public async Task<QuerySiteMsgDeptRsp> UpdateAsync(UpdateSiteMsgDeptReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QuerySiteMsgDeptRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
return ret.FirstOrDefault()?.Adapt<QuerySiteMsgDeptRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_SiteMsgDept> UpdateForSqliteAsync(Sys_SiteMsgDept req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QuerySiteMsgDeptReq { Id = req.Id });
}
private ISelect<Sys_SiteMsgDept> QueryInternal(QueryReq<QuerySiteMsgDeptReq> req)
{
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
}

102
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgFlagService.cs Normal file
View File

@ -0,0 +1,102 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsgFlag;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
using DataType = FreeSql.DataType;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="ISiteMsgFlagService" />
public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) //
: RepositoryService<Sys_SiteMsgFlag, ISiteMsgFlagService>(rpo), ISiteMsgFlagService
{
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
}
return sum;
}
/// <inheritdoc />
public async Task<QuerySiteMsgFlagRsp> CreateAsync(CreateSiteMsgFlagReq req)
{
var ret = await Rpo.InsertAsync(req);
return ret.Adapt<QuerySiteMsgFlagRsp>();
}
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QuerySiteMsgFlagReq> req)
{
return QueryInternal(req).AnyAsync();
}
/// <inheritdoc />
public async Task<QuerySiteMsgFlagRsp> GetAsync(QuerySiteMsgFlagReq req)
{
var ret = await QueryInternal(new QueryReq<QuerySiteMsgFlagReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QuerySiteMsgFlagRsp>();
}
/// <inheritdoc />
public async Task<PagedQueryRsp<QuerySiteMsgFlagRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgFlagReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
return new PagedQueryRsp<QuerySiteMsgFlagRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgFlagRsp>>());
}
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgFlagRsp>> QueryAsync(QueryReq<QuerySiteMsgFlagReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
return ret.Adapt<IEnumerable<QuerySiteMsgFlagRsp>>();
}
/// <inheritdoc />
public async Task<QuerySiteMsgFlagRsp> UpdateAsync(UpdateSiteMsgFlagReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QuerySiteMsgFlagRsp;
}
var ret = await Rpo.UpdateDiy.Set(a => a.UserSiteMsgStatus == req.UserSiteMsgStatus)
.Where(a => a.UserId == req.UserId && a.SiteMsgId == req.SiteMsgId)
.ExecuteUpdatedAsync();
return ret.FirstOrDefault()?.Adapt<QuerySiteMsgFlagRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_SiteMsgFlag> UpdateForSqliteAsync(Sys_SiteMsgFlag req)
{
return await Rpo.UpdateDiy.Set(a => a.UserSiteMsgStatus == req.UserSiteMsgStatus)
.Where(a => a.UserId == req.UserId && a.SiteMsgId == req.SiteMsgId)
.ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QuerySiteMsgFlagReq { Id = req.Id });
}
private ISelect<Sys_SiteMsgFlag> QueryInternal(QueryReq<QuerySiteMsgFlagReq> req)
{
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
}

98
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgRoleService.cs Normal file
View File

@ -0,0 +1,98 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsgRole;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
using DataType = FreeSql.DataType;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="ISiteMsgRoleService" />
public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) //
: RepositoryService<Sys_SiteMsgRole, ISiteMsgRoleService>(rpo), ISiteMsgRoleService
{
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
}
return sum;
}
/// <inheritdoc />
public async Task<QuerySiteMsgRoleRsp> CreateAsync(CreateSiteMsgRoleReq req)
{
var ret = await Rpo.InsertAsync(req);
return ret.Adapt<QuerySiteMsgRoleRsp>();
}
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QuerySiteMsgRoleReq> req)
{
return QueryInternal(req).AnyAsync();
}
/// <inheritdoc />
public async Task<QuerySiteMsgRoleRsp> GetAsync(QuerySiteMsgRoleReq req)
{
var ret = await QueryInternal(new QueryReq<QuerySiteMsgRoleReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QuerySiteMsgRoleRsp>();
}
/// <inheritdoc />
public async Task<PagedQueryRsp<QuerySiteMsgRoleRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgRoleReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
return new PagedQueryRsp<QuerySiteMsgRoleRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgRoleRsp>>());
}
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgRoleRsp>> QueryAsync(QueryReq<QuerySiteMsgRoleReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
return ret.Adapt<IEnumerable<QuerySiteMsgRoleRsp>>();
}
/// <inheritdoc />
public async Task<QuerySiteMsgRoleRsp> UpdateAsync(UpdateSiteMsgRoleReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QuerySiteMsgRoleRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
return ret.FirstOrDefault()?.Adapt<QuerySiteMsgRoleRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_SiteMsgRole> UpdateForSqliteAsync(Sys_SiteMsgRole req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QuerySiteMsgRoleReq { Id = req.Id });
}
private ISelect<Sys_SiteMsgRole> QueryInternal(QueryReq<QuerySiteMsgRoleReq> req)
{
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
}

280
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgService.cs Normal file
View File

@ -0,0 +1,280 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.Contexts;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsg;
using NetAdmin.Domain.Dto.Sys.SiteMsgFlag;
using NetAdmin.Domain.Dto.Sys.User;
using NetAdmin.Domain.Enums.Sys;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="ISiteMsgService" />
public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUserInfo contextUserInfo
, ISiteMsgFlagService siteMsgFlagService) //
: RepositoryService<Sys_SiteMsg, ISiteMsgService>(rpo), ISiteMsgService
{
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
}
return sum;
}
/// <inheritdoc />
public async Task<QuerySiteMsgRsp> CreateAsync(CreateSiteMsgReq req)
{
await CreateUpdateCheckAsync(req);
// 主表
var entity = req.Adapt<Sys_SiteMsg>();
var dbSiteMsg = await Rpo.InsertAsync(entity);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Roles));
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Users));
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Depts));
var ret = await QueryAsync(
new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = dbSiteMsg.Id } });
return ret.Adapt<QuerySiteMsgRsp>();
}
/// <inheritdoc />
public async Task<int> DeleteAsync(DelReq req)
{
var ret = await Rpo.DeleteCascadeByDatabaseAsync(a => a.Id == req.Id);
return ret.Count;
}
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QuerySiteMsgReq> req)
{
return QueryInternal(req).AnyAsync();
}
/// <inheritdoc />
public async Task<QuerySiteMsgRsp> GetAsync(QuerySiteMsgReq req)
{
var ret = await QueryInternal(new QueryReq<QuerySiteMsgReq> { Filter = req })
.IncludeMany(a => a.Roles)
.IncludeMany(a => a.Users)
.IncludeMany(a => a.Depts)
.ToOneAsync();
return ret.Adapt<QuerySiteMsgRsp>();
}
/// <inheritdoc />
public async Task<QuerySiteMsgRsp> GetMineAsync(QuerySiteMsgReq req)
{
var ret = await PagedQueryMineAsync(
new PagedQueryReq<QuerySiteMsgReq> {
DynamicFilter
= new DynamicFilterInfo {
Field = nameof(req.Id)
, Value = req.Id
, Operator = DynamicFilterOperators.Eq
}
}, true);
return ret.Rows.FirstOrDefault();
}
/// <inheritdoc />
public async Task<PagedQueryRsp<QuerySiteMsgRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgReq> req)
{
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync(a => new {
a.CreatedTime
, a.Creator
, a.Id
, a.MsgType
, a.Summary
, a.Title
, a.Version
});
return new PagedQueryRsp<QuerySiteMsgRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgRsp>>());
}
/// <inheritdoc />
public Task<PagedQueryRsp<QuerySiteMsgRsp>> PagedQueryMineAsync(PagedQueryReq<QuerySiteMsgReq> req)
{
return PagedQueryMineAsync(req, false);
}
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgRsp>> QueryAsync(QueryReq<QuerySiteMsgReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
return ret.Adapt<IEnumerable<QuerySiteMsgRsp>>();
}
/// <inheritdoc />
public async Task SetSiteMsgStatusAsync(UpdateSiteMsgFlagReq req)
{
if (!await ExistAsync(new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = req.SiteMsgId } })) {
throw new NetAdminInvalidOperationException(Ln.站内信不存在);
}
try {
_ = await siteMsgFlagService.CreateAsync(req with { UserId = contextUserInfo.Id });
}
catch {
_ = await siteMsgFlagService.UpdateAsync(req with { UserId = contextUserInfo.Id });
}
}
/// <inheritdoc />
public async Task<long> UnreadCountAsync()
{
// 减去标记已读的数量
var subtract = await Rpo.Orm.Select<Sys_SiteMsgFlag>()
.Where(a => a.UserId == contextUserInfo.Id &&
a.UserSiteMsgStatus == UserSiteMsgStatues.Read)
.CountAsync();
return await QueryMineInternal(new QueryReq<QuerySiteMsgReq>()).CountAsync() - subtract;
}
/// <inheritdoc />
public async Task<QuerySiteMsgRsp> UpdateAsync(UpdateSiteMsgReq req)
{
await CreateUpdateCheckAsync(req);
// 主表
var entity = req.Adapt<Sys_SiteMsg>();
_ = await Rpo.UpdateDiy.SetSource(entity).ExecuteAffrowsAsync();
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Roles));
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Users));
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Depts));
return (await QueryAsync(new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = req.Id } }))
.First();
}
/// <inheritdoc />
protected override async Task<Sys_SiteMsg> UpdateForSqliteAsync(Sys_SiteMsg req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QuerySiteMsgReq { Id = req.Id });
}
private async Task CreateUpdateCheckAsync(CreateSiteMsgReq req)
{
// 检查角色是否存在
if (!req.RoleIds.NullOrEmpty()) {
var roles = await Rpo.Orm.Select<Sys_Role>().Where(a => req.RoleIds.Contains(a.Id)).ToListAsync(a => a.Id);
if (roles.Count != req.RoleIds.Count) {
throw new NetAdminInvalidOperationException(Ln.角色不存在);
}
}
if (!req.DeptIds.NullOrEmpty()) {
// 检查部门是否存在
var depts = await Rpo.Orm.Select<Sys_Dept>().Where(a => req.DeptIds.Contains(a.Id)).ToListAsync(a => a.Id);
if (depts.Count != req.DeptIds.Count) {
throw new NetAdminInvalidOperationException(Ln.部门不存在);
}
}
if (!req.UserIds.NullOrEmpty()) {
// 检查用户是否存在
var users = await Rpo.Orm.Select<Sys_User>().Where(a => req.UserIds.Contains(a.Id)).ToListAsync(a => a.Id);
if (users.Count != req.UserIds.Count) {
throw new NetAdminInvalidOperationException(Ln.用户不存在);
}
}
}
private async Task<PagedQueryRsp<QuerySiteMsgRsp>> PagedQueryMineAsync(
PagedQueryReq<QuerySiteMsgReq> req, bool containsContent)
{
var list = await QueryMineInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync(a => new QuerySiteMsgRsp {
Id = a.Max(a.Value.Item1.Id)
, Title = a.Max(a.Value.Item1.Title)
, Summary = a.Max(a.Value.Item1.Summary)
, Content
= containsContent
? a.Max(a.Value.Item1.Content)
: null
, CreatedTime = a.Max(a.Value.Item1.CreatedTime)
, MyFlags
= new QuerySiteMsgFlagRsp {
UserSiteMsgStatus
= a.Max(a.Value.Item6
.UserSiteMsgStatus)
}
, Sender = new QueryUserRsp {
UserName = a.Max(
a.Value.Item2.UserName)
, Avatar = a.Max(a.Value.Item2.Avatar)
}
});
return new PagedQueryRsp<QuerySiteMsgRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgRsp>>());
}
private ISelect<Sys_SiteMsg> QueryInternal(QueryReq<QuerySiteMsgReq> req)
{
var ret = Rpo.Select.Include(a => a.Creator)
.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.WhereIf( //
req.Keywords?.Length > 0
, a => a.Id == req.Keywords.Int64Try(0) || a.Title.Contains(req.Keywords) ||
a.Summary.Contains(req.Keywords))
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
private ISelectGrouping //
<long, NativeTuple<Sys_SiteMsg, Sys_User, Sys_SiteMsgDept, Sys_SiteMsgRole, Sys_SiteMsgUser, Sys_SiteMsgFlag>>
QueryMineInternal(QueryReq<QuerySiteMsgReq> req)
{
var roleIds = contextUserInfo.Roles.Select(x => x.Id).ToList();
return Rpo.Orm
.Select<Sys_SiteMsg, Sys_User, Sys_SiteMsgDept, Sys_SiteMsgRole, Sys_SiteMsgUser, Sys_SiteMsgFlag>()
.LeftJoin((a, b, _, _, _, _) => a.CreatedUserId == b.Id)
.LeftJoin((a, _, c, _, _, _) => a.Id == c.SiteMsgId)
.LeftJoin((a, _, _, d, _, _) => a.Id == d.SiteMsgId)
.LeftJoin((a, _, _, _, e, _) => a.Id == e.SiteMsgId)
.LeftJoin((a, _, _, _, _, f) => a.Id == f.SiteMsgId)
.WhereDynamicFilter(req.DynamicFilter)
.Where((a, _, c, d, e, f) =>
(SqlExt.EqualIsNull(f.UserSiteMsgStatus) ||
f.UserSiteMsgStatus != UserSiteMsgStatues.Deleted) &&
(a.MsgType == SiteMsgTypes.Public || c.DeptId == contextUserInfo.DeptId ||
roleIds.Contains(d.RoleId) || e.UserId == contextUserInfo.Id))
.GroupBy((a, _, _, _, _, _) => a.Id)
.OrderByDescending(a => a.Value.Item1.CreatedTime);
}
}

98
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgUserService.cs Normal file
View File

@ -0,0 +1,98 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsgUser;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
using DataType = FreeSql.DataType;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="ISiteMsgUserService" />
public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) //
: RepositoryService<Sys_SiteMsgUser, ISiteMsgUserService>(rpo), ISiteMsgUserService
{
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
}
return sum;
}
/// <inheritdoc />
public async Task<QuerySiteMsgUserRsp> CreateAsync(CreateSiteMsgUserReq req)
{
var ret = await Rpo.InsertAsync(req);
return ret.Adapt<QuerySiteMsgUserRsp>();
}
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QuerySiteMsgUserReq> req)
{
return QueryInternal(req).AnyAsync();
}
/// <inheritdoc />
public async Task<QuerySiteMsgUserRsp> GetAsync(QuerySiteMsgUserReq req)
{
var ret = await QueryInternal(new QueryReq<QuerySiteMsgUserReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QuerySiteMsgUserRsp>();
}
/// <inheritdoc />
public async Task<PagedQueryRsp<QuerySiteMsgUserRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgUserReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
return new PagedQueryRsp<QuerySiteMsgUserRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgUserRsp>>());
}
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgUserRsp>> QueryAsync(QueryReq<QuerySiteMsgUserReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
return ret.Adapt<IEnumerable<QuerySiteMsgUserRsp>>();
}
/// <inheritdoc />
public async Task<QuerySiteMsgUserRsp> UpdateAsync(UpdateSiteMsgUserReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QuerySiteMsgUserRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
return ret.FirstOrDefault()?.Adapt<QuerySiteMsgUserRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_SiteMsgUser> UpdateForSqliteAsync(Sys_SiteMsgUser req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QuerySiteMsgUserReq { Id = req.Id });
}
private ISelect<Sys_SiteMsgUser> QueryInternal(QueryReq<QuerySiteMsgUserReq> req)
{
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
}

31
src/backend/NetAdmin.SysComponent.Application/Services/Sys/ToolsService.cs
View File

@ -1,4 +1,5 @@
using NetAdmin.Application.Services;
using NetAdmin.Domain.Dto.Sys.Tool;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
@ -6,19 +7,29 @@ namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IToolsService" />
public sealed class ToolsService : ServiceBase<IToolsService>, IToolsService
{
/// <summary>
/// 服务器时间
/// </summary>
public DateTime GetServerUtcTime()
/// <inheritdoc />
public Task<IEnumerable<GetModulesRsp>> GetModulesAsync()
{
return DateTime.UtcNow;
return Task.FromResult<IEnumerable<GetModulesRsp>>(AppDomain.CurrentDomain.GetAssemblies()
.Select(x => {
var asm = x.GetName();
return new GetModulesRsp {
Name = asm.Name
, Version = asm.Version?.ToString()
};
})
.OrderBy(x => x.Name));
}
/// <summary>
/// 版本信息
/// </summary>
public string Version()
/// <inheritdoc />
public Task<DateTime> GetServerUtcTimeAsync()
{
return Global.ProductVersion;
return Task.FromResult(DateTime.UtcNow);
}
/// <inheritdoc />
public Task<string> GetVersionAsync()
{
return Task.FromResult(GlobalStatic.ProductVersion);
}
}

70
src/backend/NetAdmin.SysComponent.Application/Services/Sys/UserProfileService.cs
View File

@ -10,17 +10,10 @@ using DataType = FreeSql.DataType;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IUserProfileService" />
public sealed class UserProfileService : RepositoryService<Sys_UserProfile, IUserProfileService>, IUserProfileService
public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) //
: RepositoryService<Sys_UserProfile, IUserProfileService>(rpo), IUserProfileService
{
/// <summary>
/// Initializes a new instance of the <see cref="UserProfileService" /> class.
/// </summary>
public UserProfileService(Repository<Sys_UserProfile> rpo) //
: base(rpo) { }
/// <summary>
/// 批量删除用户档案
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -31,9 +24,7 @@ public sealed class UserProfileService : RepositoryService<Sys_UserProfile, IUse
return sum;
}
/// <summary>
/// 创建用户档案
/// </summary>
/// <inheritdoc />
public async Task<QueryUserProfileRsp> CreateAsync(CreateUserProfileReq req)
{
var entity = req.Adapt<Sys_UserProfile>();
@ -41,36 +32,26 @@ public sealed class UserProfileService : RepositoryService<Sys_UserProfile, IUse
return ret.Adapt<QueryUserProfileRsp>();
}
/// <summary>
/// 删除用户档案
/// </summary>
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <summary>
/// 判断用户档案是否存在
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryUserProfileReq> req)
{
throw new NotImplementedException();
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个用户档案
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
/// <inheritdoc />
public async Task<QueryUserProfileRsp> GetAsync(QueryUserProfileReq req)
{
var ret = await QueryInternal(new QueryReq<QueryUserProfileReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryUserProfileRsp>();
}
/// <summary>
/// 分页查询用户档案
/// </summary>
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryUserProfileRsp>> PagedQueryAsync(PagedQueryReq<QueryUserProfileReq> req)
{
var list = await QueryInternal(req)
@ -95,9 +76,7 @@ public sealed class UserProfileService : RepositoryService<Sys_UserProfile, IUse
}));
}
/// <summary>
/// 查询用户档案
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryUserProfileRsp>> QueryAsync(QueryReq<QueryUserProfileReq> req)
{
var ret = await QueryInternal(req)
@ -122,29 +101,37 @@ public sealed class UserProfileService : RepositoryService<Sys_UserProfile, IUse
= x.d.Key == null
? null
: x.d.Adapt<QueryDicContentRsp>()
, EmergencyContactArea = x.e.Key == null
, EmergencyContactArea
= x.e.Key == null
? null
: x.e.Adapt<QueryDicContentRsp>()
});
}
/// <summary>
/// 更新用户档案
/// </summary>
/// <inheritdoc />
public async Task<QueryUserProfileRsp> UpdateAsync(UpdateUserProfileReq req)
{
var entity = req.Adapt<Sys_UserProfile>();
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(entity);
return await UpdateForSqliteAsync(entity) as QueryUserProfileRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(entity).ExecuteUpdatedAsync();
return ret.FirstOrDefault()?.Adapt<QueryUserProfileRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_UserProfile> UpdateForSqliteAsync(Sys_UserProfile req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QueryUserProfileReq { Id = req.Id });
}
private ISelect<Sys_UserProfile, Sys_DicContent, Sys_DicContent, Sys_DicContent, Sys_DicContent> QueryInternal(
QueryReq<QueryUserProfileReq> req)
{
#pragma warning disable CA1305
return Rpo.Orm.Select<Sys_UserProfile, Sys_DicContent, Sys_DicContent, Sys_DicContent, Sys_DicContent>()
.LeftJoin((a, b, _, __, ___) =>
a.NationArea.ToString() == b.Value && b.CatalogId == Numbers.DIC_CATALOG_ID_GEO_AREA)
@ -157,15 +144,6 @@ public sealed class UserProfileService : RepositoryService<Sys_UserProfile, IUse
.WhereDynamicFilter(req.DynamicFilter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending)
.OrderByDescending((a, _, __, ___, ____) => a.Id);
}
/// <summary>
/// 非sqlite数据库请删掉
/// </summary>
private async Task<QueryUserProfileRsp> UpdateForSqliteAsync(Sys_UserProfile req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QueryUserProfileReq { Id = req.Id });
#pragma warning restore CA1305
}
}

190
src/backend/NetAdmin.SysComponent.Application/Services/Sys/UserService.cs
View File

@ -14,10 +14,12 @@ using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IUserService" />
public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUserService
public sealed class UserService(DefaultRepository<Sys_User> rpo //
, IUserProfileService userProfileService //
, IVerifyCodeService verifyCodeService //
, IEventPublisher eventPublisher) //
: RepositoryService<Sys_User, IUserService>(rpo), IUserService
{
private readonly IEventPublisher _eventPublisher;
private readonly Expression<Func<Sys_User, Sys_User>> _selectUserFields = a => new Sys_User {
Id = a.Id
, Avatar = a.Avatar
@ -32,25 +34,7 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
, Roles = a.Roles
};
private readonly IUserProfileService _userProfileService;
private readonly IVerifyCodeService _verifyCodeService;
/// <summary>
/// Initializes a new instance of the <see cref="UserService" /> class.
/// </summary>
public UserService(Repository<Sys_User> rpo, IUserProfileService userProfileService
, IVerifyCodeService verifyCodeService, IEventPublisher eventPublisher) //
: base(rpo)
{
_userProfileService = userProfileService;
_verifyCodeService = verifyCodeService;
_eventPublisher = eventPublisher;
}
/// <summary>
/// 批量删除用户
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -61,25 +45,19 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
return sum;
}
/// <summary>
/// 检查手机号是否可用
/// </summary>
/// <inheritdoc />
public async Task<bool> CheckMobileAvailableAsync(CheckMobileAvailableReq req)
{
return !await Rpo.Select.Where(a => a.Mobile == req.Mobile && a.Id != req.Id).AnyAsync();
}
/// <summary>
/// 检查用户名是否可用
/// </summary>
/// <inheritdoc />
public async Task<bool> CheckUserNameAvailableAsync(CheckUserNameAvailableReq req)
{
return !await Rpo.Select.Where(a => a.UserName == req.UserName && a.Id != req.Id).AnyAsync();
}
/// <summary>
/// 创建用户
/// </summary>
/// <inheritdoc />
public async Task<QueryUserRsp> CreateAsync(CreateUserReq req)
{
await CreateUpdateCheckAsync(req);
@ -92,14 +70,12 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
await Rpo.SaveManyAsync(entity, nameof(entity.Roles));
// 档案表
_ = await _userProfileService.CreateAsync(req.Profile with { Id = dbUser.Id });
_ = await userProfileService.CreateAsync(req.Profile with { Id = dbUser.Id });
var ret = await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = dbUser.Id } });
return ret.First();
}
/// <summary>
/// 删除用户
/// </summary>
/// <inheritdoc />
public async Task<int> DeleteAsync(DelReq req)
{
var effect = 0;
@ -111,31 +87,25 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
effect += await Rpo.Orm.Delete<Sys_UserRole>(new { UserId = req.Id }).ExecuteAffrowsAsync();
// 删除档案表
effect += await _userProfileService.DeleteAsync(req);
effect += await userProfileService.DeleteAsync(req);
return effect;
}
/// <summary>
/// 判断用户是否存在
/// </summary>
/// <inheritdoc />
public async Task<bool> ExistAsync(QueryReq<QueryUserReq> req)
{
return await (await QueryInternalAsync(req)).AnyAsync();
}
/// <summary>
/// 获取单个用户
/// </summary>
/// <exception cref="NotImplementedException">NotImplementedException</exception>
public Task<QueryUserRsp> GetAsync(QueryUserReq req)
/// <inheritdoc />
public async Task<QueryUserRsp> GetAsync(QueryUserReq req)
{
throw new NotImplementedException();
var ret = await (await QueryInternalAsync(new QueryReq<QueryUserReq> { Filter = req })).ToOneAsync();
return ret.Adapt<QueryUserRsp>();
}
/// <summary>
/// 获取单个用户（带更新锁）
/// </summary>
/// <inheritdoc />
public async Task<QueryUserRsp> GetForUpdateAsync(QueryUserReq req)
{
// ReSharper disable once MethodHasAsyncOverload
@ -143,9 +113,7 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
.Adapt<QueryUserRsp>();
}
/// <summary>
/// 密码登录
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">用户名或密码错误</exception>
public async Task<LoginRsp> LoginByPwdAsync(LoginByPwdReq req)
{
@ -155,35 +123,31 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
#pragma warning disable IDE0045
if (new MobileAttribute().IsValid(req.Account)) {
#pragma warning restore IDE0045
dbUser = await Rpo.GetAsync(a => a.Mobile == req.Account && a.Password == pwd);
dbUser = await Rpo.Where(a => a.Mobile == req.Account && a.Password == pwd).ToOneAsync();
}
else {
dbUser = new EmailAddressAttribute().IsValid(req.Account)
? await Rpo.GetAsync(a => a.Email == req.Account && a.Password == pwd)
: await Rpo.GetAsync(a => a.UserName == req.Account && a.Password == pwd);
? await Rpo.Where(a => a.Email == req.Account && a.Password == pwd).ToOneAsync()
: await Rpo.Where(a => a.UserName == req.Account && a.Password == pwd).ToOneAsync();
}
return dbUser == null ? throw new NetAdminInvalidOperationException(Ln.用户名或密码错误) : LoginInternal(dbUser);
}
/// <summary>
/// 短信登录
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">验证码不正确</exception>
/// <exception cref="NetAdminInvalidOperationException">用户不存在</exception>
public async Task<LoginRsp> LoginBySmsAsync(LoginBySmsReq req)
{
if (!await _verifyCodeService.VerifyAsync(req.Adapt<VerifySmsCodeReq>())) {
if (!await verifyCodeService.VerifyAsync(req.Adapt<VerifySmsCodeReq>())) {
throw new NetAdminInvalidOperationException(Ln.验证码不正确);
}
var dbUser = await Rpo.GetAsync(a => a.Mobile == req.DestDevice);
var dbUser = await Rpo.Where(a => a.Mobile == req.DestDevice).ToOneAsync();
return dbUser == null ? throw new NetAdminInvalidOperationException(Ln.用户不存在) : LoginInternal(dbUser);
}
/// <summary>
/// 分页查询用户
/// </summary>
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryUserRsp>> PagedQueryAsync(PagedQueryReq<QueryUserReq> req)
{
var list = await (await QueryInternalAsync(req)).Page(req.Page, req.PageSize)
@ -192,30 +156,24 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
return new PagedQueryRsp<QueryUserRsp>(req.Page, req.PageSize, total, list.Adapt<IEnumerable<QueryUserRsp>>());
}
/// <summary>
/// 查询用户
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryUserRsp>> QueryAsync(QueryReq<QueryUserReq> req)
{
var list = await (await QueryInternalAsync(req)).Take(req.Count).ToListAsync(_selectUserFields);
return list.Adapt<IEnumerable<QueryUserRsp>>();
}
/// <summary>
/// 查询用户档案
/// </summary>
/// <inheritdoc />
public Task<IEnumerable<QueryUserProfileRsp>> QueryProfileAsync(QueryReq<QueryUserProfileReq> req)
{
return _userProfileService.QueryAsync(req);
return userProfileService.QueryAsync(req);
}
/// <summary>
/// 注册用户
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">验证码不正确</exception>
public async Task<UserInfoRsp> RegisterAsync(RegisterUserReq req)
{
if (!await _verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)) {
if (!await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)) {
throw new NetAdminInvalidOperationException(Ln.验证码不正确);
}
@ -223,14 +181,12 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
return (await CreateAsync(createReq)).Adapt<UserInfoRsp>();
}
/// <summary>
/// 重设密码
/// </summary>
/// <inheritdoc />
/// <exception cref="NetAdminInvalidOperationException">验证码不正确</exception>
/// <exception cref="NetAdminInvalidOperationException">用户不存在</exception>
public async Task<uint> ResetPasswordAsync(ResetPasswordReq req)
{
return !await _verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)
return !await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)
? throw new NetAdminInvalidOperationException(Ln.验证码不正确)
: (uint)await Rpo.UpdateDiy
.SetSource((await Rpo.Where(a => a.Mobile == req.VerifySmsCodeReq.DestDevice)
@ -259,7 +215,7 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
.Adapt<UserInfoRsp>();
// 发布用户更新事件
await _eventPublisher.PublishAsync(new UserUpdatedEvent(ret));
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret));
return ret;
}
@ -270,12 +226,12 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
// 如果已绑定手机号、需要手机安全验证
if (!user.Mobile.NullOrEmpty()) {
if (!await _verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)) {
if (!await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)) {
throw new NetAdminInvalidOperationException(Ln.验证码不正确);
}
if (user.Mobile != req.VerifySmsCodeReq.DestDevice) {
throw new NetAdminInvalidOperationException($"{Ln.手机号码} {Ln.不正确}");
throw new NetAdminInvalidOperationException($"{Ln.手机号码不正确}");
}
}
@ -291,7 +247,7 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
.Adapt<UserInfoRsp>();
// 发布用户更新事件
await _eventPublisher.PublishAsync(new UserUpdatedEvent(ret));
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret));
return ret;
}
@ -302,18 +258,18 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
if (!user.Mobile.NullOrEmpty()) {
// 已有手机号，需验证旧手机
if (!await _verifyCodeService.VerifyAsync(req.OriginVerifySmsCodeReq)) {
throw new NetAdminInvalidOperationException($"{Ln.旧手机号码} {Ln.验证码不正确}");
if (!await verifyCodeService.VerifyAsync(req.OriginVerifySmsCodeReq)) {
throw new NetAdminInvalidOperationException($"{Ln.旧手机号码验证码不正确}");
}
if (user.Mobile != req.OriginVerifySmsCodeReq.DestDevice) {
throw new NetAdminInvalidOperationException($"{Ln.旧手机号码} {Ln.不正确}");
throw new NetAdminInvalidOperationException($"{Ln.旧手机号码不正确}");
}
}
// 验证新手机号
if (!await _verifyCodeService.VerifyAsync(req.NewVerifySmsCodeReq)) {
throw new NetAdminInvalidOperationException($"{Ln.新手机号码} {Ln.验证码不正确}");
if (!await verifyCodeService.VerifyAsync(req.NewVerifySmsCodeReq)) {
throw new NetAdminInvalidOperationException($"{Ln.新手机号码验证码不正确}");
}
if (await Rpo.UpdateDiy
@ -332,7 +288,7 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
.Adapt<UserInfoRsp>();
// 发布用户更新事件
await _eventPublisher.PublishAsync(new UserUpdatedEvent(ret));
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret));
return ret;
}
@ -341,24 +297,22 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
{
var version = await Rpo.Where(a => a.Id == UserToken.Id && a.Password == req.OldPassword.Pwd().Guid())
.ToOneAsync(a => new long?(a.Version));
if (version == null) {
throw new NetAdminInvalidInputException($"{Ln.旧密码} {Ln.不正确}");
if (version != null) {
var ret = await Rpo.UpdateDiy
.SetSource(new Sys_User {
Id = UserToken.Id
, Password = req.NewPassword.Pwd().Guid()
, Version = version.Value
})
.UpdateColumns(a => a.Password)
.ExecuteAffrowsAsync();
return ret <= 0 ? throw new NetAdminUnexpectedException() : (uint)ret;
}
var ret = await Rpo.UpdateDiy
.SetSource(new Sys_User {
Id = UserToken.Id
, Password = req.NewPassword.Pwd().Guid()
, Version = version.Value
})
.UpdateColumns(a => a.Password)
.ExecuteAffrowsAsync();
return ret <= 0 ? throw new NetAdminUnexpectedException() : (uint)ret;
throw new NetAdminInvalidOperationException($"{Ln.旧密码不正确}");
}
/// <summary>
/// 更新用户
/// </summary>
/// <inheritdoc />
public async Task<QueryUserRsp> UpdateAsync(UpdateUserReq req)
{
await CreateUpdateCheckAsync(req);
@ -373,7 +327,7 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
_ = await Rpo.UpdateDiy.SetSource(entity).IgnoreColumns(ignoreCols.ToArray()).ExecuteAffrowsAsync();
// 档案表
_ = await _userProfileService.UpdateAsync(req.Profile);
_ = await userProfileService.UpdateAsync(req.Profile);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Roles));
@ -381,21 +335,17 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = req.Id } })).First();
// 发布用户更新事件
await _eventPublisher.PublishAsync(new UserUpdatedEvent(ret.Adapt<UserInfoRsp>()));
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret.Adapt<UserInfoRsp>()));
return ret;
}
/// <summary>
/// 单体更新
/// </summary>
/// <inheritdoc />
public Task UpdateSingleAsync(UpdateUserReq req)
{
return Rpo.UpdateAsync(req);
}
/// <summary>
/// 当前用户信息
/// </summary>
/// <inheritdoc />
public async Task<UserInfoRsp> UserInfoAsync()
{
var dbUser = await Rpo.Where(a => a.Token == UserToken.Token && a.Enabled)
@ -410,6 +360,12 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
return dbUser.Adapt<UserInfoRsp>();
}
/// <inheritdoc />
protected override Task<Sys_User> UpdateForSqliteAsync(Sys_User req)
{
throw new NotImplementedException();
}
private static LoginRsp LoginInternal(IFieldEnabled dbUser)
{
if (!dbUser.Enabled) {
@ -447,10 +403,14 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
private ISelect<Sys_User> QueryInternal(QueryReq<QueryUserReq> req)
{
return Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending)
.OrderByDescending(a => a.Id);
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
private async Task<ISelect<Sys_User>> QueryInternalAsync(QueryReq<QueryUserReq> req)
@ -473,8 +433,8 @@ public sealed class UserService : RepositoryService<Sys_User, IUserService>, IUs
req.Filter?.RoleId > 0, a => a.Roles.Any(b => b.Id == req.Filter.RoleId))
.WhereIf( //
req.Keywords?.Length > 0
, a => a.UserName.Contains(req.Keywords) || a.Id == req.Keywords.Int64Try(0) ||
a.Mobile.Contains(req.Keywords) || a.Email.Contains(req.Keywords) ||
, a => a.Id == req.Keywords.Int64Try(0) || a.UserName.Contains(req.Keywords) ||
a.Mobile.Contains(req.Keywords) || a.Email.Contains(req.Keywords) ||
a.Summary.Contains(req.Keywords))
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);

84
src/backend/NetAdmin.SysComponent.Application/Services/Sys/VerifyCodeService.cs
View File

@ -11,22 +11,12 @@ using DataType = FreeSql.DataType;
namespace NetAdmin.SysComponent.Application.Services.Sys;
/// <inheritdoc cref="IVerifyCodeService" />
public sealed class VerifyCodeService : RepositoryService<Sys_VerifyCode, IVerifyCodeService>, IVerifyCodeService
public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEventPublisher eventPublisher) //
: RepositoryService<Sys_VerifyCode, IVerifyCodeService>(rpo), IVerifyCodeService
{
private readonly IEventPublisher _eventPublisher;
private static readonly int[] _randRange = { 0, 10000 };
/// <summary>
/// Initializes a new instance of the <see cref="VerifyCodeService" /> class.
/// </summary>
public VerifyCodeService(Repository<Sys_VerifyCode> rpo, IEventPublisher eventPublisher) //
: base(rpo)
{
_eventPublisher = eventPublisher;
}
/// <summary>
/// 批量删除验证码
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -37,9 +27,7 @@ public sealed class VerifyCodeService : RepositoryService<Sys_VerifyCode, IVerif
return sum;
}
/// <summary>
/// 创建验证码
/// </summary>
/// <inheritdoc />
public async Task<QueryVerifyCodeRsp> CreateAsync(CreateVerifyCodeReq req)
{
var entity = await Rpo.InsertAsync(req);
@ -47,39 +35,31 @@ public sealed class VerifyCodeService : RepositoryService<Sys_VerifyCode, IVerif
var ret = entity.Adapt<QueryVerifyCodeRsp>();
// 发布验证码创建事件
await _eventPublisher.PublishAsync(new VerifyCodeCreatedEvent(ret));
await eventPublisher.PublishAsync(new VerifyCodeCreatedEvent(ret));
return ret;
}
/// <summary>
/// 删除验证码
/// </summary>
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <summary>
/// 判断验证码是否存在
/// </summary>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryVerifyCodeReq> req)
{
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个验证码
/// </summary>
/// <inheritdoc />
public async Task<QueryVerifyCodeRsp> GetAsync(QueryVerifyCodeReq req)
{
var ret = await QueryInternal(new QueryReq<QueryVerifyCodeReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryVerifyCodeRsp>();
}
/// <summary>
/// 分页查询验证码
/// </summary>
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryVerifyCodeRsp>> PagedQueryAsync(PagedQueryReq<QueryVerifyCodeReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
@ -88,9 +68,7 @@ public sealed class VerifyCodeService : RepositoryService<Sys_VerifyCode, IVerif
, list.Adapt<IEnumerable<QueryVerifyCodeRsp>>());
}
/// <summary>
/// 查询验证码
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryVerifyCodeRsp>> QueryAsync(QueryReq<QueryVerifyCodeReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
@ -115,20 +93,18 @@ public sealed class VerifyCodeService : RepositoryService<Sys_VerifyCode, IVerif
ret = await CreateAsync(req.Adapt<CreateVerifyCodeReq>() with { Code = lastSent.Code });
}
else { // 生成新的code
var code = new[] { 0, 10000 }.Rand().ToString(CultureInfo.InvariantCulture).PadLeft(4, '0');
var code = _randRange.Rand().ToString(CultureInfo.InvariantCulture).PadLeft(4, '0');
ret = await CreateAsync(req.Adapt<CreateVerifyCodeReq>() with { Code = code });
}
return ret.Adapt<SendVerifyCodeRsp>();
}
/// <summary>
/// 更新验证码
/// </summary>
/// <inheritdoc />
public async Task<QueryVerifyCodeRsp> UpdateAsync(UpdateVerifyCodeReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req);
return await UpdateForSqliteAsync(req) as QueryVerifyCodeRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
@ -143,7 +119,7 @@ public sealed class VerifyCodeService : RepositoryService<Sys_VerifyCode, IVerif
return true;
}
#endif
if (req.Code == Global.SecretKey) {
if (req.Code == GlobalStatic.SecretKey) {
return true;
}
@ -159,6 +135,14 @@ public sealed class VerifyCodeService : RepositoryService<Sys_VerifyCode, IVerif
return true;
}
/// <inheritdoc />
protected override async Task<Sys_VerifyCode> UpdateForSqliteAsync(Sys_VerifyCode req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QueryVerifyCodeReq { Id = req.Id });
}
private Task<Sys_VerifyCode> GetLastSentAsync(string destDevice)
{
return QueryInternal(new QueryReq<QueryVerifyCodeReq> {
@ -167,7 +151,7 @@ public sealed class VerifyCodeService : RepositoryService<Sys_VerifyCode, IVerif
= new DynamicFilterInfo {
Field = nameof(
Sys_VerifyCode.DestDevice)
, Operator = DynamicFilterOperator.Eq
, Operator = DynamicFilterOperators.Eq
, Value = destDevice
}
})
@ -176,19 +160,13 @@ public sealed class VerifyCodeService : RepositoryService<Sys_VerifyCode, IVerif
private ISelect<Sys_VerifyCode> QueryInternal(QueryReq<QueryVerifyCodeReq> req)
{
return Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending)
.OrderByDescending(a => a.Id);
}
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
/// <summary>
/// 非sqlite数据库请删掉
/// </summary>
private async Task<QueryVerifyCodeRsp> UpdateForSqliteAsync(Sys_VerifyCode req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QueryVerifyCodeReq { Id = req.Id });
return ret;
}
}

69
src/backend/NetAdmin.SysComponent.Application/Services/Tpl/ExampleService.cs
View File

@ -9,17 +9,10 @@ using DataType = FreeSql.DataType;
namespace NetAdmin.SysComponent.Application.Services.Tpl;
/// <inheritdoc cref="IExampleService" />
public sealed class ExampleService : RepositoryService<Tpl_Example, IExampleService>, IExampleService
public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
: RepositoryService<Tpl_Example, IExampleService>(rpo), IExampleService
{
/// <summary>
/// Initializes a new instance of the <see cref="ExampleService" /> class.
/// </summary>
public ExampleService(Repository<Tpl_Example> rpo) //
: base(rpo) { }
/// <summary>
/// 批量删除示例
/// </summary>
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
var sum = 0;
@ -30,43 +23,33 @@ public sealed class ExampleService : RepositoryService<Tpl_Example, IExampleServ
return sum;
}
/// <summary>
/// 创建示例
/// </summary>
/// <inheritdoc />
public async Task<QueryExampleRsp> CreateAsync(CreateExampleReq req)
{
var ret = await Rpo.InsertAsync(req);
return ret.Adapt<QueryExampleRsp>();
}
/// <summary>
/// 删除示例
/// </summary>
/// <inheritdoc />
public Task<int> DeleteAsync(DelReq req)
{
return Rpo.DeleteAsync(a => a.Id == req.Id);
}
/// <summary>
/// 判断示例是否存在
/// </summary>
/// <inheritdoc />
public Task<bool> ExistAsync(QueryReq<QueryExampleReq> req)
{
return QueryInternal(req).AnyAsync();
}
/// <summary>
/// 获取单个示例
/// </summary>
/// <inheritdoc />
public async Task<QueryExampleRsp> GetAsync(QueryExampleReq req)
{
var ret = await QueryInternal(new QueryReq<QueryExampleReq> { Filter = req }).ToOneAsync();
return ret.Adapt<QueryExampleRsp>();
}
/// <summary>
/// 分页查询示例
/// </summary>
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryExampleRsp>> PagedQueryAsync(PagedQueryReq<QueryExampleReq> req)
{
var list = await QueryInternal(req).Page(req.Page, req.PageSize).Count(out var total).ToListAsync();
@ -75,43 +58,41 @@ public sealed class ExampleService : RepositoryService<Tpl_Example, IExampleServ
, list.Adapt<IEnumerable<QueryExampleRsp>>());
}
/// <summary>
/// 查询示例
/// </summary>
/// <inheritdoc />
public async Task<IEnumerable<QueryExampleRsp>> QueryAsync(QueryReq<QueryExampleReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
return ret.Adapt<IEnumerable<QueryExampleRsp>>();
}
/// <summary>
/// 更新示例
/// </summary>
/// <inheritdoc />
public async Task<QueryExampleRsp> UpdateAsync(UpdateExampleReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req);
return await UpdateForSqliteAsync(req) as QueryExampleRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
return ret.FirstOrDefault()?.Adapt<QueryExampleRsp>();
}
private ISelect<Tpl_Example> QueryInternal(QueryReq<QueryExampleReq> req)
{
return Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending)
.OrderByDescending(a => a.Id);
}
/// <summary>
/// 非sqlite数据库请删掉
/// </summary>
private async Task<QueryExampleRsp> UpdateForSqliteAsync(Tpl_Example req)
/// <inheritdoc />
protected override async Task<Tpl_Example> UpdateForSqliteAsync(Tpl_Example req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
? null
: await GetAsync(new QueryExampleReq { Id = req.Id });
}
private ISelect<Tpl_Example> QueryInternal(QueryReq<QueryExampleReq> req)
{
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
}