public void BuildPostContentStep_WithSubstitution(string token, string value)
{
var contentStep = new MessageBuilder.BuildPostContentStep(MailerMessage.Create());
if (token == null)
{
contentStep.Invoking(c => c.WithSubstitution(null, value)).Should().Throw <ArgumentNullException>();
}
else
{
var stepBuilder = contentStep.WithSubstitution(token, value);
stepBuilder
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildPostContentStep.BuildAttachmentOrSubstitutionStep>()
.Which.As <IBuilderContext>()
.Message.Substitutions
.Should()
.NotBeEmpty()
.And.ContainKey(token)
.WhichValue.Should()
.Be(value);
}
}
public void BuildHtmlBodyStep_AndPlainText(string text)
{
var body = new ContentBody().WithHtml("<tag>something</tag>");
var contentStep =
new MessageBuilder.BuildContentStep.BuildBodyStep.BuildHtmlBodyStep(
MailerMessage.Create().WithBody(body), body);
var stepBuilder = contentStep.AndPlainText(text);
stepBuilder
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildContentStep.BuildBodyStep.BuildBodyCompleteStep>()
.Which.As <IBuilderContext>()
.Message.Body
.As <ContentBody>()
.Should().BeEquivalentTo
(
new ContentBody
{
HtmlContent = "<tag>something</tag>",
PlainTextContent = text
},
config => config
.Including(b => b.HtmlContent)
.Including(b => b.PlainTextContent));
}
public async Task Ef_History_List()
{
var store = Fixture.ServiceProvider.GetService <IHistoryStore>();
store.Should().BeOfType <EntityHistoryStore <TestHistoryContext> >();
for (var x = 0; x < 15; x++)
{
await store.AddAsync(new DeliveryItem(MailerMessage.Create(), new MessageRecipient())
{
CreatedDate = DateTimeOffset.Now,
ToDisplayName = x.ToString(),
Subject = x.ToString(),
ToEmailAddress = $"{x}@toast.com",
DeliveryProvider = "xunit",
Id = Guid.NewGuid(),
IsSuccess = true,
ExceptionMessage = null,
Body = new ContentBody {
PlainTextContent = "content"
},
FromDisplayName = "noone",
FromEmailAddress = "*****@*****.**"
});
}
var items = await store.GetAsync(0, 10, CancellationToken.None);
items.Should().HaveCount(10);
var secondPageitems = await store.GetAsync(10, 5, CancellationToken.None);
secondPageitems.Should().HaveCount(5).And.NotBeSameAs(items);
}
public ActionResult Send(Common.FeedBack feedback)
{
if (!ModelState.IsValid)
{
var err = ModelState.Values.Select(s => s.Errors);
var errStr = new List <string>();
foreach (var item in err)
{
errStr.AddRange(item.Select(i => i.ErrorMessage));
}
var msg = string.Join(" ", errStr);
return(Json(new { isSend = false, message = msg }, JsonRequestBehavior.AllowGet));
}
//ValidateModel(feedback);
var message = RenderViewToString(this.ControllerContext, "/Views/FeedBack/_PartialEmailMessage.cshtml", feedback, true);
MailerMessage mailerMessage = new MailerMessage();
mailerMessage.Body = message;
mailerMessage.Subject = "Заявка с сайта Пирамида строй";
mailerMessage.To = feedBackEmailRepository.GetAll().Select(i => i.Email).ToList();
mailerMessage.SenderName = "Pyramid";
if (mailerMessage.To.Count > 0)
{
Mailer.Send(mailerMessage);
}
return(Json(new { isSend = true }, JsonRequestBehavior.AllowGet));
}
public void BuildTextBody_AndHtml(string html)
{
var body = new ContentBody().WithPlainText("some text");
var contentStep =
new MessageBuilder.BuildContentStep.BuildBodyStep.BuildTextBodyStep(
MailerMessage.Create().WithBody(body), body);
var stepBuilder = contentStep.AndHtml(html);
stepBuilder
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildContentStep.BuildBodyStep.BuildBodyCompleteStep>()
.Which.As <IBuilderContext>()
.Message.Body
.As <ContentBody>()
.ShouldBeEquivalentTo
(
new ContentBody
{
HtmlContent = html,
PlainTextContent = "some text"
},
config => config
.Including(b => b.HtmlContent)
.Including(b => b.PlainTextContent));
}
public void BuildPostContentStep_WithAttachment(string fileName)
{
var contentStep = new MessageBuilder.BuildPostContentStep(MailerMessage.Create());
if (string.IsNullOrEmpty(fileName))
{
contentStep.Invoking(s => s.WithAttachment(fileName)).Should().Throw <FileNotFoundException>();
}
else
{
var path = Path.Combine(AppContext.BaseDirectory, fileName);
var stepBuilder = contentStep.WithAttachment(path);
stepBuilder
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildPostContentStep.BuildAttachmentOrSubstitutionStep>()
.Which.As <IBuilderContext>()
.Message.Attachments
.Should()
.NotBeEmpty()
.And.Subject.Keys.Select(Path.GetFileName)
.Should()
.Contain(Path.GetFileName(path));
}
}
public ActionResult Checkout(CheckoutModel model)
{
ValidateModel(model);
var cart = new Cart(GetCart());
var emailModel = new CartOrderFromEmailSendModel()
{
Cart = cart,
UserData = model
};
var message = RenderViewToString(this.ControllerContext, "/Views/Cart/_PartialNewOrderFromEmailSend.cshtml", emailModel, true);
var entity = new Order()
{
Adress = model.Adress,
Email = model.Email,
Phone = model.Phone,
TypeProgressOrder = (int)Entity.Enumerable.TypeProgressOrder.SimplePrice,
UserName = model.Name,
Products = cart.Lines.Select(i => new OrderProduct()
{
Product = new Product()
{
Id = i.Product.Id
},
Quantity = i.Quantity
}).ToList(),
DateOrder = DateTime.Now
};
MailerMessage mailerMessage = new MailerMessage();
mailerMessage.Body = message;
mailerMessage.Subject = "Заказ с сайта Пирамида строй";
mailerMessage.To = _feedBackEmailRepository.GetAll().Select(i => i.Email).ToList();
mailerMessage.SenderName = "Pyramid";
if (mailerMessage.To.Count > 0)
{
Mailer.Send(mailerMessage);
}
GetCart().Clear();
bool flagErr = false;
try
{
_orederRepository.Add(entity);
}
catch (Exception)
{
flagErr = true;
}
ViewBag.IsAddedOrder = !flagErr;
ViewBag.MetaTitle = "Подтверждение заказа";
return(View("ResultCheckout", cart));
}
public async Task Ef_Sql_History_Search()
{
var history = Fixture.ServiceProvider.GetService <IHistoryStore>();
await history.AddAsync(new DeliveryItem(MailerMessage.Create(), new MessageRecipient())
{
CreatedDate = DateTimeOffset.Now,
ToDisplayName = "No One",
Subject = "test message",
ToEmailAddress = "*****@*****.**",
DeliveryProvider = "xunit",
SourceApplicationName = "xunit",
Id = Guid.NewGuid(),
IsSuccess = true,
ExceptionMessage = null,
Body = new ContentBody {
PlainTextContent = "content"
},
FromDisplayName = "noone",
FromEmailAddress = "*****@*****.**"
});
await history.AddAsync(new DeliveryItem(MailerMessage.Create(), new MessageRecipient())
{
CreatedDate = DateTimeOffset.Now,
ToDisplayName = "Some One",
Subject = "test message",
ToEmailAddress = "*****@*****.**",
DeliveryProvider = "xunit",
SourceApplicationName = "xunit",
Id = Guid.NewGuid(),
IsSuccess = true,
ExceptionMessage = null,
Body = new ContentBody {
PlainTextContent = "content"
},
FromDisplayName = "noone",
FromEmailAddress = "*****@*****.**"
});
var searchA = await history.SearchAsync("else");
searchA.Should().NotBeNull().And.OnlyContain(i => i.SourceApplicationName == "xunit");
searchA.Should().NotBeNull().And.OnlyContain(i => i.ToEmailAddress == "*****@*****.**");
var searchB = await history.SearchAsync("else", sourceApplicationName : "noxunit");
searchB.Should().BeEmpty();
var searchC = await history.SearchAsync("else", startDate : DateTimeOffset.UtcNow.AddHours(-1),
endDate : DateTimeOffset.UtcNow);
searchC.Should().NotBeNull().And.OnlyContain(i => i.SourceApplicationName == "xunit");
searchC.Should().NotBeNull().And.OnlyContain(i => i.ToEmailAddress == "*****@*****.**");
var searchD = await history.SearchAsync("else", startDate : DateTimeOffset.UtcNow.AddHours(-2),
endDate : DateTimeOffset.UtcNow.AddHours(-1));
searchD.Should().BeEmpty();
}
/// <summary>
/// Add the sender's info to the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="recipientAction">The recipient action.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage To(this MailerMessage message, Action <MessageRecipient> recipientAction)
{
var newRecipient = new MessageRecipient();
recipientAction(newRecipient);
message.Recipients.Add(newRecipient);
return(message);
}
/// <summary>
/// Adds a collection of recipients the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="recipients">The recipients.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage To(this MailerMessage message, IEnumerable <MessageRecipient> recipients)
{
foreach (var recipient in recipients)
{
message.Recipients.Add(recipient);
}
return(message);
}
/// <summary>
/// Adds one or more replacement variables to the message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="substitutions">The substitutions.</param>
/// <returns>MailerMessage.</returns>
/// <remarks>Substitutions can be applied to the subject, html body, text body, and templates</remarks>
public static MailerMessage WithSubstitutions(this MailerMessage message,
IDictionary <string, string> substitutions)
{
foreach (var substitution in substitutions)
{
message.Substitutions.Add(substitution);
}
return(message);
}
/// <summary>
/// Adds a collection of attachments to the message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="attachments">The attachments.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage WithAttachments(this MailerMessage message, IEnumerable <string> attachments)
{
foreach (var attachment in attachments ?? new string[0])
{
message.Attachments.Add(attachment.GetAttachmentStreamForFile());
}
return(message);
}
/// <summary>
/// Creates a body of the specified type and adds it to the message.
/// </summary>
/// <typeparam name="T">The body type</typeparam>
/// <param name="message">The message.</param>
/// <param name="bodyAction">Configure the new message body.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage WithBody <T>(
this MailerMessage message, Action <T> bodyAction) where T : class, IMessageBody
{
var body = Activator.CreateInstance <T>();
bodyAction(body);
message.Body = body;
return(message);
}
public void BuildContentStep_ForBody()
{
var contentStep = new MessageBuilder.BuildContentStep(MailerMessage.Create());
var stepBuilder = contentStep.ForBody();
stepBuilder
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildContentStep.BuildBodyStep>();
}
/// <summary>
/// Adds a collection of attachments to the message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="attachments">The attachments.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage WithAttachments(this MailerMessage message, IDictionary <string, Stream> attachments)
{
if (attachments != null && attachments.Any())
{
foreach (var attachment in attachments)
{
message.Attachments.Add(attachment);
}
}
return(message);
}
public void BuildPostContentStep_Build()
{
var contentStep = new MessageBuilder.BuildPostContentStep(MailerMessage.Create());
var message = contentStep.Build();
message
.Should()
.NotBeNull()
.And.BeOfType <MailerMessage>();
}
public void BuildTextBody_And()
{
var contentStep =
new MessageBuilder.BuildContentStep.BuildBodyStep.BuildTextBodyStep(MailerMessage.Create(),
ContentBody.Create());
contentStep.And
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildPostContentStep>();
}
/// <summary>
/// Initializes a new instance of the <see cref="BuildToStep" /> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="recipientAddress">The recipient address.</param>
public BuildToStep(MailerMessage context, string recipientAddress) : base(context)
{
Recipient = Context.Recipients.FirstOrDefault(r => r.EmailAddress == recipientAddress);
if (Recipient == null)
{
Recipient = new MessageRecipient {
EmailAddress = recipientAddress
};
context.To(Recipient);
}
}
/// <summary>
/// Add the sender's info to the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="emailAddress">The email address.</param>
/// <param name="displayName">The display name.</param>
/// <param name="replyToEmailAddress">The reply to email address.</param>
/// <param name="replyToDisplayName">Display name of the reply to.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage From(this MailerMessage message, string emailAddress, string displayName = null,
string replyToEmailAddress = null, string replyToDisplayName = null)
{
message.From = new MessageSender
{
EmailAddress = emailAddress,
DisplayName = displayName,
ReplyToEmailAddress = replyToEmailAddress,
ReplyToDisplayName = replyToDisplayName
};
return(message);
}
/// <summary>
/// Adds a recipient to the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="emailAddress">The email address.</param>
/// <param name="displayName">The display name.</param>
/// <param name="personalizedSubstitutions">The personalized substitutions.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage To(this MailerMessage message, string emailAddress, string displayName = null,
IDictionary <string, string> personalizedSubstitutions = null)
{
var recipient = new MessageRecipient
{
EmailAddress = emailAddress,
DisplayName = displayName,
PersonalizedSubstitutions = personalizedSubstitutions ?? new Dictionary <string, string>()
};
message.Recipients.Add(recipient);
return(message);
}
public void BuildContentStep_ForTemplate(string templateName)
{
var contentStep = new MessageBuilder.BuildContentStep(MailerMessage.Create());
var stepBuilder = contentStep.ForTemplate(templateName);
stepBuilder
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildContentStep.BuildContentTemplateStep>()
.Which.As <IBuilderContext>()
.Message.Body.As <TemplateBody>()
.TemplateName
.Should()
.Be(templateName);
}
public void BuildBodyStep_WithHtml(string html)
{
var contentStep = new MessageBuilder.BuildContentStep.BuildBodyStep(MailerMessage.Create());
var stepBuilder = contentStep.WithHtml(html);
stepBuilder
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildContentStep.BuildBodyStep.BuildHtmlBodyStep>()
.Which.As <IBuilderContext>()
.Message.Body
.As <ContentBody>()
.HtmlContent
.Should()
.Be(html);
}
public void BuildBodyStep_WithPlainText(string text)
{
var contentStep = new MessageBuilder.BuildContentStep.BuildBodyStep(MailerMessage.Create());
var stepBuilder = contentStep.WithPlainText(text);
stepBuilder
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildContentStep.BuildBodyStep.BuildTextBodyStep>()
.Which.As <IBuilderContext>()
.Message.Body
.As <ContentBody>()
.PlainTextContent
.Should()
.Be(text);
}
public void BuildContentStep_To(string address)
{
var contentStep = new MessageBuilder.BuildContentStep(MailerMessage.Create());
var stepBuilder = contentStep.To(address);
stepBuilder
.Should()
.NotBeNull()
.And.BeOfType <MessageBuilder.BuildRecipientsStep.BuildToStep>()
.Which.As <IBuilderContext>()
.Message.Recipients
.Should()
.NotBeNull()
.And.NotBeEmpty()
.And.AllBeAssignableTo <MessageRecipient>()
.And.Contain(r => r.EmailAddress == address);
}
public void BuildHtmlBodyStep_Build()
{
var body = new ContentBody().WithHtml("<tag>something</tag>");
var contentStep =
new MessageBuilder.BuildContentStep.BuildBodyStep.BuildHtmlBodyStep(
MailerMessage.Create().WithBody(body), body);
var message = contentStep.Build();
message
.Should()
.NotBeNull()
.And.BeOfType <MailerMessage>()
.Which.Body.As <ContentBody>()
.HtmlContent
.Should()
.NotBeNullOrEmpty()
.And.Be("<tag>something</tag>");
}
public static bool SendEmail(MailerServerSettings settings, MailerMessage message)
{
lock (o)
{
var msg = new MailMessage(message.From, message.To)
{
Body = message.Body,
Subject = message.Subject,
Priority = MailPriority.Normal,
IsBodyHtml = message.Body.Contains("<") || message.Body.Contains(">"),
BodyEncoding = Encoding.UTF8
};
if ((message.Cc != null) && message.Cc.Length != 0)
{
foreach (var c in message.Cc)
msg.CC.Add(c);
}
if ((message.Bcc != null) && message.Bcc.Length != 0)
{
foreach (var bc in message.Bcc)
msg.Bcc.Add(bc);
}
if (message.Attachments != null)
foreach (var a in message.Attachments)
msg.Attachments.Add(new Attachment(a));
using (var smtp = new SmtpClient())
{
smtp.Host = settings.Server;
smtp.UseDefaultCredentials = false;
smtp.Timeout = 30000;
smtp.EnableSsl = false;
smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
smtp.Credentials = new NetworkCredential(settings.Username, settings.Pwd);
smtp.Port = settings.Port;
smtp.Send(msg);
}
return true;
}
}
public void BuildTextBody_Build()
{
var body = new ContentBody().WithPlainText("some text");
var contentStep =
new MessageBuilder.BuildContentStep.BuildBodyStep.BuildTextBodyStep(
MailerMessage.Create().WithBody(body), body);
var message = contentStep.Build();
message
.Should()
.NotBeNull()
.And.BeOfType <MailerMessage>()
.Which.Body.As <ContentBody>()
.PlainTextContent
.Should()
.NotBeNullOrEmpty()
.And.Be("some text");
}
public static void Send(MailerMessage message)
{
new System.Threading.Thread((obj) =>
{
var info = obj as MailerMessage;
var client = new SmtpClient();
var fromAddress = client.Credentials.GetCredential("", 0, "").UserName;
var mailMessage = new MailMessage(fromAddress, string.Join(",", info.To), info.Subject, info.Body);
mailMessage.IsBodyHtml = true;
mailMessage.Sender = mailMessage.From = new MailAddress(fromAddress, info.SenderName);
try
{
client.Send(mailMessage);
}
catch (Exception ex)
{
//Logger.Log(LogLevel.Error, ex, $"Ошибка при отправке письма: {ex}");
}
}).Start(message);
}
/// <summary>
/// Add the sender's info to the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="sender">The sender.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage From(this MailerMessage message, MessageSender sender)
{
message.From = sender;
return(message);
}
/// <summary>
/// Add the sender's info to the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="sender">The action to setup the sender.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage From(this MailerMessage message, Action <MessageSender> sender)
{
message.From = new MessageSender();
sender(message.From);
return(message);
}
/// <summary>
/// Adds the specified body to the message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="body">The body.</param>
/// <returns>MailerMessage.</returns>
public static MailerMessage WithBody(this MailerMessage message, IMessageBody body)
{
message.Body = body;
return(message);
}
