lingyun/NetAdmin
lingyun/NetAdmin
Template
6
0
Fork 0
mirror of https://github.com/nsnail/NetAdmin.git synced 2025-04-23 14:42:51 +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
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
55 changed files with 545 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
code.quality.props
View File

@ -15,6 +15,10 @@
<PrivateAssets>all</PrivateAssets> <PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference> </PackageReference>
<PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.8.14">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Roslynator.Analyzers" Version="4.6.2"> <PackageReference Include="Roslynator.Analyzers" Version="4.6.2">
<PrivateAssets>all</PrivateAssets> <PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

4
dotnet-tools.json
View File

@ -9,13 +9,13 @@
] ]
}, },
"cake.tool": { "cake.tool": {
"version": "3.2.0", "version": "4.0.0",
"commands": [ "commands": [
"dotnet-cake" "dotnet-cake"
] ]
}, },
"dotnet-script": { "dotnet-script": {
"version": "1.4.0", "version": "1.5.0",
"commands": [ "commands": [
"dotnet-script" "dotnet-script"
] ]

4
src/backend/NetAdmin.BizServer.Host/Extensions/IApplicationBuilderExtensions.cs
View File

@ -56,11 +56,11 @@ public static class IApplicationBuilderExtensions
if (output != null) { if (output != null) {
context.Response.ContentLength = output.Length; context.Response.ContentLength = output.Length;
context.Response.ContentType = MimeTypeHelper.GetMimeTypeByExtName(_regex.Match(path!).Groups[1].Value); context.Response.ContentType = MimeTypeHelper.GetMimeTypeByExtName(_regex.Match(path!).Groups[1].Value);
await output.CopyToAsync(context.Response.Body); await output.CopyToAsync(context.Response.Body).ConfigureAwait(false);
return; return;
} }
} }
await next.Invoke(); await next.Invoke().ConfigureAwait(false);
} }
} }

2
src/backend/NetAdmin.BizServer.Host/Filters/JwtHandler.cs
View File

@ -23,7 +23,7 @@ public sealed class JwtHandler : AppAuthorizeHandler
} }
// 数据库不存在context user，或用户已被禁用，拒绝访问 // 数据库不存在context user，或用户已被禁用，拒绝访问
var userInfo = await App.GetService<IUserCache>().UserInfoAsync(); var userInfo = await App.GetService<IUserCache>().UserInfoAsync().ConfigureAwait(false);
if (userInfo?.Roles == null) { if (userInfo?.Roles == null) {
return false; return false;
} }

11
src/backend/NetAdmin.BizServer.Tests/AllTests.cs
View File

@ -32,7 +32,7 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
[Fact] [Fact]
public async Task<CacheStatisticsRsp> CacheStatisticsAsync() public async Task<CacheStatisticsRsp> CacheStatisticsAsync()
{ {
var rsp = await PostAsync("/api/sys/cache/cache.statistics", null); var rsp = await PostAsync("/api/sys/cache/cache.statistics", null).ConfigureAwait(false);
Assert.Equal(HttpStatusCode.OK, rsp.StatusCode); Assert.Equal(HttpStatusCode.OK, rsp.StatusCode);
return default; return default;
} }
@ -73,7 +73,8 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
public async Task<PagedQueryRsp<GetAllEntriesRsp>> GetAllEntriesAsync(PagedQueryReq<GetAllEntriesReq> req) public async Task<PagedQueryRsp<GetAllEntriesRsp>> GetAllEntriesAsync(PagedQueryReq<GetAllEntriesReq> req)
{ {
var rsp = await PostAsync("/api/sys/cache/get.all.entries" var rsp = await PostAsync("/api/sys/cache/get.all.entries"
, JsonContent.Create(new PagedQueryReq<GetAllEntriesReq>())); , JsonContent.Create(new PagedQueryReq<GetAllEntriesReq>()))
.ConfigureAwait(false);
Assert.Equal(HttpStatusCode.OK, rsp.StatusCode); Assert.Equal(HttpStatusCode.OK, rsp.StatusCode);
return default; return default;
} }
@ -106,7 +107,7 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
[Fact] [Fact]
public async Task<DateTime> GetServerUtcTimeAsync() public async Task<DateTime> GetServerUtcTimeAsync()
{ {
var response = await PostAsync("/api/sys/tools/get.server.utc.time", null); var response = await PostAsync("/api/sys/tools/get.server.utc.time", null).ConfigureAwait(false);
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
return default; return default;
} }
@ -115,7 +116,7 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
[Fact] [Fact]
public async Task<string> GetVersionAsync() public async Task<string> GetVersionAsync()
{ {
var response = await PostAsync("/api/sys/tools/version", null); var response = await PostAsync("/api/sys/tools/version", null).ConfigureAwait(false);
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
return default; return default;
} }
@ -154,7 +155,7 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
[Fact] [Fact]
public async Task SyncAsync() public async Task SyncAsync()
{ {
var response = await PostAsync("/api/sys/api/sync", null); var response = await PostAsync("/api/sys/api/sync", null).ConfigureAwait(false);
Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(HttpStatusCode.OK, response.StatusCode);
} }

8
src/backend/NetAdmin.Cache/DistributedCache.cs
View File

@ -45,7 +45,7 @@ public abstract class DistributedCache<TService> : CacheBase<IDistributedCache,
/// </summary> /// </summary>
protected async Task<T> GetAsync<T>(string key) protected async Task<T> GetAsync<T>(string key)
{ {
var cacheRead = await Cache.GetStringAsync(key); var cacheRead = await Cache.GetStringAsync(key).ConfigureAwait(false);
return cacheRead != null ? cacheRead.ToObject<T>() : default; return cacheRead != null ? cacheRead.ToObject<T>() : default;
} }
@ -69,19 +69,19 @@ public abstract class DistributedCache<TService> : CacheBase<IDistributedCache,
protected async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> createProc, TimeSpan? absLifeTime = null protected async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> createProc, TimeSpan? absLifeTime = null
, TimeSpan? slideLifeTime = null) , TimeSpan? slideLifeTime = null)
{ {
var cacheRead = await GetAsync<T>(key); var cacheRead = await GetAsync<T>(key).ConfigureAwait(false);
if (cacheRead is not null) { if (cacheRead is not null) {
return cacheRead; return cacheRead;
} }
var obj = await createProc.Invoke(); var obj = await createProc.Invoke().ConfigureAwait(false);
var cacheWrite = obj?.ToJson(); var cacheWrite = obj?.ToJson();
if (cacheWrite == null) { if (cacheWrite == null) {
return obj; return obj;
} }
await CreateAsync(key, obj, absLifeTime, slideLifeTime); await CreateAsync(key, obj, absLifeTime, slideLifeTime).ConfigureAwait(false);
return obj; return obj;
} }

4
src/backend/NetAdmin.Domain/Contexts/ContextApp.cs
View File

@ -66,7 +66,7 @@ public sealed record ContextApp : DataAbstraction, IValidatableObject
// 具有secret的情况下，自动生成时间戳+sign，方便调试 // 具有secret的情况下，自动生成时间戳+sign，方便调试
if (!ret.AppSecret.NullOrEmpty()) { if (!ret.AppSecret.NullOrEmpty()) {
ret.Timestamp = DateTime.Now.TimeUnixUtc(); ret.Timestamp = DateTime.Now.TimeUnixUtc();
ret.Sign = await ret.BuildSignFromHttpContextAsync(); ret.Sign = await ret.BuildSignFromHttpContextAsync().ConfigureAwait(false);
} }
return ret; return ret;
@ -88,7 +88,7 @@ public sealed record ContextApp : DataAbstraction, IValidatableObject
public async Task<string> BuildSignFromHttpContextAsync() public async Task<string> BuildSignFromHttpContextAsync()
{ {
var sr = new StreamReader(App.HttpContext.Request.Body); var sr = new StreamReader(App.HttpContext.Request.Body);
var reqBody = await sr.ReadToEndAsync(); var reqBody = await sr.ReadToEndAsync().ConfigureAwait(false);
_ = App.HttpContext.Request.Body.Seek(0, SeekOrigin.Begin); _ = App.HttpContext.Request.Body.Seek(0, SeekOrigin.Begin);
return BuildSign(reqBody); return BuildSign(reqBody);

6
src/backend/NetAdmin.Host/BackgroundRunning/WorkBase.cs
View File

@ -58,15 +58,15 @@ public abstract class WorkBase<TLogger>
{ {
if (singleInstance) { if (singleInstance) {
// 加锁 // 加锁
await using var redLock = await GetLockerAsync(GetType().FullName); await using var redLock = await GetLockerAsync(GetType().FullName).ConfigureAwait(false);
if (!redLock.IsAcquired) { if (!redLock.IsAcquired) {
throw new NetAdminGetLockerException(); throw new NetAdminGetLockerException();
} }
await WorkflowAsync(cancelToken); await WorkflowAsync(cancelToken).ConfigureAwait(false);
return; return;
} }
await WorkflowAsync(cancelToken); await WorkflowAsync(cancelToken).ConfigureAwait(false);
} }
} }

4
src/backend/NetAdmin.Host/Extensions/HttpContextExtensions.cs
View File

@ -24,11 +24,11 @@ public static class HttpContextExtensions
_ = me.Response.Body.Seek(0, SeekOrigin.Begin); _ = me.Response.Body.Seek(0, SeekOrigin.Begin);
var sr = new StreamReader(me.Response.Body); var sr = new StreamReader(me.Response.Body);
var bodyString = await sr.ReadToEndAsync(); var bodyString = await sr.ReadToEndAsync().ConfigureAwait(false);
bodyString = _nullRegex.Replace(bodyString, string.Empty).Replace(",}", "}"); bodyString = _nullRegex.Replace(bodyString, string.Empty).Replace(",}", "}");
_ = me.Response.Body.Seek(0, SeekOrigin.Begin); _ = me.Response.Body.Seek(0, SeekOrigin.Begin);
var bytes = Encoding.UTF8.GetBytes(bodyString); var bytes = Encoding.UTF8.GetBytes(bodyString);
me.Response.Body.SetLength(bytes.Length); me.Response.Body.SetLength(bytes.Length);
await me.Response.Body.WriteAsync(bytes); await me.Response.Body.WriteAsync(bytes).ConfigureAwait(false);
} }
} }

3
src/backend/NetAdmin.Host/Extensions/ServiceCollectionExtensions.cs
View File

@ -164,6 +164,8 @@ public static class ServiceCollectionExtensions
freeSql.Aop.AuditValue += sqlAuditor.DataAuditHandler; // Insert/Update自动值处理 freeSql.Aop.AuditValue += sqlAuditor.DataAuditHandler; // Insert/Update自动值处理
var eventPublisher = App.GetService<IEventPublisher>(); var eventPublisher = App.GetService<IEventPublisher>();
#pragma warning disable VSTHRD110
// AOP事件发布（异步） // AOP事件发布（异步）
freeSql.Aop.CommandBefore freeSql.Aop.CommandBefore
+= (_, e) => eventPublisher.PublishAsync(new SqlCommandBeforeEvent(e)); // 增删查改，执行命令之前触发 += (_, e) => eventPublisher.PublishAsync(new SqlCommandBeforeEvent(e)); // 增删查改，执行命令之前触发
@ -175,6 +177,7 @@ public static class ServiceCollectionExtensions
freeSql.Aop.SyncStructureAfter += (_, e) => freeSql.Aop.SyncStructureAfter += (_, e) =>
eventPublisher.PublishAsync(new SyncStructureAfterEvent(e)); // CodeFirst迁移，执行完成触发 eventPublisher.PublishAsync(new SyncStructureAfterEvent(e)); // CodeFirst迁移，执行完成触发
#pragma warning restore VSTHRD110
// 全局过滤器设置 // 全局过滤器设置
freeSqlConfig?.Invoke(freeSql); freeSqlConfig?.Invoke(freeSql);

2
src/backend/NetAdmin.Host/Extensions/UnitOfWorkManagerExtensions.cs
View File

