2778 lines
117 KiB
C#
2778 lines
117 KiB
C#
using Microsoft.EntityFrameworkCore;
|
||
using Newtonsoft.Json;
|
||
using Newtonsoft.Json.Linq;
|
||
using SqlSugar;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.ComponentModel.DataAnnotations;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Linq.Expressions;
|
||
using System.Reflection;
|
||
using VolPro.Core.Configuration;
|
||
using VolPro.Core.DBManager;
|
||
using VolPro.Core.DbSqlSugar;
|
||
using VolPro.Core.Enums;
|
||
using VolPro.Core.Extensions;
|
||
using VolPro.Core.Extensions.AutofacManager;
|
||
using VolPro.Core.Filters;
|
||
using VolPro.Core.Log;
|
||
using VolPro.Core.ManageUser;
|
||
using VolPro.Core.Middleware;
|
||
using VolPro.Core.Services;
|
||
using VolPro.Core.Tenancy;
|
||
using VolPro.Core.UserManager;
|
||
using VolPro.Core.Utilities;
|
||
using VolPro.Core.WorkFlow;
|
||
using VolPro.Entity;
|
||
using VolPro.Entity.DomainModels;
|
||
using VolPro.Entity.SystemModels;
|
||
using CC = VolPro.Core.CacheManager;
|
||
|
||
namespace VolPro.Core.BaseProvider
|
||
{
|
||
public abstract class ServiceBase<T, TRepository> : ServiceFunFilter<T>
|
||
where T : BaseEntity, new()
|
||
where TRepository : IRepository<T>
|
||
{
|
||
public ServiceBase()
|
||
{
|
||
|
||
}
|
||
public CC.ICacheService CacheContext
|
||
{
|
||
get
|
||
{
|
||
return AutofacContainerModule.GetService<CC.ICacheService>();
|
||
}
|
||
}
|
||
|
||
public Microsoft.AspNetCore.Http.HttpContext Context
|
||
{
|
||
get
|
||
{
|
||
return HttpContext.Current;
|
||
}
|
||
}
|
||
private WebResponseContent Response { get; set; }
|
||
|
||
protected IRepository<T> repository;
|
||
|
||
private PropertyInfo[] _propertyInfo { get; set; } = null;
|
||
private PropertyInfo[] TProperties
|
||
{
|
||
get
|
||
{
|
||
if (_propertyInfo != null)
|
||
{
|
||
return _propertyInfo;
|
||
}
|
||
_propertyInfo = typeof(T).GetProperties();
|
||
return _propertyInfo;
|
||
}
|
||
}
|
||
|
||
public ServiceBase(TRepository repository)
|
||
{
|
||
Response = new WebResponseContent(true);
|
||
this.repository = repository;
|
||
}
|
||
|
||
protected virtual void Init(IRepository<T> repository)
|
||
{
|
||
|
||
}
|
||
|
||
protected virtual Type GetRealDetailType()
|
||
{
|
||
return typeof(T).GetCustomAttribute<EntityAttribute>()?.DetailTable?[0];
|
||
}
|
||
|
||
/// <summary>
|
||
///
|
||
/// </summary>
|
||
/// <param name="predicate"></param>
|
||
/// <param name="filterDeleted">过滤逻辑删除的数据</param>
|
||
/// <returns></returns>
|
||
public ISugarQueryable<T> FindAsIQueryable(Expression<Func<T, bool>> predicate, bool filterDeleted = true)
|
||
{
|
||
return repository.FindAsIQueryable(predicate, null, filterDeleted);
|
||
}
|
||
/// <summary>
|
||
/// 将前端table的查询条件转换为查询ISugarQueryable
|
||
/// </summary>
|
||
/// <param name="options">前端查询参数</param>
|
||
/// <param name="useTenancy">是否使用数据隔离</param>
|
||
/// <returns></returns>
|
||
public ISugarQueryable<T> FindAsIQueryable(PageDataOptions options, bool useTenancy = true)
|
||
{
|
||
ValidatePageOptions(options, out ISugarQueryable<T> queryable, useTenancy);
|
||
return queryable;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 2020.08.15添加自定义原生查询sql或多租户(查询、导出)
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private ISugarQueryable<T> GetSearchQueryable()
|
||
{
|
||
if (QuerySql != null)
|
||
{
|
||
var customerQueryable = repository.DbContext.SqlQueryable<T>(QuerySql.ToString());
|
||
QuerySql = null;
|
||
return GetSearchQueryable(customerQueryable);
|
||
}
|
||
if (!IsMultiTenancy)
|
||
{
|
||
return repository.DbContext.Set<T>();
|
||
}
|
||
return GetSearchQueryable(repository.DbContext.Set<T>().FilterTenancy<T>());
|
||
}
|
||
private ISugarQueryable<T> GetSearchQueryable(ISugarQueryable<T> queryable)
|
||
{
|
||
string tableName = typeof(T).GetEntityTableName();
|
||
var (sql, query) = TenancyManager<T>.GetSearchQueryable(QuerySql, tableName, queryable);
|
||
if (!string.IsNullOrEmpty(sql))
|
||
{
|
||
return repository.DbContext.SqlQueryable<T>(sql);
|
||
}
|
||
return query;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 2020.08.15添加获取多租户数据过滤sql（删除、编辑）
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private string GetMultiTenancySql(string ids, string tableKey)
|
||
{
|
||
return TenancyManager<T>.GetMultiTenancySql(typeof(T).GetEntityTableName(), ids, tableKey);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 2020.08.15添加多租户数据过滤（删除）
|
||
/// </summary>
|
||
private void CheckDelMultiTenancy(string ids, string tableKey)
|
||
{
|
||
//string sql = GetMultiTenancySql(ids, tableKey);
|
||
//if (string.IsNullOrEmpty(sql))
|
||
//{
|
||
// return;
|
||
//}
|
||
|
||
////请接着过滤条件
|
||
////例如sql，只能(删除)自己创建的数据:找出不是自己创建的数据
|
||
////sql = $" {sql} and CreateId!={UserContext.Current.UserId}";
|
||
//object obj = repository.DapperContext.ExecuteScalar(sql, null);
|
||
//int idsCount = ids.Split(",").Distinct().Count();
|
||
//if (obj == null || obj.GetInt() != idsCount)
|
||
//{
|
||
// Response.Error("不能删除此数据");
|
||
//}
|
||
}
|
||
|
||
private const string _asc = "asc";
|
||
/// <summary>
|
||
/// 生成排序字段
|
||
/// </summary>
|
||
/// <param name="pageData"></param>
|
||
/// <param name="propertyInfo"></param>
|
||
private Dictionary<string, QueryOrderBy> GetPageDataSort(PageDataOptions pageData, PropertyInfo[] propertyInfo)
|
||
{
|
||
if (base.OrderByExpression != null)
|
||
{
|
||
return base.OrderByExpression.GetExpressionToDic();
|
||
}
|
||
if (!string.IsNullOrEmpty(pageData.Sort))
|
||
{
|
||
if (pageData.Sort.Contains(","))
|
||
{
|
||
var sortArr = pageData.Sort.Split(",").Where(x => propertyInfo.Any(c => c.Name == x)).Select(s => s).Distinct().ToList();
|
||
Dictionary<string, QueryOrderBy> sortDic = new Dictionary<string, QueryOrderBy>();
|
||
foreach (var name in sortArr)
|
||
{
|
||
sortDic[name] = pageData.Order?.ToLower() == _asc ? QueryOrderBy.Asc : QueryOrderBy.Desc;
|
||
}
|
||
return sortDic;
|
||
}
|
||
else if (propertyInfo.Any(x => x.Name == pageData.Sort))
|
||
{
|
||
return new Dictionary<string, QueryOrderBy>() { {
|
||
pageData.Sort,
|
||
pageData.Order?.ToLower() == _asc? QueryOrderBy.Asc: QueryOrderBy.Desc
|
||
} };
|
||
}
|
||
}
|
||
//如果没有排序字段，则使用主键作为排序字段
|
||
|
||
PropertyInfo property = propertyInfo.GetKeyProperty();
|
||
//如果主键不是自增类型则使用appsettings.json中CreateMember->DateField配置的创建时间作为排序
|
||
if (property.PropertyType == typeof(int) || property.PropertyType == typeof(long))
|
||
{
|
||
if (!propertyInfo.Any(x => x.Name.ToLower() == pageData.Sort))
|
||
{
|
||
pageData.Sort = propertyInfo.GetKeyName();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!string.IsNullOrEmpty(AppSetting.CreateMember.DateField)
|
||
&& propertyInfo.Any(x => x.Name == AppSetting.CreateMember.DateField))
|
||
{
|
||
pageData.Sort = AppSetting.CreateMember.DateField;
|
||
}
|
||
else
|
||
{
|
||
pageData.Sort = propertyInfo.GetKeyName();
|
||
}
|
||
}
|
||
return new Dictionary<string, QueryOrderBy>() { {
|
||
pageData.Sort, pageData.Order?.ToLower() == _asc? QueryOrderBy.Asc: QueryOrderBy.Desc
|
||
} };
|
||
}
|
||
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 验证排序与查询字段合法性
|
||
/// </summary>
|
||
/// <param name="options"></param>
|
||
/// <param name="queryable"></param>
|
||
/// <returns></returns>
|
||
protected PageDataOptions ValidatePageOptions(PageDataOptions options, out ISugarQueryable<T> queryable, bool useTenancy = true)
|
||
{
|
||
options = options ?? new PageDataOptions();
|
||
|
||
List<SearchParameters> searchParametersList = new List<SearchParameters>();
|
||
if (options.Filter != null && options.Filter.Count > 0)
|
||
{
|
||
searchParametersList.AddRange(options.Filter);
|
||
}
|
||
else if (!string.IsNullOrEmpty(options.Wheres))
|
||
{
|
||
try
|
||
{
|
||
searchParametersList = options.Wheres.DeserializeObject<List<SearchParameters>>();
|
||
options.Filter = searchParametersList;
|
||
}
|
||
catch { }
|
||
}
|
||
QueryRelativeList?.Invoke(searchParametersList);
|
||
if (useTenancy && options.Value?.ToString() != "viewflow")
|
||
{
|
||
queryable = GetSearchQueryable();
|
||
}
|
||
else
|
||
{
|
||
queryable = repository.DbContext.Set<T>();
|
||
}
|
||
// Connection
|
||
// queryable = repository.DbContext.Set<T>();
|
||
//2020.08.15添加自定义原生查询sql或多租户
|
||
|
||
|
||
//判断列的数据类型数字，日期的需要判断值的格式是否正确
|
||
for (int i = 0; i < searchParametersList.Count; i++)
|
||
{
|
||
SearchParameters x = searchParametersList[i];
|
||
//空或null值查询条件
|
||
if (Enum.TryParse(x.DisplayType, ignoreCase: true, out LinqExpressionType filterType))
|
||
{
|
||
if (filterType.CheckFilterNullExpression())
|
||
{
|
||
queryable = queryable.Where(x.Name.CreateExpression<T>(null, filterType));
|
||
continue;
|
||
}
|
||
}
|
||
if (string.IsNullOrEmpty(x.Value))
|
||
{
|
||
continue;
|
||
}
|
||
// x.DisplayType = x.DisplayType.GetDbCondition();
|
||
PropertyInfo property = TProperties.Where(c => c.Name.ToUpper() == x.Name.ToUpper()).FirstOrDefault();
|
||
//2020.06.25增加字段null处理
|
||
if (property == null) continue;
|
||
// property
|
||
//移除查询的值与数据库类型不匹配的数据
|
||
object[] values = property.ValidationValueForDbType(x.Value.Split(',')).Where(q => q.Item1).Select(s => s.Item3).ToArray();
|
||
if (values == null || values.Length == 0)
|
||
{
|
||
continue;
|
||
}
|
||
LinqExpressionType expressionType = x.DisplayType.GetLinqCondition();
|
||
//if (x.DisplayType == HtmlElementType.Contains)
|
||
// x.Value = string.Join(",", values);
|
||
queryable = LinqExpressionType.In == expressionType
|
||
? queryable.Where(x.Name.CreateExpression<T>(values, expressionType))
|
||
: queryable.Where(x.Name.CreateExpression<T>(x.Value, expressionType));
|
||
}
|
||
options.TableName = base.TableName ?? typeof(T).Name;
|
||
return options;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 加载页面数据
|
||
/// </summary>
|
||
/// <param name="loadSingleParameters"></param>
|
||
/// <returns></returns>
|
||
public virtual PageGridData<T> GetPageData(PageDataOptions options)
|
||
{
|
||
options = ValidatePageOptions(options, out ISugarQueryable<T> queryable, IsMultiTenancy);
|
||
//获取排序字段
|
||
Dictionary<string, QueryOrderBy> orderbyDic = GetPageDataSort(options, TProperties);
|
||
|
||
PageGridData<T> pageGridData = new PageGridData<T>();
|
||
if (QueryRelativeExpression != null)
|
||
{
|
||
queryable = QueryRelativeExpression.Invoke(queryable);
|
||
}
|
||
|
||
//过滤逻辑删除
|
||
var logicDelProperty = GetLogicDelProperty<T>();
|
||
if (logicDelProperty != null)
|
||
{
|
||
queryable = queryable.Where(logicDelProperty.Name.CreateExpression<T>(((int)DelStatus.正常).ChangeType(logicDelProperty.PropertyType), LinqExpressionType.Equal));
|
||
}
|
||
|
||
|
||
if (options.Export)
|
||
{
|
||
queryable = queryable.GetISugarQueryableOrderBy(orderbyDic);
|
||
if (Limit > 0)
|
||
{
|
||
queryable = queryable.Take(Limit);
|
||
}
|
||
pageGridData.rows = FilterQueryableAuthFields(queryable);
|
||
}
|
||
else
|
||
{
|
||
queryable = repository.IQueryablePage(queryable,
|
||
options.Page,
|
||
options.Rows,
|
||
out int rowCount,
|
||
orderbyDic);
|
||
pageGridData.rows = FilterQueryableAuthFields(queryable);
|
||
pageGridData.total = rowCount;
|
||
|
||
//查询界面统计求等字段
|
||
//这里sqlsugar会把IQueryablePage里面的排序字段也添加进去了就会导致异常2023.10.17
|
||
if (SummaryExpress != null)
|
||
{
|
||
options = ValidatePageOptions(options, out ISugarQueryable<T> queryableSummary);
|
||
//if (QueryRelativeExpression!=null)
|
||
//{
|
||
// queryableSummary = QueryRelativeExpression.Invoke(queryableSummary);
|
||
//}
|
||
pageGridData.summary = SummaryExpress.Invoke(queryableSummary);
|
||
}
|
||
|
||
}
|
||
GetPageDataOnExecuted?.Invoke(pageGridData);
|
||
return pageGridData;
|
||
|
||
}
|
||
/// <summary>
|
||
/// 映射指定权限的字段不查询数据库2023.08.03
|
||
/// </summary>
|
||
/// <param name="queryable"></param>
|
||
/// <returns></returns>
|
||
private List<T> FilterQueryableAuthFields(ISugarQueryable<T> queryable)
|
||
{
|
||
string tableName = typeof(T).Name;
|
||
var authFields = RoleContext.GetCurrentRoleAuthFields(tableName);
|
||
if (authFields.Length == 0)
|
||
{
|
||
return queryable.ToList();
|
||
}
|
||
var source = typeof(T);
|
||
var target = typeof(T);
|
||
|
||
var t = Expression.Parameter(source, "t");
|
||
|
||
List<MemberAssignment> assignments = new();
|
||
|
||
//获取代码生成器隐藏的字段
|
||
var hideFields = TableColumnContext.GetTableHideFields(tableName);
|
||
|
||
var fields = source.GetProperties().Where(x => authFields.Contains(x.Name) || hideFields.Contains(x.Name)).Select(s => s.Name).ToList();
|
||
|
||
foreach (var item in fields)
|
||
{
|
||
var member1 = Expression.MakeMemberAccess(t, source.GetProperty(item));
|
||
|
||
var member2 = Expression.Bind(target.GetProperty(item), member1);
|
||
assignments.Add(member2);
|
||
}
|
||
var newExpression = Expression.New(target);
|
||
var memberInit = Expression.MemberInit(newExpression, assignments);
|
||
var expression = (Expression<Func<T, T>>)Expression.Lambda(memberInit, t);
|
||
return queryable.Select(expression).ToList();
|
||
|
||
}
|
||
public virtual object GetDetailPage(PageDataOptions pageData)
|
||
{
|
||
var tables = typeof(T).GetCustomAttribute<EntityAttribute>();
|
||
if (tables == null)
|
||
{
|
||
return null;
|
||
}
|
||
string keyName = typeof(T).GetKeyName();
|
||
|
||
Type detailType = null;
|
||
|
||
if (string.IsNullOrEmpty(pageData.TableName) && string.IsNullOrEmpty(pageData.DetailTable))
|
||
{
|
||
detailType = tables.DetailTable.FirstOrDefault();
|
||
}
|
||
else
|
||
{ //三级明细表查询
|
||
if (!string.IsNullOrEmpty(pageData.DetailTable))
|
||
{
|
||
//获取二级明细表
|
||
detailType = tables.DetailTable.Where(c => c.Name == pageData.DetailTable).FirstOrDefault();
|
||
keyName = detailType.GetKeyName();
|
||
detailType = detailType.GetCustomAttribute<EntityAttribute>()?.DetailTable
|
||
?.Where(x => x.Name == pageData.TableName)?.FirstOrDefault();
|
||
}
|
||
else
|
||
{
|
||
//多表二级明细表查询
|
||
detailType = tables.DetailTable.Where(c => c.Name == pageData.TableName).FirstOrDefault();
|
||
}
|
||
}
|
||
|
||
if (detailType == null)
|
||
{
|
||
string message = $"未找到配置{pageData.TableName},请检查代码生成器明细表配置及是否生成model";
|
||
Console.WriteLine(message);
|
||
return new { message = message };
|
||
}
|
||
object obj = typeof(ServiceBase<T, TRepository>)
|
||
.GetMethod("GetDetailPage", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { detailType }).Invoke(this, new object[] { pageData, keyName });
|
||
return obj;
|
||
}
|
||
protected override object GetDetailSummary<Detail>(ISugarQueryable<Detail> queryable)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
private PageGridData<Detail> GetDetailPage<Detail>(PageDataOptions options, string keyName) where Detail : class, new()
|
||
{
|
||
//校验查询值，排序字段，分页大小规则待完
|
||
PageGridData<Detail> gridData = new PageGridData<Detail>();
|
||
if (options.Value == null) return gridData;
|
||
////主表主键字段
|
||
//string keyName = typeof(T).GetKeyName();
|
||
|
||
//生成查询条件
|
||
Expression<Func<Detail, bool>> whereExpression = keyName.CreateExpression<Detail>(options.Value, LinqExpressionType.Equal);
|
||
|
||
var queryable = repository.DbContext.Set<Detail>().Where(whereExpression);
|
||
|
||
//过滤逻辑删除
|
||
|
||
var logicDelProperty = GetLogicDelProperty<Detail>();
|
||
if (logicDelProperty != null)
|
||
{
|
||
queryable = queryable.Where(logicDelProperty.Name.CreateExpression<Detail>(((int)DelStatus.正常).ChangeType(logicDelProperty.PropertyType), LinqExpressionType.Equal));
|
||
}
|
||
|
||
gridData.total = queryable.Count();
|
||
options.Sort = options.Sort ?? typeof(Detail).GetKeyName();
|
||
Dictionary<string, QueryOrderBy> orderBy = GetPageDataSort(options, typeof(Detail).GetProperties());
|
||
|
||
gridData.rows = queryable
|
||
.GetISugarQueryableOrderBy(orderBy)
|
||
.Skip((options.Page - 1) * options.Rows)
|
||
.Take(options.Rows)
|
||
.ToList();
|
||
|
||
//查询界面统计求等字段
|
||
//这里sqlsugar会把IQueryablePage里面的排序字段也添加进去了就会导致异常2023.10.17
|
||
queryable = repository.DbContext.Set<Detail>().Where(whereExpression);
|
||
gridData.summary = GetDetailSummary<Detail>(queryable);
|
||
return gridData;
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 上传文件
|
||
/// </summary>
|
||
/// <param name="files"></param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent Upload(List<Microsoft.AspNetCore.Http.IFormFile> files)
|
||
{
|
||
if (files == null || files.Count == 0) return Response.Error("请上传文件");
|
||
|
||
string filePath;
|
||
if (!string.IsNullOrEmpty(UploadFolder))
|
||
{
|
||
filePath = UploadFolder;
|
||
if (!filePath.EndsWith("/") || !filePath.EndsWith("\\"))
|
||
{
|
||
filePath += "/";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
filePath = $"Upload/Tables/{typeof(T).GetEntityTableName()}/{DateTime.Now.ToString("yyyMMddHHmmsss") + new Random().Next(1000, 9999)}/";
|
||
}
|
||
|
||
string fullPath = filePath.MapPath(IsRoot);
|
||
int i = 0;
|
||
try
|
||
{
|
||
if (!Directory.Exists(fullPath)) Directory.CreateDirectory(fullPath);
|
||
for (i = 0; i < files.Count; i++)
|
||
{
|
||
string fileName = HttpContext.Current.Request("fileName");
|
||
if (string.IsNullOrEmpty(fileName))
|
||
{
|
||
fileName = files[i].FileName;
|
||
}
|
||
using var stream = new FileStream(fullPath + fileName, FileMode.Create);
|
||
files[i].CopyTo(stream);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Logger.Error($"上传文件失败：{typeof(T).GetEntityTableCnName()},路径：{filePath},失败文件:{files[i]},{ex.Message + ex.StackTrace}");
|
||
return Response.Error("文件上传失败".Translator());
|
||
}
|
||
return Response.OK("文件上传成功".Translator(), filePath);
|
||
}
|
||
|
||
private List<string> GetIgnoreTemplate()
|
||
{
|
||
//忽略创建人、修改人、审批等字段
|
||
List<string> ignoreTemplate = UserIgnoreFields.ToList();
|
||
ignoreTemplate.AddRange(WorkFlowGeneric.AuditFields);
|
||
return ignoreTemplate;
|
||
}
|
||
|
||
public virtual WebResponseContent DownLoadTemplate()
|
||
{
|
||
string tableName = typeof(T).GetEntityTableCnName();
|
||
|
||
string dicPath = $"Download/{DateTime.Now.ToString("yyyMMdd")}/Template/".MapPath();
|
||
if (!Directory.Exists(dicPath)) Directory.CreateDirectory(dicPath);
|
||
string fileName = tableName + DateTime.Now.ToString("yyyyMMddHHssmm") + ".xlsx";
|
||
//DownLoadTemplateColumns 2020.05.07增加扩展指定导出模板的列
|
||
EPPlusHelper.ExportTemplate<T>(DownLoadTemplateColumns, GetIgnoreTemplate(), dicPath, fileName, ExcelHeaderMap);
|
||
return Response.OK(null, dicPath + fileName);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 导入表数据Excel文件夹
|
||
/// </summary>
|
||
/// <param name="files"></param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent Import(List<Microsoft.AspNetCore.Http.IFormFile> files)
|
||
{
|
||
if (files == null || files.Count == 0)
|
||
return new WebResponseContent { Status = true, Message = "请选择上传的文件".Translator() };
|
||
Microsoft.AspNetCore.Http.IFormFile formFile = files[0];
|
||
string dicPath = $"Upload/{DateTime.Now.ToString("yyyMMdd")}/{typeof(T).Name}/".MapPath();
|
||
if (!Directory.Exists(dicPath)) Directory.CreateDirectory(dicPath);
|
||
dicPath = $"{dicPath}{Guid.NewGuid().ToString()}_{formFile.FileName}";
|
||
|
||
using (var stream = new FileStream(dicPath, FileMode.Create))
|
||
{
|
||
formFile.CopyTo(stream);
|
||
}
|
||
try
|
||
{
|
||
//2022.06.20增加原生excel读取方法(导入时可以自定义读取excel内容)
|
||
//2022.06.20增加原生excel读取方法(导入时可以自定义读取excel内容)
|
||
Response = EPPlusHelper.ReadToDataTable<T>(dicPath, DownLoadTemplateColumns, GetIgnoreTemplate(), readValue: ImportOnReadCellValue,
|
||
ExcelHeaderMap, ImportStartRowIndex, ImportIgnoreSelectValidationColumns);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Response.Error("未能处理导入的文件,请检查导入的文件是否正确".Translator());
|
||
Logger.Error($"表{typeof(T).GetEntityTableCnName()}导入失败{ex.Message + ex.InnerException?.Message}");
|
||
}
|
||
if (CheckResponseResult()) return Response;
|
||
List<T> list = Response.Data as List<T>;
|
||
|
||
var logicDelProperty = GetLogicDelProperty<T>();
|
||
if (logicDelProperty != null)
|
||
{
|
||
foreach (var item in list)
|
||
{
|
||
logicDelProperty.SetValue(item, ((int)DelStatus.正常).ChangeType(logicDelProperty.PropertyType));
|
||
}
|
||
}
|
||
|
||
var keyPro = typeof(T).GetKeyProperty();
|
||
if (keyPro.PropertyType == typeof(long) && AppSetting.UseSnow)
|
||
{
|
||
//生成雪花id
|
||
var idWorker = new Utilities.IdWorker();
|
||
foreach (var item in list)
|
||
{
|
||
keyPro.SetValue(item, idWorker.NextId());
|
||
}
|
||
}
|
||
else if (keyPro == typeof(Guid))
|
||
{
|
||
foreach (var item in list)
|
||
{
|
||
keyPro.SetValue(item, Guid.NewGuid());
|
||
}
|
||
}
|
||
list.SetTenancyValue().CreateCodeList();
|
||
|
||
if (ImportOnExecuting != null)
|
||
{
|
||
Response = ImportOnExecuting.Invoke(list);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
//2022.01.08增加明细表导入判断
|
||
if (HttpContext.Current.Request.Query.ContainsKey("table"))
|
||
{
|
||
ImportOnExecuted?.Invoke(list);
|
||
return Response.OK("文件上传成功".Translator(), list.Serialize());
|
||
}
|
||
repository.SqlSugarClient.Insertable<T>(list).ExecuteCommand();
|
||
if (ImportOnExecuted != null)
|
||
{
|
||
Response = ImportOnExecuted.Invoke(list);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
return Response.OK("文件上传成功".Translator());
|
||
}
|
||
|
||
/// <summary>
|
||
/// 导出
|
||
/// </summary>
|
||
/// <param name="pageData"></param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent Export(PageDataOptions pageData)
|
||
{
|
||
pageData.Export = true;
|
||
List<T> list = GetPageData(pageData).rows;
|
||
string tableName = typeof(T).GetEntityTableCnName();
|
||
string fileName = tableName + DateTime.Now.ToString("yyyyMMddHHssmm") + ".xlsx";
|
||
string folder = DateTime.Now.ToString("yyyyMMdd");
|
||
string savePath = $"Download/ExcelExport/{folder}/".MapPath();
|
||
List<string> ignoreColumn = new List<string>();
|
||
if (ExportOnExecuting != null)
|
||
{
|
||
Response = ExportOnExecuting(list, ignoreColumn);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
|
||
var exportFields = ExportColumns?.GetExpressionToArray() ?? new string[] { };
|
||
//2024.02.03增加导出列表与界面显示字段一致
|
||
if (exportFields == null || exportFields.Length == 0)
|
||
{
|
||
if (pageData.Columns != null && pageData.Columns.Length > 0)
|
||
{
|
||
exportFields = pageData.Columns;
|
||
}
|
||
}
|
||
var fields = RoleContext.GetCurrentRoleAuthFields(typeof(T).Name);
|
||
if (fields.Length > 0)
|
||
{
|
||
var _arr = exportFields.ToList();
|
||
_arr.AddRange(fields);
|
||
exportFields = _arr.Distinct().ToArray();
|
||
}
|
||
if (ignoreColumn.Count > 0)
|
||
{
|
||
ignoreColumn = ignoreColumn.Distinct().ToList();
|
||
}
|
||
//ExportColumns 2020.05.07增加扩展指定导出模板的列
|
||
EPPlusHelper.Export(list, exportFields, ignoreColumn, savePath, fileName);
|
||
//return Response.OK(null, (savePath + "/" + fileName).EncryptDES(AppSetting.Secret.ExportFile));
|
||
//2022.01.08优化导出功能
|
||
return Response.OK(null, (savePath + "/" + fileName));
|
||
}
|
||
|
||
/// <summary>
|
||
/// 新建
|
||
/// </summary>
|
||
/// <param name="saveDataModel"></param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent Add(SaveModel saveDataModel)
|
||
{
|
||
if (AddOnExecute != null)
|
||
{
|
||
Response = AddOnExecute(saveDataModel);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
if (saveDataModel == null
|
||
|| saveDataModel.MainData == null
|
||
|| saveDataModel.MainData.Count == 0)
|
||
return Response.Set(ResponseType.ParametersLack, false);
|
||
|
||
saveDataModel.DetailData = saveDataModel.DetailData?.Where(x => x.Count > 0).ToList();
|
||
Type type = typeof(T);
|
||
//adams 2023.10.31
|
||
PropertyInfo keyPro = type.GetKeyProperty();
|
||
string validReslut = type.ValidateDicInEntity(saveDataModel.MainData, removeNotContains: true, removerKey: keyPro.PropertyType != typeof(string), UserIgnoreFields);
|
||
|
||
if (!string.IsNullOrEmpty(validReslut)) return Response.Error(validReslut);
|
||
|
||
if (saveDataModel.MainData.Count == 0)
|
||
return Response.Error("保存的数据为空，请检查model是否配置正确!");
|
||
|
||
//过滤逻辑删除
|
||
var logicDelProperty = GetLogicDelProperty<T>();
|
||
if (logicDelProperty != null)
|
||
{
|
||
saveDataModel.MainData[logicDelProperty.Name] = (int)DelStatus.正常;
|
||
}
|
||
//2024.06.10增加数据版本号管理
|
||
if (!string.IsNullOrEmpty(saveDataModel.DataVersionField))
|
||
{
|
||
saveDataModel.MainData.TryAdd(saveDataModel.DataVersionField, Guid.NewGuid().ToString());
|
||
}
|
||
UserInfo userInfo = UserContext.Current.UserInfo;
|
||
saveDataModel.SetDefaultVal(AppSetting.CreateMember, userInfo);
|
||
|
||
//主键值
|
||
object keyProVal = null;
|
||
if (saveDataModel.MainData.ContainsKey(keyPro.Name))
|
||
keyProVal = saveDataModel.MainData[keyPro.Name];
|
||
|
||
if (keyPro.PropertyType == typeof(Guid))
|
||
{
|
||
saveDataModel.MainData.Add(keyPro.Name, Guid.NewGuid());
|
||
}
|
||
else if (keyPro.PropertyType == typeof(long) && AppSetting.UseSnow)
|
||
{
|
||
saveDataModel.MainData.Add(keyPro.Name, new Utilities.IdWorker().NextId());
|
||
}
|
||
else if (keyPro.PropertyType == typeof(string))
|
||
{
|
||
if (keyProVal.IsNullOrEmpty())
|
||
saveDataModel.MainData[keyPro.Name] = new Utilities.IdWorker().NextId().ToString(); //adams 2023.4.27 雪花算法
|
||
}
|
||
else
|
||
{
|
||
saveDataModel.MainData.Remove(keyPro.Name);
|
||
}
|
||
|
||
//一对多
|
||
if (saveDataModel.Details != null && saveDataModel.Details.Count() > 0)
|
||
{
|
||
return AddMultipleDetail(saveDataModel);
|
||
}
|
||
|
||
//没有明细直接保存返回
|
||
if (saveDataModel.DetailData == null || saveDataModel.DetailData.Count == 0)
|
||
{
|
||
T mainEntity = saveDataModel.MainData.DicToEntity<T>();
|
||
SetAuditDefaultValue(mainEntity);
|
||
mainEntity.SetTenancyValue().SetValue();
|
||
|
||
if (base.AddOnExecuting != null)
|
||
{
|
||
Response = base.AddOnExecuting(mainEntity, null);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
mainEntity.CreateCode<T>();
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
SetEntityValue(mainEntity);
|
||
repository.AddWithSetIdentity(mainEntity);
|
||
saveDataModel.MainData[keyPro.Name] = keyPro.GetValue(mainEntity);
|
||
Response.OK(ResponseType.SaveSuccess);
|
||
if (base.AddOnExecuted != null)
|
||
{
|
||
Response = base.AddOnExecuted(mainEntity, null);
|
||
}
|
||
return Response;
|
||
});
|
||
if (Response.Status) Response.Data = new { data = mainEntity };
|
||
AddProcese(mainEntity);
|
||
//审计日志
|
||
WriteAtionLog(ActionChangeType.Add, mainEntity);
|
||
return Response;
|
||
}
|
||
|
||
Type detailType = GetRealDetailType();
|
||
|
||
return typeof(ServiceBase<T, TRepository>)
|
||
.GetMethod("Add", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { detailType })
|
||
.Invoke(this, new object[] { saveDataModel })
|
||
as WebResponseContent;
|
||
}
|
||
|
||
public virtual WebResponseContent AddEntity(T entity, bool validationEntity = true)
|
||
{
|
||
return Add<T>(entity, null, validationEntity);
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 保存主、明细数据
|
||
/// </summary>
|
||
/// <typeparam name="TDetail"></typeparam>
|
||
/// <param name="entity"></param>
|
||
/// <param name="list"></param>
|
||
/// <param name="validationEntity">是否进行实体验证</param>
|
||
/// <returns></returns>
|
||
public WebResponseContent Add<TDetail>(T entity, List<TDetail> list = null, bool validationEntity = true) where TDetail : class, new()
|
||
{
|
||
//设置用户默认值
|
||
entity.SetCreateDefaultVal();
|
||
SetAuditDefaultValue(entity);
|
||
if (validationEntity)
|
||
{
|
||
Response = entity.ValidationEntity();
|
||
if (CheckResponseResult()) return Response;
|
||
if (list != null && list.Count > 0)
|
||
{
|
||
Response = list.ValidationEntity();
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
}
|
||
var logicDelEntityProperty = GetLogicDelProperty<T>();
|
||
if (logicDelEntityProperty != null)
|
||
{
|
||
logicDelEntityProperty.SetValue(entity, ((int)DelStatus.正常).ChangeType(logicDelEntityProperty.PropertyType));
|
||
}
|
||
entity.SetTenancyValue().SetValue();
|
||
|
||
if (AddOnExecuting != null)
|
||
{
|
||
Response = AddOnExecuting(entity, list);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
entity.CreateCode<T>();
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
SetEntityValue(entity);
|
||
repository.AddWithSetIdentity(entity);
|
||
|
||
//repository.DbContext.SaveChanges();
|
||
//保存明细
|
||
if (list != null && list.Count > 0)
|
||
{
|
||
|
||
//过滤逻辑删除
|
||
var logicDelProperty = GetLogicDelProperty<TDetail>();
|
||
//获取保存后的主键值
|
||
PropertyInfo mainKey = typeof(T).GetKeyProperty();
|
||
PropertyInfo detailMainKey = typeof(TDetail).GetProperties()
|
||
.Where(q => q.Name.ToLower() == mainKey.Name.ToLower()).FirstOrDefault();
|
||
object keyValue = mainKey.GetValue(entity);
|
||
|
||
//adams 2023.5.30
|
||
PropertyInfo detailKey = typeof(TDetail).GetKeyProperty();
|
||
var idWorker = new Utilities.IdWorker();
|
||
list.ForEach(x =>
|
||
{
|
||
//adams 2023.6.17
|
||
if (detailKey.PropertyType == typeof(string))
|
||
{
|
||
detailKey.SetValue(x, idWorker.NextId().ToString());
|
||
}
|
||
else if (detailKey.PropertyType == typeof(long) && AppSetting.UseSnow)
|
||
{
|
||
detailKey.SetValue(x, idWorker.NextId());
|
||
}
|
||
if (logicDelProperty != null)
|
||
{
|
||
logicDelProperty.SetValue(x, ((int)DelStatus.正常).ChangeType(logicDelProperty.PropertyType));
|
||
}
|
||
//设置用户默认值
|
||
x.SetCreateDefaultVal();
|
||
// detailMainKey.SetValue(x, keyValue);
|
||
SetDetailEntityValue<T, TDetail>(entity, x);
|
||
repository.AddWithSetIdentity<TDetail>(x);
|
||
//repository.DbContext.Entry<TDetail>(x).State = EntityState.Added;
|
||
});
|
||
// repository.DbContext.SaveChanges();
|
||
}
|
||
Response.OK(ResponseType.SaveSuccess);
|
||
if (AddOnExecuted != null)
|
||
Response = AddOnExecuted(entity, list);
|
||
return Response;
|
||
});
|
||
if (Response.Status && string.IsNullOrEmpty(Response.Message))
|
||
{
|
||
Response.OK(ResponseType.SaveSuccess);
|
||
}
|
||
AddProcese(entity);
|
||
//审计日志
|
||
WriteAtionLog(ActionChangeType.Add, entity, null, new { DetailData = list });
|
||
return Response;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置审批字段默认值
|
||
/// </summary>
|
||
/// <param name="entity"></param>
|
||
private void SetAuditDefaultValue(T entity)
|
||
{
|
||
//if (!WorkFlowManager.Exists<T>())
|
||
//{
|
||
// return;
|
||
//}
|
||
var propertity = TProperties.Where(x => x.Name.ToLower() == "auditstatus").FirstOrDefault();
|
||
if (propertity != null && propertity.GetValue(entity) == null)
|
||
{
|
||
propertity.SetValue(entity, 0);
|
||
}
|
||
}
|
||
///// <summary>
|
||
///// 写入流程
|
||
///// </summary>
|
||
///// <typeparam name="T"></typeparam>
|
||
///// <param name="entity"></param>
|
||
///// <param name="changeTableStatus">是否修改原表的审批状态</param>
|
||
//protected void RewriteFlow(T entity, bool changeTableStatus = true)
|
||
//{
|
||
// WorkFlowManager.AddProcese(entity, true, changeTableStatus);
|
||
//}
|
||
|
||
/// <summary>
|
||
/// 获取三级明细表
|
||
/// </summary>
|
||
/// <param name="detail"></param>
|
||
/// <returns></returns>
|
||
private Type GetSubType(Type detailType)
|
||
{
|
||
return detailType.GetCustomAttribute<EntityAttribute>()?.DetailTable?[0];
|
||
}
|
||
|
||
public bool AddProcese(T entity)
|
||
{
|
||
if (!CheckResponseResult() && WorkFlowManager.Exists<T>(WorkFlowTableName))
|
||
{
|
||
if (AddWorkFlowExecuting != null && !AddWorkFlowExecuting.Invoke(entity))
|
||
{
|
||
return false;
|
||
}
|
||
//写入流程
|
||
WorkFlowManager.AddProcese<T>(entity, addWorkFlowExecuted: AddWorkFlowExecuted, workFlowTableName: WorkFlowTableName);
|
||
return true;
|
||
// WorkFlowManager.Audit<T>(entity, AuditStatus.待审批, null, null, null, null, init: true, initInvoke: AddWorkFlowExecuted);
|
||
}
|
||
return false;
|
||
}
|
||
/// <summary>
|
||
/// 提交审批数据 2023.11.12
|
||
/// </summary>
|
||
/// <param name="id"></param>
|
||
/// <param name="msg"></param>
|
||
/// <param name="flowWriteState"></param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent SubmitWorkFlowAudit(object[] ids)
|
||
{
|
||
Expression<Func<T, bool>> whereExpression = typeof(T).GetKeyName().CreateExpression<T>(ids, LinqExpressionType.In);
|
||
var list = repository.FindAsIQueryable(whereExpression).ToList();
|
||
if (list.Count != ids.Length)
|
||
{
|
||
return Response.Error($"未查到数据,或者数据已被删除");
|
||
}
|
||
var auditProperty = GetAuditProperty();
|
||
if (auditProperty == null)
|
||
{
|
||
return Response.Error("表缺少审核状态字段：AuditStatus");
|
||
}
|
||
foreach (var entity in list)
|
||
{
|
||
int val = auditProperty.GetValue(entity).GetInt();
|
||
if (val != (int)AuditStatus.草稿 && val != (int)AuditStatus.待提交)
|
||
{
|
||
return Response.Error("只能提交[草稿]或[待提交]数据", true);
|
||
}
|
||
}
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
foreach (var entity in list)
|
||
{
|
||
WorkFlowManager.AddProcese<T>(entity, addWorkFlowExecuted: AddWorkFlowExecuted, checkId: true, workFlowTableName: WorkFlowTableName);
|
||
auditProperty.SetValue(entity, (int)AuditStatus.待审核);
|
||
repository.Update(entity, new string[] { auditProperty.Name });
|
||
}
|
||
repository.SaveChanges();
|
||
return Response.OK("提交成功", true);
|
||
//return
|
||
});
|
||
return Response;
|
||
}
|
||
|
||
public void AddDetailToDBSet<TDetail>() where TDetail : class
|
||
{
|
||
List<PropertyInfo> listChilds = TProperties.Where(x => x.PropertyType.Name == "List`1").ToList();
|
||
// repository.DbContext.Set<TDetail>().AddRange();
|
||
}
|
||
/// <summary>
|
||
/// 一对多新建功能
|
||
/// </summary>
|
||
/// <param name="saveDataModel"></param>
|
||
/// <returns></returns>
|
||
private WebResponseContent AddMultipleDetail(SaveModel saveDataModel)
|
||
{
|
||
Response.OK();
|
||
T mainEntity = saveDataModel.MainData.DicToEntity<T>();
|
||
SetAuditDefaultValue(mainEntity);
|
||
|
||
var tables = typeof(T).GetCustomAttribute<EntityAttribute>().DetailTable;
|
||
for (int i = 0; i < saveDataModel.Details.Count; i++)
|
||
{
|
||
DetailInfo detailInfo = saveDataModel.Details[i];
|
||
if (detailInfo.Data == null && detailInfo.Data.Count == 0)
|
||
{
|
||
continue;
|
||
}
|
||
Type type = tables.Where(c => c.Name == detailInfo.Table).FirstOrDefault();
|
||
if (type == null)
|
||
{
|
||
return Response.Error($"未找到明细表[{detailInfo.Table}],请重新配置主表的明细表");
|
||
}
|
||
Type subType = GetSubType(type);
|
||
string reslut = null;
|
||
if (subType == null)
|
||
{
|
||
//验证明细
|
||
reslut = type.ValidateDicInEntity(detailInfo.Data, true, false, new string[] { TProperties.GetKeyName() });
|
||
}
|
||
else
|
||
{
|
||
//验证明细
|
||
reslut = type.ValidateDicInEntity(detailInfo.Data, true, false, new string[] { TProperties.GetKeyName(), subType.Name });
|
||
//验证三级明细表
|
||
if (string.IsNullOrEmpty(reslut))
|
||
{
|
||
ValidateSubDicInEntity(subType, detailInfo.Data);
|
||
if (!Response.Status)
|
||
{
|
||
return Response;
|
||
}
|
||
}
|
||
}
|
||
var logicDelProperty = GetLogicDelProperty(type);
|
||
if (logicDelProperty != null)
|
||
{
|
||
foreach (var item in detailInfo.Data)
|
||
{
|
||
item.TryAdd(logicDelProperty.Name, ((int)DelStatus.正常).ToString());
|
||
}
|
||
}
|
||
|
||
if (reslut != string.Empty)
|
||
{
|
||
return Response.Error($"{type.GetEntityTableCnName()}:{reslut}");
|
||
}
|
||
//一对多设置明细表数据
|
||
typeof(ServiceBase<T, TRepository>).GetMethod("SetEntityDetail", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { type })
|
||
.Invoke(this, new object[] { mainEntity, detailInfo.Data, null, subType != null });
|
||
}
|
||
mainEntity.SetTenancyValue().SetValue();
|
||
mainEntity.CreateCode();
|
||
if (AddOnExecuting != null)
|
||
{
|
||
Response = AddOnExecuting(mainEntity, null);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
repository.AddWithSetIdentity(mainEntity);
|
||
Type[] detailTypes = typeof(T).GetCustomAttribute<EntityAttribute>().DetailTable;
|
||
foreach (var item in detailTypes)
|
||
{
|
||
Type subType = item.GetCustomAttribute<EntityAttribute>()?.DetailTable?[0] ?? item;
|
||
typeof(ServiceBase<T, TRepository>).GetMethod("InsertNav", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { item, subType })
|
||
.Invoke(this, new object[] { mainEntity });
|
||
}
|
||
|
||
if (AddOnExecuted != null)
|
||
Response = AddOnExecuted(mainEntity, null);
|
||
return Response;
|
||
});
|
||
if (Response.Status && string.IsNullOrEmpty(Response.Message))
|
||
{
|
||
Response.OK(ResponseType.SaveSuccess);
|
||
}
|
||
AddProcese(mainEntity);
|
||
var propertyKey = typeof(T).GetKeyProperty();
|
||
// saveDataModel.MainData[propertyKey.Name] = propertyKey.GetValue(mainEntity);
|
||
Response.Data = new { data = mainEntity };
|
||
return Response;
|
||
}
|
||
/// <summary>
|
||
/// 设置主表的主键值
|
||
/// </summary>
|
||
/// <typeparam name="Main"></typeparam>
|
||
/// <typeparam name="Detail"></typeparam>
|
||
/// <param name="entity"></param>
|
||
/// <param name="detailEntity"></param>
|
||
private void SetEntityValue(T entity)
|
||
{
|
||
var mainType = typeof(T);
|
||
var mainProperty = mainType.GetKeyProperty();
|
||
if ((mainProperty.PropertyType == typeof(long) && AppSetting.UseSnow) || mainProperty.PropertyType == typeof(string))
|
||
{
|
||
var idWork = new Utilities.IdWorker();
|
||
//adams 2023.11.8
|
||
var att = mainProperty.GetCustomAttribute<MaxLengthAttribute>();
|
||
if ((mainProperty.PropertyType == typeof(string)) && (att != null) && (att.Length == 38))
|
||
{
|
||
mainProperty.SetValue(entity, (idWork.NextId()).ToString());
|
||
return;
|
||
}
|
||
else if (mainProperty.PropertyType == typeof(string))
|
||
{
|
||
object value = mainProperty.GetValue(entity);
|
||
if (value?.ToString()?.Trim() == "")
|
||
{
|
||
mainProperty.SetValue(entity, Guid.NewGuid().ToString());
|
||
}
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
|
||
mainProperty.SetValue(entity, idWork.NextId());
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 设置二三级表新建数据的主键值
|
||
/// </summary>
|
||
/// <typeparam name="Main"></typeparam>
|
||
/// <typeparam name="Detail"></typeparam>
|
||
/// <param name="entity"></param>
|
||
/// <param name="detailEntity"></param>
|
||
private void SetDetailEntityValue<Main, Detail>(Main entity, Detail detailEntity)
|
||
{
|
||
var detailProperty = typeof(Detail).GetKeyProperty();
|
||
|
||
var mainType = typeof(Main);
|
||
//主表主键字段
|
||
var mainKeyValue = mainType.GetKeyProperty().GetValue(entity);
|
||
|
||
var mainKeyPro = typeof(Detail).GetProperty(mainType.GetKeyProperty().Name);
|
||
mainKeyPro.SetValue(detailEntity, mainKeyValue);
|
||
|
||
if ((detailProperty.PropertyType == typeof(long) && AppSetting.UseSnow) || detailProperty.PropertyType == typeof(string))
|
||
{
|
||
//adams 2023.11.18
|
||
var att = detailProperty.GetCustomAttribute<MaxLengthAttribute>();
|
||
var idWork = new Utilities.IdWorker();
|
||
if ((detailProperty.PropertyType == typeof(string)) && (att != null) && (att.Length == 38))
|
||
{
|
||
detailProperty.SetValue(detailEntity, idWork.NextId().ToString());
|
||
return;
|
||
}
|
||
else if (detailProperty.PropertyType == typeof(string))
|
||
{
|
||
detailProperty.SetValue(detailEntity, Guid.NewGuid().ToString());
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
detailProperty.SetValue(detailEntity, idWork.NextId());
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 二级明细插入
|
||
/// </summary>
|
||
/// <typeparam name="Detail"></typeparam>
|
||
/// <param name="insertNav"></param>
|
||
/// <param name="name"></param>
|
||
private void InsertNav<Detail, SubDetail>(T mainEntity)
|
||
where Detail : class, new()
|
||
where SubDetail : class, new()
|
||
{
|
||
var obj = typeof(T).GetProperty(typeof(Detail).Name).GetValue(mainEntity);
|
||
if (obj == null)
|
||
{
|
||
return;
|
||
}
|
||
List<Detail> details = obj as List<Detail>;
|
||
if (details == null || details.Count == 0)
|
||
{
|
||
return;
|
||
}
|
||
foreach (var detail in details)
|
||
{
|
||
SetDetailEntityValue<T, Detail>(mainEntity, detail);
|
||
repository.AddWithSetIdentity<Detail>(detail);
|
||
obj = typeof(Detail).GetProperty(typeof(SubDetail).Name)?.GetValue(detail);
|
||
if (obj == null)
|
||
{
|
||
continue;
|
||
}
|
||
List<SubDetail> subDetails = obj as List<SubDetail>;
|
||
if (subDetails == null || subDetails.Count == 0)
|
||
{
|
||
continue;
|
||
}
|
||
foreach (var sub in subDetails)
|
||
{
|
||
SetDetailEntityValue<Detail, SubDetail>(detail, sub);
|
||
repository.AddWithSetIdentity<SubDetail>(sub);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 验证三级明细
|
||
/// </summary>
|
||
/// <param name="subType"></param>
|
||
/// <param name="data"></param>
|
||
private void ValidateSubDicInEntity(Type subType, List<Dictionary<string, object>> data)
|
||
{
|
||
if (!data.Any(x => x.ContainsKey(subType.Name)))
|
||
{
|
||
return;
|
||
}
|
||
var user = UserContext.Current.UserInfo;
|
||
foreach (var item in data)
|
||
{
|
||
if (!item.TryGetValue(subType.Name, out object value) || value == null)
|
||
{
|
||
continue;
|
||
}
|
||
List<Dictionary<string, object>> list = new List<Dictionary<string, object>>();
|
||
foreach (JObject jObject in (JArray)value)
|
||
{
|
||
Dictionary<string, object> dict = new Dictionary<string, object>();
|
||
foreach (var property in jObject.Properties())
|
||
{
|
||
dict[property.Name] = property.Value.ToObject<object>();
|
||
}
|
||
string result = subType.ValidateDicInEntity(dict, removeNotContains: false, removerKey: false);
|
||
if (!string.IsNullOrEmpty(result))
|
||
{
|
||
Response.Error($"{subType.GetEntityTableCnName()}:{result}");
|
||
return;
|
||
}
|
||
dict.TryAdd(AppSetting.CreateMember.UserIdField, user.User_Id);
|
||
dict.TryAdd(AppSetting.CreateMember.UserNameField, user.UserTrueName);
|
||
dict.TryAdd(AppSetting.CreateMember.DateField, DateTime.Now);
|
||
list.Add(dict);
|
||
}
|
||
item[subType.Name] = list;
|
||
}
|
||
|
||
}
|
||
/// <summary>
|
||
/// 一对多设置明细表数据
|
||
/// </summary>
|
||
/// <typeparam name="TDetail"></typeparam>
|
||
/// <param name="entity"></param>
|
||
/// <param name="detailData"></param>
|
||
private void SetEntityDetail<TDetail>(T entity, List<Dictionary<string, object>> detailData, List<TDetail> list, bool hasSubDetail = false) where TDetail : class
|
||
{
|
||
bool setDefault = false;
|
||
if (list == null)
|
||
{
|
||
setDefault = true;
|
||
list = hasSubDetail
|
||
? detailData.Serialize().DeserializeObject<List<TDetail>>()
|
||
: detailData.DicToList<TDetail>();
|
||
PropertyInfo detailProperty = typeof(TDetail).GetKeyProperty();
|
||
if (detailProperty.PropertyType == typeof(long) && AppSetting.UseSnow)
|
||
{
|
||
var idWork = new Utilities.IdWorker();
|
||
var mainType = typeof(T);
|
||
var mainKeyValue = mainType.GetKeyProperty().GetValue(entity);
|
||
var mainKeyPro = typeof(TDetail).GetProperty(mainType.GetKeyProperty().Name);
|
||
foreach (var item in list)
|
||
{
|
||
detailProperty.SetValue(item, idWork.NextId());
|
||
mainKeyPro.SetValue(item, mainKeyValue);
|
||
}
|
||
}
|
||
else if (detailProperty.PropertyType == typeof(string))
|
||
{
|
||
var mainType = typeof(T);
|
||
var mainKeyValue = mainType.GetKeyProperty().GetValue(entity);
|
||
var mainKeyPro = typeof(TDetail).GetProperty(mainType.GetKeyProperty().Name);
|
||
foreach (var item in list)
|
||
{
|
||
detailProperty.SetValue(item, Guid.NewGuid().ToString());
|
||
mainKeyPro.SetValue(item, mainKeyValue);
|
||
}
|
||
}
|
||
}
|
||
PropertyInfo property = typeof(T).GetProperty(typeof(TDetail).Name);
|
||
if (setDefault)
|
||
{
|
||
foreach (var item in list)
|
||
{
|
||
//设置用户默认值
|
||
item.SetCreateDefaultVal();
|
||
}
|
||
}
|
||
property.SetValue(entity, list);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 主从表新建
|
||
/// </summary>
|
||
/// <typeparam name="TDetail"></typeparam>
|
||
/// <param name="saveDataModel"></param>
|
||
/// <returns></returns>
|
||
private WebResponseContent Add<TDetail>(SaveModel saveDataModel) where TDetail : class, new()
|
||
{
|
||
T mainEntity = saveDataModel.MainData.DicToEntity<T>();
|
||
//验证明细
|
||
string reslut = typeof(TDetail).ValidateDicInEntity(saveDataModel.DetailData, true, false, new string[] { TProperties.GetKeyName() });
|
||
if (reslut != string.Empty)
|
||
return Response.Error(reslut);
|
||
|
||
List<TDetail> list = saveDataModel.DetailData.DicToList<TDetail>();
|
||
Response = Add<TDetail>(mainEntity, list, false);
|
||
|
||
//保存失败
|
||
if (CheckResponseResult())
|
||
{
|
||
Logger.Error(LoggerType.Add, saveDataModel.Serialize() + Response.Message);
|
||
return Response;
|
||
}
|
||
|
||
PropertyInfo propertyKey = typeof(T).GetKeyProperty();
|
||
saveDataModel.MainData[propertyKey.Name] = propertyKey.GetValue(mainEntity);
|
||
Response.Data = new { data = mainEntity, list };
|
||
return Response.Set(ResponseType.SaveSuccess);
|
||
}
|
||
|
||
#region 编辑
|
||
|
||
/// <summary>
|
||
/// 获取编辑明细主键
|
||
/// </summary>
|
||
/// <typeparam name="DetailT"></typeparam>
|
||
/// <typeparam name="Tkey"></typeparam>
|
||
/// <param name="detailKeyName"></param>
|
||
/// <param name="mainKeyName"></param>
|
||
/// <param name="mainKeyValue"></param>
|
||
/// <returns></returns>
|
||
public List<Tkey> GetUpdateDetailSelectKeys<DetailT, Tkey>(string detailKeyName, string mainKeyName, string mainKeyValue) where DetailT : class, new()
|
||
{
|
||
ISugarQueryable<DetailT> queryable = repository.DbContext.Set<DetailT>();
|
||
Expression<Func<DetailT, Tkey>> selectExpression = detailKeyName.GetExpression<DetailT, Tkey>();
|
||
Expression<Func<DetailT, bool>> whereExpression = mainKeyName.CreateExpression<DetailT>(mainKeyValue, LinqExpressionType.Equal);
|
||
List<Tkey> detailKeys = queryable.Where(whereExpression).Select(selectExpression).ToList();
|
||
return detailKeys;
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 获取配置的创建人ID创建时间创建人,修改人ID修改时间、修改人与数据相同的字段
|
||
/// </summary>
|
||
private static string[] _userIgnoreFields { get; set; }
|
||
|
||
private static string[] UserIgnoreFields
|
||
{
|
||
get
|
||
{
|
||
if (_userIgnoreFields != null) return _userIgnoreFields;
|
||
List<string> fields = new List<string>();
|
||
//逻辑删除字段
|
||
if (!string.IsNullOrEmpty(AppSetting.LogicDelField))
|
||
{
|
||
fields.Add(AppSetting.LogicDelField);
|
||
}
|
||
fields.AddRange(CreateFields);
|
||
fields.AddRange(ModifyFields);
|
||
_userIgnoreFields = fields.ToArray();
|
||
return _userIgnoreFields;
|
||
}
|
||
}
|
||
private static string[] _createFields { get; set; }
|
||
private static string[] CreateFields
|
||
{
|
||
get
|
||
{
|
||
if (_createFields != null) return _createFields;
|
||
_createFields = AppSetting.CreateMember.GetType().GetProperties()
|
||
.Select(x => x.GetValue(AppSetting.CreateMember)?.ToString())
|
||
.Where(w => !string.IsNullOrEmpty(w)).ToArray();
|
||
return _createFields;
|
||
}
|
||
}
|
||
|
||
private static string[] _modifyFields { get; set; }
|
||
private static string[] ModifyFields
|
||
{
|
||
get
|
||
{
|
||
if (_modifyFields != null) return _modifyFields;
|
||
_modifyFields = AppSetting.ModifyMember.GetType().GetProperties()
|
||
.Select(x => x.GetValue(AppSetting.ModifyMember)?.ToString())
|
||
.Where(w => !string.IsNullOrEmpty(w)).ToArray();
|
||
return _modifyFields;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 编辑
|
||
/// 1、明细表必须把主表的主键字段也设置为可编辑
|
||
/// 2、修改、增加只会操作设置为编辑列的数据
|
||
/// </summary>
|
||
/// <param name="saveModel"></param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent Update(SaveModel saveModel)
|
||
{
|
||
if (UpdateOnExecute != null)
|
||
{
|
||
Response = UpdateOnExecute(saveModel);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
if (saveModel == null)
|
||
return Response.Error(ResponseType.ParametersLack);
|
||
|
||
|
||
//if (WorkFlowManager.Exists<T>())
|
||
//{
|
||
// var auditProperty = TProperties.Where(x => x.Name.ToLower() == "auditstatus").FirstOrDefault();
|
||
// string value = saveModel.MainData[auditProperty.Name]?.ToString();
|
||
// if (WorkFlowManager.GetAuditStatus<T>(value) != 1)
|
||
// {
|
||
// return Response.Error("数据已经在审批中，不能修改");
|
||
// }
|
||
//}
|
||
Type type = typeof(T);
|
||
|
||
//设置修改时间,修改人的默认值
|
||
UserInfo userInfo = UserContext.Current.UserInfo;
|
||
saveModel.SetDefaultVal(AppSetting.ModifyMember, userInfo);
|
||
|
||
|
||
//判断提交的数据与实体格式是否一致
|
||
string result = type.ValidateDicInEntity(saveModel.MainData, true, false, UserIgnoreFields, requireAllField: false);
|
||
if (result != string.Empty)
|
||
return Response.Error(result);
|
||
|
||
PropertyInfo mainKeyProperty = type.GetKeyProperty();
|
||
//adams 2023.4.29
|
||
object keyDefaultVal = "";
|
||
//获取主建类型的默认值用于判断后面数据是否正确,int long默认值为0,guid :0000-000....
|
||
//object keyDefaultVal = mainKeyProperty.PropertyType.Assembly.CreateInstance(mainKeyProperty.PropertyType.FullName);
|
||
if (mainKeyProperty.PropertyType != typeof(System.String))
|
||
keyDefaultVal = mainKeyProperty.PropertyType.Assembly.CreateInstance(mainKeyProperty.PropertyType.FullName);
|
||
//判断是否包含主键
|
||
if (mainKeyProperty == null
|
||
|| !saveModel.MainData.ContainsKey(mainKeyProperty.Name)
|
||
|| saveModel.MainData[mainKeyProperty.Name] == null
|
||
)
|
||
{
|
||
return Response.Error(ResponseType.NoKey);
|
||
}
|
||
|
||
object mainKeyVal = saveModel.MainData[mainKeyProperty.Name];
|
||
//判断主键类型是否正确
|
||
(bool, string, object) validation = mainKeyProperty.ValidationValueForDbType(mainKeyVal).FirstOrDefault();
|
||
if (!validation.Item1)
|
||
return Response.Error(ResponseType.KeyError);
|
||
|
||
object valueType = mainKeyVal.ToString().ChangeType(mainKeyProperty.PropertyType);
|
||
//判断主键值是不是当前类型的默认值
|
||
if (valueType == null ||
|
||
(!valueType.GetType().Equals(mainKeyProperty.PropertyType)
|
||
|| valueType.ToString() == keyDefaultVal.ToString()
|
||
))
|
||
return Response.Error(ResponseType.KeyError);
|
||
|
||
if (saveModel.MainData.Count <= 1) return Response.Error("系统没有配置好编辑的数据，请检查model或设置编辑行再点击生成model!");
|
||
|
||
Expression<Func<T, bool>> expression = mainKeyProperty.Name.CreateExpression<T>(mainKeyVal.ToString(), LinqExpressionType.Equal);
|
||
if (!repository.Exists(expression)) return Response.Error("保存的数据不存在!");
|
||
|
||
saveModel.DetailData = saveModel.DetailData == null
|
||
? new List<Dictionary<string, object>>()
|
||
: saveModel.DetailData.Where(x => x.Count > 0).ToList();
|
||
bool isActionLog = IsTableActionLog<T>();
|
||
//没有明细的直接保存主表数据
|
||
if (!(saveModel.DetailData.Count > 0 || saveModel.DelKeys?.Count > 0 || (saveModel.Details != null && saveModel.Details.Count > 0)))
|
||
{
|
||
saveModel.SetDefaultVal(AppSetting.ModifyMember, userInfo);
|
||
|
||
T mainEntity = saveModel.MainData.DicToEntity<T>();
|
||
CheckDataVersion(mainEntity, saveModel);
|
||
if (CheckResponseResult())
|
||
{
|
||
return Response;
|
||
}
|
||
if (UpdateOnExecuting != null)
|
||
{
|
||
Response = UpdateOnExecuting(mainEntity, null, null, null);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
T orginData = isActionLog ? repository.FindFirst(expression) : default;
|
||
//不修改!CreateFields.Contains创建人信息
|
||
repository.Update(mainEntity, type.GetEditField().Where(c => saveModel.MainData.Keys.Contains(c) && !CreateFields.Contains(c)).ToArray());
|
||
if (base.UpdateOnExecuted == null)
|
||
{
|
||
repository.SaveChanges();
|
||
Response.OK(ResponseType.SaveSuccess);
|
||
}
|
||
else
|
||
{
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
repository.SaveChanges();
|
||
Response = UpdateOnExecuted(mainEntity, null, null, null);
|
||
return Response;
|
||
});
|
||
}
|
||
if (Response.Status) Response.Data = new { data = mainEntity };
|
||
if (Response.Status && string.IsNullOrEmpty(Response.Message))
|
||
Response.OK(ResponseType.SaveSuccess);
|
||
if (Response.Status && isActionLog)
|
||
{
|
||
WriteAtionLog(ActionChangeType.Update, orginData, repository.FindFirst(expression), saveModel);
|
||
}
|
||
return Response;
|
||
}
|
||
|
||
return UpdateMultipleDetail(saveModel, mainKeyProperty, keyDefaultVal, expression, isActionLog);
|
||
}
|
||
|
||
#endregion
|
||
|
||
/// <summary>
|
||
/// 提交的数据版号检测
|
||
/// </summary>
|
||
/// <param name="entity"></param>
|
||
/// <param name="saveModel"></param>
|
||
private void CheckDataVersion(T entity, SaveModel saveModel)
|
||
{
|
||
Response.Status = true;
|
||
if (string.IsNullOrEmpty(saveModel.DataVersionField) || string.IsNullOrEmpty(saveModel.DataVersionValue))
|
||
{
|
||
return;
|
||
}
|
||
var versionProperty = typeof(T).GetProperty(saveModel.DataVersionField);
|
||
if (versionProperty == null)
|
||
{
|
||
return;
|
||
}
|
||
var keyProperty = typeof(T).GetKeyProperty();
|
||
object keyValue = keyProperty.GetValue(entity);
|
||
var where = keyProperty.Name.CreateExpression<T>(keyValue, LinqExpressionType.Equal);
|
||
var selectExpression = saveModel.DataVersionField.GetExpression<T, string>();
|
||
string dataVersionValue = repository.FindAsIQueryable(where).Select(selectExpression).FirstOrDefault();
|
||
if (string.IsNullOrEmpty(dataVersionValue))
|
||
{
|
||
return;
|
||
}
|
||
if (dataVersionValue != saveModel.DataVersionValue)
|
||
{
|
||
Response.Error("数据已发生变化,请刷新页面后重新编辑".Translator());
|
||
}
|
||
string value = Guid.NewGuid().ToString();
|
||
versionProperty.SetValue(entity, value);
|
||
saveModel.MainData[saveModel.DataVersionField] = value;
|
||
}
|
||
|
||
|
||
|
||
/// <summary>
|
||
/// 一对多编辑功能
|
||
/// </summary>
|
||
/// <param name="saveDataModel"></param>
|
||
/// <returns></returns>
|
||
private WebResponseContent UpdateMultipleDetail(SaveModel saveModel, PropertyInfo mainKeyProperty, object keyDefaultVal, Expression<Func<T, bool>> expression, bool isActionLog)
|
||
{
|
||
T orginData = isActionLog ? repository.FindFirst(expression) : default;
|
||
Response.OK();
|
||
bool isMultipleDetail = false;
|
||
var entity = saveModel.MainData.DicToEntity<T>();
|
||
CheckDataVersion(entity, saveModel);
|
||
if (CheckResponseResult())
|
||
{
|
||
return Response;
|
||
}
|
||
List<DetailInfo> details = new List<DetailInfo>();
|
||
//一对多细明
|
||
if (saveModel.Details != null && saveModel.Details.Count > 0)
|
||
{
|
||
details = saveModel.Details;
|
||
isMultipleDetail = true;
|
||
// return UpdateMultipleDetail(saveModel);
|
||
}
|
||
else
|
||
{
|
||
//主从明细
|
||
Type detailType = GetRealDetailType();
|
||
details.Add(new DetailInfo()
|
||
{
|
||
Data = saveModel.DetailData,
|
||
DelKeys = saveModel.DelKeys,
|
||
//adams 2023.11.18 修改中表别名的不兼容
|
||
//Table = detailType.GetEntityTableName()
|
||
Table = detailType.Name
|
||
});
|
||
}
|
||
|
||
CreateSubDel(saveModel);
|
||
|
||
//判断明细是否包含了主表的主键
|
||
var detailTypes = typeof(T).GetCustomAttribute<EntityAttribute>().DetailTable;
|
||
|
||
int index = 0;
|
||
foreach (var item in details)
|
||
{
|
||
var detailType = detailTypes.Where(c => c.Name == item.Table).FirstOrDefault();
|
||
var detailKeyInfo = detailType.GetKeyProperty();
|
||
|
||
|
||
//adams 2023.10.31
|
||
string deatilDefaultVal;
|
||
if (detailKeyInfo.PropertyType == typeof(string))
|
||
deatilDefaultVal = "";
|
||
else
|
||
deatilDefaultVal = detailKeyInfo.PropertyType.Assembly.CreateInstance(detailKeyInfo.PropertyType.FullName).ToString();
|
||
|
||
string result = detailType.ValidateDicInEntity(item.Data, false, false, ignoreFields: [mainKeyProperty.Name]);
|
||
if (!string.IsNullOrEmpty(result))
|
||
{
|
||
return Response.Error($"{detailType.GetEntityTableCnName()}:{result}");
|
||
}
|
||
|
||
Type subType = GetSubType(detailType);
|
||
if (subType != null)
|
||
{
|
||
//验证三级明细表
|
||
ValidateSubDicInEntity(subType, item.Data);
|
||
if (!Response.Status)
|
||
{
|
||
return Response;
|
||
}
|
||
}
|
||
|
||
foreach (Dictionary<string, object> dic in item.Data)
|
||
{
|
||
//不包含主键的默认添加主键默认值，用于后面判断是否为新增数据
|
||
if (!dic.ContainsKey(detailKeyInfo.Name))
|
||
{
|
||
dic.Add(detailKeyInfo.Name, keyDefaultVal);
|
||
if (dic.ContainsKey(mainKeyProperty.Name))
|
||
{
|
||
dic[mainKeyProperty.Name] = keyDefaultVal;
|
||
}
|
||
else
|
||
{
|
||
dic.Add(mainKeyProperty.Name, keyDefaultVal);
|
||
}
|
||
continue;
|
||
}
|
||
if (dic[detailKeyInfo.Name] == null)
|
||
return Response.Error(ResponseType.NoKey);
|
||
|
||
//主键值是否正确
|
||
string detailKeyVal = dic[detailKeyInfo.Name].ToString();
|
||
if (detailKeyInfo.PropertyType != typeof(string) && (!detailKeyInfo.ValidationValueForDbType(detailKeyVal).FirstOrDefault().Item1
|
||
|| deatilDefaultVal == detailKeyVal))
|
||
return Response.Error(ResponseType.KeyError);
|
||
|
||
////判断主表的值是否正确
|
||
//if (detailKeyVal != keyDefaultVal.ToString() && (!dic.ContainsKey(mainKeyProperty.Name) || dic[mainKeyProperty.Name] == null || dic[mainKeyProperty.Name].ToString() == keyDefaultVal.ToString()))
|
||
//{
|
||
// return Response.Error($"[{mainKeyProperty.Name.Translator()}]{"是必填项".Translator()}");
|
||
//}
|
||
if (saveModel.DetailData.Exists(c => c.Count <= 2))
|
||
{
|
||
return Response.Error("系统没有配置好明细编辑的数据，请检查model,或者明细表点击生成model!");
|
||
}
|
||
|
||
}
|
||
index++;
|
||
this.GetType().GetMethod("UpdateToEntity")
|
||
.MakeGenericMethod(new Type[] { detailType })
|
||
.Invoke(this, new object[] {
|
||
entity,
|
||
saveModel.MainData,
|
||
item.Data,
|
||
item.DelKeys,
|
||
mainKeyProperty,
|
||
detailKeyInfo,
|
||
keyDefaultVal,
|
||
index == details.Count,
|
||
isMultipleDetail,
|
||
subType
|
||
});
|
||
}
|
||
if (Response.Status && isActionLog)
|
||
{
|
||
WriteAtionLog(ActionChangeType.Update, orginData, repository.FindFirst(expression), saveModel);
|
||
}
|
||
return Response;
|
||
}
|
||
|
||
private List<MultipleTableEntity> multipleTableEntities = null;
|
||
|
||
|
||
/// <summary>
|
||
/// 将数据转换成对象后最终保存
|
||
/// </summary>
|
||
/// <typeparam name="DetailT"></typeparam>
|
||
/// <param name="saveModel"></param>
|
||
/// <param name="mainKeyProperty"></param>
|
||
/// <param name="detailKeyInfo"></param>
|
||
/// <param name="keyDefaultVal"></param>
|
||
/// <returns></returns>
|
||
public void UpdateToEntity<DetailT>(
|
||
T mainEntity,
|
||
Dictionary<string, object> mainData,
|
||
List<Dictionary<string, object>> detailData,
|
||
List<object> detailDelKeys,
|
||
PropertyInfo mainKeyProperty,
|
||
PropertyInfo detailKeyInfo,
|
||
object keyDefaultVal,
|
||
bool save,
|
||
bool isMultipleDetail,
|
||
Type subType
|
||
) where DetailT : class
|
||
{
|
||
if (multipleTableEntities == null)
|
||
{
|
||
multipleTableEntities = new List<MultipleTableEntity>();
|
||
}
|
||
// T mainEntity = saveModel.MainData.DicToEntity<T>();
|
||
List<DetailT> detailList = subType != null
|
||
? detailData.Serialize().DeserializeObject<List<DetailT>>()
|
||
: detailData.DicToList<DetailT>();
|
||
|
||
//新增对象
|
||
List<DetailT> addList = new List<DetailT>();
|
||
// List<object> containsKeys = new List<object>();
|
||
//编辑对象
|
||
List<DetailT> editList = new List<DetailT>();
|
||
//删除的主键
|
||
List<object> delKeys = new List<object>();
|
||
Type detailType = typeof(DetailT);
|
||
mainKeyProperty = detailType.GetProperties().Where(x => x.Name == mainKeyProperty.Name).FirstOrDefault();
|
||
//获取新增与修改的对象
|
||
foreach (DetailT item in detailList)
|
||
{
|
||
object value = detailKeyInfo.GetValue(item);
|
||
if (keyDefaultVal.Equals(value))//主键为默认值的,新增数据
|
||
{
|
||
//设置新增的主表的值
|
||
//mainKeyProperty.SetValue(item,
|
||
// mainData[mainKeyProperty.Name]
|
||
// .ChangeType(mainKeyProperty.PropertyType));
|
||
|
||
//if (detailKeyInfo.PropertyType == typeof(Guid))
|
||
//{
|
||
// detailKeyInfo.SetValue(item, Guid.NewGuid());
|
||
//}
|
||
SetDetailEntityValue<T, DetailT>(mainEntity, item);
|
||
addList.Add(item);
|
||
}
|
||
else //if (detailKeys.Contains(value))
|
||
{
|
||
editList.Add(item);
|
||
}
|
||
}
|
||
|
||
//获取需要删除的对象的主键
|
||
if (detailDelKeys != null && detailDelKeys.Count > 0)
|
||
{
|
||
//2021.08.21优化明细表删除
|
||
delKeys = detailDelKeys.Select(q => q.ChangeType(detailKeyInfo.PropertyType)).Where(x => x != null).ToList();
|
||
//.Where(x => detailKeys.Contains(x.ChangeType(detailKeyInfo.PropertyType)))
|
||
//.Select(q => q.ChangeType(detailKeyInfo.PropertyType)).ToList();
|
||
}
|
||
|
||
if (editList.Count > 0)
|
||
{
|
||
//明细修改
|
||
editList.ForEach(x =>
|
||
{
|
||
//設置默認值
|
||
x.SetModifyDefaultVal();
|
||
//添加修改字段
|
||
|
||
// repository.Update<DetailT>(x, updateField.ToArray());
|
||
});
|
||
//获取编辑的字段
|
||
var updateField = detailData
|
||
.Where(c => c[detailKeyInfo.Name].ChangeType(detailKeyInfo.PropertyType)
|
||
.Equal(detailKeyInfo.GetValue(editList[0])))
|
||
.FirstOrDefault()
|
||
.Keys.Where(k => k != detailKeyInfo.Name)
|
||
.Where(r => !CreateFields.Contains(r) && r != subType?.Name)
|
||
.ToList();
|
||
updateField.AddRange(ModifyFields);
|
||
//if (subType != null)
|
||
//{
|
||
// updateField.Add(subType.Name);
|
||
//}
|
||
multipleTableEntities.Add(new MultipleTableEntity()
|
||
{
|
||
Type = detailType,
|
||
List = editList,
|
||
Flag = TableFlag.Update,
|
||
Fields = updateField,
|
||
SubType = subType
|
||
});
|
||
}
|
||
|
||
|
||
if (addList.Count > 0)
|
||
{
|
||
var idWork = new Utilities.IdWorker();
|
||
if (detailKeyInfo.PropertyType == typeof(long) && AppSetting.UseSnow)
|
||
{
|
||
foreach (var item in addList)
|
||
{
|
||
detailKeyInfo.SetValue(item, idWork.NextId());
|
||
}
|
||
}
|
||
else if (detailKeyInfo.PropertyType == typeof(string))
|
||
{
|
||
//adams 2023.11.18 雪花算法
|
||
var att = detailKeyInfo.GetCustomAttribute<MaxLengthAttribute>();
|
||
|
||
foreach (var item in addList)
|
||
{
|
||
if ((detailKeyInfo.PropertyType == typeof(string)) && (att != null) && (att.Length == 38))
|
||
detailKeyInfo.SetValue(item, idWork.NextId().ToString());
|
||
else
|
||
detailKeyInfo.SetValue(item, Guid.NewGuid().ToString());
|
||
}
|
||
}
|
||
PropertyInfo lgProperty = detailType.GetProperty(AppSetting.LogicDelField ?? "");
|
||
//明细新增
|
||
addList.ForEach(x =>
|
||
{
|
||
x.SetCreateDefaultVal();
|
||
|
||
if (lgProperty != null)
|
||
{
|
||
lgProperty.SetValue(x, ((int)DelStatus.正常).ChangeType(lgProperty.PropertyType));
|
||
}
|
||
|
||
// repository.DbContext.Entry<DetailT>(x).State = EntityState.Added;
|
||
});
|
||
|
||
multipleTableEntities.Add(new MultipleTableEntity()
|
||
{
|
||
Type = detailType,
|
||
List = addList,
|
||
Flag = TableFlag.Add,
|
||
SubType = subType
|
||
});
|
||
}
|
||
|
||
//明细删除
|
||
if (delKeys.Count > 0)
|
||
{
|
||
//delKeys.ForEach(x =>
|
||
//{
|
||
// DetailT delT = Activator.CreateInstance<DetailT>();
|
||
// detailKeyInfo.SetValue(delT, x);
|
||
// repository.DbContext.Entry<DetailT>(delT).State = EntityState.Deleted;
|
||
//});
|
||
|
||
multipleTableEntities.Add(new MultipleTableEntity()
|
||
{
|
||
Type = detailType,
|
||
List = delKeys,
|
||
Flag = TableFlag.Del
|
||
});
|
||
}
|
||
|
||
//多个明细表时，记录明细表数据
|
||
//一对多设置明细表数据
|
||
if (isMultipleDetail)
|
||
{
|
||
var list = new List<DetailT>();
|
||
list.AddRange(editList);
|
||
list.AddRange(addList);
|
||
typeof(ServiceBase<T, TRepository>).GetMethod("SetEntityDetail", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { detailType })
|
||
.Invoke(this, new object[] { mainEntity, null, list, false });
|
||
}
|
||
|
||
//不保存直接返回
|
||
if (!save)
|
||
{
|
||
return;
|
||
}
|
||
|
||
//2023.07.11调整更新前方法
|
||
if (UpdateOnExecuting != null)
|
||
{
|
||
//多明细表从mainEntity与SaveModel.Details中取数据
|
||
//mainEntity为主表与明细表数据，SaveModel.Details中取删除的数据
|
||
if (isMultipleDetail)
|
||
{
|
||
Response = UpdateOnExecuting(mainEntity, null, null, null);
|
||
}
|
||
else
|
||
{
|
||
Response = UpdateOnExecuting(mainEntity, addList, editList, delKeys);
|
||
if (addList.Count > 0 && !multipleTableEntities.Exists(x => x.Flag == TableFlag.Add))
|
||
{
|
||
multipleTableEntities.Add(new MultipleTableEntity()
|
||
{
|
||
Type = detailType,
|
||
List = addList,
|
||
Flag = TableFlag.Add
|
||
});
|
||
}
|
||
|
||
if (editList.Count > 0 && !multipleTableEntities.Exists(x => x.Flag == TableFlag.Update))
|
||
{
|
||
var updateField = detailData.SelectMany(x => x.Keys).Distinct().Where(k => k != detailKeyInfo.Name)
|
||
.Where(r => !CreateFields.Contains(r) && r != subType?.Name)
|
||
.ToList();
|
||
updateField.AddRange(ModifyFields);
|
||
multipleTableEntities.Add(new MultipleTableEntity()
|
||
{
|
||
Type = detailType,
|
||
List = editList,
|
||
Fields = updateField,
|
||
Flag = TableFlag.Update
|
||
});
|
||
}
|
||
}
|
||
if (CheckResponseResult())
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
|
||
//最后一个明细执行保存
|
||
|
||
|
||
//if (UpdateOnExecuted == null)
|
||
//{
|
||
// SetMultipleTableEntities();
|
||
// repository.DbContext.SaveChanges();
|
||
// Response.OK(ResponseType.SaveSuccess);
|
||
//}
|
||
//else
|
||
//{
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
mainEntity.SetModifyDefaultVal();
|
||
//主表修改
|
||
//不修改!CreateFields.Contains创建人信息
|
||
repository.Update(mainEntity, typeof(T).GetEditField()
|
||
.Where(c => mainData.Keys.Contains(c) && !CreateFields.Contains(c))
|
||
.ToArray(), true);
|
||
|
||
SetMultipleTableEntities();
|
||
repository.DbContext.SaveChanges();
|
||
|
||
//多明细表从mainEntity与SaveModel.Details中取数据
|
||
//mainEntity为主表与明细表数据，SaveModel.Details中取删除的数据
|
||
if (UpdateOnExecuted != null)
|
||
{
|
||
if (isMultipleDetail)
|
||
{
|
||
Response = UpdateOnExecuted(mainEntity, null, null, null);
|
||
}
|
||
else
|
||
{
|
||
Response = UpdateOnExecuted(mainEntity, addList, editList, delKeys);
|
||
}
|
||
}
|
||
return Response;
|
||
});
|
||
// }
|
||
if (Response.Status)
|
||
{
|
||
addList.AddRange(editList);
|
||
Response.Data = new { data = mainEntity, list = addList };
|
||
if (string.IsNullOrEmpty(Response.Message))
|
||
Response.OK(ResponseType.SaveSuccess);
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 2023.09.10增加主从、一对多编辑时可修改原对象属性
|
||
/// </summary>
|
||
private void SetMultipleTableEntities()
|
||
{
|
||
if (multipleTableEntities == null || multipleTableEntities.Count == 0)
|
||
{
|
||
return;
|
||
}
|
||
foreach (var item in multipleTableEntities)
|
||
{
|
||
typeof(ServiceBase<T, TRepository>).GetMethod("EntryDbContextMultipleTableEntities", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { item.Type })
|
||
.Invoke(this, new object[] { item });
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 2023.09.10增加主从、一对多编辑时可修改原对象属性
|
||
/// </summary>
|
||
/// <typeparam name="Detail"></typeparam>
|
||
/// <param name="multipleTable"></param>
|
||
private void EntryDbContextMultipleTableEntities<Detail>(MultipleTableEntity multipleTable) where Detail : class, new()
|
||
{
|
||
if (multipleTable.Flag == TableFlag.Add)
|
||
{
|
||
foreach (var detail in (List<Detail>)multipleTable.List)
|
||
{
|
||
detail.SetCreateDefaultVal();
|
||
repository.AddWithSetIdentity<Detail>(detail);
|
||
}
|
||
if (multipleTable.SubType != null)
|
||
{
|
||
typeof(ServiceBase<T, TRepository>).GetMethod("EntryDbContextSubType", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { multipleTable.SubType, typeof(Detail) })
|
||
.Invoke(this, new object[] { multipleTable.List });
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (multipleTable.Flag == TableFlag.Update)
|
||
{
|
||
repository.UpdateRange((List<Detail>)multipleTable.List, multipleTable.Fields.ToArray());
|
||
if (multipleTable.SubType != null)
|
||
{
|
||
// 设置三级明细表
|
||
typeof(ServiceBase<T, TRepository>).GetMethod("EntryDbContextSubType", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { multipleTable.SubType, typeof(Detail) })
|
||
.Invoke(this, new object[] { multipleTable.List });
|
||
}
|
||
//repository.DbContext.Entry<Detail>(x).State = EntityState.Added;
|
||
|
||
return;
|
||
}
|
||
var detailKeyInfo = typeof(Detail).GetKeyProperty();
|
||
var list = (List<object>)multipleTable.List;
|
||
if (list.Count() > 0)
|
||
{
|
||
typeof(ServiceBase<T, TRepository>)
|
||
.GetMethod("DelDetails", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { typeof(Detail), detailKeyInfo.PropertyType })
|
||
.Invoke(this, new object[] { list.ToArray(), typeof(Detail).GetKeyName() });
|
||
}
|
||
//foreach (var key in (List<object>)multipleTable.List)
|
||
//{
|
||
// Detail delT = Activator.CreateInstance<Detail>();
|
||
// detailKeyInfo.SetValue(delT, key);
|
||
// repository.Delete<Detail>(delT, false);
|
||
// // repository.DbContext.Entry<Detail>(delT).State = EntityState.Deleted;
|
||
//}
|
||
}
|
||
/// <summary>
|
||
/// 设置三级明细表
|
||
/// </summary>
|
||
/// <typeparam name="TSub"></typeparam>
|
||
/// <typeparam name="Detail"></typeparam>
|
||
/// <param name="list"></param>
|
||
private void EntryDbContextSubType<TSub, Detail>(List<Detail> list) where TSub : class, new()
|
||
{
|
||
string subTableName = typeof(TSub).Name;
|
||
var subKeyPeroperty = typeof(TSub).GetKeyProperty();
|
||
|
||
var subProperty = typeof(Detail).GetProperty(subTableName);
|
||
var updateFields = typeof(TSub).GetProperties().Where(x =>
|
||
x.Name != subKeyPeroperty.Name
|
||
&& x.Name != subProperty.Name
|
||
&& !CreateFields.Contains(x.Name))
|
||
.Select(s => s.Name);
|
||
foreach (var item in list)
|
||
{
|
||
var obj = subProperty.GetValue(item);
|
||
if (obj == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
foreach (var sub in (List<TSub>)obj)
|
||
{
|
||
string value = subKeyPeroperty.GetValue(sub)?.ToString();
|
||
|
||
if (string.IsNullOrEmpty(value) || value == "0" || value == Guid.Empty.ToString())
|
||
{
|
||
sub.SetCreateDefaultVal();
|
||
// repository.Add(sub);
|
||
//新加的数据
|
||
SetDetailEntityValue<Detail, TSub>(item, sub);
|
||
repository.AddWithSetIdentity<TSub>(sub);
|
||
}
|
||
else
|
||
{
|
||
sub.SetModifyDefaultVal();
|
||
repository.Update<TSub>(sub, updateFields.ToArray());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 三级明细删除
|
||
/// </summary>
|
||
private void CreateSubDel(SaveModel saveModel)
|
||
{
|
||
if (saveModel.SubDelInfo == null || saveModel.SubDelInfo.Count == 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
var detailTypes = typeof(T).GetCustomAttribute<EntityAttribute>()?.DetailTable;
|
||
if (detailTypes == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
foreach (var item in detailTypes)
|
||
{
|
||
var subTypes = item.GetCustomAttribute<EntityAttribute>()?.DetailTable;
|
||
if (subTypes != null)
|
||
{
|
||
foreach (var type in subTypes)
|
||
{
|
||
typeof(ServiceBase<T, TRepository>).GetMethod("CreateSubDelContext", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { type })
|
||
.Invoke(this, new object[] { saveModel, type.Name });
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 三级表删除
|
||
/// </summary>
|
||
/// <typeparam name="TSub"></typeparam>
|
||
/// <param name="saveModel"></param>
|
||
/// <param name="tableName"></param>
|
||
private void CreateSubDelContext<TSub>(SaveModel saveModel, string tableName) where TSub : class, new()
|
||
{
|
||
foreach (var item in saveModel.SubDelInfo.Where(x => !x.IsProescc && x.Table == tableName))
|
||
{
|
||
item.IsProescc = true;
|
||
var keyPro = typeof(TSub).GetKeyProperty();
|
||
foreach (var key in item.DelKeys)
|
||
{
|
||
TSub entity = Activator.CreateInstance<TSub>();
|
||
keyPro.SetValue(entity, key.ChangeType(keyPro.PropertyType));
|
||
// repository.DbContext.Entry<TSub>(entity).State = EntityState.Deleted;
|
||
repository.Delete(entity);
|
||
}
|
||
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
///
|
||
/// </summary>
|
||
/// <param name="keys"></param>
|
||
/// <param name="delList">是否删除明细数据(默认会删除明细)</param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent Del(object[] keys, bool delList = true)
|
||
{
|
||
Type entityType = typeof(T);
|
||
var keyProperty = entityType.GetKeyProperty();
|
||
if (keyProperty == null || keys == null || keys.Length == 0) return Response.Error(ResponseType.NoKeyDel);
|
||
|
||
IEnumerable<(bool, string, object)> validation = keyProperty.ValidationValueForDbType(keys);
|
||
if (validation.Any(x => !x.Item1))
|
||
{
|
||
return Response.Error(validation.Where(x => !x.Item1).Select(s => s.Item2 + "</br>").Serialize());
|
||
}
|
||
string tKey = keyProperty.Name;
|
||
if (string.IsNullOrEmpty(tKey))
|
||
return Response.Error("没有主键不能删除");
|
||
|
||
if (DelOnExecuting != null)
|
||
{
|
||
Response = DelOnExecuting(keys);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
PropertyInfo lgProperty = entityType.GetProperty(AppSetting.LogicDelField ?? "");
|
||
//逻辑删除
|
||
if (lgProperty != null)
|
||
{
|
||
LogicDel(keys, keyProperty, lgProperty);
|
||
return Response;
|
||
}
|
||
// FieldType fieldType = entityType.GetFieldType();
|
||
//string joinKeys = (fieldType == FieldType.Int || fieldType == FieldType.BigInt)
|
||
// ? string.Join(",", keys)
|
||
// : $"'{string.Join("','", keys)}'";
|
||
|
||
// 2020.08.15添加判断多租户数据（删除）
|
||
if (IsMultiTenancy && !UserContext.Current.IsSuperAdmin)
|
||
{
|
||
// CheckDelMultiTenancy(joinKeys, tKey);
|
||
if (CheckResponseResult())
|
||
{
|
||
return Response;
|
||
}
|
||
}
|
||
|
||
var logicDelProperty = GetLogicDelProperty<T>();
|
||
//逻辑删除
|
||
if (logicDelProperty != null)
|
||
{
|
||
return LogicDel(keys, keyProperty, logicDelProperty);
|
||
}
|
||
//可能在删除后还要做一些其它数据库新增或删除操作，这样就可能需要与删除保持在同一个事务中处理
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
// repository.SqlSugarClient.Deleteable<T>().In(keys).ExecuteCommand();
|
||
typeof(ServiceBase<T, TRepository>)
|
||
.GetMethod("DelDetails", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { entityType, keyProperty.PropertyType })
|
||
.Invoke(this, new object[] { keys, keyProperty.Name });
|
||
if (delList)
|
||
{
|
||
var types = entityType.GetCustomAttribute<EntityAttribute>()?.DetailTable;
|
||
if (types != null)
|
||
{
|
||
foreach (var type in types)
|
||
{
|
||
typeof(ServiceBase<T, TRepository>)
|
||
.GetMethod("DelDetails", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { type, keyProperty.PropertyType })
|
||
.Invoke(this, new object[] { keys, keyProperty.Name });
|
||
}
|
||
}
|
||
}
|
||
if (DelOnExecuted != null)
|
||
{
|
||
Response = DelOnExecuted(keys);
|
||
}
|
||
return Response;
|
||
});
|
||
string tableName = entityType.GetEntityTableName();
|
||
if (!string.IsNullOrEmpty(WorkFlowTableName))
|
||
{
|
||
tableName = WorkFlowTableName;
|
||
}
|
||
//是否有流程
|
||
if (WorkFlowManager.Exists(tableName))
|
||
{
|
||
//删除进入流程的数据
|
||
var ids = keys.Select(s => s.ToString()).ToList();
|
||
DbManger.SysDbContext.Deleteable<Sys_WorkFlowTable>()
|
||
.Where(x => x.WorkTable == tableName && ids.Contains(x.WorkTableKey)).ExecuteCommand();
|
||
}
|
||
if (Response.Status && string.IsNullOrEmpty(Response.Message)) Response.OK(ResponseType.DelSuccess);
|
||
return Response;
|
||
}
|
||
|
||
private void DelDetails<Entity, KeyType>(object[] keys, string keyName = null) where Entity : class, new()
|
||
{
|
||
var values = keys.Select(s => (KeyType)(s.ChangeType(typeof(KeyType)))).ToList();
|
||
if (string.IsNullOrEmpty(keyName))
|
||
{
|
||
keyName = typeof(T).GetKeyName();
|
||
}
|
||
var expression = keyName.CreateExpression<Entity>(values, LinqExpressionType.In);
|
||
if (IsTableActionLog<Entity>())
|
||
{
|
||
WriteAtionLog<Entity>(repository.DbContext.Set<Entity>().Where(expression).ToList(), ActionChangeType.Delete);
|
||
}
|
||
repository.DbContext.Deleteable<Entity>().Where(expression).ExecuteCommand();
|
||
}
|
||
private object[] GetLogicDelIds<TKey>(object[] keys, PropertyInfo keyProperty)
|
||
{
|
||
var keyCondition = keyProperty.Name.CreateExpression<T>(keys, LinqExpressionType.In);
|
||
var selectExp = keyProperty.Name.GetExpression<T, TKey>();
|
||
return repository.FindAsIQueryable(keyCondition).Select(selectExp).ToArray().Select(s => s as object).ToArray();
|
||
}
|
||
/// <summary>
|
||
/// 明细表逻辑删除
|
||
/// </summary>
|
||
/// <typeparam name="Entity"></typeparam>
|
||
/// <typeparam name="KeyType"></typeparam>
|
||
/// <param name="keys"></param>
|
||
private void LogicDelDetails<Entity, KeyType>(object[] keys, PropertyInfo keyProperty) where Entity : class, new()
|
||
{
|
||
var values = keys.Select(s => (KeyType)(s.ChangeType(typeof(KeyType)))).ToList();
|
||
var expression = keyProperty.Name.CreateExpression<Entity>(values, LinqExpressionType.In);
|
||
|
||
repository.SqlSugarClient.Updateable<Entity>()
|
||
.SetColumns(AppSetting.LogicDelField, (int)DelStatus.已删除)
|
||
.Where(expression)
|
||
.ExecuteCommand();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 逻辑删除
|
||
/// </summary>
|
||
/// <param name="keys"></param>
|
||
/// <param name="keyProperty"></param>
|
||
/// <param name="logicDelProperty"></param>
|
||
/// <returns></returns>
|
||
private WebResponseContent LogicDel(object[] keys, PropertyInfo keyProperty, PropertyInfo logicDelProperty)
|
||
{
|
||
keys = typeof(ServiceBase<T, TRepository>).GetMethod("GetLogicDelIds", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { keyProperty.PropertyType })
|
||
.Invoke(this, new object[] { keys, keyProperty }) as object[];
|
||
List<T> delList = new List<T>();
|
||
|
||
foreach (object key in keys)
|
||
{
|
||
var entity = Activator.CreateInstance<T>();
|
||
keyProperty.SetValue(entity, key.ChangeType(keyProperty.PropertyType));
|
||
logicDelProperty.SetValue(entity, ((int)DelStatus.已删除).ChangeType(logicDelProperty.PropertyType));
|
||
delList.Add(entity);
|
||
}
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
repository.UpdateRange(delList, new string[] { logicDelProperty.Name }, true);
|
||
|
||
var types = typeof(T).GetCustomAttribute<EntityAttribute>()?.DetailTable;
|
||
if (types != null && types.Length > 0)
|
||
{
|
||
foreach (var detailType in types)
|
||
{
|
||
var logPro = GetLogicDelProperty(detailType);
|
||
if (logPro != null)
|
||
{
|
||
typeof(ServiceBase<T, TRepository>)
|
||
.GetMethod("LogicDelDetails", BindingFlags.Instance | BindingFlags.NonPublic)
|
||
.MakeGenericMethod(new Type[] { detailType, keyProperty.PropertyType })
|
||
.Invoke(this, new object[] { keys, keyProperty });
|
||
}
|
||
}
|
||
}
|
||
if (DelOnExecuted != null)
|
||
{
|
||
return DelOnExecuted(keys);
|
||
}
|
||
return Response.OK("删除成功".Translator());
|
||
});
|
||
return Response;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
///
|
||
/// </summary>
|
||
/// <param name="id">表数据id</param>
|
||
/// <param name="msg">重写流程的日志信息</param>
|
||
/// <param name="flowWriteState">重新开始或回退到上一级节点</param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent RestartWorkFlowAudit(object id, string msg, FlowWriteState flowWriteState = FlowWriteState.重新开始)
|
||
{
|
||
Expression<Func<T, bool>> whereExpression = typeof(T).GetKeyName().CreateExpression<T>(id, LinqExpressionType.Equal);
|
||
T entity = repository.FindAsIQueryable(whereExpression).FirstOrDefault();
|
||
if (entity == null)
|
||
{
|
||
return Response.Error($"未查到数据,或者数据已被删除,id:{id}");
|
||
}
|
||
return WorkFlowManager.Audit<T>(repository.BaseDbContext, entity, AuditStatus.审核未通过, msg, autditProperty: GetAuditProperty(), flowWriteState: flowWriteState, workFlowTableName: WorkFlowTableName);
|
||
}
|
||
|
||
private PropertyInfo GetAuditProperty()
|
||
{
|
||
return TProperties.Where(x => x.Name.ToLower() == "auditstatus").FirstOrDefault();
|
||
}
|
||
/// <summary>
|
||
/// 审批实际使用的表名(解决视图新建数据时实时调用原表新建进入不了流程的问题2024.01.01)
|
||
/// </summary>
|
||
public string WorkFlowTableName { get; set; }
|
||
/// <summary>
|
||
/// 审核默认对应数据库字段为AuditId审核人ID ,AuditStatus审核状态,Auditor审核人,Auditdate审核时间,Auditreason审核原因
|
||
/// </summary>
|
||
/// <param name="keys"></param>
|
||
/// <param name="auditStatus"></param>
|
||
/// <param name="auditReason"></param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent Audit(object[] keys, int? auditStatus, string auditReason)
|
||
{
|
||
if (keys == null || keys.Length == 0)
|
||
return Response.Error("未获取到参数!");
|
||
|
||
Expression<Func<T, bool>> whereExpression = typeof(T).GetKeyName().CreateExpression<T>(keys[0], LinqExpressionType.Equal);
|
||
T entity = repository.FindAsIQueryable(whereExpression).FirstOrDefault();
|
||
if (entity == null)
|
||
{
|
||
return Response.Error($"未查到数据,或者数据已被删除,id:{keys[0]}");
|
||
}
|
||
var auditProperty = GetAuditProperty();
|
||
// var auditProperty = TProperties.Where(x => x.Name.ToLower() == "auditstatus").FirstOrDefault();
|
||
if (auditProperty == null)
|
||
{
|
||
return Response.Error("表缺少审核状态字段：AuditStatus");
|
||
}
|
||
//进入流程审批
|
||
if (WorkFlowManager.Exists<T>(entity, WorkFlowTableName))
|
||
{
|
||
AuditStatus status = (AuditStatus)Enum.Parse(typeof(AuditStatus), auditStatus.ToString());
|
||
int val = auditProperty.GetValue(entity).GetInt();
|
||
if (!(val == (int)AuditStatus.待审核 || val == (int)AuditStatus.审核中))
|
||
{
|
||
return Response.Error("只能审批[待审核或审核中]的数据");
|
||
}
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
return WorkFlowManager.Audit<T>(repository.BaseDbContext,
|
||
entity, status, auditReason,
|
||
auditProperty, AuditWorkFlowExecuting, AuditWorkFlowExecuted,
|
||
workFlowTableName: WorkFlowTableName);
|
||
});
|
||
if (Response.Status)
|
||
{
|
||
return Response.OK(ResponseType.AuditSuccess);
|
||
}
|
||
return Response.Error(Response.Message ?? "审批失败");
|
||
}
|
||
|
||
|
||
//获取主键
|
||
PropertyInfo property = TProperties.GetKeyProperty();
|
||
if (property == null)
|
||
return Response.Error("没有配置好主键!");
|
||
|
||
UserInfo userInfo = UserContext.Current.UserInfo;
|
||
|
||
//表如果有审核相关字段，设置默认审核
|
||
List<string> updateFileds = null;
|
||
List<T> auditList = new List<T>();
|
||
foreach (var value in keys)
|
||
{
|
||
object convertVal = value.ToString().ChangeType(property.PropertyType);
|
||
if (convertVal == null) continue;
|
||
|
||
entity = Activator.CreateInstance<T>();
|
||
property.SetValue(entity, convertVal);
|
||
updateFileds = WorkFlowGeneric.UpdateAuditInfo<T>(entity, auditStatus ?? 0, auditReason);
|
||
auditList.Add(entity);
|
||
}
|
||
if (base.AuditOnExecuting != null)
|
||
{
|
||
Response = AuditOnExecuting(auditList);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
Response = repository.DbContextBeginTransaction(() =>
|
||
{
|
||
//2023.11.26增加审批日志
|
||
WorkFlowManager.AddAuditLog<T>(keys, auditStatus, auditReason);
|
||
repository.UpdateRange(auditList, updateFileds.ToArray(), true);
|
||
if (base.AuditOnExecuted != null)
|
||
{
|
||
Response = AuditOnExecuted(auditList);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
return Response.OK();
|
||
});
|
||
if (Response.Status)
|
||
{
|
||
return Response.OK(ResponseType.AuditSuccess);
|
||
}
|
||
return Response.Error(Response.Message);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 撤销审批
|
||
/// </summary>
|
||
/// <param name="keys"></param>
|
||
/// <param name="status">1=撤销，-1终止</param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent CancelAudit(AntiData antiData, int status)
|
||
{
|
||
if (antiData.Key == null)
|
||
{
|
||
return Response.Error($"未获取到主键".Translator());
|
||
}
|
||
object[] keys = antiData.Key.Serialize().DeserializeObject<object[]>();
|
||
Expression<Func<T, bool>> whereExpression = typeof(T).GetKeyName().CreateExpression<T>(keys, LinqExpressionType.In);
|
||
var list = repository.FindAsIQueryable(whereExpression).ToList();
|
||
if (list.Count == 0)
|
||
{
|
||
return Response.Error($"未查到数据,或者数据已被删除".Translator());
|
||
}
|
||
|
||
var auditProperty = GetAuditProperty();
|
||
if (!WorkFlowGeneric.CheckAudting(list, auditProperty))
|
||
{
|
||
return Response.Error($"只能操作审批中的数据".Translator());
|
||
}
|
||
//foreach (var entity in list)
|
||
//{
|
||
// int value= auditProperty.GetValue(entity).GetInt();
|
||
// if (value!=(int)AuditStatus.审核中&& value != (int)AuditStatus.待审核)
|
||
// {
|
||
// return Response.Error($"只能操作审批中的数据".Translator());
|
||
// }
|
||
//}
|
||
|
||
|
||
WebResponseContent webResponse = null;
|
||
string msg = $"[{UserContext.Current.UserTrueName}]{(status == -1 ? "终止了流程" : "撤销了流程").Translator()}";
|
||
if (!string.IsNullOrEmpty(antiData.AuditReason))
|
||
{
|
||
antiData.AuditReason = $"{msg}:{antiData.AuditReason}";
|
||
}
|
||
|
||
foreach (var entity in list)
|
||
{
|
||
var data = new AntiData()
|
||
{
|
||
AuditReason = antiData.AuditReason,
|
||
IsFlow = true
|
||
};
|
||
if (status == -1)
|
||
{
|
||
webResponse = WorkFlowManager.Audit<T>(repository.BaseDbContext, entity, AuditStatus.终止, antiData.AuditReason, auditProperty, null, null, workFlowTableName: WorkFlowTableName, flowWriteState: FlowWriteState.终止);
|
||
}
|
||
else
|
||
{
|
||
webResponse = WorkFlowManager.AntiAudit<T>(data, repository.BaseDbContext, entity, WorkFlowTableName, restart: true, isAnti: false, msg: antiData.AuditReason);
|
||
}
|
||
if (!webResponse.Status)
|
||
{
|
||
return webResponse;
|
||
}
|
||
}
|
||
return webResponse.OK("操作成功".Translator());
|
||
}
|
||
/// <summary>
|
||
/// 催办
|
||
/// </summary>
|
||
/// <param name="keys"></param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent UrgentAudit(object[] keys)
|
||
{
|
||
WorkFlowManager.SendMessage<T>(keys, WorkFlowTableName);
|
||
return Response.OK("发送成功".Translator());
|
||
}
|
||
|
||
/// <summary>
|
||
/// 反审2023.11.26
|
||
/// </summary>
|
||
/// <param name="keys"></param>
|
||
/// <param name="auditStatus"></param>
|
||
/// <param name="auditReason"></param>
|
||
/// <returns></returns>
|
||
public virtual WebResponseContent AntiAudit(AntiData antiData)
|
||
{
|
||
if (antiData.Key == null)
|
||
return Response.Error("未获取到参数!");
|
||
|
||
Expression<Func<T, bool>> whereExpression = typeof(T).GetKeyName().CreateExpression<T>(antiData.IsFlow ? antiData.Key : antiData.Key.ToString().Split(",")[0], LinqExpressionType.Equal);
|
||
T entity = repository.FindAsIQueryable(whereExpression).FirstOrDefault();
|
||
if (entity == null)
|
||
{
|
||
return Response.Error($"未查到数据,或者数据已被删除,id:{antiData.Key}");
|
||
}
|
||
var auditProperty = GetAuditProperty();
|
||
// var auditProperty = TProperties.Where(x => x.Name.ToLower() == "auditstatus").FirstOrDefault();
|
||
if (auditProperty == null)
|
||
{
|
||
return Response.Error("表缺少审核状态字段：AuditStatus");
|
||
}
|
||
antiData.IsFlow = WorkFlowManager.Exists<T>(entity);
|
||
if (!antiData.IsFlow)
|
||
{
|
||
int val = auditProperty.GetValue(entity).GetInt();
|
||
if ((val == (int)AuditStatus.待审核 || val == (int)AuditStatus.草稿 || val == (int)AuditStatus.待提交))
|
||
{
|
||
return Response.Error("只能选择已审核数据");
|
||
}
|
||
}
|
||
Response.OK("反审成功".Translator());
|
||
|
||
if (base.AntiAuditOnExecuting != null)
|
||
{
|
||
Response = AntiAuditOnExecuting(entity);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
//审批流程返审
|
||
if (antiData.IsFlow)
|
||
{
|
||
Response = WorkFlowManager.AntiAudit<T>(antiData, repository.BaseDbContext, entity, WorkFlowTableName);
|
||
if (!Response.Status)
|
||
{
|
||
return Response;
|
||
}
|
||
//RestartWorkFlowAudit(antiData.Key, $"[{UserContext.Current.UserTrueName}]反审了数据", FlowWriteState.重新开始);
|
||
}
|
||
else
|
||
{
|
||
auditProperty.SetValue(entity, (int)AuditStatus.待审核);
|
||
var updateFileds = WorkFlowGeneric.UpdateAuditInfo<T>(entity, (int)AuditStatus.待审核, antiData.AuditReason);
|
||
repository.SqlSugarClient.Update(entity, updateFileds.ToArray(), true);
|
||
WorkFlowManager.AddAuditLog<T>(new object[] { antiData.Key }, (int)AuditStatus.待审核, "反审：" + (antiData.AuditReason ?? ""));
|
||
}
|
||
if (base.AntiAuditOnExecuted != null)
|
||
{
|
||
Response = AntiAuditOnExecuted(entity);
|
||
if (CheckResponseResult()) return Response;
|
||
}
|
||
return Response;
|
||
}
|
||
|
||
|
||
public virtual (string, T, bool) ApiValidate(string bizContent, Expression<Func<T, object>> expression = null)
|
||
{
|
||
return ApiValidateInput<T>(bizContent, expression);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 对指定类与api的参数进行验证
|
||
/// </summary>
|
||
/// <typeparam name="TInput"></typeparam>
|
||
/// <param name="bizContent"></param>
|
||
/// <param name="input"></param>
|
||
/// <param name="expression">对指属性验证</param>
|
||
/// <returns>(string,TInput, bool) string:返回验证消息,TInput：bizContent序列化后的对象,bool:验证是否通过</returns>
|
||
public virtual (string, TInput, bool) ApiValidateInput<TInput>(string bizContent, Expression<Func<TInput, object>> expression)
|
||
{
|
||
return ApiValidateInput(bizContent, expression, null);
|
||
}
|
||
|
||
/// <summary>
|
||
///
|
||
/// </summary>
|
||
/// <typeparam name="TInput"></typeparam>
|
||
/// <param name="bizContent"></param>
|
||
/// <param name="expression">对指属性验证格式如：x=>new { x.UserName,x.Value }</param>
|
||
/// <param name="validateExpression">对指定的字段只做合法性判断比如长度是是否超长</param>
|
||
/// <returns>(string,TInput, bool) string:返回验证消息,TInput：bizContent序列化后的对象,bool:验证是否通过</returns>
|
||
public virtual (string, TInput, bool) ApiValidateInput<TInput>(string bizContent, Expression<Func<TInput, object>> expression, Expression<Func<TInput, object>> validateExpression)
|
||
{
|
||
try
|
||
{
|
||
TInput input = JsonConvert.DeserializeObject<TInput>(bizContent);
|
||
if (!(input is System.Collections.IList))
|
||
{
|
||
Response = input.ValidationEntity(expression, validateExpression);
|
||
return (Response.Message, input, Response.Status);
|
||
}
|
||
System.Collections.IList list = input as System.Collections.IList;
|
||
for (int i = 0; i < list.Count; i++)
|
||
{
|
||
Response = list[i].ValidationEntity(expression?.GetExpressionProperty(),
|
||
validateExpression?.GetExpressionProperty());
|
||
if (CheckResponseResult())
|
||
return (Response.Message, default(TInput), false);
|
||
}
|
||
return ("", input, true);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Response.Status = false;
|
||
Response.Message = ApiMessage.ParameterError;
|
||
Logger.Error(LoggerType.HandleError, bizContent, null, ex.Message);
|
||
}
|
||
return (Response.Message, default(TInput), Response.Status);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 将数据源映射到新的数据中,目前只支持List<TSource>映射到List<TResult>或TSource映射到TResult
|
||
/// 目前只支持Dictionary或实体类型
|
||
/// </summary>
|
||
/// <typeparam name="TSource"></typeparam>
|
||
/// <typeparam name="TResult"></typeparam>
|
||
/// <param name="source"></param>
|
||
/// <param name="resultExpression">只映射返回对象的指定字段</param>
|
||
/// <param name="sourceExpression">只映射数据源对象的指定字段</param>
|
||
/// 过滤条件表达式调用方式：List表达式x => new { x[0].MenuName, x[0].Menu_Id}，表示指定映射MenuName,Menu_Id字段
|
||
/// List<Sys_Menu> list = new List<Sys_Menu>();
|
||
/// list.MapToObject<List<Sys_Menu>, List<Sys_Menu>>(x => new { x[0].MenuName, x[0].Menu_Id}, null);
|
||
///
|
||
///过滤条件表达式调用方式：实体表达式x => new { x.MenuName, x.Menu_Id}，表示指定映射MenuName,Menu_Id字段
|
||
/// Sys_Menu sysMenu = new Sys_Menu();
|
||
/// sysMenu.MapToObject<Sys_Menu, Sys_Menu>(x => new { x.MenuName, x.Menu_Id}, null);
|
||
/// <returns></returns>
|
||
public virtual TResult MapToEntity<TSource, TResult>(TSource source, Expression<Func<TResult, object>> resultExpression,
|
||
Expression<Func<TSource, object>> sourceExpression = null) where TResult : class
|
||
{
|
||
return source.MapToObject<TSource, TResult>(resultExpression, sourceExpression);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 将一个实体的赋到另一个实体上,应用场景：
|
||
/// 两个实体，a a1= new a();b b1= new b(); a1.P=b1.P; a1.Name=b1.Name;
|
||
/// </summary>
|
||
/// <typeparam name="TSource"></typeparam>
|
||
/// <typeparam name="TResult"></typeparam>
|
||
/// <param name="source"></param>
|
||
/// <param name="result"></param>
|
||
/// <param name="expression">指定对需要的字段赋值,格式x=>new {x.Name,x.P},返回的结果只会对Name与P赋值</param>
|
||
public virtual void MapValueToEntity<TSource, TResult>(TSource source, TResult result, Expression<Func<TResult, object>> expression = null) where TResult : class
|
||
{
|
||
source.MapValueToEntity<TSource, TResult>(result, expression);
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 2021.07.04增加code="-1"强制返回，具体使用见：后台开发文档->后台基础代码扩展实现
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private bool CheckResponseResult()
|
||
{
|
||
return !Response.Status || Response.Code == "-1";
|
||
}
|
||
|
||
private PropertyInfo GetLogicDelProperty<TLg>()
|
||
{
|
||
|
||
return GetLogicDelProperty(typeof(TLg));
|
||
}
|
||
|
||
private PropertyInfo GetLogicDelProperty(Type type)
|
||
{
|
||
if (string.IsNullOrEmpty(AppSetting.LogicDelField))
|
||
{
|
||
return null;
|
||
}
|
||
return type.GetProperty(AppSetting.LogicDelField ?? "");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 审计日志
|
||
/// </summary>
|
||
private void WriteAtionLog(ActionChangeType changeType, T data, T changedData = null, object requestParameter = null)
|
||
{
|
||
if (!IsTableActionLog<T>()) return;
|
||
HttpContext.Current.GetService<ActionChangeLog>().Write<T>(changeType, data, changedData, requestParameter.Serialize());
|
||
}
|
||
private void WriteAtionLog<Entity>(List<Entity> list, ActionChangeType changeType) where Entity : class
|
||
{
|
||
// if (!IsTableActionLog<Entity>()) return;
|
||
HttpContext.Current.GetService<ActionChangeLog>().WriteRange<Entity>(changeType, list);
|
||
}
|
||
private bool IsTableActionLog<Entity>()
|
||
{
|
||
string table = typeof(Entity).GetEntityTableName();
|
||
return TableColumnContext.TableInfo.Any(x => x.TableTrueName == table && x.ActionLog == 1);
|
||
}
|
||
}
|
||
|
||
public enum DelStatus
|
||
{
|
||
正常 = 0,
|
||
已删除 = 1
|
||
}
|
||
public enum TableFlag
|
||
{
|
||
Add = 1,
|
||
Update = 2,
|
||
Del = 3
|
||
}
|
||
public class MultipleTableEntity
|
||
{
|
||
|
||
public Type Type { get; set; }
|
||
public object List { get; set; }
|
||
|
||
public TableFlag Flag { get; set; }
|
||
|
||
public List<string> Fields { get; set; }
|
||
|
||
public Type SubType { get; set; }
|
||
|
||
public List<string> SubFields { get; set; }
|
||
}
|
||
}
|