ewide/number_zj
22
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

宁波既有建筑外墙脱落问卷调查

Browse Source
This commit is contained in:
范露尧
2023-06-28 23:07:04 +08:00
parent 22d312934d
commit 352c658960
62 changed files with 3721 additions and 611 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
20220330_Vote/Ewide.Core/Cache/CacheOptions.cs
View File

@@ -1,33 +0,0 @@
using Furion.ConfigurableOptions;
namespace Ewide.Core
{
/// <summary>
/// 缓存配置
/// </summary>
public class CacheOptions : IConfigurableOptions
{
/// <summary>
/// 缓存类型
/// </summary>
public CacheType CacheType { get; set; }
/// <summary>
/// Redis配置
/// </summary>
public string RedisConnectionString { get; set; }
}
public enum CacheType
{
/// <summary>
/// 内存缓存
/// </summary>
MemoryCache,
/// <summary>
/// Redis缓存
/// </summary>
RedisCache
}
}

6
20220330_Vote/Ewide.Core/Cache/ICache.cs
View File

@@ -1,4 +1,5 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Ewide.Core
@@ -103,5 +104,10 @@ namespace Ewide.Core
/// <param name="expire">有效期</param>
/// <returns></returns>
Task<bool> SetAsync(string key, object value, TimeSpan expire);
/// <summary>
/// 获取所有缓存
/// </summary>
/// <returns></returns>
List<string> GetAllKeys();
}
}

3
20220330_Vote/Ewide.Core/Cache/MemoryCache.cs
View File

@@ -107,7 +107,7 @@ namespace Ewide.Core
return Task.FromResult(true);
}
private List<string> GetAllKeys()
public List<string> GetAllKeys()
{
const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
var entries = _memoryCache.GetType().GetField("_entries", flags).GetValue(_memoryCache);
@@ -121,5 +121,6 @@ namespace Ewide.Core
//}
//return keys;
}
}
}

6
20220330_Vote/Ewide.Core/Cache/RedisCache.cs
View File

