private static UserConfiguration BuildConfigurationFromQueryItem(Folder folder, IStorePropertyBag row, bool hasLoadedUserConfigurationData) { if (PropertyError.IsPropertyError(row.TryGetProperty(InternalSchema.ItemClass))) { ExTraceGlobals.StorageTracer.TraceError(0L, "The configuration data's field has been corrupted. Field = ItemClass."); throw new CorruptDataException(ServerStrings.ExConfigDataCorrupted("ItemClass")); } if (PropertyError.IsPropertyError(row.TryGetProperty(InternalSchema.ItemId))) { ExTraceGlobals.StorageTracer.TraceError(0L, "The configuration data's field has been corrupted. Field = Id."); throw new CorruptDataException(ServerStrings.ExConfigDataCorrupted("Id")); } if (PropertyError.IsPropertyError(row.TryGetProperty(InternalSchema.UserConfigurationType))) { ExTraceGlobals.StorageTracer.TraceError(0L, "The configuration data's field has been corrupted. Field = UserConfigurationType."); throw new CorruptDataException(ServerStrings.ExConfigDataCorrupted("UserConfigurationType")); } string name = (string)row[InternalSchema.ItemClass]; if (!UserConfigurationName.IsValidName(name, ConfigurationNameKind.ItemClass)) { return(null); } UserConfigurationName configurationName = new UserConfigurationName(name, ConfigurationNameKind.ItemClass); if (hasLoadedUserConfigurationData) { object dictionaryObject = UserConfiguration.CheckDictionaryData(row.TryGetProperty(InternalSchema.UserConfigurationDictionary)); return(new UserConfiguration(configurationName, folder.Session, folder.Id.ObjectId, (VersionedId)row[InternalSchema.ItemId], dictionaryObject, UserConfiguration.CheckUserConfigurationType((int)row[InternalSchema.UserConfigurationType]), row)); } return(new UserConfiguration(configurationName, folder.Session, folder.Id.ObjectId, (VersionedId)row[InternalSchema.ItemId], null, UserConfiguration.CheckUserConfigurationType((int)row[InternalSchema.UserConfigurationType]), row)); }
private static IList <IStorePropertyBag> QueryConfigurations(Folder folder, SortBy[] sorts, UserConfigurationName configurationName, UserConfigurationSearchFlags searchFlags, int maxRow, params PropertyDefinition[] columns) { List <IStorePropertyBag> list = new List <IStorePropertyBag>(); columns = UserConfiguration.BuildPrefetchProperties(columns); IList <IStorePropertyBag> list2 = UserConfiguration.FetchAllConfigurations(folder, sorts, 10000, columns); IComparer customComparer = UserConfigurationName.GetCustomComparer(searchFlags); foreach (IStorePropertyBag storePropertyBag in list2) { string x = storePropertyBag.TryGetProperty(InternalSchema.ItemClass) as string; if (customComparer.Compare(x, configurationName) == 0) { list.Add(storePropertyBag); } } if (folder.Session is MailboxSession) { if (folder.Session.LogonType == LogonType.Owner) { UserConfiguration.AddToConfigurationCache(folder, list); } else { UserConfiguration.AddToConfigurationCache(folder, list2); } } return(list); }
private UserConfiguration(UserConfigurationName configurationName, UserConfigurationTypes type, IStorePropertyBag queryPropertyBag) { EnumValidator.AssertValid <UserConfigurationTypes>(type); this.queryPropertyBag = queryPropertyBag; StorageGlobals.TraceConstructIDisposable(this); this.disposeTracker = this.GetDisposeTracker(); }
private UserConfiguration GetMessageConfiguration(UserConfigurationName configurationName, UserConfigurationTypes freefetchDataTypes, StoreObjectId messageId) { UserConfiguration result = null; ConfigurationItem configurationItem = null; EnumValidator.ThrowIfInvalid <UserConfigurationTypes>(freefetchDataTypes, "freefetchDataTypes"); try { configurationItem = ConfigurationItem.Bind(this.mailboxSession, messageId); result = new UserConfiguration(configurationItem, (StoreObjectId)configurationItem.TryGetProperty(StoreObjectSchema.ParentItemId), configurationName, freefetchDataTypes, true); } catch (ObjectNotFoundException arg) { result = null; if (configurationItem != null) { configurationItem.Dispose(); } ExTraceGlobals.StorageTracer.TraceError <ObjectNotFoundException>(0L, "UserConfigurationManager::GetMessageConfiguration. Message object not found. Exception = {0}.", arg); } catch (Exception arg2) { result = null; if (configurationItem != null) { configurationItem.Dispose(); } ExTraceGlobals.StorageTracer.TraceError <Exception>(0L, "UserConfigurationManager::GetMessageConfiguration. Unable to create user configuration. Exception = {0}.", arg2); } return(result); }
internal UserConfiguration Get(UserConfigurationName configName, StoreObjectId folderId) { bool flag = false; UserConfigurationCacheEntry userConfigurationCacheEntry; if (!this.SharedCacheEntryManager.TryGetUserConfigurationCachedEntry(configName, folderId, out userConfigurationCacheEntry)) { ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName, StoreObjectId>((long)this.GetHashCode(), "UserConfigurationCache::Get. Miss the cache. ConfigName = {0}, folderId = {1}.", configName, folderId); return(null); } StoreObjectId itemId = userConfigurationCacheEntry.ItemId; ConfigurationItem configurationItem = null; bool flag2 = false; UserConfiguration result; try { configurationItem = ConfigurationItem.Bind(this.mailboxSession, itemId); ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName>((long)this.GetHashCode(), "UserConfigurationCache::Get. Hit the item in the cache. ConfigName = {0}.", configName); object obj = configurationItem.TryGetProperty(InternalSchema.UserConfigurationType); if (!(obj is int)) { ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName, object>((long)this.GetHashCode(), "UserConfigurationCache::Get. The type has been corrupted. ConfigName = {0}. Actual = {1}.", configName, configurationItem.TryGetProperty(InternalSchema.UserConfigurationType)); ExTraceGlobals.UserConfigurationTracer.TraceError((long)this.GetHashCode(), "UserConfiguration::Get. The configuration type has been corrupted. PropValue = {0}.", new object[] { configurationItem.TryGetProperty(InternalSchema.UserConfigurationType) }); throw new CorruptDataException(ServerStrings.ExConfigDataCorrupted("ConfigurationType")); } UserConfigurationTypes type = UserConfiguration.CheckUserConfigurationType((int)obj); ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName>((long)this.GetHashCode(), "UserConfigurationCache::Get. Hit the cache. ConfigName = {0}.", configName); UserConfiguration userConfiguration = new UserConfiguration(configurationItem, folderId, configName, type, true); flag2 = true; result = userConfiguration; } catch (ObjectNotFoundException) { ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName>((long)this.GetHashCode(), "UserConfigurationCache::Get. Miss the cache. The object has been deleted. ConfigName = {0}.", configName); ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName>((long)this.GetHashCode(), "The user configuration object cannot be found though we hold its itemId in cache. ConfigName = {0}.", configName); this.Remove(configName, folderId); flag = true; result = null; } finally { if (!flag2) { if (configurationItem != null) { configurationItem.Dispose(); } if (flag && this.mailboxSession.LogonType == LogonType.Owner) { this.Save(); } } } return(result); }
public static bool IsValidName(string configurationName) { if (configurationName == null) { throw new ArgumentNullException("configurationName"); } return(UserConfigurationName.IsValidName(configurationName, ConfigurationNameKind.Name)); }
private static void AddToConfigurationCache(Folder folder, IList <IStorePropertyBag> items) { if (items == null || items.Count == 0) { return; } MailboxSession mailboxSession = folder.Session as MailboxSession; if (mailboxSession == null) { throw new NotSupportedException(); } UserConfigurationManager userConfigurationManager = mailboxSession.UserConfigurationManager; List <VersionedId> list = new List <VersionedId>(); new List <int>(); string a = null; for (int i = 0; i < items.Count; i++) { IStorePropertyBag storePropertyBag = items[i]; if (PropertyError.IsPropertyError(storePropertyBag.TryGetProperty(InternalSchema.ItemClass))) { ExTraceGlobals.StorageTracer.TraceError(0L, "The configuration data's field has been corrupted. Field = ItemClass."); throw new CorruptDataException(ServerStrings.ExConfigDataCorrupted("ItemClass")); } if (PropertyError.IsPropertyError(storePropertyBag.TryGetProperty(InternalSchema.ItemId))) { ExTraceGlobals.StorageTracer.TraceError(0L, "The configuration data's field has been corrupted. Field = Id."); throw new CorruptDataException(ServerStrings.ExConfigDataCorrupted("Id")); } string b = storePropertyBag.TryGetProperty(InternalSchema.ItemClass) as string; if (a == b) { list.Add((VersionedId)storePropertyBag[InternalSchema.ItemId]); items.RemoveAt(i); i--; } else { string name = (string)storePropertyBag[InternalSchema.ItemClass]; if (UserConfigurationName.IsValidName(name, ConfigurationNameKind.ItemClass)) { userConfigurationManager.UserConfigurationCache.Add(folder.Id.ObjectId, new UserConfigurationName(name, ConfigurationNameKind.ItemClass), ((VersionedId)storePropertyBag[InternalSchema.ItemId]).ObjectId); } } a = (storePropertyBag.TryGetProperty(InternalSchema.ItemClass) as string); } if (folder.Session.LogonType == LogonType.Owner) { userConfigurationManager.UserConfigurationCache.Save(); } AggregateOperationResult result = folder.Session.Delete(DeleteItemFlags.SoftDelete, list.ToArray()); UserConfiguration.CheckOperationResults(result, "DeleteDuplicates"); }
private UserConfiguration InternalGetUserConfiguration(StoreId folderId, UserConfigurationName configurationName, UserConfigurationTypes freefetchDataType, StoreObjectId messageId) { if (this.aggregators.Count > 0) { lock (this.aggregators) { foreach (UserConfigurationManager.AggregationContext aggregationContext in this.aggregators) { ExTraceGlobals.StorageTracer.TraceWarning <UserConfigurationName>((long)this.GetHashCode(), "UserConfigurationManager::InternalGetUserConfiguration cache miss = {0}.", configurationName); aggregationContext.FaiCacheMiss(); } } } if (folderId == null) { throw new ArgumentNullException("folderId"); } UserConfiguration userConfiguration = null; bool flag2 = false; UserConfiguration result; try { userConfiguration = this.userConfigurationCache.Get(configurationName, StoreId.GetStoreObjectId(folderId)); if (userConfiguration == null) { if (messageId != null) { userConfiguration = this.GetMessageConfiguration(configurationName, freefetchDataType, messageId); } if (userConfiguration == null) { ExTraceGlobals.UserConfigurationTracer.TraceDebug <string>((long)this.GetHashCode(), "UserConfigurationManager::InternalBindAndGetUserConfiguration. Miss the cache. ConfigName = {0}.", configurationName.Name); userConfiguration = this.InternalBindAndGetUserConfiguration(folderId, configurationName, freefetchDataType); } } if ((userConfiguration.DataTypes & freefetchDataType) == (UserConfigurationTypes)0) { ExTraceGlobals.StorageTracer.TraceError(0L, "The configuration data's field has been corrupted. Field = UserConfigurationType."); throw new CorruptDataException(ServerStrings.ExConfigDataCorrupted("UserConfigurationType")); } flag2 = true; result = userConfiguration; } finally { if (!flag2 && userConfiguration != null) { userConfiguration.Dispose(); userConfiguration = null; } } return(result); }
private static string CheckConfigurationName(string name, ConfigurationNameKind kind) { Util.ThrowOnNullArgument(name, "name"); string result; if (!UserConfigurationName.TryCheckConfigurationName(name, kind, out result)) { throw new ArgumentException(ServerStrings.ExConfigNameInvalid(name)); } return(result); }
public static UserConfiguration GetConfiguration(Folder folder, UserConfigurationName configurationName, UserConfigurationTypes type) { EnumValidator.ThrowIfInvalid <UserConfigurationTypes>(type, "type"); try { return(UserConfiguration.GetIgnoringCache(null, folder, configurationName, type)); } catch (ObjectNotFoundException arg) { ExTraceGlobals.StorageTracer.TraceError <ObjectNotFoundException>(0L, "UserConfiguration::GetConfiguration. User Configuration object not found. Exception = {0}.", arg); } return(UserConfiguration.Create(folder, configurationName, type)); }
private UserConfiguration InternalCreateUserConfiguration(Folder folder, UserConfigurationName configurationName, UserConfigurationTypes dataTypes) { ExTraceGlobals.StorageTracer.Information <UserConfigurationName, UserConfigurationTypes>((long)this.GetHashCode(), "UserConfigurationManager::InternalCreateUserConfiguration. configurationName = {0}, dataTypes = {1}.", configurationName, dataTypes); if (folder == null) { throw new ArgumentNullException("folder"); } if (!EnumValidator.IsValidValue <UserConfigurationTypes>(dataTypes)) { ExTraceGlobals.StorageTracer.TraceError((long)this.GetHashCode(), "UserConfigurationManager::InternalCreateUserConfiguration. dataTypes is invalid."); throw new ArgumentException("dataTypes"); } return(UserConfiguration.Create(folder, configurationName, dataTypes)); }
internal void Remove(UserConfigurationName configName, StoreObjectId folderId) { LinkedListNode <UserConfigurationCacheEntry> linkedListNode = this.userConfigCacheEntryList.First; lock (this.userConfigCacheEntryList) { while (linkedListNode != null) { UserConfigurationCacheEntry value = linkedListNode.Value; if (value.CheckMatch(configName.Name, folderId)) { this.userConfigCacheEntryList.Remove(linkedListNode); break; } linkedListNode = linkedListNode.Next; } } }
private static bool TryCheckConfigurationName(string name, ConfigurationNameKind kind, out string validatedName) { validatedName = null; int num = name.IndexOf("IPM.Configuration."); switch (kind) { case ConfigurationNameKind.Name: case ConfigurationNameKind.PartialName: if (num >= 0) { ExTraceGlobals.StorageTracer.TraceError <string>(0L, "UserConfigurationName::TryCheckConfigurationName. Invalid config name contains well known prefix. Name = {0}", name); return(false); } break; case ConfigurationNameKind.ItemClass: if (num < 0) { ExTraceGlobals.StorageTracer.TraceError <string>(0L, "UserConfigurationName::TryCheckConfigurationName. Invalid full name. Name = {0}", name); return(false); } name = name.Substring("IPM.Configuration.".Length); break; } if (name.Length == 0 && kind != ConfigurationNameKind.PartialName) { ExTraceGlobals.StorageTracer.TraceError <string, ConfigurationNameKind>(0L, "UserConfigurationName::TryCheckConfigurationName. ConfigName is empty. Name = {0}. Kind = {1}", name, kind); return(false); } if (name.Length > UserConfigurationName.MaxUserConfigurationNameLength) { ExTraceGlobals.StorageTracer.TraceError <string, int, int>(0L, "UserConfigurationName::TryCheckConfigurationName. Name = {0}, Length = {1}, MaxLength = {2}.", name, name.Length, UserConfigurationName.MaxUserConfigurationNameLength); return(false); } if (!UserConfigurationName.TryValidateConfigName(name)) { return(false); } validatedName = name; return(true); }
internal bool TryGetUserConfigurationCachedEntry(UserConfigurationName configName, StoreObjectId folderId, out UserConfigurationCacheEntry cacheEntry) { bool result; lock (this.userConfigCacheEntryList) { for (LinkedListNode <UserConfigurationCacheEntry> linkedListNode = this.userConfigCacheEntryList.First; linkedListNode != null; linkedListNode = linkedListNode.Next) { UserConfigurationCacheEntry value = linkedListNode.Value; if (value.CheckMatch(configName.Name, folderId)) { cacheEntry = value; return(true); } } cacheEntry = null; result = false; } return(result); }
public UserConfigurationName(string name, ConfigurationNameKind kind) { EnumValidator.ThrowIfInvalid <ConfigurationNameKind>(kind, "kind"); this.kind = kind; this.name = UserConfigurationName.CheckConfigurationName(name, kind); switch (kind) { case ConfigurationNameKind.Name: case ConfigurationNameKind.PartialName: this.fullName = "IPM.Configuration." + this.name; return; case ConfigurationNameKind.ItemClass: this.fullName = this.name; return; default: throw new InvalidOperationException(string.Format("Unrecognized kind. Kind = {0}.", this.kind)); } }
public static UserConfiguration Create(Folder folder, UserConfigurationName configurationName, UserConfigurationTypes type) { EnumValidator.ThrowIfInvalid <UserConfigurationTypes>(type, "type"); IList <IStorePropertyBag> list = null; try { list = UserConfiguration.QueryConfigurations(folder, null, configurationName, UserConfigurationSearchFlags.FullString, 1, new PropertyDefinition[0]); } catch (InvalidOperationException innerException) { throw new InvalidOperationException(ServerStrings.ExCannotQueryAssociatedTable, innerException); } if (list.Count > 0) { ExTraceGlobals.StorageTracer.TraceError <UserConfigurationName>(0L, "UserConfiguration::Create. The configuration object has existed. ConfigName = {0}.", configurationName); throw new ObjectExistedException(ServerStrings.ExConfigExisted(configurationName.Name)); } ConfigurationItem configurationItem = null; bool flag = false; UserConfiguration result; try { configurationItem = ItemBuilder.CreateNewItem <ConfigurationItem>(folder.Session, folder.Id, ItemCreateInfo.ConfigurationItemInfo, CreateMessageType.Associated); bool openMode = false; UserConfiguration userConfiguration = new UserConfiguration(configurationItem, folder.StoreObjectId, configurationName, type, openMode); flag = true; result = userConfiguration; } finally { if (!flag) { Util.DisposeIfPresent(configurationItem); } } return(result); }
public int Compare(object x, object y) { string text = x as string; UserConfigurationName userConfigurationName = y as UserConfigurationName; if (text == null || userConfigurationName == null) { return(-1); } switch (this.searchFlags) { case UserConfigurationSearchFlags.FullString: if (text == userConfigurationName.FullName) { return(0); } break; case UserConfigurationSearchFlags.SubString: { int num = text.IndexOf("IPM.Configuration."); int num2 = text.IndexOf(userConfigurationName.Name); if (num == 0 && num2 >= "IPM.Configuration.".Length) { return(0); } break; } case UserConfigurationSearchFlags.Prefix: if (text.IndexOf(userConfigurationName.FullName) == 0) { return(0); } break; } return(-1); }
private UserConfiguration(UserConfigurationName configurationName, StoreSession storeSession, StoreObjectId folderId, VersionedId versionedId, object dictionaryObject, UserConfigurationTypes type, IStorePropertyBag queryPropertyBag) : this(configurationName, type, queryPropertyBag) { PropertyError propertyError = dictionaryObject as PropertyError; if (propertyError != null) { if (propertyError.PropertyErrorCode != PropertyErrorCode.NotFound) { ExTraceGlobals.StorageTracer.TraceError <string, PropertyErrorCode>((long)this.GetHashCode(), "UserConfiguration::.ctor. The configuration data is corrupted. Field = {0}, PropertyErrorCode = {1}.", "Dictionary", propertyError.PropertyErrorCode); throw new CorruptDataException(ServerStrings.ExConfigDataCorrupted("Dictionary")); } } else if (dictionaryObject != null && !(dictionaryObject is byte[])) { ExTraceGlobals.StorageTracer.TraceError <string>((long)this.GetHashCode(), "UserConfiguration::.ctor. The configuration data is corrupted. Field = {0}.", "Dictionary"); throw new CorruptDataException(ServerStrings.ExConfigDataCorrupted("Dictionary")); } this.storeSession = storeSession; this.folderId = folderId; this.id = versionedId.ObjectId; this.configName = configurationName; this.configType = type; this.dictionaryPropValue = dictionaryObject; }
internal void Remove(UserConfigurationName configName, StoreObjectId folderId) { this.SharedCacheEntryManager.Remove(configName, folderId); }
internal void Add(StoreObjectId folderId, UserConfigurationName configName, StoreObjectId itemId) { this.SharedCacheEntryManager.AddUserConfigurationCachedEntry(folderId, configName.Name, itemId, this.mailboxSession.LogonType == LogonType.Owner); }
internal UserConfiguration(ConfigurationItem configurationItem, StoreObjectId folderId, UserConfigurationName configurationName, UserConfigurationTypes type, bool openMode) : this(configurationName, type, null) { this.storeSession = configurationItem.Session; this.configType = type; this.configName = configurationName; this.item = configurationItem; this.id = configurationItem.StoreObjectId; this.folderId = folderId; this.isOpenMode = openMode; if (!this.isOpenMode) { this.dictionaryPropValue = new PropertyError(InternalSchema.UserConfigurationDictionary, PropertyErrorCode.NotFound); } else { this.dictionaryPropValue = null; } this.isDisposed = false; }
internal static bool IsValidName(string name, ConfigurationNameKind kind) { string text; return(UserConfigurationName.TryCheckConfigurationName(name, kind, out text)); }
private UserConfiguration InternalBindAndGetUserConfiguration(StoreId folderId, UserConfigurationName configurationName, UserConfigurationTypes freefetchDataType) { UserConfiguration result = null; using (Folder folder = Folder.Bind(this.mailboxSession, folderId)) { if (folder.IsNew) { ExTraceGlobals.StorageTracer.TraceError <string>((long)this.GetHashCode(), "UserConfigurationManager::InternalGetUserConfiguration. The folder Id is null maybe it is because the folder has not been saved yet. Id = {0}.", "null"); throw new InvalidOperationException(ServerStrings.ExFolderWithoutMapiProp); } if (!EnumValidator.IsValidValue <UserConfigurationTypes>(freefetchDataType)) { ExTraceGlobals.StorageTracer.TraceError <UserConfigurationTypes>((long)this.GetHashCode(), "UserConfigurationManager::InternalGetUserConfiguration. freefetchDataType is not allowed. freefetchDataType = {0}.", freefetchDataType); throw new ArgumentException("freefetchDataType"); } ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName>((long)this.GetHashCode(), "UserConfigurationManager::InternalGetUserConfiguration. Hit code GetIgnoringCache. ConfigName = {0}.", configurationName); result = UserConfiguration.GetIgnoringCache(this, folder, configurationName, freefetchDataType); } return(result); }
internal static UserConfiguration GetIgnoringCache(UserConfigurationManager manager, Folder folder, UserConfigurationName configurationName, UserConfigurationTypes freefetchType) { EnumValidator.AssertValid <UserConfigurationTypes>(freefetchType); UserConfiguration userConfiguration = null; PropertyDefinition[] columns; if ((freefetchType & UserConfigurationTypes.Dictionary) > (UserConfigurationTypes)0) { columns = new PropertyDefinition[] { InternalSchema.UserConfigurationDictionary }; } else { columns = UserConfiguration.ZeroProperties; } SortBy[] sorts = new SortBy[] { new SortBy(InternalSchema.CreationTime, SortOrder.Ascending), new SortBy(InternalSchema.MID, SortOrder.Ascending) }; IList <IStorePropertyBag> list = null; try { ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName>(0L, "UserConfiguration::GetIgnoringCache. Hit Query. ConfigName = {0}.", configurationName); list = UserConfiguration.QueryConfigurations(folder, sorts, configurationName, UserConfigurationSearchFlags.FullString, 2, columns); } catch (InvalidOperationException innerException) { throw new InvalidOperationException(ServerStrings.ExCannotQueryAssociatedTable, innerException); } if (list.Count <= 0) { ExTraceGlobals.StorageTracer.TraceError <UserConfigurationName, UserConfigurationTypes>(0L, "UserConfiguration::GetIgnoringCache. The configuration object was not found. Name = {0}, type = {1}.", configurationName, freefetchType); throw new ObjectNotFoundException(ServerStrings.ExConfigurationNotFound(configurationName.Name)); } ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName>(0L, "UserConfiguration::GetIgnoringCache. Find the config item and build user config object from it. ConfigName = {0}.", configurationName); bool flag = false; UserConfiguration result2; try { userConfiguration = UserConfiguration.BuildConfigurationFromQueryItem(folder, list[0], (freefetchType & UserConfigurationTypes.Dictionary) > (UserConfigurationTypes)0); if (list.Count > 1) { ExTraceGlobals.UserConfigurationTracer.TraceDebug <UserConfigurationName>(0L, "UserConfiguration::GetIgnoringCache. Found duplicate items. Conflict resolution. ConfigName = {0}.", configurationName); List <VersionedId> list2 = new List <VersionedId>(); list = UserConfiguration.QueryConfigurations(folder, sorts, configurationName, UserConfigurationSearchFlags.FullString, 100, new PropertyDefinition[0]); for (int i = 1; i < list.Count; i++) { list2.Add((VersionedId)list[i][InternalSchema.ItemId]); } if (list2.Count > 0) { AggregateOperationResult result = folder.Session.Delete(DeleteItemFlags.HardDelete, list2.ToArray()); UserConfiguration.CheckOperationResults(result, "DeleteDuplicates"); } } flag = true; result2 = userConfiguration; } finally { if (!flag && userConfiguration != null) { userConfiguration.Dispose(); } } return(result2); }
private UserConfiguration InternalGetUserConfiguration(StoreId folderId, UserConfigurationName configurationName, UserConfigurationTypes freefetchDataType) { return(this.InternalGetUserConfiguration(folderId, configurationName, freefetchDataType, null)); }