public StoreObjectId ResolveStoreObjectIdFromFolderPath(MapiFolderPath folderPath)
{
Util.ThrowOnNullArgument(folderPath, "folderPath");
StoreObjectId storeObjectId;
if (folderPath.IsNonIpmPath)
{
storeObjectId = this.PublicFolderSession.GetNonIpmSubtreeFolderId();
}
else
{
storeObjectId = this.PublicFolderSession.GetIpmSubtreeFolderId();
}
if (folderPath.Depth <= 0)
{
return(storeObjectId);
}
foreach (string text in folderPath)
{
QueryFilter seekFilter = new TextFilter(FolderSchema.DisplayName, text, MatchOptions.FullString, MatchFlags.IgnoreCase);
using (Folder folder = Folder.Bind(this.PublicFolderSession, storeObjectId, PublicFolderDataProvider.FolderQueryReturnColumns))
{
using (QueryResult queryResult = folder.FolderQuery(FolderQueryFlags.None, null, PublicFolderDataProvider.FolderQuerySorts, PublicFolderDataProvider.FolderQueryReturnColumns))
{
if (!queryResult.SeekToCondition(SeekReference.OriginBeginning, seekFilter, SeekToConditionFlags.AllowExtendedFilters))
{
return(null);
}
object[][] rows = queryResult.GetRows(1);
storeObjectId = ((VersionedId)rows[0][0]).ObjectId;
}
}
}
return(storeObjectId);
}
public StoreObjectId ResolveStoreObjectIdFromFolderPath(MapiFolderPath folderPath)
{
Util.ThrowOnNullArgument(folderPath, "folderPath");
StoreObjectId storeObjectId;
if (folderPath.IsNonIpmPath)
{
storeObjectId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Configuration);
}
else
{
storeObjectId = base.MailboxSession.GetDefaultFolderId(DefaultFolderType.Root);
}
if (folderPath.Depth <= 0)
{
return(storeObjectId);
}
foreach (string propertyValue in folderPath)
{
QueryFilter seekFilter = new ComparisonFilter(ComparisonOperator.Equal, FolderSchema.DisplayName, propertyValue);
using (Folder folder = Folder.Bind(base.MailboxSession, storeObjectId, MailboxFolderDataProviderBase.FolderQueryReturnColumns))
{
using (QueryResult queryResult = folder.FolderQuery(FolderQueryFlags.None, null, MailboxFolderDataProviderBase.FolderQuerySorts, MailboxFolderDataProviderBase.FolderQueryReturnColumns))
{
if (!queryResult.SeekToCondition(SeekReference.OriginBeginning, seekFilter))
{
return(null);
}
object[][] rows = queryResult.GetRows(1);
storeObjectId = ((VersionedId)rows[0][0]).ObjectId;
}
}
}
return(storeObjectId);
}
protected override IConfigurable PrepareDataObject()
{
MailboxFolder mailboxFolder = (MailboxFolder)base.PrepareDataObject();
MailboxFolder mailboxFolder2 = (MailboxFolder)base.GetDataObject <MailboxFolder>(this.Parent, base.DataSession, null, new LocalizedString?(Strings.ErrorMailboxFolderNotFound(this.Parent.ToString())), new LocalizedString?(Strings.ErrorMailboxFolderNotUnique(this.Parent.ToString())));
if (mailboxFolder2.FolderPath.IsNonIpmPath)
{
base.WriteError(new InvalidOperationException(Strings.ErrorCannotCreateFolderUnderNonIpmSubtree(this.Name, this.Parent.ToString())), ErrorCategory.InvalidOperation, this.Name);
}
if (mailboxFolder2.ExtendedFolderFlags != null && ((mailboxFolder2.ExtendedFolderFlags.Value & ExtendedFolderFlags.ExclusivelyBound) != (ExtendedFolderFlags)0 || (mailboxFolder2.ExtendedFolderFlags.Value & ExtendedFolderFlags.RemoteHierarchy) != (ExtendedFolderFlags)0))
{
base.WriteError(new InvalidOperationException(Strings.ErrorInvalidParentExtendedFolderFlags(this.Name, this.Parent.ToString(), string.Join(",", new string[]
{
ExtendedFolderFlags.ExclusivelyBound.ToString(),
ExtendedFolderFlags.RemoteHierarchy.ToString()
}))), ErrorCategory.InvalidOperation, this.Name);
}
mailboxFolder[MailboxFolderSchema.InternalParentFolderIdentity] = mailboxFolder2.InternalFolderIdentity.ObjectId;
mailboxFolder.FolderPath = MapiFolderPath.GenerateFolderPath(mailboxFolder2.FolderPath, mailboxFolder.Name);
mailboxFolder.MailboxOwnerId = mailboxFolder2.MailboxOwnerId;
mailboxFolder.SetDefaultFolderType(DefaultFolderType.None);
if (string.IsNullOrEmpty(mailboxFolder.FolderClass))
{
if (DefaultFolderType.Root == mailboxFolder2.DefaultFolderType || string.IsNullOrEmpty(mailboxFolder2.FolderClass))
{
mailboxFolder.FolderClass = "IPF.Note";
}
else
{
mailboxFolder.FolderClass = mailboxFolder2.FolderClass;
}
}
return(mailboxFolder);
}
internal static MapiFolderPath CalculateMailboxFolderPath(StoreSession session, StoreObjectId storeFolderId, StoreObjectId parentStoreFolderId, string displayName, Dictionary <StoreObjectId, MapiFolderPath> knownFolderPathsCache)
{
if (storeFolderId == null)
{
throw new ArgumentNullException("storeFolderId");
}
if (parentStoreFolderId == null)
{
throw new ArgumentNullException("parentStoreFolderId");
}
if (knownFolderPathsCache == null)
{
throw new ArgumentNullException("knownFolderPathsCache");
}
Stack <string> stack = new Stack <string>();
Stack <StoreObjectId> stack2 = new Stack <StoreObjectId>();
MapiFolderPath mapiFolderPath = null;
while (null == mapiFolderPath)
{
if (knownFolderPathsCache.ContainsKey(storeFolderId))
{
mapiFolderPath = knownFolderPathsCache[storeFolderId];
}
else if (knownFolderPathsCache.ContainsKey(parentStoreFolderId))
{
mapiFolderPath = knownFolderPathsCache[parentStoreFolderId];
stack.Push(displayName);
stack2.Push(storeFolderId);
}
else
{
using (Folder folder = Folder.Bind(session, parentStoreFolderId, new PropertyDefinition[]
{
FolderSchema.DisplayName,
StoreObjectSchema.ParentItemId
}))
{
stack.Push(displayName);
stack2.Push(storeFolderId);
storeFolderId = parentStoreFolderId;
parentStoreFolderId = (StoreObjectId)folder[StoreObjectSchema.ParentItemId];
displayName = (string)folder[FolderSchema.DisplayName];
}
}
}
MapiFolderPath mapiFolderPath2 = mapiFolderPath;
while (0 < stack.Count)
{
mapiFolderPath2 = MapiFolderPath.GenerateFolderPath(mapiFolderPath2, stack.Pop());
StoreObjectId key = stack2.Pop();
if (!knownFolderPathsCache.ContainsKey(key))
{
knownFolderPathsCache.Add(key, mapiFolderPath2);
}
}
return(mapiFolderPath2);
}
protected override IConfigurable PrepareDataObject()
{
if (this.Path == null)
{
this.Path = new PublicFolderIdParameter(new PublicFolderId(MapiFolderPath.IpmSubtreeRoot));
}
PublicFolder publicFolder = null;
try
{
publicFolder = (PublicFolder)base.GetDataObject <PublicFolder>(this.Path, base.DataSession, null, new LocalizedString?(Strings.ErrorPublicFolderNotFound(this.Path.ToString())), new LocalizedString?(Strings.ErrorPublicFolderNotUnique(this.Path.ToString())));
}
catch (NotSupportedException exception)
{
base.WriteError(exception, ErrorCategory.InvalidType, this.Name);
}
if (publicFolder.ExtendedFolderFlags != null && ((publicFolder.ExtendedFolderFlags.Value & ExtendedFolderFlags.ExclusivelyBound) != (ExtendedFolderFlags)0 || (publicFolder.ExtendedFolderFlags.Value & ExtendedFolderFlags.RemoteHierarchy) != (ExtendedFolderFlags)0))
{
base.WriteError(new InvalidOperationException(Strings.ErrorInvalidParentExtendedFolderFlags(this.Name, this.Path.ToString(), string.Join(",", new string[]
{
ExtendedFolderFlags.ExclusivelyBound.ToString(),
ExtendedFolderFlags.RemoteHierarchy.ToString()
}))), ErrorCategory.InvalidOperation, this.Name);
}
PublicFolder publicFolder2 = (PublicFolder)base.PrepareDataObject();
publicFolder2.MailboxOwnerId = this.publicFolderDataProvider.PublicFolderSession.MailboxPrincipal.ObjectId;
publicFolder2[MailboxFolderSchema.InternalParentFolderIdentity] = publicFolder.InternalFolderIdentity.ObjectId;
publicFolder2.FolderPath = MapiFolderPath.GenerateFolderPath(publicFolder.FolderPath, this.Name);
publicFolder2.Name = this.Name;
publicFolder2.PerUserReadStateEnabled = publicFolder.PerUserReadStateEnabled;
publicFolder2.EformsLocaleId = this.EformsLocaleId;
if (this.Mailbox != null)
{
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.FullyConsistent, base.SessionSettings, 237, "PrepareDataObject", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MapiTasks\\PublicFolder\\NewPublicFolder.cs");
ADUser aduser = (ADUser)base.GetDataObject <ADUser>(this.Mailbox, tenantOrRootOrgRecipientSession, null, new LocalizedString?(Strings.ErrorMailboxNotFound(this.Mailbox.ToString())), new LocalizedString?(Strings.ErrorMailboxNotUnique(this.Mailbox.ToString())));
if (aduser.RecipientTypeDetails != RecipientTypeDetails.PublicFolderMailbox)
{
base.WriteError(new ManagementObjectNotFoundException(Strings.ErrorMailboxNotFound(this.Mailbox.ToString())), ExchangeErrorCategory.Client, this.Mailbox);
}
publicFolder2.ContentMailboxGuid = aduser.ExchangeGuid;
}
publicFolder2.SetDefaultFolderType(DefaultFolderType.None);
if (string.IsNullOrEmpty(publicFolder2.FolderClass))
{
if (DefaultFolderType.Root == publicFolder.DefaultFolderType || string.IsNullOrEmpty(publicFolder.FolderClass))
{
publicFolder2.FolderClass = "IPF.Note";
}
else
{
publicFolder2.FolderClass = publicFolder.FolderClass;
}
}
return(publicFolder2);
}
internal new static object IdentityGetter(IPropertyBag propertyBag)
{
VersionedId versionedId = (VersionedId)propertyBag[MailboxFolderSchema.InternalFolderIdentity];
MapiFolderPath mapiFolderPath = (MapiFolderPath)propertyBag[MailboxFolderSchema.FolderPath];
if (null != mapiFolderPath || versionedId != null)
{
return(new PublicFolderId((versionedId == null) ? null : versionedId.ObjectId, mapiFolderPath));
}
return(null);
}
internal static object IdentityGetter(IPropertyBag propertyBag)
{
ADObjectId mailboxOwnerId = (ADObjectId)propertyBag[XsoMailboxConfigurationObjectSchema.MailboxOwnerId];
VersionedId versionedId = (VersionedId)propertyBag[MailboxFolderSchema.InternalFolderIdentity];
MapiFolderPath mapiFolderPath = (MapiFolderPath)propertyBag[MailboxFolderSchema.FolderPath];
if (null != mapiFolderPath || versionedId != null)
{
return(new MailboxFolderId(mailboxOwnerId, (versionedId == null) ? null : versionedId.ObjectId, mapiFolderPath));
}
return(null);
}
public static MapiFolderPath Redact(MapiFolderPath folderPath, out string raw, out string redacted)
{
raw = null;
redacted = null;
if (folderPath != null)
{
raw = folderPath.ToString();
redacted = SuppressingPiiData.Redact(raw);
folderPath = new MapiFolderPath('\\' + redacted);
}
return(folderPath);
}
internal new static object ParentFolderGetter(IPropertyBag propertyBag)
{
VersionedId versionedId = (VersionedId)propertyBag[MailboxFolderSchema.InternalFolderIdentity];
StoreObjectId storeObjectId = (StoreObjectId)propertyBag[MailboxFolderSchema.InternalParentFolderIdentity];
MapiFolderPath mapiFolderPath = (MapiFolderPath)propertyBag[MailboxFolderSchema.FolderPath];
if (versionedId != null && versionedId.ObjectId != null && object.Equals(versionedId.ObjectId, storeObjectId))
{
return(null);
}
if ((null != mapiFolderPath && null != mapiFolderPath.Parent) || storeObjectId != null)
{
return(new PublicFolderId(storeObjectId, (null == mapiFolderPath) ? null : mapiFolderPath.Parent));
}
return(null);
}
public MailboxFolderIdParameter(string mailboxFolderId)
{
if (string.IsNullOrEmpty(mailboxFolderId))
{
throw new ArgumentNullException("mailboxFolderId");
}
this.rawIdentity = mailboxFolderId;
int num = mailboxFolderId.IndexOf(':');
if (-1 == num)
{
this.RawOwner = new MailboxIdParameter(mailboxFolderId);
this.RawFolderPath = MapiFolderPath.IpmSubtreeRoot;
return;
}
string text = mailboxFolderId.Substring(0, num);
string text2 = mailboxFolderId.Substring(1 + num);
if (!string.IsNullOrEmpty(text))
{
this.RawOwner = new MailboxIdParameter(text);
}
if (string.IsNullOrEmpty(text2))
{
throw new FormatException(Strings.ErrorInvalidMailboxFolderIdentity(this.rawIdentity));
}
try
{
if (text2[0] == '\\' || text2[0] == '')
{
this.RawFolderPath = MapiFolderPath.Parse(text2);
}
else
{
this.RawFolderStoreId = StoreObjectId.Deserialize(text2);
}
}
catch (FormatException innerException)
{
throw new FormatException(Strings.ErrorInvalidMailboxFolderIdentity(this.rawIdentity), innerException);
}
catch (CorruptDataException innerException2)
{
throw new FormatException(Strings.ErrorInvalidMailboxFolderIdentity(this.rawIdentity), innerException2);
}
}
internal static object ParentFolderGetter(IPropertyBag propertyBag)
{
ADObjectId mailboxOwnerId = (ADObjectId)propertyBag[XsoMailboxConfigurationObjectSchema.MailboxOwnerId];
VersionedId versionedId = (VersionedId)propertyBag[MailboxFolderSchema.InternalFolderIdentity];
StoreObjectId storeObjectId = (StoreObjectId)propertyBag[MailboxFolderSchema.InternalParentFolderIdentity];
MapiFolderPath mapiFolderPath = (MapiFolderPath)propertyBag[MailboxFolderSchema.FolderPath];
if (versionedId != null && versionedId != null && object.Equals(versionedId.ObjectId, storeObjectId))
{
return(null);
}
if ((null != mapiFolderPath && null != mapiFolderPath.Parent) || storeObjectId != null)
{
return(new MailboxFolderId(mailboxOwnerId, storeObjectId, (null == mapiFolderPath) ? null : mapiFolderPath.Parent));
}
return(null);
}
internal static MapiFolder GetFolderByPath(MapiStore mapiStore, MapiFolderPath folderPath)
{
MapiFolder mapiFolder = null;
MapiFolder folderByPath;
try
{
folderByPath = Folder.GetFolderByPath(mapiStore, folderPath, out mapiFolder);
}
finally
{
if (mapiFolder != null)
{
mapiFolder.Dispose();
}
}
return(folderByPath);
}
public static PublicFolderId Parse(string input)
{
if (string.IsNullOrEmpty(input))
{
throw new FormatException(Strings.ExceptionFormatNotSupported);
}
try
{
return(new PublicFolderId(MapiFolderPath.Parse(input)));
}
catch (FormatException)
{
}
try
{
return(new PublicFolderId(MapiEntryId.Parse(input)));
}
catch (FormatException)
{
}
return(new PublicFolderId(input));
}
internal PublicFolderId(StoreObjectId storeObjectId, MapiFolderPath folderPath)
{
this.StoreObjectId = storeObjectId;
this.MapiFolderPath = folderPath;
}
internal static MapiFolder RetrieveMapiFolder(MapiStore store, FolderId identity, ref MapiFolder parent, Folder.IdentityConstructor idCtor, out FolderId realId)
{
realId = null;
if (store == null)
{
throw new ArgumentNullException("store");
}
Folder.CheckRequirementsOnIdentityToContinue(identity);
MapiFolder mapiFolder = null;
bool flag = false;
bool flag2 = false;
MapiFolder result;
try
{
byte[] array = null;
MapiEntryId entryId = null;
MapiFolderPath folderPath = null;
string legacyDn = null;
if (null == identity.MapiEntryId)
{
if (identity.LegacyDistinguishedName != null)
{
legacyDn = identity.LegacyDistinguishedName;
array = store.GetFolderEntryId(identity.LegacyDistinguishedName);
}
}
else
{
array = (byte[])identity.MapiEntryId;
}
if (array != null)
{
entryId = new MapiEntryId(array);
mapiFolder = (MapiFolder)store.OpenEntry(array);
if (parent == null)
{
parent = (MapiFolder)store.OpenEntry(mapiFolder.GetProp(PropTag.ParentEntryId).GetBytes());
flag = true;
}
}
else if (null != identity.MapiFolderPath)
{
folderPath = identity.MapiFolderPath;
if (parent == null)
{
mapiFolder = Folder.GetFolderByPath(store, identity.MapiFolderPath, out parent);
flag = true;
}
else
{
mapiFolder = Folder.GetFolderByPath(store, parent, identity.MapiFolderPath);
}
}
if (idCtor != null)
{
realId = idCtor(entryId, folderPath, legacyDn);
}
flag2 = true;
result = mapiFolder;
}
finally
{
if (!flag2)
{
if (mapiFolder != null)
{
mapiFolder.Dispose();
mapiFolder = null;
}
if (flag && parent != null)
{
parent.Dispose();
parent = null;
}
}
}
return(result);
}
private static MapiFolder RetrieveParentMapiFolder(MapiStore store, FolderId identity, ref MapiFolder folder)
{
if (store == null)
{
throw new ArgumentNullException("store");
}
Folder.CheckRequirementsOnIdentityToContinue(identity);
MapiFolder mapiFolder = null;
bool flag = false;
bool flag2 = false;
MapiFolder result;
try
{
byte[] array = null;
if (null == identity.MapiEntryId)
{
if (identity.LegacyDistinguishedName != null)
{
array = store.GetFolderEntryId(identity.LegacyDistinguishedName);
}
}
else
{
array = (byte[])identity.MapiEntryId;
}
if (array != null)
{
if (folder == null)
{
folder = (MapiFolder)store.OpenEntry(array);
flag = true;
}
mapiFolder = (MapiFolder)store.OpenEntry(folder.GetProp(PropTag.ParentEntryId).GetBytes());
}
else if (null != identity.MapiFolderPath)
{
MapiFolderPath parent = identity.MapiFolderPath.Parent;
if (null == parent)
{
mapiFolder = store.GetRootFolder();
}
else
{
mapiFolder = Folder.GetFolderByPath(store, parent);
}
}
flag2 = true;
result = mapiFolder;
}
finally
{
if (!flag2)
{
if (flag && folder != null)
{
folder.Dispose();
folder = null;
}
if (mapiFolder != null)
{
mapiFolder.Dispose();
mapiFolder = null;
}
}
}
return(result);
}
internal PublicFolderId(MapiEntryId entryId, MapiFolderPath folderPath, string legacyDn) : base(new PublicStoreId(), entryId, folderPath, legacyDn)
{
}
internal FolderId(MessageStoreId storeId, MapiEntryId entryId, MapiFolderPath folderPath, string legacyDn) : base(entryId)
{
this.messageStoreId = storeId;
this.mapiFolderPath = folderPath;
this.legacyDistinguishedName = legacyDn;
}
public PublicFolderId(MapiFolderPath folderPath) : base(new PublicStoreId(), folderPath)
{
}
private static MapiFolderPath GetFolderPath(MapiEntryId folderEntryId, MapiFolder mapiFolder, MapiStore mapiStore)
{
MapiFolderPath result;
try
{
if (null == folderEntryId)
{
if (mapiFolder == null)
{
throw new ArgumentNullException("mapiFolder");
}
PropValue prop = mapiFolder.GetProp(PropTag.EntryId);
if (PropType.Error == prop.PropType)
{
return(null);
}
folderEntryId = new MapiEntryId(prop.GetBytes());
}
if (mapiStore == null)
{
throw new ArgumentNullException("mapiStore");
}
MapiEntryId operand;
using (MapiFolder rootFolder = mapiStore.GetRootFolder())
{
operand = new MapiEntryId(rootFolder.GetProp(PropTag.EntryId).GetBytes());
}
MapiEntryId operand2 = new MapiEntryId(mapiStore.GetIpmSubtreeFolderEntryId());
MapiEntryId operand3 = new MapiEntryId(mapiStore.GetNonIpmSubtreeFolderEntryId());
MapiFolderPath mapiFolderPath = null;
MapiEntryId mapiEntryId = folderEntryId;
MapiEntryId mapiEntryId2 = null;
string parentFolderName = null;
while (!(operand2 == mapiEntryId))
{
if (operand3 == mapiEntryId || operand == mapiEntryId)
{
mapiFolderPath = MapiFolderPath.GenerateFolderPath("NON_IPM_SUBTREE", mapiFolderPath, true);
}
else
{
using (MapiFolder mapiFolder2 = (MapiFolder)mapiStore.OpenEntry((byte[])mapiEntryId))
{
PropValue[] props = mapiFolder2.GetProps(new PropTag[]
{
PropTag.ParentEntryId,
PropTag.DisplayName
});
if (PropType.Error == props[0].PropType || PropType.Error == props[1].PropType)
{
return(null);
}
mapiEntryId2 = new MapiEntryId(props[0].GetBytes());
parentFolderName = props[1].GetString();
}
if (!(mapiEntryId2 == mapiEntryId))
{
mapiFolderPath = MapiFolderPath.GenerateFolderPath(parentFolderName, mapiFolderPath, false);
mapiEntryId = mapiEntryId2;
continue;
}
}
IL_19C:
return(mapiFolderPath);
}
mapiFolderPath = MapiFolderPath.GenerateFolderPath("IPM_SUBTREE", mapiFolderPath, true);
goto IL_19C;
}
catch (MapiPermanentException)
{
result = null;
}
catch (MapiRetryableException)
{
result = null;
}
return(result);
}
public FolderId(MessageStoreId storeId, MapiFolderPath folderPath)
{
this.messageStoreId = storeId;
this.mapiFolderPath = folderPath;
}
internal MailboxFolderId(ADObjectId mailboxOwnerId, StoreObjectId storeObjectId, MapiFolderPath folderPath) : base(mailboxOwnerId)
{
if (null == folderPath && storeObjectId == null)
{
throw new ArgumentException(ServerStrings.ErrorNoStoreObjectIdAndFolderPath);
}
this.StoreObjectIdValue = storeObjectId;
this.MailboxFolderPath = folderPath;
}
internal override void Save(bool keepUnmanagedResources)
{
if (ObjectState.Unchanged == base.ObjectState)
{
return;
}
if (ObjectState.Deleted == base.ObjectState)
{
throw new MapiInvalidOperationException(Strings.ExceptionObjectStateInvalid(base.ObjectState.ToString()));
}
base.EnableDisposeTracking();
using (MapiStore messageStore = this.GetMessageStore())
{
MapiFolder mapiFolder = null;
MapiFolder parentFolder = null;
bool isFolderRetrieved = false;
try
{
MapiSession mapiSession = base.MapiSession;
Folder.CheckRequirementsOnSessionToContinue(base.MapiSession);
bool creating = false;
if (base.ObjectState == ObjectState.New)
{
creating = true;
string text = null;
if (this.newFolderIdentity == null)
{
if (null == this.Identity)
{
throw new MapiInvalidOperationException(Strings.ExceptionIdentityNull);
}
if (null == this.Identity.MapiFolderPath)
{
throw new MapiInvalidOperationException(Strings.ExceptionIdentityInvalid);
}
MapiFolder mapiFolder2 = null;
try
{
parentFolder = Folder.RetrieveParentMapiFolder(messageStore, this.Identity, ref mapiFolder2);
}
finally
{
if (mapiFolder2 != null)
{
mapiFolder2.Dispose();
}
}
if (parentFolder != null && !parentFolder.AllowWarnings)
{
parentFolder.AllowWarnings = true;
}
text = this.Identity.MapiFolderPath.Name;
}
else
{
this.Identity = this.ConstructIdentity(null, MapiFolderPath.GenerateFolderPath(this.newFolderIdentity.ParentIdentity.MapiFolderPath, this.newFolderIdentity.FolderName, false), null);
parentFolder = Folder.RetrieveMapiFolder(messageStore, this.newFolderIdentity.ParentIdentity);
if (parentFolder != null && !parentFolder.AllowWarnings)
{
parentFolder.AllowWarnings = true;
}
text = this.newFolderIdentity.FolderName;
}
ExTraceGlobals.FolderTracer.TraceDebug <FolderId, string>((long)this.GetHashCode(), "To Create Folder '{0}' on server '{1}'.", this.Identity, base.MapiSession.ServerName);
try
{
mapiFolder = parentFolder.CreateFolder(text, string.Empty, false);
if (mapiFolder != null && !mapiFolder.AllowWarnings)
{
mapiFolder.AllowWarnings = true;
}
isFolderRetrieved = true;
}
catch (MapiExceptionCollision innerException)
{
this.DetectFolderExistence(messageStore, parentFolder, text, innerException);
throw;
}
this.UpdateIdentity(this.UpdateIdentityFlagsForCreating);
}
if (creating || ObjectState.Changed == base.ObjectState)
{
Folder.CheckRequirementsOnIdentityToContinue(this.Identity);
this.DetectDisallowedModification(messageStore);
if (ObjectState.Changed == base.ObjectState && base.IsChanged(MapiPropertyDefinitions.Name))
{
string name = (string)this[MapiPropertyDefinitions.Name];
if (parentFolder == null)
{
MapiFolder mapiFolder3 = null;
try
{
parentFolder = Folder.RetrieveParentMapiFolder(messageStore, this.Identity, ref mapiFolder3);
}
finally
{
if (mapiFolder3 != null)
{
mapiFolder3.Dispose();
}
}
}
this.DetectFolderExistence(messageStore, parentFolder, name, null);
}
PropProblem[] array = null;
PropProblem[] array2 = null;
FolderId folderId = null;
if (mapiFolder != null)
{
mapiFolder.Dispose();
mapiFolder = null;
}
mapiFolder = Folder.RetrieveMapiFolder(messageStore, this.Identity, ref parentFolder, new Folder.IdentityConstructor(this.ConstructIdentity), out folderId);
ParameterlessReturnlessDelegate parameterlessReturnlessDelegate = delegate()
{
if (creating && isFolderRetrieved)
{
ExTraceGlobals.FolderTracer.TraceDebug <FolderId, string>((long)this.GetHashCode(), "To Remove Folder '{0}' for rolling back creating on server '{1}'.", this.Identity, this.MapiSession.ServerName);
try
{
parentFolder.DeleteFolder((byte[])this.Identity.MapiEntryId);
}
catch (MapiRetryableException ex)
{
ExTraceGlobals.FolderTracer.TraceError <FolderId, string, string>((long)this.GetHashCode(), "Removing Folder '{0}' for rolling back caughting an exception on server '{1}': {2}", this.Identity, this.MapiSession.ServerName, ex.Message);
}
catch (MapiPermanentException ex2)
{
ExTraceGlobals.FolderTracer.TraceError <FolderId, string, string>((long)this.GetHashCode(), "Removing Folder '{0}' for rolling back caughting an exception on server '{1}': {2}", this.Identity, this.MapiSession.ServerName, ex2.Message);
}
}
};
try
{
PropValue[] propertyValuesToUpdate = base.GetPropertyValuesToUpdate();
if (0 < propertyValuesToUpdate.Length)
{
ExTraceGlobals.FolderTracer.TraceDebug <FolderId, string>((long)this.GetHashCode(), "To Set PropValues against Folder '{0}' on server '{1}'.", this.Identity, base.MapiSession.ServerName);
array = mapiFolder.SetProps(propertyValuesToUpdate);
}
PropTag[] propertyTagsToDelete = base.GetPropertyTagsToDelete();
if (0 < propertyTagsToDelete.Length)
{
ExTraceGlobals.FolderTracer.TraceDebug <FolderId, string>((long)this.GetHashCode(), "To Delete PropTags against Folder '{0}' on server '{1}'.", this.Identity, base.MapiSession.ServerName);
array2 = mapiFolder.DeleteProps(propertyTagsToDelete);
}
}
catch (DataValidationException)
{
parameterlessReturnlessDelegate();
throw;
}
catch (MapiRetryableException)
{
parameterlessReturnlessDelegate();
throw;
}
catch (MapiPermanentException)
{
parameterlessReturnlessDelegate();
throw;
}
base.ResetChangeTrackingAndObjectState();
StringBuilder stringBuilder = new StringBuilder();
if (array != null && 0 < array.Length)
{
stringBuilder.AppendLine(Strings.ErrorSetPropsProblem(this.Identity.ToString(), array.Length.ToString()));
foreach (PropProblem propProblem in array)
{
stringBuilder.Append('\t');
stringBuilder.AppendLine(Strings.ErrorPropProblem(propProblem.PropTag.ToString(), propProblem.PropType.ToString(), propProblem.Scode.ToString()));
}
stringBuilder.AppendLine();
}
if (array2 != null && 0 < array2.Length)
{
stringBuilder.AppendLine(Strings.ErrorDeletePropsProblem(this.Identity.ToString(), array2.Length.ToString()));
foreach (PropProblem propProblem2 in array2)
{
stringBuilder.Append('\t');
stringBuilder.Append(Strings.ErrorPropProblem(propProblem2.PropTag.ToString(), propProblem2.PropType.ToString(), propProblem2.Scode.ToString()));
stringBuilder.AppendLine();
}
stringBuilder.AppendLine();
}
if (0 < stringBuilder.Length)
{
string text2 = stringBuilder.ToString();
ExTraceGlobals.FolderTracer.TraceDebug <FolderId, string, string>((long)this.GetHashCode(), "Setting Folder '{0}' on server '{1}' returns error '{2}'.", this.Identity, base.MapiSession.ServerName, text2);
parameterlessReturnlessDelegate();
throw new MapiInvalidOperationException(new LocalizedString(text2));
}
}
}
finally
{
if (mapiFolder != null)
{
mapiFolder.Dispose();
}
if (parentFolder != null)
{
parentFolder.Dispose();
}
base.Dispose();
}
}
}
internal static MapiFolder GetFolderByPath(MapiStore mapiStore, MapiFolderPath folderPath, out MapiFolder parent)
{
if (mapiStore == null)
{
throw new ArgumentNullException("mapiStore");
}
if (null == folderPath)
{
throw new ArgumentNullException("folderPath");
}
parent = null;
MapiFolder mapiFolder = null;
bool flag = false;
MapiFolder result;
try
{
mapiFolder = (folderPath.IsIpmPath ? mapiStore.GetIpmSubtreeFolder() : mapiStore.GetNonIpmSubtreeFolder());
int num = 0;
while (folderPath.Depth - 1 > num)
{
MapiFolder mapiFolder2;
parent = (mapiFolder2 = mapiFolder);
using (mapiFolder2)
{
mapiFolder = parent.OpenSubFolderByName(folderPath[num]);
}
num++;
}
if (folderPath.Depth - 1 == num)
{
if (parent != null)
{
parent.Dispose();
parent = null;
}
parent = mapiFolder;
mapiFolder = parent.OpenSubFolderByName(folderPath[num]);
}
if (parent == null)
{
parent = mapiStore.GetRootFolder();
}
flag = true;
result = mapiFolder;
}
finally
{
if (!flag)
{
if (mapiFolder != null)
{
mapiFolder.Dispose();
mapiFolder = null;
}
if (parent != null)
{
parent.Dispose();
parent = null;
}
}
}
return(result);
}
// Token: 0x06000B23 RID: 2851 RVA: 0x00023C30 File Offset: 0x00021E30
internal PublicFolderIdParameter(string publicFolderIdString, bool isEntryId)
{
if (string.IsNullOrEmpty(publicFolderIdString))
{
throw new ArgumentNullException("publicFolderIdString");
}
this.rawIdentity = publicFolderIdString;
PublicFolderId publicFolderId = null;
try
{
int num = publicFolderIdString.IndexOf('\\');
if (num < 0)
{
if (isEntryId)
{
publicFolderId = new PublicFolderId(StoreObjectId.FromHexEntryId(publicFolderIdString));
}
}
else if (num == 0)
{
if (publicFolderIdString.Length > 1 && publicFolderIdString[num + 1] == '\\')
{
throw new FormatException(Strings.ErrorIncompletePublicFolderIdParameter(publicFolderIdString));
}
publicFolderId = new PublicFolderId(MapiFolderPath.Parse(publicFolderIdString));
}
else
{
if (!MapiTaskHelper.IsDatacenter)
{
throw new FormatException(Strings.ErrorIncompletePublicFolderIdParameter(publicFolderIdString));
}
if (num == publicFolderIdString.Length - 1)
{
throw new FormatException(Strings.ErrorIncompleteDCPublicFolderIdParameter(publicFolderIdString));
}
this.Organization = new OrganizationIdParameter(publicFolderIdString.Substring(0, num));
if (publicFolderIdString[num + 1] == '\\')
{
publicFolderId = new PublicFolderId(MapiFolderPath.Parse(publicFolderIdString.Substring(num + 1)));
}
else if (isEntryId)
{
publicFolderId = new PublicFolderId(StoreObjectId.FromHexEntryId(publicFolderIdString.Substring(num + 1)));
}
}
}
catch (FormatException innerException)
{
throw new FormatException(MapiTaskHelper.IsDatacenter ? Strings.ErrorIncompleteDCPublicFolderIdParameter(this.rawIdentity) : Strings.ErrorIncompletePublicFolderIdParameter(this.rawIdentity), innerException);
}
catch (CorruptDataException innerException2)
{
throw new FormatException(MapiTaskHelper.IsDatacenter ? Strings.ErrorIncompleteDCPublicFolderIdParameter(this.rawIdentity) : Strings.ErrorIncompletePublicFolderIdParameter(this.rawIdentity), innerException2);
}
if (publicFolderId != null)
{
((IIdentityParameter)this).Initialize(publicFolderId);
}
}
internal static MapiFolder GetFolderByPath(MapiStore mapiStore, MapiFolder parentFolder, MapiFolderPath folderPath)
{
if (null == folderPath)
{
throw new ArgumentNullException("folderPath");
}
if (folderPath.IsSubtreeRoot)
{
if (mapiStore == null)
{
throw new ArgumentNullException("mapiStore");
}
if (!folderPath.IsIpmPath)
{
return(mapiStore.GetNonIpmSubtreeFolder());
}
return(mapiStore.GetIpmSubtreeFolder());
}
else
{
if (parentFolder == null)
{
throw new ArgumentNullException("parentFolder");
}
return(parentFolder.OpenSubFolderByName(folderPath[folderPath.Depth - 1]));
}
}
internal PublicFolderId(OrganizationId organizationId, StoreObjectId storeObjectId, MapiFolderPath folderPath) : this(storeObjectId, folderPath)
{
this.OrganizationId = organizationId;
}
internal PublicFolderId(MapiFolderPath folderPath)
{
this.MapiFolderPath = folderPath;
}
