private bool innerBeginTransaction(string connectionString)
{
try
{
if (string.IsNullOrEmpty(connectionString))
{
return(false);
}
if (TransConnection == null)
{
TransConnection = new NpgsqlConnection(connectionString);
}
if (TransConnection == null)
{
return(false);
}
if (TransConnection.State != ConnectionState.Open)
{
TransConnection.Open();
}
Transaction = TransConnection.BeginTransaction();
return(true);
}
catch (Exception ex)
{
var method = MethodBase.GetCurrentMethod();
Logger?.LogError(ex, $"Error in: {method.Module.Name} {method.Name}");
throw new DbDataException(ex, "");
}
}
private bool innerBeginTransaction(string connectionString)
{
try
{
if (string.IsNullOrEmpty(connectionString))
{
return(false);
}
if (TransConnection == null)
{
TransConnection = new SqlConnection(connectionString);
}
if (TransConnection == null)
{
return(false);
}
if (TransConnection.State != ConnectionState.Open)
{
TransConnection.Open();
}
Transaction = TransConnection.BeginTransaction();
return(true);
}
catch (Exception ex)
{
Logger?.LogError(ex, "Error at BeginTransaction");
throw new DbDataException(ex, "");
}
}
/// <summary> 还原历史版本 </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <TConfig> RecoveryAsync(string id)
{
//更新之前版本为历史版本
const string updateSql = "UPDATE [t_config] SET [status]=1 WHERE [project_id]=@projectId AND [name]=@name AND [mode]=@mode AND [status]=0";
return(await Transaction(async() =>
{
var history = await Connection.QueryByIdAsync <TConfig>(id);
if (history == null || history.Status != (byte)ConfigStatus.History)
{
throw new BusiException("历史版本不存在");
}
var count = await TransConnection.ExecuteAsync(Connection.FormatSql(updateSql), new
{
projectId = history.ProjectId,
name = history.Name,
mode = history.Mode
}, Trans);
//更新状态
history.Status = (byte)ConfigStatus.Normal;
count += await TransConnection.UpdateAsync(history, new[] { nameof(TConfig.Status) }, Trans);
return count > 0 ? history : null;
}));
}
/// <summary>
/// Protected implementation of Dispose pattern.
/// </summary>
/// <param name="disposing">Disposed flag.</param>
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
Connection?.Dispose();
TransConnection?.Dispose();
}
_disposed = true;
}
private int innerExecute(string query, int timeout, bool inTransaction)
{
try
{
using (var cmd = inTransaction
? TransConnection.CreateCommand()
: Connection.CreateCommand())
{
if (timeout != -1)
{
if (timeout >= 0)
{
cmd.CommandTimeout = timeout;
}
else
{
throw new ArgumentException("Invalid CommandTimeout value", nameof(timeout));
}
}
cmd.CommandText = query;
if (inTransaction)
{
cmd.Transaction = Transaction;
}
else
{
Connection.Open();
}
var rows = cmd.ExecuteNonQuery();
return(rows);
}
}
catch (Exception ex)
{
Logger?.LogError(ex, $"Error at Execute; command text: {query}");
throw new DbDataException(ex, query);
}
finally
{
if (!inTransaction)
{
if (Connection.State == ConnectionState.Open)
{
Connection.Close();
}
}
}
}
/// <summary> 保存配置 </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <int> UpdateAsync(TConfig model)
{
model.Id = IdentityHelper.Guid32;
model.Timestamp = Clock.Now;
model.Md5 = model.Content.Md5();
var version = await QueryVersionAsync(model.ProjectId, model.Name, model.Mode);
if (version != null && version == model.Md5)
{
throw new BusiException("配置未更改");
}
//更新之前版本为历史版本
return(await UnitOfWork.Trans(async() =>
{
var count = await DeleteByModuleAsync(model.ProjectId, model.Name, model.Mode);
count += await TransConnection.InsertAsync(model, trans: Trans);
return count;
}));
}
/// <inheritdoc />
public void RollbackTransaction()
{
try
{
Transaction.Rollback();
Transaction.Dispose();
Transaction = null;
if (TransConnection.State == ConnectionState.Open)
{
TransConnection.Close();
}
TransConnection.Dispose();
TransConnection = null;
}
catch (Exception ex)
{
Logger?.LogError(ex, "Error at RollbackTransaction");
throw new DbDataException(ex, "Error at RollbackTransaction");
}
}
/// <summary> 删除配置 </summary>
/// <param name="projectId"></param>
/// <param name="module"></param>
/// <param name="env"></param>
/// <returns></returns>
public async Task <int> DeleteByModuleAsync(string projectId, string module, string env)
{
//更新之前版本为历史版本
SQL updateSql =
"UPDATE [t_config] SET [status]=1 WHERE [project_id]=@projectId AND [name]=@name AND [status]=0";
if (string.IsNullOrWhiteSpace(env))
{
updateSql += "AND [mode] IS NULL";
}
else
{
updateSql += "AND [mode]=@mode";
}
var sql = Connection.FormatSql(updateSql.ToString());
return(await TransConnection.ExecuteAsync(sql, new { projectId, name = module, mode = env },
Trans));
}
/// <summary> 批量更新数据 </summary>
/// <param name="models"></param>
/// <param name="propExpression"></param>
/// <returns></returns>
public Task <int> UpdateAsync(IEnumerable <T> models, Expression <Func <T, object> > propExpression)
{
var props = propExpression.MemberNames()?.ToArray();
return(TransConnection.UpdateAsync(models, props, Trans));
}
/// <summary> 更新数据 </summary>
/// <param name="model"></param>
/// <param name="props"></param>
/// <returns></returns>
public Task <int> UpdateAsync(T model, string[] props = null)
{
return(TransConnection.UpdateAsync(model, props, Trans));
}
/// <summary> 批量插入 </summary>
/// <param name="models"></param>
/// <param name="excepts"></param>
/// <returns></returns>
public int Insert(IEnumerable <T> models, string[] excepts = null)
{
return(TransConnection.Insert <T>(models, excepts, Trans));
}
/// <summary> 插入单条数据,不支持有自增列 </summary>
/// <param name="model"></param>
/// <param name="excepts">过滤项(如：自增ID)</param>
/// <returns></returns>
public int Insert(T model, string[] excepts = null)
{
return(TransConnection.Insert(model, excepts, Trans));
}
/// <summary> 删除 </summary>
/// <param name="key"></param>
/// <param name="keyColumn"></param>
/// <returns></returns>
public int Delete(object key, string keyColumn = null)
{
return(TransConnection.Delete <T>(key, keyColumn, Trans));
}
/// <summary> 批量更新 </summary>
/// <param name="model"></param>
/// <param name="props"></param>
/// <returns></returns>
public int Update(IEnumerable <T> models, string[] props = null)
{
return(TransConnection.Update(models, props, Trans));
}
/// <summary> 插入单条数据,不支持有自增列 </summary>
/// <param name="model"></param>
/// <param name="excepts">过滤项(如：自增ID)</param>
/// <returns></returns>
public Task <int> InsertAsync(T model, string[] excepts = null)
{
return(TransConnection.InsertAsync(model, excepts, Trans));
}
/// <summary> 批量插入 </summary>
/// <param name="models"></param>
/// <param name="excepts"></param>
/// <returns></returns>
public Task <int> InsertAsync(IEnumerable <T> models, string[] excepts = null)
{
return(TransConnection.InsertAsync(models, excepts, Trans));
}
/// <summary> 更新 </summary>
/// <param name="model"></param>
/// <param name="props"></param>
/// <returns></returns>
public int Update(T model, string[] props = null)
{
return(TransConnection.Update(model, props, Trans));
}
/// <summary> 批量更新数据 </summary>
/// <param name="models"></param>
/// <param name="props"></param>
/// <returns></returns>
public Task <int> UpdateAsync(IEnumerable <T> models, string[] props = null)
{
return(TransConnection.UpdateAsync(models, props, Trans));
}
/// <summary> 更新 </summary>
/// <param name="model"></param>
/// <param name="props"></param>
/// <returns></returns>
public int Update(T model, Expression <Func <T, object> > propExpression)
{
var props = propExpression.MemberNames()?.ToArray();
return(TransConnection.Update(model, props, Trans));
}
/// <summary> 删除 </summary>
/// <param name="key"></param>
/// <param name="keyColumn"></param>
/// <returns></returns>
public Task <int> DeleteAsync(object key, string keyColumn = null)
{
return(TransConnection.DeleteAsync <T>(key, keyColumn, Trans));
}
public async Task <int> UpdateAsync(TAccount model)
{
return(await TransConnection.UpdateAsync(model, new[] { nameof(TAccount.Nick), nameof(TAccount.Avatar) }, Trans));
}
