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]); } }