void SelectNode(RuleElement element) { TreeNode node = this.theTree.Nodes.Cast <TreeNode>().Single(tn => tn.Tag == element.Type); node.Expand(); this.theTree.SelectedNode = node.Nodes.Cast <TreeNode>().Single(tn => tn.Tag == element); }
private void MoveWithRule(string name, string fullPath, RuleElement rule) { StringBuilder fileNameResult = new StringBuilder(); if (rule.IsIndexNumber) { int countOfElementsInDirectory = Directory.GetDirectories(rule.OutputFolder.FullName).Length; fileNameResult.Append(++countOfElementsInDirectory); fileNameResult.Append("_"); } if (rule.IsRelocationDate) { fileNameResult.Append(DateTime.Now.ToString("dd.MM.yyyy_HH.mm")); fileNameResult.Append("_"); } fileNameResult.Append(name); var pathResult = Path.Combine(rule.OutputFolder.FullName, fileNameResult.ToString()); File.Move(fullPath, pathResult); OnFileMoved(new MessageEventArgs { Message = string.Format(Resources.Resource.FileMoved, rule.OutputFolder.FullName) }); }
protected override void FillObject(XmlDescriptor d, RuleElement element) { XmlAttribute attr = d.Element.Attributes[RuleConstants.DayOfWeekAttrName]; if (attr != null) { (element as GetClosestDay).DayOfWeek = new ItemDayOfWeek(attr.Value); } attr = d.Element.Attributes[RuleConstants.WeekCountAttrName]; if (int.TryParse(attr?.Value, out int count)) { (element as GetClosestDay).WeekCount = count; } if (d.Element.HasChildNodes) { (element as GetClosestDay).ChildDateExp = SerializerRoot.Container <DateExpression>() .Deserialize(new XmlDescriptor() { Element = d.Element.FirstChild }); } }
private void BuildJoinNode(ReteBuilderContext context, RuleElement element, IEnumerable <ConditionElement> conditions = null) { var betaConditions = new List <IBetaCondition>(); if (conditions != null) { foreach (var condition in conditions) { var betaCondition = ExpressionCompiler.CompileBetaCondition(condition, context.Declarations); betaConditions.Add(betaCondition); } } var node = context.BetaSource .Sinks.OfType <JoinNode>() .FirstOrDefault(x => x.RightSource == context.AlphaSource && x.LeftSource == context.BetaSource && ConditionComparer.AreEqual(x.Conditions, betaConditions)); if (node == null) { node = new JoinNode(context.BetaSource, context.AlphaSource, context.HasSubnet); foreach (var betaCondition in betaConditions) { node.Conditions.Add(betaCondition); } } node.NodeInfo.Add(context.Rule, element); BuildBetaMemoryNode(context, node); context.ResetAlphaSource(); }
protected override void FillObject(XmlDescriptor d, RuleElement element) { XmlNode valuesNode = d.Element.SelectSingleNode(RuleConstants.ValuesNodeName); if (valuesNode?.HasChildNodes == true) { foreach (XmlNode valueNode in valuesNode.ChildNodes) { RuleExpression valueElement = SerializerRoot.Container <RuleExpression>() .Deserialize(new XmlDescriptor() { Element = valueNode }); (element as Case).ValuesElements.Add(valueElement); } } XmlNode actionNode = d.Element.SelectSingleNode(RuleConstants.ActionNodeName); if (actionNode != null) { (element as Case).ActionElement = SerializerRoot.Container <ExecContainer>() .Deserialize(new XmlDescriptor() { Element = actionNode }); } }
//protected Type _type; //public CustomParameterBase(Type type) //{ // _type = type; //} public void Apply(RuleElement element) { if (element is T) { InnerApply(element as T); } }
/// <summary> /// Creates a new instance of the Rule using the rule defined in the policy document. /// </summary> /// <param name="rule">The rule defined in the policy document.</param> public Rule(RuleElement rule) { if (rule == null) { throw new ArgumentNullException("rule"); } _rule = rule; if (_rule.SchemaVersion == XacmlVersion.Version10 || _rule.SchemaVersion == XacmlVersion.Version11) { _condition = new Condition((ConditionElement)_rule.Condition); } else if (_rule.SchemaVersion == XacmlVersion.Version20) { _condition = new Condition2((ConditionElement)_rule.Condition); } if (rule.Target != null) { _target = new Target((TargetElement)rule.Target); // Load all the resources for the elements within this rule. foreach (ResourceElement resource in rule.Target.Resources.ItemsList) { foreach (ResourceMatchElement rmatch in resource.Match) { if (!_allResources.Contains(rmatch.AttributeValue.Contents)) { _allResources.Add(rmatch.AttributeValue.Contents); } } } } }
/// <summary> /// Creates a new instance of the Rule using the rule defined in the policy document. /// </summary> /// <param name="rule">The rule defined in the policy document.</param> public Rule(RuleElement rule) { if (rule == null) throw new ArgumentNullException("rule"); _rule = rule; if (_rule.SchemaVersion == XacmlVersion.Version10 || _rule.SchemaVersion == XacmlVersion.Version11) { _condition = new Condition((ConditionElement)_rule.Condition); } else if (_rule.SchemaVersion == XacmlVersion.Version20) { _condition = new Condition2((ConditionElement)_rule.Condition); } if (rule.Target != null) { _target = new Target((TargetElement)rule.Target); // Load all the resources for the elements within this rule. foreach (ResourceElement resource in rule.Target.Resources.ItemsList) { foreach (ResourceMatchElement rmatch in resource.Match) { if (!_allResources.Contains(rmatch.AttributeValue.Contents)) { _allResources.Add(rmatch.AttributeValue.Contents); } } } } }
protected override void FillObject(XmlDescriptor d, RuleElement element) { if (Enum.TryParse(d.Element.Name, true, out YmnosRuleKind kind)) { (element as YmnosRule).Kind = kind; } XmlAttribute attr = d.Element.Attributes[RuleConstants.YmnosRuleSourceAttrName]; if (Enum.TryParse(attr?.Value, true, out YmnosSource source)) { (element as YmnosRule).Source = source; } attr = d.Element.Attributes[RuleConstants.YmnosRulePlaceAttrName]; if (Enum.TryParse(attr?.Value, true, out PlaceYmnosSource place)) { (element as YmnosRule).Place = place; } attr = d.Element.Attributes[RuleConstants.YmnosRuleCountAttrName]; if (int.TryParse(attr?.Value, out int intValue)) { (element as YmnosRule).Count = intValue; } attr = d.Element.Attributes[RuleConstants.YmnosRuleStartFromAttrName]; if (int.TryParse(attr?.Value, out intValue)) { (element as YmnosRule).StartFrom = intValue; } }
/// <summary> /// Gets all rule elements out of an XElement. /// </summary> /// <param name="elements">The XElement which includes the rule elements.</param> /// <returns>List of rule elements.</returns> private IEnumerable <RuleElement> GetRuleElements(IEnumerable <XElement> elements) { List <RuleElement> ruleElements = new List <RuleElement>(); foreach (XElement element in elements) { RuleElement ruleElement = new RuleElement(); ruleElement.RuleType = this.GetRuleElementType(element.Name.LocalName); // Any Childs? if (element.Descendants().Count() > 0) { ruleElement.Childs = this.GetRuleElements(element.Descendants()); } else { ruleElement.Data = element.Value; } // Key and value? if (element.HasAttributes) { foreach (XAttribute attribute in element.Attributes()) { ruleElement.Attributes.Add(new KeyValuePair <string, string>(attribute.Name.LocalName, attribute.Value)); } } var test = ruleElement.Attributes.Where(t => t.Key.Equals("")).Select(t => t.Value); ruleElements.Add(ruleElement); } return(ruleElements); }
public static string ConvertElement(RuleIndex index, RuleElement element) { var stringWriter = new StringWriter(); element.WriteJS(new IndentedTextWriter(stringWriter, " ")); return(stringWriter.ToString()); }
public void StoreRule(RuleElement rule, string path) { try { var filePath = Path.GetDirectoryName(path); RuleManager.SaveRule(rule, filePath); } catch (Exception ex) { } }
protected override void FillObject(XmlDescriptor d, RuleElement container) { base.FillObject(d, container); if (Enum.TryParse(d.GetElementName(), true, out WorshipSequenceKind kind)) { (container as WorshipSequence).Kind = kind; } }
public void WriteGenericRulesElement(RuleElement element) { writer.Write(@"te = {0}[""{1}""] = new engine.RulesElement(", QuoteIdentifier(element.Type), QuoteString(element.Name)); element.WriteJS(this.writer); writer.WriteLine(");"); writer.WriteLine("byID[te.id] = te;"); writer.WriteLine(); }
private string GetDestinationFolderPath(RuleElement rule, FileSystemEventArgs e, string outFileName) { var destinationFolderPath = rule != null ? rule.MovingDestinationFolder : _defaultFolderPath; var logInfoMessage = rule != null ? string.Format(Messages.RulePassed, e.Name, rule.FilePathTemplate, rule.MovingDestinationFolder) : string.Format(Messages.RuleNotPassed, e.Name, _defaultFolderPath); _logger.LogInfo(logInfoMessage); return(Path.Combine(destinationFolderPath, outFileName)); }
protected override void FillObject(XmlDescriptor d, RuleElement element) { base.FillObject(d, element); XmlAttribute attr = d.Element.Attributes[RuleConstants.KSedalenPlaceAttrName]; if (Enum.TryParse(attr?.Value, true, out KanonasPlaceKind place)) { (element as KSedalenRule).Place = place; } }
protected override void FillObject(XmlDescriptor d, RuleElement element) { foreach (XmlNode childNode in d.Element.ChildNodes) { RuleElement child = SerializerRoot.Container <RuleElement>().Deserialize(new XmlDescriptor() { Element = childNode }); (element as ExecContainer).ChildElements.Add(child); } }
protected override void FillObject(XmlDescriptor d, RuleElement element) { if (d.Element.HasChildNodes)// && node.FirstChild.Name == RuleConstants.YmnosRuleNode) { (element as IsExists).ChildElement = SerializerRoot.Container <RuleExecutable, ICalcStructureElement>() .Deserialize(new XmlDescriptor() { Element = d.Element.FirstChild }) as ICalcStructureElement; } }
protected override void FillObject(XmlDescriptor d, RuleElement element) { base.FillObject(d, element); XmlAttribute attr = d.Element.Attributes[RuleConstants.KontakionShowIkosAttrName]; if (bool.TryParse(attr?.Value, out bool val)) { (element as KontakionRule).ShowIkos = val; } }
protected override void FillObject(XmlDescriptor d, RuleElement element) { base.FillObject(d, element); XmlAttribute attr = d.Element.Attributes[RuleConstants.KindAttrName]; if (Enum.TryParse(attr?.Value, true, out KindOfReplacedDay value)) { (element as ModifyReplacedDay).Kind = value; } }
protected override void FillObject(XmlDescriptor d, RuleElement container) { base.FillObject(d, container); XmlAttribute attr = d.Element.Attributes[RuleConstants.ShowPsalmAttribute]; if (bool.TryParse(attr?.Value, out bool showPsalm)) { (container as KekragariaRule).ShowPsalm = showPsalm; } }
protected override void FillObject(XmlDescriptor d, RuleElement element) { base.FillObject(d, element); var attr = d.Element.Attributes[RuleConstants.KAfterOdiNumberAttrName]; if (int.TryParse(attr?.Value, out int intValue)) { (element as KAfterRule).OdiNumber = intValue; } }
private Terminal BuildTerminal(ReteBuilderContext context, RuleElement element, IEnumerable <Declaration> ruleDeclarations) { if (context.AlphaSource != null) { BuildJoinNode(context, element); } var factMap = IndexMap.CreateMap(ruleDeclarations, context.Declarations); var terminalNode = new Terminal(context.BetaSource, factMap); return(terminalNode); }
protected override void FillObject(XmlDescriptor d, RuleElement element) { if (d.Element.HasChildNodes) { (element as DateByDaysFromEaster).ChildExpression = SerializerRoot.Container <IntExpression>() .Deserialize(new XmlDescriptor() { Element = d.Element.FirstChild }); } }
protected override void FillObject(XmlDescriptor d, RuleElement element) { XmlAttribute attr = d.Element.Attributes[RuleConstants.ShortNameAttrName]; (element as ModifyDay).ShortName = attr?.Value; attr = d.Element.Attributes[RuleConstants.IsLastNameAttrName]; (element as ModifyDay).IsLastName = bool.TryParse(attr?.Value, out bool value) ? value : false; attr = d.Element.Attributes[RuleConstants.AsAdditionAttrName]; (element as ModifyDay).AsAddition = bool.TryParse(attr?.Value, out value) ? value : false; attr = d.Element.Attributes[RuleConstants.UseFullNameAttrName]; (element as ModifyDay).UseFullName = bool.TryParse(attr?.Value, out value) ? value : true; attr = d.Element.Attributes[RuleConstants.DayMoveAttrName]; if (int.TryParse(attr?.Value, out int intValue)) { (element as ModifyDay).DayMoveCount = intValue; } attr = d.Element.Attributes[RuleConstants.PriorityAttrName]; (element as ModifyDay).Priority = int.TryParse(attr?.Value, out intValue) ? intValue : 0; attr = d.Element.Attributes[RuleConstants.SignNumberAttrName]; if (int.TryParse(attr?.Value, out intValue)) { (element as ModifyDay).SignNumber = intValue; } //filter DeserializeFilter(d.Element, element as ModifyDay); foreach (XmlNode childNode in d.Element.ChildNodes) { if (childNode.Name == RuleConstants.ModifyReplacedDayNodeName) { (element as ModifyDay).ModifyReplacedDay = SerializerRoot.Container <ModifyReplacedDay>() .Deserialize(new XmlDescriptor() { Element = childNode }); } else { (element as ModifyDay).ChildDateExp = SerializerRoot.Container <DateExpression>() .Deserialize(new XmlDescriptor() { Element = childNode }); } } }
/// <summary> /// Creates an element that represents a negative existential quantifier. /// </summary> /// <param name="source">Source element to apply the negative existential quantifier to.</param> /// <returns>Created element.</returns> public static NotElement Not(RuleElement source) { if (source == null) { throw new ArgumentNullException(nameof(source), "Source element not provided"); } var element = new NotElement(source); ElementValidator.ValidateNot(element); return(element); }
private static void AddRule(RuleElement rule) { using (CustomConfigSectionManager customConfigManager = new CustomConfigSectionManager()) { customConfigManager.AddRule(rule); } if (Rules == null) { Rules = new RuleElementCollection(); } Rules.Add(rule); }
public virtual RuleElement Deserialize(IDescriptor descriptor) { RuleElement element = null; if (descriptor is XmlDescriptor d) { element = CreateObject(d); FillObject(d, element); } return(element); }
protected override void FillObject(XmlDescriptor d, RuleElement element) { base.FillObject(d, element); if (d.Element.SelectSingleNode(RuleConstants.YmnosRuleNode) is XmlNode ymnosNode) { (element as TheotokionRule).ReferenceYmnos = SerializerRoot.Container <YmnosRule>() .Deserialize(new XmlDescriptor() { Element = ymnosNode }); } }
protected override void FillObject(XmlDescriptor d, RuleElement element) { foreach (XmlNode childNode in d.Element.ChildNodes) { var exp = SerializerRoot.Container <RuleExpression>() .Deserialize(new XmlDescriptor() { Element = childNode }); (element as LogicalExpression).ChildElements.Add(exp); } }
private void BuildTypeNode(ReteBuilderContext context, RuleElement element, Type declarationType) { TypeNode node = context.CurrentAlphaNode .ChildNodes.OfType <TypeNode>() .FirstOrDefault(tn => tn.FilterType.AsType() == declarationType); if (node == null) { node = new TypeNode(declarationType); context.CurrentAlphaNode.ChildNodes.Add(node); } node.NodeInfo.Add(context.Rule, element); context.CurrentAlphaNode = node; }