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);
}
internal ISet <string> GetRuleIdentifiersFromExistingRulePack()
{
if (this.existingrulePackXDocument == null)
{
return(null);
}
return(new HashSet <string>(XmlProcessingUtils.GetAllRuleIds(this.existingrulePackXDocument), ClassificationDefinitionConstants.RuleIdComparer));
}
public bool Delete(ValidationContext validationContext)
{
ArgumentValidator.ThrowIfNull("validationContext", validationContext);
try
{
this.ruleXElement.Remove();
this.ruleResourceXElement.Remove();
if (XmlProcessingUtils.GetAllRuleIds(this.rulePackXDocument).Count <= 0)
{
return(true);
}
this.InternalSave(validationContext, true);
return(false);
}
catch (LocalizedException exception)
{
this.task.WriteError(exception, ErrorCategory.InvalidOperation, null);
}
return(false);
}
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);
}
internal static IList <string> GetDeletedRulesInUse(IConfigDataProvider dataSession, TransportRule existingRulePackObject, ISet <string> referencingRules = null, XDocument updatedRulePackXDoc = null)
{
ExAssert.RetailAssert(dataSession != null && existingRulePackObject != null, "The data session and rule package object to be updated / deleted must be specified in order to check if any deleted rules are in-use by ETR.");
HashSet <string> hashSet;
try
{
XDocument ruleCollectionDocumentFromTransportRule = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(existingRulePackObject);
hashSet = new HashSet <string>(XmlProcessingUtils.GetAllRuleIds(ruleCollectionDocumentFromTransportRule), ClassificationDefinitionConstants.RuleIdComparer);
}
catch (ArgumentException)
{
((ClassificationDefinitionsDiagnosticsReporter)ClassificationDefinitionsDiagnosticsReporter.Instance).Tracer.TraceWarning <string>(0L, "Deleting classification rule collection '{0}' with null compressed data.", existingRulePackObject.DistinguishedName);
return(Enumerable.Empty <string>().ToList <string>());
}
catch (AggregateException ex)
{
((ClassificationDefinitionsDiagnosticsReporter)ClassificationDefinitionsDiagnosticsReporter.Instance).Tracer.TraceWarning <string, string>(0L, "Deleting classification rule collection '{0}' with invalid compressed data or invalid decompressed data. Details: {1}", existingRulePackObject.DistinguishedName, ex.Flatten().ToString());
return(Enumerable.Empty <string>().ToList <string>());
}
catch (XmlException ex2)
{
((ClassificationDefinitionsDiagnosticsReporter)ClassificationDefinitionsDiagnosticsReporter.Instance).Tracer.TraceWarning <string, string>(0L, "Deleting classification rule collection '{0}' with invalid XML contents. Details: {1}", existingRulePackObject.DistinguishedName, new AggregateException(new Exception[]
{
ex2
}).Flatten().ToString());
return(Enumerable.Empty <string>().ToList <string>());
}
if (updatedRulePackXDoc != null)
{
foreach (string item in XmlProcessingUtils.GetAllRuleIds(updatedRulePackXDoc))
{
hashSet.Remove(item);
}
}
return(ClassificationRuleCollectionValidationUtils.ProcessClassificationReferences(DlpUtils.GetDataClassificationsInUse(dataSession, hashSet, ClassificationDefinitionConstants.RuleIdComparer), referencingRules));
}
