lingyun/NetAdmin
lingyun/NetAdmin
Template
6
0
Fork 0
mirror of https://github.com/nsnail/NetAdmin.git synced 2025-04-20 05:02:50 +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>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</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">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

4
dotnet-tools.json
View File

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

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

@ -56,11 +56,11 @@ public static class IApplicationBuilderExtensions
if (output != null) {
context.Response.ContentLength = output.Length;
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;
}
}
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，或用户已被禁用，拒绝访问
var userInfo = await App.GetService<IUserCache>().UserInfoAsync();
var userInfo = await App.GetService<IUserCache>().UserInfoAsync().ConfigureAwait(false);
if (userInfo?.Roles == null) {
return false;
}

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

@ -32,7 +32,7 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
[Fact]
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);
return default;
}
@ -73,7 +73,8 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
public async Task<PagedQueryRsp<GetAllEntriesRsp>> GetAllEntriesAsync(PagedQueryReq<GetAllEntriesReq> req)
{
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);
return default;
}
@ -106,7 +107,7 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
[Fact]
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);
return default;
}
@ -115,7 +116,7 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
[Fact]
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);
return default;
}
@ -154,7 +155,7 @@ public class AllTests(WebApplicationFactory<Startup> factory, ITestOutputHelper
[Fact]
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);
}

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

@ -45,7 +45,7 @@ public abstract class DistributedCache<TService> : CacheBase<IDistributedCache,
/// </summary>
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;
}
@ -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
, TimeSpan? slideLifeTime = null)
{
var cacheRead = await GetAsync<T>(key);
var cacheRead = await GetAsync<T>(key).ConfigureAwait(false);
if (cacheRead is not null) {
return cacheRead;
}
var obj = await createProc.Invoke();
var obj = await createProc.Invoke().ConfigureAwait(false);
var cacheWrite = obj?.ToJson();
if (cacheWrite == null) {
return obj;
}
await CreateAsync(key, obj, absLifeTime, slideLifeTime);
await CreateAsync(key, obj, absLifeTime, slideLifeTime).ConfigureAwait(false);
return obj;
}

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

@ -66,7 +66,7 @@ public sealed record ContextApp : DataAbstraction, IValidatableObject
// 具有secret的情况下，自动生成时间戳+sign，方便调试
if (!ret.AppSecret.NullOrEmpty()) {
ret.Timestamp = DateTime.Now.TimeUnixUtc();
ret.Sign = await ret.BuildSignFromHttpContextAsync();
ret.Sign = await ret.BuildSignFromHttpContextAsync().ConfigureAwait(false);
}
return ret;
@ -88,7 +88,7 @@ public sealed record ContextApp : DataAbstraction, IValidatableObject
public async Task<string> BuildSignFromHttpContextAsync()
{
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);
return BuildSign(reqBody);

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

