public static void Run() { //ExStart:SetMAPIProperties // The path to the File directory. string dataDir = RunExamples.GetDataDir_Outlook(); // Create a sample Message MapiMessage mapiMsg = new MapiMessage("*****@*****.**", "*****@*****.**", "This is subject", "This is body"); // Set multiple properties mapiMsg.SetProperty(new MapiProperty(MapiPropertyTag.PR_SENDER_ADDRTYPE_W, Encoding.Unicode.GetBytes("EX"))); MapiRecipient recipientTo = mapiMsg.Recipients[0]; MapiProperty propAddressType = new MapiProperty(MapiPropertyTag.PR_RECEIVED_BY_ADDRTYPE_W, Encoding.UTF8.GetBytes("MYFAX")); recipientTo.SetProperty(propAddressType); string faxAddress = "My Fax User@/FN=fax#/VN=voice#/CO=My Company/CI=Local"; MapiProperty propEmailAddress = new MapiProperty(MapiPropertyTag.PR_RECEIVED_BY_EMAIL_ADDRESS_W, Encoding.UTF8.GetBytes(faxAddress)); recipientTo.SetProperty(propEmailAddress); mapiMsg.SetMessageFlags(MapiMessageFlags.MSGFLAG_UNSENT | MapiMessageFlags.MSGFLAG_FROMME); mapiMsg.SetProperty(new MapiProperty(MapiPropertyTag.PR_RTF_IN_SYNC, BitConverter.GetBytes((long)1))); // Set DateTime property MapiProperty modificationTime = new MapiProperty(MapiPropertyTag.PR_LAST_MODIFICATION_TIME, ConvertDateTime(new DateTime(2013, 9, 11))); mapiMsg.SetProperty(modificationTime); mapiMsg.Save(dataDir + "MapiProp_out.msg"); //ExEnd:SetMAPIProperties }
public static void Run() { //ExStart:ConvertMSGToMIMEMessage MapiMessage msg = new MapiMessage("*****@*****.**","[email protected]; [email protected]","Test Subject","This is a body of message."); var options = new MailConversionOptions(); options.ConvertAsTnef = true; MailMessage mail = msg.ToMailMessage(options); //ExEnd:ConvertMSGToMIMEMessage }
private static MapiMessage CreateTestMessage(bool draft) { MapiMessage msg = new MapiMessage( "*****@*****.**", "*****@*****.**", "Flagged message", "Make it nice and short, but descriptive. The description may appear in search engines' search results pages..."); if (!draft) { msg.SetMessageFlags(msg.Flags ^ MapiMessageFlags.MSGFLAG_UNSENT); } return msg; }
static void Run() { // ExStart: SaveMsgAsTemplate ///<summary> /// This example shows how to save an Outlook MSG file to Outlook Template using the MapiMessage API /// Available from Aspose.Email for .NET 6.4.0 onwards /// MapiMessage.SaveAsTemplate(Stream stream) - Saves to the specified stream as Outlook File Template(OFT format). /// MapiMessage.SaveAsTemplate(string fileName) - Saves to the specified file as Outlook File Template(OFT format). ///</summary> using (MapiMessage mapi = new MapiMessage("*****@*****.**", "*****@*****.**", "template subject", "Template body")) { string oftMapiFileName = "mapiToOft.msg"; mapi.SaveAsTemplate(oftMapiFileName); } // ExEnd: SaveMsgAsTemplate }
public void SendMail () { var recipients = new List<MapiRecipDesc>(); To.ForEach(email => recipients.Add(new MapiRecipDesc { recipClass = RecipClass.To, name = email })); CC.ForEach(email => recipients.Add(new MapiRecipDesc { recipClass = RecipClass.CC, name = email })); BCC.ForEach(email => recipients.Add(new MapiRecipDesc { recipClass = RecipClass.BCC, name = email })); var msg = new MapiMessage { subject = Subject, noteText = Body, recips = GetRecipientsData(recipients), recipCount = recipients.Count, files = GetAttachmentsData(Attachments), fileCount = Attachments.Count, }; int result = MAPISendMail(IntPtr.Zero, IntPtr.Zero, msg, MAPI_LOGON_UI | MAPI_DIALOG, 0); if (result > 1) throw new Exception("Failed to send mail: {0}.".Fmt(GetErrorMessage(result))); Cleanup(msg); }
public static void Run() { string dataDir = RunExamples.GetDataDir_Outlook(); // Load mail message MapiMessage msg = MapiMessage.FromMailMessage(dataDir + "Message.eml"); MapiMessageItemBase itemBase = new MapiMessage(); // Text body if (itemBase.Body != null) Console.WriteLine(msg.Body); else Console.WriteLine("There's no text body."); // RTF body if (itemBase.BodyRtf != null) Console.WriteLine(msg.BodyRtf); else Console.WriteLine("There's no RTF body."); }
private bool SendMail(string subject, string body, SendFlags flags) { MapiMessage message = new MapiMessage(); message.subject = subject; message.noteText = body; message.recips = GetRecipients(out message.recipCount); message.files = GetAttachments(out message.fileCount); lastError = (MessageApiError)MAPISendMail(IntPtr.Zero, IntPtr.Zero, message, flags, 0); Cleanup(message); return lastError == MessageApiError.Success; }
public static bool IsInlineAttachment(MapiAttachment att, MapiMessage msg) { switch (msg.BodyType) { case BodyContentType.PlainText: // ignore indications for plain text messages return false; case BodyContentType.Html: // check the PidTagAttachFlags property if (att.Properties.Contains(0x37140003)) { long? attachFlagsValue = att.GetPropertyLong(0x37140003); if (attachFlagsValue != null && (attachFlagsValue & 0x00000004) == 0x00000004) { // check PidTagAttachContentId property if (att.Properties.Contains(MapiPropertyTag.PR_ATTACH_CONTENT_ID) || att.Properties.Contains(MapiPropertyTag.PR_ATTACH_CONTENT_ID_W)) { string contentId = att.Properties.Contains(MapiPropertyTag.PR_ATTACH_CONTENT_ID) ? att.Properties[MapiPropertyTag.PR_ATTACH_CONTENT_ID].GetString() : att.Properties[MapiPropertyTag.PR_ATTACH_CONTENT_ID_W].GetString(); if (msg.BodyHtml.Contains(contentId)) { return true; } } // check PidTagAttachContentLocation property if (att.Properties.Contains(0x3713001E) || att.Properties.Contains(0x3713001F)) { return true; } } else if ((att.Properties.Contains(0x3716001F) && att.GetPropertyString(0x3716001F) == "inline") || (att.Properties.Contains(0x3716001E) && att.GetPropertyString(0x3716001E) == "inline")) { return true; } } else if ((att.Properties.Contains(0x3716001F) && att.GetPropertyString(0x3716001F) == "inline") || (att.Properties.Contains(0x3716001E) && att.GetPropertyString(0x3716001E) == "inline")) { return true; } return false; case BodyContentType.Rtf: // If the body is RTF, then all OLE attachments are inline attachments. // OLE attachments have 0x00000006 for the value of the PidTagAttachMethod property if (att.Properties.Contains(MapiPropertyTag.PR_ATTACH_METHOD)) { return att.GetPropertyLong(MapiPropertyTag.PR_ATTACH_METHOD) == 0x00000006; } return false; default: throw new ArgumentOutOfRangeException(); } }
int SendMail(string strSubject, string strBody, int how) { MapiMessage msg = new MapiMessage(); msg.subject = strSubject; msg.noteText = strBody; msg.recips = GetRecipients(out msg.recipCount); msg.files = GetAttachments(out msg.fileCount); m_lastError = MAPISendMail(new IntPtr(0), new IntPtr(0), msg, how, 0); if (m_lastError > 1) MessageBox.Show("MAPISendMail failed! " + GetLastError(), "MAPISendMail"); Cleanup(ref msg); return m_lastError; }
private void genrateSpecialTestCases() { string strFrom = textBoxFrom.Text; string strTo = textBoxTo.Text; string strCC = textBoxCC.Text; string strSubject = textBoxSubject.Text; string strTemplate = textBoxTemplate.Text; string strWorkPath = textBoxWorkPath.Text; string strPreProcessedFolder = textBoxPreProcessedFolder.Text; string strProcessedFolder = textBoxProcessedFolder.Text; string strTestcasePrefix = textBoxTestCasePrefix.Text; string strLogfilePrefix = textBoxLogfilePrefix.Text; string strPayloadPattern = textBoxPayloadPattern.Text; int intKeepOpen = StrToIntDef(textBoxKeepOpen.Text, 3); processTimeoutInSecond = StrToIntDef(textBoxProcessTimeout.Text, 10); textBoxKeepOpen.Text = intKeepOpen.ToString(); Boolean isURLEncoded = checkBoxURLDecode.Checked; Boolean isAutoRun = checkBoxAutoRun.Checked; timestampLogger = new TimestampLogging(strWorkPath + "\\" + strLogfilePrefix); payloadsListLogger = new SimpleLogging(strWorkPath + "\\" + textBoxPayloadsListFilename.Text); payloadsProcessedTestcaseFilesLogger = new SimpleLogging(strWorkPath + "\\" + textBoxProcessedTestcaseFilesFilename.Text); //logger.log("==Begin=="); try { caseID = 0; string[] arrPrefix = UniqueTextArrayFromFile(textBoxPrefix.Text); string[] arrSuffix = UniqueTextArrayFromFile(textBoxSuffix.Text); string[] arrFormula = UniqueTextArrayFromFile(textBoxFormula.Text); string[] arrSchemes = UniqueTextArrayFromFile(textBoxSchemes.Text); string[] arrTargets = UniqueTextArrayFromFile(textBoxTargets.Text); string[] arrSpecialFormula = UniqueTextArrayFromFile(textBoxSpecialFormula.Text); string strPreProcessedFolderFullPath = strWorkPath + "\\" + strPreProcessedFolder + "\\"; string strProcessedFolderFullPath = strWorkPath + "\\" + strProcessedFolder + "\\"; System.IO.Directory.CreateDirectory(strPreProcessedFolderFullPath); System.IO.Directory.CreateDirectory(strProcessedFolderFullPath); if (isURLEncoded) { timestampLogger.log("URL Decoding..."); strTemplate = Uri.UnescapeDataString(strTemplate); } string strTemplateSha1Sig = SHA1FromString(strTemplate); int intPrefixParalDegree = StrToIntDef(textBoxThreadPrefixHigh.Text, 1); int intTargetsParalDegree = StrToIntDef(textBoxThreadTargetsHigh.Text, 2); int intSpecialFormulaParalDegree = StrToIntDef(textBoxThreadSpecialFormulaHigh.Text, 5); int intSuffixParalDegree = StrToIntDef(textBoxThreadSuffixHigh.Text, 1); if (isAutoRun) { intPrefixParalDegree = StrToIntDef(textBoxThreadPrefixLow.Text, 1); intTargetsParalDegree = StrToIntDef(textBoxThreadTargetsLow.Text, 1); intSpecialFormulaParalDegree = StrToIntDef(textBoxThreadSpecialFormulaLow.Text, 3); intSuffixParalDegree = StrToIntDef(textBoxThreadSuffixLow.Text, 1); } long totalEvents = arrPrefix.Length * arrTargets.Length * arrSpecialFormula.Length * arrSuffix.Length; progressBarStatus.Value = 0; setLabelStatus(0, totalEvents); ResetCaseID(); // to kill it on timeout: http://stackoverflow.com/questions/1410602/how-do-set-a-timeout-for-a-method Action <object, string, string, string, int> longMethod_showCloseMoveEmail = showCloseMoveEmail; Parallel.ForEach(arrPrefix, new ParallelOptions { MaxDegreeOfParallelism = intPrefixParalDegree }, (strPrefix, loopStatePrefix) => { Parallel.ForEach(arrTargets, new ParallelOptions { MaxDegreeOfParallelism = intTargetsParalDegree }, (strTarget, loopStateTargets) => { Parallel.ForEach(arrSpecialFormula, new ParallelOptions { MaxDegreeOfParallelism = intSpecialFormulaParalDegree }, (strSpecialFormula, loopSpecialFormula) => { Parallel.ForEach(arrSuffix, new ParallelOptions { MaxDegreeOfParallelism = intSuffixParalDegree }, (strSuffix, loopStateSuffix) => { if (Interlocked.Read(ref paused) == 1) { mre.WaitOne(); } long currentCaseID = GetNextValue(); string strPayload = strSpecialFormula.Replace("<$target$>", strTarget); strPayload = strPrefix + strPayload + strSuffix + currentCaseID.ToString(); payloadsListLogger.log(strTemplateSha1Sig + "," + strPayload); string strTempTemplate = System.Text.RegularExpressions.Regex.Replace(strTemplate, strPayloadPattern, strPayload); string strTempSubject = System.Text.RegularExpressions.Regex.Replace(strSubject, strPayloadPattern, strPayload); string strTempFrom = System.Text.RegularExpressions.Regex.Replace(strFrom, strPayloadPattern, strPayload); string strTempTo = System.Text.RegularExpressions.Regex.Replace(strTo, strPayloadPattern, strPayload); string strTempCC = System.Text.RegularExpressions.Regex.Replace(strCC, strPayloadPattern, strPayload); MailMessage msg = new MailMessage(); // Set recipients information if (!String.IsNullOrEmpty(strTempFrom)) { msg.From = strTempFrom; } if (!String.IsNullOrEmpty(strTempTo)) { msg.To = strTempTo; } if (!String.IsNullOrEmpty(strTempCC)) { msg.CC = strTempCC; } // Set the subject msg.Subject = strTempSubject; // Set HTML body msg.HtmlBody = strTempTemplate; // Add an attachment // msg.Attachments.Add(new Aspose.Email.Mail.Attachment("test.txt")); // Local filenames string strTestCaseFileName = MakeValidFileName(strTestcasePrefix + currentCaseID.ToString() + "-" + strTempSubject + ".msg"); string strInProgressFilePath = strPreProcessedFolderFullPath + strTestCaseFileName; //msg.Save(strFullFilePath,SaveOptions.DefaultMsg); MapiMessage outlookMsg = MapiMessage.FromMailMessage(msg); outlookMsg.SetMessageFlags(MapiMessageFlags.MSGFLAG_SUBMIT); while (File.Exists(strInProgressFilePath)) { strInProgressFilePath = strPreProcessedFolderFullPath + Guid.NewGuid() + "_" + strTestCaseFileName; } timestampLogger.log("Saving the " + strTestCaseFileName + " file in: " + strInProgressFilePath); outlookMsg.Save(strInProgressFilePath); if (isAutoRun) { mre.WaitOne(); //showCloseMoveEmail(strInProgressFilePath, strProcessedFolderFullPath, strTestCaseFileName, intKeepOpen); // to kill it on timeout: http://stackoverflow.com/questions/1410602/how-do-set-a-timeout-for-a-method object monitorSync = new object(); bool timedOut; lock (monitorSync) { longMethod_showCloseMoveEmail.BeginInvoke(monitorSync, strInProgressFilePath, strProcessedFolderFullPath, strTestCaseFileName, intKeepOpen, null, null); timedOut = !Monitor.Wait(monitorSync, TimeSpan.FromSeconds(processTimeoutInSecond)); } if (timedOut) { object _lock = new object(); lock (_lock) { killProcess("OUTLOOK", processTimeoutInSecond); timestampLogger.log("Process killed due to " + processTimeoutInSecond.ToString() + " seconds timeout"); } } if (currentCaseID % 10 == 0 || currentCaseID == totalEvents) { setLabelStatus(currentCaseID, totalEvents); } } else { if (currentCaseID % 100 == 0 || currentCaseID == totalEvents) { setLabelStatus(currentCaseID, totalEvents); } } } ); } ); } ); } ); } catch (Exception e) { timestampLogger.log("Error in genrateSpecialTestCases(): " + e.StackTrace); MessageBox.Show("An error occured!", "Error!"); } //logger.log("==End=="); }
private static void Cleanup(MapiMessage msg) { Native.FreeHGlobalArray <MapiRecipDesc>(msg.recips, msg.recipCount); Native.FreeHGlobalArray <MapiFileDesc>(msg.files, msg.fileCount); }
public ICoreItem OpenAttachedItem(ICollection <PropertyDefinition> propertiesToLoad, AttachmentPropertyBag attachmentBag, bool isNew) { MapiMessage mapiMessage = null; PersistablePropertyBag persistablePropertyBag = null; CoreItem coreItem = null; bool flag = false; StoreObjectId storeObjectId = null; byte[] array = null; ICoreItem result; try { StoreObjectPropertyBag storeObjectPropertyBag = (StoreObjectPropertyBag)attachmentBag.PersistablePropertyBag; MapiAttach mapiAttach = (MapiAttach)storeObjectPropertyBag.MapiProp; StoreSession session = this.AttachmentCollection.ContainerItem.Session; OpenPropertyFlags openPropertyFlags = isNew ? OpenPropertyFlags.Create : (this.AttachmentCollection.IsReadOnly ? OpenPropertyFlags.BestAccess : OpenPropertyFlags.BestAccess); openPropertyFlags |= OpenPropertyFlags.DeferredErrors; string text = storeObjectPropertyBag.TryGetProperty(InternalSchema.ItemClass) as string; Schema schema = (text != null) ? ObjectClass.GetSchema(text) : MessageItemSchema.Instance; propertiesToLoad = InternalSchema.Combine <PropertyDefinition>(schema.AutoloadProperties, propertiesToLoad); StoreSession session2 = this.AttachmentCollection.ContainerItem.Session; bool flag2 = false; try { if (session2 != null) { session2.BeginMapiCall(); session2.BeginServerHealthCall(); flag2 = true; } if (StorageGlobals.MapiTestHookBeforeCall != null) { StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod()); } mapiMessage = mapiAttach.OpenEmbeddedMessage(openPropertyFlags); } catch (MapiPermanentException ex) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenEmbeddedMessage, ex, session2, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::OpenAttachedItem", new object[0]), ex }); } catch (MapiRetryableException ex2) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenEmbeddedMessage, ex2, session2, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::OpenAttachedItem", new object[0]), ex2 }); } finally { try { if (session2 != null) { session2.EndMapiCall(); if (flag2) { session2.EndServerHealthCall(); } } } finally { if (StorageGlobals.MapiTestHookAfterCall != null) { StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod()); } } } persistablePropertyBag = new StoreObjectPropertyBag(session, mapiMessage, propertiesToLoad); if (!isNew) { StoreObjectType storeObjectType = ItemBuilder.ReadStoreObjectTypeFromPropertyBag(persistablePropertyBag); ItemCreateInfo itemCreateInfo = ItemCreateInfo.GetItemCreateInfo(storeObjectType); propertiesToLoad = InternalSchema.Combine <PropertyDefinition>(itemCreateInfo.Schema.AutoloadProperties, propertiesToLoad); if (this.AttachmentCollection.IsReadOnly) { StoreId.SplitStoreObjectIdAndChangeKey(StoreObjectId.DummyId, out storeObjectId, out array); } persistablePropertyBag = new AcrPropertyBag(persistablePropertyBag, itemCreateInfo.AcrProfile, storeObjectId, new RetryBagFactory(session), array); } coreItem = new CoreItem(session, persistablePropertyBag, storeObjectId, array, isNew ? Origin.New : Origin.Existing, ItemLevel.Attached, propertiesToLoad, ItemBindOption.None); if (text != null && isNew) { coreItem.PropertyBag[InternalSchema.ItemClass] = text; } flag = true; result = coreItem; } finally { if (!flag) { if (coreItem != null) { coreItem.Dispose(); coreItem = null; } if (persistablePropertyBag != null) { persistablePropertyBag.Dispose(); persistablePropertyBag = null; } if (mapiMessage != null) { mapiMessage.Dispose(); mapiMessage = null; } } } return(result); }
public PersistablePropertyBag CreateAttachment(ICollection <PropertyDefinition> propertiesToLoad, CoreAttachment attachmentToClone, IItem itemToAttach, out int attachmentNumber) { MapiAttach mapiAttach = null; PersistablePropertyBag persistablePropertyBag = null; bool flag = false; int num = 0; try { StoreSession session = this.AttachmentCollection.ContainerItem.Session; bool flag2 = false; try { if (session != null) { session.BeginMapiCall(); session.BeginServerHealthCall(); flag2 = true; } if (StorageGlobals.MapiTestHookBeforeCall != null) { StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod()); } mapiAttach = this.AttachmentCollection.ContainerItem.MapiMessage.CreateAttach(out num); } catch (MapiPermanentException ex) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenAttachment, ex, session, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::CreateMapiAttachment", new object[0]), ex }); } catch (MapiRetryableException ex2) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenAttachment, ex2, session, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::CreateMapiAttachment", new object[0]), ex2 }); } finally { try { if (session != null) { session.EndMapiCall(); if (flag2) { session.EndServerHealthCall(); } } } finally { if (StorageGlobals.MapiTestHookAfterCall != null) { StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod()); } } } attachmentNumber = num; if (attachmentToClone != null) { MapiAttachmentProvider.CopySavedMapiAttachment(true, this, this.AttachmentCollection.ContainerItem.Session, (MapiAttach)attachmentToClone.PropertyBag.MapiProp, mapiAttach); } else if (itemToAttach != null) { MapiMessage mapiMessage = itemToAttach.MapiMessage; MapiMessage mapiMessage2 = null; StoreSession session2 = this.AttachmentCollection.ContainerItem.Session; bool flag3 = false; try { if (session2 != null) { session2.BeginMapiCall(); session2.BeginServerHealthCall(); flag3 = true; } if (StorageGlobals.MapiTestHookBeforeCall != null) { StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod()); } mapiMessage2 = mapiAttach.OpenEmbeddedMessage(OpenPropertyFlags.Create); } catch (MapiPermanentException ex3) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenEmbeddedMessage, ex3, session2, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::CreateMapiAttachment", new object[0]), ex3 }); } catch (MapiRetryableException ex4) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenEmbeddedMessage, ex4, session2, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::CreateMapiAttachment", new object[0]), ex4 }); } finally { try { if (session2 != null) { session2.EndMapiCall(); if (flag3) { session2.EndServerHealthCall(); } } } finally { if (StorageGlobals.MapiTestHookAfterCall != null) { StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod()); } } } using (mapiMessage2) { PropProblem[] array = null; StoreSession session3 = this.AttachmentCollection.ContainerItem.Session; bool flag4 = false; try { if (session3 != null) { session3.BeginMapiCall(); session3.BeginServerHealthCall(); flag4 = true; } if (StorageGlobals.MapiTestHookBeforeCall != null) { StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod()); } array = mapiMessage.CopyTo(mapiMessage2, new PropTag[] { (PropTag)InternalSchema.UrlCompName.PropertyTag }); } catch (MapiPermanentException ex5) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCopyFailedProperties, ex5, session3, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::CreateMapiAttachment", new object[0]), ex5 }); } catch (MapiRetryableException ex6) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCopyFailedProperties, ex6, session3, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::CreateMapiAttachment", new object[0]), ex6 }); } finally { try { if (session3 != null) { session3.EndMapiCall(); if (flag4) { session3.EndServerHealthCall(); } } } finally { if (StorageGlobals.MapiTestHookAfterCall != null) { StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod()); } } } if (array != null) { int num2 = -1; for (int i = 0; i < array.Length; i++) { int scode = array[i].Scode; if (scode == -2147221233 || scode == -2147221222) { ExTraceGlobals.StorageTracer.TraceDebug <int>((long)this.GetHashCode(), "Storage.MapiAttachmentProvider.AddExisting Item: CopyTo returned ignorable scode = {0}", scode); } else { ExTraceGlobals.StorageTracer.TraceError <int>((long)this.GetHashCode(), "Storage.MapiAttachmentProvider.AddExisting Item: CopyTo returned fatal scode = {0}", scode); num2 = i; } if (num2 != -1) { throw PropertyError.ToException(ServerStrings.ExUnableToCopyAttachments, StoreObjectPropertyBag.MapiPropProblemsToPropertyErrors(null, mapiMessage, array)); } } } StoreSession session4 = this.AttachmentCollection.ContainerItem.Session; bool flag5 = false; try { if (session4 != null) { session4.BeginMapiCall(); session4.BeginServerHealthCall(); flag5 = true; } if (StorageGlobals.MapiTestHookBeforeCall != null) { StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod()); } mapiMessage2.SaveChanges(); } catch (MapiPermanentException ex7) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotSaveChanges, ex7, session4, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::CreateMapiAttachment", new object[0]), ex7 }); } catch (MapiRetryableException ex8) { throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotSaveChanges, ex8, session4, this, "{0}. MapiException = {1}.", new object[] { string.Format("MapiAttachmentProvider::CreateMapiAttachment", new object[0]), ex8 }); } finally { try { if (session4 != null) { session4.EndMapiCall(); if (flag5) { session4.EndServerHealthCall(); } } } finally { if (StorageGlobals.MapiTestHookAfterCall != null) { StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod()); } } } } } persistablePropertyBag = this.CreateStorePropertyBag(mapiAttach, propertiesToLoad); persistablePropertyBag.ExTimeZone = this.ExTimeZone; flag = true; } finally { if (!flag) { if (persistablePropertyBag != null) { persistablePropertyBag.Dispose(); } if (mapiAttach != null) { mapiAttach.Dispose(); } } } return(persistablePropertyBag); }
int SendMail(string strSubject, string strBody, int how) { MapiMessage msg = new MapiMessage(); msg.subject = strSubject; msg.noteText = strBody; msg.recips = GetRecipients(out msg.recipCount); msg.files = GetAttachments(out msg.fileCount); m_lastError = MAPISendMail(new IntPtr(0), new IntPtr(0), msg, how, 0); if (m_lastError > 1) { string samp = "MAPISendMail failed! " + GetLastError() + "MAPISendMail"; YesNoBox yesNo = new YesNoBox(samp); yesNo.ShowDialog(); //MessageBox.Show("MAPISendMail failed! " + GetLastError(), // "MAPISendMail"); } Cleanup(ref msg); return m_lastError; }
public static extern uint MAPISendMail(IntPtr lhSession, IntPtr ulUIParam, MapiMessage lpMessage, uint flFlags, uint ulReserved);
public static extern int MAPISendMail(IntPtr session, IntPtr hwnd, MapiMessage message, int flg, int rsv);
private static extern int MAPISendMail(IntPtr sess, IntPtr hwnd, MapiMessage message, int flg, int rsv);
void Cleanup(ref MapiMessage msg) { int size = Marshal.SizeOf(typeof(MapiRecipDesc)); int ptr = 0; if (msg.recips != IntPtr.Zero) { ptr = (int)msg.recips; for (int i = 0; i < msg.recipCount; i++) { Marshal.DestroyStructure((IntPtr)ptr, typeof(MapiRecipDesc)); ptr += size; } Marshal.FreeHGlobal(msg.recips); } if (msg.files != IntPtr.Zero) { size = Marshal.SizeOf(typeof(MapiFileDesc)); ptr = (int)msg.files; for (int i = 0; i < msg.fileCount; i++) { Marshal.DestroyStructure((IntPtr)ptr, typeof(MapiFileDesc)); ptr += size; } Marshal.FreeHGlobal(msg.files); } m_recipients.Clear(); m_attachments.Clear(); m_lastError = 0; }
///<Summary> /// Add Custom Property ///</Summary> /// <param name="msg"></param> /// <param name="name"></param> /// <param name="value"></param> public static MapiProperty AddCustomProperty(this MapiMessage msg, string name, long value) { return(msg.AddCustomProperty(name, MapiPropertyType.PT_LONG, BitConverter.GetBytes(value))); }
private static extern int MAPISendMail (IntPtr sess, IntPtr hwnd, MapiMessage message, int flg, int rsv);
///<Summary> /// Add Custom Property ///</Summary> /// <param name="msg"></param> /// <param name="name"></param> /// <param name="value"></param> public static MapiProperty AddCustomProperty(this MapiMessage msg, string name, string value) { return(msg.AddCustomProperty(name, MapiPropertyType.PT_UNICODE, Encoding.Unicode.GetBytes(value))); }
private static void Cleanup (MapiMessage msg) { Native.FreeHGlobalArray<MapiRecipDesc>(msg.recips, msg.recipCount); Native.FreeHGlobalArray<MapiFileDesc>(msg.files, msg.fileCount); }
private static extern int MAPISendMail(IntPtr session, IntPtr hWnd, MapiMessage message, SendFlags flags, uint reserved);
private void Cleanup(MapiMessage msg) { int size = Marshal.SizeOf(typeof(MapiRecipDesc)); long ptr = 0; if (msg.recips != IntPtr.Zero) { ptr = msg.recips.ToInt64(); for (int i = 0; i < msg.recipCount; i++) { Marshal.DestroyStructure(new IntPtr(ptr), typeof(MapiRecipDesc)); ptr += size; } Marshal.FreeHGlobal(msg.recips); } if (msg.files != IntPtr.Zero) { size = Marshal.SizeOf(typeof(MapiFileDesc)); ptr = msg.files.ToInt64(); for (int i = 0; i < msg.fileCount; i++) { Marshal.DestroyStructure(new IntPtr(ptr), typeof(MapiFileDesc)); ptr += size; } Marshal.FreeHGlobal(msg.files); } recipients.Clear(); attachments.Clear(); }
internal static extern uint MAPISendMailW(IntPtr lhSession, IntPtr ulUIParam, ref MapiMessage lpMessage, int flFlags, uint ulReserved);
/// <summary> /// Creates and sends an e-mail message using the Simple MAPI protocol.</summary> /// <param name="subject"> /// The subject line of the e-mail message.</param> /// <param name="noteText"> /// The text of the e-mail message.</param> /// <param name="recipients"> /// An <see cref="Array"/> of <see cref="MapiAddress"/> instances holding the display names /// and SMTP addresses of all message recipients. The protocol identifier "smtp:" is /// automatically prepended to any non-empty addresses without this prefix.</param> /// <param name="attachments"> /// An <see cref="Array"/> of <see cref="MapiAddress"/> instances holding the display names /// and fully qualified local file paths of any attachment files sent to the <paramref /// name="recipients"/>.</param> /// <exception cref="MapiException"> /// <see cref="Mapi.MAPISendMail"/> indicated an error.</exception> /// <remarks><para> /// <b>SendMail</b> creates and sends an e-mail message with optional file attachments, /// using the Win32 API call <see cref="Mapi.MAPISendMail"/> which is part of the Simple /// MAPI protocol. The originator is left undefined which will cause Simple MAPI to assert /// the user’s default e-mail account as the originator. /// </para><para> /// The <paramref name="subject"/> and <paramref name="noteText"/> parameters may be a null /// reference or an empty string to leave the corresponding field blank. The <paramref /// name="recipients"/> and <paramref name="attachments"/> parameters may be null references /// or empty arrays to create a message without recipients or file attachments, /// respectively. /// </para><para> /// The e-mail message is presented to the user who can choose to edit (filling in any blank /// fields or adding text as desired), send, or cancel the message. User cancellation /// generates a <see cref="MapiException"/> whose <see cref="MapiException.Code"/> is <see /// cref="MapiException.Abort"/>.</para></remarks> public static void SendMail(string subject, string noteText, MapiAddress[] recipients, MapiAddress[] attachments) { // remember current working directory string currentDir = Directory.GetCurrentDirectory(); // construct MAPI message descriptor MapiMessage message = new MapiMessage(); message.lpszSubject = subject; message.lpszNoteText = noteText; try { // create any specified recipients if (recipients != null && recipients.Length > 0) { // store count of recipient descriptors int count = recipients.Length; message.nRecipCount = (uint)count; // allocate memory for recipient descriptors int size = Marshal.SizeOf(typeof(MapiRecipDesc)); message.lpRecips.AllocateHandle(count * size); // construct recipient descriptors MapiRecipDesc recip = new MapiRecipDesc(); for (int i = 0; i < count; i++) { // prepend "smtp:" to address if not present string address = recipients[i].Address; if (!String.IsNullOrEmpty(address) && !address.StartsWith("smtp:", StringComparison.OrdinalIgnoreCase)) { address = "smtp:" + address; } // create MAPI recipient descriptor recip.ulRecipClass = MapiRecipClass.MAPI_TO; recip.lpszName = recipients[i].Name; recip.lpszAddress = address; // copy recipient descriptor to unmanaged memory message.lpRecips.SetMemory(recip, i * size, false); } } // create any specified attachments if (attachments != null && attachments.Length > 0) { // store count of attachment descriptors int count = attachments.Length; message.nFileCount = (uint)count; // allocate memory for attachment descriptors int size = Marshal.SizeOf(typeof(MapiFileDesc)); message.lpFiles.AllocateHandle(count * size); // construct attachment descriptors MapiFileDesc fileDesc = new MapiFileDesc(); for (int i = 0; i < count; i++) { // create MAPI file attachment descriptor fileDesc.lpszFileName = attachments[i].Name; fileDesc.lpszPathName = attachments[i].Address; fileDesc.nPosition = 0xffffffff; // don’t embed files // copy attachment descriptor to unmanaged memory message.lpFiles.SetMemory(fileDesc, i * size, false); } } // invoke MAPISendMail to deliver this message MapiFlags flags = MapiFlags.MAPI_DIALOG | MapiFlags.MAPI_LOGON_UI; MapiError code = Mapi.MAPISendMail(UIntPtr.Zero, UIntPtr.Zero, message, flags, 0); // throw exception if MAPI reports failure if (code != MapiError.SUCCESS_SUCCESS) { ThrowMapiException(code); } } finally { // release unmanaged memory blocks message.Dispose(); // restore original working directory Directory.SetCurrentDirectory(currentDir); } }
public static void Run() { // ExStart:RemovePropertiesFromMSGAndAttachments // The path to the File directory. string dataDir = RunExamples.GetDataDir_Outlook(); MapiMessage mapi = new MapiMessage("*****@*****.**", "*****@*****.**", "subject", "body"); mapi.SetBodyContent("<html><body><h1>This is the body content</h1></body></html>", BodyContentType.Html); MapiMessage attachment = MapiMessage.FromFile(dataDir + @"message.msg"); mapi.Attachments.Add("Outlook2 Test subject.msg", attachment); Console.WriteLine("Before removal = " + mapi.Attachments[mapi.Attachments.Count - 1].Properties.Count); mapi.Attachments[mapi.Attachments.Count - 1].RemoveProperty(923467779);// Delete anyone property Console.WriteLine("After removal = " + mapi.Attachments[mapi.Attachments.Count - 1].Properties.Count); mapi.Save(@"EMAIL_589265.msg"); MapiMessage mapi2 = MapiMessage.FromFile(@"EMAIL_589265.msg"); Console.WriteLine("Reloaded = " + mapi2.Attachments[mapi2.Attachments.Count - 1].Properties.Count); // ExEnd:RemovePropertiesFromMSGAndAttachments }