internal static ReadOnlyCollection <AttachmentLink> MergeAttachmentLinks(IList <AttachmentLink> existingLinks, CoreAttachmentCollection attachments)
{
IList <AttachmentLink> list;
if (attachments != null)
{
list = ((existingLinks == null) ? new List <AttachmentLink>(attachments.Count) : new List <AttachmentLink>(existingLinks));
ICollection <PropertyDefinition> preloadProperties = new PropertyDefinition[]
{
AttachmentSchema.AttachContentId
};
using (IEnumerator <AttachmentHandle> enumerator = attachments.GetEnumerator())
{
while (enumerator.MoveNext())
{
AttachmentHandle handle = enumerator.Current;
using (CoreAttachment coreAttachment = attachments.Open(handle, preloadProperties))
{
using (Attachment attachment = AttachmentCollection.CreateTypedAttachment(coreAttachment, null))
{
if (AttachmentLink.Find(attachment.Id, list) == null)
{
AttachmentLink item = new AttachmentLink(attachment);
list.Add(item);
}
}
}
}
goto IL_C5;
}
}
list = ((existingLinks == null) ? new List <AttachmentLink>(0) : new List <AttachmentLink>(existingLinks));
IL_C5:
return(new ReadOnlyCollection <AttachmentLink>(list));
}
public static bool IsMessageOpaqueSigned(Item item)
{
Util.ThrowOnNullArgument(item, "item");
ICoreItem coreItem = item.CoreItem;
string valueOrDefault = coreItem.PropertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
if (!ObjectClass.IsSmime(valueOrDefault))
{
return(false);
}
if (coreItem.AttachmentCollection.Count != 1)
{
return(false);
}
IList <AttachmentHandle> allHandles = coreItem.AttachmentCollection.GetAllHandles();
bool result;
using (CoreAttachment coreAttachment = coreItem.AttachmentCollection.Open(allHandles[0]))
{
using (StreamAttachment streamAttachment = (StreamAttachment)AttachmentCollection.CreateTypedAttachment(coreAttachment, new AttachmentType?(AttachmentType.Stream)))
{
if (streamAttachment == null)
{
result = false;
}
else
{
result = ConvertUtils.IsMessageOpaqueSigned(coreItem, streamAttachment);
}
}
}
return(result);
}
public ItemAttachment Create(StoreObjectType type)
{
EnumValidator.ThrowIfInvalid <StoreObjectType>(type, "type");
ItemAttachment result = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
CoreAttachment coreAttachment = this.CoreAttachmentCollection.CreateItemAttachment(type);
disposeGuard.Add <CoreAttachment>(coreAttachment);
result = (ItemAttachment)AttachmentCollection.CreateTypedAttachment(coreAttachment, new AttachmentType?(AttachmentType.EmbeddedMessage));
disposeGuard.Success();
}
return(result);
}
public ItemAttachment AddExistingItem(IItem item)
{
Util.ThrowOnNullArgument(item, "item");
ItemAttachment result = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
CoreAttachment coreAttachment = this.CoreAttachmentCollection.CreateFromExistingItem(item);
disposeGuard.Add <CoreAttachment>(coreAttachment);
result = (ItemAttachment)AttachmentCollection.CreateTypedAttachment(coreAttachment, new AttachmentType?(AttachmentType.EmbeddedMessage));
disposeGuard.Success();
}
return(result);
}
public Attachment Open(AttachmentHandle handle, ICollection <PropertyDefinition> propertyDefinitions)
{
Util.ThrowOnNullArgument(handle, "handle");
Attachment result = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
CoreAttachment coreAttachment = this.CoreAttachmentCollection.Open(handle, propertyDefinitions);
disposeGuard.Add <CoreAttachment>(coreAttachment);
result = AttachmentCollection.CreateTypedAttachment(coreAttachment, null);
disposeGuard.Success();
}
return(result);
}
internal static bool IsSmimeMessage(ICoreItem coreItem, out bool isMultipartSigned, out bool isOpaqueSigned, out StreamAttachment attachment)
{
isMultipartSigned = false;
isOpaqueSigned = false;
attachment = null;
string valueOrDefault = coreItem.PropertyBag.GetValueOrDefault <string>(InternalSchema.ItemClass, string.Empty);
if (!ObjectClass.IsSmime(valueOrDefault))
{
return(false);
}
IList <AttachmentHandle> allHandles = coreItem.AttachmentCollection.GetAllHandles();
if (allHandles.Count != 1)
{
return(false);
}
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
CoreAttachment coreAttachment = coreItem.AttachmentCollection.Open(allHandles[0]);
disposeGuard.Add <CoreAttachment>(coreAttachment);
StreamAttachment streamAttachment = (StreamAttachment)AttachmentCollection.CreateTypedAttachment(coreAttachment, new AttachmentType?(AttachmentType.Stream));
if (streamAttachment == null)
{
return(false);
}
disposeGuard.Add <StreamAttachment>(streamAttachment);
if (ObjectClass.IsSmimeClearSigned(valueOrDefault))
{
isMultipartSigned = ConvertUtils.IsMessageMultipartSigned(coreItem, streamAttachment);
if (isMultipartSigned)
{
attachment = streamAttachment;
disposeGuard.Success();
return(true);
}
}
isOpaqueSigned = ConvertUtils.IsMessageOpaqueSigned(coreItem, streamAttachment);
if (isOpaqueSigned)
{
attachment = streamAttachment;
disposeGuard.Success();
return(true);
}
}
return(false);
}
public Attachment Create(AttachmentType?type, Attachment clone)
{
if (type != null)
{
EnumValidator.ThrowIfInvalid <AttachmentType>(type.Value, "type");
}
Util.ThrowOnNullArgument(clone, "clone");
Attachment result = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
CoreAttachment coreAttachment = this.CoreAttachmentCollection.InternalCreateCopy(type, clone.CoreAttachment);
disposeGuard.Add <CoreAttachment>(coreAttachment);
result = AttachmentCollection.CreateTypedAttachment(coreAttachment, type);
disposeGuard.Success();
}
return(result);
}
internal void SaveAttachment()
{
this.CheckDisposed("SaveAttachment");
if (this.attachMethod == null)
{
this.ResetAttachMethod(1);
}
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
disposeGuard.Add <CoreAttachment>(this.coreAttachment);
using (Attachment attachment = AttachmentCollection.CreateTypedAttachment(this.coreAttachment, null))
{
attachment.SaveFlags |= PropertyBagSaveFlags.IgnoreMapiComputedErrors;
attachment.Save();
}
disposeGuard.Success();
}
}
internal static void CloneAttachmentCollection(ICoreItem sourceItem, ICoreItem destinationItem)
{
foreach (AttachmentHandle handle in sourceItem.AttachmentCollection)
{
using (CoreAttachment coreAttachment = sourceItem.AttachmentCollection.Open(handle, CoreObjectSchema.AllPropertiesOnStore))
{
using (CoreAttachment coreAttachment2 = destinationItem.AttachmentCollection.CreateCopy(coreAttachment))
{
using (Attachment attachment = AttachmentCollection.CreateTypedAttachment(coreAttachment2, new AttachmentType?(coreAttachment2.AttachmentType)))
{
attachment.SaveFlags |= (coreAttachment.PropertyBag.SaveFlags | PropertyBagSaveFlags.IgnoreMapiComputedErrors);
attachment.Save();
}
}
}
}
destinationItem.AttachmentCollection.IsClonedFromAnExistingAttachmentCollection = (sourceItem.AttachmentCollection.Count > 0 && !sourceItem.AttachmentCollection.IsDirty && sourceItem.AttachmentCollection.Count == destinationItem.AttachmentCollection.Count);
}
public StreamAttachment ConvertToImageAttachment(CoreAttachmentCollection collection, ImageFormat format)
{
base.CheckDisposed("ConvertToImageAttachment");
Util.ThrowOnNullArgument(collection, "collection");
EnumValidator.ThrowIfInvalid <ImageFormat>(format);
StreamAttachment result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
CoreAttachment coreAttachment = collection.InternalCreateCopy(new AttachmentType?(AttachmentType.Stream), base.CoreAttachment);
disposeGuard.Add <CoreAttachment>(coreAttachment);
StreamAttachment streamAttachment = (StreamAttachment)AttachmentCollection.CreateTypedAttachment(coreAttachment, new AttachmentType?(AttachmentType.Stream));
disposeGuard.Add <StreamAttachment>(streamAttachment);
string text = streamAttachment.FileName;
if (string.IsNullOrEmpty(text))
{
text = Attachment.GenerateFilename();
}
string str = null;
switch (format)
{
case ImageFormat.Jpeg:
str = ".jpg";
break;
case ImageFormat.Png:
str = ".png";
break;
}
streamAttachment.FileName = text + str;
streamAttachment.ContentType = "image/jpeg";
streamAttachment.IsInline = true;
using (Stream contentStream = streamAttachment.GetContentStream(PropertyOpenMode.Create))
{
if (!this.TryConvertToImage(contentStream, ImageFormat.Jpeg))
{
ConvertUtils.SaveDefaultImage(contentStream);
}
}
disposeGuard.Success();
result = streamAttachment;
}
return(result);
}
public Attachment Create(AttachmentType type)
{
EnumValidator.ThrowIfInvalid <AttachmentType>(type, new AttachmentType[]
{
AttachmentType.Stream,
AttachmentType.EmbeddedMessage,
AttachmentType.Ole,
AttachmentType.Reference
});
Attachment result = null;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
CoreAttachment coreAttachment = this.CoreAttachmentCollection.Create(type);
disposeGuard.Add <CoreAttachment>(coreAttachment);
result = AttachmentCollection.CreateTypedAttachment(coreAttachment, new AttachmentType?(type));
disposeGuard.Success();
}
return(result);
}
internal Attachment Open(AttachmentHandle handle, AttachmentType?type, ICollection <PropertyDefinition> propertyDefinitions)
{
Util.ThrowOnNullArgument(handle, "handle");
if (type != null)
{
EnumValidator.ThrowIfInvalid <AttachmentType>(type.Value, "type");
}
Attachment attachment = null;
CoreAttachment coreAttachment = null;
try
{
coreAttachment = this.CoreAttachmentCollection.Open(handle, propertyDefinitions);
attachment = AttachmentCollection.CreateTypedAttachment(coreAttachment, type);
}
finally
{
if (attachment == null && coreAttachment != null)
{
coreAttachment.Dispose();
}
}
return(attachment);
}
public Attachment Open(AttachmentId id, ICollection <PropertyDefinition> propertyDefinitions)
{
Util.ThrowOnNullArgument(id, "id");
return(AttachmentCollection.CreateTypedAttachment(this.CoreAttachmentCollection.Open(id, propertyDefinitions), null));
}