@ -58,15 +58,15 @@ public abstract class WorkBase<TLogger>
{
if (singleInstance) {
// 加锁
await using var redLock = await GetLockerAsync(GetType().FullName);
await using var redLock = await GetLockerAsync(GetType().FullName).ConfigureAwait(false);
if (!redLock.IsAcquired) {
throw new NetAdminGetLockerException();
}
await WorkflowAsync(cancelToken);
await WorkflowAsync(cancelToken).ConfigureAwait(false);
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);
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(",}", "}");
_ = me.Response.Body.Seek(0, SeekOrigin.Begin);
var bytes = Encoding.UTF8.GetBytes(bodyString);
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自动值处理
var eventPublisher = App.GetService<IEventPublisher>();
#pragma warning disable VSTHRD110
// AOP事件发布（异步）
freeSql.Aop.CommandBefore
+= (_, e) => eventPublisher.PublishAsync(new SqlCommandBeforeEvent(e)); // 增删查改，执行命令之前触发
@ -175,6 +177,7 @@ public static class ServiceCollectionExtensions
freeSql.Aop.SyncStructureAfter += (_, e) =>
eventPublisher.PublishAsync(new SyncStructureAfterEvent(e)); // CodeFirst迁移，执行完成触发
#pragma warning restore VSTHRD110
// 全局过滤器设置
freeSqlConfig?.Invoke(freeSql);

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

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

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

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

13
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>() ==
null) {
_ = await next();
_ = await next().ConfigureAwait(false);
return;
}
// 事务操作
await uowManager.AtomicOperateAsync(async () => {
var result = await next();
if (result.Exception != null) {
throw result.Exception;
}
});
var result = await next().ConfigureAwait(false);
if (result.Exception != null) {
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>
public async Task InvokeAsync(HttpContext context)
{
await next(context);
await next(context).ConfigureAwait(false);
if (context.GetMetadata<RemoveNullNodeAttribute>() is null) {
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请求
|| context.Request.Path.StartsWithSegments(_healthCheckRoutePrefix) // 健康检查
|| context.Request.Method == Chars.FLG_HTTP_METHOD_OPTIONS) { // is options 请求
await next(context);
await next(context).ConfigureAwait(false);
return;
}
@ -40,14 +40,14 @@ public sealed class RequestAuditMiddleware(RequestDelegate next
// 调用下一个中间件
var sw = Stopwatch.StartNew();
await next(context);
await next(context).ConfigureAwait(false);
sw.Stop();
_ = ms.Seek(0, SeekOrigin.Begin);
using var sr = new StreamReader(ms);
var responseBody = await sr.ReadToEndAsync();
var responseBody = await sr.ReadToEndAsync().ConfigureAwait(false);
_ = ms.Seek(0, SeekOrigin.Begin);
await ms.CopyToAsync(stream);
await ms.CopyToAsync(stream).ConfigureAwait(false);
context.Response.Body = stream;
var exception = context.Features.Get<IExceptionHandlerFeature>();
@ -56,6 +56,7 @@ public sealed class RequestAuditMiddleware(RequestDelegate next
?.Enum<ErrorCodes>() ?? 0;
_ = 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
, x => context.Request.ContentType?.Contains(
x, StringComparison.OrdinalIgnoreCase) ?? false)
? await context.ReadBodyContentAsync()
? await context.ReadBodyContentAsync().ConfigureAwait(false)
: string.Empty
, RequestUrl = context.Request.GetRequestUrlAddress()
, ResponseBody = responseBody
@ -57,7 +57,7 @@ public sealed class RequestLogger(ILogger<RequestLogger>
logger.Info(auditData);
// 发布请求日志事件
await eventPublisher.PublishAsync(new RequestLogEvent(auditData));
await eventPublisher.PublishAsync(new RequestLogEvent(auditData)).ConfigureAwait(false);
return auditData;
}

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

@ -10,7 +10,7 @@ public static class HttpRequestMessageExtensions
/// </summary>
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();
}
@ -19,7 +19,7 @@ public static class HttpRequestMessageExtensions
/// </summary>
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;
}
}

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
, Func<string, string> bodyHandle = null)
{
async void RequestHandle(HttpClient _, HttpRequestMessage req)
#pragma warning disable S1172
Task RequestHandle(HttpClient _, HttpRequestMessage req)
{
#pragma warning disable IDE0058
await req.LogAsync(logger);
#pragma warning restore IDE0058
return req.LogAsync(logger);
}
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);
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
, Func<string, string> bodyPreHandle = null)
{
logger.Info(await me.BuildJsonAsync(bodyPreHandle));
logger.Info(await me.BuildJsonAsync(bodyPreHandle).ConfigureAwait(false));
}
/// <summary>
@ -20,7 +20,7 @@ public static class HttpResponseMessageExtensions
public static async Task LogExceptionAsync<T>(this HttpResponseMessage me, string errors, ILogger<T> logger
, Func<string, string> bodyHandle = null)
{
logger.Warn($"{errors}: {await me.BuildJsonAsync(bodyHandle)}");
logger.Warn($"{errors}: {await me.BuildJsonAsync(bodyHandle).ConfigureAwait(false)}");
}
/// <summary>
@ -29,7 +29,7 @@ public static class HttpResponseMessageExtensions
private static async Task<string> BuildJsonAsync( //
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();
}
}

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

