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

perf: ⚡ 引入 Microsoft.VisualStudio.Threading.Analyzers 分析器 (#62)

Browse Source
This commit is contained in:
nsnail
2023-11-20 18:11:44 +08:00
committed by GitHub
parent b6bbd8dc88
commit 36c20b813d
55 changed files with 545 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -52,7 +52,10 @@ public sealed class ApiService(DefaultRepository<Sys_Api> rpo
/// <inheritdoc />
public async Task<IEnumerable<QueryApiRsp>> QueryAsync(QueryReq<QueryApiReq> req)
{
var ret = await Rpo.Select.WhereDynamicFilter(req.DynamicFilter).WhereDynamic(req.Filter).ToTreeListAsync();
var ret = await Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.ToTreeListAsync()
.ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryApiRsp>>();
}
@ -90,14 +93,14 @@ public sealed class ApiService(DefaultRepository<Sys_Api> rpo
/// <inheritdoc />
public async Task SyncAsync()
{
_ = await Rpo.DeleteAsync(_ => true);
_ = await Rpo.DeleteAsync(_ => true).ConfigureAwait(false);
var list = ReflectionList(false);
EnableCascadeSave = true;
foreach (var item in list) {
var entity = item.Adapt<Sys_Api>();
_ = await Rpo.InsertAsync(entity);
_ = await Rpo.InsertAsync(entity).ConfigureAwait(false);
}
}

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

@ -11,19 +11,23 @@ public sealed class CacheService(IConnectionMultiplexer connectionMultiplexer) /
: ServiceBase<ICacheService>, ICacheService
{
/// <inheritdoc />
public Task<CacheStatisticsRsp> CacheStatisticsAsync()
public async Task<CacheStatisticsRsp> CacheStatisticsAsync()
{
var database = connectionMultiplexer.GetDatabase();
return Task.FromResult(
new CacheStatisticsRsp((string)database.Execute("info")) { DbSize = (long)database.Execute("dbSize") });
return new CacheStatisticsRsp((string)await database.ExecuteAsync("info").ConfigureAwait(false)) {
DbSize = (long)await database.ExecuteAsync("dbSize").ConfigureAwait(false)
};
}
/// <inheritdoc />
public Task<PagedQueryRsp<GetAllEntriesRsp>> GetAllEntriesAsync(PagedQueryReq<GetAllEntriesReq> req)
public async Task<PagedQueryRsp<GetAllEntriesRsp>> GetAllEntriesAsync(PagedQueryReq<GetAllEntriesReq> req)
{
var database = connectionMultiplexer.GetDatabase((int?)req.Filter?.DbIndex ?? 0);
var redisResults
= (RedisResult[])database.Execute("scan", (req.Page - 1) * req.PageSize, "count", req.PageSize);
var redisResults = (RedisResult[])await database
.ExecuteAsync("scan", (req.Page - 1) * req.PageSize, "count"
, req.PageSize)
.ConfigureAwait(false);
var list = ((string[])redisResults![1])!.Where(x => database.KeyType(x) == RedisType.Hash)
.Select(x => database.HashGetAll(x)
@ -33,6 +37,6 @@ public sealed class CacheService(IConnectionMultiplexer connectionMultiplexer) /
.ToList()
.ConvertAll(x => x.Adapt<GetAllEntriesRsp>());
return Task.FromResult(new PagedQueryRsp<GetAllEntriesRsp>(req.Page, req.PageSize, 10000, list));
return new PagedQueryRsp<GetAllEntriesRsp>(req.Page, req.PageSize, 10000, list);
}
}

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

@ -21,8 +21,9 @@ public sealed class CaptchaService : ServiceBase<ICaptchaService>, ICaptchaServi
public async Task<GetCaptchaRsp> GetCaptchaImageAsync()
{
var (backgroundImage, sliderImage, offsetSaw) = await CaptchaImageHelper.CreateSawSliderImageAsync(
_entryAsm, $"{_entryAsmName}.Assets.Captcha.background", $"{_entryAsmName}.Assets.Captcha.template"
, (1, 101), (1, 7), new Size(50, 50));
_entryAsm, $"{_entryAsmName}.Assets.Captcha.background", $"{_entryAsmName}.Assets.Captcha.template"
, (1, 101), (1, 7), new Size(50, 50))
.ConfigureAwait(false);
var id = $"{nameof(GetCaptchaImageAsync)}_{YitIdHelper.NextId()}";
return new GetCaptchaRsp {

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

@ -17,7 +17,7 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,7 +26,7 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
/// <inheritdoc />
public async Task<QueryConfigRsp> CreateAsync(CreateConfigReq req)
{
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryConfigRsp>();
}
@ -45,7 +45,7 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
/// <inheritdoc />
public async Task<QueryConfigRsp> GetAsync(QueryConfigReq req)
{
var ret = await QueryInternal(new QueryReq<QueryConfigReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryConfigReq> { Filter = req }).ToOneAsync().ConfigureAwait(false);
return ret.Adapt<QueryConfigRsp>();
}
@ -53,14 +53,19 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
public async Task<QueryConfigRsp> GetLatestConfigAsync()
{
var ret = await QueryAsync(
new QueryReq<QueryConfigReq> { Count = 1, Filter = new QueryConfigReq { Enabled = true } });
new QueryReq<QueryConfigReq> { Count = 1, Filter = new QueryConfigReq { Enabled = true } })
.ConfigureAwait(false);
return ret.FirstOrDefault();
}
/// <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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QueryConfigRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryConfigRsp>>());
@ -69,7 +74,7 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
/// <inheritdoc />
public async Task<IEnumerable<QueryConfigRsp>> QueryAsync(QueryReq<QueryConfigReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryConfigRsp>>();
}
@ -77,19 +82,19 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
public async Task<QueryConfigRsp> UpdateAsync(UpdateConfigReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QueryConfigRsp;
return await UpdateForSqliteAsync(req).ConfigureAwait(false) as QueryConfigRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync().ConfigureAwait(false);
return ret.FirstOrDefault()?.Adapt<QueryConfigRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_Config> UpdateForSqliteAsync(Sys_Config req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0
? null
: await GetAsync(new QueryConfigReq { Id = req.Id });
: await GetAsync(new QueryConfigReq { Id = req.Id }).ConfigureAwait(false);
}
private ISelect<Sys_Config> QueryInternal(QueryReq<QueryConfigReq> req)

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

@ -16,7 +16,7 @@ public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,11 +26,11 @@ public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
/// <exception cref="NetAdminInvalidOperationException">Parent_department_does_not_exist</exception>
public async Task<QueryDeptRsp> CreateAsync(CreateDeptReq req)
{
if (req.ParentId != 0 && !await Rpo.Select.AnyAsync(a => a.Id == req.ParentId)) {
if (req.ParentId != 0 && !await Rpo.Select.AnyAsync(a => a.Id == req.ParentId).ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.父节点不存在);
}
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryDeptRsp>();
}
@ -40,17 +40,17 @@ public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
/// <exception cref="NetAdminInvalidOperationException">该部门下存在子部门</exception>
public async Task<int> DeleteAsync(DelReq req)
{
if (await Rpo.Orm.Select<Sys_User>().AnyAsync(a => a.DeptId == req.Id)) {
if (await Rpo.Orm.Select<Sys_User>().AnyAsync(a => a.DeptId == req.Id).ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.该部门下存在用户);
}
#pragma warning disable IDE0046
if (await Rpo.Select.AnyAsync(a => a.ParentId == req.Id)) {
if (await Rpo.Select.AnyAsync(a => a.ParentId == req.Id).ConfigureAwait(false)) {
#pragma warning restore IDE0046
throw new NetAdminInvalidOperationException(Ln.该部门下存在子部门);
}
return await Rpo.DeleteAsync(x => x.Id == req.Id);
return await Rpo.DeleteAsync(x => x.Id == req.Id).ConfigureAwait(false);
}
/// <inheritdoc />
@ -62,7 +62,7 @@ public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
/// <inheritdoc />
public async Task<QueryDeptRsp> GetAsync(QueryDeptReq req)
{
var ret = await QueryInternal(new QueryReq<QueryDeptReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryDeptReq> { Filter = req }).ToOneAsync().ConfigureAwait(false);
return ret.Adapt<QueryDeptRsp>();
}
@ -75,17 +75,18 @@ public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
/// <inheritdoc />
public async Task<IEnumerable<QueryDeptRsp>> QueryAsync(QueryReq<QueryDeptReq> req)
{
return (await QueryInternal(req).ToTreeListAsync()).Adapt<IEnumerable<QueryDeptRsp>>();
return (await QueryInternal(req).ToTreeListAsync().ConfigureAwait(false)).Adapt<IEnumerable<QueryDeptRsp>>();
}
/// <inheritdoc />
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryDeptRsp> UpdateAsync(UpdateDeptReq req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0
? throw new NetAdminUnexpectedException()
: (await QueryInternal(new QueryReq<QueryDeptReq> { Filter = new QueryDeptReq { Id = req.Id } }, true)
.ToTreeListAsync())[0]
.ToTreeListAsync()
.ConfigureAwait(false))[0]
.Adapt<QueryDeptRsp>();
}

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

@ -54,57 +54,70 @@ public sealed class DevService(IApiService apiService) : ServiceBase<DevService>
// Controller
await WriteCodeFileAsync(req, Path.Combine(tplHostDir, "Controllers", "Tpl", "ExampleController.cs")
, Path.Combine(hostControllerDir, $"{req.ModuleName}Controller.cs"));
, Path.Combine(hostControllerDir, $"{req.ModuleName}Controller.cs"))
.ConfigureAwait(false);
// CreateReq
await WriteCodeFileAsync(req, Path.Combine(dataDir, "Dto", "Tpl", "Example", "CreateExampleReq.cs")
, Path.Combine(dtoDir, $"Create{req.ModuleName}Req.cs"));
, Path.Combine(dtoDir, $"Create{req.ModuleName}Req.cs"))
.ConfigureAwait(false);
// UpdateReq
await WriteCodeFileAsync(req, Path.Combine(dataDir, "Dto", "Tpl", "Example", "UpdateExampleReq.cs")
, Path.Combine(dtoDir, $"Update{req.ModuleName}Req.cs"));
, Path.Combine(dtoDir, $"Update{req.ModuleName}Req.cs"))
.ConfigureAwait(false);
// QueryReq
await WriteCodeFileAsync(req, Path.Combine(dataDir, "Dto", "Tpl", "Example", "QueryExampleReq.cs")
, Path.Combine(dtoDir, $"Query{req.ModuleName}Req.cs"));
, Path.Combine(dtoDir, $"Query{req.ModuleName}Req.cs"))
.ConfigureAwait(false);
// QueryRsp
await WriteCodeFileAsync(req, Path.Combine(dataDir, "Dto", "Tpl", "Example", "QueryExampleRsp.cs")
, Path.Combine(dtoDir, $"Query{req.ModuleName}Rsp.cs"));
, Path.Combine(dtoDir, $"Query{req.ModuleName}Rsp.cs"))
.ConfigureAwait(false);
// ICache
await WriteCodeFileAsync(req, Path.Combine(tplCacheDir, "Tpl", "Dependency", "IExampleCache.cs")
, Path.Combine(cacheDependencyDir, $"I{req.ModuleName}Cache.cs"));
, Path.Combine(cacheDependencyDir, $"I{req.ModuleName}Cache.cs"))
.ConfigureAwait(false);
// Cache
await WriteCodeFileAsync(req, Path.Combine(tplCacheDir, "Tpl", "ExampleCache.cs")
, Path.Combine(cacheDir, $"{req.ModuleName}Cache.cs"));
, Path.Combine(cacheDir, $"{req.ModuleName}Cache.cs"))
.ConfigureAwait(false);
// IModule
await WriteCodeFileAsync(req, Path.Combine(tplAppDir, "Modules", "Tpl", "IExampleModule.cs")
, Path.Combine(appModulesDir, $"I{req.ModuleName}Module.cs"));
, Path.Combine(appModulesDir, $"I{req.ModuleName}Module.cs"))
.ConfigureAwait(false);
// IService
await WriteCodeFileAsync(req, Path.Combine(tplAppDir, "Services", "Tpl", "Dependency", "IExampleService.cs")
, Path.Combine(appServicesDependencyDir, $"I{req.ModuleName}Service.cs"));
, Path.Combine(appServicesDependencyDir, $"I{req.ModuleName}Service.cs"))
.ConfigureAwait(false);
// Service
await WriteCodeFileAsync(req, Path.Combine(tplAppDir, "Services", "Tpl", "ExampleService.cs")
, Path.Combine(appServicesDir, $"{req.ModuleName}Service.cs"));
, Path.Combine(appServicesDir, $"{req.ModuleName}Service.cs"))
.ConfigureAwait(false);
// Entity
await WriteCodeFileAsync(req, Path.Combine(dataDir, "DbMaps", "Tpl", "Tpl_Example.cs")
, Path.Combine(entityDir, $"{moduleType[..3]}_{req.ModuleName}.cs"));
, Path.Combine(entityDir, $"{moduleType[..3]}_{req.ModuleName}.cs"))
.ConfigureAwait(false);
}
/// <inheritdoc />
public async Task GenerateIconCodeAsync(GenerateIconCodeReq req)
{
var tplSvg = await File.ReadAllTextAsync(
Path.Combine(_clientProjectPath, "src", "assets", "icons", "tpl", "Svg.vue"));
var tplExport
= await File.ReadAllTextAsync(
Path.Combine(_clientProjectPath, "src", "assets", "icons", "tpl", "export.js"));
Path.Combine(_clientProjectPath, "src", "assets", "icons", "tpl", "Svg.vue"))
.ConfigureAwait(false);
var tplExport = await File
.ReadAllTextAsync(Path.Combine(_clientProjectPath, "src", "assets", "icons", "tpl"
, "export.js"))
.ConfigureAwait(false);
var vueContent = tplSvg.Replace("$svgCode$", req.SvgCode).Replace(_REPLACE_TO_EMPTY, string.Empty);
@ -114,18 +127,19 @@ public sealed class DevService(IApiService apiService) : ServiceBase<DevService>
}
var vueFile = Path.Combine(dir, $"{req.IconName}.vue");
await File.WriteAllTextAsync(vueFile, vueContent);
await File.WriteAllTextAsync(vueFile, vueContent).ConfigureAwait(false);
var indexJsFile = Path.Combine(dir, "index.js");
await File.AppendAllTextAsync(
indexJsFile
, Environment.NewLine +
tplExport.Replace("$iconName$", req.IconName).Replace(_REPLACE_TO_EMPTY, string.Empty));
indexJsFile
, Environment.NewLine +
tplExport.Replace("$iconName$", req.IconName).Replace(_REPLACE_TO_EMPTY, string.Empty))
.ConfigureAwait(false);
// 修改iconSelect.js
var iconSelectFile = Path.Combine(_clientProjectPath, "src", "config", "iconSelect.js");
var iconSelectContent = await File.ReadAllTextAsync(iconSelectFile);
var iconSelectContent = await File.ReadAllTextAsync(iconSelectFile).ConfigureAwait(false);
iconSelectContent = iconSelectContent.Replace("export default", "exportDefault:").Replace("'", "\"");
iconSelectContent = _regex2.Replace(iconSelectContent, "\"$1\":");
iconSelectContent = "{" + iconSelectContent + "}";
@ -133,15 +147,17 @@ public sealed class DevService(IApiService apiService) : ServiceBase<DevService>
iconExportJsInfo.ExportDefault.Icons.Last().Icons.Add($"sc-icon-{req.IconName.ToLowerInvariant()}");
var newContent = iconExportJsInfo.ToJson().TrimStart('{')[..^1].Replace("\"exportDefault\":", "export default");
await File.WriteAllTextAsync(iconSelectFile, newContent);
await File.WriteAllTextAsync(iconSelectFile, newContent).ConfigureAwait(false);
}
/// <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"));
var tplOuter = await File.ReadAllTextAsync(Path.Combine(_clientProjectPath, "src", "api", "tpl", "outer.js"))
.ConfigureAwait(false);
var tplInner = await File.ReadAllTextAsync(Path.Combine(_clientProjectPath, "src", "api", "tpl", "inner.js"))
.ConfigureAwait(false);
foreach (var item in apiService.ReflectionList(false)) {
var dir = Path.Combine(_clientProjectPath, "src", "api", item.Namespace);
@ -158,7 +174,7 @@ public sealed class DevService(IApiService apiService) : ServiceBase<DevService>
, string.Join(Environment.NewLine + Environment.NewLine, Select(item)))
.Replace(_REPLACE_TO_EMPTY, string.Empty);
await File.WriteAllTextAsync(file, content);
await File.WriteAllTextAsync(file, content).ConfigureAwait(false);
}
IEnumerable<string> Select(QueryApiRsp item)
@ -191,12 +207,12 @@ public sealed class DevService(IApiService apiService) : ServiceBase<DevService>
private static async Task WriteCodeFileAsync(GenerateCsCodeReq req, string tplFile, string writeFile)
{
var tplContent = await File.ReadAllTextAsync(tplFile);
var tplContent = await File.ReadAllTextAsync(tplFile).ConfigureAwait(false);
tplContent = tplContent.Replace("Tpl", Enum.GetName(req.Type)![..3])
.Replace("示例", req.ModuleRemark)
.Replace("Example", req.ModuleName)
.Replace("NetAdmin.SysComponent", "SysComponent");
await File.WriteAllTextAsync(writeFile, tplContent);
await File.WriteAllTextAsync(writeFile, tplContent).ConfigureAwait(false);
}
}

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

