public override void Validate()
{
base.Validate();
DlpPolicyMetaData dlpPolicyMetaData = DlpPolicyParser.ParseDlpPolicyInstance(this.taskObject.TargetItem.TransportRulesXml);
if (this.taskObject.Fields.IsModified("State"))
{
dlpPolicyMetaData.State = this.taskObject.State;
}
if (this.taskObject.Fields.IsModified("Mode"))
{
dlpPolicyMetaData.Mode = this.taskObject.Mode;
}
if (this.taskObject.TargetItem.IsModified(ADObjectSchema.Name))
{
dlpPolicyMetaData.Name = this.taskObject.TargetItem.Name;
}
if (this.taskObject.Fields.IsModified("Description"))
{
dlpPolicyMetaData.Description = this.taskObject.Description;
}
ADComplianceProgram adcomplianceProgram = dlpPolicyMetaData.ToAdObject();
this.taskObject.TargetItem.State = adcomplianceProgram.State;
this.taskObject.TargetItem.Name = adcomplianceProgram.Name;
this.taskObject.TargetItem.Description = adcomplianceProgram.Description;
this.taskObject.TargetItem.TransportRulesXml = adcomplianceProgram.TransportRulesXml;
}
internal static IEnumerable <DlpPolicyMetaData> LoadDlpPolicyInstances(byte[] data)
{
IEnumerable <DlpPolicyMetaData> result;
using (MemoryStream memoryStream = new MemoryStream(data))
{
result = DlpPolicyParser.ParseDlpPolicyInstances(memoryStream);
}
return(result);
}
internal DlpPolicy(ADComplianceProgram adDlpPolicy) : base(adDlpPolicy)
{
if (base.AdDlpPolicy != null)
{
base.AdDlpPolicy = base.AdDlpPolicy;
this.dlpPolicyMetaData = DlpPolicyParser.ParseDlpPolicyInstance(base.AdDlpPolicy.TransportRulesXml);
return;
}
base.AdDlpPolicy = new ADComplianceProgram();
this.dlpPolicyMetaData = new DlpPolicyMetaData();
}
public static byte[] SerializeDlpPolicyInstance(DlpPolicyMetaData dlpPolicyMetaData)
{
byte[] result;
using (MemoryStream memoryStream = new MemoryStream())
{
XElement xelement = DlpPolicyParser.CreateDlpPolicyXelement(dlpPolicyMetaData, false);
xelement.Save(memoryStream);
result = memoryStream.ToArray();
}
return(result);
}
internal static DlpPolicyTemplateMetaData LoadOutOfBoxDlpTemplate(Fqdn domainController, string templateName)
{
IConfigDataProvider dataSession = DlpUtils.CreateOrgSession(domainController);
ADComplianceProgram adcomplianceProgram = DlpUtils.GetOutOfBoxDlpTemplates(dataSession, templateName).FirstOrDefault <ADComplianceProgram>();
if (adcomplianceProgram != null)
{
return(DlpPolicyParser.ParseDlpPolicyTemplate(adcomplianceProgram.TransportRulesXml));
}
return(null);
}
protected override void WriteResult <T>(IEnumerable <T> dataObjects)
{
IList <DlpPolicyMetaData> list = (from dataObject in (IEnumerable <ADComplianceProgram>) dataObjects
select DlpPolicyParser.ParseDlpPolicyInstance(dataObject.TransportRulesXml)).ToList <DlpPolicyMetaData>();
foreach (DlpPolicyMetaData dlpPolicyMetaData in list)
{
dlpPolicyMetaData.PolicyCommands = DlpUtils.GetEtrsForDlpPolicy(dlpPolicyMetaData.ImmutableId, base.DataSession);
}
this.WriteResult(new BinaryFileDataObject
{
FileData = DlpPolicyParser.SerializeDlpPolicyInstances(list)
});
}
public DlpPolicyTemplate(ADComplianceProgram dlpPolicy, CultureInfo culture) : base(dlpPolicy)
{
if (base.AdDlpPolicy != null)
{
base.AdDlpPolicy = base.AdDlpPolicy;
this.dlpTemplateMetaData = DlpPolicyParser.ParseDlpPolicyTemplate(base.AdDlpPolicy.TransportRulesXml);
}
else
{
base.AdDlpPolicy = new ADComplianceProgram();
this.dlpTemplateMetaData = new DlpPolicyTemplateMetaData();
}
this.CurrentCulture = culture;
}
internal ADComplianceProgram ToAdObject()
{
return(new ADComplianceProgram
{
Name = this.Name,
Description = this.Description,
ImmutableId = this.ImmutableId,
Keywords = this.Keywords.ToArray(),
PublisherName = this.PublisherName,
State = DlpUtils.RuleStateToDlpState(this.State, this.Mode),
TransportRulesXml = new StreamReader(new MemoryStream(DlpPolicyParser.SerializeDlpPolicyInstance(this))).ReadToEnd(),
Version = this.Version
});
}
public static byte[] SerializeDlpPolicyInstances(IEnumerable <DlpPolicyMetaData> dlpPolicies)
{
byte[] result;
using (MemoryStream memoryStream = new MemoryStream())
{
XDeclaration declaration = new XDeclaration("1.0", "utf-8", "yes");
object[] array = new object[1];
array[0] = new XElement(XName.Get("dlpPolicies"), from dlpPolicy in dlpPolicies
select DlpPolicyParser.CreateDlpPolicyXelement(dlpPolicy, true));
XDocument xdocument = new XDocument(declaration, array);
xdocument.Save(memoryStream);
result = memoryStream.ToArray();
}
return(result);
}
internal static DlpPolicyTemplateMetaData ParseDlpPolicyTemplate(string data)
{
DlpPolicyTemplateMetaData result;
try
{
XElement root = XDocument.Parse(data).Root;
DlpPolicyTemplateMetaData dlpPolicyTemplateMetaData = new DlpPolicyTemplateMetaData();
dlpPolicyTemplateMetaData.Version = root.Attribute("version").Value.Trim();
dlpPolicyTemplateMetaData.State = (RuleState)Enum.Parse(typeof(RuleState), root.Attribute("state").Value.Trim());
dlpPolicyTemplateMetaData.Mode = (RuleMode)Enum.Parse(typeof(RuleMode), root.Attribute("mode").Value.Trim());
dlpPolicyTemplateMetaData.ImmutableId = ((root.Attribute("id") == null) ? Guid.Empty : Guid.Parse(root.Attribute("id").Value.Trim()));
dlpPolicyTemplateMetaData.ContentVersion = root.Element("contentVersion").Value.Trim();
dlpPolicyTemplateMetaData.PublisherName = root.Element("publisherName").Value.Trim();
dlpPolicyTemplateMetaData.LocalizedNames = DlpPolicyParser.ParseLocalizedString(root.Element("name"));
dlpPolicyTemplateMetaData.LocalizedDescriptions = DlpPolicyParser.ParseLocalizedString(root.Element("description"));
dlpPolicyTemplateMetaData.LocalizedKeywords = (from localizedKeyword in root.Element("keywords").Elements("keyword")
select DlpPolicyParser.ParseLocalizedString(localizedKeyword)).ToList <Dictionary <string, string> >();
dlpPolicyTemplateMetaData.RuleParameters = (from ruleParameter in root.Element("ruleParameters").Elements("ruleParameter")
select new DlpTemplateRuleParameter
{
Type = ruleParameter.Attribute("type").Value.Trim(),
Required = bool.Parse(ruleParameter.Attribute("required").Value),
Token = ruleParameter.Attribute("token").Value.Trim(),
LocalizedDescriptions = DlpPolicyParser.ParseLocalizedString(ruleParameter.Element("description"))
}).ToList <DlpTemplateRuleParameter>();
dlpPolicyTemplateMetaData.PolicyCommands = (from policyCommand in root.Element("policyCommands").Elements("commandBlock")
select policyCommand.Value.Trim()).ToList <string>();
dlpPolicyTemplateMetaData.LocalizedPolicyCommandResources = (from localizedResource in root.Element("policyCommandsResources").Elements("resource")
select new KeyValuePair <string, Dictionary <string, string> >(localizedResource.Attribute("token").Value.Trim(), DlpPolicyParser.ParseLocalizedString(localizedResource))).ToDictionary((KeyValuePair <string, Dictionary <string, string> > pair) => pair.Key, (KeyValuePair <string, Dictionary <string, string> > pair) => pair.Value, StringComparer.OrdinalIgnoreCase);
DlpPolicyTemplateMetaData dlpPolicyTemplateMetaData2 = dlpPolicyTemplateMetaData;
dlpPolicyTemplateMetaData2.Validate();
result = dlpPolicyTemplateMetaData2;
}
catch (ArgumentException innerException)
{
throw new DlpPolicyParsingException(Strings.DlpPolicyStateStateInvalid, innerException);
}
catch (NullReferenceException innerException2)
{
throw new DlpPolicyParsingException(Strings.DlpPolicyXmlMissingElements, innerException2);
}
catch (XmlException innerException3)
{
throw new DlpPolicyParsingException(Strings.DlpPolicyXmlInvalid, innerException3);
}
return(result);
}
internal ADComplianceProgram ToAdObject()
{
string transportRulesXml;
using (MemoryStream memoryStream = new MemoryStream(DlpPolicyParser.SerializeDlpPolicyTemplate(this)))
{
StreamReader streamReader = new StreamReader(memoryStream);
transportRulesXml = streamReader.ReadToEnd();
}
ADComplianceProgram adcomplianceProgram = new ADComplianceProgram();
adcomplianceProgram.Name = DlpPolicyTemplateMetaData.GetLocalizedStringValue(this.LocalizedNames, null);
adcomplianceProgram.Description = DlpPolicyTemplateMetaData.GetLocalizedStringValue(this.LocalizedDescriptions, null);
adcomplianceProgram.ImmutableId = this.ImmutableId;
adcomplianceProgram.Keywords = (from keyword in this.LocalizedKeywords
select DlpPolicyTemplateMetaData.GetLocalizedStringValue(keyword, DlpPolicyTemplateMetaData.DefaultCulture)).ToArray <string>();
adcomplianceProgram.PublisherName = this.PublisherName;
adcomplianceProgram.State = DlpUtils.RuleStateToDlpState(this.State, this.Mode);
adcomplianceProgram.TransportRulesXml = transportRulesXml;
adcomplianceProgram.Version = this.Version;
return(adcomplianceProgram);
}
internal static IEnumerable <DlpPolicyMetaData> ParseDlpPolicyInstances(Stream data)
{
List <DlpPolicyMetaData> result;
try
{
XDocument xdocument = XDocument.Load(data);
result = (from dlpPolicy in xdocument.Element("dlpPolicies").Elements("dlpPolicy")
select DlpPolicyParser.ParseDlpPolicyInstance(dlpPolicy.ToString())).ToList <DlpPolicyMetaData>();
}
catch (ArgumentException innerException)
{
throw new DlpPolicyParsingException(Strings.DlpPolicyStateStateInvalid, innerException);
}
catch (NullReferenceException innerException2)
{
throw new DlpPolicyParsingException(Strings.DlpPolicyXmlMissingElements, innerException2);
}
catch (XmlException innerException3)
{
throw new DlpPolicyParsingException(Strings.DlpPolicyXmlInvalid, innerException3);
}
return(result);
}