@ -8,9 +8,9 @@
<ItemGroup>
<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="Furion.Extras.Authentication.JwtBearer" Version="4.9.1"/>
<PackageReference Include="Furion.Extras.ObjectMapper.Mapster.NS" Version="4.9.1-ns1"/>
<PackageReference Include="Furion.Pure.NS" Version="4.9.1-ns1"/>
<PackageReference Include="Furion.Extras.Authentication.JwtBearer" Version="4.9.1.5"/>
<PackageReference Include="Furion.Extras.ObjectMapper.Mapster.NS" Version="4.9.1.5-ns1"/>
<PackageReference Include="Furion.Pure.NS" Version="4.9.1.5-ns1"/>
<PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="8.0.0"/>
<PackageReference Include="NSExt" Version="1.1.0"/>
<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");
// 底图
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));

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);
if (!await minio.BucketExistsAsync(beArgs)) {
if (!await minio.BucketExistsAsync(beArgs).ConfigureAwait(false)) {
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)
@ -36,7 +36,7 @@ public sealed class MinioHelper(IOptions<UploadOptions> uploadOptions) : IScoped
.WithStreamData(fileStream)
.WithObjectSize(fileSize)
.WithContentType(contentType);
_ = await minio.PutObjectAsync(putArgs);
_ = await minio.PutObjectAsync(putArgs).ConfigureAwait(false);
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>
public async Task ExecuteAsync(JobExecutingContext context, CancellationToken stoppingToken)
{
await WorkflowAsync(stoppingToken);
await WorkflowAsync(stoppingToken).ConfigureAwait(false);
}
/// <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 />
public async Task<IEnumerable<QueryApiRsp>> QueryAsync(QueryReq<QueryApiReq> req)
{
var ret = await Rpo.Select.WhereDynamicFilter(req.DynamicFilter).WhereDynamic(req.Filter).ToTreeListAsync();
var ret = await Rpo.Select.WhereDynamicFilter(req.DynamicFilter)
.WhereDynamic(req.Filter)
.ToTreeListAsync()
.ConfigureAwait(false);
return ret.Adapt<IEnumerable<QueryApiRsp>>();
}
@ -90,14 +93,14 @@ public sealed class ApiService(DefaultRepository<Sys_Api> rpo
/// <inheritdoc />
public async Task SyncAsync()
{
_ = await Rpo.DeleteAsync(_ => true);
_ = await Rpo.DeleteAsync(_ => true).ConfigureAwait(false);
var list = ReflectionList(false);
EnableCascadeSave = true;
foreach (var item in list) {
var entity = item.Adapt<Sys_Api>();
_ = await Rpo.InsertAsync(entity);
_ = await Rpo.InsertAsync(entity).ConfigureAwait(false);
}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -29,6 +29,6 @@ public sealed class FileService(IOptions<UploadOptions> uploadOptions, MinioHelp
var fileName = $"{Guid.NewGuid()}{Path.GetExtension(file.FileName)}";
var objectName = $"{UserToken.Id}/{fileName}";
await using var fs = file.OpenReadStream();
return await minioHelper.UploadAsync(objectName, fs, file.ContentType, file.Length);
return await minioHelper.UploadAsync(objectName, fs, file.ContentType, file.Length).ConfigureAwait(false);
}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -72,8 +72,8 @@ public sealed class VerifyCodeController
[AllowAnonymous]
public async Task<SendVerifyCodeRsp> SendVerifyCodeAsync(SendVerifyCodeReq req)
{
await captchaCache.VerifyCaptchaAndRemoveAsync(req.VerifyCaptchaReq);
return await Cache.SendVerifyCodeAsync(req);
await captchaCache.VerifyCaptchaAndRemoveAsync(req.VerifyCaptchaReq).ConfigureAwait(false);
return await Cache.SendVerifyCodeAsync(req).ConfigureAwait(false);
}
/// <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 _)
{
var logService = App.GetService<IApiService>();
await logService.SyncAsync();
await logService.SyncAsync().ConfigureAwait(false);
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>();
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>();
_ = 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.已完成}");
}
}

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

@ -41,6 +41,6 @@ public sealed class OperationLogger : IEventSubscriber
logReq ??= operationEvent.Data;
var logService = App.GetService<IRequestLogService>();
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>();
_ = 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.已完成}");
}
}

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

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

2
switcher.furion.json
View File

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