@ -16,7 +16,7 @@ public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,18 +26,19 @@ public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
/// <exception cref="NetAdminInvalidOperationException">The_parent_node_does_not_exist</exception>
public async Task<QueryDicCatalogRsp> CreateAsync(CreateDicCatalogReq req)
{
if (req.ParentId != 0 && !await Rpo.Where(a => a.Id == req.ParentId).ForUpdate().AnyAsync()) {
if (req.ParentId != 0 &&
!await Rpo.Where(a => a.Id == req.ParentId).ForUpdate().AnyAsync().ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.父节点不存在);
}
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryDicCatalogRsp>();
}
/// <inheritdoc />
public async Task<int> DeleteAsync(DelReq req)
{
var ret = await Rpo.DeleteCascadeByDatabaseAsync(a => a.Id == req.Id);
var ret = await Rpo.DeleteCascadeByDatabaseAsync(a => a.Id == req.Id).ConfigureAwait(false);
return ret.Count;
}
@ -50,14 +51,20 @@ public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
/// <inheritdoc />
public async Task<QueryDicCatalogRsp> GetAsync(QueryDicCatalogReq req)
{
var ret = await QueryInternal(new QueryReq<QueryDicCatalogReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryDicCatalogReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
return ret.Adapt<QueryDicCatalogRsp>();
}
/// <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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QueryDicCatalogRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryDicCatalogRsp>>());
@ -66,7 +73,7 @@ public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
/// <inheritdoc />
public async Task<IEnumerable<QueryDicCatalogRsp>> QueryAsync(QueryReq<QueryDicCatalogReq> req)
{
var ret = await QueryInternal(req).ToTreeListAsync();
var ret = await QueryInternal(req).ToTreeListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryDicCatalogRsp>>();
}
@ -75,15 +82,16 @@ public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryDicCatalogRsp> UpdateAsync(UpdateDicCatalogReq req)
{
if (req.ParentId != 0 && !await Rpo.Where(a => a.Id == req.ParentId).ForUpdate().AnyAsync()) {
if (req.ParentId != 0 &&
!await Rpo.Where(a => a.Id == req.ParentId).ForUpdate().AnyAsync().ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.父节点不存在);
}
if (await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0) {
if (await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0) {
throw new NetAdminUnexpectedException();
}
var ret = await Rpo.Where(a => a.Id == req.Id).ToOneAsync();
var ret = await Rpo.Where(a => a.Id == req.Id).ToOneAsync().ConfigureAwait(false);
return ret.Adapt<QueryDicCatalogRsp>();
}

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

@ -16,7 +16,7 @@ public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,11 +26,15 @@ public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
/// <exception cref="NetAdminInvalidOperationException">Dictionary_directory_does_not_exist</exception>
public async Task<QueryDicContentRsp> CreateAsync(CreateDicContentReq req)
{
if (!await Rpo.Orm.Select<Sys_DicCatalog>().Where(a => a.Id == req.CatalogId).ForUpdate().AnyAsync()) {
if (!await Rpo.Orm.Select<Sys_DicCatalog>()
.Where(a => a.Id == req.CatalogId)
.ForUpdate()
.AnyAsync()
.ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.字典目录不存在);
}
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryDicContentRsp>();
}
@ -49,14 +53,20 @@ public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
/// <inheritdoc />
public async Task<QueryDicContentRsp> GetAsync(QueryDicContentReq req)
{
var ret = await QueryInternal(new QueryReq<QueryDicContentReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryDicContentReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
return ret.Adapt<QueryDicContentRsp>();
}
/// <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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QueryDicContentRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryDicContentRsp>>());
@ -65,7 +75,7 @@ public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
/// <inheritdoc />
public async Task<IEnumerable<QueryDicContentRsp>> QueryAsync(QueryReq<QueryDicContentReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryDicContentRsp>>();
}
@ -74,15 +84,19 @@ public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryDicContentRsp> UpdateAsync(UpdateDicContentReq req)
{
if (!await Rpo.Orm.Select<Sys_DicCatalog>().Where(a => a.Id == req.CatalogId).ForUpdate().AnyAsync()) {
if (!await Rpo.Orm.Select<Sys_DicCatalog>()
.Where(a => a.Id == req.CatalogId)
.ForUpdate()
.AnyAsync()
.ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.字典目录不存在);
}
if (await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0) {
if (await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0) {
throw new NetAdminUnexpectedException();
}
var ret = await Rpo.Where(a => a.Id == req.Id).ToOneAsync();
var ret = await Rpo.Where(a => a.Id == req.Id).ToOneAsync().ConfigureAwait(false);
return ret.Adapt<QueryDicContentRsp>();
}

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

@ -29,6 +29,6 @@ public sealed class FileService(IOptions<UploadOptions> uploadOptions, MinioHelp
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).ConfigureAwait(false);
}
}

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

@ -16,7 +16,7 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -25,7 +25,7 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
/// <inheritdoc />
public async Task<QueryMenuRsp> CreateAsync(CreateMenuReq req)
{
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryMenuRsp>();
}
@ -44,7 +44,7 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
/// <inheritdoc />
public async Task<QueryMenuRsp> GetAsync(QueryMenuReq req)
{
var ret = await QueryInternal(new QueryReq<QueryMenuReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryMenuReq> { Filter = req }).ToOneAsync().ConfigureAwait(false);
return ret.Adapt<QueryMenuRsp>();
}
@ -57,7 +57,7 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
/// <inheritdoc />
public async Task<IEnumerable<QueryMenuRsp>> QueryAsync(QueryReq<QueryMenuReq> req)
{
var ret = await QueryInternal(req).ToTreeListAsync();
var ret = await QueryInternal(req).ToTreeListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryMenuRsp>>();
}
@ -65,18 +65,18 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryMenuRsp> UpdateAsync(UpdateMenuReq req)
{
if (await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0) {
if (await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0) {
throw new NetAdminUnexpectedException();
}
var ret = await Rpo.Where(a => a.Id == req.Id).ToOneAsync();
var ret = await Rpo.Where(a => a.Id == req.Id).ToOneAsync().ConfigureAwait(false);
return ret.Adapt<QueryMenuRsp>();
}
/// <inheritdoc />
public async Task<IEnumerable<QueryMenuRsp>> UserMenusAsync()
{
var userInfo = await userService.UserInfoAsync();
var userInfo = await userService.UserInfoAsync().ConfigureAwait(false);
Task<IEnumerable<QueryMenuRsp>> ret;
var req = new QueryReq<QueryMenuReq>();
@ -98,7 +98,7 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
ret = QueryAsync(req with { DynamicFilter = df });
}
return await ret;
return await ret.ConfigureAwait(false);
}
/// <inheritdoc />

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

@ -16,7 +16,7 @@ public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -25,7 +25,7 @@ public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
/// <inheritdoc />
public async Task<QueryRequestLogRsp> CreateAsync(CreateRequestLogReq req)
{
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryRequestLogRsp>();
}
@ -44,7 +44,9 @@ public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
/// <inheritdoc />
public async Task<QueryRequestLogRsp> GetAsync(QueryRequestLogReq req)
{
var ret = await QueryInternal(new QueryReq<QueryRequestLogReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryRequestLogReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
return ret.Adapt<QueryRequestLogRsp>();
}
@ -66,7 +68,8 @@ public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
, a.CreatedUserAgent
, a.HttpStatusCode
, a.Id
});
})
.ConfigureAwait(false);
return new PagedQueryRsp<QueryRequestLogRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryRequestLogRsp>>());
@ -75,7 +78,7 @@ public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
/// <inheritdoc />
public async Task<IEnumerable<QueryRequestLogRsp>> QueryAsync(QueryReq<QueryRequestLogReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryRequestLogRsp>>();
}

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