@ -17,7 +17,7 @@ public static class UnitOfWorkManagerExtensions
#if DEBUG #if DEBUG
logger?.Debug($"{Ln.开始事务}: {hashCode}"); logger?.Debug($"{Ln.开始事务}: {hashCode}");
#endif #endif
await handle(); await handle().ConfigureAwait(false);
unitOfWork.Commit(); unitOfWork.Commit();
logger?.Info($"{Ln.事务已提交}: {hashCode}"); logger?.Info($"{Ln.事务已提交}: {hashCode}");
} }

4
src/backend/NetAdmin.Host/Filters/ApiResultHandler.cs
View File

@ -35,7 +35,7 @@ public abstract class ApiResultHandler<T>
/// <summary> /// <summary>
/// HTTP状态码处理 /// HTTP状态码处理
/// </summary> /// </summary>
#pragma warning disable ASA001 #pragma warning disable ASA001, VSTHRD200
public Task OnResponseStatusCodes( // public Task OnResponseStatusCodes( //
HttpContext context, int statusCode, UnifyResultSettingsOptions unifyResultSettings = null) HttpContext context, int statusCode, UnifyResultSettingsOptions unifyResultSettings = null)
{ {
@ -44,6 +44,8 @@ public abstract class ApiResultHandler<T>
return Task.CompletedTask; return Task.CompletedTask;
} }
#pragma warning restore ASA001, VSTHRD200
/// <summary> /// <summary>
/// 请求成功 /// 请求成功
/// </summary> /// </summary>

7
src/backend/NetAdmin.Host/Filters/TransactionInterceptor.cs
View File

@ -15,16 +15,17 @@ public sealed class TransactionInterceptor(UnitOfWorkManager uowManager) : IAsyn
// 跳过没有事务特性标记的方法 // 跳过没有事务特性标记的方法
if (context.HttpContext.GetControllerActionDescriptor().MethodInfo.GetCustomAttribute<TransactionAttribute>() == if (context.HttpContext.GetControllerActionDescriptor().MethodInfo.GetCustomAttribute<TransactionAttribute>() ==
null) { null) {
_ = await next(); _ = await next().ConfigureAwait(false);
return; return;
} }
// 事务操作 // 事务操作
await uowManager.AtomicOperateAsync(async () => { await uowManager.AtomicOperateAsync(async () => {
var result = await next(); var result = await next().ConfigureAwait(false);
if (result.Exception != null) { if (result.Exception != null) {
throw result.Exception; throw result.Exception;
} }
}); })
.ConfigureAwait(false);
} }
} }

4
src/backend/NetAdmin.Host/Middlewares/RemoveNullNodeMiddleware.cs
View File

@ -13,12 +13,12 @@ public sealed class RemoveNullNodeMiddleware(RequestDelegate next)
/// </summary> /// </summary>
public async Task InvokeAsync(HttpContext context) public async Task InvokeAsync(HttpContext context)
{ {
await next(context); await next(context).ConfigureAwait(false);
if (context.GetMetadata<RemoveNullNodeAttribute>() is null) { if (context.GetMetadata<RemoveNullNodeAttribute>() is null) {
return; return;
} }
await context.RemoveJsonNodeWithNullValueAsync(); await context.RemoveJsonNodeWithNullValueAsync().ConfigureAwait(false);
} }
} }

11
src/backend/NetAdmin.Host/Middlewares/RequestAuditMiddleware.cs
View File

@ -27,7 +27,7 @@ public sealed class RequestAuditMiddleware(RequestDelegate next
if (!context.Request.Path.StartsWithSegments(_defaultRoutePrefix) // 非api请求 if (!context.Request.Path.StartsWithSegments(_defaultRoutePrefix) // 非api请求
|| context.Request.Path.StartsWithSegments(_healthCheckRoutePrefix) // 健康检查 || context.Request.Path.StartsWithSegments(_healthCheckRoutePrefix) // 健康检查
|| context.Request.Method == Chars.FLG_HTTP_METHOD_OPTIONS) { // is options 请求 || context.Request.Method == Chars.FLG_HTTP_METHOD_OPTIONS) { // is options 请求
await next(context); await next(context).ConfigureAwait(false);
return; return;
} }
@ -40,14 +40,14 @@ public sealed class RequestAuditMiddleware(RequestDelegate next
// 调用下一个中间件 // 调用下一个中间件
var sw = Stopwatch.StartNew(); var sw = Stopwatch.StartNew();
await next(context); await next(context).ConfigureAwait(false);
sw.Stop(); sw.Stop();
_ = ms.Seek(0, SeekOrigin.Begin); _ = ms.Seek(0, SeekOrigin.Begin);
using var sr = new StreamReader(ms); using var sr = new StreamReader(ms);
var responseBody = await sr.ReadToEndAsync(); var responseBody = await sr.ReadToEndAsync().ConfigureAwait(false);
_ = ms.Seek(0, SeekOrigin.Begin); _ = ms.Seek(0, SeekOrigin.Begin);
await ms.CopyToAsync(stream); await ms.CopyToAsync(stream).ConfigureAwait(false);
context.Response.Body = stream; context.Response.Body = stream;
var exception = context.Features.Get<IExceptionHandlerFeature>(); var exception = context.Features.Get<IExceptionHandlerFeature>();
@ -56,6 +56,7 @@ public sealed class RequestAuditMiddleware(RequestDelegate next
?.Enum<ErrorCodes>() ?? 0; ?.Enum<ErrorCodes>() ?? 0;
_ = await requestLogger.LogAsync(context, (long)sw.Elapsed.TotalMicroseconds, responseBody, errorCode _ = await requestLogger.LogAsync(context, (long)sw.Elapsed.TotalMicroseconds, responseBody, errorCode
, exception); , exception)
.ConfigureAwait(false);
} }
} }

4
src/backend/NetAdmin.Host/Utils/RequestLogger.cs
View File

@ -35,7 +35,7 @@ public sealed class RequestLogger(ILogger<RequestLogger>
_textContentTypes _textContentTypes
, x => context.Request.ContentType?.Contains( , x => context.Request.ContentType?.Contains(
x, StringComparison.OrdinalIgnoreCase) ?? false) x, StringComparison.OrdinalIgnoreCase) ?? false)
? await context.ReadBodyContentAsync() ? await context.ReadBodyContentAsync().ConfigureAwait(false)
: string.Empty : string.Empty
, RequestUrl = context.Request.GetRequestUrlAddress() , RequestUrl = context.Request.GetRequestUrlAddress()
, ResponseBody = responseBody , ResponseBody = responseBody
@ -57,7 +57,7 @@ public sealed class RequestLogger(ILogger<RequestLogger>
logger.Info(auditData); logger.Info(auditData);
// 发布请求日志事件 // 发布请求日志事件
await eventPublisher.PublishAsync(new RequestLogEvent(auditData)); await eventPublisher.PublishAsync(new RequestLogEvent(auditData)).ConfigureAwait(false);
return auditData; return auditData;
} }

4
src/backend/NetAdmin.Infrastructure/Extensions/HttpRequestMessageExtensions.cs
View File

@ -10,7 +10,7 @@ public static class HttpRequestMessageExtensions
/// </summary> /// </summary>
public static async Task<string> BuildJsonAsync(this HttpRequestMessage me) public static async Task<string> BuildJsonAsync(this HttpRequestMessage me)
{ {
var body = me?.Content == null ? null : await me.Content!.ReadAsStringAsync(); var body = me?.Content == null ? null : await me.Content!.ReadAsStringAsync().ConfigureAwait(false);
return new { Uri = me?.RequestUri, Header = me?.ToString(), Body = body }.ToJson(); return new { Uri = me?.RequestUri, Header = me?.ToString(), Body = body }.ToJson();
} }
@ -19,7 +19,7 @@ public static class HttpRequestMessageExtensions
/// </summary> /// </summary>
public static async Task<HttpRequestMessage> LogAsync<T>(this HttpRequestMessage me, ILogger<T> logger) public static async Task<HttpRequestMessage> LogAsync<T>(this HttpRequestMessage me, ILogger<T> logger)
{ {
logger.Info($"{Ln.请求}: {await me.BuildJsonAsync()}"); logger.Info($"{Ln.请求}: {await me.BuildJsonAsync().ConfigureAwait(false)}");
return me; return me;
} }
} }

30
src/backend/NetAdmin.Infrastructure/Extensions/HttpRequestPartExtensions.cs
View File

@ -13,23 +13,25 @@ public static class HttpRequestPartExtensions
public static HttpRequestPart SetLog<T>(this HttpRequestPart me, ILogger<T> logger public static HttpRequestPart SetLog<T>(this HttpRequestPart me, ILogger<T> logger
, Func<string, string> bodyHandle = null) , Func<string, string> bodyHandle = null)
{ {
async void RequestHandle(HttpClient _, HttpRequestMessage req) #pragma warning disable S1172
Task RequestHandle(HttpClient _, HttpRequestMessage req)
{ {
#pragma warning disable IDE0058 return req.LogAsync(logger);
await req.LogAsync(logger);
#pragma warning restore IDE0058
} }
Task ExceptionHandle(HttpClient _, HttpResponseMessage rsp, string errors)
{
return rsp.LogExceptionAsync(errors, logger, bodyHandle);
}
Task ResponseHandle(HttpClient _, HttpResponseMessage rsp)
{
return rsp.LogAsync(logger, bodyHandle);
}
#pragma warning restore S1172
return me.OnRequesting(RequestHandle).OnResponsing(ResponseHandle).OnException(ExceptionHandle); return me.OnRequesting(RequestHandle).OnResponsing(ResponseHandle).OnException(ExceptionHandle);
async void ExceptionHandle(HttpClient _, HttpResponseMessage rsp, string errors)
{
await rsp.LogExceptionAsync(errors, logger, bodyHandle);
}
async void ResponseHandle(HttpClient _, HttpResponseMessage rsp)
{
await rsp.LogAsync(logger, bodyHandle);
}
} }
} }

6
src/backend/NetAdmin.Infrastructure/Extensions/HttpResponseMessageExtensions.cs
View File

@ -11,7 +11,7 @@ public static class HttpResponseMessageExtensions
public static async Task LogAsync<T>(this HttpResponseMessage me, ILogger<T> logger public static async Task LogAsync<T>(this HttpResponseMessage me, ILogger<T> logger
, Func<string, string> bodyPreHandle = null) , Func<string, string> bodyPreHandle = null)
{ {
logger.Info(await me.BuildJsonAsync(bodyPreHandle)); logger.Info(await me.BuildJsonAsync(bodyPreHandle).ConfigureAwait(false));
} }
/// <summary> /// <summary>
@ -20,7 +20,7 @@ public static class HttpResponseMessageExtensions
public static async Task LogExceptionAsync<T>(this HttpResponseMessage me, string errors, ILogger<T> logger public static async Task LogExceptionAsync<T>(this HttpResponseMessage me, string errors, ILogger<T> logger
, Func<string, string> bodyHandle = null) , Func<string, string> bodyHandle = null)
{ {
logger.Warn($"{errors}: {await me.BuildJsonAsync(bodyHandle)}"); logger.Warn($"{errors}: {await me.BuildJsonAsync(bodyHandle).ConfigureAwait(false)}");
} }
/// <summary> /// <summary>
@ -29,7 +29,7 @@ public static class HttpResponseMessageExtensions
private static async Task<string> BuildJsonAsync( // private static async Task<string> BuildJsonAsync( //
this HttpResponseMessage me, Func<string, string> bodyHandle = null) this HttpResponseMessage me, Func<string, string> bodyHandle = null)
{ {
var body = me?.Content is null ? null : await me.Content!.ReadAsStringAsync(); var body = me?.Content is null ? null : await me.Content!.ReadAsStringAsync().ConfigureAwait(false);
return new { Header = me?.ToString(), Body = bodyHandle is null ? body : bodyHandle(body) }.ToJson(); return new { Header = me?.ToString(), Body = bodyHandle is null ? body : bodyHandle(body) }.ToJson();
} }
} }

6
src/backend/NetAdmin.Infrastructure/NetAdmin.Infrastructure.csproj
View File

