private IEnumerable<IRuleDependency> CompileDependencies(IRuleDefinition ruleDefinition)
{
foreach (var dependency in ruleDefinition.DependencyGroup.Dependencies)
{
var compiledDependency = new RuleDependency(dependency.Declaration, dependency.ServiceType);
yield return compiledDependency;
}
}
public CompiledRule(IRuleDefinition definition, IEnumerable<IRuleAction> actions, IEnumerable<IRuleDependency> dependencies)
{
_priority = definition.Priority;
_repeatability = definition.Repeatability;
_definition = definition;
_actions = new List<IRuleAction>(actions);
_dependencies = new List<IRuleDependency>(dependencies);
}
public IRuleDefinition Transform(IRuleDefinition rule)
{
var lhsContext = new Context();
var lhs = Transform <GroupElement>(lhsContext, rule.LeftHandSide);
var rhsContext = new Context();
var rhs = Transform <ActionGroupElement>(rhsContext, rule.RightHandSide);
if (lhsContext.IsModified || rhsContext.IsModified)
{
var transformedRule = new RuleDefinition(rule.Name, rule.Description, rule.Priority,
rule.Repeatability, rule.Tags, rule.Properties, rule.DependencyGroup, rule.FilterGroup, lhs, rhs);
return(transformedRule);
}
return(rule);
}
public void Tags_TagAttributesAndParentAttributesPresent_CustomValues()
{
//Arrange
_repository.Load(x => x.From(typeof(RuleWithMetadataAndParentMetadata)));
IRuleDefinition rule = _repository.GetRules().Single();
//Act
string[] actual = rule.Tags.ToArray();
//Assert
Assert.AreEqual(4, actual.Length);
Assert.Contains("ChildTag", actual);
Assert.Contains("ChildMetadata", actual);
Assert.Contains("ParentTag", actual);
Assert.Contains("ParentMetadata", actual);
}
public static XmlNode CreateCategoryDefinitionXmlNode(XmlDocument doc, ICategoryDefinition definition)
{
// <CategoryDefinition Enabled="true" Id="{GUID}" RefName="Try-Catches" RefId="{GUID}">
// <RuleDefinition Enabled="true" Id="{GUID}" RefName="No explicit exception identifier" RefId="{GUID}"/>
// <RuleDefinition Enabled="true" Id="{GUID}" RefName="Empty try-catch" RefId="{GUID}"/>
// <RuleDefinition Enabled="true" Id="{GUID}" RefName="Try-catch vs. throw exception" RefId="{GUID}"/>
// </CategoryDefinition>
XmlNode categoryDefinitionNode = doc.CreateNode(XmlNodeType.Element, "CategoryDefinition", null);
XmlAttribute idAttrib = doc.CreateAttribute("Id");
XmlAttribute enabledAttrib = doc.CreateAttribute("Enabled");
XmlAttribute refNameAttrib = doc.CreateAttribute("RefName");
XmlAttribute refIdAttrib = doc.CreateAttribute("RefId");
idAttrib.Value = definition.Id.ToString();
enabledAttrib.Value = definition.Enabled.ToString();
refNameAttrib.Value = definition.CategoryDeclarationReferenceName;
refIdAttrib.Value = definition.CategoryDeclarationReferenceId + "";
categoryDefinitionNode.Attributes.Append(idAttrib);
categoryDefinitionNode.Attributes.Append(enabledAttrib);
categoryDefinitionNode.Attributes.Append(refNameAttrib);
categoryDefinitionNode.Attributes.Append(refIdAttrib);
foreach (KeyValuePair <int, IRuleDefinition> pair in definition.Rules)
{
IRuleDefinition ruleDef = pair.Value;
XmlNode ruleDefinitionNode = doc.CreateNode(XmlNodeType.Element, "RuleDefinition", null);
XmlAttribute id = doc.CreateAttribute("Id");
XmlAttribute enabled = doc.CreateAttribute("Enabled");
XmlAttribute refName = doc.CreateAttribute("RefName");
XmlAttribute refId = doc.CreateAttribute("RefId");
id.Value = ruleDef.Id.ToString();
enabled.Value = ruleDef.Enabled.ToString();
refName.Value = ruleDef.RuleDeclarationReferenceName;
refId.Value = ruleDef.RuleDeclarationReferenceId + "";
ruleDefinitionNode.Attributes.Append(id);
ruleDefinitionNode.Attributes.Append(enabled);
ruleDefinitionNode.Attributes.Append(refName);
ruleDefinitionNode.Attributes.Append(refId);
categoryDefinitionNode.AppendChild(ruleDefinitionNode);
}
return(categoryDefinitionNode);
}
public void AddFilter(IRuleDefinition rule, IAgendaFilter filter)
{
if (!_ruleFilters.TryGetValue(rule, out var filters))
{
filters = new List <IAgendaFilter>();
_ruleFilters.Add(rule, filters);
}
filters.Add(filter);
if (filter is IStatefulAgendaFilter saf)
{
if (!_ruleStatefulFilters.TryGetValue(rule, out var statefulFilters))
{
statefulFilters = new List <IStatefulAgendaFilter>();
_ruleStatefulFilters.Add(rule, statefulFilters);
}
statefulFilters.Add(saf);
}
}
private ICompiledRule CompileRule(ReteBuilder reteBuilder, IRuleDefinition ruleDefinition)
{
var transformation = new RuleTransformation();
var transformedRule = transformation.Transform(ruleDefinition);
var ruleDeclarations = transformedRule.LeftHandSide.Declarations.ToList();
IEnumerable <ITerminalNode> terminals = reteBuilder.AddRule(transformedRule);
var rightHandSide = transformedRule.RightHandSide;
var actions = new List <IRuleAction>();
foreach (var action in rightHandSide.Actions)
{
var factIndexMap = FactIndexMap.CreateMap(action.References, ruleDeclarations);
var ruleAction = new RuleAction(action.Expression, factIndexMap);
actions.Add(ruleAction);
}
var rule = new CompiledRule(ruleDefinition, actions);
BuildRuleNode(rule, terminals);
return(rule);
}
public void ConfigurationFactory_AllSupportedTypes_ReturnsValidObject()
{
ConfigurationComponentFactory factory = ConfigurationComponentFactory.Instance;
factory.InitializeComponentAccessPermissions(AppManager);
Debug.Assert(factory != null, "proxy != null");
ILanguageDeclaration languageDeclaration = factory.ConfigurationFactory <ILanguageDeclaration>(typeof(ILanguageDeclaration));
IRuleDeclaration ruleDeclaration = factory.ConfigurationFactory <IRuleDeclaration>(typeof(IRuleDeclaration));
IProjectDefinition projectDefinition = factory.ConfigurationFactory <IProjectDefinition>(typeof(IProjectDefinition));
ICategoryDefinition categoryDefinition = factory.ConfigurationFactory <ICategoryDefinition>(typeof(ICategoryDefinition));
IRuleDefinition ruleDefinition = factory.ConfigurationFactory <IRuleDefinition>(typeof(IRuleDefinition));
IDirectoryDefinition directoryDefinition = factory.ConfigurationFactory <IDirectoryDefinition>(typeof(IDirectoryDefinition));
IFileDefinition fileDefinition = factory.ConfigurationFactory <IFileDefinition>(typeof(IFileDefinition));
Assert.IsNotNull(languageDeclaration);
Assert.IsNotNull(ruleDeclaration);
Assert.IsNotNull(projectDefinition);
Assert.IsNotNull(categoryDefinition);
Assert.IsNotNull(ruleDefinition);
Assert.IsNotNull(directoryDefinition);
Assert.IsNotNull(fileDefinition);
}
private void CompileRule(IReteBuilder reteBuilder, IRuleDefinition ruleDefinition)
{
var transformation = new RuleTransformation();
var transformedRule = transformation.Transform(ruleDefinition);
var ruleDeclarations = transformedRule.LeftHandSide.Declarations.ToList();
var ruleDependencies = transformedRule.DependencyGroup.Dependencies.Select(x => x.Declaration).ToList();
IEnumerable <IRuleDependency> dependencies = CompileDependencies(transformedRule);
IEnumerable <ITerminalNode> terminals = reteBuilder.AddRule(transformedRule);
var rightHandSide = transformedRule.RightHandSide;
var actions = new List <IRuleAction>();
foreach (var action in rightHandSide.Actions)
{
var ruleAction = ExpressionCompiler.CompileAction(action, ruleDeclarations, ruleDependencies);
actions.Add(ruleAction);
}
var rule = new CompiledRule(ruleDefinition, ruleDeclarations, actions, dependencies);
BuildRuleNode(rule, terminals);
}
private void CompileRule(ReteBuilder reteBuilder, IRuleDefinition ruleDefinition)
{
var transformation = new RuleTransformation();
var transformedRule = transformation.Transform(ruleDefinition);
var ruleDeclarations = transformedRule.LeftHandSide.Declarations.ToList();
var ruleDependencies = transformedRule.DependencyGroup.Dependencies.Select(x => x.Declaration).ToList();
IEnumerable<IRuleDependency> dependencies = CompileDependencies(transformedRule);
IEnumerable<ITerminalNode> terminals = reteBuilder.AddRule(transformedRule);
var rightHandSide = transformedRule.RightHandSide;
var actions = new List<IRuleAction>();
foreach (var action in rightHandSide.Actions)
{
var factIndexMap = IndexMap.CreateMap(action.References, ruleDeclarations);
var dependencyIndexMap = IndexMap.CreateMap(action.References, ruleDependencies);
var ruleAction = new RuleAction(action.Expression, factIndexMap, dependencyIndexMap);
actions.Add(ruleAction);
}
var rule = new CompiledRule(ruleDefinition, actions, dependencies);
BuildRuleNode(rule, terminals);
}
private void CreateRuleDefinitionsFile()
{
IConfigurationProxy proxy = ProxyHome.Instance.RetrieveConfigurationProxy(OutputKeyKeeper.Instance.AccessKey);
XmlNode node;
XmlDocument doc = XmlFactory.CreateXmlFile(Ids.XSLT_DIR, Ids.ALL_RULE_DEFINITIONS_XSLT_FILE, "RuleDefinitions", out node);
//<RuleDefinitions>
// <RuleDefinition />
//</RuleDefinitions>
foreach (KeyValuePair <int, IProjectDefinition> projectDefinition in proxy.Projects())
{
foreach (KeyValuePair <int, IRuleDefinition> pair in proxy.ProjectRules(projectDefinition.Value.Id))
{
IRuleDefinition ruleDefinition = pair.Value;
IRuleDeclaration ruleDeclaration = proxy.RuleDeclarationFromRuleId(ruleDefinition.RuleDeclarationReferenceId);
node.AppendChild(XmlFactory.CreateRuleDefinitionXmlNode(doc, ruleDeclaration, ruleDefinition));
doc.AppendChild(node);
}
}
XmlFactory.SaveXmlFile(Path.Combine(OutputRootDir, Ids.OUTPUT_DIR, Ids.ALL_RULE_DEFINITIONS_XML_FILE), doc);
}
public ResolutionContext(ISession session, IRuleDefinition rule)
{
_session = session;
_rule = rule;
}
public ResolutionContext(ISession session, IRuleDefinition rule)
{
_session = session;
_rule = rule;
}
public void SetRuleDefinition(IRuleDefinition collection)
{
currentCollection = collection;
RefreshCategories();
}
public void Add(IRuleDefinition rule, RuleElement element)
{
_rules.Add(rule);
_elements.Add(element);
}
public static XmlNode CreateRuleDefinitionXmlNode(XmlDocument doc, IRuleDeclaration declaration, IRuleDefinition definition)
{
// <RuleDefinition Enabled="true" RefName="No explicit exception identifier" RefId="{6C021885-99A7-48D7-97DB-C1FE3242182A}" >
// <Description><CDATA ELEMENT /></Description>
// </RuleDefinition>
XmlNode ruleDefinitionXmlNode = doc.CreateNode(XmlNodeType.Element, "RuleDefinition", null);
XmlNode descriptionXmlNode = doc.CreateNode(XmlNodeType.Element, "Description", null);
XmlNode projectRelationXmlNode = doc.CreateNode(XmlNodeType.Element, "ProjectDefinitionRelation", null);
XmlNode categoryRelationXmlNode = doc.CreateNode(XmlNodeType.Element, "CategoryDeclarationRelation", null);
XmlAttribute idAttrib = doc.CreateAttribute("Id");
XmlAttribute enabledAttrib = doc.CreateAttribute("Enabled");
XmlAttribute refNameAttrib = doc.CreateAttribute("RefName");
XmlAttribute refIdAttrib = doc.CreateAttribute("RefId");
idAttrib.Value = definition.Id.ToString();
enabledAttrib.Value = definition.Enabled.ToString();
refNameAttrib.Value = definition.RuleDeclarationReferenceName;
refIdAttrib.Value = definition.RuleDeclarationReferenceId + "";
ruleDefinitionXmlNode.Attributes.Append(idAttrib);
ruleDefinitionXmlNode.Attributes.Append(enabledAttrib);
ruleDefinitionXmlNode.Attributes.Append(refNameAttrib);
ruleDefinitionXmlNode.Attributes.Append(refIdAttrib);
XmlCDataSection cdataNameNode = doc.CreateCDataSection(declaration.Description);
descriptionXmlNode.AppendChild(cdataNameNode);
projectRelationXmlNode.InnerText = definition.ParentDefinition.ParentDefinition.Name;
categoryRelationXmlNode.InnerText = declaration.ParentDeclaration.Name;
ruleDefinitionXmlNode.AppendChild(descriptionXmlNode);
ruleDefinitionXmlNode.AppendChild(projectRelationXmlNode);
ruleDefinitionXmlNode.AppendChild(categoryRelationXmlNode);
return(ruleDefinitionXmlNode);
}
public ActionContext(IRuleDefinition rule, ISession session)
{
_rule = rule;
_session = session;
_isHalted = false;
}
public ActionContext(IRuleDefinition rule, ISession session)
{
_rule = rule;
_session = session;
_isHalted = false;
}
public void Add(IRuleDefinition rule)
{
_rules.Add(rule);
}
public CompiledRule(IRuleDefinition definition, IEnumerable <IRuleAction> actions)
{
Priority = definition.Priority;
Definition = definition;
Actions = new List <IRuleAction>(actions);
}
public static Model.RuleDefinition RuleDefinitionMapper(IRuleDefinition ruleDefinition)
{
return new Model.RuleDefinition()
{
Enabled = ruleDefinition.Enabled,
};
}
public ActionContext(IRuleDefinition rule)
{
Rule = rule;
IsHalted = false;
Operations = new Queue <ActionOperation>();
}
public static XmlNode CreateRuleDefinitionXmlNode(XmlDocument doc, IRuleDeclaration declaration, IRuleDefinition definition)
{
// <RuleDefinition Enabled="true" RefName="No explicit exception identifier" RefId="{6C021885-99A7-48D7-97DB-C1FE3242182A}" >
// <Description><CDATA ELEMENT /></Description>
// </RuleDefinition>
XmlNode ruleDefinitionXmlNode = doc.CreateNode(XmlNodeType.Element, "RuleDefinition", null);
XmlNode descriptionXmlNode = doc.CreateNode(XmlNodeType.Element, "Description", null);
XmlNode projectRelationXmlNode = doc.CreateNode(XmlNodeType.Element, "ProjectDefinitionRelation", null);
XmlNode categoryRelationXmlNode = doc.CreateNode(XmlNodeType.Element, "CategoryDeclarationRelation", null);
XmlAttribute idAttrib = doc.CreateAttribute("Id");
XmlAttribute enabledAttrib = doc.CreateAttribute("Enabled");
XmlAttribute refNameAttrib = doc.CreateAttribute("RefName");
XmlAttribute refIdAttrib = doc.CreateAttribute("RefId");
idAttrib.Value = definition.Id.ToString();
enabledAttrib.Value = definition.Enabled.ToString();
refNameAttrib.Value = definition.RuleDeclarationReferenceName;
refIdAttrib.Value = definition.RuleDeclarationReferenceId + "";
ruleDefinitionXmlNode.Attributes.Append(idAttrib);
ruleDefinitionXmlNode.Attributes.Append(enabledAttrib);
ruleDefinitionXmlNode.Attributes.Append(refNameAttrib);
ruleDefinitionXmlNode.Attributes.Append(refIdAttrib);
XmlCDataSection cdataNameNode = doc.CreateCDataSection(declaration.Description);
descriptionXmlNode.AppendChild(cdataNameNode);
projectRelationXmlNode.InnerText = definition.ParentDefinition.ParentDefinition.Name;
categoryRelationXmlNode.InnerText = declaration.ParentDeclaration.Name;
ruleDefinitionXmlNode.AppendChild(descriptionXmlNode);
ruleDefinitionXmlNode.AppendChild(projectRelationXmlNode);
ruleDefinitionXmlNode.AppendChild(categoryRelationXmlNode);
return ruleDefinitionXmlNode;
}
public ReteBuilderContext(IRuleDefinition rule, DummyNode dummyNode)
{
Rule = rule;
_declarations = new List <Declaration>();
BetaSource = dummyNode;
}
/// <summary>
/// Adds a rule to the rule set.
/// </summary>
/// <param name="ruleSet">Rule set instance.</param>
/// <param name="ruleDefinition">Rule definition to add.</param>
public static void Add(this IRuleSet ruleSet, IRuleDefinition ruleDefinition)
{
ruleSet.Add(Enumerable.Repeat(ruleDefinition, 1));
}