@ -16,7 +16,7 @@ public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,11 +26,11 @@ public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
public async Task<QueryRoleRsp> CreateAsync(CreateRoleReq req)
{
var entity = req.Adapt<Sys_Role>();
var ret = await Rpo.InsertAsync(entity);
var ret = await Rpo.InsertAsync(entity).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Depts));
await Rpo.SaveManyAsync(entity, nameof(entity.Menus));
await Rpo.SaveManyAsync(entity, nameof(entity.Apis));
await Rpo.SaveManyAsync(entity, nameof(entity.Depts)).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Menus)).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Apis)).ConfigureAwait(false);
entity = entity with { Id = ret.Id };
return entity.Adapt<QueryRoleRsp>();
@ -40,9 +40,9 @@ public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
/// <exception cref="NetAdminInvalidOperationException">Users_exist_under_this_role_and_deletion_is_not_allowed</exception>
public async Task<int> DeleteAsync(DelReq req)
{
return await Rpo.Orm.Select<Sys_UserRole>().ForUpdate().AnyAsync(a => a.RoleId == req.Id)
return await Rpo.Orm.Select<Sys_UserRole>().ForUpdate().AnyAsync(a => a.RoleId == req.Id).ConfigureAwait(false)
? throw new NetAdminInvalidOperationException(Ln.该角色下存在用户)
: await Rpo.DeleteAsync(a => a.Id == req.Id);
: await Rpo.DeleteAsync(a => a.Id == req.Id).ConfigureAwait(false);
}
/// <inheritdoc />
@ -54,14 +54,18 @@ public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
/// <inheritdoc />
public async Task<QueryRoleRsp> GetAsync(QueryRoleReq req)
{
var ret = await QueryInternal(new QueryReq<QueryRoleReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryRoleReq> { Filter = req }).ToOneAsync().ConfigureAwait(false);
return ret.Adapt<QueryRoleRsp>();
}
/// <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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QueryRoleRsp>(req.Page, req.PageSize, total, list.Adapt<IEnumerable<QueryRoleRsp>>());
}
@ -69,7 +73,7 @@ public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
/// <inheritdoc />
public async Task<IEnumerable<QueryRoleRsp>> QueryAsync(QueryReq<QueryRoleReq> req)
{
var ret = await QueryInternal(req).ToListAsync();
var ret = await QueryInternal(req).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryRoleRsp>>();
}
@ -77,12 +81,13 @@ public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
public async Task<QueryRoleRsp> UpdateAsync(UpdateRoleReq req)
{
var entity = req.Adapt<Sys_Role>();
_ = await Rpo.UpdateAsync(entity);
await Rpo.SaveManyAsync(entity, nameof(entity.Depts));
await Rpo.SaveManyAsync(entity, nameof(entity.Menus));
await Rpo.SaveManyAsync(entity, nameof(entity.Apis));
_ = await Rpo.UpdateAsync(entity).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Depts)).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Menus)).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Apis)).ConfigureAwait(false);
return (await QueryAsync(new QueryReq<QueryRoleReq> { Filter = new QueryRoleReq { Id = req.Id } })).First();
return (await QueryAsync(new QueryReq<QueryRoleReq> { Filter = new QueryRoleReq { Id = req.Id } })
.ConfigureAwait(false)).First();
}
/// <inheritdoc />