@ -8,9 +8,9 @@
<ItemGroup> <ItemGroup>
<PackageReference Include="FreeSql.DbContext.NS" Version="3.2.802-preview20231010-ns1"/> <PackageReference Include="FreeSql.DbContext.NS" Version="3.2.802-preview20231010-ns1"/>
<PackageReference Include="FreeSql.Provider.Sqlite.NS" Version="3.2.802-preview20231010-ns1"/> <PackageReference Include="FreeSql.Provider.Sqlite.NS" Version="3.2.802-preview20231010-ns1"/>
<PackageReference Include="Furion.Extras.Authentication.JwtBearer" Version="4.9.1"/> <PackageReference Include="Furion.Extras.Authentication.JwtBearer" Version="4.9.1.5"/>
<PackageReference Include="Furion.Extras.ObjectMapper.Mapster.NS" Version="4.9.1-ns1"/> <PackageReference Include="Furion.Extras.ObjectMapper.Mapster.NS" Version="4.9.1.5-ns1"/>
<PackageReference Include="Furion.Pure.NS" Version="4.9.1-ns1"/> <PackageReference Include="Furion.Pure.NS" Version="4.9.1.5-ns1"/>
<PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="8.0.0"/> <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="8.0.0"/>
<PackageReference Include="NSExt" Version="1.1.0"/> <PackageReference Include="NSExt" Version="1.1.0"/>
<PackageReference Include="RedLock.net" Version="2.3.2"/> <PackageReference Include="RedLock.net" Version="2.3.2"/>

6
src/backend/NetAdmin.Infrastructure/Utils/CaptchaImageHelper.cs
View File

@ -39,12 +39,12 @@ public static class CaptchaImageHelper
await using var tranStream = resAsm.GetManifestResourceStream($"{tempPath}._{templateIndex}.transparent.png"); await using var tranStream = resAsm.GetManifestResourceStream($"{tempPath}._{templateIndex}.transparent.png");
// 底图 // 底图
using var backgroundImage = await Image.LoadAsync<Rgba32>(bgStream); using var backgroundImage = await Image.LoadAsync<Rgba32>(bgStream).ConfigureAwait(false);
using var darkTemplateImage = await Image.LoadAsync<Rgba32>(darkStream); using var darkTemplateImage = await Image.LoadAsync<Rgba32>(darkStream).ConfigureAwait(false);
// 透明模板图 // 透明模板图
using var transparentTemplateImage = await Image.LoadAsync<Rgba32>(tranStream); using var transparentTemplateImage = await Image.LoadAsync<Rgba32>(tranStream).ConfigureAwait(false);
// 调整模板图大小 // 调整模板图大小
darkTemplateImage.Mutate(x => x.Resize(sliderSize)); darkTemplateImage.Mutate(x => x.Resize(sliderSize));

6
src/backend/NetAdmin.Infrastructure/Utils/MinioHelper.cs
View File

@ -26,9 +26,9 @@ public sealed class MinioHelper(IOptions<UploadOptions> uploadOptions) : IScoped
var beArgs = new BucketExistsArgs().WithBucket(uploadOptions.Value.Minio.BucketName); var beArgs = new BucketExistsArgs().WithBucket(uploadOptions.Value.Minio.BucketName);
if (!await minio.BucketExistsAsync(beArgs)) { if (!await minio.BucketExistsAsync(beArgs).ConfigureAwait(false)) {
var mbArgs = new MakeBucketArgs().WithBucket(uploadOptions.Value.Minio.BucketName); var mbArgs = new MakeBucketArgs().WithBucket(uploadOptions.Value.Minio.BucketName);
await minio.MakeBucketAsync(mbArgs); await minio.MakeBucketAsync(mbArgs).ConfigureAwait(false);
} }
var putArgs = new PutObjectArgs().WithBucket(uploadOptions.Value.Minio.BucketName) var putArgs = new PutObjectArgs().WithBucket(uploadOptions.Value.Minio.BucketName)
@ -36,7 +36,7 @@ public sealed class MinioHelper(IOptions<UploadOptions> uploadOptions) : IScoped
.WithStreamData(fileStream) .WithStreamData(fileStream)
.WithObjectSize(fileSize) .WithObjectSize(fileSize)
.WithContentType(contentType); .WithContentType(contentType);
_ = await minio.PutObjectAsync(putArgs); _ = await minio.PutObjectAsync(putArgs).ConfigureAwait(false);
return $"{uploadOptions.Value.Minio.AccessUrl}/{uploadOptions.Value.Minio.BucketName}/{objectName}"; return $"{uploadOptions.Value.Minio.AccessUrl}/{uploadOptions.Value.Minio.BucketName}/{objectName}";
} }

2
src/backend/NetAdmin.ScheduledService/Jobs/ExampleJob.cs
View File

@ -20,7 +20,7 @@ public sealed class ExampleJob : WorkBase<ExampleJob>, IJob
/// <exception cref="NetAdminGetLockerException">加锁失败异常</exception> /// <exception cref="NetAdminGetLockerException">加锁失败异常</exception>
public async Task ExecuteAsync(JobExecutingContext context, CancellationToken stoppingToken) public async Task ExecuteAsync(JobExecutingContext context, CancellationToken stoppingToken)
{ {
await WorkflowAsync(stoppingToken); await WorkflowAsync(stoppingToken).ConfigureAwait(false);
} }
/// <summary> /// <summary>

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 /> /// <inheritdoc />
public async Task<IEnumerable<QueryApiRsp>> QueryAsync(QueryReq<QueryApiReq> req) 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>>(); return ret.Adapt<IEnumerable<QueryApiRsp>>();
} }
@ -90,14 +93,14 @@ public sealed class ApiService(DefaultRepository<Sys_Api> rpo
/// <inheritdoc /> /// <inheritdoc />
public async Task SyncAsync() public async Task SyncAsync()
{ {
_ = await Rpo.DeleteAsync(_ => true); _ = await Rpo.DeleteAsync(_ => true).ConfigureAwait(false);
var list = ReflectionList(false); var list = ReflectionList(false);
EnableCascadeSave = true; EnableCascadeSave = true;
foreach (var item in list) { foreach (var item in list) {
var entity = item.Adapt<Sys_Api>(); 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 : ServiceBase<ICacheService>, ICacheService
{ {
/// <inheritdoc /> /// <inheritdoc />
public Task<CacheStatisticsRsp> CacheStatisticsAsync() public async 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") }); return new CacheStatisticsRsp((string)await database.ExecuteAsync("info").ConfigureAwait(false)) {
DbSize = (long)await database.ExecuteAsync("dbSize").ConfigureAwait(false)
};
} }
/// <inheritdoc /> /// <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 database = connectionMultiplexer.GetDatabase((int?)req.Filter?.DbIndex ?? 0);
var redisResults var redisResults = (RedisResult[])await database
= (RedisResult[])database.Execute("scan", (req.Page - 1) * req.PageSize, "count", req.PageSize); .ExecuteAsync("scan", (req.Page - 1) * req.PageSize, "count"
, req.PageSize)
.ConfigureAwait(false);
var list = ((string[])redisResults![1])!.Where(x => database.KeyType(x) == RedisType.Hash) var list = ((string[])redisResults![1])!.Where(x => database.KeyType(x) == RedisType.Hash)
.Select(x => database.HashGetAll(x) .Select(x => database.HashGetAll(x)
@ -33,6 +37,6 @@ public sealed class CacheService(IConnectionMultiplexer connectionMultiplexer) /
.ToList() .ToList()
.ConvertAll(x => x.Adapt<GetAllEntriesRsp>()); .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);
} }
} }

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

@ -22,7 +22,8 @@ public sealed class CaptchaService : ServiceBase<ICaptchaService>, ICaptchaServi
{ {
var (backgroundImage, sliderImage, offsetSaw) = await CaptchaImageHelper.CreateSawSliderImageAsync( var (backgroundImage, sliderImage, offsetSaw) = await CaptchaImageHelper.CreateSawSliderImageAsync(
_entryAsm, $"{_entryAsmName}.Assets.Captcha.background", $"{_entryAsmName}.Assets.Captcha.template" _entryAsm, $"{_entryAsmName}.Assets.Captcha.background", $"{_entryAsmName}.Assets.Captcha.template"
, (1, 101), (1, 7), new Size(50, 50)); , (1, 101), (1, 7), new Size(50, 50))
.ConfigureAwait(false);
var id = $"{nameof(GetCaptchaImageAsync)}_{YitIdHelper.NextId()}"; var id = $"{nameof(GetCaptchaImageAsync)}_{YitIdHelper.NextId()}";
return new GetCaptchaRsp { 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,7 +26,7 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryConfigRsp> CreateAsync(CreateConfigReq req) 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>(); return ret.Adapt<QueryConfigRsp>();
} }
@ -45,7 +45,7 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryConfigRsp> GetAsync(QueryConfigReq req) 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>(); return ret.Adapt<QueryConfigRsp>();
} }
@ -53,14 +53,19 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
public async Task<QueryConfigRsp> GetLatestConfigAsync() public async Task<QueryConfigRsp> GetLatestConfigAsync()
{ {
var ret = await QueryAsync( 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(); return ret.FirstOrDefault();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QueryConfigRsp>> PagedQueryAsync(PagedQueryReq<QueryConfigReq> req) 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 return new PagedQueryRsp<QueryConfigRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryConfigRsp>>()); , list.Adapt<IEnumerable<QueryConfigRsp>>());
@ -69,7 +74,7 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryConfigRsp>> QueryAsync(QueryReq<QueryConfigReq> req) 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>>(); return ret.Adapt<IEnumerable<QueryConfigRsp>>();
} }
@ -77,19 +82,19 @@ public sealed class ConfigService(DefaultRepository<Sys_Config> rpo) //
public async Task<QueryConfigRsp> UpdateAsync(UpdateConfigReq req) public async Task<QueryConfigRsp> UpdateAsync(UpdateConfigReq req)
{ {
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) { 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>(); return ret.FirstOrDefault()?.Adapt<QueryConfigRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
protected override async Task<Sys_Config> UpdateForSqliteAsync(Sys_Config req) 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 ? 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) 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,11 +26,11 @@ public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
/// <exception cref="NetAdminInvalidOperationException">Parent_department_does_not_exist</exception> /// <exception cref="NetAdminInvalidOperationException">Parent_department_does_not_exist</exception>
public async Task<QueryDeptRsp> CreateAsync(CreateDeptReq req) 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.父节点不存在); throw new NetAdminInvalidOperationException(Ln.父节点不存在);
} }
var ret = await Rpo.InsertAsync(req); var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryDeptRsp>(); return ret.Adapt<QueryDeptRsp>();
} }
@ -40,17 +40,17 @@ public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
/// <exception cref="NetAdminInvalidOperationException">该部门下存在子部门</exception> /// <exception cref="NetAdminInvalidOperationException">该部门下存在子部门</exception>
public async Task<int> DeleteAsync(DelReq req) 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.该部门下存在用户); throw new NetAdminInvalidOperationException(Ln.该部门下存在用户);
} }
#pragma warning disable IDE0046 #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 #pragma warning restore IDE0046
throw new NetAdminInvalidOperationException(Ln.该部门下存在子部门); 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 /> /// <inheritdoc />
@ -62,7 +62,7 @@ public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryDeptRsp> GetAsync(QueryDeptReq req) 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>(); return ret.Adapt<QueryDeptRsp>();
} }
@ -75,17 +75,18 @@ public sealed class DeptService(DefaultRepository<Sys_Dept> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryDeptRsp>> QueryAsync(QueryReq<QueryDeptReq> req) 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 /> /// <inheritdoc />
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception> /// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryDeptRsp> UpdateAsync(UpdateDeptReq req) 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() ? throw new NetAdminUnexpectedException()
: (await QueryInternal(new QueryReq<QueryDeptReq> { Filter = new QueryDeptReq { Id = req.Id } }, true) : (await QueryInternal(new QueryReq<QueryDeptReq> { Filter = new QueryDeptReq { Id = req.Id } }, true)
.ToTreeListAsync())[0] .ToTreeListAsync()
.ConfigureAwait(false))[0]
.Adapt<QueryDeptRsp>(); .Adapt<QueryDeptRsp>();
} }

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

