Пример #1
0
        public override IDictionary <string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            WfActivityDescriptor actDesp = (WfActivityDescriptor)obj;

            IDictionary <string, object> dictionary = base.Serialize(obj, serializer);

            DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "AllowEmptyCandidates", actDesp.Properties.GetValue("AllowEmptyCandidates", false));
            DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "AllowInvalidCandidates", actDesp.Properties.GetValue("AllowInvalidCandidates", false));

            DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "ActivityType", actDesp.ActivityType);
            DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "CodeName", actDesp.CodeName);
            DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "Url", actDesp.Url);

            dictionary.Add("Variables", actDesp.Variables);
            dictionary.Add("Condition", actDesp.Condition);
            dictionary.Add("BranchProcessTemplates", actDesp.BranchProcessTemplates);
            dictionary.Add("Resources", actDesp.Resources);
            dictionary.Add("RelativeLinks", actDesp.RelativeLinks);
            dictionary.Add("EnterEventReceivers", actDesp.EnterEventReceivers);
            dictionary.Add("LeaveEventReceivers", actDesp.LeaveEventReceivers);
            dictionary.Add("InternalRelativeUsers", actDesp.InternalRelativeUsers);
            dictionary.Add("ExternalUsers", actDesp.ExternalUsers);

            dictionary.Add("EnterEventExecuteServices", actDesp.EnterEventExecuteServices);
            dictionary.Add("LeaveEventExecuteServices", actDesp.LeaveEventExecuteServices);

            dictionary.Add("WithdrawExecuteServices", actDesp.WithdrawExecuteServices);
            dictionary.Add("BeWithdrawnExecuteServices", actDesp.BeWithdrawnExecuteServices);

            return(dictionary);
        }
Пример #2
0
        private IWfActivityDescriptor AddMainStreamActivity()
        {
            WfActivityDescriptor newMSActDesp = null;

            if (this._NewActivityDescriptor.IsMainStreamActivity == false)
            {
                newMSActDesp = new WfActivityDescriptor(this.Process.MainStream.FindNotUsedActivityKey(),
                                                        WfActivityType.NormalActivity);

                string originalKey = newMSActDesp.Key;

                ((WfActivityDescriptor)this._NewActivityDescriptor).CloneProperties(newMSActDesp);
                newMSActDesp.Key = originalKey;

                ((WfActivityBase)(this._NewActivityDescriptor.Instance)).MainStreamActivityKey = newMSActDesp.Key;

                IWfActivityDescriptor fromActDesp   = this._FromActivityDescriptor;
                IWfActivityDescriptor msFromActDesp = null;

                if (fromActDesp != null)
                {
                    msFromActDesp = fromActDesp.Instance.GetMainStreamActivityDescriptor();
                }

                this.Process.MainStream.Activities.Add(newMSActDesp);

                if (msFromActDesp != null)
                {
                    msFromActDesp.ToTransitions.AddForwardTransition(newMSActDesp);
                }
            }

            return(newMSActDesp);
        }
		private void descriptorEditor_SaveButtonClicked(object sender, EventArgs e)
		{
			if (this.descriptorEditor.CurrentProcess != null)
			{
				WfActivityDescriptor activityTemplate = new WfActivityDescriptor(
					this.descriptorEditor.CurrentProcessDescriptor.FindNotUsedActivityKey(),
					WfActivityType.NormalActivity);

				activityTemplate.Properties.ReplaceExistedPropertyValues(this.propertyGrid.Properties);

				this.descriptorEditor.CurrentProcessDescriptor.Activities.Add(activityTemplate);

				if (this.descriptorEditor.CurrentProcessDescriptor.IsMainStream == false)
					WfActivityBase.CreateActivityInstance(activityTemplate, this.descriptorEditor.CurrentProcess);

				WfAdminAddActivityExecutor executor = new WfAdminAddActivityExecutor(
					this.descriptorEditor.CurrentProcess.CurrentActivity,
					this.descriptorEditor.CurrentProcess,
					this.FromActivity,
					activityTemplate,
					this.syncMSObj.Checked);

				executor.Execute();
			}
		}
		private IWfActivityDescriptor AddMainStreamActivity()
		{
			WfActivityDescriptor newMSActDesp = null;

			if (this._NewActivityDescriptor.IsMainStreamActivity == false)
			{
				newMSActDesp = new WfActivityDescriptor(this.Process.MainStream.FindNotUsedActivityKey(),
					WfActivityType.NormalActivity);

				string originalKey = newMSActDesp.Key;

				((WfActivityDescriptor)this._NewActivityDescriptor).CloneProperties(newMSActDesp);
				newMSActDesp.Key = originalKey;

				((WfActivityBase)(this._NewActivityDescriptor.Instance)).MainStreamActivityKey = newMSActDesp.Key;

				IWfActivityDescriptor fromActDesp = this._FromActivityDescriptor;
				IWfActivityDescriptor msFromActDesp = null;

				if (fromActDesp != null)
					msFromActDesp = fromActDesp.Instance.GetMainStreamActivityDescriptor();

				this.Process.MainStream.Activities.Add(newMSActDesp);

				if (msFromActDesp != null)
					msFromActDesp.ToTransitions.AddForwardTransition(newMSActDesp);
			}

			return newMSActDesp;
		}
        public override IDictionary <string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            WfActivityDescriptor actDesp = (WfActivityDescriptor)obj;

            IDictionary <string, object> dictionary = base.Serialize(obj, serializer);

            DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "ActivityType", actDesp.ActivityType);
            DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "CodeName", actDesp.CodeName);
            DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "Url", actDesp.Url);

            SetPropertiesValue(actDesp, "Variables", actDesp.Variables);
            SetPropertiesValue(actDesp, "Condition", actDesp.Condition);
            SetPropertiesValue(actDesp, "Resources", actDesp.Resources);
            SetPropertiesValue(actDesp, "RelativeLinks", actDesp.RelativeLinks);
            SetPropertiesValue(actDesp, "BranchProcessTemplates", actDesp.BranchProcessTemplates);
            SetPropertiesValue(actDesp, "EnterEventReceivers", actDesp.EnterEventReceivers);
            SetPropertiesValue(actDesp, "LeaveEventReceivers", actDesp.LeaveEventReceivers);

            SetPropertiesValue(actDesp, "EnterEventExecuteServices", actDesp.EnterEventExecuteServices);
            SetPropertiesValue(actDesp, "LeaveEventExecuteServices", actDesp.LeaveEventExecuteServices);

            SetPropertiesValue(actDesp, "WithdrawExecuteServices", actDesp.WithdrawExecuteServices);
            SetPropertiesValue(actDesp, "BeWithdrawnExecuteServices", actDesp.BeWithdrawnExecuteServices);

            SetPropertiesValue(actDesp, "InternalRelativeUsers", actDesp.InternalRelativeUsers);
            SetPropertiesValue(actDesp, "ExternalUsers", actDesp.ExternalUsers);
            SetPropertiesValue(actDesp, "ParametersNeedToBeCollected", actDesp.ParametersNeedToBeCollected);

            return(dictionary);
        }
        private static void ResetPropertiesByDefinedName(WfActivityDescriptor actDesp, string definedName)
        {
            PropertyDefineCollection definedProperties = new PropertyDefineCollection();

            definedProperties.LoadPropertiesFromConfiguration(WfActivitySettings.GetConfig().PropertyGroups[definedName]);

            actDesp.Properties.ReplaceDefinedProperties(definedProperties);
        }
Пример #7
0
        public static IWfActivityDescriptor CreateNormalActivity(string key)
        {
            WfActivityDescriptor normalAct = new WfActivityDescriptor(key, WfActivityType.NormalActivity);
            normalAct.Name = key;
            normalAct.CodeName = key;

            return normalAct;
        }
 private void SetPropertiesValue(WfActivityDescriptor actDesp, string propertyName, object input)
 {
     if (actDesp.Properties.ContainsKey(propertyName))
     {
         string itemvalue = JSONSerializerExecute.Serialize(input);
         actDesp.Properties.SetValue <string>(propertyName, itemvalue);
     }
 }
