protected virtual void Initialize()
{
ExAssert.RetailAssert(this.StoredRuleCollection != null, "The stored transport rule instance for classification rule collection presentation object must not be null");
XDocument ruleCollectionDocumentFromTransportRule = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(this.StoredRuleCollection);
this.Initialize(ruleCollectionDocumentFromTransportRule);
}
private bool TryParseADRulePack(TransportRule adRulePack, out XDocument rulePackXDocument)
{
ArgumentValidator.ThrowIfNull("adRulePack", adRulePack);
rulePackXDocument = null;
Exception ex = null;
try
{
rulePackXDocument = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(adRulePack);
}
catch (ArgumentException ex2)
{
ex = ex2;
}
catch (AggregateException ex3)
{
ex = ex3;
}
catch (XmlException ex4)
{
ex = ex4;
}
if (ex != null)
{
this.task.WriteWarning(Strings.WarningInvalidRuleCollectionADObject(adRulePack.Identity.ToString(), ex.Message));
}
return(rulePackXDocument != null);
}
protected override void WriteResult(IConfigurable dataObject)
{
TaskLogger.LogEnter();
TransportRule transportRule = dataObject as TransportRule;
if (transportRule != null)
{
XDocument ruleCollectionDocumentFromTransportRule = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(transportRule);
if (ruleCollectionDocumentFromTransportRule != null)
{
string[] ruleIdQueries = new string[]
{
((DataClassificationObjectId)this.implementation.DataClassificationPresentationObject.Identity).Name
};
List <QueryMatchResult> list = XmlProcessingUtils.GetMatchingRulesById(ruleCollectionDocumentFromTransportRule, ruleIdQueries).ToList <QueryMatchResult>();
if (list.Count > 0)
{
ClassificationRuleCollectionPresentationObject rulePackPresentationObject = ClassificationRuleCollectionPresentationObject.Create(transportRule);
DataClassificationPresentationObject result = DataClassificationPresentationObject.Create(list[0].MatchingRuleId, list[0].MatchingRuleXElement, list[0].MatchingResourceXElement, rulePackPresentationObject);
this.WriteResult(result);
}
}
}
else
{
base.WriteResult(dataObject);
}
TaskLogger.LogExit();
}
private XDocument TryGetRuleCollectionDocumentFromTransportRule(TransportRule transportRule)
{
XDocument result = null;
try
{
result = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(transportRule);
}
catch (InvalidOperationException)
{
ClassificationDefinitionsDiagnosticsReporter.Instance.WriteInvalidObjectInformation(this.GetHashCode(), transportRule.OrganizationId, transportRule.DistinguishedName);
}
catch (ArgumentException underlyingException)
{
ClassificationDefinitionsDiagnosticsReporter.Instance.WriteCorruptRulePackageDiagnosticsInformation(this.GetHashCode(), transportRule.OrganizationId, transportRule.DistinguishedName, underlyingException);
}
catch (AggregateException ex)
{
ClassificationDefinitionsDiagnosticsReporter.Instance.WriteCorruptRulePackageDiagnosticsInformation(this.GetHashCode(), transportRule.OrganizationId, transportRule.DistinguishedName, ex.Flatten());
}
catch (XmlException ex2)
{
ClassificationDefinitionsDiagnosticsReporter.Instance.WriteCorruptRulePackageDiagnosticsInformation(this.GetHashCode(), transportRule.OrganizationId, transportRule.DistinguishedName, new AggregateException(new Exception[]
{
ex2
}).Flatten());
}
return(result);
}
internal static IEnumerable <Tuple <TransportRule, XDocument> > AggregateOobAndCustomClassificationDefinitions(OrganizationId organizationId, IConfigurationSession openedDataSession = null, Func <TransportRule, bool> inclusiveFilter = null, QueryFilter additionalFilter = null, IClassificationDefinitionsDataReader dataReader = null, IClassificationDefinitionsDiagnosticsReporter classificationDefinitionsDiagnosticsReporter = null)
{
IClassificationDefinitionsDataReader dataReaderToUse = dataReader ?? ClassificationDefinitionsDataReader.DefaultInstance;
IClassificationDefinitionsDiagnosticsReporter classificationDefinitionsDiagnosticsReporterToUse = classificationDefinitionsDiagnosticsReporter ?? ClassificationDefinitionsDiagnosticsReporter.Instance;
foreach (TransportRule transportRule in dataReaderToUse.GetAllClassificationRuleCollection(organizationId, openedDataSession, additionalFilter))
{
if (inclusiveFilter != null)
{
if (!inclusiveFilter(transportRule))
{
continue;
}
}
XDocument rulePackXDoc;
try
{
rulePackXDoc = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(transportRule);
}
catch (InvalidOperationException)
{
classificationDefinitionsDiagnosticsReporterToUse.WriteInvalidObjectInformation(0, organizationId, transportRule.DistinguishedName);
continue;
}
catch (ArgumentException underlyingException)
{
classificationDefinitionsDiagnosticsReporterToUse.WriteCorruptRulePackageDiagnosticsInformation(0, organizationId, transportRule.DistinguishedName, underlyingException);
continue;
}
catch (AggregateException ex)
{
classificationDefinitionsDiagnosticsReporterToUse.WriteCorruptRulePackageDiagnosticsInformation(0, organizationId, transportRule.DistinguishedName, ex.Flatten());
continue;
}
catch (XmlException ex2)
{
classificationDefinitionsDiagnosticsReporterToUse.WriteCorruptRulePackageDiagnosticsInformation(0, organizationId, transportRule.DistinguishedName, new AggregateException(new Exception[]
{
ex2
}).Flatten());
continue;
}
yield return(new Tuple <TransportRule, XDocument>(transportRule, rulePackXDoc));
}
yield break;
}
protected override IConfigurable PrepareDataObject()
{
TaskLogger.LogEnter();
TransportRule transportRule = null;
try
{
transportRule = this.TryGetDataObject();
XDocument rulePackXDoc;
if (transportRule == null)
{
transportRule = (TransportRule)base.PrepareDataObject();
string rawIdentity = this.ClassificationRuleCollectionIdentity.RawIdentity;
transportRule.SetId(ClassificationDefinitionUtils.GetClassificationRuleCollectionContainerId(base.DataSession).GetChildId(rawIdentity));
transportRule.OrganizationId = base.CurrentOrganizationId;
transportRule.Xml = null;
string organizationId;
string name;
if (base.CurrentOrganizationId != null && base.CurrentOrganizationId.OrganizationalUnit != null)
{
organizationId = base.CurrentOrganizationId.OrganizationalUnit.ObjectGuid.ToString();
name = base.CurrentOrganizationId.OrganizationalUnit.Name;
}
else
{
organizationId = base.CurrentOrgContainerId.ObjectGuid.ToString();
name = base.CurrentOrgContainerId.DomainId.Name;
}
rulePackXDoc = ClassificationDefinitionUtils.CreateRuleCollectionDocumentFromTemplate(rawIdentity, organizationId, name);
}
else
{
rulePackXDoc = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(transportRule);
}
this.implementation = new DataClassificationCmdletsImplementation(this);
this.implementation.Initialize(transportRule, rulePackXDoc);
}
catch (LocalizedException exception)
{
base.WriteError(exception, ErrorCategory.InvalidOperation, null);
}
TaskLogger.LogExit();
return(transportRule);
}
private void InitializeExistingRulePack(TransportRule existingRulePack)
{
this.ExistingRulePackDataObject = existingRulePack;
if (ClassificationRuleCollectionOperationType.Update == this.OperationType)
{
ExAssert.RetailAssert(existingRulePack != null, "ValidationContext constructor must check that there's an existing rule pack data object for update operation.");
}
if (this.OperationType == ClassificationRuleCollectionOperationType.Import || existingRulePack == null)
{
return;
}
XDocument xdocument = null;
try
{
xdocument = ClassificationDefinitionUtils.GetRuleCollectionDocumentFromTransportRule(existingRulePack);
}
catch (InvalidOperationException)
{
this.classificationDiagnosticsReporter.WriteInvalidObjectInformation(this.GetHashCode(), existingRulePack.OrganizationId, existingRulePack.DistinguishedName);
}
catch (ArgumentException underlyingException)
{
this.classificationDiagnosticsReporter.WriteCorruptRulePackageDiagnosticsInformation(this.GetHashCode(), existingRulePack.OrganizationId, existingRulePack.DistinguishedName, underlyingException);
}
catch (AggregateException ex)
{
this.classificationDiagnosticsReporter.WriteCorruptRulePackageDiagnosticsInformation(this.GetHashCode(), existingRulePack.OrganizationId, existingRulePack.DistinguishedName, ex.Flatten());
}
catch (XmlException ex2)
{
this.classificationDiagnosticsReporter.WriteCorruptRulePackageDiagnosticsInformation(this.GetHashCode(), existingRulePack.OrganizationId, existingRulePack.DistinguishedName, new AggregateException(new Exception[]
{
ex2
}).Flatten());
}
this.existingrulePackXDocument = xdocument;
}
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));
}
