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

feat: ✨ 框架代码同步 (#150)

Browse Source 
Co-authored-by: tk <fiyne1a@dingtalk.com>
This commit is contained in:
nsnail
2024-07-03 22:09:58 +08:00
committed by GitHub
parent beba4124b0
commit e1b0030193
263 changed files with 2604 additions and 684 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/backend/NetAdmin.SysComponent.Application/Modules/Sys/IDicModule.cs
View File

@ -49,6 +49,11 @@ public interface IDicModule
/// </summary>
Task<QueryDicContentRsp> EditContentAsync(EditDicContentReq req);
/// <summary>
/// 导出字典内容
/// </summary>
Task<IActionResult> ExportContentAsync(QueryReq<QueryDicContentReq> req);
/// <summary>
/// 获取单个字典目录
/// </summary>

22
src/backend/NetAdmin.SysComponent.Application/Modules/Sys/IJobModule.cs
View File

@ -14,6 +14,11 @@ public interface IJobModule : ICrudModule<CreateJobReq, QueryJobRsp // 创建类
, DelReq // 删除类型
>
{
/// <summary>
/// 作业记录计数
/// </summary>
Task<long> CountRecordAsync(QueryReq<QueryJobRecordReq> req);
/// <summary>
/// 编辑作业
/// </summary>
@ -24,6 +29,16 @@ public interface IJobModule : ICrudModule<CreateJobReq, QueryJobRsp // 创建类
/// </summary>
Task ExecuteAsync(QueryJobReq req);
/// <summary>
/// 导出作业记录
/// </summary>
Task<IActionResult> ExportRecordAsync(QueryReq<QueryJobRecordReq> req);
/// <summary>
/// 获取单个作业记录
/// </summary>
Task<QueryJobRecordRsp> GetRecordAsync(QueryJobRecordReq req);
/// <summary>
/// 获取作业记录条形图数据
/// </summary>
@ -39,15 +54,10 @@ public interface IJobModule : ICrudModule<CreateJobReq, QueryJobRsp // 创建类
/// </summary>
Task<IOrderedEnumerable<GetPieChartRsp>> GetRecordPieChartByNameAsync(QueryReq<QueryJobRecordReq> req);
/// <summary>
/// 获取单个作业记录
/// </summary>
Task<QueryJobRecordRsp> RecordGetAsync(QueryJobRecordReq req);
/// <summary>
/// 分页查询作业记录
/// </summary>
Task<PagedQueryRsp<QueryJobRecordRsp>> RecordPagedQueryAsync(PagedQueryReq<QueryJobRecordReq> req);
Task<PagedQueryRsp<QueryJobRecordRsp>> PagedQueryRecordAsync(PagedQueryReq<QueryJobRecordReq> req);
/// <summary>
/// 设置计划作业启用状态

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

@ -1,6 +1,7 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.Api;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -57,6 +58,39 @@ public sealed class ApiService(
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryApiReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportApiRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportApiRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.接口导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public Task<QueryApiRsp> GetAsync(QueryApiReq req)
{

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

@ -1,6 +1,7 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.Config;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -74,6 +75,39 @@ public sealed class ConfigService(BasicRepository<Sys_Config, long> rpo) //
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryConfigReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportConfigRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportConfigRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.配置导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public async Task<QueryConfigRsp> GetAsync(QueryConfigReq req)
{

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

@ -1,6 +1,5 @@
using Microsoft.OpenApi.Extensions;
using NetAdmin.Application.Services;
using NetAdmin.Domain.Attributes;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
namespace NetAdmin.SysComponent.Application.Services.Sys;

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

@ -1,6 +1,7 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.Dept;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -92,6 +93,39 @@ public sealed class DeptService(BasicRepository<Sys_Dept, long> rpo) //
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryDeptReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportDeptRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportDeptRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.部门导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public async Task<QueryDeptRsp> GetAsync(QueryDeptReq req)
{

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

@ -1,6 +1,5 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.Dic.Catalog;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -80,6 +79,12 @@ public sealed class DicCatalogService(BasicRepository<Sys_DicCatalog, long> rpo)
.AnyAsync();
}
/// <inheritdoc />
public Task<IActionResult> ExportAsync(QueryReq<QueryDicCatalogReq> req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public async Task<QueryDicCatalogRsp> GetAsync(QueryDicCatalogReq req)
{

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

@ -1,6 +1,7 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.Dic.Content;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -94,6 +95,39 @@ public sealed class DicContentService(BasicRepository<Sys_DicContent, long> rpo)
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryDicContentReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportDicContentRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportDicContentRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.字典内容导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public async Task<QueryDicContentRsp> GetAsync(QueryDicContentReq req)
{

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

@ -66,6 +66,13 @@ public sealed class DicService(IDicCatalogService catalogService, IDicContentSer
return contentService.EditAsync(req);
}
/// <inheritdoc />
public Task<IActionResult> ExportContentAsync(QueryReq<QueryDicContentReq> req)
{
req.ThrowIfInvalid();
return contentService.ExportAsync(req);
}
/// <inheritdoc />
public Task<QueryDicCatalogRsp> GetCatalogAsync(QueryDicCatalogReq req)
{

39
src/backend/NetAdmin.SysComponent.Application/Services/Sys/JobRecordService.cs
View File

@ -1,6 +1,7 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys;
using NetAdmin.Domain.Dto.Sys.JobRecord;
@ -63,6 +64,39 @@ public sealed class JobRecordService(BasicRepository<Sys_JobRecord, long> rpo) /
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryJobRecordReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportJobRecordRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportJobRecordRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.计划作业执行记录导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public async Task<QueryJobRecordRsp> GetAsync(QueryJobRecordReq req)
{
@ -170,7 +204,8 @@ public sealed class JobRecordService(BasicRepository<Sys_JobRecord, long> rpo) /
.WhereDynamic(req.Filter)
.WhereIf( //
req.Keywords?.Length > 0
, a => a.JobId == req.Keywords.Int64Try(0) || a.Id == req.Keywords.Int64Try(0));
, a => a.JobId == req.Keywords.Int64Try(0) || a.Id == req.Keywords.Int64Try(0) ||
a.Job.JobName == req.Keywords);
switch (req.Order) {
case Orders.None:
return ret;

77
src/backend/NetAdmin.SysComponent.Application/Services/Sys/JobService.cs
View File

@ -1,8 +1,9 @@
using Cronos;
using CsvHelper;
using FreeSql.Internal;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys;
using NetAdmin.Domain.Dto.Sys.Job;
@ -41,6 +42,12 @@ public sealed class JobService(BasicRepository<Sys_Job, long> rpo, IJobRecordSer
.CountAsync();
}
/// <inheritdoc />
public Task<long> CountRecordAsync(QueryReq<QueryJobRecordReq> req)
{
return jobRecordService.CountAsync(req);
}
/// <inheritdoc />
public async Task<QueryJobRsp> CreateAsync(CreateJobReq req)
{
@ -132,6 +139,46 @@ public sealed class JobService(BasicRepository<Sys_Job, long> rpo, IJobRecordSer
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryJobReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportJobRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportJobRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.计划作业导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public Task<IActionResult> ExportRecordAsync(QueryReq<QueryJobRecordReq> req)
{
req.ThrowIfInvalid();
return jobRecordService.ExportAsync(req);
}
/// <inheritdoc />
public async Task FinishJobAsync(FinishJobReq req)
{
@ -209,6 +256,13 @@ public sealed class JobService(BasicRepository<Sys_Job, long> rpo, IJobRecordSer
#endif
}
/// <inheritdoc />
public Task<QueryJobRecordRsp> GetRecordAsync(QueryJobRecordReq req)
{
req.ThrowIfInvalid();
return jobRecordService.GetAsync(req);
}
/// <inheritdoc />
public Task<IOrderedEnumerable<GetBarChartRsp>> GetRecordBarChartAsync(QueryReq<QueryJobRecordReq> req)
{
@ -247,6 +301,13 @@ public sealed class JobService(BasicRepository<Sys_Job, long> rpo, IJobRecordSer
return new PagedQueryRsp<QueryJobRsp>(req.Page, req.PageSize, total, list.Adapt<IEnumerable<QueryJobRsp>>());
}
/// <inheritdoc />
public Task<PagedQueryRsp<QueryJobRecordRsp>> PagedQueryRecordAsync(PagedQueryReq<QueryJobRecordReq> req)
{
req.ThrowIfInvalid();
return jobRecordService.PagedQueryAsync(req);
}
/// <inheritdoc />
public async Task<IEnumerable<QueryJobRsp>> QueryAsync(QueryReq<QueryJobReq> req)
{
@ -261,20 +322,6 @@ public sealed class JobService(BasicRepository<Sys_Job, long> rpo, IJobRecordSer
return ret.Adapt<IEnumerable<QueryJobRsp>>();
}
/// <inheritdoc />
public Task<QueryJobRecordRsp> RecordGetAsync(QueryJobRecordReq req)
{
req.ThrowIfInvalid();
return jobRecordService.GetAsync(req);
}
/// <inheritdoc />
public Task<PagedQueryRsp<QueryJobRecordRsp>> RecordPagedQueryAsync(PagedQueryReq<QueryJobRecordReq> req)
{
req.ThrowIfInvalid();
return jobRecordService.PagedQueryAsync(req);
}
/// <inheritdoc />
public async Task<int> ReleaseStuckTaskAsync()
{

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

@ -1,6 +1,5 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.Menu;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -79,6 +78,12 @@ public sealed class MenuService(BasicRepository<Sys_Menu, long> rpo, IUserServic
.AnyAsync();
}
/// <inheritdoc />
public Task<IActionResult> ExportAsync(QueryReq<QueryMenuReq> req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public async Task<QueryMenuRsp> GetAsync(QueryMenuReq req)
{

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

@ -1,6 +1,7 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys;
using NetAdmin.Domain.Dto.Sys.RequestLog;
@ -65,6 +66,39 @@ public sealed class RequestLogService(BasicRepository<Sys_RequestLog, long> rpo)
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryRequestLogReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportRequestLogRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportRequestLogRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.请求日志导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public async Task<QueryRequestLogRsp> GetAsync(QueryRequestLogReq req)
{

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

@ -1,6 +1,7 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.Role;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -86,6 +87,39 @@ public sealed class RoleService(BasicRepository<Sys_Role, long> rpo) //
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryRoleReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportRoleRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportRoleRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.角色导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public async Task<QueryRoleRsp> GetAsync(QueryRoleReq req)
{

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

@ -1,6 +1,5 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsgDept;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -62,6 +61,12 @@ public sealed class SiteMsgDeptService(BasicRepository<Sys_SiteMsgDept, long> rp
.AnyAsync();
}
/// <inheritdoc />
public Task<IActionResult> ExportAsync(QueryReq<QuerySiteMsgDeptReq> req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public async Task<QuerySiteMsgDeptRsp> GetAsync(QuerySiteMsgDeptReq req)
{

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

@ -1,6 +1,5 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsgFlag;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -62,6 +61,12 @@ public sealed class SiteMsgFlagService(BasicRepository<Sys_SiteMsgFlag, long> rp
.AnyAsync();
}
/// <inheritdoc />
public Task<IActionResult> ExportAsync(QueryReq<QuerySiteMsgFlagReq> req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public async Task<QuerySiteMsgFlagRsp> GetAsync(QuerySiteMsgFlagReq req)
{

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

@ -1,6 +1,5 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsgRole;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -62,6 +61,12 @@ public sealed class SiteMsgRoleService(BasicRepository<Sys_SiteMsgRole, long> rp
.AnyAsync();
}
/// <inheritdoc />
public Task<IActionResult> ExportAsync(QueryReq<QuerySiteMsgRoleReq> req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public async Task<QuerySiteMsgRoleRsp> GetAsync(QuerySiteMsgRoleReq req)
{

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

@ -1,7 +1,8 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.Contexts;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsg;
using NetAdmin.Domain.Dto.Sys.SiteMsgFlag;
@ -110,6 +111,39 @@ public sealed class SiteMsgService(
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QuerySiteMsgReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportSiteMsgRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportSiteMsgRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.站内信导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public async Task<QuerySiteMsgRsp> GetAsync(QuerySiteMsgReq req)
{
@ -325,7 +359,7 @@ public sealed class SiteMsgService(
.LeftJoin((a, _, c, _, _, _) => a.Id == c.SiteMsgId)
.LeftJoin((a, _, _, d, _, _) => a.Id == d.SiteMsgId)
.LeftJoin((a, _, _, _, e, _) => a.Id == e.SiteMsgId)
.LeftJoin((a, b, _, _, _, f) => a.Id == f.SiteMsgId && f.UserId == b.Id)
.LeftJoin((a, _, _, _, _, f) => a.Id == f.SiteMsgId && f.UserId == contextUserInfo.Id)
.WhereDynamicFilter(req.DynamicFilter)
.Where((a, _, c, d, e, f) =>
(SqlExt.EqualIsNull(f.UserSiteMsgStatus) ||

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

@ -1,6 +1,5 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.SiteMsgUser;
using NetAdmin.SysComponent.Application.Services.Sys.Dependency;
@ -62,6 +61,12 @@ public sealed class SiteMsgUserService(BasicRepository<Sys_SiteMsgUser, long> rp
.AnyAsync();
}
/// <inheritdoc />
public Task<IActionResult> ExportAsync(QueryReq<QuerySiteMsgUserReq> req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public async Task<QuerySiteMsgUserRsp> GetAsync(QuerySiteMsgUserReq req)
{

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

@ -1,6 +1,6 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Contexts;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.Dic.Content;
using NetAdmin.Domain.Dto.Sys.UserProfile;
@ -12,6 +12,26 @@ namespace NetAdmin.SysComponent.Application.Services.Sys;
public sealed class UserProfileService(BasicRepository<Sys_UserProfile, long> rpo) //
: RepositoryService<Sys_UserProfile, long, IUserProfileService>(rpo), IUserProfileService
{
/// <summary>
/// 构建应用配置
/// </summary>
public static string BuildAppConfig(Dictionary<long, string> roles)
{
try {
return new string[][] { [
Chars.FLG_FRONT_APP_SET_HOME_GRID
, new {
content = roles.MaxBy(x => x.Key).Value.ToObject<object>()
, datetime = 0
}.ToJson()
]
}.ToJson();
}
catch {
return "[]";
}
}
/// <inheritdoc />
public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
{
@ -70,6 +90,12 @@ public sealed class UserProfileService(BasicRepository<Sys_UserProfile, long> rp
.AnyAsync();
}
/// <inheritdoc />
public Task<IActionResult> ExportAsync(QueryReq<QueryUserProfileReq> req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public async Task<QueryUserProfileRsp> GetAsync(QueryUserProfileReq req)
{
@ -158,6 +184,13 @@ public sealed class UserProfileService(BasicRepository<Sys_UserProfile, long> rp
public Task<int> SetSessionUserAppConfigAsync(SetSessionUserAppConfigReq req)
{
req.ThrowIfInvalid();
// 默认仪表版
if (req.AppConfig == "[]") {
req.AppConfig = BuildAppConfig(App.GetService<ContextUserInfo>()
.Roles.ToDictionary(x => x.Id, x => x.DashboardLayout));
}
return UpdateAsync(req, [nameof(req.AppConfig)], null, a => a.Id == UserToken.Id, null, true);
}

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

@ -1,8 +1,8 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.Attributes.DataValidation;
using NetAdmin.Domain.Contexts;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.User;
using NetAdmin.Domain.Dto.Sys.UserProfile;
@ -81,7 +81,7 @@ public sealed class UserService(
public async Task<QueryUserRsp> CreateAsync(CreateUserReq req)
{
req.ThrowIfInvalid();
await CreateEditCheckAsync(req).ConfigureAwait(false);
var roles = await CreateEditCheckAsync(req).ConfigureAwait(false);
// 主表
var entity = req.Adapt<Sys_User>();
@ -91,7 +91,13 @@ public sealed class UserService(
await Rpo.SaveManyAsync(entity, nameof(entity.Roles)).ConfigureAwait(false);
// 档案表
_ = await userProfileService.CreateAsync((req.Profile ?? new CreateUserProfileReq()) with { Id = dbUser.Id })
var appConfig = UserProfileService.BuildAppConfig(roles);
_ = await userProfileService.CreateAsync((req.Profile ?? new CreateUserProfileReq()) with //
{
Id = dbUser.Id //
, AppConfig = appConfig
})
.ConfigureAwait(false);
var ret = await QueryAsync(new QueryReq<QueryUserReq> { Filter = new QueryUserReq { Id = dbUser.Id } })
.ConfigureAwait(false);
@ -119,7 +125,7 @@ public sealed class UserService(
public async Task<QueryUserRsp> EditAsync(EditUserReq req)
{
req.ThrowIfInvalid();
await CreateEditCheckAsync(req).ConfigureAwait(false);
_ = await CreateEditCheckAsync(req).ConfigureAwait(false);
// 主表
var entity = req.Adapt<Sys_User>();
@ -153,6 +159,43 @@ public sealed class UserService(
return await (await QueryInternalAsync(req).ConfigureAwait(false)).AnyAsync().ConfigureAwait(false);
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryUserReq> req)
{
req.ThrowIfInvalid();
#pragma warning disable VSTHRD103, S6966
// ReSharper disable once MethodHasAsyncOverload
var data = await QueryInternal(req)
#pragma warning restore S6966, VSTHRD103
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<ExportUserRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<ExportUserRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.用户导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public async Task<QueryUserRsp> GetAsync(QueryUserReq req)
{
@ -443,13 +486,13 @@ public sealed class UserService(
};
}
private async Task CreateEditCheckAsync(CreateEditUserReq req)
private async Task<Dictionary<long, string>> CreateEditCheckAsync(CreateEditUserReq req)
{
// 检查角色是否存在
var roles = await Rpo.Orm.Select<Sys_Role>()
.ForUpdate()
.Where(a => req.RoleIds.Contains(a.Id))
.ToListAsync(a => a.Id)
.ToDictionaryAsync(a => a.Id, a => a.DashboardLayout)
.ConfigureAwait(false);
if (roles.Count != req.RoleIds.Count) {
throw new NetAdminInvalidOperationException(Ln.角色不存在);
@ -462,40 +505,11 @@ public sealed class UserService(
.ToListAsync(a => a.Id)
.ConfigureAwait(false);
if (dept.Count != 1) {
throw new NetAdminInvalidOperationException(Ln.部门不存在);
}
return dept.Count != 1 ? throw new NetAdminInvalidOperationException(Ln.部门不存在) : roles;
}
private ISelect<Sys_User> QueryInternal(QueryReq<QueryUserReq> req)
private ISelect<Sys_User> QueryInternal(QueryReq<QueryUserReq> req, IEnumerable<long> deptIds)
{
var ret = Rpo.Select.WhereDynamicFilter(req.DynamicFilter).WhereDynamic(req.Filter);
switch (req.Order) {
case Orders.None:
return ret;
case Orders.Random:
return ret.OrderByRandom();
}
ret = ret.OrderByPropertyNameIf(req.Prop?.Length > 0, req.Prop, req.Order == Orders.Ascending);
if (!req.Prop?.Equals(nameof(req.Filter.Id), StringComparison.OrdinalIgnoreCase) ?? true) {
ret = ret.OrderByDescending(a => a.Id);
}
return ret;
}
private async Task<ISelect<Sys_User>> QueryInternalAsync(QueryReq<QueryUserReq> req)
{
IEnumerable<long> deptIds = null;
if (req.Filter?.DeptId > 0) {
deptIds = await Rpo.Orm.Select<Sys_Dept>()
.Where(a => a.Id == req.Filter.DeptId)
.AsTreeCte()
.ToListAsync(a => a.Id)
.ConfigureAwait(false);
}
var ret = Rpo.Select.Include(a => a.Dept)
.IncludeMany(a => a.Roles.Select(b => new Sys_Role { Id = b.Id, Name = b.Name }))
.WhereDynamicFilter(req.DynamicFilter)
@ -524,4 +538,28 @@ public sealed class UserService(
return ret;
}
private ISelect<Sys_User> QueryInternal(QueryReq<QueryUserReq> req)
{
IEnumerable<long> deptIds = null;
if (req.Filter?.DeptId > 0) {
deptIds = Rpo.Orm.Select<Sys_Dept>().Where(a => a.Id == req.Filter.DeptId).AsTreeCte().ToList(a => a.Id);
}
return QueryInternal(req, deptIds);
}
private async Task<ISelect<Sys_User>> QueryInternalAsync(QueryReq<QueryUserReq> req)
{
IEnumerable<long> deptIds = null;
if (req.Filter?.DeptId > 0) {
deptIds = await Rpo.Orm.Select<Sys_Dept>()
.Where(a => a.Id == req.Filter.DeptId)
.AsTreeCte()
.ToListAsync(a => a.Id)
.ConfigureAwait(false);
}
return QueryInternal(req, deptIds);
}
}

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

@ -1,6 +1,5 @@
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Sys;
using NetAdmin.Domain.Dto.Dependency;
using NetAdmin.Domain.Dto.Sys.VerifyCode;
using NetAdmin.Domain.Enums.Sys;
@ -72,6 +71,12 @@ public sealed class VerifyCodeService(BasicRepository<Sys_VerifyCode, long> rpo,
.AnyAsync();
}
/// <inheritdoc />
public Task<IActionResult> ExportAsync(QueryReq<QueryVerifyCodeReq> req)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public async Task<QueryVerifyCodeRsp> GetAsync(QueryVerifyCodeReq req)
{

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

@ -1,3 +1,5 @@
using CsvHelper;
using Microsoft.Net.Http.Headers;
using NetAdmin.Application.Repositories;
using NetAdmin.Application.Services;
using NetAdmin.Domain.DbMaps.Tpl;
@ -62,6 +64,39 @@ public sealed class ExampleService(BasicRepository<Tpl_Example, long> rpo) //
.AnyAsync();
}
/// <inheritdoc />
public async Task<IActionResult> ExportAsync(QueryReq<QueryExampleReq> req)
{
req.ThrowIfInvalid();
var data = await QueryInternal(req)
#if DBTYPE_SQLSERVER
.WithLock(SqlServerLock.NoLock | SqlServerLock.NoWait)
#endif
.Take(Numbers.MAX_LIMIT_EXPORT)
.ToListAsync()
.ConfigureAwait(false);
var list = data.Adapt<List<QueryExampleRsp>>();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
var csv = new CsvWriter(writer, CultureInfo.InvariantCulture);
csv.WriteHeader<QueryExampleRsp>();
await csv.NextRecordAsync().ConfigureAwait(false);
foreach (var item in list) {
csv.WriteRecord(item);
await csv.NextRecordAsync().ConfigureAwait(false);
}
await csv.FlushAsync().ConfigureAwait(false);
_ = stream.Seek(0, SeekOrigin.Begin);
App.HttpContext.Response.Headers.ContentDisposition
= new ContentDispositionHeaderValue(Chars.FLG_HTTP_HEADER_VALUE_ATTACHMENT) {
FileNameStar = $"{Ln.示例导出}_{DateTime.Now:yyyy.MM.dd-HH.mm.ss}.csv"
}.ToString();
return new FileStreamResult(stream, Chars.FLG_HTTP_HEADER_VALUE_APPLICATION_OCTET_STREAM);
}
/// <inheritdoc />
public async Task<QueryExampleRsp> GetAsync(QueryExampleReq req)
{