static void OnWorkflowIdle(object sender, WorkflowEventArgs e) { if (wasChanged) { return; } wasChanged = true; WorkflowInstance workflowInstance = e.WorkflowInstance; Int32 newAmount = 15000; Console.WriteLine("Dynamically change approved amount to {0:c}", newAmount); // Dynamic update of order rule WorkflowChanges workflowchanges = new WorkflowChanges(workflowInstance.GetWorkflowDefinition()); CompositeActivity transient = workflowchanges.TransientWorkflow; RuleDefinitions ruleDefinitions = (RuleDefinitions)transient.GetValue(RuleDefinitions.RuleDefinitionsProperty); RuleConditionCollection conditions = ruleDefinitions.Conditions; RuleExpressionCondition condition1 = (RuleExpressionCondition)conditions["Check"]; (condition1.Expression as CodeBinaryOperatorExpression).Right = new CodePrimitiveExpression(newAmount); workflowInstance.ApplyWorkflowChanges(workflowchanges); }
public override object GetValue(object component) { if (component == null) { throw new ArgumentNullException("component"); } RuleConditionReference reference = component as RuleConditionReference; if (reference == null) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, new object[] { "component" }), "component"); } if (reference.ConditionName != null) { RuleDefinitions ruleDefinitions = base.GetRuleDefinitions(component); if (ruleDefinitions != null) { RuleConditionCollection conditions = ruleDefinitions.Conditions; if ((conditions != null) && conditions.Contains(reference.ConditionName)) { RuleExpressionCondition condition = (RuleExpressionCondition)conditions[reference.ConditionName]; return(condition.Expression); } } } return(null); }
public override void SetValue(object component, object value) { if (component == null) { throw new ArgumentNullException("component"); } RuleConditionReference reference = component as RuleConditionReference; if (reference == null) { throw new ArgumentNullException("component"); } CodeExpression expression = value as CodeExpression; if (reference.ConditionName != null) { ISite serviceProvider = PropertyDescriptorUtils.GetSite(base.ServiceProvider, component); if (serviceProvider == null) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.MissingService, new object[] { typeof(ISite).FullName })); } RuleConditionCollection conditions = null; RuleDefinitions definitions = ConditionHelper.Load_Rules_DT(serviceProvider, Helpers.GetRootActivity(serviceProvider.Component as Activity)); if (definitions != null) { conditions = definitions.Conditions; } if ((conditions != null) && conditions.Contains(reference.ConditionName)) { RuleExpressionCondition condition = (RuleExpressionCondition)conditions[reference.ConditionName]; condition.Expression = expression; ConditionHelper.Flush_Rules_DT(serviceProvider, Helpers.GetRootActivity(serviceProvider.Component as Activity)); } } }
/// <summary> /// Replace the entire rule definition for a workflow /// </summary> /// <param name="instance"></param> private static void ReplaceRuleDefinition(WorkflowInstance instance) { //create a workflow changes object WorkflowChanges wfChanges = new WorkflowChanges( instance.GetWorkflowDefinition()); //get a stream from an externally saved .rules file Stream stream = new FileStream(@"ModifiedRule.rules", FileMode.Open, FileAccess.Read, FileShare.Read); //read the .rules file using an XmlReader using (XmlReader xmlReader = XmlReader.Create( new StreamReader(stream))) { WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer(); //deserialize the rule definitions RuleDefinitions ruleDefinitions = markupSerializer.Deserialize(xmlReader) as RuleDefinitions; if (ruleDefinitions != null) { //replace the embedded rules definition //with the new one that was deserialzed from a file wfChanges.TransientWorkflow.SetValue( RuleDefinitions.RuleDefinitionsProperty, ruleDefinitions); ValidateAndApplyChanges(instance, wfChanges); } } }
/// <summary> /// Modify a single rule condition /// </summary> /// <param name="instance"></param> private static void ModifyRuleCondition(WorkflowInstance instance) { //create a workflow changes object WorkflowChanges wfChanges = new WorkflowChanges( instance.GetWorkflowDefinition()); //retrieve the RuleDefinitions for the workflow RuleDefinitions ruleDefinitions = (RuleDefinitions)wfChanges.TransientWorkflow.GetValue( RuleDefinitions.RuleDefinitionsProperty); if (ruleDefinitions != null) { if (ruleDefinitions.Conditions.Contains("conditionOne")) { //retrieve the rule that we want to change RuleExpressionCondition condition = ruleDefinitions.Conditions["conditionOne"] as RuleExpressionCondition; //change the rule by setting the right side of the //operation to 300 instead of the original value of 100. //was: this.TestNumber > 100 //now: this.TestNumber > 300 CodeBinaryOperatorExpression codeExpression = condition.Expression as CodeBinaryOperatorExpression; codeExpression.Right = new CodePrimitiveExpression(300); ValidateAndApplyChanges(instance, wfChanges); } } }
public override void SetValue(object component, object value) { if (component == null) { throw new ArgumentNullException("component"); } RuleSetReference reference = component as RuleSetReference; if (reference == null) { throw new ArgumentNullException("component"); } RuleSet item = value as RuleSet; if (!string.IsNullOrEmpty(reference.RuleSetName)) { ISite serviceProvider = PropertyDescriptorUtils.GetSite(base.ServiceProvider, component); if (serviceProvider == null) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.MissingService, new object[] { typeof(ISite).FullName })); } RuleSetCollection ruleSets = null; RuleDefinitions definitions = ConditionHelper.Load_Rules_DT(serviceProvider, Helpers.GetRootActivity(serviceProvider.Component as Activity)); if (definitions != null) { ruleSets = definitions.RuleSets; } if ((ruleSets != null) && ruleSets.Contains(reference.RuleSetName)) { ruleSets.Remove(reference.RuleSetName); ruleSets.Add(item); ConditionHelper.Flush_Rules_DT(serviceProvider, Helpers.GetRootActivity(serviceProvider.Component as Activity)); } } }
public override void PerformReflection(ReflectionContext context) { Type workflowType = ((WorkflowNode)context.CurrentTreeNode).WorkflowType; DependencyObject workflow = ((WorkflowNode)context.CurrentTreeNode).WorkflowType.InvokeMember(string.Empty, BindingFlags.CreateInstance, null, null, null, CultureInfo.InvariantCulture) as DependencyObject; if (workflow == null) { throw new ApplicationException("Could not create the workflow and cast to DependencyObject"); } RuleDefinitions definitions = workflow.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions; if (definitions != null) { foreach (RuleCondition cond in definitions.Conditions) { RuleNode node = new RuleNode(); node.Rule = cond; node.SelectedImageIndex = node.ImageIndex = context.GetImageIndex(typeof(RuleComponent), RuleNodeImageName); context.CurrentTreeNode.Nodes.Add(node); ReflectChildComponents(context.CreateClone(node)); } } }
public override object GetValue(object component) { if (component == null) { throw new ArgumentNullException("component"); } RuleSetReference ruleSetReference = component as RuleSetReference; if (!string.IsNullOrEmpty(ruleSetReference.RuleSetName)) { RuleDefinitions rules = GetRuleDefinitions(component); if (rules != null) { RuleSetCollection ruleSetCollection = rules.RuleSets; if (ruleSetCollection != null && ruleSetCollection.Contains(ruleSetReference.RuleSetName)) { //in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection RuleSet ruleSet = ruleSetCollection[ruleSetReference.RuleSetName]; return(ruleSet); } } } return(null); }
public override object GetValue(object component) { if (component == null) { throw new ArgumentNullException("component"); } RuleConditionReference conditionDecl = component as RuleConditionReference; if (conditionDecl == null) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, "component"), "component"); } if (conditionDecl.ConditionName != null) { RuleDefinitions rules = GetRuleDefinitions(component); if (rules != null) { RuleConditionCollection conditionDefs = rules.Conditions; if (conditionDefs != null && conditionDefs.Contains(conditionDecl.ConditionName)) { //in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection RuleExpressionCondition conditionDefinition = (RuleExpressionCondition)conditionDefs[conditionDecl.ConditionName]; return(conditionDefinition.Expression); } } } return(null); }
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } Activity declaringActivity = Helpers.GetDeclaringActivity(this); if (declaringActivity == null) { declaringActivity = Helpers.GetRootActivity(this); } RuleDefinitions ruleDefinitions = (RuleDefinitions)declaringActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty); if (ruleDefinitions != null) { RuleSet ruleSet = ruleDefinitions.RuleSets[this.RuleSetReference.RuleSetName]; if (ruleSet != null) { ruleSet.Execute(declaringActivity, executionContext); } } return(ActivityExecutionStatus.Closed); }
public void GetRuleDefinitions() { var serializer = new WorkflowMarkupSerializer(); _ruleDefinitions = new RuleDefinitions(); Parallel.For(0, _rulesStream.Count, streamCounter => { using (XmlReader reader = new XmlTextReader(_rulesStream[streamCounter])) { var temp = serializer.Deserialize(reader) as RuleDefinitions; if (temp == null) { return; } if (temp.RuleSets != null) { for (int i = 0; i < temp.RuleSets.Count; i++) { _ruleDefinitions.RuleSets.Add(temp.RuleSets[i]); } } if (temp.Conditions != null) { for (int i = 0; i < temp.Conditions.Count; i++) { _ruleDefinitions.Conditions.Add(temp.Conditions[i]); } } } }); }
public override object EditValue(ITypeDescriptorContext typeDescriptorContext, IServiceProvider serviceProvider, object o) { if (typeDescriptorContext == null) { throw new ArgumentNullException("typeDescriptorContext"); } if (serviceProvider == null) { throw new ArgumentNullException("serviceProvider"); } object obj2 = o; RuleConditionReference instance = typeDescriptorContext.Instance as RuleConditionReference; if (((instance == null) || (instance.ConditionName == null)) || (instance.ConditionName.Length <= 0)) { throw new ArgumentException(Messages.ConditionNameNotSet); } Activity component = null; IReferenceService service = serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService; if (service != null) { component = service.GetComponent(typeDescriptorContext.Instance) as Activity; } RuleConditionCollection conditions = null; RuleDefinitions definitions = ConditionHelper.Load_Rules_DT(serviceProvider, Helpers.GetRootActivity(component)); if (definitions != null) { conditions = definitions.Conditions; } if ((conditions != null) && !conditions.Contains(instance.ConditionName)) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.ConditionNotFound, new object[] { instance.ConditionName })); } this.editorService = (IWindowsFormsEditorService)serviceProvider.GetService(typeof(IWindowsFormsEditorService)); if (this.editorService != null) { CodeExpression expression = typeDescriptorContext.PropertyDescriptor.GetValue(typeDescriptorContext.Instance) as CodeExpression; try { using (RuleConditionDialog dialog = new RuleConditionDialog(component, expression)) { if (DialogResult.OK == this.editorService.ShowDialog(dialog)) { obj2 = dialog.Expression; } } } catch (NotSupportedException) { DesignerHelpers.DisplayError(Messages.Error_ExpressionNotSupported, Messages.ConditionEditor, serviceProvider); } } return(obj2); }
public ConditionBrowserDialog(Activity activity, string name) : base(activity, name) { RuleDefinitions definitions = ConditionHelper.Load_Rules_DT(activity.Site, Helpers.GetRootActivity(activity)); if (definitions != null) { this.declarativeConditionCollection = definitions.Conditions; } base.InitializeListView(this.declarativeConditionCollection, name); }
/// <summary> /// Deserialize the markup file /// </summary> /// <param name="fileName"></param> /// <returns></returns> private Activity DeserializeFromMarkup(String fileName) { Activity workflow = null; //construct a serialization manager. DesignerSerializationManager dsm = new DesignerSerializationManager(); using (dsm.CreateSession()) { using (XmlReader xmlReader = XmlReader.Create(fileName)) { //deserialize the workflow from the XmlReader WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer(); workflow = markupSerializer.Deserialize( dsm, xmlReader) as Activity; if (dsm.Errors.Count > 0) { WorkflowMarkupSerializationException error = dsm.Errors[0] as WorkflowMarkupSerializationException; throw error; } } //deserialize a .rules file is one exists String rulesFileName = GetRulesFileName(fileName); if (File.Exists(rulesFileName)) { //read the .rules file using (XmlReader xmlReader = XmlReader.Create(rulesFileName)) { WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer(); //deserialize the rule definitions RuleDefinitions ruleDefinitions = markupSerializer.Deserialize(dsm, xmlReader) as RuleDefinitions; if (ruleDefinitions != null) { //add the rules definitions to the workflow workflow.SetValue( RuleDefinitions.RuleDefinitionsProperty, ruleDefinitions); } } } } return(workflow); }
public override object EditValue(ITypeDescriptorContext typeDescriptorContext, IServiceProvider serviceProvider, object o) { if (typeDescriptorContext == null) { throw new ArgumentNullException("typeDescriptorContext"); } if (serviceProvider == null) { throw new ArgumentNullException("serviceProvider"); } object obj2 = o; WorkflowDesignerLoader loader = serviceProvider.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader; if ((loader != null) && loader.InDebugMode) { throw new InvalidOperationException(Messages.DebugModeEditsDisallowed); } RuleSetReference instance = typeDescriptorContext.Instance as RuleSetReference; if (((instance == null) || (instance.RuleSetName == null)) || (instance.RuleSetName.Length <= 0)) { throw new ArgumentException(Messages.RuleSetNameNotSet); } Activity component = null; IReferenceService service = serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService; if (service != null) { component = service.GetComponent(typeDescriptorContext.Instance) as Activity; } RuleSetCollection ruleSets = null; RuleDefinitions definitions = ConditionHelper.Load_Rules_DT(serviceProvider, System.Workflow.Activities.Common.Helpers.GetRootActivity(component)); if (definitions != null) { ruleSets = definitions.RuleSets; } if ((ruleSets != null) && !ruleSets.Contains(instance.RuleSetName)) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.RuleSetNotFound, new object[] { instance.RuleSetName })); } this.editorService = (IWindowsFormsEditorService)serviceProvider.GetService(typeof(IWindowsFormsEditorService)); if (this.editorService != null) { RuleSet ruleSet = ruleSets[instance.RuleSetName]; using (RuleSetDialog dialog = new RuleSetDialog(component, ruleSet)) { if (DialogResult.OK == this.editorService.ShowDialog(dialog)) { obj2 = dialog.RuleSet; } } } return(obj2); }
public override void SetValue(object component, object value) { if (component == null) { throw new ArgumentNullException("component"); } RuleConditionReference conditionDecl = component as RuleConditionReference; if (conditionDecl == null) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, "component"), "component"); } string conditionName = value as string; if ((conditionName == null) || (conditionName.TrimEnd().Length == 0)) { conditionName = string.Empty; } ISite site = PropertyDescriptorUtils.GetSite(this.ServiceProvider, component); if (site == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName); throw new InvalidOperationException(message); } RuleConditionCollection conditionDefinitions = null; RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity)); if (rules != null) { conditionDefinitions = rules.Conditions; } if (conditionDefinitions != null && conditionName.Length != 0 && !conditionDefinitions.Contains(conditionName)) { //in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection RuleExpressionCondition newCondition = new RuleExpressionCondition(); newCondition.Name = conditionName; conditionDefinitions.Add(newCondition); ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity)); } // Cause component change events to be fired. PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(component)["ConditionName"]; if (propertyDescriptor != null) { PropertyDescriptorUtils.SetPropertyValue(site, propertyDescriptor, component, conditionName); } }
public void SaveRuleSet() { RuleDefinitions ruleDefinitions = new RuleDefinitions(); ruleDefinitions.RuleSets.Add(createRuleSet); WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); XmlTextWriter writer = new XmlTextWriter("RackRateRules.rules", System.Text.Encoding.Unicode); serializer.Serialize(writer, ruleDefinitions); writer.Close(); }
public TransformingMessageServiceBehavior(string ruleSet) { if (!string.IsNullOrWhiteSpace(ruleSet)) { _ruleSetPath = ruleSet; WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); XmlTextReader reader = new XmlTextReader(_ruleSetPath); RuleDefinitions rules = serializer.Deserialize(reader) as RuleDefinitions; _ruleSet = rules.RuleSets[0]; } }
public void CreateRuleSet() { createRuleSet = new RuleSet("CreateRackRate"); // Define property and activity reference expressions through CodeDom functionality CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression(); CodeFieldReferenceExpression RoleNameRef = new CodeFieldReferenceExpression(thisRef, "RoleName"); CodeFieldReferenceExpression ValidityRef = new CodeFieldReferenceExpression(thisRef, "Validity"); CodeTypeReferenceExpression RoleEnumRef = new CodeTypeReferenceExpression(typeof(RoleType)); CodeFieldReferenceExpression OutputRef = new CodeFieldReferenceExpression(thisRef, "Output"); // IF RoleType != "SalesAdmin" AND ValidityLimit > 3 // THEN Output = "invalid" Rule createRackRateRule = new Rule("CreatRackRateRule"); createRuleSet.Rules.Add(createRackRateRule); // define first predicate: RoleType != "SalesAdmin" CodeBinaryOperatorExpression ruleRoleName = new CodeBinaryOperatorExpression(); ruleRoleName.Left = RoleNameRef; ruleRoleName.Operator = CodeBinaryOperatorType.IdentityInequality; ruleRoleName.Right = new CodeFieldReferenceExpression(RoleEnumRef, "SalesAdmin"); // define second predicate: Validity > 3 CodeBinaryOperatorExpression ruleValidityTest = new CodeBinaryOperatorExpression(); ruleValidityTest.Left = ValidityRef; ruleValidityTest.Operator = CodeBinaryOperatorType.ValueEquality; ruleValidityTest.Right = new CodePrimitiveExpression("3"); // join the first two predicates into a single condition CodeBinaryOperatorExpression ruleCondition = new CodeBinaryOperatorExpression(); ruleCondition.Left = ruleRoleName; ruleCondition.Operator = CodeBinaryOperatorType.BooleanAnd; ruleCondition.Right = ruleValidityTest; createRackRateRule.Condition = new RuleExpressionCondition(ruleCondition); // add the action: Output = invalid CodeAssignStatement ruleSurchargeAction = new CodeAssignStatement(OutputRef, new CodePrimitiveExpression("invalid")); createRackRateRule.ThenActions.Add(new RuleStatementAction(ruleSurchargeAction)); // Add the ruleset RuleDefinitions ruleDef = new RuleDefinitions(); ruleDef.RuleSets.Add(createRuleSet); // Set the RuleDefinitions on the workflow //this.SetValue(RuleDefinitions.RuleDefinitionsProperty, ruleDef); }
public RuleSetBrowserDialog(Activity activity, string name) : base(activity, name) { RuleDefinitions rules = ConditionHelper.Load_Rules_DT(activity.Site, Helpers.GetRootActivity(activity)); if (rules != null) { this.ruleSetCollection = rules.RuleSets; } InitializeListView(this.ruleSetCollection, name); }
protected override void DoDefaultAction() { base.DoDefaultAction(); WorkflowDesignerLoader service = this.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader; if ((service != null) && service.InDebugMode) { throw new InvalidOperationException(Messages.DebugModeEditsDisallowed); } PolicyActivity activity = (PolicyActivity)base.Activity; if (!System.Workflow.Activities.Common.Helpers.IsActivityLocked(activity)) { RuleDefinitions definitions = ConditionHelper.Load_Rules_DT(this, System.Workflow.Activities.Common.Helpers.GetRootActivity(activity)); if (definitions != null) { RuleSetCollection ruleSets = definitions.RuleSets; RuleSetReference ruleSetReference = activity.RuleSetReference; RuleSet ruleSet = null; string key = null; if ((ruleSetReference != null) && !string.IsNullOrEmpty(ruleSetReference.RuleSetName)) { key = ruleSetReference.RuleSetName; if (ruleSets.Contains(key)) { ruleSet = ruleSets[key]; } } else { key = ruleSets.GenerateRuleSetName(); } using (RuleSetDialog dialog = new RuleSetDialog(activity, ruleSet)) { if (DialogResult.OK == dialog.ShowDialog()) { if (ruleSet != null) { ruleSets.Remove(key); } else { dialog.RuleSet.Name = key; activity.RuleSetReference = new RuleSetReference(key); } ruleSets.Add(dialog.RuleSet); ConditionHelper.Flush_Rules_DT(this, System.Workflow.Activities.Common.Helpers.GetRootActivity(activity)); } } } TypeDescriptor.GetProperties(activity)["RuleSetReference"].SetValue(activity, activity.RuleSetReference); } }
/// <summary> /// 克隆一个实例 /// </summary> /// <param name="WfRuntimeClone"></param> /// <param name="instanceClone"></param> /// <param name="WfRuntime"></param> /// <returns></returns> public static WorkflowInstance CloneWorkflowInstance(WorkflowRuntime WfRuntimeClone, WorkflowInstance instanceClone, WorkflowRuntime WfRuntime) { try { if (!WfRuntimeClone.IsStarted) { WfRuntimeClone.StartRuntime(); } StateMachineWorkflowInstance workflowinstance = new StateMachineWorkflowInstance(WfRuntimeClone, instanceClone.InstanceId); System.Workflow.Activities.StateMachineWorkflowActivity smworkflow = new StateMachineWorkflowActivity(); smworkflow = workflowinstance.StateMachineWorkflow; RuleDefinitions ruleDefinitions = smworkflow.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions; WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer(); StringBuilder xoml = new StringBuilder(); StringBuilder rule = new StringBuilder(); XmlWriter xmlWriter = XmlWriter.Create(xoml); XmlWriter ruleWriter = XmlWriter.Create(rule); markupSerializer.Serialize(xmlWriter, smworkflow); if (ruleDefinitions != null) { markupSerializer.Serialize(ruleWriter, ruleDefinitions); } xmlWriter.Close(); ruleWriter.Close(); StringReader readxoml = new StringReader(xoml.ToString()); XmlReader readerxoml = XmlReader.Create(readxoml); WorkflowInstance instance; if (ruleDefinitions == null) { instance = WfRuntime.CreateWorkflow(readerxoml); } else { StringReader readrule = new StringReader(rule.ToString()); XmlReader readerrule = XmlReader.Create(readrule); instance = WfRuntime.CreateWorkflow(readerxoml, readerrule, null); } instance.Start(); return(instance); } catch (Exception ex) { LogHelper.WriteLog("CloneWorkflowInstance异常信息 :" + ex.ToString()); throw new Exception(ex.Message); } }
/// <summary> /// Execute a RuleSet definition read from /// a file /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void codeExecuteRuleSet_ExecuteCode( object sender, EventArgs e) { //get a stream from the embedded .rules resource Assembly assembly = Assembly.GetAssembly(typeof(SellItemWorkflow)); Stream stream = assembly.GetManifestResourceStream( "SharedWorkflows.SellItemMethods2Workflow.rules"); //get a stream from an externally saved .rules file //Stream stream // = new FileStream(@"SerializedSellItem.rules", // FileMode.Open, FileAccess.Read, FileShare.Read); using (XmlReader xmlReader = XmlReader.Create( new StreamReader(stream))) { WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer(); //deserialize the rule definitions RuleDefinitions ruleDefinitions = markupSerializer.Deserialize(xmlReader) as RuleDefinitions; if (ruleDefinitions != null) { if (ruleDefinitions.RuleSets.Contains("CalculateItemTotals")) { RuleSet rs = ruleDefinitions.RuleSets["CalculateItemTotals"]; //validate and execute the RuleSet against this //workflow instance RuleValidation validation = new RuleValidation( typeof(SellItemSerializedWorkflow), null); if (rs.Validate(validation)) { RuleExecution execution = new RuleExecution(validation, this); rs.Execute(execution); } else { foreach (ValidationError error in validation.Errors) { Console.WriteLine(error.ErrorText); } } } } } }
public RulesConverter(RulesExtractor ruleExtractor, bool runAsync) { if (ruleExtractor == null) { throw new ArgumentNullException("ruleExtractor"); } if (ruleExtractor.RuleDefinitions == null) { SendMessage("Rule definitions have not been extracted", EventType.Output); ruleExtractor.GetRuleDefinitions(); } _ruleDefinitions = ruleExtractor.RuleDefinitions; _runAsync = runAsync; }
internal static string ConvertRuleConditionReference(RuleDefinitions ruleDefinitions, RuleConditionReference ruleRef) { var builder = new StringBuilder(); builder.AppendFormat("This activity gets executed only if condition '{0}' is true", ruleRef.ConditionName); try { RuleCondition condition = ruleDefinitions.Conditions.First(x => x.Name != null && x.Name == ruleRef.ConditionName); builder.AppendFormat("[Condition Code: {0}]", ConvertRuleCondition(condition)); } catch { // no condition, so don't append anything } return(builder.ToString()); }
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object valueToConvert) { if (context == null) { throw new ArgumentNullException("context"); } string ruleSetName = valueToConvert as string; if ((ruleSetName == null) || (ruleSetName.TrimEnd().Length == 0)) { ruleSetName = string.Empty; } ISite site = PropertyDescriptorUtils.GetSite(context, context.Instance); if (site == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName); throw new InvalidOperationException(message); } RuleSetCollection ruleSetCollection = null; RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity)); if (rules != null) { ruleSetCollection = rules.RuleSets; } if (ruleSetCollection != null && ruleSetName.Length != 0 && !ruleSetCollection.Contains(ruleSetName)) { //in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection RuleSet newRuleSet = new RuleSet(); newRuleSet.Name = ruleSetName; ruleSetCollection.Add(newRuleSet); ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity)); } RuleSetReference ruleSetReference = new RuleSetReference(); ruleSetReference.RuleSetName = ruleSetName; return(ruleSetReference); }
protected override void Execute(CodeActivityContext context) { if (RulesFilePath == null || RuleSetName == null) { throw new InvalidOperationException("Rules File path and RuleSet Name need to be configured"); } if (!File.Exists(RulesFilePath)) { throw new InvalidOperationException("Rules File " + RulesFilePath + " did not exist"); } // Get the RuleSet from the .rules file WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); XmlTextReader reader = new XmlTextReader(RulesFilePath); RuleDefinitions rules = serializer.Deserialize(reader) as RuleDefinitions; RuleSet ruleSet = rules.RuleSets[RuleSetName]; if (ruleSet == null) { throw new InvalidOperationException("RuleSet " + RuleSetName + " not found in " + RulesFilePath); } // Validate before running Type targetType = this.TargetObject.Get(context).GetType(); RuleValidation validation = new RuleValidation(targetType, null); if (!ruleSet.Validate(validation)) { // Set the ValidationErrors OutArgument this.ValidationErrors.Set(context, validation.Errors); // Throw exception throw new ValidationException(string.Format("The ruleset is not valid. {0} validation errors found (check the ValidationErrors property for more information).", validation.Errors.Count)); } // Execute the ruleset object evaluatedTarget = this.TargetObject.Get(context); RuleEngine engine = new RuleEngine(ruleSet, validation); engine.Execute(evaluatedTarget); // Update the Result object this.ResultObject.Set(context, evaluatedTarget); }
public override void SetValue(object component, object value) { if (component == null) { throw new ArgumentNullException("component"); } if (!(component is RuleConditionReference)) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.NotARuleConditionReference, new object[] { "component" }), "component"); } string key = value as string; if ((key == null) || (key.TrimEnd(new char[0]).Length == 0)) { key = string.Empty; } ISite serviceProvider = PropertyDescriptorUtils.GetSite(base.ServiceProvider, component); if (serviceProvider == null) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.MissingService, new object[] { typeof(ISite).FullName })); } RuleConditionCollection conditions = null; RuleDefinitions definitions = ConditionHelper.Load_Rules_DT(serviceProvider, Helpers.GetRootActivity(serviceProvider.Component as Activity)); if (definitions != null) { conditions = definitions.Conditions; } if (((conditions != null) && (key.Length != 0)) && !conditions.Contains(key)) { RuleExpressionCondition item = new RuleExpressionCondition { Name = key }; conditions.Add(item); ConditionHelper.Flush_Rules_DT(serviceProvider, Helpers.GetRootActivity(serviceProvider.Component as Activity)); } PropertyDescriptor propertyDescriptor = TypeDescriptor.GetProperties(component)["ConditionName"]; if (propertyDescriptor != null) { PropertyDescriptorUtils.SetPropertyValue(serviceProvider, propertyDescriptor, component, key); } }
public override void SetValue(object component, object value) { if (component == null) { throw new ArgumentNullException("component"); } RuleConditionReference conditionDecl = component as RuleConditionReference; if (conditionDecl == null) { throw new ArgumentNullException("component"); } CodeExpression expression = value as CodeExpression; if (conditionDecl.ConditionName != null) { ISite site = PropertyDescriptorUtils.GetSite(this.ServiceProvider, component); if (site == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.MissingService, typeof(ISite).FullName); throw new InvalidOperationException(message); } RuleConditionCollection conditionDefs = null; RuleDefinitions rules = ConditionHelper.Load_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity)); if (rules != null) { conditionDefs = rules.Conditions; } if (conditionDefs != null && conditionDefs.Contains(conditionDecl.ConditionName)) { //in this case, RuleExpressionCondition is the only type allowed in the ruleConditionCollection RuleExpressionCondition conditionDefinition = (RuleExpressionCondition)conditionDefs[conditionDecl.ConditionName]; conditionDefinition.Expression = expression; ConditionHelper.Flush_Rules_DT(site, Helpers.GetRootActivity(site.Component as Activity)); } } }
private ValidationErrorCollection ApplyRuleSet(T target, String path, String setName) { ValidationErrorCollection errors = null; WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); RuleSet rs = null; if (File.Exists(path)) { using (XmlTextReader reader = new XmlTextReader(path)) { RuleDefinitions rules = serializer.Deserialize(reader) as RuleDefinitions; if (rules != null && rules.RuleSets.Contains(setName)) { rs = rules.RuleSets[setName]; } } } if (rs == null) { throw new ArgumentException(String.Format( "Unable to retrieve RuleSet {0} from {1}", setName, path)); } RuleValidation val = new RuleValidation(target.GetType(), null); if (!rs.Validate(val)) { errors = val.Errors; return(errors); } RuleEngine rulesEngine = new RuleEngine(rs, val); rulesEngine.Execute(target); return(errors); }