internal static string GetName(MapiProp mapiObject)
{
string result;
try
{
if (mapiObject == null)
{
throw new ArgumentNullException("mapiObject");
}
PropValue prop = mapiObject.GetProp(PropTag.DisplayName);
if (PropType.Error == prop.PropType)
{
result = null;
}
else
{
result = prop.GetString();
}
}
catch (MapiPermanentException)
{
result = null;
}
catch (MapiRetryableException)
{
result = null;
}
return(result);
}
// Token: 0x06000155 RID: 341 RVA: 0x00006A38 File Offset: 0x00004C38
private MailboxInformation GetMailboxInformation(PropValue[] mailboxPropValue)
{
PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(mailboxPropValue, PropTag.UserGuid);
PropValue mailboxProperty2 = MailboxTableQuery.GetMailboxProperty(mailboxPropValue, PropTag.DisplayName);
PropValue mailboxProperty3 = MailboxTableQuery.GetMailboxProperty(mailboxPropValue, PropTag.DateDiscoveredAbsentInDS);
DateTime lastLogonTime = MailboxInformation.GetLastLogonTime(mailboxPropValue);
if (mailboxProperty.PropTag != PropTag.UserGuid || mailboxProperty2.PropTag != PropTag.DisplayName)
{
return(null);
}
if (mailboxProperty3.PropTag == PropTag.DateDiscoveredAbsentInDS)
{
return(null);
}
return(MailboxInformation.Create(mailboxProperty.GetBytes(), this.Guid, mailboxProperty2.GetString(), null, mailboxPropValue, lastLogonTime, null));
}
protected override List <MailboxData> GetMailboxesForCurrentWindow(out int totalMailboxOnDatabaseCount, out int notInterestingMailboxCount, out int filteredMailboxCount, out int failedFilteringCount)
{
Guid activityId = Guid.NewGuid();
PropTag[] mailboxProperties = this.GetMailboxProperties();
PropValue[][] mailboxes = MailboxTableQuery.GetMailboxes("Client=TBA", base.DatabaseInfo, mailboxProperties);
totalMailboxOnDatabaseCount = ((mailboxes == null) ? 0 : mailboxes.Length);
notInterestingMailboxCount = 0;
filteredMailboxCount = 0;
failedFilteringCount = 0;
AssistantsLog.LogGetMailboxesQueryEvent(activityId, base.Assistant.NonLocalizedName, totalMailboxOnDatabaseCount, base.Assistant as AssistantBase);
if (mailboxes == null)
{
return(new List <MailboxData>());
}
List <MailboxInformation> list3 = new List <MailboxInformation>(mailboxes.Length);
Guid mailboxGuid = Guid.Empty;
VariantConfigurationSnapshot snapshot = VariantConfiguration.GetSnapshot(DatabaseSettingsContext.Get(base.DatabaseInfo.Guid), null, null);
TimeSpan notInterestingLogInterval = snapshot.MailboxAssistants.GetObject <IMailboxAssistantSettings>(base.AssistantType.Identifier, new object[0]).MailboxNotInterestingLogInterval;
int filteredMailboxCountLocal = 0;
int notInterestingMailboxCountLocal = 0;
string traceMessage;
foreach (PropValue[] propertiesForDelegateClosure2 in mailboxes)
{
try
{
PropValue[] propertiesForDelegateClosure = propertiesForDelegateClosure2;
List <MailboxInformation> list = list3;
base.CatchMeIfYouCan(delegate
{
PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.UserGuid);
PropValue mailboxProperty2 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.DisplayName);
string mailboxDisplayNameTracingOnlyUsage = (mailboxProperty2.IsNull() || mailboxProperty2.Value == null) ? string.Empty : mailboxProperty2.Value.ToString();
if (mailboxProperty.PropTag != PropTag.UserGuid || mailboxProperty2.PropTag != PropTag.DisplayName)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNoGuidFilter, MailboxSlaFilterReasonType.NoGuid, new object[]
{
mailboxProperty.Value
});
filteredMailboxCountLocal++;
return;
}
byte[] bytes = mailboxProperty.GetBytes();
if (bytes != null && bytes.Length == 16)
{
mailboxGuid = new Guid(bytes);
}
if (MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.DateDiscoveredAbsentInDS).PropTag == PropTag.DateDiscoveredAbsentInDS)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNotInDirectoryFilter, MailboxSlaFilterReasonType.NotInDirectory, new object[0]);
filteredMailboxCountLocal++;
return;
}
PropValue mailboxProperty3 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.MailboxMiscFlags);
MailboxMiscFlags @int = (MailboxMiscFlags)mailboxProperty3.GetInt(0);
if ((@int & MailboxMiscFlags.CreatedByMove) == MailboxMiscFlags.CreatedByMove)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxMoveDestinationFilter, MailboxSlaFilterReasonType.MoveDestination, new object[0]);
filteredMailboxCountLocal++;
return;
}
MailboxMiscFlags mailboxMiscFlags = @int & (MailboxMiscFlags.DisabledMailbox | MailboxMiscFlags.SoftDeletedMailbox | MailboxMiscFlags.MRSSoftDeletedMailbox);
if (mailboxMiscFlags != MailboxMiscFlags.None)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxInaccessibleFilter, MailboxSlaFilterReasonType.Inaccessible, new object[]
{
mailboxMiscFlags
});
filteredMailboxCountLocal++;
return;
}
IMailboxFilter mailboxFilter = this.AssistantType as IMailboxFilter;
if (mailboxFilter != null && mailboxProperty3.PropTag == PropTag.MailboxMiscFlags)
{
MailboxMiscFlags int2 = (MailboxMiscFlags)mailboxProperty3.GetInt();
bool flag = (int2 & MailboxMiscFlags.ArchiveMailbox) == MailboxMiscFlags.ArchiveMailbox;
if (flag && !mailboxFilter.MailboxType.Contains(MailboxType.Archive))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxArchiveFilter, MailboxSlaFilterReasonType.Archive, new object[0]);
filteredMailboxCountLocal++;
return;
}
}
ControlData controlData = ControlData.Empty;
if (this.AssistantType.ControlDataPropertyDefinition != null)
{
PropValue mailboxProperty4 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, (PropTag)this.AssistantType.ControlDataPropertyDefinition.PropertyTag);
if (mailboxProperty4.PropTag == (PropTag)this.AssistantType.ControlDataPropertyDefinition.PropertyTag)
{
controlData = ControlData.CreateFromByteArray(mailboxProperty4.GetBytes());
}
}
TenantPartitionHint tenantPartitionHint = null;
PropValue mailboxProperty5 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.PersistableTenantPartitionHint);
if (mailboxProperty5.PropTag == PropTag.PersistableTenantPartitionHint)
{
byte[] bytes2 = mailboxProperty5.GetBytes();
if (bytes2 != null && bytes2.Length != 0)
{
tenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(bytes2);
}
}
MailboxInformation mailboxInformation2 = MailboxInformation.Create(mailboxProperty.GetBytes(), this.DatabaseInfo.Guid, mailboxProperty2.GetString(), controlData, propertiesForDelegateClosure, MailboxInformation.GetLastLogonTime(propertiesForDelegateClosure), tenantPartitionHint);
if (!this.DatabaseInfo.IsUserMailbox(mailboxInformation2.MailboxGuid))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNotUserFilter, MailboxSlaFilterReasonType.NotUser, new object[0]);
filteredMailboxCountLocal++;
return;
}
if (mailboxInformation2.MailboxData.IsPublicFolderMailbox && (mailboxFilter == null || !mailboxFilter.MailboxType.Contains(MailboxType.PublicFolder)))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxPublicFolderFilter, MailboxSlaFilterReasonType.PublicFolder, new object[0]);
filteredMailboxCountLocal++;
return;
}
if (this.IsMailboxInDemandJob(mailboxInformation2.MailboxData))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxInDemandJobFilter, MailboxSlaFilterReasonType.InDemandJob, new object[0]);
filteredMailboxCountLocal++;
return;
}
if (this.AssistantType.MailboxExtendedProperties != null)
{
if (!this.AssistantType.IsMailboxInteresting(mailboxInformation2))
{
traceMessage = string.Format("{0}: {1} is not interesting for the assistant {2}.", this, mailboxGuid, this.Assistant.NonLocalizedName);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
DateTime utcNow = DateTime.UtcNow;
if (!this.notInterestingEventsLastLogDateTimes.ContainsKey(this.Assistant.NonLocalizedName) || utcNow - this.notInterestingEventsLastLogDateTimes[this.Assistant.NonLocalizedName] >= notInterestingLogInterval)
{
AssistantsLog.LogMailboxNotInterestingEvent(activityId, this.Assistant.NonLocalizedName, this.Assistant as AssistantBase, mailboxGuid, mailboxDisplayNameTracingOnlyUsage);
this.notInterestingEventsLastLogDateTimes[this.Assistant.NonLocalizedName] = utcNow;
}
notInterestingMailboxCountLocal++;
return;
}
}
else
{
traceMessage = string.Format("{0}: {1} mailbox properties are null, IsMailboxInteresting was not called.", this, mailboxGuid);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
}
traceMessage = string.Format("{0}: {1} is interesting for the assistant {2}.", this, mailboxGuid, this.Assistant.NonLocalizedName);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
AssistantsLog.LogMailboxInterestingEvent(activityId, this.Assistant.NonLocalizedName, this.Assistant as AssistantBase, null, mailboxGuid, mailboxDisplayNameTracingOnlyUsage);
list.Add(mailboxInformation2);
}, base.AssistantType.NonLocalizedName);
}
catch (AIException exception)
{
failedFilteringCount++;
AssistantsLog.LogErrorEnumeratingMailboxes(base.Assistant, mailboxGuid, exception, true);
}
catch (Exception exception2)
{
AssistantsLog.LogErrorEnumeratingMailboxes(base.Assistant, mailboxGuid, exception2, false);
throw;
}
}
traceMessage = string.Format("{0}: {1} mailboxes after filtering", this, list3.Count);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
if (this.firstIteration || base.AssistantType.WorkCycleCheckpoint < base.AssistantType.WorkCycle)
{
int count = list3.Count;
list3 = list3.FindAll((MailboxInformation mailbox) => DateTime.UtcNow - mailbox.LastProcessedDate > base.AssistantType.WorkCycle - base.AssistantType.WorkCycleCheckpoint);
this.firstIteration = false;
filteredMailboxCountLocal += count - list3.Count;
}
list3.Sort((MailboxInformation m1, MailboxInformation m2) => m1.LastProcessedDate.CompareTo(m2.LastProcessedDate));
List <MailboxData> list2 = new List <MailboxData>();
foreach (MailboxInformation mailboxInformation in list3)
{
list2.Add(mailboxInformation.MailboxData);
}
AssistantsLog.LogEndGetMailboxesEvent(activityId, base.Assistant.NonLocalizedName, list2.Count, base.Assistant as AssistantBase);
filteredMailboxCount = filteredMailboxCountLocal;
notInterestingMailboxCount = notInterestingMailboxCountLocal;
return(list2);
}
public static object Extract(PropValue value, MapiPropertyDefinition propertyDefinition)
{
bool isReadOnly = propertyDefinition.IsReadOnly;
Type type = propertyDefinition.Type;
Type underlyingType = Nullable.GetUnderlyingType(type);
if (null != underlyingType)
{
type = underlyingType;
}
if (propertyDefinition.PropertyTag.Id() != value.PropTag.Id())
{
throw MapiPropValueConvertor.ConstructExtractingException(value, propertyDefinition, Strings.ExceptionUnmatchedPropTag(propertyDefinition.PropertyTag.ToString(), value.PropTag.ToString()));
}
if (PropType.Binary == value.PropType)
{
if (typeof(Guid) == type)
{
return(new Guid(value.GetBytes()));
}
if (typeof(Schedule) == type)
{
return(Schedule.FromByteArray(value.GetBytes()));
}
if (typeof(MapiEntryId) == type)
{
return(new MapiEntryId(value.GetBytes()));
}
}
if (typeof(short) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <short>(isReadOnly, propertyDefinition, value.GetShortArray()));
}
return(value.GetShort());
}
else if (typeof(int) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <int>(isReadOnly, propertyDefinition, value.GetIntArray()));
}
return(value.GetInt());
}
else if (typeof(long) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <long>(isReadOnly, propertyDefinition, value.GetLongArray()));
}
return(value.GetLong());
}
else if (typeof(float) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <float>(isReadOnly, propertyDefinition, value.GetFloatArray()));
}
return(value.GetFloat());
}
else if (typeof(double) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <double>(isReadOnly, propertyDefinition, value.GetDoubleArray()));
}
return(value.GetDouble());
}
else if (typeof(DateTime) == type)
{
if (propertyDefinition.IsMultivalued)
{
DateTime[] dateTimeArray = value.GetDateTimeArray();
List <DateTime> list = new List <DateTime>(dateTimeArray.Length);
foreach (DateTime dateTime in dateTimeArray)
{
list.Add(dateTime.ToLocalTime());
}
return(new MultiValuedProperty <DateTime>(isReadOnly, propertyDefinition, list.ToArray()));
}
return(value.GetDateTime().ToLocalTime());
}
else if (typeof(bool) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <bool>(isReadOnly, propertyDefinition, value.GetBoolArray()));
}
return(value.GetBoolean());
}
else if (typeof(string) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <string>(isReadOnly, propertyDefinition, value.GetStringArray()));
}
return(value.GetString());
}
else if (typeof(Guid) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <Guid>(isReadOnly, propertyDefinition, value.GetGuidArray()));
}
return(value.GetGuid());
}
else if (typeof(byte[]) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <byte[]>(isReadOnly, propertyDefinition, value.GetBytesArray()));
}
return(value.GetBytes());
}
else
{
if (typeof(short[]) == type)
{
return(value.GetShortArray());
}
if (typeof(int[]) == type)
{
return(value.GetIntArray());
}
if (typeof(long[]) == type)
{
return(value.GetLongArray());
}
if (typeof(float[]) == type)
{
return(value.GetFloatArray());
}
if (typeof(double[]) == type)
{
return(value.GetDoubleArray());
}
if (typeof(DateTime[]) == type)
{
DateTime[] dateTimeArray2 = value.GetDateTimeArray();
List <DateTime> list2 = new List <DateTime>(dateTimeArray2.Length);
foreach (DateTime dateTime2 in dateTimeArray2)
{
list2.Add(dateTime2.ToLocalTime());
}
return(list2.ToArray());
}
if (typeof(bool[]) == type)
{
return(value.GetBoolArray());
}
if (typeof(string[]) == type)
{
return(value.GetStringArray());
}
if (typeof(Guid[]) == type)
{
return(value.GetGuidArray());
}
if (typeof(byte[][]) == type)
{
return(value.GetBytesArray());
}
if (type.IsAssignableFrom(MapiPropValueConvertor.TypeFromPropType(value.PropType, false)))
{
return(value.RawValue);
}
object result = null;
if (MapiPropValueConvertor.TryCastValueToExtract(value, type, out result))
{
return(result);
}
throw MapiPropValueConvertor.ConstructExtractingException(value, propertyDefinition, Strings.ConstantNa);
}
}
internal static PropertyValue ConvertFromMapiPropValue(PropValue mapiPropValue, int codePage)
{
PropertyValue result;
try
{
PropertyTag propertyTag = new PropertyTag((uint)mapiPropValue.PropTag);
object obj = null;
PropertyType propertyType = propertyTag.PropertyType;
if (propertyType <= PropertyType.Guid)
{
if (propertyType <= PropertyType.Object)
{
switch (propertyType)
{
case PropertyType.Null:
goto IL_2E7;
case PropertyType.Int16:
obj = mapiPropValue.GetShort();
goto IL_2E7;
case PropertyType.Int32:
obj = mapiPropValue.GetInt();
goto IL_2E7;
default:
switch (propertyType)
{
case PropertyType.Error:
obj = (ErrorCode)mapiPropValue.GetErrorValue();
goto IL_2E7;
case PropertyType.Bool:
obj = mapiPropValue.GetBoolean();
goto IL_2E7;
case PropertyType.Object:
goto IL_2E7;
}
break;
}
}
else
{
switch (propertyType)
{
case PropertyType.String8:
obj = ConvertHelper.ConvertMapiPtString8ToString8(mapiPropValue.Value, codePage);
goto IL_2E7;
case PropertyType.Unicode:
obj = mapiPropValue.GetString();
goto IL_2E7;
default:
if (propertyType == PropertyType.SysTime)
{
DateTime dateTime = mapiPropValue.GetDateTime();
obj = (ExDateTime)dateTime;
goto IL_2E7;
}
if (propertyType == PropertyType.Guid)
{
obj = mapiPropValue.GetGuid();
goto IL_2E7;
}
break;
}
}
}
else if (propertyType <= PropertyType.MultiValueUnicode)
{
if (propertyType == PropertyType.Binary)
{
obj = mapiPropValue.GetBytes();
goto IL_2E7;
}
switch (propertyType)
{
case PropertyType.MultiValueInt16:
obj = mapiPropValue.GetShortArray();
goto IL_2E7;
case PropertyType.MultiValueInt32:
obj = mapiPropValue.GetIntArray();
goto IL_2E7;
default:
switch (propertyType)
{
case PropertyType.MultiValueString8:
if (mapiPropValue.Value is string[])
{
string[] array = (string[])mapiPropValue.Value;
String8[] array2 = new String8[array.Length];
for (int i = 0; i < array.Length; i++)
{
array2[i] = ConvertHelper.ConvertMapiPtString8ToString8(array[i], codePage);
}
obj = array2;
goto IL_2E7;
}
if (mapiPropValue.Value is byte[][])
{
byte[][] array3 = (byte[][])mapiPropValue.Value;
String8[] array4 = new String8[array3.Length];
for (int j = 0; j < array3.Length; j++)
{
array4[j] = ConvertHelper.ConvertMapiPtString8ToString8(array3[j], codePage);
}
obj = array4;
goto IL_2E7;
}
goto IL_2E7;
case PropertyType.MultiValueUnicode:
obj = mapiPropValue.GetStringArray();
goto IL_2E7;
}
break;
}
}
else if (propertyType != PropertyType.MultiValueSysTime)
{
if (propertyType == PropertyType.MultiValueGuid)
{
obj = mapiPropValue.GetGuidArray();
goto IL_2E7;
}
if (propertyType == PropertyType.MultiValueBinary)
{
obj = mapiPropValue.GetBytesArray();
goto IL_2E7;
}
}
else
{
DateTime[] dateTimeArray = mapiPropValue.GetDateTimeArray();
if (dateTimeArray != null)
{
ExDateTime[] array5 = new ExDateTime[dateTimeArray.Length];
for (int k = 0; k < dateTimeArray.Length; k++)
{
array5[k] = (ExDateTime)dateTimeArray[k];
}
obj = array5;
goto IL_2E7;
}
goto IL_2E7;
}
throw new NspiException(NspiStatus.InvalidParameter, string.Format("Unable to convert unsupported property type {0} on property {1}.", propertyTag.PropertyType, propertyTag));
IL_2E7:
if (obj == null)
{
result = PropertyValue.NullValue(propertyTag);
}
else
{
result = new PropertyValue(propertyTag, obj);
}
}
catch (InvalidPropertyValueTypeException inner)
{
throw new NspiException(NspiStatus.InvalidParameter, string.Format("Unable to convert invalid PropValue on property {0}.", mapiPropValue), inner);
}
catch (NotSupportedException inner2)
{
throw new NspiException(NspiStatus.InvalidParameter, string.Format("Unable to convert invalid PropValue as it contains unsupported PropType on property {0}.", mapiPropValue), inner2);
}
return(result);
}
public static T GetValue <T>(PropValue pv, T defaultValue)
{
object obj = null;
PropType propType = pv.PropType;
if (propType <= PropType.String)
{
if (propType != PropType.Int)
{
if (propType != PropType.Boolean)
{
if (propType == PropType.String)
{
obj = pv.GetString();
}
}
else
{
obj = pv.GetBoolean();
}
}
else
{
obj = pv.GetInt();
}
}
else if (propType != PropType.SysTime)
{
if (propType != PropType.Guid)
{
if (propType == PropType.Binary)
{
obj = pv.GetBytes();
if (typeof(T) == typeof(Guid))
{
byte[] array = obj as byte[];
if (array != null && array.Length == 16)
{
obj = new Guid(array);
}
else
{
obj = null;
}
}
}
}
else
{
obj = pv.GetGuid();
}
}
else
{
obj = pv.GetDateTime();
}
if (obj == null)
{
return(defaultValue);
}
T result;
try
{
result = (T)((object)obj);
}
catch (InvalidCastException)
{
result = defaultValue;
}
return(result);
}