public static bool IsMessage(string itemClass, bool includeCalendaringMessages = false)
{
bool flag = ObjectClass.IsOfClass(itemClass, "IPM.Note") || ObjectClass.IsOfClass(itemClass, "REPORT");
if (includeCalendaringMessages)
{
flag |= (ObjectClass.IsMeetingMessage(itemClass) || ObjectClass.IsMeetingMessageSeries(itemClass));
}
return(flag);
}
private static void CompleteFlagStatus(PropertyBag.BasicPropertyStore propertyBag)
{
string valueOrDefault = propertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
if (ObjectClass.IsMeetingMessage(valueOrDefault))
{
propertyBag.Delete(InternalSchema.MapiFlagStatus);
propertyBag.Delete(InternalSchema.ItemColor);
propertyBag.SetValueWithFixup(InternalSchema.TaskStatus, TaskStatus.Completed);
return;
}
propertyBag.SetValueWithFixup(InternalSchema.MapiFlagStatus, FlagStatus.Complete);
propertyBag.SetValueWithFixup(InternalSchema.TaskStatus, TaskStatus.Completed);
propertyBag.Delete(InternalSchema.ItemColor);
}
private static string GenerateWhen(Item item)
{
if (item is MeetingMessage)
{
return((item as MeetingMessage).GenerateWhen());
}
if (item is CalendarItemBase)
{
return((item as CalendarItemBase).GenerateWhen());
}
if (ObjectClass.IsMeetingMessage(item.ClassName))
{
return(string.Empty);
}
throw new ArgumentException("Unsupported type, this is a bug");
}
protected override object InternalTryGetValue(PropertyBag.BasicPropertyStore propertyBag)
{
bool? flag = null;
string valueOrDefault = propertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
if (ObjectClass.IsCalendarItemCalendarItemOccurrenceOrRecurrenceException(valueOrDefault) || ObjectClass.IsCalendarItemSeries(valueOrDefault))
{
AppointmentStateFlags valueOrDefault2 = propertyBag.GetValueOrDefault <AppointmentStateFlags>(InternalSchema.AppointmentStateInternal);
flag = new bool?(IsOrganizerProperty.GetForCalendarItem(valueOrDefault, valueOrDefault2));
}
else if (ObjectClass.IsMeetingMessage(valueOrDefault))
{
MeetingMessage meetingMessage = propertyBag.Context.StoreObject as MeetingMessage;
if (meetingMessage != null)
{
CalendarItemBase calendarItemBase = null;
try
{
calendarItemBase = meetingMessage.GetCorrelatedItemInternal(true);
}
catch (CorruptDataException)
{
}
catch (CorrelationFailedException)
{
}
if (calendarItemBase != null)
{
flag = new bool?(calendarItemBase.IsOrganizer());
}
else if (!(meetingMessage is MeetingResponse))
{
flag = new bool?(meetingMessage.IsMailboxOwnerTheSender());
}
}
}
if (flag != null)
{
return(flag);
}
return(new PropertyError(this, PropertyErrorCode.NotFound));
}
private static Charset GetItemOutboundMimeCharsetInternal(Item item, OutboundConversionOptions options)
{
object obj = item.TryGetProperty(InternalSchema.InternetCpid);
bool valueOrDefault = item.GetValueOrDefault <bool>(InternalSchema.IsAutoForwarded, false);
string className = item.ClassName;
Charset charset = null;
if (valueOrDefault || (obj is PropertyError && !item.Body.IsBodyDefined) || (options != null && options.DetectionOptions.PreferredCharset != null && (options.DetectionOptions.RequiredCoverage < 100 || ObjectClass.IsTaskRequest(className) || ObjectClass.IsMeetingMessage(className))))
{
charset = ConvertUtils.DetectOutboundCharset(item, options, obj, !valueOrDefault);
if (charset != null)
{
if (!item.CharsetDetector.IsItemCharsetKnownWithoutDetection(BodyCharsetFlags.DisableCharsetDetection, charset, out charset))
{
throw new InvalidOperationException();
}
return(charset);
}
}
if (!(obj is PropertyError) && Charset.TryGetCharset((int)obj, out charset) && ConvertUtils.TryTransformCharset(ref charset))
{
return(charset);
}
object obj2 = item.TryGetProperty(InternalSchema.Codepage);
if (!(obj2 is PropertyError) && Charset.TryGetCharset((int)obj2, out charset))
{
charset = charset.Culture.MimeCharset;
if (ConvertUtils.TryTransformCharset(ref charset))
{
return(charset);
}
}
return(Charset.GetCharset(65001));
}
internal static Charset GetItemOutboundMimeCharset(Item item, OutboundConversionOptions options)
{
Charset charset = ConvertUtils.GetItemOutboundMimeCharsetInternal(item, options);
string className = item.ClassName;
if (options.DetectionOptions.PreferredCharset == null && charset.CodePage != 54936 && (ObjectClass.IsTaskRequest(className) || ObjectClass.IsMeetingMessage(className) || ObjectClass.IsCalendarItem(className)))
{
charset = Charset.GetCharset(65001);
}
return(charset);
}
public static void CreateForwardReplyHeader(ReplyForwardConfiguration configuration, Item item, ForwardReplyHeaderOptions headerOptions = null)
{
if (!(item is MessageItem) && !(item is CalendarItemBase) && !(item is PostItem))
{
throw new ArgumentException("HTML reply forward headers can only be created for MessageItem, CalendarItemBase and PostItem");
}
if (headerOptions == null)
{
headerOptions = new ForwardReplyHeaderOptions();
}
CultureInfo cultureInfo = configuration.Culture ?? item.Session.InternalCulture;
if (item is PostItem)
{
ReplyForwardHeader.CreatePostReplyForwardHeader(configuration, item, headerOptions, cultureInfo);
}
IList <IRecipientBase> toRecipients = null;
IList <IRecipientBase> ccRecipients = null;
string from = string.Empty;
string sender = null;
string fromLabel = ClientStrings.FromColon.ToString(cultureInfo);
string toLabel = ClientStrings.ToColon.ToString(cultureInfo);
string ccLabel = ClientStrings.CcColon.ToString(cultureInfo);
bool isMeetingItem = ObjectClass.IsMeetingMessage(item.ClassName);
if (item is MessageItem)
{
MessageItem messageItem = (MessageItem)item;
if (messageItem.From != null)
{
from = messageItem.From.DisplayName;
}
if (messageItem.Sender != null)
{
sender = messageItem.Sender.DisplayName;
}
toRecipients = ReplyForwardHeader.GetMessageRecipientCollection(RecipientItemType.To, messageItem);
ccRecipients = ReplyForwardHeader.GetMessageRecipientCollection(RecipientItemType.Cc, messageItem);
}
else if (item is CalendarItemBase)
{
CalendarItemBase calendarItemBase = (CalendarItemBase)item;
if (calendarItemBase.Organizer != null)
{
from = calendarItemBase.Organizer.DisplayName;
}
toRecipients = ReplyForwardHeader.GetCalendarItemRecipientCollection(AttendeeType.Required, calendarItemBase);
ccRecipients = ReplyForwardHeader.GetCalendarItemRecipientCollection(AttendeeType.Optional, calendarItemBase);
}
BodyInjectionFormat bodyPrefixFormat;
string bodyPrefix;
switch (configuration.TargetFormat)
{
case BodyFormat.TextPlain:
bodyPrefixFormat = BodyInjectionFormat.Text;
bodyPrefix = ReplyForwardHeader.CreateTextReplyForwardHeader(item, headerOptions, fromLabel, from, sender, toLabel, ccLabel, toRecipients, ccRecipients, isMeetingItem, cultureInfo, configuration.TimeZone);
break;
case BodyFormat.TextHtml:
case BodyFormat.ApplicationRtf:
bodyPrefixFormat = BodyInjectionFormat.Html;
bodyPrefix = ReplyForwardHeader.CreateHtmlReplyForwardHeader(item, headerOptions, fromLabel, from, sender, toLabel, ccLabel, toRecipients, ccRecipients, isMeetingItem, cultureInfo, configuration.TimeZone);
break;
default:
throw new ArgumentException("Unsupported body format");
}
configuration.AddBodyPrefix(bodyPrefix, bodyPrefixFormat);
}
private void WriteRecipientTable()
{
if (this.tnefType != TnefType.LegacyTnef || this.isEmbeddedItem)
{
this.tnefWriter.StartAttribute(TnefAttributeTag.RecipientTable, TnefAttributeLevel.Message);
List <ConversionRecipientEntry> recipients = this.addressCache.Recipients;
if (recipients != null)
{
this.conversionResult.RecipientCount = recipients.Count;
foreach (ConversionRecipientEntry conversionRecipientEntry in recipients)
{
if (!(this.item is MessageItem) || this.options.DemoteBcc || conversionRecipientEntry.RecipientItemType != RecipientItemType.Bcc || ((conversionRecipientEntry.Participant.GetValueOrDefault <bool>(ParticipantSchema.IsRoom, false) || conversionRecipientEntry.Participant.GetValueOrDefault <bool>(ParticipantSchema.IsResource, false)) && ObjectClass.IsMeetingMessage(this.item.ClassName)))
{
this.WriteRecipient(conversionRecipientEntry);
}
}
}
}
}
internal override StoreObjectValidationError Validate(ValidationContext context, IValidatablePropertyBag validatablePropertyBag)
{
string text = validatablePropertyBag.TryGetProperty(InternalSchema.ItemClass) as string;
if (!string.IsNullOrEmpty(text) && (ObjectClass.IsCalendarItem(text) || ObjectClass.IsRecurrenceException(text) || ObjectClass.IsMeetingMessage(text)) && validatablePropertyBag.IsPropertyDirty(InternalSchema.AppointmentStateInternal))
{
object obj = validatablePropertyBag.TryGetProperty(InternalSchema.AppointmentStateInternal);
if (obj is int)
{
AppointmentStateFlags appointmentStateFlags = (AppointmentStateFlags)obj;
if (EnumValidator <AppointmentStateFlags> .IsValidValue(appointmentStateFlags))
{
PropertyValueTrackingData originalPropertyInformation = validatablePropertyBag.GetOriginalPropertyInformation(InternalSchema.AppointmentStateInternal);
if (originalPropertyInformation.PropertyValueState == PropertyTrackingInformation.Modified && originalPropertyInformation.OriginalPropertyValue != null && !PropertyError.IsPropertyNotFound(originalPropertyInformation.OriginalPropertyValue))
{
AppointmentStateFlags appointmentStateFlags2 = (AppointmentStateFlags)originalPropertyInformation.OriginalPropertyValue;
bool flag = (appointmentStateFlags2 & AppointmentStateFlags.Received) == AppointmentStateFlags.None;
bool flag2 = (appointmentStateFlags & AppointmentStateFlags.Received) == AppointmentStateFlags.None;
if (flag != flag2)
{
return(new StoreObjectValidationError(context, InternalSchema.AppointmentStateInternal, obj, this));
}
}
}
}
}
return(null);
}
private ConflictResolutionResult ApplyAcr(PropertyBag acrPropBag, SaveMode saveMode)
{
Dictionary <PropertyDefinition, AcrPropertyProfile.ValuesToResolve> valuesToResolve = this.GetValuesToResolve(acrPropBag);
string valueOrDefault = this.PropertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
if (ObjectClass.IsCalendarItemCalendarItemOccurrenceOrRecurrenceException(valueOrDefault) || ObjectClass.IsMeetingMessage(valueOrDefault))
{
LocationIdentifierHelper locationIdentifierHelper = new LocationIdentifierHelper();
AcrPropertyProfile.ValuesToResolve valuesToResolve2;
object serverValue;
if (valuesToResolve.TryGetValue(InternalSchema.ChangeList, out valuesToResolve2))
{
locationIdentifierHelper.ChangeBuffer = (byte[])valuesToResolve2.ClientValue;
serverValue = valuesToResolve2.ServerValue;
}
else
{
serverValue = new PropertyError(InternalSchema.ChangeList, PropertyErrorCode.NotFound);
}
locationIdentifierHelper.SetLocationIdentifier(53909U, LastChangeAction.AcrPerformed);
valuesToResolve2 = new AcrPropertyProfile.ValuesToResolve(locationIdentifierHelper.ChangeBuffer, serverValue, null);
valuesToResolve[InternalSchema.ChangeList] = valuesToResolve2;
}
ConflictResolutionResult conflictResolutionResult = this.profile.ResolveConflicts(valuesToResolve);
if (this.propertiesWrittenAsStream.Count > 0)
{
List <PropertyConflict> list = new List <PropertyConflict>(conflictResolutionResult.PropertyConflicts);
foreach (PropertyDefinition propertyDefinition in this.propertiesWrittenAsStream.Keys)
{
PropertyConflict item = new PropertyConflict(propertyDefinition, null, null, null, null, false);
list.Add(item);
}
conflictResolutionResult = new ConflictResolutionResult(SaveResult.IrresolvableConflict, list.ToArray());
}
if (this.irresolvableChanges || saveMode == SaveMode.FailOnAnyConflict)
{
conflictResolutionResult = new ConflictResolutionResult(SaveResult.IrresolvableConflict, conflictResolutionResult.PropertyConflicts);
}
if (conflictResolutionResult.SaveStatus != SaveResult.IrresolvableConflict)
{
List <PropertyDefinition> list2 = new List <PropertyDefinition>();
List <PropertyDefinition> list3 = new List <PropertyDefinition>();
List <object> list4 = new List <object>();
if (this.propertyBag == acrPropBag)
{
foreach (PropertyConflict propertyConflict in conflictResolutionResult.PropertyConflicts)
{
if (propertyConflict.ResolvedValue is PropertyError)
{
if (PropertyError.IsPropertyNotFound(propertyConflict.ResolvedValue) && (!PropertyError.IsPropertyError(propertyConflict.ClientValue) || !PropertyError.IsPropertyNotFound(propertyConflict.ClientValue)))
{
list2.Add(propertyConflict.PropertyDefinition);
}
}
else if (propertyConflict.ResolvedValue != propertyConflict.ClientValue)
{
list3.Add(propertyConflict.PropertyDefinition);
list4.Add(propertyConflict.ResolvedValue);
}
}
}
else
{
foreach (PropertyConflict propertyConflict2 in conflictResolutionResult.PropertyConflicts)
{
if (propertyConflict2.ResolvedValue is PropertyError)
{
if (PropertyError.IsPropertyNotFound(propertyConflict2.ResolvedValue))
{
list2.Add(propertyConflict2.PropertyDefinition);
}
}
else if (propertyConflict2.ServerValue != propertyConflict2.ResolvedValue)
{
list3.Add(propertyConflict2.PropertyDefinition);
list4.Add(propertyConflict2.ResolvedValue);
}
}
}
for (int k = 0; k < list2.Count; k++)
{
acrPropBag.Delete(list2[k]);
}
for (int l = 0; l < list3.Count; l++)
{
acrPropBag[list3[l]] = list4[l];
}
}
return(conflictResolutionResult);
}
public static MessageItem CreateForward(MessageItem originalItem, bool asAttachment, CultureInfo culture, string imceaDomain, string xLoop, ExTimeZone timeZone, IRuleEvaluationContext context)
{
Util.ThrowOnNullArgument(originalItem, "originalItem");
Util.ThrowOnNullArgument(culture, "culture");
Util.ThrowOnNullOrEmptyArgument(imceaDomain, "imceaDomain");
ExTraceGlobals.StorageTracer.Information(0L, "RuleMessageUtils::CreateForward.");
MessageItem messageItem = null;
bool flag = false;
MessageItem result;
try
{
ForwardCreationFlags forwardCreationFlags = ForwardCreationFlags.None;
string className = originalItem.ClassName;
if (ObjectClass.IsMeetingMessage(className))
{
forwardCreationFlags |= ForwardCreationFlags.TreatAsMeetingMessage;
}
messageItem = context.CreateMessageItem(InternalSchema.ContentConversionProperties);
messageItem[InternalSchema.ItemClass] = "IPM.Note";
StoreSession storeSession = context.StoreSession ?? originalItem.Session;
if (asAttachment)
{
ForwardAsAttachmentCreation forwardAsAttachmentCreation = new ForwardAsAttachmentCreation(originalItem, messageItem, new ReplyForwardConfiguration(forwardCreationFlags, culture)
{
XLoop = xLoop,
TimeZone = timeZone,
ConversionOptionsForSmime = new InboundConversionOptions(storeSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid), imceaDomain)
});
forwardAsAttachmentCreation.PopulateProperties();
}
else
{
bool flag2 = ObjectClass.IsMeetingCancellation(className);
bool flag3 = ObjectClass.IsMeetingRequest(className);
bool isRestricted = originalItem.IsRestricted;
if (flag2)
{
messageItem[InternalSchema.ItemClass] = "IPM.Schedule.Meeting.Canceled";
messageItem[InternalSchema.IconIndex] = IconIndex.AppointmentMeetCancel;
}
else if (flag3)
{
messageItem[InternalSchema.ItemClass] = "IPM.Schedule.Meeting.Request";
messageItem[InternalSchema.IsResponseRequested] = true;
messageItem[InternalSchema.IsReplyRequested] = true;
}
else if (isRestricted)
{
messageItem[StoreObjectSchema.ContentClass] = "rpmsg.message";
messageItem.IconIndex = IconIndex.MailIrm;
}
BodyFormat format = originalItem.Body.Format;
ReplyForwardConfiguration replyForwardConfiguration = new ReplyForwardConfiguration(format, forwardCreationFlags, culture);
replyForwardConfiguration.XLoop = xLoop;
replyForwardConfiguration.TimeZone = timeZone;
replyForwardConfiguration.ConversionOptionsForSmime = new InboundConversionOptions(storeSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid), imceaDomain);
RuleMessageUtils.GenerateHeader(replyForwardConfiguration, originalItem);
ForwardCreation forwardCreation = new ForwardCreation(originalItem, messageItem, replyForwardConfiguration);
forwardCreation.PopulateProperties();
if (flag2 || flag3)
{
AppointmentStateFlags appointmentStateFlags = messageItem.GetValueOrDefault <AppointmentStateFlags>(InternalSchema.AppointmentState);
appointmentStateFlags |= (AppointmentStateFlags.Meeting | AppointmentStateFlags.Received);
messageItem[InternalSchema.AppointmentState] = appointmentStateFlags;
int num = messageItem.GetValueOrDefault <int>(InternalSchema.AppointmentAuxiliaryFlags, 0);
num |= 4;
messageItem[InternalSchema.AppointmentAuxiliaryFlags] = num;
if (flag3)
{
List <BlobRecipient> list = BlobRecipientParser.ReadRecipients(originalItem, InternalSchema.UnsendableRecipients);
list = MeetingRequest.FilterBlobRecipientList(list);
list = MeetingRequest.MergeRecipientLists(originalItem.Recipients, list);
list = MeetingRequest.FilterBlobRecipientList(list);
BlobRecipientParser.WriteRecipients(messageItem, InternalSchema.UnsendableRecipients, list);
}
}
}
flag = true;
result = messageItem;
}
finally
{
if (!flag && messageItem != null)
{
messageItem.Dispose();
messageItem = null;
}
}
return(result);
}
private static OutlookModule GetModuleForObjectClass(string objectClass)
{
if (objectClass == null)
{
return(OutlookModule.None);
}
if (ObjectClass.IsCalendarFolder(objectClass) || ObjectClass.IsCalendarItem(objectClass))
{
return(OutlookModule.Calendar);
}
if (ObjectClass.IsContactsFolder(objectClass) || ObjectClass.IsContact(objectClass) || ObjectClass.IsDistributionList(objectClass))
{
return(OutlookModule.Contacts);
}
if (ObjectClass.IsJournalFolder(objectClass) || ObjectClass.IsJournalItem(objectClass))
{
return(OutlookModule.Journal);
}
if (ObjectClass.IsNotesFolder(objectClass) || ObjectClass.IsNotesItem(objectClass))
{
return(OutlookModule.Notes);
}
if (ObjectClass.IsTaskFolder(objectClass) || ObjectClass.IsTask(objectClass))
{
return(OutlookModule.Tasks);
}
if (ObjectClass.IsMessageFolder(objectClass) || ObjectClass.IsMessage(objectClass, false) || ObjectClass.IsMeetingMessage(objectClass) || ObjectClass.IsTaskRequest(objectClass) || ObjectClass.IsReport(objectClass))
{
return(OutlookModule.Mail);
}
return(OutlookModule.None);
}
protected override object InternalTryGetValue(PropertyBag.BasicPropertyStore propertyBag)
{
string valueOrDefault = propertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass);
if (valueOrDefault == null)
{
return(RecurrenceType.None);
}
if (ObjectClass.IsTask(valueOrDefault) || ObjectClass.IsTaskRequest(valueOrDefault))
{
if (propertyBag.GetValueOrDefault <bool>(InternalSchema.IsOneOff))
{
return(RecurrenceType.None);
}
byte[] valueOrDefault2 = propertyBag.GetValueOrDefault <byte[]>(InternalSchema.TaskRecurrence);
return(RecurrenceTypeProperty.GetTaskRecurrenceTypeFromBlob(valueOrDefault2));
}
else
{
if (ObjectClass.IsCalendarItemCalendarItemOccurrenceOrRecurrenceException(valueOrDefault) || ObjectClass.IsMeetingMessage(valueOrDefault))
{
return(propertyBag.GetValueOrDefault <RecurrenceType>(InternalSchema.MapiRecurrenceType));
}
return(RecurrenceType.None);
}
}
