public bool Migrate(DBContextBase dbContext, Tenant tenant, MigrationType migrationType)
{
var result = true;
using (dbContext)
{
try
{
var migrator = dbContext.GetService <IMigrator>();
if (migrationType == MigrationType.Down)
{
migrator.Migrate(Migration.InitialDatabase);
}
else
{
migrator.Migrate();
}
}
catch (Exception e)
{
Console.WriteLine(e);
result = false;
}
}
return(result);
}
public virtual DBContextBase GetDataContext(ISessionable session, Type dataContextType)
{
if (!this.dataContextBySession.ContainsKey(session.Session.Guid))
{
this.dataContextBySession.Add(session.Session.Guid, new Dictionary <Type, DBContextBase>());
}
var dataContexts = this.dataContextBySession[session.Session.Guid];
Type mapType = GetMapDataContextType(dataContextType);
if (mapType != null)
{
if (dataContexts.ContainsKey(mapType))
{
return(dataContexts[mapType]);
}
ConstructorInfo cinfo = mapType.GetConstructor(new Type[] { typeof(IDatabase) });
if (cinfo == null)
{
throw new BusException("Typ " + mapType.Name + " nie posiada Kontruktora " + mapType.Name + "(IDatabase database, string connectionString)");
}
DBContextBase dbContext = (DBContextBase)cinfo.Invoke(new object[] { this });
if (dbContext != null)
{
dbContext.session = session.Session;
dataContexts.Add(mapType, dbContext);
return(dbContext);
}
}
throw new BusException("Nieprawidłowo zarejestrowany DataContext (" + dataContextType.Name + ")");
}
public WBPersistence(Func <DBContextBase> contextBuilder)
{
this.contextBuilder = contextBuilder;
dBContext = contextBuilder();
taskQueue = new ActionBlock <string>(query => dBContext.ExecuteNonQuery(query));
}
private List <T> GetLists()
{
using (var dbContext = new DBContextBase())
{
var allmodel = dbContext.GetContext <T>().Query("");
return(allmodel);
}
}
public void SetCtx(DBContextBase c)
{
// context must be assigned max 1 time
if (!ReferenceEquals(null, _ctx))
{
throw new ApplicationException("Db context can be assigned just one time!");
}
_ctx = new WeakReference(c);
}
public Repository(DBContextBase dbContext)
{
if (dbContext == null)
{
throw new ArgumentNullException("DBContextBase in Repository");
}
objectSet = dbContext.Set <DomainType>();
}
public BaseRepository(DBContextBase dbProvider)
{
_connection = dbProvider.Connection;
if (_connection.State == ConnectionState.Closed)
{
_connection.Open();
}
_transaction = dbProvider.Transaction;
_context = dbProvider;
}
private T GetOne(string key, object id)
{
using (var dbContext = new DBContextBase())
{
var models = dbContext.GetContext <T>().Query(" " + key + "=?", "", id);
if (models.Count > 0)
{
return(models[0]);
}
return(null);
}
}
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
context.Dispose();
context = null;
}
}
this.disposed = true;
}
public bool GetIsReallyChanged(bool ForceDetectChanges = false)
{
// cache original values
if (ReferenceEquals(_originalValues, null))
{
DBContextBase ctx = null;
bool oldState = true; // if something goes wrong it will force TRUE, it can slow down program, but cant break anything
try{
ctx = GetCtx();
if (ctx == null)
{
throw new ApplicationException("GetIsReallyChanged need db context!");
}
// defaultly off
oldState = ctx.Configuration.AutoDetectChangesEnabled;
ctx.Configuration.AutoDetectChangesEnabled = ForceDetectChanges;
System.Data.Entity.Infrastructure.DbEntityEntry <EntityBase> _Entry = ctx.Entry(this as EntityBase);
if (ReferenceEquals(_Entry, null) || ReferenceEquals(_Entry.OriginalValues, null))
{
throw new ApplicationException("GetIsReallyChanged can't identify entity in db contet!");
}
_originalValues = _Entry.OriginalValues;
}finally{
// be sure autodetect is on
if (!ReferenceEquals(ctx, null))
{
ctx.Configuration.AutoDetectChangesEnabled = oldState;
}
}
if (ReferenceEquals(_originalValues, null))
{
throw new ApplicationException("GetIsReallyChanged can't work without original values!");
}
}
/* just use original values and manually test */
foreach (string en in _originalValues.PropertyNames)
{
if (!Equals(_originalValues[en], GetPropertyValue(en)))
{
return(true);
}
}
// not changed
return(false);
}
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
ICallContext callContext = DependencyManager.Instance().Resolve <ICallContext>();
callContext.Remove(AppKeyConst.UoW);
context.Dispose();
context = null;
}
}
this.disposed = true;
}
public void DeleteEmployee(string employeeCode)
{
try
{
var deleteSql = string.Format("DELETE FROM [dbo].[hrm_t_employee_base] WHERE employee_code = {0}", employeeCode);
using (var dbContext = new DBContextBase())
{
dbContext.Database.ExecuteSqlCommand(deleteSql);
}
}
catch (Exception ex)
{
throw ex;
}
}
//public UnitOfWorkBase(ContextCache contextCache)
//{
// this.contextCache = contextCache;
//}
//public UnitOfWorkBase(DbContext dbcontext)
//{
// dbContext = dbcontext;
// ticks = DateTime.Now.Ticks;
//}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="contextCache"></param>
/// <param name="dbcontext"></param>
public UnitOfWorkBase(ContextCache contextCache, DBContextBase dbcontext)
{
dbContext = dbcontext;
this.contextCache = contextCache;
ticks = DateTime.Now.Ticks;
// 记录sql
dbContext.Database.Log = (sql) =>
{
if (string.IsNullOrEmpty(sql) == false)
{
SqlLog.AppendLine(sql);
if (DebugSql)
{
Debug.WriteLine(sql);
}
}
};
}
public bool Migrate(DBContextBase dbContext, Tenant tenant, MigrationType migrationType)
{
var result = true;
using (dbContext)
{
var migrator = dbContext.GetService <IMigrator>();
if (migrationType == MigrationType.Down)
{
migrator.Migrate(Migration.InitialDatabase);
}
else
{
migrator.Migrate();
}
}
return(result);
}
public virtual void SetCtx(DBContextBase c)
{
if (ReferenceEquals(null, c))
{
_ctx = null;
}
else
{
// context must be assigned max 1 time
if (!ReferenceEquals(null, _ctx) && !ReferenceEquals(c, GetCtx()))
{
throw new ApplicationException("Db context can be assigned just one time!");
}
// maby done
if (ReferenceEquals(c, GetCtx()))
{
return;
}
_ctx = new WeakReference(c);
}
// reset original values
_originalValues = null;
}
public DomainBaseOption(DBContextBase dbContext = null, ServiceContext serviceContext = null)
{
DBContext = dbContext;
ServiceContext = serviceContext;
}
public void SetCtx(DBContextBase c)
{
throw new NotImplementedException();
}
public void Init(DBContextBase dbContext, ServiceContext serviceContext)
{
DBContext = dbContext;
ServiceContext = serviceContext;
}
public static void SendMessage(DBContextBase dbContext, Messager CurrentMessager)
{
//********************消息队列******************************
var entries = dbContext.ChangeTracker.Entries();
// 如果默认不发送，则启动允许列表
if (FaSongPz == 0)
{
entries = entries.Where(m => DuiXingList.Contains(m.Entity.GetType().Name, StringComparer.InvariantCultureIgnoreCase));
}
else if (FaSongPz == 1) // 如果配置默认全部发送，则启动过滤列表
{
entries = entries.Where(m => !DuiXingList.Contains(m.Entity.GetType().Name.ToUpper()));
}
// 获取新增实体
var addedEntries = entries.Where(m => m.State == EntityState.Added);
foreach (DbEntityEntry entity in addedEntries)
{
// 创建一个Messager实体
MessageEntity messageEntity = new MessageEntity();
messageEntity.EntityName = entity.Entity.GetType().Name;
messageEntity.Type = OperationType.ADDED;
messageEntity.Entity = entity.Entity;
// 反射出entity中的所有属性
var properties = entity.Entity.GetType().GetProperties();
foreach (var propertie in properties)
{
// 获取主键
if (propertie.GetCustomAttributes(true).Any(m => m.GetType() == typeof(KeyAttribute)))
{
messageEntity.KeyNameList.Add(propertie.Name);
}
}
// 记录当前值
foreach (var pName in entity.CurrentValues.PropertyNames)
{
messageEntity.CurrentValues.Add(pName, entity.CurrentValues[pName]);
}
// 保存到当前待发送队列
CurrentMessager.AddedEntityList.Add(messageEntity);
CurrentMessager.EntityNameList.Add(messageEntity.EntityName);
CurrentMessager.IsPublish = true;
}
// 获取删除实体
var deletedEntries = entries.Where(m => m.State == EntityState.Deleted);
foreach (var entity in deletedEntries)
{
// 创建一个Messager实体
MessageEntity messageEntity = new MessageEntity();
messageEntity.EntityName = entity.Entity.GetType().Name;
messageEntity.Type = OperationType.DELETED;
messageEntity.Entity = entity.Entity;
// 反射出entity中的所有属性
var properties = entity.Entity.GetType().GetProperties();
foreach (var propertie in properties)
{
// 获取主键
if (propertie.GetCustomAttributes(true).Any(m => m.GetType() == typeof(KeyAttribute)))
{
messageEntity.KeyNameList.Add(propertie.Name);
}
}
// 记录历史值
foreach (var pName in entity.OriginalValues.PropertyNames)
{
messageEntity.OriginalValues.Add(pName, entity.OriginalValues[pName]);
}
// 保存到当前待发送队列
CurrentMessager.DeletedEntityList.Add(messageEntity);
CurrentMessager.EntityNameList.Add(messageEntity.EntityName);
CurrentMessager.IsPublish = true;
}
// 获取修改实体
var modifiedEntries = entries.Where(m => m.State == EntityState.Modified);
foreach (var entity in modifiedEntries)
{
// 创建一个Messager实体
MessageEntity messageEntity = new MessageEntity();
messageEntity.EntityName = entity.Entity.GetType().Name;
messageEntity.Type = OperationType.MODIFIED;
messageEntity.Entity = entity.Entity;
// 反射出entity中的所有属性
var properties = entity.Entity.GetType().GetProperties();
foreach (var propertie in properties)
{
// 获取主键
if (propertie.GetCustomAttributes(true).Any(m => m.GetType() == typeof(KeyAttribute)))
{
messageEntity.KeyNameList.Add(propertie.Name);
}
}
// 记录当前值
foreach (var pName in entity.CurrentValues.PropertyNames)
{
messageEntity.CurrentValues.Add(pName, entity.CurrentValues[pName]);
}
// 记录历史值
foreach (var pName in entity.OriginalValues.PropertyNames)
{
messageEntity.OriginalValues.Add(pName, entity.OriginalValues[pName]);
}
// 保存到当前待发送队列
CurrentMessager.ModifiedEntityList.Add(messageEntity);
CurrentMessager.EntityNameList.Add(messageEntity.EntityName);
CurrentMessager.IsPublish = true;
}
//***********************消息队列***************************
}
public override void SetCtx(DBContextBase ctx)
{
base.SetCtx(ctx);
_srcList = ctx.GetPropertyByName(_RootEntityPropertyName) as System.Data.Entity.DbSet <TEntity>;
_attachedToDb = true;
}
public BaseService(DBContextBase context)
{
Context = context;
_disposed = false;
}
public DomainBase(DBContextBase dbContext = null, ServiceContext serviceContext = null) : base(dbContext, serviceContext)
{
}
public RepositoryFactory(DBContextBase dbContext)
{
this.dbContext = dbContext ?? throw new ArgumentOutOfRangeException("dbContext in RepositoryFactory");
}
/// <summary>
/// 输出日志
/// </summary>
/// <param name="cmd"></param>
private void WriteSqlLog(DBContextBase dBContextBase, DbCommand cmd)
{
if (dBContextBase.Database.Log == null)
{
return;
}
StringBuilder builder = new StringBuilder(256);
builder.AppendLine(cmd.CommandText);
for (int i = 0; i < cmd.Parameters.Count; i++)
{
var parameter = cmd.Parameters[i];
builder.Append("-- ")
.Append(parameter.ParameterName);
if (null != parameter.Value && parameter.Value.GetType() == typeof(object[]))
{
object[] values = (object[])parameter.Value;
builder.Append(": ");
foreach (var item in values)
{
builder.Append("'")
.Append((item == null || item == DBNull.Value) ? "null" : item)
.Append(",");
}
if (values.Length > 0)
{
builder.Remove(builder.Length - 1, 1);
}
builder.Append("' (Type = ")
.Append(parameter.DbType);
}
else
{
builder.Append(": '")
.Append((parameter.Value == null || parameter.Value == DBNull.Value) ? "null" : parameter.Value)
.Append("' (Type = ")
.Append(parameter.DbType);
}
if (parameter.Direction != ParameterDirection.Input)
{
builder.Append(", Direction = ").Append(parameter.Direction);
}
if (!parameter.IsNullable)
{
builder.Append(", IsNullable = false");
}
if (parameter.Size != 0)
{
builder.Append(", Size = ").Append(parameter.Size);
}
if (((IDbDataParameter)parameter).Precision != 0)
{
builder.Append(", Precision = ").Append(((IDbDataParameter)parameter).Precision);
}
if (((IDbDataParameter)parameter).Scale != 0)
{
builder.Append(", Scale = ").Append(((IDbDataParameter)parameter).Scale);
}
builder.Append(")").Append(Environment.NewLine);
}
dBContextBase.Database.Log(builder.ToString());
}
internal RepositoryBase(DBContextBase context)
{
this.dbContext = context;
this.dbSet = context.Set <TEntity>();
}
public UnitOfWork(DBContextBase dbContext, IRepositoryFactory repositoryFactory)
{
this.dbContext = dbContext ?? throw new ArgumentNullException("dbContext in UnitOfWorkBase");
this.repositoryFactory = repositoryFactory ?? throw new ArgumentNullException("repositoryFactory in UnitOfWorkBase");
}
