internal void Load(MailboxSession mailboxSession, IList <UserConfigurationPropertyDefinition> properties, bool ignoreOverQuotaException)
{
try
{
using (IReadableUserConfiguration readOnlyConfiguration = this.GetReadOnlyConfiguration(mailboxSession))
{
if (readOnlyConfiguration != null)
{
IDictionary dictionary = readOnlyConfiguration.GetDictionary();
for (int i = 0; i < properties.Count; i++)
{
UserConfigurationPropertyDefinition userConfigurationPropertyDefinition = properties[i];
object originalValue = dictionary[userConfigurationPropertyDefinition.PropertyName];
this.optionProperties[userConfigurationPropertyDefinition] = userConfigurationPropertyDefinition.GetValidatedProperty(originalValue);
ExTraceGlobals.UserOptionsDataTracer.TraceDebug((long)this.GetHashCode(), "Loaded property: {0}", new object[]
{
this.optionProperties[userConfigurationPropertyDefinition]
});
}
}
}
}
catch (QuotaExceededException ex)
{
ExTraceGlobals.UserContextCallTracer.TraceDebug <string>(0L, "UserConfigurationBaseType: Load failed. Exception: {0}", ex.Message);
if (!ignoreOverQuotaException)
{
throw;
}
}
}
public IReadableUserConfiguration Read(IMailboxSession session, UserConfigurationDescriptor descriptor)
{
IReadableUserConfiguration readableUserConfiguration = this.reader.Read(session, descriptor);
if (readableUserConfiguration != null)
{
this.FaiCacheHit();
}
return(readableUserConfiguration);
}
public IReadableUserConfiguration GetReadOnlyFolderConfiguration(string configName, UserConfigurationTypes freefetchDataTypes, StoreId folderId)
{
IReadableUserConfiguration result = null;
if (!this.TryGetAggregatedConfiguration(() => UserConfigurationDescriptor.CreateFolderDescriptor(configName, freefetchDataTypes, StoreId.GetStoreObjectId(folderId)), out result))
{
result = this.GetFolderConfiguration(configName, freefetchDataTypes, folderId);
}
return(result);
}
public IReadableUserConfiguration GetReadOnlyMailboxConfiguration(string configName, UserConfigurationTypes freefetchDataTypes)
{
IReadableUserConfiguration result = null;
if (!this.TryGetAggregatedConfiguration(() => UserConfigurationDescriptor.CreateMailboxDescriptor(configName, freefetchDataTypes), out result))
{
result = this.GetMailboxConfiguration(configName, freefetchDataTypes);
}
return(result);
}
internal void Load(bool forceReload)
{
if (this.IsLoaded && !forceReload)
{
return;
}
IReadableUserConfiguration readableUserConfiguration = null;
this.loadedWithProblems = false;
try
{
try
{
readableUserConfiguration = this.session.UserConfigurationManager.GetReadOnlyFolderConfiguration("CategoryList", UserConfigurationTypes.XML, this.session.GetDefaultFolderId(DefaultFolderType.Calendar));
ExTraceGlobals.StorageTracer.TraceDebug((long)this.GetHashCode(), "MasterCategoryList::Load - newly loaded configurationItem");
if (this.configurationItemId != null && this.configurationItemId.Equals(readableUserConfiguration.VersionedId))
{
ExTraceGlobals.StorageTracer.TraceDebug((long)this.GetHashCode(), "MasterCategoryList::Load - returning without reloading since this.configurationItemId.Equals(configurationItem.VersionedId.");
return;
}
}
catch (ObjectNotFoundException)
{
ExTraceGlobals.StorageTracer.TraceDebug((long)this.GetHashCode(), "MasterCategoryList::Load - ObjectNotFoundException: creating and saving a new MCL");
try
{
readableUserConfiguration = this.CreateMclConfiguration();
}
catch (ObjectExistedException ex)
{
ExTraceGlobals.StorageTracer.TraceWarning <string, string>((long)this.GetHashCode(), "MclConfiguration already created. Error: {0}. Stack: {1}.", ex.Message, ex.StackTrace);
readableUserConfiguration = this.session.UserConfigurationManager.GetFolderConfiguration("CategoryList", UserConfigurationTypes.XML, this.session.GetDefaultFolderId(DefaultFolderType.Calendar));
}
}
using (Stream xmlStream = readableUserConfiguration.GetXmlStream())
{
this.Load(xmlStream);
this.originalMcl = this.Clone();
this.configurationItemId = readableUserConfiguration.VersionedId;
}
this.isListModified = false;
}
finally
{
if (readableUserConfiguration != null)
{
readableUserConfiguration.Dispose();
}
}
}
private void LoadUserConfigurationToConfigObject(string userConfigurationName, XsoMailboxConfigurationObject configObject)
{
using (IReadableUserConfiguration readableUserConfiguration = this.getReadOnlyUserConfiguration(base.MailboxSession, userConfigurationName, UserConfigurationTypes.Dictionary, false))
{
if (readableUserConfiguration != null)
{
IDictionary dictionary = readableUserConfiguration.GetDictionary();
foreach (PropertyDefinition propertyDefinition in configObject.Schema.AllProperties)
{
XsoDictionaryPropertyDefinition xsoDictionaryPropertyDefinition = propertyDefinition as XsoDictionaryPropertyDefinition;
if (xsoDictionaryPropertyDefinition != null && !(xsoDictionaryPropertyDefinition.UserConfigurationName != userConfigurationName) && dictionary.Contains(xsoDictionaryPropertyDefinition.Name))
{
configObject.propertyBag.SetField(xsoDictionaryPropertyDefinition, StoreValueConverter.ConvertValueFromStore(xsoDictionaryPropertyDefinition, dictionary[xsoDictionaryPropertyDefinition.Name]));
}
}
}
}
}
internal static ConfigurableObject Fill(ConfigurableObject configObject, ProviderPropertyDefinition property, UserConfigurationXmlHelper.GetReadableXmlUserConfigurationDelegate getXmlUserConfigurationDelegate)
{
Util.ThrowOnNullArgument(configObject, "configObject");
Util.ThrowOnNullArgument(property, "property");
using (IReadableUserConfiguration readableUserConfiguration = getXmlUserConfigurationDelegate(false))
{
if (readableUserConfiguration == null)
{
return(null);
}
using (Stream xmlStream = readableUserConfiguration.GetXmlStream())
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(property.Type);
configObject[property] = dataContractSerializer.ReadObject(xmlStream);
}
}
return(configObject);
}
internal static WorkHoursInCalendar GetFromCalendar(MailboxSession session, StoreId folderId)
{
WorkHoursInCalendar workHoursInCalendar = null;
try
{
UserConfigurationManager userConfigurationManager = session.UserConfigurationManager;
using (IReadableUserConfiguration readOnlyFolderConfiguration = userConfigurationManager.GetReadOnlyFolderConfiguration("WorkHours", UserConfigurationTypes.XML, folderId))
{
if (readOnlyFolderConfiguration == null)
{
ExTraceGlobals.WorkHoursTracer.TraceDebug <string>(-1L, "{0}: Work hours configuration item was not found", session.MailboxOwner.MailboxInfo.DisplayName);
}
else
{
using (Stream xmlStream = readOnlyFolderConfiguration.GetXmlStream())
{
workHoursInCalendar = WorkHoursInCalendar.DeserializeObject(xmlStream);
if (workHoursInCalendar == null)
{
ExTraceGlobals.WorkHoursTracer.TraceDebug <string>(-1L, "{0}: Work hours configuration item was found, but no content was found", session.MailboxOwner.MailboxInfo.DisplayName);
}
}
}
}
}
catch (ObjectNotFoundException arg)
{
ExTraceGlobals.WorkHoursTracer.TraceError <string, ObjectNotFoundException>(-1L, "{0}: Could not retrieve working hours. Exception information is {1}", session.MailboxOwner.MailboxInfo.DisplayName, arg);
}
catch (InvalidOperationException ex)
{
ExTraceGlobals.WorkHoursTracer.TraceError <string, InvalidOperationException>(-1L, "{0}: Malformed working hours XML in mailbox. Exception information is {1}", session.MailboxOwner.MailboxInfo.DisplayName, ex);
throw new WorkingHoursXmlMalformedException(ServerStrings.MalformedWorkingHours(session.MailboxOwner.MailboxInfo.DisplayName, ex.ToString()), ex);
}
catch (XmlException ex2)
{
ExTraceGlobals.WorkHoursTracer.TraceError <string, XmlException>(-1L, "{0}: Hit an XmlException deserializing working hours XML in mailbox. Exception information is {1}", session.MailboxOwner.MailboxInfo.DisplayName, ex2);
throw new WorkingHoursXmlMalformedException(ServerStrings.MalformedWorkingHours(session.MailboxOwner.MailboxInfo.DisplayName, ex2.ToString()), ex2);
}
return(workHoursInCalendar);
}
// Token: 0x06001665 RID: 5733 RVA: 0x0007E184 File Offset: 0x0007C384
private System.DayOfWeek LoadFirstDayOfWeek()
{
ExTraceGlobals.HeuristicsTracer.TraceFunction(0L, "ReminderTimeCalculatorContext.LoadFirstDayOfWeek");
using (IReadableUserConfiguration readOnlyMailboxConfiguration = UserConfigurationHelper.GetReadOnlyMailboxConfiguration(this.session as MailboxSession, "OWA.UserOptions", UserConfigurationTypes.Dictionary, false))
{
if (readOnlyMailboxConfiguration != null)
{
IDictionary dictionary = readOnlyMailboxConfiguration.GetDictionary();
object obj = dictionary[MailboxCalendarConfigurationSchema.WeekStartDay.Name];
if (obj != null)
{
ExTraceGlobals.HeuristicsTracer.TraceDebug(0L, "Found first day of week: {0}", new object[]
{
obj
});
return((System.DayOfWeek)obj);
}
ExTraceGlobals.HeuristicsTracer.TraceDebug(0L, "WeekStartDay is null on config object");
}
}
ExTraceGlobals.HeuristicsTracer.TraceDebug(0L, "Unable to determine first day of week");
return(System.DayOfWeek.Sunday);
}
internal static PolicyTagList GetPolicyTagListFromMailboxSession(RetentionActionType type, MailboxSession session)
{
StoreId defaultFolderId = session.GetDefaultFolderId(DefaultFolderType.Inbox);
IReadableUserConfiguration readableUserConfiguration = null;
try
{
readableUserConfiguration = session.UserConfigurationManager.GetReadOnlyFolderConfiguration("MRM", UserConfigurationTypes.Stream | UserConfigurationTypes.XML | UserConfigurationTypes.Dictionary, defaultFolderId);
if (readableUserConfiguration != null)
{
using (Stream xmlStream = readableUserConfiguration.GetXmlStream())
{
string sessionCultureName = null;
if (session.Capabilities.CanHaveCulture)
{
sessionCultureName = session.PreferedCulture.Name;
}
return(PolicyTagList.GetPolicyTakListFromXmlStream(type, xmlStream, sessionCultureName));
}
}
}
catch (ObjectNotFoundException)
{
}
catch (CorruptDataException)
{
}
finally
{
if (readableUserConfiguration != null)
{
readableUserConfiguration.Dispose();
}
}
return(null);
}
private bool TryGetAggregatedConfiguration(Func <UserConfigurationDescriptor> descriptorFactory, out IReadableUserConfiguration config)
{
config = null;
if (this.aggregators.Count > 0)
{
lock (this.aggregators)
{
UserConfigurationDescriptor descriptor = descriptorFactory();
foreach (UserConfigurationManager.AggregationContext aggregationContext in this.aggregators)
{
config = aggregationContext.Read(this.mailboxSession, descriptor);
if (config != null)
{
break;
}
}
}
}
return(null != config);
}