Пример #9
0
        /// <summary>
        /// 生成空正常节点定义的JSON串
        /// </summary>
        /// <returns></returns>
        public static string GetEmptyNormalActivityDescriptorJsonString()
        {
            RegisterConverters();

            WfActivityDescriptor activityDesp = new WfActivityDescriptor(string.Empty);

            return(JSONSerializerExecute.Serialize(activityDesp));
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="newActDesp"></param>
        /// <param name="createParams"></param>
        private static void AdjustActivityDescriptorProperties(WfActivityDescriptor newActDesp, WfActivityDescriptorCreateParams createParams)
        {
            newActDesp.Name = createParams.Name;

            if (createParams.Variables != null)
            {
                foreach (WfVariableDescriptor variable in createParams.Variables)
                {
                    if (newActDesp.Properties.ContainsKey(variable.Key) == false)
                    {
                        PropertyDefine pd = new PropertyDefine();

                        pd.Name         = variable.Key;
                        pd.DataType     = PropertyDataType.Boolean;
                        pd.DefaultValue = variable.OriginalValue;

                        newActDesp.Properties.Add(new PropertyValue(pd));
                    }

                    newActDesp.Properties.SetValue(variable.Key, variable.ActualValue);
                }
            }

            if (createParams.Users != null)
            {
                newActDesp.Resources.Clear();
                createParams.Users.ForEach(u => newActDesp.Resources.Add(new WfUserResourceDescriptor(u)));
            }

            if (createParams.CirculateUsers != null)
            {
                newActDesp.EnterEventReceivers.Clear();
                createParams.CirculateUsers.ForEach(u => newActDesp.EnterEventReceivers.Add(new WfUserResourceDescriptor(u)));
            }

            newActDesp.BranchProcessTemplates.Clear();

            if (createParams.AllAgreeWhenConsign && newActDesp.Resources.Count > 1)
            {
                newActDesp.Properties.SetValue("AutoMoveAfterPending", true);

                if (newActDesp.BranchProcessTemplates.ContainsKey(WfTemplateBuilder.AutoStartSubProcessTemplateKey))
                {
                    newActDesp.BranchProcessTemplates.Remove(t => t.Key == WfTemplateBuilder.AutoStartSubProcessTemplateKey);
                }

                WfBranchProcessTemplateDescriptor template = new WfBranchProcessTemplateDescriptor(WfTemplateBuilder.AutoStartSubProcessTemplateKey);

                template.BranchProcessKey = WfProcessDescriptorManager.DefaultConsignProcessKey;
                template.ExecuteSequence  = WfBranchProcessExecuteSequence.Parallel;
                template.BlockingType     = WfBranchProcessBlockingType.WaitAllBranchProcessesComplete;

                template.Resources.CopyFrom(newActDesp.Resources);

                newActDesp.BranchProcessTemplates.Add(template);
            }
        }
        public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            #region "base Deserialize"
            string key = DictionaryHelper.GetValue(dictionary, "Key", string.Empty);
            WfActivityDescriptor actDesp = (WfActivityDescriptor)CreateInstance(key, dictionary, type, serializer);
            actDesp.Name        = DictionaryHelper.GetValue(dictionary, "Name", string.Empty);;
            actDesp.Enabled     = DictionaryHelper.GetValue(dictionary, "Enabled", false);
            actDesp.Description = DictionaryHelper.GetValue(dictionary, "Description", string.Empty);

            Dictionary <string, object> activityProperties = new Dictionary <string, object>();

            Dictionary <string, Type> constKey = new Dictionary <string, Type>();
            constKey.Add("Variables", typeof(WfVariableDescriptorCollection));
            constKey.Add("Condition", typeof(WfConditionDescriptor));
            constKey.Add("BranchProcessTemplates", typeof(WfBranchProcessTemplateCollection));
            constKey.Add("Resources", typeof(WfResourceDescriptorCollection));
            constKey.Add("RelativeLinks", typeof(WfRelativeLinkDescriptorCollection));
            constKey.Add("EnterEventReceivers", typeof(WfResourceDescriptorCollection));
            constKey.Add("LeaveEventReceivers", typeof(WfResourceDescriptorCollection));
            constKey.Add("InternalRelativeUsers", typeof(WfResourceDescriptorCollection));
            constKey.Add("ExternalUsers", typeof(WfExternalUserCollection));

            constKey.Add("EnterEventExecuteServices", typeof(WfServiceOperationDefinitionCollection));
            constKey.Add("LeaveEventExecuteServices", typeof(WfServiceOperationDefinitionCollection));

            constKey.Add("WithdrawExecuteServices", typeof(WfServiceOperationDefinitionCollection));
            constKey.Add("BeWithdrawnExecuteServices", typeof(WfServiceOperationDefinitionCollection));

            constKey.Add("ParametersNeedToBeCollected", typeof(WfParameterNeedToBeCollected));

            if (dictionary.ContainsKey("Properties"))
            {
                PropertyValueCollection properties = JSONSerializerExecute.Deserialize <PropertyValueCollection>(dictionary["Properties"]);
                properties.Remove(p => string.Compare(p.Definition.Name, "ImportWfMatrix") == 0);
                //properties.Remove(p => string.Compare(p.Definition.Name, "BranchProcessTemplates") == 0);
                actDesp.Properties.Clear();
                foreach (PropertyValue pv in properties)
                {
                    if (constKey.ContainsKey(pv.Definition.Name))
                    {
                        var objValue = JSONSerializerExecute.DeserializeObject(pv.StringValue, constKey[pv.Definition.Name]);
                        activityProperties.Add(pv.Definition.Name, objValue);
                    }
                    else
                    {
                        actDesp.Properties.Add(pv);
                    }
                }
            }
            #endregion
            actDesp.ActivityType = DictionaryHelper.GetValue(dictionary, "ActivityType", WfActivityType.NormalActivity);

            ClearAllProperties(actDesp);
            SetActivityProperties(actDesp, activityProperties, dictionary);

            return(actDesp);
        }
        /// <summary>
        /// 准备专用退件流程,B有BC和BE两条出线,IsCLine为True走BC,否则走BE
        /// </summary>
        /// <returns></returns>
        public static IWfProcessDescriptor PrepareSpecialReturnProcessDesp()
        {
            WfProcessDescriptor processDesp = new WfProcessDescriptor();

            processDesp.Key = "TestProcess" + UuidHelper.NewUuidString().Substring(0, 8);
            processDesp.Name = "专用退回流程";
            processDesp.ApplicationName = "TEST_APP_NAME";
            processDesp.ProgramName = "TEST_PROGRAM_NAME";
            processDesp.Url = "/MCS_Framework/WebTestProject/defaultHandler.aspx";

            WfActivityDescriptor initActivity = new WfActivityDescriptor("A", WfActivityType.InitialActivity);
            initActivity.Name = "A";
            initActivity.CodeName = "A";
            initActivity.Resources.Add(new WfUserResourceDescriptor((IUser)OguObjectSettings.GetConfig().Objects["requestor"].Object));

            processDesp.Activities.Add(initActivity);

            IWfActivityDescriptor activityB = CreateNormalDescriptor("B", "B");

            activityB.Resources.Add(new WfUserResourceDescriptor((IUser)OguObjectSettings.GetConfig().Objects["approver1"].Object));
            processDesp.Activities.Add(activityB);

            IWfActivityDescriptor activityC = CreateNormalDescriptor("C", "C");
            processDesp.Activities.Add(activityC);

            IWfActivityDescriptor activityE = CreateNormalDescriptor("E", "E");
            processDesp.Activities.Add(activityE);

            IWfActivityDescriptor activityD = CreateNormalDescriptor("D", "D");
            processDesp.Activities.Add(activityD);

            WfActivityDescriptor completedActivity = new WfActivityDescriptor("F", WfActivityType.CompletedActivity);
            completedActivity.Name = "F";
            completedActivity.CodeName = "F";

            processDesp.Activities.Add(completedActivity);

            //A到B
            initActivity.ToTransitions.AddForwardTransition(activityB);

            //B有两根出线,分别是C和E
            WfTransitionDescriptor transitionBC = (WfTransitionDescriptor)activityB.ToTransitions.AddForwardTransition(activityC);
            transitionBC.Condition = new WfConditionDescriptor(transitionBC) { Expression = "IsCLine" };

            WfTransitionDescriptor transitionBE = (WfTransitionDescriptor)activityB.ToTransitions.AddForwardTransition(activityE);
            transitionBE.Condition = new WfConditionDescriptor(transitionBE) { Expression = "!IsCLine" };

            //C和E都汇聚到D
            activityC.ToTransitions.AddForwardTransition(activityD);
            activityE.ToTransitions.AddForwardTransition(activityD);

            //D到结束点
            activityD.ToTransitions.AddForwardTransition(completedActivity);

            return processDesp;
        }
        public static WfActivityDescriptor CreateSimpleServerActivity(string key, string name, WfActivityType actType)
        {
            WfActivityDescriptor actDesp = new WfActivityDescriptor(key, actType);

            actDesp.Name = name;

            actDesp.RelativeLinks.Add(new WfRelativeLinkDescriptor("AR1") { Category = "Activity", Url = "http://www.ak47.com" });

            return actDesp;
        }