@@ -1,6 +1,7 @@
using Furion.DependencyInjection;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
@@ -62,6 +63,11 @@ namespace Ewide.Core
return RedisHelper.Get<T>(key);
}
public List<string> GetAllKeys()
{
throw new NotImplementedException();
}
public Task<string> GetAsync(string key)
{
return RedisHelper.GetAsync(key);

63
20220330_Vote/Ewide.Core/Cache/SqlSugarCache.cs Normal file
View File

@@ -0,0 +1,63 @@
using Furion;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Ewide.Core.Cache
{
public class SqlSugarCache : ICacheService
{
private static ICache _cache = App.GetOptions<CacheOptions>().CacheType == CacheType.MemoryCache ? App.RootServices.GetService(typeof(MemoryCache)) as ICache : App.RootServices.GetService(typeof(RedisCache)) as ICache;
public void Add<TV>(string key, TV value)
{
_cache.Set(key, value);
}
public void Add<TV>(string key, TV value, int cacheDurationInSeconds)
{
_cache.Set(key, value, TimeSpan.FromSeconds(cacheDurationInSeconds));
}
public bool ContainsKey<TV>(string key)
{
return _cache.Exists(key);
}
public TV Get<TV>(string key)
{
return _cache.Get<TV>(key);
}
public IEnumerable<string> GetAllKey<TV>()
{
return _cache.GetAllKeys();
}
public TV GetOrCreate<TV>(string cacheKey, Func<TV> create, int cacheDurationInSeconds = int.MaxValue)
{
if (this.ContainsKey<TV>(cacheKey))
{
return this.Get<TV>(cacheKey);
}
else
{
var result = create();
this.Add(cacheKey, result, cacheDurationInSeconds);
return result;
}
}
public void Remove<TV>(string key)
{
_cache.Del(key);
}
}
}

235
20220330_Vote/Ewide.Core/ConfigOption/ConfigOptions.cs Normal file
View File

@@ -0,0 +1,235 @@
using Furion.ConfigurableOptions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Ewide.Core
{
/// <summary>
/// 缓存配置
/// </summary>
public class CacheOptions : IConfigurableOptions
{
/// <summary>
/// 缓存类型
/// </summary>
public CacheType CacheType { get; set; }
/// <summary>
/// Redis配置
/// </summary>
public string RedisConnectionString { get; set; }
}
public enum CacheType
{
/// <summary>
/// 内存缓存
/// </summary>
MemoryCache,
/// <summary>
/// Redis缓存
/// </summary>
RedisCache
}
/// <summary>
/// 系统配置
/// </summary>
public class SystemSettingsOptions : IConfigurableOptions
{
/// <summary>
/// 超管是否可以查看所有租户的数据
/// </summary>
public bool SuperAdminViewAllData { get; set; }
/// <summary>
/// 是否开启全局请求日志
/// </summary>
public bool IsGlobalRequestLog { get; set; }
}
/// <summary>
/// 雪花Id配置
/// </summary>
public class SnowIdOptions : IConfigurableOptions
{
/// <summary>
/// 取值范围0~63,默认1
/// </summary>
public string WorkerId { get; set; } = "1";
}
/// <summary>
/// 第三方配置
/// </summary>
public class OAuthOptions : IConfigurableOptions
{
/// <summary>
///微信
/// </summary>
public ThirdParty Wechat { get; set; }
}
/// <summary>
/// 上传文件
/// </summary>
public class UploadFileOptions : IConfigurableOptions
{
/// <summary>
/// 阿里云
/// </summary>
public FileDescription Aliyun { get; set; }
/// <summary>
/// 头像
/// </summary>
public FileDescription Avatar { get; set; }
/// <summary>
/// 文档
/// </summary>
public FileDescription Document { get; set; }
/// <summary>
/// 商店
/// </summary>
public FileDescription Shop { get; set; }
/// <summary>
/// 编辑器
/// </summary>
public FileDescription Editor { get; set; }
/// <summary>
/// 默认
/// </summary>
public FileDescription Default { get; set; }
}
/// <summary>
/// 数据库配置
/// </summary>
public class ConnectionStringsOptions : IConfigurableOptions
{
/// <summary>
/// 默认数据库编号
/// </summary>
public string DefaultDbNumber { get; set; }
/// <summary>
/// 默认数据库类型
/// </summary>
public string DefaultDbType { get; set; }
/// <summary>
/// 默认数据库连接字符串
/// </summary>
public string DefaultDbString { get; set; }
/// <summary>
/// 业务库集合
/// </summary>
public List<DbConfig> DbConfigs { get; set; }
}
/// <summary>
/// JWT配置
/// </summary>
public class JWTSettingsOptions : IConfigurableOptions
{
/// <summary>
/// 是否验证密钥
/// </summary>
public bool ValidateIssuerSigningKey { get; set; }
/// <summary>
/// 密钥
/// </summary>
public string IssuerSigningKey { get; set; }
/// <summary>
/// 是否验证签发方
/// </summary>
public bool ValidateIssuer { get; set; }
/// <summary>
/// 签发方
/// </summary>
public string ValidIssuer { get; set; }
/// <summary>
/// 是否验证签收方
/// </summary>
public bool ValidateAudience { get; set; }
/// <summary>
/// 签收方
/// </summary>
public string ValidAudience { get; set; }
/// <summary>
/// 是否验证过期时间
/// </summary>
public bool ValidateLifetime { get; set; }
/// <summary>
/// 过期时间
/// </summary>
public long ExpiredTime { get; set; }
/// <summary>
/// 过期时间容错值
/// </summary>
public long ClockSkew { get; set; }
}
/// <summary>
/// 数据库参数
/// </summary>
public class DbConfig
{
/// <summary>
/// 数据库编号
/// </summary>
public string DbNumber { get; set; }
/// <summary>
/// 数据库类型
/// </summary>
public string DbType { get; set; }
/// <summary>
/// 数据库连接字符串
/// </summary>
public string DbString { get; set; }
}
/// <summary>
/// 文件参数
/// </summary>
public class FileDescription
{
/// <summary>
/// 路径
/// </summary>
public string path { get; set; }
/// <summary>
/// 大小
/// </summary>
public long maxSize { get; set; }
/// <summary>
/// 类型
/// </summary>
public string[] contentType { get; set; }
}
/// <summary>
/// 第三方参数
/// </summary>
public class ThirdParty
{
/// <summary>
/// id
/// </summary>
public string app_id { get; set; }
/// <summary>
/// key
/// </summary>
public string app_key { get; set; }
/// <summary>
/// 回调地址
/// </summary>
public string redirect_uri { get; set; }
/// <summary>
/// scope
/// </summary>
public string scope { get; set; }
}
public class FileOption
{
public string Path { get; set; }
public int MaxSize { get; set; }
public string[] ContentType { get; set; }
}
}

744
20220330_Vote/Ewide.Core/Ewide.Core.xml
View File

@@ -4,31 +4,6 @@
<name>Ewide.Core</name>
</assembly>
<members>
<member name="T:Ewide.Core.CacheOptions">
<summary>
缓存配置
</summary>
</member>
<member name="P:Ewide.Core.CacheOptions.CacheType">
<summary>
缓存类型
</summary>
</member>
<member name="P:Ewide.Core.CacheOptions.RedisConnectionString">
<summary>
Redis配置
</summary>
</member>
<member name="F:Ewide.Core.CacheType.MemoryCache">
<summary>
内存缓存
</summary>
</member>
<member name="F:Ewide.Core.CacheType.RedisCache">
<summary>
Redis缓存
</summary>
</member>
<member name="T:Ewide.Core.ICache">
<summary>
缓存接口
@@ -130,6 +105,12 @@
<param name="expire">有效期</param>
<returns></returns>
</member>
<member name="M:Ewide.Core.ICache.GetAllKeys">
<summary>
获取所有缓存
</summary>
<returns></returns>
</member>
<member name="T:Ewide.Core.MemoryCache">
<summary>
内存缓存
@@ -253,6 +234,241 @@
Token
</summary>
</member>
<member name="T:Ewide.Core.CacheOptions">
<summary>
缓存配置
</summary>
</member>
<member name="P:Ewide.Core.CacheOptions.CacheType">
<summary>
缓存类型
</summary>
</member>
<member name="P:Ewide.Core.CacheOptions.RedisConnectionString">
<summary>
Redis配置
</summary>
</member>
<member name="F:Ewide.Core.CacheType.MemoryCache">
<summary>
内存缓存
</summary>
</member>
<member name="F:Ewide.Core.CacheType.RedisCache">
<summary>
Redis缓存
</summary>
</member>
<member name="T:Ewide.Core.SystemSettingsOptions">
<summary>
系统配置
</summary>
</member>
<member name="P:Ewide.Core.SystemSettingsOptions.SuperAdminViewAllData">
<summary>
超管是否可以查看所有租户的数据
</summary>
</member>
<member name="P:Ewide.Core.SystemSettingsOptions.IsGlobalRequestLog">
<summary>
是否开启全局请求日志
</summary>
</member>
<member name="T:Ewide.Core.SnowIdOptions">
<summary>
雪花Id配置
</summary>
</member>
<member name="P:Ewide.Core.SnowIdOptions.WorkerId">
<summary>
取值范围0~63,默认1
</summary>
</member>
<member name="T:Ewide.Core.OAuthOptions">
<summary>
第三方配置
</summary>
</member>
<member name="P:Ewide.Core.OAuthOptions.Wechat">
<summary>
微信
</summary>
</member>
<member name="T:Ewide.Core.UploadFileOptions">
<summary>
上传文件
</summary>
</member>
<member name="P:Ewide.Core.UploadFileOptions.Aliyun">
<summary>
阿里云
</summary>
</member>
<member name="P:Ewide.Core.UploadFileOptions.Avatar">
<summary>
头像
</summary>
</member>
<member name="P:Ewide.Core.UploadFileOptions.Document">
<summary>
文档
</summary>
</member>
<member name="P:Ewide.Core.UploadFileOptions.Shop">
<summary>
商店
</summary>
</member>
<member name="P:Ewide.Core.UploadFileOptions.Editor">
<summary>
编辑器
</summary>
</member>
<member name="P:Ewide.Core.UploadFileOptions.Default">
<summary>
默认
</summary>
</member>
<member name="T:Ewide.Core.ConnectionStringsOptions">
<summary>
数据库配置
</summary>
</member>
<member name="P:Ewide.Core.ConnectionStringsOptions.DefaultDbNumber">
<summary>
默认数据库编号
</summary>
</member>
<member name="P:Ewide.Core.ConnectionStringsOptions.DefaultDbType">
<summary>
默认数据库类型
</summary>
</member>
<member name="P:Ewide.Core.ConnectionStringsOptions.DefaultDbString">
<summary>
默认数据库连接字符串
</summary>
</member>
<member name="P:Ewide.Core.ConnectionStringsOptions.DbConfigs">
<summary>
业务库集合
</summary>
</member>
<member name="T:Ewide.Core.JWTSettingsOptions">
<summary>
JWT配置
</summary>
</member>
<member name="P:Ewide.Core.JWTSettingsOptions.ValidateIssuerSigningKey">
<summary>
是否验证密钥
</summary>
</member>
<member name="P:Ewide.Core.JWTSettingsOptions.IssuerSigningKey">
<summary>
密钥
</summary>
</member>
<member name="P:Ewide.Core.JWTSettingsOptions.ValidateIssuer">
<summary>
是否验证签发方
</summary>
</member>
<member name="P:Ewide.Core.JWTSettingsOptions.ValidIssuer">
<summary>
签发方
</summary>
</member>
<member name="P:Ewide.Core.JWTSettingsOptions.ValidateAudience">
<summary>
是否验证签收方
</summary>
</member>
<member name="P:Ewide.Core.JWTSettingsOptions.ValidAudience">
<summary>
签收方
</summary>
</member>
<member name="P:Ewide.Core.JWTSettingsOptions.ValidateLifetime">
<summary>
是否验证过期时间
</summary>
</member>
<member name="P:Ewide.Core.JWTSettingsOptions.ExpiredTime">
<summary>
过期时间
</summary>
</member>
<member name="P:Ewide.Core.JWTSettingsOptions.ClockSkew">
<summary>
过期时间容错值
</summary>
</member>
<member name="T:Ewide.Core.DbConfig">
<summary>
数据库参数
</summary>
</member>
<member name="P:Ewide.Core.DbConfig.DbNumber">
<summary>
数据库编号
</summary>
</member>
<member name="P:Ewide.Core.DbConfig.DbType">
<summary>
数据库类型
</summary>
</member>
<member name="P:Ewide.Core.DbConfig.DbString">
<summary>
数据库连接字符串
</summary>
</member>
<member name="T:Ewide.Core.FileDescription">
<summary>
文件参数
</summary>
</member>
<member name="P:Ewide.Core.FileDescription.path">
<summary>
路径
</summary>
</member>
<member name="P:Ewide.Core.FileDescription.maxSize">
<summary>
大小
</summary>
</member>
<member name="P:Ewide.Core.FileDescription.contentType">
<summary>
类型
</summary>
</member>
<member name="T:Ewide.Core.ThirdParty">
<summary>
第三方参数
</summary>
</member>
<member name="P:Ewide.Core.ThirdParty.app_id">
<summary>
id
</summary>
</member>
<member name="P:Ewide.Core.ThirdParty.app_key">
<summary>
key
</summary>
</member>
<member name="P:Ewide.Core.ThirdParty.redirect_uri">
<summary>
回调地址
</summary>
</member>
<member name="P:Ewide.Core.ThirdParty.scope">
<summary>
scope
</summary>
</member>
<member name="F:Ewide.Core.ClaimConst.CLAINM_USERID">
<summary>
用户Id
@@ -4695,6 +4911,20 @@
<param name="file"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.Service.SysFileService.UploadFilesDefault(System.Collections.Generic.List{Microsoft.AspNetCore.Http.IFormFile})">
<summary>
上传文件
</summary>
<param name="files"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.Service.SysFileService.UploadFileDefault(Microsoft.AspNetCore.Http.FormFileCollection)">
<summary>
批量上传文件
</summary>
<param name="files"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.Service.SysFileService.DownloadFileInfo(Ewide.Core.Service.QueryFileInoInput)">
<summary>
下载文件
@@ -6810,6 +7040,470 @@
<param name="input"></param>
<returns></returns>
</member>
<member name="T:Ewide.Core.SqlSugarRepository`1">
<summary>
SqlSugar 仓储实现类
</summary>
<typeparam name="TEntity"></typeparam>
</member>
<member name="F:Ewide.Core.SqlSugarRepository`1._db">
<summary>
初始化 SqlSugar 客户端
</summary>
</member>
<member name="P:Ewide.Core.SqlSugarRepository`1.Context">
<summary>
数据库上下文
</summary>
</member>
<member name="P:Ewide.Core.SqlSugarRepository`1.EntityContext">
<summary>
独立数据库上下文
</summary>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.#ctor(SqlSugar.ISqlSugarClient)">
<summary>
构造函数
</summary>
<param name="db"></param>
</member>
<member name="P:Ewide.Core.SqlSugarRepository`1.Entities">
<summary>
实体集合
</summary>
</member>
<member name="P:Ewide.Core.SqlSugarRepository`1.Ado">
<summary>
原生 Ado 对象
</summary>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Count(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
获取总数
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.CountAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
获取总数
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Any(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
检查是否存在
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.AnyAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
检查是否存在
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Single(System.Object)">
<summary>
通过主键获取实体
</summary>
<param name="Id"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Single(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
获取一个实体
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.SingleAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
获取一个实体
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.FirstOrDefault(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
获取一个实体
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.FirstOrDefaultAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
获取一个实体
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.ToList">
<summary>
获取列表
</summary>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.ToList(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
获取列表
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.ToList(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{`0,System.Object}},SqlSugar.OrderByType)">
<summary>
获取列表
</summary>
<param name="whereExpression"></param>
<param name="orderByExpression"></param>
<param name="orderByType"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.ToListAsync">
<summary>
获取列表
</summary>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.ToListAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
获取列表
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.ToListAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{`0,System.Object}},SqlSugar.OrderByType)">
<summary>
获取列表
</summary>
<param name="whereExpression"></param>
<param name="orderByExpression"></param>
<param name="orderByType"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Insert(`0)">
<summary>
新增一条记录
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Insert(`0[])">
<summary>
新增多条记录
</summary>
<param name="entities"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Insert(System.Collections.Generic.IEnumerable{`0})">
<summary>
新增多条记录
</summary>
<param name="entities"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.InsertReturnIdentity(`0)">
<summary>
新增一条记录返回自增Id
</summary>
<param name="insertObj"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.InsertReturnSnowflakeId(`0)">
<summary>
新增一条记录返回雪花Id
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.InsertReturnEntity(`0)">
<summary>
新增一条记录返回实体
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.InsertAsync(`0)">
<summary>
新增一条记录
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.InsertAsync(`0[])">
<summary>
新增多条记录
</summary>
<param name="entities"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.InsertAsync(System.Collections.Generic.IEnumerable{`0})">
<summary>
新增多条记录
</summary>
<param name="entities"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.InsertReturnIdentityAsync(`0)">
<summary>
新增一条记录返回自增Id
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.InsertReturnSnowflakeIdAsync(`0)">
<summary>
新增一条记录返回雪花Id
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.InsertReturnEntityAsync(`0)">
<summary>
新增一条记录返回实体
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Update(`0)">
<summary>
更新一条记录
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Update(`0[])">
<summary>
更新多条记录
</summary>
<param name="entities"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Update(System.Collections.Generic.IEnumerable{`0})">
<summary>
更新多条记录
</summary>
<param name="entities"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.UpdateIgnoreNullAsync(`0)">
<summary>
更新一条记录忽略所有Null值
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.UpdateAsync(`0)">
<summary>
更新一条记录
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Update(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{`0,`0}})">
<summary>
更新记录
</summary>
<param name="predicate">更新的条件</param>
<param name="content">更新的内容</param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.UpdateAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.Linq.Expressions.Expression{System.Func{`0,`0}})">
<summary>
更新记录
</summary>
<param name="predicate">更新的条件</param>
<param name="content">更新的内容</param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.UpdateAsync(`0[])">
<summary>
更新多条记录
</summary>
<param name="entities"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.UpdateAsync(System.Collections.Generic.IEnumerable{`0})">
<summary>
更新多条记录
</summary>
<param name="entities"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Delete(`0)">
<summary>
删除一条记录
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Delete(System.Object)">
<summary>
删除一条记录
</summary>
<param name="key"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Delete(System.Object[])">
<summary>
删除多条记录
</summary>
<param name="keys"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Delete(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
自定义条件删除记录
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.DeleteAsync(`0)">
<summary>
删除一条记录
</summary>
<param name="entity"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.DeleteAsync(System.Object)">
<summary>
删除一条记录
</summary>
<param name="key"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.DeleteAsync(System.Object[])">
<summary>
删除多条记录
</summary>
<param name="keys"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.DeleteAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
自定义条件删除记录
</summary>
<param name="whereExpression"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Where(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
根据表达式查询多条记录
</summary>
<param name="predicate"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Where(System.Boolean,System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
根据表达式查询多条记录
</summary>
<param name="condition"></param>
<param name="predicate"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.AsQueryable">
<summary>
构建查询分析器
</summary>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.AsQueryable(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
构建查询分析器
</summary>
<param name="predicate"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.AsEnumerable">
<summary>
直接返回数据库结果
</summary>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.AsEnumerable(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
直接返回数据库结果
</summary>
<param name="predicate"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.AsAsyncEnumerable">
<summary>
直接返回数据库结果
</summary>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.AsAsyncEnumerable(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
直接返回数据库结果
</summary>
<param name="predicate"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.Change``1">
<summary>
切换仓储(注意使用环境)
</summary>
<typeparam name="T">实体类型</typeparam>
<returns>仓储</returns>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.CurrentBeginTran">
<summary>
当前db
</summary>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.CurrentCommitTran">
<summary>
当前db
</summary>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.CurrentRollbackTran">
<summary>
当前db
</summary>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.BeginTran">
<summary>
所有db
</summary>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.CommitTran">
<summary>
所有db
</summary>
</member>
<member name="M:Ewide.Core.SqlSugarRepository`1.RollbackTran">
<summary>
所有db
</summary>
</member>
<member name="M:Ewide.Core.SqlsugarSetup.IsSuperAdmin">
<summary>
判断是不是超级管理员
</summary>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlsugarSetup.AddSqlSugar(Microsoft.Extensions.DependencyInjection.IServiceCollection,SqlSugar.ConnectionConfig,System.Action{SqlSugar.ISqlSugarClient})">
<summary>
添加 SqlSugar 拓展
</summary>
<param name="services"></param>
<param name="config"></param>
<param name="buildAction"></param>
<returns></returns>
</member>
<member name="M:Ewide.Core.SqlsugarSetup.AddSqlSugar(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Collections.Generic.List{SqlSugar.ConnectionConfig},System.Action{SqlSugar.ISqlSugarClient})">
<summary>
添加 SqlSugar 拓展
</summary>
<param name="services"></param>
<param name="configs"></param>
<param name="buildAction"></param>
<returns></returns>
</member>
<member name="F:Ewide.Core.Util.CodeHelper.code_Countdown">
<summary>
发送验证码间隔时间(秒)

678
20220330_Vote/Ewide.Core/SqlSugar/SqlSugarRepository.cs Normal file
View File

@@ -0,0 +1,678 @@
using Furion;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace Ewide.Core
{
/// <summary>
/// SqlSugar 仓储实现类
/// </summary>
/// <typeparam name="TEntity"></typeparam>
public partial class SqlSugarRepository<TEntity>
where TEntity : class, new()
{
private readonly string[] UpdateIgnoreColumns = new string[] { "CreatedTime", "CreatedUserId", "CreatedUserName" };
#region 属性
/// <summary>
/// 初始化 SqlSugar 客户端
/// </summary>
private readonly SqlSugarScope _db;
/// <summary>
/// 数据库上下文
/// </summary>
public virtual SqlSugarScope Context { get; }
/// <summary>
/// 独立数据库上下文
/// </summary>
public virtual SqlSugarProvider EntityContext { get; }
/// <summary>
/// 构造函数
/// </summary>
/// <param name="db"></param>
public SqlSugarRepository(ISqlSugarClient db)
{
Context = _db = (SqlSugarScope)db;
EntityContext = _db.GetConnectionWithAttr<TEntity>();
Ado = EntityContext.Ado;
}
/// <summary>
/// 实体集合
/// </summary>
public virtual ISugarQueryable<TEntity> Entities => EntityContext.Queryable<TEntity>();
/// <summary>
/// 原生 Ado 对象
/// </summary>
public virtual IAdo Ado { get; }
#endregion
#region 查询
/// <summary>
/// 获取总数
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public int Count(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.Count(whereExpression);
}
/// <summary>
/// 获取总数
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public Task<int> CountAsync(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.CountAsync(whereExpression);
}
/// <summary>
/// 检查是否存在
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public bool Any(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.Any(whereExpression);
}
/// <summary>
/// 检查是否存在
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public async Task<bool> AnyAsync(Expression<Func<TEntity, bool>> whereExpression)
{
return await Entities.AnyAsync(whereExpression);
}
/// <summary>
/// 通过主键获取实体
/// </summary>
/// <param name="Id"></param>
/// <returns></returns>
public TEntity Single(dynamic Id)
{
return Entities.InSingle(Id);
}
/// <summary>
/// 获取一个实体
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public TEntity Single(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.Single(whereExpression);
}
/// <summary>
/// 获取一个实体
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public Task<TEntity> SingleAsync(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.SingleAsync(whereExpression);
}
/// <summary>
/// 获取一个实体
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public TEntity FirstOrDefault(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.First(whereExpression);
}
/// <summary>
/// 获取一个实体
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public async Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> whereExpression)
{
return await Entities.FirstAsync(whereExpression);
}
/// <summary>
/// 获取列表
/// </summary>
/// <returns></returns>
public List<TEntity> ToList()
{
return Entities.ToList();
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public List<TEntity> ToList(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.Where(whereExpression).ToList();
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="whereExpression"></param>
/// <param name="orderByExpression"></param>
/// <param name="orderByType"></param>
/// <returns></returns>
public List<TEntity> ToList(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression = null, OrderByType orderByType = OrderByType.Asc)
{
return Entities.OrderByIF(orderByExpression != null, orderByExpression, orderByType).Where(whereExpression).ToList();
}
/// <summary>
/// 获取列表
/// </summary>
/// <returns></returns>
public Task<List<TEntity>> ToListAsync()
{
return Entities.ToListAsync();
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public Task<List<TEntity>> ToListAsync(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.Where(whereExpression).ToListAsync();
}
/// <summary>
/// 获取列表
/// </summary>
/// <param name="whereExpression"></param>
/// <param name="orderByExpression"></param>
/// <param name="orderByType"></param>
/// <returns></returns>
public Task<List<TEntity>> ToListAsync(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression = null, OrderByType orderByType = OrderByType.Asc)
{
return Entities.OrderByIF(orderByExpression != null, orderByExpression, orderByType).Where(whereExpression).ToListAsync();
}
#endregion
#region 新增
public virtual IInsertable<TEntity> AsInsertable(TEntity entity)
{
return EntityContext.Insertable(entity);
}
public virtual IInsertable<TEntity> AsInsertable(params TEntity[] entities)
{
return EntityContext.Insertable(entities);
}
/// <summary>
/// 新增一条记录
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual int Insert(TEntity entity)
{
return EntityContext.Insertable(entity).ExecuteCommand();
}
/// <summary>
/// 新增多条记录
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public virtual int Insert(params TEntity[] entities)
{
return EntityContext.Insertable(entities).ExecuteCommand();
}
/// <summary>
/// 新增多条记录
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public virtual int Insert(IEnumerable<TEntity> entities)
{
return EntityContext.Insertable(entities.ToArray()).ExecuteCommand();
}
/// <summary>
/// 新增一条记录返回自增Id
/// </summary>
/// <param name="insertObj"></param>
/// <returns></returns>
public virtual int InsertReturnIdentity(TEntity insertObj)
{
return EntityContext.Insertable(insertObj).ExecuteReturnIdentity();
}
/// <summary>
/// 新增一条记录返回雪花Id
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual long InsertReturnSnowflakeId(TEntity entity)
{
return EntityContext.Insertable(entity).ExecuteReturnSnowflakeId();
}
/// <summary>
/// 新增一条记录返回实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual TEntity InsertReturnEntity(TEntity entity)
{
return EntityContext.Insertable(entity).ExecuteReturnEntity();
}
/// <summary>
/// 新增一条记录
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual Task<int> InsertAsync(TEntity entity)
{
return EntityContext.Insertable(entity).ExecuteCommandAsync();
}
/// <summary>
/// 新增多条记录
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public virtual Task<int> InsertAsync(params TEntity[] entities)
{
return EntityContext.Insertable(entities).ExecuteCommandAsync();
}
/// <summary>
/// 新增多条记录
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public virtual Task<int> InsertAsync(IEnumerable<TEntity> entities)
{
if (entities != null && entities.Any())
{
return EntityContext.Insertable(entities.ToArray()).ExecuteCommandAsync();
}
return Task.FromResult(0);
}
/// <summary>
/// 新增一条记录返回自增Id
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual async Task<long> InsertReturnIdentityAsync(TEntity entity)
{
return await EntityContext.Insertable(entity).ExecuteReturnBigIdentityAsync();
}
/// <summary>
/// 新增一条记录返回雪花Id
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual async Task<long> InsertReturnSnowflakeIdAsync(TEntity entity)
{
return await EntityContext.Insertable(entity).ExecuteReturnSnowflakeIdAsync();
}
/// <summary>
/// 新增一条记录返回实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual async Task<TEntity> InsertReturnEntityAsync(TEntity entity)
{
return await EntityContext.Insertable(entity).ExecuteReturnEntityAsync();
}
#endregion
#region 更新
/// <summary>
/// 更新一条记录
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual int Update(TEntity entity)
{
return EntityContext.Updateable(entity).IgnoreColumns(UpdateIgnoreColumns).ExecuteCommand();
}
/// <summary>
/// 更新多条记录
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public virtual int Update(params TEntity[] entities)
{
return EntityContext.Updateable(entities).IgnoreColumns(UpdateIgnoreColumns).ExecuteCommand();
}
/// <summary>
/// 更新多条记录
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public virtual int Update(IEnumerable<TEntity> entities)
{
return EntityContext.Updateable(entities.ToArray()).IgnoreColumns(UpdateIgnoreColumns).ExecuteCommand();
}
/// <summary>
/// 更新一条记录忽略所有Null值
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual async Task<int> UpdateIgnoreNullAsync(TEntity entity)
{
return await EntityContext.Updateable(entity).IgnoreColumns(true).IgnoreColumns(UpdateIgnoreColumns).ExecuteCommandAsync();
}
/// <summary>
/// 更新一条记录
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual async Task<int> UpdateAsync(TEntity entity)
{
return await EntityContext.Updateable(entity).IgnoreColumns(UpdateIgnoreColumns).ExecuteCommandAsync();
}
/// <summary>
/// 更新记录
/// </summary>
/// <param name="predicate">更新的条件</param>
/// <param name="content">更新的内容</param>
/// <returns></returns>
public virtual int Update(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TEntity>> content)
{
return EntityContext.Updateable(content).Where(predicate).IgnoreColumns(UpdateIgnoreColumns).ExecuteCommand();
}
/// <summary>
/// 更新记录
/// </summary>
/// <param name="predicate">更新的条件</param>
/// <param name="content">更新的内容</param>
/// <returns></returns>
public virtual async Task<int> UpdateAsync(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TEntity>> content)
{
return await EntityContext.Updateable(content).Where(predicate).IgnoreColumns(UpdateIgnoreColumns).ExecuteCommandAsync();
}
/// <summary>
/// 更新多条记录
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public virtual Task<int> UpdateAsync(params TEntity[] entities)
{
return EntityContext.Updateable(entities).IgnoreColumns(UpdateIgnoreColumns).ExecuteCommandAsync();
}
/// <summary>
/// 更新多条记录
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
public virtual Task<int> UpdateAsync(IEnumerable<TEntity> entities)
{
return EntityContext.Updateable(entities.ToArray()).IgnoreColumns(UpdateIgnoreColumns).ExecuteCommandAsync();
}
public virtual IUpdateable<TEntity> AsUpdateable(TEntity entity)
{
return EntityContext.Updateable(entity).IgnoreColumns(UpdateIgnoreColumns);
}
public virtual IUpdateable<TEntity> AsUpdateable(IEnumerable<TEntity> entities)
{
return EntityContext.Updateable<TEntity>(entities).IgnoreColumns(UpdateIgnoreColumns);
}
#endregion
#region 删除
/// <summary>
/// 删除一条记录
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual int Delete(TEntity entity)
{
return EntityContext.Deleteable(entity).ExecuteCommand();
}
/// <summary>
/// 删除一条记录
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public virtual int Delete(object key)
{
return EntityContext.Deleteable<TEntity>().In(key).ExecuteCommand();
}
/// <summary>
/// 删除多条记录
/// </summary>
/// <param name="keys"></param>
/// <returns></returns>
public virtual int Delete(params object[] keys)
{
return EntityContext.Deleteable<TEntity>().In(keys).ExecuteCommand();
}
/// <summary>
/// 自定义条件删除记录
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public int Delete(Expression<Func<TEntity, bool>> whereExpression)
{
return EntityContext.Deleteable<TEntity>().Where(whereExpression).ExecuteCommand();
}
/// <summary>
/// 删除一条记录
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual Task<int> DeleteAsync(TEntity entity)
{
return EntityContext.Deleteable(entity).ExecuteCommandAsync();
}
/// <summary>
/// 删除一条记录
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public virtual Task<int> DeleteAsync(object key)
{
return EntityContext.Deleteable<TEntity>().In(key).ExecuteCommandAsync();
}
/// <summary>
/// 删除多条记录
/// </summary>
/// <param name="keys"></param>
/// <returns></returns>
public virtual Task<int> DeleteAsync(params object[] keys)
{
return EntityContext.Deleteable<TEntity>().In(keys).ExecuteCommandAsync();
}
/// <summary>
/// 自定义条件删除记录
/// </summary>
/// <param name="whereExpression"></param>
/// <returns></returns>
public async Task<int> DeleteAsync(Expression<Func<TEntity, bool>> whereExpression)
{
return await EntityContext.Deleteable<TEntity>().Where(whereExpression).ExecuteCommandAsync();
}
#endregion
#region 其他
/// <summary>
/// 根据表达式查询多条记录
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public virtual ISugarQueryable<TEntity> Where(Expression<Func<TEntity, bool>> predicate)
{
return AsQueryable(predicate);
}
/// <summary>
/// 根据表达式查询多条记录
/// </summary>
/// <param name="condition"></param>
/// <param name="predicate"></param>
/// <returns></returns>
public virtual ISugarQueryable<TEntity> Where(bool condition, Expression<Func<TEntity, bool>> predicate)
{
return AsQueryable().WhereIF(condition, predicate);
}
/// <summary>
/// 构建查询分析器
/// </summary>
/// <returns></returns>
public virtual ISugarQueryable<TEntity> AsQueryable()
{
return Entities;
}
/// <summary>
/// 构建查询分析器
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public virtual ISugarQueryable<TEntity> AsQueryable(Expression<Func<TEntity, bool>> predicate)
{
return Entities.Where(predicate);
}
/// <summary>
/// 直接返回数据库结果
/// </summary>
/// <returns></returns>
public virtual List<TEntity> AsEnumerable()
{
return AsQueryable().ToList();
}
/// <summary>
/// 直接返回数据库结果
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public virtual List<TEntity> AsEnumerable(Expression<Func<TEntity, bool>> predicate)
{
return AsQueryable(predicate).ToList();
}
/// <summary>
/// 直接返回数据库结果
/// </summary>
/// <returns></returns>
public virtual Task<List<TEntity>> AsAsyncEnumerable()
{
return AsQueryable().ToListAsync();
}
/// <summary>
/// 直接返回数据库结果
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
public virtual Task<List<TEntity>> AsAsyncEnumerable(Expression<Func<TEntity, bool>> predicate)
{
return AsQueryable(predicate).ToListAsync();
}
public virtual bool IsExists(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.Any(whereExpression);
}
public virtual Task<bool> IsExistsAsync(Expression<Func<TEntity, bool>> whereExpression)
{
return Entities.AnyAsync(whereExpression);
}
#endregion
#region 仓储事务
/// <summary>
/// 切换仓储(注意使用环境)
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <returns>仓储</returns>
public virtual SqlSugarRepository<T> Change<T>()
where T : class, new()
{
return App.GetService<SqlSugarRepository<T>>();
}
/// <summary>
/// 当前db
/// </summary>
public void CurrentBeginTran()
{
Ado.BeginTran();
}
/// <summary>
/// 当前db
/// </summary>
public void CurrentCommitTran()
{
Ado.CommitTran();
}
/// <summary>
/// 当前db
/// </summary>
public void CurrentRollbackTran()
{
Ado.RollbackTran();
}
/// <summary>
/// 所有db
/// </summary>
public void BeginTran()
{
Context.BeginTran();
}
/// <summary>
/// 所有db
/// </summary>
public void CommitTran()
{
Context.CommitTran();
}
/// <summary>
/// 所有db
/// </summary>
public void RollbackTran()
{
Context.RollbackTran();
}
#endregion
}
}

283
20220330_Vote/Ewide.Core/SqlSugar/SqlsugarSetup.cs Normal file
View File

@@ -0,0 +1,283 @@
using Ewide.Core;
using Ewide.Core.Cache;
using Furion;
using Furion.Logging.Extensions;
using Microsoft.Extensions.DependencyInjection;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Ewide.Core
{
public static class SqlsugarSetup
{
public static void AddSqlsugarSetup(this IServiceCollection services)
{
var connList = App.GetConfig<List<MutiDBConnectionString>>("ConnectionStrings")?.Where(p => p.Enabled).ToList();
List<ConnectionConfig> connectConfigList = new();
connList.ForEach(conn =>
{
connectConfigList.Add(new ConnectionConfig
{
ConfigId = conn.Id,
ConnectionString = conn.ConnectionString,
DbType = conn.DbType,
IsAutoCloseConnection = true,
InitKeyType = InitKeyType.Attribute,
MoreSettings = new ConnMoreSettings()
{
IsAutoRemoveDataCache = true//自动清理缓存
},
ConfigureExternalServices = new ConfigureExternalServices()
{
DataInfoCacheService = new SqlSugarCache(),
EntityNameService = (type, entity) =>
{
var attributes = type.GetCustomAttributes(true);
if (attributes.Any(it => it is TableAttribute))
{
entity.DbTableName = (attributes.First(it => it is TableAttribute) as TableAttribute).Name;
}
},
EntityService = (type, column) =>
{
var attributes = type.GetCustomAttributes(true);
if (attributes.Any(it => it is KeyAttribute))// by attribute set primarykey
{
column.IsPrimarykey = true; //有哪些特性可以看 1.2 特性明细
}
if (attributes.Any(it => it is ColumnAttribute))
{
column.DbColumnName = (attributes.First(it => it is ColumnAttribute) as ColumnAttribute).Name;
}
}
}
});
});
services.AddSqlSugar(connectConfigList.ToArray(), db =>
{
//处理日志事务
db.Aop.OnLogExecuting = (sql, pars) =>
{
Debugger.Log(1, "", $"===================CurrentConfigId:{db.CurrentConnectionConfig.ConfigId} SqlSugar log started ===================\r\n");
Debugger.Log(2, "语句:", sql);
Debugger.Log(3, "参数:", string.Join(",", pars?.Select(it => it.ParameterName + ":" + it.Value)));
Debugger.Log(4, "", $"===================CurrentConfigId:{db.CurrentConnectionConfig.ConfigId} SqlSugar log end ===================\r\n");
//App.PrintToMiniProfiler("SqlSugar", "Info", sql + "\r\n" + db.Utilities.SerializeObject(pars.ToDictionary(it => it.ParameterName, it => it.Value)));
};
});
List<Type> types = App.EffectiveTypes.Where(a => !a.IsAbstract && a.IsClass && a.GetCustomAttributes(typeof(SugarTable), true)?.FirstOrDefault() != null).ToList();
SqlSugarScope sqlSugarScope = new SqlSugarScope(connectConfigList,
//全局上下文生效
db =>
{
/*
* 默认只会配置到第一个数据库，这里按照官方文档进行多数据库/多租户文档的说明进行循环配置
*/
foreach (var c in connectConfigList)
{
var dbProvider = db.GetConnectionScope((string)c.ConfigId);
//执行超时时间
dbProvider.Ado.CommandTimeOut = 30;
dbProvider.Aop.OnLogExecuting = (sql, pars) =>
{
if (sql.StartsWith("SELECT"))
{
Console.ForegroundColor = ConsoleColor.Green;
}
if (sql.StartsWith("UPDATE") || sql.StartsWith("INSERT"))
{
Console.ForegroundColor = ConsoleColor.White;
}
if (sql.StartsWith("DELETE"))
{
Console.ForegroundColor = ConsoleColor.Blue;
}
//Console.WriteLine("Sql:" + "\r\n\r\n" + UtilMethods.GetSqlString(c.DbType, sql, pars));
App.PrintToMiniProfiler("SqlSugar", "Info", UtilMethods.GetSqlString(c.DbType, sql, pars));
$"DB:{c.ConfigId}, Sql:\r\n\r\n {UtilMethods.GetSqlString(c.DbType, sql, pars)}".LogInformation();
};
dbProvider.Aop.DataExecuting = (oldValue, entityInfo) =>
{
//// 新增操作
//if (entityInfo.OperationType == DataFilterType.InsertByObject)
//{
// // 主键(long)-赋值雪花Id
// if (entityInfo.EntityColumnInfo.IsPrimarykey && entityInfo.EntityColumnInfo.PropertyInfo.PropertyType == typeof(long))
// {
// var id = ((dynamic)entityInfo.EntityValue).Id;
// if (id == null || id == 0)
// entityInfo.SetValue(Yitter.IdGenerator.YitIdHelper.NextId());
// }
// if (entityInfo.PropertyName == "CreatedTime")
// entityInfo.SetValue(DateTime.Now);
// if (App.User != null)
// {
// if (entityInfo.PropertyName == "TenantId")
// {
// var tenantId = ((dynamic)entityInfo.EntityValue).TenantId;
// if (tenantId == null || tenantId == 0)
// entityInfo.SetValue(App.User.FindFirst(ClaimConst.TENANT_ID)?.Value);
// }
// if (entityInfo.PropertyName == "CreatedUserId")
// {
// var createUserId = ((dynamic)entityInfo.EntityValue).CreatedUserId;
// if (createUserId == null || createUserId == 0)
// entityInfo.SetValue(App.User.FindFirst(ClaimConst.CLAINM_USERID)?.Value);
// }
// if (entityInfo.PropertyName == "CreatedUserName")
// entityInfo.SetValue(App.User.FindFirst(ClaimConst.CLAINM_NAME)?.Value);
// }
//}
//// 更新操作
//if (entityInfo.OperationType == DataFilterType.UpdateByObject)
//{
// if (entityInfo.PropertyName == "UpdatedTime")
// entityInfo.SetValue(DateTime.Now);
// if (entityInfo.PropertyName == "UpdatedUserId")
// entityInfo.SetValue(App.User?.FindFirst(ClaimConst.CLAINM_USERID)?.Value);
// if (entityInfo.PropertyName == "UpdatedUserName")
// entityInfo.SetValue(App.User?.FindFirst(ClaimConst.CLAINM_NAME)?.Value);
//}
};
/*
* 使用 SqlSugarScope 循环配置此项的时候会覆盖整个 ConfigureExternalServices，
* 移动到 New ConnectionConfig中配置
*/
//db.CurrentConnectionConfig.ConfigureExternalServices = new ConfigureExternalServices()
//{
// DataInfoCacheService = new SqlSugarCache()//配置我们创建的缓存类
//};
////全局过滤器
//var superAdminViewAllData = Convert.ToBoolean(App.GetOptions<SystemSettingsOptions>().SuperAdminViewAllData);
//foreach (var entityType in types)
//{
// // 配置多租户全局过滤器
// //if (!entityType.GetProperty(ClaimConst.TENANT_ID).IsEmpty())
// //{ //判断实体类中包含TenantId属性
// // //构建动态Lambda
// // var lambda = DynamicExpressionParser.ParseLambda
// // (new[] { Expression.Parameter(entityType, "it") },
// // typeof(bool), $"{nameof(DBEntityTenant.TenantId)} == @0 or (@1 and @2)",
// // GetTenantId(), IsSuperAdmin(), superAdminViewAllData);
// // dbProvider.QueryFilter.Add(new TableFilterItem<object>(entityType, lambda)); //将Lambda传入过滤器
// //}
// // 配置加删除全局过滤器
// if (!entityType.GetProperty(CommonConst.DELETE_FIELD).IsEmpty())
// { //判断实体类中包含IsDeleted属性
// //构建动态Lambda
// var lambda = DynamicExpressionParser.ParseLambda
// (new[] { Expression.Parameter(entityType, "it") },
// typeof(bool), $"{nameof(DEntityBase.IsDeleted)} == @0",
// false);
// dbProvider.QueryFilter.Add(new TableFilterItem<object>(entityType, lambda)
// {
// IsJoinQuery = true
// }); //将Lambda传入过滤器
// }
//}
}
});
services.AddSingleton<ISqlSugarClient>(sqlSugarScope);
// 注册 SqlSugar 仓储
services.AddScoped(typeof(SqlSugarRepository<>));
////如果多个数数据库传 List<ConnectionConfig>
//var configConnection = new ConnectionConfig()
//{
// DbType = SqlSugar.DbType.MySql,
// ConnectionString = configuration.GetConnectionString(dbName),
// IsAutoCloseConnection = true,
//};
//SqlSugarScope sqlSugar = new SqlSugarScope(configConnection,
// db =>
// {
// //单例参数配置，所有上下文生效
// db.Aop.OnLogExecuting = (sql, pars) =>
// {
// //Console.WriteLine(sql);//输出sql
// };
// });
//services.AddSingleton<ISqlSugarClient>(sqlSugar);//这边是SqlSugarScope用AddSingleton
}
/// <summary>
/// 判断是不是超级管理员
/// </summary>
/// <returns></returns>
private static bool IsSuperAdmin()
{
if (App.User == null) return false;
return App.User.FindFirst(ClaimConst.CLAINM_SUPERADMIN)?.Value == AdminType.SuperAdmin.GetHashCode().ToString();
}
/// <summary>
/// 添加 SqlSugar 拓展
/// </summary>
/// <param name="services"></param>
/// <param name="config"></param>
/// <param name="buildAction"></param>
/// <returns></returns>
public static IServiceCollection AddSqlSugar(this IServiceCollection services, ConnectionConfig config, Action<ISqlSugarClient> buildAction = default)
{
var list = new List<ConnectionConfig>();
list.Add(config);
return services.AddSqlSugar(list, buildAction);
}
/// <summary>
/// 添加 SqlSugar 拓展
/// </summary>
/// <param name="services"></param>
/// <param name="configs"></param>
/// <param name="buildAction"></param>
/// <returns></returns>
public static IServiceCollection AddSqlSugar(this IServiceCollection services, List<ConnectionConfig> configs, Action<ISqlSugarClient> buildAction = default)
{
// 注册 SqlSugar 客户端
services.AddScoped<ISqlSugarClient>(u =>
{
var db = new SqlSugarClient(configs);
buildAction?.Invoke(db);
return db;
});
// 注册 SqlSugar 仓储
services.AddScoped(typeof(SqlSugarRepository<>));
return services;
}
}
public class MutiDBConnectionString
{
public string Id { get; set; }
public string ConnectionString { get; set; }
public DbType DbType { get; set; }
public bool Enabled { get; set; }
public string ProviderName { get; set; }
}
}