public static WordTemplateEntity GetDefaultTemplate(SystemWordTemplateEntity systemWordTemplate, Entity entity)
{
var templates = SystemWordTemplateToWordTemplates.Value.TryGetC(systemWordTemplate.ToLite()).EmptyIfNull().Select(a => WordTemplateLogic.WordTemplatesLazy.Value.GetOrThrow(a));
if (templates.IsNullOrEmpty() && HasDefaultTemplateConstructor(systemWordTemplate))
{
using (ExecutionMode.Global())
using (OperationLogic.AllowSave <WordTemplateEntity>())
using (Transaction tr = Transaction.ForceNew())
{
var template = CreateDefaultTemplate(systemWordTemplate);
template.Save();
return(tr.Commit(template));
}
}
var isAllowed = Schema.Current.GetInMemoryFilter <WordTemplateEntity>(userInterface: false);
var candidates = templates.Where(isAllowed).Where(t => t.IsApplicable(entity));
return(GetTemplate(candidates, systemWordTemplate, CultureInfo.CurrentCulture) ??
GetTemplate(candidates, systemWordTemplate, CultureInfo.CurrentCulture.Parent) ??
candidates.Only() ??
throw new InvalidProgramException($"No active template found for {systemWordReports} in {CultureInfo.CurrentCulture} or {CultureInfo.CurrentCulture.Parent}"));
}
public override Task OnActionExecutedAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
{
try
{
var request =
(RestLogEntity)actionExecutedContext.ActionContext.ControllerContext.RouteData.Values.GetOrThrow(
typeof(RestLogEntity).FullName);
request.EndDate = TimeZoneManager.Now;
if (actionExecutedContext.Exception == null)
{
request.ResponseBody = actionExecutedContext.Response.Content?.ReadAsStringAsync()?.Result;
}
if (actionExecutedContext.Exception != null)
{
request.Exception = actionExecutedContext.Exception.LogException()?.ToLite();
}
using (ExecutionMode.Global())
request.Save();
}
catch (Exception e)
{
e.LogException();
}
return(base.OnActionExecutedAsync(actionExecutedContext, cancellationToken));
}
public override void OnResultExecuted(ResultExecutedContext context)
{
try
{
var request = (RestLogEntity)context.HttpContext.Items.GetOrThrow(typeof(RestLogEntity).FullName !) !;
request.EndDate = Clock.Now;
Stream memoryStream = RestoreOriginalStream(context);
if (context.Exception == null)
{
memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
request.ResponseBody = Encoding.UTF8.GetString(memoryStream.ReadAllBytes());
}
if (context.Exception != null)
{
request.Exception = context.Exception.LogException()?.ToLite();
}
using (ExecutionMode.Global())
request.Save();
}
catch (Exception e)
{
e.LogException();
}
}
public static ResetLazy <T> WithoutInvalidations <T>(Func <T> func, LazyThreadSafetyMode mode = LazyThreadSafetyMode.ExecutionAndPublication)
{
ResetLazy <T> result = new ResetLazy <T>(() =>
{
using (ExecutionMode.Global())
using (HeavyProfiler.Log("ResetLazy", () => typeof(T).TypeName()))
using (Transaction? tr = Transaction.InTestTransaction ? null : Transaction.ForceNew())
using (new EntityCache(EntityCacheType.ForceNewSealed))
{
var value = func();
if (tr != null)
{
tr.Commit();
}
return(value);
}
}, mode,
declaringType: func.Method.DeclaringType);
registeredLazyList.Add(result);
return(result);
}
public static List <CodeFile> GetCodeFiles()
{
CacheLogic.GloballyDisabled = true;
try
{
using (ExecutionMode.Global())
{
var result = new List <CodeFile>();
var controllers = !Administrator.ExistsTable <DynamicApiEntity>() ?
new List <DynamicApiEntity>() :
Database.Query <DynamicApiEntity>()
.Where(a => a.Mixin <DisabledMixin>().IsDisabled == false)
.ToList();
var dtcg = new DynamicApiCodeGenerator(DynamicCode.CodeGenControllerNamespace, controllers, DynamicCode.GetNamespaces().ToHashSet());
var content = dtcg.GetFileCode();
result.Add(new CodeFile("CodeGenController.cs", content));
return(result);
}
}
finally
{
CacheLogic.GloballyDisabled = false;
}
}
public static Dictionary <OperationSymbol, string> GetContextualCanExecute(IEnumerable <Lite <IEntity> > lites, List <OperationSymbol> operationSymbols)
{
Dictionary <OperationSymbol, string> result = null;
using (ExecutionMode.Global())
{
foreach (var grLites in lites.GroupBy(a => a.EntityType))
{
var operations = operationSymbols.Select(opKey => FindOperation(grLites.Key, opKey)).ToList();
foreach (var grOperations in operations.GroupBy(a => a.GetType().GetGenericArguments().Let(arr => Tuple.Create(arr[0], arr[1]))))
{
var dic = giGetContextualGraphCanExecute.GetInvoker(grLites.Key, grOperations.Key.Item1, grOperations.Key.Item2)(grLites, grOperations);
if (result == null)
{
result = dic;
}
else
{
foreach (var kvp in dic)
{
result[kvp.Key] = "\r\n".Combine(result.TryGetC(kvp.Key), kvp.Value);
}
}
}
}
}
return(result);
}
public static List <CodeFile> GetCodeFiles()
{
CacheLogic.GloballyDisabled = true;
try
{
using (ExecutionMode.Global())
{
var result = new List <CodeFile>();
var expressions = !Administrator.ExistsTable <DynamicExpressionEntity>() ?
new List <DynamicExpressionEntity>() :
Database.Query <DynamicExpressionEntity>().ToList();
var dtcg = new DynamicExpressionCodeGenerator(DynamicCode.CodeGenEntitiesNamespace, expressions, DynamicCode.Namespaces);
var content = dtcg.GetFileCode();
result.Add(new CodeFile
{
FileName = "CodeGenExpressionStarter.cs",
FileContent = content,
});
return(result);
}
}
finally
{
CacheLogic.GloballyDisabled = false;
}
}
static string ValidateTemplate(WordTemplateEntity template, PropertyInfo pi)
{
if (template.Template == null)
{
return(null);
}
using (template.DisableAuthorization ? ExecutionMode.Global() : null)
{
QueryDescription qd = DynamicQueryManager.Current.QueryDescription(template.Query.ToQueryName());
string error = null;
template.ProcessOpenXmlPackage(document =>
{
Dump(document, "0.Original.txt");
var parser = new TemplateParser(document, qd, template.SystemWordTemplate.ToType(), template);
parser.ParseDocument(); Dump(document, "1.Match.txt");
parser.CreateNodes(); Dump(document, "2.BaseNode.txt");
parser.AssertClean();
error = parser.Errors.IsEmpty() ? null :
parser.Errors.ToString(e => e.Message, "\r\n");
});
return(error);
}
}
protected virtual T Return <T>(MethodBase mi, string description, Func <T> function)
{
try
{
using (CultureFromOperationContext())
using (ScopeSessionFactory.OverrideSession(session))
using (ExecutionMode.Global())
{
return(function());
}
}
catch (Exception e)
{
e.LogException(el =>
{
el.ControllerName = GetType().Name;
el.ActionName = mi.Name;
el.QueryString = description;
});
throw;
}
finally
{
Statics.CleanThreadContextAndAssert();
}
}
public static IDisposable?LogView(Lite <IEntity> entity, string viewAction)
{
if (!IsStarted)
{
return(null);
}
if (entity == null || !LogType(entity.EntityType) || UserHolder.Current == null)
{
return(null);
}
var viewLog = new ViewLogEntity
{
Target = (Lite <Entity>)entity.Clone(),
User = UserHolder.Current.ToLite(),
ViewAction = viewAction,
Data = new BigStringEmbedded(),
};
return(new Disposable(() =>
{
viewLog.EndDate = TimeZoneManager.Now;
using (ExecutionMode.Global())
viewLog.Save();
}));
}
public static bool Log(string eventType, ExceptionEntity?exception = null)
{
if (!Started)
{
return(false);
}
try
{
using (var tr = Transaction.ForceNew())
{
using (ExecutionMode.Global())
new SystemEventLogEntity
{
Date = Clock.Now,
MachineName = Environment.MachineName,
User = UserHolder.Current?.ToLite(),
EventType = eventType,
Exception = exception?.ToLite()
}.Save();
tr.Commit();
}
return(true);
}
catch (Exception e)
{
e.LogException(ex => ex.ControllerName = "SystemEventLog.Log");
return(false);
}
}
public SqlPreCommand SynchronizationScript(bool interactive = true, bool schemaOnly = false, string replaceDatabaseName = null)
{
OnBeforeDatabaseAccess();
if (Synchronizing == null)
{
return(null);
}
using (CultureInfoUtils.ChangeBothCultures(ForceCultureInfo))
using (ExecutionMode.Global())
{
Replacements replacements = new Replacements()
{
Interactive = interactive, ReplaceDatabaseName = replaceDatabaseName, SchemaOnly = schemaOnly
};
SqlPreCommand command = Synchronizing
.GetInvocationListTyped()
.Select(e =>
{
try
{
return(e(replacements));
}
catch (Exception ex)
{
return(new SqlPreCommandSimple("-- Exception on {0}.{1}\r\n{2}".FormatWith(e.Method.DeclaringType.Name, e.Method.Name, ex.Message.Indent(2, '-'))));
}
})
.Combine(Spacing.Triple);
return(command);
}
}
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());
}
}
public void Initialize()
{
OnBeforeDatabaseAccess();
if (Initializing == null)
{
return;
}
if (InvalidateCache != null)
{
foreach (var ic in InvalidateCache.GetInvocationListTyped())
{
using (HeavyProfiler.Log("InvalidateCache", () => ic.Method.DeclaringType !.ToString()))
ic();
}
}
using (ExecutionMode.Global())
foreach (var init in Initializing.GetInvocationListTyped())
{
using (HeavyProfiler.Log("Initialize", () => init.Method.DeclaringType !.ToString()))
init();
}
Initializing = null;
}
public string SetCurrentCulture([Required, FromBody] Lite <CultureInfoEntity> culture)
{
var ci = ExecutionMode.Global().Using(_ => culture.RetrieveAndRemember().ToCultureInfo());
if (UserEntity.Current != null && !UserEntity.Current.Is(AuthLogic.AnonymousUser)) //Won't be used till next refresh
{
using (AuthLogic.Disable())
using (OperationLogic.AllowSave <UserEntity>())
{
var user = UserEntity.Current.ToLite().RetrieveAndRemember();
user.CultureInfo = culture.RetrieveAndRemember();
UserEntity.Current = user;
user.Save();
}
}
ControllerContext.HttpContext.Response.Cookies.Append("language", ci.Name, new CookieOptions
{
Expires = DateTimeOffset.Now.AddYears(10),
Path = "/",
IsEssential = true,
Domain = Request.Host.Host
});
return(ci.Name);
}
static void StartTrainingAsync(PredictorEntity p)
{
var cancellationSource = new CancellationTokenSource();
var ctx = new PredictorTrainingContext(p, cancellationSource.Token);
var state = new PredictorTrainingState(cancellationSource, ctx);
if (!Trainings.TryAdd(p.ToLite(), state))
{
throw new InvalidOperationException(PredictorMessage._0IsAlreadyBeingTrained.NiceToString(p));
}
using (ExecutionContext.SuppressFlow())
{
Task.Run(() =>
{
var user = ExecutionMode.Global().Using(_ => p.User !.RetrieveAndRemember());
using (UserHolder.UserSession(user))
{
try
{
DoTraining(ctx);
}
finally
{
Trainings.TryRemove(p.ToLite(), out var _);
}
}
});
}
}
public static void Start(SchemaBuilder sb, DynamicQueryManager dqm)
{
if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
{
sb.Include <DynamicExpressionEntity>()
.WithUniqueIndex(a => new { a.FromType, a.Name })
.WithSave(DynamicExpressionOperation.Save)
.WithDelete(DynamicExpressionOperation.Delete)
.WithQuery(dqm, () => e => new
{
Entity = e,
e.Id,
e.Name,
e.ReturnType,
e.FromType,
});
new Graph <DynamicExpressionEntity> .ConstructFrom <DynamicExpressionEntity>(DynamicExpressionOperation.Clone)
{
Construct = (e, _) =>
{
return(new DynamicExpressionEntity
{
Name = e.Name + "_2",
ReturnType = e.ReturnType,
FromType = e.FromType,
Body = e.Body,
});
}
}
.Register();
DynamicLogic.GetCodeFiles += GetCodeFiles;
DynamicLogic.OnWriteDynamicStarter += WriteDynamicStarter;
DynamicTypeLogic.GetAlreadyTranslatedExpressions = () =>
{
CacheLogic.GloballyDisabled = true;
try
{
if (!Administrator.ExistsTable <DynamicExpressionEntity>())
{
return(new Dictionary <string, Dictionary <string, string> >());
}
using (ExecutionMode.Global())
return(Database.Query <DynamicExpressionEntity>()
.Where(a => a.Translation == DynamicExpressionTranslation.TranslateExpressionName)
.AgGroupToDictionary(a => a.FromType, gr => gr.ToDictionary(a => a.Name, a => "CodeGenExpressionMessage." + a.Name)));
}
finally
{
CacheLogic.GloballyDisabled = false;
}
};
sb.Schema.Table <TypeEntity>().PreDeleteSqlSync += type => Administrator.UnsafeDeletePreCommand(Database.Query <DynamicExpressionEntity>().Where(de => de.FromType == ((TypeEntity)type).ClassName));
}
}
static int UnlockTable <T>(Lite <DisconnectedMachineEntity> machine) where T : Entity
{
using (ExecutionMode.Global())
return(Database.Query <T>().Where(a => a.Mixin <DisconnectedSubsetMixin>().DisconnectedMachine == machine)
.UnsafeUpdate()
.Set(a => a.Mixin <DisconnectedSubsetMixin>().DisconnectedMachine, a => null)
.Set(a => a.Mixin <DisconnectedSubsetMixin>().LastOnlineTicks, a => null)
.Execute());
}
static SqlHierarchyId LastChild <T>(SqlHierarchyId node)
where T : TreeEntity
{
using (ExecutionMode.Global())
return(Database.Query <T>()
.Select(c => (SqlHierarchyId?)c.Route)
.Where(n => (bool)((SqlHierarchyId)n !.Value.GetAncestor(1) == node))
.OrderByDescending(n => n).FirstOrDefault() ?? SqlHierarchyId.Null);
}
private static SqlHierarchyId Previous <T>(SqlHierarchyId node)
where T : TreeEntity
{
using (ExecutionMode.Global())
return(Database.Query <T>()
.Select(t => (SqlHierarchyId?)t.Route)
.Where(n => (bool)(n !.Value.GetAncestor(1) == node.GetAncestor(1)) && (bool)(n.Value < node))
.OrderByDescending(n => n).FirstOrDefault() ?? SqlHierarchyId.Null);
}
public void Execute(ExecutingProcess executingProcess)
{
NewsletterEntity newsletter = (NewsletterEntity)executingProcess.Data !;
var queryName = QueryLogic.ToQueryName(newsletter.Query !.Key);
QueryDescription qd = QueryLogic.Queries.QueryDescription(queryName);
List <QueryToken> list = new List <QueryToken>();
using (ExecutionMode.Global())
{
list.Add(QueryUtils.Parse("Entity", qd, 0));
list.Add(QueryUtils.Parse(".".Combine("Entity", "NewsletterDeliveries", "Element"), qd, SubTokensOptions.CanElement));
list.Add(QueryUtils.Parse(".".Combine("Entity", "EmailOwnerData"), qd, 0));
TextTemplateParser.Parse(newsletter.Subject, qd, null).FillQueryTokens(list);
TextTemplateParser.Parse(newsletter.Text, qd, null).FillQueryTokens(list);
list = list.Distinct().ToList();
}
var columns = list.Select(qt => new Column(qt, null)).ToList();
//var columns = new List<QueryToken>();
//columns.Add(QueryUtils.Parse("Entity.NewsletterDeliveries.Element", qd, canAggregate: false));
//columns.Add(QueryUtils.Parse("Entity.Email", qd, canAggregate: false));
//columns.AddRange(NewsletterLogic.GetTokens(queryName, newsletter.Subject));
//columns.AddRange(NewsletterLogic.GetTokens(queryName, newsletter.Text));
columns = columns.Distinct().ToList();
var resultTable = QueryLogic.Queries.ExecuteQuery(new QueryRequest
{
QueryName = queryName,
Filters = new List <Filter>
{
new FilterCondition(QueryUtils.Parse("Entity.NewsletterDeliveries.Element.Newsletter", qd, SubTokensOptions.CanElement), FilterOperation.EqualTo, newsletter.ToLite()),
new FilterCondition(QueryUtils.Parse("Entity.NewsletterDeliveries.Element.Sent", qd, SubTokensOptions.CanElement), FilterOperation.EqualTo, false),
},
Orders = new List <Order>(),
Columns = columns,
Pagination = new Pagination.All(),
});
var dicTokenColumn = resultTable.Columns.ToDictionary(rc => rc.Column.Token);
var entityColumn = resultTable.Columns.SingleEx(c => c.Column.Token.FullKey() == "Entity");
var deliveryColumn = resultTable.Columns.SingleEx(c => c.Column.Token.FullKey() == "Entity.NewsletterDeliveries.Element");
var emailOwnerColumn = resultTable.Columns.SingleEx(c => c.Column.Token.FullKey() == "Entity.EmailOwnerData");
var lines = resultTable.Rows.GroupBy(r => (Lite <Entity>)r[entityColumn] !).Select(g => new SendLine
{
NewsletterDelivery = (Lite <NewsletterDeliveryEntity>)g.DistinctSingle(deliveryColumn) !,
Email = (EmailOwnerData)g.DistinctSingle(emailOwnerColumn) !,
Rows = g,
}).ToList();
public static T GlobalContext <T>(Func <T> customFunc)
{
using (var tr = Transaction.ForceNew())
using (ExecutionMode.Global())
using (new EntityCache(EntityCacheType.ForceNew))
{
return(tr.Commit(customFunc()));
}
}
public void Execute()
{
var user = ExecutionMode.Global().Using(_ => CurrentProcess.User.RetrieveAndRemember());
using (UserHolder.UserSession(user))
{
using (ProcessLogic.OnApplySession(CurrentProcess))
{
if (UserEntity.Current == null)
{
UserEntity.Current = AuthLogic.SystemUser !;
}
try
{
Algorithm.Execute(this);
CurrentProcess.ExecutionEnd = TimeZoneManager.Now;
CurrentProcess.State = ProcessState.Finished;
CurrentProcess.Progress = null;
CurrentProcess.User.ClearEntity();
using (OperationLogic.AllowSave <ProcessEntity>())
CurrentProcess.Save();
}
catch (OperationCanceledException e)
{
if (!e.CancellationToken.Equals(this.CancellationToken))
{
throw;
}
CurrentProcess.SuspendDate = TimeZoneManager.Now;
CurrentProcess.State = ProcessState.Suspended;
using (OperationLogic.AllowSave <ProcessEntity>())
CurrentProcess.Save();
}
catch (Exception e)
{
if (Transaction.InTestTransaction)
{
throw;
}
CurrentProcess.State = ProcessState.Error;
CurrentProcess.ExceptionDate = TimeZoneManager.Now;
CurrentProcess.Exception = e.LogException(el => el.ActionName = CurrentProcess.Algorithm.ToString()).ToLite();
using (OperationLogic.AllowSave <ProcessEntity>())
CurrentProcess.Save();
}
finally
{
ProcessRunnerLogic.OnFinally?.Invoke(this);
}
}
}
}
public SqlPreCommand?SynchronizationScript(bool interactive = true, bool schemaOnly = false, string?replaceDatabaseName = null)
{
OnBeforeDatabaseAccess();
if (Synchronizing == null)
{
return(null);
}
using (CultureInfoUtils.ChangeBothCultures(ForceCultureInfo))
using (ExecutionMode.Global())
{
Replacements replacements = new Replacements()
{
Interactive = interactive,
ReplaceDatabaseName = replaceDatabaseName,
SchemaOnly = schemaOnly
};
SqlPreCommand?command = Synchronizing
.GetInvocationListTyped()
.Select(e =>
{
try
{
SafeConsole.WriteColor(ConsoleColor.White, e.Method.DeclaringType !.TypeName());
Console.Write(".");
SafeConsole.WriteColor(ConsoleColor.DarkGray, e.Method.MethodName());
Console.Write("...");
var result = e(replacements);
if (result == null)
{
SafeConsole.WriteLineColor(ConsoleColor.Green, "OK");
}
else
{
SafeConsole.WriteLineColor(ConsoleColor.Yellow, "Changes");
}
return(result);
}
catch (Exception ex)
{
SafeConsole.WriteColor(ConsoleColor.Red, "Error");
SafeConsole.WriteLineColor(ConsoleColor.DarkRed, " (...it's probably ok, execute this script and try again)");
return(new SqlPreCommandSimple("-- Exception on {0}.{1}\r\n{2}".FormatWith(e.Method.DeclaringType !.Name, e.Method.Name, ex.Message.Indent(2, '-'))));
}
})
.Combine(Spacing.Triple);
return(command);
}
}
protected internal virtual PartialViewResult Search(ControllerBase controller, QueryRequest request, bool allowSelection, bool navigate, bool showFooter, Context context)
{
if (!Finder.IsFindable(request.QueryName))
{
throw new UnauthorizedAccessException(NormalControlMessage.ViewForType0IsNotAllowed.NiceToString().FormatWith(request.QueryName));
}
QuerySettings settings = QuerySettings[request.QueryName];
QueryDescription qd = DynamicQueryManager.Current.QueryDescription(request.QueryName);
if (settings.HiddenColumns != null)
{
if (settings.HiddenColumns.Any(a => a.Token == null))
{
using (ExecutionMode.Global())
ColumnOption.SetColumnTokens(settings.HiddenColumns, qd, canAggregate: false);
}
request.Columns.AddRange(settings.HiddenColumns.Select(c => c.ToColumn(qd, isVisible: false)));
}
ResultTable queryResult = DynamicQueryManager.Current.ExecuteQuery(request);
controller.ViewData.Model = context;
controller.ViewData[ViewDataKeys.AllowSelection] = allowSelection;
controller.ViewData[ViewDataKeys.Navigate] = navigate;
controller.ViewData[ViewDataKeys.ShowFooter] = showFooter;
controller.ViewData[ViewDataKeys.QueryDescription] = qd;
Type entitiesType = Lite.Extract(qd.Columns.SingleEx(a => a.IsEntity).Type);
string message = CollectionElementToken.MultipliedMessage(request.Multiplications, entitiesType);
if (message.HasText())
{
controller.ViewData[ViewDataKeys.MultipliedMessage] = message;
}
controller.ViewData[ViewDataKeys.Results] = queryResult;
controller.ViewData[ViewDataKeys.QueryRequest] = request;
controller.ViewData[ViewDataKeys.Formatters] = queryResult.Columns.Select((c, i) => new { c, i }).ToDictionary(c => c.i, c => settings.GetFormatter(c.c.Column));
controller.ViewData[ViewDataKeys.EntityFormatter] = settings.EntityFormatter;
controller.ViewData[ViewDataKeys.RowAttributes] = settings.RowAttributes;
return(new PartialViewResult
{
ViewName = SearchResultsView,
ViewData = controller.ViewData,
TempData = controller.TempData
});
}
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));
}
}
public static void SaveLog(this OperationLogEntity log)
{
if (!LogOperation(log))
{
return;
}
using (ExecutionMode.Global())
log.Save();
}
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);
}
}
void ExecuteQuery()
{
using (ExecutionMode.Global())
{
List <QueryToken> tokens = new List <QueryToken>();
if (template.From != null && template.From.Token != null)
{
tokens.Add(template.From.Token.Token);
}
foreach (var tr in template.Recipients.Where(r => r.Token != null))
{
tokens.Add(tr.Token.Token);
}
foreach (var t in template.Messages)
{
TextNode(t).FillQueryTokens(tokens);
SubjectNode(t).FillQueryTokens(tokens);
}
foreach (var a in template.Attachments)
{
EmailTemplateLogic.FillAttachmentTokens.Invoke(a, new EmailTemplateLogic.FillAttachmentTokenContext
{
QueryDescription = qd,
ModelType = template.SystemEmail.ToType(),
QueryTokens = tokens,
});
}
var columns = tokens.Distinct().Select(qt => new Column(qt, null)).ToList();
var filters = systemEmail != null?systemEmail.GetFilters(qd) :
new List <Filter>
{
new Filter(QueryUtils.Parse("Entity", qd, 0), FilterOperation.EqualTo, entity.ToLite())
};
this.table = DynamicQueryManager.Current.ExecuteQuery(new QueryRequest
{
QueryName = queryName,
Columns = columns,
Pagination = systemEmail?.GetPagination() ?? new Pagination.All(),
Filters = filters,
Orders = systemEmail?.GetOrders(qd) ?? new List <Order>(),
});
this.dicTokenColumn = table.Columns.ToDictionary(rc => rc.Column.Token);
this.currentRows = table.Rows;
}
}
public static Dictionary <Type, TypeHelp> CachedEntityHelp()
{
return(Types.Value.GetOrAdd(GetCulture(), ci => GlobalContext(() =>
{
using (ExecutionMode.Global())
{
var dic = Database.Query <TypeHelpEntity>().Where(n => n.Culture == ci.ToCultureInfoEntity()).ToDictionary(a => a.Type.ToType());
return AllTypes().ToDictionary(t => t, t => new TypeHelp(t, ci, dic.TryGetC(t)));
}
})));
}