Пример #14
0
        /// <summary>
        /// 生成空办结节点定义的JSON串
        /// </summary>
        /// <returns></returns>
        public static string GetEmptyCompletedActivityDescriptorJsonString()
        {
            RegisterConverters();

            WfActivityDescriptor activityDesp = new WfActivityDescriptor(string.Empty, WfActivityType.CompletedActivity);

            activityDesp.Name = "办结";

            return(JSONSerializerExecute.Serialize(activityDesp));
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="newActDesp"></param>
        /// <param name="createParams"></param>
        private static void AdjustActivityDescriptorProperties(WfActivityDescriptor newActDesp, WfActivityDescriptorCreateParams createParams)
        {
            newActDesp.Name = createParams.Name;

            if (createParams.Variables != null)
            {
                foreach (WfVariableDescriptor variable in createParams.Variables)
                {
                    if (newActDesp.Properties.ContainsKey(variable.Key) == false)
                    {
                        PropertyDefine pd = new PropertyDefine();

                        pd.Name = variable.Key;
                        pd.DataType = PropertyDataType.Boolean;
                        pd.DefaultValue = variable.OriginalValue;

                        newActDesp.Properties.Add(new PropertyValue(pd));
                    }

                    newActDesp.Properties.SetValue(variable.Key, variable.ActualValue);
                }
            }

            if (createParams.Users != null)
            {
                newActDesp.Resources.Clear();
                createParams.Users.ForEach(u => newActDesp.Resources.Add(new WfUserResourceDescriptor(u)));
            }

            if (createParams.CirculateUsers != null)
            {
                newActDesp.EnterEventReceivers.Clear();
                createParams.CirculateUsers.ForEach(u => newActDesp.EnterEventReceivers.Add(new WfUserResourceDescriptor(u)));
            }

            newActDesp.BranchProcessTemplates.Clear();

            if (createParams.AllAgreeWhenConsign && newActDesp.Resources.Count > 1)
            {
                newActDesp.Properties.SetValue("AutoMoveAfterPending", true);

				if (newActDesp.BranchProcessTemplates.ContainsKey(WfTemplateBuilder.AutoStartSubProcessTemplateKey))
					newActDesp.BranchProcessTemplates.Remove(t => t.Key == WfTemplateBuilder.AutoStartSubProcessTemplateKey);

				WfBranchProcessTemplateDescriptor template = new WfBranchProcessTemplateDescriptor(WfTemplateBuilder.AutoStartSubProcessTemplateKey);

                template.BranchProcessKey = WfProcessDescriptorManager.DefaultConsignProcessKey;
                template.ExecuteSequence = WfBranchProcessExecuteSequence.Parallel;
                template.BlockingType = WfBranchProcessBlockingType.WaitAllBranchProcessesComplete;

                template.Resources.CopyFrom(newActDesp.Resources);

                newActDesp.BranchProcessTemplates.Add(template);
            }
        }
Пример #16
0
        /// <summary>
        /// 生成空开始节点定义的JSON串
        /// </summary>
        /// <returns></returns>
        public static string GetEmptyInitialActivityDescriptorJsonString()
        {
            RegisterConverters();

            WfActivityDescriptor activityDesp = new WfActivityDescriptor(string.Empty, WfActivityType.InitialActivity);

            activityDesp.ActivityType = WfActivityType.InitialActivity;
            activityDesp.Name = "申请";

            return JSONSerializerExecute.Serialize(activityDesp);
        }
Пример #17
0
        /// <summary>
        /// 生成空开始节点定义的JSON串
        /// </summary>
        /// <returns></returns>
        public static string GetEmptyInitialActivityDescriptorJsonString()
        {
            RegisterConverters();

            WfActivityDescriptor activityDesp = new WfActivityDescriptor(string.Empty, WfActivityType.InitialActivity);

            activityDesp.ActivityType = WfActivityType.InitialActivity;
            activityDesp.Name         = "申请";

            return(JSONSerializerExecute.Serialize(activityDesp));
        }
Пример #18
0
        private WfActivityDescriptor CreateAddApproverActivityDescriptor(IWfActivityDescriptor templateActDesp)
        {
            WfActivityDescriptor addActDesp = templateActDesp.Clone() as WfActivityDescriptor;

            addActDesp.ActivityType          = WfActivityType.NormalActivity;
            addActDesp.ClonedKey             = templateActDesp.Key;
            addActDesp.AssociatedActivityKey = WfRuntime.ProcessContext.ActivityChangingContext.AssociatedActivityKey;
            addActDesp.IsReturnSkipped       = true;
            addActDesp.Properties.TrySetValue("AutoMaintain", false);

            if ((this.AddApproverMode & WfAddApproverMode.AreAssociatedActivities) == WfAddApproverMode.OnlyAddApprover)
            {
                addActDesp.Name = string.Empty;
            }

            return(addActDesp);
        }
		private void descriptorEditor_PreRenderControl(object sender, EventArgs e)
		{
			if (this.descriptorEditor.CurrentProcess != null)
			{
				WfActivityDescriptor activityTemplate = new WfActivityDescriptor(
					this.descriptorEditor.CurrentProcessDescriptor.FindNotUsedActivityKey(),
					WfActivityType.NormalActivity);

				this.ClientScript.RegisterHiddenField("template", JSONSerializerExecute.Serialize(activityTemplate));

				this.descriptorEditor.RegisterAfterProcessDeserializedFunction(
					"WFWeb.BindPropertyGrid(process.Key, Sys.Serialization.JavaScriptSerializer.deserialize($get(\"template\").value));");
			}

			if (this.descriptorEditor.ShowMainStream)
				this.syncMSObj.Disabled = true;
		}
Пример #20
0
        private static IWfActivityDescriptor CreateSecretaryActivityDescriptor(IWfActivityDescriptor templateDescriptor, IEnumerable <IUser> secretaries)
        {
            WfActivityDescriptor actDesp = new WfActivityDescriptor(templateDescriptor.Process.FindNotUsedActivityKey(), WfActivityType.NormalActivity);

            actDesp.Name = "秘书";

            ChangeActivityResources(actDesp, secretaries);

            actDesp.Variables.SetValue(WfHelper.SecretaryActivity, "True", DataType.Boolean);
            actDesp.Variables.SetValue(WfHelper.ActivityGroupName, templateDescriptor.Key);

            if (templateDescriptor.TemplateKey.IsNotEmpty())
            {
                actDesp.SetDynamicActivityProperties(templateDescriptor.TemplateKey);
            }

            return(actDesp);
        }
        private void ClearAllProperties(WfActivityDescriptor actDesp)
        {
            actDesp.Variables.Clear();
            actDesp.Resources.Clear();
            actDesp.ExternalUsers.Clear();
            actDesp.RelativeLinks.Clear();
            actDesp.EnterEventReceivers.Clear();
            actDesp.LeaveEventReceivers.Clear();
            actDesp.InternalRelativeUsers.Clear();
            actDesp.BranchProcessTemplates.Clear();
            actDesp.ParametersNeedToBeCollected.Clear();

            actDesp.EnterEventExecuteServices.Clear();
            actDesp.LeaveEventExecuteServices.Clear();

            actDesp.WithdrawExecuteServices.Clear();
            actDesp.BeWithdrawnExecuteServices.Clear();
        }
        /// <summary>
        /// 创建动态活动
        /// </summary>
        /// <param name="createActivitiesParamsFetcher"></param>
        /// <returns></returns>
        private IList <IWfActivityDescriptor> InternalGenerateDynamicActivities(Func <WfCreateActivityParamCollection> createActivitiesParamsFetcher)
        {
            createActivitiesParamsFetcher.NullCheck("createActivitiesParamsFetcher");

            List <IWfActivityDescriptor> result = null;

            //随便找一条进线和活动,构造动态活动的起始点。
            IWfTransitionDescriptor firstTemplateTransition = this.FromTransitions.FirstOrDefault();

            if (firstTemplateTransition != null)
            {
                //寻找动态活动的前一个点,如果有多个点,随机选取一个
                WfActivityDescriptor startActDesp = (WfActivityDescriptor)firstTemplateTransition.FromActivity;

                IWfTransitionDescriptor dynInTransition = startActDesp.FindExsitedDynamicToTransition(this);

                ////没有生成过,或者已经生成过,且生成的活动还没有执行
                if (dynInTransition == null || InstanceIsRunning(dynInTransition.ToActivity) == false)
                {
                    //如果已经生成过
                    if (dynInTransition != null)
                    {
                        DeleteExistedDynamicActivities(dynInTransition, this);
                    }

                    WfCreateActivityParamCollection createActivityParams = createActivitiesParamsFetcher();

                    //活动矩阵定义的属性优先于活动模板定义的属性,矩阵中没有设置的属性,则使用活动模版的属性
                    MergeDynamicActivitiesProperties(createActivityParams, this);

                    WfActivityDescriptorCollection createdActivities = CreateActivities(this.FromTransitions, createActivityParams, this.ToTransitions);

                    ChangeNewDynActivitiesProperties(createdActivities, this);

                    result = new List <IWfActivityDescriptor>();

                    createdActivities.CopyTo(result);
                }
            }

            return(result);
        }
Пример #23
0
        public static void AddNodeToDescription(IWfProcess process, int addNumber)
        {
            WfNormalActivityBuilder builder = new WfNormalActivityBuilder();
            var desc = process.Descriptor;
            for (var i = 0; i < addNumber; i++)
            {
                WfActivityDescriptor normalAct = new WfActivityDescriptor("Extra" + i, WfActivityType.NormalActivity);
                normalAct.Name = "Normal" + i;
                normalAct.CodeName = "Normal Activity" + i;
                normalAct.ActivityType = WfActivityType.NormalActivity;
                normalAct.BranchProcessTemplates.Add(new WfBranchProcessTemplateDescriptor("no delete tks!"));
                desc.Activities.Add(normalAct);

                desc.Activities[1].ToTransitions.AddForwardTransition(normalAct);
                normalAct.ToTransitions.AddForwardTransition(desc.Activities[2]);

                WfActivityBase act = WfActivitySettings.GetConfig().GetActivityBuilder(normalAct).CreateActivity(normalAct);
                act.Process = process;
                process.Activities.Add(act);
            }
        }
Пример #24
0
        /// <summary>
        /// 创建一个简单的流程定义
        /// </summary>
        /// <returns></returns>
        public static IWfProcessDescriptor CreateSimpleProcessDescriptor()
        {
            WfProcessDescriptor processDesp = new WfProcessDescriptor();

            processDesp.Key = "TestProcess" + UuidHelper.NewUuidString().Substring(0, 8);
            processDesp.Name = "测试流程";
            processDesp.ApplicationName = "TEST_APP_NAME";
            processDesp.ProgramName = "TEST_PROGRAM_NAME";
            processDesp.Url = "/MCS_Framework/WebTestProject/defaultHandler.aspx";

            WfActivityDescriptor initAct = new WfActivityDescriptor("Initial", WfActivityType.InitialActivity);
            initAct.Name = "Initial";
            initAct.CodeName = "Initial Activity";

            processDesp.Activities.Add(initAct);

            WfActivityDescriptor normalAct = new WfActivityDescriptor("NormalActivity", WfActivityType.NormalActivity);

            normalAct.Name = "Normal";
            normalAct.CodeName = "Normal Activity";

            normalAct.Properties.SetValue("AutoMoveAfterPending", true);

            processDesp.Activities.Add(normalAct);

            processDesp.RelativeLinks.Add(new WfRelativeLinkDescriptor("TestLink") { Name = "测试链接", Url = "/MCSWebApp/Sample.htm" });

            WfActivityDescriptor completedAct = new WfActivityDescriptor("Completed", WfActivityType.CompletedActivity);
            completedAct.Name = "Completed";
            completedAct.CodeName = "Completed Activity";

            completedAct.RelativeLinks.Add(new WfRelativeLinkDescriptor("TestLink") { Name = "测试链接", Url = "/MCSWebApp/Sample.htm" });

            processDesp.Activities.Add(completedAct);

            initAct.ToTransitions.AddForwardTransition(normalAct);
            normalAct.ToTransitions.AddForwardTransition(completedAct);

            return processDesp;
        }
		public void CreateInstanceTest()
		{
			WfActivitySettings setting = WfActivitySettings.GetConfig();
			var process1 = new WfProcessDescriptor() { Key = "Process1" };

			IWfActivityDescriptor actDescriptor = new WfActivityDescriptor("Init", WfActivityType.InitialActivity)
			{
				CodeName = "test",
				Description = "test",
				Enabled = true
			};

			process1.Activities.Add(actDescriptor);

			IWfActivity initActivity = setting.GetActivityBuilder(actDescriptor).CreateActivity(actDescriptor);

			Assert.IsTrue(initActivity.EnterActions.Count > 0);
			Assert.IsTrue(initActivity.LeaveActions.Count > 0);

			initActivity.EnterActions.PrepareActions(null);
			initActivity.EnterActions.PersistActions(null);

			initActivity.LeaveActions.PrepareActions(null);
			initActivity.LeaveActions.PersistActions(null);

			actDescriptor = new WfActivityDescriptor("Completed", WfActivityType.CompletedActivity)
			{
				CodeName = "test",
				Description = "test",
				Enabled = true
			};

			process1.Activities.Add(actDescriptor);

			var completedActivity = setting.GetActivityBuilder(actDescriptor).CreateActivity(actDescriptor);

			Assert.IsTrue(completedActivity.EnterActions.Count > 0);
			Assert.IsTrue(completedActivity.LeaveActions.Count > 0);
		}
        private static WfActivityDescriptor PrepareServerActivity(string key)
        {
            WfActivityDescriptor actDesp = new WfActivityDescriptor(key, WfActivityType.InitialActivity);

            actDesp.Key = key;
            actDesp.Name = key;

            actDesp.Condition.Expression = "Amount > 1000";
            actDesp.Variables.SetValue("ActKey", key);
            actDesp.Variables.SetValue("ActName", key);

            actDesp.Resources.Add(new WfUserResourceDescriptor((IUser)OguUser.CreateWrapperObject(ActivityConverterTest.UserID, SchemaType.Users)));
            actDesp.Resources.Add(new WfDepartmentResourceDescriptor((IOrganization)OguOrganization.CreateWrapperObject(ActivityConverterTest.OrganizationID, SchemaType.Organizations)));
            actDesp.Resources.Add(new WfGroupResourceDescriptor((IGroup)OguGroup.CreateWrapperObject(ActivityConverterTest.GroupID, SchemaType.Groups)));
            actDesp.Resources.Add(new WfRoleResourceDescriptor(new SOARole(ActivityConverterTest.RoleFullCodeName)));
            actDesp.Resources.Add(new WfActivityOperatorResourceDescriptor() { ActivityKey = ActivityConverterTest.ResActivityKey });
            actDesp.Resources.Add(new WfActivityAssigneesResourceDescriptor() { ActivityKey = ActivityConverterTest.ResActivityKey });
            actDesp.Resources.Add(new WfDynamicResourceDescriptor("ConditionResource", "Amount > 1000"));
            actDesp.BranchProcessTemplates.Add(BranchProcessTemplateConverterTest.PrepareServerBranchProcessTemplate());

            return actDesp;
        }
        protected override void OnModifyWorkflow(WfExecutorDataContext dataContext)
        {
            IWfActivity instActivity = PrepareInstanceActivity();

            WfActivityDescriptor instActDesp = (WfActivityDescriptor)instActivity.Descriptor;

            AdjustActivityDescriptorProperties(instActDesp, this.CreateParams);

            IWfActivityDescriptor msTargetActDesp = this.TargetActivity.GetMainStreamActivityDescriptor();

            if (msTargetActDesp != null)
            {
                //同步增加主线活动
                IWfActivityDescriptor newMSActDesp = PrepareActivityDescriptor(msTargetActDesp);

                ((WfActivityBase)instActivity).MainStreamActivityKey = newMSActDesp.Key;
                AdjustActivityDescriptorProperties((WfActivityDescriptor)newMSActDesp, this.CreateParams);
            }

            instActivity.GenerateCandidatesFromResources();
            WfRuntime.DecorateProcess(instActivity.Process);
        }
        /// <summary>
        /// 准备同意/不同意的退回流程。在B环节有两根出线BC和BA,BA是退回线,退回到A。其中BA默认是没有选择的
        /// </summary>
        /// <returns></returns>
        public static IWfProcessDescriptor PrepareAgreeReturnProcessDesp()
        {
            WfProcessDescriptor processDesp = new WfProcessDescriptor();

            processDesp.Key = "TestProcess" + UuidHelper.NewUuidString().Substring(0, 8);
            processDesp.Name = "专用退回流程";
            processDesp.ApplicationName = "TEST_APP_NAME";
            processDesp.ProgramName = "TEST_PROGRAM_NAME";
            processDesp.Url = "/MCS_Framework/WebTestProject/defaultHandler.aspx";

            WfActivityDescriptor initActivity = new WfActivityDescriptor("A", WfActivityType.InitialActivity);
            initActivity.Name = "A";
            initActivity.CodeName = "A";

            processDesp.Activities.Add(initActivity);

            IWfActivityDescriptor activityB = CreateNormalDescriptor("B", "B");

            processDesp.Activities.Add(activityB);

            IWfActivityDescriptor activityC = CreateNormalDescriptor("C", "C");
            processDesp.Activities.Add(activityC);

            IWfActivityDescriptor activityD = CreateNormalDescriptor("D", "D");
            processDesp.Activities.Add(activityD);

            WfActivityDescriptor completedActivity = new WfActivityDescriptor("F", WfActivityType.CompletedActivity);
            completedActivity.Name = "F";
            completedActivity.CodeName = "F";

            processDesp.Activities.Add(completedActivity);

            //A->B
            initActivity.ToTransitions.AddForwardTransition(activityB);

            //B有两根出线,分别是C和A,A是退回线
            WfTransitionDescriptor transitionBC = (WfTransitionDescriptor)activityB.ToTransitions.AddForwardTransition(activityC);
            transitionBC.Enabled = true;
            transitionBC.DefaultSelect = true;
            WfTransitionDescriptor transitionBA = (WfTransitionDescriptor)activityB.ToTransitions.AddBackwardTransition(initActivity);
            //transitionBA.Enabled = false;
            transitionBA.Enabled = true;
            transitionBC.DefaultSelect = false;
            transitionBA.IsBackward = true;

            //C->D
            activityC.ToTransitions.AddForwardTransition(activityD);

            //D到结束点
            activityD.ToTransitions.AddForwardTransition(completedActivity);

            return processDesp;
        }
        /// <summary>
        /// 生成用于复制退件活动的测试流程
        /// A为起点、两条分支,A、B、C、D和A、E、D,D为终点
        /// </summary>
        /// <returns></returns>
        public static IWfProcessDescriptor PrepareCopyTestProcessDesp()
        {
            WfProcessDescriptor processDesp = new WfProcessDescriptor();

            processDesp.Key = "TestProcess" + UuidHelper.NewUuidString().Substring(0, 8);
            processDesp.Name = "专用退回流程";
            processDesp.ApplicationName = "TEST_APP_NAME";
            processDesp.ProgramName = "TEST_PROGRAM_NAME";
            processDesp.Url = "/MCS_Framework/WebTestProject/defaultHandler.aspx";

            WfActivityDescriptor initActivity = new WfActivityDescriptor("A", WfActivityType.InitialActivity);
            initActivity.Name = "A";
            initActivity.CodeName = "A";

            processDesp.Activities.Add(initActivity);

            IWfActivityDescriptor activityB = CreateNormalDescriptor("B", "B");

            processDesp.Activities.Add(activityB);

            IWfActivityDescriptor activityC = CreateNormalDescriptor("C", "C");
            processDesp.Activities.Add(activityC);

            IWfActivityDescriptor activityE = CreateNormalDescriptor("E", "E");
            processDesp.Activities.Add(activityE);

            WfActivityDescriptor completedActivity = new WfActivityDescriptor("D", WfActivityType.CompletedActivity);
            completedActivity.Name = "D";
            completedActivity.CodeName = "D";

            processDesp.Activities.Add(completedActivity);

            //A到B
            WfTransitionDescriptor transitionAB = (WfTransitionDescriptor)initActivity.ToTransitions.AddForwardTransition(activityB);
            transitionAB.Enabled = true;

            //A到E
            WfTransitionDescriptor transitionAE = (WfTransitionDescriptor)initActivity.ToTransitions.AddBackwardTransition(activityE);
            transitionAE.Enabled = false;

            //B到C
            activityB.ToTransitions.AddForwardTransition(activityC);

            //E到C
            activityE.ToTransitions.AddForwardTransition(activityC);

            //C到结束点
            activityC.ToTransitions.AddForwardTransition(completedActivity);

            return processDesp;
        }
        private WfActivityDescriptorCollection CreateActivities(WfTransitionDescriptorCollection fromTransitions, WfCreateActivityParamCollection capc, WfTransitionDescriptorCollection toTransitions)
        {
            WfActivityDescriptorCollection result = new WfActivityDescriptorCollection(this.Process);

            IWfActivityDescriptor firstDynamicActivity     = null;
            IWfActivityDescriptor lastDynamicActivity      = null;
            WfCreateActivityParam lastCreatedActivityParam = null;

            foreach (WfCreateActivityParam cap in capc)
            {
                WfActivityDescriptor actDesp = (WfActivityDescriptor)cap.Template.Clone();

                actDesp.Process = this.Process;

                string newActKey = "ND" + cap.ActivitySN;

                if (this.Process.Activities.ContainsKey(newActKey))
                {
                    newActKey = this.Process.FindNotUsedActivityKey();
                }

                actDesp.Key           = newActKey;
                cap.CreatedDescriptor = actDesp;

                this.Process.Activities.Add(actDesp);

                if (lastCreatedActivityParam != null)
                {
                    lastCreatedActivityParam.DefaultNextDescriptor = actDesp;
                }

                lastCreatedActivityParam = cap;

                if (this.IsMainStreamActivity == false && this.ProcessInstance != null)
                {
                    WfActivityBase.CreateActivityInstance(actDesp, this.ProcessInstance);
                }

                if (firstDynamicActivity == null)
                {
                    firstDynamicActivity = actDesp;
                }

                if (lastDynamicActivity != null)
                {
                    WfTransitionDescriptor newTransition = (WfTransitionDescriptor)lastDynamicActivity.ToTransitions.AddForwardTransition(actDesp);

                    //如果不是第一个生成的活动
                    if (firstDynamicActivity != actDesp)
                    {
                        newTransition.GeneratedByTemplate = true;
                        newTransition.TemplateKey         = this.Key;
                    }
                }

                lastDynamicActivity = actDesp;

                result.Add(actDesp);
            }

            if (firstDynamicActivity != null && lastDynamicActivity != null)
            {
                SetEntryTransitionsProperties(firstDynamicActivity, fromTransitions);

                if (lastCreatedActivityParam != null)
                {
                    IWfTransitionDescriptor defaultTransition =
                        toTransitions.GetAllConditionMatchedTransitions().FindDefaultSelectTransition(true);

                    if (defaultTransition != null)
                    {
                        lastCreatedActivityParam.DefaultNextDescriptor = defaultTransition.ToActivity;
                    }
                }

                capc.AdjustTransitionsByTemplate(this.Key);

                //如果在活动模板参数的最后一个活动没有配置出线,则使用默认的出线;否则使用配置的出线
                if (lastDynamicActivity.ToTransitions.Count == 0)
                {
                    SetExitTransitionsProperties(lastDynamicActivity, toTransitions);
                }
                else
                {
                    lastDynamicActivity.ToTransitions.ForEach(t => SetDynamicTransitionProperties(null, t, this, false));
                }
            }
            else
            {
                //当没有动态活动生成时,前后的活动直接串联到一起
                JoinOriginalActivitiesAndSetProperties(fromTransitions, toTransitions);
            }

            //将模版点的进出线的Enabled都设置为False
            fromTransitions.ForEach(t => ((WfTransitionDescriptor)t).Enabled = false);
            toTransitions.ForEach(t => ((WfTransitionDescriptor)t).Enabled   = false);

            return(result);
        }
        /// <summary>
        /// 准备一条简单的直线流程,主要用于两次退回等场景
        /// 流程为A->B->C->D
        /// </summary>
        /// <returns></returns>
        public static IWfProcessDescriptor PrepareStraightProcessDesp()
        {
            WfProcessDescriptor processDesp = new WfProcessDescriptor();

            processDesp.Key = "TestProcess" + UuidHelper.NewUuidString().Substring(0, 8);
            processDesp.Name = "简单直线流程";
            processDesp.ApplicationName = "TEST_APP_NAME";
            processDesp.ProgramName = "TEST_PROGRAM_NAME";
            processDesp.Url = "/MCS_Framework/WebTestProject/defaultHandler.aspx";

            WfActivityDescriptor initActivity = new WfActivityDescriptor("A", WfActivityType.InitialActivity);
            initActivity.Name = "A";
            initActivity.CodeName = "A";
            initActivity.Resources.Add(new WfUserResourceDescriptor((IUser)OguObjectSettings.GetConfig().Objects["requestor"].Object));

            processDesp.Activities.Add(initActivity);

            IWfActivityDescriptor activityB = CreateNormalDescriptor("B", "B");

            processDesp.Activities.Add(activityB);
            activityB.Resources.Add(new WfUserResourceDescriptor((IUser)OguObjectSettings.GetConfig().Objects["approver1"].Object));

            IWfActivityDescriptor activityC = CreateNormalDescriptor("C", "C");
            processDesp.Activities.Add(activityC);

            WfActivityDescriptor completedActivity = new WfActivityDescriptor("D", WfActivityType.CompletedActivity);
            completedActivity.Name = "D";
            completedActivity.CodeName = "D";

            processDesp.Activities.Add(completedActivity);

            //A到B
            WfTransitionDescriptor transitionAB = (WfTransitionDescriptor)initActivity.ToTransitions.AddForwardTransition(activityB);
            transitionAB.Enabled = true;


            //B到C
            activityB.ToTransitions.AddForwardTransition(activityC);

            //C到结束点
            activityC.ToTransitions.AddForwardTransition(completedActivity);

            return processDesp;
        }
Пример #32
0
        public void BasicMainStreamActivities()
        {
            //主流程描述点
            IWfProcessDescriptor desp = WfProcessTestCommon.CreateProcessDescriptor();

            WfMainStreamActivityDescriptorCollection coll = desp.GetMainStreamActivities();

            Assert.AreEqual(desp.Activities.Count, coll.Count);

            //添加动态点
            string activityKey = desp.FindNotUsedActivityKey();
            WfActivityDescriptor actDesp = new WfActivityDescriptor(activityKey, WfActivityType.NormalActivity);
            desp.InitialActivity.Append(actDesp);

            coll = desp.GetMainStreamActivities();
            Assert.AreEqual(desp.Activities.Count, coll.Count, "流程描述时,添加节点描述也为主线流程中的活动");
        }
		public void BasicAdminAddActivityWithMainStreamAndFromActivityExecutorTest()
		{
			IWfProcess process = WfProcessTestCommon.StartupSimpleProcess();

			const string targetName = "修改后的名称";

			IWfActivityDescriptor targetDesp = new WfActivityDescriptor(process.Descriptor.FindNotUsedActivityKey(), WfActivityType.NormalActivity);

			targetDesp.Properties.SetValue("Name", targetName);
			process.Descriptor.Activities.Add(targetDesp);

			WfActivityBase.CreateActivityInstance(targetDesp, process);

			IWfActivity fromActivity = process.Activities.FindActivityByDescriptorKey("NormalActivity");

			WfAdminAddActivityExecutor executor = new WfAdminAddActivityExecutor(process.CurrentActivity, process, fromActivity.Descriptor, targetDesp, true);

			executor.Execute();

			process = WfRuntime.GetProcessByProcessID(process.ID);

			targetDesp = process.Descriptor.Activities[targetDesp.Key];

			Assert.IsNotNull(targetDesp);
			Assert.AreEqual(targetName, targetDesp.Properties.GetValue("Name", string.Empty));
			fromActivity = process.Activities.FindActivityByDescriptorKey("NormalActivity");

			Assert.IsNotNull(fromActivity.Descriptor.ToTransitions.GetTransitionByToActivity(targetDesp));

			IWfActivityDescriptor msActDesp = targetDesp.Instance.GetMainStreamActivityDescriptor();
			Assert.IsNotNull(msActDesp);
			Assert.AreEqual(process.MainStream, msActDesp.Process);
			Assert.AreEqual(targetName, msActDesp.Properties.GetValue("Name", string.Empty));

			IWfActivityDescriptor msFromActDesp = fromActivity.GetMainStreamActivityDescriptor();

			Assert.IsNotNull(msFromActDesp);
			Assert.AreEqual(process.MainStream, msFromActDesp.Process);
			Assert.IsNotNull(msFromActDesp.ToTransitions.GetTransitionByToActivity(msActDesp));
		}
		public void BasicAdminAddActivityExecutorTest()
		{
			IWfProcess process = WfProcessTestCommon.StartupSimpleProcess();

			const string targetName = "修改后的名称";

			IWfActivityDescriptor targetDesp = new WfActivityDescriptor(process.Descriptor.FindNotUsedActivityKey(), WfActivityType.NormalActivity);

			targetDesp.Properties.SetValue("Name", targetName);
			process.Descriptor.Activities.Add(targetDesp);

			WfActivityBase.CreateActivityInstance(targetDesp, process);

			WfAdminAddActivityExecutor executor = new WfAdminAddActivityExecutor(process.CurrentActivity, process, null, targetDesp, false);

			executor.Execute();

			process = WfRuntime.GetProcessByProcessID(process.ID);

			targetDesp = process.Descriptor.Activities[targetDesp.Key];

			Assert.IsNotNull(targetDesp);
			Assert.AreEqual(targetName, targetDesp.Properties.GetValue("Name", string.Empty));
		}
Пример #35
0
        /// <summary>
        /// 生成空办结节点定义的JSON串
        /// </summary>
        /// <returns></returns>
        public static string GetEmptyCompletedActivityDescriptorJsonString()
        {
            RegisterConverters();

            WfActivityDescriptor activityDesp = new WfActivityDescriptor(string.Empty, WfActivityType.CompletedActivity);
            activityDesp.Name = "办结";

            return JSONSerializerExecute.Serialize(activityDesp);
        }
Пример #36
0
        public void FindElapsedTransitionTest()
        {
            //流程运行时
            IWfProcess process = WfProcessTestCommon.StartupProcessWithAssignee();

            //新增加活动描述,没有为此添加实例
            string activityKey = process.Descriptor.FindNotUsedActivityKey();
            WfActivityDescriptor actDesp = new WfActivityDescriptor(activityKey, WfActivityType.NormalActivity);

            process.CurrentActivity.Descriptor.Append(actDesp);

            //使用GetMainStreamActivities方法时,会出错,因为只添加了描述,没添加实例。这里需要正常抛出异常
            WfMainStreamActivityDescriptorCollection coll = process.Descriptor.GetMainStreamActivities();
            Assert.IsNotNull(coll);
        }
Пример #37
0
        /// <summary>
        /// 生成空正常节点定义的JSON串
        /// </summary>
        /// <returns></returns>
        public static string GetEmptyNormalActivityDescriptorJsonString()
        {
            RegisterConverters();

            WfActivityDescriptor activityDesp = new WfActivityDescriptor(string.Empty);

            return JSONSerializerExecute.Serialize(activityDesp);
        }
Пример #38
0
        private static WfActivityDescriptor AddActivity(IWfProcess process)
        {
            string activityKey = process.Descriptor.FindNotUsedActivityKey();
            WfActivityDescriptor actDesp = new WfActivityDescriptor(activityKey, WfActivityType.NormalActivity);

            WfRuntime.ProcessContext.ActivityChangingContext.CreatorInstanceID = process.CurrentActivity.ID;
            WfRuntime.ProcessContext.ActivityChangingContext.AssociatedActivityKey =
                process.CurrentActivity.Descriptor.AssociatedActivityKey.IsNotEmpty() ?
                    process.CurrentActivity.Descriptor.AssociatedActivityKey : process.CurrentActivity.Descriptor.Key;

            process.CurrentActivity.Append(actDesp);
            return actDesp;
        }
        protected override IWfActivityDescriptor PrepareActivityDescriptor(IWfActivityDescriptor targetActDesp)
        {
            IWfProcessDescriptor processDesp = targetActDesp.Process;

            string activityKey = processDesp.FindNotUsedActivityKey();

            WfActivityDescriptor newActDesp = new WfActivityDescriptor(activityKey);

            newActDesp.ActivityType = WfActivityType.NormalActivity;

            //主线活动不应该有关联Key
            newActDesp.AssociatedActivityKey = WfRuntime.ProcessContext.ActivityChangingContext.AssociatedActivityKey;
            newActDesp.FromTransitions.Clear();
            newActDesp.ToTransitions.Clear();

            processDesp.Activities.Add(newActDesp);
            newActDesp.Properties.SetValue("AutoMoveAfterPending", true);

            IWfTransitionDescriptor defaultSelectTran = targetActDesp.ToTransitions.FindDefaultSelectTransition();

            List <IWfTransitionDescriptor> movedTransitions = new List <IWfTransitionDescriptor>();

            foreach (WfTransitionDescriptor t in targetActDesp.ToTransitions)
            {
                WfTransitionDescriptor cloneTransition = (WfTransitionDescriptor)t.Clone();
                cloneTransition.Key = processDesp.FindNotUsedTransitionKey();

                if (t.IsBackward == false)
                {
                    cloneTransition.JoinActivity(newActDesp, t.ToActivity);
                    newActDesp.ToTransitions.Add(cloneTransition);

                    movedTransitions.Add(t);

                    t.ToActivity.FromTransitions.Remove(td => td.Key == t.Key);
                    t.ToActivity.FromTransitions.Add(cloneTransition);

                    if (t.Key == defaultSelectTran.Key)
                    {
                        t.Key = processDesp.FindNotUsedTransitionKey();
                        t.JoinActivity(targetActDesp, newActDesp);
                        newActDesp.FromTransitions.Add(t);
                    }
                }
                else
                {
                    cloneTransition.JoinActivity(newActDesp, t.ToActivity);
                    newActDesp.ToTransitions.Add(cloneTransition);

                    movedTransitions.Add(t);
                }
            }

            foreach (WfTransitionDescriptor t in movedTransitions)
            {
                targetActDesp.ToTransitions.Remove(t);
            }

            SetDynamicActivityProperties(targetActDesp, newActDesp);

            IWfTransitionDescriptor newTransition = targetActDesp.ToTransitions.AddForwardTransition(newActDesp);

            SetDynamicTransitionProperties(targetActDesp, newTransition);

            return(newActDesp);
        }
Пример #40
0
        /// <summary>
        /// 创建一个有四个节点的带条件流程,Init,Complete,Normal和Manager
        /// </summary>
        /// <returns></returns>
        public static IWfProcessDescriptor CreateSimpleProcessDescriptorWithCondition()
        {
            IWfProcessDescriptor processDesp = CreateSimpleProcessDescriptor();

            //直接到结束点
            ((IWfForwardTransitionDescriptor)processDesp.Activities["NormalActivity"].ToTransitions[0]).Condition.Expression = "Amount < 5000";

            WfActivityDescriptor mgrAct = new WfActivityDescriptor("ManagerActivity", WfActivityType.NormalActivity);

            mgrAct.Name = "Manager";
            mgrAct.CodeName = "Manager";

            processDesp.Activities.Add(mgrAct);

            //经过管理员点
            IWfForwardTransitionDescriptor transition = processDesp.Activities["NormalActivity"].ToTransitions.AddForwardTransition(mgrAct);

            transition.Condition.Expression = "Amount >= 5000";

            mgrAct.ToTransitions.AddForwardTransition(processDesp.CompletedActivity);

            return processDesp;
        }
Пример #41
0
        protected override void OnModifyWorkflow(WfExecutorDataContext dataContext)
        {
            (this.Assignees.Count > 0).FalseThrow <WfRuntimeException>("加签的用户数必须大于零");

            IWfProcess process = this.TargetActivity.Process;

            WfRuntime.ProcessContext.BeginChangeActivityChangingContext();

            try
            {
                WfRuntime.ProcessContext.ActivityChangingContext.CreatorInstanceID = OperatorActivity.ID;
                string clonedKey = TargetActivity.Descriptor.AssociatedActivityKey.IsNotEmpty() ?
                                   TargetActivity.Descriptor.AssociatedActivityKey : TargetActivity.Descriptor.Key;

                IWfActivity templateAct = process.Activities.FindActivityByDescriptorKey(clonedKey);

                //不是仅添加审批人时
                if ((this.AddApproverMode & WfAddApproverMode.AreAssociatedActivities) != WfAddApproverMode.OnlyAddApprover)
                {
                    WfRuntime.ProcessContext.ActivityChangingContext.AssociatedActivityKey = clonedKey;
                }

                //生成加签的点
                WfActivityDescriptor addActDesp = CreateAddApproverActivityDescriptor(templateAct.Descriptor);

                IWfActivity addedActivity = this.TargetActivity.Append(addActDesp);

                //当仅添加审批人时
                if ((this.AddApproverMode & WfAddApproverMode.AreAssociatedActivities) == WfAddApproverMode.OnlyAddApprover)
                {
                    //将指派人直接赋值给办理人
                    addedActivity.Candidates.CopyFrom(this.Assignees);

                    IWfActivityDescriptor mainStreamActDesp = templateAct.GetMainStreamActivityDescriptor();

                    if (mainStreamActDesp != null)
                    {
                        WfActivityDescriptor newMSActDesp = CreateAddApproverActivityDescriptor(mainStreamActDesp);

                        newMSActDesp.Resources.Clear();

                        foreach (IUser user in this.Assignees.ToUsers())
                        {
                            newMSActDesp.Resources.Add(new WfUserResourceDescriptor(user));
                        }

                        mainStreamActDesp.Append(newMSActDesp);
                    }
                }

                //不是仅添加审批人时
                if ((this.AddApproverMode & WfAddApproverMode.AppendCurrentActivity) != WfAddApproverMode.OnlyAddApprover)
                {
                    //Clone当前的点,在加签点后生成再添加当前活动
                    IWfActivity          foundActivity        = process.Activities.FindActivityByDescriptorKey(clonedKey);
                    WfActivityDescriptor clonedCurrentActDesp = ((WfActivityDescriptor)foundActivity.Descriptor).Clone() as WfActivityDescriptor;

                    //加签按照加签活动模板进行属性设置
                    WfActivityBase.ResetPropertiesByDefinedName(addActDesp, "DefaultAddApproverActivityTemplate");

                    //if (foundActivity.Descriptor.ActivityType == WfActivityType.InitialActivity)
                    //	WfActivityBase.ResetPropertiesByDefinedName(clonedCurrentActDesp, "DefaultAddApproverActivityTemplate");

                    clonedCurrentActDesp.AssociatedActivityKey = WfRuntime.ProcessContext.ActivityChangingContext.AssociatedActivityKey;
                    clonedCurrentActDesp.ClonedKey             = this.TargetActivity.Descriptor.Key;
                    clonedCurrentActDesp.IsReturnSkipped       = true;

                    IWfActivity clonedActivity = addActDesp.Instance.Append(clonedCurrentActDesp);
                    clonedActivity.Candidates.CopyFrom(foundActivity.Candidates);
                }

                WfTransferParams tp = new WfTransferParams(addActDesp);

                tp.Assignees.CopyFrom(this.Assignees);

                process.MoveTo(tp);
            }
            finally
            {
                WfRuntime.ProcessContext.RestoreChangeActivityChangingContext();
            }
        }
        private void SetActivityProperties(WfActivityDescriptor actDesp, Dictionary <string, object> activityProperties, IDictionary <string, object> dictionary)
        {
            if (activityProperties.ContainsKey("Variables"))
            {
                var item = (WfVariableDescriptorCollection)activityProperties["Variables"];
                if (item != null)
                {
                    actDesp.Variables.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("Variables"))
            {
                WfVariableDescriptorCollection variables = JSONSerializerExecute.Deserialize <WfVariableDescriptorCollection>(dictionary["Variables"]);
                actDesp.Variables.CopyFrom(variables);
            }

            if (activityProperties.ContainsKey("Condition"))
            {
                var item = (WfConditionDescriptor)activityProperties["Condition"];
                if (item != null)
                {
                    actDesp.Condition = (WfConditionDescriptor)activityProperties["Condition"];
                }
                else
                {
                    actDesp.Condition.Owner = actDesp;
                }
            }
            else if (dictionary.ContainsKey("Condition"))
            {
                actDesp.Condition       = JSONSerializerExecute.Deserialize <WfConditionDescriptor>(dictionary["Condition"]);
                actDesp.Condition.Owner = actDesp;
            }

            if (activityProperties.ContainsKey("BranchProcessTemplates"))
            {
                var item = (WfBranchProcessTemplateCollection)activityProperties["BranchProcessTemplates"];
                if (item != null)
                {
                    actDesp.BranchProcessTemplates.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("BranchProcessTemplates"))
            {
                WfBranchProcessTemplateCollection templates = JSONSerializerExecute.Deserialize <WfBranchProcessTemplateCollection>(dictionary["BranchProcessTemplates"]);
                actDesp.BranchProcessTemplates.CopyFrom(templates);
            }

            if (activityProperties.ContainsKey("Resources"))
            {
                var item = (WfResourceDescriptorCollection)activityProperties["Resources"];
                if (item != null)
                {
                    actDesp.Resources.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("Resources"))
            {
                WfResourceDescriptorCollection resource = JSONSerializerExecute.Deserialize <WfResourceDescriptorCollection>(dictionary["Resources"]);
                actDesp.Resources.CopyFrom(resource);
            }

            if (activityProperties.ContainsKey("RelativeLinks"))
            {
                var item = (WfRelativeLinkDescriptorCollection)activityProperties["RelativeLinks"];
                if (item != null)
                {
                    actDesp.RelativeLinks.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("RelativeLinks"))
            {
                WfRelativeLinkDescriptorCollection relativeLinks = JSONSerializerExecute.Deserialize <WfRelativeLinkDescriptorCollection>(dictionary["RelativeLinks"]);
                actDesp.RelativeLinks.CopyFrom(relativeLinks);
            }

            if (activityProperties.ContainsKey("EnterEventReceivers"))
            {
                var item = (WfResourceDescriptorCollection)activityProperties["EnterEventReceivers"];
                if (item != null)
                {
                    actDesp.EnterEventReceivers.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("EnterEventReceivers"))
            {
                WfResourceDescriptorCollection resource = JSONSerializerExecute.Deserialize <WfResourceDescriptorCollection>(dictionary["EnterEventReceivers"]);
                actDesp.EnterEventReceivers.CopyFrom(resource);
            }

            if (activityProperties.ContainsKey("LeaveEventReceivers"))
            {
                var item = (WfResourceDescriptorCollection)activityProperties["LeaveEventReceivers"];
                if (item != null)
                {
                    actDesp.LeaveEventReceivers.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("LeaveEventReceivers"))
            {
                WfResourceDescriptorCollection resource = JSONSerializerExecute.Deserialize <WfResourceDescriptorCollection>(dictionary["LeaveEventReceivers"]);
                actDesp.LeaveEventReceivers.CopyFrom(resource);
            }

            if (activityProperties.ContainsKey("InternalRelativeUsers"))
            {
                var item = (WfResourceDescriptorCollection)activityProperties["InternalRelativeUsers"];
                if (item != null)
                {
                    actDesp.InternalRelativeUsers.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("InternalRelativeUsers"))
            {
                WfResourceDescriptorCollection interRelUser = JSONSerializerExecute.Deserialize <WfResourceDescriptorCollection>(dictionary["InternalRelativeUsers"]);
                actDesp.InternalRelativeUsers.CopyFrom(interRelUser);
            }

            if (activityProperties.ContainsKey("ExternalUsers"))
            {
                var item = (WfExternalUserCollection)activityProperties["ExternalUsers"];
                if (item != null)
                {
                    actDesp.ExternalUsers.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("ExternalUsers"))
            {
                WfExternalUserCollection externalUser = JSONSerializerExecute.Deserialize <WfExternalUserCollection>(dictionary["ExternalUsers"]);
                actDesp.ExternalUsers.CopyFrom(externalUser);
            }

            if (activityProperties.ContainsKey("EnterEventExecuteServices"))
            {
                var item = (WfServiceOperationDefinitionCollection)activityProperties["EnterEventExecuteServices"];
                if (item != null)
                {
                    actDesp.EnterEventExecuteServices.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("EnterEventExecuteServices"))
            {
                WfServiceOperationDefinitionCollection svcOperationDef =
                    JSONSerializerExecute.Deserialize <WfServiceOperationDefinitionCollection>(dictionary["EnterEventExecuteServices"]);
                actDesp.EnterEventExecuteServices.CopyFrom(svcOperationDef);
            }

            if (activityProperties.ContainsKey("LeaveEventExecuteServices"))
            {
                var item = (WfServiceOperationDefinitionCollection)activityProperties["LeaveEventExecuteServices"];

                if (item != null)
                {
                    actDesp.LeaveEventExecuteServices.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("LeaveEventExecuteServices"))
            {
                WfServiceOperationDefinitionCollection svcOperationDef =
                    JSONSerializerExecute.Deserialize <WfServiceOperationDefinitionCollection>(dictionary["LeaveEventExecuteServices"]);

                actDesp.LeaveEventExecuteServices.CopyFrom(svcOperationDef);
            }

            if (activityProperties.ContainsKey("WithdrawExecuteServices"))
            {
                var item = (WfServiceOperationDefinitionCollection)activityProperties["WithdrawExecuteServices"];

                if (item != null)
                {
                    actDesp.WithdrawExecuteServices.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("WithdrawExecuteServices"))
            {
                WfServiceOperationDefinitionCollection svcOperationDef =
                    JSONSerializerExecute.Deserialize <WfServiceOperationDefinitionCollection>(dictionary["WithdrawExecuteServices"]);

                actDesp.WithdrawExecuteServices.CopyFrom(svcOperationDef);
            }

            if (activityProperties.ContainsKey("BeWithdrawnExecuteServices"))
            {
                var item = (WfServiceOperationDefinitionCollection)activityProperties["BeWithdrawnExecuteServices"];

                if (item != null)
                {
                    actDesp.BeWithdrawnExecuteServices.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("BeWithdrawnExecuteServices"))
            {
                WfServiceOperationDefinitionCollection svcOperationDef =
                    JSONSerializerExecute.Deserialize <WfServiceOperationDefinitionCollection>(dictionary["BeWithdrawnExecuteServices"]);

                actDesp.BeWithdrawnExecuteServices.CopyFrom(svcOperationDef);
            }

            if (activityProperties.ContainsKey("ParametersNeedToBeCollected"))
            {
                var item = (WfParameterNeedToBeCollected)activityProperties["ParametersNeedToBeCollected"];
                if (item != null)
                {
                    actDesp.ParametersNeedToBeCollected.CopyFrom(item);
                }
            }
            else if (dictionary.ContainsKey("ParametersNeedToBeCollected"))
            {
                WfParameterNeedToBeCollected parameters =
                    JSONSerializerExecute.Deserialize <WfParameterNeedToBeCollected>(dictionary["ParametersNeedToBeCollected"]);
                actDesp.ParametersNeedToBeCollected.CopyFrom(parameters);
            }
        }
        internal static void ResetPropertiesByDefinedName(WfActivityDescriptor actDesp, string definedName)
        {
            PropertyDefineCollection definedProperties = new PropertyDefineCollection();
            definedProperties.LoadPropertiesFromConfiguration(WfActivitySettings.GetConfig().PropertyGroups[definedName]);

            actDesp.Properties.ReplaceDefinedProperties(definedProperties);
        }
Пример #44
0
        protected override void OnModifyWorkflow(WfExecutorDataContext dataContext)
        {
            this.TargetActivity.Process.Committed = true;

            IWfProcess process = TargetActivity.Process;

            WfRuntime.ProcessContext.BeginChangeActivityChangingContext();
            try
            {
                WfRuntime.ProcessContext.ActivityChangingContext.CreatorInstanceID     = TargetActivity.ID;
                WfRuntime.ProcessContext.ActivityChangingContext.AssociatedActivityKey =
                    TargetActivity.Descriptor.AssociatedActivityKey.IsNotEmpty() ?
                    TargetActivity.Descriptor.AssociatedActivityKey : TargetActivity.Descriptor.Key;

                //string activityKey = process.Descriptor.FindNotUsedActivityKey();

                //WfActivityDescriptor actDesp = new WfActivityDescriptor(activityKey);

                //actDesp.Name = "会签";
                var toReturnTrans = process.CurrentActivity.Descriptor.ToTransitions.FindAll(t => t.IsBackward == true);

                WfActivityDescriptor actDesp = process.CurrentActivity.Descriptor.Clone() as WfActivityDescriptor;
                actDesp.ActivityType = WfActivityType.NormalActivity;
                actDesp.Properties.SetValue("AutoMoveAfterPending", false);
                actDesp.ClonedKey = process.CurrentActivity.Descriptor.Key;
                actDesp.BranchProcessTemplates.Clear();
                process.CurrentActivity.Append(actDesp);

                foreach (WfTransitionDescriptor t in toReturnTrans)
                {
                    WfTransitionDescriptor trans = t.Clone() as WfTransitionDescriptor;
                    if (t.FromActivityKey == t.ToActivityKey)
                    {
                        trans.JoinActivity(actDesp, actDesp);
                    }
                    else
                    {
                        trans.JoinActivity(actDesp, t.ToActivity);
                    }

                    actDesp.ToTransitions.Add(trans);
                }

                //添加子流程
                WfTransferParams tp = new WfTransferParams(actDesp);
                tp.Assignees.CopyFrom(Assignees);

                tp.BranchTransferParams.Add(new WfBranchProcessTransferParams(
                                                WfTemplateBuilder.CreateDefaultConsignTemplate(
                                                    "WfConsignProcessTemplateDescriptorKey",
                                                    this.Sequence,
                                                    this.BlockingType,
                                                    this.ConsignUsers)));

                if (this.CirculateUsers.Count <IUser>() > 0)
                {
                    tp.BranchTransferParams.Add(new WfBranchProcessTransferParams(
                                                    WfTemplateBuilder.CreateDefaultCirculationTemplate(
                                                        "WfCirculationProcessTemplateDescriptorKey",
                                                        this.CirculateUsers)));
                }

                WfRuntime.ProcessContext.AfterStartupBranchProcess += new WfAfterStartupBranchProcessHandler(WfActivityRelativeExecutorBase.AfterStartupBranchProcess);
                process.MoveTo(tp);
            }
            finally
            {
                WfRuntime.ProcessContext.RestoreChangeActivityChangingContext();
            }
        }
Пример #45
0
        public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            WfActivityDescriptor actDesp = (WfActivityDescriptor)base.Deserialize(dictionary, type, serializer);

            //actDesp.ActivityType = DictionaryHelper.GetValue(dictionary, "ActivityType", WfActivityType.NormalActivity);

            if (true == DictionaryHelper.GetValue(dictionary, "AllowEmptyCandidates", false))
            {
                actDesp.Properties.SetValue("AllowEmptyCandidates", true);
            }

            if (true == DictionaryHelper.GetValue(dictionary, "AllowInvalidCandidates", false))
            {
                if (actDesp.Properties.ContainsKey("AllowInvalidCandidates"))
                {
                    actDesp.Properties.SetValue("AllowInvalidCandidates", true);
                }
            }

            actDesp.Url      = DictionaryHelper.GetValue(dictionary, "Url", string.Empty);
            actDesp.CodeName = DictionaryHelper.GetValue(dictionary, "CodeName", string.Empty);

            WfVariableDescriptorCollection variables = JSONSerializerExecute.Deserialize <WfVariableDescriptorCollection>(dictionary["Variables"]);

            actDesp.Variables.Clear();
            actDesp.Variables.CopyFrom(variables);

            if (dictionary.ContainsKey("Condition"))
            {
                actDesp.Condition       = JSONSerializerExecute.Deserialize <WfConditionDescriptor>(dictionary["Condition"]);
                actDesp.Condition.Owner = actDesp;
            }

            if (dictionary.ContainsKey("BranchProcessTemplates"))
            {
                WfBranchProcessTemplateCollection templates = JSONSerializerExecute.Deserialize <WfBranchProcessTemplateCollection>(dictionary["BranchProcessTemplates"]);
                actDesp.BranchProcessTemplates.Clear();
                actDesp.BranchProcessTemplates.CopyFrom(templates);
            }

            if (dictionary.ContainsKey("Resources"))
            {
                WfResourceDescriptorCollection resource = JSONSerializerExecute.Deserialize <WfResourceDescriptorCollection>(dictionary["Resources"]);
                actDesp.Resources.Clear();
                actDesp.Resources.CopyFrom(resource);
            }

            if (dictionary.ContainsKey("RelativeLinks"))
            {
                WfRelativeLinkDescriptorCollection relativeLinks = JSONSerializerExecute.Deserialize <WfRelativeLinkDescriptorCollection>(dictionary["RelativeLinks"]);

                actDesp.RelativeLinks.Clear();
                actDesp.RelativeLinks.CopyFrom(relativeLinks);
            }

            if (dictionary.ContainsKey("EnterEventReceivers"))
            {
                WfResourceDescriptorCollection resource = JSONSerializerExecute.Deserialize <WfResourceDescriptorCollection>(dictionary["EnterEventReceivers"]);
                actDesp.EnterEventReceivers.Clear();
                actDesp.EnterEventReceivers.CopyFrom(resource);
            }

            if (dictionary.ContainsKey("LeaveEventReceivers"))
            {
                WfResourceDescriptorCollection resource = JSONSerializerExecute.Deserialize <WfResourceDescriptorCollection>(dictionary["LeaveEventReceivers"]);
                actDesp.LeaveEventReceivers.Clear();
                actDesp.LeaveEventReceivers.CopyFrom(resource);
            }

            if (dictionary.ContainsKey("InternalRelativeUsers"))
            {
                WfResourceDescriptorCollection interRelUser = JSONSerializerExecute.Deserialize <WfResourceDescriptorCollection>(dictionary["InternalRelativeUsers"]);
                actDesp.InternalRelativeUsers.Clear();
                actDesp.InternalRelativeUsers.CopyFrom(interRelUser);
            }

            if (dictionary.ContainsKey("ExternalUsers"))
            {
                WfExternalUserCollection externalUser = JSONSerializerExecute.Deserialize <WfExternalUserCollection>(dictionary["ExternalUsers"]);
                actDesp.ExternalUsers.Clear();
                actDesp.ExternalUsers.CopyFrom(externalUser);
            }

            if (dictionary.ContainsKey("EnterEventExecuteServices"))
            {
                WfServiceOperationDefinitionCollection svcOperationDef =
                    JSONSerializerExecute.Deserialize <WfServiceOperationDefinitionCollection>(dictionary["EnterEventExecuteServices"]);
                actDesp.EnterEventExecuteServices.Clear();
                actDesp.EnterEventExecuteServices.CopyFrom(svcOperationDef);
            }

            if (dictionary.ContainsKey("LeaveEventExecuteServices"))
            {
                WfServiceOperationDefinitionCollection svcOperationDef =
                    JSONSerializerExecute.Deserialize <WfServiceOperationDefinitionCollection>(dictionary["LeaveEventExecuteServices"]);
                actDesp.LeaveEventExecuteServices.Clear();
                actDesp.LeaveEventExecuteServices.CopyFrom(svcOperationDef);
            }

            if (dictionary.ContainsKey("WithdrawExecuteServices"))
            {
                WfServiceOperationDefinitionCollection svcOperationDef =
                    JSONSerializerExecute.Deserialize <WfServiceOperationDefinitionCollection>(dictionary["WithdrawExecuteServices"]);
                actDesp.WithdrawExecuteServices.Clear();
                actDesp.WithdrawExecuteServices.CopyFrom(svcOperationDef);
            }

            if (dictionary.ContainsKey("BeWithdrawnExecuteServices"))
            {
                WfServiceOperationDefinitionCollection svcOperationDef =
                    JSONSerializerExecute.Deserialize <WfServiceOperationDefinitionCollection>(dictionary["BeWithdrawnExecuteServices"]);
                actDesp.BeWithdrawnExecuteServices.Clear();
                actDesp.BeWithdrawnExecuteServices.CopyFrom(svcOperationDef);
            }

            return(actDesp);
        }
        private static IWfActivityDescriptor CreateNormalDescriptor(string key, string name)
        {
            WfActivityDescriptor activityDesp = new WfActivityDescriptor(key, WfActivityType.NormalActivity);

            activityDesp.Name = name;
            activityDesp.CodeName = key;

            return activityDesp;
        }
Пример #47
0
        /// <summary>
        /// 创建一个有多个节点的流程
        /// </summary>
        /// <returns></returns>
        public static IWfProcessDescriptor CreateProcessDescriptor()
        {
            WfProcessDescriptor processDesp = new WfProcessDescriptor();

            processDesp.Key = "TestProcess" + UuidHelper.NewUuidString().Substring(0, 8);
            processDesp.Name = "测试流程";
            processDesp.ApplicationName = "TEST_APP_NAME";
            processDesp.ProgramName = "TEST_PROGRAM_NAME";
            processDesp.Url = "/MCS_Framework/WebTestProject/defaultHandler.aspx";

            WfActivityDescriptor initAct = new WfActivityDescriptor("Initial", WfActivityType.InitialActivity);
            initAct.Name = "Initial";
            initAct.CodeName = "Initial Activity";

            processDesp.Activities.Add(initAct);

            WfActivityDescriptor normalAct = new WfActivityDescriptor("NormalActivity", WfActivityType.NormalActivity);
            normalAct.Name = "Normal";
            normalAct.CodeName = "Normal Activity";

            processDesp.Activities.Add(normalAct);

            WfActivityDescriptor normalAct1 = new WfActivityDescriptor("NormalActivity1", WfActivityType.NormalActivity);
            normalAct1.Name = "Normal";
            normalAct1.CodeName = "Normal Activity1";

            processDesp.Activities.Add(normalAct1);

            WfActivityDescriptor normalAct2 = new WfActivityDescriptor("NormalActivity2", WfActivityType.NormalActivity);
            normalAct2.Name = "Normal";
            normalAct2.CodeName = "Normal Activity2";

            processDesp.Activities.Add(normalAct2);

            WfActivityDescriptor normalAct3 = new WfActivityDescriptor("NormalActivity3", WfActivityType.NormalActivity);
            normalAct3.Name = "Normal";
            normalAct3.CodeName = "Normal Activity3";

            processDesp.Activities.Add(normalAct3);

            WfActivityDescriptor completedAct = new WfActivityDescriptor("Completed", WfActivityType.CompletedActivity);
            completedAct.Name = "Completed";
            completedAct.CodeName = "Completed Activity";

            processDesp.Activities.Add(completedAct);

            initAct.ToTransitions.AddForwardTransition(normalAct);
            normalAct.ToTransitions.AddForwardTransition(normalAct1);
            normalAct1.ToTransitions.AddForwardTransition(normalAct2);
            normalAct2.ToTransitions.AddForwardTransition(normalAct3);
            normalAct3.ToTransitions.AddForwardTransition(completedAct);

            return processDesp;
        }
Пример #48
0
        /// <summary>
        /// 在某个活动下 的同级添加一组活动
        /// </summary>
        /// <param name="desp"></param>
        /// <param name="n">添加的个数</param>
        private static void AddActivitiesDespToSameActivityDesp(IWfActivityDescriptor actDesp, int n)
        {
            IWfActivityDescriptor toActDesp = actDesp.ToTransitions[0].ToActivity;
            actDesp.ToTransitions.Clear();

            for (int i = 7; i < 7 + n; i++)
            {
                WfActivityDescriptor normalAct = new WfActivityDescriptor("NormalActivity" + i, WfActivityType.NormalActivity);
                normalAct.Name = "Normal" + i;
                normalAct.CodeName = "Normal Activity" + i;

                actDesp.Process.Activities.Add(normalAct);

                actDesp.ToTransitions.AddForwardTransition(normalAct);
                normalAct.ToTransitions.AddForwardTransition(toActDesp);
            }
        }
Пример #49
0
        /// <summary>
        /// 根据WfCreateActivityParamCollection的值创建节点,覆盖当前的流程
        /// </summary>
        /// <param name="capc"></param>
        /// <param name="overrideInitActivity"></param>
        public void CreateActivities(WfCreateActivityParamCollection capc, bool overrideInitActivity)
        {
            WfActivityDescriptor currentActDesp = (WfActivityDescriptor)this.InitialActivity;

            capc.CreateActivities(this, overrideInitActivity);
        }
		/// <summary>
		/// 准备管理单元相关的模板
		/// </summary>
		/// <returns></returns>
		private IWfActivityDescriptor PrepareAURelativeActivityDescriptor(string key)
		{
			WfActivityDescriptor templateActDesp = new WfActivityDescriptor(key, WfActivityType.NormalActivity);
			templateActDesp.Name = "审批";
			templateActDesp.CodeName = key;
			templateActDesp.Properties.SetValue("IsDynamic", true);

			WrappedAUSchemaRole role = new WrappedAUSchemaRole(AUHelper.AUSchemaActivityMatrixRoleID) { Name = "实物管理员", Description = "实物管理员" };

			WfAURoleResourceDescriptor roleDesp = new WfAURoleResourceDescriptor(role);

			templateActDesp.Resources.Add(roleDesp);

			return templateActDesp;
		}
		public void WfActivitySerilizeConverterTest()
		{
			WfConverterHelper.RegisterConverters();

			WfActivityDescriptor normalAct = new WfActivityDescriptor("NormalActivity", WfActivityType.NormalActivity);
			normalAct.Name = "Normal";
			normalAct.CodeName = "Normal Activity";

			WfServiceOperationDefinition enterSvcDef = new WfServiceInvokerFactory().SvcOpDef;
			enterSvcDef.AddressDef.RequestMethod = WfServiceRequestMethod.Get;
			enterSvcDef.OperationName = "StringTypeService";
			enterSvcDef.RtnXmlStoreParamName = "EnterServiceRtnXml";

			enterSvcDef.Params.Add(new WfServiceOperationParameter()
			{
				Name = "input",
				Type = WfSvcOperationParameterType.String,
				Value = "this is a get action!"
			});

			normalAct.EnterEventExecuteServices.Add(enterSvcDef);

			string result = JSONSerializerExecute.Serialize(normalAct);

			Console.WriteLine(result);

			WfActivityDescriptor deserializedActDesp = JSONSerializerExecute.Deserialize<WfActivityDescriptor>(result);

			string reSerialized = JSONSerializerExecute.Serialize(deserializedActDesp);

			Assert.AreEqual(result, reSerialized);
		}
		/// <summary>
		/// 准备流程
		/// </summary>
		private void PrepareProcess()
		{
			string returnUrl = Request.QueryString.GetValue("ru", string.Empty);

			WfProcessDescriptor processDesp = new WfProcessDescriptor();

			processDesp.Key = UuidHelper.NewUuidString();
			processDesp.Name = "自由流程";
			processDesp.ApplicationName = "秘书服务";
			processDesp.ProgramName = "部门通知";
			processDesp.Url = returnUrl;
			processDesp.DefaultTaskTitle = "${Subject}$";

			WfActivityDescriptor initDesp = new WfActivityDescriptor("Initial", WfActivityType.InitialActivity);
			initDesp.Name = "起草";
			initDesp.CodeName = "Initial Activity";
			initDesp.Properties.SetValue("AutoSendUserTask", false);

			processDesp.Activities.Add(initDesp);

			processDesp.Activities.Add(PrepareAURelativeActivityDescriptor(processDesp.FindNotUsedActivityKey()));

			WfActivityDescriptor completedActDesp = new WfActivityDescriptor("Completed", WfActivityType.CompletedActivity);
			completedActDesp.Name = "完成";
			completedActDesp.CodeName = "Completed Activity";

			processDesp.Activities.Add(completedActDesp);

			for (int i = 0; i < processDesp.Activities.Count - 1; i++)
			{
				processDesp.Activities[i].ToTransitions.AddForwardTransition(processDesp.Activities[i + 1]);
			}

			WfProcessStartupParams startupParams = new WfProcessStartupParams();

			startupParams.ApplicationRuntimeParameters["AdministrativeUnit"] = "Group";
			startupParams.ApplicationRuntimeParameters["Amount"] = "";
			startupParams.ApplicationRuntimeParameters["CostCenter"] = "1001";
			startupParams.ProcessDescriptor = processDesp;
			startupParams.Creator = DeluxeIdentity.CurrentUser;
			startupParams.Assignees.Add(DeluxeIdentity.CurrentUser);
			startupParams.DefaultTaskTitle = "${Subject}$";
			startupParams.ResourceID = UuidHelper.NewUuidString();
			startupParams.Department = DeluxeIdentity.CurrentUser.Parent;

			string relativeParams = Request.QueryString["relativeParams"];

			if (relativeParams.IsNotEmpty())
				startupParams.RelativeParams.CopyFrom(UriHelper.GetUriParamsCollection(relativeParams));

			WfStartWorkflowExecutor executor = new WfStartWorkflowExecutor(WfClientContext.Current.OriginalActivity, startupParams);

			executor.AfterModifyWorkflow += new ExecutorEventHandler(executor_AfterModifyWorkflow);
			executor.Execute();

			IWfProcess process = WfClientContext.Current.OriginalActivity.Process;

			returnUrl = UriHelper.RemoveUriParams(returnUrl, "relativeParams");

			HttpContext.Current.Response.Redirect(string.Format("{0}?resourceID={1}&activityID={2}",
				returnUrl, process.ResourceID, process.CurrentActivity.ID));
		}
        public override object Deserialize(IDictionary <string, object> dictionary, Type type, System.Web.Script.Serialization.JavaScriptSerializer serializer)
        {
            //WfProcessDescriptor processDesp = (WfProcessDescriptor)base.Deserialize(dictionary, type, serializer);
            #region "base Deserialize"
            string key = DictionaryHelper.GetValue(dictionary, "Key", string.Empty);
            WfProcessDescriptor processDesp = (WfProcessDescriptor)CreateInstance(key, dictionary, type, serializer);
            processDesp.Name        = DictionaryHelper.GetValue(dictionary, "Name", string.Empty);;
            processDesp.Enabled     = DictionaryHelper.GetValue(dictionary, "Enabled", false);
            processDesp.Description = DictionaryHelper.GetValue(dictionary, "Description", string.Empty);

            Dictionary <string, object> processProperties = new Dictionary <string, object>();
            Dictionary <string, Type>   constKey          = new Dictionary <string, Type>();
            constKey.Add("RelativeLinks", typeof(WfRelativeLinkDescriptorCollection));
            constKey.Add("CancelEventReceivers", typeof(WfResourceDescriptorCollection));
            constKey.Add("CompleteEventReceivers", typeof(WfResourceDescriptorCollection));
            constKey.Add("InternalRelativeUsers", typeof(WfResourceDescriptorCollection));
            constKey.Add("ExternalUsers", typeof(WfExternalUserCollection));
            constKey.Add("Variables", typeof(WfVariableDescriptorCollection));
            constKey.Add("ParametersNeedToBeCollected", typeof(WfParameterNeedToBeCollected));

            constKey.Add("CancelBeforeExecuteServices", typeof(WfServiceOperationDefinitionCollection));
            constKey.Add("CancelAfterExecuteServices", typeof(WfServiceOperationDefinitionCollection));

            if (dictionary.ContainsKey("Properties"))
            {
                PropertyValueCollection properties = JSONSerializerExecute.Deserialize <PropertyValueCollection>(dictionary["Properties"]);
                properties.Remove(p => string.Compare(p.Definition.Name, "ImportWfMatrix") == 0);
                processDesp.Properties.Clear();
                foreach (PropertyValue pv in properties)
                {
                    if (constKey.ContainsKey(pv.Definition.Name))
                    {
                        var objValue = JSONSerializerExecute.DeserializeObject(pv.StringValue, constKey[pv.Definition.Name]);
                        processProperties.Add(pv.Definition.Name, objValue);
                    }
                    else
                    {
                        processDesp.Properties.Add(pv);
                    }
                }
            }
            #endregion

            processDesp.GraphDescription = DictionaryHelper.GetValue(dictionary, "GraphDescription", string.Empty);

            WfActivityDescriptorCollection activities = JSONSerializerExecute.Deserialize <WfActivityDescriptorCollection>(dictionary["Activities"]);
            processDesp.Activities.Clear();
            processDesp.Activities.CopyFrom(activities);

            ClearAllProperties(processDesp);
            SetProcessProperties(processDesp, processProperties, dictionary);

            ToTransitionsDescriptorCollection transitions = JSONSerializerExecute.Deserialize <ToTransitionsDescriptorCollection>(dictionary["Transitions"]);

            foreach (WfTransitionDescriptor tranDesp in transitions)
            {
                WfActivityDescriptor fromActDesc = (WfActivityDescriptor)processDesp.Activities[tranDesp.FromActivityKey];
                WfActivityDescriptor toActDesc   = (WfActivityDescriptor)processDesp.Activities[tranDesp.ToActivityKey];

                if (fromActDesc != null && toActDesc != null)
                {
                    fromActDesc.ToTransitions.AddTransition(toActDesc, tranDesp);
                }
            }

            return(processDesp);
        }
        private IWfActivityDescriptor CreateClonedActivityDescriptor(IWfProcess processInstance, WfCopyMainStreamContext context, WfControlOperationType operationType)
        {
            WfActivityDescriptor result = this.TemplateActivityDescriptor.Clone() as WfActivityDescriptor;

            result.Key = processInstance.Descriptor.FindNotUsedActivityKey();

            //2012/12/03 修改克隆时向开始环节转换时需要设置的属性
            if (this.TemplateActivityDescriptor.ActivityType == WfActivityType.InitialActivity && operationType == WfControlOperationType.Return)
            {
                ResetPropertiesByDefinedName(result, "DefaultReturnToInitialActivityTemplate");
            }

            //如果模板活动不是主线活动,则使用该活动的关联Key,否则去实例上查找主线活动对应活动的关联Key。
            if (this.TemplateActivityDescriptor.IsMainStreamActivity == false)
            {
                result.AssociatedActivityKey = this.TemplateActivityDescriptor.GetAssociatedActivity().Key;

                result.ClonedKey = this.TemplateActivityDescriptor.Key;
            }
            else
            {
                IWfActivityDescriptor matchActDesp = FindActivityDescriptorByMainStreamKey(processInstance, this.TemplateActivityDescriptor.Key);

                if (matchActDesp != null)
                {
                    result.AssociatedActivityKey = matchActDesp.Key;

                    result.ClonedKey = matchActDesp.Key;
                }
            }

            //如果原来活动上没有配置资源,则使用原来活动实例的指派人作为资源
            if (result.Resources.Count == 0)
            {
                result.Resources.CopyFrom(this.TemplateActivityDescriptor.Instance.Assignees.ToResources());
            }

            WfActivityBase newActivity = WfActivityBase.CreateActivityInstance(result, processInstance);

            if (context.IsMainStream)
            {
                newActivity.MainStreamActivityKey = this.TemplateActivityDescriptor.Key;
            }

            //沈峥调整,生成资源
            if (result.Resources.Count == 0)
            {
                newActivity.Candidates.CopyFrom(this.TemplateActivityDescriptor.Instance.Candidates);

                if (newActivity.Candidates.Count == 0)
                {
                    IWfActivityDescriptor matchActDesp = FindActivityDescriptorByMainStreamKey(processInstance, this.TemplateActivityDescriptor.Key);

                    if (matchActDesp != null && OguBase.IsNotNullOrEmpty(matchActDesp.Instance.Operator))
                    {
                        newActivity.Candidates.Add(matchActDesp.Instance.Operator);
                    }
                }

                newActivity.Assignees.CopyFrom(newActivity.Candidates);
            }
            else
            {
                if (newActivity.Descriptor.Properties.GetValue("AutoGenerateCadidates", true))
                {
                    newActivity.GenerateCandidatesFromResources();
                    newActivity.Assignees.Clear();
                    newActivity.Assignees.CopyFrom(newActivity.Candidates);
                }
                else
                {
                    newActivity.Candidates.Clear();
                    newActivity.Assignees.Clear();

                    //仅复制能够和直接转换为用户的角色
                    foreach (IUser user in result.Resources.ToUsers())
                    {
                        newActivity.Candidates.Add(user);
                        newActivity.Assignees.Add(user);
                    }
                }
            }

            processInstance.Descriptor.Activities.Add(result);

            return(result);
        }