public override UpdateAction Where(TableFilter filter)
{
if (this.UpdateColumns.Count == 0)
{
throw new Exception("no update columns");
}
#region update columns
string columnStr = string.Empty;
foreach (var col in this.UpdateColumns)
{
var p = new DBParam(col.Key, col.Value);
ParamCollection.Add(p);
columnStr += string.Format(" {0} ={1},", col.Key, p.ParamName);
}
columnStr = columnStr.TrimEnd(',');
#endregion
#region where
string filterCondition = string.Empty, where = string.Empty;
if (filter != null)
{
filterCondition = filter.Build(base.ParamCollection);
if (!string.IsNullOrWhiteSpace(filterCondition))
{
where = string.Format(" where {0} ", filterCondition);
}
}
#endregion
base.MainSql = string.Format("update {0} set {1} {2}", base.TableCode, columnStr, where);
return(this);
}
private string GetSelectTopStatement(int count, TableFilter filter, TableSort sort)
{
var sql = new StringBuilder();
sql.Append($"SELECT TOP {count} ");
filter.WriteColumnsProjection(sql);
sql.Append($" FROM {QuotedName} ");
if (count > 0)
{
if (filter != null && filter.IsRowFiltered)
{
sql.Append(" WHERE ");
filter.WriteWhereStatement(sql);
}
sql.Append(" ORDER BY ");
if (sort != null && sort.IsSorted)
{
sort.WriteOrderBy(sql);
}
else
{
WriteDefaultOrderBy(sql);
}
}
return(sql.ToString());
}
public override DataTable GetData(int startIndex, int count, TableFilter filter, TableSort sort)
{
var sql = new StringBuilder();
sql.Append("SELECT ");
filter.WriteColumnsProjection(sql);
sql.Append(" FROM ");
sql.Append(QuotedName);
if (filter != null && filter.IsRowFiltered)
{
sql.Append(" WHERE ");
filter.WriteWhereStatement(sql);
}
if (sort != null && sort.IsSorted)
{
sql.Append(" ORDER BY ");
sort.WriteOrderBy(sql);
}
sql.Append($" ROWS {startIndex + 1} TO {startIndex + count}");
var data = new DataTable(Name);
using (var connectionScope = Database.CreateConnectionScope())
using (var select = Connection.CreateCommand()) {
select.CommandText = sql.ToString();
using (var reader = select.ExecuteReader()) {
data.Load(reader);
}
}
return(data);
}
public override DataTable GetData(int startIndex, int count, TableFilter filter, TableSort sort)
{
var data = new DataTable(this.Name);
var text = new StringBuilder();
text.Append("SELECT ");
filter.WriteColumnsProjection(text);
text.Append(" FROM ");
text.Append(this.QuotedName);
if (filter.IsRowFiltered)
{
text.Append(" WHERE ");
filter.WriteWhereStatement(text);
}
if (sort != null && sort.IsSorted)
{
text.Append(" ORDER BY ");
sort.WriteOrderBy(text);
}
text.AppendFormat(" LIMIT {0}, {1}", startIndex, count);
using (var select = this.Connection.CreateCommand()) {
select.CommandText = text.ToString();
using (this.Database.CreateConnectionScope()) {
using (var adapter = (MySqlDataAdapter)this.Database.CreateAdapter(this, filter)) {
adapter.SelectCommand = select;
adapter.Fill(data);
}
}
}
return(data);
}
public TableDocument(Table table, TableFilter filter)
{
InitializeComponent();
this.tableToolStripMenuItem.DropDown = this.dataGridView.MainMenu;
this.autoResizeColumnsDropDownButton.DropDown = this.dataGridView.AutoResizeColumnsMenu;
this.rowsPerPage = Settings.Default.RowsPerPage;
this.rowsPerPageButton.Text = this.rowsPerPage.ToString();
this.table = table;
////this.adapter = table.Database.CreateAdapter(table);
this.filter = filter ?? new TableFilter(table);
this.sort = new TableSort(table);
////sort.SortPanel.LoadColumns(table.GetColumnNames());
////this.sortToolStripButton.DropDown.Items.Add(sort);
if (table.IsReadOnly)
{
SetReadOnlyTable();
}
SetupLoadingPanel();
HideLoadingPanel();
dataGridView.AutoGenerateColumns = true;
}
public async Task <int> Count(TableFilter filter)
{
IQueryable <TableDAO> Tables = DataContext.Table;
Tables = DynamicFilter(Tables, filter);
return(await Tables.CountAsync());
}
public int ProcessWftEvent(uint batchCount)
{
var filter = TableFilter.New().Equals("status", 0); //.Equals("waitcallback", 0);
//#if DEBUG
// filter = TableFilter.New().Equals("status", 0).Equals("flowid", "00001F493WJRC0000A01");
//#endif
var jobs = _DataAccess.Query(WFTEventEntity.TableCode).FixField("*").Paging(1, batchCount).Where(filter).QueryList <WFTEventEntity>();
Parallel.ForEach <WFTEventEntity>(jobs,
new ParallelOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount
}, (job) =>
{
try
{
Run(job);
}
catch (HttpRequestException ex)
{
_Logger.LogError($"处理wftevent发升网络错误：{ex.Message}", ex);
}
catch (Exception ex)
{
if (ex.InnerException != null)
{
_Logger.LogError($"处理wftevent发升错误InnerException：{ex.InnerException.Message}", ex.InnerException);
}
_Logger.LogError($"处理wftevent发升错误：{ex.Message}", ex);
}
});
return(jobs.Count());
}
public int Callback(string mqId)
{
var filter = TableFilter.New().Equals("id", mqId);
var eventEntity = _DataAccess.Query(WFTEventEntity.TableCode).FixField("*").Where(filter).QueryFirst <WFTEventEntity>();
if (eventEntity == null)
{
throw new Exception($"回调任务{mqId}不存在");
}
if (eventEntity.ProcessDate == DateTime.MinValue)
{
throw new Exception($"回到任务会处理完毕，请稍后回调");
}
var tinsEntity = _WFTask.GetTinsById(eventEntity.Tinsid);
var taskEntity = _WFTask.GetTaskById(eventEntity.Taskid);
var fins = _WorkFlowIns.GetFlowInstance(eventEntity.Finsid);
var bisJsonData = GetBisData(taskEntity, eventEntity.Dataid, fins.ServiceId, eventEntity.Tinsid, out bool isMultipleNextTask);
var nextTasks = _WFTask.GetNextTasks(taskEntity, tinsEntity, bisJsonData);
if (nextTasks.Length != 1)
{
throw new Exception("流程配置错误，下个任务节点数量必须是1");
}
taskEntity.ReplaceTemplateInfo(bisJsonData);
using (var tran = TransHelper.BeginTrans())
{
//1、更新任务实例状态
eventEntity.State = EDBEntityState.Modified;
eventEntity.Waitcallback = 0;
eventEntity.Callbackdate = DateTime.Now;
_DataAccess.Update(eventEntity);
tinsEntity.State = EDBEntityState.Modified;
tinsEntity.Edate = DateTime.Now;
_DataAccess.Update(tinsEntity);
//2、找下个任务节点，并流转，回调节点不应该有多个下个节点
//如果下一个节点是聚合节点，则需要加锁，防止与回调冲突。默认等待10S
if (nextTasks[0].Type == ETaskType.JuHe)
{
var lockKey = $"{MutexConfig.WORKFLOWLOCKPRE}{fins.Dataid}";
var success = ExeWithLock(lockKey, MutexConfig.WORKFLOWLOCKTIMEOUT, () =>
{
ExeNextTask(fins, nextTasks);
tran.Commit();
});
if (!success)
{
throw new Exception($"未获取独占锁，请重试，dataid：{fins.Dataid }");
}
}
else
{
ExeNextTask(fins, nextTasks);
tran.Commit();
}
}
return(1);
}
private string GetSelectOffsetFetchStatement(int startIndex, int count, TableFilter filter, TableSort sort)
{
var sql = new StringBuilder();
sql.Append("SELECT ");
filter.WriteColumnsProjection(sql);
sql.Append(" FROM ");
sql.Append(QuotedName);
if (filter.IsRowFiltered)
{
sql.Append(" WHERE ");
filter.WriteWhereStatement(sql);
}
sql.Append(" ORDER BY ");
if (sort != null && sort.IsSorted)
{
sort.WriteOrderBy(sql);
}
else
{
WriteDefaultOrderBy(sql);
}
sql.Append($" OFFSET {startIndex} ROWS FETCH NEXT {count} ROWS ONLY");
return(sql.ToString());
}
private IQueryable <TableDAO> OrFilter(IQueryable <TableDAO> query, TableFilter filter)
{
if (filter.OrFilter == null || filter.OrFilter.Count == 0)
{
return(query);
}
IQueryable <TableDAO> initQuery = query.Where(q => false);
foreach (TableFilter TableFilter in filter.OrFilter)
{
IQueryable <TableDAO> queryable = query;
if (filter.Id != null)
{
queryable = queryable.Where(q => q.Id, filter.Id);
}
if (filter.Code != null)
{
queryable = queryable.Where(q => q.Code, filter.Code);
}
if (filter.OrderId != null)
{
queryable = queryable.Where(q => q.OrderId, filter.OrderId);
}
initQuery = initQuery.Union(queryable);
}
return(initQuery);
}
public override DbDataAdapter CreateAdapter(Table table, TableFilter filter)
{
var sqlTable = table as SqlCeTable;
if (sqlTable == null)
{
throw new InvalidOperationException("Table should be an SqlCeTable");
}
var adapter = new SqlCeDataAdapter(table.GetBaseSelectCommandText(filter), this.connection);
if (!table.IsReadOnly)
{
var builder = new SqlCeCommandBuilder(adapter);
builder.ConflictOption = ConflictOption.OverwriteChanges;
try {
adapter.UpdateCommand = builder.GetUpdateCommand();
adapter.InsertCommand = builder.GetInsertCommand();
adapter.DeleteCommand = builder.GetDeleteCommand();
} catch (InvalidOperationException) {
sqlTable.SetReadOnly(true);
return(adapter);
}
}
return(adapter);
}
public WFFinsEntity GetFlowInstance(string finsId)
{
var filter = TableFilter.New().Equals("ID", finsId);
return(_DataAccess.Query(WFFinsEntity.TableCode).FixField("*")
.Where(filter).QueryFirst <WFFinsEntity>());
}
public static string[] AsStrings(this TableFilter value)
{
var lines = new List <string>();
for (int i = 0; i < value.Count(); i++)
{
var isFirstLine = (i == 0);
var isLastLine = (i == value.Count() - 1);
var tableFilterLine = value.ElementAt(i);
var line = string.Format("{0}={1}({2})", tableFilterLine.FieldName, tableFilterLine.Type.AsString(), tableFilterLine.Value);
if (isFirstLine)
{
line = string.Format("WHERE({0}", line);
}
else
{
line = string.Format(" {0}", line);
}
if (isLastLine)
{
line = string.Format("{0})", line);
}
else
{
line = string.Format("{0},", line);
}
lines.Add(line);
}
return(lines.ToArray <string>());
}
public List <WFFlowEntity> GetFlowsByServiceId(string serviceId)
{
if (string.IsNullOrWhiteSpace(serviceId))
{
throw new ArgumentException($"{nameof(serviceId)} is not null");
}
var filter = TableFilter.New().Equals("id", serviceId);
var serviceEntity = DataAccess.Query(WFServiceEntity.TableCode).FixField("*").Where(filter).QueryFirst <WFServiceEntity>();
if (serviceEntity == null)
{
throw new Exception("没有找到流程业务");
}
filter = TableFilter.New().Equals("serviceId", serviceId).Equals("istemplate", 1);
var query = DataAccess.Query(WFFlowEntity.TableCode).FixField("*").Sort("version desc").Where(filter);
var list = query.QueryList <WFFlowEntity>().ToList();
var currentFlow = list.Where(flow => flow.ID == serviceEntity.Currentflowid).FirstOrDefault();
if (currentFlow != null)
{
currentFlow.CurrentTag = 1;
}
return(list);
}
public WFTaskSettingEntity GetTaskJobInfo(WFTaskEntity taskEntity)
{
var filter = TableFilter.New().Equals("id", taskEntity.ID);
var settingEntity = DataAccess.Query(WFTaskSettingEntity.TableCode)
.FixField("*").Where(filter).QueryFirst <WFTaskSettingEntity>();
return(settingEntity);
}
public void Set(CalcFormulaMethod method, string tableName, string fieldName, bool reverseSign = false, params CalcFormulaTableFilterLine[] tableFilter)
{
Method = method;
TableName = tableName;
FieldName = fieldName;
ReverseSign = reverseSign;
TableFilter.AddRange(tableFilter);
}
public WFTinsEntity GetTinsById(string tinsId)
{
var filter = TableFilter.New().Equals("id", tinsId);
var tinsEntity = DataAccess.Query(WFTinsEntity.TableCode)
.FixField("*").Where(filter).QueryFirst <WFTinsEntity>();
return(tinsEntity);
}
/// <summary>
/// 从数据库或者缓存中获取流程服务的接入url信息
/// </summary>
/// <param name="serviceId"></param>
/// <returns></returns>
private string GetAppAccessUrl(string serviceId)
{
var filter = TableFilter.New().Equals("id", serviceId);
var serviceEntity = _dataAccess.Query(WFServiceEntity.TableCode).FixField("id,wfappid").Where(filter).QueryFirst <WFServiceEntity>();
filter = TableFilter.New().Equals("id", serviceEntity.WfappId);
return(_dataAccess.Query("wfapp").FixField("url").Where(filter).QueryScalar().ConvertTostring());
}
public WFTaskEntity GetStartTask(string flowId)
{
var filter = TableFilter.New().Equals("flowid", flowId).Equals("type", 1);
var taskEntity = DataAccess.Query(WFTaskEntity.TableCode)
.FixField("*").Where(filter).QueryFirst <WFTaskEntity>();
return(taskEntity);
}
public bool IsMultipleNextTask(WFTaskEntity preTask)
{
var filter = TableFilter.New().Equals("BEGINTASKID", preTask.ID);
var links = DataAccess.Query(WFLinkEntity.TableCode)
.FixField("*").Where(filter).QueryList <WFLinkEntity>().ToList();
return(links.Count > 1);
}
public IEnumerable <WFTinsEntity> GetTinssById(string finsId, string[] taskIds)
{
var filter = TableFilter.New().Equals("FINSID", finsId).In("taskid", string.Join(',', taskIds));
var tinsEntitys = DataAccess.Query(WFTinsEntity.TableCode)
.FixField("*").Where(filter).QueryList <WFTinsEntity>();
return(tinsEntitys);
}
public FilterDialog(TableFilter filter)
{
InitializeComponent();
this.filter = filter;
columnFilterBindingSource.DataSource = this.filter.ColumnFilters;
FormExtensions.TrySetSize(this, Settings.Default.FilterDialogSize);
}
protected virtual DataTable GetDataSecuencial(int startIndex, int count, TableFilter filter, TableSort sort)
{
var sql = new StringBuilder();
sql.Append("SELECT ");
filter.WriteColumnsProjection(sql);
sql.Append(" FROM ");
sql.Append(QuotedName);
if (filter != null && filter.IsRowFiltered)
{
sql.Append(" WHERE ");
filter.WriteWhereStatement(sql);
}
if (sort != null && sort.IsSorted)
{
sql.Append(" ORDER BY ");
sort.WriteOrderBy(sql);
}
using (var select = Connection.CreateCommand()) {
select.CommandText = sql.ToString();
using (Database.CreateConnectionScope()) {
using (var reader = select.ExecuteReader(CommandBehavior.SequentialAccess)) {
var data = new DataTable(Name);
data.BeginLoadData();
for (var i = 0; i < reader.FieldCount; i++)
{
data.Columns.Add(new DataColumn(reader.GetName(i), reader.GetFieldType(i)));
}
while (startIndex > 0 && reader.Read())
{
startIndex--;
}
if (reader.Read())
{
do
{
var row = data.NewRow();
for (var i = 0; i < reader.FieldCount; i++)
{
row[i] = reader[i];
}
data.Rows.Add(row);
count--;
} while (reader.Read() && count > 0);
}
data.EndLoadData();
data.AcceptChanges();
return(data);
}
}
}
}
public DBCollection <WFTEventEntity> GetList(TableFilter tf)
{
var col = this._DataAccess.Query(WFTEventEntity.TableCode)
.FixField("*")
.Where(tf)
.Query <WFTEventEntity>();
return(col);
}
public WFTEventEntity GetById(string id)
{
var col = this._DataAccess.Query(WFTEventEntity.TableCode)
.FixField("*")
.Where(TableFilter.New().Equals("ID", id))
.Query <WFTEventEntity>();
return(col.Data.FirstOrDefault());
}
public DBCollection <WFTDataEntity> GetByFlowIdAndTaskId(TableFilter tf)
{
var col = this._da.Query(WFTDataEntity.TableCode)
.FixField("*")
.Where(tf)
.Query <WFTDataEntity>();
return(col);
}
private WFServiceEntity InitData(string key)
{
var col = this._da.Query(WFServiceEntity.TableCode)
.FixField("*")
.Where(TableFilter.New().Equals("ID", key))
.Query <WFServiceEntity>();
return(col.Data.FirstOrDefault());
}
public DBCollection <WFFinsEntity> GetRuningData(WFMonitorSearchModel searchModel)
{
TableFilter filter = TableFilter.New();
BuildFilter(filter, searchModel);
var coll = GetRuningData(searchModel, filter);
return(coll);
}
public void TestMethod()
{
var col = this._da.Query(WFTinsEntity.TableCode)
.FixField("*")
.Where(TableFilter.New().Equals("ID", "00001Q1FJ6JYK0000A03"))
.Query <WFTinsEntity>();
Console.WriteLine(this.Json.Serialize(col.Data.FirstOrDefault().Edate));
}
public List <WFTinsEntity> GetTinsList(string finsId)
{
var col = this.DataAccess.Query(WFTinsEntity.TableCode)
.FixField("*")
.Where(TableFilter.New().Equals("FINSID", finsId))
.Query <WFTinsEntity>();
return(col.Data.ToList());
}