24
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgDeptService.cs
View File

@ -17,7 +17,7 @@ public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) /
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,7 +26,7 @@ public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) /
/// <inheritdoc />
public async Task<QuerySiteMsgDeptRsp> CreateAsync(CreateSiteMsgDeptReq req)
{
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QuerySiteMsgDeptRsp>();
}
@ -45,14 +45,20 @@ public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) /
/// <inheritdoc />
public async Task<QuerySiteMsgDeptRsp> GetAsync(QuerySiteMsgDeptReq req)
{
var ret = await QueryInternal(new QueryReq<QuerySiteMsgDeptReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QuerySiteMsgDeptReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QuerySiteMsgDeptRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgDeptRsp>>());
@ -61,7 +67,7 @@ public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) /
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgDeptRsp>> QueryAsync(QueryReq<QuerySiteMsgDeptReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QuerySiteMsgDeptRsp>>();
}
@ -69,19 +75,19 @@ public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) /
public async Task<QuerySiteMsgDeptRsp> UpdateAsync(UpdateSiteMsgDeptReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QuerySiteMsgDeptRsp;
return await UpdateForSqliteAsync(req).ConfigureAwait(false) as QuerySiteMsgDeptRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync().ConfigureAwait(false);
return ret.FirstOrDefault()?.Adapt<QuerySiteMsgDeptRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_SiteMsgDept> UpdateForSqliteAsync(Sys_SiteMsgDept req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0
? null
: await GetAsync(new QuerySiteMsgDeptReq { Id = req.Id });
: await GetAsync(new QuerySiteMsgDeptReq { Id = req.Id }).ConfigureAwait(false);
}
private ISelect<Sys_SiteMsgDept> QueryInternal(QueryReq<QuerySiteMsgDeptReq> req)

26
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgFlagService.cs
View File

@ -17,7 +17,7 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,7 +26,7 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
/// <inheritdoc />
public async Task<QuerySiteMsgFlagRsp> CreateAsync(CreateSiteMsgFlagReq req)
{
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QuerySiteMsgFlagRsp>();
}
@ -45,14 +45,20 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
/// <inheritdoc />
public async Task<QuerySiteMsgFlagRsp> GetAsync(QuerySiteMsgFlagReq req)
{
var ret = await QueryInternal(new QueryReq<QuerySiteMsgFlagReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QuerySiteMsgFlagReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QuerySiteMsgFlagRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgFlagRsp>>());
@ -61,7 +67,7 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgFlagRsp>> QueryAsync(QueryReq<QuerySiteMsgFlagReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QuerySiteMsgFlagRsp>>();
}
@ -69,12 +75,13 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
public async Task<QuerySiteMsgFlagRsp> UpdateAsync(UpdateSiteMsgFlagReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QuerySiteMsgFlagRsp;
return await UpdateForSqliteAsync(req).ConfigureAwait(false) as QuerySiteMsgFlagRsp;
}
var ret = await Rpo.UpdateDiy.Set(a => a.UserSiteMsgStatus == req.UserSiteMsgStatus)
.Where(a => a.UserId == req.UserId && a.SiteMsgId == req.SiteMsgId)
.ExecuteUpdatedAsync();
.ExecuteUpdatedAsync()
.ConfigureAwait(false);
return ret.FirstOrDefault()?.Adapt<QuerySiteMsgFlagRsp>();
}
@ -83,9 +90,10 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
{
return await Rpo.UpdateDiy.Set(a => a.UserSiteMsgStatus == req.UserSiteMsgStatus)
.Where(a => a.UserId == req.UserId && a.SiteMsgId == req.SiteMsgId)
.ExecuteAffrowsAsync() <= 0
.ExecuteAffrowsAsync()
.ConfigureAwait(false) <= 0
? null
: await GetAsync(new QuerySiteMsgFlagReq { Id = req.Id });
: await GetAsync(new QuerySiteMsgFlagReq { Id = req.Id }).ConfigureAwait(false);
}
private ISelect<Sys_SiteMsgFlag> QueryInternal(QueryReq<QuerySiteMsgFlagReq> req)

24
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgRoleService.cs
View File

@ -17,7 +17,7 @@ public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) /
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,7 +26,7 @@ public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) /
/// <inheritdoc />
public async Task<QuerySiteMsgRoleRsp> CreateAsync(CreateSiteMsgRoleReq req)
{
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QuerySiteMsgRoleRsp>();
}
@ -45,14 +45,20 @@ public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) /
/// <inheritdoc />
public async Task<QuerySiteMsgRoleRsp> GetAsync(QuerySiteMsgRoleReq req)
{
var ret = await QueryInternal(new QueryReq<QuerySiteMsgRoleReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QuerySiteMsgRoleReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QuerySiteMsgRoleRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgRoleRsp>>());
@ -61,7 +67,7 @@ public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) /
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgRoleRsp>> QueryAsync(QueryReq<QuerySiteMsgRoleReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QuerySiteMsgRoleRsp>>();
}
@ -69,19 +75,19 @@ public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) /
public async Task<QuerySiteMsgRoleRsp> UpdateAsync(UpdateSiteMsgRoleReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QuerySiteMsgRoleRsp;
return await UpdateForSqliteAsync(req).ConfigureAwait(false) as QuerySiteMsgRoleRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync().ConfigureAwait(false);
return ret.FirstOrDefault()?.Adapt<QuerySiteMsgRoleRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_SiteMsgRole> UpdateForSqliteAsync(Sys_SiteMsgRole req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0
? null
: await GetAsync(new QuerySiteMsgRoleReq { Id = req.Id });
: await GetAsync(new QuerySiteMsgRoleReq { Id = req.Id }).ConfigureAwait(false);
}
private ISelect<Sys_SiteMsgRole> QueryInternal(QueryReq<QuerySiteMsgRoleReq> req)

91
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgService.cs
View File

@ -21,7 +21,7 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -30,23 +30,23 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
/// <inheritdoc />
public async Task<QuerySiteMsgRsp> CreateAsync(CreateSiteMsgReq req)
{
await CreateUpdateCheckAsync(req);
await CreateUpdateCheckAsync(req).ConfigureAwait(false);
// 主表
var entity = req.Adapt<Sys_SiteMsg>();
var dbSiteMsg = await Rpo.InsertAsync(entity);
var dbSiteMsg = await Rpo.InsertAsync(entity).ConfigureAwait(false);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Roles));
await Rpo.SaveManyAsync(entity, nameof(entity.Roles)).ConfigureAwait(false);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Users));
await Rpo.SaveManyAsync(entity, nameof(entity.Users)).ConfigureAwait(false);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Depts));
await Rpo.SaveManyAsync(entity, nameof(entity.Depts)).ConfigureAwait(false);
var ret = await QueryAsync(
new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = dbSiteMsg.Id } });
var ret = await QueryAsync(new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = dbSiteMsg.Id } })
.ConfigureAwait(false);
return ret.Adapt<QuerySiteMsgRsp>();
}
@ -54,7 +54,7 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
/// <inheritdoc />
public async Task<int> DeleteAsync(DelReq req)
{
var ret = await Rpo.DeleteCascadeByDatabaseAsync(a => a.Id == req.Id);
var ret = await Rpo.DeleteCascadeByDatabaseAsync(a => a.Id == req.Id).ConfigureAwait(false);
return ret.Count;
}
@ -71,7 +71,8 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
.IncludeMany(a => a.Roles)
.IncludeMany(a => a.Users)
.IncludeMany(a => a.Depts)
.ToOneAsync();
.ToOneAsync()
.ConfigureAwait(false);
return ret.Adapt<QuerySiteMsgRsp>();
}
@ -79,14 +80,15 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
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);
new PagedQueryReq<QuerySiteMsgReq> {
DynamicFilter
= new DynamicFilterInfo {
Field = nameof(req.Id)
, Value = req.Id
, Operator = DynamicFilterOperators.Eq
}
}, true)
.ConfigureAwait(false);
return ret.Rows.FirstOrDefault();
}
@ -104,7 +106,8 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
, a.Summary
, a.Title
, a.Version
});
})
.ConfigureAwait(false);
return new PagedQueryRsp<QuerySiteMsgRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgRsp>>());
@ -119,22 +122,23 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgRsp>> QueryAsync(QueryReq<QuerySiteMsgReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QuerySiteMsgRsp>>();
}
/// <inheritdoc />
public async Task SetSiteMsgStatusAsync(UpdateSiteMsgFlagReq req)
{
if (!await ExistAsync(new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = req.SiteMsgId } })) {
if (!await ExistAsync(new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = req.SiteMsgId } })
.ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.站内信不存在);
}
try {
_ = await siteMsgFlagService.CreateAsync(req with { UserId = contextUserInfo.Id });
_ = await siteMsgFlagService.CreateAsync(req with { UserId = contextUserInfo.Id }).ConfigureAwait(false);
}
catch {
_ = await siteMsgFlagService.UpdateAsync(req with { UserId = contextUserInfo.Id });
_ = await siteMsgFlagService.UpdateAsync(req with { UserId = contextUserInfo.Id }).ConfigureAwait(false);
}
}
@ -145,46 +149,50 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
var subtract = await Rpo.Orm.Select<Sys_SiteMsgFlag>()
.Where(a => a.UserId == contextUserInfo.Id &&
a.UserSiteMsgStatus == UserSiteMsgStatues.Read)
.CountAsync();
.CountAsync()
.ConfigureAwait(false);
return await QueryMineInternal(new QueryReq<QuerySiteMsgReq>()).CountAsync() - subtract;
return await QueryMineInternal(new QueryReq<QuerySiteMsgReq>()).CountAsync().ConfigureAwait(false) - subtract;
}
/// <inheritdoc />
public async Task<QuerySiteMsgRsp> UpdateAsync(UpdateSiteMsgReq req)
{
await CreateUpdateCheckAsync(req);
await CreateUpdateCheckAsync(req).ConfigureAwait(false);
// 主表
var entity = req.Adapt<Sys_SiteMsg>();
_ = await Rpo.UpdateDiy.SetSource(entity).ExecuteAffrowsAsync();
_ = await Rpo.UpdateDiy.SetSource(entity).ExecuteAffrowsAsync().ConfigureAwait(false);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Roles));
await Rpo.SaveManyAsync(entity, nameof(entity.Roles)).ConfigureAwait(false);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Users));
await Rpo.SaveManyAsync(entity, nameof(entity.Users)).ConfigureAwait(false);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Depts));
await Rpo.SaveManyAsync(entity, nameof(entity.Depts)).ConfigureAwait(false);
return (await QueryAsync(new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = req.Id } }))
.First();
return (await QueryAsync(new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = req.Id } })
.ConfigureAwait(false)).First();
}
/// <inheritdoc />
protected override async Task<Sys_SiteMsg> UpdateForSqliteAsync(Sys_SiteMsg req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0
? null
: await GetAsync(new QuerySiteMsgReq { Id = req.Id });
: await GetAsync(new QuerySiteMsgReq { Id = req.Id }).ConfigureAwait(false);
}
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);
var roles = await Rpo.Orm.Select<Sys_Role>()
.Where(a => req.RoleIds.Contains(a.Id))
.ToListAsync(a => a.Id)
.ConfigureAwait(false);
if (roles.Count != req.RoleIds.Count) {
throw new NetAdminInvalidOperationException(Ln.角色不存在);
}
@ -192,7 +200,10 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
if (!req.DeptIds.NullOrEmpty()) {
// 检查部门是否存在
var depts = await Rpo.Orm.Select<Sys_Dept>().Where(a => req.DeptIds.Contains(a.Id)).ToListAsync(a => a.Id);
var depts = await Rpo.Orm.Select<Sys_Dept>()
.Where(a => req.DeptIds.Contains(a.Id))
.ToListAsync(a => a.Id)
.ConfigureAwait(false);
if (depts.Count != req.DeptIds.Count) {
throw new NetAdminInvalidOperationException(Ln.部门不存在);
}
@ -200,7 +211,10 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
if (!req.UserIds.NullOrEmpty()) {
// 检查用户是否存在
var users = await Rpo.Orm.Select<Sys_User>().Where(a => req.UserIds.Contains(a.Id)).ToListAsync(a => a.Id);
var users = await Rpo.Orm.Select<Sys_User>()
.Where(a => req.UserIds.Contains(a.Id))
.ToListAsync(a => a.Id)
.ConfigureAwait(false);
if (users.Count != req.UserIds.Count) {
throw new NetAdminInvalidOperationException(Ln.用户不存在);
}
@ -233,7 +247,8 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
a.Value.Item2.UserName)
, Avatar = a.Max(a.Value.Item2.Avatar)
}
});
})
.ConfigureAwait(false);
return new PagedQueryRsp<QuerySiteMsgRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgRsp>>());
}

