private static string GenerateName(RetentionPolicyTag newTag, ElcContentSettings oldContentSettings)
{
StringBuilder stringBuilder = new StringBuilder(63, 63);
stringBuilder.Append(newTag.Name);
stringBuilder.Append('-');
stringBuilder.Append(oldContentSettings.Name);
if (stringBuilder.Length >= 64)
{
return(stringBuilder.ToString(0, 63));
}
return(stringBuilder.ToString());
}
internal ContentSetting(ElcContentSettings elcContentSettings)
{
this.guid = elcContentSettings.Guid;
this.name = elcContentSettings.Name;
this.messageClass = elcContentSettings.MessageClass;
this.ageLimitForRetention = elcContentSettings.AgeLimitForRetention;
this.retentionEnabled = elcContentSettings.RetentionEnabled;
this.retentionAction = elcContentSettings.RetentionAction;
this.journalingEnabled = elcContentSettings.JournalingEnabled;
this.triggerForRetention = elcContentSettings.TriggerForRetention;
if (elcContentSettings.MoveToDestinationFolder != null)
{
this.moveToDestinationFolder = new Guid?(elcContentSettings.MoveToDestinationFolder.ObjectGuid);
this.moveToDestinationFolderName = elcContentSettings.MoveToDestinationFolder.Name;
}
this.managedFolderName = elcContentSettings.ManagedFolderName;
this.addressForJournaling = elcContentSettings.AddressForJournaling;
this.labelForJournaling = elcContentSettings.LabelForJournaling;
this.messageFormatForJournaling = elcContentSettings.MessageFormatForJournaling;
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
if (this.DataObject != null && SharedConfiguration.IsSharedConfiguration(this.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(this.DataObject.OrganizationId.OrganizationalUnit.Name)))
{
TaskLogger.LogExit();
return;
}
if (this.Mailbox != null)
{
ExchangePrincipal exchangePrincipal = this.ProcessPrimaryMailbox();
IRecipientSession recipientSession;
ADUser user = StoreRetentionPolicyTagHelper.FetchRecipientFromMailboxId(base.DomainController, this.Mailbox, out recipientSession, exchangePrincipal.MailboxInfo.OrganizationId);
if (exchangePrincipal != null && StoreRetentionPolicyTagHelper.HasOnPremArchiveMailbox(user))
{
this.ProcessArchiveMailbox();
}
}
else
{
bool flag = this.DataObject.IsChanged(ADObjectSchema.Name);
if (this.DataObject.IsChanged(RetentionPolicyTagSchema.RetentionId) && !this.Force && !base.ShouldContinue(Strings.WarningRetentionTagIdChange(this.DataObject.Identity.ToString())))
{
return;
}
base.InternalProcessRecord();
if (this.contentSettingsObject.ObjectState == ObjectState.Changed)
{
if (flag)
{
ElcContentSettings elcContentSettings = this.DataObject.GetELCContentSettings().FirstOrDefault <ElcContentSettings>();
elcContentSettings.CopyChangesFrom(this.contentSettingsObject);
this.contentSettingsObject = elcContentSettings;
}
base.DataSession.Save(this.contentSettingsObject);
}
}
TaskLogger.LogExit();
}
public ELCContentSettingsIdParameter(ElcContentSettings elcContentSetting) : base(elcContentSetting.Id)
{
}
private void StampModeratedTransportExpiry()
{
byte[] policyTag = null;
string text = string.Empty;
int retentionPeriod = 2;
ADOperationResult adoperationResult = ADNotificationAdapter.TryRunADOperation(delegate()
{
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.mbxTransportMailItem.OrganizationId), 361, "StampModeratedTransportExpiry", "f:\\15.00.1497\\sources\\dev\\MailboxTransport\\src\\MailboxTransportDelivery\\StoreDriver\\agents\\approval\\ApprovalEngine.cs");
ADObjectId descendantId = tenantOrTopologyConfigurationSession.GetOrgContainerId().GetDescendantId(ApprovalApplication.ParentPathInternal);
ADObjectId childId = descendantId.GetChildId("ModeratedRecipients");
ApprovalEngine.diag.TraceDebug <ADObjectId>((long)this.GetHashCode(), "Reading ModeratedRecipient app from {0}", childId);
if (childId != null)
{
ApprovalApplication approvalApplication = tenantOrTopologyConfigurationSession.Read <ApprovalApplication>(childId);
if (approvalApplication != null)
{
ADObjectId elcretentionPolicyTag = approvalApplication.ELCRetentionPolicyTag;
ApprovalEngine.diag.TraceDebug <ADObjectId>((long)this.GetHashCode(), "Read ModeratedRecipient, now reading Recipient Policy Tag {0}", elcretentionPolicyTag);
RetentionPolicyTag retentionPolicyTag = null;
if (elcretentionPolicyTag != null)
{
retentionPolicyTag = tenantOrTopologyConfigurationSession.Read <RetentionPolicyTag>(elcretentionPolicyTag);
}
else
{
IConfigurationSession configurationSession = SharedConfiguration.CreateScopedToSharedConfigADSession(this.mbxTransportMailItem.OrganizationId);
if (configurationSession != null)
{
IList <RetentionPolicyTag> defaultRetentionPolicyTag = ApprovalUtils.GetDefaultRetentionPolicyTag(configurationSession, ApprovalApplicationId.ModeratedRecipient, 1);
if (defaultRetentionPolicyTag != null && defaultRetentionPolicyTag.Count > 0)
{
retentionPolicyTag = defaultRetentionPolicyTag[0];
}
}
}
if (retentionPolicyTag != null)
{
ADPagedReader <ElcContentSettings> elccontentSettings = retentionPolicyTag.GetELCContentSettings();
using (IEnumerator <ElcContentSettings> enumerator = elccontentSettings.GetEnumerator())
{
if (enumerator.MoveNext())
{
ElcContentSettings elcContentSettings = enumerator.Current;
retentionPeriod = (int)elcContentSettings.AgeLimitForRetention.Value.TotalDays;
}
}
policyTag = retentionPolicyTag.RetentionId.ToByteArray();
}
}
}
});
if (!adoperationResult.Succeeded)
{
if (adoperationResult.Exception is TransientException)
{
throw adoperationResult.Exception;
}
text = adoperationResult.Exception.ToString();
ApprovalEngine.diag.TraceError <string>((long)this.GetHashCode(), "Can't get PolicyTag guid {0}, NDRing.", text);
}
if (policyTag == null)
{
ApprovalEngine.diag.TraceError((long)this.GetHashCode(), "PolicyTag not read. NDRing");
string text2 = this.mbxTransportMailItem.OrganizationId.ToString();
StoreDriverDeliveryDiagnostics.LogEvent(MailboxTransportEventLogConstants.Tuple_ApprovalCannotStampExpiry, text2, new object[]
{
text2,
text
});
throw new SmtpResponseException(AckReason.ApprovalCannotReadExpiryPolicy);
}
if (retentionPeriod < 2)
{
retentionPeriod = 2;
}
else if (retentionPeriod > 30)
{
retentionPeriod = 30;
}
this.messageItem[ItemSchema.RetentionDate] = ExDateTime.UtcNow.AddDays((double)retentionPeriod);
this.messageItem[StoreObjectSchema.RetentionPeriod] = retentionPeriod;
this.messageItem[StoreObjectSchema.PolicyTag] = policyTag;
}
public PresentationRetentionPolicyTag(RetentionPolicyTag retentionPolicyTag, ElcContentSettings contentSettings)
{
this.propertyBag = retentionPolicyTag.propertyBag;
this.m_Session = retentionPolicyTag.m_Session;
this.contentSettings = contentSettings;
}
private void MakeContentSettingUniqueAndSave(IConfigurationSession session, RetentionPolicyTag newTag, ElcContentSettings newContentSettings, string baseName)
{
if (newContentSettings != null)
{
if (!newTag.OrganizationId.Equals(OrganizationId.ForestWideOrgId) && newContentSettings.OrganizationId.Equals(OrganizationId.ForestWideOrgId))
{
newContentSettings.OrganizationId = newTag.OrganizationId;
}
bool flag = false;
int num = 1;
while (!flag || num < 10)
{
try
{
session.Save(newContentSettings);
flag = true;
}
catch (ADObjectAlreadyExistsException)
{
newContentSettings.SetId(newTag.Id.GetChildId(baseName + "-" + num.ToString()));
}
num++;
}
if (!flag)
{
base.ThrowTerminatingError(new CouldNotSaveContentSetting(baseName), ErrorCategory.InvalidData, null);
}
}
}
private ElcContentSettings[] GetUpgradedConentSettings(ElcContentSettings[] folderContentSettings, bool defaultTag)
{
List <ElcContentSettings> upgradedSettings = new List <ElcContentSettings>();
ElcContentSettings[] array = (from x in folderContentSettings
where x.RetentionEnabled || x.JournalingEnabled
select x).ToArray <ElcContentSettings>();
folderContentSettings.Except(array).ForEach(delegate(ElcContentSettings x)
{
this.WriteWarning(Strings.CouldNotUpgradeDisabledContentSettings(x.Name));
});
RetentionActionType[] allowedRetentionActions = new RetentionActionType[]
{
RetentionActionType.PermanentlyDelete,
RetentionActionType.DeleteAndAllowRecovery,
RetentionActionType.MoveToDeletedItems
};
if (!defaultTag)
{
ElcContentSettings elcContentSettings = new ElcContentSettings();
elcContentSettings.JournalingEnabled = false;
elcContentSettings.RetentionEnabled = false;
elcContentSettings.RetentionAction = RetentionActionType.PermanentlyDelete;
ElcContentSettings[] array2 = (from x in array
where x.RetentionEnabled
select x).ToArray <ElcContentSettings>();
ElcContentSettings[] array3 = (from x in array2
where allowedRetentionActions.Any((RetentionActionType y) => x.RetentionAction == y)
select x).ToArray <ElcContentSettings>();
array2.Except(array3).ForEach(delegate(ElcContentSettings x)
{
this.WriteWarning(Strings.CouldNotUpgradeSpecificContentSetting(x.Name));
});
ElcContentSettings[] array4 = (from x in array3
where x.TriggerForRetention == RetentionDateType.WhenDelivered
select x).ToArray <ElcContentSettings>();
array3.Except(array4).ForEach(delegate(ElcContentSettings x)
{
this.WriteWarning(Strings.CouldNotUpgradeRetentionTrigger(x.TriggerForRetention.ToString(), x.Name, RetentionDateType.WhenDelivered.ToString()));
});
array4.Aggregate(elcContentSettings, delegate(ElcContentSettings a, ElcContentSettings x)
{
if (a.AgeLimitForRetention == null)
{
a.AgeLimitForRetention = x.AgeLimitForRetention;
}
else if (x.AgeLimitForRetention != null && a.AgeLimitForRetention < x.AgeLimitForRetention)
{
a.AgeLimitForRetention = x.AgeLimitForRetention;
}
if (Array.FindIndex <RetentionActionType>(allowedRetentionActions, (RetentionActionType y) => y == a.RetentionAction) < Array.FindIndex <RetentionActionType>(allowedRetentionActions, (RetentionActionType y) => y == x.RetentionAction))
{
a.RetentionAction = x.RetentionAction;
}
a.RetentionEnabled = true;
return(a);
});
if (elcContentSettings.RetentionEnabled)
{
elcContentSettings.TriggerForRetention = RetentionDateType.WhenDelivered;
elcContentSettings.MessageClass = ElcMessageClass.AllMailboxContent;
(from x in array4
where string.Compare(x.MessageClass, ElcMessageClass.AllMailboxContent, StringComparison.OrdinalIgnoreCase) != 0
select x).ForEach(delegate(ElcContentSettings x)
{
this.WriteWarning(Strings.ChangedMessageClass(x.Name, x.MessageClass));
});
}
ElcContentSettings[] array5 = (from x in array
where x.JournalingEnabled
select x).ToArray <ElcContentSettings>();
if (array5.Length > 0)
{
elcContentSettings.JournalingEnabled = true;
elcContentSettings.MessageFormatForJournaling = array5[0].MessageFormatForJournaling;
elcContentSettings.AddressForJournaling = array5[0].AddressForJournaling;
elcContentSettings.LabelForJournaling = array5[0].LabelForJournaling;
array5.Skip(1).ForEach(delegate(ElcContentSettings x)
{
this.WriteWarning(Strings.CouldNotUpgradeJournaling(x.Name));
});
}
if (elcContentSettings.RetentionEnabled || elcContentSettings.JournalingEnabled)
{
upgradedSettings.Add(elcContentSettings);
}
}
else
{
array.ForEach(delegate(ElcContentSettings x)
{
ElcContentSettings elcContentSettings2 = new ElcContentSettings();
if (x.RetentionEnabled)
{
if (allowedRetentionActions.Any((RetentionActionType y) => x.RetentionAction == y))
{
if (x.TriggerForRetention != RetentionDateType.WhenDelivered)
{
this.WriteWarning(Strings.CouldNotUpgradeRetentionTrigger(x.TriggerForRetention.ToString(), x.Name, RetentionDateType.WhenDelivered.ToString()));
}
else
{
elcContentSettings2.RetentionAction = x.RetentionAction;
elcContentSettings2.AgeLimitForRetention = x.AgeLimitForRetention;
elcContentSettings2.TriggerForRetention = RetentionDateType.WhenDelivered;
elcContentSettings2.RetentionEnabled = x.RetentionEnabled;
if (x.MessageClass.Equals(ElcMessageClass.AllMailboxContent, StringComparison.OrdinalIgnoreCase) || x.MessageClass.Equals(ElcMessageClass.VoiceMail, StringComparison.OrdinalIgnoreCase))
{
elcContentSettings2.MessageClass = x.MessageClass;
}
else
{
elcContentSettings2.MessageClass = ElcMessageClass.AllMailboxContent;
this.WriteWarning(Strings.ChangedMessageClass(x.Name, x.MessageClass));
}
}
}
else
{
this.WriteWarning(Strings.CouldNotUpgradeSpecificContentSetting(x.Name));
}
}
if (x.JournalingEnabled)
{
elcContentSettings2.MessageFormatForJournaling = x.MessageFormatForJournaling;
elcContentSettings2.JournalingEnabled = x.JournalingEnabled;
elcContentSettings2.AddressForJournaling = x.AddressForJournaling;
elcContentSettings2.LabelForJournaling = x.LabelForJournaling;
if (x.MessageClass.Equals(ElcMessageClass.AllMailboxContent, StringComparison.OrdinalIgnoreCase) || x.MessageClass.Equals(ElcMessageClass.VoiceMail, StringComparison.OrdinalIgnoreCase))
{
elcContentSettings2.MessageClass = x.MessageClass;
}
else
{
elcContentSettings2.MessageClass = ElcMessageClass.AllMailboxContent;
this.WriteWarning(Strings.ChangedMessageClass(x.Name, x.MessageClass));
}
}
if (elcContentSettings2.RetentionEnabled || elcContentSettings2.JournalingEnabled)
{
upgradedSettings.Add(elcContentSettings2);
}
});
}
return(upgradedSettings.ToArray());
}
