// Token: 0x060003D4 RID: 980 RVA: 0x0001B9C0 File Offset: 0x00019BC0
private bool PreScreenPassed(object[] itemProperties, PropertyIndexHolder propertyIndexHolder, out string itemClass)
{
itemClass = null;
VersionedId versionedId = itemProperties[propertyIndexHolder.IdIndex] as VersionedId;
if (versionedId == null)
{
ExpirationTagEnforcer.Tracer.TraceError <ExpirationTagEnforcer>((long)this.GetHashCode(), "{0}: We could not get id of this item. Skipping it.", this);
return(false);
}
StoreObjectId storeObjectId = itemProperties[propertyIndexHolder.ParentItemIdIndex] as StoreObjectId;
if (storeObjectId == null)
{
ExpirationTagEnforcer.Tracer.TraceError <ExpirationTagEnforcer>((long)this.GetHashCode(), "{0}: We could not get parent id of this item. Skipping it.", this);
return(false);
}
if (base.MailboxDataForTags.CorruptItemList.Contains(versionedId.ObjectId))
{
ExpirationTagEnforcer.Tracer.TraceError <ExpirationTagEnforcer, VersionedId>((long)this.GetHashCode(), "{0}: The item {1} is in the corrupt list. Skipping it.", this, versionedId);
return(false);
}
itemClass = (itemProperties[propertyIndexHolder.ItemClassIndex] as string);
itemClass = ((itemClass == null) ? string.Empty : itemClass.ToLower(CultureInfo.InvariantCulture));
return(TagAssistantHelper.IsRetainableItem(itemClass) && (!TagAssistantHelper.IsConflictableItem(itemClass, storeObjectId.ProviderLevelItemId, this.deletedItemsId) || base.ElcTagSubAssistant.ELCAssistantCalendarTaskRetentionEnabled));
}
// Token: 0x0600049E RID: 1182 RVA: 0x00021E0A File Offset: 0x0002000A
private bool IsConflictableItem(string itemClass)
{
if (TagAssistantHelper.IsConflictableItemClass(itemClass) && this.folderType != DefaultFolderType.DeletedItems)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer, DefaultFolderType>((long)this.GetHashCode(), "{0}: Item is conflictable and not in deleted items folder. Folder: {1}. Skipping it.", this, this.folderType);
return(true);
}
return(false);
}
// Token: 0x06000383 RID: 899 RVA: 0x00018855 File Offset: 0x00016A55
internal static bool IsConflictableItem(string itemClass, byte[] currentFolderId, byte[] deletedItemsFolderId)
{
if (TagAssistantHelper.IsConflictableItemClass(itemClass) && !ArrayComparer <byte> .Comparer.Equals(currentFolderId, deletedItemsFolderId))
{
TagAssistantHelper.Tracer.TraceDebug <string, byte[]>(0L, "Item is of message class {0}, in folder {1} and is hence conflictable.", itemClass, currentFolderId);
return(true);
}
return(false);
}
// Token: 0x060004A2 RID: 1186 RVA: 0x00021FA8 File Offset: 0x000201A8
public bool IsEventInteresting(MapiEvent mapiEvent)
{
ElcEventBasedAssistant.Tracer.TraceDebug <MapiEvent>((long)this.GetHashCode(), "MapiEvent is dispatched: {0}", mapiEvent);
if (!this.IsEventRelevant(mapiEvent))
{
return(false);
}
CachedState cachedState = AssistantsService.CachedObjectsList.GetCachedState(mapiEvent.MailboxGuid);
UserRetentionPolicyCache userRetentionPolicyCache = RetentionPolicyCheck.QuickCheckForRetentionPolicy(mapiEvent, cachedState);
if (userRetentionPolicyCache == null || userRetentionPolicyCache.UnderRetentionPolicy)
{
bool flag = RetentionPolicyCheck.IsEventConfigChange(mapiEvent);
if (flag)
{
RetentionPolicyCheck.UpdateStateForPendingFaiEvent(mapiEvent.EventCounter, cachedState);
ElcEventBasedAssistant.Tracer.TraceDebug <object, MapiEvent>((long)this.GetHashCode(), "{0}: this event is interesting because it is a change to our FAI: {1}", TraceContext.Get(), mapiEvent);
return(true);
}
if (RetentionPolicyCheck.IsAutoTagFai(mapiEvent))
{
ElcEventBasedAssistant.Tracer.TraceDebug <object, MapiEvent>((long)this.GetHashCode(), "{0}: this event is interesting because it is a change to an Autotag FAI: {1}", TraceContext.Get(), mapiEvent);
return(true);
}
MapiEventTypeFlags mapiEventTypeFlags = MapiEventTypeFlags.ObjectCreated | MapiEventTypeFlags.ObjectModified | MapiEventTypeFlags.ObjectMoved | MapiEventTypeFlags.ObjectCopied;
if ((mapiEvent.EventMask & mapiEventTypeFlags) != (MapiEventTypeFlags)0)
{
if (mapiEvent.ClientType == MapiEventClientTypes.Transport && userRetentionPolicyCache != null && !this.InSentItems(userRetentionPolicyCache, mapiEvent))
{
ElcEventBasedAssistant.Tracer.TraceDebug <MapiEvent>((long)this.GetHashCode(), "Event is from transport and item not in SentItems. Ignoring from IsEventInteresting. Mapievent: {0}", mapiEvent);
return(false);
}
if (userRetentionPolicyCache != null && !this.IsEventOnRelevantFolder(userRetentionPolicyCache, mapiEvent))
{
return(false);
}
if (userRetentionPolicyCache != null && TagAssistantHelper.IsConflictableItem(mapiEvent.ObjectClass, mapiEvent.ParentEntryId, userRetentionPolicyCache.DeletedItemsId))
{
return(false);
}
MapiEventTypeFlags mapiEventTypeFlags2 = MapiEventTypeFlags.ObjectMoved | MapiEventTypeFlags.ObjectCopied;
if (mapiEvent.ItemType == ObjectType.MAPI_FOLDER && (mapiEvent.EventMask & mapiEventTypeFlags2) != (MapiEventTypeFlags)0)
{
ElcEventBasedAssistant.Tracer.TraceDebug <object, MapiEvent>((long)this.GetHashCode(), "{0}: this event is interesting because is a moved folder: {1}", TraceContext.Get(), mapiEvent);
return(true);
}
if (mapiEvent.ItemType == ObjectType.MAPI_MESSAGE)
{
ElcEventBasedAssistant.Tracer.TraceDebug <object, MapiEvent>((long)this.GetHashCode(), "{0}: this event is interesting because is a message: {1}", TraceContext.Get(), mapiEvent);
return(true);
}
}
}
return(false);
}
// Token: 0x06000380 RID: 896 RVA: 0x000187A0 File Offset: 0x000169A0
internal static bool IsRetainableItem(UserRetentionPolicyCache mailboxState, MailboxSession mailboxSession, StoreObjectId parentId, StoreObject item)
{
DefaultFolderType parentDefaultFolderType = TagAssistantHelper.GetParentDefaultFolderType(mailboxState, mailboxSession, parentId);
if (UserRetentionPolicyCache.IsFolderTypeToSkip(parentDefaultFolderType))
{
TagAssistantHelper.Tracer.TraceDebug <DefaultFolderType>(0L, "Current item is in folder {0} (or a sub-folder) that should not be processed.", parentDefaultFolderType);
return(false);
}
return(TagAssistantHelper.IsRetainableItem(item.ClassName));
}
// Token: 0x06000497 RID: 1175 RVA: 0x000212CC File Offset: 0x0001F4CC
private void UpdateContentSettingProperties(bool tagChanged, Guid updatedTagGuid, DateTime updatedStartDate, string itemClass, object[] itemProperties)
{
if (!tagChanged && updatedTagGuid.Equals(Guid.Empty))
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: No need to update ContentSettings since tag is null and there was no change.", this);
return;
}
int num = -1;
if (itemProperties[this.propertyIndexHolder.RetentionPeriodIndex] is int)
{
num = (int)itemProperties[this.propertyIndexHolder.RetentionPeriodIndex];
}
DateTime dateTime = DateTime.MinValue;
if (itemProperties[this.propertyIndexHolder.RetentionDateIndex] is ExDateTime)
{
dateTime = (DateTime)((ExDateTime)itemProperties[this.propertyIndexHolder.RetentionDateIndex]).ToUtc();
}
if (tagChanged && updatedTagGuid.Equals(Guid.Empty))
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Tag is null, so we need to delete the Retention Date & Retention Period.", this);
if (dateTime != DateTime.MinValue)
{
base.PropertiesToBeDeleted.Add(ItemSchema.RetentionDate);
}
if (num != -1)
{
base.PropertiesToBeDeleted.Add(StoreObjectSchema.RetentionPeriod);
}
return;
}
int retentionPeriod = this.GetRetentionPeriod(updatedTagGuid, itemClass);
DateTime retentionDate = this.GetRetentionDate(updatedStartDate, retentionPeriod);
if (itemProperties[this.propertyIndexHolder.RetentionPeriodIndex] is int && num != retentionPeriod)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Retention period needs to be updated.", this);
base.PropertiesToBeUpdated.Add(StoreObjectSchema.RetentionPeriod, retentionPeriod);
}
if (!TagAssistantHelper.DateSlushyEquals(new DateTime?(retentionDate), new DateTime?(dateTime)))
{
if (retentionDate == DateTime.MinValue)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Retention date needs to be deleted.", this);
base.PropertiesToBeDeleted.Add(ItemSchema.RetentionDate);
return;
}
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Retention date needs to be updated.", this);
base.PropertiesToBeUpdated.Add(ItemSchema.RetentionDate, retentionDate);
}
}
// Token: 0x06000448 RID: 1096 RVA: 0x0001E678 File Offset: 0x0001C878
private void UpdateRetentionFlags(Guid retentionTagToUpdateTo)
{
RetentionAndArchiveFlags retentionAndArchiveFlags = TagAssistantHelper.UpdatePersonalTagBit((!base.ElcUserTagInformation.ContainsTag(retentionTagToUpdateTo)) ? null : base.ElcUserTagInformation.GetTag(retentionTagToUpdateTo), this.originalRetentionFlags);
if (retentionTagToUpdateTo.Equals(Guid.Empty))
{
retentionAndArchiveFlags = FlagsMan.ClearAllRetentionFlags(retentionAndArchiveFlags);
}
else if (this.explicitRetention)
{
retentionAndArchiveFlags = (RetentionAndArchiveFlags)FlagsMan.SetExplicit((int)retentionAndArchiveFlags);
}
else
{
retentionAndArchiveFlags = (RetentionAndArchiveFlags)FlagsMan.ClearExplicit((int)retentionAndArchiveFlags);
}
if (this.effectiveArchiveGuid == null || this.effectiveArchiveGuid.Equals(Guid.Empty))
{
retentionAndArchiveFlags = FlagsMan.ClearAllArchiveFlags(retentionAndArchiveFlags);
}
else if (this.explicitArchive)
{
retentionAndArchiveFlags = FlagsMan.SetExplicitArchiveFlag(retentionAndArchiveFlags);
}
else
{
retentionAndArchiveFlags = FlagsMan.ClearExplicitArchiveFlag(retentionAndArchiveFlags);
}
retentionAndArchiveFlags = FlagsMan.SetPendingRescan(retentionAndArchiveFlags);
retentionAndArchiveFlags = FlagsMan.ClearNeedRescan(retentionAndArchiveFlags);
if (retentionAndArchiveFlags != this.originalRetentionFlags)
{
if (retentionAndArchiveFlags == RetentionAndArchiveFlags.None)
{
PropertySynchronizerBase.Tracer.TraceDebug <FolderPropertySynchronizer>((long)this.GetHashCode(), "{0}: The flags bit on the folder will be removed.", this);
base.PropertiesToBeDeleted.Add(StoreObjectSchema.RetentionFlags);
base.FolderProperties[3] = null;
return;
}
PropertySynchronizerBase.Tracer.TraceDebug <FolderPropertySynchronizer, RetentionAndArchiveFlags, RetentionAndArchiveFlags>((long)this.GetHashCode(), "{0}: The flags bit on the folder will be updated. ExpectedFlags: {1}. OriginalFlags: {2}. ", this, retentionAndArchiveFlags, this.originalRetentionFlags);
base.PropertiesToBeUpdated.Add(StoreObjectSchema.RetentionFlags, (int)retentionAndArchiveFlags);
base.FolderProperties[3] = (int)retentionAndArchiveFlags;
}
}
// Token: 0x060004A3 RID: 1187 RVA: 0x00022124 File Offset: 0x00020324
protected override void HandleEventInternal(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item, List <KeyValuePair <string, object> > customDataToLog)
{
ElcEventBasedAssistant.Tracer.TraceDebug <MapiEvent>((long)this.GetHashCode(), "MapiEvent is handled: {0}", mapiEvent);
this.ManageCache(mapiEvent.MailboxGuid);
if (this.IsIgnorableDraft(mapiEvent, item))
{
return;
}
CachedState cachedState = AssistantsService.CachedObjectsList.GetCachedState(mapiEvent.MailboxGuid);
cachedState.LockForRead();
UserRetentionPolicyCache userRetentionPolicyCache = null;
try
{
userRetentionPolicyCache = RetentionPolicyCheck.DetailedCheckForRetentionPolicy(mapiEvent, itemStore, item, cachedState);
}
finally
{
cachedState.ReleaseReaderLock();
}
if (RetentionPolicyCheck.IsEventConfigChange(mapiEvent))
{
ElcEventBasedAssistant.Tracer.TraceDebug <object, MapiEvent>((long)this.GetHashCode(), "{0}: updated configuration {1}", TraceContext.Get(), mapiEvent);
return;
}
if (userRetentionPolicyCache != null && userRetentionPolicyCache.UnderRetentionPolicy)
{
bool flag = false;
if (!this.IsEventOnRelevantFolder(userRetentionPolicyCache, mapiEvent))
{
return;
}
if (mapiEvent.ClientType == MapiEventClientTypes.Transport && !this.InSentItems(userRetentionPolicyCache, mapiEvent))
{
ElcEventBasedAssistant.Tracer.TraceDebug <ElcEventBasedAssistant, MapiEvent>((long)this.GetHashCode(), "{0} Event is from transport and item not in SentItems. Ignoring from HandleEvent. Mapievent: {1}", this, mapiEvent);
return;
}
if (TagAssistantHelper.IsConflictableItem(mapiEvent.ObjectClass, mapiEvent.ParentEntryId, userRetentionPolicyCache.DeletedItemsId))
{
return;
}
if ((mapiEvent.EventMask & MapiEventTypeFlags.ObjectMoved) != (MapiEventTypeFlags)0 && mapiEvent.ItemType == ObjectType.MAPI_FOLDER)
{
userRetentionPolicyCache.ResetFolderCaches();
}
StoreObjectId storeObjectId = StoreObjectId.FromProviderSpecificId(mapiEvent.ItemEntryId);
if (mapiEvent.ItemType == ObjectType.MAPI_FOLDER && item == null && mapiEvent.ItemEntryId != null && (mapiEvent.EventMask & MapiEventTypeFlags.ObjectDeleted) == (MapiEventTypeFlags)0)
{
Exception ex = null;
try
{
ElcEventBasedAssistant.Tracer.TraceDebug <object, MapiEvent>((long)this.GetHashCode(), "{0}: A folder was changed and needs to be manually loaded {1}", TraceContext.Get(), mapiEvent);
item = Folder.Bind(itemStore, storeObjectId, ElcEventBasedAssistantType.InternalPreloadItemProperties);
flag = true;
}
catch (ObjectNotFoundException ex2)
{
ex = ex2;
}
catch (ConversionFailedException ex3)
{
ex = ex3;
}
catch (VirusMessageDeletedException ex4)
{
ex = ex4;
}
if (ex != null)
{
ElcEventBasedAssistant.Tracer.TraceDebug <ElcEventBasedAssistant, Exception>((long)this.GetHashCode(), "{0}: Problems loading a folder. It will not be processed. Exception: {1}", this, ex);
return;
}
}
try
{
StoreObjectId parentId = StoreObjectId.FromProviderSpecificId(mapiEvent.ParentEntryId);
ElcEventProcessor elcEventProcessor = ElcEventProcessor.GetElcEventProcessor();
elcEventProcessor.ValidateStoreObject(userRetentionPolicyCache, itemStore, parentId, storeObjectId, item, mapiEvent);
}
finally
{
if (flag)
{
item.Dispose();
}
}
}
}
// Token: 0x06000491 RID: 1169 RVA: 0x00020AF8 File Offset: 0x0001ECF8
private Guid UpdateTagProperties(out bool tagChanged, out Guid effectiveParentTagGuid, string itemClass, object[] itemProperties)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Start to update tag properties", this);
Guid value = ElcMailboxHelper.GetGuidFromBytes(itemProperties[this.propertyIndexHolder.PolicyTagIndex], new Guid?(Guid.Empty), true, (VersionedId)itemProperties[this.propertyIndexHolder.IdIndex]).Value;
Guid value2 = ElcMailboxHelper.GetGuidFromBytes(itemProperties[this.propertyIndexHolder.ExplicitPolicyTagIndex], new Guid?(Guid.Empty), true, (VersionedId)itemProperties[this.propertyIndexHolder.IdIndex]).Value;
int? retentionPeriod = (itemProperties[this.propertyIndexHolder.RetentionPeriodIndex] is int) ? ((int?)itemProperties[this.propertyIndexHolder.RetentionPeriodIndex]) : null;
int? retentionFlags = (itemProperties[this.propertyIndexHolder.RetentionFlagsIndex] is int) ? ((int?)itemProperties[this.propertyIndexHolder.RetentionFlagsIndex]) : null;
tagChanged = false;
Guid guid = value;
effectiveParentTagGuid = this.GetEffectiveParentTag(itemClass);
bool flag = TagAssistantHelper.IsTagImplicit(retentionPeriod, retentionFlags);
bool flag2 = !base.ElcUserTagInformation.ContainsTag(value);
if (!value2.Equals(Guid.Empty) && base.ElcUserTagInformation.ContainsTag(value2))
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Found explicit personal tag", this);
tagChanged = true;
guid = value2;
base.AddAdriftTagToFai(value2);
this.SetTagProperties(guid, value, true);
base.PropertiesToBeDeleted.Add(StoreObjectSchema.ExplicitPolicyTag);
itemProperties[this.propertyIndexHolder.RetentionPeriodIndex] = 1;
ELCPerfmon.TotalItemsWithPersonalTag.Increment();
this.taggedByPersonalExpiryTag = true;
}
else if (flag || (itemProperties[this.propertyIndexHolder.RetentionPeriodIndex] is int && flag2))
{
if (!effectiveParentTagGuid.Equals(value))
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: The original tag doesn't match the parent tag", this);
if (!flag)
{
base.PropertiesToBeUpdated.Add(StoreObjectSchema.ExplicitPolicyTag, value.ToByteArray());
base.AddDeletedTag(value);
}
if (!this.ShouldSkipImplicitItem(itemProperties, effectiveParentTagGuid, value, itemClass))
{
tagChanged = true;
guid = effectiveParentTagGuid;
this.SetTagProperties(effectiveParentTagGuid, value, false);
itemProperties[this.propertyIndexHolder.RetentionPeriodIndex] = null;
if (effectiveParentTagGuid != Guid.Empty)
{
if (base.ElcUserTagInformation.AllAdTags.ContainsKey(effectiveParentTagGuid))
{
if (base.ElcUserTagInformation.GetTag(effectiveParentTagGuid).Tag.Type == ElcFolderType.Personal)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Inherited explicit personal tag", this);
ELCPerfmon.TotalItemsWithPersonalTag.Increment();
this.taggedByPersonalExpiryTag = true;
}
else if (base.ElcUserTagInformation.GetTag(effectiveParentTagGuid).Tag.Type == ElcFolderType.All)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Inherited default tag", this);
ELCPerfmon.TotalItemsWithDefaultTag.Increment();
this.taggedByDefaultExpiryTag = true;
}
else
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Inherited system tag", this);
ELCPerfmon.TotalItemsWithDefaultTag.Increment();
this.taggedBySystemExpiryTag = true;
}
}
else
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: The parent tag is not in AD. Its type is unknown.", this);
this.taggedByUncertainExpiryTag = true;
}
}
else if (!flag)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: The tag is explicit. Removed personal tag", this);
this.taggedByPersonalExpiryTag = true;
}
else if (!flag2)
{
if (base.ElcUserTagInformation.GetTag(value).Tag.Type == ElcFolderType.Personal)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Removed personal tag", this);
this.taggedByPersonalExpiryTag = true;
}
else if (base.ElcUserTagInformation.GetTag(value).Tag.Type == ElcFolderType.All)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Removed default tag", this);
this.taggedByDefaultExpiryTag = true;
}
else
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Removed system tag", this);
this.taggedBySystemExpiryTag = true;
}
}
else
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: The removed tag is deleted in AD. Its type is unknown.", this);
this.taggedByUncertainExpiryTag = true;
}
}
else
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: The item is skipped", this);
}
}
else
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: The original tag matches the parent tag", this);
if (FlagsMan.IsAutoTagSet(itemProperties[this.propertyIndexHolder.RetentionFlagsIndex]))
{
base.PropertiesToBeDeleted.Add(StoreObjectSchema.RetentionPeriod);
itemProperties[this.propertyIndexHolder.RetentionPeriodIndex] = null;
}
}
}
else if (itemProperties[this.propertyIndexHolder.RetentionPeriodIndex] is int)
{
base.AddAdriftTagToFai(value);
}
return(guid);
}
// Token: 0x0600048D RID: 1165 RVA: 0x0002067C File Offset: 0x0001E87C
internal void Update()
{
bool processEhaMigratedMessages = base.MailboxDataForTags.ElcUserInformation.ProcessEhaMigratedMessages;
using (IEnumerator <List <object[]> > allItemsIterator = this.GetAllItemsIterator())
{
while (allItemsIterator != null && allItemsIterator.MoveNext())
{
List <object[]> list = allItemsIterator.Current;
VersionedId versionedId = null;
Guid empty = Guid.Empty;
Guid empty2 = Guid.Empty;
DateTime updatedStartDate = DateTime.MaxValue;
Guid updatedTagGuid = Guid.Empty;
foreach (object[] array in list)
{
versionedId = (array[this.propertyIndexHolder.IdIndex] as VersionedId);
if (versionedId == null)
{
PropertySynchronizerBase.Tracer.TraceError <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: We could not get id of this item.", this);
}
else
{
if (processEhaMigratedMessages)
{
object obj = array[this.propertyIndexHolder.EHAMigrationExpiryDateIndex];
if (obj != null && obj is ExDateTime)
{
PropertySynchronizerBase.Tracer.TraceError <ItemPropertySynchronizer, object>((long)this.GetHashCode(), "{0}: We dont tag eha migration messages, this message is stamped with migration expiration date from eha. Expiration date is {1}", this, obj);
continue;
}
}
base.PropertiesToBeDeleted.Clear();
base.PropertiesToBeUpdated.Clear();
bool tagChanged = false;
this.taggedByDefaultExpiryTag = false;
this.taggedByPersonalArchiveTag = false;
this.taggedByPersonalExpiryTag = false;
this.taggedBySystemExpiryTag = false;
this.taggedByUncertainExpiryTag = false;
string text = array[this.propertyIndexHolder.ItemClassIndex] as string;
text = ((text == null) ? string.Empty : ElcPolicySettings.GetEffectiveItemClass(text).ToLower());
if (TagAssistantHelper.IsRetainableItem(text) && !this.ShouldSkipItem(array) && !this.IsRuleMessageItem(text))
{
try
{
empty = Guid.Empty;
empty2 = Guid.Empty;
updatedStartDate = DateTime.MaxValue;
updatedTagGuid = this.UpdateTagProperties(out tagChanged, out empty, text, array);
bool tagChanged2 = this.UpdateArchiveTag(array, out empty2);
if (!updatedTagGuid.Equals(Guid.Empty) || !empty2.Equals(Guid.Empty))
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer>((long)this.GetHashCode(), "{0}: Need to set StartDate since no tag is present.", this);
updatedStartDate = this.UpdateStartDateEtc(versionedId, text, array);
}
this.UpdateContentSettingProperties(tagChanged, updatedTagGuid, updatedStartDate, text, array);
this.UpdateRetentionFlags(empty, tagChanged, updatedTagGuid, empty2, array);
this.UpdateArchiveContentSettingProperties(tagChanged2, array, text, empty2, updatedStartDate);
this.CommitChangesAlready(versionedId);
}
catch (ArgumentOutOfRangeException arg)
{
PropertySynchronizerBase.Tracer.TraceDebug <ItemPropertySynchronizer, string, ArgumentOutOfRangeException>((long)this.GetHashCode(), "{0} Corrupted Data. Skip current item {1}. Exception: {2}", this, versionedId.ObjectId.ToHexEntryId(), arg);
}
}
}
}
}
}
}
