internal static Dictionary <string, HashSet <string> > GetAllClassificationIdentifiers(OrganizationId organizationId, IConfigurationSession openedDataSession = null, Func <TransportRule, bool> inclusiveFilter = null, QueryFilter additionalFilter = null, IClassificationDefinitionsDataReader dataReader = null, IClassificationDefinitionsDiagnosticsReporter classificationDefinitionsDiagnosticsReporter = null)
{
IClassificationDefinitionsDiagnosticsReporter classificationDefinitionsDiagnosticsReporter2 = classificationDefinitionsDiagnosticsReporter ?? ClassificationDefinitionsDiagnosticsReporter.Instance;
Dictionary <string, HashSet <string> > dictionary = new Dictionary <string, HashSet <string> >(ClassificationDefinitionConstants.RuleCollectionIdComparer);
foreach (Tuple <TransportRule, XDocument> tuple in DlpUtils.AggregateOobAndCustomClassificationDefinitions(organizationId, openedDataSession, inclusiveFilter, additionalFilter, dataReader, classificationDefinitionsDiagnosticsReporter2))
{
TransportRule item = tuple.Item1;
XDocument item2 = tuple.Item2;
ExAssert.RetailAssert(item2 != null, "XDocument instance returned from AggregateOobAndCustomClassificationDefinitions should never be null!");
string rulePackId;
HashSet <string> value;
try
{
rulePackId = XmlProcessingUtils.GetRulePackId(item2);
value = new HashSet <string>(XmlProcessingUtils.GetAllRuleIds(item2), ClassificationDefinitionConstants.RuleIdComparer);
}
catch (XmlException ex)
{
ClassificationDefinitionsDiagnosticsReporter.Instance.WriteCorruptRulePackageDiagnosticsInformation(0, organizationId, item.DistinguishedName, new AggregateException(new Exception[]
{
ex
}).Flatten());
continue;
}
ExAssert.RetailAssert(!dictionary.ContainsKey(rulePackId), "Duplicate classification rule collection ID '{0}' under tenant's organization '{1}' is a should never ever happen case", new object[]
{
rulePackId,
organizationId.ToString()
});
dictionary.Add(rulePackId, value);
}
return(dictionary);
}
private string ValidateAndReadMetadata(byte[] rulePackageRawData)
{
string result = null;
try
{
XDocument xdocument = XmlProcessingUtils.ValidateRulePackageXmlContentsLite(rulePackageRawData);
this.rulePackageIdentifier = XmlProcessingUtils.GetRulePackId(xdocument);
this.rulePackVersion = (this.InstallDefaultCollection ? XmlProcessingUtils.SetRulePackVersionFromAssemblyFileVersion(xdocument) : XmlProcessingUtils.GetRulePackVersion(xdocument));
ClassificationRuleCollectionIdParameter classificationRuleCollectionIdParameter = ClassificationRuleCollectionIdParameter.Parse("*");
classificationRuleCollectionIdParameter.ShouldIncludeOutOfBoxCollections = true;
List <TransportRule> list = base.GetDataObjects <TransportRule>(classificationRuleCollectionIdParameter, base.DataSession, ClassificationDefinitionUtils.GetClassificationRuleCollectionContainerId(base.DataSession)).ToList <TransportRule>();
this.existingRulePack = list.FirstOrDefault((TransportRule transportRule) => transportRule.Name.Equals(this.rulePackageIdentifier, StringComparison.OrdinalIgnoreCase));
this.validationContext = new ValidationContext(this.InstallDefaultCollection ? ClassificationRuleCollectionOperationType.ImportOrUpdate : ClassificationRuleCollectionOperationType.Import, base.CurrentOrganizationId, this.InstallDefaultCollection || (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled && this.OutOfBoxCollection), false, (IConfigurationSession)base.DataSession, this.existingRulePack, null, null);
if (this.validationContext.DcValidationConfig != null && list.Count >= this.validationContext.DcValidationConfig.MaxRulePackages)
{
base.WriteError(new ClassificationRuleCollectionNumberExceedLimit(this.validationContext.DcValidationConfig.MaxRulePackages), ErrorCategory.InvalidOperation, null);
}
result = ClassificationRuleCollectionValidationUtils.ValidateRulePackageContents(this.validationContext, xdocument);
this.rulePackageDetailsElement = XmlProcessingUtils.GetRulePackageMetadataElement(xdocument);
ClassificationRuleCollectionLocalizableDetails classificationRuleCollectionLocalizableDetails = XmlProcessingUtils.ReadDefaultRulePackageMetadata(this.rulePackageDetailsElement);
this.defaultName = classificationRuleCollectionLocalizableDetails.Name;
ClassificationRuleCollectionLocalizableDetails classificationRuleCollectionLocalizableDetails2 = XmlProcessingUtils.ReadRulePackageMetadata(this.rulePackageDetailsElement, CultureInfo.CurrentCulture);
this.localizedName = ((classificationRuleCollectionLocalizableDetails2 != null && classificationRuleCollectionLocalizableDetails2.Name != null) ? classificationRuleCollectionLocalizableDetails2.Name : this.defaultName);
}
catch (ClassificationRuleCollectionVersionValidationException ex)
{
this.WriteWarning(ex.LocalizedString);
}
catch (ClassificationRuleCollectionAlreadyExistsException exception)
{
base.WriteError(exception, ErrorCategory.InvalidOperation, null);
}
catch (ClassificationRuleCollectionInternalValidationException ex2)
{
base.WriteError(ex2, (-2147287038 == ex2.Error) ? ErrorCategory.ObjectNotFound : ErrorCategory.InvalidResult, null);
}
catch (ClassificationRuleCollectionTimeoutException exception2)
{
base.WriteError(exception2, ErrorCategory.OperationTimeout, null);
}
catch (LocalizedException exception3)
{
base.WriteError(exception3, ErrorCategory.InvalidData, null);
}
return(result);
}
public void Validate(ValidationContext context, XDocument rulePackXDocument)
{
IList <string> allRuleIds = XmlProcessingUtils.GetAllRuleIds(rulePackXDocument);
DataClassificationIdentifierValidator.ValidateRuleIdentifiersUniqueness(allRuleIds);
if (context.OperationType != ClassificationRuleCollectionOperationType.Import && context.IsPayloadOobRuleCollection && context.ExistingRulePackDataObject != null)
{
DataClassificationIdentifierValidator.ValidateUpdatedOobRulePackIsSuperSet(context.GetRuleIdentifiersFromExistingRulePack(), allRuleIds);
}
string rulePackId = XmlProcessingUtils.GetRulePackId(rulePackXDocument);
Dictionary <string, HashSet <string> > allExistingClassificationIdentifiers = context.GetAllExistingClassificationIdentifiers(delegate(TransportRule rulePackDataObject)
{
string name = rulePackDataObject.Name;
if (string.IsNullOrEmpty(name))
{
name = rulePackDataObject.Id.Name;
}
return(!ClassificationDefinitionConstants.RuleCollectionIdComparer.Equals(rulePackId, name));
});
DataClassificationIdentifierValidator.ValidateNoRuleIdentifiersConflicts(allExistingClassificationIdentifiers, allRuleIds);
}
private void SetIdentityParameter(XDocument rulePackXDoc)
{
this.rulePackageIdentifier = XmlProcessingUtils.GetRulePackId(rulePackXDoc);
this.Identity = ClassificationRuleCollectionIdParameter.Parse(this.rulePackageIdentifier);
}
public void Validate(ValidationContext context, XDocument rulePackXDocument)
{
ClassificationRuleCollectionIdentifierValidator.ValidateRulePackIdentifier(context.IsPayloadOobRuleCollection, context.IsPayloadFingerprintsRuleCollection, XmlProcessingUtils.GetRulePackId(rulePackXDocument));
}
internal static bool IsFingerprintRuleCollection(XDocument rulePackXDoc)
{
ArgumentValidator.ThrowIfNull("rulePackXDoc", rulePackXDoc);
return(XmlProcessingUtils.GetRulePackId(rulePackXDoc).StartsWith("00000000-0000-0000-0001", StringComparison.OrdinalIgnoreCase));
}
