protected WfActivityBase(SerializationInfo info, StreamingContext context)
{
this._ID = info.GetString("ID");
if (WorkflowSettings.GetConfig().IsSerializeDesc)
{
this._Descriptor = (IWfActivityDescriptor)info.GetValue("Descriptor", typeof(IWfActivityDescriptor));
}
this._ProcessDescKey = info.GetString("ProcessDescKey");
this._ActivityDescKey = info.GetString("ActivityDescKey");
this._FromTransition = (IWfTransition)info.GetValue("FromTransition", typeof(IWfTransition));
this._ToTransition = (IWfTransition)info.GetValue("ToTransition", typeof(IWfTransition));
this._Context = (WfActivityContext)info.GetValue("Context", typeof(WfActivityContext));
this._Status = (WfActivityStatus)info.GetValue("Status", typeof(WfActivityStatus));
this._Process = (IWfProcess)info.GetValue("Process", typeof(IWfProcess));
this._IsAborted = info.GetBoolean("IsAborted");
this._StartTime = info.GetDateTime("StartTime");
this._EndTime = info.GetDateTime("EndTime");
this._Assignees = (WfAssigneeCollection)info.GetValue("Assignees", typeof(WfAssigneeCollection));
this._Operator = (IUser)info.GetValue("Operator", typeof(IUser));
this._LoadingType = (DataLoadingType)info.GetValue("LoadingType", typeof(DataLoadingType));
}
/// <summary>
///
/// </summary>
/// <param name="processType"></param>
/// <param name="startupParams"></param>
/// <returns></returns>
public static IWfProcess StartWorkflow(System.Type processType, WfProcessStartupParams startupParams)
{
ExceptionHelper.FalseThrow <ArgumentNullException>(processType != null, "processType");
ExceptionHelper.FalseThrow <ArgumentNullException>(startupParams != null, "startupParams");
IWfProcess process = (IWfProcess)Activator.CreateInstance(processType, true);
Type[] types = new Type[] { };
ConstructorInfo constructorInfoObj = process.GetType().GetConstructor(
BindingFlags.Instance | BindingFlags.Public, null,
CallingConventions.HasThis, types, null);
if (constructorInfoObj != null)
{
process = (IWfProcess)constructorInfoObj.Invoke(new object[] { });
}
process.Creator = startupParams.Operator;
process.OwnerDepartment = startupParams.Department;
process.ResourceID = startupParams.ResourceID;
WorkflowSettings.GetConfig().EnqueueWorkItemExecutor.EnqueueInitialWfWorkItem(process);
AddProcessToCache(process.ID, process);
return(process);
}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("ID", this._ID);
if (WorkflowSettings.GetConfig().IsSerializeDesc)
{
info.AddValue("Descriptor", this._Descriptor, typeof(IWfActivityDescriptor));
}
info.AddValue("ProcessDescKey", this._ProcessDescKey);
info.AddValue("ActivityDescKey", this._ActivityDescKey);
info.AddValue("FromTransition", this._FromTransition, typeof(IWfTransition));
info.AddValue("ToTransition", this._ToTransition, typeof(IWfTransition));
info.AddValue("Context", this._Context);
info.AddValue("Status", this._Status);
info.AddValue("Process", this._Process);
info.AddValue("IsAborted", this._IsAborted);
info.AddValue("StartTime", this._StartTime);
info.AddValue("EndTime", this._EndTime);
info.AddValue("Assignees", this._Assignees);
info.AddValue("Operator", this._Operator);
info.AddValue("LoadingType", _LoadingType);
}
public void Withdraw(IWfActivity destinationActivity)
{
ExceptionHelper.FalseThrow <ArgumentNullException>(destinationActivity != null, "destinationActivity");
lock (this)
{
ExceptionHelper.FalseThrow <WfEngineException>(this.Activities.ContainsKey(destinationActivity.ID),
Resource.InvalidWithdrawActivityID, destinationActivity.ID);
if (this.CurrentActivity != destinationActivity &&
string.Compare(this.CurrentActivity.ID, destinationActivity.ID, true) != 0)
{
WfActivityCollection deletedActivities = DoWithdraw(destinationActivity);
WfProcessCollection deletedProcesses = GetDeletedProcesses(deletedActivities);
((WfActivityBase)destinationActivity).Status = WfActivityStatus.Running;
this.Status = WfProcessStatus.Running;
WorkflowSettings.GetConfig().EnqueueWorkItemExecutor.EnqueueWithdrawWorkItem(
destinationActivity,
deletedActivities,
deletedProcesses);
}
}
}
private void saveWfProcess(IWfProcessDescriptor wfProcess)
{
try
{
using (TransactionScope scope = TransactionScopeFactory.Create())
{
var pManager = WorkflowSettings.GetConfig().GetDescriptorManager();
pManager.SaveDescriptor(wfProcess);
//change import time
WfProcessDescriptorInfoAdapter.Instance.UpdateImportTime(wfProcess.Key, DeluxeIdentity.CurrentUser);
//write log
UserOperationLog log = new UserOperationLog()
{
ResourceID = wfProcess.Key,
Operator = DeluxeIdentity.CurrentUser,
OperationDateTime = DateTime.Now,
Subject = "导入流程模板",
OperationName = "导入",
OperationDescription = "导入流程模板"
};
UserOperationLogAdapter.Instance.Update(log);
scope.Complete();
}
}
catch (Exception ex)
{
throw ex;
}
}
public InvokeWebServiceJob LoadSingleData(IConnectiveSqlClause whereClause)
{
InvokeWebServiceJob result = null;
if (whereClause.IsEmpty == false)
{
using (DbContext dbi = DbHelper.GetDBContext(GetConnectionName()))
{
using (IDataReader dr = DbHelper.RunSqlReturnDR(string.Format(SingleData_InvokeWebService,
whereClause.ToSqlString(TSqlBuilder.Instance)), GetConnectionName()))
{
while (dr.Read())
{
result = new InvokeWebServiceJob();
ORMapping.DataReaderToObject(dr, result);
break;
}
}
if (result != null)
{
XElementFormatter formatter = new XElementFormatter();
formatter.OutputShortType = WorkflowSettings.GetConfig().OutputShortType;
XElement root = XElement.Parse(result.XmlData);
result.SvcOperationDefs = (WfServiceOperationDefinitionCollection)formatter.Deserialize(root);
result.InitJobBaseData(JobBaseAdapter.Instance.LoadSingleDataByJobID(whereClause));
}
}
}
return(result);
}
private WfBranchProcessInfoCollection LoadBranches()
{
WfBranchProcessInfoCollection resultCollection = new WfBranchProcessInfoCollection();
IWorkflowReader persistProcess = WorkflowSettings.GetConfig().Reader;
List <string> branchProcessIDs = persistProcess.GetBranchProcessIDsByOperationID(this.ID);
WfProcessCollection processes = WfRuntime.GetWfProcesses(branchProcessIDs.ToArray());
IWfProcess[] processesArray = new IWfProcess[processes.Count];
int i = 0;
foreach (IWfProcess process in processes)
{
((WfBranchProcessInfo)process.EntryInfo).OwnerOperation = this;
processesArray[i++] = process;
}
//按照子流程的序号排序
Array.Sort <IWfProcess>(processesArray,
delegate(IWfProcess process1, IWfProcess process2)
{
return(Math.Sign(process1.EntryInfo.Sequence - process2.EntryInfo.Sequence));
});
foreach (IWfProcess process in processesArray)
{
resultCollection.Add(process.EntryInfo);
}
return(resultCollection);
}
public static string[] QueryGuidsByCondition(IConnectiveSqlClause condition)
{
QueryCondition qc = new QueryCondition();
qc.FromClause = "WF.PROCESS_INSTANCES (NOLOCK)";
qc.SelectFields = "INSTANCE_ID";
qc.OrderByClause = "CREATE_TIME DESC";
qc.WhereClause = condition.ToSqlString(TSqlBuilder.Instance);
string sql = string.Format("SELECT {0} FROM {1} WHERE 1 = 1 {2} {3} ORDER BY {4}",
qc.SelectFields,
qc.FromClause,
qc.WhereClause.IsNotEmpty() ? " AND " + qc.WhereClause : string.Empty,
qc.GroupBy.IsNotEmpty() ? "GROUP BY " + qc.GroupBy : string.Empty,
qc.OrderByClause);
using (DbContext context = DbContext.GetContext(WorkflowSettings.GetConfig().ConnectionName))
{
Database db = DatabaseFactory.Create(context);
using (var dr = db.ExecuteReader(CommandType.Text, sql))
{
List <string> guids = new List <string>();
while (dr.Read())
{
guids.Add(dr.GetString(0));
}
return(guids.ToArray());
}
}
}
public static int GetResourceUserTasksAccomplished(string resourceId, string userId)
{
string sql = string.Format("select COUNT(*) from WF.USER_ACCOMPLISHED_TASK where RESOURCE_ID='{0}' and SEND_TO_USER='******'", resourceId, userId);
int i = (int)DbHelper.RunSqlReturnScalar(sql, WorkflowSettings.GetConfig().ConnectionName);
return(i);
}
public virtual void RemoveOperations(params IWfOperation[] operations)
{
WorkflowSettings.GetConfig().EnqueueWorkItemExecutor.EnqueueRemoveOperationsWorkItem(operations);
for (int i = 0; i < operations.Length; i++)
{
Operations.Remove(operations[i]);
}
}
public static WfProcessCollection GetWfProcessesByResourceID(string resourceID)
{
ExceptionHelper.TrueThrow <ArgumentNullException>(resourceID == null, "resourceID");
IWorkflowReader persistProcess = WorkflowSettings.GetConfig().Reader;
IList <string> processIDs = persistProcess.GetProcessIDsByResourceID(resourceID);
return(GetProcessesFromIDs(processIDs));
}
protected override void BeforeInnerUpdate(InvokeWebServiceJob data, Dictionary <string, object> context)
{
base.BeforeInnerUpdate(data, context);
XElementFormatter formatter = new XElementFormatter();
formatter.OutputShortType = WorkflowSettings.GetConfig().OutputShortType;
data.XmlData = formatter.Serialize(data.SvcOperationDefs).ToString();
}
/// <summary>
///
/// </summary>
public virtual IWfOperation AddNewOperation(WfBranchesTransferParams transferParams)
{
IWfOperation newOperation = this.Process.Factory.CreateOperation(this, transferParams);
this.Operations.Add(newOperation);
WorkflowSettings.GetConfig().EnqueueWorkItemExecutor.EnqueueAddNewOperationWorkItem(newOperation);
return(newOperation);
}
public static WfProcessCollection GetUserRelativeProcessesByResourceID(string resourceID, IUser user)
{
ExceptionHelper.CheckStringIsNullOrEmpty(resourceID, "resourceID");
ExceptionHelper.TrueThrow <ArgumentNullException>(user == null, "user");
IWorkflowReader persistProcess = WorkflowSettings.GetConfig().Reader;
List <string> processIDs = persistProcess.GetUserRelativeProcessIDsByResourceID(resourceID, user);
return(GetWfProcesses(processIDs.ToArray()));
}
protected override string GetConnectionName()
{
string connectionName = MaterialContentSettings.GetConfig().ConnectionName;
if (connectionName.IsNullOrEmpty())
{
connectionName = WorkflowSettings.GetConfig().ConnectionName;
}
return(connectionName);
}
private static string GetConnectionName()
{
string result = EmailMessageSettings.GetConfig().ConnectionName;
if (result.IsNullOrEmpty())
{
result = WorkflowSettings.GetConfig().ConnectionName;
}
return(result);
}
public static void ClearProcessCache()
{
if (WorkflowSettings.GetConfig().UseGlobalCache)
{
WfProcessCache.Instance.Clear();
}
else
{
WfProcessContextCache.Instance.Clear();
}
}
private static void AddProcessToCache(string processID, IWfProcess process)
{
if (WorkflowSettings.GetConfig().UseGlobalCache)
{
SlidingTimeDependency dependency = new SlidingTimeDependency(WorkflowSettings.GetConfig().GlobalCacheTimeOut);
WfProcessCache.Instance.Add(processID, process, dependency);
}
else
{
WfProcessContextCache.Instance.Add(processID, process);
}
}
private void InitInstanceDescription(string processID)
{
IWfProcess process = WorkflowSettings.GetConfig().GetPersistManager().LoadProcessByProcessID(processID);
if (process != null)
{
instanceDescription.Value = JSONSerializerExecute.Serialize(new List <IWfProcessDescriptor>()
{
process.Descriptor
});
this.processID.Value = processID;
}
}
private static void FillProcessesFromPersistence(WfProcessCollection processes, List <string> notInCacheIDs)
{
if (notInCacheIDs.Count > 0)
{
IWorkflowReader persistProcess = WorkflowSettings.GetConfig().Reader;
WfProcessCollection tempCollection = persistProcess.LoadProcesses(notInCacheIDs.ToArray());
foreach (IWfProcess tempProcess in tempCollection)
{
processes.Add(tempProcess);
AddProcessToCache(tempProcess.ID, tempProcess);
}
}
}
public void ProcessRequest(HttpContext context)
{
string json = context.Request["info"];
string processID = context.Request["processID"];
context.Response.ContentType = "text/plain";
WfConverterHelper.RegisterConverters();
List <WfProcessDescriptor> deserializedProcessDesp;
IWfProcess process = null;
if (!string.IsNullOrEmpty(processID))
{
process = WorkflowSettings.GetConfig().GetPersistManager().LoadProcessByProcessID(processID);
}
try
{
deserializedProcessDesp = JSONSerializerExecute.Deserialize <List <WfProcessDescriptor> >(json);
}
catch (Exception ex)
{
context.Response.Write("反序列化错误:" + ex.Message + ex.StackTrace);
return;
}
try
{
foreach (var descriptor in deserializedProcessDesp)
{
if (process != null && descriptor.Key == process.Descriptor.Key)
{
process.Descriptor = descriptor;
WorkflowSettings.GetConfig().GetPersistManager().SaveProcess(process);
}
else
{
WfSaveTemplateExecutor executor = new WfSaveTemplateExecutor(descriptor);
executor.Execute();
}
}
}
catch (Exception ex)
{
context.Response.Write("保存错误:" + ex.Message + ex.StackTrace);
return;
}
context.Response.Write("保存成功!");
}
private static bool TryGetProcessFromCache(string processID, out IWfProcess process)
{
bool result = false;
if (WorkflowSettings.GetConfig().UseGlobalCache)
{
result = WfProcessCache.Instance.TryGetValue(processID, out process);
}
else
{
result = WfProcessContextCache.Instance.TryGetValue(processID, out process);
}
return(result);
}
public void CancelProcess()
{
lock (this)
{
ExceptionHelper.TrueThrow(Status == WfProcessStatus.Aborted, Resource.CanNotCacelProcess);
Status = WfProcessStatus.Aborted;
if (this.CurrentActivity != null)
{
((WfActivityBase)this.CurrentActivity).Status = WfActivityStatus.Aborted;
}
WorkflowSettings.GetConfig().EnqueueWorkItemExecutor.EnqueueCancelProcessWorkItem(this);
}
}
public static IWfActivity GetWfActivity(string activityID)
{
ExceptionHelper.CheckStringIsNullOrEmpty(activityID, "activityID");
IWorkflowReader persistProcess = WorkflowSettings.GetConfig().Reader;
string processID = persistProcess.GetProcessIDByActivityID(activityID);
if (string.IsNullOrEmpty(processID))
{
throw new WfRuntimeException(WfRuntimeErrorType.ActivityError,
string.Format("不能根据activityID:{0}恢复流程数据", activityID));
}
IWfProcess wfProcess = GetWfProcesses(processID)[processID];
return(wfProcess.Activities[activityID]);
}
private WfBranchProcessInfoContext LoadContext()
{
WfBranchProcessInfoContext branchContext = null;
IWorkflowReader persistProcess = WorkflowSettings.GetConfig().Reader;
string strContext = persistProcess.GetBranchContext(this.OperationID, this.Process.ID);
if (string.IsNullOrEmpty(strContext) == false)
{
branchContext = SerializationHelper.DeserializeStringToObject <WfBranchProcessInfoContext>(strContext, SerializationFormatterType.Binary);
}
else
{
branchContext = new WfBranchProcessInfoContext();
}
return(branchContext);
}
public void Update(CommonInfoMappingCollection cimItems)
{
cimItems.NullCheck("cimItems");
string sqlString = string.Empty;
StringBuilder strB = new StringBuilder();
ConnectiveSqlClauseCollection connective = new ConnectiveSqlClauseCollection(LogicOperatorDefine.Or);
foreach (CommonInfoMapping cim in cimItems)
{
if (cim.ResourceID.IsNotEmpty() && cim.ProcessID.IsNotEmpty())
{
if (strB.Length > 0)
{
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
}
WhereSqlClauseBuilder wBuilder = new WhereSqlClauseBuilder();
wBuilder.AppendItem("RESOURCE_ID", cim.ResourceID);
wBuilder.AppendItem("PROCESS_ID", cim.ProcessID);
wBuilder.AppendTenantCode(typeof(CommonInfoMapping));
connective.Add(wBuilder);
strB.Append(TSqlBuilder.Instance.DBStatementSeperator);
strB.Append(ORMapping.GetInsertSql(cim, TSqlBuilder.Instance));
}
}
if (connective.Count > 0)
{
sqlString = string.Format("DELETE WF.COMMON_INFO_MAPPING WHERE {0}", connective.ToSqlString(TSqlBuilder.Instance));
sqlString += strB.ToString();
}
if (sqlString.Length > 0)
{
DbHelper.RunSqlWithTransaction(sqlString, WorkflowSettings.GetConfig().ConnectionName);
}
}
public void AdjustBranches(WfAdjustBranchesParams adjustParams)
{
lock (this)
{
WfBranchProcessInfoCollection deletedBranchProcesses;
AddBranchProcess(adjustParams.User, adjustParams.AddedBranchesParamsCollection);
deletedBranchProcesses = DeleteBranchProcesses(adjustParams.DeletedBranchIDs);
UpdateBranchesSort(adjustParams.SortBranchParamsList);
FinalInitBranches();
this.OpState = State.Modified;
WorkflowSettings.GetConfig().EnqueueWorkItemExecutor.EnqueueAdjustBranchesWorkItem(this, deletedBranchProcesses);
}
}
/// <summary>
///
/// </summary>
/// <param name="transferParams"></param>
/// <returns></returns>
public IWfActivity MoveTo(WfTransferParamsBase transferParams)
{
lock (this)
{
IWfActivity activity = InnerMoveTo(transferParams);
if (this.CurrentActivity.FromTransition == null)
{
WorkflowSettings.GetConfig().EnqueueWorkItemExecutor.EnqueueMoveToWorkItem(
null, this.CurrentActivity);
}
else
{
WorkflowSettings.GetConfig().EnqueueWorkItemExecutor.EnqueueMoveToWorkItem(
this.CurrentActivity.FromTransition.FromActivity, this.CurrentActivity);
}
return(activity);
}
}
private WfOperationContext LoadContext()
{
WfOperationContext operationContext = null;
IWorkflowReader persistProcess = WorkflowSettings.GetConfig().Reader;
Dictionary <string, string> context = persistProcess.GetWfContext(this.ID);
string strContext = string.Empty;
if (context.TryGetValue(this.ID, out strContext))
{
operationContext = SerializationHelper.DeserializeStringToObject <WfOperationContext>(strContext, SerializationFormatterType.Binary);
}
else
{
operationContext = new WfOperationContext();
}
return(operationContext);
}
protected override void AfterLoad(InvokeWebServiceJobCollection data)
{
base.AfterLoad(data);
XElementFormatter formatter = new XElementFormatter();
formatter.OutputShortType = WorkflowSettings.GetConfig().OutputShortType;
foreach (var job in data)
{
XElement root = XElement.Parse(job.XmlData);
job.SvcOperationDefs = (WfServiceOperationDefinitionCollection)formatter.Deserialize(root);
var baseColl = JobBaseAdapter.Instance.Load(p => p.AppendItem("JOB_ID", job.JobID));
if (baseColl.Count == 0)
{
return;
}
job.InitJobBaseData(baseColl[0]);
}
}