24
src/backend/NetAdmin.SysComponent.Application/Services/Sys/SiteMsgUserService.cs
View File

@ -17,7 +17,7 @@ public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) /
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,7 +26,7 @@ public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) /
/// <inheritdoc />
public async Task<QuerySiteMsgUserRsp> CreateAsync(CreateSiteMsgUserReq req)
{
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QuerySiteMsgUserRsp>();
}
@ -45,14 +45,20 @@ public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) /
/// <inheritdoc />
public async Task<QuerySiteMsgUserRsp> GetAsync(QuerySiteMsgUserReq req)
{
var ret = await QueryInternal(new QueryReq<QuerySiteMsgUserReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QuerySiteMsgUserReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QuerySiteMsgUserRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgUserRsp>>());
@ -61,7 +67,7 @@ public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) /
/// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgUserRsp>> QueryAsync(QueryReq<QuerySiteMsgUserReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QuerySiteMsgUserRsp>>();
}
@ -69,19 +75,19 @@ public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) /
public async Task<QuerySiteMsgUserRsp> UpdateAsync(UpdateSiteMsgUserReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QuerySiteMsgUserRsp;
return await UpdateForSqliteAsync(req).ConfigureAwait(false) as QuerySiteMsgUserRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync().ConfigureAwait(false);
return ret.FirstOrDefault()?.Adapt<QuerySiteMsgUserRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_SiteMsgUser> UpdateForSqliteAsync(Sys_SiteMsgUser req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0
? null
: await GetAsync(new QuerySiteMsgUserReq { Id = req.Id });
: await GetAsync(new QuerySiteMsgUserReq { Id = req.Id }).ConfigureAwait(false);
}
private ISelect<Sys_SiteMsgUser> QueryInternal(QueryReq<QuerySiteMsgUserReq> req)

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

@ -18,7 +18,7 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -28,7 +28,7 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
public async Task<QueryUserProfileRsp> CreateAsync(CreateUserProfileReq req)
{
var entity = req.Adapt<Sys_UserProfile>();
var ret = await Rpo.InsertAsync(entity);
var ret = await Rpo.InsertAsync(entity).ConfigureAwait(false);
return ret.Adapt<QueryUserProfileRsp>();
}
@ -47,7 +47,9 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
/// <inheritdoc />
public async Task<QueryUserProfileRsp> GetAsync(QueryUserProfileReq req)
{
var ret = await QueryInternal(new QueryReq<QueryUserProfileReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryUserProfileReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
return ret.Adapt<QueryUserProfileRsp>();
}
@ -63,7 +65,8 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
, c = new { c.Key, c.Value }
, d = new { d.Key, d.Value }
, e = new { e.Key, e.Value }
});
})
.ConfigureAwait(false);
return new PagedQueryRsp<QueryUserProfileRsp>(req.Page, req.PageSize, total
, list.ConvertAll(
@ -87,7 +90,8 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
, c = new { c.Key, c.Value }
, d = new { d.Key, d.Value }
, e = new { e.Key, e.Value }
});
})
.ConfigureAwait(false);
return ret.ConvertAll(x => x.a.Adapt<QueryUserProfileRsp>() with {
NationArea
= x.b.Key == null
@ -113,19 +117,19 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
{
var entity = req.Adapt<Sys_UserProfile>();
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(entity) as QueryUserProfileRsp;
return await UpdateForSqliteAsync(entity).ConfigureAwait(false) as QueryUserProfileRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(entity).ExecuteUpdatedAsync();
var ret = await Rpo.UpdateDiy.SetSource(entity).ExecuteUpdatedAsync().ConfigureAwait(false);
return ret.FirstOrDefault()?.Adapt<QueryUserProfileRsp>();
}
/// <inheritdoc />
protected override async Task<Sys_UserProfile> UpdateForSqliteAsync(Sys_UserProfile req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0
? null
: await GetAsync(new QueryUserProfileReq { Id = req.Id });
: await GetAsync(new QueryUserProfileReq { Id = req.Id }).ConfigureAwait(false);
}
private ISelect<Sys_UserProfile, Sys_DicContent, Sys_DicContent, Sys_DicContent, Sys_DicContent> QueryInternal(

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

@ -39,7 +39,7 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -48,30 +48,33 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <inheritdoc />
public async Task<bool> CheckMobileAvailableAsync(CheckMobileAvailableReq req)
{
return !await Rpo.Select.Where(a => a.Mobile == req.Mobile && a.Id != req.Id).AnyAsync();
return !await Rpo.Select.Where(a => a.Mobile == req.Mobile && a.Id != req.Id).AnyAsync().ConfigureAwait(false);
}
/// <inheritdoc />
public async Task<bool> CheckUserNameAvailableAsync(CheckUserNameAvailableReq req)
{
return !await Rpo.Select.Where(a => a.UserName == req.UserName && a.Id != req.Id).AnyAsync();
return !await Rpo.Select.Where(a => a.UserName == req.UserName && a.Id != req.Id)
.AnyAsync()
.ConfigureAwait(false);
}
/// <inheritdoc />
public async Task<QueryUserRsp> CreateAsync(CreateUserReq req)
{
await CreateUpdateCheckAsync(req);
await CreateUpdateCheckAsync(req).ConfigureAwait(false);
// 主表
var entity = req.Adapt<Sys_User>();
var dbUser = await Rpo.InsertAsync(entity);
var dbUser = await Rpo.InsertAsync(entity).ConfigureAwait(false);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Roles));
await Rpo.SaveManyAsync(entity, nameof(entity.Roles)).ConfigureAwait(false);
// 档案表
_ = await userProfileService.CreateAsync(req.Profile with { Id = dbUser.Id });
var ret = await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = dbUser.Id } });
_ = await userProfileService.CreateAsync(req.Profile with { Id = dbUser.Id }).ConfigureAwait(false);
var ret = await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = dbUser.Id } })
.ConfigureAwait(false);
return ret.First();
}
@ -81,13 +84,15 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
var effect = 0;
// 删除主表
effect += await Rpo.DeleteAsync(req.Id);
effect += await Rpo.DeleteAsync(req.Id).ConfigureAwait(false);
// 删除分表
effect += await Rpo.Orm.Delete<Sys_UserRole>(new { UserId = req.Id }).ExecuteAffrowsAsync();
effect += await Rpo.Orm.Delete<Sys_UserRole>(new { UserId = req.Id })
.ExecuteAffrowsAsync()
.ConfigureAwait(false);
// 删除档案表
effect += await userProfileService.DeleteAsync(req);
effect += await userProfileService.DeleteAsync(req).ConfigureAwait(false);
return effect;
}
@ -95,13 +100,15 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <inheritdoc />
public async Task<bool> ExistAsync(QueryReq<QueryUserReq> req)
{
return await (await QueryInternalAsync(req)).AnyAsync();
return await (await QueryInternalAsync(req).ConfigureAwait(false)).AnyAsync().ConfigureAwait(false);
}
/// <inheritdoc />
public async Task<QueryUserRsp> GetAsync(QueryUserReq req)
{
var ret = await (await QueryInternalAsync(new QueryReq<QueryUserReq> { Filter = req })).ToOneAsync();
var ret = await (await QueryInternalAsync(new QueryReq<QueryUserReq> { Filter = req }).ConfigureAwait(false))
.ToOneAsync()
.ConfigureAwait(false);
return ret.Adapt<QueryUserRsp>();
}
@ -109,8 +116,12 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
public async Task<QueryUserRsp> GetForUpdateAsync(QueryUserReq req)
{
// ReSharper disable once MethodHasAsyncOverload
return (await QueryInternal(new QueryReq<QueryUserReq> { Filter = req }).ForUpdate().ToOneAsync())
.Adapt<QueryUserRsp>();
#pragma warning disable VSTHRD103
return (await QueryInternal(new QueryReq<QueryUserReq> { Filter = req })
#pragma warning restore VSTHRD103
.ForUpdate()
.ToOneAsync()
.ConfigureAwait(false)).Adapt<QueryUserRsp>();
}
/// <inheritdoc />
@ -123,12 +134,16 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
#pragma warning disable IDE0045
if (new MobileAttribute().IsValid(req.Account)) {
#pragma warning restore IDE0045
dbUser = await Rpo.Where(a => a.Mobile == req.Account && a.Password == pwd).ToOneAsync();
dbUser = await Rpo.Where(a => a.Mobile == req.Account && a.Password == pwd)
.ToOneAsync()
.ConfigureAwait(false);
}
else {
dbUser = new EmailAddressAttribute().IsValid(req.Account)
? await Rpo.Where(a => a.Email == req.Account && a.Password == pwd).ToOneAsync()
: await Rpo.Where(a => a.UserName == req.Account && a.Password == pwd).ToOneAsync();
? await Rpo.Where(a => a.Email == req.Account && a.Password == pwd).ToOneAsync().ConfigureAwait(false)
: await Rpo.Where(a => a.UserName == req.Account && a.Password == pwd)
.ToOneAsync()
.ConfigureAwait(false);
}
return dbUser == null ? throw new NetAdminInvalidOperationException(Ln.用户名或密码错误) : LoginInternal(dbUser);
@ -139,27 +154,30 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <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>()).ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.验证码不正确);
}
var dbUser = await Rpo.Where(a => a.Mobile == req.DestDevice).ToOneAsync();
var dbUser = await Rpo.Where(a => a.Mobile == req.DestDevice).ToOneAsync().ConfigureAwait(false);
return dbUser == null ? throw new NetAdminInvalidOperationException(Ln.用户不存在) : LoginInternal(dbUser);
}
/// <inheritdoc />
public async Task<PagedQueryRsp<QueryUserRsp>> PagedQueryAsync(PagedQueryReq<QueryUserReq> req)
{
var list = await (await QueryInternalAsync(req)).Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync(_selectUserFields);
var list = await (await QueryInternalAsync(req).ConfigureAwait(false)).Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync(_selectUserFields)
.ConfigureAwait(false);
return new PagedQueryRsp<QueryUserRsp>(req.Page, req.PageSize, total, list.Adapt<IEnumerable<QueryUserRsp>>());
}
/// <inheritdoc />
public async Task<IEnumerable<QueryUserRsp>> QueryAsync(QueryReq<QueryUserReq> req)
{
var list = await (await QueryInternalAsync(req)).Take(req.Count).ToListAsync(_selectUserFields);
var list = await (await QueryInternalAsync(req).ConfigureAwait(false)).Take(req.Count)
.ToListAsync(_selectUserFields)
.ConfigureAwait(false);
return list.Adapt<IEnumerable<QueryUserRsp>>();
}
@ -173,12 +191,12 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <exception cref="NetAdminInvalidOperationException">验证码不正确</exception>
public async Task<UserInfoRsp> RegisterAsync(RegisterUserReq req)
{
if (!await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)) {
if (!await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq).ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.验证码不正确);
}
var createReq = req.Adapt<CreateUserReq>() with { Profile = new CreateUserProfileReq() };
return (await CreateAsync(createReq)).Adapt<UserInfoRsp>();
return (await CreateAsync(createReq).ConfigureAwait(false)).Adapt<UserInfoRsp>();
}
/// <inheritdoc />
@ -186,15 +204,17 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <exception cref="NetAdminInvalidOperationException">用户不存在</exception>
public async Task<uint> ResetPasswordAsync(ResetPasswordReq req)
{
return !await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)
return !await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq).ConfigureAwait(false)
? throw new NetAdminInvalidOperationException(Ln.验证码不正确)
: (uint)await Rpo.UpdateDiy
.SetSource((await Rpo.Where(a => a.Mobile == req.VerifySmsCodeReq.DestDevice)
.ToOneAsync(a => new { a.Version, a.Id })).Adapt<Sys_User>() with {
.ToOneAsync(a => new { a.Version, a.Id })
.ConfigureAwait(false)).Adapt<Sys_User>() with {
Password = req.PasswordText.Pwd().Guid()
})
.UpdateColumns(a => a.Password)
.ExecuteAffrowsAsync();
.ExecuteAffrowsAsync()
.ConfigureAwait(false);
}
/// <inheritdoc />
@ -206,16 +226,17 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
, Version = Rpo.Where(a => a.Id == UserToken.Id).ToOne(a => a.Version)
})
.UpdateColumns(a => a.Avatar)
.ExecuteAffrowsAsync() <= 0) {
.ExecuteAffrowsAsync()
.ConfigureAwait(false) <= 0) {
throw new NetAdminUnexpectedException();
}
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } }))
.First()
.Adapt<UserInfoRsp>();
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } })
.ConfigureAwait(false)).First()
.Adapt<UserInfoRsp>();
// 发布用户更新事件
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret));
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret)).ConfigureAwait(false);
return ret;
}
@ -226,7 +247,7 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
// 如果已绑定手机号、需要手机安全验证
if (!user.Mobile.NullOrEmpty()) {
if (!await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)) {
if (!await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq).ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.验证码不正确);
}
@ -238,27 +259,30 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
if (await Rpo.UpdateDiy
.SetSource(new Sys_User { Email = req.DestDevice, Id = UserToken.Id, Version = user.Version })
.UpdateColumns(a => a.Email)
.ExecuteAffrowsAsync() <= 0) {
.ExecuteAffrowsAsync()
.ConfigureAwait(false) <= 0) {
throw new NetAdminUnexpectedException();
}
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } }))
.First()
.Adapt<UserInfoRsp>();
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } })
.ConfigureAwait(false)).First()
.Adapt<UserInfoRsp>();
// 发布用户更新事件
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret));
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret)).ConfigureAwait(false);
return ret;
}
/// <inheritdoc />
public async Task<UserInfoRsp> SetMobileAsync(SetMobileReq req)
{
var user = await Rpo.Where(a => a.Id == UserToken.Id).ToOneAsync(a => new { a.Version, a.Mobile });
var user = await Rpo.Where(a => a.Id == UserToken.Id)
.ToOneAsync(a => new { a.Version, a.Mobile })
.ConfigureAwait(false);
if (!user.Mobile.NullOrEmpty()) {
// 已有手机号，需验证旧手机
if (!await verifyCodeService.VerifyAsync(req.OriginVerifySmsCodeReq)) {
if (!await verifyCodeService.VerifyAsync(req.OriginVerifySmsCodeReq).ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException($"{Ln.旧手机号码验证码不正确}");
}
@ -268,7 +292,7 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
}
// 验证新手机号
if (!await verifyCodeService.VerifyAsync(req.NewVerifySmsCodeReq)) {
if (!await verifyCodeService.VerifyAsync(req.NewVerifySmsCodeReq).ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException($"{Ln.新手机号码验证码不正确}");
}
@ -279,16 +303,17 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
, Mobile = req.NewVerifySmsCodeReq.DestDevice
})
.UpdateColumns(a => a.Mobile)
.ExecuteAffrowsAsync() <= 0) {
.ExecuteAffrowsAsync()
.ConfigureAwait(false) <= 0) {
throw new NetAdminUnexpectedException();
}
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } }))
.First()
.Adapt<UserInfoRsp>();
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } })
.ConfigureAwait(false)).First()
.Adapt<UserInfoRsp>();
// 发布用户更新事件
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret));
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret)).ConfigureAwait(false);
return ret;
}
@ -296,7 +321,8 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
public async Task<uint> SetPasswordAsync(SetPasswordReq req)
{
var version = await Rpo.Where(a => a.Id == UserToken.Id && a.Password == req.OldPassword.Pwd().Guid())
.ToOneAsync(a => new long?(a.Version));
.ToOneAsync(a => new long?(a.Version))
.ConfigureAwait(false);
if (version != null) {
var ret = await Rpo.UpdateDiy
.SetSource(new Sys_User {
@ -305,7 +331,8 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
, Version = version.Value
})
.UpdateColumns(a => a.Password)
.ExecuteAffrowsAsync();
.ExecuteAffrowsAsync()
.ConfigureAwait(false);
return ret <= 0 ? throw new NetAdminUnexpectedException() : (uint)ret;
}
@ -315,7 +342,7 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <inheritdoc />
public async Task<QueryUserRsp> UpdateAsync(UpdateUserReq req)
{
await CreateUpdateCheckAsync(req);
await CreateUpdateCheckAsync(req).ConfigureAwait(false);
// 主表
var entity = req.Adapt<Sys_User>();
@ -324,18 +351,22 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
ignoreCols.Add(nameof(Sys_User.Password));
}
_ = await Rpo.UpdateDiy.SetSource(entity).IgnoreColumns(ignoreCols.ToArray()).ExecuteAffrowsAsync();
_ = await Rpo.UpdateDiy.SetSource(entity)
.IgnoreColumns(ignoreCols.ToArray())
.ExecuteAffrowsAsync()
.ConfigureAwait(false);
// 档案表
_ = await userProfileService.UpdateAsync(req.Profile);
_ = await userProfileService.UpdateAsync(req.Profile).ConfigureAwait(false);
// 分表
await Rpo.SaveManyAsync(entity, nameof(entity.Roles));
await Rpo.SaveManyAsync(entity, nameof(entity.Roles)).ConfigureAwait(false);
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = req.Id } })).First();
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = req.Id } })
.ConfigureAwait(false)).First();
// 发布用户更新事件
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret.Adapt<UserInfoRsp>()));
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret.Adapt<UserInfoRsp>())).ConfigureAwait(false);
return ret;
}
@ -356,7 +387,8 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
.IncludeMany(a => a.Menus)
.IncludeMany(a => a.Depts)
.IncludeMany(a => a.Apis))
.ToOneAsync();
.ToOneAsync()
.ConfigureAwait(false);
return dbUser.Adapt<UserInfoRsp>();
}
@ -388,13 +420,18 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
var roles = await Rpo.Orm.Select<Sys_Role>()
.ForUpdate()
.Where(a => req.RoleIds.Contains(a.Id))
.ToListAsync(a => a.Id);
.ToListAsync(a => a.Id)
.ConfigureAwait(false);
if (roles.Count != req.RoleIds.Count) {
throw new NetAdminInvalidOperationException(Ln.角色不存在);
}
// 检查部门是否存在
var dept = await Rpo.Orm.Select<Sys_Dept>().ForUpdate().Where(a => req.DeptId == a.Id).ToListAsync(a => a.Id);
var dept = await Rpo.Orm.Select<Sys_Dept>()
.ForUpdate()
.Where(a => req.DeptId == a.Id)
.ToListAsync(a => a.Id)
.ConfigureAwait(false);
if (dept.Count != 1) {
throw new NetAdminInvalidOperationException(Ln.部门不存在);
@ -420,7 +457,8 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
deptIds = await Rpo.Orm.Select<Sys_Dept>()
.Where(a => a.Id == req.Filter.DeptId)
.AsTreeCte()
.ToListAsync(a => a.Id);
.ToListAsync(a => a.Id)
.ConfigureAwait(false);
}
var ret = Rpo.Select.Include(a => a.Dept)

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

