From 8ef2ff43b04aaeaf15b743451db468b021579035 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=99=88=E6=B7=B3?= <454313500@qq.com> Date: Wed, 27 Dec 2023 18:59:26 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E6=90=AD=E5=BB=BA=E5=AE=A1=E8=AE=A1?= =?UTF-8?q?=E6=97=A5=E5=BF=97=E6=A8=A1=E5=9D=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Yi.Abp.Net8/Yi.Abp.sln | 10 + .../SqlSugarDbContext.cs | 13 +- .../SqlSugarCoreAuditLogRepository.cs | 266 ++++++++++++++++++ .../Yi.AuditLogging.SqlSugarCore.csproj | 17 ++ .../YiAuditLoggingDbContext.cs | 134 +++++++++ .../YiAuditLoggingSqlSugarCoreModule.cs | 16 ++ 6 files changed, 455 insertions(+), 1 deletion(-) create mode 100644 Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/SqlSugarCoreAuditLogRepository.cs create mode 100644 Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/Yi.AuditLogging.SqlSugarCore.csproj create mode 100644 Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/YiAuditLoggingDbContext.cs create mode 100644 Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/YiAuditLoggingSqlSugarCoreModule.cs diff --git a/Yi.Abp.Net8/Yi.Abp.sln b/Yi.Abp.Net8/Yi.Abp.sln index eba0b309..2c715929 100644 --- a/Yi.Abp.Net8/Yi.Abp.sln +++ b/Yi.Abp.Net8/Yi.Abp.sln @@ -68,6 +68,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Yi.Framework.Bbs.Applicatio EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Yi.Framework.Bbs.SqlSugarCore", "module\bbs\Yi.Framework.Bbs.SqlSugarCore\Yi.Framework.Bbs.SqlSugarCore.csproj", "{6C86BA71-9F87-4E2C-B467-2950D77DCDFA}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "audit-logging", "audit-logging", "{73CCF2C4-B9FD-44AB-8D4B-0A421805B094}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Yi.AuditLogging.SqlSugarCore", "module\audit-logging\Yi.AuditLogging.SqlSugarCore\Yi.AuditLogging.SqlSugarCore.csproj", "{48806510-8E18-4E1E-9BAF-5B97E88C5FC3}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -166,6 +170,10 @@ Global {6C86BA71-9F87-4E2C-B467-2950D77DCDFA}.Debug|Any CPU.Build.0 = Debug|Any CPU {6C86BA71-9F87-4E2C-B467-2950D77DCDFA}.Release|Any CPU.ActiveCfg = Release|Any CPU {6C86BA71-9F87-4E2C-B467-2950D77DCDFA}.Release|Any CPU.Build.0 = Release|Any CPU + {48806510-8E18-4E1E-9BAF-5B97E88C5FC3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {48806510-8E18-4E1E-9BAF-5B97E88C5FC3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {48806510-8E18-4E1E-9BAF-5B97E88C5FC3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {48806510-8E18-4E1E-9BAF-5B97E88C5FC3}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -196,6 +204,8 @@ Global {7E569FD9-B1AB-4848-8AB7-FD9EFA1DBA20} = {E902A945-4F41-4E96-A0DA-9F66CDA22261} {AD4EE9E6-F4A3-4139-AF05-71388167DE5B} = {E902A945-4F41-4E96-A0DA-9F66CDA22261} {6C86BA71-9F87-4E2C-B467-2950D77DCDFA} = {E902A945-4F41-4E96-A0DA-9F66CDA22261} + {73CCF2C4-B9FD-44AB-8D4B-0A421805B094} = {2317227D-7796-4E7B-BEDB-7CD1CAE7B853} + {48806510-8E18-4E1E-9BAF-5B97E88C5FC3} = {73CCF2C4-B9FD-44AB-8D4B-0A421805B094} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {23D6FBC9-C970-4641-BC1E-2AEA59F51C18} diff --git a/Yi.Abp.Net8/framework/Yi.Framework.SqlSugarCore/SqlSugarDbContext.cs b/Yi.Abp.Net8/framework/Yi.Framework.SqlSugarCore/SqlSugarDbContext.cs index 01a70e75..2e743506 100644 --- a/Yi.Abp.Net8/framework/Yi.Framework.SqlSugarCore/SqlSugarDbContext.cs +++ b/Yi.Abp.Net8/framework/Yi.Framework.SqlSugarCore/SqlSugarDbContext.cs @@ -76,12 +76,13 @@ namespace Yi.Framework.SqlSugarCore { EntityService = (c, p) => { - if (new NullabilityInfoContext() .Create(c).WriteState is NullabilityState.Nullable) { p.IsNullable = true; } + + EntityService(c,p); } } }, @@ -236,6 +237,16 @@ namespace Yi.Framework.SqlSugarCore { } + /// + /// 实体配置 + /// + /// + /// + protected virtual void EntityService(PropertyInfo property, EntityColumnInfo column) + { + + } + public void BackupDataBase() { string directoryName = "database_backup"; diff --git a/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/SqlSugarCoreAuditLogRepository.cs b/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/SqlSugarCoreAuditLogRepository.cs new file mode 100644 index 00000000..c15151f7 --- /dev/null +++ b/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/SqlSugarCoreAuditLogRepository.cs @@ -0,0 +1,266 @@ +//using System.Linq.Dynamic.Core; +//using System.Net; +//using Volo.Abp.Auditing; +//using Volo.Abp.Domain.Entities; +//using Yi.Framework.SqlSugarCore.Abstractions; +//using Yi.Framework.SqlSugarCore.Repositories; + +//namespace Volo.Abp.AuditLogging.EntityFrameworkCore; + +//public class SqlSugarCoreAuditLogRepository : SqlSugarRepository, IAuditLogRepository +//{ +// public SqlSugarCoreAuditLogRepository(ISugarDbContextProvider sugarDbContextProvider) : base(sugarDbContextProvider) +// { +// } + +// public virtual async Task> GetListAsync( +// string sorting = null, +// int maxResultCount = 50, +// int skipCount = 0, +// DateTime? startTime = null, +// DateTime? endTime = null, +// string httpMethod = null, +// string url = null, +// Guid? userId = null, +// string userName = null, +// string applicationName = null, +// string clientIpAddress = null, +// string correlationId = null, +// int? maxExecutionDuration = null, +// int? minExecutionDuration = null, +// bool? hasException = null, +// HttpStatusCode? httpStatusCode = null, +// bool includeDetails = false, +// CancellationToken cancellationToken = default) +// { +// var query = await GetListQueryAsync( +// startTime, +// endTime, +// httpMethod, +// url, +// userId, +// userName, +// applicationName, +// clientIpAddress, +// correlationId, +// maxExecutionDuration, +// minExecutionDuration, +// hasException, +// httpStatusCode, +// includeDetails +// ); + +// var auditLogs = await query +// .OrderBy(sorting.IsNullOrWhiteSpace() ? (nameof(AuditLog.ExecutionTime) + " DESC") : sorting) +// .PageBy(skipCount, maxResultCount) +// .ToListAsync(GetCancellationToken(cancellationToken)); + +// return auditLogs; +// } + +// public virtual async Task GetCountAsync( +// DateTime? startTime = null, +// DateTime? endTime = null, +// string httpMethod = null, +// string url = null, +// Guid? userId = null, +// string userName = null, +// string applicationName = null, +// string clientIpAddress = null, +// string correlationId = null, +// int? maxExecutionDuration = null, +// int? minExecutionDuration = null, +// bool? hasException = null, +// HttpStatusCode? httpStatusCode = null, +// CancellationToken cancellationToken = default) +// { +// var query = await GetListQueryAsync( +// startTime, +// endTime, +// httpMethod, +// url, +// userId, +// userName, +// applicationName, +// clientIpAddress, +// correlationId, +// maxExecutionDuration, +// minExecutionDuration, +// hasException, +// httpStatusCode +// ); + +// var totalCount = await query.LongCountAsync(GetCancellationToken(cancellationToken)); + +// return totalCount; +// } + +// protected virtual async Task> GetListQueryAsync( +// DateTime? startTime = null, +// DateTime? endTime = null, +// string httpMethod = null, +// string url = null, +// Guid? userId = null, +// string userName = null, +// string applicationName = null, +// string clientIpAddress = null, +// string correlationId = null, +// int? maxExecutionDuration = null, +// int? minExecutionDuration = null, +// bool? hasException = null, +// HttpStatusCode? httpStatusCode = null, +// bool includeDetails = false) +// { +// var nHttpStatusCode = (int?)httpStatusCode; +// return (await GetDbSetAsync()).AsNoTracking() +// .IncludeDetails(includeDetails) +// .WhereIf(startTime.HasValue, auditLog => auditLog.ExecutionTime >= startTime) +// .WhereIf(endTime.HasValue, auditLog => auditLog.ExecutionTime <= endTime) +// .WhereIf(hasException.HasValue && hasException.Value, auditLog => auditLog.Exceptions != null && auditLog.Exceptions != "") +// .WhereIf(hasException.HasValue && !hasException.Value, auditLog => auditLog.Exceptions == null || auditLog.Exceptions == "") +// .WhereIf(httpMethod != null, auditLog => auditLog.HttpMethod == httpMethod) +// .WhereIf(url != null, auditLog => auditLog.Url != null && auditLog.Url.Contains(url)) +// .WhereIf(userId != null, auditLog => auditLog.UserId == userId) +// .WhereIf(userName != null, auditLog => auditLog.UserName == userName) +// .WhereIf(applicationName != null, auditLog => auditLog.ApplicationName == applicationName) +// .WhereIf(clientIpAddress != null, auditLog => auditLog.ClientIpAddress != null && auditLog.ClientIpAddress == clientIpAddress) +// .WhereIf(correlationId != null, auditLog => auditLog.CorrelationId == correlationId) +// .WhereIf(httpStatusCode != null && httpStatusCode > 0, auditLog => auditLog.HttpStatusCode == nHttpStatusCode) +// .WhereIf(maxExecutionDuration != null && maxExecutionDuration.Value > 0, auditLog => auditLog.ExecutionDuration <= maxExecutionDuration) +// .WhereIf(minExecutionDuration != null && minExecutionDuration.Value > 0, auditLog => auditLog.ExecutionDuration >= minExecutionDuration); +// } + +// public virtual async Task> GetAverageExecutionDurationPerDayAsync( +// DateTime startDate, +// DateTime endDate, +// CancellationToken cancellationToken = default) +// { +// var result = await (await GetDbSetAsync()).AsNoTracking() +// .Where(a => a.ExecutionTime < endDate.AddDays(1) && a.ExecutionTime > startDate) +// .OrderBy(t => t.ExecutionTime) +// .GroupBy(t => new { t.ExecutionTime.Date }) +// .Select(g => new { Day = g.Min(t => t.ExecutionTime), avgExecutionTime = g.Average(t => t.ExecutionDuration) }) +// .ToListAsync(GetCancellationToken(cancellationToken)); + +// return result.ToDictionary(element => element.Day.ClearTime(), element => element.avgExecutionTime); +// } + +// [Obsolete("Use WithDetailsAsync method.")] +// public override IQueryable WithDetails() +// { +// return GetQueryable().IncludeDetails(); +// } + +// public override async Task> WithDetailsAsync() +// { +// return (await GetQueryableAsync()).IncludeDetails(); +// } + +// public virtual async Task GetEntityChange( +// Guid entityChangeId, +// CancellationToken cancellationToken = default) +// { +// var entityChange = await (await GetDbContextAsync()).Set() +// .AsNoTracking() +// .IncludeDetails() +// .Where(x => x.Id == entityChangeId) +// .OrderBy(x => x.Id) +// .FirstOrDefaultAsync(GetCancellationToken(cancellationToken)); + +// if (entityChange == null) +// { +// throw new EntityNotFoundException(typeof(EntityChange)); +// } + +// return entityChange; +// } + +// public virtual async Task> GetEntityChangeListAsync( +// string sorting = null, +// int maxResultCount = 50, +// int skipCount = 0, +// Guid? auditLogId = null, +// DateTime? startTime = null, +// DateTime? endTime = null, +// EntityChangeType? changeType = null, +// string entityId = null, +// string entityTypeFullName = null, +// bool includeDetails = false, +// CancellationToken cancellationToken = default) +// { +// var query = await GetEntityChangeListQueryAsync(auditLogId, startTime, endTime, changeType, entityId, entityTypeFullName, includeDetails); + +// return await query.OrderBy(sorting.IsNullOrWhiteSpace() ? (nameof(EntityChange.ChangeTime) + " DESC") : sorting) +// .PageBy(skipCount, maxResultCount) +// .ToListAsync(GetCancellationToken(cancellationToken)); +// } + +// public virtual async Task GetEntityChangeCountAsync( +// Guid? auditLogId = null, +// DateTime? startTime = null, +// DateTime? endTime = null, +// EntityChangeType? changeType = null, +// string entityId = null, +// string entityTypeFullName = null, +// CancellationToken cancellationToken = default) +// { +// var query = await GetEntityChangeListQueryAsync(auditLogId, startTime, endTime, changeType, entityId, entityTypeFullName); + +// var totalCount = await query.LongCountAsync(GetCancellationToken(cancellationToken)); + +// return totalCount; +// } + +// public virtual async Task GetEntityChangeWithUsernameAsync( +// Guid entityChangeId, +// CancellationToken cancellationToken = default) +// { +// var auditLog = await (await GetDbSetAsync()).AsNoTracking().IncludeDetails() +// .Where(x => x.EntityChanges.Any(y => y.Id == entityChangeId)).FirstAsync(GetCancellationToken(cancellationToken)); + +// return new EntityChangeWithUsername() +// { +// EntityChange = auditLog.EntityChanges.First(x => x.Id == entityChangeId), +// UserName = auditLog.UserName +// }; +// } + +// public virtual async Task> GetEntityChangesWithUsernameAsync( +// string entityId, +// string entityTypeFullName, +// CancellationToken cancellationToken = default) +// { +// var dbContext = await GetDbContextAsync(); + +// var query = dbContext.Set() +// .AsNoTracking() +// .IncludeDetails() +// .Where(x => x.EntityId == entityId && x.EntityTypeFullName == entityTypeFullName); + +// return await (from e in query +// join auditLog in dbContext.AuditLogs on e.AuditLogId equals auditLog.Id +// select new EntityChangeWithUsername { EntityChange = e, UserName = auditLog.UserName }) +// .OrderByDescending(x => x.EntityChange.ChangeTime).ToListAsync(GetCancellationToken(cancellationToken)); +// } + +// protected virtual async Task> GetEntityChangeListQueryAsync( +// Guid? auditLogId = null, +// DateTime? startTime = null, +// DateTime? endTime = null, +// EntityChangeType? changeType = null, +// string entityId = null, +// string entityTypeFullName = null, +// bool includeDetails = false) +// { +// return (await GetDbContextAsync()) +// .Set() +// .AsNoTracking() +// .IncludeDetails(includeDetails) +// .WhereIf(auditLogId.HasValue, e => e.AuditLogId == auditLogId) +// .WhereIf(startTime.HasValue, e => e.ChangeTime >= startTime) +// .WhereIf(endTime.HasValue, e => e.ChangeTime <= endTime) +// .WhereIf(changeType.HasValue, e => e.ChangeType == changeType) +// .WhereIf(!string.IsNullOrWhiteSpace(entityId), e => e.EntityId == entityId) +// .WhereIf(!string.IsNullOrWhiteSpace(entityTypeFullName), e => e.EntityTypeFullName.Contains(entityTypeFullName)); +// } +//} diff --git a/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/Yi.AuditLogging.SqlSugarCore.csproj b/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/Yi.AuditLogging.SqlSugarCore.csproj new file mode 100644 index 00000000..f16bc4cd --- /dev/null +++ b/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/Yi.AuditLogging.SqlSugarCore.csproj @@ -0,0 +1,17 @@ + + + + net8.0 + enable + enable + + + + + + + + + + + diff --git a/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/YiAuditLoggingDbContext.cs b/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/YiAuditLoggingDbContext.cs new file mode 100644 index 00000000..1726fe9c --- /dev/null +++ b/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/YiAuditLoggingDbContext.cs @@ -0,0 +1,134 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; +using SqlSugar; +using Volo.Abp.AuditLogging; +using Volo.Abp.DependencyInjection; +using Yi.Framework.SqlSugarCore; + +namespace Yi.AuditLogging.SqlSugarCore +{ + public class YiAuditLoggingDbContext : SqlSugarDbContext + { + public YiAuditLoggingDbContext(IAbpLazyServiceProvider lazyServiceProvider) : base(lazyServiceProvider) + { + } + + protected override void EntityService(PropertyInfo property, EntityColumnInfo column) + { + base.EntityService(property, column); + column.DbTableName = AbpAuditLoggingDbProperties.DbTablePrefix + "AuditLogs"; + + column.IfTable() + + .UpdateProperty(x => x.Id, + x => + { + x.IsPrimarykey = true; + }) + + .UpdateProperty(x => x.ApplicationName, + x => + { + x.Length = AuditLogConsts.MaxApplicationNameLength; + x.DbColumnName = nameof(AuditLog.ApplicationName); + }); + + + //builder.Entity(b => + //{ + // b.ToTable(AbpAuditLoggingDbProperties.DbTablePrefix + "AuditLogs", AbpAuditLoggingDbProperties.DbSchema); + + // b.ConfigureByConvention(); + + // b.Property(x => x.ApplicationName).HasMaxLength(AuditLogConsts.MaxApplicationNameLength).HasColumnName(nameof(AuditLog.ApplicationName)); + // b.Property(x => x.ClientIpAddress).HasMaxLength(AuditLogConsts.MaxClientIpAddressLength).HasColumnName(nameof(AuditLog.ClientIpAddress)); + // b.Property(x => x.ClientName).HasMaxLength(AuditLogConsts.MaxClientNameLength).HasColumnName(nameof(AuditLog.ClientName)); + // b.Property(x => x.ClientId).HasMaxLength(AuditLogConsts.MaxClientIdLength).HasColumnName(nameof(AuditLog.ClientId)); + // b.Property(x => x.CorrelationId).HasMaxLength(AuditLogConsts.MaxCorrelationIdLength).HasColumnName(nameof(AuditLog.CorrelationId)); + // b.Property(x => x.BrowserInfo).HasMaxLength(AuditLogConsts.MaxBrowserInfoLength).HasColumnName(nameof(AuditLog.BrowserInfo)); + // b.Property(x => x.HttpMethod).HasMaxLength(AuditLogConsts.MaxHttpMethodLength).HasColumnName(nameof(AuditLog.HttpMethod)); + // b.Property(x => x.Url).HasMaxLength(AuditLogConsts.MaxUrlLength).HasColumnName(nameof(AuditLog.Url)); + // b.Property(x => x.HttpStatusCode).HasColumnName(nameof(AuditLog.HttpStatusCode)); + + // b.Property(x => x.Comments).HasMaxLength(AuditLogConsts.MaxCommentsLength).HasColumnName(nameof(AuditLog.Comments)); + // b.Property(x => x.ExecutionDuration).HasColumnName(nameof(AuditLog.ExecutionDuration)); + // b.Property(x => x.ImpersonatorTenantId).HasColumnName(nameof(AuditLog.ImpersonatorTenantId)); + // b.Property(x => x.ImpersonatorUserId).HasColumnName(nameof(AuditLog.ImpersonatorUserId)); + // b.Property(x => x.ImpersonatorTenantName).HasMaxLength(AuditLogConsts.MaxTenantNameLength).HasColumnName(nameof(AuditLog.ImpersonatorTenantName)); + // b.Property(x => x.ImpersonatorUserName).HasMaxLength(AuditLogConsts.MaxUserNameLength).HasColumnName(nameof(AuditLog.ImpersonatorUserName)); + // b.Property(x => x.UserId).HasColumnName(nameof(AuditLog.UserId)); + // b.Property(x => x.UserName).HasMaxLength(AuditLogConsts.MaxUserNameLength).HasColumnName(nameof(AuditLog.UserName)); + // b.Property(x => x.TenantId).HasColumnName(nameof(AuditLog.TenantId)); + // b.Property(x => x.TenantName).HasMaxLength(AuditLogConsts.MaxTenantNameLength).HasColumnName(nameof(AuditLog.TenantName)); + + // b.HasMany(a => a.Actions).WithOne().HasForeignKey(x => x.AuditLogId).IsRequired(); + // b.HasMany(a => a.EntityChanges).WithOne().HasForeignKey(x => x.AuditLogId).IsRequired(); + + // b.HasIndex(x => new { x.TenantId, x.ExecutionTime }); + // b.HasIndex(x => new { x.TenantId, x.UserId, x.ExecutionTime }); + + // b.ApplyObjectExtensionMappings(); + //}); + + //builder.Entity(b => + //{ + // b.ToTable(AbpAuditLoggingDbProperties.DbTablePrefix + "AuditLogActions", AbpAuditLoggingDbProperties.DbSchema); + + // b.ConfigureByConvention(); + + // b.Property(x => x.AuditLogId).HasColumnName(nameof(AuditLogAction.AuditLogId)); + // b.Property(x => x.ServiceName).HasMaxLength(AuditLogActionConsts.MaxServiceNameLength).HasColumnName(nameof(AuditLogAction.ServiceName)); + // b.Property(x => x.MethodName).HasMaxLength(AuditLogActionConsts.MaxMethodNameLength).HasColumnName(nameof(AuditLogAction.MethodName)); + // b.Property(x => x.Parameters).HasMaxLength(AuditLogActionConsts.MaxParametersLength).HasColumnName(nameof(AuditLogAction.Parameters)); + // b.Property(x => x.ExecutionTime).HasColumnName(nameof(AuditLogAction.ExecutionTime)); + // b.Property(x => x.ExecutionDuration).HasColumnName(nameof(AuditLogAction.ExecutionDuration)); + + // b.HasIndex(x => new { x.AuditLogId }); + // b.HasIndex(x => new { x.TenantId, x.ServiceName, x.MethodName, x.ExecutionTime }); + + // b.ApplyObjectExtensionMappings(); + //}); + + //builder.Entity(b => + //{ + // b.ToTable(AbpAuditLoggingDbProperties.DbTablePrefix + "EntityChanges", AbpAuditLoggingDbProperties.DbSchema); + + // b.ConfigureByConvention(); + + // b.Property(x => x.EntityTypeFullName).HasMaxLength(EntityChangeConsts.MaxEntityTypeFullNameLength).IsRequired().HasColumnName(nameof(EntityChange.EntityTypeFullName)); + // b.Property(x => x.EntityId).HasMaxLength(EntityChangeConsts.MaxEntityIdLength).IsRequired().HasColumnName(nameof(EntityChange.EntityId)); + // b.Property(x => x.AuditLogId).IsRequired().HasColumnName(nameof(EntityChange.AuditLogId)); + // b.Property(x => x.ChangeTime).IsRequired().HasColumnName(nameof(EntityChange.ChangeTime)); + // b.Property(x => x.ChangeType).IsRequired().HasColumnName(nameof(EntityChange.ChangeType)); + // b.Property(x => x.TenantId).HasColumnName(nameof(EntityChange.TenantId)); + + // b.HasMany(a => a.PropertyChanges).WithOne().HasForeignKey(x => x.EntityChangeId); + + // b.HasIndex(x => new { x.AuditLogId }); + // b.HasIndex(x => new { x.TenantId, x.EntityTypeFullName, x.EntityId }); + + // b.ApplyObjectExtensionMappings(); + //}); + + //builder.Entity(b => + //{ + // b.ToTable(AbpAuditLoggingDbProperties.DbTablePrefix + "EntityPropertyChanges", AbpAuditLoggingDbProperties.DbSchema); + + // b.ConfigureByConvention(); + + // b.Property(x => x.NewValue).HasMaxLength(EntityPropertyChangeConsts.MaxNewValueLength).HasColumnName(nameof(EntityPropertyChange.NewValue)); + // b.Property(x => x.PropertyName).HasMaxLength(EntityPropertyChangeConsts.MaxPropertyNameLength).IsRequired().HasColumnName(nameof(EntityPropertyChange.PropertyName)); + // b.Property(x => x.PropertyTypeFullName).HasMaxLength(EntityPropertyChangeConsts.MaxPropertyTypeFullNameLength).IsRequired().HasColumnName(nameof(EntityPropertyChange.PropertyTypeFullName)); + // b.Property(x => x.OriginalValue).HasMaxLength(EntityPropertyChangeConsts.MaxOriginalValueLength).HasColumnName(nameof(EntityPropertyChange.OriginalValue)); + + // b.HasIndex(x => new { x.EntityChangeId }); + + // b.ApplyObjectExtensionMappings(); + //}); + } + } +} diff --git a/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/YiAuditLoggingSqlSugarCoreModule.cs b/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/YiAuditLoggingSqlSugarCoreModule.cs new file mode 100644 index 00000000..2c0b2126 --- /dev/null +++ b/Yi.Abp.Net8/module/audit-logging/Yi.AuditLogging.SqlSugarCore/YiAuditLoggingSqlSugarCoreModule.cs @@ -0,0 +1,16 @@ +using Volo.Abp.AuditLogging; +using Volo.Abp.Modularity; +using Yi.Framework.SqlSugarCore; + +namespace Yi.AuditLogging.SqlSugarCore +{ + [DependsOn(typeof(AbpAuditLoggingDomainModule))] + [DependsOn(typeof(YiFrameworkSqlSugarCoreModule))] + public class YiAuditLoggingSqlSugarCoreModule:AbpModule + { + public override void ConfigureServices(ServiceConfigurationContext context) + { + context.Services.AddYiDbContext(); + } + } +}