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 ConfigurationDictionary DeserializeDictionary(byte[] data)
{
if (data == null)
{
return(null);
}
using (MemoryStream memoryStream = new MemoryStream(data))
{
this.configDictionary = new ConfigurationDictionary();
this.configDictionary.ReadXml(UserConfiguration.InternalGetXmlReader(memoryStream));
}
return(this.configDictionary);
}
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));
}
private IReadableUserConfiguration CreateMclConfiguration()
{
IReadableUserConfiguration result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
UserConfiguration userConfiguration = this.session.UserConfigurationManager.CreateFolderConfiguration("CategoryList", UserConfigurationTypes.XML, this.session.GetDefaultFolderId(DefaultFolderType.Calendar));
disposeGuard.Add <UserConfiguration>(userConfiguration);
userConfiguration.Save();
disposeGuard.Success();
result = userConfiguration;
}
return(result);
}
private void InternalDeleteUserConfiguration(Folder folder, string configurationName)
{
ExTraceGlobals.StorageTracer.Information <string>((long)this.GetHashCode(), "Folder::DeleteUserConfiguration. configurationName = {0}.", (configurationName == null) ? "<Null>" : configurationName);
if (configurationName == null)
{
ExTraceGlobals.StorageTracer.TraceError <string>((long)this.GetHashCode(), "Folder::DeleteUserConfiguration. Argument {0} is Null.", "configurationName");
throw new ArgumentNullException(ServerStrings.ExNullParameter("configurationName", 1));
}
if (configurationName.Length == 0)
{
ExTraceGlobals.StorageTracer.TraceError <string>((long)this.GetHashCode(), "Folder::DeleteUserConfiguration. Argument {0} is Empty.", "configurationName");
throw new ArgumentException(ServerStrings.ExInvalidParameter("configurationName", 1));
}
UserConfiguration.Delete(folder, configurationName, UserConfigurationSearchFlags.FullString);
}
public void Save(SaveMode saveMode)
{
EnumValidator.ThrowIfInvalid <SaveMode>(saveMode);
if (!this.IsLoaded)
{
throw new InvalidOperationException("The Master Category List is not loaded and thus cannot be saved");
}
this.FlushCategoryUsageLog();
if (!this.IsDirty())
{
return;
}
this.propertyBag[MasterCategoryListSchema.LastSavedTime] = ExDateTime.GetNow(ExTimeZone.UtcTimeZone);
using (UserConfiguration folderConfiguration = this.session.UserConfigurationManager.GetFolderConfiguration("CategoryList", UserConfigurationTypes.XML, this.session.GetDefaultFolderId(DefaultFolderType.Calendar)))
{
MasterCategoryList masterCategoryList;
using (Stream xmlStream = folderConfiguration.GetXmlStream())
{
masterCategoryList = ((!this.configurationItemId.Equals(folderConfiguration.VersionedId)) ? this.MergeCopies(saveMode, folderConfiguration, xmlStream) : this);
xmlStream.Position = 0L;
using (Stream stream = new MemoryStream((int)xmlStream.Length))
{
masterCategoryList.SaveToStream(saveMode, stream, xmlStream);
if (stream.Length > 524288L)
{
throw new StoragePermanentException(ServerStrings.ExMclIsTooBig(stream.Length, 524288L));
}
stream.Position = 0L;
xmlStream.Position = 0L;
xmlStream.SetLength(0L);
Util.StreamHandler.CopyStreamData(stream, xmlStream);
}
}
folderConfiguration.Save();
this.MovePersistentContent(masterCategoryList);
this.originalMcl = this.Clone();
this.configurationItemId = folderConfiguration.VersionedId;
this.loadedWithProblems = false;
this.propertyBag.ClearChangeInfo();
this.isListModified = false;
}
}
internal void SaveToCalendar(MailboxSession session, StoreId folderId)
{
try
{
using (UserConfiguration orCreateWorkingHourConfiguration = WorkHoursInCalendar.GetOrCreateWorkingHourConfiguration(session, folderId))
{
using (Stream xmlStream = orCreateWorkingHourConfiguration.GetXmlStream())
{
xmlStream.SetLength(0L);
this.SerializeObject(xmlStream);
orCreateWorkingHourConfiguration.Save();
}
}
}
catch (InvalidOperationException ex)
{
ExTraceGlobals.WorkHoursTracer.TraceError <string, InvalidOperationException>((long)this.GetHashCode(), "{0}: Could not save work hours configuration item to mailbox. Exception information is {1}.", session.MailboxOwner.MailboxInfo.DisplayName, ex);
throw new WorkingHoursXmlMalformedException(ServerStrings.SaveConfigurationItem(session.MailboxOwner.MailboxInfo.DisplayName, ex.ToString()));
}
}
private static UserConfiguration GetOrCreateWorkingHourConfiguration(MailboxSession session, StoreId folderId)
{
UserConfigurationManager userConfigurationManager = session.UserConfigurationManager;
UserConfiguration userConfiguration = null;
try
{
userConfiguration = userConfigurationManager.GetFolderConfiguration("WorkHours", UserConfigurationTypes.XML, folderId);
}
catch (ObjectNotFoundException)
{
ExTraceGlobals.WorkHoursTracer.TraceDebug <string>(0L, "WorkHoursInCalendar::GetOrCreateWorkingHourConfiguration. GetOrCreateWorkingHourConfigurationStorageWorkingHours does not exist yet. I am going to create a new one. Mailbox = {0}.", session.MailboxOwner.MailboxInfo.DisplayName);
userConfiguration = userConfigurationManager.CreateFolderConfiguration("WorkHours", UserConfigurationTypes.XML, folderId);
}
if (userConfiguration == null)
{
throw new WorkingHoursSaveFailedException(ServerStrings.CreateConfigurationItem(session.MailboxOwner.MailboxInfo.DisplayName));
}
return(userConfiguration);
}
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);
}
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 static ExTimeZone GetUserTimeZone(MailboxSession mailboxSession)
{
ExTimeZone result = null;
UserConfiguration mailboxConfiguration = UserConfigurationHelper.GetMailboxConfiguration(mailboxSession, "OWA.UserOptions", UserConfigurationTypes.Dictionary, false);
if (mailboxConfiguration == null)
{
ExTraceGlobals.StorageTracer.TraceDebug <IExchangePrincipal>(0L, "{0}: UserOption doesn't exist.", mailboxSession.MailboxOwner);
}
else
{
using (mailboxConfiguration)
{
IDictionary dictionary = null;
try
{
dictionary = mailboxConfiguration.GetDictionary();
}
catch (CorruptDataException)
{
ExTraceGlobals.StorageTracer.TraceError <IExchangePrincipal>(0L, "{0}: Dictionary exists but is corrupt.", mailboxSession.MailboxOwner);
}
catch (InvalidOperationException)
{
ExTraceGlobals.StorageTracer.TraceError <IExchangePrincipal>(0L, "{0}: Dictionary is invalid.", mailboxSession.MailboxOwner);
}
if (dictionary != null)
{
string text = dictionary[MailboxRegionalConfigurationSchema.TimeZone.Name] as string;
ExTraceGlobals.StorageTracer.TraceDebug <IExchangePrincipal, string>(0L, "{0}: Get timezone from dictionary of configuration. KeyName = {1}", mailboxSession.MailboxOwner, text);
if (string.IsNullOrEmpty(text) || !ExTimeZoneEnumerator.Instance.TryGetTimeZoneByName(text, out result))
{
ExTraceGlobals.StorageTracer.TraceError <IExchangePrincipal, string>(0L, "{0}: The KeyName of TimeZone is invalid. KeyName = {1}", mailboxSession.MailboxOwner, text);
}
}
}
}
return(result);
}
IList <IStorePropertyBag> IUserConfigurationManager.FetchAllConfigurations(IFolder folder, SortBy[] sorts, int maxRow, params PropertyDefinition[] columns)
{
return(UserConfiguration.FetchAllConfigurations(folder, sorts, maxRow, columns));
}
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);
}
protected override void InitializeNewItemData(IStoreSession session, IFolder folder, HierarchySyncMetadataItem newMetadataItem)
{
if (folder != null)
{
bool flag = false;
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <VersionedId>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Getting UserConfiguration from folder {0}", folder.Id);
using (UserConfiguration configuration = UserConfiguration.GetConfiguration(folder as Folder, new UserConfigurationName("PublicFolderSyncInfo", ConfigurationNameKind.Name), UserConfigurationTypes.Dictionary))
{
IDictionary dictionary = configuration.GetDictionary();
ExDateTime exDateTime;
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <ExDateTime>(dictionary, "FirstFailedSyncTimeAfterLastSuccess", out exDateTime))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <ExDateTime>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found FirstFailedSyncTimeAfterLastSuccess in UserConfiguration. Value {0}", exDateTime);
newMetadataItem.FirstFailedSyncTimeAfterLastSuccess = exDateTime;
flag = true;
}
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <ExDateTime>(dictionary, "LastAttemptedSyncTime", out exDateTime))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <ExDateTime>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found LastAttemptedSyncTime in UserConfiguration. Value {0}", exDateTime);
newMetadataItem.LastAttemptedSyncTime = exDateTime;
flag = true;
}
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <ExDateTime>(dictionary, "LastFailedSyncTime", out exDateTime))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <ExDateTime>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found LastFailedSyncTime in UserConfiguration. Value {0}", exDateTime);
newMetadataItem.LastFailedSyncTime = exDateTime;
flag = true;
}
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <ExDateTime>(dictionary, "LastSuccessfulSyncTime", out exDateTime))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <ExDateTime>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found LastSuccessfulSyncTime in UserConfiguration. Value {0}", exDateTime);
newMetadataItem.LastSuccessfulSyncTime = exDateTime;
flag = true;
}
int num;
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <int>(dictionary, "NumberofAttemptsAfterLastSuccess", out num))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <int>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found NumberOfAttemptsAfterLastSuccess in UserConfiguration. Value {0}", num);
newMetadataItem.NumberOfAttemptsAfterLastSuccess = num;
flag = true;
}
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <int>(dictionary, "NumberOfBatchesExecuted", out num))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <int>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found NumberOfBatchesExecuted in UserConfiguration. Value {0}", num);
newMetadataItem.NumberOfBatchesExecuted = num;
flag = true;
}
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <int>(dictionary, "NumberOfFoldersSynced", out num))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <int>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found NumberOfFoldersSynced in UserConfiguration. Value {0}", num);
newMetadataItem.NumberOfFoldersSynced = num;
flag = true;
}
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <int>(dictionary, "NumberOfFoldersToBeSynced", out num))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <int>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found NumberOfFoldersToBeSynced in UserConfiguration. Value {0}", num);
newMetadataItem.NumberOfFoldersToBeSynced = num;
flag = true;
}
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <int>(dictionary, "BatchSize", out num))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <int>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found BatchSize in UserConfiguration. Value {0}", num);
newMetadataItem.BatchSize = num;
flag = true;
}
string text;
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <string>(dictionary, "LastSyncFailure", out text))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <string>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found LastSyncFailure in UserConfiguration. Value {0}", text);
newMetadataItem.LastSyncFailure = text;
flag = true;
}
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <string>(dictionary, "SyncState", out text) && !string.IsNullOrWhiteSpace(text))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <string>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found SyncState in UserConfiguration. Value {0}", text);
using (Stream syncStateOverrideStream = newMetadataItem.GetSyncStateOverrideStream())
{
HierarchySyncMetadataItemHandler.CopyStringToMetadataAttachment(text, syncStateOverrideStream);
flag = true;
}
}
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <string>(dictionary, "FinalJobSyncState", out text) && !string.IsNullOrWhiteSpace(text))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <string>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found FinalJobSyncState in UserConfiguration. Value {0}", text);
using (Stream finalJobSyncStateWriteStream = newMetadataItem.GetFinalJobSyncStateWriteStream(true))
{
HierarchySyncMetadataItemHandler.CopyStringToMetadataAttachment(text, finalJobSyncStateWriteStream);
flag = true;
}
}
byte[] array;
if (HierarchySyncMetadataItemHandler.TryGetLegacyMetadataValue <byte[]>(dictionary, "PartiallyCommittedFolderIds", out array))
{
if (HierarchySyncMetadataItemHandler.PublicFolderTracer.IsTraceEnabled(TraceType.DebugTrace))
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug <string>((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Found PartiallyCommittedFolderIds in UserConfiguration. Value {0}", Convert.ToBase64String(array));
}
using (Reader reader = Reader.CreateBufferReader(array))
{
newMetadataItem.SetPartiallyCommittedFolderIds(IdSet.ParseWithReplGuids(reader));
flag = true;
}
}
}
if (flag)
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Metadata Item was updated. Saving and reloading properties.");
newMetadataItem.Save(SaveMode.FailOnAnyConflict);
newMetadataItem.Load();
return;
}
}
else
{
HierarchySyncMetadataItemHandler.PublicFolderTracer.TraceDebug((long)this.GetHashCode(), "HierarchySyncMetadataItemHandler:InitializeNewItemData - Skipping import from UserConfiguration as no folder was provided.");
}
}
// Token: 0x06000FC7 RID: 4039 RVA: 0x00040805 File Offset: 0x0003EA05
public static RecipientInfoCache Create(UserConfiguration userConfiguration)
{
return(new RecipientInfoCache(userConfiguration));
}
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 bool VerifyAndFixRemindersSearchFolder(DefaultFolderContext context, SearchFolder reminders)
{
RemindersSearchFolderValidation.RemindersSearchFolderState remindersSearchFolderState = RemindersSearchFolderValidation.GetRemindersSearchFolderState(context, reminders);
if (!remindersSearchFolderState.IsUpToDate)
{
ExTraceGlobals.DefaultFoldersTracer.TraceDebug <RemindersSearchFolderValidation.RemindersSearchFolderState>(-1L, "RemindersSearchFolderValidation::VerifyAndFixRemindersSearchFolder. We are updating reminder's state: {0}", remindersSearchFolderState);
if (context.Session.LogonType != LogonType.Owner)
{
return(false);
}
QueryFilter[] array = (remindersSearchFolderState.Version == RemindersSearchFolderValidation.RemindersSearchFolderVersion.O12) ? RemindersSearchFolderValidation.GetO12RemindersSearchFolderExclusionList(reminders.GetSearchCriteria()) : null;
if (array != null && array.Length > 30)
{
string message = "A maximum allowed number of exclusion entries for a Reminders search folder is reached.Either default folders got re-created numerous times or the folder completeness criteria produced false negatives.";
ExTraceGlobals.DefaultFoldersTracer.TraceError(-1L, message);
return(true);
}
SearchFolderCriteria searchFolderCriteria = RemindersSearchFolderValidation.CreateRemindersQueryForO12(context, array);
if (array != null)
{
ExTraceGlobals.DefaultFoldersTracer.TraceDebug <int, int>(-1L, "RemindersSearchFolderValidation::VerifyAndFixRemindersSearchFolder. Current Reminders search criteria is incomplete: {0} exclusions versus {1} expected", array.Length, RemindersSearchFolderValidation.GetO12RemindersSearchFolderExclusionList(searchFolderCriteria).Length);
}
if (remindersSearchFolderState.Version != RemindersSearchFolderValidation.RemindersSearchFolderVersion.O11)
{
ExTraceGlobals.DefaultFoldersTracer.TraceDebug <RemindersSearchFolderValidation.RemindersSearchFolderState>(-1L, "RemindersSearchFolderValidation::VerifyAndFixRemindersSearchFolder. Reminder starts to apply new criteria on the folder. folderState = {0}.", remindersSearchFolderState);
reminders.ApplyContinuousSearch(searchFolderCriteria);
}
else
{
ExTraceGlobals.DefaultFoldersTracer.TraceDebug <RemindersSearchFolderValidation.RemindersSearchFolderState>(-1L, "RemindersSearchFolderValidation::VerifyAndFixRemindersSearchFolder. Outlook12. folderState = {0}.", remindersSearchFolderState);
IAsyncResult asyncResult = reminders.BeginApplyContinuousSearch(searchFolderCriteria, null, null);
if (RemindersSearchFolderValidation.InternalWaitForRemindersIndexing(asyncResult))
{
reminders.EndApplyContinuousSearch(asyncResult);
}
else
{
ExTraceGlobals.DefaultFoldersTracer.TraceDebug(-1L, "RemindersSearchFolderValidation::VerifyAndFixRemindersSearchFolder. Timeout expired waiting for a Reminders search folder to finish population.");
}
RemindersSearchFolderValidation.UnsetStaleReminders(context, reminders);
UserConfiguration userConfiguration = null;
try
{
try
{
userConfiguration = context.Session.UserConfigurationManager.GetFolderConfiguration("Calendar", UserConfigurationTypes.Dictionary, context.Session.GetDefaultFolderId(DefaultFolderType.Calendar));
}
catch (ObjectNotFoundException)
{
ExTraceGlobals.DefaultFoldersTracer.TraceDebug(-1L, "RemindersSearchFolderValidation::VerifyAndFixRemindersSearchFolder. No existing Calendar configuration was found. We are creating new one.");
userConfiguration = context.Session.UserConfigurationManager.CreateFolderConfiguration("Calendar", UserConfigurationTypes.Dictionary, context.Session.GetDefaultFolderId(DefaultFolderType.Calendar));
}
IDictionary dictionary = userConfiguration.GetDictionary();
dictionary["piReminderUpgradeTime"] = Util.ConvertDateTimeToRTime(ExDateTime.GetNow(context.Session.ExTimeZone));
userConfiguration.Save();
}
finally
{
if (userConfiguration != null)
{
userConfiguration.Dispose();
}
}
}
}
return(true);
}