@ -21,7 +21,7 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -30,12 +30,12 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
/// <inheritdoc />
public async Task<QueryVerifyCodeRsp> CreateAsync(CreateVerifyCodeReq req)
{
var entity = await Rpo.InsertAsync(req);
var entity = await Rpo.InsertAsync(req).ConfigureAwait(false);
var ret = entity.Adapt<QueryVerifyCodeRsp>();
// 发布验证码创建事件
await eventPublisher.PublishAsync(new VerifyCodeCreatedEvent(ret));
await eventPublisher.PublishAsync(new VerifyCodeCreatedEvent(ret)).ConfigureAwait(false);
return ret;
}
@ -55,14 +55,20 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
/// <inheritdoc />
public async Task<QueryVerifyCodeRsp> GetAsync(QueryVerifyCodeReq req)
{
var ret = await QueryInternal(new QueryReq<QueryVerifyCodeReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryVerifyCodeReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
return ret.Adapt<QueryVerifyCodeRsp>();
}
/// <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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QueryVerifyCodeRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryVerifyCodeRsp>>());
@ -71,14 +77,14 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
/// <inheritdoc />
public async Task<IEnumerable<QueryVerifyCodeRsp>> QueryAsync(QueryReq<QueryVerifyCodeReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryVerifyCodeRsp>>();
}
/// <inheritdoc />
public async Task<SendVerifyCodeRsp> SendVerifyCodeAsync(SendVerifyCodeReq req)
{
var lastSent = await GetLastSentAsync(req.DestDevice);
var lastSent = await GetLastSentAsync(req.DestDevice).ConfigureAwait(false);
QueryVerifyCodeRsp ret;
@ -90,11 +96,12 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
#endif
if (lastSent != null && lastSent.Status != VerifyCodeStatues.Verified) { // 上次发送未验证，生成相同code
ret = await CreateAsync(req.Adapt<CreateVerifyCodeReq>() with { Code = lastSent.Code });
ret = await CreateAsync(req.Adapt<CreateVerifyCodeReq>() with { Code = lastSent.Code })
.ConfigureAwait(false);
}
else { // 生成新的code
var code = _randRange.Rand().ToString(CultureInfo.InvariantCulture).PadLeft(4, '0');
ret = await CreateAsync(req.Adapt<CreateVerifyCodeReq>() with { Code = code });
ret = await CreateAsync(req.Adapt<CreateVerifyCodeReq>() with { Code = code }).ConfigureAwait(false);
}
return ret.Adapt<SendVerifyCodeRsp>();
@ -104,10 +111,10 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
public async Task<QueryVerifyCodeRsp> UpdateAsync(UpdateVerifyCodeReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QueryVerifyCodeRsp;
return await UpdateForSqliteAsync(req).ConfigureAwait(false) as QueryVerifyCodeRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync().ConfigureAwait(false);
return ret.FirstOrDefault()?.Adapt<QueryVerifyCodeRsp>();
}
@ -123,14 +130,15 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
return true;
}
var lastSent = await GetLastSentAsync(req.DestDevice);
var lastSent = await GetLastSentAsync(req.DestDevice).ConfigureAwait(false);
if (lastSent is not { Status: VerifyCodeStatues.Sent } || req.Code != lastSent.Code ||
(DateTime.UtcNow - lastSent.CreatedTime).TotalMinutes > 10) {
return false;
}
_ = await UpdateAsync((lastSent with { Status = VerifyCodeStatues.Verified }).Adapt<UpdateVerifyCodeReq>());
_ = await UpdateAsync((lastSent with { Status = VerifyCodeStatues.Verified }).Adapt<UpdateVerifyCodeReq>())
.ConfigureAwait(false);
return true;
}
@ -138,9 +146,9 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
/// <inheritdoc />
protected override async Task<Sys_VerifyCode> UpdateForSqliteAsync(Sys_VerifyCode req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0
? null
: await GetAsync(new QueryVerifyCodeReq { Id = req.Id });
: await GetAsync(new QueryVerifyCodeReq { Id = req.Id }).ConfigureAwait(false);
}
private Task<Sys_VerifyCode> GetLastSentAsync(string destDevice)

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

