public void AddProcessDefinition(Guid schemeId, ProcessDefinition processDefinition)
{
if (this._cache == null)
{
this._cache = new Dictionary<Guid, ProcessDefinition>()
{
{ schemeId, processDefinition }
};
}
else if (!this._cache.ContainsKey(schemeId))
{
this._cache.Add(schemeId, processDefinition);
}
else
{
this._cache[schemeId] = processDefinition;
}
int maxNumberOfSchemes = Licensing.GetLicenseRestrictions<WorkflowEngineNetRestrictions>().MaxNumberOfSchemes;
if (maxNumberOfSchemes > 0)
{
if ((
from pi in this._cache.Values
group pi by pi.Name).Count<IGrouping<string, ProcessDefinition>>() > maxNumberOfSchemes)
{
throw new LicenseException(string.Format("Maximum number of schemes for your license {0}.", maxNumberOfSchemes));
}
}
}
private static void AddActivitiesAndTransitions(ProcessDefinition processDefinition, List<ActivityDefinition> activities, List<TransitionDefinition> transitions, TransitionDefinition startingTransition, List<string> finalActivities, int cutoffNestingLevel)
{
if (transitions.Any<TransitionDefinition>((TransitionDefinition t) => t.Name.Equals(startingTransition.Name, StringComparison.InvariantCulture)))
{
return;
}
ActivityDefinition to = startingTransition.To;
if (startingTransition.ForkType == TransitionForkType.ForkEnd)
{
int? nestingLevel = to.NestingLevel;
if ((nestingLevel.GetValueOrDefault() > cutoffNestingLevel ? false : nestingLevel.HasValue))
{
TransitionDefinition transitionDefinition = startingTransition.Clone() as TransitionDefinition;
transitionDefinition.IsFork = false;
transitions.Add(transitionDefinition);
if (!activities.Any<ActivityDefinition>((ActivityDefinition a) => a.Name.Equals(to.Name, StringComparison.InvariantCulture)))
{
ActivityDefinition activityDefinition = ActivityDefinition.Create(to.Name, to.State, false, true, false, false);
activities.Add(activityDefinition);
finalActivities.Add(to.Name);
}
return;
}
}
transitions.Add(startingTransition);
if (!activities.Any<ActivityDefinition>((ActivityDefinition a) => a.Name.Equals(to.Name, StringComparison.InvariantCulture)))
{
activities.Add(to.Clone() as ActivityDefinition);
}
foreach (TransitionDefinition possibleTransitionsForActivity in processDefinition.GetPossibleTransitionsForActivity(startingTransition.To, ForkTransitionSearchType.Both))
{
SubprocessUtils.AddActivitiesAndTransitions(processDefinition, activities, transitions, possibleTransitionsForActivity, finalActivities, cutoffNestingLevel);
}
}
internal StartingTransitionNotFoundEventArgs(Guid processId, Guid rootProcessId, ProcessDefinition oldRootScheme, ProcessDefinition newRootScheme, string oldTransitionName)
{
this.ProcessId = processId;
this.RootProcessId = rootProcessId;
this.OldRootScheme = oldRootScheme;
this.NewRootScheme = newRootScheme;
this.OldTransitionName = oldTransitionName;
}
public override void RegisterFinal(ProcessDefinition pd, List<WorkflowBlock> blocks)
{
base.RegisterFinal(pd, 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);
ParameterDefinition pdParameterComment = pd.Parameters.Where(p=> p.Name == "Comment").FirstOrDefault();
if(pdParameterComment == null)
{
pdParameterComment = ParameterDefinition.Create("Comment", typeof(string), ParameterPurpose.Temporary, null);
pd.Parameters.Add(pdParameterComment);
}
pdCommand.InputParameters.Add(new ParameterDefinitionReference()
{
Name = "Comment",
Parameter = pdParameterComment
});
pd.Commands.Add(pdCommand);
}
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
});
}
}
}
public void AddProcessDefinition(Guid schemeId, ProcessDefinition processDefinition)
{
if (_cache == null)
{
_cache = new Dictionary<Guid, ProcessDefinition> {{schemeId, processDefinition}};
}
else
{
if (_cache.ContainsKey(schemeId))
_cache[schemeId] = processDefinition;
else
_cache.Add(schemeId, processDefinition);
}
}
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;
}
}
/// <summary>
/// 获取审批流程实例中系统定义的缺省参数及参数值(DefaultDefinitions中定义)
/// </summary>
/// <param name="processId"></param>
/// <param name="processDefinition"></param>
/// <returns></returns>
private IEnumerable<ParameterDefinitionWithValue> GetSystemProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
WorkflowProcessInstance processInstance = this.GetProcessInstance(processId);
List<ParameterDefinition> source = (
from p in processDefinition.Parameters
where p.Purpose == ParameterPurpose.System
select p).ToList<ParameterDefinition>();
var list = new List<ParameterDefinitionWithValue>(source.Count<ParameterDefinition>());
list.Add(ParameterDefinition.Create(source.Single((ParameterDefinition sp) => sp.Name == DefaultDefinitions.ParameterProcessId.Name), processId));
list.Add(ParameterDefinition.Create(source.Single((ParameterDefinition sp) => sp.Name == DefaultDefinitions.ParameterPreviousState.Name), (object)processInstance.PreviousState));
list.Add(ParameterDefinition.Create(source.Single((ParameterDefinition sp) => sp.Name == DefaultDefinitions.ParameterCurrentState.Name), (object)processInstance.StateName));
list.Add(ParameterDefinition.Create(source.Single((ParameterDefinition sp) => sp.Name == DefaultDefinitions.ParameterPreviousStateForDirect.Name), (object)processInstance.PreviousStateForDirect));
list.Add(ParameterDefinition.Create(source.Single((ParameterDefinition sp) => sp.Name == DefaultDefinitions.ParameterPreviousStateForReverse.Name), (object)processInstance.PreviousStateForReverse));
list.Add(ParameterDefinition.Create(source.Single((ParameterDefinition sp) => sp.Name == DefaultDefinitions.ParameterPreviousActivity.Name), (object)processInstance.PreviousActivity));
list.Add(ParameterDefinition.Create(source.Single((ParameterDefinition sp) => sp.Name == DefaultDefinitions.ParameterCurrentActivity.Name), (object)processInstance.ActivityName));
list.Add(ParameterDefinition.Create(source.Single((ParameterDefinition sp) => sp.Name == DefaultDefinitions.ParameterPreviousActivityForDirect.Name), (object)processInstance.PreviousActivityForDirect));
list.Add(ParameterDefinition.Create(source.Single((ParameterDefinition sp) => sp.Name == DefaultDefinitions.ParameterPreviousActivityForReverse.Name), (object)processInstance.PreviousActivityForReverse));
return list;
}
private IEnumerable<ParameterDefinitionWithValue> GetProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
List<ParameterDefinitionWithValue> list = new List<ParameterDefinitionWithValue>(processDefinition.Parameters.Count<ParameterDefinition>());
list.AddRange(this.GetPersistedProcessParameters(processId, processDefinition));
list.AddRange(this.GetSystemProcessParameters(processId, processDefinition));
return list;
}
private IEnumerable<ParameterDefinitionWithValue> GetPersistedProcessParameters(Guid processId, ProcessDefinition processDefinition)
{
List<ParameterDefinition> persistenceParameters = processDefinition.PersistenceParameters.ToList<ParameterDefinition>();
List<ParameterDefinitionWithValue> list = new List<ParameterDefinitionWithValue>(persistenceParameters.Count<ParameterDefinition>());
List<WorkflowProcessInstancePersistence> list2;
using (PredefinedTransactionScopes.ReadUncommittedSupressedScope)
{
using (WorkflowPersistenceModelDataContext workflowPersistenceModelDataContext = base.CreateContext())
{
list2 = (
from wpip in workflowPersistenceModelDataContext.WorkflowProcessInstancePersistences
where wpip.ProcessId == processId && (
from pp in persistenceParameters
select pp.Name).Contains(wpip.ParameterName)
select wpip).ToList<WorkflowProcessInstancePersistence>();
}
}
foreach (WorkflowProcessInstancePersistence persistedParameter in list2)
{
ParameterDefinition parameterDefinition = persistenceParameters.Single((ParameterDefinition p) => p.Name == persistedParameter.ParameterName);
list.Add(ParameterDefinition.Create(parameterDefinition, this.DeserializeParameter(persistedParameter.Value, parameterDefinition.Type)));
}
return list;
}
private static ProcessDefinition InitializeProcessDefinition(this WorkflowRuntime runtime, string schemecode, string schemeid, string processid)
{
ProcessDefinition processScheme = null;
if (!string.IsNullOrWhiteSpace(processid))
{
ProcessInstance processInstance = runtime.Builder.GetProcessInstance(new Guid(processid));
runtime.PersistenceProvider.FillSystemProcessParameters(processInstance);
processScheme = processInstance.ProcessScheme.Clone() as ProcessDefinition;
processScheme.AdditionalParams.Clear();
if (!processScheme.AdditionalParams.ContainsKey("ProcessParameters"))
{
processScheme.AdditionalParams.Add("ProcessParameters", processInstance.ProcessParameters);
}
}
else if (!string.IsNullOrWhiteSpace(schemeid))
{
processScheme = runtime.Builder.GetProcessScheme(new Guid(schemeid));
processScheme.AdditionalParams.Clear();
}
else if (string.IsNullOrEmpty(schemecode))
{
processScheme = new ProcessDefinition();
}
else
{
processScheme = runtime.Builder.GetProcessSchemeForDesigner(schemecode);
processScheme.AdditionalParams.Clear();
}
Designer.InitializeAdditionalParams(runtime, processScheme);
return processScheme;
}
private static void InitializeAdditionalParams(WorkflowRuntime runtime, ProcessDefinition pd)
{
if (!pd.AdditionalParams.ContainsKey("Rules"))
{
pd.AdditionalParams.Add("Rules", runtime.RuleProvider.GetRules());
}
if (!pd.AdditionalParams.ContainsKey("TimerTypes"))
{
pd.AdditionalParams.Add("TimerTypes",
from TimerType t in Enum.GetValues(typeof(TimerType))
select t.ToString());
}
if (!pd.AdditionalParams.ContainsKey("Actions"))
{
pd.AdditionalParams.Add("Actions", runtime.ActionProvider.GetActions());
}
if (!pd.AdditionalParams.ContainsKey("Namespaces"))
{
pd.AdditionalParams.Add("Usings", CodeActionsCompiller.Usings);
}
}
private void UpdateChildrenSchemes(ProcessInstancesTree currentNode, ProcessDefinition oldRootScheme, ProcessDefinition newRootScheme, List<SchemaWasChangedEventArgs> changes)
{
if (!currentNode.Children.Any<ProcessInstancesTree>())
{
return;
}
foreach (ProcessInstancesTree child in currentNode.Children)
{
ProcessInstance processInstance = this.Builder.GetProcessInstance(child.Id);
bool flag = false;
try
{
this.SetProcessNewStatus(processInstance, ProcessStatus.Running);
this.PersistenceProvider.FillSystemProcessParameters(processInstance);
if (processInstance.CurrentActivity.IsAutoSchemeUpdate)
{
TransitionDefinition transitionDefinition = null;
try
{
transitionDefinition = newRootScheme.FindTransition(child.Name);
}
catch (TransitionNotFoundException transitionNotFoundException)
{
}
if (transitionDefinition != null)
{
ProcessDefinition processDefinition = this.Builder.CreateNewSubprocessScheme(newRootScheme, transitionDefinition);
this.BindProcessToNewScheme(processInstance, processDefinition, changes);
}
else if (this.OnStartingTransitionNotFound == null)
{
this.DropProcesses(new List<Guid>()
{
processInstance.ProcessId
}, currentNode);
flag = true;
continue;
}
else
{
StartingTransitionNotFoundEventArgs startingTransitionNotFoundEventArg = new StartingTransitionNotFoundEventArgs(processInstance.ProcessId, processInstance.RootProcessId, oldRootScheme, newRootScheme, child.Name);
this.OnStartingTransitionNotFound(this, startingTransitionNotFoundEventArg);
if (startingTransitionNotFoundEventArg.Decision == StartingTransitionNotFoundEventArgs.SubprocessUpdateDecision.DropProcess)
{
this.DropProcesses(new List<Guid>()
{
processInstance.ProcessId
}, currentNode);
flag = true;
continue;
}
else if (startingTransitionNotFoundEventArg.Decision == StartingTransitionNotFoundEventArgs.SubprocessUpdateDecision.Ignore)
{
continue;
}
else if (startingTransitionNotFoundEventArg.Decision == StartingTransitionNotFoundEventArgs.SubprocessUpdateDecision.StartWithNewTransition)
{
transitionDefinition = newRootScheme.FindTransition(startingTransitionNotFoundEventArg.NewTransitionName);
ProcessDefinition processDefinition1 = this.Builder.CreateNewSubprocessScheme(newRootScheme, transitionDefinition);
this.BindProcessToNewScheme(processInstance, processDefinition1, changes);
}
}
}
this.UpdateChildrenSchemes(child, oldRootScheme, newRootScheme, changes);
}
finally
{
if (!flag)
{
this.SetIdledStatusAfterSchemaUpdated(processInstance);
}
}
}
}
private void BindProcessToNewScheme(ProcessInstance processInstance, ProcessDefinition updatedProcessScheme, List<SchemaWasChangedEventArgs> changes)
{
bool ısSchemeObsolete = processInstance.IsSchemeObsolete;
bool ısDeterminingParametersChanged = processInstance.IsDeterminingParametersChanged;
processInstance.SchemeId = updatedProcessScheme.Id;
processInstance.IsSchemeObsolete = false;
processInstance.IsDeterminingParametersChanged = false;
processInstance.ProcessScheme = updatedProcessScheme;
this.PersistenceProvider.BindProcessToNewScheme(processInstance, true);
SchemaWasChangedEventArgs schemaWasChangedEventArg = new SchemaWasChangedEventArgs()
{
DeterminingParametersWasChanged = ısDeterminingParametersChanged,
ProcessId = processInstance.ProcessId,
SchemeId = processInstance.SchemeId,
SchemaWasObsolete = ısSchemeObsolete
};
changes.Add(schemaWasChangedEventArg);
processInstance.SchemeId = updatedProcessScheme.Id;
processInstance.IsSchemeObsolete = false;
processInstance.IsDeterminingParametersChanged = false;
processInstance.ProcessScheme = updatedProcessScheme;
this.PersistenceProvider.BindProcessToNewScheme(processInstance, true);
}
public static ProcessInstance Create(Guid schemeId, Guid processId, ProcessDefinition processScheme, bool isSchemeObsolete, bool isDeterminingParametersChanged)
{
return new ProcessInstance() {SchemeId = schemeId, ProcessId = processId, ProcessScheme = processScheme, IsSchemeObsolete = isSchemeObsolete, IsDeterminingParametersChanged = isDeterminingParametersChanged};
}
public override void Register(ProcessDefinition pd, List<WorkflowBlock> blocks)
{
base.Register(pd, blocks);
var actor = ActorDefinition.Create(string.Format("LegalEntitySigns_{0}", Name), "BudgetItemIsLegalEntityNeedSigns", Name);
pd.Actors.Add(actor);
this["_actorRestrictions"] = actor;
}
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
});
}
}
}
}
public static WorkflowCommand Create(Guid processId, TransitionDefinition transitionDefinition, ProcessDefinition processDefinition)
{
if (transitionDefinition.Trigger.Type != TriggerType.Command || transitionDefinition.Trigger.Command == null)
{
throw new InvalidOperationException();
}
List<CommandParameter> commandParameters = new List<CommandParameter>(transitionDefinition.Trigger.Command.InputParameters.Count);
commandParameters.AddRange(
from p in transitionDefinition.Trigger.Command.InputParameters
select new CommandParameter()
{
ParameterName = p.Name,
TypeName = p.Parameter.Type.AssemblyQualifiedName,
LocalizedName = processDefinition.GetLocalizedParameterName(p.Name, CultureInfo.CurrentCulture),
Value = null
});
WorkflowCommand workflowCommand = new WorkflowCommand()
{
CommandName = transitionDefinition.Trigger.Command.Name,
LocalizedName = processDefinition.GetLocalizedCommandName(transitionDefinition.Trigger.Command.Name, CultureInfo.CurrentCulture),
Parameters = commandParameters,
ProcessId = processId,
ValidForActivityName = transitionDefinition.From.Name,
ValidForStateName = transitionDefinition.From.State,
Classifier = transitionDefinition.Classifier
};
return workflowCommand;
}
public static CodeActionsInvoker CompileCodeActions(ProcessDefinition processDefinition, Guid schemeId)
{
List<CodeActionDefinition> codeActions = processDefinition.CodeActions;
if (!codeActions.Any<CodeActionDefinition>())
{
return new CodeActionsInvoker();
}
string str = string.Format("CodeActions_{0}_{1}", processDefinition.Name, schemeId.ToString("N"));
return CodeActionsCompiller.CodeActionsInvoker(str, codeActions);
}
public static ProcessDefinition Create(string name, List<ActorDefinition> actors, List<ParameterDefinition> parameters, List<CommandDefinition> commands, List<TimerDefinition> timers, List<ActivityDefinition> activities, List<TransitionDefinition> transitions, List<LocalizeDefinition> localization, List<CodeActionDefinition> codeActions, OptimaJet.Workflow.Core.Model.DesignerSettings designerSettigs)
{
ProcessDefinition processDefinition = new ProcessDefinition()
{
Activities = activities,
Actors = actors,
Commands = commands,
Timers = timers,
Name = name,
Parameters = parameters,
Transitions = transitions,
Localization = localization,
CodeActions = codeActions,
DesignerSettings = designerSettigs
};
return processDefinition;
}
