public static void SendTo(this EmailCredentials credentials, EmailMessage email, User recipient)
{
var mySmtpClient = new SmtpClient(credentials.Client);
var networkCredentials = new NetworkCredential(credentials.Username, credentials.Password);
// set smtp-client with basicAuthentication
mySmtpClient.UseDefaultCredentials = false;
mySmtpClient.Credentials = networkCredentials;
mySmtpClient.EnableSsl = true;
mySmtpClient.Port = credentials.Port;
mySmtpClient.DeliveryMethod = SmtpDeliveryMethod.Network;
// add from,to mailaddresses
var from = new MailAddress(credentials.Username, "Expenses");
var to = new MailAddress(recipient.Email, recipient.Username);
var myMail = new MailMessage(from, to);
// set subject and encoding
myMail.Subject = email.Subject;
myMail.SubjectEncoding = System.Text.Encoding.UTF8;
// set body-message and encoding
myMail.Body = email.Body;
myMail.BodyEncoding = System.Text.Encoding.UTF8;
// text or html
myMail.IsBodyHtml = true;
mySmtpClient.Send(myMail);
}
public async Task SendMailAsync(EmailCredentials sender, string receiverAddresses, string text)
{
if (receiverAddresses.Length < 1)
{
throw new ArgumentException(nameof(receiverAddresses));
}
var message = InitializeAddresses(sender.Username, receiverAddresses);
message.Subject = AppConstants.applicationName;
message.Body = text;
var client = InitializeSmtpClient(sender);
try
{
await client.SendMailAsync(message);
}
catch (Exception e)
{
Console.WriteLine(e.InnerException);
Console.ReadLine();
return;
}
Console.WriteLine("Email sent");
}
private ExchangeService GetExchangeService(EmailCredentials credentials)
{
var url = credentials.AccessEndPoint;
var cacheKey = BuildCacheKey(credentials.Email);
if (string.IsNullOrWhiteSpace(url))
{
url = _cacheRepository.Get <string>(cacheKey);
}
if (string.IsNullOrWhiteSpace(url))
{
var autodiscover = new AutodiscoverService(ExchangeVersion.Exchange2013_SP1)
{
RedirectionUrlValidationCallback = x => true,
Credentials = new WebCredentials(credentials.Email, credentials.Password)
};
var userSettings = autodiscover.GetUsersSettings(new List <string>()
{
credentials.Email
}, UserSettingName.ExternalEwsUrl);
var successResponse = userSettings.First(x => x.ErrorCode == AutodiscoverErrorCode.NoError);
successResponse.TryGetSettingValue(UserSettingName.ExternalEwsUrl, out url);
_cacheRepository.Put(cacheKey, url, new CacheRepositoryOptions());
}
var service =
new ExchangeService(ExchangeVersion.Exchange2013_SP1)
{
Credentials = new WebCredentials(credentials.Email, credentials.Password),
Url = new Uri(url)
};
return(service);
}
protected void btnsubmit_Click(object sender, EventArgs e)
{
try
{
if (txtemail.Text.Length > 0)
{
string myIP = string.Empty;
try
{
string hostName = Dns.GetHostName();
myIP = Dns.GetHostByName(hostName).AddressList[0].ToString();
}
catch (Exception)
{
}
EmailCredentials objEmail = new EmailCredentials();
System.Net.Mime.ContentType mimeType = new System.Net.Mime.ContentType("text/html");
objEmail.From = "From Email Address";
objEmail.UserName = "******";
objEmail.Password = "******";
objEmail.To = "*****@*****.**";
if (txtbcc.Text.Trim().Length > 0)
{
objEmail.BCC = txtbcc.Text.Trim();
}
objEmail.SMTPMail = "smtp.gmail.com";
objEmail._Port = 587;
objEmail._SSL = true;
objEmail.Subject = "This Email is generated from Email tester!! by " + myIP;
objEmail.Mail = txtemail.Text.Trim();
if (SendMail(objEmail))
{
lblMessage.Text = "Email Sent Successfully!!!";
}
else
{
lblMessage.Text = "Email Sending Error!!";
}
}
else
{
lblMessage.Text = "Please Paste html content to send it as an email!!";
}
}
catch (Exception ex)
{
lblMessage.Text = ex.Message;
}
}
public RetrieveSecureEmailCredentials()
{
var configs = GetConfiguration.GetConfigs;
EmailCredentials = configs.Configuration.GetSection("EmailCredentials")
.Get <EmailCredentials>();
}
public virtual async Task <bool> SendEmailAsync(
SmtpSettings smtpSettings,
ImapSettings imapSettings,
EmailCredentials credentials,
BaseEmailMessage <string> message)
{
var streams = new List <Stream>();
try
{
var emailMessage = GetEmailMessage(credentials.Email, message);
if (emailMessage == null)
{
return(false);
}
message.Body = _emailHelperService.AttachGuidToBody(message.TrackingGuid, message.Body);
var bodyBuilder = new BodyBuilder {
HtmlBody = message.Body
};
using (var client = new SmtpClient())
{
if (message.Attachments != null)
{
PrepareAttachments(emailMessage, streams, message.Attachments, bodyBuilder);
}
else
{
emailMessage.Body = bodyBuilder.ToMessageBody();
}
await client.ConnectAsync(smtpSettings.SmtpHost, smtpSettings.SmtpPort);
client.AuthenticationMechanisms.Remove("XOAUTH2");
await client.AuthenticateAsync(credentials.Email, credentials.Password);
await client.SendAsync(emailMessage);
await client.DisconnectAsync(true);
if (!string.IsNullOrWhiteSpace(message.SentFolder))
{
AppendToFolder(imapSettings, credentials, emailMessage, message.SentFolder);
}
return(true);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(false);
}
finally
{
streams.ForEach(x => { x.Dispose(); });
}
}
public void SendHtmlAsync(EmailInfo emailInfo, EmailCredentials credentials)
{
var message = BuildEmailMessage(emailInfo);
message.IsBodyHtml = true;
this.BuildEmailClient(credentials)
.SendMailAsync(message);
}
public virtual async Task <bool> SendEmailAsync(
SmtpSettings smtpSettings,
ImapSettings imapSettings,
EmailCredentials credentials,
BaseEmailMessage <string> message)
=>
await GetEmailProvider(imapSettings, smtpSettings).SendEmailAsync(smtpSettings,
imapSettings,
credentials,
message);
private SmtpClient BuildEmailClient(EmailCredentials credentials)
{
var host = this._configuration["Email:Host"];
var port = Int32.Parse(this._configuration["Email:Port"]);
return(new SmtpClient
{
Host = host,
Port = port,
EnableSsl = true,
Credentials = new NetworkCredential(credentials.Username, credentials.Password)
});
}
public async Task <bool> SendEmailAsync(
SmtpSettings smtpSettings,
ImapSettings imapSettings,
EmailCredentials credentials,
BaseEmailMessage <string> baseEmailMessage)
{
var service = GetExchangeService(credentials);
var message = PrepareMessage(service, baseEmailMessage);
PrepareAttachments(message, baseEmailMessage.Attachments);
await message.SendAndSaveCopy(WellKnownFolderName.SentItems);
return(true);
}
private static void AppendToFolder(ImapSettings settings, EmailCredentials credentials,
MimeMessage emailMessage, string folder)
{
using (var imapClient = new ImapClient())
{
imapClient.Connect(settings.ImapHost, settings.ImapPort);
imapClient.Authenticate(credentials.Email, credentials.Password);
var personal = imapClient.GetFolder(imapClient.PersonalNamespaces[0]);
var sentFolder = personal.GetSubfolders()
.FirstOrDefault(x => x.Name.ToLowerInvariant() == folder.ToLowerInvariant());
if (sentFolder != null)
{
sentFolder.Append(emailMessage);
sentFolder.Close();
}
imapClient.Disconnect(true);
}
}
public HttpResponseMessage VerifyEmail(users item)
{
var res = r.EmailExist(item.email);
if (res == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, $"El email no esta registrado"));
}
else
{
Random rand = new Random();
int codigo = rand.Next(1000, 9999);
MailMessage mail = new MailMessage();
mail.To.Add(new MailAddress(item.email));
mail.From = new MailAddress("*****@*****.**");
mail.Subject = "Password recovery";
mail.Body = "Hola " + res.nombre + "Este es tu codigo de seguridad: <b>" + codigo + "</b>";
mail.IsBodyHtml = true;
SmtpClient smtp = new SmtpClient();
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.UseDefaultCredentials = false;
smtp.EnableSsl = true;
var credentials = new EmailCredentials();
smtp.Credentials = new NetworkCredential(credentials.Email, credentials.pass);
try
{
smtp.Send(mail);
mail.Dispose();
codigos code = new codigos();
code.codigo = codigo.ToString();
code.id_user = res.id_user;
v.Post(code);
return(Request.CreateResponse(HttpStatusCode.OK, code));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, "Error " + ex.Message));
}
}
}
private SmtpClient InitializeSmtpClient(EmailCredentials sender)
{
using (CryptographyService cryptographyService = new CryptographyService())
{
sender.Password = cryptographyService.Decrypt(sender.Password);
}
var client = new SmtpClient();
client.Credentials = new NetworkCredential()
{
UserName = sender.Username,
Password = sender.Password,
};
client.Port = ProjectConfigurationManager.DefaultSmtpPort;
client.Host = ProjectConfigurationManager.DefaultSmtpHost;
client.EnableSsl = ProjectConfigurationManager.DefaultSmtpSSL;
return(client);
}
public async Task SendOrderDetailsEmail(string toEmail, string subject, IEnumerable <Game> items, Address adress, decimal price)
{
string Body = System.IO.File.ReadAllText(@"C:\Users\adria\Projects\GamingShop\GamingShop.Service\EmailTemplates\Templates\OrderEmailTemplate.htm");
Body = Body.Replace("#Country#", adress.Country);
Body = Body.Replace("#City#", adress.City);
Body = Body.Replace("#Street#", adress.Street);
Body = Body.Replace("#PhoneNumber#", adress.PhoneNumber);
Body = Body.Replace("#price#", price.ToString());
foreach (var game in items)
{
Body += $"<p>{game.Title}</p>";
}
try
{
SmtpClient client = new SmtpClient("smtp.gmail.com", 587);
client.EnableSsl = true;
client.DeliveryMethod = SmtpDeliveryMethod.Network;
client.UseDefaultCredentials = false;
client.Credentials = new NetworkCredential(EmailCredentials.GetEmail(), EmailCredentials.GetPassword());
MailMessage msg = new MailMessage();
msg.IsBodyHtml = true;
msg.To.Add(toEmail);
msg.From = new MailAddress(EmailCredentials.GetEmail());
msg.Subject = subject;
msg.Body = Body;
client.Send(msg);
}
catch (Exception ex)
{
// TODO: handle exception
throw new InvalidOperationException(ex.Message);
}
}
public IIdentityMessageService CreateService(EmailCredentials credentials)
{
var email = credentials.EmailAddress.ToLower();
if (!_servicies.ContainsKey(email))
{
IIdentityMessageService service;
var emailType = GetEmailType(credentials.EmailAddress);
switch (emailType)
{
case EmailType.Gmail:
service = new GmailService(credentials);
break;
default:
throw new NotImplementedException($"{emailType}: there is no implemented instance for this type");
}
_servicies.Add(email, service);
}
return(_servicies[email]);
}
/// <summary>
/// Sends Email messages via gmail client
/// </summary>
/// <param name="sender">sender, from email credentials</param>
public GmailService(EmailCredentials credentials)
{
_credentials = credentials;
}
public EmailSender(IOptions <EmailCredentials> options, IOptions <SmtpSettings> settings)
{
_settings = settings.Value;
_options = options.Value;
}
public void SendTextAsync(EmailInfo emailInfo, EmailCredentials credentials)
{
this.BuildEmailClient(credentials)
.SendMailAsync(BuildEmailMessage(emailInfo));
}
public EmailCredentials(EmailCredentials credentials)
{
Email = credentials.Email;
Password = credentials.Password;
AccessEndPoint = credentials.AccessEndPoint;
}
public bool SendMail(EmailCredentials objEmail)
{
bool Issent = false;
try
{
MailMessage MailMsg = new MailMessage();
MailMsg.Subject = objEmail.Subject;
MailMsg.From = new MailAddress(objEmail.From);
if (objEmail.To.Contains(","))
{
foreach (var EmailTo in objEmail.To.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
{
MailMsg.To.Add(new MailAddress(EmailTo));
}
}
else
{
MailMsg.To.Add(new MailAddress(objEmail.To));
}
if (objEmail.BCC != null)
{
if (objEmail.BCC.Length > 0)
{
if (objEmail.BCC.Contains(","))
{
foreach (var EmailBCC in objEmail.BCC.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries))
{
MailMsg.Bcc.Add(new MailAddress(EmailBCC));
}
}
else
{
MailMsg.Bcc.Add(new MailAddress(objEmail.BCC));
}
}
}
//MailMsg.To.Add(new MailAddress(To));
MailMsg.Priority = MailPriority.High;
MailMsg.Body = objEmail.Mail;
MailMsg.IsBodyHtml = true;
SmtpClient SmtpMail = new SmtpClient();
SmtpMail.Host = objEmail.SMTPMail;
SmtpMail.UseDefaultCredentials = false;
NetworkCredential basicInfo = new NetworkCredential(objEmail.UserName, objEmail.Password);
SmtpMail.Credentials = basicInfo;
SmtpMail.Port = objEmail._Port;
SmtpMail.EnableSsl = objEmail._SSL;
SmtpMail.Send(MailMsg);
Issent = true;
}
catch (Exception)
{
Issent = false;
}
return(Issent);
}
public EmailService(EmailCredentials credentials, CertificateInformation information = null, bool useCustomCertificateValidationCallback = false)
{
_credentials = credentials;
_information = information;
_useCustomCertificateValidationCallback = useCustomCertificateValidationCallback;
}
