internal static void Delete(Folder folder, string searchString, UserConfigurationSearchFlags searchFlags)
{
EnumValidator.AssertValid <UserConfigurationSearchFlags>(searchFlags);
if (searchFlags != UserConfigurationSearchFlags.SubString && searchFlags != UserConfigurationSearchFlags.FullString && searchFlags != UserConfigurationSearchFlags.Prefix)
{
ExTraceGlobals.StorageTracer.TraceError <UserConfigurationSearchFlags>(0L, "UserConfiguration::FindItems. The search flag is not supported. searchFlags = {0}.", searchFlags);
throw new NotSupportedException();
}
IList <IStorePropertyBag> list = null;
try
{
list = UserConfiguration.QueryConfigurations(folder, null, new UserConfigurationName(searchString, ConfigurationNameKind.PartialName), searchFlags, StorageLimits.Instance.UserConfigurationMaxSearched, new PropertyDefinition[0]);
}
catch (InvalidOperationException innerException)
{
throw new InvalidOperationException(ServerStrings.ExCannotQueryAssociatedTable, innerException);
}
List <VersionedId> list2 = new List <VersionedId>();
for (int i = 0; i < list.Count; i++)
{
list2.Add((VersionedId)list[i][InternalSchema.ItemId]);
if (i == list.Count - 1 || list2.Count > 100)
{
AggregateOperationResult result = folder.Session.Delete(DeleteItemFlags.SoftDelete, list2.ToArray());
UserConfiguration.CheckOperationResults(result, "Delete");
list2.Clear();
}
}
}
public override Stream OpenPropertyStream(PropertyDefinition propertyDefinition, PropertyOpenMode openMode)
{
base.CheckDisposed("OpenPropertyStream");
EnumValidator.AssertValid <PropertyOpenMode>(openMode);
NativeStorePropertyDefinition nativeStorePropertyDefinition = propertyDefinition as NativeStorePropertyDefinition;
if (nativeStorePropertyDefinition == null)
{
throw new InvalidOperationException(ServerStrings.ExPropertyNotStreamable(propertyDefinition.ToString()));
}
Stream result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
StoreObjectStream storeObjectStream = new StoreObjectStream(this, nativeStorePropertyDefinition, openMode);
disposeGuard.Add <StoreObjectStream>(storeObjectStream);
this.listOfStreams.Add(storeObjectStream);
disposeGuard.Success();
if (openMode == PropertyOpenMode.Create || openMode == PropertyOpenMode.Modify)
{
this.TrackProperty(nativeStorePropertyDefinition, true);
}
result = storeObjectStream;
}
return(result);
}
public static void PerformActionOnNativePropertyDefinitions <T>(PropertyDependencyType targetDependencyType, ICollection <T> propertyDefinitions, Action <NativeStorePropertyDefinition> action) where T : PropertyDefinition
{
EnumValidator.AssertValid <PropertyDependencyType>(targetDependencyType);
if (propertyDefinitions == null)
{
return;
}
int actualDependencyCount = 0;
foreach (T t in propertyDefinitions)
{
PropertyDefinition propertyDefinition = t;
StorePropertyDefinition storePropertyDefinition = InternalSchema.ToStorePropertyDefinition(propertyDefinition);
storePropertyDefinition.ForEachMatch(targetDependencyType, delegate(NativeStorePropertyDefinition item)
{
action(item);
actualDependencyCount++;
});
}
int num = (propertyDefinitions.Count >= StorePropertyDefinition.dependencyEstimates.Length) ? propertyDefinitions.Count : StorePropertyDefinition.dependencyEstimates[propertyDefinitions.Count];
if (actualDependencyCount != num && propertyDefinitions.Count < StorePropertyDefinition.dependencyEstimates.Length)
{
Interlocked.Exchange(ref StorePropertyDefinition.dependencyEstimates[propertyDefinitions.Count], actualDependencyCount);
}
}
public override Stream OpenPropertyStream(PropertyDefinition propertyDefinition, PropertyOpenMode openMode)
{
base.CheckDisposed("OpenPropertyStream");
EnumValidator.AssertValid <PropertyOpenMode>(openMode);
this.OnOpenConnection();
return(this.persistablePropertyBag.OpenPropertyStream(propertyDefinition, openMode));
}
public EwsConnectionManager(ExchangePrincipal principal, OpenAsAdminOrSystemServiceBudgetTypeType budgetType, Trace tracer)
{
EnumValidator.AssertValid <OpenAsAdminOrSystemServiceBudgetTypeType>(budgetType);
this.budgetType = budgetType;
this.currentExchangePrincipal = principal;
this.Tracer = tracer;
}
private UserConfiguration(UserConfigurationName configurationName, UserConfigurationTypes type, IStorePropertyBag queryPropertyBag)
{
EnumValidator.AssertValid <UserConfigurationTypes>(type);
this.queryPropertyBag = queryPropertyBag;
StorageGlobals.TraceConstructIDisposable(this);
this.disposeTracker = this.GetDisposeTracker();
}
internal static ICollection <UserConfiguration> Find(Folder folder, string searchString, UserConfigurationSearchFlags searchFlags)
{
EnumValidator.AssertValid <UserConfigurationSearchFlags>(searchFlags);
List <UserConfiguration> list = new List <UserConfiguration>();
if (searchFlags != UserConfigurationSearchFlags.SubString && searchFlags != UserConfigurationSearchFlags.FullString && searchFlags != UserConfigurationSearchFlags.Prefix)
{
ExTraceGlobals.StorageTracer.TraceError <UserConfigurationSearchFlags>(0L, "UserConfiguration::FindItems. The search flag is not supported. searchFlags = {0}.", searchFlags);
throw new NotSupportedException(ServerStrings.ExNotSupportedConfigurationSearchFlags(searchFlags.ToString()));
}
IList <IStorePropertyBag> list2 = null;
try
{
list2 = UserConfiguration.QueryConfigurations(folder, null, new UserConfigurationName(searchString, ConfigurationNameKind.PartialName), searchFlags, StorageLimits.Instance.UserConfigurationMaxSearched + 1, new PropertyDefinition[0]);
}
catch (InvalidOperationException innerException)
{
throw new InvalidOperationException(ServerStrings.ExCannotQueryAssociatedTable, innerException);
}
if (list2.Count > StorageLimits.Instance.UserConfigurationMaxSearched)
{
ExTraceGlobals.StorageTracer.TraceError <int, int>(0L, "UserConfiguration::FindItems. There are too many user configuration objects created with the same name. Max. = {0}, Find = {1}.", StorageLimits.Instance.UserConfigurationMaxSearched, list2.Count);
throw new TooManyConfigurationObjectsException(ServerStrings.ExTooManyObjects(searchString, list2.Count, StorageLimits.Instance.UserConfigurationMaxSearched));
}
if (list2.Count > 0)
{
UserConfiguration.BuildConfigurationsFromFilterQuery(list2, folder, list);
}
return(list);
}
private static ICollection <NativeStorePropertyDefinition> GetNativePropertyDefinitions <T>(PropertyDependencyType targetDependencyType, ICollection <T> propertyDefinitions, bool hashSetOrList, Predicate <NativeStorePropertyDefinition> addToCollection) where T : PropertyDefinition
{
EnumValidator.AssertValid <PropertyDependencyType>(targetDependencyType);
if (propertyDefinitions == null)
{
return(StorePropertyDefinition.EmptyNativeStoreProperties);
}
int num = (propertyDefinitions.Count >= StorePropertyDefinition.dependencyEstimates.Length) ? propertyDefinitions.Count : StorePropertyDefinition.dependencyEstimates[propertyDefinitions.Count];
ICollection <NativeStorePropertyDefinition> collection = null;
Action <NativeStorePropertyDefinition> action;
if (hashSetOrList)
{
HashSet <NativeStorePropertyDefinition> nativePropertyDefinitionsSet = new HashSet <NativeStorePropertyDefinition>(num);
action = delegate(NativeStorePropertyDefinition item)
{
if (addToCollection == null)
{
nativePropertyDefinitionsSet.TryAdd(item);
return;
}
if (addToCollection(item))
{
nativePropertyDefinitionsSet.TryAdd(item);
}
};
collection = nativePropertyDefinitionsSet;
}
else
{
IList <NativeStorePropertyDefinition> loadList = new List <NativeStorePropertyDefinition>(num);
action = delegate(NativeStorePropertyDefinition item)
{
if (addToCollection == null)
{
loadList.Add(item);
return;
}
if (addToCollection(item))
{
loadList.Add(item);
}
};
collection = loadList;
}
foreach (T t in propertyDefinitions)
{
PropertyDefinition propertyDefinition = t;
StorePropertyDefinition storePropertyDefinition = InternalSchema.ToStorePropertyDefinition(propertyDefinition);
storePropertyDefinition.ForEachMatch(targetDependencyType, action);
}
int count = collection.Count;
if (count != num && propertyDefinitions.Count < StorePropertyDefinition.dependencyEstimates.Length)
{
Interlocked.Exchange(ref StorePropertyDefinition.dependencyEstimates[propertyDefinitions.Count], count);
}
return(collection);
}
internal OneOffParticipantEntryId(string displayName, string addressType, string address, OneOffFlag flags)
{
EnumValidator.AssertValid <OneOffFlag>(flags);
this.emailDisplayName = Util.NullIf <string>(displayName, string.Empty);
this.emailAddressType = Util.NullIf <string>(addressType, string.Empty);
this.emailAddress = Util.NullIf <string>(address, string.Empty);
this.flags = flags;
}
internal void Initialize(string itemClassPrefix, ResponseType responseType)
{
base.Initialize();
EnumValidator.AssertValid <ResponseType>(responseType);
base.LocationIdentifierHelperInstance.SetLocationIdentifier(55413U);
this[InternalSchema.ItemClass] = MeetingResponse.ItemClassFromResponseType(itemClassPrefix, responseType);
this[InternalSchema.IconIndex] = IconIndex.AppointmentMeet;
}
internal StoreParticipantEntryId(ParticipantEntryId.WabEntryFlag flags, ParticipantEntryId.Reader reader)
{
EnumValidator.AssertValid <ParticipantEntryId.WabEntryFlag>(flags);
this.isMapiPDL = StoreParticipantEntryId.WabEntryFlagToMapiPDL(flags);
this.emailAddressIndex = StoreParticipantEntryId.WabEntryFlagToEmailAddressIndex(flags);
this.ltEntryId = reader.ReadLTEntryId();
this.useWabFormat = true;
reader.EnsureEnd();
}
internal FolderCreatePropertyBag(StoreSession storeSession, StoreObjectId parentFolderId, bool isSearchFolder, CreateMode createMode, bool isSecure, ICollection <PropertyDefinition> properties) : base(storeSession, null, properties)
{
Util.ThrowOnNullArgument(storeSession, "storeSession");
Util.ThrowOnNullArgument(parentFolderId, "parentFolderId");
EnumValidator.AssertValid <CreateMode>(createMode);
this.parentFolderId = parentFolderId;
this.isSearchFolder = isSearchFolder;
this.createMode = createMode;
this.isSecure = isSecure;
}
public sealed override Stream OpenPropertyStream(PropertyDefinition propertyDefinition, PropertyOpenMode openMode)
{
EnumValidator.AssertValid <PropertyOpenMode>(openMode);
NativeStorePropertyDefinition nativeStorePropertyDefinition = propertyDefinition as NativeStorePropertyDefinition;
if (nativeStorePropertyDefinition == null)
{
throw new InvalidOperationException(ServerStrings.ExPropertyNotStreamable(propertyDefinition.ToString()));
}
return(new FolderPropertyStream(base.MapiPropertyBag, nativeStorePropertyDefinition, openMode));
}
internal void InternalSet(EmailAddressIndex key, Participant value)
{
EnumValidator.AssertValid <EmailAddressIndex>(key);
Contact.EmailAddressDictionary.Check(key);
if (value != null)
{
base[key] = value;
return;
}
base.Remove(key);
}
protected StoreObjectId(byte[] entryId, StoreObjectType itemType)
{
Util.ThrowOnNullArgument(entryId, "entryId");
EnumValidator.AssertValid <StoreObjectType>(itemType);
if (entryId.Length > 255)
{
throw new CorruptDataException(ServerStrings.ExEntryIdToLong);
}
this.EntryId = entryId;
this.SetObjectType(itemType);
this.Validate();
}
private static string EncodeReplyForwardStatus(LastAction lastAction, IconIndex iconIndex, string parentMessageItemIdBase64String)
{
EnumValidator.AssertValid <IconIndex>(iconIndex);
return(string.Format("{0}{1}{2}{3}{4}", new object[]
{
(int)lastAction,
',',
(int)iconIndex,
',',
parentMessageItemIdBase64String
}));
}
private StoreParticipantEntryId(StoreObjectId itemId, bool isMapiPDL, EmailAddressIndex emailIndex, bool useWabFormat)
{
EnumValidator.AssertValid <EmailAddressIndex>(emailIndex);
using (ParticipantEntryId.Reader reader = new ParticipantEntryId.Reader(itemId.ProviderLevelItemId))
{
this.ltEntryId = reader.ReadLTEntryId();
reader.EnsureEnd();
}
this.isMapiPDL = isMapiPDL;
this.emailAddressIndex = emailIndex;
this.useWabFormat = useWabFormat;
}
private static void Stop(AuditingOpticsLoggerType loggerType)
{
EnumValidator.AssertValid <AuditingOpticsLoggerType>(loggerType);
lock (AuditingOpticsLogger.instanceLock)
{
AuditingOpticsLoggerInstance auditingOpticsLoggerInstance = AuditingOpticsLogger.instances[(int)loggerType];
if (auditingOpticsLoggerInstance != null)
{
auditingOpticsLoggerInstance.Stop();
AuditingOpticsLogger.instances[(int)loggerType] = null;
}
}
}
internal PropertyComparisonConstraint(StorePropertyDefinition leftPropertyDefinition, StorePropertyDefinition rightPropertyDefinition, ComparisonOperator comparisonOperator) : base(new PropertyDefinition[]
{
leftPropertyDefinition,
rightPropertyDefinition
})
{
EnumValidator.AssertValid <ComparisonOperator>(comparisonOperator);
if (comparisonOperator != ComparisonOperator.Equal && comparisonOperator != ComparisonOperator.NotEqual && !typeof(IComparable).GetTypeInfo().IsAssignableFrom(leftPropertyDefinition.Type.GetTypeInfo()))
{
throw new NotSupportedException(ServerStrings.ExConstraintNotSupportedForThisPropertyType);
}
this.leftPropertyDefinition = leftPropertyDefinition;
this.rightPropertyDefinition = rightPropertyDefinition;
this.comparisonOperator = comparisonOperator;
}
internal StoreObjectId this[DefaultFolderType defaultFolderType]
{
get
{
EnumValidator.AssertValid <DefaultFolderType>(defaultFolderType);
DefaultFolder defaultFolder = this.defaultFolders[(int)defaultFolderType];
if (defaultFolder != null)
{
StoreObjectId result;
defaultFolder.TryGetFolderId(out result);
return(result);
}
return(null);
}
}
internal static IAuditingOpticsLoggerInstance GetInstance(AuditingOpticsLoggerType loggerType)
{
EnumValidator.AssertValid <AuditingOpticsLoggerType>(loggerType);
if (AuditingOpticsLogger.auditingOpticsLoggerInstanceHook.Value != null)
{
return(AuditingOpticsLogger.auditingOpticsLoggerInstanceHook.Value);
}
IAuditingOpticsLoggerInstance result;
lock (AuditingOpticsLogger.instanceLock)
{
AuditingOpticsLoggerInstance auditingOpticsLoggerInstance = AuditingOpticsLogger.instances[(int)loggerType];
if (auditingOpticsLoggerInstance == null)
{
auditingOpticsLoggerInstance = new AuditingOpticsLoggerInstance(loggerType);
AuditingOpticsLogger.instances[(int)loggerType] = auditingOpticsLoggerInstance;
}
result = auditingOpticsLoggerInstance;
}
return(result);
}
internal AuditingOpticsLoggerInstance(AuditingOpticsLoggerType loggerType)
{
EnumValidator.AssertValid <AuditingOpticsLoggerType>(loggerType);
AuditingOpticsLoggerSettings auditingOpticsLoggerSettings = AuditingOpticsLoggerSettings.Load();
if (auditingOpticsLoggerSettings.Enabled)
{
this.Enabled = true;
this.LoggerType = loggerType;
if (this.IsDebugTraceEnabled())
{
this.SafeTraceDebug(0L, "Start creating Auditing Optics log.", new object[0]);
}
this.LogSchema = new LogSchema(AuditingOpticsConstants.SoftwareName, "15.00.1497.012", this.LogTypeName, this.GetLogFields());
LogHeaderFormatter headerFormatter = new LogHeaderFormatter(this.LogSchema);
this.Logger = new Log(this.FileNamePrefix, headerFormatter, this.LogComponentName);
if (this.IsDebugTraceEnabled())
{
this.SafeTraceDebug(0L, "Start configuring the Auditing Optics log.", new object[0]);
}
this.Logger.Configure(Path.Combine(auditingOpticsLoggerSettings.DirectoryPath, this.FileNamePrefix), auditingOpticsLoggerSettings.MaxAge, (long)auditingOpticsLoggerSettings.MaxDirectorySize.ToBytes(), (long)auditingOpticsLoggerSettings.MaxFileSize.ToBytes(), (int)auditingOpticsLoggerSettings.CacheSize.ToBytes(), auditingOpticsLoggerSettings.FlushInterval, auditingOpticsLoggerSettings.FlushToDisk);
if (this.IsDebugTraceEnabled())
{
this.SafeTraceDebug(0L, "Auditing Optics log on server '{0}' is created and ready for use.", new object[]
{
this.ServerName
});
return;
}
}
else
{
this.Enabled = false;
if (this.IsDebugTraceEnabled())
{
this.SafeTraceDebug(0L, "The Auditing Optics log is disabled.", new object[0]);
}
}
}
public override Stream OpenPropertyStream(PropertyDefinition propertyDefinition, PropertyOpenMode openMode)
{
base.CheckDisposed("AcrPropertyBag::OpenPropertyStream");
EnumValidator.AssertValid <PropertyOpenMode>(openMode);
if (openMode != PropertyOpenMode.ReadOnly)
{
if (this.Mode == AcrPropertyBag.AcrMode.ReadOnly)
{
ExTraceGlobals.StorageTracer.TraceError <int, PropertyOpenMode>((long)this.GetHashCode(), "AcrPropertyBag::SetProperties {0}, OpenPropertyStream called for readonly AcrPropertyBag with opemMode = {1}", this.GetHashCode(), openMode);
throw new AccessDeniedException(ServerStrings.ExItemIsOpenedInReadOnlyMode);
}
if (!this.propertiesWrittenAsStream.ContainsKey(propertyDefinition))
{
if (this.propertyTrackingCache.ContainsKey(propertyDefinition))
{
ExTraceGlobals.StorageTracer.Information <int, string>((long)this.GetHashCode(), "AcrPropertyBag::OpenPropertyStream HashCode[{0}]: PropertyRemoved from acr {1}", this.GetHashCode(), propertyDefinition.Name);
this.propertyTrackingCache.Remove(propertyDefinition);
}
this.propertiesWrittenAsStream.Add(propertyDefinition, propertyDefinition);
}
}
return(this.propertyBag.OpenPropertyStream(propertyDefinition, openMode));
}
internal Stream OpenPropertyStream(NativeStorePropertyDefinition propertyDefinition, PropertyOpenMode openMode, bool bufferStream)
{
this.CheckDisposed("OpenPropertyStream");
EnumValidator.AssertValid <PropertyOpenMode>(openMode);
PropTag propTag = PropertyTagCache.Cache.PropTagFromPropertyDefinition(this.MapiProp, this.storeSession, propertyDefinition);
OpenPropertyFlags flags;
switch (openMode)
{
case PropertyOpenMode.ReadOnly:
flags = OpenPropertyFlags.DeferredErrors;
break;
case PropertyOpenMode.Modify:
flags = OpenPropertyFlags.Modify;
break;
case PropertyOpenMode.Create:
flags = (OpenPropertyFlags.Create | OpenPropertyFlags.Modify);
break;
default:
throw new ArgumentException(ServerStrings.ExInvalidParameter("openMode", 2), "openMode");
}
Stream stream = null;
StoreSession storeSession = this.StoreSession;
bool flag = false;
try
{
if (storeSession != null)
{
storeSession.BeginMapiCall();
storeSession.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
stream = new MapiStreamWrapper(this.MapiProp.OpenStream(propTag, flags), this.StoreSession);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.ExUnableToGetStreamProperty(propertyDefinition.Name), ex, storeSession, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("MapiPropertyBag::OpenPropertyStream. Failed to open property stream for property {0}, openMode = {1}.", propertyDefinition, openMode),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.ExUnableToGetStreamProperty(propertyDefinition.Name), ex2, storeSession, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("MapiPropertyBag::OpenPropertyStream. Failed to open property stream for property {0}, openMode = {1}.", propertyDefinition, openMode),
ex2
});
}
finally
{
try
{
if (storeSession != null)
{
storeSession.EndMapiCall();
if (flag)
{
storeSession.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
if (bufferStream)
{
stream = new PooledBufferedStream(stream, StorageLimits.Instance.PropertyStreamPageSize);
}
return(stream);
}
protected SimpleVirtualPropertyDefinition(PropertyTypeSpecifier specifiedWith, string displayName, Type propertyValueType, PropertyFlags flags, params PropertyDefinitionConstraint[] constraints) : base(specifiedWith, displayName, propertyValueType, flags, constraints)
{
EnumValidator.AssertValid <PropertyFlags>(flags);
this.hashCode = new LazilyInitialized <int>(new Func <int>(this.ComputeHashCode));
}
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);
}
internal Notification(NotificationType type)
{
EnumValidator.AssertValid <NotificationType>(type);
this.type = type;
this.createTime = Stopwatch.GetTimestamp();
}
public static void LogAuditOpticsEntry(AuditingOpticsLoggerType loggerType, List <KeyValuePair <string, object> > customData)
{
EnumValidator.AssertValid <AuditingOpticsLoggerType>(loggerType);
AuditingOpticsLogger.GetInstance(loggerType).InternalLogRow(customData);
}
internal bool IsEventRelevant(Guid mailboxGuid, MapiEventTypeFlags mapiEventType, ObjectType mapiObjectType, MapiEventFlags mapiEventFlags, MapiExtendedEventFlags mapiExtendedEventFlags, byte[] entryId, byte[] parentEntryId, byte[] oldParentEntryId, string messageClass, string containerClass)
{
EnumValidator.AssertValid <ObjectType>(mapiObjectType);
EnumValidator.AssertValid <MapiEventTypeFlags>(mapiEventType);
if (mailboxGuid != this.mailboxGuid)
{
return(false);
}
if (this.condition.EventType != EventType.None && ((this.condition.EventType & EventType.FreeBusyChanged) != EventType.FreeBusyChanged || !EventSink.HasFreeBusyChanged(messageClass, mapiEventType, mapiExtendedEventFlags)) && (mapiEventType & this.mapiEventTypes) == (MapiEventTypeFlags)0)
{
return(false);
}
if (this.condition.ObjectType != EventObjectType.None)
{
switch (this.condition.ObjectType)
{
case EventObjectType.Item:
if (mapiObjectType != ObjectType.MAPI_MESSAGE)
{
return(false);
}
break;
case EventObjectType.Folder:
if (mapiObjectType != ObjectType.MAPI_FOLDER)
{
return(false);
}
break;
}
}
if (this.condition.EventSubtree != EventSubtreeFlag.All)
{
if (this.condition.EventSubtree == EventSubtreeFlag.NonIPMSubtree && (mapiExtendedEventFlags & MapiExtendedEventFlags.NonIPMFolder) != MapiExtendedEventFlags.NonIPMFolder)
{
return(false);
}
if (this.condition.EventSubtree == EventSubtreeFlag.IPMSubtree && (mapiExtendedEventFlags & (MapiExtendedEventFlags)(-2147483648)) != (MapiExtendedEventFlags)(-2147483648))
{
return(false);
}
}
if (this.condition.EventFlags != EventFlags.None)
{
EventFlags eventFlags = ((mapiExtendedEventFlags & MapiExtendedEventFlags.NoReminderPropertyModified) == MapiExtendedEventFlags.NoReminderPropertyModified) ? EventFlags.None : EventFlags.ReminderPropertiesModified;
if ((mapiExtendedEventFlags & MapiExtendedEventFlags.TimerEventFired) == MapiExtendedEventFlags.TimerEventFired)
{
eventFlags |= EventFlags.TimerEventFired;
}
if ((eventFlags & this.condition.EventFlags) != this.condition.EventFlags)
{
return(false);
}
}
if ((mapiEventFlags & MapiEventFlags.SoftDeleted) == MapiEventFlags.SoftDeleted)
{
return(false);
}
if (this.parentEntryIds.Length != 0 || this.objectEntryIds.Length != 0)
{
bool flag = false;
bool flag2 = (mapiEventType & MapiEventTypeFlags.ObjectMoved) == MapiEventTypeFlags.ObjectMoved;
IEqualityComparer <byte[]> comparer = ArrayComparer <byte> .Comparer;
foreach (byte[] x in this.parentEntryIds)
{
if (comparer.Equals(x, parentEntryId))
{
flag = true;
break;
}
if (flag2 && comparer.Equals(x, oldParentEntryId))
{
flag = true;
break;
}
}
if (!flag)
{
foreach (byte[] x2 in this.objectEntryIds)
{
if (comparer.Equals(x2, entryId))
{
flag = true;
break;
}
}
if (!flag)
{
return(false);
}
}
}
if (this.considerClassNames)
{
string text;
if (mapiObjectType == ObjectType.MAPI_FOLDER)
{
text = containerClass;
}
else
{
text = messageClass;
}
foreach (string b in this.expectedClassNameExactMatches)
{
if (text == b)
{
return(true);
}
}
foreach (string value in this.expectedClassNamePrefixes)
{
if (text.StartsWith(value))
{
return(true);
}
}
return(false);
}
return(true);
}