@ -54,57 +54,70 @@ public sealed class DevService(IApiService apiService) : ServiceBase<DevService>
// Controller // Controller
await WriteCodeFileAsync(req, Path.Combine(tplHostDir, "Controllers", "Tpl", "ExampleController.cs") 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 // CreateReq
await WriteCodeFileAsync(req, Path.Combine(dataDir, "Dto", "Tpl", "Example", "CreateExampleReq.cs") 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 // UpdateReq
await WriteCodeFileAsync(req, Path.Combine(dataDir, "Dto", "Tpl", "Example", "UpdateExampleReq.cs") 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 // QueryReq
await WriteCodeFileAsync(req, Path.Combine(dataDir, "Dto", "Tpl", "Example", "QueryExampleReq.cs") 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 // QueryRsp
await WriteCodeFileAsync(req, Path.Combine(dataDir, "Dto", "Tpl", "Example", "QueryExampleRsp.cs") 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 // ICache
await WriteCodeFileAsync(req, Path.Combine(tplCacheDir, "Tpl", "Dependency", "IExampleCache.cs") 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 // Cache
await WriteCodeFileAsync(req, Path.Combine(tplCacheDir, "Tpl", "ExampleCache.cs") 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 // IModule
await WriteCodeFileAsync(req, Path.Combine(tplAppDir, "Modules", "Tpl", "IExampleModule.cs") 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 // IService
await WriteCodeFileAsync(req, Path.Combine(tplAppDir, "Services", "Tpl", "Dependency", "IExampleService.cs") 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 // Service
await WriteCodeFileAsync(req, Path.Combine(tplAppDir, "Services", "Tpl", "ExampleService.cs") 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 // Entity
await WriteCodeFileAsync(req, Path.Combine(dataDir, "DbMaps", "Tpl", "Tpl_Example.cs") 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 /> /// <inheritdoc />
public async Task GenerateIconCodeAsync(GenerateIconCodeReq req) public async Task GenerateIconCodeAsync(GenerateIconCodeReq req)
{ {
var tplSvg = await File.ReadAllTextAsync( var tplSvg = await File.ReadAllTextAsync(
Path.Combine(_clientProjectPath, "src", "assets", "icons", "tpl", "Svg.vue")); Path.Combine(_clientProjectPath, "src", "assets", "icons", "tpl", "Svg.vue"))
var tplExport .ConfigureAwait(false);
= await File.ReadAllTextAsync( var tplExport = await File
Path.Combine(_clientProjectPath, "src", "assets", "icons", "tpl", "export.js")); .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); 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"); 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"); var indexJsFile = Path.Combine(dir, "index.js");
await File.AppendAllTextAsync( await File.AppendAllTextAsync(
indexJsFile indexJsFile
, Environment.NewLine + , Environment.NewLine +
tplExport.Replace("$iconName$", req.IconName).Replace(_REPLACE_TO_EMPTY, string.Empty)); tplExport.Replace("$iconName$", req.IconName).Replace(_REPLACE_TO_EMPTY, string.Empty))
.ConfigureAwait(false);
// 修改iconSelect.js // 修改iconSelect.js
var iconSelectFile = Path.Combine(_clientProjectPath, "src", "config", "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 = iconSelectContent.Replace("export default", "exportDefault:").Replace("'", "\"");
iconSelectContent = _regex2.Replace(iconSelectContent, "\"$1\":"); iconSelectContent = _regex2.Replace(iconSelectContent, "\"$1\":");
iconSelectContent = "{" + iconSelectContent + "}"; 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()}"); iconExportJsInfo.ExportDefault.Icons.Last().Icons.Add($"sc-icon-{req.IconName.ToLowerInvariant()}");
var newContent = iconExportJsInfo.ToJson().TrimStart('{')[..^1].Replace("\"exportDefault\":", "export default"); var newContent = iconExportJsInfo.ToJson().TrimStart('{')[..^1].Replace("\"exportDefault\":", "export default");
await File.WriteAllTextAsync(iconSelectFile, newContent); await File.WriteAllTextAsync(iconSelectFile, newContent).ConfigureAwait(false);
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task GenerateJsCodeAsync() public async Task GenerateJsCodeAsync()
{ {
// 模板文件 // 模板文件
var tplOuter = await File.ReadAllTextAsync(Path.Combine(_clientProjectPath, "src", "api", "tpl", "outer.js")); 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")); .ConfigureAwait(false);
var tplInner = await File.ReadAllTextAsync(Path.Combine(_clientProjectPath, "src", "api", "tpl", "inner.js"))
.ConfigureAwait(false);
foreach (var item in apiService.ReflectionList(false)) { foreach (var item in apiService.ReflectionList(false)) {
var dir = Path.Combine(_clientProjectPath, "src", "api", item.Namespace); 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))) , string.Join(Environment.NewLine + Environment.NewLine, Select(item)))
.Replace(_REPLACE_TO_EMPTY, string.Empty); .Replace(_REPLACE_TO_EMPTY, string.Empty);
await File.WriteAllTextAsync(file, content); await File.WriteAllTextAsync(file, content).ConfigureAwait(false);
} }
IEnumerable<string> Select(QueryApiRsp item) 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) 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]) tplContent = tplContent.Replace("Tpl", Enum.GetName(req.Type)![..3])
.Replace("示例", req.ModuleRemark) .Replace("示例", req.ModuleRemark)
.Replace("Example", req.ModuleName) .Replace("Example", req.ModuleName)
.Replace("NetAdmin.SysComponent", "SysComponent"); .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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,18 +26,19 @@ public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
/// <exception cref="NetAdminInvalidOperationException">The_parent_node_does_not_exist</exception> /// <exception cref="NetAdminInvalidOperationException">The_parent_node_does_not_exist</exception>
public async Task<QueryDicCatalogRsp> CreateAsync(CreateDicCatalogReq req) 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.父节点不存在); throw new NetAdminInvalidOperationException(Ln.父节点不存在);
} }
var ret = await Rpo.InsertAsync(req); var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryDicCatalogRsp>(); return ret.Adapt<QueryDicCatalogRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<int> DeleteAsync(DelReq req) 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; return ret.Count;
} }
@ -50,14 +51,20 @@ public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryDicCatalogRsp> GetAsync(QueryDicCatalogReq req) 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>(); return ret.Adapt<QueryDicCatalogRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QueryDicCatalogRsp>> PagedQueryAsync(PagedQueryReq<QueryDicCatalogReq> req) 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 return new PagedQueryRsp<QueryDicCatalogRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryDicCatalogRsp>>()); , list.Adapt<IEnumerable<QueryDicCatalogRsp>>());
@ -66,7 +73,7 @@ public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryDicCatalogRsp>> QueryAsync(QueryReq<QueryDicCatalogReq> req) 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>>(); return ret.Adapt<IEnumerable<QueryDicCatalogRsp>>();
} }
@ -75,15 +82,16 @@ public sealed class DicCatalogService(DefaultRepository<Sys_DicCatalog> rpo) //
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception> /// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryDicCatalogRsp> UpdateAsync(UpdateDicCatalogReq req) 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.父节点不存在); 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(); 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>(); 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,11 +26,15 @@ public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
/// <exception cref="NetAdminInvalidOperationException">Dictionary_directory_does_not_exist</exception> /// <exception cref="NetAdminInvalidOperationException">Dictionary_directory_does_not_exist</exception>
public async Task<QueryDicContentRsp> CreateAsync(CreateDicContentReq req) 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.字典目录不存在); throw new NetAdminInvalidOperationException(Ln.字典目录不存在);
} }
var ret = await Rpo.InsertAsync(req); var ret = await Rpo.InsertAsync(req).ConfigureAwait(false);
return ret.Adapt<QueryDicContentRsp>(); return ret.Adapt<QueryDicContentRsp>();
} }
@ -49,14 +53,20 @@ public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryDicContentRsp> GetAsync(QueryDicContentReq req) 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>(); return ret.Adapt<QueryDicContentRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QueryDicContentRsp>> PagedQueryAsync(PagedQueryReq<QueryDicContentReq> req) 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 return new PagedQueryRsp<QueryDicContentRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryDicContentRsp>>()); , list.Adapt<IEnumerable<QueryDicContentRsp>>());
@ -65,7 +75,7 @@ public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryDicContentRsp>> QueryAsync(QueryReq<QueryDicContentReq> req) 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>>(); return ret.Adapt<IEnumerable<QueryDicContentRsp>>();
} }
@ -74,15 +84,19 @@ public sealed class DicContentService(DefaultRepository<Sys_DicContent> rpo) //
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception> /// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryDicContentRsp> UpdateAsync(UpdateDicContentReq req) 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.字典目录不存在); 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(); 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>(); 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 fileName = $"{Guid.NewGuid()}{Path.GetExtension(file.FileName)}";
var objectName = $"{UserToken.Id}/{fileName}"; var objectName = $"{UserToken.Id}/{fileName}";
await using var fs = file.OpenReadStream(); 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -25,7 +25,7 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryMenuRsp> CreateAsync(CreateMenuReq req) 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>(); return ret.Adapt<QueryMenuRsp>();
} }
@ -44,7 +44,7 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryMenuRsp> GetAsync(QueryMenuReq req) 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>(); return ret.Adapt<QueryMenuRsp>();
} }
@ -57,7 +57,7 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryMenuRsp>> QueryAsync(QueryReq<QueryMenuReq> req) 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>>(); return ret.Adapt<IEnumerable<QueryMenuRsp>>();
} }
@ -65,18 +65,18 @@ public sealed class MenuService(DefaultRepository<Sys_Menu> rpo, IUserService us
/// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception> /// <exception cref="NetAdminUnexpectedException">NetAdminUnexpectedException</exception>
public async Task<QueryMenuRsp> UpdateAsync(UpdateMenuReq req) 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(); 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>(); return ret.Adapt<QueryMenuRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryMenuRsp>> UserMenusAsync() public async Task<IEnumerable<QueryMenuRsp>> UserMenusAsync()
{ {
var userInfo = await userService.UserInfoAsync(); var userInfo = await userService.UserInfoAsync().ConfigureAwait(false);
Task<IEnumerable<QueryMenuRsp>> ret; Task<IEnumerable<QueryMenuRsp>> ret;
var req = new QueryReq<QueryMenuReq>(); 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 }); ret = QueryAsync(req with { DynamicFilter = df });
} }
return await ret; return await ret.ConfigureAwait(false);
} }
/// <inheritdoc /> /// <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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -25,7 +25,7 @@ public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryRequestLogRsp> CreateAsync(CreateRequestLogReq req) 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>(); return ret.Adapt<QueryRequestLogRsp>();
} }
@ -44,7 +44,9 @@ public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryRequestLogRsp> GetAsync(QueryRequestLogReq req) 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>(); return ret.Adapt<QueryRequestLogRsp>();
} }
@ -66,7 +68,8 @@ public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
, a.CreatedUserAgent , a.CreatedUserAgent
, a.HttpStatusCode , a.HttpStatusCode
, a.Id , a.Id
}); })
.ConfigureAwait(false);
return new PagedQueryRsp<QueryRequestLogRsp>(req.Page, req.PageSize, total return new PagedQueryRsp<QueryRequestLogRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryRequestLogRsp>>()); , list.Adapt<IEnumerable<QueryRequestLogRsp>>());
@ -75,7 +78,7 @@ public sealed class RequestLogService(DefaultRepository<Sys_RequestLog> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryRequestLogRsp>> QueryAsync(QueryReq<QueryRequestLogReq> req) 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>>(); 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,11 +26,11 @@ public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
public async Task<QueryRoleRsp> CreateAsync(CreateRoleReq req) public async Task<QueryRoleRsp> CreateAsync(CreateRoleReq req)
{ {
var entity = req.Adapt<Sys_Role>(); 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.Depts)).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Menus)); await Rpo.SaveManyAsync(entity, nameof(entity.Menus)).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Apis)); await Rpo.SaveManyAsync(entity, nameof(entity.Apis)).ConfigureAwait(false);
entity = entity with { Id = ret.Id }; entity = entity with { Id = ret.Id };
return entity.Adapt<QueryRoleRsp>(); 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> /// <exception cref="NetAdminInvalidOperationException">Users_exist_under_this_role_and_deletion_is_not_allowed</exception>
public async Task<int> DeleteAsync(DelReq req) 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.该角色下存在用户) ? throw new NetAdminInvalidOperationException(Ln.该角色下存在用户)
: await Rpo.DeleteAsync(a => a.Id == req.Id); : await Rpo.DeleteAsync(a => a.Id == req.Id).ConfigureAwait(false);
} }
/// <inheritdoc /> /// <inheritdoc />
@ -54,14 +54,18 @@ public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryRoleRsp> GetAsync(QueryRoleReq req) 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>(); return ret.Adapt<QueryRoleRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QueryRoleRsp>> PagedQueryAsync(PagedQueryReq<QueryRoleReq> req) 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>>()); 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 /> /// <inheritdoc />
public async Task<IEnumerable<QueryRoleRsp>> QueryAsync(QueryReq<QueryRoleReq> req) 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>>(); return ret.Adapt<IEnumerable<QueryRoleRsp>>();
} }
@ -77,12 +81,13 @@ public sealed class RoleService(DefaultRepository<Sys_Role> rpo) //
public async Task<QueryRoleRsp> UpdateAsync(UpdateRoleReq req) public async Task<QueryRoleRsp> UpdateAsync(UpdateRoleReq req)
{ {
var entity = req.Adapt<Sys_Role>(); var entity = req.Adapt<Sys_Role>();
_ = await Rpo.UpdateAsync(entity); _ = await Rpo.UpdateAsync(entity).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Depts)); await Rpo.SaveManyAsync(entity, nameof(entity.Depts)).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Menus)); await Rpo.SaveManyAsync(entity, nameof(entity.Menus)).ConfigureAwait(false);
await Rpo.SaveManyAsync(entity, nameof(entity.Apis)); 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 /> /// <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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,7 +26,7 @@ public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QuerySiteMsgDeptRsp> CreateAsync(CreateSiteMsgDeptReq req) 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>(); return ret.Adapt<QuerySiteMsgDeptRsp>();
} }
@ -45,14 +45,20 @@ public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QuerySiteMsgDeptRsp> GetAsync(QuerySiteMsgDeptReq req) 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>(); return ret.Adapt<QuerySiteMsgDeptRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QuerySiteMsgDeptRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgDeptReq> req) 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 return new PagedQueryRsp<QuerySiteMsgDeptRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgDeptRsp>>()); , list.Adapt<IEnumerable<QuerySiteMsgDeptRsp>>());
@ -61,7 +67,7 @@ public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgDeptRsp>> QueryAsync(QueryReq<QuerySiteMsgDeptReq> req) 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>>(); return ret.Adapt<IEnumerable<QuerySiteMsgDeptRsp>>();
} }
@ -69,19 +75,19 @@ public sealed class SiteMsgDeptService(DefaultRepository<Sys_SiteMsgDept> rpo) /
public async Task<QuerySiteMsgDeptRsp> UpdateAsync(UpdateSiteMsgDeptReq req) public async Task<QuerySiteMsgDeptRsp> UpdateAsync(UpdateSiteMsgDeptReq req)
{ {
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) { 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>(); return ret.FirstOrDefault()?.Adapt<QuerySiteMsgDeptRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
protected override async Task<Sys_SiteMsgDept> UpdateForSqliteAsync(Sys_SiteMsgDept req) 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 ? 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) 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,7 +26,7 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QuerySiteMsgFlagRsp> CreateAsync(CreateSiteMsgFlagReq req) 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>(); return ret.Adapt<QuerySiteMsgFlagRsp>();
} }
@ -45,14 +45,20 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QuerySiteMsgFlagRsp> GetAsync(QuerySiteMsgFlagReq req) 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>(); return ret.Adapt<QuerySiteMsgFlagRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QuerySiteMsgFlagRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgFlagReq> req) 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 return new PagedQueryRsp<QuerySiteMsgFlagRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgFlagRsp>>()); , list.Adapt<IEnumerable<QuerySiteMsgFlagRsp>>());
@ -61,7 +67,7 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgFlagRsp>> QueryAsync(QueryReq<QuerySiteMsgFlagReq> req) 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>>(); return ret.Adapt<IEnumerable<QuerySiteMsgFlagRsp>>();
} }
@ -69,12 +75,13 @@ public sealed class SiteMsgFlagService(DefaultRepository<Sys_SiteMsgFlag> rpo) /
public async Task<QuerySiteMsgFlagRsp> UpdateAsync(UpdateSiteMsgFlagReq req) public async Task<QuerySiteMsgFlagRsp> UpdateAsync(UpdateSiteMsgFlagReq req)
{ {
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) { 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) var ret = await Rpo.UpdateDiy.Set(a => a.UserSiteMsgStatus == req.UserSiteMsgStatus)
.Where(a => a.UserId == req.UserId && a.SiteMsgId == req.SiteMsgId) .Where(a => a.UserId == req.UserId && a.SiteMsgId == req.SiteMsgId)
.ExecuteUpdatedAsync(); .ExecuteUpdatedAsync()
.ConfigureAwait(false);
return ret.FirstOrDefault()?.Adapt<QuerySiteMsgFlagRsp>(); 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) return await Rpo.UpdateDiy.Set(a => a.UserSiteMsgStatus == req.UserSiteMsgStatus)
.Where(a => a.UserId == req.UserId && a.SiteMsgId == req.SiteMsgId) .Where(a => a.UserId == req.UserId && a.SiteMsgId == req.SiteMsgId)
.ExecuteAffrowsAsync() <= 0 .ExecuteAffrowsAsync()
.ConfigureAwait(false) <= 0
? null ? 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) 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,7 +26,7 @@ public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QuerySiteMsgRoleRsp> CreateAsync(CreateSiteMsgRoleReq req) 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>(); return ret.Adapt<QuerySiteMsgRoleRsp>();
} }
@ -45,14 +45,20 @@ public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QuerySiteMsgRoleRsp> GetAsync(QuerySiteMsgRoleReq req) 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>(); return ret.Adapt<QuerySiteMsgRoleRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QuerySiteMsgRoleRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgRoleReq> req) 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 return new PagedQueryRsp<QuerySiteMsgRoleRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgRoleRsp>>()); , list.Adapt<IEnumerable<QuerySiteMsgRoleRsp>>());
@ -61,7 +67,7 @@ public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgRoleRsp>> QueryAsync(QueryReq<QuerySiteMsgRoleReq> req) 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>>(); return ret.Adapt<IEnumerable<QuerySiteMsgRoleRsp>>();
} }
@ -69,19 +75,19 @@ public sealed class SiteMsgRoleService(DefaultRepository<Sys_SiteMsgRole> rpo) /
public async Task<QuerySiteMsgRoleRsp> UpdateAsync(UpdateSiteMsgRoleReq req) public async Task<QuerySiteMsgRoleRsp> UpdateAsync(UpdateSiteMsgRoleReq req)
{ {
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) { 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>(); return ret.FirstOrDefault()?.Adapt<QuerySiteMsgRoleRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
protected override async Task<Sys_SiteMsgRole> UpdateForSqliteAsync(Sys_SiteMsgRole req) 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 ? 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) private ISelect<Sys_SiteMsgRole> QueryInternal(QueryReq<QuerySiteMsgRoleReq> req)

77
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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -30,23 +30,23 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
/// <inheritdoc /> /// <inheritdoc />
public async Task<QuerySiteMsgRsp> CreateAsync(CreateSiteMsgReq req) public async Task<QuerySiteMsgRsp> CreateAsync(CreateSiteMsgReq req)
{ {
await CreateUpdateCheckAsync(req); await CreateUpdateCheckAsync(req).ConfigureAwait(false);
// 主表 // 主表
var entity = req.Adapt<Sys_SiteMsg>(); 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( var ret = await QueryAsync(new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = dbSiteMsg.Id } })
new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = dbSiteMsg.Id } }); .ConfigureAwait(false);
return ret.Adapt<QuerySiteMsgRsp>(); return ret.Adapt<QuerySiteMsgRsp>();
} }
@ -54,7 +54,7 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
/// <inheritdoc /> /// <inheritdoc />
public async Task<int> DeleteAsync(DelReq req) 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; return ret.Count;
} }
@ -71,7 +71,8 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
.IncludeMany(a => a.Roles) .IncludeMany(a => a.Roles)
.IncludeMany(a => a.Users) .IncludeMany(a => a.Users)
.IncludeMany(a => a.Depts) .IncludeMany(a => a.Depts)
.ToOneAsync(); .ToOneAsync()
.ConfigureAwait(false);
return ret.Adapt<QuerySiteMsgRsp>(); return ret.Adapt<QuerySiteMsgRsp>();
} }
@ -86,7 +87,8 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
, Value = req.Id , Value = req.Id
, Operator = DynamicFilterOperators.Eq , Operator = DynamicFilterOperators.Eq
} }
}, true); }, true)
.ConfigureAwait(false);
return ret.Rows.FirstOrDefault(); return ret.Rows.FirstOrDefault();
} }
@ -104,7 +106,8 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
, a.Summary , a.Summary
, a.Title , a.Title
, a.Version , a.Version
}); })
.ConfigureAwait(false);
return new PagedQueryRsp<QuerySiteMsgRsp>(req.Page, req.PageSize, total return new PagedQueryRsp<QuerySiteMsgRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgRsp>>()); , list.Adapt<IEnumerable<QuerySiteMsgRsp>>());
@ -119,22 +122,23 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgRsp>> QueryAsync(QueryReq<QuerySiteMsgReq> req) 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>>(); return ret.Adapt<IEnumerable<QuerySiteMsgRsp>>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task SetSiteMsgStatusAsync(UpdateSiteMsgFlagReq req) 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.站内信不存在); throw new NetAdminInvalidOperationException(Ln.站内信不存在);
} }
try { try {
_ = await siteMsgFlagService.CreateAsync(req with { UserId = contextUserInfo.Id }); _ = await siteMsgFlagService.CreateAsync(req with { UserId = contextUserInfo.Id }).ConfigureAwait(false);
} }
catch { 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>() var subtract = await Rpo.Orm.Select<Sys_SiteMsgFlag>()
.Where(a => a.UserId == contextUserInfo.Id && .Where(a => a.UserId == contextUserInfo.Id &&
a.UserSiteMsgStatus == UserSiteMsgStatues.Read) 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 /> /// <inheritdoc />
public async Task<QuerySiteMsgRsp> UpdateAsync(UpdateSiteMsgReq req) public async Task<QuerySiteMsgRsp> UpdateAsync(UpdateSiteMsgReq req)
{ {
await CreateUpdateCheckAsync(req); await CreateUpdateCheckAsync(req).ConfigureAwait(false);
// 主表 // 主表
var entity = req.Adapt<Sys_SiteMsg>(); 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 } })) return (await QueryAsync(new QueryReq<QuerySiteMsgReq> { Filter = new QuerySiteMsgReq { Id = req.Id } })
.First(); .ConfigureAwait(false)).First();
} }
/// <inheritdoc /> /// <inheritdoc />
protected override async Task<Sys_SiteMsg> UpdateForSqliteAsync(Sys_SiteMsg req) 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 ? null
: await GetAsync(new QuerySiteMsgReq { Id = req.Id }); : await GetAsync(new QuerySiteMsgReq { Id = req.Id }).ConfigureAwait(false);
} }
private async Task CreateUpdateCheckAsync(CreateSiteMsgReq req) private async Task CreateUpdateCheckAsync(CreateSiteMsgReq req)
{ {
// 检查角色是否存在 // 检查角色是否存在
if (!req.RoleIds.NullOrEmpty()) { 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) { if (roles.Count != req.RoleIds.Count) {
throw new NetAdminInvalidOperationException(Ln.角色不存在); throw new NetAdminInvalidOperationException(Ln.角色不存在);
} }
@ -192,7 +200,10 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
if (!req.DeptIds.NullOrEmpty()) { 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) { if (depts.Count != req.DeptIds.Count) {
throw new NetAdminInvalidOperationException(Ln.部门不存在); throw new NetAdminInvalidOperationException(Ln.部门不存在);
} }
@ -200,7 +211,10 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
if (!req.UserIds.NullOrEmpty()) { 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) { if (users.Count != req.UserIds.Count) {
throw new NetAdminInvalidOperationException(Ln.用户不存在); throw new NetAdminInvalidOperationException(Ln.用户不存在);
} }
@ -233,7 +247,8 @@ public sealed class SiteMsgService(DefaultRepository<Sys_SiteMsg> rpo, ContextUs
a.Value.Item2.UserName) a.Value.Item2.UserName)
, Avatar = a.Max(a.Value.Item2.Avatar) , Avatar = a.Max(a.Value.Item2.Avatar)
} }
}); })
.ConfigureAwait(false);
return new PagedQueryRsp<QuerySiteMsgRsp>(req.Page, req.PageSize, total return new PagedQueryRsp<QuerySiteMsgRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgRsp>>()); , 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,7 +26,7 @@ public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QuerySiteMsgUserRsp> CreateAsync(CreateSiteMsgUserReq req) 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>(); return ret.Adapt<QuerySiteMsgUserRsp>();
} }
@ -45,14 +45,20 @@ public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QuerySiteMsgUserRsp> GetAsync(QuerySiteMsgUserReq req) 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>(); return ret.Adapt<QuerySiteMsgUserRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QuerySiteMsgUserRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgUserReq> req) 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 return new PagedQueryRsp<QuerySiteMsgUserRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QuerySiteMsgUserRsp>>()); , list.Adapt<IEnumerable<QuerySiteMsgUserRsp>>());
@ -61,7 +67,7 @@ public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QuerySiteMsgUserRsp>> QueryAsync(QueryReq<QuerySiteMsgUserReq> req) 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>>(); return ret.Adapt<IEnumerable<QuerySiteMsgUserRsp>>();
} }
@ -69,19 +75,19 @@ public sealed class SiteMsgUserService(DefaultRepository<Sys_SiteMsgUser> rpo) /
public async Task<QuerySiteMsgUserRsp> UpdateAsync(UpdateSiteMsgUserReq req) public async Task<QuerySiteMsgUserRsp> UpdateAsync(UpdateSiteMsgUserReq req)
{ {
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) { 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>(); return ret.FirstOrDefault()?.Adapt<QuerySiteMsgUserRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
protected override async Task<Sys_SiteMsgUser> UpdateForSqliteAsync(Sys_SiteMsgUser req) 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 ? 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) 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -28,7 +28,7 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
public async Task<QueryUserProfileRsp> CreateAsync(CreateUserProfileReq req) public async Task<QueryUserProfileRsp> CreateAsync(CreateUserProfileReq req)
{ {
var entity = req.Adapt<Sys_UserProfile>(); var entity = req.Adapt<Sys_UserProfile>();
var ret = await Rpo.InsertAsync(entity); var ret = await Rpo.InsertAsync(entity).ConfigureAwait(false);
return ret.Adapt<QueryUserProfileRsp>(); return ret.Adapt<QueryUserProfileRsp>();
} }
@ -47,7 +47,9 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryUserProfileRsp> GetAsync(QueryUserProfileReq req) 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>(); return ret.Adapt<QueryUserProfileRsp>();
} }
@ -63,7 +65,8 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
, c = new { c.Key, c.Value } , c = new { c.Key, c.Value }
, d = new { d.Key, d.Value } , d = new { d.Key, d.Value }
, e = new { e.Key, e.Value } , e = new { e.Key, e.Value }
}); })
.ConfigureAwait(false);
return new PagedQueryRsp<QueryUserProfileRsp>(req.Page, req.PageSize, total return new PagedQueryRsp<QueryUserProfileRsp>(req.Page, req.PageSize, total
, list.ConvertAll( , list.ConvertAll(
@ -87,7 +90,8 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
, c = new { c.Key, c.Value } , c = new { c.Key, c.Value }
, d = new { d.Key, d.Value } , d = new { d.Key, d.Value }
, e = new { e.Key, e.Value } , e = new { e.Key, e.Value }
}); })
.ConfigureAwait(false);
return ret.ConvertAll(x => x.a.Adapt<QueryUserProfileRsp>() with { return ret.ConvertAll(x => x.a.Adapt<QueryUserProfileRsp>() with {
NationArea NationArea
= x.b.Key == null = x.b.Key == null
@ -113,19 +117,19 @@ public sealed class UserProfileService(DefaultRepository<Sys_UserProfile> rpo) /
{ {
var entity = req.Adapt<Sys_UserProfile>(); var entity = req.Adapt<Sys_UserProfile>();
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) { 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>(); return ret.FirstOrDefault()?.Adapt<QueryUserProfileRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
protected override async Task<Sys_UserProfile> UpdateForSqliteAsync(Sys_UserProfile req) 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 ? 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( private ISelect<Sys_UserProfile, Sys_DicContent, Sys_DicContent, Sys_DicContent, Sys_DicContent> QueryInternal(

150
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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -48,30 +48,33 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <inheritdoc /> /// <inheritdoc />
public async Task<bool> CheckMobileAvailableAsync(CheckMobileAvailableReq req) 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 /> /// <inheritdoc />
public async Task<bool> CheckUserNameAvailableAsync(CheckUserNameAvailableReq req) 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 /> /// <inheritdoc />
public async Task<QueryUserRsp> CreateAsync(CreateUserReq req) public async Task<QueryUserRsp> CreateAsync(CreateUserReq req)
{ {
await CreateUpdateCheckAsync(req); await CreateUpdateCheckAsync(req).ConfigureAwait(false);
// 主表 // 主表
var entity = req.Adapt<Sys_User>(); 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 }); _ = await userProfileService.CreateAsync(req.Profile with { Id = dbUser.Id }).ConfigureAwait(false);
var ret = await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = dbUser.Id } }); var ret = await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = dbUser.Id } })
.ConfigureAwait(false);
return ret.First(); return ret.First();
} }
@ -81,13 +84,15 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
var effect = 0; 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; return effect;
} }
@ -95,13 +100,15 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <inheritdoc /> /// <inheritdoc />
public async Task<bool> ExistAsync(QueryReq<QueryUserReq> req) 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 /> /// <inheritdoc />
public async Task<QueryUserRsp> GetAsync(QueryUserReq req) 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>(); return ret.Adapt<QueryUserRsp>();
} }
@ -109,8 +116,12 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
public async Task<QueryUserRsp> GetForUpdateAsync(QueryUserReq req) public async Task<QueryUserRsp> GetForUpdateAsync(QueryUserReq req)
{ {
// ReSharper disable once MethodHasAsyncOverload // ReSharper disable once MethodHasAsyncOverload
return (await QueryInternal(new QueryReq<QueryUserReq> { Filter = req }).ForUpdate().ToOneAsync()) #pragma warning disable VSTHRD103
.Adapt<QueryUserRsp>(); return (await QueryInternal(new QueryReq<QueryUserReq> { Filter = req })
#pragma warning restore VSTHRD103
.ForUpdate()
.ToOneAsync()
.ConfigureAwait(false)).Adapt<QueryUserRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
@ -123,12 +134,16 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
#pragma warning disable IDE0045 #pragma warning disable IDE0045
if (new MobileAttribute().IsValid(req.Account)) { if (new MobileAttribute().IsValid(req.Account)) {
#pragma warning restore IDE0045 #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 { else {
dbUser = new EmailAddressAttribute().IsValid(req.Account) dbUser = new EmailAddressAttribute().IsValid(req.Account)
? await Rpo.Where(a => a.Email == 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(); : await Rpo.Where(a => a.UserName == req.Account && a.Password == pwd)
.ToOneAsync()
.ConfigureAwait(false);
} }
return dbUser == null ? throw new NetAdminInvalidOperationException(Ln.用户名或密码错误) : LoginInternal(dbUser); 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> /// <exception cref="NetAdminInvalidOperationException">用户不存在</exception>
public async Task<LoginRsp> LoginBySmsAsync(LoginBySmsReq req) 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.验证码不正确); 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); return dbUser == null ? throw new NetAdminInvalidOperationException(Ln.用户不存在) : LoginInternal(dbUser);
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QueryUserRsp>> PagedQueryAsync(PagedQueryReq<QueryUserReq> req) public async Task<PagedQueryRsp<QueryUserRsp>> PagedQueryAsync(PagedQueryReq<QueryUserReq> req)
{ {
var list = await (await QueryInternalAsync(req)).Page(req.Page, req.PageSize) var list = await (await QueryInternalAsync(req).ConfigureAwait(false)).Page(req.Page, req.PageSize)
.Count(out var total) .Count(out var total)
.ToListAsync(_selectUserFields); .ToListAsync(_selectUserFields)
.ConfigureAwait(false);
return new PagedQueryRsp<QueryUserRsp>(req.Page, req.PageSize, total, list.Adapt<IEnumerable<QueryUserRsp>>()); return new PagedQueryRsp<QueryUserRsp>(req.Page, req.PageSize, total, list.Adapt<IEnumerable<QueryUserRsp>>());
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryUserRsp>> QueryAsync(QueryReq<QueryUserReq> req) 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>>(); return list.Adapt<IEnumerable<QueryUserRsp>>();
} }
@ -173,12 +191,12 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <exception cref="NetAdminInvalidOperationException">验证码不正确</exception> /// <exception cref="NetAdminInvalidOperationException">验证码不正确</exception>
public async Task<UserInfoRsp> RegisterAsync(RegisterUserReq req) 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.验证码不正确); throw new NetAdminInvalidOperationException(Ln.验证码不正确);
} }
var createReq = req.Adapt<CreateUserReq>() with { Profile = new CreateUserProfileReq() }; var createReq = req.Adapt<CreateUserReq>() with { Profile = new CreateUserProfileReq() };
return (await CreateAsync(createReq)).Adapt<UserInfoRsp>(); return (await CreateAsync(createReq).ConfigureAwait(false)).Adapt<UserInfoRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
@ -186,15 +204,17 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <exception cref="NetAdminInvalidOperationException">用户不存在</exception> /// <exception cref="NetAdminInvalidOperationException">用户不存在</exception>
public async Task<uint> ResetPasswordAsync(ResetPasswordReq req) 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.验证码不正确) ? throw new NetAdminInvalidOperationException(Ln.验证码不正确)
: (uint)await Rpo.UpdateDiy : (uint)await Rpo.UpdateDiy
.SetSource((await Rpo.Where(a => a.Mobile == req.VerifySmsCodeReq.DestDevice) .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() Password = req.PasswordText.Pwd().Guid()
}) })
.UpdateColumns(a => a.Password) .UpdateColumns(a => a.Password)
.ExecuteAffrowsAsync(); .ExecuteAffrowsAsync()
.ConfigureAwait(false);
} }
/// <inheritdoc /> /// <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) , Version = Rpo.Where(a => a.Id == UserToken.Id).ToOne(a => a.Version)
}) })
.UpdateColumns(a => a.Avatar) .UpdateColumns(a => a.Avatar)
.ExecuteAffrowsAsync() <= 0) { .ExecuteAffrowsAsync()
.ConfigureAwait(false) <= 0) {
throw new NetAdminUnexpectedException(); throw new NetAdminUnexpectedException();
} }
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } })) var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } })
.First() .ConfigureAwait(false)).First()
.Adapt<UserInfoRsp>(); .Adapt<UserInfoRsp>();
// 发布用户更新事件 // 发布用户更新事件
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret)); await eventPublisher.PublishAsync(new UserUpdatedEvent(ret)).ConfigureAwait(false);
return ret; return ret;
} }
@ -226,7 +247,7 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
// 如果已绑定手机号、需要手机安全验证 // 如果已绑定手机号、需要手机安全验证
if (!user.Mobile.NullOrEmpty()) { if (!user.Mobile.NullOrEmpty()) {
if (!await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq)) { if (!await verifyCodeService.VerifyAsync(req.VerifySmsCodeReq).ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException(Ln.验证码不正确); throw new NetAdminInvalidOperationException(Ln.验证码不正确);
} }
@ -238,27 +259,30 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
if (await Rpo.UpdateDiy if (await Rpo.UpdateDiy
.SetSource(new Sys_User { Email = req.DestDevice, Id = UserToken.Id, Version = user.Version }) .SetSource(new Sys_User { Email = req.DestDevice, Id = UserToken.Id, Version = user.Version })
.UpdateColumns(a => a.Email) .UpdateColumns(a => a.Email)
.ExecuteAffrowsAsync() <= 0) { .ExecuteAffrowsAsync()
.ConfigureAwait(false) <= 0) {
throw new NetAdminUnexpectedException(); throw new NetAdminUnexpectedException();
} }
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } })) var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } })
.First() .ConfigureAwait(false)).First()
.Adapt<UserInfoRsp>(); .Adapt<UserInfoRsp>();
// 发布用户更新事件 // 发布用户更新事件
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret)); await eventPublisher.PublishAsync(new UserUpdatedEvent(ret)).ConfigureAwait(false);
return ret; return ret;
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<UserInfoRsp> SetMobileAsync(SetMobileReq req) 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 (!user.Mobile.NullOrEmpty()) {
// 已有手机号，需验证旧手机 // 已有手机号，需验证旧手机
if (!await verifyCodeService.VerifyAsync(req.OriginVerifySmsCodeReq)) { if (!await verifyCodeService.VerifyAsync(req.OriginVerifySmsCodeReq).ConfigureAwait(false)) {
throw new NetAdminInvalidOperationException($"{Ln.旧手机号码验证码不正确}"); 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.新手机号码验证码不正确}"); throw new NetAdminInvalidOperationException($"{Ln.新手机号码验证码不正确}");
} }
@ -279,16 +303,17 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
, Mobile = req.NewVerifySmsCodeReq.DestDevice , Mobile = req.NewVerifySmsCodeReq.DestDevice
}) })
.UpdateColumns(a => a.Mobile) .UpdateColumns(a => a.Mobile)
.ExecuteAffrowsAsync() <= 0) { .ExecuteAffrowsAsync()
.ConfigureAwait(false) <= 0) {
throw new NetAdminUnexpectedException(); throw new NetAdminUnexpectedException();
} }
var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } })) var ret = (await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = UserToken.Id } })
.First() .ConfigureAwait(false)).First()
.Adapt<UserInfoRsp>(); .Adapt<UserInfoRsp>();
// 发布用户更新事件 // 发布用户更新事件
await eventPublisher.PublishAsync(new UserUpdatedEvent(ret)); await eventPublisher.PublishAsync(new UserUpdatedEvent(ret)).ConfigureAwait(false);
return ret; return ret;
} }
@ -296,7 +321,8 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
public async Task<uint> SetPasswordAsync(SetPasswordReq req) public async Task<uint> SetPasswordAsync(SetPasswordReq req)
{ {
var version = await Rpo.Where(a => a.Id == UserToken.Id && a.Password == req.OldPassword.Pwd().Guid()) 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) { if (version != null) {
var ret = await Rpo.UpdateDiy var ret = await Rpo.UpdateDiy
.SetSource(new Sys_User { .SetSource(new Sys_User {
@ -305,7 +331,8 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
, Version = version.Value , Version = version.Value
}) })
.UpdateColumns(a => a.Password) .UpdateColumns(a => a.Password)
.ExecuteAffrowsAsync(); .ExecuteAffrowsAsync()
.ConfigureAwait(false);
return ret <= 0 ? throw new NetAdminUnexpectedException() : (uint)ret; return ret <= 0 ? throw new NetAdminUnexpectedException() : (uint)ret;
} }
@ -315,7 +342,7 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryUserRsp> UpdateAsync(UpdateUserReq req) public async Task<QueryUserRsp> UpdateAsync(UpdateUserReq req)
{ {
await CreateUpdateCheckAsync(req); await CreateUpdateCheckAsync(req).ConfigureAwait(false);
// 主表 // 主表
var entity = req.Adapt<Sys_User>(); var entity = req.Adapt<Sys_User>();
@ -324,18 +351,22 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
ignoreCols.Add(nameof(Sys_User.Password)); 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; return ret;
} }
@ -356,7 +387,8 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
.IncludeMany(a => a.Menus) .IncludeMany(a => a.Menus)
.IncludeMany(a => a.Depts) .IncludeMany(a => a.Depts)
.IncludeMany(a => a.Apis)) .IncludeMany(a => a.Apis))
.ToOneAsync(); .ToOneAsync()
.ConfigureAwait(false);
return dbUser.Adapt<UserInfoRsp>(); return dbUser.Adapt<UserInfoRsp>();
} }
@ -388,13 +420,18 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
var roles = await Rpo.Orm.Select<Sys_Role>() var roles = await Rpo.Orm.Select<Sys_Role>()
.ForUpdate() .ForUpdate()
.Where(a => req.RoleIds.Contains(a.Id)) .Where(a => req.RoleIds.Contains(a.Id))
.ToListAsync(a => a.Id); .ToListAsync(a => a.Id)
.ConfigureAwait(false);
if (roles.Count != req.RoleIds.Count) { if (roles.Count != req.RoleIds.Count) {
throw new NetAdminInvalidOperationException(Ln.角色不存在); 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) { if (dept.Count != 1) {
throw new NetAdminInvalidOperationException(Ln.部门不存在); throw new NetAdminInvalidOperationException(Ln.部门不存在);
@ -420,7 +457,8 @@ public sealed class UserService(DefaultRepository<Sys_User> rpo /
deptIds = await Rpo.Orm.Select<Sys_Dept>() deptIds = await Rpo.Orm.Select<Sys_Dept>()
.Where(a => a.Id == req.Filter.DeptId) .Where(a => a.Id == req.Filter.DeptId)
.AsTreeCte() .AsTreeCte()
.ToListAsync(a => a.Id); .ToListAsync(a => a.Id)
.ConfigureAwait(false);
} }
var ret = Rpo.Select.Include(a => a.Dept) 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -30,12 +30,12 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryVerifyCodeRsp> CreateAsync(CreateVerifyCodeReq req) 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>(); var ret = entity.Adapt<QueryVerifyCodeRsp>();
// 发布验证码创建事件 // 发布验证码创建事件
await eventPublisher.PublishAsync(new VerifyCodeCreatedEvent(ret)); await eventPublisher.PublishAsync(new VerifyCodeCreatedEvent(ret)).ConfigureAwait(false);
return ret; return ret;
} }
@ -55,14 +55,20 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryVerifyCodeRsp> GetAsync(QueryVerifyCodeReq req) 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>(); return ret.Adapt<QueryVerifyCodeRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QueryVerifyCodeRsp>> PagedQueryAsync(PagedQueryReq<QueryVerifyCodeReq> req) 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 return new PagedQueryRsp<QueryVerifyCodeRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryVerifyCodeRsp>>()); , list.Adapt<IEnumerable<QueryVerifyCodeRsp>>());
@ -71,14 +77,14 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryVerifyCodeRsp>> QueryAsync(QueryReq<QueryVerifyCodeReq> req) 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>>(); return ret.Adapt<IEnumerable<QueryVerifyCodeRsp>>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<SendVerifyCodeRsp> SendVerifyCodeAsync(SendVerifyCodeReq req) public async Task<SendVerifyCodeRsp> SendVerifyCodeAsync(SendVerifyCodeReq req)
{ {
var lastSent = await GetLastSentAsync(req.DestDevice); var lastSent = await GetLastSentAsync(req.DestDevice).ConfigureAwait(false);
QueryVerifyCodeRsp ret; QueryVerifyCodeRsp ret;
@ -90,11 +96,12 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
#endif #endif
if (lastSent != null && lastSent.Status != VerifyCodeStatues.Verified) { // 上次发送未验证，生成相同code 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 else { // 生成新的code
var code = _randRange.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 }); ret = await CreateAsync(req.Adapt<CreateVerifyCodeReq>() with { Code = code }).ConfigureAwait(false);
} }
return ret.Adapt<SendVerifyCodeRsp>(); return ret.Adapt<SendVerifyCodeRsp>();
@ -104,10 +111,10 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
public async Task<QueryVerifyCodeRsp> UpdateAsync(UpdateVerifyCodeReq req) public async Task<QueryVerifyCodeRsp> UpdateAsync(UpdateVerifyCodeReq req)
{ {
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) { 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>(); return ret.FirstOrDefault()?.Adapt<QueryVerifyCodeRsp>();
} }
@ -123,14 +130,15 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
return true; 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 || if (lastSent is not { Status: VerifyCodeStatues.Sent } || req.Code != lastSent.Code ||
(DateTime.UtcNow - lastSent.CreatedTime).TotalMinutes > 10) { (DateTime.UtcNow - lastSent.CreatedTime).TotalMinutes > 10) {
return false; return false;
} }
_ = await UpdateAsync((lastSent with { Status = VerifyCodeStatues.Verified }).Adapt<UpdateVerifyCodeReq>()); _ = await UpdateAsync((lastSent with { Status = VerifyCodeStatues.Verified }).Adapt<UpdateVerifyCodeReq>())
.ConfigureAwait(false);
return true; return true;
} }
@ -138,9 +146,9 @@ public sealed class VerifyCodeService(DefaultRepository<Sys_VerifyCode> rpo, IEv
/// <inheritdoc /> /// <inheritdoc />
protected override async Task<Sys_VerifyCode> UpdateForSqliteAsync(Sys_VerifyCode req) 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 ? null
: await GetAsync(new QueryVerifyCodeReq { Id = req.Id }); : await GetAsync(new QueryVerifyCodeReq { Id = req.Id }).ConfigureAwait(false);
} }
private Task<Sys_VerifyCode> GetLastSentAsync(string destDevice) 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; var sum = 0;
foreach (var item in req.Items) { foreach (var item in req.Items) {
sum += await DeleteAsync(item); sum += await DeleteAsync(item).ConfigureAwait(false);
} }
return sum; return sum;
@ -26,7 +26,7 @@ public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryExampleRsp> CreateAsync(CreateExampleReq req) 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>(); return ret.Adapt<QueryExampleRsp>();
} }
@ -45,14 +45,20 @@ public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<QueryExampleRsp> GetAsync(QueryExampleReq req) 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>(); return ret.Adapt<QueryExampleRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
public async Task<PagedQueryRsp<QueryExampleRsp>> PagedQueryAsync(PagedQueryReq<QueryExampleReq> req) 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 return new PagedQueryRsp<QueryExampleRsp>(req.Page, req.PageSize, total
, list.Adapt<IEnumerable<QueryExampleRsp>>()); , list.Adapt<IEnumerable<QueryExampleRsp>>());
@ -61,7 +67,7 @@ public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
/// <inheritdoc /> /// <inheritdoc />
public async Task<IEnumerable<QueryExampleRsp>> QueryAsync(QueryReq<QueryExampleReq> req) 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>>(); return ret.Adapt<IEnumerable<QueryExampleRsp>>();
} }
@ -69,19 +75,19 @@ public sealed class ExampleService(DefaultRepository<Tpl_Example> rpo) //
public async Task<QueryExampleRsp> UpdateAsync(UpdateExampleReq req) public async Task<QueryExampleRsp> UpdateAsync(UpdateExampleReq req)
{ {
if (Rpo.Orm.Ado.DataType == DataType.Sqlite) { 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>(); return ret.FirstOrDefault()?.Adapt<QueryExampleRsp>();
} }
/// <inheritdoc /> /// <inheritdoc />
protected override async Task<Tpl_Example> UpdateForSqliteAsync(Tpl_Example req) 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 ? 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) private ISelect<Tpl_Example> QueryInternal(QueryReq<QueryExampleReq> req)

