private void ProcessClassificationsForJournalReport(StoreDriverDeliveryEventArgsImpl argsImpl)
{
ClassificationSummary classificationSummary = this.GetClassificationSummary(argsImpl);
if (classificationSummary != null && classificationSummary.IsValid && classificationSummary.IsClassified)
{
using (ItemAttachment itemAttachment = this.TryOpenFirstAttachment(argsImpl.ReplayItem) as ItemAttachment)
{
if (itemAttachment != null)
{
using (MessageItem itemAsMessage = itemAttachment.GetItemAsMessage(StoreObjectSchema.ContentConversionProperties))
{
if (itemAsMessage != null)
{
ClassificationApplicationAgent.diag.TraceDebug <string>(0L, "Promote banner for recipient {0} on embedded message of journal report", argsImpl.MailRecipient.Email.ToString());
itemAsMessage[ItemSchema.IsClassified] = classificationSummary.IsClassified;
itemAsMessage[ItemSchema.Classification] = classificationSummary.DisplayName;
itemAsMessage[ItemSchema.ClassificationDescription] = classificationSummary.RecipientDescription;
itemAsMessage[ItemSchema.ClassificationGuid] = classificationSummary.ClassificationID.ToString();
itemAsMessage[ItemSchema.ClassificationKeep] = classificationSummary.RetainClassificationEnabled;
itemAsMessage.Save(SaveMode.NoConflictResolution);
itemAttachment.Save();
}
}
}
}
}
}
private Attachment14Data CreateAttachment14Data(IAttachment attachment)
{
Attachment14Data attachment14Data = new Attachment14Data();
attachment14Data.DisplayName = attachment.Name;
attachment14Data.EstimatedDataSize = attachment.Size;
attachment14Data.IsInline = attachment.IsInline;
attachment14Data.FileReference = HttpUtility.UrlEncode(base.Item.Id + ":" + attachment.Id);
attachment14Data.Id = EntitySyncItemId.GetAttachmentId(attachment.Id);
FileAttachment fileAttachment = attachment as FileAttachment;
ItemAttachment itemAttachment = attachment as ItemAttachment;
if (fileAttachment != null)
{
attachment14Data.Method = 1;
attachment14Data.ContentId = fileAttachment.ContentId;
attachment14Data.ContentLocation = fileAttachment.ContentLocation;
if (fileAttachment.Content != null)
{
attachment14Data.EstimatedDataSize = (long)fileAttachment.Content.Length;
}
}
else
{
if (itemAttachment == null)
{
throw new ConversionException(string.Format("Attachment type \"{0}\" is not supported.", attachment.GetType().FullName));
}
attachment14Data.Method = 5;
}
return(attachment14Data);
}
public override IAttachment Read(string attachmentId)
{
IList <AttachmentId> attachmentIds = IdConverter.GetAttachmentIds(attachmentId);
IAttachment result;
using (IItem item = this.BindToParentItem())
{
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
IItem item2 = item;
Attachment attachment = null;
for (int i = 0; i < attachmentIds.Count; i++)
{
attachment = IrmUtils.GetAttachmentCollection(item2).Open(attachmentIds[i]);
disposeGuard.Add <Attachment>(attachment);
if (i < attachmentIds.Count - 1)
{
if (!(attachment is ItemAttachment))
{
throw new CorruptDataException(Strings.ErrorAllButLastNestedAttachmentMustBeItemAttachment);
}
ItemAttachment itemAttachment = attachment as ItemAttachment;
item2 = itemAttachment.GetItem();
disposeGuard.Add <IItem>(item2);
}
}
StorageTranslator <IAttachment, IAttachment> attachmentTranslator = this.GetAttachmentTranslator(attachment.AttachmentType, false);
IAttachment attachment2 = attachmentTranslator.ConvertToEntity(attachment);
attachment2.Id = attachmentId;
result = attachment2;
}
}
return(result);
}
public Signal Unpack(MessageItem mailMessage)
{
this.itemAttach = new Dictionary <Guid, byte[]>();
this.messageItemAttach = new Dictionary <Guid, MessageItem>();
foreach (AttachmentHandle handle in mailMessage.AttachmentCollection.GetHandles())
{
using (Attachment attachment = mailMessage.AttachmentCollection.Open(handle))
{
StreamAttachment streamAttachment = attachment as StreamAttachment;
if (streamAttachment != null)
{
byte[] value = Unpacker.ReadBytes(streamAttachment.GetContentStream(PropertyOpenMode.ReadOnly));
this.itemAttach.Add(new Guid(streamAttachment.FileName), value);
}
else
{
ItemAttachment itemAttachment = attachment as ItemAttachment;
if (itemAttachment != null)
{
MessageItem itemAsMessage = itemAttachment.GetItemAsMessage();
string contentId = itemAttachment.ContentId;
if (contentId != null)
{
this.messageItemAttach.Add(new Guid(contentId), itemAsMessage);
}
}
}
}
}
return(this.ReadSignal(mailMessage));
}
//gavdcodeend 15
//gavdcodebegin 16
static void CreateAndSendEmailWithAttachment(ExchangeService ExService)
{
EmailMessage newEmail = new EmailMessage(ExService)
{
Subject = "Email with Attachments",
Body = "This is an email with attachments"
};
newEmail.ToRecipients.Add("*****@*****.**");
newEmail.Attachments.AddFileAttachment(@"C:\Temporary\file_01.jpg");
newEmail.Attachments.AddFileAttachment("SecondAttachment.jpg",
@"C:\Temporary\file_01.jpg");
byte[] attBytes = File.ReadAllBytes(@"C:\Temporary\file_01.jpg");
newEmail.Attachments.AddFileAttachment("ThirdAttachment.jpg", attBytes);
ItemAttachment <EmailMessage> emailAttachment =
newEmail.Attachments.AddItemAttachment <EmailMessage>();
emailAttachment.Name = "Attached email";
emailAttachment.Item.Subject = "Attached email Subject";
emailAttachment.Item.Body = "Attached email Body";
emailAttachment.Item.ToRecipients.Add("*****@*****.**");
newEmail.SendAndSaveCopy();
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ImageData,ContentType,ItemId")] ItemAttachment itemAttachment)
{
if (id != itemAttachment.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(itemAttachment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ItemAttachmentExists(itemAttachment.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ItemId"] = new SelectList(_context.Item, "Id", "Description", itemAttachment.ItemId);
return(View(itemAttachment));
}
public void Put(int id, [FromBody] ItemAttachment attachment)
{
// TODO: Add data validation
attachment.ID = id;
db.ItemAttachments.Update(attachment);
db.SaveChanges();
}
public void Test_MessageWithEventAttachmentDeserialization()
{
string serializedMessage = @"{
""@odata.type"": ""#Microsoft.Graph.Message"",
""id"": ""msgId"",
""subject"": ""message with attachs"",
""isRead"": ""true"",
""attachments"": [
{
""@odata.type"": ""#Microsoft.Graph.ItemAttachment"",
""id"": ""itemAttachment=="",
""item"":{
""id"": ""attachmentitemId"",
""changeKey"": ""ck=="",
""subject"": ""attachment item subject"",
""@odata.type"": ""#Microsoft.Graph.Event"",
""attendees"": [
{
""emailAddress"":{
""address"": ""*****@*****.**""
}
},
{
""emailAddress"": {
""address"": ""*****@*****.**""
}
}
],
""body"": {
""Content"": ""this is event"",
""ContentType"": ""Html""
},
""start"":{
""dateTime"": ""2019-01-01T12:00:00"",
""TimeZone"": ""Pacific Standard Time""
},
""end"": {
""dateTime"": ""2019-01-01T04:00:00"",
""TimeZone"": ""Pacific Standard Time""
}
}
}
]
}";
Message msg = this.Convert <Message>(serializedMessage);
Assert.AreEqual(
1,
msg.Attachments.Count);
ItemAttachment messageAttach = (ItemAttachment)msg.Attachments[0];
Event messageAttachEvent = (Event)messageAttach.Item;
Assert.AreEqual(
2,
messageAttachEvent.Attendees.Count);
Assert.IsNotNull(messageAttachEvent.Start.DateTime);
Assert.IsNotNull(messageAttachEvent.End.DateTime);
}
private void MnuDisplayAsItem_Click(object sender, EventArgs e)
{
// Don't do anything if a content row is not selected
if (this.ContentsGrid.SelectedRows.Count == 0)
{
return;
}
Attachment attach = this.ContentsGrid.SelectedRows[0].Cells[ColNameAttachmentObj].Value as Attachment;
// If we can't get the attachment object bail out
if (attach == null)
{
return;
}
ItemAttachment itemAttachment = attach as ItemAttachment;
if (itemAttachment == null)
{
// Warn the user that an ItemAttachment is required?
return;
}
if (itemAttachment.Item == null)
{
DebugLog.WriteVerbose("Cannot display ItemAttachment.Item because ItemAttachment.Item is NULL.");
ErrorDialog.ShowWarning("Cannot display ItemAttachment.Item because ItemAttachment.Item is NULL.");
return;
}
this.PropertyDetailsGrid.LoadObject(itemAttachment.Item);
}
public void Test_InnerPropertyTracking()
{
ItemAttachment itemAttachment = new ItemAttachment()
{
Name = "Item attach",
Item = new Event()
{
Subject = "Lets meet?",
Attendees = new List <Attendee>()
{
new Attendee()
{
EmailAddress = new EmailAddress()
{
Address = "*****@*****.**"
}
}
},
Body = new ItemBody()
{
ContentType = BodyType.Html,
Content = "Meeting!"
}
}
};
Assert.AreEqual(
2,
itemAttachment.GetChangedProperties().Count());
Assert.AreEqual(
3,
itemAttachment.Item.GetChangedProperties().Count());
}
public static void Pack(Signal signal, MessageItem mailMessage)
{
List <Item> list = new List <Item>();
using (MemoryStream memoryStream = new MemoryStream())
{
using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8))
{
binaryWriter.Write(1);
list = signal.WriteObject(binaryWriter);
using (TextWriter textWriter = mailMessage.Body.OpenTextWriter(BodyFormat.TextPlain))
{
textWriter.Write(Convert.ToBase64String(memoryStream.ToArray()));
}
}
}
foreach (Item item in list)
{
ExchangeItem exchangeItem = item as ExchangeItem;
if (exchangeItem != null)
{
if (exchangeItem.Item.IsNew)
{
throw new ArgumentException("Item must be saved in order to attach.");
}
using (ItemAttachment itemAttachment = mailMessage.AttachmentCollection.AddExistingItem(exchangeItem.Item))
{
itemAttachment.ContentId = exchangeItem.AttachContentId.ToString();
itemAttachment.Save();
}
}
}
}
public void Delete(int id)
{
ItemAttachment attachment = new ItemAttachment();
attachment.ID = id;
db.ItemAttachments.Remove(attachment);
db.SaveChanges();
}
public void Test_InnerPropertyListTracking()
{
DateTime startTime = DateTimeHelper.GetFormattedDateTime();
DateTime endTime = DateTimeHelper.GetFormattedDateTime(2);
string timeZone = "Central European Standard Time";
Message msg = new Message();
msg.Subject = "Test item attachment";
ItemAttachment attach = new ItemAttachment()
{
Name = "Event Item",
Item = new Event()
{
Attendees = new List <Attendee>()
{
new Attendee()
{
EmailAddress = new EmailAddress()
{
Address = "*****@*****.**"
}
}
},
Body = new ItemBody()
{
ContentType = BodyType.Html,
Content = "Lets meet up"
},
Start = new DateTimeTimeZone()
{
DateTime = startTime.ToString(),
TimeZone = timeZone.ToString()
},
End = new DateTimeTimeZone()
{
DateTime = endTime.ToString(),
TimeZone = timeZone
}
}
};
msg.Attachments.Add(attach);
Assert.AreEqual(
2,
msg.GetChangedProperties().Count());
Assert.AreEqual(
2,
msg.Attachments[0].GetChangedProperties().Count());
Assert.AreEqual(
4,
((ItemAttachment)msg.Attachments[0]).Item.GetChangedProperties().Count());
}
private AttachmentResponse GetAttachmentsFromExchangeServerUsingEWSManagedApi(AttachmentRequest request)
{
var attachmentsProcessedCount = 0;
var attachmentNames = new List <string>();
// Creo un oggetto di tipo ExchangeService
ExchangeService service = new ExchangeService();
//imposto il token di autenticazione ricevuto dall'add-in
service.Credentials = new OAuthCredentials(request.attachmentToken);
//imposto la url del server Exchange
service.Url = new Uri(request.ewsUrl);
// Richiede gli allegati al server
var getAttachmentsResponse = service.GetAttachments(
request.attachments.Select(a => a.id).ToArray(),
null,
new PropertySet(BasePropertySet.FirstClassProperties,
ItemSchema.MimeContent));
if (getAttachmentsResponse.OverallResult == ServiceResult.Success)
{
foreach (var attachmentResponse in getAttachmentsResponse)
{
attachmentNames.Add(attachmentResponse.Attachment.Name);
if (attachmentResponse.Attachment is FileAttachment)
{
//mette il contenuto dell'allegato in uno stream
FileAttachment fileAttachment = attachmentResponse.Attachment as FileAttachment;
Stream s = new MemoryStream(fileAttachment.Content);
// Qui è possibile processare il contenuto dell'allegato
}
if (attachmentResponse.Attachment is ItemAttachment)
{
//mette il contenuto dell'allegato in uno stream
ItemAttachment itemAttachment = attachmentResponse.Attachment as ItemAttachment;
Stream s = new MemoryStream(itemAttachment.Item.MimeContent.Content);
// Qui è possibile processare il contenuto dell'allegato
}
attachmentsProcessedCount++;
}
}
// La risposta contiene il nome ed il numero degli allegati che sono stati
// processati dal servizio
var response = new AttachmentResponse();
response.attachmentNames = attachmentNames.ToArray();
response.attachmentsProcessed = attachmentsProcessedCount;
return(response);
}
public void Post([FromBody] ItemAttachment attachment)
{
// TODO: Add data validation
using (var dataContext = new APIDBContext())
{
dataContext.ItemAttachments.Add(attachment);
dataContext.SaveChanges();
}
}
private static void RenderAttachment(TextWriter output, AttachmentWellInfo attachmentInfoObject, UserContext userContext, ArrayList previousAttachmentDisplayNames)
{
ItemAttachment itemAttachment = null;
Item item = null;
string value = null;
try
{
if (attachmentInfoObject.AttachmentType == AttachmentType.EmbeddedMessage)
{
itemAttachment = (ItemAttachment)attachmentInfoObject.OpenAttachment();
item = itemAttachment.GetItemAsReadOnly(new PropertyDefinition[]
{
TaskSchema.TaskType
});
}
if (item != null)
{
value = Utilities.HtmlEncode(AttachmentUtility.TrimAttachmentDisplayName(AttachmentUtility.GetEmbeddedAttachmentDisplayName(item), previousAttachmentDisplayNames, true));
}
else
{
value = Utilities.HtmlEncode(AttachmentUtility.TrimAttachmentDisplayName(attachmentInfoObject.AttachmentName, previousAttachmentDisplayNames, false));
}
}
catch (ObjectNotFoundException)
{
return;
}
finally
{
if (item != null)
{
item.Dispose();
item = null;
}
if (itemAttachment != null)
{
itemAttachment.Dispose();
itemAttachment = null;
}
}
output.Write("<span id=\"spnAtmt\" tabindex=\"-1\">");
output.Write(value);
long size = attachmentInfoObject.Size;
if (size > 0L)
{
output.Write(userContext.DirectionMark);
output.Write(" ");
output.Write(LocalizedStrings.GetHtmlEncoded(6409762));
Utilities.RenderSizeWithUnits(output, size, true);
output.Write(userContext.DirectionMark);
output.Write(LocalizedStrings.GetHtmlEncoded(-1023695022));
}
output.Write("</span>");
}
public void Put(int id, [FromBody] ItemAttachment attachment)
{
// TODO: Add data validation
attachment.ID = id;
using (var dataContext = new APIDBContext())
{
dataContext.ItemAttachments.Update(attachment);
dataContext.SaveChanges();
}
}
/// <summary>
/// CRUD operation for item attachments
/// </summary>
/// <param name="exchangeService"></param>
public static void CreateReadUpdateDeleteItemAttachment(ExchangeService exchangeService)
{
DateTime startTime = TestHelpers.GetFormattedDateTime();
DateTime endTime = TestHelpers.GetFormattedDateTime(2);
string timeZone = "Central European Standard Time";
Message msg = new Message(exchangeService);
msg.Subject = "Test item attachment";
ItemAttachment attach = new ItemAttachment()
{
Name = "Attached message",
Item = new Message()
{
Body = new ItemBody()
{
ContentType = BodyType.HTML,
Content = "Lets meet up"
},
ToRecipients = new List <Recipient>()
{
new Recipient()
{
EmailAddress = new EmailAddress()
{
Address = "*****@*****.**"
}
}
}
}
};
msg.Attachments.Add(attach);
msg.Save(WellKnownFolderName.Inbox);
AttachmentId attachId = new AttachmentId(
msg.Attachments[0].Id,
msg.ItemId,
AppConfig.MailboxA);
Attachment attachment = exchangeService.GetAttachment(attachId);
Assert.IsInstanceOfType(
attachment,
typeof(ItemAttachment));
attachment = exchangeService.GetAttachment(attachId,
new ExpandQuery("Microsoft.OutlookServices.ItemAttachment/Item"));
ItemAttachment itemAttachment = (ItemAttachment)attachment;
Assert.IsNotNull(itemAttachment.Item);
Assert.IsInstanceOfType(itemAttachment.Item, typeof(Message));
}
public void Delete(int id)
{
ItemAttachment attachment = new ItemAttachment();
attachment.ID = id;
using (var dataContext = new APIDBContext())
{
dataContext.ItemAttachments.Remove(attachment);
dataContext.SaveChanges();
}
}
public static void LoadItemsAttachmentsListLv(Item oItem, ref ListView oListView)
{
oListView.Clear();
oListView.View = View.Details;
oListView.GridLines = true;
oListView.FullRowSelect = true;
oListView.Columns.Add("Id", 70, HorizontalAlignment.Left);
oListView.Columns.Add("ContentId", 70, HorizontalAlignment.Left);
oListView.Columns.Add("ContentLocation", 70, HorizontalAlignment.Left);
oListView.Columns.Add("ContentType", 70, HorizontalAlignment.Left);
oListView.Columns.Add("Name", 140, HorizontalAlignment.Left);
oListView.Columns.Add("IsInline", 50, HorizontalAlignment.Left); // Exchange 2010 and later.
//oListView.Columns.Add("LastModifiedTime", 70, HorizontalAlignment.Left); // Exchange 2010 and later.
//oListView.Columns.Add("Size", 70, HorizontalAlignment.Right); // Exchange 2010 and later.
ListViewItem oListItem = null;
int iAttachmentCount = 0;
foreach (Attachment oAttachment in oItem.Attachments)
{
oItem.Service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID
oAttachment.Load();
if (oAttachment is ItemAttachment)
{
ItemAttachment oItemAttachment = oAttachment as ItemAttachment;
// Load attachment into memory so we can get to the item properties (such as subject).
oItem.Service.ClientRequestId = Guid.NewGuid().ToString(); // Set a new GUID
oItemAttachment.Load();
oListItem = new ListViewItem(oAttachment.Id, 0);
oListItem.SubItems.Add(oItemAttachment.ContentId);
oListItem.SubItems.Add(oItemAttachment.ContentLocation);
oListItem.SubItems.Add(oItemAttachment.ContentType);
oListItem.SubItems.Add(oItemAttachment.Name);
oListItem.SubItems.Add(oItemAttachment.IsInline.ToString());
oListItem.Tag = iAttachmentCount;
oListView.Items.AddRange(new ListViewItem[] { oListItem });
oListItem = null;
}
if (oAttachment is FileAttachment)
{
}
}
iAttachmentCount++;
}
public EWSIncomingItemAttachment(ItemAttachment attachment)
{
_attachment = attachment;
Logger.DebugFormat("Loading attachment");
var additionalProperties = new PropertySet {
ItemSchema.MimeContent
};
_attachment.Load(additionalProperties);
Logger.DebugFormat("Attachment name is {0}", _attachment.Name);
}
internal static void CreateAttachment(IItem parentItem, Attachment16Data attachmentData)
{
AirSyncDiagnostics.TraceDebug <byte>(ExTraceGlobals.RequestsTracer, null, "CreateAttachment with AttachMethod:{0}", attachmentData.Method);
if (attachmentData.Method == 1)
{
if (attachmentData.Content == null)
{
throw new ConversionException(string.Format(" Attachment content can not be null.", new object[0]));
}
IStreamAttachment streamAttachment = parentItem.IAttachmentCollection.CreateIAttachment(AttachmentType.Stream) as IStreamAttachment;
AttachmentHelper.CopyCommonAttachmentProperties(streamAttachment, attachmentData);
using (Stream contentStream = streamAttachment.GetContentStream())
{
contentStream.Write(attachmentData.Content, 0, attachmentData.Content.Length);
}
streamAttachment.Save();
}
else
{
if (attachmentData.Method != 5)
{
throw new ConversionException(string.Format("UnSupported Value '{0}' for Attachment Method. Only 1 & 5 is supported AttachemntType", attachmentData.Method));
}
ItemAttachment itemAttachment = parentItem.IAttachmentCollection.CreateIAttachment(AttachmentType.EmbeddedMessage) as ItemAttachment;
AttachmentHelper.CopyCommonAttachmentProperties(itemAttachment, attachmentData);
using (Stream stream = new MemoryStream(attachmentData.Content))
{
stream.Seek(0L, SeekOrigin.Begin);
InboundConversionOptions inboundConversionOptions = AirSyncUtility.GetInboundConversionOptions();
inboundConversionOptions.ClearCategories = false;
try
{
using (Item item = itemAttachment.GetItem())
{
ItemConversion.ConvertAnyMimeToItem(item, stream, inboundConversionOptions);
item.Save(SaveMode.NoConflictResolution);
}
}
catch (ExchangeDataException innerException)
{
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidMIME, innerException, false);
}
catch (ConversionFailedException innerException2)
{
throw new AirSyncPermanentException(HttpStatusCode.BadRequest, StatusCode.InvalidMIME, innerException2, false);
}
}
itemAttachment.Save();
}
AirSyncDiagnostics.TraceDebug <int>(ExTraceGlobals.RequestsTracer, null, "AttachmentHelper:CreateAttachments:: AttachmentCreated successful. AttachmentCount:{0}", parentItem.IAttachmentCollection.Count);
}
/// <summary>
/// Demonstrates three ways to get file attachments and how to get an item attachment.
/// </summary>
/// <param name="service">An ExchangeService object with credentials and the EWS URL.</param>
private static void GetAttachments(ExchangeService service)
{
// Return a single item.
ItemView view = new ItemView(1);
string querystring = "HasAttachments:true Subject:'Message with Attachments' Kind:email";
// Find the first email message in the Inbox that has attachments. This results in a FindItem operation call to EWS.
FindItemsResults <Item> results = service.FindItems(WellKnownFolderName.Inbox, querystring, view);
if (results.TotalCount > 0)
{
EmailMessage email = results.Items[0] as EmailMessage;
// Request all the attachments on the email message. This results in a GetItem operation call to EWS.
email.Load(new PropertySet(EmailMessageSchema.Attachments));
foreach (Attachment attachment in email.Attachments)
{
if (attachment is FileAttachment)
{
FileAttachment fileAttachment = attachment as FileAttachment;
// Load the file attachment into memory. This gives you access to the attachment content, which
// is a byte array that you can use to attach this file to another item. This results in a GetAttachment operation
// call to EWS.
fileAttachment.Load();
Console.WriteLine("Load a file attachment with a name = " + fileAttachment.Name);
// Load attachment contents into a file. This results in a GetAttachment operation call to EWS.
fileAttachment.Load("C:\\temp\\" + fileAttachment.Name);
// Put attachment contents into a stream.
using (FileStream theStream = new FileStream("C:\\temp\\Stream_" + fileAttachment.Name, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
//This results in a GetAttachment operation call to EWS.
fileAttachment.Load(theStream);
}
}
else // Attachment is an item attachment.
{
ItemAttachment itemAttachment = attachment as ItemAttachment;
// Load the item attachment properties. This results in a GetAttachment operation call to EWS.
itemAttachment.Load();
Console.WriteLine("Loaded an item attachment with Subject = " + itemAttachment.Item.Subject);
}
}
}
}
// TODO: Figure out how to implement this
public void AddAttachment(IMailItem mailItem)
{
#if false
var itemProvider = mailItem as MailItemProvider;
var itemAttachment = new ItemAttachment
{
Item = new Item {
Id = itemProvider.Handle.Id
},
Name = "Item Attachment!!!",
};
Util.PostAsync <ItemAttachment>(Uri + "/attachments", itemAttachment).Wait();
#endif
}
// Token: 0x06001988 RID: 6536 RVA: 0x000953D4 File Offset: 0x000935D4
internal Stream GetItemAttachmentStream(Attachment attachment, HttpContext httpContext)
{
OwaContext owaContext = OwaContext.Get(httpContext);
UserContext userContext = owaContext.UserContext;
OutboundConversionOptions outboundConversionOptions = Utilities.CreateOutboundConversionOptions(userContext);
Stream stream = Streams.CreateTemporaryStorageStream();
string text = null;
ItemAttachment itemAttachment = attachment as ItemAttachment;
using (Item item = itemAttachment.GetItem(StoreObjectSchema.ContentConversionProperties))
{
try
{
if (ItemConversion.IsItemClassConvertibleToMime(item.ClassName))
{
ItemConversion.ConvertItemToMime(item, stream, outboundConversionOptions);
text = ".eml";
}
else if (ObjectClass.IsCalendarItemCalendarItemOccurrenceOrRecurrenceException(item.ClassName))
{
(item as CalendarItemBase).ExportAsICAL(stream, "UTF-8", outboundConversionOptions);
text = ".ics";
}
else if (ObjectClass.IsContact(item.ClassName))
{
Contact.ExportVCard(item as Contact, stream, outboundConversionOptions);
text = ".vcf";
}
else
{
ItemConversion.ConvertItemToMsgStorage(item, stream, outboundConversionOptions);
}
}
catch (Exception)
{
stream = this.GetContentsReplacementStream(-1706159495);
text = ".txt";
}
}
if (text != null)
{
this.fileName = this.GetConvertedItemFileName(this.fileName, text);
this.encodedfileNameBytes = this.GetEncodedString(this.fileName);
}
stream.Position = 0L;
return(stream);
}
// TODO: Figure out how to implement this
public void AddAttachment(IMailItem mailItem)
{
#if false
var itemProvider = mailItem as MailItemProvider;
var msgFetcher = _outlookClient.Me.Messages.GetById(_message.Id);
var itemAttachment = new ItemAttachment
{
Item = itemProvider.Handle as Message,
Name = "Item Attachment!!!",
};
Util.Synchronize(async() => await msgFetcher.Attachments.AddAttachmentAsync(itemAttachment));
#endif
}
public async Task <IActionResult> Create([Bind("Id,ImageData,Link,ContentType,ItemId,ItemAttachmentTypeId")] ItemAttachment itemAttachment, IFormFile image)
{
var slug = _context.Item.FirstOrDefault(i => i.Id == itemAttachment.ItemId).Slug;
if (ModelState.IsValid)
{
itemAttachment.ContentType = _imageService.RecordContentType(image);
itemAttachment.ImageData = await _imageService.EncodeFileAsync(image);
_context.Add(itemAttachment);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "Items", new { slug }));
}
ViewData["ItemId"] = new SelectList(_context.Item, "Id", "Name", itemAttachment.ItemId);
return(RedirectToAction("Details", "Items", new { slug }));
}
public void TestPropertyTrackingWithInnerProperties()
{
ItemAttachment itemAttachment = new ItemAttachment()
{
Name = "Item attach",
Item = new Event()
{
Subject = "Event subject",
Attendees = new List <Attendee>()
{
new Attendee()
{
EmailAddress = new EmailAddress()
{
Address = "*****@*****.**"
}
}
},
Body = new ItemBody()
}
};
Assert.AreEqual(
2,
itemAttachment.GetChangedProperies().Count);
Assert.AreEqual(
3,
itemAttachment.Item.GetChangedProperies().Count);
Assert.IsTrue(
ItemAttachmentObjectSchema.Item.ChangeTrackable);
itemAttachment.ResetChangeTracking();
Assert.AreEqual(
0,
itemAttachment.GetChangedProperies().Count);
Assert.AreEqual(
0,
itemAttachment.Item.GetChangedProperies().Count);
}
public EmailAttachDTO(object attach, bool loadContent = true)
{
byte[] content = null;
if (attach.GetType() == typeof(FileAttachment))
{
FileAttachment fAttach = (FileAttachment)attach;
if (loadContent)
{
if (fAttach.Content is null)
{
fAttach.Load();
}
content = fAttach.Content;
}
cargar_datos(fAttach.Id, fAttach.Name, fAttach.ContentType, fAttach.Size, content, fAttach.IsInline);
}
else if (attach.GetType() == typeof(ItemAttachment))
{
ItemAttachment iAttach = (ItemAttachment)attach;
if (loadContent)
{
iAttach.Load(ItemSchema.MimeContent);
if (iAttach.Item is object && iAttach.Item.GetType() == typeof(EmailMessage))
{
EmailMessage mAttach = (EmailMessage)iAttach.Item;
if (loadContent)
{
content = mAttach.MimeContent.Content;
}
cargar_datos(iAttach.Id, iAttach.Name + ".eml", iAttach.ContentType, iAttach.Size, content, iAttach.IsInline);
}
else
{
cargar_datos(iAttach.Id, iAttach.Name, iAttach.ContentType, iAttach.Size, null, iAttach.IsInline);
}
}
else
{
cargar_datos(iAttach.Id, iAttach.Name, iAttach.ContentType, iAttach.Size, null, iAttach.IsInline);
}
}
}
//gavdcodeend 16
//gavdcodebegin 17
static void GetAttachments(ExchangeService ExService)
{
SearchFilter myFilter = new SearchFilter.SearchFilterCollection(
LogicalOperator.And,
new SearchFilter.IsEqualTo(
EmailMessageSchema.Subject,
"Email with Attachments"));
ItemView myView = new ItemView(1);
FindItemsResults <Item> findResults = ExService.FindItems(
WellKnownFolderName.Inbox, myFilter, myView);
ItemId myEmailId = null;
foreach (Item oneItem in findResults)
{
myEmailId = oneItem.Id;
}
PropertySet myPropSet = new PropertySet(BasePropertySet.IdOnly,
ItemSchema.Attachments);
EmailMessage emailWithAttachments =
EmailMessage.Bind(ExService, myEmailId, myPropSet);
foreach (Attachment oneAttachment in emailWithAttachments.Attachments)
{
if (oneAttachment is FileAttachment) // Attachment is a File
{
FileAttachment myAttachment = oneAttachment as FileAttachment;
FileStream attStream = new FileStream(@"C:\Temporary\Attch_" +
myAttachment.Name, FileMode.OpenOrCreate, FileAccess.ReadWrite);
myAttachment.Load(attStream);
attStream.Close();
attStream.Dispose();
}
else // Attachment is an Item
{
ItemAttachment itemAttachment = oneAttachment as ItemAttachment;
itemAttachment.Load();
Console.WriteLine("Subject: " + itemAttachment.Item.Subject);
}
}
}
// TODO: Figure out how to implement this
public void AddAttachment(IMailItem mailItem)
{
#if false
var itemProvider = mailItem as MailItemProvider;
var itemAttachment = new ItemAttachment
{
Item = new Item { Id = itemProvider.Handle.Id },
Name = "Item Attachment!!!",
};
Util.PostAsync<ItemAttachment>(Uri + "/attachments", itemAttachment).Wait();
#endif
}
/// <summary>
/// Initializes a new instance of the <see cref="ContactGroup"/> class.
/// </summary>
/// <param name="parentAttachment">The parent attachment.</param>
internal ContactGroup(ItemAttachment parentAttachment)
: base(parentAttachment)
{
}
// Call this function when play press the pegs. check if in item selection mode
public void SetSelectionMode(bool mode)
{
if(mode)
{
// get the Peg attach script from the current selected peg
PegAttach = PegAttachObject.GetComponent<ItemAttachment>();
} else
{
//Exit Item selection mode and reset pegattach
ItemSelectionMode = false;
PegAttach= null;
}
// Remove the seleced item from the inventory
if(!eventSystem.IsPointerOverGameObject(-1) && from != null && PegAttach == null)
{
from.GetComponent<Image>().color = Color.white;
from.ClearSlot(); // remove item from slot
//Reset objects
to = null;
from = null;
emptySlots++;
}else if (!eventSystem.IsPointerOverGameObject(-1) && from != null && PegAttach != null)
{
PegAttach.ItemAttach(from.Items.Peek());
from.GetComponent<Image>().color = Color.white;
from.ClearSlot(); // remove item from slot
//Reset objects
to = null;
from = null;
emptySlots++;
// Debug.Log("Did not Click on the UI " + eventSystem.name);
}
}
// TODO: Figure out how to implement this
public void AddAttachment(IMailItem mailItem)
{
#if false
var itemProvider = mailItem as MailItemProvider;
var msgFetcher = _outlookClient.Me.Messages.GetById(_message.Id);
var itemAttachment = new ItemAttachment
{
Item = itemProvider.Handle as Message,
Name = "Item Attachment!!!",
};
Util.Synchronize(async () => await msgFetcher.Attachments.AddAttachmentAsync(itemAttachment));
#endif
}