Ejemplo n.º 1
0
        public override void Register(ProcessDefinition pd, List <WorkflowBlock> blocks)
        {
            base.Register(pd, blocks);

            bool isFinal = this["Commands"] == null
                ? true :
                           (this["Commands"] as List <SimpleCommand>).Count == 0;

            //activity
            var c = ActivityDefinition.Create(Name, Name, TryCast <bool>("Initial", false), isFinal, true, true);

            if (c.IsInitial)
            {
                c.AddAction(ActionDefinitionReference.Create("CheckDocumentType", "0", string.Empty));
            }

            //actions
            if (this["AllowEdit"] is bool)
            {
                c.AddAction(ActionDefinitionReference.Create("SetDocumentEditable", "1", this["AllowEdit"].ToString()));
            }

            c.AddAction(ActionDefinitionReference.Create("SetDocumentState", "2", string.Empty));
            c.AddAction(ActionDefinitionReference.Create("UpdateHistory", "3", string.Empty));
            c.AddPreExecutionAction(ActionDefinitionReference.Create("WriteHistory", "0", string.Empty));

            pd.Activities.Add(c);
            this["_currentActivity"] = c;

            //actor
            var users = this["Users"] as string;

            if (!string.IsNullOrWhiteSpace(users))
            {
                var actor = ActorDefinition.Create(string.Format("Actor{0}", Name), "CheckUsers", users);
                pd.Actors.Add(actor);
                this["_actorRestrictions"] = actor;
            }
            else if (c.IsInitial)
            {
                var actor = pd.Actors.FirstOrDefault(a => a.Name == "Author");
                if (actor == null)
                {
                    actor = ActorDefinition.Create("Author", "Author", null);
                    pd.Actors.Add(actor);
                }
                this["_actorRestrictions"] = actor;
            }
        }
Ejemplo n.º 2
0
        private XElement GenerateByDesigner(dynamic entityRoute, IDictionary <string, object> parameters)
        {
            ProcessDefinition pd = Workflow.Runtime.Builder.GetProcessSchemeForDesigner(string.Format("Route_{0}", entityRoute.Id.ToString("N")));

            if (pd == null)
            {
                throw new Exception("Scheme not found for the Route. Please, check the Route");
            }

            //CheckDocument
            var initial = pd.Activities.Where(c => c.IsInitial).FirstOrDefault();

            if (!initial.Implementation.Any(c => c.ActionName == "CheckDocumentType"))
            {
                initial.AddAction(ActionDefinitionReference.Create("CheckDocumentType", "0", string.Empty));
            }

            //SetDocumentState
            foreach (var a in pd.Activities.Where(c => !string.IsNullOrWhiteSpace(c.State)))
            {
                if (!a.Implementation.Any(c => c.ActionName == "SetDocumentState"))
                {
                    a.AddAction(ActionDefinitionReference.Create("SetDocumentState", "0", string.Empty));
                }
            }

            //History
            foreach (var a in pd.Activities.Where(c => !string.IsNullOrWhiteSpace(c.State) && c.IsForSetState))
            {
                if (!a.Implementation.Any(c => c.ActionName == "UpdateHistory"))
                {
                    a.AddAction(ActionDefinitionReference.Create("UpdateHistory", "99", string.Empty));
                }
                if (!a.PreExecutionImplementation.Any(c => c.ActionName == "WriteHistory"))
                {
                    a.AddPreExecutionAction(ActionDefinitionReference.Create("WriteHistory", "99", string.Empty));
                }
            }

            return(XElement.Parse(pd.Serialize()));
        }
Ejemplo n.º 3
0
        public override void RegisterFinal(ProcessDefinition pd, List <WorkflowBlock> blocks)
        {
            //transitions
            var commands = this["Commands"] as List <SimpleCommand>;

            if (commands != null)
            {
                var restrictions = new List <RestrictionDefinition>();
                if (this["_actorRestrictions"] is ActorDefinition)
                {
                    restrictions.Add(RestrictionDefinition.Create(RestrictionType.Allow, (ActorDefinition)this["_actorRestrictions"]));
                }

                foreach (var c in commands)
                {
                    var pdCommand = pd.Commands.Where(pdc => pdc.Name == c.Name).FirstOrDefault();
                    if (pdCommand == null)
                    {
                        pdCommand = CommandDefinition.Create(c.Name);
                        pd.Commands.Add(pdCommand);
                    }

                    if (c.Classifier == TransitionClassifier.Direct)
                    {
                        //CA
                        pd.Transitions.Add(new TransitionDefinition()
                        {
                            Name       = string.Format("{0}_{1}_{2}", Name, c.ToBlock.Name, c.Name),
                            Classifier = c.Classifier,
                            From       = (ActivityDefinition)this["_currentActivity"],
                            To         = (ActivityDefinition)this["_currentActivity"],
                            Trigger    = new TriggerDefinition(TriggerType.Command)
                            {
                                Command = pdCommand
                            },
                            Conditions = new List <ConditionDefinition>()
                            {
                                ConditionDefinition.Always
                            },
                            Restrictions = restrictions
                        });

                        //AC
                        pd.Transitions.Add(new TransitionDefinition()
                        {
                            Name       = string.Format("{0}_{1}_{2}", Name, c.ToBlock.Name, "Auto"),
                            Classifier = c.Classifier,
                            From       = (ActivityDefinition)this["_currentActivity"],
                            To         = (ActivityDefinition)c.ToBlock["_currentActivity"],
                            Trigger    = new TriggerDefinition(TriggerType.Auto),
                            Conditions = new List <ConditionDefinition>()
                            {
                                ConditionDefinition.Create("Action", ActionDefinitionReference.Create("BudgetItemIsLegalEntitySignsComplete", "0", Name), "false", "true")
                            }
                        });
                    }
                    else
                    {
                        pd.Transitions.Add(new TransitionDefinition()
                        {
                            Name       = string.Format("{0}_{1}_{2}", Name, c.ToBlock.Name, c.Name),
                            Classifier = c.Classifier,
                            From       = (ActivityDefinition)this["_currentActivity"],
                            To         = (ActivityDefinition)c.ToBlock["_currentActivity"],
                            Trigger    = new TriggerDefinition(TriggerType.Command)
                            {
                                Command = pdCommand
                            },
                            Conditions = new List <ConditionDefinition>()
                            {
                                ConditionDefinition.Always
                            },
                            Restrictions = restrictions
                        });
                    }
                }
            }
        }