@ -17,7 +17,7 @@ public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
{
var sum = 0;
foreach (var item in req.Items) {
sum += await DeleteAsync(item);
sum += await DeleteAsync(item).ConfigureAwait(false);
}
return sum;
@ -26,7 +26,7 @@ public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
/// <inheritdoc />
public async Task<QueryExampleRsp> CreateAsync(CreateExampleReq req)
{
var ret = await Rpo.InsertAsync(req);
var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryExampleRsp>();
}
@ -45,14 +45,20 @@ public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
/// <inheritdoc />
public async Task<QueryExampleRsp> GetAsync(QueryExampleReq req)
{
var ret = await QueryInternal(new QueryReq<QueryExampleReq> { Filter = req }).ToOneAsync();
var ret = await QueryInternal(new QueryReq<QueryExampleReq> { Filter = req })
.ToOneAsync()
.ConfigureAwait(false);
return ret.Adapt<QueryExampleRsp>();
}
/// <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();
var list = await QueryInternal(req)
.Page(req.Page, req.PageSize)
.Count(out var total)
.ToListAsync()
.ConfigureAwait(false);
return new PagedQueryRsp<QueryExampleRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryExampleRsp>>());
@ -61,7 +67,7 @@ public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
/// <inheritdoc />
public async Task<IEnumerable<QueryExampleRsp>> QueryAsync(QueryReq<QueryExampleReq> req)
{
var ret = await QueryInternal(req).Take(req.Count).ToListAsync();
var ret = await QueryInternal(req).Take(req.Count).ToListAsync().ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryExampleRsp>>();
}
@ -69,19 +75,19 @@ public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
public async Task<QueryExampleRsp> UpdateAsync(UpdateExampleReq req)
{
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) {
return await UpdateForSqliteAsync(req) as QueryExampleRsp;
return await UpdateForSqliteAsync(req).ConfigureAwait(false) as QueryExampleRsp;
}
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync();
var ret = await Rpo.UpdateDiy.SetSource(req).ExecuteUpdatedAsync().ConfigureAwait(false);
return ret.FirstOrDefault()?.Adapt<QueryExampleRsp>();
}
/// <inheritdoc />
protected override async Task<Tpl_Example> UpdateForSqliteAsync(Tpl_Example req)
{
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync() <= 0
return await Rpo.UpdateDiy.SetSource(req).ExecuteAffrowsAsync().ConfigureAwait(false) <= 0
? null
: await GetAsync(new QueryExampleReq { Id = req.Id });
: await GetAsync(new QueryExampleReq { Id = req.Id }).ConfigureAwait(false);
}
private ISelect<Tpl_Example> QueryInternal(QueryReq<QueryExampleReq> req)