Beispiel #1
0
        public WfActivityBase CreateActivity(IWfActivityDescriptor actDesp)
        {
            WfActivityBase activity = CreateActivityInstance(actDesp);

            LoadActions(activity);

            return(activity);
        }
Beispiel #2
0
        public static WfActivityBase CreateActivityInstance(IWfActivityDescriptor actDesp, IWfProcess process)
        {
            WfActivityBase act = WfActivitySettings.GetConfig().GetActivityBuilder(actDesp).CreateActivity(actDesp);

            act.Process = process;
            process.Activities.Add(act);

            act.CreatorInstanceID = WfRuntime.ProcessContext.ActivityChangingContext.CreatorInstanceID;

            return(act);
        }
        protected override IWfActivity PrepareInstanceActivity()
        {
            ExceptionHelper.TrueThrow(this.TargetActivity.Descriptor.ActivityType == WfActivityType.CompletedActivity, "不能在结束活动后添加活动");

            IWfProcess            process    = this.TargetActivity.Process;
            IWfActivityDescriptor newActDesp = PrepareActivityDescriptor(this.TargetActivity.Descriptor);

            IWfActivity newActivity = WfActivityBase.CreateActivityInstance(newActDesp, process);

            if (WfRuntime.ProcessContext != null)
            {
                WfRuntime.ProcessContext.AffectedProcesses.AddOrReplace(process);
            }

            this.AddedActivity = newActivity;

            return(newActivity);
        }
Beispiel #4
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 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);
        }
Beispiel #6
0
 /// <summary>
 /// 将Activity中的Assignees填充到Acl中
 /// </summary>
 /// <param name="resourceID"></param>
 /// <param name="nextActivity"></param>
 private static void FillAclInContext(string resourceID, WfActivityBase nextActivity)
 {
     if (resourceID.IsNotEmpty())
     {
         WfAclItemCollection acl = nextActivity.Assignees.ToAcl(resourceID, nextActivity.ID);
         WfRuntime.ProcessContext.Acl.CopyFrom(acl);
     }
 }
Beispiel #7
0
 /// <summary>
 /// 准备下一步的Assignees
 /// </summary>
 /// <param name="nextActivity"></param>
 /// <param name="transferParams"></param>
 private void PrepareActivityAssigneesFromTransferParams(WfActivityBase nextActivity, WfTransferParams transferParams)
 {
     nextActivity.Assignees.Clear();
     nextActivity.Assignees.CopyFrom(transferParams.Assignees);
     nextActivity.Assignees.CopyFrom(GetDelegatedAssignees(transferParams.Assignees, this));
     nextActivity.Assignees.Distinct((a1, a2) => string.Compare(a1.User.ID, a2.User.ID, true) == 0 && a1.AssigneeType == a2.AssigneeType);
 }
Beispiel #8
0
        /// <summary>
        /// 流转时,设置目标节点的状态,包括启动分支流程等操作。
        /// </summary>
        /// <param name="nextActivity"></param>
        /// <param name="transferParams"></param>
        private void ExecuteNextActivityActionsAndSetStatus(WfActivityBase nextActivity, WfTransferParams transferParams)
        {
            PrepareActivityAssigneesFromTransferParams(nextActivity, transferParams);

            CalculateActivityCompleteTime(nextActivity.Descriptor);

            FillAclInContext(this.SearchID, nextActivity);

            //启动分支流程
            transferParams.BranchTransferParams.ForEach(b => nextActivity.StartupBranchProcesses(b));

            if (transferParams.BranchTransferParams.Count == 0 &&
                    WfRuntime.ProcessContext.TargetActivityCanMoveTo &&
                    nextActivity.Descriptor.IsConditionActivity == false)
            {
                nextActivity.Status = WfActivityStatus.Running;
            }
            else
            {
                nextActivity.Status = WfActivityStatus.Pending;
            }

            WfRuntime.ProcessContext.ResetContextByProcess(this);
            RegisterAndPrepareActions(nextActivity.EnterActions);

            if (nextActivity.Descriptor.ActivityType == WfActivityType.CompletedActivity)
            {
                nextActivity.Status = WfActivityStatus.Completed;

                this.Status = WfProcessStatus.Completed;
                this.EndTime = DateTime.Now;

                WfRuntime.ProcessContext.ResetContextByProcess(this);

                this._ElapsedActivities.Add(nextActivity);

                RegisterAndPrepareActions(nextActivity.LeaveActions);
                RegisterAndPrepareActions(this.CompleteProcessActions);

                ExecuteNextSerialProcess(this.EntryInfo);
            }

            SyncUrlsInAssigneesFromTasks(nextActivity, WfRuntime.ProcessContext.MoveToUserTasks);

            this.ProcessPendingActivity();
        }
        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);
        }