/// <summary> /// Sends an email asynchronously. /// </summary> /// <param name="emailMessage">The email message.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns> /// A Task. /// </returns> public Task SendAsync(IEmailMessage emailMessage, CancellationToken cancellationToken = default(CancellationToken)) { Contract.Requires(emailMessage != null); Contract.Ensures(Contract.Result<Task>() != null); return Contract.Result<Task>(); }
public async void SendEmail(IEmailMessage email) { if (email == null) { throw new ArgumentNullException(nameof(email)); } if (CanSendEmail) { Tizen.Messaging.Email.EmailMessage emailMessage = new Tizen.Messaging.Email.EmailMessage(); EmailRecipient emailRecipientTo = new EmailRecipient(); foreach (var to in email.Recipients) { emailRecipientTo.Address = to; emailMessage.To.Add(emailRecipientTo); } emailMessage.Subject = email.Subject; emailMessage.Body = email.Message; Tizen.Messaging.Email.EmailAttachment emailAttachment = new Tizen.Messaging.Email.EmailAttachment(); foreach (var attachment in email.Attachments.Cast <EmailAttachment>()) { emailAttachment.FilePath = attachment.FilePath; emailMessage.Attachments.Add(emailAttachment); } await EmailSender.SendAsync(emailMessage); } }
public void Send( IEmailMessage emailMessage ) { var smtp = new SmtpClient { Credentials = new NetworkCredential( _username, _password ), Host = _address, Timeout = _timeoutInSeconds*1000 } ; using ( var mailMessage = new MailMessage { From = emailMessage.From, Body = emailMessage.Body, Subject = emailMessage.Subject, } ) { mailMessage.To.Add( recipientsToCommaSeparatedString( emailMessage.Recipients ) ); foreach ( string eachAttachmentPath in emailMessage.Attachments ) { mailMessage.Attachments.Add( new Attachment( eachAttachmentPath ) ); } smtp.Send( mailMessage ); } }
/// <summary> /// Adds all files on the given <paramref name="objVerEx"/> to the <paramref name="emailMessage"/>. /// </summary> /// <param name="emailMessage">The email message to add the files to.</param> /// <param name="objVerEx">The object version that has the files.</param> /// <param name="fileFormat">The format for the attached files.</param> public static void AddAllFiles ( this IEmailMessage emailMessage, ObjVerEx objVerEx, MFFileFormat fileFormat = MFFileFormat.MFFileFormatNative ) { // Sanity. if (null == emailMessage) { throw new ArgumentNullException(nameof(emailMessage)); } if (null == objVerEx) { throw new ArgumentNullException(nameof(objVerEx)); } if (null == objVerEx.Vault) { throw new ArgumentException("The objVerEx's vault reference is null.", nameof(objVerEx)); } if (null == objVerEx.Vault) { throw new ArgumentException("The objVerEx's info (ObjectVersion) reference is null.", nameof(objVerEx)); } // Use the base implementation. emailMessage.AddAllFiles(objVerEx.Info, objVerEx.Vault, fileFormat); }
public async Task <OperationResult> SendEmail(IEmailMessage emailMessage) { try { var msg = new MailMessage { From = new MailAddress("*****@*****.**", "Website Contact Form"), Subject = emailMessage.Subject, Body = emailMessage.Body, IsBodyHtml = emailMessage.IsBodyHtml, To = { emailMessage.To } }; var awsCredential = new AwsCredential(_awsConfig.AccessKeyId, _awsConfig.SecretKey); using (var client = new SesClient(AwsRegion.USEast1, awsCredential)) { var sendEmailResult = await client.SendEmailAsync(msg); return(OperationResult.Ok(sendEmailResult)); } } catch (Exception ex) { return(OperationResult.Error(ex)); } }
public static async Task <(string id, Exception error)> send(IEmailMessage message) { if (_impl != null) { return(await _impl.send(message)); } return(default, new NotImplementedException());
public void SendEmail(IEmailMessage email) { if (email == null) throw new ArgumentNullException("email"); if (CanSendEmail) { // NOTE: Refer to http://www.faqs.org/rfcs/rfc2368.html for info on mailto protocol if (email.RecipientsBcc.Count > 0) Debug.WriteLine("Bcc headers are inherently unsafe to include in a message generated from a URL - ignoring RecipientBcc"); var sb = new StringBuilder(); sb.AppendFormat(CultureInfo.InvariantCulture, "mailto:{0}?", ToDelimitedAddress(email.Recipients)); if (email.RecipientsCc.Count > 0) sb.AppendFormat(CultureInfo.InvariantCulture, "cc={0}&", ToDelimitedAddress(email.RecipientsCc)); sb.AppendFormat(CultureInfo.InvariantCulture, "subject={0}&body={1}", email.Subject, email.Message); var escaped = Uri.EscapeUriString(sb.ToString()); Launcher.LaunchUriAsync(new Uri(escaped, UriKind.Absolute)); } }
// Preferred method to send email. Modify interface for new features... public SendEmailResponse <INotification> SendSmtpMail(IEmailMessage emailMessage) { SendEmailResponse <INotification> result = new SendEmailResponse <INotification>(); try { using (MailMessage mailMessage = emailMessage.ToMailMessage()) using (SmtpClient smtp = new SmtpClient()) { smtp.Send(mailMessage); } } catch (SmtpException smtpException) { result.Value = new Notification(smtpException); } catch (InvalidOperationException invalidOperationException) { result.Value = new Notification(invalidOperationException); } catch (ArgumentException argumentExceptionException) { result.Value = new Notification(argumentExceptionException); } return(result); }
private void getMessages(int numberOfMessagesToReceive) { try { if (connectToServer()) { int numberOfMessagesOnServer = emailClient.GetMessageCount(); if (numberOfMessagesOnServer == 0) { throw new EmailServiceException("brak wiadomości na serwerze " + "emailClient.IsConnected " + emailClient.IsConnected); } for (int i = numberOfMessagesOnServer - 1; i >= 0 && i > (numberOfMessagesOnServer - 1 - numberOfMessagesToReceive); i--) { IEmailMessage emailMessage = getOneEmail(i); emailsReceived.AddLast(emailMessage); } } } catch (MailKit.Net.Pop3.Pop3ProtocolException e) { throw new EmailServiceException("Email service error", e); } catch (MailKit.ServiceNotConnectedException e) { throw new EmailServiceException("Email service error", e); } }
public virtual async Task ComposeEmail(IEmailMessage emailMessage) { if (emailMessage == null) { throw new ArgumentNullException("emailMessage", "Supplied argument 'emailMessage' is null."); } if (!CanComposeEmail) { throw new FeatureNotAvailableException(); } var task = new EmailComposeTask { To = emailMessage.To.ToString(), Cc = emailMessage.Cc.ToString(), Bcc = emailMessage.Bcc.ToString(), Subject = emailMessage.Subject, Body = emailMessage.Body }; task.Show(); }
public async Task RecordEmailSent(IEmailMessage message) { if (!message.IsNew) { await Database.Delete(message); } }
/// <summary> /// Creates an SMTP mail message for a specified mail item. /// </summary> static async Task <MailMessage> CreateMailMessage(IEmailMessage mailItem) { if (mailItem.SendableDate > LocalTime.Now) { return(null); // Not due yet } var mail = new MailMessage { Subject = mailItem.Subject.Or("[NO SUBJECT]").Remove("\r", "\n") }; mailItem.GetEffectiveToAddresses().Do(x => mail.To.Add(x)); mailItem.GetEffectiveCcAddresses().Do(x => mail.CC.Add(x)); mailItem.GetEffectiveBccAddresses().Do(x => mail.Bcc.Add(x)); if (mail.To.None() && mail.CC.None() && mail.Bcc.None()) { Debug.WriteLine($"Mail message {mailItem.GetId()} will not be sent as there is no effective recipient."); return(null); } mail.AlternateViews.AddRange(mailItem.GetEffectiveBodyViews()); mail.From = new MailAddress(mailItem.GetEffectiveFromAddress(), mailItem.GetEffectiveFromName()); mail.ReplyToList.Add(new MailAddress(mailItem.GetEffectiveReplyToAddress(), mailItem.GetEffectiveReplyToName())); mail.Attachments.AddRange(await mailItem.GetAttachments()); return(mail); }
public bool SendMessage(IEmailMessage message) { if (!Platform.IsWindows) { return(false); } var mapi = new MAPI(); foreach (string recipient in message.To) { Debug.Assert(!string.IsNullOrEmpty(recipient), "Email address for reporting is empty"); mapi.AddRecipientTo(recipient); } foreach (string recipient in message.Cc) { mapi.AddRecipientCc(recipient); } foreach (string recipient in message.Bcc) { mapi.AddRecipientBcc(recipient); } foreach (string attachmentFilePath in message.AttachmentFilePath) { mapi.AddAttachment(attachmentFilePath); } //this one is better if it works (and it does for Microsoft emailers), but //return mapi.SendMailDirect(message.Subject, message.Body); //this one works for thunderbird, too. It opens a window rather than just sending: return(mapi.SendMailPopup(message.Subject, message.Body)); }
public void SendEmail(IEmailMessage email) { if (email == null) { throw new ArgumentNullException(nameof(email)); } if (CanSendEmail) { // NOTE: Refer to http://www.faqs.org/rfcs/rfc2368.html for info on mailto protocol if (email.RecipientsBcc.Count > 0) { Debug.WriteLine("Bcc headers are inherently unsafe to include in a message generated from a URL - ignoring RecipientBcc"); } var sb = new StringBuilder(); sb.AppendFormat(CultureInfo.InvariantCulture, "mailto:{0}?", ToDelimitedAddress(email.Recipients)); if (email.RecipientsCc.Count > 0) { sb.AppendFormat(CultureInfo.InvariantCulture, "cc={0}&", ToDelimitedAddress(email.RecipientsCc)); } sb.AppendFormat(CultureInfo.InvariantCulture, "subject={0}&body={1}", email.Subject, email.Message); var escaped = Uri.EscapeUriString(sb.ToString()); #pragma warning disable 4014 Launcher.LaunchUriAsync(new Uri(escaped, UriKind.Absolute)); #pragma warning restore 4014 } }
/// <summary> /// Will try to send the specified email and returns true for successful sending. /// </summary> public static async Task <bool> Send(IEmailMessage mailItem) { if (mailItem == null) { throw new ArgumentNullException(nameof(mailItem)); } if (mailItem.Retries >= MaximumRetries) { return(false); } MailMessage mail = null; try { using (mail = await CreateMailMessage(mailItem)) { if (mail == null) { return(false); } return(await EmailDispatcher(mailItem, mail)); } } catch (Exception ex) { await SendError.Raise(new EmailSendingEventArgs(mailItem, mail) { Error = ex }); await mailItem.RecordRetry(); Log.Error($"Error in sending an email for this EmailQueueItem of '{mailItem.GetId()}'", ex); return(false); } }
public void SendEmail(IEmailMessage email) { if (email == null) throw new ArgumentNullException("email"); if (CanSendEmail) { var mail = new Windows.ApplicationModel.Email.EmailMessage { Subject = email.Subject, Body = email.Message }; foreach (var recipient in email.Recipients) { mail.To.Add(new EmailRecipient(recipient)); } foreach (var recipient in email.RecipientsCc) { mail.CC.Add(new EmailRecipient(recipient)); } foreach (var recipient in email.RecipientsBcc) { mail.Bcc.Add(new EmailRecipient(recipient)); } foreach (var attachment in email.Attachments.Cast<EmailAttachment>()) { mail.Attachments.Add(new Windows.ApplicationModel.Email.EmailAttachment( attachment.FileName, attachment.Content)); } EmailManager.ShowComposeNewEmailAsync(mail); } }
public static string GetEmailFileName(IEmailMessage email) { string fileName; if (String.IsNullOrEmpty(email.Subject)) { fileName = "(no name)"; } else { var invalidChars = Path.GetInvalidFileNameChars(); var chars = email.Subject.ToCharArray(); for (int i = 0; i < chars.Length; i++) { for (int j = 0; j < invalidChars.Length; j++) { if (chars[i] == invalidChars[j]) { chars[i] = '_'; } } } fileName = new String(chars); } return(fileName + ".eml"); }
public Task <OperationResult> SendEmail(IEmailMessage emailMessage) { Debug.WriteLine(emailMessage.To.ToString()); Debug.WriteLine(emailMessage.Body); return(Task.FromResult(OperationResult.Ok())); }
private void ValidateEmailMessage(IEmailMessage emailMessage) { if (emailMessage == null) { throw new EmailMessageNotFoundException("Email Message is null and contains no information"); } }
public bool SendMessage(IEmailMessage message) { #if MONO return false; #else var mapi = new MAPI(); foreach (string recipient in message.To) { Debug.Assert(!string.IsNullOrEmpty(recipient),"Email address for reporting is empty"); mapi.AddRecipientTo(recipient); } foreach (string recipient in message.Cc) { mapi.AddRecipientCc(recipient); } foreach (string recipient in message.Bcc) { mapi.AddRecipientBcc(recipient); } foreach (string attachmentFilePath in message.AttachmentFilePath) { mapi.AddAttachment(attachmentFilePath); } //this one is better if it works (and it does for Microsoft emailers), but //return mapi.SendMailDirect(message.Subject, message.Body); //this one works for thunderbird, too. It opens a window rather than just sending: return mapi.SendMailPopup(message.Subject, message.Body); #endif }
/// <summary> /// Attaches a file to this email. /// </summary> /// <param name="this">The email queue item.</param> /// <param name="file">The path of the attachment file. /// This must be the physical path of a file inside the running application.</param> public static void Attach(this IEmailMessage @this, FileInfo file) { if (file == null) { throw new ArgumentNullException(nameof(file)); } var basePath = AppDomain.CurrentDomain.WebsiteRoot().FullName.ToLower(); var path = file.FullName; if (path.StartsWith(basePath, caseSensitive: false)) // Relative: { path = path.Substring(basePath.Length).TrimStart("\\"); } if (@this.Attachments.IsEmpty()) { @this.Attachments = path; } else { @this.Attachments += "|" + path; } }
/// <summary> /// Sends the email. /// </summary> /// <param name="message">The message.</param> /// <returns><c>true</c> if email sent succesfully, <c>false</c> otherwise.</returns> public bool SendEmail(IEmailMessage message) { if (message == null) { return(false); } //Smtp settings ?? is it OK to read setting directly here from config? var smtp = (SmtpSection)ConfigurationManager.GetSection("system.net/mailSettings/smtp"); // Create the email object first, then add the properties. var eMessage = SendGrid.GetInstance(); eMessage.From = !string.IsNullOrEmpty(message.From) ? new MailAddress(message.From) : new MailAddress(smtp.From); // Add multiple addresses to the To field. eMessage.AddTo(message.To); eMessage.Subject = message.Subject; //Add the HTML and Text bodies eMessage.Html = message.Html; eMessage.Text = message.Text; //Add attachments if (message.Attachments != null && message.Attachments.Count > 0) { foreach (var attachment in message.Attachments) { try { using (var stream = new MemoryStream(attachment.Length)) { stream.Write(attachment, 0, attachment.Length); stream.Position = 0; eMessage.AddAttachment(stream, "file_" + message.Attachments.IndexOf(attachment)); } } catch { return(false); } } } // Create credentials, specifying your user name and password. var credentials = new NetworkCredential(smtp.Network.UserName, smtp.Network.Password); // Create an SMTP transport for sending email. var transportSMTP = SMTP.GetInstance(credentials, smtp.Network.Host, smtp.Network.Port); // Send the email. try { transportSMTP.Deliver(eMessage); } catch { return(false); } return(true); }
public async Task <HttpResponseMessage> SendAsync(IEmailMessage emailMessage) { using (var client = new HttpClient { BaseAddress = new Uri(_emailConfiguration.ApiBaseUri) }) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes("api:" + _emailConfiguration.ApiKey))); var toAddresses = new List <KeyValuePair <string, string> >(); foreach (var address in emailMessage.ToAddresses) { toAddresses.Add(new KeyValuePair <string, string>("to", address)); } var content = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("from", _emailConfiguration.From), new KeyValuePair <string, string>("subject", emailMessage.Subject), new KeyValuePair <string, string>("html", emailMessage.Content) }.Union(toAddresses).ToArray()); return(await client.PostAsync(_emailConfiguration.ApiBaseUri + "/messages", content).ConfigureAwait(false)); } }
public void Send(IEmailMessage emailMessage) { var smtp = new SmtpClient { Credentials = new NetworkCredential(_username, _password), Host = _address, Timeout = _timeoutInSeconds * 1000 }; using (var mailMessage = new MailMessage { From = emailMessage.From, Body = emailMessage.Body, Subject = emailMessage.Subject, }) { mailMessage.To.Add(recipientsToCommaSeparatedString(emailMessage.Recipients)); foreach (string eachAttachmentPath in emailMessage.Attachments) { mailMessage.Attachments.Add(new Attachment(eachAttachmentPath)); } smtp.Send(mailMessage); } }
public EnvoiFichePaieViewModel(IRegionManager regionManager, IDataTableFormExcelFileDataService dataTableFormExcelFileDataService, IDialogService dialogService, IEmailMessage emailMessage) { _logger.Debug($"-- ******** Demarrage du module ******** [Nom de la machine :] " + $"{Environment.MachineName} ******* --"); IsPreviewEmail = false; IsFilePathVisible = false; IsMainGridEnable = true; IsProgressBarVisible = false; _regionManager = regionManager; _dialogService = dialogService; _emailMessage = emailMessage; _dataTableFormExcelFileDataService = dataTableFormExcelFileDataService; _logger.Debug($"==> Debut Initialisation des commandes..."); BrowseCommand = new DelegateCommand(OnBrowse, CanBrowse); SendMailCommand = new DelegateCommand(OnSendMail, CanSendMail); //.ObservesProperty(() => _emailMessage.ToEmail); SendPreviewCommand = new DelegateCommand(OnSendPreview, CanSendPreview); CleerBccOrCcMailCommand = new DelegateCommand(OnClearBccAndCcMail, CanClearBccOrCcMail); ChooseMailTemplateCommand = new DelegateCommand(OnChooseMailTemplate, CanChooseMailTemplate); _logger.Debug($"==> Fin Initialisation des commandes..."); #region -- Thread for cut chart -- bgWorkerExport = new BackgroundWorker(); bgWorkerExport.WorkerReportsProgress = true; bgWorkerExport.DoWork += Export_DoWork; bgWorkerExport.RunWorkerCompleted += Export_RunWorkerCompleted; bgWorkerExport.ProgressChanged += new ProgressChangedEventHandler(this.Export_ProgressChanged); #endregion }
public static void SendSampleEmail(this IEmailTask emailTask, IEmailMessage email) { if (emailTask.CanSendEmail) { emailTask.SendEmail(email); } }
private void AddBccAddress(IEmailMessage emailMessage, MimeMessage message) { if (emailMessage.BccAddress != null && emailMessage.BccAddress.Any()) { message.Bcc.AddRange(emailMessage.BccAddress.Select(x => new MailboxAddress(x.Name, x.Address))); } }
private void getEmails(IEmailMessage benchmarkEmail) { try { if (connectToServer()) { emailClient.Inbox.Open(FolderAccess.ReadWrite); int numberOfEmailsOnServer = emailClient.Inbox.Count; if (numberOfEmailsOnServer == 0) { throw new EmailServiceException("brak wiadomości na serwerze " + emailAccountConfiguration.receiveServer.url + " emailClient.IsConnected " + emailClient.IsConnected); } int emailIndex = numberOfEmailsOnServer - 1; //index ostatniego, tj najnowszego, maila na serwerze IEmailMessage emailMessage; do { emailMessage = getOneEmail(emailIndex); tryAddToNewEmailsList(benchmarkEmail, emailMessage); emailIndex--; }while (conditionContinueGettingEmails(benchmarkEmail, emailMessage)); } } catch (Exception e) { throw new EmailServiceException("Email service error", e); } }
public static void TrySend(this ISendMail sender, IEmailMessage message) { if (sender != null) { sender.Send(message); } }
private void getEmails(int numberOfEmailsToReceive) { try { if (connectToServer()) { emailClient.Inbox.Open(FolderAccess.ReadOnly); //testMethod(); int numberOfEmailsOnServer = emailClient.Inbox.Count; if (numberOfEmailsOnServer == 0) { throw new EmailServiceException("brak wiadomości na serwerze " + emailAccountConfiguration.receiveServer.url + " emailClient.IsConnected " + emailClient.IsConnected); } for (int i = numberOfEmailsOnServer - 1; i >= 0 && i > (numberOfEmailsOnServer - 1 - numberOfEmailsToReceive); i--) { IEmailMessage emailMessage = getOneEmail(i); emailsReceived.AddLast(emailMessage); } } } catch (ImapProtocolException e) { throw new EmailServiceException("Email service error", e); } catch (MailKit.ServiceNotConnectedException e) { throw new EmailServiceException("Email service error", e); } }
public async Task SaveForFutureSend(IEmailMessage message) { if (message.IsNew) { await Database.Save(message); } }
IEnumerable <AlternateView> GetBodyViews(IEmailMessage message) { yield return(AlternateView.CreateAlternateViewFromString( message.Body.RemoveHtmlTags(), new ContentType("text/plain; charset=UTF-8"))); if (message.Html) { var htmlView = AlternateView.CreateAlternateViewFromString( message.Body, new ContentType("text/html; charset=UTF-8")); htmlView.LinkedResources.AddRange(AttachmentSerializer.GetLinkedResources(message)); yield return(htmlView); } if (message.VCalendarView.HasValue()) { var calendarType = new ContentType("text/calendar"); calendarType.Parameters.Add("method", "REQUEST"); calendarType.Parameters.Add("name", "meeting.ics"); var calendarView = AlternateView .CreateAlternateViewFromString(message.VCalendarView, calendarType); calendarView.TransferEncoding = TransferEncoding.SevenBit; yield return(calendarView); } }
public virtual Task ComposeEmail(IEmailMessage emailMessage) { if (!CanComposeEmail) { throw new FeatureNotAvailableException(); } var intent = new Intent(Intent.ActionSend); intent.PutExtra(Intent.ExtraEmail, emailMessage.To.Select(x => x.Address).ToArray()); intent.PutExtra(Intent.ExtraCc, emailMessage.Cc.Select(x => x.Address).ToArray()); intent.PutExtra(Intent.ExtraBcc, emailMessage.Bcc.Select(x => x.Address).ToArray()); intent.PutExtra(Intent.ExtraTitle, emailMessage.Subject); if (emailMessage.IsHTML) { intent.PutExtra(Intent.ExtraText, Html.FromHtml(emailMessage.Body)); } else { intent.PutExtra(Intent.ExtraText, emailMessage.Body); } intent.SetType("message/rfc822"); intent.StartNewActivity(); return Task.FromResult(true); }
MailAddress CreateFrom(IEmailMessage message) { var address = message.FromAddress.Or(Config.From?.Address); var name = message.FromName.Or(Config.From?.Name); return(new MailAddress(address, name)); }
/// <summary> /// Creates a VCalendar text with the specified parameters. /// </summary> /// <param name="meetingUniqueIdentifier">This uniquely identifies the meeting and is used for changes / cancellations. It is recommended to use the ID of the owner object.</param> public static string AddVCalendarView(this IEmailMessage @this, string meetingUniqueIdentifier, DateTime start, DateTime end, string subject, string description, string location) { var dateFormat = "yyyyMMddTHHmmssZ"; Func <string, string> cleanUp = s => s.Or("").Remove("\r").Replace("\n", "\\n"); var r = new StringBuilder(); r.AppendLine(@"BEGIN:VCALENDAR"); r.AppendLine(@"PRODID:-//Microsoft Corporation//Outlook 12.0 MIMEDIR//EN"); r.AppendLine(@"VERSION:1.0"); r.AppendLine(@"BEGIN:VEVENT"); r.AddFormattedLine(@"DTSTART:{0}", start.ToString(dateFormat)); r.AddFormattedLine(@"DTEND:{0}", end.ToString(dateFormat)); r.AddFormattedLine(@"UID:{0}", meetingUniqueIdentifier); r.AddFormattedLine(@"SUMMARY:{0}", cleanUp(subject)); r.AppendLine("LOCATION:" + cleanUp(location)); r.AppendLine("DESCRIPTION:" + cleanUp(description)); // bodyCalendar.AppendLine(@"PRIORITY:3"); r.AppendLine(@"END:VEVENT"); r.AppendLine(@"END:VCALENDAR"); return(@this.VCalendarView = r.ToString()); }
static async Task <bool> SendViaSmtp(IEmailMessage mailItem, MailMessage mail) { using (var smtpClient = new SmtpClient()) { smtpClient.EnableSsl = mailItem.EnableSsl ?? Config.GetOrThrow("Email:EnableSsl").To <bool>(); smtpClient.Port = mailItem.SmtpPort ?? Config.GetOrThrow("Email:SmtpPort").To <int>(); smtpClient.Host = mailItem.SmtpHost.OrNullIfEmpty() ?? Config.GetOrThrow("Email:SmtpHost"); var userName = mailItem.Username.OrNullIfEmpty() ?? Config.GetOrThrow("Email:Username"); var password = mailItem.Password.OrNullIfEmpty() ?? Config.GetOrThrow("Email:Password"); smtpClient.Credentials = new NetworkCredential(userName, password); await Sending.Raise(new EmailSendingEventArgs(mailItem, mail)); await smtpClient.SendMailAsync(mail); if (!mailItem.IsNew) { await Entity.Database.Delete(mailItem); } await Sent.Raise(new EmailSendingEventArgs(mailItem, mail)); } return(true); }
/// <summary> /// Sends the email. /// </summary> /// <param name="message">The message.</param> public bool SendEmail(IEmailMessage message) { if (message == null) { return false; } var eMessage = new MailMessage(); if (!string.IsNullOrEmpty(message.From)) { eMessage.From = new MailAddress(message.From); } foreach (var to in message.To.Where(to => !string.IsNullOrEmpty(to))) { eMessage.To.Add(new MailAddress(to)); } eMessage.Subject = message.Subject; if (!string.IsNullOrEmpty(message.Html)) { eMessage.Body = message.Html; eMessage.IsBodyHtml = true; } else if (!string.IsNullOrEmpty(message.Text)) { eMessage.Body = message.Text; } //Add attachments var openedStream = new List<Stream>(); if (message.Attachments != null & message.Attachments.Count > 0) { foreach (var attachment in message.Attachments) { try { var stream = new MemoryStream(attachment.Length); stream.Write(attachment, 0, attachment.Length); stream.Position = 0; var eAttachment = new Attachment(stream, (string)null); eMessage.Attachments.Add(eAttachment); openedStream.Add(stream); } catch { return false; } } } var client = new SmtpClient(); client.Send(eMessage); //Must close streams here otherwise client.Send will fail with exception openedStream.ForEach(s => s.Dispose()); return true; }
public void SendEmail(IEmailMessage email) { // NOTE: http://developer.xamarin.com/recipes/android/networking/email/send_an_email/ if (email == null) throw new ArgumentNullException("email"); if (CanSendEmail) { // NOTE: http://developer.android.com/guide/components/intents-common.html#Email string intentAction = Intent.ActionSend; if (email.Attachments.Count > 1) intentAction = Intent.ActionSendMultiple; Intent emailIntent = new Intent(intentAction); emailIntent.SetType("message/rfc822"); if (email.Recipients.Count > 0) emailIntent.PutExtra(Intent.ExtraEmail, email.Recipients.ToArray()); if (email.RecipientsCc.Count > 0) emailIntent.PutExtra(Intent.ExtraCc, email.RecipientsCc.ToArray()); if (email.RecipientsBcc.Count > 0) emailIntent.PutExtra(Intent.ExtraBcc, email.RecipientsBcc.ToArray()); emailIntent.PutExtra(Intent.ExtraSubject, email.Subject); // NOTE: http://stackoverflow.com/questions/13756200/send-html-email-with-gmail-4-2-1 if (((EmailMessage)email).IsHtml) emailIntent.PutExtra(Intent.ExtraText, Html.FromHtml(email.Message)); else emailIntent.PutExtra(Intent.ExtraText, email.Message); if (email.Attachments.Count > 0) { var uris = new List<IParcelable>(); foreach (var attachment in email.Attachments) { var uri = Android.Net.Uri.Parse("file://" + ((EmailAttachment)attachment).FilePath); uris.Add(uri); } if (uris.Count > 1) emailIntent.PutParcelableArrayListExtra(Intent.ExtraStream, uris); else emailIntent.PutExtra(Intent.ExtraStream, uris[0]); } emailIntent.StartNewActivity(); } }
public Plugin( IEmailServer emailServer, IEmailMessage emailMessage, IStaticSettings staticSettings, IDisk disk) { _emailServer = emailServer ; _emailMessage = emailMessage ; _staticSettings = staticSettings ; _disk = disk ; }
/// <summary> /// Sends the email. /// </summary> /// <param name="message">The message.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns> public bool SendEmail(IEmailMessage message) { if (message == null) { return false; } //Smtp settings ?? is it OK to read setting directly here from config? var smtp = (SmtpSection)ConfigurationManager.GetSection("system.net/mailSettings/smtp"); // Create the email object first, then add the properties. var eMessage = SendGrid.GetInstance(); eMessage.From = !string.IsNullOrEmpty(message.From) ? new MailAddress(message.From) : new MailAddress(smtp.From); // Add multiple addresses to the To field. eMessage.AddTo(message.To); eMessage.Subject = message.Subject; //Add the HTML and Text bodies eMessage.Html = message.Html; eMessage.Text = message.Text; //Add attachments if (message.Attachments != null && message.Attachments.Count > 0) { foreach (var attachment in message.Attachments) { try { using (var stream = new MemoryStream(attachment.Length)) { stream.Write(attachment, 0, attachment.Length); stream.Position = 0; eMessage.AddAttachment(stream, "file_" + message.Attachments.IndexOf(attachment)); } } catch { return false; } } } // Create credentials, specifying your user name and password. var credentials = new NetworkCredential(smtp.Network.UserName, smtp.Network.Password); // Create an SMTP transport for sending email. var transportSMTP = SMTP.GetInstance(credentials, smtp.Network.Host, smtp.Network.Port); // Send the email. transportSMTP.Deliver(eMessage); return true; }
internal UsageEmailDialog() { // // Required for Windows Form Designer support // InitializeComponent(); richTextBox2.Text = "May we ask you a favor? We would like to send a tiny e-mail back to the software developers telling us of your progress.\nYou will be able to view the e-mail before it goes out. You do not need to be connected to the Internet right now...the e-mail will just open and you can save it in your outbox."; m_topLineText.Text = string.Format(this.m_topLineText.Text, UsageReporter.AppNameToUseInDialogs); _emailProvider = EmailProviderFactory.PreferredEmailProvider(); _emailMessage = _emailProvider.CreateMessage(); }
/// <summary> /// Sends the provided email message /// </summary> public void Send(IEmailMessage emailMessage) { if (emailMessage == null) { throw new ArgumentNullException("emailMessage"); } // Fail Gracefully if SMTP Settings are not set if(string.IsNullOrWhiteSpace(this.SMTPConfiguration.Host) || this.SMTPConfiguration.Port == 0) { return; } var message = new MailMessage(); // Set Sender message.From = new MailAddress(emailMessage.SenderAddress, emailMessage.SenderDisplayName); // Set Recipients emailMessage.ToRecipients.ForEach(x => message.To.Add(x)); emailMessage.CcRecipients.ForEach(x => message.CC.Add(x)); emailMessage.BccRecipients.ForEach(x => message.Bcc.Add(x)); emailMessage.ReplyToRecipients.ForEach(x => message.ReplyToList.Add(x)); // Set Content message.IsBodyHtml = emailMessage.FormatAsHtml; message.Body = emailMessage.BuildMessageBody(); message.Subject = emailMessage.Subject; // Set Attachments if(emailMessage.Attachments.Count > 0) { emailMessage.Attachments.ForEach(x => { var attachment = new Attachment(x.GetContentStream(), x.Name); message.Attachments.Add(attachment); }); } // Set SMTP Settings var smtpClient = new SmtpClient(this.SMTPConfiguration.Host, this.SMTPConfiguration.Port); smtpClient.EnableSsl = this.SMTPConfiguration.EnableSSL; // Set Credentials if (!string.IsNullOrWhiteSpace(this.SMTPConfiguration.Username) || !string.IsNullOrWhiteSpace(this.SMTPConfiguration.Password)) { smtpClient.UseDefaultCredentials = this.SMTPConfiguration.UseDefaultCredentials; smtpClient.Credentials = new NetworkCredential(this.SMTPConfiguration.Username, this.SMTPConfiguration.Password); } // Send Message smtpClient.Send(message); }
public bool SendMessage(IEmailMessage message) { string body = EscapeString(message.Body); string subject = EscapeString(message.Subject); var recipientTo = message.To; var toBuilder = new StringBuilder(); for (int i = 0; i < recipientTo.Count; ++i) { if (i > 0) { toBuilder.Append(","); } toBuilder.Append(recipientTo[i]); } string commandLine; if (message.AttachmentFilePath.Count == 0) { commandLine = String.Format( FormatStringNoAttachments, toBuilder, subject, body ); } else { // DG: attachments untested with xdg-email // review CP: throw if AttachmentFilePath.Count > 0 ? // review CP: throw if file not present? string attachments = EscapeString(String.Format(FormatStringAttachFile, message.AttachmentFilePath[0])); commandLine = String.Format( FormatStringWithAttachments, toBuilder, subject, attachments, body ); } Console.WriteLine(commandLine); var p = new Process { StartInfo = { FileName = EmailCommand, Arguments = commandLine, UseShellExecute = true, ErrorDialog = true } }; return p.Start(); // Always return true. The false from p.Start may only indicate that the email client // was already open. // DG: This may be different with xdg-email //return true; }
private MailMessage PopulateMailMessage(IEmailMessage email) { MailMessage message = new MailMessage(); message.From = new MailAddress(email.From); message.To.Add(new MailAddress(email.To)); message.Subject = email.Subject; message.Body = email.Body; message.Headers.Add("X-SME-AppDomain", AppDomain.CurrentDomain.FriendlyName); message.IsBodyHtml = email.IsHtml; return message; }
public bool SendMessage(IEmailMessage message) { //string body = _body.Replace(System.Environment.NewLine, "%0A").Replace("\"", "%22").Replace("&", "%26"); string body = Uri.EscapeDataString(message.Body); string subject = Uri.EscapeDataString(message.Subject); var recipientTo = message.To; var toBuilder = new StringBuilder(); for (int i = 0; i < recipientTo.Count; ++i) { if (i > 0) { toBuilder.Append(","); } toBuilder.Append(recipientTo[i]); } string commandLine = ""; if (message.AttachmentFilePath.Count == 0) { commandLine = String.Format("mailto:{0}?subject={1}&body={2}", toBuilder, subject, body); } else { // review CP: throw if AttachmentFilePath.Count > 0 ? // review CP: throw if file not present? string attachments = message.AttachmentFilePath[0]; commandLine = String.Format("mailto:{0}?subject={1}&attachment={2}&body={3}", toBuilder, subject, attachments, body); } Console.WriteLine(commandLine); var p = new Process { StartInfo = { FileName = commandLine, UseShellExecute = true, ErrorDialog = true } }; p.Start(); // Always return true. The false from p.Start may only indicate that the email client // was already open. return true; }
public void SendEmail(IEmailMessage email) { if (email == null) throw new ArgumentNullException("email"); if (CanSendEmail) { EmailComposeTask emailComposeTask = new EmailComposeTask { Subject = email.Subject, Body = email.Message, To = ToDelimitedAddress(email.Recipients), Cc = ToDelimitedAddress(email.RecipientsCc), Bcc = ToDelimitedAddress(email.RecipientsBcc) }; emailComposeTask.Show(); } }
public void SendEmail(IEmailMessage email) { // NOTE: http://developer.xamarin.com/recipes/android/networking/email/send_an_email/ if (email == null) throw new ArgumentNullException("email"); if (email.Attachments.Count > 1) throw new NotSupportedException("Cannot send more than once attachment for Android"); if (CanSendEmail) { Intent emailIntent = new Intent(Intent.ActionSend); emailIntent.SetType("message/rfc822"); if (email.Recipients.Count > 0) emailIntent.PutExtra(Intent.ExtraEmail, email.Recipients.ToArray()); if (email.RecipientsCc.Count > 0) emailIntent.PutExtra(Intent.ExtraCc, email.RecipientsCc.ToArray()); if (email.RecipientsBcc.Count > 0) emailIntent.PutExtra(Intent.ExtraBcc, email.RecipientsBcc.ToArray()); emailIntent.PutExtra(Intent.ExtraSubject, email.Subject); // NOTE: http://stackoverflow.com/questions/13756200/send-html-email-with-gmail-4-2-1 if (((EmailMessage) email).IsHtml) emailIntent.PutExtra(Intent.ExtraText, Html.FromHtml(email.Message)); else emailIntent.PutExtra(Intent.ExtraText, email.Message); if (email.Attachments.Count > 0) { var attachment = (EmailAttachment) email.Attachments[0]; var uri = Android.Net.Uri.Parse("file://" + attachment.FilePath); emailIntent.PutExtra(Intent.ExtraStream, uri); } emailIntent.StartNewActivity(); } }
public void SendEmail(IEmailMessage email) { if (email == null) throw new ArgumentNullException("email"); if (CanSendEmail) { _mailController = new MFMailComposeViewController(); _mailController.SetSubject(email.Subject); _mailController.SetMessageBody(email.Message, ((EmailMessage) email).IsHtml); _mailController.SetToRecipients(email.Recipients.ToArray()); if (email.RecipientsCc.Count > 0) _mailController.SetCcRecipients(email.RecipientsCc.ToArray()); if (email.RecipientsBcc.Count > 0) _mailController.SetBccRecipients(email.RecipientsBcc.ToArray()); foreach (var attachment in email.Attachments.Cast<EmailAttachment>()) { _mailController.AddAttachmentData(NSData.FromStream(attachment.Content), attachment.ContentType, attachment.FileName); } EventHandler<MFComposeResultEventArgs> handler = null; handler = (sender, e) => { _mailController.Finished -= handler; var uiViewController = sender as UIViewController; if (uiViewController == null) { throw new ArgumentException("sender"); } uiViewController.DismissViewController(true, () => { }); }; _mailController.Finished += handler; _mailController.PresentUsingRootViewController(); } }
public virtual async Task ComposeEmail(IEmailMessage emailMessage) { if (emailMessage == null) { throw new ArgumentNullException("emailMessage", "Supplied argument 'emailMessage' is null."); } if (!CanComposeEmail) { throw new FeatureNotAvailableException(); } var email = new Windows.ApplicationModel.Email.EmailMessage() { }; await EmailManager.ShowComposeNewEmailAsync(null); }
public virtual Task ComposeEmail(IEmailMessage emailMessage) { if (!CanComposeEmail) { throw new FeatureNotAvailableException(); } var mailer = new MFMailComposeViewController(); mailer.SetToRecipients(emailMessage.To.ToArray()); mailer.SetCcRecipients(emailMessage.Cc.ToArray()); mailer.SetBccRecipients(emailMessage.Bcc.ToArray()); mailer.SetSubject(emailMessage.Subject); mailer.SetMessageBody(emailMessage.Body, emailMessage.IsHTML); mailer.Finished += (s, e) => ((MFMailComposeViewController) s).DismissViewController(true, () => { }); UIApplication.SharedApplication.KeyWindow.RootViewController.PresentViewController(mailer, true, null); return Task.FromResult(true); }
public ISendEmailResult Dispatch(IEmailMessage email) { MailMessage message = PopulateMailMessage(email); return Dispatch(message); }
public static void Send(IEmailMessage message) { }
/// <summary> /// Sends an email asynchronously. /// </summary> /// <param name="emailMessage">The email message.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns> /// A Task. /// </returns> public Task SendAsync(IEmailMessage emailMessage, CancellationToken cancellationToken = default(CancellationToken)) { return TaskHelper.CompletedTask; }
/// <summary> /// Sends an email asynchronously. /// </summary> /// <param name="emailMessage">The email message.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns> /// A Task. /// </returns> public Task SendAsync(IEmailMessage emailMessage, CancellationToken cancellationToken = default(CancellationToken)) { var smtpClient = this.CreateSmtpClient(); return smtpClient.SendMailAsync(emailMessage.ToMailMessage()); }