public async Task Send(EMailMessage data)
{
if (!_smtpServer.Ativo)
{
return;
}
var smtpClient = new SmtpClient
{
Host = _smtpServer.Server,
Port = _smtpServer.Port,
EnableSsl = _smtpServer.SSL,
Credentials = new NetworkCredential(_smtpServer.Email, _smtpServer.Senha)
};
using (var message = new MailMessage(_smtpServer.Email, data.To)
{
Subject = data.Subject,
Body = data.Body
})
{
try
{
await smtpClient.SendMailAsync(message);
}
catch
{
return;
}
}
}
public void SendMailTest()
{
var obj = new EMailMessage
{
From = "*****@*****.**",
To = new List <string>
{
"*****@*****.**"
},
Subject = "Test",
Body = "<h1>Hi</h1>",
IsBodyHtml = true
};
Email.SendMail(obj, true);
obj = new EMailMessage
{
To = new List <string>
{
"*****@*****.**"
},
Subject = "Test",
Body = "<h1>Hi</h1>",
IsBodyHtml = true
};
Email.SendMail(obj, true);
Email.SendMail("Test", "Test", "*****@*****.**");
Assert.ThrowsException <ArgumentNullException>(() => Email.SendMail("Test", "Test", ""));
}
public bool MakeWorkNotificationEMail()
{
var emailMessages = repo.AllReadonly <EMailMessage>();
var notifications = repo.AllReadonly <WorkNotification>()
.Include(x => x.User)
.Where(x => x.User.WorkNotificationToMail == true)
.Where(x => !emailMessages.Any(e => e.SourceType == SourceTypeSelectVM.WorkNotification && e.SourceId == x.Id))
.ToList();
foreach (var notification in notifications)
{
var emailMessage = new EMailMessage();
emailMessage.SourceType = SourceTypeSelectVM.WorkNotification;
emailMessage.SourceId = notification.Id;
emailMessage.Body = notification.Description;
emailMessage.Title = notification.Title;
emailMessage.EmailAddress = notification.User.Email;
emailMessage.EMailMessageStateId = NomenclatureConstants.EMailMessageState.ForSend;
emailMessage.UserId = notification.UserId;
emailMessage.DateWrt = DateTime.Now;
repo.Add(emailMessage);
repo.SaveChanges();
}
return(true);
}
public void GetQueueCountTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
EMailService.EMailService emailService = new EMailService.EMailService(db, testCompany);
int expected = emailService.GetQueueCount();
// Create a message
string subject = RandomString(),
text = LorumIpsum();
var sender = new UserModel {
EMail = RandomEMail()
};
var message = new EMailMessage(sender, testUser, subject, text);
var result = emailService.SendEMail(message);
Assert.IsTrue(!result.IsError, result.Message);
int actual = emailService.GetQueueCount();
expected++;
Assert.IsTrue(actual == expected, $"Error: SendEMail returned error code {result} when 0 was expected");
// Delete the email
emailService.DeleteEMailQueue(result.Id);
actual = emailService.GetQueueCount();
expected--;
Assert.IsTrue(actual == expected, $"Error: SendEMail returned error code {result} when 0 was expected");
}
public EMailMessage CreateEmailFromRawText(string RawEmail)
{
EMailMessage result = new EMailMessage();
ParseEMailMessage(ref result, RawEmail);
return(result);
}
public Error SendMSQOverrideEMail(CompanyModel company,
UserModel sender,
UserModel recipient,
SalesOrderHeaderModel model)
{
var error = new Error();
// Send a message to the selected user, indicating that they have been
// nominated as an approver of an MSQ override
var message = new EMailMessage(sender, recipient, MessageTemplateType.MSQChangeNotification);
message.AddProperty("ORDERNO", model.OrderNumber);
message.AddProperty("SALESPERSON", sender.FullName);
message.AddProperty("URL", GetConfigurationSetting("SiteHttp", "") + "/Sales/Sales/Edit?id=" + model.Id.ToString());
EMailService.EMailService emailService = new Evolution.EMailService.EMailService(db, company);
error = emailService.SendEMail(message);
if (!error.IsError)
{
var NotificationService = GetTaskManagerService(company);
error = NotificationService.SendTask(Enumerations.MessageTemplateType.MSQChangeNotification,
TaskType.MSQChangeNotification,
LookupService.FindLOVItemsModel(company, LOVName.BusinessUnit)
.Where(bu => bu.ItemText == "Sales")
.FirstOrDefault(),
recipient,
model.CustomerId,
message.Dict);
}
return(error);
}
public EMailMessage GetMessageHeaders(EMailsListElement Element)
{
EMailMessage message = GetMessageHeaders(Element.Number, 0);
message.Bytes = Element.Bytes;
return(message);
}
public void Invoke(object Sender, object Element)
{
if (Element is CommandParameters)
{
CommandParameters cp = (CommandParameters)Element;
int issueId = int.Parse(cp.CommandArguments["SelectedValue"]);
if (cp.CommandArguments.ContainsKey("GridId"))
{
string[] checkedElems = MCGrid.GetCheckedCollection(((CommandManager)Sender).Page, cp.CommandArguments["GridId"]);
ArrayList alIds = new ArrayList();
foreach (string elem in checkedElems)
{
int id = Convert.ToInt32(elem.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries)[0], CultureInfo.InvariantCulture);
if (id > 0)
{
alIds.Add(id);
}
}
EMailMessage.CopyToIncident(alIds, issueId);
}
else if (cp.CommandArguments.ContainsKey("ObjectId"))
{
int emailMessageId = int.Parse(cp.CommandArguments["ObjectId"]);
EMailMessage.CopyToIncident(emailMessageId, issueId);
}
CHelper.RequireBindGrid();
}
}
private void FillDataRowFromMessage(EMailMessage message, ref DataRow messageRow)
{
EmailParser parser = new EmailParser();
messageRow[EMailTableColumns.Headers.ToString()] = message.Header;
messageRow[EMailTableColumns.From.ToString()] = (message.From == null ? string.Empty : string.Format("{0} <{1}>", message.From.DisplayName, message.From.Address));
messageRow[EMailTableColumns.Priority.ToString()] = message.Priority.ToString();
messageRow[EMailTableColumns.Number.ToString()] = message.Number;
messageRow[EMailTableColumns.ReplyTo.ToString()] = (message.ReplyTo == null ? string.Empty : string.Format("{0} <{1}>", message.ReplyTo.DisplayName, message.ReplyTo.Address));
messageRow[EMailTableColumns.Sender.ToString()] = (message.Sender == null ? string.Empty : string.Format("{0} <{1}>", message.Sender.DisplayName, message.Sender.Address));
messageRow[EMailTableColumns.Subject.ToString()] = message.Subject;
messageRow[EMailTableColumns.Bytes.ToString()] = message.Bytes;
messageRow[EMailTableColumns.Retrieved.ToString()] = message.Retrieved;
try
{
messageRow[EMailTableColumns.Date.ToString()] = ((message.Date == null || message.Date == string.Empty) ? DateTime.MinValue.ToShortDateString() : message.Date);
}
catch
{
messageRow[EMailTableColumns.Date.ToString()] = DateTime.MinValue;
}
StringBuilder bldr = new StringBuilder();
if (message.To != null)
{
foreach (EMailAddress to in message.To)
{
// TODO: review EmailParser instanciation
bldr.AppendFormat("{0} ", new EmailParser().GetEMailAddressTag(to));
}
messageRow[EMailTableColumns.To.ToString()] = bldr.ToString();
}
}
public async Task <ActionResult> SendMail(EMailMessage msg)//aceasta metoda este asincrona
{
if (ModelState.IsValid)
{
string body = msg.MessageContent;
MailMessage message = new MailMessage();
message.To.Add(new MailAddress(msg.To));
message.From = new MailAddress("*****@*****.**");
message.Subject = msg.Subject;
message.Body = body; //pana la aceasta linie se pregateste continutul mesajului
using (SmtpClient smtp = new SmtpClient()) //se introduce datele de conectare ale serverului de mail. in cazul acesta numele de utilizator si parola de la gmail
{
NetworkCredential credentials = new NetworkCredential
{
UserName = "******",
Password = ""//niciodata aceasta informatie sa nu se afiseze in plain text
};
smtp.Credentials = credentials;
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.EnableSsl = true;
await smtp.SendMailAsync(message);//punem in obiectul smtp propietatile necesare. pot diferii de la un providel de mail la altul
}
}
return(RedirectToAction("MailSent"));//dupa ce am trmimis mailul intoarce utilizatorul la actinea Index
}
protected Error SendMessage(CompanyModel company,
UserModel sender,
MessageTemplateType templateId,
TaskType notificationType,
List <UserModel> recipients,
Dictionary <string, string> dict,
List <string> attachments = null)
{
// Send as email
var message = new EMailMessage(sender, templateId);
message.AddRecipients(recipients);
message.AddProperties(dict);
message.AddAttachments(attachments);
EMailService.EMailService es = new EMailService.EMailService(_db, company);
var error = es.SendEMail(message);
//if (!error.IsError) {
// Now send as a notification
// TaskManagerService.TaskManagerService ts = new TaskManagerService.TaskManagerService(_db, company);
// error = ts.SendTask(templateId, notificationType, recipients, dict);
//}
return(error);
}
public void SendMail(EMailMessage emailMessage)
{
var message = new MimeMessage();
if (emailMessage.FromAddresses.Count == 0)
{
emailMessage.FromAddresses.Add(new EMailAddress
{
Name = _configuration.DefaultSenderName, Address = _configuration.DefaultSenderAddress
});
}
message.To.AddRange(emailMessage.ToAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
message.From.AddRange(emailMessage.FromAddresses.Select(x => new MailboxAddress(x.Name, x.Address)));
message.Subject = emailMessage.Subject;
message.Body = new TextPart(TextFormat.Html)
{
Text = emailMessage.Content
};
using (var client = new SmtpClient {
SslProtocols = SslProtocols.None
})
{
client.Connect(_configuration.SmtpServer, _configuration.SmtpPort, SecureSocketOptions.None);
client.Authenticate(_configuration.SmtpUsername, _configuration.SmtpPassword);
client.Send(message);
client.Disconnect(true);
}
}
private void button1_Click(object sender, EventArgs e)
{
EMailMessage message = new EMailMessage();
EmailParser parser = new EmailParser();
parser.ParseEMailMessage(ref message, textBox1.Text);
message.ToString();
}
public void ParseEMailMessageHeader(ref EMailMessage OriginalEmail, string RawEMail, bool Overwrite)
{
string[] messageLines = ExtractMessageLines(RawEMail);
int endHeaderPos = FindHeaderEnd(messageLines);
string MessageBoundary = string.Empty;
ParseMessageHeaders(ref OriginalEmail, GetHeaderLines(messageLines, endHeaderPos), out MessageBoundary);
}
public async Task Send(EMailMessage emailMessage)
{
MailAddress from = new MailAddress("*****@*****.**", "Tripster");
MailAddress to = new MailAddress(emailMessage.To[0]);
MailMessage message = new MailMessage(from, to);
message.Body = emailMessage.Body;
message.Subject = emailMessage.Subject;
await this._smtpClient.SendMailAsync(message);
}
private void BindDataGrid(bool dataBind)
{
DataView dv = EMailMessage.GetPendingMessages().DefaultView;
grdMain.DataSource = dv;
if (dataBind)
{
grdMain.DataBind();
}
}
private string TempReplace(string sMessage)
{
string sTemplate = EMailMessage.GetOutgoingEmailFormatBodyPreview(IncidentId);
sTemplate = sTemplate.Replace("<BR>", "\r\n");
sTemplate = sTemplate.Replace("<BR/>", "\r\n");
sTemplate = sTemplate.Replace("<BR />", "\r\n");
sTemplate = sTemplate.Replace("<br>", "\r\n");
sTemplate = sTemplate.Replace("<br/>", "\r\n");
sTemplate = sTemplate.Replace("<br />", "\r\n");
return(sTemplate.Replace("[=Text=]", sMessage));
}
private void lbApproveChecked_Click(object sender, EventArgs e)
{
string sIds = hidForDelete.Value;
ArrayList alIds = new ArrayList();
while (sIds.Length > 0)
{
alIds.Add(int.Parse(sIds.Substring(0, sIds.IndexOf(","))));
sIds = sIds.Remove(0, sIds.IndexOf(",") + 1);
}
EMailMessage.ApprovePending(alIds);
Response.Redirect("~/Incidents/EMailPendingMessages.aspx");
}
private static EMailMessage CreateMessage(EMailAddress from, EMailAddress recipient, string subject, string message)
{
EMailMessage result = new EMailMessage();
result.Subject = subject;
result.From = from;
result.To = new EMailAddress[1];
result.To[0] = recipient;
result.Body = new EMailBodyAlternateView();
result.Body.ContentStream = message;
return(result);
}
public async Task <ActionResult> Post([FromBody] EMailMessage emailMessage)
{
try
{
await _sendService.Send(emailMessage);
}
catch (Exception e)
{
return(BadRequest("Some problem occured at our side"));
}
return(Ok(new { message = "Message Sent Successfully" }));
}
public ReadingForm(EMailMessage Message, bool AccountSendEnabled)
: this()
{
if (Message == null)
{
MessageBox.Show("Error Retrieving Message");
return;
}
this.message = Message;
this.accountSendEnabled = AccountSendEnabled;
FillContros();
}
public EMailMessage[] GetAllPop3EMailsHeaders(string Server, int Port, string Username, string Password, bool Ssl)
{
Pop3Manager popMngr = new Pop3Manager(Server, Port, Username, Password);
EMailMessage[] mails = new EMailMessage[0];
try
{
mails = popMngr.GetAllMessagesHeaders(0);
}
catch
{
}
return(mails);
}
private void SendActivationMail(Account account)
{
var mail = new EMailMessage
{
// improve activation mail template
Content = $"Activation token {account.ActivationToken}",
Subject = "Identity Server - Activation Mail",
};
mail.ToAddresses.Add(new EMailAddress {
Name = account.Username, Address = account.UserMail
});
_mailService.SendMail(mail);
}
public bool SendMail(FlightWeatherResponse flightWeatherResponse)
{
string body = GetBody(flightWeatherResponse);
var subject = MailText.EmailSubject(flightWeatherResponse);
using (MMT_WEBS_InteractionManagerSoapClient client = new MMT_WEBS_InteractionManagerSoapClient())
{
if (string.IsNullOrWhiteSpace(body))
{
return(false);
}
EMailAttachment[] attachments = null;
if (flightWeatherResponse.ItineraryFlightStatus.FlightStatus == "S")
{
try
{
attachments = new EMailAttachment[1];
EMailAttachment attachment = new EMailAttachment
{
Content = MailManager.GetETicketBytes(flightWeatherResponse.ItineraryQueue),
ContentId = "E-Ticket",
FileName = flightWeatherResponse.ItineraryQueue.BookingID + ".E-Ticket.pdf"
};
attachments[0] = attachment;
}
catch (Exception exception)
{
ErrorLog.WriteErrorLog(exception, flightWeatherResponse.ItineraryQueue.BookingID, "MMT_WS_FlightWeather");
}
}
EMailMessage mailMessage = new EMailMessage
{
To = new[] { flightWeatherResponse.ItineraryQueue.BookingDetails.Email },
Subject = subject,
Source = MailText.Source,
ReferenceNo = flightWeatherResponse.ItineraryQueue.BookingID,
IsBodyHtml = true,
Body = body,
From = MailText.From,
ReferenceType = "BookingID",
RequestDate = DateTime.Now,
Attachment = attachments,
emailType = EmailType.General
};
string errorMessage = string.Empty;
return(client.SendEmail(mailMessage, ref errorMessage));
}
}
public EMailMessage RetrievePop3EMail(string Server, int Port, string Username, string Password, bool Ssl, int MessageNumber)
{
Pop3Manager popMngr = new Pop3Manager(Server, Port, Username, Password, Ssl);
EMailMessage mails = null;
try
{
mails = popMngr.RetrieveEmail(MessageNumber);
}
catch
{
}
return(mails);
}
private void dgPendMess_ItemCommand(object source, DataGridCommandEventArgs e)
{
if (e.CommandName == "Delete")
{
int Id = int.Parse(e.CommandArgument.ToString());
EMailMessage.Delete(Id);
Response.Redirect("~/Incidents/EMailPendingMessages.aspx");
}
else if (e.CommandName == "Approve")
{
int Id = int.Parse(e.CommandArgument.ToString());
EMailMessage.ApprovePending(Id);
Response.Redirect("~/Incidents/EMailPendingMessages.aspx");
}
}
public EMailMessage[] GetAllPop3EMailsHeaders(String Server, int Port, string Username, string Password, bool ssl)
{
Pop3Provider popMngr = new Pop3Provider(Server, Port, Username, Password, ssl);
EMailMessage[] mails = new EMailMessage[0];
try
{
popMngr.OpenConnection();
mails = popMngr.GetAllMessagesHeaders(0);
popMngr.CloseConnection();
}
catch
{
}
return(mails);
}
private void listadoMails_CellClick(object sender, DataGridViewCellEventArgs e)
{
//Imap4Provider provider = EmailProviderFactory.CreateProvider<Imap4Provider>("localhost", 143, "testuser@localhost", "testpass", false);
provider = EmailProviderFactory.CreateProvider <Pop3Provider>("mail.siprod.net", 110, "*****@*****.**", "testPass09", false);
provider.OpenConnection();
EMailMessage email = provider.RetrieveEmail(4);
provider.CloseConnection();
Form f = new Form();
WebBrowser w = new WebBrowser();
f.Controls.Add(w);
w.DocumentText = email.Body.ContentStream;
f.ShowDialog();
}
override public EMailMessage RetrieveEmail(EMailsListElement ListElement)
{
string response = RetrieveRawEmailStream(ListElement.Number);
EmailParser parser = new EmailParser();
// TODO: clean it up
Regex rx = new Regex(@"(\+OK \d* Octets\r\n)");
string answer = rx.Replace(response, string.Empty);
EMailMessage result = parser.CreateEmailFromRawText(answer);
result.Retrieved = true;
return(result);
}
private void ShowWritingEMailForm(EMailMessage Message, string AccountId, MessageActions Action)
{
if (Message == null)
{
MessageBox.Show("There was an error retrieving the email.");
return;
}
WritingForm wForm = new WritingForm(Message, Action, AccountId);
DialogResult dResult = wForm.ShowDialog();
if (dResult == DialogResult.OK)
{
client.SendEMail(AccountId, wForm.Message);
}
SetDataGridFocus();
}
public void Send(EMailMessage message, object userToken = null)
{
// Build mail message
MailMessage mailMessage = message.ToMailMessage();
mailMessage.From = new MailAddress(FromAddress);
MessageQueueItem item = new MessageQueueItem
{
Message = mailMessage,
UserToken = userToken
};
// Enqueue message
queue.Enqueue(item);
// Initiate despooling queue
ThreadPool.QueueUserWorkItem(SendNextQueueItem);
}
private EMailMessage CreateEMailMessage(IEnumerable<String> recipients)
{
EMailMessage message = new EMailMessage();
if (SponsoringOrganization != null
&& SponsoringOrganization.SMTPHostConfiguration != null)
{
message.Bcc.Add(SponsoringOrganization.SMTPHostConfiguration.FromAddress);
#if DEBUG
message.To.Add(SponsoringOrganization.SMTPHostConfiguration.FromAddress);
#endif
}
#if ! DEBUG
foreach (var recipient in recipients)
{
message.To.Add(recipient);
}
#endif
return message;
}
private void SendAssignmentNotification(TournamentOrganizationRegistration registration, String paymentPageUrl, User user) {
if (registration != null
&& registration.Tournament != null) {
var balance = String.Format("{0} {1}",
registration.Tournament.Currency.Symbol,
bookingManager.GetBalance(registration.OrganizationId, registration.TournamentId));
// Create message
EMailMessage message = new EMailMessage();
message.To = new List<string>();
var delegates = from ua in registration.Organization.UserAssociations
where ua.Role == OrganizationRole.Delegate
select ua.User;
#if DEBUG
message.To.Add(mailService.FromAddress);
#else
foreach (var deleg in delegates) {
message.To.Add(deleg.Email);
}
#endif
message.Bcc = new List<string>();
message.Bcc.Add(mailService.FromAddress);
message.Subject = String.Format(
Resources.Facade.PaymentManager.Strings.ConfirmationNotificationSubject,
registration.Tournament.Name);
Object[] messageVariables = new Object[] {
registration.Tournament.Name, // {0}
registration.Organization.Name, // {1}
registration.TeamsPaid, // {2}
registration.AdjudicatorsPaid, // {3}
balance, // {4}
String.Format(paymentPageUrl, // {5}
registration.TournamentId,
registration.OrganizationId)
};
message.Body = String.Format(
Resources.Facade.PaymentManager.Strings.ConfirmationNotificationBody,
messageVariables);
#if DEBUG
mailService.Send(message);
#endif
message.HTMLBody = String.Format(
Resources.Facade.PaymentManager.Strings.ConfirmationNotificationHTMLBody,
messageVariables);
Guid messageId = Guid.NewGuid();
sentMessages.Add(messageId, new SlotAssignmentStatusMessage {
Registration = registration,
MailMessage = message,
User = user
});
mailService.Send(message, messageId);
}
}