13
src/backend/NetAdmin.SysComponent.Cache/Sys/CaptchaCache.cs
View File

@ -12,9 +12,10 @@ public sealed class CaptchaCache(IDistributedCache cache, ICaptchaService servic
/// <inheritdoc /> /// <inheritdoc />
public async Task<GetCaptchaRsp> GetCaptchaImageAsync() public async Task<GetCaptchaRsp> GetCaptchaImageAsync()
{ {
var captchaRsp = await Service.GetCaptchaImageAsync(); var captchaRsp = await Service.GetCaptchaImageAsync().ConfigureAwait(false);
await CreateAsync(GetCacheKey(captchaRsp.Id, nameof(CaptchaCache)), captchaRsp.SawOffsetX await CreateAsync(GetCacheKey(captchaRsp.Id, nameof(CaptchaCache)), captchaRsp.SawOffsetX
, TimeSpan.FromMinutes(1)); , TimeSpan.FromMinutes(1))
.ConfigureAwait(false);
return captchaRsp; return captchaRsp;
} }
@ -22,10 +23,10 @@ public sealed class CaptchaCache(IDistributedCache cache, ICaptchaService servic
/// <exception cref="NetAdminInvalidOperationException">人机验证未通过</exception> /// <exception cref="NetAdminInvalidOperationException">人机验证未通过</exception>
public async Task VerifyCaptchaAndRemoveAsync(VerifyCaptchaReq req) public async Task VerifyCaptchaAndRemoveAsync(VerifyCaptchaReq req)
{ {
var ret = await VerifyCaptchaAsync(req); var ret = await VerifyCaptchaAsync(req).ConfigureAwait(false);
if (ret) { if (ret) {
// 人机验证通过，删除人机验证缓存 // 人机验证通过，删除人机验证缓存
await RemoveAsync(GetCacheKey(req.Id, nameof(CaptchaCache))); await RemoveAsync(GetCacheKey(req.Id, nameof(CaptchaCache))).ConfigureAwait(false);
} }
else { else {
throw new NetAdminInvalidOperationException(Ln.人机验证未通过); throw new NetAdminInvalidOperationException(Ln.人机验证未通过);
@ -35,7 +36,7 @@ public sealed class CaptchaCache(IDistributedCache cache, ICaptchaService servic
/// <inheritdoc /> /// <inheritdoc />
public async Task<bool> VerifyCaptchaAsync(VerifyCaptchaReq req) public async Task<bool> VerifyCaptchaAsync(VerifyCaptchaReq req)
{ {
var val = await GetAsync<int?>(GetCacheKey(req.Id, nameof(CaptchaCache))); var val = await GetAsync<int?>(GetCacheKey(req.Id, nameof(CaptchaCache))).ConfigureAwait(false);
return await Service.VerifyCaptchaAsync(req with { SawOffsetX = val }); return await Service.VerifyCaptchaAsync(req with { SawOffsetX = val }).ConfigureAwait(false);
} }
} }

4
src/backend/NetAdmin.SysComponent.Cache/Sys/UserCache.cs
View File

@ -153,9 +153,9 @@ public sealed class UserCache(IDistributedCache cache, IUserService service, IVe
/// <inheritdoc /> /// <inheritdoc />
public async Task<UserInfoRsp> SetEmailAsync(SetEmailReq req) public async Task<UserInfoRsp> SetEmailAsync(SetEmailReq req)
{ {
return !await verifyCodeCache.VerifyAsync(req) return !await verifyCodeCache.VerifyAsync(req).ConfigureAwait(false)
? throw new NetAdminInvalidOperationException(Ln.邮箱验证码不正确) ? throw new NetAdminInvalidOperationException(Ln.邮箱验证码不正确)
: await Service.SetEmailAsync(req); : await Service.SetEmailAsync(req).ConfigureAwait(false);
} }
/// <inheritdoc /> /// <inheritdoc />

9
src/backend/NetAdmin.SysComponent.Host/Controllers/Sys/UserController.cs
View File

@ -86,7 +86,7 @@ public sealed class UserController
[Transaction] [Transaction]
public async Task<LoginRsp> LoginByPwdAsync(LoginByPwdReq req) public async Task<LoginRsp> LoginByPwdAsync(LoginByPwdReq req)
{ {
var ret = await Cache.LoginByPwdAsync(req); var ret = await Cache.LoginByPwdAsync(req).ConfigureAwait(false);
ret.SetToRspHeader(); ret.SetToRspHeader();
return ret; return ret;
} }
@ -98,7 +98,7 @@ public sealed class UserController
[Transaction] [Transaction]
public async Task<LoginRsp> LoginBySmsAsync(LoginBySmsReq req) public async Task<LoginRsp> LoginBySmsAsync(LoginBySmsReq req)
{ {
var ret = await Cache.LoginBySmsAsync(req); var ret = await Cache.LoginBySmsAsync(req).ConfigureAwait(false);
ret.SetToRspHeader(); ret.SetToRspHeader();
return ret; return ret;
} }
@ -134,7 +134,7 @@ public sealed class UserController
[AllowAnonymous] [AllowAnonymous]
public async Task<UserInfoRsp> RegisterAsync(RegisterUserReq req) public async Task<UserInfoRsp> RegisterAsync(RegisterUserReq req)
{ {
var config = await configCache.GetLatestConfigAsync(); var config = await configCache.GetLatestConfigAsync().ConfigureAwait(false);
return await Cache.RegisterAsync(req with { return await Cache.RegisterAsync(req with {
DeptId = config.UserRegisterDeptId DeptId = config.UserRegisterDeptId
@ -142,7 +142,8 @@ public sealed class UserController
, Profile = new CreateUserProfileReq() , Profile = new CreateUserProfileReq()
, Enabled = !config.UserRegisterConfirm , Enabled = !config.UserRegisterConfirm
, Mobile = req.VerifySmsCodeReq.DestDevice , Mobile = req.VerifySmsCodeReq.DestDevice
}); })
.ConfigureAwait(false);
} }
/// <summary> /// <summary>

4
src/backend/NetAdmin.SysComponent.Host/Controllers/Sys/VerifyCodeController.cs
View File

@ -72,8 +72,8 @@ public sealed class VerifyCodeController
[AllowAnonymous] [AllowAnonymous]
public async Task<SendVerifyCodeRsp> SendVerifyCodeAsync(SendVerifyCodeReq req) public async Task<SendVerifyCodeRsp> SendVerifyCodeAsync(SendVerifyCodeReq req)
{ {
await captchaCache.VerifyCaptchaAndRemoveAsync(req.VerifyCaptchaReq); await captchaCache.VerifyCaptchaAndRemoveAsync(req.VerifyCaptchaReq).ConfigureAwait(false);
return await Cache.SendVerifyCodeAsync(req); return await Cache.SendVerifyCodeAsync(req).ConfigureAwait(false);
} }
/// <inheritdoc /> /// <inheritdoc />

2
src/backend/NetAdmin.SysComponent.Host/Subscribers/ApiSynchronizer.cs
View File

@ -15,7 +15,7 @@ public sealed class ApiSynchronizer(ILogger<ApiSynchronizer> logger) : IEventSub
public async Task SyncApiAsync(EventHandlerExecutingContext _) public async Task SyncApiAsync(EventHandlerExecutingContext _)
{ {
var logService = App.GetService<IApiService>(); var logService = App.GetService<IApiService>();
await logService.SyncAsync(); await logService.SyncAsync().ConfigureAwait(false);
logger.Info($"{nameof(IApiService)}.{nameof(IApiService.SyncAsync)} {Ln.已完成}"); logger.Info($"{nameof(IApiService)}.{nameof(IApiService.SyncAsync)} {Ln.已完成}");
} }
} }

2
src/backend/NetAdmin.SysComponent.Host/Subscribers/CacheCleaner.cs
View File

@ -26,6 +26,6 @@ public sealed class CacheCleaner : IEventSubscriber
var cache = App.GetService<IUserCache>(); var cache = App.GetService<IUserCache>();
cache.Service.UserToken = ContextUserToken.Create(userUpdatedEvent.Data); cache.Service.UserToken = ContextUserToken.Create(userUpdatedEvent.Data);
await cache.RemoveUserInfoAsync(); await cache.RemoveUserInfoAsync().ConfigureAwait(false);
} }
} }

