// Token: 0x060002E6 RID: 742 RVA: 0x000120AC File Offset: 0x000102AC
internal ItemUpdater(MailboxDataForFolders mailboxData, ProvisionedFolder provisionedFolder, ElcSubAssistant elcAssistant)
{
this.mailboxData = mailboxData;
this.provisionedFolder = provisionedFolder;
this.elcAssistant = elcAssistant;
this.mailboxOwner = mailboxData.MailboxSession.MailboxOwner;
}
// Token: 0x06000321 RID: 801 RVA: 0x00013F08 File Offset: 0x00012108
internal FolderAuditLogData(ProvisionedFolder provisionedFolder, MailboxData mailboxData, string elcAction, string autoCopyAddress)
{
this.folderFullPath = provisionedFolder.FullFolderPath;
this.mailboxOwner = mailboxData.MailboxSmtpAddress;
this.elcAction = elcAction;
this.autoCopyAddress = autoCopyAddress;
}
// Token: 0x060002EB RID: 747 RVA: 0x000124C1 File Offset: 0x000106C1
internal MovePolicyItems(ContentSetting elcPolicy, ProvisionedFolder provisionedFolder, MailboxDataForFolders mailboxData, string itemClass)
{
this.elcPolicy = elcPolicy;
this.sourceFolder = provisionedFolder;
this.mailboxData = mailboxData;
this.InitItemList(itemClass);
}
// Token: 0x06000305 RID: 773 RVA: 0x00013484 File Offset: 0x00011684
private void MarkItemAsCopied(ItemData itemData, ProvisionedFolder provisionedFolder)
{
ItemUpdater itemUpdater = new ItemUpdater(base.MailboxData, provisionedFolder, base.Assistant);
itemUpdater.SetProperty(itemData, ItemSchema.ElcAutoCopyTag, itemData.Id.ChangeKeyAsByteArray());
AutoCopyEnforcer.Tracer.TraceDebug <object, VersionedId>((long)this.GetHashCode(), "{0}: item '{1}' marked as copied.", TraceContext.Get(), itemData.Id);
AutoCopyEnforcer.TracerPfd.TracePfd <int, object, VersionedId>((long)this.GetHashCode(), "PFD IWE {0} {1}: item '{2}' marked as copied.", 21783, TraceContext.Get(), itemData.Id);
}
// Token: 0x06000302 RID: 770 RVA: 0x00012EF0 File Offset: 0x000110F0
internal override void SetItemQueryFlags(ProvisionedFolder provisionedFolder, ItemFinder itemFinder)
{
itemFinder.NeedAutoCopyProps = true;
if (base.MailboxData.ElcAuditLog.AutocopyLoggingEnabled)
{
itemFinder.SetAuditLogFlags(base.MailboxData.ElcAuditLog.SubjectLoggingEnabled);
}
}
// Token: 0x0600032E RID: 814 RVA: 0x0001405C File Offset: 0x0001225C
internal FolderExpirationExecutor(ProvisionedFolder provisionedFolder, MailboxDataForFolders mailboxData, ElcFolderSubAssistant elcAssistant) : base(mailboxData, elcAssistant, FolderExpirationExecutor.Tracer)
{
this.provisionedFolder = provisionedFolder;
this.expiryTimeList = new List <ItemData>(2000);
this.moveDateStampingList = new List <ItemData>(2000);
this.moveLists = new Dictionary <Guid, MovePolicyItems>();
ExpirationExecutor.TracerPfd.TracePfd <int, FolderExpirationExecutor>((long)this.GetHashCode(), "PFD IWE {0} {1} called", 30999, this);
}
// Token: 0x060002DB RID: 731 RVA: 0x00011F20 File Offset: 0x00010120
private ContentSetting GetDestinationPolicy(ProvisionedFolder destProvisionedFolder, string itemClass)
{
ContentSetting applyingPolicy = ElcPolicySettings.GetApplyingPolicy(destProvisionedFolder.ElcPolicies, itemClass, destProvisionedFolder.ItemClassToPolicyMapping);
if (applyingPolicy == null || !ElcPolicySettings.ArePolicyPropertiesValid(applyingPolicy, TraceContext.Get(), this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString()))
{
return(null);
}
return(applyingPolicy);
}
// Token: 0x060002D5 RID: 725 RVA: 0x000115C4 File Offset: 0x0000F7C4
private void BuildListOfProvisionedFolders()
{
VersionedId rootFolderId = null;
string text = null;
using (Folder folder = Folder.Bind(this.MailboxSession, DefaultFolderType.Root, FolderProcessor.DataColumns))
{
rootFolderId = folder.Id;
try
{
if (ElcMailboxHelper.Exists(folder[FolderSchema.ELCPolicyIds]))
{
text = (string)folder[FolderSchema.ELCPolicyIds];
List <object> list = new List <object>(folder.GetProperties(FolderProcessor.DataColumns));
list.Add(list[3]);
this.entireFolderList.Add(list.ToArray());
FolderProcessor.Tracer.TraceDebug <FolderProcessor, string>((long)this.GetHashCode(), "{0}: Root Policy '{1}' is set for this mailbox.", this, text);
}
}
catch (PropertyErrorException ex)
{
if (ex.PropertyErrors[0].PropertyErrorCode != PropertyErrorCode.NotFound)
{
throw;
}
FolderProcessor.Tracer.TraceDebug <FolderProcessor>((long)this.GetHashCode(), "{0}: Root Policy does not exist for this mailbox.", this);
}
using (QueryResult queryResult = folder.FolderQuery(FolderQueryFlags.DeepTraversal, null, null, FolderProcessor.DataColumns))
{
for (;;)
{
object[][] rows = queryResult.GetRows(100);
if (rows.Length <= 0)
{
break;
}
for (int i = 0; i < rows.Length; i++)
{
this.entireFolderList.Add(rows[i]);
}
}
}
}
ElcMailboxHelper.PopulateFolderPathProperty(this.entireFolderList, new FolderPathIndices(3, 6, 0, 1, 7));
for (int j = 0; j < this.entireFolderList.Count; j++)
{
ProvisionedFolder provisionedFolder = this.GetProvisionedFolder(j, rootFolderId, text);
if (provisionedFolder != null)
{
this.ProvisionedFolderList.Add(provisionedFolder);
}
}
FolderProcessor.Tracer.TraceDebug <FolderProcessor, int>((long)this.GetHashCode(), "{0}: Number of folders found with policies for this mailbox is: {1}.", this, this.ProvisionedFolderList.Count);
}
// Token: 0x060002D1 RID: 721 RVA: 0x00011000 File Offset: 0x0000F200
internal bool IsPolicyValid(ProvisionedFolder provisionedFolder, ContentSetting policy, string itemClass, MailboxDataForFolders mailboxData)
{
if (!ElcPolicySettings.ArePolicyPropertiesValid(policy, TraceContext.Get(), this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString()))
{
return(false);
}
FolderProcessor.CircularPolicyType circularPolicyType = this.LookForCircularPolicies(provisionedFolder, policy, itemClass, mailboxData);
if (circularPolicyType == FolderProcessor.CircularPolicyType.BadCycle)
{
throw new SkipException(Strings.descCycleInPolicies(this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString(), policy.Name));
}
return(true);
}
// Token: 0x060002F6 RID: 758 RVA: 0x00012AE4 File Offset: 0x00010CE4
private void SetDestPolicyType(StoreObjectId destFolderId, string itemClass)
{
ContentSetting contentSetting = null;
ProvisionedFolder folderFromId = this.mailboxData.FolderProcessor.GetFolderFromId(destFolderId);
if (folderFromId != null)
{
contentSetting = ElcPolicySettings.GetApplyingPolicy(folderFromId.ElcPolicies, itemClass, folderFromId.ItemClassToPolicyMapping);
}
if (contentSetting != null && contentSetting.RetentionEnabled && contentSetting.TriggerForRetention == RetentionDateType.WhenMoved && contentSetting.AgeLimitForRetention != null && contentSetting.AgeLimitForRetention.Value.TotalDays > 0.0)
{
this.setDateWhileMoving = true;
}
}
// Token: 0x0600037B RID: 891 RVA: 0x00017EC8 File Offset: 0x000160C8
internal override void SetItemQueryFlags(ProvisionedFolder provisionedFolder, ItemFinder itemFinder)
{
int num = -1;
bool flag = false;
foreach (ElcPolicySettings elcPolicySettings in provisionedFolder.ElcPolicies)
{
if (elcPolicySettings.RetentionEnabled)
{
EnhancedTimeSpan?ageLimitForRetention = elcPolicySettings.AgeLimitForRetention;
TimeSpan? timeSpan2;
TimeSpan? timeSpan = timeSpan2 = ((ageLimitForRetention != null) ? new TimeSpan?(ageLimitForRetention.GetValueOrDefault()) : null);
double totalDays;
if (timeSpan2 != null && (totalDays = timeSpan.Value.TotalDays) > 0.0)
{
ExpirationEnforcer.Tracer.TraceDebug <object, string, string>((long)this.GetHashCode(), "{0}: Reading policy. MessageClass {1} in Policy '{2}' has expiration enabled.", TraceContext.Get(), elcPolicySettings.MessageClass, elcPolicySettings.Name);
flag = true;
if (!itemFinder.NeedMoveDate && (num == -1 || (double)num > totalDays))
{
num = (int)totalDays;
}
if (elcPolicySettings.RetentionAction == RetentionActionType.MarkAsPastRetentionLimit)
{
itemFinder.NeedExpiryTime = true;
ExpirationEnforcer.Tracer.TraceDebug <object, string, string>((long)this.GetHashCode(), "{0}: Reading policy. MessageClass {1} in Policy '{2}' has expiration action of tag expiry time.", TraceContext.Get(), elcPolicySettings.MessageClass, elcPolicySettings.Name);
}
if (elcPolicySettings.TriggerForRetention == RetentionDateType.WhenMoved)
{
itemFinder.NeedMoveDate = true;
num = 0;
ExpirationEnforcer.Tracer.TraceDebug <object, string, string>((long)this.GetHashCode(), "{0}: Reading policy. MessageClass {1} in Policy '{2}' expires based on move date.", TraceContext.Get(), elcPolicySettings.MessageClass, elcPolicySettings.Name);
}
}
}
}
itemFinder.SmallestAgeLimit = num;
if (provisionedFolder.ContainerClass != null && ObjectClass.IsCalendarFolder(provisionedFolder.ContainerClass) && flag)
{
itemFinder.NeedCalendarProps = true;
}
if (provisionedFolder.ContainerClass != null && ObjectClass.IsTaskFolder(provisionedFolder.ContainerClass) && flag)
{
itemFinder.NeedTaskProps = true;
}
if (base.MailboxData.ElcAuditLog.ExpirationLoggingEnabled)
{
itemFinder.SetAuditLogFlags(base.MailboxData.ElcAuditLog.SubjectLoggingEnabled);
}
}
// Token: 0x060002F2 RID: 754 RVA: 0x000125F4 File Offset: 0x000107F4
private void GetOriginalDestinationFolder(out StoreObjectId originalDestFolderId, out string fullFolderPath)
{
originalDestFolderId = null;
fullFolderPath = null;
if (this.elcPolicy.RetentionAction == RetentionActionType.MoveToFolder)
{
if (this.elcPolicy.MoveToDestinationFolder == null)
{
MovePolicyItems.Tracer.TraceError <MovePolicyItems, string, string>((long)this.GetHashCode(), "{0}: Invalid policy: '{1}' on folder: '{2}'. Expiration action is MoveToFolder but destination folder is null.", this, this.elcPolicy.Name, this.sourceFolder.DisplayName);
Globals.Logger.LogEvent(InfoWorkerEventLogConstants.Tuple_NullDestinationFolder, null, new object[]
{
this.sourceFolder.DisplayName,
this.mailboxData.MailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString(),
this.elcPolicy.Name,
this.elcPolicy.ManagedFolderName
});
throw new InvalidExpiryDestinationException(Strings.descNullExpiryDestination(this.mailboxData.MailboxSmtpAddress, this.elcPolicy.Name));
}
Guid folderGuidFromObjectGuid = this.mailboxData.GetFolderGuidFromObjectGuid(this.elcPolicy.MoveToDestinationFolder);
if (folderGuidFromObjectGuid == Guid.Empty)
{
MovePolicyItems.Tracer.TraceError((long)this.GetHashCode(), "{0}: Invalid policy: '{1}' on folder: '{2}'. Destination folder '{3}' is not in the cached list of ELC folders from AD.", new object[]
{
this,
this.elcPolicy.Name,
this.sourceFolder.DisplayName,
this.elcPolicy.MoveToDestinationFolderName
});
throw new InvalidExpiryDestinationException(Strings.descExpiryDestNotProvisioned(this.mailboxData.MailboxSmtpAddress, this.elcPolicy.MoveToDestinationFolderName, this.elcPolicy.Name));
}
ProvisionedFolder folderFromId = this.mailboxData.FolderProcessor.GetFolderFromId(folderGuidFromObjectGuid);
if (folderFromId != null)
{
originalDestFolderId = folderFromId.FolderId;
fullFolderPath = folderFromId.FullFolderPath;
return;
}
}
else
{
originalDestFolderId = this.mailboxData.MailboxSession.GetDefaultFolderId(DefaultFolderType.DeletedItems);
if (originalDestFolderId != null)
{
fullFolderPath = this.mailboxData.FolderProcessor.GetFolderPathFromId(originalDestFolderId);
}
}
}
// Token: 0x06000301 RID: 769 RVA: 0x00012E48 File Offset: 0x00011048
internal override bool IsEnabled(ProvisionedFolder provisionedFolder)
{
bool flag = false;
foreach (ElcPolicySettings elcPolicySettings in provisionedFolder.ElcPolicies)
{
if (elcPolicySettings.JournalingEnabled)
{
AutoCopyEnforcer.Tracer.TraceDebug <object, string, string>((long)this.GetHashCode(), "{0}: search for items in folder '{1}' will include autocopy properties because policy '{2}' has autocopy enabled and applies to this folder.", TraceContext.Get(), provisionedFolder.DisplayName, elcPolicySettings.Name);
flag = true;
break;
}
}
if (!flag)
{
AutoCopyEnforcer.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: search for items in folder '{1}' will not include autocopy properties because no policy with autocopy applies to this folder.", TraceContext.Get(), provisionedFolder.DisplayName);
}
return(flag);
}
// Token: 0x060002D8 RID: 728 RVA: 0x00011C28 File Offset: 0x0000FE28
private FolderProcessor.CircularPolicyType LookForCircularPolicies(ProvisionedFolder provisionedFolder, ContentSetting policy, string itemClass, MailboxDataForFolders mailboxData)
{
if (provisionedFolder.ValidatedPolicies.Contains(itemClass))
{
return(FolderProcessor.CircularPolicyType.NoCycle);
}
List <FolderProcessor.FolderPolicy> list = new List <FolderProcessor.FolderPolicy>();
list.Add(new FolderProcessor.FolderPolicy(provisionedFolder, policy));
while (policy.RetentionAction == RetentionActionType.MoveToFolder || policy.RetentionAction == RetentionActionType.MoveToDeletedItems)
{
ProvisionedFolder destinationFolder = this.GetDestinationFolder(policy, mailboxData);
if (destinationFolder == null)
{
FolderProcessor.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: The destination folder of Policy '{1}' is not in the list of provisioned folders. Quit.", TraceContext.Get(), policy.Name);
}
else
{
FolderProcessor.CircularPolicyType circularPolicyType = this.CheckDestinationFolder(list, destinationFolder, policy);
if (circularPolicyType != FolderProcessor.CircularPolicyType.NoCycle)
{
return(circularPolicyType);
}
ContentSetting destinationPolicy = this.GetDestinationPolicy(destinationFolder, itemClass);
if (destinationPolicy != null)
{
list.Add(new FolderProcessor.FolderPolicy(destinationFolder, destinationPolicy));
policy = destinationPolicy;
continue;
}
FolderProcessor.Tracer.TraceDebug <object, string, string>((long)this.GetHashCode(), "{0}: The destination folder '{1}' of Policy '{2}' does not have a valid policy on it. Quit.", TraceContext.Get(), destinationFolder.FullFolderPath, policy.Name);
}
IL_E8:
provisionedFolder.ValidatedPolicies.Add(itemClass);
return(FolderProcessor.CircularPolicyType.NoCycle);
}
FolderProcessor.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: The Policy '{1}' is not a MoveTo policy. Quit", TraceContext.Get(), policy.Name);
goto IL_E8;
}
// Token: 0x0600037A RID: 890 RVA: 0x00017E10 File Offset: 0x00016010
internal override bool IsEnabled(ProvisionedFolder provisionedFolder)
{
if (base.MailboxData.SuspendExpiration)
{
ExpirationEnforcer.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Expiration for this user is currently suspended. This user will be skipped.", new object[]
{
TraceContext.Get()
});
return(false);
}
ExpirationEnforcer.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Expiration for this user is not suspended. This user will be processed.", new object[]
{
TraceContext.Get()
});
foreach (ElcPolicySettings elcPolicySettings in provisionedFolder.ElcPolicies)
{
if (elcPolicySettings.RetentionEnabled)
{
return(true);
}
}
return(false);
}
// Token: 0x0600031F RID: 799 RVA: 0x00013EDB File Offset: 0x000120DB
internal FolderAuditLogData(ProvisionedFolder provisionedFolder, MailboxData mailboxData, string elcAction) : this(provisionedFolder, mailboxData, elcAction, string.Empty)
{
}
// Token: 0x060002FB RID: 763 internal abstract bool IsEnabled(ProvisionedFolder provisionedFolder);
// Token: 0x0600037C RID: 892 RVA: 0x000180B4 File Offset: 0x000162B4
internal override void Invoke(ProvisionedFolder provisionedFolder, List <object[]> items, PropertyIndexHolder propertyIndexHolder)
{
FolderExpirationExecutor folderExpirationExecutor = new FolderExpirationExecutor(provisionedFolder, base.MailboxData, base.Assistant);
ExpirationEnforcer.Tracer.TraceDebug <object, string, int>((long)this.GetHashCode(), "{0}: Number of items found in folder '{1}' is {2}.", TraceContext.Get(), provisionedFolder.DisplayName, items.Count);
DefaultFolderType folderType = DefaultFolderType.None;
if (provisionedFolder.FolderId.Equals(base.MailboxData.MailboxSession.GetDefaultFolderId(DefaultFolderType.DeletedItems)))
{
folderType = DefaultFolderType.DeletedItems;
}
else if (provisionedFolder.ContainerClass != null && ObjectClass.IsCalendarFolder(provisionedFolder.ContainerClass))
{
folderType = DefaultFolderType.Calendar;
}
else if (provisionedFolder.ContainerClass != null && ObjectClass.IsTaskFolder(provisionedFolder.ContainerClass))
{
folderType = DefaultFolderType.Tasks;
}
ItemStartDateCalculator itemStartDateCalculator = new ItemStartDateCalculator(propertyIndexHolder, provisionedFolder.Folder.DisplayName, folderType, base.MailboxData.MailboxSession, ExpirationEnforcer.Tracer);
FolderAuditLogData folderAuditLogData = null;
if (base.MailboxData.ElcAuditLog.ExpirationLoggingEnabled)
{
folderAuditLogData = new FolderAuditLogData(provisionedFolder, base.MailboxData, ELCAction.Retention.ToString());
}
foreach (object[] array in items)
{
VersionedId versionedId = array[propertyIndexHolder.IdIndex] as VersionedId;
string text = array[propertyIndexHolder.ItemClassIndex] as string;
if (versionedId == null)
{
ExpirationEnforcer.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Current item in folder {1} is null. Skipping it.", TraceContext.Get(), provisionedFolder.DisplayName);
}
else
{
provisionedFolder.CurrentItems = new VersionedId[]
{
versionedId
};
text = ((text == null) ? string.Empty : text.ToLower());
ContentSetting contentSetting = null;
contentSetting = ElcPolicySettings.GetApplyingPolicy(provisionedFolder.ElcPolicies, text, provisionedFolder.ItemClassToPolicyMapping);
if (contentSetting == null)
{
ExpirationEnforcer.Tracer.TraceDebug <object, string, string>((long)this.GetHashCode(), "{0}: Policy for item class {1} in folder {2} is null. Skipping item.", TraceContext.Get(), text, provisionedFolder.DisplayName);
}
else if (!base.MailboxData.FolderProcessor.IsPolicyValid(provisionedFolder, contentSetting, text, base.MailboxData))
{
ExpirationEnforcer.Tracer.TraceDebug <object, string, string>((long)this.GetHashCode(), "{0}: Removing policy {1} from the list in folder {2} because it is invalid.", TraceContext.Get(), contentSetting.Name, provisionedFolder.DisplayName);
provisionedFolder.RemovePolicy(contentSetting);
}
else
{
double totalDays = contentSetting.AgeLimitForRetention.Value.TotalDays;
int num;
if (contentSetting.TriggerForRetention == RetentionDateType.WhenMoved)
{
ExpirationEnforcer.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Applying policy. Policy '{1}' expires based on move date.", TraceContext.Get(), contentSetting.Name);
CompositeProperty compositeProperty = null;
if (ElcMailboxHelper.Exists(array[propertyIndexHolder.MoveDateIndex]))
{
try
{
compositeProperty = CompositeProperty.Parse((byte[])array[propertyIndexHolder.MoveDateIndex]);
}
catch (ArgumentException ex)
{
ExpirationEnforcer.Tracer.TraceError((long)this.GetHashCode(), "{0}: Could not parse move date property of item. Folder: {1} ItemClass: {2} Exception: {3}.", new object[]
{
TraceContext.Get(),
provisionedFolder.DisplayName,
text,
ex
});
base.MailboxData.ThrowIfErrorsOverLimit();
}
}
if (compositeProperty == null)
{
string arg = "Stamped Move date is null.";
ExpirationEnforcer.Tracer.TraceDebug <object, VersionedId, string>((long)this.GetHashCode(), "{0}: Move date needs to be stamped on item {1}. {2}", TraceContext.Get(), versionedId, arg);
folderExpirationExecutor.AddToMoveDateStampingList(new ItemData(versionedId, (int)array[propertyIndexHolder.SizeIndex]));
continue;
}
ExpirationEnforcer.Tracer.TraceDebug <object, VersionedId>((long)this.GetHashCode(), "{0}: Calculating age of item {1} based on move date", TraceContext.Get(), versionedId);
num = (int)base.MailboxData.Now.Subtract(compositeProperty.Date.Value).TotalDays;
}
else
{
DateTime startDate = itemStartDateCalculator.GetStartDate(versionedId, text, array);
if (startDate == DateTime.MinValue)
{
num = 0;
}
else
{
num = (int)base.MailboxData.UtcNow.Subtract(startDate).TotalDays;
}
}
try
{
if ((double)num >= totalDays)
{
if (contentSetting.RetentionAction == RetentionActionType.MarkAsPastRetentionLimit && array[propertyIndexHolder.ExpiryTimeIndex] != null && !(array[propertyIndexHolder.ExpiryTimeIndex] is PropertyError))
{
ExpirationEnforcer.Tracer.TraceDebug <object, VersionedId>((long)this.GetHashCode(), "{0}: Item {1} is already tagged with expiry time, hence will not tag again.", TraceContext.Get(), versionedId);
}
else
{
ExpirationEnforcer.Tracer.TraceDebug <object, VersionedId>((long)this.GetHashCode(), "{0}: Adding item {1} to list to be expired.", TraceContext.Get(), versionedId);
ItemAuditLogData itemAuditLogData = null;
if (base.MailboxData.ElcAuditLog.ExpirationLoggingEnabled)
{
folderAuditLogData.ExpirationAction = contentSetting.RetentionAction.ToString();
itemAuditLogData = new ItemAuditLogData(array, propertyIndexHolder, folderAuditLogData);
}
ItemData itemData = new ItemData(versionedId, (array[propertyIndexHolder.ReceivedTimeIndex] is ExDateTime) ? ((DateTime)((ExDateTime)array[propertyIndexHolder.ReceivedTimeIndex])) : DateTime.MinValue, itemAuditLogData, (int)array[propertyIndexHolder.SizeIndex]);
folderExpirationExecutor.AddToReportAndDoomedList(array, propertyIndexHolder, contentSetting, itemData, text, this.allPolicyTags);
}
}
}
catch (InvalidExpiryDestinationException ex2)
{
ExpirationEnforcer.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Removing policy '{1}', that applies to folder '{2}' from list of policies to process. Exception: {3}", new object[]
{
TraceContext.Get(),
contentSetting.Name,
contentSetting.ManagedFolderName,
ex2
});
provisionedFolder.RemovePolicy(contentSetting);
}
catch (SkipFolderException ex3)
{
ExpirationEnforcer.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Policy '{1}', that applies to folder '{2}' will be skipped for the current folder. Exception: {3}", new object[]
{
TraceContext.Get(),
contentSetting.Name,
contentSetting.ManagedFolderName,
ex3
});
return;
}
}
}
}
ExpirationEnforcer.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: Done identifying items for expiration. Proceed to expire.", new object[]
{
TraceContext.Get()
});
ExpirationEnforcer.TracerPfd.TracePfd <int, object>((long)this.GetHashCode(), "PFD IWE {0} {1}: Done identifying items for expiration. Calling ExpirationExecutor to expire.", 26903, TraceContext.Get());
folderExpirationExecutor.ExecuteTheDoomed();
}
// Token: 0x060002DD RID: 733 RVA: 0x00011FD4 File Offset: 0x000101D4
internal FolderPolicy(ProvisionedFolder provisionedFolder, ContentSetting policy)
{
this.provisionedFolder = provisionedFolder;
this.policy = policy;
}
// Token: 0x060002FC RID: 764 internal abstract void SetItemQueryFlags(ProvisionedFolder provisionedFolder, ItemFinder itemFinder);
// Token: 0x060002DA RID: 730 RVA: 0x00011DC0 File Offset: 0x0000FFC0
private FolderProcessor.CircularPolicyType CheckDestinationFolder(List <FolderProcessor.FolderPolicy> visitedNodes, ProvisionedFolder destProvisionedFolder, ContentSetting policy)
{
int num = visitedNodes.FindIndex((FolderProcessor.FolderPolicy folderPolicy) => folderPolicy.ProvisionedFolder.FolderId.Equals(destProvisionedFolder.FolderId));
if (num < 0)
{
FolderProcessor.Tracer.TraceDebug <object, ProvisionedFolder>((long)this.GetHashCode(), "{0}: Folder {1} has not been visited before. No cycle yet.", TraceContext.Get(), destProvisionedFolder);
return(FolderProcessor.CircularPolicyType.NoCycle);
}
if (num == visitedNodes.Count - 1)
{
FolderProcessor.Tracer.TraceDebug <object, string>((long)this.GetHashCode(), "{0}: Policy '{1}' has source = destination. Quit without error.", TraceContext.Get(), policy.Name);
return(FolderProcessor.CircularPolicyType.GoodCycle);
}
StringBuilder stringBuilder = new StringBuilder();
for (int i = num; i < visitedNodes.Count; i++)
{
stringBuilder.Append(visitedNodes[i].ProvisionedFolder.DisplayName + ":" + visitedNodes[i].Policy.Name + ", ");
}
string text = stringBuilder.ToString().TrimEnd(new char[]
{
',',
' '
});
FolderProcessor.Tracer.TraceError <object, string>((long)this.GetHashCode(), "{0}: There is a cycle among the policies in this mailbox. Policies involved (Folder Name:Policy Name) are {1}", TraceContext.Get(), text);
Globals.Logger.LogEvent(InfoWorkerEventLogConstants.Tuple_CycleInPolicies, null, new object[]
{
this.mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString(),
text
});
return(FolderProcessor.CircularPolicyType.BadCycle);
}
// Token: 0x060002FD RID: 765 internal abstract void Invoke(ProvisionedFolder provisionedFolder, List <object[]> items, PropertyIndexHolder propertyIndexHolder);
// Token: 0x06000303 RID: 771 RVA: 0x00012F24 File Offset: 0x00011124
internal override void Invoke(ProvisionedFolder provisionedFolder, List <object[]> items, PropertyIndexHolder propertyIndexHolder)
{
AutoCopyEnforcer.TracerPfd.TracePfd <int, Folder>((long)this.GetHashCode(), "PFD IWE {0} {1} AutoCopyEnforcer Invoked", 18711, provisionedFolder.Folder);
using (Folder folder = Folder.Bind(base.MailboxData.MailboxSession, this.SendFolderId))
{
foreach (object[] array in items)
{
if (array[propertyIndexHolder.IdIndex] is VersionedId)
{
VersionedId versionedId = (VersionedId)array[propertyIndexHolder.IdIndex];
provisionedFolder.CurrentItems = new VersionedId[]
{
versionedId
};
object obj = array[propertyIndexHolder.AutoCopiedIndex];
if (obj is byte[])
{
AutoCopyEnforcer.Tracer.TraceDebug <object, VersionedId>((long)this.GetHashCode(), "{0}: ignoring item '{1}' because it has been copied already.", TraceContext.Get(), versionedId);
}
else
{
string text = array[propertyIndexHolder.ItemClassIndex] as string;
text = ((text == null) ? string.Empty : text.ToLower());
ContentSetting applyingPolicy = ElcPolicySettings.GetApplyingPolicy(provisionedFolder.ElcPolicies, text, provisionedFolder.ItemClassToPolicyMapping);
if (applyingPolicy != null && applyingPolicy.JournalingEnabled)
{
ItemAuditLogData itemAuditLogData = null;
if (base.MailboxData.ElcAuditLog.AutocopyLoggingEnabled)
{
itemAuditLogData = new ItemAuditLogData(array, propertyIndexHolder, new FolderAuditLogData(provisionedFolder, base.MailboxData, ELCAction.Journaling.ToString(), this.GetOfficialFileParticipant(applyingPolicy).EmailAddress));
}
ItemData itemData = new ItemData(versionedId, (array[propertyIndexHolder.ReceivedTimeIndex] is ExDateTime) ? ((DateTime)((ExDateTime)array[propertyIndexHolder.ReceivedTimeIndex])) : DateTime.MinValue, itemAuditLogData, (int)array[propertyIndexHolder.SizeIndex]);
StoreObjectId storeObjectId;
bool flag = this.SendItemAsAttachement(applyingPolicy, itemData, out storeObjectId);
if (flag)
{
this.MarkItemAsCopied(itemData, provisionedFolder);
ELCPerfmon.TotalItemsAutoCopied.Increment();
}
else
{
Exception ex = null;
OperationResult operationResult = OperationResult.Succeeded;
try
{
operationResult = folder.DeleteObjects(DeleteItemFlags.HardDelete, new StoreObjectId[]
{
storeObjectId
}).OperationResult;
}
catch (Exception ex2)
{
operationResult = OperationResult.Failed;
ex = ex2;
}
if (operationResult != OperationResult.Succeeded)
{
AutoCopyEnforcer.Tracer.TraceDebug <object, string, string>((long)this.GetHashCode(), "{0}: Failed to delete the journal message '{1}'. Exception: '{2}'.", TraceContext.Get(), storeObjectId.ToString(), (ex == null) ? "" : ex.Message);
}
}
}
}
}
}
}
}
