private static object GetMapiValueFromValue(StoreSession session, ExTimeZone timeZone, object value)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(timeZone, "timeZone");
if (value is PropertyError)
{
throw new ArgumentException(string.Format("We should never need to translate a PropertyError into mapi.net, because it makes no sense to set an error. PropertyError found = {0}.", value));
}
QueryFilter queryFilter = value as QueryFilter;
if (queryFilter != null)
{
return(FilterRestrictionConverter.CreateRestriction(session, timeZone, session.Mailbox.MapiStore, queryFilter));
}
RuleAction[] array = value as RuleAction[];
if (array != null)
{
RuleAction[] array2 = new RuleAction[array.Length];
for (int i = 0; i < array2.Length; i++)
{
array2[i] = RuleActionConverter.ConvertRuleAction(session, timeZone, array[i]);
}
return(array2);
}
return(ExTimeZoneHelperForMigrationOnly.ToLegacyUtcIfDateTime(timeZone, value));
}
private void WriteTnefWriterPropertyValue(TnefPropertyTag propertyTag, object propertyValue)
{
TnefPropertyType tnefType = propertyTag.TnefType;
if (tnefType == TnefPropertyType.AppTime || tnefType == (TnefPropertyType)4103)
{
DateTime dateTime = (DateTime)Util.Date1601Utc.ToUtc();
try
{
dateTime = ConvertUtils.GetDateTimeFromOADate((double)propertyValue);
}
catch (ArgumentException arg)
{
StorageGlobals.ContextTraceError <double, ArgumentException>(ExTraceGlobals.CcOutboundTnefTracer, "TnefContentWriter::WriteTnefWriterPropertyValue: ArgumentException processing date {0}, {1}.", (double)propertyValue, arg);
}
propertyValue = dateTime;
}
propertyValue = ExTimeZoneHelperForMigrationOnly.ToLegacyUtcIfDateTime(propertyValue);
if (propertyValue is DateTime)
{
DateTime dateTime2 = (DateTime)propertyValue;
if ((ExDateTime)dateTime2 < Util.Date1601Utc)
{
propertyValue = (DateTime)Util.Date1601Utc;
}
}
this.tnefWriter.WritePropertyValue(propertyValue);
}
private long WriteAttachmentProperties(Attachment attachment)
{
long result = 0L;
this.tnefWriter.StartAttribute(TnefAttributeTag.Attachment, TnefAttributeLevel.Attachment);
foreach (NativeStorePropertyDefinition nativeStorePropertyDefinition in attachment.AllNativeProperties)
{
if (nativeStorePropertyDefinition.Equals(InternalSchema.AttachDataObj))
{
result = this.WriteAttachDataObj(attachment);
}
else if (!nativeStorePropertyDefinition.Equals(InternalSchema.AttachDataBin) && this.propertyChecker.IsAttachmentPropertyWritable(nativeStorePropertyDefinition))
{
object obj = attachment.TryGetProperty(nativeStorePropertyDefinition);
PropertyError propertyError = obj as PropertyError;
if (propertyError != null && PropertyError.IsPropertyValueTooBig(propertyError))
{
this.WritePropertyStreamData(attachment.PropertyBag, nativeStorePropertyDefinition);
}
else if (propertyError == null)
{
obj = ExTimeZoneHelperForMigrationOnly.ToLegacyUtcIfDateTime(obj);
this.tnefWriter.WriteProperty(nativeStorePropertyDefinition, obj);
}
}
}
ItemAttachment itemAttachment = attachment as ItemAttachment;
if (itemAttachment != null)
{
result = this.WriteAttachedItem(itemAttachment);
}
return(result);
}
private void InternalSetValidatedStoreProperty(PropertyDefinition propertyDefinition, object value)
{
this.EnsureInternalDataStructuresAllocated(8);
Array array = value as Array;
if (array != null)
{
value = MemoryPropertyBag.ClonePropertyValue <Array>(array);
}
else if (value is DateTime)
{
ExTimeZoneHelperForMigrationOnly.CheckValidationLevel(false, ExTimeZoneHelperForMigrationOnly.ValidationLevel.Low, "MemoryPropertyBag.InternalSetValidatedStoreProperty: System.DateTime", new object[0]);
value = new ExDateTime(this.ExTimeZone, (DateTime)value);
}
else if (value is ExDateTime)
{
((ExDateTime)value).CheckExpectedTimeZone(this.ExTimeZone, ExTimeZoneHelperForMigrationOnly.ValidationLevel.High);
value = this.ExTimeZone.ConvertDateTime((ExDateTime)value);
}
object originalValue = null;
StorePropertyDefinition storePropertyDefinition = InternalSchema.ToStorePropertyDefinition(propertyDefinition);
bool flag = (storePropertyDefinition.PropertyFlags & PropertyFlags.TrackChange) == PropertyFlags.TrackChange;
if (!(value is PropertyError) && flag && this.propertyValues.ContainsKey(propertyDefinition))
{
originalValue = this.propertyValues[propertyDefinition];
}
this.propertyValues[propertyDefinition] = value;
if (this.deletedProperties != null)
{
this.deletedProperties.Remove(propertyDefinition);
}
this.ChangedProperties.TryAdd(propertyDefinition);
this.AddTrackingInformation(storePropertyDefinition, PropertyTrackingInformation.Modified, originalValue);
}
private void WriteProperty(NativeStorePropertyDefinition property, object value)
{
value = ExTimeZoneHelperForMigrationOnly.ToLegacyUtcIfDateTime(value);
switch (property.SpecifiedWith)
{
case PropertyTypeSpecifier.PropertyTag:
{
PropertyTagPropertyDefinition propertyTagPropertyDefinition = (PropertyTagPropertyDefinition)property;
TnefPropertyTag propertyTag = (int)propertyTagPropertyDefinition.PropertyTag;
this.PropertyWriter.WriteProperty(propertyTag, value);
return;
}
case PropertyTypeSpecifier.GuidString:
{
GuidNamePropertyDefinition guidNamePropertyDefinition = (GuidNamePropertyDefinition)property;
TnefPropertyType propertyType = (TnefPropertyType)guidNamePropertyDefinition.MapiPropertyType;
this.PropertyWriter.WriteProperty(guidNamePropertyDefinition.Guid, guidNamePropertyDefinition.PropertyName, propertyType, value);
return;
}
case PropertyTypeSpecifier.GuidId:
{
GuidIdPropertyDefinition guidIdPropertyDefinition = (GuidIdPropertyDefinition)property;
TnefPropertyType propertyType2 = (TnefPropertyType)guidIdPropertyDefinition.MapiPropertyType;
this.PropertyWriter.WriteProperty(guidIdPropertyDefinition.Guid, guidIdPropertyDefinition.Id, propertyType2, value);
return;
}
default:
throw new InvalidOperationException(string.Format("Invalid native property specifier: {0}", property.SpecifiedWith));
}
}
protected override object ReadValue()
{
if (this.IsLargeValue())
{
StorageGlobals.ContextTraceError(ExTraceGlobals.CcInboundTnefTracer, "InboundMsgConverter::ReadValue: large property value");
throw new ConversionFailedException(ConversionFailureReason.CorruptContent);
}
return(ExTimeZoneHelperForMigrationOnly.ToExDateTimeIfObjectIsDateTime(this.PropertyReader.ReadValue()));
}
public EndDateRecurrenceRange(ExDateTime startDate, ExDateTime endDate)
{
ExTimeZoneHelperForMigrationOnly.CheckValidationLevel(startDate.TimeZone == endDate.TimeZone, ExTimeZoneHelperForMigrationOnly.ValidationLevel.Mid, "EndDateRecurrenceRange constructor.\nstartDate.TimeZone={0}\nendDateTime.TimeZone={1}", new object[]
{
startDate.TimeZone,
endDate.TimeZone
});
this.StartDate = startDate;
this.EndDate = endDate;
}
private bool WriteRecipientProperty(ConversionRecipientEntry recipient, NativeStorePropertyDefinition property)
{
object obj = recipient.TryGetProperty(property);
if (!PropertyError.IsPropertyError(obj))
{
obj = ExTimeZoneHelperForMigrationOnly.ToLegacyUtcIfDateTime(obj);
this.tnefWriter.WriteProperty(property, obj);
return(true);
}
return(false);
}
protected override void SetValidatedStoreProperty(StorePropertyDefinition propertyDefinition, object propertyValue)
{
SchemaConverter.Setter setter = this.schemaConverter.GetSetter(propertyDefinition);
if (!this.isReadOnly && setter != null)
{
setter((IPropertyBag)this.underlyingPropertyBag, ExTimeZoneHelperForMigrationOnly.ToUtcIfDateTime(propertyValue));
return;
}
throw PropertyError.ToException(new PropertyError[]
{
new PropertyError(propertyDefinition, PropertyErrorCode.NotSupported)
});
}
protected override object TryGetStoreProperty(StorePropertyDefinition propertyDefinition)
{
SchemaConverter.Getter getter = this.schemaConverter.GetGetter(propertyDefinition);
if (getter != null)
{
object obj = getter(this.underlyingPropertyBag);
if (obj is PropertyErrorCode)
{
obj = new PropertyError(propertyDefinition, (PropertyErrorCode)obj);
}
return(ExTimeZoneHelperForMigrationOnly.ToExDateTimeIfObjectIsDateTime(this.exTimeZone, obj));
}
return(new PropertyError(propertyDefinition, PropertyErrorCode.NotSupported));
}
private object ReadSingleValue()
{
TnefPropertyType tnefType = this.PropertyReader.PropertyTag.TnefType;
if (tnefType == TnefPropertyType.AppTime || tnefType == (TnefPropertyType)4103)
{
double num = 0.0;
DateTime dateTime = this.PropertyReader.ReadValueAsDateTime();
try
{
num = ConvertUtils.GetOADate(dateTime);
}
catch (OverflowException arg)
{
StorageGlobals.ContextTraceError <DateTime, OverflowException>(ExTraceGlobals.CcInboundTnefTracer, "InboundTnefConverter::ReadPropertyReaderValue: OverflowException processing date {0}, {1}.", dateTime, arg);
}
return(num);
}
return(ExTimeZoneHelperForMigrationOnly.ToExDateTimeIfObjectIsDateTime(this.PropertyReader.ReadValue()));
}
public static ExTimeZone GetExTimeZoneFromItem(Item item)
{
ExTimeZone exTimeZone = TimeZoneHelper.GetRecurringTimeZoneFromPropertyBag(item.PropertyBag);
if (exTimeZone == null)
{
exTimeZone = TimeZoneHelper.GetTimeZoneFromProperties("Customized Time Zone", null, item.GetValueOrDefault <byte[]>(InternalSchema.TimeZoneDefinitionStart));
}
if (exTimeZone == null)
{
if (item.Session != null && item.Session.ExTimeZone != ExTimeZone.UtcTimeZone)
{
exTimeZone = item.Session.ExTimeZone;
}
else
{
ExTimeZoneHelperForMigrationOnly.CheckValidationLevel(false, ExTimeZoneHelperForMigrationOnly.ValidationLevel.Low, "TimeZoneHelper.GetTimeZoneFromItem: no time zone", new object[0]);
exTimeZone = ExTimeZone.CurrentTimeZone;
}
}
return(exTimeZone);
}
private static void WriteRecipient(BinaryWriter writer, BlobRecipient recipient)
{
List <PropValue> list = new List <PropValue>(recipient.PropertyValues.Count);
foreach (PropValue item in PropValue.ConvertEnumerator <PropertyDefinition>(recipient.PropertyValues))
{
if (!PropertyError.IsPropertyError(item.Value) && !((PropTag)((PropertyTagPropertyDefinition)item.Property).PropertyTag).IsNamedProperty())
{
list.Add(item);
}
}
uint count = (uint)list.Count;
uint value = 0U;
writer.Write(count);
writer.Write(value);
foreach (PropValue propValue in list)
{
PropertyTagPropertyDefinition propertyTagPropertyDefinition = (PropertyTagPropertyDefinition)propValue.Property;
object value2 = ExTimeZoneHelperForMigrationOnly.ToUtcIfDateTime(propValue.Value);
BlobRecipientParser.WritePropValue(writer, (PropTag)propertyTagPropertyDefinition.PropertyTag, value2);
}
}
internal static object GetValueFromPropValue(StoreSession storeSession, ExTimeZone exTimeZone, StorePropertyDefinition propertyDefinition, PropValue propertyValue)
{
if (propertyValue.IsError())
{
int num = propertyValue.GetErrorValue();
if (num == -2147220732 && (propertyDefinition.SpecifiedWith == PropertyTypeSpecifier.GuidId || propertyDefinition.SpecifiedWith == PropertyTypeSpecifier.GuidString))
{
num = -2147221233;
}
return(MapiPropertyBag.CreatePropertyError(num, propertyDefinition));
}
PropType propType = propertyValue.PropTag.ValueType();
if (propType == PropType.Restriction)
{
if (storeSession == null)
{
throw new NotSupportedException("PT_RESTRICTION is not supported when we do not have a session. This very likely is an attachment.");
}
return(FilterRestrictionConverter.CreateFilter(storeSession, storeSession.Mailbox.MapiStore, (Restriction)propertyValue.Value, false));
}
else
{
if (propertyValue.Value == null)
{
return(MapiPropertyBag.CreatePropertyError(-2147221233, propertyDefinition));
}
if (propType == PropType.Actions)
{
if (storeSession == null)
{
throw new NotSupportedException("RuleAction type not supported without a session.");
}
RuleAction[] array = (RuleAction[])propertyValue.Value;
RuleAction[] array2 = new RuleAction[array.Length];
for (int i = 0; i < array2.Length; i++)
{
array2[i] = RuleActionConverter.ConvertRuleAction(storeSession, exTimeZone, array[i]);
}
return(array2);
}
else if (propType == PropType.SysTime)
{
DateTime dateTime = (DateTime)propertyValue.Value;
if (ExDateTime.IsValidDateTime(dateTime))
{
return(new ExDateTime(exTimeZone, dateTime));
}
return(MapiPropertyBag.CreatePropertyError(-2147221221, propertyDefinition));
}
else
{
if (propType == PropType.SysTimeArray)
{
DateTime[] array3 = (DateTime[])propertyValue.Value;
foreach (DateTime dateTime2 in array3)
{
if (!ExDateTime.IsValidDateTime(dateTime2))
{
return(MapiPropertyBag.CreatePropertyError(-2147221221, propertyDefinition));
}
}
return(ExTimeZoneHelperForMigrationOnly.ToExDateTimeArray(exTimeZone, array3));
}
return(propertyValue.Value);
}
}
}
internal void WritePropValue(PropTag propertyTag, object value)
{
this.WriteInt((int)propertyTag);
if (value is int)
{
this.WriteInt((int)value);
return;
}
if (value is bool)
{
this.WritePropValueBool((bool)value);
return;
}
if (value is DateTime)
{
ExTimeZoneHelperForMigrationOnly.CheckValidationLevel(false, ExTimeZoneHelperForMigrationOnly.ValidationLevel.High, "OutlookBlobWriter.WritePropValue is being passed a DateTime argument.", new object[0]);
this.WritePropValueDateTime((DateTime)value);
return;
}
if (value is DateTime[])
{
ExTimeZoneHelperForMigrationOnly.CheckValidationLevel(false, ExTimeZoneHelperForMigrationOnly.ValidationLevel.High, "OutlookBlobWriter.WritePropValue is being passed a DateTime[] argument.", new object[0]);
DateTime[] array = (DateTime[])value;
this.WriteInt(array.Length);
foreach (DateTime dateTime in array)
{
this.WritePropValueDateTime(dateTime);
}
return;
}
if (value is ExDateTime)
{
this.WritePropValueDateTime((DateTime)((ExDateTime)value));
return;
}
if (value is ExDateTime[])
{
ExDateTime[] array3 = (ExDateTime[])value;
this.WriteInt(array3.Length);
foreach (ExDateTime exDateTime in array3)
{
this.WritePropValueDateTime((DateTime)exDateTime);
}
return;
}
if (value is string)
{
this.WritePropValueString((string)value, propertyTag.ValueType());
return;
}
if (value is string[])
{
string[] array5 = (string[])value;
this.WriteInt(array5.Length);
foreach (string value2 in array5)
{
this.WritePropValueString(value2, propertyTag.ValueType());
}
return;
}
if (value is byte[])
{
byte[] array7 = (byte[])value;
this.WriteShort((short)array7.Length);
this.WriteByteArray(array7);
return;
}
if (value is byte[][])
{
byte[][] array8 = (byte[][])value;
this.WriteInt(array8.Length);
foreach (byte[] array10 in array8)
{
this.WriteInt(array10.Length);
this.WriteByteArray(array10);
}
return;
}
throw new NotSupportedException();
}
