public static bool ValidateIntraPolicy(string policyName, IPolicyObjectCollection<IPolicyObject> conditions, PolicySetValidator.AddViolationMessageHandler AddMessage) { bool result = true; foreach (IPolicyObject policyObject in conditions) { if (policyObject is ICondition) { if (policyObject.Name.Value.Length > MAX_NAME_LENGTH) { if (null != AddMessage) { AddMessage(policyName, Properties.Resources.CONDITION_SHORTNAME_TOO_LONG, true); } result = false; } } else { result = ValidateIntraPolicy(policyName, (policyObject as IConditionGroup).Conditions, AddMessage); if (!FileTypeExpressionValidator.ValidateIntraPolicy(policyName, policyObject, AddMessage)) { result = false; } if (!FileSizeExpressionValidator.ValidateIntraPolicy(policyName, policyObject, AddMessage)) { result = false; } } } return result; }
private IPolicyObjectCollection<IPolicyObject> FilterConditions(ConditionLogic logic, IPolicyObjectCollection<IPolicyObject> conditions) { if (null == conditions) return null; IPolicyObjectCollection<IPolicyObject> reducedConditions = new PolicyObjectCollection<IPolicyObject>(); foreach (IPolicyObject policyObject in conditions) { if (ConditionContainsFilter(policyObject as ICondition)) { reducedConditions.Add((policyObject as Condition).DeepCopy(policyObject.ReadOnly, true)); } else if(policyObject is IConditionGroup) { IConditionGroup conditionGroup = policyObject as IConditionGroup; ConditionGroup reducedConditionGroup = new ConditionGroup(Guid.NewGuid(), conditionGroup.Name, conditionGroup.Logic, conditionGroup.ExitOnFirstPass); reducedConditionGroup.AddConditions(FilterConditions(conditionGroup.Logic, conditionGroup.Conditions)); if (0 != reducedConditionGroup.Conditions.Count) { reducedConditions.Add(reducedConditionGroup); } } } return reducedConditions; }
public XmlConditionGroupReader(XmlPolicyReader reader, object parent, string xpath) : base(reader, parent, xpath) { m_xpath += "/*"; m_availableConditionGroups = m_reader.CataloguesCache.ConditionGroups; }
public ConditionGroup(Guid guid, IPolicyLanguageItem name, ConditionLogic logic, bool exitOnFirstPass) : base(guid, name) { m_logic = logic; m_exitOnFirstPass = exitOnFirstPass; m_conditions = new PolicyObjectCollection<IPolicyObject>(); }
private string ArePoliciesDifferent(IPolicyObjectCollection<IPolicy> lhs, IPolicyObjectCollection<IPolicy> rhs) { if (lhs.Count != rhs.Count) { PolicyLogger logger = new PolicyLogger(m_testPath); logger.WritePolicies("lhs", lhs); logger.WritePolicies("rhs", rhs); return string.Format("Expected the resultant policy set to have the same amount of policies as the expected policy set. Expected {0} but got {1}", lhs.Count, rhs.Count); } System.Collections.IEnumerator lhsPoliciesEnumerator = lhs.GetEnumerator(); System.Collections.IEnumerator rhsPoliciesEnumerator = rhs.GetEnumerator(); while (lhsPoliciesEnumerator.MoveNext() && rhsPoliciesEnumerator.MoveNext()) { IPolicy lhsPolicy = lhsPoliciesEnumerator.Current as IPolicy; IPolicy rhsPolicy = rhsPoliciesEnumerator.Current as IPolicy; string errorMessage = DoConditonsMatch(lhsPolicy.Conditions, rhsPolicy.Conditions); if (string.Empty != errorMessage) { return errorMessage; } if (lhsPolicy.Channels.Count != rhsPolicy.Channels.Count) { return "The policy channels have not been copied across"; } } return string.Empty; }
private void ReadDataItem(XmlNode dataNode, DataType dataType, IPolicyObjectCollection<IDataItem> dataItemCollection) { if (dataNode.Name != "DataItem") return; dataItemCollection.Add(new XmlDataItemReader(dataNode, dataType).Read()); }
private void ReadDataSource(XmlNode dataNode, IPolicyObjectCollection<IDataSource> dataSourceCollection) { if (dataNode.Name != "DataSource") return; dataSourceCollection.Add(new XmlDataSourceReader(dataNode).Read()); }
public void WriteChildCollection(IPolicySet policySet, IPolicyObject parent, string name, IPolicyObjectCollection<IPolicyObject> collection) { if (parent == null) return; IPolicy policy = parent as IPolicy; if (policy == null) return; string ruleXpath = string.Format(CultureInfo.InvariantCulture, "PolicySet[@id='{0}']/Policies/Policy[@id='{1}']", XmlHelpers.GetPolicyObjectIdString(policySet), XmlHelpers.GetPolicyObjectIdString(parent)); XmlNode xmlRuleNode = m_policieSetsNode.SelectSingleNode(ruleXpath); if (xmlRuleNode == null) { new XmlCataloguePolicyWriter(m_xmlRootNode, policy).Write(); xmlRuleNode = m_xmlRootNode.SelectSingleNode(ruleXpath); } if (collection.Count == 0) return; IPolicyChannel channel = collection[0] as IPolicyChannel; if (channel == null) { new XmlConditionsWriter(xmlRuleNode, collection).Write(); } else { new XmlPolicyChannelsWriter(xmlRuleNode, collection).Write(); } }
private void SetDefaults(string assembly, string className, RunAt runAtMode, bool overrideMode, int precedence, bool readOnly) { m_assembly = assembly; m_className = className; m_runAtMode = runAtMode; m_override = overrideMode; m_precedence = precedence; m_dataElements = new PolicyObjectCollection<IDataElement>(readOnly); m_fileTypes = new PolicyObjectCollection<IActionFiletype>(readOnly); }
public ConditionGroup(ConditionGroup conditionGroup, IPolicyObjectCollection<IPolicyObject> conditions) : base(conditionGroup) { if (null == conditionGroup) throw new Workshare.Policy.Exceptions.ArgumentNullException("conditionGroup", "Input condition group is null"); m_parent = conditionGroup.m_parent; m_logic = conditionGroup.Logic; m_exitOnFirstPass = conditionGroup.ExitOnFirstPass; m_conditions = new PolicyObjectCollection<IPolicyObject>(conditions as PolicyObjectCollection<IPolicyObject>); }
private void AddPoliciesToPolicySet(IPolicySet policySet, IPolicyObjectCollection<IPolicy> policies) { foreach (IPolicy policy in policies) { // This will force the policy to read the conditions from the test file if the policy has any. if (null == policy.Conditions) continue; } (policySet as PolicySet).Policies = policies; }
public static string[] PolicyObjectModelStringArrayToStringArray(IPolicyObjectCollection<IDataItem> dataItems) { if (null == dataItems) return new string[0]; string[] items = new string[dataItems.Count]; for (int index = 0; index < dataItems.Count; ++index) { items[index] = (string)dataItems[index].Value; } return items; }
private void WriteParameters(XmlNode xmlDataMethod, IPolicyObjectCollection<IParameter> parameters) { XmlNode xmlParameters = m_xmlDocument.CreateElement("Parameters"); xmlDataMethod.AppendChild(xmlParameters); foreach (IParameter parameter in parameters) { XmlNode xmlParameter = m_xmlDocument.CreateElement("Parameter"); xmlParameters.AppendChild(xmlParameter); XmlHelpers.AddLanguageItemAttribute(xmlParameter, "name", parameter.Name); XmlHelpers.AddReadOnlyAttribute(xmlParameter, parameter.ReadOnly); new XmlCustomAttributesWriter(xmlParameter, parameter).Write(); WriteDataElementData(xmlParameter, parameter.Value); } }
private void CopyConditionGroup(ConditionGroup conditionGroup) { if (null == conditionGroup) throw new Workshare.Policy.Exceptions.ArgumentNullException("conditionGroup", "Input condition group is null"); m_parent = conditionGroup.m_parent; m_logic = conditionGroup.Logic; m_exitOnFirstPass = conditionGroup.ExitOnFirstPass; m_policySetObserver = conditionGroup.PolicySetObserver; if (null != conditionGroup.Conditions) { m_conditions = new PolicyObjectCollection<IPolicyObject>(conditionGroup.Conditions as PolicyObjectCollection<IPolicyObject>); (m_conditions as PolicyObjectCollection<IPolicyObject>).PolicySetObserver = m_policySetObserver; } }
public void WritePolicies(string comment, IPolicyObjectCollection<IPolicy> policies) { using (System.IO.StreamWriter writer = new System.IO.StreamWriter(m_testPath + "TestPolicyConditionFilter.txt", true)) { writer.WriteLine("------------------------------------------------------------------------"); writer.WriteLine(comment); writer.WriteLine("------------------------------------------------------------------------"); IPolicyCatalogue catalogue = null; foreach (IPolicy policy in policies) { WritePolicy(writer, policy); catalogue = policy.PolicySet.MasterCatalogue; } WriteCalalogue(writer, catalogue); } }
/// <summary> /// Returns the formatted text to display for a collection of IDataItem objects /// </summary> /// <param name="items">The collection of IDataItem objects</param> /// <returns>The formatted text to display</returns> public static string GetLinkText(IPolicyObjectCollection<IDataItem> items, int maxLength) { StringBuilder display = new StringBuilder(); foreach (IDataItem item in items) { if (display.Length > 0) display.Append(", "); display.Append(item.Value); if (display.Length > maxLength) { display.Length = maxLength - 3; display.Append("..."); break; } } return display.ToString(); }
public static bool ValidateExpressionsExist(string policyName, IPolicyObjectCollection<IPolicyObject> conditions) { foreach (IPolicyObject condition in conditions) { if (condition is ICondition) { // Return true when we find the first condition. // There should be at least one condition defined. return true; } if (ValidateExpressionsExist(policyName, (condition as IConditionGroup).Conditions)) { // If a condition has been found in the condition group, return true. return true; } } return false; }
private void WriteConditions(System.IO.StreamWriter writer, IPolicyObjectCollection<IPolicyObject> conditions) { foreach (IPolicyObject po in conditions) { writer.WriteLine(string.Format("{0} {1}", po is ICondition ? "Condition:" : "ConditionGroup:", po.Name.Value)); if (po is ICondition) { ICondition condition = po as ICondition; writer.WriteLine(string.Format("Class: {0}", condition.Class)); writer.WriteLine(string.Format("Operator: {0}", condition.Operator.ToString())); writer.WriteLine(string.Format("Data left: {0}", condition.DataLeft.Name.Value)); WriteDataElement(writer, condition.DataLeft); writer.WriteLine(string.Format("Data right: {0}", condition.DataRight.Name.Value)); WriteDataElement(writer, condition.DataRight); } else if (po is IConditionGroup) { WriteConditions(writer, (po as IConditionGroup).Conditions); } } }
public static bool ValidateIntraPolicy(string policyName, IPolicyObjectCollection<IPolicyChannel> channels, PolicySetValidator.AddViolationMessageHandler AddMessage) { bool valid = true; List<IPolicyChannel> validChannels = new List<IPolicyChannel>(); List<IPolicyChannel> invalidChannels = new List<IPolicyChannel>(); foreach (IPolicyChannel channel in channels) { if (ValidateChannelActions(policyName, channel.Actions, AddMessage)) { validChannels.Add(channel); } else { invalidChannels.Add(channel); } } if (validChannels.Count == 0) { valid = false; if (null != AddMessage) AddMessage(policyName, Properties.Resources.VALIDATION_INTRAPOLICY_NO_ACTIONS, true); } foreach (IPolicyChannel channel in validChannels) { if (ChannelType.ActiveContent == channel.Type) continue; if (!ValidateRoutingItemCollections(policyName, channel, AddMessage)) { valid = false; } } return valid; }
private string DoConditonsMatch(IPolicyObjectCollection<IPolicyObject> lhsConditions, IPolicyObjectCollection<IPolicyObject> rhsConditions) { if (lhsConditions.Count != rhsConditions.Count) { return string.Format("The resultant policy does not contain the expected number of conditions. Expected {0} but got {1}", lhsConditions.Count, rhsConditions.Count); } System.Collections.IEnumerator lhsConditionsEnumerator = lhsConditions.GetEnumerator(); System.Collections.IEnumerator rhsConditionsEnumerator = rhsConditions.GetEnumerator(); while (lhsConditionsEnumerator.MoveNext() && rhsConditionsEnumerator.MoveNext()) { IPolicyObject lhsCondition = lhsConditionsEnumerator.Current as IPolicyObject; IPolicyObject rhsCondition = rhsConditionsEnumerator.Current as IPolicyObject; if (rhsCondition is ICondition) { if (0 != string.Compare(lhsCondition.Name.Value, rhsCondition.Name.Value, true)) { return "The expression names do not match the expected expression names"; } else if (!AreConditionsEqual(lhsCondition as ICondition, rhsCondition as ICondition)) { return "The expression date do not match the expected expression data"; } } else if (rhsCondition is IConditionGroup) { string errorMessage = DoConditonsMatch((lhsCondition as IConditionGroup).Conditions, (rhsCondition as IConditionGroup).Conditions); if (string.Empty != errorMessage) { return errorMessage; } } } return string.Empty; }
public static void AddCustomAttributes(XmlNode parentNode, IPolicyObjectCollection<IPolicyObject> policyObjectCollection) { AddCustomAttributes(parentNode, policyObjectCollection.GetAttributeEnumerator()); }
private bool EffectivelyAllFileTypesSelected(List<Workshare.Policy.FileType> availableFileTypes, IPolicyObjectCollection<IDataItem> dataItemCollection) { int count = dataItemCollection.Count; if (availableFileTypes.Contains(Workshare.Policy.FileType.Selection)) count++; if (availableFileTypes.Count == count) return true; return false; }
private void WriteActionConditionGroups(XmlNode xmlParentNode, IPolicyObjectCollection<IActionConditionGroup> actionConditionGroups) { foreach (IActionConditionGroup actionConditionGroup in actionConditionGroups) { XmlNode xmlConditionGroupNode = m_xmlDocument.CreateElement("ConditionGroup"); xmlParentNode.AppendChild(xmlConditionGroupNode); XmlHelpers.AddIdAttribute(xmlConditionGroupNode, actionConditionGroup); XmlHelpers.AddReadOnlyAttribute(xmlConditionGroupNode, actionConditionGroup.ReadOnly); WriteActionGroup(xmlConditionGroupNode, actionConditionGroup.ActionGroup); } }
private void WriteActions(XmlNode xmlParentNode, IPolicyObjectCollection<IAction> actions) { foreach (IAction action in actions) { XmlNode xmlActionNode = m_xmlDocument.CreateElement("Action"); xmlParentNode.AppendChild(xmlActionNode); string id = XmlHelpers.GetPolicyObjectIdString(action); XmlHelpers.AddAttribute(xmlActionNode, "id", id); XmlHelpers.AddReadOnlyAttribute(xmlActionNode, action.ReadOnly); } }
private void WriteActionGroups(XmlNode xmlParentNode, IPolicyObjectCollection<IActionGroup> actionGroups) { foreach (IActionGroup subActionGroup in actionGroups) { WriteActionGroup(xmlParentNode, subActionGroup); } }
public XmlDataElementsWriter(XmlNode xmlParentNode, IDataElement dataElement) : base(xmlParentNode) { m_dataElements = new PolicyObjectCollection<IDataElement>(); m_dataElements.Add(dataElement); }
public XmlDataElementsWriter(XmlNode xmlParentNode, IPolicyObjectCollection<IDataElement> dataElements) : base(xmlParentNode) { m_dataElements = dataElements; }
public XmlDataSourcesCatalogueWriter(XmlNode xmlParentNode, XmlPolicyCatalogueWriter policyCatalogueWriter, object data, DataType dataType) : base(xmlParentNode, policyCatalogueWriter) { m_dataSources = data as IPolicyObjectCollection<IDataSource>; m_dataType = dataType; }
internal static List<Workshare.Policy.ObjectModel.IAction> ExtractActionsFromActionGroups(IPolicyObjectCollection<IActionConditionGroup> groups, IPolicySet policyset, bool checkForAllowInterpolicyDuplicates) { List<Workshare.Policy.ObjectModel.IAction> returnVal = new List<Workshare.Policy.ObjectModel.IAction>(); foreach (IActionConditionGroup group in groups) { foreach (Workshare.Policy.ObjectModel.IAction action in group.ActionGroup.Actions) { if (checkForAllowInterpolicyDuplicates && CanHaveInterPolicyDuplicates(action, policyset)) continue; returnVal.Add(action); } } return returnVal; }
private void WriteParameters(System.IO.StreamWriter writer, IPolicyObjectCollection<IParameter> parameters) { writer.WriteLine("Parameters"); foreach (IParameter parameter in parameters) { WriteDataElement(writer, parameter.Value); } }