public IDev2Activity Parse(DynamicActivity dynamicActivity, List<IDev2Activity> seenActivities) { try { var chart = WorkflowInspectionServices.GetActivities(dynamicActivity).FirstOrDefault() as Flowchart; if (chart != null) { if (chart.StartNode == null) { return null; } var start = chart.StartNode as FlowStep; if (start != null) { var tool = ParseTools(start, seenActivities); return tool.FirstOrDefault(); } var flowstart = chart.StartNode as FlowSwitch<string>; if (flowstart != null) { return ParseSwitch(flowstart, seenActivities).FirstOrDefault(); } var flowdec = chart.StartNode as FlowDecision; return ParseDecision(flowdec, seenActivities).FirstOrDefault(); } return null; } catch (InvalidWorkflowException e) { Dev2Logger.Log.Error(e); throw; } }
private void GetVariables(DynamicActivity act) { Variables = new List<string>(); InspectActivity(act); }
public IDev2Activity Parse(DynamicActivity activity,Guid resourceIdGuid,bool failOnException=false) { if(HasActivityInCache(resourceIdGuid)) { return GetActivity(resourceIdGuid); } var dynamicActivity = activity; if (dynamicActivity != null) { try { IDev2Activity act = _activityParser.Parse(dynamicActivity); if (_cache.TryAdd(resourceIdGuid, act)) { return act; } } // ReSharper disable EmptyGeneralCatchClause catch(Exception err) //errors caught inside // ReSharper restore EmptyGeneralCatchClause { Dev2Logger.Log.Error(err); if(failOnException) throw; } } return null; }
private List<string> GetArgumentsNames(DynamicActivity act) { List<string> names = new List<string>(); if (act != null) { act.Properties.Where(p => typeof(Argument).IsAssignableFrom(p.Type)).ToList().ForEach(dp => { names.Add(dp.Name); }); } return names; }
public static WFRuleEngine Compile(RuleSet ruleSet) { if (ruleSet.IsValid()) { var activity = new DynamicActivity(); CompileInputs(activity, ruleSet); var implementation = CompileRules(ruleSet); activity.Implementation = () => implementation; return new WFRuleEngine(activity); } else { throw new Exception("RuleSet cannot be compiled."); } }
public IDev2Activity Parse(DynamicActivity activity,Guid resourceIdGuid) { if(HasActivityInCache(resourceIdGuid)) { return GetActivity(resourceIdGuid); } var dynamicActivity = activity; if (dynamicActivity != null) { IDev2Activity act = _activityParser.Parse(dynamicActivity); if (_cache.TryAdd(resourceIdGuid, act)) { return act; } } return null; }
internal static void ConvertActivityBuilderToDynamicActivity(ActivityBuilder activityBuilder, DynamicActivity bodyPlaceholder) { bodyPlaceholder.Name = activityBuilder.Name; bodyPlaceholder.Implementation = () => activityBuilder.Implementation; if (activityBuilder.Implementation != null) { VisualBasic.SetSettings(bodyPlaceholder, VisualBasic.GetSettings(activityBuilder)); } bodyPlaceholder.Attributes.Clear(); foreach (Attribute attribute in activityBuilder.Attributes) { bodyPlaceholder.Attributes.Add(attribute); } bodyPlaceholder.Properties.Clear(); foreach (DynamicActivityProperty property in activityBuilder.Properties) { bodyPlaceholder.Properties.Add(property); } }
private void SortStartParameters(DynamicActivity dynamicActivity, CommandParameterCollection parameters) { uint num = 0; bool flag; bool flag1; string str; object baseObject; if (dynamicActivity == null) { flag = false; } else { flag = dynamicActivity.Properties.Contains("PSComputerName"); } bool flag2 = flag; if (dynamicActivity == null) { flag1 = false; } else { flag1 = dynamicActivity.Properties.Contains("PSPrivateMetadata"); } bool flag3 = flag1; this._jobMetadata.Add("WorkflowTakesPrivateMetadata", flag3); if (parameters != null) { foreach (CommandParameter parameter in parameters) { PowerShellTraceSource powerShellTraceSource = this._tracer; string str1 = "PSWorkflowJob"; string str2 = "SortStartParameters"; Guid workflowGuidForTraces = this.WorkflowGuidForTraces; PSWorkflowJob pSWorkflowJob = this; string str3 = "Found parameter; {0}; {1}"; string[] name = new string[2]; name[0] = parameter.Name; string[] strArrays = name; int num1 = 1; if (parameter.Value == null) { str = null; } else { str = parameter.Value.ToString(); } strArrays[num1] = str; powerShellTraceSource.WriteMessage(str1, str2, workflowGuidForTraces, pSWorkflowJob, str3, name); string name1 = parameter.Name; string str4 = name1; if (name1 != null) { if (str4 == "PSComputerName") { if (!flag2) { string value = parameter.Value as string; this._location = value; string[] strArrays1 = LanguagePrimitives.ConvertTo<string[]>(parameter.Value); this._psWorkflowCommonParameters[parameter.Name] = strArrays1; PSSQMAPI.NoteWorkflowCommonParametersValues(parameter.Name, (int)strArrays1.Length); continue; } else { this._location = "localhost"; this._workflowParameters[parameter.Name] = LanguagePrimitives.ConvertTo<string[]>(parameter.Value); continue; } } else if (str4 == "PSPrivateMetadata") { Hashtable hashtables = parameter.Value as Hashtable; if (hashtables == null) { continue; } IDictionaryEnumerator enumerator = hashtables.GetEnumerator(); while (enumerator.MoveNext()) { this._privateMetadata.Add(enumerator.Key.ToString(), enumerator.Value); } if (flag3) { this._workflowParameters.Add(parameter.Name, parameter.Value); } PSSQMAPI.NoteWorkflowCommonParametersValues(parameter.Name, hashtables.Count); continue; } else if (str4 == "PSInputCollection") { if (parameter.Value as PSObject != null) { baseObject = ((PSObject)parameter.Value).BaseObject; } else { baseObject = parameter.Value; } object obj = baseObject; if (obj as PSDataCollection<PSObject> == null) { PSDataCollection<PSObject> pSObjects = new PSDataCollection<PSObject>(); IEnumerator enumerator1 = LanguagePrimitives.GetEnumerator(obj); if (enumerator1 == null) { pSObjects.Add(PSObject.AsPSObject(parameter.Value)); } else { while (enumerator1.MoveNext()) { pSObjects.Add(PSObject.AsPSObject(enumerator1.Current)); } } this._inputCollection = pSObjects; continue; } else { this._inputCollection = obj as PSDataCollection<PSObject>; continue; } } else if (str4 == "PSParameterCollection") { continue; } else if (str4 == "PSRunningTimeoutSec" || str4 == "PSElapsedTimeoutSec" || str4 == "PSConnectionRetryCount" || str4 == "PSActionRetryCount" || str4 == "PSConnectionRetryIntervalSec" || str4 == "PSActionRetryIntervalSec") { this._psWorkflowCommonParameters.Add(parameter.Name, parameter.Value); if (!LanguagePrimitives.TryConvertTo<uint>(parameter.Value, out num)) { continue; } PSSQMAPI.NoteWorkflowCommonParametersValues(parameter.Name, num); continue; } else if (str4 == "PSPersist" || str4 == "PSCredential" || str4 == "PSPort" || str4 == "PSUseSSL" || str4 == "PSConfigurationName" || str4 == "PSApplicationName" || str4 == "PSConnectionURI" || str4 == "PSSessionOption" || str4 == "PSAuthentication" || str4 == "PSAuthenticationLevel" || str4 == "PSCertificateThumbprint" || str4 == "PSAllowRedirection" || str4 == "Verbose" || str4 == "Debug" || str4 == "ErrorAction" || str4 == "WarningAction" || str4 == "PSWorkflowErrorAction") { this._psWorkflowCommonParameters.Add(parameter.Name, parameter.Value); PSSQMAPI.IncrementWorkflowCommonParameterPresent(parameter.Name); continue; } else if (str4 == "PSSenderInfo" || str4 == "PSWorkflowRoot" || str4 == "PSCurrentDirectory") { this._psWorkflowCommonParameters.Add(parameter.Name, parameter.Value); continue; } } this._workflowParameters.Add(parameter.Name, parameter.Value); if (parameter.Value == null) { continue; } PSSQMAPI.IncrementWorkflowSpecificParameterType(parameter.Value.GetType()); } } this._psWorkflowCommonParameters.Add("WorkflowCommandName", this._definition.Command); }
private static void CompileInputs(DynamicActivity activity, RuleSet ruleSet) { var settings = new VisualBasicSettings(); foreach (var input in ruleSet.Inputs) { var inProperty = new DynamicActivityProperty { Name = input.Key, Type = typeof(InArgument<>).MakeGenericType(input.Value) }; activity.Properties.Add(inProperty); settings.ImportReferences.Add(new VisualBasicImportReference { Assembly = input.Value.Assembly.GetName().Name, Import = input.Value.Namespace }); } VisualBasic.SetSettings(activity, settings); }
private WFRuleEngine(DynamicActivity activity) { _activity = activity; }
public void WorkflowHelperCompileExpressionsWithActivityExpectedCompilesExpressionsAddsToCacheThenInvalidate() { const string ExpressionParams = "(\"\",AmbientDataList)"; var fsa = new DsfFlowSwitchActivity { ExpressionText = GlobalConstants.InjectedSwitchDataFetchOld + ExpressionParams }; var fda = new DsfFlowDecisionActivity { ExpressionText = GlobalConstants.InjectedDecisionHandlerOld + ExpressionParams }; var startNode = new FlowStep { Action = new CommentActivityForTest() }; var chart = new Flowchart { StartNode = startNode }; chart.Nodes.Add(startNode); chart.Nodes.Add(new FlowDecision(fda)); chart.Nodes.Add(new FlowSwitch<string> { Expression = fsa }); var workflow = new DynamicActivity { Implementation = () => chart }; var guid = Guid.NewGuid(); new WorkflowHelper().CompileExpressions(workflow, guid); // No exception thrown means compilation worked var compiledExpressionRoot = CompiledExpressionInvoker.GetCompiledExpressionRootForImplementation(workflow) as ICompiledExpressionRoot; Assert.AreEqual(GlobalConstants.Resultscache.Count, 1); GlobalConstants.InvalidateCache(guid); Assert.AreEqual(GlobalConstants.Resultscache.Count, 0); Assert.IsNotNull(compiledExpressionRoot); }
public void WorkflowHelperCompileExpressionsWithActivityNoNamespacesExpectedThrowsCompilerException() { var workflow = new DynamicActivity { Implementation = () => new WriteLine { // ExpressionText MUST be use a class that is not been referenced! Text = new CSharpValue<string>("Dev2.Runtime.Utilities.GenerateString(new Random(), 6)") } }; new WorkflowHelper().CompileExpressions(workflow,Guid.NewGuid()); }
static DynamicActivity GetDynamicActivity(ActivityBuilder activityDefinition) { DynamicActivity result = new DynamicActivity { Name = activityDefinition.Name }; foreach (DynamicActivityProperty property in activityDefinition.Properties) { result.Properties.Add(property); } foreach (Attribute attrib in activityDefinition.Attributes) { result.Attributes.Add(attrib); } foreach (Constraint constraint in activityDefinition.Constraints) { result.Constraints.Add(constraint); } result.Implementation = () => activityDefinition.Implementation; VisualBasicSettings vbsettings = VisualBasic.GetSettings(activityDefinition); if (vbsettings != null) { VisualBasic.SetSettings(result, vbsettings); } IList<string> namespacesForImplementation = TextExpression.GetNamespacesForImplementation(activityDefinition); if (namespacesForImplementation.Count > 0) { TextExpression.SetNamespacesForImplementation(result, namespacesForImplementation); } IList<AssemblyReference> referencesForImplementation = TextExpression.GetReferencesForImplementation(activityDefinition); if (referencesForImplementation.Count > 0) { TextExpression.SetReferencesForImplementation(result, referencesForImplementation); } return result; }
public void WorkflowHelperCompileExpressionsWithActivityExpectedSetsNamespaces() { var activity = new DynamicActivity(); new WorkflowHelper().CompileExpressions(activity,Guid.NewGuid()); var impl = new AttachableMemberIdentifier(typeof(TextExpression), "NamespacesForImplementation"); object property; AttachablePropertyServices.TryGetProperty(activity, impl, out property); var namespaces = property as List<string>; if(namespaces != null) { Assert.IsTrue(namespaces.SequenceEqual(ExpectedNamespaces)); } else { Assert.Fail(); } }
public static Activity getRuntimeActivityByDynamicActivity(DynamicActivity dynamicActivity) { IEnumerator<Activity> list = WorkflowInspectionServices.GetActivities(dynamicActivity).GetEnumerator(); list.MoveNext(); Activity runtimeActivity = list.Current; return runtimeActivity; }
public void Eval(DynamicActivity flowchartProcess, Guid resourceID, IDSFDataObject dsfDataObject) { IDev2Activity resource = new ActivityParser().Parse(flowchartProcess); resource.Execute(dsfDataObject); }
/// <summary> /// Create necessary dictionaries for WorkflowManager consumption based on StartParameters. /// </summary> private void SortStartParameters(DynamicActivity dynamicActivity, CommandParameterCollection parameters) { bool selfRemoting = dynamicActivity != null && dynamicActivity.Properties.Any(x => x.Name.Equals(Constants.ComputerName, StringComparison.CurrentCultureIgnoreCase)); bool takesPSPrivateMetadata = dynamicActivity != null && dynamicActivity.Properties.Contains(Constants.PrivateMetadata); _jobMetadata.Add(Constants.WorkflowTakesPrivateMetadata, takesPSPrivateMetadata); if (parameters != null) { foreach (var parameter in parameters) { _tracer.WriteMessage(ClassNameTrace, "SortStartParameters", WorkflowGuidForTraces, this, "Found parameter; {0}; {1}", parameter.Name, parameter.Value == null ? null : parameter.Value.ToString()); switch (parameter.Name) { case Constants.ComputerName: if (selfRemoting) { // If we're self-remoting, location becomes the default computer // and the PSComputerNames is passed in as an argument instead // of going to the ubiquitous parameters _location = Constants.DefaultComputerName; string parameterName = dynamicActivity.Properties.First(x => x.Name.Equals(Constants.ComputerName, StringComparison.CurrentCultureIgnoreCase)).Name; _workflowParameters[parameterName] = LanguagePrimitives.ConvertTo<string[]>(parameter.Value); } else { // Set _location before adding parameter. var computer = parameter.Value as string; _location = computer; string[] computerNames = LanguagePrimitives.ConvertTo<string[]>(parameter.Value); _psWorkflowCommonParameters[parameter.Name] = computerNames; } break; case Constants.PrivateMetadata: Hashtable privateData = parameter.Value as Hashtable; if (privateData != null) { IDictionaryEnumerator enumerator = privateData.GetEnumerator(); while (enumerator.MoveNext()) { _privateMetadata.Add(enumerator.Key.ToString(), enumerator.Value); } // Make the combined object available within the workflow as well... if (takesPSPrivateMetadata) { _workflowParameters.Add(parameter.Name, parameter.Value); } } break; case Constants.PSInputCollection: { // Remove the input collection so we can properly pass it to the workflow job object baseObject = parameter.Value is PSObject ? ((PSObject)parameter.Value).BaseObject : parameter.Value; if (baseObject is PSDataCollection<PSObject>) { _inputCollection = baseObject as PSDataCollection<PSObject>; } else { var inputCollection = new PSDataCollection<PSObject>(); var e = LanguagePrimitives.GetEnumerator(baseObject); if (e != null) { while (e.MoveNext()) { inputCollection.Add(PSObject.AsPSObject(e.Current)); } } else { inputCollection.Add(PSObject.AsPSObject(parameter.Value)); } _inputCollection = inputCollection; } } break; case Constants.PSParameterCollection: // Remove this one from the parameter collection... break; case Constants.PSRunningTime: case Constants.PSElapsedTime: case Constants.ConnectionRetryCount: case Constants.ActionRetryCount: case Constants.ConnectionRetryIntervalSec: case Constants.ActionRetryIntervalSec: _psWorkflowCommonParameters.Add(parameter.Name, parameter.Value); break; case Constants.Persist: case Constants.Credential: case Constants.Port: case Constants.UseSSL: case Constants.ConfigurationName: case Constants.ApplicationName: case Constants.ConnectionURI: case Constants.SessionOption: case Constants.Authentication: case Constants.AuthenticationLevel: case Constants.CertificateThumbprint: case Constants.AllowRedirection: case Constants.Verbose: case Constants.Debug: case Constants.ErrorAction: case Constants.WarningAction: case Constants.InformationAction: case Constants.PSWorkflowErrorAction: case Constants.PSSuspendOnError: case Constants.PSSenderInfo: case Constants.ModulePath: case Constants.PSCurrentDirectory: // Note: We don't add ErrorVariable, WarningVariable, OutVariable, or OutBuffer // here because they are interpreted by PowerShell in the function generated over // the workflow definition. _psWorkflowCommonParameters.Add(parameter.Name, parameter.Value); break; default: _workflowParameters.Add(parameter.Name, parameter.Value); break; } } } // Add in the workflow command name... _psWorkflowCommonParameters.Add("WorkflowCommandName", _definition.Command); }
//得到[DynamicActivity]的Implementation public static Activity getImplementation(DynamicActivity dynamicActivity) { return dynamicActivity.Implementation(); }
internal static DynamicActivity ConvertToDynamicActivity(this ActivityBuilder activityBuilder) { DynamicActivity result = new DynamicActivity(); ActivityBuilderExtensions.ConvertActivityBuilderToDynamicActivity(activityBuilder, result); return result; }
public void Eval(DynamicActivity flowchartProcess, IDSFDataObject dsfDataObject,int update) { IDev2Activity resource = new ActivityParser().Parse(flowchartProcess); EvalInner(dsfDataObject, resource, update); }
public IDev2Activity Parse(DynamicActivity dynamicActivity) { return Parse(dynamicActivity, new List<IDev2Activity>()); }