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);
}
}
