internal CoreObject(StoreSession session, PersistablePropertyBag propertyBag, StoreObjectId storeObjectId, byte[] changeKey, Origin origin, ItemLevel itemLevel, ICollection <PropertyDefinition> prefetchProperties)
{
using (DisposeGuard disposeGuard = this.Guard())
{
this.session = session;
this.propertyBag = propertyBag;
this.itemLevel = itemLevel;
this.Origin = origin;
if (propertyBag.DisposeTracker != null)
{
propertyBag.DisposeTracker.AddExtraDataWithStackTrace("CoreObject owns PersistablePropertyBag propertyBag at");
}
((IDirectPropertyBag)CoreObject.GetPersistablePropertyBag(this)).Context.CoreObject = this;
((IDirectPropertyBag)CoreObject.GetPersistablePropertyBag(this)).Context.Session = this.Session;
if (prefetchProperties != null)
{
if (prefetchProperties == CoreObjectSchema.AllPropertiesOnStore)
{
this.propertyBag.PrefetchPropertyArray = CoreObjectSchema.AllPropertiesOnStore;
}
else
{
this.propertyBag.PrefetchPropertyArray = StorePropertyDefinition.GetNativePropertyDefinitions <PropertyDefinition>(PropertyDependencyType.AllRead, prefetchProperties).ToArray <NativeStorePropertyDefinition>();
}
this.propertyBag.Load(prefetchProperties);
}
this.storeObjectId = storeObjectId;
this.id = ((changeKey != null) ? new VersionedId(this.storeObjectId, changeKey) : null);
disposeGuard.Success();
}
}
public static void InitExtendedRuleSizeLimitIfNeeded(MailboxSession originalSession)
{
if (originalSession.LogonType != LogonType.BestAccess && originalSession.LogonType != LogonType.Delegated && originalSession.LogonType != LogonType.Owner)
{
return;
}
int?num = originalSession.Mailbox.TryGetProperty(MailboxSchema.ExtendedRuleSizeLimit) as int?;
if (num == null || num > 522240)
{
using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(originalSession.MailboxOwner, originalSession.InternalCulture, "Client=Management;Action=InitExtendedRuleSizeLimit"))
{
mailboxSession.Mailbox.SetProperties(new PropertyDefinition[]
{
MailboxSchema.ExtendedRuleSizeLimit
}, new object[]
{
522240
});
CoreObject.GetPersistablePropertyBag((CoreMailboxObject)mailboxSession.Mailbox.CoreObject).FlushChanges();
}
originalSession.Mailbox.ForceReload(new PropertyDefinition[]
{
MailboxSchema.ExtendedRuleSizeLimit
});
}
}
public PropertyError[] CopyProperties(CoreAttachment destinationAttachment, CopyPropertiesFlags copyPropertiesFlags, NativeStorePropertyDefinition[] includeProperties)
{
this.CheckDisposed(null);
Util.ThrowOnNullArgument(destinationAttachment, "destinationAttachment");
Util.ThrowOnNullArgument(includeProperties, "includeProperties");
EnumValidator.ThrowIfInvalid <CopyPropertiesFlags>(copyPropertiesFlags, "copyPropertiesFlags");
return(CoreObject.MapiCopyProps(this.PropertyBag.MapiProp, destinationAttachment.PropertyBag.MapiProp, this.Session, destinationAttachment.Session, copyPropertiesFlags, includeProperties));
}
internal FolderInformation(CoreFolder coreFolder)
{
this.propertyBag = CoreObject.GetPersistablePropertyBag(coreFolder);
this.propertyBag.Load(MapiAclTableRestriction.FolderInformation.PropertyDefinitions);
string valueOrDefault = this.propertyBag.GetValueOrDefault <string>(StoreObjectSchema.ContainerClass);
this.storeObjectType = ObjectClass.GetObjectType(valueOrDefault);
}
public void Flush()
{
this.CheckDisposed(null);
this.CoreObjectUpdate();
PersistablePropertyBag persistablePropertyBag = CoreObject.GetPersistablePropertyBag(this.ParentCollection.ContainerItem);
if (!persistablePropertyBag.Context.IsValidationDisabled)
{
ValidationContext context = new ValidationContext(this.Session);
Validation.Validate(this, context);
}
this.PropertyBag.FlushChanges();
}
private void InternalConvertToItem(MsgStorageReader reader)
{
CoreObject.GetPersistablePropertyBag(base.CoreItem).SaveFlags |= (PropertyBagSaveFlags.IgnoreMapiComputedErrors | PropertyBagSaveFlags.IgnoreUnresolvedHeaders);
this.reader = reader;
this.ConvertMessage();
for (int num = 0; num != this.reader.RecipientCount; num++)
{
this.ConvertRecipient(num);
}
for (int num2 = 0; num2 != this.reader.AttachmentCount; num2++)
{
this.ConvertAttachment(num2);
}
}
public FolderSaveResult Save()
{
this.CheckDisposed(null);
this.ValidateStoreObject();
try
{
CoreObject.GetPersistablePropertyBag(this).FlushChanges();
}
catch (PropertyErrorException ex)
{
return(new FolderSaveResult(OperationResult.Failed, ex, ex.PropertyErrors));
}
CoreObject.GetPersistablePropertyBag(this).SaveChanges(false);
return(FolderPropertyBag.SuccessfulSave);
}
internal void CopyDataToItem(ICoreItem coreItem, bool importResourceFromTnef)
{
base.ReplyTo.Resync(true);
foreach (ConversionItemParticipants.ParticipantDefinitionEntry participantDefinitionEntry in ConversionItemParticipants.ParticipantEntries)
{
CoreObject.GetPersistablePropertyBag(coreItem).SetOrDeleteProperty(participantDefinitionEntry.ParticipantProperty, this.propertyBag.TryGetProperty(participantDefinitionEntry.ParticipantProperty));
}
CoreObject.GetPersistablePropertyBag(coreItem).SetOrDeleteProperty(InternalSchema.MapiReplyToBlob, this.propertyBag.TryGetProperty(InternalSchema.MapiReplyToBlob));
CoreObject.GetPersistablePropertyBag(coreItem).SetOrDeleteProperty(InternalSchema.MapiReplyToNames, this.propertyBag.TryGetProperty(InternalSchema.MapiReplyToNames));
if (this.tnefRecipientList != null)
{
Dictionary <ConversionRecipientEntry, ConversionRecipientEntry> dictionary = new Dictionary <ConversionRecipientEntry, ConversionRecipientEntry>();
foreach (ConversionRecipientEntry conversionRecipientEntry in this.tnefRecipientList)
{
dictionary[conversionRecipientEntry] = conversionRecipientEntry;
}
foreach (ConversionRecipientEntry conversionRecipientEntry2 in this.recipients)
{
ConversionRecipientEntry conversionRecipientEntry3 = null;
if (dictionary.TryGetValue(conversionRecipientEntry2, out conversionRecipientEntry3) && conversionRecipientEntry3 != null)
{
conversionRecipientEntry2.CopyDependentProperties(conversionRecipientEntry3);
}
}
}
foreach (ConversionRecipientEntry conversionRecipientEntry4 in this.recipients)
{
if (RecipientItemType.Bcc == conversionRecipientEntry4.RecipientItemType)
{
importResourceFromTnef = false;
}
this.CopyRecipientToMessage(coreItem, conversionRecipientEntry4);
}
if (importResourceFromTnef)
{
foreach (ConversionRecipientEntry conversionRecipientEntry5 in this.tnefRecipientList)
{
if (RecipientItemType.Bcc == conversionRecipientEntry5.RecipientItemType && (conversionRecipientEntry5.Participant.GetValueOrDefault <bool>(ParticipantSchema.IsRoom, false) || conversionRecipientEntry5.Participant.GetValueOrDefault <bool>(ParticipantSchema.IsResource, false)))
{
this.CopyRecipientToMessage(coreItem, conversionRecipientEntry5);
}
}
}
}
internal void UndoTnef()
{
this.CheckDisposed("UndoTnef");
this.ClearRecipientTable();
this.ClearAttachmentTable();
foreach (PropertyDefinition propertyDefinition in InboundMessageWriter.UndoPropertyList)
{
this.coreItem.PropertyBag.Delete(propertyDefinition);
}
PersistablePropertyBag persistablePropertyBag = CoreObject.GetPersistablePropertyBag(this.CoreItem);
IDirectPropertyBag directPropertyBag = persistablePropertyBag;
directPropertyBag.SetValue(InternalSchema.ItemClass, "IPM.Note");
MessageItem messageItem = this.coreItem as MessageItem;
if (messageItem != null)
{
messageItem.ReplyTo.Clear();
}
}
private void ConvertToItem(TnefReader reader, bool isSummaryTnef)
{
if (this.IsReplicationMessage)
{
PersistablePropertyBag persistablePropertyBag = CoreObject.GetPersistablePropertyBag(base.MessageWriter.CoreItem);
if (persistablePropertyBag != null)
{
persistablePropertyBag.Context.IsValidationDisabled = true;
}
}
this.reader = reader;
this.isSummaryTnef = isSummaryTnef;
this.isRecipientTablePromoted = false;
while (this.reader.ReadNextAttribute())
{
this.CheckTnefComplianceStatus();
this.ReadAttribute();
}
this.ProcessEndTnef();
PropertyBagSaveFlags propertyBagSaveFlags = PropertyBagSaveFlags.IgnoreMapiComputedErrors | base.ConversionOptions.GetSaveFlags(base.IsTopLevelMessage);
CoreObject.GetPersistablePropertyBag(base.CoreItem).SaveFlags |= propertyBagSaveFlags;
}
private void CopyRequiredData(MapiMessage sourceMessage)
{
CoreObject.MapiCopyTo(sourceMessage, this.underlyingMessage, this.session, this.session, CopyPropertiesFlags.None, CopySubObjects.Copy, CoreCalendarItemVersion.ItemBodyAndAttachmentProperties);
}
protected SynchronizerProviderBase(CoreFolder folder, SynchronizerConfigFlags flags, QueryFilter filter, StorageIcsState initialState, PropertyDefinition[] includeProperties, PropertyDefinition[] excludeProperties, short[] unspecifiedIncludeProperties, short[] unspecifiedExcludeProperties, int fastTransferBlockSize)
{
this.folder = folder;
bool flag = false;
try
{
PersistablePropertyBag persistablePropertyBag = CoreObject.GetPersistablePropertyBag(this.folder);
Restriction restriction = null;
if (filter != null)
{
restriction = FilterRestrictionConverter.CreateRestriction(folder.Session, persistablePropertyBag.ExTimeZone, persistablePropertyBag.MapiProp, filter);
}
ICollection <PropTag> includePropertyTags = null;
if (includeProperties != null && includeProperties.Length > 0)
{
includePropertyTags = PropertyTagCache.Cache.PropTagsFromPropertyDefinitions <PropertyDefinition>(this.MapiFolder, this.folder.Session, true, includeProperties);
}
ICollection <PropTag> excludePropertyTags = null;
if (excludeProperties != null && excludeProperties.Length > 0)
{
excludePropertyTags = PropertyTagCache.Cache.PropTagsFromPropertyDefinitions <PropertyDefinition>(this.MapiFolder, this.folder.Session, true, excludeProperties);
}
SynchronizerProviderBase.ReconstituteProperties(unspecifiedIncludeProperties, ref includePropertyTags);
SynchronizerProviderBase.ReconstituteProperties(unspecifiedExcludeProperties, ref excludePropertyTags);
StoreSession session = this.folder.Session;
object thisObject = this.folder;
bool flag2 = false;
try
{
if (session != null)
{
session.BeginMapiCall();
session.BeginServerHealthCall();
flag2 = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
this.MapiCreateSynchronizer(flags, restriction, initialState, includePropertyTags, excludePropertyTags, fastTransferBlockSize);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.CannotCreateSynchronizerEx(base.GetType()), ex, session, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("SynchronizerProviderBase..ctor. Failed to create/configure MapiSynchronizerEx.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.CannotCreateSynchronizerEx(base.GetType()), ex2, session, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("SynchronizerProviderBase..ctor. Failed to create/configure MapiSynchronizerEx.", new object[0]),
ex2
});
}
finally
{
try
{
if (session != null)
{
session.EndMapiCall();
if (flag2)
{
session.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
flag = true;
}
finally
{
if (!flag)
{
base.Dispose();
}
}
}
protected PropValue[] FromMapiPropValueToXsoPropValue(PropValue[] propValues)
{
PropTag[] array = new PropTag[propValues.Length];
for (int i = 0; i < propValues.Length; i++)
{
array[i] = propValues[i].PropTag;
}
NativeStorePropertyDefinition[] array2 = PropertyTagCache.Cache.PropertyDefinitionsFromPropTags(NativeStorePropertyDefinition.TypeCheckingFlag.DisableTypeCheck, this.MapiFolder, this.Session, array);
PropValue[] array3 = new PropValue[propValues.Length];
for (int j = 0; j < array2.Length; j++)
{
if (array2[j] == null)
{
throw new NotSupportedException(string.Format("The property tag cannot be resolved to a property definition. PropertyTag = {0}", array[j]));
}
object valueFromPropValue = MapiPropertyBag.GetValueFromPropValue(this.Session, CoreObject.GetPersistablePropertyBag(this.folder).ExTimeZone, array2[j], propValues[j]);
array3[j] = new PropValue(array2[j], valueFromPropValue);
}
return(array3);
}
internal RecipientTable(ICoreItem item)
{
bool flag = false;
try
{
StorageGlobals.TraceConstructIDisposable(this);
if (item.Session == null)
{
this.recipientTable = null;
}
else
{
this.mapiMessage = (MapiMessage)CoreObject.GetPersistablePropertyBag(item).MapiProp;
this.storeSession = item.Session;
this.timeZone = CoreObject.GetPersistablePropertyBag(item).ExTimeZone;
StoreSession storeSession = this.storeSession;
bool flag2 = false;
try
{
if (storeSession != null)
{
storeSession.BeginMapiCall();
storeSession.BeginServerHealthCall();
flag2 = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
this.recipientTable = this.mapiMessage.GetRecipientTable();
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotGetRecipientTable, ex, storeSession, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("RecipientTable::Storage.RecipientTable.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotGetRecipientTable, ex2, storeSession, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("RecipientTable::Storage.RecipientTable.", new object[0]),
ex2
});
}
finally
{
try
{
if (storeSession != null)
{
storeSession.EndMapiCall();
if (flag2)
{
storeSession.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
}
flag = true;
}
finally
{
if (!flag)
{
base.Dispose();
}
}
}
private ContactLinkingProcessingState InspectNotification(COWTriggerAction operation, StoreSession session, CoreItem item, bool onBeforeNotification, bool onDumpster)
{
if (onDumpster)
{
return(ContactLinkingProcessingState.DoNotProcess);
}
if (!onBeforeNotification)
{
return(ContactLinkingProcessingState.DoNotProcess);
}
if (item == null)
{
return(ContactLinkingProcessingState.Unknown);
}
if (!(session is MailboxSession))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: not a mailbox session.");
return(ContactLinkingProcessingState.DoNotProcess);
}
if (operation != COWTriggerAction.Create && operation != COWTriggerAction.Update)
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: not an Create or Update operation.");
return(ContactLinkingProcessingState.DoNotProcess);
}
PersistablePropertyBag persistablePropertyBag = CoreObject.GetPersistablePropertyBag(item);
switch (persistablePropertyBag.Context.AutomaticContactLinkingAction)
{
case AutomaticContactLinkingAction.ClientBased:
if (!this.IsClientAllowed(session.ClientInfoString))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: not allowed client session.");
return(ContactLinkingProcessingState.DoNotProcess);
}
break;
case AutomaticContactLinkingAction.Ignore:
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: IgnoreAutomaticContactLinking=true.");
return(ContactLinkingProcessingState.DoNotProcess);
}
if (session.LogonType != LogonType.Owner && session.LogonType != LogonType.Delegated)
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: logon session is not user or delegated.");
return(ContactLinkingProcessingState.DoNotProcess);
}
string valueOrDefault = item.PropertyBag.GetValueOrDefault <string>(StoreObjectSchema.ItemClass, string.Empty);
if (string.IsNullOrEmpty(valueOrDefault))
{
return(ContactLinkingProcessingState.Unknown);
}
if (ObjectClass.IsPlace(valueOrDefault))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: place item class are not processed.");
return(ContactLinkingProcessingState.DoNotProcess);
}
if (!ObjectClass.IsContact(valueOrDefault))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: item class is not contact.");
return(ContactLinkingProcessingState.DoNotProcess);
}
if (operation == COWTriggerAction.Update && !Array.Exists <StorePropertyDefinition>(COWContactLinking.NotificationProperties, (StorePropertyDefinition property) => item.PropertyBag.IsPropertyDirty(property)))
{
COWContactLinking.Tracer.TraceDebug((long)this.GetHashCode(), "COWContactLinking.InspectNotification: no relevant properties changed");
return(ContactLinkingProcessingState.Unknown);
}
if (ClientInfo.MOMT.IsMatch(session.ClientInfoString))
{
return(ContactLinkingProcessingState.ProcessAfterSave);
}
return(ContactLinkingProcessingState.ProcessBeforeSave);
}
private static MapiModifyTable GetMapiModifyTable(CoreFolder coreFolder, NativeStorePropertyDefinition property)
{
PersistablePropertyBag persistablePropertyBag = CoreObject.GetPersistablePropertyBag(coreFolder);
PropTag propTag = PropertyTagCache.Cache.PropTagFromPropertyDefinition(persistablePropertyBag.MapiProp, coreFolder.Session, property);
StoreSession storeSession = coreFolder.Session;
object thisObject = null;
bool flag = false;
MapiModifyTable result;
try
{
if (storeSession != null)
{
storeSession.BeginMapiCall();
storeSession.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
result = (MapiModifyTable)persistablePropertyBag.MapiProp.OpenProperty(propTag, PropertyTable.IExchangeModifyTableInterfaceId, 0, OpenPropertyFlags.DeferredErrors);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotGetMapiTable, ex, storeSession, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("PropertyTable.GetMapiModifyTable. Unable to get MapiModifyTable.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotGetMapiTable, ex2, storeSession, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("PropertyTable.GetMapiModifyTable. Unable to get MapiModifyTable.", new object[0]),
ex2
});
}
finally
{
try
{
if (storeSession != null)
{
storeSession.EndMapiCall();
if (flag)
{
storeSession.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
return(result);
}
internal void SetSubjectProperty(NativeStorePropertyDefinition property, string value)
{
this.CheckDisposed("SetSubjectProperty");
SubjectProperty.ModifySubjectProperty(CoreObject.GetPersistablePropertyBag(this.coreItem), property, value);
}
protected ManifestProviderBase(CoreFolder folder, ManifestConfigFlags flags, QueryFilter filter, StorageIcsState initialState, PropertyDefinition[] includeProperties, PropertyDefinition[] excludeProperties)
{
this.folder = folder;
this.disposeTracker = this.GetDisposeTracker();
bool flag = false;
try
{
PersistablePropertyBag persistablePropertyBag = CoreObject.GetPersistablePropertyBag(this.folder);
Restriction restriction = null;
if (filter != null)
{
restriction = FilterRestrictionConverter.CreateRestriction(folder.Session, persistablePropertyBag.ExTimeZone, persistablePropertyBag.MapiProp, filter);
}
ICollection <PropTag> includePropertyTags = PropertyTagCache.Cache.PropTagsFromPropertyDefinitions <PropertyDefinition>(this.MapiFolder, this.Session, true, includeProperties);
ICollection <PropTag> excludePropertyTags = PropertyTagCache.Cache.PropTagsFromPropertyDefinitions <PropertyDefinition>(this.MapiFolder, this.Session, true, excludeProperties);
StoreSession session = this.Session;
object thisObject = this.folder;
bool flag2 = false;
try
{
if (session != null)
{
session.BeginMapiCall();
session.BeginServerHealthCall();
flag2 = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
this.mapiManifest = this.MapiCreateManifest(flags, restriction, initialState, includePropertyTags, excludePropertyTags);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.CannotCreateManifestEx(base.GetType()), ex, session, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("ManifestProviderBase..ctor. Failed to create/configure HierarchyManifestEx.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.CannotCreateManifestEx(base.GetType()), ex2, session, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("ManifestProviderBase..ctor. Failed to create/configure HierarchyManifestEx.", new object[0]),
ex2
});
}
finally
{
try
{
if (session != null)
{
session.EndMapiCall();
if (flag2)
{
session.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
flag = true;
}
finally
{
if (!flag)
{
base.Dispose();
}
}
}
internal static PropertyError[] MapiCopyProps(MapiProp source, MapiProp destination, StoreSession sourceSession, StoreSession destSession, CopyPropertiesFlags copyPropertiesFlags, params NativeStorePropertyDefinition[] includedProperties)
{
Util.ThrowOnNullArgument(source, "sources");
Util.ThrowOnNullArgument(destination, "destination");
ICollection <PropTag> collection = PropertyTagCache.Cache.PropTagsFromPropertyDefinitions(source, sourceSession, true, includedProperties);
PropProblem[] problems = null;
bool flag = false;
try
{
if (sourceSession != null)
{
sourceSession.BeginMapiCall();
sourceSession.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
CopyPropertiesFlags copyPropertiesFlags2 = CoreObject.ToCopyPropertiesFlags(copyPropertiesFlags);
try
{
problems = source.CopyProps(destination, copyPropertiesFlags2, collection);
}
catch (MapiExceptionNamedPropsQuotaExceeded)
{
List <PropTag> list = new List <PropTag>(collection.Count);
foreach (PropTag propTag in collection)
{
if (propTag != PropTag.Unresolved)
{
list.Add(propTag);
}
}
problems = source.CopyProps(destination, copyPropertiesFlags2, list);
}
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotCopyMapiProps, ex, sourceSession, source, "{0}. MapiException = {1}.", new object[]
{
string.Format("CoreItem::MapiCopyProperties.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotCopyMapiProps, ex2, sourceSession, source, "{0}. MapiException = {1}.", new object[]
{
string.Format("CoreItem::MapiCopyProperties.", new object[0]),
ex2
});
}
finally
{
try
{
if (sourceSession != null)
{
sourceSession.EndMapiCall();
if (flag)
{
sourceSession.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
CoreObject.ProcessCopyPropertyProblems(problems, sourceSession, source);
return(CoreObject.ToXsoPropertyErrors(destSession, destination, problems));
}
void IValidatable.Validate(ValidationContext context, IList <StoreObjectValidationError> validationErrors)
{
this.CheckDisposed(null);
Validation.ValidateProperties(context, this, CoreObject.GetPersistablePropertyBag(this), validationErrors);
this.ValidateContainedObjects(validationErrors);
}
