private static IEnumerable <EmailMessageEntity> CreateEmailMessage(EmailTemplateEntity template, ModifiableEntity?modifiableEntity, ref IEmailModel?model, CultureInfo?cultureInfo = null)
{
Entity?entity = null;
if (template.Model != null)
{
if (model == null)
{
model = EmailModelLogic.CreateModel(template.Model, modifiableEntity);
}
else if (template.Model.ToType() != model.GetType())
{
throw new ArgumentException("model should be a {0} instead of {1}".FormatWith(template.Model.FullClassName, model.GetType().FullName));
}
}
else
{
entity = modifiableEntity as Entity ?? throw new InvalidOperationException("Model should be an Entity");
}
using (template.DisableAuthorization ? ExecutionMode.Global() : null)
{
var emailBuilder = new EmailMessageBuilder(template, entity, model, cultureInfo);
return(emailBuilder.CreateEmailMessageInternal().ToList());
}
}
internal static EmailTemplateEntity CreateDefaultTemplate(EmailModelEntity emailModel)
{
EmailModelInfo info = registeredModels.GetOrThrow(entityToType.Value.GetOrThrow(emailModel));
if (info.DefaultTemplateConstructor == null)
{
throw new InvalidOperationException($"No EmailTemplate for {emailModel} found and DefaultTemplateConstructor = null");
}
EmailTemplateEntity template = info.DefaultTemplateConstructor.Invoke();
if (template.MasterTemplate != null)
{
template.MasterTemplate = EmailMasterTemplateLogic.GetDefaultMasterTemplate();
}
if (template.Name == null)
{
template.Name = emailModel.FullClassName;
}
template.Model = emailModel;
template.Query = QueryLogic.GetQueryEntity(info.QueryName);
template.ParseData(QueryLogic.Queries.QueryDescription(info.QueryName));
return(template);
}
public EmailTemplateEntity GetEmailTemplate(string templateKey)
{
string methodName = MethodBase.GetCurrentMethod().Name;
EmailTemplateEntity entity = null;
using (var connection = CreateConnection())
{
try
{
connection.Open();
var query = "SELECT * FROM EmailTemplates WHERE TemplateKey = @TemplateKey;";
var param = new { @TemplateKey = templateKey };
entity = connection.Query <EmailTemplateEntity>(query, param).FirstOrDefault();
BindSubscribers(entity);
}
catch (Exception ex)
{
Log?.Error(className, methodName, ex.ToString());
}
finally
{
connection.Close();
}
}
return(entity);
}
private IEnumerable <EmailSubscriberEntity> BindSubscribers(EmailTemplateEntity entity)
{
string methodName = MethodBase.GetCurrentMethod().Name;
using (var connection = CreateConnection())
{
try
{
connection.Open();
var query = "SELECT s.* FROM EmailTemplates et INNER JOIN EmailSubscriptions es ON et.Id = es.TemplateId INNER JOIN EmailSubscribers s ON s.Id = es.SubscriberId WHERE TemplateId = @TemplateId;";
var param = new { @TemplateId = entity.Id };
entity.Subscribers = connection.Query <EmailSubscriberEntity>(query, param);
//BindSubscribers(entity);
}
catch (Exception ex)
{
Log?.Error(className, methodName, ex.ToString());
}
finally
{
connection.Close();
}
}
return(entity.Subscribers);
}
/// <summary>Creates a new, empty EmailTemplateEntity object.</summary>
/// <returns>A new, empty EmailTemplateEntity object.</returns>
public override IEntity Create()
{
IEntity toReturn = new EmailTemplateEntity();
// __LLBLGENPRO_USER_CODE_REGION_START CreateNewEmailTemplate
// __LLBLGENPRO_USER_CODE_REGION_END
return(toReturn);
}
/// <summary> setups the sync logic for member _emailTemplate</summary>
/// <param name="relatedEntity">Instance to set as the related entity of type entityType</param>
private void SetupSyncEmailTemplate(IEntity2 relatedEntity)
{
if (_emailTemplate != relatedEntity)
{
DesetupSyncEmailTemplate(true, true);
_emailTemplate = (EmailTemplateEntity)relatedEntity;
base.PerformSetupSyncRelatedEntity(_emailTemplate, new PropertyChangedEventHandler(OnEmailTemplatePropertyChanged), "EmailTemplate", EmailTemplateMacroEntity.Relations.EmailTemplateEntityUsingEmailTemplateId, true, new string[] { });
}
}
public GenerateAttachmentContext(QueryDescription queryDescription, EmailTemplateEntity template,
Dictionary <QueryToken, ResultColumn> resultColumns,
IEnumerable <ResultRow> currentRows, CultureInfo culture)
{
QueryDescription = queryDescription;
Template = template;
ResultColumns = resultColumns;
CurrentRows = currentRows;
Culture = culture;
}
public EmailMessageBuilder(EmailTemplateEntity template, Entity?entity, IEmailModel?systemEmail)
{
this.template = template;
this.entity = entity;
this.model = systemEmail;
this.queryName = QueryLogic.ToQueryName(template.Query.Key);
this.qd = QueryLogic.Queries.QueryDescription(queryName);
this.smtpConfig = EmailTemplateLogic.GetSmtpConfiguration?.Invoke(template, (systemEmail?.UntypedEntity as Entity ?? entity)?.ToLite());
}
public EmailMessageBuilder(EmailTemplateEntity template, Entity entity, ISystemEmail systemEmail)
{
this.template = template;
this.entity = entity;
this.systemEmail = systemEmail;
this.queryName = QueryLogic.ToQueryName(template.Query.Key);
this.qd = DynamicQueryManager.Current.QueryDescription(queryName);
this.smtpConfig = EmailTemplateLogic.GetSmtpConfiguration == null ? null : EmailTemplateLogic.GetSmtpConfiguration(template);
}
static void EmailTemplateLogic_Retrieved(EmailTemplateEntity emailTemplate)
{
using (emailTemplate.DisableAuthorization ? ExecutionMode.Global() : null)
{
object queryName = QueryLogic.ToQueryName(emailTemplate.Query.Key);
QueryDescription description = QueryLogic.Queries.QueryDescription(queryName);
using (emailTemplate.DisableAuthorization ? ExecutionMode.Global() : null)
emailTemplate.ParseData(description);
}
}
public static TextTemplateParser.BlockNode ParseTemplate(EmailTemplateEntity template, string?text, out string errorMessage)
{
using (template.DisableAuthorization ? ExecutionMode.Global() : null)
{
object queryName = QueryLogic.ToQueryName(template.Query.Key);
QueryDescription qd = QueryLogic.Queries.QueryDescription(queryName);
List <QueryToken> list = new List <QueryToken>();
return(TextTemplateParser.TryParse(text, qd, template.Model?.ToType(), out errorMessage));
}
}
/// <summary> Initializes the class members</summary>
protected virtual void InitClassMembers()
{
_emailTemplate = null;
_templateMacro = null;
PerformDependencyInjection();
// __LLBLGENPRO_USER_CODE_REGION_START InitClassMembers
// __LLBLGENPRO_USER_CODE_REGION_END
OnInitClassMembersComplete();
}
internal static SqlPreCommand?Regenerate(EmailTemplateEntity et, Replacements?replacements, Table table)
{
var newTemplate = EmailModelLogic.CreateDefaultTemplate(et.Model !);
newTemplate.SetId(et.IdOrNull);
newTemplate.SetIsNew(false);
newTemplate.Ticks = et.Ticks;
using (replacements?.WithReplacedDatabaseName())
return(table.UpdateSqlSync(newTemplate, e => e.Name == newTemplate.Name, includeCollections: true, comment: "EmailTemplate Regenerated: " + et.Name));
}
public static bool Regenerate(EmailTemplateEntity et)
{
var leaves = Regenerate(et, null, Schema.Current.Table <EmailTemplateEntity>());
if (leaves == null)
{
return(false);
}
leaves.ExecuteLeaves();
return(true);
}
public void CreateNewEmailTemplate(EmailTemplateEntity template)
{
var dbTemplate = new Email_Template();
dbTemplate.isActive = template.isActive;
dbTemplate.lastUpdate = template.lastUpdate;
dbTemplate.MailContent = template.MailContent;
dbTemplate.Name = template.Name;
dbTemplate.CateID = template.EmailCategoryId;
dbTemplate.createdDate = template.createdDate;
dbTemplate.creatorID = template.creatorID;
context.Email_Template.Add(dbTemplate);
context.SaveChanges();
}
public static EmailTemplateEntity ParseData(this EmailTemplateEntity emailTemplate)
{
if (!emailTemplate.IsNew || emailTemplate.queryName == null)
{
throw new InvalidOperationException("emailTemplate should be new and have queryName");
}
emailTemplate.Query = QueryLogic.GetQueryEntity(emailTemplate.queryName);
QueryDescription description = QueryLogic.Queries.QueryDescription(emailTemplate.queryName);
emailTemplate.ParseData(description);
return(emailTemplate);
}
static void EmailTemplate_PreSaving(EmailTemplateEntity template, PreSavingContext ctx)
{
using (template.DisableAuthorization ? ExecutionMode.Global() : null)
{
var queryName = QueryLogic.ToQueryName(template.Query.Key);
QueryDescription qd = QueryLogic.Queries.QueryDescription(queryName);
List <QueryToken> list = new List <QueryToken>();
foreach (var message in template.Messages)
{
message.Text = TextTemplateParser.Parse(message.Text, qd, template.Model?.ToType()).ToString();
message.Subject = TextTemplateParser.Parse(message.Subject, qd, template.Model?.ToType()).ToString();
}
}
}
public EmailTemplateEntity GetTemplate(Criteria criteria)
{
EmailTemplateEntity emailTemplate = null;
//using (var db = DbHelper.Open())
//{
// int templateId = criteria.ID.ToInt();
// var template = db.EmailTemplates.SingleOrDefault(r => r.ID == templateId);
// emailTemplate = new EmailTemplateEntity()
// {
// ID = template.ID,
// TemplateName = template.TemplateName,
// TemplateBody = template.TemplateBody
// };
return(emailTemplate);
//}
}
public void EditMailTemplate(EmailTemplateEntity template)
{
if (template == null)
{
return;
}
var dbTemplate = context.Email_Template.SingleOrDefault(c => c.id == template.id);
if (dbTemplate == null)
{
return;
}
dbTemplate.isActive = template.isActive;
dbTemplate.lastUpdate = template.lastUpdate;
dbTemplate.MailContent = template.MailContent;
dbTemplate.Name = template.Name;
dbTemplate.CateID = template.CateID;
dbTemplate.createdDate = template.createdDate;
dbTemplate.creatorID = template.creatorID;
context.SaveChanges();
}
protected EmailTemplateMacroEntity(SerializationInfo info, StreamingContext context) : base(info, context)
{
if (SerializationHelper.Optimization != SerializationOptimization.Fast)
{
_emailTemplate = (EmailTemplateEntity)info.GetValue("_emailTemplate", typeof(EmailTemplateEntity));
if (_emailTemplate != null)
{
_emailTemplate.AfterSave += new EventHandler(OnEntityAfterSave);
}
_templateMacro = (TemplateMacroEntity)info.GetValue("_templateMacro", typeof(TemplateMacroEntity));
if (_templateMacro != null)
{
_templateMacro.AfterSave += new EventHandler(OnEntityAfterSave);
}
base.FixupDeserialization(FieldInfoProviderSingleton.GetInstance());
}
// __LLBLGENPRO_USER_CODE_REGION_START DeserializationConstructor
// __LLBLGENPRO_USER_CODE_REGION_END
}
public static bool IsVisible(EmailTemplateEntity et, EmailTemplateVisibleOn visibleOn)
{
if (et.Model == null)
{
return(visibleOn == EmailTemplateVisibleOn.Single);
}
if (EmailModelLogic.HasDefaultTemplateConstructor(et.Model))
{
return(false);
}
var entityType = EmailModelLogic.GetEntityType(et.Model.ToType());
if (entityType.IsEntity())
{
return(visibleOn == EmailTemplateVisibleOn.Single);
}
var should = VisibleOnDictionary.TryGet(entityType, EmailTemplateVisibleOn.Single);
return((should & visibleOn) != 0);
}
internal static EmailTemplateEntity CreateDefaultTemplate(SystemEmailEntity systemEmail)
{
SystemEmailInfo info = systemEmails.GetOrThrow(systemEmailToType.Value.GetOrThrow(systemEmail));
EmailTemplateEntity template = info.DefaultTemplateConstructor();
if (template.MasterTemplate != null)
{
template.MasterTemplate = EmailMasterTemplateLogic.GetDefaultMasterTemplate();
}
if (template.Name == null)
{
template.Name = systemEmail.FullClassName;
}
template.SystemEmail = systemEmail;
template.Query = QueryLogic.GetQueryEntity(info.QueryName);
template.ParseData(DynamicQueryManager.Current.QueryDescription(info.QueryName));
return(template);
}
public ActionResult EditTemplate(int id)
{
Email_Template dbTemplate = mailRepo.getById(id);
EmailTemplateEntity template = new EmailTemplateEntity();
template.Name = dbTemplate.Name;
template.MailContent = dbTemplate.MailContent;
template.CateID = dbTemplate.CateID;
EmailCategory cate = new EmailCategory();
cate.Name = cateRepo.getById((int)template.CateID).Name;
var viewModel = new CreateEmailTemplateViewModel
{
EmailTemplateEntity = template,
EmailCategories = getCategories(),
EmailCategory = cate
};
return(View("EditTemplate", viewModel));
}
/// <summary> Removes the sync logic for member _emailTemplate</summary>
/// <param name="signalRelatedEntity">If set to true, it will call the related entity's UnsetRelatedEntity method</param>
/// <param name="resetFKFields">if set to true it will also reset the FK fields pointing to the related entity</param>
private void DesetupSyncEmailTemplate(bool signalRelatedEntity, bool resetFKFields)
{
base.PerformDesetupSyncRelatedEntity(_emailTemplate, new PropertyChangedEventHandler(OnEmailTemplatePropertyChanged), "EmailTemplate", EmailTemplateMacroEntity.Relations.EmailTemplateEntityUsingEmailTemplateId, true, signalRelatedEntity, "EmailTemplateMacro", resetFKFields, new int[] { (int)EmailTemplateMacroFieldIndex.EmailTemplateId });
_emailTemplate = null;
}
internal static SqlPreCommand?ProcessEmailTemplate(Replacements replacements, Table table, EmailTemplateEntity et, StringDistance sd)
{
Console.Write(".");
try
{
var queryName = QueryLogic.ToQueryName(et.Query.Key);
QueryDescription qd = QueryLogic.Queries.QueryDescription(queryName);
using (DelayedConsole.Delay(() => SafeConsole.WriteLineColor(ConsoleColor.White, "EmailTemplate: " + et.Name)))
using (DelayedConsole.Delay(() => Console.WriteLine(" Query: " + et.Query.Key)))
{
if (et.From != null && et.From.Token != null)
{
QueryTokenEmbedded token = et.From.Token;
switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, " From", allowRemoveToken: false, allowReCreate: et.Model != null))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(et, e => e.Name == et.Name));
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: et.From.Token = token; break;
case FixTokenResult.ReGenerateEntity: return(Regenerate(et, replacements, table));
default: break;
}
}
if (et.Recipients.Any(a => a.Token != null))
{
using (DelayedConsole.Delay(() => Console.WriteLine(" Recipients:")))
{
foreach (var item in et.Recipients.Where(a => a.Token != null).ToList())
{
QueryTokenEmbedded token = item.Token !;
switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, " Recipient", allowRemoveToken: false, allowReCreate: et.Model != null))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(et, e => e.Name == et.Name));
case FixTokenResult.RemoveToken: et.Recipients.Remove(item); break;
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: item.Token = token; break;
case FixTokenResult.ReGenerateEntity: return(Regenerate(et, replacements, table));
default: break;
}
}
}
}
try
{
foreach (var item in et.Messages)
{
SynchronizationContext sc = new SynchronizationContext(replacements, sd, qd, et.Model?.ToType());
item.Subject = TextTemplateParser.Synchronize(item.Subject, sc);
item.Text = TextTemplateParser.Synchronize(item.Text, sc);
}
using (replacements.WithReplacedDatabaseName())
return(table.UpdateSqlSync(et, e => e.Name == et.Name, includeCollections: true, comment: "EmailTemplate: " + et.Name));
}
catch (TemplateSyncException ex)
{
if (ex.Result == FixTokenResult.SkipEntity)
{
return(null);
}
if (ex.Result == FixTokenResult.DeleteEntity)
{
return(table.DeleteSqlSync(et, e => e.Name == et.Name));
}
if (ex.Result == FixTokenResult.ReGenerateEntity)
{
return(Regenerate(et, replacements, table));
}
throw new UnexpectedValueException(ex.Result);
}
}
}
catch (Exception e)
{
return(new SqlPreCommandSimple("-- Exception on {0}. {1}\r\n{2}".FormatWith(et.BaseToString(), e.GetType().Name, e.Message.Indent(2, '-'))));
}
}
public static EmailTemplateMessageEmbedded GetCultureMessage(this EmailTemplateEntity template, CultureInfo ci)
{
return(template.Messages.SingleOrDefault(tm => tm.CultureInfo.ToCultureInfo() == ci));
}
public static IEnumerable <EmailMessageEntity> CreateEmailMessage(this EmailTemplateEntity template, ModifiableEntity?modifiableEntity = null, IEmailModel?model = null)
{
return(CreateEmailMessage(template, modifiableEntity, ref model));
}
public static IEnumerable <EmailMessageEntity> CreateEmailMessage(this Lite <EmailTemplateEntity> liteTemplate, ModifiableEntity?modifiableEntity = null, IEmailModel?model = null)
{
EmailTemplateEntity template = EmailTemplatesLazy.Value.GetOrThrow(liteTemplate, "Email template {0} not in cache".FormatWith(liteTemplate));
return(CreateEmailMessage(template, modifiableEntity, ref model));
}
public EmailTemplateDto(EmailTemplateEntity entity)
{
this.Id = entity.Id;
this.Body = entity.Body;
this.IsActive = entity.IsActive;
}
internal static SqlPreCommand ProcessEmailTemplate(Replacements replacements, Table table, EmailTemplateEntity et, StringDistance sd)
{
try
{
var queryName = QueryLogic.ToQueryName(et.Query.Key);
QueryDescription qd = DynamicQueryManager.Current.QueryDescription(queryName);
Console.Clear();
SafeConsole.WriteLineColor(ConsoleColor.White, "EmailTemplate: " + et.Name);
Console.WriteLine(" Query: " + et.Query.Key);
if (et.From != null && et.From.Token != null)
{
QueryTokenEmbedded token = et.From.Token;
switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, " From", allowRemoveToken: false, allowReCreate: et.SystemEmail != null))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(et));
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: et.From.Token = token; break;
case FixTokenResult.ReGenerateEntity: return(Regenerate(et, replacements, table));
default: break;
}
}
if (et.Recipients.Any(a => a.Token != null))
{
Console.WriteLine(" Recipients:");
foreach (var item in et.Recipients.Where(a => a.Token != null).ToList())
{
QueryTokenEmbedded token = item.Token;
switch (QueryTokenSynchronizer.FixToken(replacements, ref token, qd, SubTokensOptions.CanElement, " Recipient", allowRemoveToken: false, allowReCreate: et.SystemEmail != null))
{
case FixTokenResult.Nothing: break;
case FixTokenResult.DeleteEntity: return(table.DeleteSqlSync(et));
case FixTokenResult.RemoveToken: et.Recipients.Remove(item); break;
case FixTokenResult.SkipEntity: return(null);
case FixTokenResult.Fix: item.Token = token; break;
case FixTokenResult.ReGenerateEntity: return(Regenerate(et, replacements, table));
default: break;
}
}
}
try
{
foreach (var item in et.Messages)
{
SyncronizationContext sc = new SyncronizationContext
{
ModelType = et.SystemEmail.ToType(),
QueryDescription = qd,
Replacements = replacements,
StringDistance = sd,
Variables = new ScopedDictionary <string, ValueProviderBase>(null)
};
item.Subject = Synchronize(item.Subject, sc);
item.Text = Synchronize(item.Text, sc);
}
using (replacements.WithReplacedDatabaseName())
return(table.UpdateSqlSync(et, includeCollections: true, comment: "EmailTemplate: " + et.Name));
}
catch (TemplateSyncException ex)
{
if (ex.Result == FixTokenResult.SkipEntity)
{
return(null);
}
if (ex.Result == FixTokenResult.DeleteEntity)
{
return(table.DeleteSqlSync(et));
}
if (ex.Result == FixTokenResult.ReGenerateEntity)
{
return(Regenerate(et, replacements, table));
}
throw new InvalidOperationException("Unexcpected {0}".FormatWith(ex.Result));
}
finally
{
Console.Clear();
}
}
catch (Exception e)
{
return(new SqlPreCommandSimple("-- Exception on {0}. {1}\r\n{2}".FormatWith(et.BaseToString(), e.GetType().Name, e.Message.Indent(2, '-'))));
}
}
