public static void Start(SchemaBuilder sb)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Schema.Settings.AssertImplementedBy((ProcessEntity p) => p.Data, typeof(EmailPackageEntity));
sb.Include <EmailPackageEntity>()
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.Name,
});
QueryLogic.Expressions.Register((EmailPackageEntity ep) => ep.Messages(), () => EmailMessageMessage.Messages.NiceToString());
QueryLogic.Expressions.Register((EmailPackageEntity ep) => ep.RemainingMessages(), () => EmailMessageMessage.RemainingMessages.NiceToString());
QueryLogic.Expressions.Register((EmailPackageEntity ep) => ep.ExceptionMessages(), () => EmailMessageMessage.ExceptionMessages.NiceToString());
ProcessLogic.AssertStarted(sb);
ProcessLogic.Register(EmailMessageProcess.CreateEmailsSendAsync, new CreateEmailsSendAsyncProcessAlgorithm());
ProcessLogic.Register(EmailMessageProcess.SendEmails, new SendEmailProcessAlgorithm());
new Graph <ProcessEntity> .ConstructFromMany <EmailMessageEntity>(EmailMessageOperation.ReSendEmails)
{
Construct = (messages, args) =>
{
if (!messages.Any())
{
return(null);
}
EmailPackageEntity emailPackage = new EmailPackageEntity()
{
Name = args.TryGetArgC <string>()
}.Save();
foreach (var m in messages.Select(m => m.RetrieveAndForget()))
{
new EmailMessageEntity()
{
Package = emailPackage.ToLite(),
From = m.From,
Recipients = m.Recipients.ToMList(),
Target = m.Target,
Body = new BigStringEmbedded(m.Body.Text),
IsBodyHtml = m.IsBodyHtml,
Subject = m.Subject,
Template = m.Template,
EditableMessage = m.EditableMessage,
State = EmailMessageState.RecruitedForSending,
Attachments = m.Attachments.Select(a => a.Clone()).ToMList()
}.Save();
}
return(ProcessLogic.Create(EmailMessageProcess.SendEmails, emailPackage));
}
}
.Register();
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include<EmailPackageEntity>();
dqm.RegisterExpression((EmailPackageEntity ep) => ep.Messages(), () => EmailMessageMessage.Messages.NiceToString());
dqm.RegisterExpression((EmailPackageEntity ep) => ep.RemainingMessages(), () => EmailMessageMessage.RemainingMessages.NiceToString());
dqm.RegisterExpression((EmailPackageEntity ep) => ep.ExceptionMessages(), () => EmailMessageMessage.ExceptionMessages.NiceToString());
ProcessLogic.AssertStarted(sb);
ProcessLogic.Register(EmailMessageProcess.CreateEmailsSendAsync, new CreateEmailsSendAsyncProcessAlgorithm());
ProcessLogic.Register(EmailMessageProcess.SendEmails, new SendEmailProcessAlgorithm());
new Graph<ProcessEntity>.ConstructFromMany<EmailMessageEntity>(EmailMessageOperation.ReSendEmails)
{
Construct = (messages, args) =>
{
EmailPackageEntity emailPackage = new EmailPackageEntity()
{
Name = args.TryGetArgC<string>()
}.Save();
foreach (var m in messages.Select(m => m.RetrieveAndForget()))
{
new EmailMessageEntity()
{
Package = emailPackage.ToLite(),
From = m.From,
Recipients = m.Recipients.ToMList(),
Target = m.Target,
Body = m.Body,
IsBodyHtml = m.IsBodyHtml,
Subject = m.Subject,
Template = m.Template,
EditableMessage = m.EditableMessage,
State = EmailMessageState.RecruitedForSending
}.Save();
}
return ProcessLogic.Create(EmailMessageProcess.SendEmails, emailPackage);
}
}.Register();
dqm.RegisterQuery(typeof(EmailPackageEntity), () =>
from e in Database.Query<EmailPackageEntity>()
select new
{
Entity = e,
e.Id,
e.Name,
});
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <EmailPackageEntity>()
.WithQuery(dqm, () => e => new
{
Entity = e,
e.Id,
e.Name,
});
dqm.RegisterExpression((EmailPackageEntity ep) => ep.Messages(), () => EmailMessageMessage.Messages.NiceToString());
dqm.RegisterExpression((EmailPackageEntity ep) => ep.RemainingMessages(), () => EmailMessageMessage.RemainingMessages.NiceToString());
dqm.RegisterExpression((EmailPackageEntity ep) => ep.ExceptionMessages(), () => EmailMessageMessage.ExceptionMessages.NiceToString());
ProcessLogic.AssertStarted(sb);
ProcessLogic.Register(EmailMessageProcess.CreateEmailsSendAsync, new CreateEmailsSendAsyncProcessAlgorithm());
ProcessLogic.Register(EmailMessageProcess.SendEmails, new SendEmailProcessAlgorithm());
new Graph <ProcessEntity> .ConstructFromMany <EmailMessageEntity>(EmailMessageOperation.ReSendEmails)
{
Construct = (messages, args) =>
{
EmailPackageEntity emailPackage = new EmailPackageEntity()
{
Name = args.TryGetArgC <string>()
}.Save();
foreach (var m in messages.Select(m => m.RetrieveAndForget()))
{
new EmailMessageEntity()
{
Package = emailPackage.ToLite(),
From = m.From,
Recipients = m.Recipients.ToMList(),
Target = m.Target,
Body = m.Body,
IsBodyHtml = m.IsBodyHtml,
Subject = m.Subject,
Template = m.Template,
EditableMessage = m.EditableMessage,
State = EmailMessageState.RecruitedForSending
}.Save();
}
return(ProcessLogic.Create(EmailMessageProcess.SendEmails, emailPackage));
}
}
.Register();
}
}
public void Execute(ExecutingProcess executingProcess)
{
EmailPackageEntity package = (EmailPackageEntity)executingProcess.Data !;
List <Lite <EmailMessageEntity> > emails = package.RemainingMessages()
.OrderBy(e => e.CreationDate)
.Select(e => e.ToLite())
.ToList();
int counter = 0;
using (AuthLogic.Disable())
{
foreach (var group in emails.GroupsOf(EmailLogic.Configuration.ChunkSizeSendingEmails))
{
var retrieved = group.RetrieveFromListOfLite();
foreach (var m in retrieved)
{
executingProcess.CancellationToken.ThrowIfCancellationRequested();
counter++;
try
{
using (Transaction tr = Transaction.ForceNew())
{
EmailLogic.SenderManager.Send(m);
tr.Commit();
}
executingProcess.ProgressChanged(counter, emails.Count);
}
catch
{
try
{
if (m.SendRetries < EmailLogic.Configuration.MaxEmailSendRetries)
{
using (Transaction tr = Transaction.ForceNew())
{
var nm = m.ToLite().RetrieveAndRemember();
nm.SendRetries += 1;
nm.State = EmailMessageState.ReadyToSend;
nm.Save();
tr.Commit();
}
}
}
catch { }
}
}
}
}
}
public static IQueryable <EmailMessageEntity> EmailMessages(this EmailPackageEntity e) => As.Expression(() => Database.Query <EmailMessageEntity>().Where(a => a.Package.Is(e)));
public static IQueryable <EmailMessageEntity> ExceptionMessages(this EmailPackageEntity p)
{
return(ExceptionMessagesExpression.Evaluate(p));
}
public static IQueryable <EmailMessageEntity> RemainingMessages(this EmailPackageEntity p)
{
return(RemainingMessagesExpression.Evaluate(p));
}
public static void RegisterAlertNotificationMail(SchemaBuilder sb)
{
EmailModelLogic.RegisterEmailModel <AlertNotificationMail>(() => new EmailTemplateEntity
{
Messages = CultureInfoLogic.ForEachCulture(culture => new EmailTemplateMessageEmbedded(culture)
{
Text = @"
<p>Hi @[m:Entity],</p>
<p>You have some pending alerts:</p>
<ul>
@foreach[m:Alerts] as $a
<li>
<strong>@[$a.AlertType]:</strong><br/>
@[m:TextFormatted]<br/>
<small>@[$a.AlertDate] @[$a.CreatedBy]</small>
</li>
@endforeach
</ul>
<p>Please visit <a href=""@[g:UrlLeft]"">@[g:UrlLeft]</a></p>",
Subject = AlertMessage.NewUnreadNotifications.NiceToString(),
}).ToMList()
});
sb.Include <SendNotificationEmailTaskEntity>()
.WithSave(SendNotificationEmailTaskOperation.Save)
.WithQuery(() => e => new
{
Entity = e,
e.Id,
e.SendNotificationsOlderThan,
e.SendBehavior,
});
SchedulerLogic.ExecuteTask.Register((SendNotificationEmailTaskEntity task, ScheduledTaskContext ctx) =>
{
var limit = DateTime.Now.AddMinutes(-task.SendNotificationsOlderThan);
var query = Database.Query <AlertEntity>()
.Where(a => a.State == AlertState.Saved && a.EmailNotificationsSent == 0 && a.Recipient != null && a.CreationDate < limit)
.Where(a => task.SendBehavior == SendAlertTypeBehavior.All ||
task.SendBehavior == SendAlertTypeBehavior.Include && task.AlertTypes.Contains(a.AlertType !) ||
task.SendBehavior == SendAlertTypeBehavior.Exclude && !task.AlertTypes.Contains(a.AlertType !));
if (!query.Any())
{
return(null);
}
var alerts = query
.Select(a => new { Alert = a, Recipient = a.Recipient !.Entity })
.ToList();
EmailPackageEntity emailPackage = new EmailPackageEntity().Save();
var emails = alerts.GroupBy(a => a.Recipient, a => a.Alert).SelectMany(gr => new AlertNotificationMail((UserEntity)gr.Key, gr.ToList()).CreateEmailMessage()).ToList();
emails.ForEach(a =>
{
a.State = EmailMessageState.ReadyToSend;
a.Package = emailPackage.ToLite();
});
emails.BulkInsertQueryIds(a => a.Target !);
query.UnsafeUpdate().Set(a => a.EmailNotificationsSent, a => 1).Execute();
return(emailPackage.ToLite());
});
public static IQueryable <EmailMessageEntity> ExceptionMessages(this EmailPackageEntity p) => As.Expression(() => p.Messages().Where(a => a.State == EmailMessageState.SentException));
public static IQueryable <EmailMessageEntity> RemainingMessages(this EmailPackageEntity p) => As.Expression(() => p.Messages().Where(a => a.State == EmailMessageState.RecruitedForSending));