5
src/backend/NetAdmin.SysComponent.Host/Subscribers/EmailCodeSender.cs
View File

@ -24,7 +24,10 @@ public sealed class EmailCodeSender(ILogger<EmailCodeSender> logger) : IEventSub
// 发送... // 发送...
var verifyCodeService = App.GetService<IVerifyCodeService>(); var verifyCodeService = App.GetService<IVerifyCodeService>();
_ = await verifyCodeService.UpdateAsync( _ = await verifyCodeService.UpdateAsync(
verifyCodeCreatedEvent.Data.Adapt<UpdateVerifyCodeReq>() with { Status = VerifyCodeStatues.Sent }); verifyCodeCreatedEvent.Data.Adapt<UpdateVerifyCodeReq>() with {
Status = VerifyCodeStatues.Sent
})
.ConfigureAwait(false);
logger.Info($"{nameof(IVerifyCodeService)}.{nameof(IVerifyCodeService.UpdateAsync)} {Ln.已完成}"); logger.Info($"{nameof(IVerifyCodeService)}.{nameof(IVerifyCodeService.UpdateAsync)} {Ln.已完成}");
} }
} }

2
src/backend/NetAdmin.SysComponent.Host/Subscribers/OperationLogger.cs
View File

@ -41,6 +41,6 @@ public sealed class OperationLogger : IEventSubscriber
logReq ??= operationEvent.Data; logReq ??= operationEvent.Data;
var logService = App.GetService<IRequestLogService>(); var logService = App.GetService<IRequestLogService>();
logReq.TruncateStrings(); logReq.TruncateStrings();
_ = await logService.CreateAsync(logReq); _ = await logService.CreateAsync(logReq).ConfigureAwait(false);
} }
} }

