4398 lines
192 KiB
C#
4398 lines
192 KiB
C#
using APT.Infrastructure.Core;
|
||
using APT.Infrastructure.Core.Extensions;
|
||
using APT.Infrastructure.Utility;
|
||
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.EntityFrameworkCore.ChangeTracking;
|
||
using Microsoft.EntityFrameworkCore.Infrastructure;
|
||
using Microsoft.EntityFrameworkCore.Storage;
|
||
using StackExchange.Redis;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.ComponentModel;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Linq.Expressions;
|
||
using System.Reflection;
|
||
using System.Runtime.CompilerServices;
|
||
using System.Text;
|
||
using System.Threading.Tasks;
|
||
using System.Linq.Dynamic.Core;
|
||
//using Npgsql;
|
||
using System.Collections;
|
||
using APT.Infrastructure.Core.Refctor;
|
||
using Castle.Core.Internal;
|
||
using System.Collections.ObjectModel;
|
||
using System.Text.RegularExpressions;
|
||
using Microsoft.EntityFrameworkCore.Internal;
|
||
using APT.Infrastructure.Api.Redis;
|
||
using System.Collections.Concurrent;
|
||
using System.Linq.Dynamic.Core;
|
||
using APT.Infrastructure.Api;
|
||
|
||
namespace APT.Infrastructure.EF
|
||
{
|
||
|
||
public class Repository : IRepository
|
||
{
|
||
private readonly IUnitOfWork _unitOfWork;
|
||
private DataBaseType _dataBaseType = DataBaseType.SQL;
|
||
private const string dbsRedisKey = "DbConn_RedisKey";
|
||
public Repository(IUnitOfWork unitOfWork)
|
||
{
|
||
this._unitOfWork = unitOfWork;
|
||
//this._dbContext = (DbContext)unitOfWork;
|
||
_dataBaseType = unitOfWork.GetDataBaseType();
|
||
|
||
}
|
||
|
||
private string DesKey
|
||
{
|
||
get
|
||
{
|
||
var desKey = APT.Infrastructure.Api.ConfigurationManager.AppSettings["ConnDataKey"];
|
||
if (string.IsNullOrEmpty(desKey))
|
||
desKey = "optenergy2021001";
|
||
return desKey;
|
||
}
|
||
}
|
||
public IUnitOfWork UnitOfWork { get { return this._unitOfWork; } }
|
||
|
||
|
||
public void AddEntity<T>(T entity, bool isSave = true) where T : MesEntityBase, new()
|
||
{
|
||
if (entity == null)
|
||
return;
|
||
List<T> list = new List<T>();
|
||
list.Add(entity);
|
||
this.AddEntities<T>(list, isSave);
|
||
}
|
||
|
||
public T AddAndGetEntity<T>(T entity, bool isSave = true) where T : MesEntityBase, new()
|
||
{
|
||
if (entity == null)
|
||
return null;
|
||
List<T> list = new List<T>();
|
||
List<UpdateCodeSerialInfo> updateSerialInfos = new List<UpdateCodeSerialInfo>();
|
||
var type = typeof(T);
|
||
if (Api.AppContext.CurrentSession.RootOrgId != null && type.GetAttribute<RootOrgAttribute>() != null)
|
||
{
|
||
entity.ORG_ID = Api.AppContext.CurrentSession.RootOrgId;
|
||
}
|
||
list.Add(entity);
|
||
var sysParams = GetSysParams(list);
|
||
CheckUnique(list, null);
|
||
var nowTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
this.UpdateSerialUsedStatus(list, 0, updateSerialInfos);
|
||
var userId = Api.AppContext.CurrentSession != null ? Api.AppContext.CurrentSession.UserID : null;
|
||
entity.CREATE_TIME = nowTime;
|
||
entity.MODIFY_TIME = nowTime;
|
||
entity.CREATER_ID = userId;
|
||
entity.MODIFIER_ID = userId;
|
||
this.FillAcronymFieldData(list);
|
||
var dbEntity = this.UnitOfWork.AddEntity<T>(entity);
|
||
this.SaveSysParams(sysParams);
|
||
//DoSetIsLeaf(list, null, true);
|
||
this.ExcuteUpdateSerialInfos(updateSerialInfos);
|
||
if (isSave)
|
||
this.UnitOfWork.SaveChanges();
|
||
SetRedis(entity, RedisHanddle.Add);
|
||
return dbEntity;
|
||
}
|
||
|
||
public T AddAndGetEntity_noneBase<T>(T entity) where T : class
|
||
{
|
||
if (entity == null)
|
||
return null;
|
||
|
||
var dbEntity = this.UnitOfWork.AddEntity(entity);
|
||
this.UnitOfWork.SaveChanges();
|
||
return dbEntity;
|
||
}
|
||
|
||
|
||
public void AddEntities_noneBase<T>(IEnumerable<T> entities) where T : class
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
this.UnitOfWork.AddEntities<T>(entities);
|
||
this.UnitOfWork.SaveChanges();
|
||
|
||
}
|
||
|
||
public T GetEntity_noneBase<T>(Expression<Func<T, bool>> expressions) where T : class
|
||
{
|
||
var entity = this.UnitOfWork.GetEntity<T>(expressions, null);
|
||
return entity;
|
||
}
|
||
|
||
public List<T> GetEntities_noneBase<T>(Expression<Func<T, bool>> expressions) where T : class
|
||
{
|
||
var entities = this.UnitOfWork.GetEntities(expressions, null);
|
||
return entities.ToList();
|
||
}
|
||
|
||
public void UpdateEntities_noneBase<T>(IEnumerable<T> entities) where T : class
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
|
||
this.UnitOfWork.UpdateEntities<T>(entities);
|
||
this.UnitOfWork.SaveChanges();
|
||
|
||
}
|
||
|
||
public void DeleteEntity_noneBase<T>(Expression<Func<T, bool>> expression) where T : class
|
||
{
|
||
var entities = this.UnitOfWork.GetEntities<T>(expression, null);
|
||
if (entities.Any())
|
||
{
|
||
UnitOfWork.DeleteEntities<T>(entities);
|
||
this.UnitOfWork.SaveChanges();
|
||
}
|
||
}
|
||
|
||
#region nocomit
|
||
|
||
public void AddEntityNoCommit<T>(T entity) where T : MesEntityBase, new()
|
||
{
|
||
if (entity == null)
|
||
return;
|
||
List<T> list = new List<T>();
|
||
list.Add(entity);
|
||
this.AddEntitiesNoCommit<T>(list);
|
||
}
|
||
|
||
public void AddEntitiesNoCommit<T>(IEnumerable<T> entities) where T : MesEntityBase, new()
|
||
{
|
||
AddEntities(entities, false);
|
||
}
|
||
|
||
|
||
public void UpdateEntitiesNoCommit<T>(IEnumerable<T> entities) where T : MesEntityBase, new()
|
||
{
|
||
this.UpdateEntities(entities, false);
|
||
}
|
||
|
||
public bool UpdateEntityNoCommit<T>(T entity, params string[] updateField) where T : MesEntityBase, new()
|
||
{
|
||
return this.UpdateEntity(entity, false, updateField);
|
||
}
|
||
|
||
|
||
public void UpdateEntitiesNoCommit<T>(IEnumerable<T> entities, params string[] updateField) where T : MesEntityBase, new()
|
||
{
|
||
this.UpdateEntities(entities, false, updateField);
|
||
}
|
||
|
||
//private void InitIsLeaf<T>(IEnumerable<T> entities, List<Guid> delteIds) where T : MesEntityBase, new()
|
||
//{
|
||
// var def = entities.FirstOrDefault();
|
||
// if (def != null && def is MesTreeEntityBase)
|
||
// {
|
||
// List<Guid> addParentIds = new List<Guid>();
|
||
// List<Guid> deleteParentIds = new List<Guid>();
|
||
// //DoSetIsLeafByUpdate(entities, addParentIds, deleteParentIds, delteIds);
|
||
// deleteParentIds.RemoveAll(i => addParentIds.Contains(i));
|
||
|
||
// if (addParentIds.Any())
|
||
// {
|
||
// MethodInfo methodInfo = this.GetType().GetMethod("SetParentIsLeaf",
|
||
// BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
|
||
// methodInfo.MakeGenericMethod(new Type[] { entities.FirstOrDefault().GetType() }).
|
||
// Invoke(this, new object[] { addParentIds, null, true });
|
||
// }
|
||
// if (deleteParentIds.Any())
|
||
// {
|
||
// MethodInfo methodInfo = this.GetType().GetMethod("SetParentIsLeaf",
|
||
// BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
|
||
// methodInfo.MakeGenericMethod(new Type[] { entities.FirstOrDefault().GetType() }).
|
||
// Invoke(this, new object[] { deleteParentIds, delteIds, false });
|
||
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
public void DeleteEntityNoCommit<T>(Expression<Func<T, bool>> expression) where T : MesEntityBase, new()
|
||
{
|
||
var entities = this.UnitOfWork.GetEntities<T>(expression, null);
|
||
if (entities.Any())
|
||
{
|
||
foreach (var e in entities)
|
||
{
|
||
SetRedis(e, RedisHanddle.Delete);
|
||
}
|
||
this.DeleteEntitiesNoCommit(entities);
|
||
}
|
||
}
|
||
|
||
public void DeleteEntityNoCommit<T>(T entity) where T : MesEntityBase, new()
|
||
{
|
||
this.DeleteEntityNoCommit<T>(i => i.ID == entity.ID);
|
||
}
|
||
|
||
public void DeleteEntityNoCommit<T>(Guid id) where T : MesEntityBase, new()
|
||
{
|
||
var entity = this.GetEntity<T>(id);
|
||
this.DeleteEntityNoCommit<T>(i => i.ID == id);
|
||
}
|
||
|
||
public void DeleteEntitiesNoCommit<T>(IEnumerable<T> entities) where T : MesEntityBase, new()
|
||
{
|
||
this.DeleteEntities(entities, false);
|
||
}
|
||
|
||
public void SaveEntitiesNoCommit<T>(IEnumerable<T> entities) where T : MesEntityBase, new()
|
||
{
|
||
this.SaveEntities(entities, false);
|
||
}
|
||
|
||
public T AddAndGetEntityNoCommit<T>(T entity) where T : MesEntityBase, new()
|
||
{
|
||
return AddAndGetEntity(entity, false);
|
||
}
|
||
|
||
#region 指定库更新,删除
|
||
|
||
public void AddEntityByConn<T>(T entity, string conn) where T : MesEntityBase, new()
|
||
{
|
||
if (entity == null)
|
||
return;
|
||
List<T> list = new List<T>();
|
||
list.Add(entity);
|
||
this.AddEntitiesByConn<T>(list, conn);
|
||
}
|
||
|
||
public void UpdateEntitiesByConn<T>(IEnumerable<T> entities, string conn) where T : MesEntityBase, new()
|
||
{
|
||
this.UpdateEntitiesByConn(entities, conn);
|
||
}
|
||
|
||
public void UpdateEntityByConn<T>(T entity, string conn, params string[] updateField) where T : MesEntityBase, new()
|
||
{
|
||
List<T> entities = new List<T>();
|
||
entities.Add(entity);
|
||
this.UpdateEntitiesByConn(entities, conn, updateField);
|
||
}
|
||
|
||
public void DeleteEntityByConn<T>(Expression<Func<T, bool>> expression, string conn) where T : MesEntityBase, new()
|
||
{
|
||
var dbconn = TenantInfoMiddleware.DesDbConn(conn);
|
||
if (string.IsNullOrEmpty(dbconn))
|
||
{
|
||
dbconn = ConfigurationManager.ConnectionStrings["default"];
|
||
}
|
||
List<T> entities = new List<T>();
|
||
using (var context = new EfDbContext(dbconn))
|
||
{
|
||
entities = context.GetEntities<T>(expression, null).ToList();
|
||
}
|
||
if (entities.Any())
|
||
{
|
||
foreach (var e in entities)
|
||
{
|
||
SetRedis(e, RedisHanddle.Delete);
|
||
}
|
||
this.DeleteEntitiesByConn(entities, conn);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
public void DeleteEntityByConn<T>(T entity, string conn) where T : MesEntityBase, new()
|
||
{
|
||
this.DeleteEntityByConn<T>(i => i.ID == entity.ID, conn);
|
||
}
|
||
public void DeleteEntityByConn<T>(Guid id, string conn) where T : MesEntityBase, new()
|
||
{
|
||
var entity = this.GetEntity<T>(id);
|
||
this.DeleteEntityByConn<T>(i => i.ID == id, conn);
|
||
}
|
||
|
||
//统一处理
|
||
|
||
public void DeleteEntitiesByConn<T>(IEnumerable<T> entities, string conn) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
if (string.IsNullOrEmpty(conn))
|
||
conn = ConfigurationManager.ConnectionStrings["default"];
|
||
else
|
||
conn = TenantInfoMiddleware.DesDbConn(conn);
|
||
if (!string.IsNullOrEmpty(conn))
|
||
{
|
||
try
|
||
{
|
||
DelRedis<T>(entities);
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
context.DeleteEntities<T>(entities);
|
||
context.SaveChanges();
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
if (ex.Message != null && ex.Message.IndexOf("约束", StringComparison.OrdinalIgnoreCase) > -1)
|
||
throw new Exception("存在资料已被用，不允许执行此操作");
|
||
throw ex;
|
||
}
|
||
foreach (var entity in entities)
|
||
SetRedis(entity, RedisHanddle.Delete);
|
||
|
||
}
|
||
else
|
||
{
|
||
if (string.IsNullOrEmpty(conn))
|
||
throw new Exception("无法获取数据库连接");
|
||
}
|
||
}
|
||
public void AddEntitiesByConn<T>(IEnumerable<T> entities, string conn) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
var userId = Api.AppContext.CurrentSession != null ? Api.AppContext.CurrentSession.UserID : null;
|
||
var type = typeof(T);
|
||
var rootOrgReplace = false;
|
||
if (Api.AppContext.CurrentSession.RootOrgId != null && type.GetAttribute<RootOrgAttribute>() != null)
|
||
{
|
||
rootOrgReplace = true;
|
||
}
|
||
var nowTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
entities.ForEach(i =>
|
||
{
|
||
i.CREATE_TIME = nowTime;
|
||
i.MODIFY_TIME = nowTime;
|
||
if (userId != null)
|
||
{
|
||
i.CREATER_ID = userId;
|
||
i.MODIFIER_ID = userId;
|
||
}
|
||
|
||
if (rootOrgReplace)
|
||
{
|
||
i.ORG_ID = Api.AppContext.CurrentSession.RootOrgId;
|
||
}
|
||
|
||
});
|
||
this.FillAcronymFieldData(entities);
|
||
List<UpdateCodeSerialInfo> updateSerialInfos = new List<UpdateCodeSerialInfo>();
|
||
|
||
if (string.IsNullOrEmpty(conn))
|
||
conn = ConfigurationManager.ConnectionStrings["default"];
|
||
else
|
||
conn = TenantInfoMiddleware.DesDbConn(conn);
|
||
|
||
if (!string.IsNullOrEmpty(conn))
|
||
{
|
||
if (string.IsNullOrEmpty(conn))
|
||
throw new Exception("无法获取数据库连接");
|
||
else
|
||
{
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
context.AddEntities<T>(entities);
|
||
context.SaveChanges();
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
throw new Exception("数据库连接不能为空");
|
||
}
|
||
|
||
foreach (var entity in entities)
|
||
{
|
||
SetRedis(entity, RedisHanddle.Add);
|
||
}
|
||
DelRedisGroup<T>(entities.FirstOrDefault().ORG_ID ?? Guid.Empty);
|
||
var def = entities.FirstOrDefault();
|
||
}
|
||
public void UpdateEntitiesByConn<T>(IEnumerable<T> entities, string conn, params string[] updateField) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
if (string.IsNullOrEmpty(conn))
|
||
conn = ConfigurationManager.ConnectionStrings["default"];
|
||
else
|
||
conn = TenantInfoMiddleware.DesDbConn(conn);
|
||
|
||
if (!string.IsNullOrEmpty(conn))
|
||
{
|
||
if (string.IsNullOrEmpty(conn))
|
||
throw new Exception("无法获取数据库连接");
|
||
else
|
||
{
|
||
//数据处理
|
||
var deleteEntities = entities.Where(t => t.IS_DELETED).ToList();
|
||
var updateEntities = entities.Where(t => !t.IS_DELETED).ToList();
|
||
//更新别名
|
||
this.FillAcronymFieldData(updateEntities, updateField);
|
||
//数据处理
|
||
var type = typeof(T);
|
||
var rootOrgReplace = false;
|
||
if (Api.AppContext.CurrentSession.RootOrgId != null && type.GetAttribute<RootOrgAttribute>() != null)
|
||
{
|
||
rootOrgReplace = true;
|
||
}
|
||
if (updateField != null && updateField.Any())
|
||
{
|
||
updateField = updateField.Append("ID").ToArray();
|
||
}
|
||
bool isRedis = false;
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass != null)
|
||
{
|
||
isRedis = true;
|
||
}
|
||
Guid? currentUserId = null;
|
||
if (Api.AppContext.CurrentSession != null && !string.IsNullOrEmpty(Api.AppContext.CurrentSession.UserId))
|
||
currentUserId = new Guid(Api.AppContext.CurrentSession.UserId);
|
||
var nowTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
foreach (var i in updateEntities)
|
||
{
|
||
i.MODIFY_TIME = nowTime;
|
||
if (rootOrgReplace)
|
||
{
|
||
i.ORG_ID = Api.AppContext.CurrentSession.RootOrgId;
|
||
}
|
||
|
||
if (currentUserId != null)
|
||
{
|
||
i.MODIFIER_ID = currentUserId;
|
||
}
|
||
}
|
||
//redis数据删除
|
||
if (isRedis)
|
||
{
|
||
DelRedis<T>(entities);
|
||
}
|
||
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
CheckRowVersion(entities, context);
|
||
context.UpdateEntities<T>(updateEntities, updateField);
|
||
context.DeleteEntities(deleteEntities);
|
||
context.SaveChanges();
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
throw new Exception("数据库连接不能为空");
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
public void AddEntityByTenant<T>(T entity, string tenant) where T : MesEntityBase, new()
|
||
{
|
||
if (entity == null)
|
||
return;
|
||
List<T> list = new List<T>();
|
||
list.Add(entity);
|
||
this.AddEntitiesByTenant<T>(list, tenant);
|
||
}
|
||
|
||
public void UpdateEntitiesByTenant<T>(IEnumerable<T> entities, string tenant) where T : MesEntityBase, new()
|
||
{
|
||
this.UpdateEntitiesByTenant(entities, tenant);
|
||
}
|
||
|
||
public void UpdateEntityByTenant<T>(T entity, string tenant, params string[] updateField) where T : MesEntityBase, new()
|
||
{
|
||
List<T> entities = new List<T>();
|
||
entities.Add(entity);
|
||
this.UpdateEntitiesByTenant(entities, tenant, updateField);
|
||
}
|
||
|
||
public void DeleteEntityByTenant<T>(Expression<Func<T, bool>> expression, string tenant) where T : MesEntityBase, new()
|
||
{
|
||
var dbconn = "";
|
||
if (string.IsNullOrEmpty(tenant))
|
||
dbconn = ConfigurationManager.ConnectionStrings["default"];
|
||
else
|
||
dbconn = TenantInfoMiddleware.GetDbConn(tenant);
|
||
List<T> entities = new List<T>();
|
||
using (var context = new EfDbContext(dbconn))
|
||
{
|
||
entities = context.GetEntities<T>(expression, null).ToList();
|
||
}
|
||
if (entities.Any())
|
||
{
|
||
foreach (var e in entities)
|
||
{
|
||
SetRedis(e, RedisHanddle.Delete);
|
||
}
|
||
this.DeleteEntitiesByTenant(entities, tenant);
|
||
}
|
||
}
|
||
|
||
public void DeleteEntityByTenant<T>(T entity, string tenant) where T : MesEntityBase, new()
|
||
{
|
||
this.DeleteEntityByConn<T>(i => i.ID == entity.ID, tenant);
|
||
}
|
||
public void DeleteEntityByTenant<T>(Guid id, string tenant) where T : MesEntityBase, new()
|
||
{
|
||
var entity = this.GetEntity<T>(id);
|
||
this.DeleteEntityByConn<T>(i => i.ID == id, tenant);
|
||
}
|
||
|
||
//统一处理
|
||
|
||
public void DeleteEntitiesByTenant<T>(IEnumerable<T> entities, string tenant) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
var dbconn = "";
|
||
if (string.IsNullOrEmpty(tenant))
|
||
dbconn = ConfigurationManager.ConnectionStrings["default"];
|
||
else
|
||
dbconn = TenantInfoMiddleware.GetDbConn(tenant);
|
||
if (!string.IsNullOrEmpty(tenant))
|
||
{
|
||
if (string.IsNullOrEmpty(dbconn))
|
||
throw new Exception("无法获取数据库连接");
|
||
else
|
||
{
|
||
try
|
||
{
|
||
DelRedis<T>(entities);
|
||
using (var context = new EfDbContext(dbconn))
|
||
{
|
||
context.DeleteEntities<T>(entities);
|
||
context.SaveChanges();
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
if (ex.Message != null && ex.Message.IndexOf("约束", StringComparison.OrdinalIgnoreCase) > -1)
|
||
throw new Exception("存在资料已被用，不允许执行此操作");
|
||
throw ex;
|
||
}
|
||
foreach (var entity in entities)
|
||
SetRedis(entity, RedisHanddle.Delete);
|
||
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
throw new Exception("数据库连接不能为空");
|
||
}
|
||
}
|
||
public void AddEntitiesByTenant<T>(IEnumerable<T> entities, string tenant) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
var userId = Api.AppContext.CurrentSession != null ? Api.AppContext.CurrentSession.UserID : null;
|
||
var type = typeof(T);
|
||
var rootOrgReplace = false;
|
||
if (Api.AppContext.CurrentSession.RootOrgId != null && type.GetAttribute<RootOrgAttribute>() != null)
|
||
{
|
||
rootOrgReplace = true;
|
||
}
|
||
var nowTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
entities.ForEach(i =>
|
||
{
|
||
i.CREATE_TIME = nowTime;
|
||
i.MODIFY_TIME = nowTime;
|
||
if (userId != null)
|
||
{
|
||
i.CREATER_ID = userId;
|
||
i.MODIFIER_ID = userId;
|
||
}
|
||
|
||
if (rootOrgReplace)
|
||
{
|
||
i.ORG_ID = Api.AppContext.CurrentSession.RootOrgId;
|
||
}
|
||
|
||
});
|
||
this.FillAcronymFieldData(entities);
|
||
List<UpdateCodeSerialInfo> updateSerialInfos = new List<UpdateCodeSerialInfo>();
|
||
|
||
var dbconn = "";
|
||
if (string.IsNullOrEmpty(tenant))
|
||
dbconn = ConfigurationManager.ConnectionStrings["default"];
|
||
else
|
||
dbconn = TenantInfoMiddleware.GetDbConn(tenant);
|
||
|
||
if (!string.IsNullOrEmpty(tenant))
|
||
{
|
||
if (string.IsNullOrEmpty(dbconn))
|
||
throw new Exception("无法获取数据库连接");
|
||
else
|
||
{
|
||
using (var context = new EfDbContext(dbconn))
|
||
{
|
||
context.AddEntities<T>(entities);
|
||
context.SaveChanges();
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
throw new Exception("数据库连接不能为空");
|
||
}
|
||
|
||
foreach (var entity in entities)
|
||
{
|
||
SetRedis(entity, RedisHanddle.Add);
|
||
}
|
||
DelRedisGroup<T>(entities.FirstOrDefault().ORG_ID ?? Guid.Empty);
|
||
var def = entities.FirstOrDefault();
|
||
}
|
||
public void UpdateEntitiesByTenant<T>(IEnumerable<T> entities, string tenant, params string[] updateField) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
var dbconn = "";
|
||
if (string.IsNullOrEmpty(tenant))
|
||
dbconn = ConfigurationManager.ConnectionStrings["default"];
|
||
else
|
||
dbconn = TenantInfoMiddleware.GetDbConn(tenant);
|
||
|
||
if (!string.IsNullOrEmpty(tenant))
|
||
{
|
||
if (string.IsNullOrEmpty(dbconn))
|
||
throw new Exception("无法获取数据库连接");
|
||
else
|
||
{
|
||
//数据处理
|
||
var deleteEntities = entities.Where(t => t.IS_DELETED).ToList();
|
||
var updateEntities = entities.Where(t => !t.IS_DELETED).ToList();
|
||
//更新别名
|
||
this.FillAcronymFieldData(updateEntities, updateField);
|
||
//数据处理
|
||
var type = typeof(T);
|
||
var rootOrgReplace = false;
|
||
if (Api.AppContext.CurrentSession.RootOrgId != null && type.GetAttribute<RootOrgAttribute>() != null)
|
||
{
|
||
rootOrgReplace = true;
|
||
}
|
||
if (updateField != null && updateField.Any())
|
||
{
|
||
updateField = updateField.Append("ID").ToArray();
|
||
}
|
||
bool isRedis = false;
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass != null)
|
||
{
|
||
isRedis = true;
|
||
}
|
||
Guid? currentUserId = null;
|
||
if (Api.AppContext.CurrentSession != null && !string.IsNullOrEmpty(Api.AppContext.CurrentSession.UserId))
|
||
currentUserId = new Guid(Api.AppContext.CurrentSession.UserId);
|
||
var nowTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
foreach (var i in updateEntities)
|
||
{
|
||
i.MODIFY_TIME = nowTime;
|
||
if (rootOrgReplace)
|
||
{
|
||
i.ORG_ID = Api.AppContext.CurrentSession.RootOrgId;
|
||
}
|
||
|
||
if (currentUserId != null)
|
||
{
|
||
i.MODIFIER_ID = currentUserId;
|
||
}
|
||
}
|
||
//redis数据删除
|
||
if (isRedis)
|
||
{
|
||
DelRedis<T>(entities);
|
||
}
|
||
|
||
using (var context = new EfDbContext(dbconn))
|
||
{
|
||
CheckRowVersion(entities, context);
|
||
context.UpdateEntities<T>(updateEntities, updateField);
|
||
context.DeleteEntities(deleteEntities);
|
||
context.SaveChanges();
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
throw new Exception("数据库连接不能为空");
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
#endregion
|
||
|
||
#endregion
|
||
|
||
|
||
public void AddEntities<T>(IEnumerable<T> entities, bool isSave = true) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
this.CheckUnique(entities, null);
|
||
var userId = Api.AppContext.CurrentSession != null ? Api.AppContext.CurrentSession.UserID : null;
|
||
var type = typeof(T);
|
||
var rootOrgReplace = false;
|
||
if (Api.AppContext.CurrentSession.RootOrgId != null && type.GetAttribute<RootOrgAttribute>() != null)
|
||
{
|
||
rootOrgReplace = true;
|
||
}
|
||
var nowTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
entities.ForEach(i =>
|
||
{
|
||
i.CREATE_TIME = nowTime;
|
||
i.MODIFY_TIME = nowTime;
|
||
if (userId != null)
|
||
{
|
||
i.CREATER_ID = userId;
|
||
i.MODIFIER_ID = userId;
|
||
}
|
||
|
||
if (rootOrgReplace)
|
||
{
|
||
i.ORG_ID = Api.AppContext.CurrentSession.RootOrgId;
|
||
}
|
||
|
||
});
|
||
this.FillAcronymFieldData(entities);
|
||
List<UpdateCodeSerialInfo> updateSerialInfos = new List<UpdateCodeSerialInfo>();
|
||
this.UpdateSerialUsedStatus(entities, 0, updateSerialInfos);
|
||
var sysParams = GetSysParams(entities);
|
||
this.UnitOfWork.AddEntities<T>(entities);
|
||
foreach (var entity in entities)
|
||
{
|
||
SetRedis(entity, RedisHanddle.Add);
|
||
}
|
||
DelRedisGroup<T>(entities.FirstOrDefault().ORG_ID ?? Guid.Empty);
|
||
SaveSysParams(sysParams);
|
||
//DoSetIsLeaf(entities, null, true);
|
||
var def = entities.FirstOrDefault();
|
||
|
||
this.ExcuteUpdateSerialInfos(updateSerialInfos);
|
||
if (isSave)
|
||
{
|
||
this.UnitOfWork.SaveChanges();
|
||
}
|
||
}
|
||
|
||
public void DeleteEntity<T>(T entity, bool isSave = true) where T : MesEntityBase, new()
|
||
{
|
||
this.DeleteEntity<T>(entity.ID, isSave);
|
||
|
||
}
|
||
|
||
public void DeleteEntity<T>(Guid key, bool isSave = true) where T : MesEntityBase, new()
|
||
{
|
||
var entity = this.GetEntity<T>(key);
|
||
this.DeleteEntity<T>(t => t.ID == key, isSave);
|
||
|
||
}
|
||
|
||
public void DeleteEntity<T>(Expression<Func<T, bool>> predicate, bool isSave = true) where T : MesEntityBase, new()
|
||
{
|
||
var entities = this.UnitOfWork.GetEntities<T>(predicate, null);
|
||
|
||
if (entities.Any())
|
||
{
|
||
this.DeleteEntities<T>(entities, isSave);
|
||
}
|
||
}
|
||
|
||
|
||
public void DeleteEntities<T>(IEnumerable<T> entities, bool isSave = true) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
List<UpdateCodeSerialInfo> updateSerialInfos = new List<UpdateCodeSerialInfo>();
|
||
var sysParams = GetSysParams(entities, true);
|
||
|
||
this.UpdateSerialUsedStatus(entities, 2, updateSerialInfos);
|
||
this.UnitOfWork.DeleteEntities<T>(entities);
|
||
|
||
//DoSetIsLeaf(entities, entities.Select(i => i.ID).ToList(), false);
|
||
this.SaveSysParams(sysParams);
|
||
this.ExcuteUpdateSerialInfos(updateSerialInfos);
|
||
DelRedis<T>(entities);
|
||
try
|
||
{
|
||
if (isSave)
|
||
{
|
||
|
||
this.UnitOfWork.SaveChanges();
|
||
}
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
if (ex.Message != null && ex.Message.IndexOf("约束", StringComparison.OrdinalIgnoreCase) > -1)
|
||
throw new Exception("存在资料已被用，不允许执行此操作");
|
||
throw ex;
|
||
}
|
||
foreach (var entity in entities)
|
||
SetRedis(entity, RedisHanddle.Delete);
|
||
|
||
}
|
||
|
||
|
||
public bool UpdateEntity<T>(T entity, bool isSave = true, params string[] updateField) where T : MesEntityBase, new()
|
||
{
|
||
if (entity == null)
|
||
return false;
|
||
if (entity.IS_DELETED)
|
||
this.DeleteEntity(entity);
|
||
else
|
||
{
|
||
List<T> entities = new List<T>();
|
||
entities.Add(entity);
|
||
if (updateField == null || !updateField.Any())
|
||
this.SaveEntities(entities, isSave);
|
||
else
|
||
{
|
||
this.UpdateEntities(entities, isSave, updateField);
|
||
}
|
||
|
||
}
|
||
return true;
|
||
}
|
||
|
||
public void UpdateEntities<T>(IEnumerable<T> entities, bool isSave = true, params string[] updateField) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
CheckRowVersion(entities);
|
||
|
||
|
||
List<UpdateCodeSerialInfo> updateSerialInfos = new List<UpdateCodeSerialInfo>();
|
||
var sysParams = GetSysParams(entities);
|
||
var deleteEntities = entities.Where(t => t.IS_DELETED).ToList();
|
||
var updateEntities = entities.Where(t => !t.IS_DELETED).ToList();
|
||
CheckUnique(entities, deleteEntities);
|
||
//List<Guid> addParentIds = new List<Guid>();
|
||
//List<Guid> deleteParentIds = new List<Guid>();
|
||
//List<Guid> deleteIds = new List<Guid>();
|
||
//DoSetIsLeafByUpdate(updateEntities, addParentIds, deleteParentIds, deleteIds);
|
||
//更新别名
|
||
this.FillAcronymFieldData(updateEntities, updateField);
|
||
//数据处理
|
||
var type = typeof(T);
|
||
var rootOrgReplace = false;
|
||
if (Api.AppContext.CurrentSession.RootOrgId != null && type.GetAttribute<RootOrgAttribute>() != null)
|
||
{
|
||
rootOrgReplace = true;
|
||
}
|
||
if (updateField != null && updateField.Any())
|
||
{
|
||
updateField = updateField.Append("ID").ToArray();
|
||
}
|
||
bool isRedis = false;
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass != null)
|
||
{
|
||
isRedis = true;
|
||
}
|
||
Guid? currentUserId = null;
|
||
if (Api.AppContext.CurrentSession != null && !string.IsNullOrEmpty(Api.AppContext.CurrentSession.UserId))
|
||
currentUserId = new Guid(Api.AppContext.CurrentSession.UserId);
|
||
var nowTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
foreach (var i in updateEntities)
|
||
{
|
||
i.MODIFY_TIME = nowTime;
|
||
if (rootOrgReplace)
|
||
{
|
||
i.ORG_ID = Api.AppContext.CurrentSession.RootOrgId;
|
||
}
|
||
|
||
if (currentUserId != null)
|
||
{
|
||
i.MODIFIER_ID = currentUserId;
|
||
}
|
||
}
|
||
if (isRedis)
|
||
{
|
||
//CsRedisManager.GetClient().Del(updateEntities.Select(i => i.ID.ToString()).ToArray());
|
||
DelRedis<T>(entities);
|
||
}
|
||
this.UpdateSerialUsedStatus(updateEntities, 1, updateSerialInfos);
|
||
this.UpdateSerialUsedStatus(deleteEntities, 2, updateSerialInfos);
|
||
this.UnitOfWork.UpdateEntities<T>(updateEntities, updateField);
|
||
this.UnitOfWork.DeleteEntities(deleteEntities);
|
||
//
|
||
//deleteParentIds.RemoveAll(i => addParentIds.Contains(i));
|
||
|
||
//if (addParentIds.Any())
|
||
//{
|
||
// MethodInfo methodInfo = this.GetType().GetMethod("SetParentIsLeaf",
|
||
// BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
|
||
// methodInfo.MakeGenericMethod(new Type[] { entities.FirstOrDefault().GetType() }).
|
||
// Invoke(this, new object[] { addParentIds, deleteIds, true });
|
||
//}
|
||
//if (deleteParentIds.Any())
|
||
//{
|
||
// MethodInfo methodInfo = this.GetType().GetMethod("SetParentIsLeaf",
|
||
// BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
|
||
// methodInfo.MakeGenericMethod(new Type[] { entities.FirstOrDefault().GetType() }).
|
||
// Invoke(this, new object[] { deleteParentIds, deleteIds, false });
|
||
//}
|
||
this.SaveSysParams(sysParams);
|
||
this.ExcuteUpdateSerialInfos(updateSerialInfos);
|
||
if (isSave)
|
||
this.UnitOfWork.SaveChanges();
|
||
|
||
}
|
||
|
||
public void SaveEntities<T>(IEnumerable<T> entities, bool isSave = true) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any())
|
||
return;
|
||
var type = typeof(T);
|
||
var rootOrgReplace = false;
|
||
if (Api.AppContext.CurrentSession.RootOrgId != null && type.GetAttribute<RootOrgAttribute>() != null)
|
||
{
|
||
rootOrgReplace = true;
|
||
}
|
||
|
||
CheckRowVersion(entities);
|
||
|
||
|
||
var sysParams = GetSysParams(entities);
|
||
var deleteEntities = entities.Where(t => t.IS_DELETED).ToList();
|
||
var saveEntities = entities.Where(t => !t.IS_DELETED).ToList();
|
||
List<T> updateEntities = new List<T>();
|
||
List<T> addEntities = new List<T>();
|
||
List<Guid> deleteIds = new List<Guid>();
|
||
List<UpdateCodeSerialInfo> updateSerialInfos = new List<UpdateCodeSerialInfo>();
|
||
var def = entities.FirstOrDefault();
|
||
List<Guid> addParentIds = new List<Guid>();
|
||
List<Guid> deleteParentIds = new List<Guid>();
|
||
if (deleteEntities.Any())
|
||
{
|
||
this.UpdateSerialUsedStatus(deleteEntities, 2, updateSerialInfos);
|
||
var delIds = deleteEntities.Select(i => i.ID).ToArray();
|
||
var dbDelEntities = this.UnitOfWork.GetEntities<T>(t => delIds.Contains(t.ID), null, true).ToList();
|
||
this.UnitOfWork.DeleteEntities<T>(dbDelEntities);
|
||
//if (def != null && def is MesTreeEntityBase)
|
||
//{
|
||
// var deleteTreeEntitis = deleteEntities as List<MesTreeEntityBase>;
|
||
// var deletePIds = deleteTreeEntitis.Select(i => i.PARENT_ID ?? Guid.Empty).Distinct().ToList();
|
||
// deleteIds = deleteTreeEntitis.Select(i => i.ID).Distinct().ToList();
|
||
// deleteParentIds.AddRange(deletePIds);
|
||
//}
|
||
}
|
||
if (saveEntities.Any())
|
||
{
|
||
this.CheckUnique(saveEntities, deleteEntities);
|
||
//DoSetIsLeafByUpdate(saveEntities, addParentIds, deleteParentIds, deleteIds);
|
||
var ids = saveEntities.Select(t => t.ID).ToList();
|
||
List<T> dbUpdateEntities = this.UnitOfWork.GetEntities<T>(t => ids.Contains(t.ID), null, true).ToList();
|
||
var dbContext = (DbContext)this.UnitOfWork;
|
||
var nowTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
foreach (var entity in saveEntities)
|
||
{
|
||
if (rootOrgReplace)
|
||
{
|
||
entity.ORG_ID = Api.AppContext.CurrentSession.RootOrgId;
|
||
}
|
||
var dbEntity = dbUpdateEntities.FirstOrDefault(t => t.ID.ToString() == entity.ID.ToString());
|
||
if (dbEntity != null)
|
||
{
|
||
entity.MODIFY_TIME = nowTime;
|
||
if (Api.AppContext.CurrentSession != null && !string.IsNullOrEmpty(Api.AppContext.CurrentSession.UserId))
|
||
{
|
||
entity.MODIFIER_ID = new Guid(Api.AppContext.CurrentSession.UserId);
|
||
}
|
||
var oldContexEntity = dbContext.Entry(dbEntity);
|
||
oldContexEntity.CurrentValues.SetValues(entity);
|
||
updateEntities.Add(dbEntity);
|
||
//SetRedis(entity, RedisHanddle.Update);
|
||
}
|
||
else
|
||
{
|
||
entity.MODIFY_TIME = nowTime;
|
||
entity.CREATE_TIME = nowTime;
|
||
if (Api.AppContext.CurrentSession != null && !string.IsNullOrEmpty(Api.AppContext.CurrentSession.UserId))
|
||
{
|
||
entity.MODIFIER_ID = new Guid(Api.AppContext.CurrentSession.UserId);
|
||
entity.CREATER_ID = new Guid(Api.AppContext.CurrentSession.UserId);
|
||
}
|
||
addEntities.Add(entity);
|
||
//SetRedis(entity, RedisHanddle.Add);
|
||
}
|
||
deleteParentIds.RemoveAll(i => addParentIds.Contains(i));
|
||
}
|
||
DelRedis<T>(entities);
|
||
|
||
this.FillAcronymFieldData(saveEntities);
|
||
this.UnitOfWork.UpdateEntities<T>(updateEntities);
|
||
this.UnitOfWork.AddEntities<T>(addEntities);
|
||
this.UpdateSerialUsedStatus(addEntities, 0, updateSerialInfos);
|
||
this.UpdateSerialUsedStatus(updateEntities, 1, updateSerialInfos);
|
||
}
|
||
|
||
this.SaveSysParams(sysParams);
|
||
this.ExcuteUpdateSerialInfos(updateSerialInfos);
|
||
try
|
||
{
|
||
if (isSave)
|
||
{
|
||
this.UnitOfWork.SaveChanges();
|
||
}
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
//if (ex.Message != null && ex.Message.IndexOf("约束", StringComparison.OrdinalIgnoreCase) > -1)
|
||
// throw new Exception("存在资料已被用，不允许执行此操作");
|
||
throw ex;
|
||
}
|
||
|
||
}
|
||
|
||
public T GetEntity<T>(Guid id, params string[] paths)
|
||
where T : MesEntityBase, new()
|
||
{
|
||
return this.GetEntity<T>(t => t.ID == id, null, paths);
|
||
}
|
||
|
||
public T GetEntity<T>(Expression<Func<T, bool>> expression, BaseFilter filter, params string[] paths)
|
||
where T : MesEntityBase, new()
|
||
{
|
||
return this.GetEntity(expression, filter, (!filter?.IsNoTranking) ?? true, paths);
|
||
}
|
||
public T GetEntity<T>(Expression<Func<T, bool>> expression, BaseFilter filter, bool isTracking = true, params string[] paths)
|
||
where T : MesEntityBase, new()
|
||
{
|
||
if (filter != null && Api.AppContext.CurrentSession.DataRule != null && !filter.IgnoreDataRule && !filter.DataRule.Any())
|
||
{
|
||
filter.DataRule = Api.AppContext.CurrentSession.DataRule;
|
||
}
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, filter, paths, null, out orgExpression, out realPaths, out realOrders, false);
|
||
List<string> selectFields = new List<string>();
|
||
T ret = null;
|
||
if (filter != null && filter.SelectField != null && filter.SelectField.Any())
|
||
{
|
||
selectFields = filter.SelectField.ToList();
|
||
AppendSelectedField<T>(selectFields);
|
||
}
|
||
//多库联合查询
|
||
if (filter != null)
|
||
{
|
||
if (filter.IsMultipleDb)
|
||
{
|
||
var conns = GetAllDbConns();//查询redis里面的数据库连接
|
||
foreach (var conn in conns)
|
||
{
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
ret = context.GetEntity<T>(exp, realOrders, selectFields.ToArray(), isTracking, realPaths);
|
||
if (ret != null)
|
||
{
|
||
var dbConn = TenantInfoMiddleware.EnDbConn(conn);
|
||
ret.DbConn = dbConn;
|
||
break;
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
else if (filter.IsSpecifyDb)
|
||
{
|
||
string enConn = GetSpecifyDb(filter);
|
||
using (var context = new EfDbContext(enConn))
|
||
{
|
||
ret = context.GetEntity<T>(exp, realOrders, selectFields.ToArray(), isTracking, realPaths);
|
||
if (ret != null)
|
||
{
|
||
ret.DbConn = filter.SpecifyDbConn;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ret = this.UnitOfWork.GetEntity<T>(exp, realOrders, selectFields.ToArray(), isTracking, realPaths);
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
ret = this.UnitOfWork.GetEntity<T>(exp, realOrders, selectFields.ToArray(), isTracking, realPaths);
|
||
}
|
||
//导航属性
|
||
if (ret != null)
|
||
{
|
||
List<T> list = new List<T>();
|
||
list.Add(ret);
|
||
this.FillGetEntitySysParam(list, filter, paths);
|
||
if (selectFields != null && selectFields.Any())
|
||
{
|
||
realPaths = SelectFieldInclude(realPaths, selectFields);
|
||
NavigationDeal(realPaths, list, selectFields.ToArray(), filter.DataRule.ToArray(), filter.OrgRule, filter.OrgId, filter.IgnoreOrgRule,
|
||
filter.IgnoreDataRule, isTracking,
|
||
filter.IsMultipleDb, filter.IsSpecifyDb, filter.SpecifyDbConn);
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
public IEnumerable<T> GetEntities<T>(Expression<Func<T, bool>> expression, BaseFilter filter,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetEntities(expression, filter, (!filter?.IsNoTranking) ?? true, paths);
|
||
}
|
||
|
||
|
||
private IEnumerable<T> GetEntities<T>(BaseFilter filter) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetEntities<T>(null, filter);
|
||
}
|
||
public IEnumerable<T> GetEntities<T>(Expression<Func<T, bool>> expression, BaseFilter filter,
|
||
bool isTracking = true, params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, filter, paths, null, out orgExpression, out realPaths, out realOrders, false);
|
||
List<string> selectFields = new List<string>();
|
||
if (filter != null && Api.AppContext.CurrentSession.DataRule != null && !filter.IgnoreDataRule && !filter.DataRule.Any())
|
||
{
|
||
filter.DataRule = Api.AppContext.CurrentSession.DataRule;
|
||
}
|
||
if (filter != null && filter.SelectField != null && filter.SelectField.Any())
|
||
{
|
||
selectFields = filter.SelectField.ToList();
|
||
AppendSelectedField<T>(selectFields);
|
||
}
|
||
//支持多库联合查询
|
||
var entities = new List<T>();
|
||
if (filter != null)
|
||
{
|
||
if (filter.IsMultipleDb)
|
||
{
|
||
var conns = GetAllDbConns();//查询redis里面的数据库连接
|
||
foreach (var conn in conns)
|
||
{
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
var contextEntities = context.GetEntities<T>(exp, selectFields.ToArray(), isTracking, realPaths);
|
||
if (contextEntities.Any())
|
||
{
|
||
var dbConn = TenantInfoMiddleware.EnDbConn(conn);
|
||
contextEntities.ForEach(i => i.DbConn = dbConn);
|
||
entities.AddRange(contextEntities);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (filter.IsSpecifyDb)
|
||
{
|
||
string enConn = GetSpecifyDb(filter);
|
||
using (var context = new EfDbContext(enConn))
|
||
{
|
||
entities = context.GetEntities<T>(exp, selectFields.ToArray(), isTracking, realPaths).ToList();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
entities = this.UnitOfWork.GetEntities<T>(exp, selectFields.ToArray(), isTracking, realPaths).ToList();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
entities = this.UnitOfWork.GetEntities<T>(exp, selectFields.ToArray(), isTracking, realPaths).ToList();
|
||
}
|
||
if (entities != null && entities.Any())
|
||
this.FillGetEntitySysParam(entities, filter, paths);
|
||
//导航属性处理
|
||
if (selectFields != null && selectFields.Any())
|
||
{
|
||
realPaths = SelectFieldInclude(realPaths, selectFields);
|
||
NavigationDeal(realPaths, entities, selectFields.ToArray(),
|
||
filter.DataRule.ToArray(), filter.OrgRule, filter.OrgId, filter.IgnoreOrgRule,
|
||
filter.IgnoreDataRule, isTracking, filter.IsMultipleDb, filter.IsSpecifyDb, filter.SpecifyDbConn);
|
||
}
|
||
|
||
return entities;
|
||
}
|
||
|
||
private static string[] SelectFieldInclude(string[] realPaths, List<string> selectFields)
|
||
{
|
||
List<string> tmp = new List<string>();
|
||
if (realPaths != null)
|
||
{
|
||
tmp = new List<string>(realPaths);
|
||
}
|
||
foreach (var field in selectFields)
|
||
{
|
||
if (field.IndexOf(".") > 0)
|
||
{
|
||
var index = field.LastIndexOf(".");
|
||
var includPath = field.Substring(0, index);
|
||
if (!tmp.Contains(includPath))
|
||
{
|
||
tmp.Add(includPath);
|
||
}
|
||
}
|
||
}
|
||
realPaths = tmp.ToArray();
|
||
return realPaths;
|
||
}
|
||
|
||
public IEnumerable<T> GetOrderEntities<T>(Expression<Func<T, bool>> expression, BaseFilter filter,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetOrderEntities(expression, filter, null, (!filter?.IsNoTranking) ?? true, paths);
|
||
}
|
||
|
||
public IEnumerable<T> GetTree<T>(string id, bool containCurrent = true, BaseFilter filter = null,
|
||
params string[] paths) where T : TreeEntityBase<T>, new()
|
||
{
|
||
var gid = new Guid(id);
|
||
List<Guid> guidList = new List<Guid>();
|
||
List<T> allList = new List<T>();
|
||
guidList.Add(gid);
|
||
if (containCurrent)
|
||
{
|
||
if (filter != null)
|
||
{
|
||
if (filter.IsMultipleDb)
|
||
{
|
||
var conns = GetAllDbConns();//查询redis里面的数据库连接
|
||
foreach (var conn in conns)
|
||
{
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
var top = context.GetEntity<T>(i => i.ID == gid, filter.SelectField?.ToArray(), paths);
|
||
if (top != null)
|
||
{
|
||
allList.Add(top);
|
||
var dbConn = TenantInfoMiddleware.EnDbConn(conn);
|
||
top.DbConn = dbConn;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (filter.IsSpecifyDb)
|
||
{
|
||
string enConn = GetSpecifyDb(filter);
|
||
using (var context = new EfDbContext(enConn))
|
||
{
|
||
var top = context.GetEntity<T>(i => i.ID == gid, filter.SelectField?.ToArray(), paths);
|
||
if (top != null)
|
||
{
|
||
allList.Add(top);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var top = this.GetEntity<T>(gid, paths);
|
||
if (top != null)
|
||
allList.Add(top);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var top = this.GetEntity<T>(gid, paths);
|
||
if (top != null)
|
||
allList.Add(top);
|
||
}
|
||
}
|
||
GetChildEntity(paths, filter, guidList, allList);
|
||
return allList;
|
||
}
|
||
|
||
private void AppendSelectedField<T>(List<string> selectFields)
|
||
{
|
||
if (selectFields != null && selectFields.Any())
|
||
{
|
||
var type = typeof(T);
|
||
var keys = this.UnitOfWork.GetModelForeignKey(type.Name);
|
||
foreach (var fkey in keys)
|
||
{
|
||
if (fkey.ForeignNavName == null || selectFields.Contains(fkey.ForeignFieldName)
|
||
|| !selectFields.Any(i => i.Contains(fkey.ForeignNavName)))
|
||
continue;
|
||
var prop = type.GetProperty(fkey.ForeignNavName);
|
||
if (prop != null && !typeof(System.Collections.IEnumerable).IsAssignableFrom(prop.PropertyType))
|
||
{
|
||
selectFields.Add(fkey.ForeignFieldName);
|
||
}
|
||
}
|
||
if (!selectFields.Contains("ID"))
|
||
{
|
||
selectFields.Add("ID");
|
||
}
|
||
}
|
||
}
|
||
private void GetChildEntity<T>(string[] paths, BaseFilter filter, List<Guid> guidList, List<T> allList) where T : TreeEntityBase<T>, new()
|
||
{
|
||
var top = new List<T>();
|
||
if (filter != null)
|
||
{
|
||
if (filter.IsMultipleDb)
|
||
{
|
||
var conns = GetAllDbConns();//查询redis里面的数据库连接
|
||
foreach (var conn in conns)
|
||
{
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
var contexEntities = context.GetEntities<T>(i => guidList.Contains(i.PARENT_ID ?? Guid.Empty), filter.SelectField?.ToArray(), paths).ToList();
|
||
if (contexEntities != null && contexEntities.Any())
|
||
{
|
||
var dbConn = TenantInfoMiddleware.EnDbConn(conn);
|
||
contexEntities.ForEach(i => i.DbConn = dbConn);
|
||
top.AddRange(contexEntities);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (filter.IsSpecifyDb)
|
||
{
|
||
string enConn = GetSpecifyDb(filter);
|
||
using (var context = new EfDbContext(enConn))
|
||
{
|
||
var contexEntities = context.GetEntities<T>(i => guidList.Contains(i.PARENT_ID ?? Guid.Empty), filter.SelectField?.ToArray(), paths).ToList();
|
||
if (contexEntities != null && contexEntities.Any())
|
||
{
|
||
top.AddRange(contexEntities);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
top = this.GetEntities<T>(i => guidList.Contains(i.PARENT_ID ?? Guid.Empty), new BaseFilter(), paths).ToList();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
top = this.GetEntities<T>(i => guidList.Contains(i.PARENT_ID ?? Guid.Empty), new BaseFilter(), paths).ToList(); ;
|
||
}
|
||
if (top.Any())
|
||
{
|
||
allList.AddRange(top);
|
||
var childGuidList = top.Select(i => i.ID).ToList();
|
||
GetChildEntity(paths, filter, childGuidList, allList);
|
||
}
|
||
}
|
||
|
||
public IEnumerable<TreeNode<T>> GetTreeOrderEntities<T>(Expression<Func<T, bool>> expression, BaseFilter filter, bool isTracking = true,
|
||
params string[] paths) where T : TreeEntityBase<T>, new()
|
||
{
|
||
if (filter != null && Api.AppContext.CurrentSession.DataRule != null && !filter.IgnoreDataRule && !filter.DataRule.Any())
|
||
{
|
||
filter.DataRule = Api.AppContext.CurrentSession.DataRule;
|
||
}
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, filter, paths, null, out orgExpression, out realPaths, out realOrders, false);
|
||
List<T> resultList = null;
|
||
List<TreeNode<T>> data = new List<TreeNode<T>>();
|
||
if (filter != null)
|
||
{
|
||
if (filter.IsMultipleDb)
|
||
{
|
||
var conns = GetAllDbConns();//查询redis里面的数据库连接
|
||
foreach (var conn in conns)
|
||
{
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
var contextEntities = context.GetTreeOrderEntities(exp, filter, orgExpression, out resultList, isTracking, realPaths);
|
||
if (contextEntities.Any())
|
||
{
|
||
var dbConn = TenantInfoMiddleware.EnDbConn(conn);
|
||
contextEntities.ForEach(i => i.Node.DbConn = dbConn);
|
||
data.AddRange(contextEntities);
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
else if (filter.IsSpecifyDb)
|
||
{
|
||
string enConn = GetSpecifyDb(filter);
|
||
using (var context = new EfDbContext(enConn))
|
||
{
|
||
var contexEntities = context.GetTreeOrderEntities(exp, filter, orgExpression, out resultList, isTracking, realPaths);
|
||
if (contexEntities != null && contexEntities.Any())
|
||
{
|
||
data.AddRange(contexEntities);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
data = this.UnitOfWork.GetTreeOrderEntities(exp, filter, orgExpression, out resultList, isTracking, realPaths).ToList();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
data = this.UnitOfWork.GetTreeOrderEntities(exp, filter, orgExpression, out resultList, isTracking, realPaths).ToList();
|
||
}
|
||
if (filter != null && filter.SelectField.Any())
|
||
{
|
||
realPaths = SelectFieldInclude(realPaths, filter.SelectField.ToList());
|
||
NavigationDeal(realPaths, resultList, filter.SelectField.ToArray(), filter.DataRule.ToArray(),
|
||
filter.OrgRule, filter.OrgId, filter.IgnoreOrgRule, filter.IgnoreDataRule,
|
||
isTracking, filter.IsMultipleDb, filter.IsSpecifyDb, filter.SpecifyDbConn);
|
||
}
|
||
return data;
|
||
}
|
||
|
||
private void InitTreeNode<T>(List<IList<T>> dataLists, TreeNode<T> parentNode) where T
|
||
: TreeEntityBase<T>, new()
|
||
{
|
||
|
||
if (dataLists.Count <= parentNode.Level)
|
||
return;
|
||
List<T> levalData = new List<T>();
|
||
if (parentNode.Node != null)
|
||
{
|
||
levalData = dataLists[parentNode.Level].Where(i => i.PARENT_ID == parentNode.Node.ID).ToList();
|
||
}
|
||
else
|
||
{
|
||
levalData = dataLists[parentNode.Level].ToList();
|
||
}
|
||
IList<T> childData = new List<T>();
|
||
if (parentNode.Level < dataLists.Count - 1)
|
||
{
|
||
childData = dataLists[parentNode.Level + 1];
|
||
}
|
||
//构造node节点
|
||
foreach (var d in levalData)
|
||
{
|
||
TreeNode<T> node = new Core.TreeNode<T>();
|
||
parentNode.Children.Add(node);
|
||
node.Node = d;
|
||
node.Level = parentNode.Level + 1;
|
||
node.IsLeaf = d.IS_LEAF;
|
||
node.Children = new List<TreeNode<T>>();
|
||
if (childData.Any(i => i.PARENT_ID == d.ID))
|
||
{
|
||
node.IsLeaf = false;
|
||
InitTreeNode(dataLists, node);
|
||
|
||
}
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 分级构造树的数据
|
||
/// </summary>
|
||
/// <typeparam name="T"></typeparam>
|
||
/// <param name="expression"></param>
|
||
/// <param name="filter"></param>
|
||
/// <param name="paths"></param>
|
||
/// <param name="data"></param>
|
||
/// <param name="dataLists"></param>
|
||
private void InitDownTree<T>(Expression<Func<T, bool>> expression, BaseFilter filter, string[] paths, IList<T> data, List<IList<T>> dataLists) where T : TreeEntityBase<T>, new()
|
||
{
|
||
dataLists.Add(data);
|
||
if (dataLists.Count < filter.Level || filter.Level == -1)
|
||
{
|
||
var dataIds = dataLists[dataLists.Count - 1].Select(i => i.ID).ToList();
|
||
var secExpression = expression.And(i => dataIds.Contains(i.PARENT_ID ?? Guid.Empty));
|
||
var childData = this.GetOrderEntities(secExpression, filter, null, (!filter?.IsNoTranking) ?? true, paths).ToList();
|
||
if (childData.Any())
|
||
{
|
||
InitDownTree(expression, filter, paths, childData, dataLists);
|
||
}
|
||
}
|
||
}
|
||
|
||
public IEnumerable<T> GetOrderEntities<T>(Expression<Func<T, bool>> expression, BaseFilter filter,
|
||
bool isTracking = true, params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetOrderEntities(expression, filter, null, isTracking, paths);
|
||
}
|
||
public IEnumerable<T> GetOrderEntities<T>(Expression<Func<T, bool>> expression, BaseFilter filter, Dictionary<string, string> orders,
|
||
bool isTracking = true, params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetOrderEntities(expression, filter, orders, null, isTracking, paths);
|
||
}
|
||
|
||
public IEnumerable<T> GetOrderEntities<T>(Expression<Func<T, bool>> expression, BaseFilter filter, Dictionary<string, string> orders,
|
||
Action<IOrderable<T>> orderBy,
|
||
bool isTracking = true, params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, filter, paths, orders, out orgExpression, out realPaths, out realOrders, false);
|
||
List<string> selectFields = new List<string>();
|
||
if (filter != null && Api.AppContext.CurrentSession.DataRule != null && !filter.IgnoreDataRule && !filter.DataRule.Any())
|
||
{
|
||
filter.DataRule = Api.AppContext.CurrentSession.DataRule;
|
||
}
|
||
if (filter != null && filter.SelectField != null && filter.SelectField.Any())
|
||
{
|
||
selectFields = filter.SelectField.ToList();
|
||
AppendSelectedField<T>(selectFields);
|
||
}
|
||
//支持多库联合查询
|
||
var entities = new List<T>();
|
||
if (filter != null)
|
||
{
|
||
if (filter.IsMultipleDb)
|
||
{
|
||
var conns = GetAllDbConns();//查询redis里面的数据库连接
|
||
foreach (var conn in conns)
|
||
{
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
var contextEntities = context.GetOrderEntities<T>(exp, realOrders, orderBy, filter == null ? null : selectFields.ToArray(), isTracking, realPaths);
|
||
if (contextEntities.Any())
|
||
{
|
||
var dbConn = TenantInfoMiddleware.EnDbConn(conn);
|
||
contextEntities.ForEach(i => i.DbConn = dbConn);
|
||
entities.AddRange(contextEntities);
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
else if (filter.IsSpecifyDb)
|
||
{
|
||
string enConn = GetSpecifyDb(filter);
|
||
using (var context = new EfDbContext(enConn))
|
||
{
|
||
entities = context.GetOrderEntities<T>(exp, realOrders, orderBy, filter == null ? null : selectFields.ToArray(), isTracking, realPaths).ToList();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
entities = this.UnitOfWork.GetOrderEntities<T>(exp, realOrders, orderBy, filter == null ? null : selectFields.ToArray(), isTracking, realPaths).ToList();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
entities = this.UnitOfWork.GetOrderEntities<T>(exp, realOrders, orderBy, filter == null ? null : selectFields.ToArray(), isTracking, realPaths).ToList();
|
||
}
|
||
|
||
//导航属性
|
||
if (filter != null && filter.SelectField.ToArray().Any())
|
||
{
|
||
realPaths = SelectFieldInclude(realPaths, filter.SelectField.ToList());
|
||
NavigationDeal(realPaths, entities.ToList(), filter.SelectField.ToArray(), filter.DataRule.ToArray(),
|
||
filter.OrgRule, filter.OrgId, filter.IgnoreOrgRule, filter.IgnoreDataRule, isTracking,
|
||
filter.IsMultipleDb, filter.IsSpecifyDb, filter.SpecifyDbConn);
|
||
}
|
||
if (entities != null && entities.Any())
|
||
this.FillGetEntitySysParam(entities, filter, paths);
|
||
return entities;
|
||
}
|
||
|
||
private string GetSpecifyDb(BaseFilter filter)
|
||
{
|
||
var enConn = "";
|
||
if (!string.IsNullOrEmpty(filter.SpecifyTenant))
|
||
{
|
||
enConn = TenantInfoMiddleware.GetDbConn(filter.SpecifyTenant);
|
||
}
|
||
else if (!string.IsNullOrEmpty(filter.SpecifyDbConn))
|
||
{
|
||
enConn = EncryptHelper.AesDecrypt(filter.SpecifyDbConn, DesKey);
|
||
}
|
||
else
|
||
{
|
||
enConn = ConfigurationManager.ConnectionStrings["default"];
|
||
}
|
||
return enConn;
|
||
}
|
||
|
||
public PagedResultDto<T> GetPageEntities<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetPageEntities(expression, pageFilter, paths);
|
||
}
|
||
|
||
public PagedResultDto<T> GetOrderPageEntities<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetOrderPageEntities(expression, pageFilter, 0, 0, paths);
|
||
}
|
||
public PagedResultDto<T> GetOrderPageEntities<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
int pageSize, int startIndex,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetOrderPageEntities(expression, pageFilter, pageSize, startIndex, (!pageFilter?.IsNoTranking) ?? true, paths);
|
||
}
|
||
|
||
public PagedResultDto<T> GetMultipleDbPageEntities<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
if (pageFilter == null)
|
||
throw new Exception("Filter参数不能为空");
|
||
if (expression == null)
|
||
expression = t => true;
|
||
pageFilter.IsMultipleDb = true;
|
||
//expression = expression.And(i => i.CREATE_TIME > pageFilter.StartTime);
|
||
return this.GetOrderPageEntities(expression, pageFilter, null, pageFilter.Limit, pageFilter.Start, null, (!pageFilter?.IsNoTranking) ?? true, paths);
|
||
}
|
||
|
||
|
||
public PagedResultDto<T> GetOrderPageEntities<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
int pageSize, int startIndex, bool isTracking = true,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetOrderPageEntities<T>(expression, pageFilter, null, pageSize, startIndex, isTracking, paths);
|
||
}
|
||
public PagedResultDto<T> GetOrderPageEntities<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
Dictionary<string, string> orders,
|
||
int pageSize, int startIndex, bool isTracking = true,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return this.GetOrderPageEntities<T>(expression, pageFilter, orders, pageSize, startIndex, null, isTracking, paths);
|
||
}
|
||
|
||
public PagedResultDto<T> GetOrderPageEntities<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
Dictionary<string, string> orders,
|
||
int pageSize, int startIndex, Action<IOrderable<T>> orderBy, bool isTracking = true,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
PagedResultDto<T> ret = new PagedResultDto<T>();
|
||
//查询所有数据
|
||
if (pageFilter != null && pageFilter.IsAllLoad)
|
||
{
|
||
var data = this.GetOrderEntities<T>(expression, pageFilter, orders, isTracking, paths).ToList();
|
||
ret.Items = data;
|
||
ret.TotalCount = data.Count;
|
||
return ret;
|
||
}
|
||
if (pageFilter != null && !pageFilter.IgnoreDataRule && !pageFilter.DataRule.Any())
|
||
{
|
||
pageFilter.DataRule = Api.AppContext.CurrentSession.DataRule;
|
||
}
|
||
//分页查询
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, pageFilter, paths, orders, out orgExpression, out realPaths, out realOrders, false);
|
||
int tempPageSize = 0;
|
||
int tempStartIndex = 0;
|
||
List<string> selectFields = new List<string>();
|
||
//分页参数
|
||
if (pageSize != 0)
|
||
{
|
||
tempPageSize = pageSize;
|
||
tempStartIndex = startIndex;
|
||
}
|
||
else if (pageFilter != null)
|
||
{
|
||
tempStartIndex = pageFilter.Start;
|
||
tempPageSize = pageFilter.Limit;
|
||
}
|
||
//查询字段处理
|
||
if (pageFilter != null && pageFilter.SelectField != null && pageFilter.SelectField.Any())
|
||
{
|
||
selectFields = pageFilter.SelectField.ToList();
|
||
AppendSelectedField<T>(selectFields);
|
||
}
|
||
//支持多库联合查询
|
||
ret = MutilDbOrderPaged(pageFilter, pageSize, startIndex, orderBy, isTracking, realPaths, realOrders,
|
||
exp, tempPageSize, tempStartIndex, selectFields);
|
||
//字段查询导航处理
|
||
if (selectFields.Any())
|
||
{
|
||
//导航属性
|
||
realPaths = SelectFieldInclude(realPaths, pageFilter.SelectField.ToList());
|
||
NavigationDeal(realPaths, ret.Items, pageFilter.SelectField.ToArray(), pageFilter.DataRule.ToArray(),
|
||
pageFilter.OrgRule, pageFilter.OrgId, pageFilter.IgnoreOrgRule, pageFilter.IgnoreDataRule, isTracking,
|
||
pageFilter.IsMultipleDb, pageFilter.IsSpecifyDb, pageFilter.SpecifyDbConn);
|
||
}
|
||
//系统属性
|
||
if (ret != null && ret.Items.Any())
|
||
this.FillGetEntitySysParam(ret.Items, pageFilter, paths);
|
||
return ret;
|
||
}
|
||
|
||
private PagedResultDto<T> MutilDbOrderPaged<T>(BasePageFilter pageFilter, int pageSize, int startIndex, Action<IOrderable<T>> orderBy,
|
||
|
||
bool isTracking, string[] realPaths, Dictionary<string, DbOrder> realOrders, Expression<Func<T, bool>> exp,
|
||
|
||
int tempPageSize, int tempStartIndex, List<string> selectFields) where T : MesEntityBase, new()
|
||
|
||
{
|
||
|
||
PagedResultDto<T> ret = new PagedResultDto<T>();
|
||
|
||
var entities = new List<T>();
|
||
|
||
var totalCount = 0;
|
||
|
||
if (pageFilter != null)
|
||
|
||
{
|
||
if (pageFilter.IsMultipleDb)
|
||
{
|
||
|
||
|
||
var conns = GetAllDbConns();//查询redis里面的数据库连接
|
||
|
||
var dbCount = conns.Count;
|
||
|
||
if (dbCount == 0)
|
||
|
||
return ret;
|
||
|
||
//Action<IOrderable<T>> multipleOrderBy = i => i.Asc(p => p.CREATE_TIME);
|
||
|
||
|
||
|
||
if (realOrders == null || !realOrders.Any())
|
||
{
|
||
|
||
realOrders = new Dictionary<string, DbOrder>
|
||
{
|
||
{ "CREATE_TIME", DbOrder.DESC }
|
||
};
|
||
|
||
}
|
||
|
||
|
||
if (dbCount == 1 || tempStartIndex == 0)
|
||
{
|
||
|
||
foreach (var conn in conns)
|
||
{
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
|
||
var contextEntities = context.GetOrderPageEntities<T>(exp, realOrders, selectFields?.ToArray(), tempPageSize,
|
||
tempStartIndex, null, isTracking, realPaths);
|
||
totalCount += contextEntities.TotalCount;
|
||
if (contextEntities.Items.Any())
|
||
{
|
||
var dbConn = TenantInfoMiddleware.EnDbConn(conn);
|
||
contextEntities.Items.ForEach(i => i.DbConn = dbConn);
|
||
entities.AddRange(contextEntities.Items);
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
//排序
|
||
if (dbCount > 1)
|
||
{
|
||
entities = ReOrderBy(realOrders, entities);
|
||
entities = entities.Skip(tempStartIndex).Take(tempPageSize).ToList();
|
||
}
|
||
|
||
}
|
||
|
||
else
|
||
{
|
||
|
||
var perStartIndex = tempStartIndex / dbCount;
|
||
|
||
Dictionary<int, List<T>> dbEntities = new Dictionary<int, List<T>>();
|
||
|
||
Dictionary<int, int> entityCount = new Dictionary<int, int>();
|
||
|
||
//第一次查询确定范围
|
||
|
||
var connIndex = 0;
|
||
|
||
var type = typeof(T);
|
||
|
||
var order = realOrders.FirstOrDefault();
|
||
//获取字段
|
||
var prop = type.GetProperty(order.Key);
|
||
|
||
var propType = prop.PropertyType;
|
||
//GetGenericTypeDefinition
|
||
if (propType.FullName.Contains(typeof(Nullable).ToString()))
|
||
{
|
||
propType = Nullable.GetUnderlyingType(propType);
|
||
}
|
||
|
||
var totalEnties = new List<T>();
|
||
|
||
foreach (var conn in conns)
|
||
{
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
var contextEntities = context.GetOrderPageEntities<T>(exp, realOrders, selectFields?.ToArray(), tempPageSize, perStartIndex, null, isTracking, realPaths);
|
||
totalCount += contextEntities.TotalCount;
|
||
if (contextEntities.Items.Any())
|
||
{
|
||
dbEntities.Add(connIndex, contextEntities.Items.ToList());
|
||
entityCount.Add(connIndex, contextEntities.Items.Count());
|
||
totalEnties.AddRange(contextEntities.Items);
|
||
}
|
||
else
|
||
{
|
||
dbEntities.Add(connIndex, new List<T>());
|
||
entityCount.Add(connIndex, 0);
|
||
}
|
||
|
||
}
|
||
|
||
connIndex++;
|
||
}
|
||
|
||
//重新排序
|
||
if (totalEnties.Count > 0)
|
||
{
|
||
totalEnties = ReOrderBy(realOrders, totalEnties);
|
||
//最小/最大
|
||
if (exp == null)
|
||
exp = t => true;
|
||
var pointTime = DateTime.Now;
|
||
FilterRule rule = new FilterRule();
|
||
rule.Field = order.Key;
|
||
if (propType.Name == "DateTime")
|
||
{
|
||
rule.Value = ((DateTime)prop.GetValue(totalEnties.FirstOrDefault())).ToString("yyyy-MM-dd HH:mm:ss.ffffff");
|
||
}
|
||
else
|
||
{
|
||
rule.Value = prop.GetValue(totalEnties.FirstOrDefault()).ToString();
|
||
}
|
||
|
||
if (order.Value.ToString() == "DESC")
|
||
{
|
||
rule.Operate = FilterOperate.LessThanOrEqual;
|
||
}
|
||
else
|
||
{
|
||
rule.Operate = FilterOperate.GreaterThanOrEqual;
|
||
}
|
||
var filterExp = rule.BuildExpression<T>();
|
||
|
||
exp = exp.And(filterExp);
|
||
}
|
||
|
||
//第二次查询
|
||
|
||
connIndex = 0;
|
||
|
||
totalEnties.Clear();
|
||
|
||
var oldOffSet = perStartIndex * dbCount;
|
||
|
||
foreach (var conn in conns)
|
||
{
|
||
var express = exp;
|
||
using (var context = new EfDbContext(conn))
|
||
{
|
||
if (dbEntities[connIndex].Count > 0)
|
||
{
|
||
FilterRule rule = new FilterRule();
|
||
rule.Field = order.Key;
|
||
|
||
if (propType.Name == "DateTime")
|
||
{
|
||
rule.Value = ((DateTime)prop.GetValue(dbEntities[connIndex].LastOrDefault())).ToString("yyyy-MM-dd HH:mm:ss.ffffff");
|
||
}
|
||
else
|
||
{
|
||
rule.Value = prop.GetValue(dbEntities[connIndex].LastOrDefault()).ToString();
|
||
}
|
||
if (order.Value.ToString() == "DESC")
|
||
{
|
||
rule.Operate = FilterOperate.GreaterThanOrEqual;
|
||
}
|
||
else
|
||
{
|
||
rule.Operate = FilterOperate.LessThanOrEqual;
|
||
}
|
||
var filterExp = rule.BuildExpression<T>();
|
||
express = express.And(filterExp);
|
||
}
|
||
|
||
var contextEntities = context.GetEntities<T>(express, selectFields?.ToArray(), isTracking, realPaths);
|
||
if (contextEntities.Any())
|
||
{
|
||
totalEnties.AddRange(contextEntities);
|
||
}
|
||
var moreEntitiesCount = contextEntities.Count() - entityCount[connIndex];//多出的数据条数
|
||
oldOffSet -= moreEntitiesCount;
|
||
}
|
||
connIndex++;
|
||
}
|
||
//确定全局的OffSet后，返回数据
|
||
totalEnties = ReOrderBy(realOrders, totalEnties);
|
||
entities = totalEnties.Skip((tempStartIndex - oldOffSet)).Take(tempPageSize).ToList();
|
||
}
|
||
}
|
||
else if (pageFilter.IsSpecifyDb)
|
||
{
|
||
string enConn = GetSpecifyDb(pageFilter);
|
||
using (var context = new EfDbContext(enConn))
|
||
{
|
||
var contextEntities = context.GetOrderPageEntities<T>(exp, realOrders, selectFields?.ToArray(), tempPageSize,
|
||
tempStartIndex, orderBy, isTracking, realPaths);
|
||
totalCount = contextEntities.TotalCount;
|
||
if (contextEntities.Items.Any())
|
||
entities.AddRange(contextEntities.Items);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
totalCount = UnitWorkOrderPaged(orderBy, isTracking, realPaths, realOrders, exp, tempPageSize, tempStartIndex, selectFields, entities);
|
||
}
|
||
}
|
||
else
|
||
|
||
{
|
||
|
||
totalCount = UnitWorkOrderPaged(orderBy, isTracking, realPaths, realOrders, exp, tempPageSize, tempStartIndex, selectFields, entities);
|
||
}
|
||
ret.Items = entities;
|
||
ret.TotalCount = totalCount;
|
||
return ret;
|
||
|
||
}
|
||
|
||
private int UnitWorkOrderPaged<T>(Action<IOrderable<T>> orderBy, bool isTracking, string[] realPaths, Dictionary<string, DbOrder> realOrders, Expression<Func<T, bool>> exp, int tempPageSize, int tempStartIndex, List<string> selectFields, List<T> entities) where T : MesEntityBase, new()
|
||
{
|
||
int totalCount;
|
||
var contextEntities = this.UnitOfWork.GetOrderPageEntities<T>(exp, realOrders, selectFields?.ToArray(), tempPageSize,
|
||
tempStartIndex, orderBy, isTracking, realPaths);
|
||
totalCount = contextEntities.TotalCount;
|
||
if (contextEntities.Items.Any())
|
||
{
|
||
entities.AddRange(contextEntities.Items);
|
||
}
|
||
|
||
return totalCount;
|
||
}
|
||
|
||
private static List<T> ReOrderBy<T>(Dictionary<string, DbOrder> realOrders, List<T> entities) where T : MesEntityBase, new()
|
||
{
|
||
var queryable = entities.AsQueryable();
|
||
|
||
queryable = queryable.SetQueryableOrder(realOrders.FirstOrDefault().Key, realOrders.FirstOrDefault().Value.ToString());
|
||
|
||
var linq = new Orderable<T>(queryable);
|
||
|
||
queryable = linq.Queryable;
|
||
|
||
entities = queryable.ToList();
|
||
return entities;
|
||
}
|
||
|
||
public PagedResultDto<T> GetOrderPageEntities<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter, string[] selectField,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
if (pageFilter == null)
|
||
pageFilter = new BasePageFilter();
|
||
pageFilter.SelectField = selectField;
|
||
return this.GetOrderPageEntities<T>(expression, pageFilter, paths);
|
||
}
|
||
|
||
private void NavigationDeal<T>(string[] realPaths, IEnumerable<T> list, string[] selecedFields, string[] dataRules, List<Guid> orgRules, Guid? orgId,
|
||
bool isIgnoreOrgRule, bool isIgnoreDataRule, bool isNoTranking, bool isMultipleDb, bool isSpecifyDb, string specifyDbConn) where T : MesEntityBase, new()
|
||
{
|
||
if (realPaths != null && realPaths.Any())
|
||
{
|
||
//var tmpList = list;
|
||
var hasDataList = new Hashtable();
|
||
hasDataList["."] = list;
|
||
var hasDealNavPath = new List<string>();
|
||
foreach (var path in realPaths)
|
||
{
|
||
var splitPaths = path.Split('.').ToArray();
|
||
var type = typeof(T);
|
||
var curentPath = ".";
|
||
var isICollection = false;
|
||
var navTableName = "";
|
||
foreach (var spath in splitPaths)
|
||
{
|
||
navTableName += spath + ".";
|
||
dynamic curentList = hasDataList[curentPath];
|
||
if (curentList == null)
|
||
break;
|
||
|
||
PropertyInfo navProp = null;
|
||
PropertyInfo idProp = null;
|
||
var fieldInfos = type.GetProperties();
|
||
var theType = type;
|
||
EFModelForeignKey foreignKey = null;
|
||
var isOneOnOne = false;
|
||
|
||
foreach (var p in fieldInfos)
|
||
{
|
||
if (p.Name == spath)
|
||
{
|
||
navProp = p;
|
||
type = p.PropertyType;
|
||
isICollection = false;
|
||
foreignKey = this.UnitOfWork.GetModelForeignKey(theType.Name, spath);
|
||
if (typeof(System.Collections.IEnumerable).IsAssignableFrom(type))
|
||
{
|
||
isICollection = true;
|
||
var generTypeFullName = type.GenericTypeArguments[0].FullName;
|
||
type = ReflectHelper.FindTypeInCurrentDomain(generTypeFullName);
|
||
idProp = type.GetProperty(foreignKey.ForeignFieldName);
|
||
}
|
||
else
|
||
{
|
||
idProp = theType.GetProperty(foreignKey.ForeignFieldName);
|
||
if (idProp == null)
|
||
{
|
||
idProp = theType.GetProperty("ID");
|
||
isOneOnOne = true;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if (idProp == null || navProp == null)
|
||
throw new Exception($"导航属性{path}中的{spath}属性异常，请确认");
|
||
curentPath += "/" + navProp.Name;
|
||
if (!hasDealNavPath.Contains(navTableName))
|
||
{
|
||
//筛选字段
|
||
List<string> typeSelectFields = new List<string>();
|
||
foreach (var f in selecedFields)
|
||
{
|
||
//导航属性
|
||
if (f.StartsWith(navTableName))
|
||
{
|
||
var tmpField = f.Replace(navTableName, "");
|
||
if (tmpField.IndexOf(".") < 0)
|
||
typeSelectFields.Add(tmpField);
|
||
else
|
||
{
|
||
//为了增加下级的导航属性
|
||
var nextNavIndex = tmpField.IndexOf(".");
|
||
var navField = tmpField.Substring(0, nextNavIndex);
|
||
if (!typeSelectFields.Contains(navField))
|
||
typeSelectFields.Add(navField);
|
||
}
|
||
}
|
||
}
|
||
|
||
BaseFilter filter = new BaseFilter();
|
||
filter.SelectField = typeSelectFields;
|
||
filter.DataRule = dataRules;
|
||
filter.IgnoreDataRule = isIgnoreDataRule;
|
||
filter.IsNoTranking = isNoTranking;
|
||
filter.OrgId = orgId;
|
||
filter.IgnoreOrgRule = isIgnoreOrgRule;
|
||
filter.OrgRule = orgRules;
|
||
filter.IsMultipleDb = isMultipleDb;
|
||
filter.IsSpecifyDb = isSpecifyDb;
|
||
filter.SpecifyDbConn = specifyDbConn;
|
||
List<Guid> ids = new List<Guid>();
|
||
if (!typeSelectFields.Contains("ID"))
|
||
typeSelectFields.Add("ID");
|
||
if (isOneOnOne)
|
||
typeSelectFields.Add(foreignKey.ForeignFieldName);
|
||
//增加外键的查询
|
||
var methodInfo = this.GetType().GetMethod("AppendSelectedField", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static);
|
||
if (methodInfo != null)
|
||
{
|
||
methodInfo.MakeGenericMethod(type).Invoke(this, new object[] { typeSelectFields });
|
||
}
|
||
//this.GetType().GetMethod("AppendSelectedField", new Type[] { typeof(string[]) })
|
||
// .MakeGenericMethod(type).Invoke(this, new object[] { selecedFields });
|
||
//集合
|
||
//var filterGroup = new FilterGroup();
|
||
//filter.FilterGroup.Groups.Add(filterGroup);
|
||
//filterGroup.IsAnd = false;
|
||
List<FilterRule> filterRules = new List<FilterRule>();
|
||
bool searchFlag = false;
|
||
if (isICollection)//对多
|
||
{
|
||
if (!typeSelectFields.Contains(idProp.Name))
|
||
typeSelectFields.Add(idProp.Name);
|
||
|
||
foreach (var obj in curentList)
|
||
{
|
||
if (obj.ID != null)
|
||
{
|
||
var val = Convert.ToString(obj.ID);
|
||
if (!string.IsNullOrEmpty(val) && !filterRules.Any(x => x.Value.ToString() == val))
|
||
{
|
||
FilterRule rule = new FilterRule();
|
||
rule.Field = idProp.Name;
|
||
rule.Operate = FilterOperate.Equal;
|
||
rule.Value = val;
|
||
//filterGroup.Rules.Add(rule);
|
||
filterRules.Add(rule);
|
||
searchFlag = true;
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
}
|
||
else//对1
|
||
{
|
||
foreach (var obj in curentList)
|
||
{
|
||
var objVal = theType.GetProperty(idProp.Name).GetValue(obj);
|
||
if (objVal != null)
|
||
{
|
||
var val = Convert.ToString(objVal);
|
||
if (!string.IsNullOrEmpty(val) && !filterRules.Any(x => x.Value.ToString() == val))
|
||
{
|
||
FilterRule newRule = new FilterRule();
|
||
newRule.Field = "ID";
|
||
if (isOneOnOne)
|
||
{
|
||
newRule.Field = foreignKey.ForeignFieldName;
|
||
}
|
||
newRule.Operate = FilterOperate.Equal;
|
||
newRule.Value = val;
|
||
//filterGroup.Rules.Add(newRule);
|
||
filterRules.Add(newRule);
|
||
searchFlag = true;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
if (!searchFlag)
|
||
break;
|
||
var getEntities = this.GetType().GetMethod("GetEntities", BindingFlags.Instance | BindingFlags.NonPublic);
|
||
if (getEntities == null)
|
||
{
|
||
throw new Exception("GetEntities不存在此方法");
|
||
}
|
||
List<dynamic> navLists = new List<dynamic>();
|
||
if (navProp != null && idProp != null)
|
||
{
|
||
//500查一次
|
||
int ruleLimit = 1000;
|
||
var startRule = 0;
|
||
var filterGroup = new FilterGroup();
|
||
filterGroup.IsAnd = false;
|
||
foreach (var rule in filterRules)
|
||
{
|
||
startRule++;
|
||
filterGroup.Rules.Add(rule);
|
||
if (startRule >= ruleLimit)
|
||
{
|
||
GetRroupRules(type, filter, getEntities, navLists, filterGroup);
|
||
filterGroup.Rules.Clear();
|
||
startRule = 0;
|
||
}
|
||
}
|
||
if (filterGroup.Rules.Count > 0)
|
||
GetRroupRules(type, filter, getEntities, navLists, filterGroup);
|
||
hasDataList[curentPath] = navLists;
|
||
foreach (var t in curentList)
|
||
{
|
||
//对1导航
|
||
if (!isICollection)
|
||
{
|
||
var objVal = t.GetType().GetProperty(idProp.Name).GetValue(t);
|
||
if (objVal == null)
|
||
continue;
|
||
var navId = Convert.ToString(objVal);
|
||
if (string.IsNullOrEmpty(navId))
|
||
continue;
|
||
foreach (var s in navLists)
|
||
{
|
||
if (!isOneOnOne)
|
||
{
|
||
if (s.ID.ToString() == navId)
|
||
{
|
||
t.GetType().GetProperty(navProp.Name).SetValue(t, s);
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var val = s.GetType().GetProperty(foreignKey.ForeignFieldName).GetValue(s);
|
||
if (val != null && val.ToString() == navId)
|
||
{
|
||
t.GetType().GetProperty(navProp.Name).SetValue(t, s);
|
||
}
|
||
}
|
||
|
||
}
|
||
} //对多导航
|
||
else
|
||
{
|
||
var id = t.ID.ToString();
|
||
var colNavList = type.GetListObject();
|
||
foreach (var s in navLists)
|
||
{
|
||
var objVal = s.GetType().GetProperty(idProp.Name).GetValue(s);
|
||
if (objVal == null)
|
||
continue;
|
||
var navId = Convert.ToString(objVal);
|
||
if (string.IsNullOrEmpty(navId))
|
||
continue;
|
||
if (navId == id)
|
||
{
|
||
var methodInfos = colNavList.GetType().GetMethod("Add");
|
||
methodInfos.Invoke(colNavList, new object[] { s });
|
||
}
|
||
}
|
||
t.GetType().GetProperty(navProp.Name).SetValue(t, colNavList);
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
hasDealNavPath.Add(navTableName);
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private void GetRroupRules(Type type, BaseFilter filter, MethodInfo getEntities, List<dynamic> navLists, FilterGroup filterGroup)
|
||
{
|
||
filter.FilterGroup.Groups.Add(filterGroup);
|
||
dynamic navGroupList = getEntities.MakeGenericMethod(type).Invoke(this, new object[] { filter });
|
||
if (navGroupList != null)
|
||
{
|
||
navLists.AddRange(navGroupList);
|
||
}
|
||
}
|
||
|
||
//
|
||
public async Task<PagedResultDto<T>> GetOrderPageEntitiesSync<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return await this.GetOrderPageEntitiesSync(expression, pageFilter, 0, 0, paths);
|
||
}
|
||
public async Task<PagedResultDto<T>> GetOrderPageEntitiesSync<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
int pageSize, int startIndex,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return await this.GetOrderPageEntitiesSync(expression, pageFilter, pageSize, startIndex, (!pageFilter?.IsNoTranking) ?? true, paths);
|
||
}
|
||
|
||
public async Task<PagedResultDto<T>> GetOrderPageEntitiesSync<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
int pageSize, int startIndex, bool isTracking = true,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return await this.GetOrderPageEntitiesSync<T>(expression, pageFilter, null, pageSize, startIndex, isTracking, paths);
|
||
}
|
||
public async Task<PagedResultDto<T>> GetOrderPageEntitiesSync<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
Dictionary<string, string> orders,
|
||
int pageSize, int startIndex, bool isTracking = true,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
return await this.GetOrderPageEntitiesSync<T>(expression, pageFilter, orders, pageSize, startIndex, null, isTracking, paths);
|
||
}
|
||
|
||
public async Task<PagedResultDto<T>> GetOrderPageEntitiesSync<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
Dictionary<string, string> orders,
|
||
int pageSize, int startIndex, Action<IOrderable<T>> orderBy, bool isTracking = true,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, pageFilter, paths, orders, out orgExpression, out realPaths, out realOrders, false);
|
||
int tempPageSize = 0;
|
||
int tempStartIndex = 0;
|
||
if (pageSize != 0)
|
||
{
|
||
tempPageSize = pageSize;
|
||
tempStartIndex = startIndex;
|
||
}
|
||
else if (pageFilter != null)
|
||
{
|
||
tempStartIndex = pageFilter.Start;
|
||
tempPageSize = pageFilter.Limit;
|
||
}
|
||
var ret = await this.UnitOfWork.GetOrderPageEntitiesSync<T>(exp, realOrders, tempPageSize,
|
||
tempStartIndex, orderBy, isTracking, realPaths);
|
||
if (ret != null && ret.Items.Any())
|
||
this.FillGetEntitySysParam(ret.Items, pageFilter, paths);
|
||
return ret;
|
||
}
|
||
|
||
|
||
|
||
public T GetEntityByRedis<T>(string key, Guid orgid) where T : MesEntityBase, new()
|
||
{
|
||
var realOrgId = Api.AppContext.CurrentSession?.RootOrgId ?? orgid;
|
||
Guid guidKey = Guid.Empty;
|
||
if (Guid.TryParse(key, out guidKey))
|
||
{
|
||
return GetEntityByRedisMethod<T>(key, realOrgId, true).Result;
|
||
}
|
||
else
|
||
{
|
||
return GetEntityByRedisMethod<T>(key, realOrgId, false).Result;
|
||
}
|
||
|
||
|
||
|
||
}
|
||
public T GetEntityByRedis<T>(Guid key, Guid orgid) where T : MesEntityBase, new()
|
||
{
|
||
var realOrgId = Api.AppContext.CurrentSession?.RootOrgId ?? orgid;
|
||
return GetEntityByRedisMethod<T>(key.ToString(), realOrgId, true).Result;
|
||
|
||
}
|
||
|
||
private async Task<T> GetEntityByRedisMethod<T>(string key, Guid orgid, bool isGuid) where T : MesEntityBase, new()
|
||
{
|
||
|
||
// CsRedisManager manager = ServiceLocator.Instance.GetService<CsRedisManager>();
|
||
var type = typeof(T);
|
||
//manager.
|
||
var perKey = "{" + type.Name + "}";
|
||
var keys = perKey + "_" + key + "_" + orgid;
|
||
T entity = null;
|
||
if (CsRedisManager.KeyExists(keys) && ConfigurationManager.IsRedis)
|
||
entity = await CsRedisManager.StringGetAsync<T>(keys);
|
||
else
|
||
{
|
||
var baseFilter = new BaseFilter(orgid);
|
||
baseFilter.IsNoTranking = true;
|
||
baseFilter.IgnoreDataRule = true;
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass != null)
|
||
{
|
||
|
||
if (redisClass.DicKeys.Any())
|
||
{
|
||
var filterGroup = new FilterGroup();
|
||
filterGroup.IsAnd = false;
|
||
foreach (var redisKey in redisClass.DicKeys)
|
||
{
|
||
|
||
if (!isGuid && redisKey.Key.EndsWith("ID"))
|
||
{
|
||
//不是ID类型，并且是ID字段，则不增加条件
|
||
}
|
||
else
|
||
{
|
||
filterGroup.Rules.Add(new FilterRule(redisKey.Key, key, FilterOperate.Equal));
|
||
}
|
||
|
||
}
|
||
baseFilter.FilterGroup.Groups.Add(filterGroup);
|
||
}
|
||
else
|
||
{
|
||
throw new Exception("未配置rediskey");
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
throw new Exception("未配置成redis类型");
|
||
}
|
||
entity = this.GetEntity<T>(null, baseFilter);
|
||
if (entity != null && ConfigurationManager.IsRedis)
|
||
{
|
||
await CsRedisManager.StringSetAsync(keys, entity);
|
||
}
|
||
}
|
||
return entity;
|
||
|
||
}
|
||
|
||
public List<T> GetEntitiesByRedis<T>(Expression<Func<T, bool>> expression, BaseFilter filter) where T : MesEntityBase, new()
|
||
{
|
||
filter.SelectField = new string[] { };
|
||
var realOrgId = Api.AppContext.CurrentSession?.RootOrgId ?? filter.OrgId;
|
||
filter.OrgId = realOrgId;
|
||
var list = GetEntitiesByRedis<T>(filter).Result;
|
||
if (expression != null)
|
||
list = list.Where(expression.Compile()).ToList();
|
||
return list;
|
||
}
|
||
public bool IsAny<T>(Expression<Func<T, bool>> expression, BaseFilter filter) where T : MesEntityBase, new()
|
||
{
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, filter, null, null, out orgExpression, out realPaths, out realOrders, false);
|
||
return this.UnitOfWork.GetCount<T>(exp) > 0;
|
||
}
|
||
|
||
|
||
public int GetCount<T>(Expression<Func<T, bool>> expression, BaseFilter filter) where T : MesEntityBase, new()
|
||
{
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, filter, null, null, out orgExpression, out realPaths, out realOrders, false);
|
||
return this.UnitOfWork.GetCount(exp);
|
||
}
|
||
|
||
|
||
|
||
public async Task<List<T>> GetEntitiesTableByRedis<T>(Expression<Func<T, bool>> expression, BaseFilter filter,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
filter.SelectField = new string[] { };
|
||
var realOrgId = Api.AppContext.CurrentSession?.RootOrgId ?? filter.GetOrgId();
|
||
if (!ConfigurationManager.IsRedis)
|
||
{
|
||
return this.GetOrderEntities<T>(expression, filter, (!filter?.IsNoTranking) ?? true, paths).ToList();
|
||
}
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, filter, paths, null, out orgExpression, out realPaths, out realOrders, true);
|
||
|
||
var list = await GetEntitiesByRedis<T>(filter);
|
||
if (list == null || !list.Any())
|
||
return list;
|
||
if (realPaths != null && realPaths.Any())
|
||
{
|
||
//var tmpList = list;
|
||
var hasDataList = new Hashtable();
|
||
hasDataList["."] = list;
|
||
foreach (var path in realPaths)
|
||
{
|
||
var splitPaths = path.Split('.').ToArray();
|
||
var type = typeof(T);
|
||
var hasDealNavPath = new List<string>();
|
||
var curentPath = ".";
|
||
var isICollection = false;
|
||
foreach (var spath in splitPaths)
|
||
{
|
||
dynamic curentList = hasDataList[curentPath];
|
||
if (curentList == null)
|
||
break;
|
||
if (!hasDealNavPath.Contains(spath))
|
||
{
|
||
PropertyInfo navProp = null;
|
||
PropertyInfo idProp = null;
|
||
var fieldInfos = type.GetProperties();
|
||
var theType = type;
|
||
foreach (var p in fieldInfos)
|
||
{
|
||
if (p.Name == spath)
|
||
{
|
||
navProp = p;
|
||
type = p.PropertyType;
|
||
isICollection = false;
|
||
var foreignKey = this.UnitOfWork.GetModelForeignKey(theType.Name, spath);
|
||
if (typeof(System.Collections.IEnumerable).IsAssignableFrom(type))
|
||
{
|
||
isICollection = true;
|
||
var generTypeFullName = type.GenericTypeArguments[0].FullName;
|
||
type = ReflectHelper.FindTypeInCurrentDomain(generTypeFullName);
|
||
idProp = type.GetProperty(foreignKey.ForeignFieldName);
|
||
}
|
||
else
|
||
{
|
||
idProp = theType.GetProperty(foreignKey.ForeignFieldName);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (navProp != null && idProp != null)
|
||
{
|
||
var methodInfo = (Task)this.GetType().GetMethod("GetEntitiesByRedis", new Type[] { typeof(BaseFilter) })
|
||
.MakeGenericMethod(type).Invoke(this, new object[] { filter });
|
||
//dynamic navLists = methodInfo.MakeGenericMethod(type).Invoke(this, new object[] { filter.OrgId });
|
||
await methodInfo;
|
||
dynamic navLists = methodInfo.GetType().GetProperty("Result").GetValue(methodInfo);
|
||
List<dynamic> navList = new List<dynamic>();
|
||
curentPath += "/" + navProp.Name;
|
||
hasDataList[curentPath] = navList;
|
||
|
||
foreach (var t in curentList)
|
||
{
|
||
//对1导航
|
||
if (!isICollection)
|
||
{
|
||
var navId = t.GetType().GetProperty(idProp.Name).GetValue(t).ToString();
|
||
foreach (var s in navLists)
|
||
{
|
||
if (s.ID.ToString() == navId)
|
||
{
|
||
navList.Add(s);
|
||
t.GetType().GetProperty(navProp.Name).SetValue(t, s);
|
||
break;
|
||
}
|
||
}
|
||
} //对多导航
|
||
else
|
||
{
|
||
var id = t.ID.ToString();
|
||
var colNavList = type.GetListObject();
|
||
foreach (var s in navLists)
|
||
{
|
||
if (s.GetType().GetProperty(idProp.Name).GetValue(s).ToString() == id)
|
||
{
|
||
var methodInfos = colNavList.GetType().GetMethod("Add");
|
||
methodInfos.Invoke(colNavList, new object[] { s });
|
||
navList.Add(s);
|
||
}
|
||
}
|
||
t.GetType().GetProperty(navProp.Name).SetValue(t, colNavList);
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
hasDealNavPath.Add(spath);
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
//排序和过滤
|
||
|
||
if (exp != null)
|
||
{
|
||
list = list.Where(exp.Compile()).ToList();
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(filter.Sort))
|
||
{
|
||
if (filter.Order == DbOrder.ASC)
|
||
{
|
||
var query = list.AsQueryable().OrderByName(filter.Sort);
|
||
list = query.ToList();
|
||
}
|
||
else
|
||
{
|
||
var query = list.AsQueryable().OrderByName(filter.Sort, true);
|
||
list = query.ToList();
|
||
}
|
||
}
|
||
return list;
|
||
}
|
||
|
||
public async Task<List<T>> GetEntitiesByRedis<T>(Expression<Func<T, bool>> expression, BaseFilter filter, string groupValue,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
filter.SelectField = new string[] { };
|
||
var realOrgId = Api.AppContext.CurrentSession?.RootOrgId ?? filter.GetOrgId();
|
||
filter.OrgId = realOrgId;
|
||
if (!ConfigurationManager.IsRedis)
|
||
{
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass == null)
|
||
{
|
||
throw new Exception("实体未配置成redis类型");
|
||
}
|
||
var groupId = redisClass.GroupName;
|
||
if (!string.IsNullOrEmpty(groupValue))
|
||
{
|
||
FilterRule rule = new FilterRule();
|
||
rule.Field = groupId;
|
||
rule.Operate = FilterOperate.Equal;
|
||
rule.Value = groupValue;
|
||
filter.FilterGroup.Rules.Add(rule);
|
||
}
|
||
return this.GetEntities<T>(expression, filter, false, paths).ToList();
|
||
}
|
||
string[] realPaths = null;
|
||
Dictionary<string, DbOrder> realOrders = null;
|
||
Expression<Func<T, bool>> orgExpression;
|
||
var exp = DoGetEntityExp(expression, filter, paths, null, out orgExpression, out realPaths, out realOrders, true);
|
||
List<T> list;
|
||
if (string.IsNullOrEmpty(groupValue))
|
||
list = await GetEntitiesByRedis<T>(filter);
|
||
else
|
||
list = await GetEntitiesByGroupRedis<T>(filter, groupValue);
|
||
if (list == null || !list.Any())
|
||
return list;
|
||
if (realPaths != null && realPaths.Any())
|
||
{
|
||
//var tmpList = list;
|
||
var hasDataList = new Hashtable();
|
||
hasDataList["."] = list;
|
||
foreach (var path in realPaths)
|
||
{
|
||
var splitPaths = path.Split('.').ToArray();
|
||
var type = typeof(T);
|
||
var hasDealNavPath = new List<string>();
|
||
var curentPath = ".";
|
||
var isICollection = false;
|
||
foreach (var spath in splitPaths)
|
||
{
|
||
dynamic curentList = hasDataList[curentPath];
|
||
if (curentList == null)
|
||
break;
|
||
if (!hasDealNavPath.Contains(spath))
|
||
{
|
||
PropertyInfo navProp = null;
|
||
PropertyInfo idProp = null;
|
||
var fieldInfos = type.GetProperties();
|
||
var theType = type;
|
||
foreach (var p in fieldInfos)
|
||
{
|
||
if (p.Name == spath)
|
||
{
|
||
navProp = p;
|
||
type = p.PropertyType;
|
||
isICollection = false;
|
||
var foreignKey = this.UnitOfWork.GetModelForeignKey(theType.Name, spath);
|
||
if (typeof(System.Collections.IEnumerable).IsAssignableFrom(type))
|
||
{
|
||
isICollection = true;
|
||
var generTypeFullName = type.GenericTypeArguments[0].FullName;
|
||
type = ReflectHelper.FindTypeInCurrentDomain(generTypeFullName);
|
||
idProp = type.GetProperty(foreignKey.ForeignFieldName);
|
||
}
|
||
else
|
||
{
|
||
idProp = theType.GetProperty(foreignKey.ForeignFieldName);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (navProp != null && idProp != null)
|
||
{
|
||
var methodInfo = (Task)this.GetType().GetMethod("GetEntitiesByRedis", new Type[] { typeof(BaseFilter) })
|
||
.MakeGenericMethod(type).Invoke(this, new object[] { filter });
|
||
//dynamic navLists = methodInfo.MakeGenericMethod(type).Invoke(this, new object[] { filter.OrgId });
|
||
await methodInfo;
|
||
dynamic navLists = methodInfo.GetType().GetProperty("Result").GetValue(methodInfo);
|
||
List<dynamic> navList = new List<dynamic>();
|
||
curentPath += "/" + navProp.Name;
|
||
hasDataList[curentPath] = navList;
|
||
|
||
foreach (var t in curentList)
|
||
{
|
||
//对1导航
|
||
if (!isICollection)
|
||
{
|
||
var navIdObj = t.GetType().GetProperty(idProp.Name).GetValue(t);
|
||
if (navIdObj != null)
|
||
{
|
||
foreach (var s in navLists)
|
||
{
|
||
if (s.ID.ToString() == navIdObj.ToString())
|
||
{
|
||
navList.Add(s);
|
||
t.GetType().GetProperty(navProp.Name).SetValue(t, s);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
} //对多导航
|
||
else
|
||
{
|
||
var id = t.ID.ToString();
|
||
var colNavList = type.GetListObject();
|
||
foreach (var s in navLists)
|
||
{
|
||
var idObj = s.GetType().GetProperty(idProp.Name).GetValue(s);
|
||
if (idObj != null)
|
||
{
|
||
if (id == idObj.ToString())
|
||
{
|
||
var methodInfos = colNavList.GetType().GetMethod("Add");
|
||
methodInfos.Invoke(colNavList, new object[] { s });
|
||
navList.Add(s);
|
||
}
|
||
}
|
||
}
|
||
t.GetType().GetProperty(navProp.Name).SetValue(t, colNavList);
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
hasDealNavPath.Add(spath);
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
//排序和过滤
|
||
|
||
if (exp != null)
|
||
{
|
||
var filterList = list.Where(exp.Compile());
|
||
if (filterList != null && filterList.Any())
|
||
list = filterList.ToList();
|
||
else
|
||
list = new List<T>();
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(filter.Sort))
|
||
{
|
||
if (filter.Order == DbOrder.ASC)
|
||
{
|
||
var query = list.AsQueryable().OrderByName(filter.Sort);
|
||
list = query.ToList();
|
||
}
|
||
else
|
||
{
|
||
var query = list.AsQueryable().OrderByName(filter.Sort, true);
|
||
list = query.ToList();
|
||
}
|
||
}
|
||
return list;
|
||
}
|
||
|
||
public PagedResultDto<T> GetOrderPageByRedis<T>(Expression<Func<T, bool>> expression, BasePageFilter pageFilter,
|
||
params string[] paths) where T : MesEntityBase, new()
|
||
{
|
||
|
||
var list = GetEntitiesTableByRedis(expression, pageFilter, paths).Result;
|
||
|
||
var returnDto = new PagedResultDto<T>();
|
||
returnDto.TotalCount = list.Count();
|
||
returnDto.Items = list.Skip(pageFilter.Start).Take(pageFilter.Limit).ToList();
|
||
return returnDto;
|
||
}
|
||
|
||
|
||
|
||
static IEnumerable<MethodInfo> GetExtensionMethods(Assembly assembly, Type extendedType)
|
||
{
|
||
var query = from type in assembly.GetTypes()
|
||
where !type.IsGenericType && !type.IsNested
|
||
from method in type.GetMethods(BindingFlags.Static
|
||
| BindingFlags.Public | BindingFlags.NonPublic)
|
||
where method.IsDefined(typeof(System.Runtime.CompilerServices.ExtensionAttribute), false)
|
||
where method.GetParameters()[0].ParameterType == extendedType
|
||
select method;
|
||
return query;
|
||
}
|
||
|
||
public async Task<List<T>> GetEntitiesByRedis<T>(BaseFilter filter) where T : MesEntityBase, new()
|
||
{
|
||
filter.SelectField = new string[] { };
|
||
var orgid = Api.AppContext.CurrentSession?.RootOrgId ?? filter.OrgId;
|
||
filter.OrgId = orgid;
|
||
var tmpFilter = filter.DeepCloneObject();
|
||
if (filter != null && Api.AppContext.CurrentSession.DataRule != null && !filter.IgnoreDataRule && !filter.DataRule.Any())
|
||
{
|
||
filter.DataRule = Api.AppContext.CurrentSession.DataRule;
|
||
}
|
||
if (!ConfigurationManager.IsRedis)
|
||
{
|
||
return this.GetEntities<T>(null, tmpFilter, false).ToList();
|
||
}
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass == null)
|
||
{
|
||
throw new Exception("实体未配置成redis类型");
|
||
}
|
||
var groupId = redisClass.GroupName;
|
||
//CsRedisManager manager = ServiceLocator.Instance.GetService<CsRedisManager>();
|
||
var type = typeof(T);
|
||
var perKey = type.Name;
|
||
var list = new List<T>();
|
||
var isUpdateRedis = false;
|
||
if (!string.IsNullOrEmpty(groupId) && groupId != "ID")
|
||
{
|
||
var groupkeys = "opt_grouplist_" + perKey + "_" + orgid;
|
||
if (CsRedisManager.KeyExists(groupkeys))
|
||
{
|
||
var keyList = await CsRedisManager.GetClient().HGetAllAsync(groupkeys);
|
||
var baseFilter = new BaseFilter(orgid);
|
||
baseFilter.DataRule = tmpFilter.DataRule;
|
||
baseFilter.IgnoreDataRule = tmpFilter.IgnoreDataRule;
|
||
foreach (var k in keyList)
|
||
{
|
||
//var datakeys = "sort_" + perKey + "_" + k.Value + "_" + orgid;
|
||
List<T> keyData;
|
||
try
|
||
{
|
||
if (CsRedisManager.KeyExists(k.Value))
|
||
{
|
||
keyData = await CsRedisManager.StringGetAsync<List<T>>(k.Value);
|
||
if (keyData != null && keyData.Any())
|
||
list.AddRange(keyData);
|
||
}
|
||
else
|
||
{
|
||
FilterRule rule = new FilterRule();
|
||
rule.Field = groupId;
|
||
rule.Operate = FilterOperate.Equal;
|
||
rule.Value = k.Key;
|
||
baseFilter.FilterGroup.Rules.Add(rule);
|
||
keyData = this.GetEntities<T>(null, baseFilter, false).ToList();
|
||
if (keyData != null && keyData.Any())
|
||
{
|
||
list.AddRange(keyData);
|
||
isUpdateRedis = true;
|
||
}
|
||
|
||
}
|
||
}
|
||
catch (Exception)
|
||
{
|
||
if (CsRedisManager.GetClient().HExists(groupkeys, k.Key))
|
||
{
|
||
await CsRedisManager.GetClient().HDelAsync(groupkeys, k.Key);
|
||
}
|
||
continue;
|
||
}
|
||
}
|
||
if (isUpdateRedis)
|
||
{
|
||
var groupList = list.GroupByMany(groupId);
|
||
foreach (var item in groupList)
|
||
{
|
||
if (item.Key != null)
|
||
{
|
||
string datakey = string.Join(',', item.Key);
|
||
var keys = "sort_" + redisClass.ClassName + "_" + datakey + "_" + orgid;
|
||
await CsRedisManager.StringSetAsync(keys, item.Items);
|
||
//var groupkey = "opt_grouplist_" + type.Name + "_" + orgid;
|
||
await CsRedisManager.GetClient().HSetAsync(groupkeys, datakey, keys);
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
list = await SetRedisValue<T>(tmpFilter, type, null);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var keys = "sort_" + perKey + "_" + orgid;
|
||
if (CsRedisManager.KeyExists(keys))
|
||
{
|
||
list = await CsRedisManager.StringGetAsync<List<T>>(keys);
|
||
if (list != null)
|
||
{
|
||
list = list.Where(i => i != null).ToList();
|
||
}
|
||
else
|
||
{
|
||
await CsRedisManager.KeyDeleteAsync(keys);
|
||
list = await SetRedisValue<T>(tmpFilter, type, null);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
list = await SetRedisValue<T>(tmpFilter, type, null);
|
||
}
|
||
//var distinctList = list.Distinct().ToList();
|
||
var cList = list.Where((x, i) => list.FindIndex(z => z.ID == x.ID) == i).ToList();
|
||
if (list.Count != cList.Count)
|
||
{
|
||
await CsRedisManager.KeyDeleteAsync(keys);
|
||
list = await SetRedisValue<T>(tmpFilter, type, null);
|
||
}
|
||
}
|
||
|
||
|
||
//manager.
|
||
|
||
|
||
return list;
|
||
|
||
}
|
||
public async Task<List<T>> GetEntitiesByGroupRedis<T>(BaseFilter filter, string groupValue) where T : MesEntityBase, new()
|
||
{
|
||
filter.SelectField = new string[] { };
|
||
var orgid = Api.AppContext.CurrentSession?.RootOrgId ?? filter.OrgId;
|
||
filter.OrgId = orgid;
|
||
var tmpFilter = filter.DeepCloneObject();
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass == null)
|
||
{
|
||
throw new Exception("实体未配置成redis类型");
|
||
}
|
||
var groupId = redisClass.GroupName;
|
||
if (!ConfigurationManager.IsRedis)
|
||
{
|
||
//BaseFilter filter = new BaseFilter(orgid);
|
||
if (!string.IsNullOrEmpty(groupId) && groupId != "ID")
|
||
{
|
||
if (!string.IsNullOrEmpty(groupValue))
|
||
{
|
||
|
||
FilterRule rule = new FilterRule();
|
||
rule.Field = groupId;
|
||
rule.Operate = FilterOperate.Equal;
|
||
rule.Value = groupValue;
|
||
tmpFilter.FilterGroup.Rules.Add(rule);
|
||
}
|
||
}
|
||
return this.GetEntities<T>(null, tmpFilter, false).ToList();
|
||
}
|
||
|
||
//CsRedisManager manager = ServiceLocator.Instance.GetService<CsRedisManager>();
|
||
var type = typeof(T);
|
||
var perKey = type.Name;
|
||
var list = new List<T>();
|
||
if (!string.IsNullOrEmpty(groupId) && groupId != "ID")
|
||
{
|
||
var groupkeys = "opt_grouplist_" + perKey + "_" + orgid;
|
||
if (CsRedisManager.KeyExists(groupkeys))
|
||
{
|
||
//var datakeys = "sort_" + perKey + "_" + groupValue + "_" + orgid;
|
||
if (CsRedisManager.GetClient().HExists(groupkeys, groupValue))
|
||
{
|
||
var data = await CsRedisManager.GetClient().HGetAsync<string>(groupkeys, groupValue);
|
||
if (!string.IsNullOrEmpty(data))
|
||
{
|
||
try
|
||
{
|
||
List<T> keyData = await CsRedisManager.StringGetAsync<List<T>>(data);
|
||
if (keyData != null && keyData.Any())
|
||
list.AddRange(keyData);
|
||
else
|
||
{
|
||
await CsRedisManager.GetClient().DelAsync(groupkeys);
|
||
list = await SetRedisValue<T>(tmpFilter, type, groupValue);
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
|
||
await CsRedisManager.GetClient().DelAsync(groupkeys);
|
||
list = await SetRedisValue<T>(tmpFilter, type, groupValue);
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
await CsRedisManager.GetClient().DelAsync(groupkeys);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
list = await SetRedisValue<T>(tmpFilter, type, groupValue);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
list = await SetRedisValue<T>(tmpFilter, type, groupValue);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
list = await SetRedisValue<T>(tmpFilter, type, "");
|
||
}
|
||
|
||
|
||
//manager.
|
||
|
||
|
||
return list;
|
||
|
||
}
|
||
|
||
|
||
|
||
private async Task<List<T>> SetRedisValue<T>(BaseFilter filter, Type type, string groupValue) where T : MesEntityBase, new()
|
||
{
|
||
var tmpFilter = filter.DeepCloneObject();
|
||
var orgid = Api.AppContext.CurrentSession?.RootOrgId ?? filter.OrgId;
|
||
tmpFilter.OrgId = orgid;
|
||
//var filter = new BaseFilter(orgid);
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass == null)
|
||
{
|
||
throw new Exception("实体未配置成redis类型");
|
||
}
|
||
var groupId = redisClass.GroupName;
|
||
|
||
if (!ConfigurationManager.IsRedis)
|
||
{
|
||
if (!string.IsNullOrEmpty(groupValue))
|
||
{
|
||
|
||
FilterRule rule = new FilterRule();
|
||
rule.Field = groupId;
|
||
rule.Operate = FilterOperate.Equal;
|
||
rule.Value = groupValue;
|
||
tmpFilter.FilterGroup.Rules.Add(rule);
|
||
}
|
||
return this.GetEntities<T>(null, tmpFilter, false).ToList();
|
||
}
|
||
List<T> list;
|
||
|
||
var keys = "sort_" + redisClass.ClassName + "_" + orgid;
|
||
if (!string.IsNullOrEmpty(groupId) && groupId != "ID")
|
||
{
|
||
if (!string.IsNullOrEmpty(groupValue))
|
||
{
|
||
|
||
FilterRule rule = new FilterRule();
|
||
rule.Field = groupId;
|
||
rule.Operate = FilterOperate.Equal;
|
||
rule.Value = groupValue;
|
||
tmpFilter.FilterGroup.Rules.Add(rule);
|
||
}
|
||
list = this.GetEntities<T>(null, tmpFilter, false).ToList();
|
||
var groupList = list.GroupByMany(groupId);
|
||
if (!string.IsNullOrEmpty(groupValue))
|
||
{
|
||
if (!groupList.Any(x => Convert.ToString(x.Key) == groupValue))
|
||
{
|
||
keys = "sort_" + redisClass.ClassName + "_" + groupValue + "_" + orgid;
|
||
await CsRedisManager.StringSetAsync(keys, new List<T>());
|
||
var groupkeys = "opt_grouplist_" + type.Name + "_" + orgid;
|
||
await CsRedisManager.GetClient().HSetAsync(groupkeys, groupValue, keys);
|
||
}
|
||
}
|
||
foreach (var item in groupList)
|
||
{
|
||
//string datakey = string.Join(',', item.Key);
|
||
string datakey = item.Key == null ? "" : item.Key.ToString();
|
||
keys = "sort_" + redisClass.ClassName + "_" + datakey + "_" + orgid;
|
||
await CsRedisManager.StringSetAsync(keys, item.Items);
|
||
var groupkeys = "opt_grouplist_" + type.Name + "_" + orgid;
|
||
await CsRedisManager.GetClient().HSetAsync(groupkeys, datakey, keys);
|
||
|
||
}
|
||
|
||
|
||
}
|
||
else
|
||
{
|
||
list = this.GetEntities<T>(null, tmpFilter, false).ToList();
|
||
await CsRedisManager.StringSetAsync(keys, list);
|
||
await CsRedisManager.GetClient().HSetAsync("opt_list_" + orgid, type.Name, keys);
|
||
}
|
||
|
||
|
||
return list;
|
||
}
|
||
|
||
|
||
private void SetRedis<T>(T entity, RedisHanddle handdle) where T : MesEntityBase, new()
|
||
{
|
||
if (!ConfigurationManager.IsRedis)
|
||
return;
|
||
try
|
||
{
|
||
//CsRedisManager redisHelper = ServiceLocator.Instance.GetService<CsRedisManager>();
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass != null)
|
||
{
|
||
var type = typeof(T);
|
||
//manager.
|
||
var perKey = "{" + type.Name + "}";
|
||
//1.处理 redisstring
|
||
if (!redisClass.DicKeys.Any())
|
||
{
|
||
redisClass.DicKeys.Add("ID", "GUID");
|
||
}
|
||
var redisKeys = redisClass.DicKeys.Distinct();
|
||
foreach (var redisKey in redisKeys)
|
||
{
|
||
var propvalue = type.GetProperty(redisKey.Key).GetValue(entity);
|
||
var filedKey = perKey + "_" + propvalue + "_" + entity.ORG_ID;//string
|
||
if (handdle == RedisHanddle.Update || handdle == RedisHanddle.Add)
|
||
{
|
||
CsRedisManager.StringSetAsync(filedKey, entity).Wait();
|
||
}
|
||
else if (handdle == RedisHanddle.Delete)
|
||
{
|
||
CsRedisManager.KeyDeleteAsync(filedKey).Wait();
|
||
}
|
||
else
|
||
{
|
||
CsRedisManager.StringSetAsync(filedKey, entity).Wait();
|
||
}
|
||
}
|
||
|
||
//2.处理sortlist
|
||
|
||
//SetRedisValue<T>(entity.ORG_ID ?? Guid.Empty, redisHelper, type, keys).Wait();
|
||
var groupValue = redisClass.GroupName;
|
||
//CsRedisManager manager = ServiceLocator.Instance.GetService<CsRedisManager>();
|
||
if (!string.IsNullOrEmpty(groupValue) && groupValue != "ID")
|
||
{
|
||
var keys = "sort_" + redisClass.ClassName + "_" + groupValue + "_" + entity.ORG_ID;
|
||
if (CsRedisManager.KeyExists(keys))
|
||
CsRedisManager.KeyDelete(keys);
|
||
var groupkeys = "opt_grouplist_" + type.Name + "_" + entity.ORG_ID;
|
||
if (CsRedisManager.KeyExists(groupkeys))
|
||
{
|
||
CsRedisManager.KeyDelete(groupkeys);
|
||
}
|
||
//因为数据库可能还没提交，所以不能更新redis
|
||
//SetRedisValue<T>(entity.ORG_ID ?? Guid.Empty, redisHelper, type,
|
||
//type.GetProperty(groupValue).GetValue(entity).ToString()).Wait();
|
||
}
|
||
else
|
||
{
|
||
var keys = "sort_" + redisClass.ClassName + "_" + entity.ORG_ID;
|
||
var listKeys = "opt_list_" + entity.ORG_ID;
|
||
if (CsRedisManager.KeyExists(keys))
|
||
CsRedisManager.KeyDeleteAsync(keys).Wait();
|
||
if (CsRedisManager.GetClient().HExists(listKeys, perKey))
|
||
{
|
||
CsRedisManager.GetClient().HDelAsync(listKeys, perKey).Wait();
|
||
}
|
||
//SetRedisValue<T>(entity.ORG_ID ?? Guid.Empty, redisHelper, type, null).Wait();
|
||
}
|
||
//if (redisHelper.KeyExists(keys))
|
||
// redisHelper.KeyDeleteAsync(keys).Wait();
|
||
/* redis数据不一致的问题，一旦出现变更，则清除redis*/
|
||
/*
|
||
var sortFile = redisClass.SortField;
|
||
if (string.IsNullOrEmpty(sortFile))
|
||
sortFile = "ID";
|
||
double souces = 0;
|
||
if (redisClass.DicKeys.Any())
|
||
{
|
||
var propvalue = type.GetProperty(sortFile).GetValue(entity).ToString();
|
||
double.TryParse(propvalue, out souces);
|
||
}
|
||
if (handdle == RedisHanddle.Update || handdle == RedisHanddle.Add)
|
||
{
|
||
var lists = redisHelper.SortedSetRangeByRank<T>(keys);
|
||
var oldEntitys = lists.Where(i => i.ID == entity.ID).ToList();
|
||
if (oldEntitys.Any())
|
||
{
|
||
oldEntitys = oldEntitys.OrderBy(i => i.MODIFY_TIME).ToList();
|
||
SortedSetEntry oldRd = new SortedSetEntry();
|
||
for (var o = 0; o < oldEntitys.Count; o++)
|
||
{
|
||
if (souces == 0)
|
||
{
|
||
if (o == oldEntitys.Count - 1)
|
||
{
|
||
var json = redisHelper.ConvertJson<T>(oldEntitys[o]);
|
||
oldRd = redisHelper.SortedSetScan(keys, json).FirstOrDefault();
|
||
if (oldRd != null)
|
||
{
|
||
souces = oldRd.Score;
|
||
}
|
||
}
|
||
}
|
||
redisHelper.SortedSetRemove(keys, oldEntitys[o]);
|
||
}
|
||
}
|
||
if (souces == 0)
|
||
{
|
||
redisHelper.SortedSetAdd(keys, entity, lists.Count + 1);
|
||
}
|
||
else
|
||
{
|
||
redisHelper.SortedSetAdd(keys, entity, souces);
|
||
}
|
||
|
||
}
|
||
else if (handdle == RedisHanddle.Delete)
|
||
{
|
||
var lists = redisHelper.SortedSetRangeByRank<T>(keys);
|
||
var oldEntity = lists.Where(i => i.ID == entity.ID).ToList();
|
||
if (oldEntity.Any())
|
||
{
|
||
foreach (var en in oldEntity)
|
||
{
|
||
redisHelper.SortedSetRemove(keys, en);
|
||
}
|
||
|
||
}
|
||
}
|
||
else
|
||
{
|
||
redisHelper.SortedSetAdd(keys, entity, souces);
|
||
}*/
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw ex;
|
||
}
|
||
}
|
||
|
||
private List<dynamic> DynamicSelect(string[] selectField, IQueryable queryTable)
|
||
{
|
||
var selectSql = "New(";
|
||
foreach (var s in selectField)
|
||
{
|
||
selectSql += s + ",";
|
||
}
|
||
selectSql = selectSql.Trim(',');
|
||
selectSql += ")";
|
||
var result = queryTable.Select(selectSql).ToDynamicList();
|
||
|
||
return result;
|
||
}
|
||
private void DelRedis<T>(IEnumerable<T> entitys) where T : MesEntityBase, new()
|
||
{
|
||
if (!ConfigurationManager.IsRedis || entitys == null || !entitys.Any())
|
||
return;
|
||
try
|
||
{
|
||
//CsRedisManager redisHelper = ServiceLocator.Instance.GetService<CsRedisManager>();
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass != null)
|
||
{
|
||
var type = typeof(T);
|
||
//manager.
|
||
var perKey = "{" + type.Name + "}";
|
||
//1.处理 redisstring
|
||
if (!redisClass.DicKeys.Any())
|
||
{
|
||
redisClass.DicKeys.Add("ID", "GUID");
|
||
}
|
||
var redisKeys = redisClass.DicKeys.Distinct();
|
||
|
||
var selectEntiys = DynamicSelect(redisKeys.Select(i => i.Key).ToArray(), entitys.AsQueryable());
|
||
List<string> keys = new List<string>();
|
||
var dyType = selectEntiys.FirstOrDefault().GetType();
|
||
var orgId = entitys.FirstOrDefault().ORG_ID?.ToString();
|
||
foreach (var d in selectEntiys)
|
||
{
|
||
foreach (var key in redisKeys)
|
||
{
|
||
keys.Add(perKey + "_" + dyType.GetProperty(key.Key).GetValue(d) + "_" + orgId);
|
||
}
|
||
}
|
||
|
||
CsRedisManager.GetClient().Del(keys.ToArray());
|
||
|
||
|
||
|
||
|
||
//2.处理sortlist
|
||
|
||
//SetRedisValue<T>(entity.ORG_ID ?? Guid.Empty, redisHelper, type, keys).Wait();
|
||
var groupValue = redisClass.GroupName;
|
||
//CsRedisManager manager = ServiceLocator.Instance.GetService<CsRedisManager>();
|
||
if (!string.IsNullOrEmpty(groupValue) && groupValue != "ID")
|
||
{
|
||
var gkeys = "sort_" + redisClass.ClassName + "_" + groupValue + "_" + orgId;
|
||
if (CsRedisManager.KeyExists(gkeys))
|
||
CsRedisManager.KeyDelete(gkeys);
|
||
var groupkeys = "opt_grouplist_" + type.Name + "_" + orgId;
|
||
if (CsRedisManager.KeyExists(groupkeys))
|
||
{
|
||
CsRedisManager.KeyDelete(groupkeys);
|
||
}
|
||
//因为数据库可能还没提交，所以不能更新redis
|
||
//SetRedisValue<T>(entity.ORG_ID ?? Guid.Empty, redisHelper, type,
|
||
//type.GetProperty(groupValue).GetValue(entity).ToString()).Wait();
|
||
}
|
||
else
|
||
{
|
||
var gkeys = "sort_" + redisClass.ClassName + "_" + orgId;
|
||
var listKeys = "opt_list_" + orgId;
|
||
if (CsRedisManager.KeyExists(gkeys))
|
||
CsRedisManager.KeyDeleteAsync(gkeys).Wait();
|
||
if (CsRedisManager.GetClient().HExists(listKeys, perKey))
|
||
{
|
||
CsRedisManager.GetClient().HDelAsync(listKeys, perKey).Wait();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw ex;
|
||
}
|
||
}
|
||
|
||
|
||
private void DelRedisGroup<T>(Guid orgId) where T : MesEntityBase, new()
|
||
{
|
||
if (!ConfigurationManager.IsRedis)
|
||
return;
|
||
try
|
||
{
|
||
//CsRedisManager redisHelper = ServiceLocator.Instance.GetService<CsRedisManager>();
|
||
var redisClass = CsRedisHelper<T>.GetRedisClass();
|
||
if (redisClass != null)
|
||
{
|
||
var type = typeof(T);
|
||
//manager.
|
||
var perKey = type.Name;
|
||
|
||
|
||
//2.处理sortlist
|
||
|
||
//SetRedisValue<T>(entity.ORG_ID ?? Guid.Empty, redisHelper, type, keys).Wait();
|
||
var groupValue = redisClass.GroupName;
|
||
//CsRedisManager manager = ServiceLocator.Instance.GetService<CsRedisManager>();
|
||
if (!string.IsNullOrEmpty(groupValue) && groupValue != "ID")
|
||
{
|
||
var gkeys = "sort_" + redisClass.ClassName + "_" + groupValue + "_" + orgId;
|
||
if (CsRedisManager.KeyExists(gkeys))
|
||
CsRedisManager.KeyDelete(gkeys);
|
||
var groupkeys = "opt_grouplist_" + type.Name + "_" + orgId;
|
||
if (CsRedisManager.KeyExists(groupkeys))
|
||
{
|
||
CsRedisManager.KeyDelete(groupkeys);
|
||
}
|
||
//因为数据库可能还没提交，所以不能更新redis
|
||
//SetRedisValue<T>(entity.ORG_ID ?? Guid.Empty, redisHelper, type,
|
||
//type.GetProperty(groupValue).GetValue(entity).ToString()).Wait();
|
||
}
|
||
else
|
||
{
|
||
var gkeys = "sort_" + redisClass.ClassName + "_" + orgId;
|
||
var listKeys = "opt_list_" + orgId;
|
||
if (CsRedisManager.KeyExists(gkeys))
|
||
CsRedisManager.KeyDeleteAsync(gkeys).Wait();
|
||
if (CsRedisManager.GetClient().HExists(listKeys, perKey))
|
||
{
|
||
CsRedisManager.GetClient().HDelAsync(listKeys, perKey).Wait();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw ex;
|
||
}
|
||
}
|
||
|
||
#region 系统参数
|
||
|
||
|
||
|
||
public void FillGetEntitySysParam<T>(IEnumerable<T> entities, BaseFilter filter, string[] includes)
|
||
{
|
||
List<string> allIncludes = new List<string>();
|
||
if (includes != null && includes.Any())
|
||
allIncludes.AddRange(includes);
|
||
if (filter != null && filter.Include != null && filter.Include.Any())
|
||
allIncludes.AddRange(filter.Include);
|
||
if (entities == null || !entities.Any() || allIncludes == null || !allIncludes.Any()) return;
|
||
var first = entities.FirstOrDefault();
|
||
if (!(first is MesEntityBase)) return;
|
||
|
||
List<MesEntityBase> mesEntityBases = new List<MesEntityBase>();
|
||
entities.ForEach(t =>
|
||
{
|
||
mesEntityBases.Add(t as MesEntityBase);
|
||
});
|
||
List<Guid> ids = new List<Guid>();
|
||
DoForEachEntitiesOnIncludes(mesEntityBases, null, string.Empty, allIncludes, (idPropertyInfo, obj) =>
|
||
{
|
||
if (obj != null)
|
||
{
|
||
var idObj = idPropertyInfo.GetValue(obj);
|
||
if (idObj != null)
|
||
ids.Add(new Guid(idObj.ToString()));
|
||
}
|
||
});
|
||
if (!ids.Any()) return;
|
||
|
||
var sysParams = this.UnitOfWork.GetEntities<T_PF_PARAM>(t => ids.Contains(t.ENTITY_ID ?? Guid.Empty), null, false).ToList();
|
||
if (sysParams != null && sysParams.Any())
|
||
{
|
||
DoForEachEntitiesOnIncludes(mesEntityBases, null, string.Empty, allIncludes, (idPropertyInfo, obj) =>
|
||
{
|
||
if (obj != null)
|
||
{
|
||
var idObj = idPropertyInfo.GetValue(obj);
|
||
if (idObj != null)
|
||
{
|
||
var id = new Guid(idObj.ToString());
|
||
var tempSysParams = sysParams.Where(t => t.ENTITY_ID == id).ToList();
|
||
if (tempSysParams != null && tempSysParams.Any())
|
||
{
|
||
var navSysParamProperty = obj.GetType().GetProperty("Nav_SysParams");
|
||
if (navSysParamProperty != null)
|
||
navSysParamProperty.SetValue(obj, tempSysParams);
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
|
||
private List<T_PF_PARAM> GetSysParams<T>(IEnumerable<T> entities, bool isDelete = false) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any()) return null;
|
||
var first = entities.FirstOrDefault();
|
||
if (!(first is MesEntityBase)) return null;
|
||
if (isDelete)
|
||
{
|
||
var ids = entities.Select(t => new Guid(t.ID.ToString())).ToList();
|
||
var dbParams = this.UnitOfWork.GetEntities<T_PF_PARAM>(t => ids.Contains(t.ENTITY_ID ?? Guid.Empty), null, false).ToList();
|
||
if (dbParams.Any())
|
||
return dbParams;
|
||
}
|
||
List<T_PF_PARAM> pfParams = new List<T_PF_PARAM>();
|
||
foreach (var item in entities)
|
||
{
|
||
if (item.Nav_SysParams != null && item.Nav_SysParams.Any())
|
||
{
|
||
pfParams.AddRange(item.Nav_SysParams);
|
||
item.Nav_SysParams.ForEach(t => t.VIR_IS_DELETED = item.IS_DELETED);
|
||
item.Nav_SysParams = null;
|
||
|
||
}
|
||
}
|
||
return pfParams;
|
||
}
|
||
|
||
private string GetRealInclude(string p)
|
||
{
|
||
if (!string.IsNullOrEmpty(p))
|
||
p = p.Trim();
|
||
if (string.IsNullOrEmpty(p)) return p;
|
||
int index = p.IndexOf("Nav_SysParams", StringComparison.OrdinalIgnoreCase);
|
||
if (index > -1)
|
||
{
|
||
if (index > 0)
|
||
return p.Substring(0, index - 1);
|
||
else
|
||
return string.Empty;
|
||
}
|
||
return p;
|
||
}
|
||
/// <summary>
|
||
/// 构造关联的表
|
||
/// </summary>
|
||
/// <param name="baseFilter"></param>
|
||
/// <param name="paths"></param>
|
||
/// <returns></returns>
|
||
private string[] GetIncludes(BaseFilter baseFilter, params string[] paths)
|
||
{
|
||
Dictionary<string, byte> dic = new Dictionary<string, byte>();
|
||
if (paths != null)
|
||
{
|
||
foreach (string path in paths)
|
||
{
|
||
var temp = GetRealInclude(path);
|
||
if (!string.IsNullOrEmpty(temp) && !dic.ContainsKey(temp))
|
||
dic[temp] = 0;
|
||
}
|
||
}
|
||
if (baseFilter != null && baseFilter.Include != null)
|
||
{
|
||
foreach (var path in baseFilter.Include)
|
||
{
|
||
var temp = GetRealInclude(path);
|
||
if (!string.IsNullOrEmpty(temp) && !dic.ContainsKey(temp))
|
||
dic[temp] = 0;
|
||
}
|
||
foreach (var path in baseFilter.SelectField.Where(i => i.IndexOf(".") > 0))
|
||
{
|
||
var index = path.LastIndexOf(".");
|
||
var temp = GetRealInclude(path.Substring(0, index));
|
||
if (!string.IsNullOrEmpty(temp) && !dic.ContainsKey(temp))
|
||
dic[temp] = 0;
|
||
}
|
||
}
|
||
if (dic.Any())
|
||
return dic.Keys.ToArray();
|
||
return null;
|
||
}
|
||
/// <summary>
|
||
/// 构造查询条件
|
||
/// </summary>
|
||
/// <typeparam name="T"></typeparam>
|
||
/// <param name="expression"></param>
|
||
/// <param name="filter"></param>
|
||
/// <param name="paths"></param>
|
||
/// <param name="orders"></param>
|
||
/// <param name="realPaths"></param>
|
||
/// <param name="realOrders"></param>
|
||
/// <returns></returns>
|
||
private Expression<Func<T, bool>> DoGetEntityExp<T>
|
||
(Expression<Func<T, bool>> expression, BaseFilter parmFilter,
|
||
string[] paths,
|
||
IDictionary<string, string> orders, out Expression<Func<T, bool>> orgExpression, out string[] realPaths, out Dictionary<string, DbOrder> realOrders, bool appendDataNav)
|
||
where T : MesEntityBase, new()
|
||
{
|
||
orgExpression = t => true;
|
||
BaseFilter filter = parmFilter;
|
||
if (expression == null)
|
||
expression = t => !t.IS_DELETED;
|
||
else
|
||
expression = expression.And(t => !t.IS_DELETED);
|
||
var dataNavField = "";
|
||
if (filter != null)
|
||
{
|
||
//OrgId的过滤条件
|
||
var orgIdExpression = this.GetPermissionExpression<T>(filter, out orgExpression);
|
||
if (orgIdExpression != null)
|
||
{
|
||
expression = expression.And(orgIdExpression);
|
||
}
|
||
//原filter过滤条件
|
||
expression = expression.And(filter.BuildExpression<T>(this.UnitOfWork));
|
||
//数据权限处理
|
||
var type = typeof(T);
|
||
var dataFieldAttr = type.GetAttribute<DataRuleFieldAttribute>();
|
||
if (dataFieldAttr != null && !parmFilter.IgnoreDataRule)
|
||
{
|
||
Guid? nullGuid = null;
|
||
var dataFieldfilter = new BaseFilter();
|
||
FilterGroup group = new FilterGroup();
|
||
group.IsAnd = false;
|
||
dataFieldfilter.FilterGroup.Groups.Add(group);
|
||
|
||
var splitAttrs = dataFieldAttr.FileName.Split(new char[] { '.' });
|
||
var tmpType = type;
|
||
var tmpFiled = "";
|
||
if (appendDataNav)
|
||
{
|
||
var dataNavFieldIndex = dataFieldAttr.FileName.LastIndexOf('.');
|
||
if (dataNavFieldIndex > 0)
|
||
{
|
||
dataNavField = dataFieldAttr.FileName.Substring(0, dataNavFieldIndex);
|
||
}
|
||
}
|
||
foreach (var a in splitAttrs)
|
||
{
|
||
var property = tmpType.GetProperty(a);
|
||
var propertyClass = property.PropertyType;
|
||
if (property.Name.StartsWith("Nav_"))
|
||
{
|
||
var keys = this.UnitOfWork.GetModelForeignKey(tmpType.Name);
|
||
var key = keys.FirstOrDefault(x => x.ForeignNavName == property.Name);
|
||
if (key != null)
|
||
{
|
||
var keyProp = tmpType.GetProperty(key.ForeignFieldName);
|
||
if (keyProp != null && keyProp.PropertyType.IsNullableType())
|
||
{
|
||
var emptyRule = new FilterRule();
|
||
emptyRule.Field = tmpFiled + keyProp.Name;
|
||
emptyRule.Operate = FilterOperate.Equal;
|
||
emptyRule.Value = nullGuid;
|
||
group.Rules.Add(emptyRule);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (property.PropertyType.IsNullableType())
|
||
{
|
||
var emptyRule = new FilterRule();
|
||
emptyRule.Field = tmpFiled + property.Name;
|
||
emptyRule.Operate = FilterOperate.Equal;
|
||
emptyRule.Value = nullGuid;
|
||
group.Rules.Add(emptyRule);
|
||
}
|
||
}
|
||
tmpFiled += property.Name + ".";
|
||
tmpType = propertyClass;
|
||
}
|
||
//数据权限的过滤条件
|
||
if (filter.DataRule.Any())
|
||
{
|
||
foreach (var data in filter.DataRule)
|
||
{
|
||
var rule = new FilterRule();
|
||
rule.Field = dataFieldAttr.FileName;
|
||
rule.Operate = FilterOperate.Equal;
|
||
rule.Value = data;
|
||
group.Rules.Add(rule);
|
||
}
|
||
expression = expression.And(dataFieldfilter.BuildExpression<T>(this.UnitOfWork));
|
||
}
|
||
else
|
||
{
|
||
expression = expression.And(t => false);
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
if (APT.Infrastructure.Api.AppContext.CurrentSession.RootOrgId != null)
|
||
{
|
||
//expression = expression.And(t => t.ORG_ID == APT.Infrastructure.Api.AppContext.CurrentSession.RootOrgId);
|
||
//orgExpression = orgExpression.And(t => t.ORG_ID == APT.Infrastructure.Api.AppContext.CurrentSession.RootOrgId);
|
||
}
|
||
else
|
||
{
|
||
}
|
||
}
|
||
realPaths = this.GetIncludes(filter, paths);
|
||
|
||
if (!string.IsNullOrEmpty(dataNavField))
|
||
{
|
||
if (realPaths == null)
|
||
realPaths = new string[] { dataNavField };
|
||
else
|
||
realPaths = realPaths.Append(dataNavField).ToArray();
|
||
}
|
||
|
||
realOrders = new Dictionary<string, DbOrder>();
|
||
if (filter != null)
|
||
{
|
||
if (!string.IsNullOrEmpty(filter.Sort))
|
||
realOrders[filter.Sort] = filter.Order;
|
||
if (filter.Orders != null && filter.Orders.Any())
|
||
foreach (var item in filter.Orders)
|
||
realOrders[item.Field] = item.Order;
|
||
}
|
||
if (orders != null && orders.Any())
|
||
{
|
||
foreach (var item in orders)
|
||
{
|
||
DbOrder dbOrder = DbOrder.ASC;
|
||
if (item.Value == "DESC")
|
||
dbOrder = DbOrder.DESC;
|
||
realOrders[item.Key] = dbOrder;
|
||
}
|
||
}
|
||
return expression;
|
||
}
|
||
|
||
private Expression<Func<T, bool>> GetPermissionExpression<T>(BaseFilter filter, out Expression<Func<T, bool>> orgExpression) where T : MesEntityBase, new()
|
||
{
|
||
orgExpression = t => true;
|
||
Expression<Func<T, bool>> expression = t => true;
|
||
|
||
if (filter.IgnoreOrgRule)
|
||
{
|
||
return null;
|
||
if (filter.OrgId == null)
|
||
return null;
|
||
expression = t => t.ORG_ID == filter.OrgId;
|
||
orgExpression = orgExpression.And(t => t.ORG_ID == filter.OrgId);
|
||
}
|
||
else
|
||
{
|
||
var currtOrgId = filter?.OrgId;
|
||
Expression<Func<T, bool>> orgPress = t => false;
|
||
if (filter != null && filter.OrgRule.Any())
|
||
{
|
||
foreach (var s in filter.OrgRule)
|
||
{
|
||
orgPress = orgPress.Or(t => t.ORG_ID == s);
|
||
}
|
||
}
|
||
if (currtOrgId != null)
|
||
orgPress = orgPress.Or(t => t.ORG_ID == currtOrgId);
|
||
expression = expression.And(orgPress);
|
||
orgExpression = orgExpression.And(orgPress);
|
||
}
|
||
return expression;
|
||
|
||
#region 原组织权限模式
|
||
/*
|
||
if (filter.OrgType == FilterOrgTypeEnum.默认)
|
||
{
|
||
var sysPermission = APT.Infrastructure.Api.AppContext.SysPermission;
|
||
List<Guid> parentOrgIds = new List<Guid>();
|
||
List<Guid> childrenOrgIds = new List<Guid>();
|
||
OrgCache orgCache = null;
|
||
UserOrgCache userOrgCache = null;
|
||
if (sysPermission != null)
|
||
{
|
||
if (sysPermission.OrgCaches != null)
|
||
{
|
||
if (sysPermission.OrgCaches.TryGetValue(filter.OrgId.Value, out orgCache))
|
||
{
|
||
if (orgCache.AllChildrenIds != null && orgCache.AllChildrenIds.Any())
|
||
childrenOrgIds.AddRange(orgCache.AllChildrenIds);
|
||
if (orgCache.AllParentIds != null && orgCache.AllParentIds.Any())
|
||
parentOrgIds.AddRange(orgCache.AllParentIds);
|
||
}
|
||
}
|
||
if (sysPermission.UserOrgCaches != null && APT.Infrastructure.Api.AppContext.CurrentSession != null &&
|
||
APT.Infrastructure.Api.AppContext.CurrentSession.UserID != null)
|
||
{
|
||
if (sysPermission.UserOrgCaches.TryGetValue(APT.Infrastructure.Api.AppContext.CurrentSession.UserID.Value, out userOrgCache))
|
||
{
|
||
if (userOrgCache.Orgs != null && userOrgCache.Orgs.Any())
|
||
{
|
||
foreach (var org in userOrgCache.Orgs)
|
||
{
|
||
if (sysPermission.OrgCaches.TryGetValue(org, out orgCache))
|
||
{
|
||
if (orgCache.AllChildrenIds != null && orgCache.AllChildrenIds.Any())
|
||
{
|
||
var remains = orgCache.AllChildrenIds.Where(t => !childrenOrgIds.Contains(t)).ToList();
|
||
if (remains != null && remains.Any())
|
||
childrenOrgIds.AddRange(remains);
|
||
}
|
||
if (orgCache.AllParentIds != null && orgCache.AllParentIds.Any())
|
||
{
|
||
var remains = orgCache.AllParentIds.Where(t => !parentOrgIds.Contains(t)).ToList();
|
||
if (remains != null && remains.Any())
|
||
parentOrgIds.AddRange(remains);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
expression = t => ((t.ENTITY_ORG_TPYE == 0 || t.ENTITY_ORG_TPYE == 1) && (t.ORG_ID == filter.OrgId || childrenOrgIds.Contains(t.ORG_ID ?? Guid.Empty))) ||
|
||
(t.ENTITY_ORG_TPYE == 1 && (parentOrgIds.Contains(t.ORG_ID ?? Guid.Empty))) ||
|
||
(t.ENTITY_ORG_TPYE == 2) ||
|
||
(t.ENTITY_ORG_TPYE == 3 && t.ORG_ID == filter.OrgId);
|
||
|
||
}
|
||
else if (filter.OrgType == FilterOrgTypeEnum.仅本组织)
|
||
{
|
||
expression = t => t.ORG_ID == filter.OrgId;
|
||
}
|
||
if (expression != null)
|
||
{
|
||
var sysPermission = APT.Infrastructure.Api.AppContext.SysPermission;
|
||
if (!string.IsNullOrEmpty(filter.AuthOrgCodes) && sysPermission != null)
|
||
{
|
||
var authOrgIds = new List<Guid>();
|
||
var c = filter.AuthOrgCodes.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
|
||
foreach (var i in c)
|
||
{
|
||
Guid orgId;
|
||
if (sysPermission.OrgCodeCaches.TryGetValue(i, out orgId))
|
||
authOrgIds.Add(orgId);
|
||
}
|
||
if (authOrgIds.Any())
|
||
expression = expression.Or(t => authOrgIds.Contains(t.ORG_ID ?? Guid.Empty));
|
||
}
|
||
}
|
||
return expression;
|
||
*/
|
||
#endregion
|
||
|
||
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 检查唯一性
|
||
/// </summary>
|
||
/// <param name="entities"></param>
|
||
private void CheckUnique<T>(IEnumerable<T> entities, IEnumerable<T> deleteEntities) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any()) return;
|
||
List<Guid> delIds = new List<Guid>();
|
||
if (deleteEntities != null && deleteEntities.Any())
|
||
delIds = deleteEntities.Select(i => i.ID).ToList();
|
||
Type type = typeof(T);
|
||
|
||
foreach (PropertyInfo item in type.GetProperties())
|
||
{
|
||
CUniqueAttribute cUniqueAttr = null;
|
||
object[] attrs = item.GetCustomAttributes(typeof(CUniqueAttribute), true);
|
||
if (attrs.Length == 1)
|
||
cUniqueAttr = (CUniqueAttribute)attrs[0];
|
||
|
||
if (cUniqueAttr == null) continue;
|
||
|
||
var groupByOrgIds = entities.GroupBy(t => t.ORG_ID).ToList();
|
||
foreach (var oId in groupByOrgIds)
|
||
{
|
||
BaseFilter filter = new BaseFilter();
|
||
FilterGroup filterGroup = new FilterGroup(false);
|
||
Guid? orgId = oId.Key;
|
||
var temps = oId.ToList();// entities.Where(t => t.ORG_ID == oId).ToList();
|
||
bool checkSelf = temps.Count() == 1 ? false : true;
|
||
int count = 0;
|
||
foreach (var entity in temps)
|
||
{
|
||
PropertyInfo propertyInfo = type.GetProperty("ID");
|
||
if (propertyInfo == null) continue;
|
||
object id = propertyInfo.GetValue(entity, null);
|
||
if (id == null) continue;
|
||
if (orgId == null)
|
||
{
|
||
propertyInfo = type.GetProperty("ORG_ID"); //获取指定名称的属性
|
||
if (propertyInfo == null) continue;
|
||
|
||
object tmpOrgId = propertyInfo.GetValue(entity, null); //获取属性值
|
||
if (tmpOrgId != null)
|
||
orgId = (Guid)tmpOrgId;
|
||
}
|
||
FilterGroup tmp = new FilterGroup();
|
||
object obj = item.GetValue(entity, null);
|
||
if ((obj == null || string.IsNullOrEmpty(obj.ToString())) && !cUniqueAttr.IsCheckEmpty) continue;
|
||
tmp.Rules.Add(new FilterRule("ID", id, FilterOperate.NotEqual));
|
||
tmp.Rules.Add(new FilterRule(item.Name, obj, FilterOperate.Equal));
|
||
filterGroup.Groups.Add(tmp);
|
||
count++;
|
||
if (count >= 100)
|
||
{
|
||
filter.FilterGroup.Groups.Add(filterGroup);
|
||
DoCheckUnique(item, cUniqueAttr, filter, checkSelf, orgId, temps, entities, delIds);
|
||
filter = new BaseFilter();
|
||
filterGroup = new FilterGroup(false);
|
||
count = 0;
|
||
}
|
||
}
|
||
if (filterGroup.Groups.Any())
|
||
{
|
||
filter.FilterGroup.Groups.Add(filterGroup);
|
||
DoCheckUnique(item, cUniqueAttr, filter, checkSelf, orgId, temps, entities, delIds);
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
private void DoCheckUnique<T>(PropertyInfo item, CUniqueAttribute cUniqueAttr, BaseFilter filter, bool checkSelf,
|
||
Guid? orgId, IEnumerable<T> temps, IEnumerable<T> entities, List<Guid> delIds) where T : MesEntityBase, new()
|
||
{
|
||
//Expression<Func<T, bool>> express = null;
|
||
//if (cUniqueAttr.IsCheckOrg)
|
||
// express = t => t.ORG_ID == orgId;
|
||
//else
|
||
// express = t => true;
|
||
//if (delIds.Any())
|
||
// express = t => !delIds.Contains(t.ID);
|
||
//express = express.And(filter.BuildExpression<T>(this.UnitOfWork));
|
||
//T dbEntity = null;
|
||
//var hasExistRecord = false;
|
||
//if (checkSelf)
|
||
//{
|
||
// if (cUniqueAttr.IsCheckOrg)
|
||
// hasExistRecord = temps.Where(express.Compile()).Any();
|
||
// else
|
||
// hasExistRecord = entities.Where(express.Compile()).Any();
|
||
//}
|
||
|
||
////if (!hasExistRecord)
|
||
////{
|
||
//dbEntity = this.UnitOfWork.GetEntity<T>(express, null, false);
|
||
//hasExistRecord = dbEntity != null;
|
||
////}
|
||
|
||
//if (hasExistRecord)
|
||
//{
|
||
// if (cUniqueAttr.IsCheckOrg)
|
||
// {
|
||
// var dbId = dbEntity.ID;
|
||
// var entity = temps.FirstOrDefault(i => i.ID == dbId);
|
||
// if (entity != null)
|
||
// return;
|
||
// }
|
||
// else
|
||
// {
|
||
// var dbId = dbEntity.ID;
|
||
// var entity = entities.FirstOrDefault(i => i.ID == dbId);
|
||
// if (entity != null)
|
||
// return;
|
||
// }
|
||
// string displayName = string.Empty;
|
||
// if (cUniqueAttr != null && !string.IsNullOrEmpty(cUniqueAttr.DisplayName))
|
||
// displayName = cUniqueAttr.DisplayName;
|
||
// if (string.IsNullOrEmpty(displayName))
|
||
// {
|
||
// object[] tmps = item.GetCustomAttributes(typeof(DescriptionAttribute), true);
|
||
// if (tmps.Length >= 1)
|
||
// {
|
||
// var descAttr = (DescriptionAttribute)tmps[0];
|
||
// displayName = "字段【" + descAttr.Description + "】";
|
||
// }
|
||
// }
|
||
// throw new Exception(displayName + "已存在其他记录，请确认");
|
||
//}
|
||
}
|
||
|
||
|
||
|
||
|
||
//private void DoSetIsLeafByUpdate<T>(IEnumerable<T> entities, List<Guid> addParentIds, List<Guid> deleteParentIds, List<Guid> deleteIds)
|
||
// where T : MesEntityBase, new()
|
||
//{
|
||
// if (entities != null)
|
||
// {
|
||
// var def = entities.FirstOrDefault();
|
||
// if (def != null && def is MesTreeEntityBase)
|
||
// {
|
||
// var ids = entities.Select(t => t.ID).ToList();
|
||
// List<T> dbUpdateEntities = this.UnitOfWork.GetEntities<T>(t => ids.Contains(t.ID), null, false).ToList();
|
||
// foreach (var entity in entities)
|
||
// {
|
||
// var dbEntity = dbUpdateEntities.FirstOrDefault(t => t.ID.ToString() == entity.ID.ToString());
|
||
// if (dbEntity != null)
|
||
// {
|
||
// var entityTree = entity as MesTreeEntityBase;
|
||
// var dbEntityTree = dbEntity as MesTreeEntityBase;
|
||
// if (entityTree.PARENT_ID != dbEntityTree.PARENT_ID)
|
||
// {
|
||
// if (entityTree.PARENT_ID != null)
|
||
// addParentIds.Add(entityTree.PARENT_ID.Value);
|
||
// if (dbEntityTree.PARENT_ID != null)
|
||
// {
|
||
// deleteParentIds.Add(dbEntityTree.PARENT_ID.Value);
|
||
// deleteIds.Add(dbEntity.ID);
|
||
// }
|
||
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// var entityTree = entity as MesTreeEntityBase;
|
||
// if (entityTree.PARENT_ID != null)
|
||
// addParentIds.Add(entityTree.PARENT_ID.Value);
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
|
||
//private void DoSetIsLeaf<T>(IEnumerable<T> entities, List<Guid> deleteIds, bool isAdd)
|
||
//{
|
||
// if (entities != null)
|
||
// {
|
||
// var def = entities.FirstOrDefault();
|
||
// if (def != null && def is MesTreeEntityBase)
|
||
// {
|
||
// List<Guid> parentIds = new List<Guid>();
|
||
// foreach (var item in entities)
|
||
// {
|
||
// var treeEntity = item as MesTreeEntityBase;
|
||
// if (treeEntity.PARENT_ID != null)
|
||
// {
|
||
// parentIds.Add(treeEntity.PARENT_ID.Value);
|
||
// }
|
||
// }
|
||
// MethodInfo methodInfo = this.GetType().GetMethod("SetParentIsLeaf",
|
||
// BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
|
||
// methodInfo.MakeGenericMethod(new Type[] { def.GetType() }).
|
||
// Invoke(this, new object[] { parentIds, deleteIds, isAdd });
|
||
|
||
// }
|
||
// }
|
||
|
||
//}
|
||
|
||
|
||
private void SaveSysParams(List<T_PF_PARAM> pfParams)
|
||
{
|
||
if (pfParams == null || !pfParams.Any()) return;
|
||
|
||
var ids = pfParams.Select(t => t.ID).ToList();
|
||
var dbParams = this.UnitOfWork.GetEntities<T_PF_PARAM>(t => ids.Contains(t.ID), null, false).ToList();
|
||
List<T_PF_PARAM> updateParams = new List<T_PF_PARAM>();
|
||
List<T_PF_PARAM> deleteParams = new List<T_PF_PARAM>();
|
||
List<T_PF_PARAM> addParams = new List<T_PF_PARAM>();
|
||
foreach (var item in pfParams)
|
||
{
|
||
var dbP = dbParams.FirstOrDefault(t => t.ID == item.ID);
|
||
if (dbP != null)
|
||
{
|
||
if (item.VIR_IS_DELETED)
|
||
{
|
||
//var entry1 = this._pfParamDataSet.GetContext().Entry(dbP);
|
||
// entry1.State = EntityState.Deleted;
|
||
deleteParams.Add(dbP);
|
||
continue;
|
||
}
|
||
dbP.ENTITY_ID = item.ENTITY_ID;
|
||
dbP.CODE = item.CODE;
|
||
dbP.VALUE = item.VALUE;
|
||
//var entry = this._pfParamDataSet.GetContext().Entry(dbP);
|
||
//entry.State = EntityState.Modified;
|
||
updateParams.Add(dbP);
|
||
}
|
||
else
|
||
{
|
||
if (item.VIR_IS_DELETED) continue;
|
||
//var entry = this._pfParamDataSet.GetContext().Entry(item);
|
||
//entry.State = EntityState.Added;
|
||
addParams.Add(item);
|
||
}
|
||
}
|
||
if (addParams.Any())
|
||
this.UnitOfWork.AddEntities(addParams);
|
||
if (updateParams.Any())
|
||
this.UnitOfWork.UpdateEntities(updateParams);
|
||
if (deleteParams.Any())
|
||
this.UnitOfWork.DeleteEntities(deleteParams);
|
||
}
|
||
|
||
//public void SetParentIsLeaf<T>(List<Guid> parentIds, List<Guid> deleteIds, bool isAdd) where T : MesTreeEntityBase, new()
|
||
//{
|
||
// if (parentIds != null && parentIds.Any())
|
||
// {
|
||
// if (isAdd)
|
||
// {
|
||
// var parentEntities = this.UnitOfWork.GetEntities<T>(t => parentIds.Contains(t.ID), null, true).ToList();
|
||
// parentEntities.ForEach(item =>
|
||
// {
|
||
// item.IS_LEAF = false;
|
||
// });
|
||
// foreach (var item in parentEntities)
|
||
// {
|
||
// this.SetRedis(item, RedisHanddle.Update);
|
||
// }
|
||
// this.UnitOfWork.UpdateEntities(parentEntities);
|
||
// }
|
||
// else
|
||
// {
|
||
// var parentEntities = this.UnitOfWork.GetEntities<T>(t => parentIds.Contains(t.ID), null, true).ToList();
|
||
// var childEntities = this.UnitOfWork.GetEntities<T>(t => t.PARENT_ID != null && parentIds.Contains(t.PARENT_ID ?? Guid.Empty), null, true).ToList();
|
||
// List<T> updateEntities = new List<T>();
|
||
// parentEntities.ForEach(item =>
|
||
// {
|
||
// var theChilds = childEntities.Where(i => i.PARENT_ID == item.ID).ToList();
|
||
// var theChildIds = theChilds.Select(i => i.ID).ToList();
|
||
// theChildIds.RemoveAll(i => deleteIds.Contains(i));
|
||
// if (!theChildIds.Any() && !item.IS_LEAF)
|
||
// {
|
||
// item.IS_LEAF = true;
|
||
// updateEntities.Add(item);
|
||
// }
|
||
// });
|
||
// if (updateEntities.Count > 0)
|
||
// {
|
||
// foreach (var item in updateEntities)
|
||
// {
|
||
// this.SetRedis(item, RedisHanddle.Update);
|
||
// }
|
||
// this.UnitOfWork.UpdateEntities(updateEntities);
|
||
// }
|
||
|
||
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
|
||
|
||
/// <summary>
|
||
///
|
||
/// </summary>
|
||
/// <param name="entities"></param>
|
||
/// <param name="updateType">0-新增 1-更新 2-删除</param>
|
||
private void UpdateSerialUsedStatus<T>(IEnumerable<T> entities, int updateType, List<UpdateCodeSerialInfo> updateSerialInfos) where T : MesEntityBase, new()
|
||
{
|
||
return;
|
||
if (entities == null || !entities.Any()) return;
|
||
|
||
Type type = typeof(T);
|
||
bool checkSelf = entities.Count() == 1 ? false : true;
|
||
// List<UpdateCodeSerialInfo> updateSerialInfos = new List<UpdateCodeSerialInfo>();
|
||
|
||
List<T> dbEntities = null;
|
||
if (updateType == 1)
|
||
{
|
||
var ids = entities.Select(t => t.ID).ToList();
|
||
dbEntities = this.UnitOfWork.GetEntities<T>(t => ids.Contains(t.ID), null, false).ToList();
|
||
}
|
||
foreach (PropertyInfo item in type.GetProperties())
|
||
{
|
||
CodeRuleAttribute cUniqueAttr = null;
|
||
object[] attrs = item.GetCustomAttributes(typeof(CodeRuleAttribute), true);
|
||
if (attrs.Length == 1)
|
||
cUniqueAttr = (CodeRuleAttribute)attrs[0];
|
||
|
||
if (cUniqueAttr == null) continue;
|
||
|
||
|
||
string displayName = string.Empty;
|
||
object[] tmps = item.GetCustomAttributes(typeof(CUniqueAttribute), true);
|
||
if (tmps != null && tmps.Any())
|
||
{
|
||
var descAttr = (CUniqueAttribute)tmps[0];
|
||
displayName = "字段【" + descAttr.DisplayName + "】";
|
||
}
|
||
if (string.IsNullOrWhiteSpace(displayName))
|
||
{
|
||
tmps = item.GetCustomAttributes(typeof(DescriptionAttribute), true);
|
||
if (tmps != null && tmps.Any())
|
||
{
|
||
var descAttr = (DescriptionAttribute)tmps[0];
|
||
displayName = "字段【" + descAttr.Description + "】";
|
||
}
|
||
}
|
||
|
||
|
||
foreach (var entity in entities)
|
||
{
|
||
object obj = item.GetValue(entity, null);
|
||
if (updateType == 0 || updateType == 2)
|
||
{
|
||
if (obj == null) continue;
|
||
var code = obj.ToString();
|
||
if (string.IsNullOrEmpty(code)) continue;
|
||
this.UpdateSerialUsedStatusSql(updateSerialInfos, cUniqueAttr, displayName, code, updateType == 0);
|
||
|
||
}
|
||
else
|
||
{
|
||
var dbEntity = dbEntities == null ? null : dbEntities.FirstOrDefault(t => t.ID.ToString() == entity.ID.ToString());
|
||
if (dbEntity != null)
|
||
{
|
||
object dbObj = item.GetValue(dbEntity, null);
|
||
string code = obj == null ? string.Empty : obj.ToString();
|
||
string dbCode = dbObj == null ? string.Empty : dbObj.ToString();
|
||
if (string.Compare(code, dbCode, true) != 0)
|
||
{
|
||
if (string.IsNullOrEmpty(dbCode))
|
||
this.UpdateSerialUsedStatusSql(updateSerialInfos, cUniqueAttr, displayName, dbCode, false);
|
||
if (string.IsNullOrEmpty(code))
|
||
this.UpdateSerialUsedStatusSql(updateSerialInfos, cUniqueAttr, displayName, code, true);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
|
||
private void ExcuteUpdateSerialInfos(List<UpdateCodeSerialInfo> updateSerialInfos)
|
||
{
|
||
|
||
if (updateSerialInfos != null && updateSerialInfos.Any())
|
||
{
|
||
List<int> types = updateSerialInfos.SelectMany(t => t.CodeTypes).Distinct().ToList();
|
||
List<string> serials = updateSerialInfos.Select(t => t.Serial).Distinct().ToList();
|
||
var dbSerials = this.UnitOfWork.GetEntities<T_PF_CODE_RULE_SERIAL>(t => types.Contains(t.CODE_TYPE) && serials.Contains(t.SERIAL), null, false).ToList();
|
||
List<T_PF_CODE_RULE_SERIAL> updateCodeRuleSerials = new List<T_PF_CODE_RULE_SERIAL>();
|
||
var nowTime = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
|
||
foreach (var item in updateSerialInfos)
|
||
{
|
||
var ss = dbSerials.Where(t => item.CodeTypes.Contains(t.CODE_TYPE) && t.SERIAL == item.Serial).ToList();
|
||
if (ss != null && ss.Any())
|
||
{
|
||
ss.ForEach(t =>
|
||
{
|
||
if (t.STATUS == 2 && item.IsUsed && item.IsCheckState)
|
||
throw new Exception((string.IsNullOrEmpty(item.DisplayCodeName) ? "编号" : item.DisplayCodeName)
|
||
+ t.SERIAL + "已被其他用户使用，请稍后重试");
|
||
|
||
t.STATUS = item.IsUsed ? 2 : 0;
|
||
t.USE_TIME = item.IsUsed ? item.Time : null;
|
||
t.ROW_VERSION++;
|
||
t.MODIFY_TIME = nowTime;
|
||
});
|
||
updateCodeRuleSerials.AddRange(ss);
|
||
}
|
||
}
|
||
if (updateCodeRuleSerials.Any())
|
||
this.UnitOfWork.UpdateEntities(updateCodeRuleSerials);
|
||
}
|
||
|
||
}
|
||
|
||
private void UpdateSerialUsedStatusSql(List<UpdateCodeSerialInfo> updateSerialInfos, CodeRuleAttribute codeRuleAttr, string displayName, string code, bool isUsed)
|
||
{
|
||
if (codeRuleAttr != null && codeRuleAttr.CodeRuleTypes != null && codeRuleAttr.CodeRuleTypes.Any())
|
||
{
|
||
UpdateCodeSerialInfo info = new UpdateCodeSerialInfo();
|
||
info.Serial = code;
|
||
info.CodeTypes.AddRange(codeRuleAttr.CodeRuleTypes);
|
||
info.IsUsed = isUsed;
|
||
info.Time = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")); ;
|
||
info.DisplayCodeName = displayName;
|
||
info.IsCheckState = codeRuleAttr.IsCheckState;
|
||
updateSerialInfos.Add(info);
|
||
|
||
}
|
||
}
|
||
|
||
|
||
void CheckRowVersion<T>(IEnumerable<T> entities) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any()) return;
|
||
|
||
bool isRowVersion = false;
|
||
foreach (var item in entities)
|
||
{
|
||
isRowVersion = item is IRowVersion;
|
||
break;
|
||
}
|
||
if (!isRowVersion) return;
|
||
var ids = entities.Select(t => t.ID).ToList();
|
||
var dbEntities = this.UnitOfWork.GetEntities<T>(t => ids.Contains(t.ID), null, false).ToList();
|
||
foreach (var entity in entities)
|
||
{
|
||
var dbEntity = dbEntities.Where(t => t.ID.ToString() == entity.ID.ToString()).FirstOrDefault();
|
||
if (dbEntity != null)
|
||
{
|
||
IRowVersion rowVersion = entity as IRowVersion;
|
||
IRowVersion dbRowVersion = dbEntity as IRowVersion;
|
||
if (rowVersion.ROW_VERSION != dbRowVersion.ROW_VERSION)
|
||
throw new RowVersionException("当前数据已发生修改，请先执行查询操作");
|
||
rowVersion.ROW_VERSION += 1;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
void CheckRowVersion<T>(IEnumerable<T> entities, EfDbContext contex) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any()) return;
|
||
|
||
bool isRowVersion = false;
|
||
foreach (var item in entities)
|
||
{
|
||
isRowVersion = item is IRowVersion;
|
||
break;
|
||
}
|
||
if (!isRowVersion) return;
|
||
var ids = entities.Select(t => t.ID).ToList();
|
||
var dbEntities = contex.GetEntities<T>(t => ids.Contains(t.ID), null, false).ToList();
|
||
foreach (var entity in entities)
|
||
{
|
||
var dbEntity = dbEntities.Where(t => t.ID.ToString() == entity.ID.ToString()).FirstOrDefault();
|
||
if (dbEntity != null)
|
||
{
|
||
IRowVersion rowVersion = entity as IRowVersion;
|
||
IRowVersion dbRowVersion = dbEntity as IRowVersion;
|
||
if (rowVersion.ROW_VERSION != dbRowVersion.ROW_VERSION)
|
||
throw new RowVersionException("当前数据已发生修改，请先执行查询操作");
|
||
rowVersion.ROW_VERSION += 1;
|
||
}
|
||
}
|
||
|
||
}
|
||
private void DoGetSysParamByEntity(MesEntityBase entityBase, MesEntityBase parentEntityBase, string parentInclude,
|
||
List<string> includes, Action<PropertyInfo, object> action)
|
||
{
|
||
string path = parentInclude;
|
||
if (!string.IsNullOrEmpty(path))
|
||
path += ".";
|
||
path += "Nav_SysParams";
|
||
bool isInclude = includes.Contains(path);
|
||
var type = entityBase.GetType();
|
||
if (isInclude)
|
||
{
|
||
action(type.GetProperty("ID"), entityBase);
|
||
}
|
||
foreach (var propertyInfo in type.GetProperties())
|
||
{
|
||
var propertyType = propertyInfo.PropertyType;
|
||
if (propertyType.IsGenericType)
|
||
{
|
||
var types = propertyType.GetGenericArguments();
|
||
Type realType = null;
|
||
if (types != null && types.Any())
|
||
realType = types[0];
|
||
if (realType.IsClass)
|
||
{
|
||
var baseType = realType.BaseType;
|
||
if (baseType == typeof(MesEntityBase) || baseType == typeof(MesTreeEntityBase))
|
||
{
|
||
object obj = propertyInfo.GetValue(entityBase, null);
|
||
if (obj != null && obj is System.Collections.IList)
|
||
{
|
||
List<MesEntityBase> testBases = new List<MesEntityBase>();
|
||
System.Collections.IList enumerator = obj as System.Collections.IList;
|
||
for (int i = 0; i < enumerator.Count; i++)
|
||
{
|
||
var ix = enumerator[i];
|
||
testBases.Add(ix as MesEntityBase);
|
||
}
|
||
if (testBases.Any())
|
||
DoForEachEntitiesOnIncludes(testBases, entityBase, string.IsNullOrEmpty(parentInclude) ?
|
||
propertyInfo.Name : (parentInclude + "." + propertyInfo.Name), includes, action);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (propertyType.IsClass)
|
||
{
|
||
var baseType = propertyType.BaseType;
|
||
if (baseType == typeof(MesEntityBase) || baseType == typeof(MesTreeEntityBase))
|
||
{
|
||
var obj = propertyInfo.GetValue(entityBase, null);
|
||
if (obj != null)
|
||
{
|
||
var temp = obj as MesEntityBase;
|
||
if (parentEntityBase == null || parentEntityBase.ID != temp.ID)
|
||
DoGetSysParamByEntity(temp, entityBase, string.IsNullOrEmpty(parentInclude) ?
|
||
propertyInfo.Name : (parentInclude + "." + propertyInfo.Name), includes, action);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private void DoForEachEntitiesOnIncludes(IEnumerable<MesEntityBase> entities, MesEntityBase parentEntityBase, string parentInclude, List<string> includes,
|
||
Action<PropertyInfo, object> action)
|
||
{
|
||
if (entities == null || !entities.Any() || includes == null || !includes.Any() ||
|
||
!includes.Any(t => t.IndexOf("Nav_SysParams", StringComparison.OrdinalIgnoreCase) > -1)) return;
|
||
|
||
foreach (var item in entities)
|
||
DoGetSysParamByEntity(item, parentEntityBase, parentInclude, includes, action);
|
||
|
||
|
||
}
|
||
/// <summary>
|
||
/// 设置首字母缩写字段
|
||
/// </summary>
|
||
/// <typeparam name="T"></typeparam>
|
||
/// <param name="entities"></param>
|
||
private void FillAcronymFieldData<T>(IEnumerable<T> entities, params string[] updateField) where T : MesEntityBase, new()
|
||
{
|
||
if (entities == null || !entities.Any()) return;
|
||
Type type = typeof(T);
|
||
foreach (var p in type.GetProperties())
|
||
{
|
||
AcronymFieldAttribute acronymAttr = null;
|
||
object[] attrs = p.GetCustomAttributes(typeof(AcronymFieldAttribute), true);
|
||
if (attrs.Length == 1)
|
||
acronymAttr = (AcronymFieldAttribute)attrs[0];
|
||
if (acronymAttr == null || string.IsNullOrEmpty(acronymAttr.AcronymFieldName)) continue;
|
||
var acronymP = type.GetProperty(acronymAttr.AcronymFieldName);
|
||
if (acronymP == null) continue;
|
||
updateField.Append(p.Name);
|
||
foreach (var entity in entities)
|
||
{
|
||
try
|
||
{
|
||
string aValue = null;
|
||
var o = p.GetValue(entity, null);
|
||
if (o != null)
|
||
{
|
||
var allSpell = AcronymHelper.ConvertToAllSpell(o.ToString());
|
||
var first = AcronymHelper.ConvertToFirstSpell(o.ToString());
|
||
aValue = first + ";" + allSpell;
|
||
}
|
||
acronymP.SetValue(entity, aValue);
|
||
}
|
||
catch { }
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取所有的数据库连接
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private List<string> GetAllDbConns()
|
||
{
|
||
List<string> dbs = new List<string>();
|
||
List<string> conns = new List<string>();
|
||
//取redis
|
||
var tenantConnKey = ConfigurationManager.AppSettings["TenantConnKey"] + "_All_" + ConfigurationManager.AppSettings["Env"];
|
||
if (CsRedisManager.KeyExists(tenantConnKey))
|
||
{
|
||
conns = CsRedisManager.StringGet<List<string>>(tenantConnKey);
|
||
|
||
}
|
||
//查询
|
||
else
|
||
{
|
||
var url = APT.Infrastructure.Api.ConfigurationManager.AppSettings["AllConnApiUrl"];
|
||
if (!string.IsNullOrEmpty(url))
|
||
{
|
||
url += $"?deskey={DesKey}";
|
||
conns = WebUtils.Get<List<string>>(url, "");
|
||
|
||
}
|
||
}
|
||
if (conns != null && conns.Any())
|
||
{
|
||
foreach (var conn in conns)
|
||
{
|
||
dbs.Add(EncryptHelper.AesDecrypt(conn, DesKey));
|
||
}
|
||
}
|
||
return dbs;
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
} |