internal static IEnumerable <KeyValuePair <string, string> > GetRegexesInRulePackage(XDocument rulePackXDoc)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
return(from regexElement in rulePackXDoc.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Regex"))
let regexProcessorId = regexElement.Attribute("id").Value
select new KeyValuePair <string, string>(regexProcessorId, regexElement.Value));
}
private void ValidateAllRulesLangCodes(XDocument rulePackXDocument)
{
foreach (XElement ruleResourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")))
{
this.ValidateRuleLangCodes(ruleResourceElement);
}
}
internal static XDocument CreateRuleCollectionDocumentFromTemplate(string rulePackId, string organizationId, string organizationName)
{
ArgumentValidator.ThrowIfNullOrEmpty("rulePackId", rulePackId);
ArgumentValidator.ThrowIfNullOrEmpty("organizationId", organizationId);
ArgumentValidator.ThrowIfNullOrEmpty("organizationName", organizationName);
string text = string.Empty;
using (Stream stream = ClassificationDefinitionUtils.LoadStreamFromEmbeddedResource("FingerprintRulePackTemplate.xml"))
{
using (StreamReader streamReader = new StreamReader(stream))
{
text = streamReader.ReadToEnd();
}
}
if (string.IsNullOrEmpty(text))
{
throw new FingerprintRulePackTemplateCorruptedException("FingerprintRulePackTemplate.xml");
}
XDocument xdocument = XDocument.Parse(text);
XElement xelement = xdocument.Root.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("RulePack"));
xelement.SetAttributeValue("id", rulePackId);
XElement xelement2 = xelement.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("Publisher"));
xelement2.SetAttributeValue("id", organizationId);
foreach (XElement xelement3 in xelement.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("PublisherName")))
{
xelement3.SetValue(organizationName);
}
XmlProcessingUtils.SetRulePackVersionFromAssemblyFileVersion(xdocument);
return(xdocument);
}
private XElement GetRuleXElement()
{
List <XElement> list = new List <XElement>();
foreach (Fingerprint fingerprint in this.Fingerprints)
{
list.Add(new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Match"), new XAttribute("idRef", fingerprint.Identity)));
}
XElement xelement = list[0];
if (list.Count > 1)
{
xelement = new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Any"), new object[]
{
new XAttribute("minMatches", 1),
list
});
}
XElement xelement2 = new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Evidence"), new object[]
{
new XAttribute("confidenceLevel", 75),
xelement
});
return(new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Affinity"), new object[]
{
new XAttribute("id", ((DataClassificationObjectId)this.Identity).Name),
new XAttribute("evidencesProximity", 300),
new XAttribute("thresholdConfidenceLevel", 75),
xelement2
}));
}
internal static string AddFingerprintTextProcessor(XDocument rulePackXDoc, Fingerprint fingerprint)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
ArgumentValidator.ThrowIfNull("fingerprint", fingerprint);
XElement xelement = rulePackXDoc.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("LocalizedStrings")).FirstOrDefault <XElement>();
if (xelement == null)
{
throw new ClassificationRuleCollectionInvalidObjectException(Strings.ClassificationRuleCollectionInvalidObject);
}
XElement fingerprintProcessor = XmlProcessingUtils.GetFingerprintProcessor(rulePackXDoc, fingerprint);
if (fingerprintProcessor == null)
{
fingerprint.Identity = Guid.NewGuid().ToString();
fingerprint.ActualDescription = fingerprint.Description;
xelement.AddBeforeSelf(fingerprint.ToXElement());
}
else
{
fingerprint.Identity = XmlProcessingUtils.GetAttributeValue(fingerprintProcessor, "id");
string attributeValue = XmlProcessingUtils.GetAttributeValue(fingerprintProcessor, "description");
if (string.IsNullOrEmpty(attributeValue) && !string.IsNullOrEmpty(fingerprint.Description))
{
fingerprintProcessor.SetAttributeValue("description", fingerprint.Description);
fingerprint.ActualDescription = fingerprint.Description;
}
else
{
fingerprint.ActualDescription = attributeValue;
}
}
return(fingerprint.Identity);
}
private static IEnumerable <KeyValuePair <string, List <string> > > GetKeywordProcessorsTerms(XDocument rulePackXDocument)
{
return(from keywordElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Keyword"))
let keywordProcessorId = keywordElement.Attribute("id").Value
let keywordTermsList = (from termElement in keywordElement.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Term")).AsParallel <XElement>()
select termElement.Value).ToList <string>()
select new KeyValuePair <string, List <string> >(keywordProcessorId, keywordTermsList));
}
internal XElement ToXElement()
{
XElement xelement = new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Fingerprint"), new object[]
{
new XAttribute("id", this.Identity),
new XAttribute("shingleCount", this.ShingleCount),
new XAttribute("threshold", 50),
this.Value
});
xelement.SetAttributeValue("description", this.Description);
return(xelement);
}
internal static ClassificationRuleCollectionLocalizableDetails ReadRulePackageMetadata(XElement rulePackDetailsElement, CultureInfo cultureInfo = null)
{
ArgumentValidator.ThrowIfNull("rulePackDetailsElement", rulePackDetailsElement);
ClassificationRuleCollectionLocalizableDetails result;
try
{
string langCodeToUse = (cultureInfo != null) ? cultureInfo.Name : rulePackDetailsElement.Attribute("defaultLangCode").Value;
XElement xelement = (from localizedDetails in rulePackDetailsElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("LocalizedDetails")).AsParallel <XElement>()
where langCodeToUse.Equals(localizedDetails.Attribute("langcode").Value, StringComparison.OrdinalIgnoreCase)
select localizedDetails).SingleOrDefault <XElement>();
if (xelement != null)
{
string value = xelement.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name")).Value;
string value2 = xelement.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("PublisherName")).Value;
string value3 = xelement.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description")).Value;
result = new ClassificationRuleCollectionLocalizableDetails
{
Name = value,
PublisherName = value2,
Description = value3,
Culture = new CultureInfo(langCodeToUse, false)
};
}
else
{
if (cultureInfo == null)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents);
}
result = null;
}
}
catch (NullReferenceException innerException)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, innerException);
}
catch (InvalidOperationException innerException2)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, innerException2);
}
catch (AggregateException ex)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, ex.Flatten());
}
catch (CultureNotFoundException innerException3)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, innerException3);
}
return(result);
}
internal static XElement GetRulePackageMetadataElement(XDocument rulePackXDoc)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
XElement result;
try
{
result = rulePackXDoc.Root.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("RulePack")).Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("Details"));
}
catch (NullReferenceException innerException)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, innerException);
}
return(result);
}
internal static string GetRulePackId(XDocument rulePackXDoc)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
string result;
try
{
result = rulePackXDoc.Root.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("RulePack")).Attribute("id").Value.ToUpperInvariant();
}
catch (NullReferenceException innerException)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, innerException);
}
return(result);
}
internal static bool OptimizeRulePackXDoc(XDocument rulePackXDoc, DataClassificationConfig dataClassificationConfig)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
bool result = false;
XElement xelement = rulePackXDoc.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Rules")).FirstOrDefault <XElement>();
if (xelement == null)
{
throw new ClassificationRuleCollectionInvalidObjectException(Strings.ClassificationRuleCollectionInvalidObject);
}
List <XElement> list = (from versionElement in xelement.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Version"))
where versionElement.IsEmpty
select versionElement).ToList <XElement>();
foreach (XElement xelement2 in list)
{
xelement2.Remove();
result = true;
}
List <string> list2 = (from versionedTextProcessorReference in TextProcessorUtils.GetTextProcessorReferences(rulePackXDoc.Root)
select versionedTextProcessorReference.Key).Distinct(ClassificationDefinitionConstants.TextProcessorIdComparer).ToList <string>();
List <XElement> list3 = XmlProcessingUtils.GetFingerprintProcessorsInRulePackage(rulePackXDoc).ToList <XElement>();
foreach (XElement xelement3 in list3)
{
XAttribute xattribute = xelement3.Attribute("id");
string item = (xattribute == null) ? string.Empty : xattribute.Value;
if (list2.Contains(item))
{
if (dataClassificationConfig != null)
{
XAttribute xattribute2 = xelement3.Attribute("threshold");
if (xattribute2 != null && !dataClassificationConfig.FingerprintThreshold.ToString().Equals(xattribute2.Value, StringComparison.Ordinal))
{
xattribute2.Value = dataClassificationConfig.FingerprintThreshold.ToString();
result = true;
}
}
}
else
{
xelement3.Remove();
result = true;
}
}
return(result);
}
private static void ValidateDefaultValueCount(XDocument rulePackXDocument)
{
List <string> list = (from ruleResourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>().Where(delegate(XElement ruleResourceElement)
{
if (ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name")).Count((XElement nameElement) => nameElement.Attribute("default") != null && (bool)nameElement.Attribute("default")) == 1)
{
return(ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description")).Count((XElement descriptionElement) => descriptionElement.Attribute("default") != null && (bool)descriptionElement.Attribute("default")) != 1);
}
return(true);
})
select ruleResourceElement.Attribute("idRef").Value).ToList <string>();
if (list.Count > 0)
{
LocalizedString message = Strings.ClassificationRuleCollectionIncorrectNumberOfDefaultInRuleResources(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list));
throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionLocalizationInfoValidationException, List <string> >(new ClassificationRuleCollectionLocalizationInfoValidationException(message), list);
}
}
private XElement GetResourceXElement()
{
List <XElement> list = new List <XElement>();
list.Add(new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name"), new object[]
{
new XAttribute("default", "true"),
new XAttribute("langcode", this.defaultDetails.Culture.Name),
this.defaultDetails.Name
}));
foreach (KeyValuePair <CultureInfo, string> keyValuePair in this.localizedNames)
{
if (!this.defaultDetails.Culture.Equals(keyValuePair.Key))
{
list.Add(new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name"), new object[]
{
new XAttribute("langcode", keyValuePair.Key.Name),
keyValuePair.Value
}));
}
}
list.Add(new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description"), new object[]
{
new XAttribute("default", "true"),
new XAttribute("langcode", this.defaultDetails.Culture.Name),
this.defaultDetails.Description
}));
foreach (KeyValuePair <CultureInfo, string> keyValuePair2 in this.localizedDescriptions)
{
if (!this.defaultDetails.Culture.Equals(keyValuePair2.Key))
{
list.Add(new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description"), new object[]
{
new XAttribute("langcode", keyValuePair2.Key.Name),
keyValuePair2.Value
}));
}
}
return(new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource"), new object[]
{
new XAttribute("idRef", ((DataClassificationObjectId)this.Identity).Name),
list
}));
}
internal static bool IsRulePackageEncrypted(XDocument rulePackXDoc)
{
if (rulePackXDoc == null)
{
throw new ArgumentNullException("rulePackXDoc");
}
bool result;
try
{
XElement xelement = rulePackXDoc.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Encryption")).SingleOrDefault <XElement>();
result = (xelement != null);
}
catch (InvalidOperationException ex)
{
throw new XmlException(ex.Message, ex);
}
return(result);
}
internal static Version GetRulePackVersion(XDocument rulePackXDoc)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
Version result;
try
{
XElement xelement = rulePackXDoc.Root.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("RulePack")).Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("Version"));
ushort major = ushort.Parse(xelement.Attribute("major").Value);
ushort minor = ushort.Parse(xelement.Attribute("minor").Value);
ushort build = ushort.Parse(xelement.Attribute("build").Value);
ushort revision = ushort.Parse(xelement.Attribute("revision").Value);
result = new Version((int)major, (int)minor, (int)build, (int)revision);
}
catch (SystemException innerException)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, innerException);
}
return(result);
}
internal static void AddLocalizedResource(XDocument rulePackXDoc, string dataClassificationId, XElement localizedResource)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
ArgumentValidator.ThrowIfNullOrEmpty("dataClassificationId", dataClassificationId);
ArgumentValidator.ThrowIfNull("localizedResource", localizedResource);
XElement xelement = rulePackXDoc.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("LocalizedStrings")).FirstOrDefault <XElement>();
if (xelement == null)
{
throw new ClassificationRuleCollectionInvalidObjectException(Strings.ClassificationRuleCollectionInvalidObject);
}
List <XElement> list = (from resourceElement in xelement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource"))
where resourceElement.Attribute("idRef") != null && dataClassificationId.Equals(resourceElement.Attribute("idRef").Value, StringComparison.Ordinal)
select resourceElement).ToList <XElement>();
foreach (XElement xelement2 in list)
{
xelement2.Remove();
}
xelement.Add(localizedResource);
}
internal static Version SetRulePackVersionFromAssemblyFileVersion(XDocument rulePackXDoc)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
Version result;
try
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(executingAssembly.Location);
XElement xelement = rulePackXDoc.Root.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("RulePack")).Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("Version"));
xelement.Attribute("major").Value = versionInfo.FileMajorPart.ToString("D");
xelement.Attribute("minor").Value = versionInfo.FileMinorPart.ToString("D");
xelement.Attribute("build").Value = versionInfo.FileBuildPart.ToString("D");
xelement.Attribute("revision").Value = versionInfo.FilePrivatePart.ToString("D");
result = new Version(versionInfo.FileMajorPart, versionInfo.FileMinorPart, versionInfo.FileBuildPart, versionInfo.FilePrivatePart);
}
catch (NullReferenceException innerException)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, innerException);
}
return(result);
}
public void Validate(ValidationContext context, XDocument rulePackXDocument)
{
ArgumentValidator.ThrowIfNull("context", context);
ArgumentValidator.ThrowIfNull("rulePackXDocument", rulePackXDocument);
if (context.IsPayloadFingerprintsRuleCollection)
{
HashSet <string> hashSet = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (XElement xelement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")))
{
HashSet <string> hashSet2 = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (XElement xelement2 in xelement.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name")))
{
hashSet2.Add(xelement2.Value);
}
List <string> list = hashSet.Intersect(hashSet2).ToList <string>();
if (list.Count > 0)
{
throw new DataClassificationNonUniqueNameViolationException(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list));
}
hashSet.UnionWith(hashSet2);
}
}
}
internal static void AddDataClassification(XDocument rulePackXDoc, string dataClassificationId, string version, XElement dataClassificationXElement)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
ArgumentValidator.ThrowIfNullOrEmpty("dataClassificationId", dataClassificationId);
ArgumentValidator.ThrowIfNullOrEmpty("version", version);
ArgumentValidator.ThrowIfNull("dataClassificationXElement", dataClassificationXElement);
List <QueryMatchResult> list = XmlProcessingUtils.GetMatchingRulesById(rulePackXDoc, new List <string>
{
dataClassificationId
}).ToList <QueryMatchResult>();
if (list.Count == 1)
{
list[0].MatchingRuleXElement.Remove();
}
else if (list.Count > 1)
{
throw new ClassificationRuleCollectionInvalidObjectException(Strings.ClassificationRuleCollectionInvalidObject);
}
XElement xelement = rulePackXDoc.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Rules")).FirstOrDefault <XElement>();
if (xelement == null)
{
throw new ClassificationRuleCollectionInvalidObjectException(Strings.ClassificationRuleCollectionInvalidObject);
}
XElement xelement2 = (from versionElement in xelement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Version"))
where versionElement.Attribute("minEngineVersion") != null && version.Equals(versionElement.Attribute("minEngineVersion").Value, StringComparison.OrdinalIgnoreCase)
select versionElement).FirstOrDefault <XElement>();
if (xelement2 == null)
{
xelement2 = new XElement(XmlProcessingUtils.GetMceNsQualifiedNodeName("Version"), new XAttribute("minEngineVersion", version));
xelement.AddFirst(xelement2);
}
xelement2.Add(dataClassificationXElement);
}
internal static IEnumerable <QueryMatchResult> GetMatchingRulesByName(XDocument rulePackXDocument, IEnumerable <string> ruleNameQueries, NameMatchingOptions matchingOption = NameMatchingOptions.InvariantNameOrLocalizedNameMatch, bool ignoreCase = true)
{
ArgumentValidator.ThrowIfNull("rulePackXDocument", rulePackXDocument);
ArgumentValidator.ThrowIfNull("ruleNameQueries", ruleNameQueries);
ArgumentValidator.ThrowIfInvalidValue <NameMatchingOptions>("matchingOption", matchingOption, (NameMatchingOptions nameMatchingOption) => nameMatchingOption == NameMatchingOptions.InvariantNameMatchOnly || NameMatchingOptions.InvariantNameOrLocalizedNameMatch == nameMatchingOption);
List <string> ruleNameQueriesList = new List <string>((from query in ruleNameQueries
where !string.IsNullOrEmpty(query)
select query).OrderBy((string query) => query, ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal));
if (ruleNameQueriesList.Count == 0)
{
return(Enumerable.Empty <QueryMatchResult>());
}
CultureInfo currentThreadCulture = CultureInfo.CurrentCulture;
ParallelQuery <QueryMatchResult> parallelQuery;
if (matchingOption != NameMatchingOptions.InvariantNameMatchOnly)
{
parallelQuery = from resourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>()
let queryHitIndex = XmlProcessingUtils.GetInvariantOrLocalizedNameHitIndex(ruleNameQueriesList, resourceElement, currentThreadCulture, ignoreCase)
where queryHitIndex >= 0
let ruleIdRef = resourceElement.Attribute("idRef").Value
let finalRuleIdRef = string.IsNullOrEmpty(ruleIdRef) ? null : ruleIdRef
select new QueryMatchResult
{
QueryString = ruleNameQueriesList[queryHitIndex],
MatchingResourceXElement = resourceElement,
MatchingRuleId = finalRuleIdRef,
MatchingRuleXElement = null
};
}
else
{
parallelQuery = from resourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>()
let invariantLocalizedNameDetails = XmlProcessingUtils.ReadDefaultRuleMetadata(resourceElement)
let queryHitIndex = ruleNameQueriesList.BinarySearch(invariantLocalizedNameDetails.Name, StringComparer.Create(invariantLocalizedNameDetails.Culture, ignoreCase))
where queryHitIndex >= 0
let ruleIdRef = resourceElement.Attribute("idRef").Value
let finalRuleIdRef = string.IsNullOrEmpty(ruleIdRef) ? null : ruleIdRef
select new QueryMatchResult
{
QueryString = ruleNameQueriesList[queryHitIndex],
MatchingResourceXElement = resourceElement,
MatchingRuleId = finalRuleIdRef,
MatchingRuleXElement = null
};
}
ParallelQuery <QueryMatchResult> mainQuery = parallelQuery;
return(XmlProcessingUtils.ExecuteQueryMatching(mainQuery, (Dictionary <string, QueryMatchResult> queryMatchResultsDictionary) => from ruleElement in rulePackXDocument.Descendants().AsParallel <XElement>()
where ClassificationDefinitionConstants.MceRuleElementNames.Contains(ruleElement.Name.LocalName)
let ruleId = (string)ruleElement.Attribute("id")
let finalRuleId = string.IsNullOrEmpty(ruleId) ? null : ruleId
where queryMatchResultsDictionary.ContainsKey(finalRuleId)
select new KeyValuePair <string, XElement>(finalRuleId, ruleElement), delegate(Dictionary <string, QueryMatchResult> queryMatchResultsDictionary, KeyValuePair <string, XElement> matchAssociation)
{
queryMatchResultsDictionary[matchAssociation.Key].MatchingRuleXElement = matchAssociation.Value;
}, new Func <string, LocalizedString>(Strings.ClassificationRuleCollectionOrphanedResourceViolation)));
}
internal static IEnumerable <XElement> GetFingerprintProcessorsInRulePackage(XDocument rulePackXDoc)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
return(rulePackXDoc.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Fingerprint")));
}
private static void ValidateDefaultValueLangCodesConsistency(XDocument rulePackXDocument)
{
List <string> list = (from ruleResourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>()
let defaultNameLangCode = ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name")).Single((XElement nameElement) => nameElement.Attribute("default") != null && (bool)nameElement.Attribute("default")).Attribute("langcode").Value
let defaultDescriptionLangCode = ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description")).Single((XElement descriptionElement) => descriptionElement.Attribute("default") != null && (bool)descriptionElement.Attribute("default")).Attribute("langcode").Value
where !new CultureInfo(defaultNameLangCode).Equals(new CultureInfo(defaultDescriptionLangCode))
select ruleResourceElement.Attribute("idRef").Value).ToList <string>();
if (list.Count > 0)
{
LocalizedString message = Strings.ClassificationRuleCollectionInconsistentDefaultInRuleResource(string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, list));
throw ClassificationDefinitionUtils.PopulateExceptionSource <ClassificationRuleCollectionLocalizationInfoValidationException, List <string> >(new ClassificationRuleCollectionLocalizationInfoValidationException(message), list);
}
}
private static Dictionary <string, int> GetKeywordProcessorTermsCount(XDocument rulePackXDocument)
{
return((from keywordElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Keyword"))
select keywordElement).ToDictionary((XElement keywordElement) => keywordElement.Attribute("id").Value, (XElement keywordElement) => keywordElement.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Term")).AsParallel <XElement>().Count <XElement>()));
}
internal static Dictionary <CultureInfo, string> ReadAllRuleDescriptions(XElement ruleResourceElement)
{
return(XmlProcessingUtils.ReadLocalizableRuleDetails(ruleResourceElement, XmlProcessingUtils.GetMceNsQualifiedNodeName("Description")));
}
internal static DataClassificationLocalizableDetails ReadDefaultRuleMetadata(XElement ruleResourceElement)
{
ArgumentValidator.ThrowIfNull("ruleResourceElement", ruleResourceElement);
XElement xelement = (from ruleNameElement in ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name"))
where ruleNameElement.Attribute("default") != null && (bool)ruleNameElement.Attribute("default")
select ruleNameElement).FirstOrDefault <XElement>();
XElement xelement2 = (from ruleDescriptionElement in ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description"))
where ruleDescriptionElement.Attribute("default") != null && (bool)ruleDescriptionElement.Attribute("default")
select ruleDescriptionElement).FirstOrDefault <XElement>();
if (xelement == null || xelement2 == null)
{
throw new XmlException(Strings.ClassificationRuleCollectionIncorrectNumberOfDefaultInRuleResources(ruleResourceElement.Attribute("idRef").Value));
}
string name = xelement.Value.Trim();
string description = xelement2.Value.Trim();
CultureInfo culture;
try
{
CultureInfo cultureInfo = new CultureInfo(xelement.Attribute("langcode").Value, false);
CultureInfo obj = new CultureInfo(xelement2.Attribute("langcode").Value, false);
if (!cultureInfo.Equals(obj))
{
throw new XmlException(Strings.ClassificationRuleCollectionInconsistentDefaultInRuleResource(ruleResourceElement.Attribute("idRef").Value));
}
culture = cultureInfo;
}
catch (NullReferenceException innerException)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, innerException);
}
catch (CultureNotFoundException innerException2)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, innerException2);
}
return(new DataClassificationLocalizableDetails
{
Name = name,
Description = description,
Culture = culture
});
}
private void ValidateRuleLangCodes(XElement ruleResourceElement)
{
ExAssert.RetailAssert(ruleResourceElement != null, "The resource element to be validated must not be null!");
string resourceIdRef = ruleResourceElement.Attribute("idRef").Value;
IEnumerable <string> langCodes = from nameElement in ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name"))
select nameElement.Attribute("langcode").Value;
base.ValidateResourceLangCodes(langCodes, (IEnumerable <string> invalidLangCodes) => Strings.ClassificationRuleCollectionInvalidLangCodesInRuleName(resourceIdRef, string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, invalidLangCodes)), (IEnumerable <string> nonUniqueLangCodes) => Strings.ClassificationRuleCollectionNonUniqueLangCodesInRuleName(resourceIdRef, string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, nonUniqueLangCodes)));
IEnumerable <string> langCodes2 = from descriptionElement in ruleResourceElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description"))
select descriptionElement.Attribute("langcode").Value;
base.ValidateResourceLangCodes(langCodes2, (IEnumerable <string> invalidLangCodes) => Strings.ClassificationRuleCollectionInvalidLangCodesInRuleDescription(resourceIdRef, string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, invalidLangCodes)), (IEnumerable <string> nonUniqueLangCodes) => Strings.ClassificationRuleCollectionNonUniqueLangCodesInRuleDescription(resourceIdRef, string.Join(Strings.ClassificationRuleCollectionOffendingListSeparator, nonUniqueLangCodes)));
}
internal static MultiValuedProperty <Fingerprint> ReadAllReferredFingerprints(XElement ruleElement)
{
ArgumentValidator.ThrowIfNull("ruleElement", ruleElement);
ArgumentValidator.ThrowIfNull("ruleElement.Document", ruleElement.Document);
List <string> distinctTextProcessorRefs = (from versionedTextProcessorReference in TextProcessorUtils.GetTextProcessorReferences(ruleElement)
select versionedTextProcessorReference.Key).Distinct(ClassificationDefinitionConstants.TextProcessorIdComparer).ToList <string>();
IEnumerable <Fingerprint> value = from fingerprintElement in ruleElement.Document.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Fingerprint"))
where distinctTextProcessorRefs.Contains(XmlProcessingUtils.GetAttributeValue(fingerprintElement, "id"))
let fingerprint = Fingerprint.FromXElement(fingerprintElement)
select fingerprint;
return(new MultiValuedProperty <Fingerprint>(value));
}
private static XElement GetFingerprintProcessor(XDocument rulePackXDoc, Fingerprint fingerprint)
{
return((from fingerprintElement in rulePackXDoc.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Fingerprint"))
where fingerprintElement.Attribute("shingleCount") != null && string.Equals(fingerprintElement.Attribute("shingleCount").Value, fingerprint.ShingleCount.ToString(), StringComparison.OrdinalIgnoreCase) && string.Equals(fingerprintElement.Value, fingerprint.Value, StringComparison.Ordinal)
select fingerprintElement).FirstOrDefault <XElement>());
}
internal static Dictionary <CultureInfo, ClassificationRuleCollectionLocalizableDetails> ReadAllRulePackageMetadata(XElement rulePackDetailsElement)
{
ArgumentValidator.ThrowIfNull("rulePackDetailsElement", rulePackDetailsElement);
ParallelQuery <ClassificationRuleCollectionLocalizableDetails> source = from localizedDetailsElement in rulePackDetailsElement.Elements(XmlProcessingUtils.GetMceNsQualifiedNodeName("LocalizedDetails")).AsParallel <XElement>()
let name = localizedDetailsElement.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("Name")).Value
let publisherName = localizedDetailsElement.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("PublisherName")).Value
let description = localizedDetailsElement.Element(XmlProcessingUtils.GetMceNsQualifiedNodeName("Description")).Value
let langCode = localizedDetailsElement.Attribute("langcode").Value
select new ClassificationRuleCollectionLocalizableDetails
{
Name = name,
PublisherName = publisherName,
Description = description,
Culture = new CultureInfo(langCode, false)
};
Dictionary <CultureInfo, ClassificationRuleCollectionLocalizableDetails> result;
try
{
Dictionary <CultureInfo, ClassificationRuleCollectionLocalizableDetails> dictionary = source.ToDictionary((ClassificationRuleCollectionLocalizableDetails localizedDetails) => localizedDetails.Culture, (ClassificationRuleCollectionLocalizableDetails localizedDetails) => localizedDetails);
result = dictionary;
}
catch (AggregateException ex)
{
throw new XmlException(Strings.ClassificationRuleCollectionUnexpectedContents, ex.Flatten());
}
return(result);
}
internal static IEnumerable <QueryMatchResult> GetMatchingRulesById(XDocument rulePackXDocument, ISet <string> ruleIdQuerySet = null)
{
ArgumentValidator.ThrowIfNull("rulePackXDocument", rulePackXDocument);
ParallelQuery <QueryMatchResult> parallelQuery;
if (ruleIdQuerySet != null)
{
parallelQuery = from rulePackElement in rulePackXDocument.Descendants().AsParallel <XElement>()
where ClassificationDefinitionConstants.MceRuleElementNames.Contains(rulePackElement.Name.LocalName)
let ruleId = rulePackElement.Attribute("id").Value
let finalRuleId = string.IsNullOrEmpty(ruleId) ? null : ruleId
where ruleIdQuerySet.Contains(finalRuleId)
select new QueryMatchResult
{
QueryString = finalRuleId,
MatchingRuleId = finalRuleId,
MatchingRuleXElement = rulePackElement
};
}
else
{
parallelQuery = from rulePackElement in rulePackXDocument.Descendants().AsParallel <XElement>()
where ClassificationDefinitionConstants.MceRuleElementNames.Contains(rulePackElement.Name.LocalName)
let ruleId = rulePackElement.Attribute("id").Value
let finalRuleId = string.IsNullOrEmpty(ruleId) ? null : ruleId
select new QueryMatchResult
{
MatchingRuleId = finalRuleId,
MatchingRuleXElement = rulePackElement
};
}
ParallelQuery <QueryMatchResult> mainQuery = parallelQuery;
return(XmlProcessingUtils.ExecuteQueryMatching(mainQuery, (Dictionary <string, QueryMatchResult> queryMatchResultsDictionary) => from resourceElement in rulePackXDocument.Descendants(XmlProcessingUtils.GetMceNsQualifiedNodeName("Resource")).AsParallel <XElement>()
let ruleIdRef = (string)resourceElement.Attribute("idRef")
where queryMatchResultsDictionary.ContainsKey(ruleIdRef)
select new KeyValuePair <string, XElement>(ruleIdRef, resourceElement), delegate(Dictionary <string, QueryMatchResult> queryMatchResultsDictionary, KeyValuePair <string, XElement> matchAssociation)
{
queryMatchResultsDictionary[matchAssociation.Key].MatchingResourceXElement = matchAssociation.Value;
}, new Func <string, LocalizedString>(Strings.ClassificationRuleCollectionResourceNotFoundViolation)));
}