5
src/backend/NetAdmin.SysComponent.Host/Subscribers/SmsCodeSender.cs
View File

@ -24,7 +24,10 @@ public sealed class SmsCodeSender(ILogger<SmsCodeSender> logger) : IEventSubscri
// 发送... // 发送...
var verifyCodeService = App.GetService<IVerifyCodeService>(); var verifyCodeService = App.GetService<IVerifyCodeService>();
_ = await verifyCodeService.UpdateAsync( _ = await verifyCodeService.UpdateAsync(
verifyCodeCreatedEvent.Data.Adapt<UpdateVerifyCodeReq>() with { Status = VerifyCodeStatues.Sent }); verifyCodeCreatedEvent.Data.Adapt<UpdateVerifyCodeReq>() with {
Status = VerifyCodeStatues.Sent
})
.ConfigureAwait(false);
logger.Info($"{nameof(IVerifyCodeService)}.{nameof(IVerifyCodeService.UpdateAsync)} {Ln.已完成}"); logger.Info($"{nameof(IVerifyCodeService)}.{nameof(IVerifyCodeService.UpdateAsync)} {Ln.已完成}");
} }
} }

10
src/backend/NetAdmin.Tests/WebApiTestBase.cs
View File

@ -30,14 +30,16 @@ public abstract class WebApiTestBase<T>
if (_accessToken == null) { if (_accessToken == null) {
var loginRsp = await client.PostAsync(_API_SYS_USER_LOGIN_BY_PWD var loginRsp = await client.PostAsync(_API_SYS_USER_LOGIN_BY_PWD
, JsonContent.Create( , JsonContent.Create(
new LoginByPwdReq { Password = _PASSWORD, Account = _ACCOUNT })); new LoginByPwdReq { Password = _PASSWORD, Account = _ACCOUNT }))
var loginRspObj = (await loginRsp.Content.ReadAsStringAsync()).ToObject<RestfulInfo<LoginRsp>>(); .ConfigureAwait(false);
var loginRspObj = (await loginRsp.Content.ReadAsStringAsync().ConfigureAwait(false))
.ToObject<RestfulInfo<LoginRsp>>();
_accessToken = loginRspObj.Data.AccessToken; _accessToken = loginRspObj.Data.AccessToken;
} }
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(_AUTH_SCHEMA, _accessToken); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(_AUTH_SCHEMA, _accessToken);
var ret = await client.PostAsync(url, content); var ret = await client.PostAsync(url, content).ConfigureAwait(false);
testOutputHelper.WriteLine(await ret.Content.ReadAsStringAsync()); testOutputHelper.WriteLine(await ret.Content.ReadAsStringAsync().ConfigureAwait(false));
return ret; return ret;
} }
} }

2
switcher.furion.json
View File

@ -9,7 +9,7 @@
"packages": [ "packages": [
{ {
"packageName": "Furion.Pure.NS", "packageName": "Furion.Pure.NS",
"version": "4.9.1-ns1" "version": "4.9.1.5-ns1"
} }
] ]
} }