public HomeController()
{
getLogic = new GetLogic();
addLogic = new Busines.AddLogic();
queryLogic = new QueryLogic();
deleteLogic = new DeleteLogic();
}
static void UserQueryLogic_Retrieved(UserQueryEntity userQuery)
{
object queryName = QueryLogic.ToQueryName(userQuery.Query.Key);
QueryDescription description = DynamicQueryManager.Current.QueryDescription(queryName);
userQuery.ParseData(description);
}
static void PredictorEntity_Retrieved(PredictorEntity predictor)
{
object queryName = QueryLogic.ToQueryName(predictor.Query.Key);
QueryDescription description = DynamicQueryManager.Current.QueryDescription(queryName);
predictor.ParseData(description);
}
static void PredictorMultiColumnEntity_Retrieved(PredictorMultiColumnEntity mc)
{
object queryName = QueryLogic.ToQueryName(mc.Query.Key);
QueryDescription description = DynamicQueryManager.Current.QueryDescription(queryName);
mc.ParseData(description);
}
public static void Start(HttpConfiguration config)
{
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(TemplateTokenMessage));
EntityJsonConverter.AfterDeserilization.Register((EmailTemplateEntity et) =>
{
if (et.Query != null)
{
var qd = DynamicQueryManager.Current.QueryDescription(et.Query.ToQueryName());
et.ParseData(qd);
}
});
QueryDescriptionTS.AddExtension += qd =>
{
object type = QueryLogic.ToQueryName(qd.queryKey);
var templates = EmailTemplateLogic.GetApplicableEmailTemplates(type, null, EmailTemplateVisibleOn.Query);
if (templates.HasItems())
{
qd.Extension.Add("emailTemplates", templates);
}
};
}
public static void Start(IApplicationBuilder app)
{
TypeHelpServer.Start(app);
SignumControllerFactory.RegisterArea(MethodInfo.GetCurrentMethod());
ReflectionServer.RegisterLike(typeof(TemplateTokenMessage));
EntityJsonConverter.AfterDeserilization.Register((EmailTemplateEntity et) =>
{
if (et.Query != null)
{
var qd = QueryLogic.Queries.QueryDescription(et.Query.ToQueryName());
et.ParseData(qd);
}
});
QueryDescriptionTS.AddExtension += qd =>
{
object type = QueryLogic.ToQueryName(qd.queryKey);
if (Schema.Current.IsAllowed(typeof(EmailTemplateEntity), true) == null)
{
var templates = EmailTemplateLogic.GetApplicableEmailTemplates(type, null, EmailTemplateVisibleOn.Query);
if (templates.HasItems())
{
qd.Extension.Add("emailTemplates", templates);
}
}
};
}
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 async Task <ResultTable> FindRowsLike([Required, FromBody] AutocompleteQueryRequestTS request, CancellationToken token)
{
var qn = QueryLogic.ToQueryName(request.queryKey);
var qd = QueryLogic.Queries.QueryDescription(qn);
var dqRequest = new DQueryableRequest
{
QueryName = qn,
Columns = request.columns.EmptyIfNull().Select(a => a.ToColumn(qd, false)).ToList(),
Filters = request.filters.EmptyIfNull().Select(a => a.ToFilter(qd, false)).ToList(),
Orders = request.orders.EmptyIfNull().Select(a => a.ToOrder(qd, false)).ToList()
};
var dqueryable = QueryLogic.Queries.GetDQueryable(dqRequest);
var entityType = qd.Columns.Single(a => a.IsEntity).Implementations !.Value.Types.SingleEx();
var result = await dqueryable.Query.AutocompleteUntypedAsync(dqueryable.Context.GetEntitySelector(), request.subString, request.count, entityType, token);
var columnAccessors = dqRequest.Columns.Select(c => (
column: c,
lambda: Expression.Lambda(c.Token.BuildExpression(dqueryable.Context), dqueryable.Context.Parameter)
)).ToList();
return(DQueryable.ToResultTable(result.ToArray(), columnAccessors, null, new Pagination.Firsts(request.count)));
}
public QueryNode(string fieldName, IFieldValue fieldValue, QueryLogic logic, QueryType type)
{
this.FieldName = fieldName;
this.FieldValue = fieldValue;
this.Logic = logic;
this.Type = type;
}
public UserQueryEntity FromQueryRequest(CreateRequest request)
{
var qr = request.queryRequest.ToQueryRequest();
var qd = DynamicQueryManager.Current.QueryDescription(qr.QueryName);
return(qr.ToUserQuery(qd, QueryLogic.GetQueryEntity(qd.QueryName), request.defaultPagination.ToPagination(), withoutFilters: false));
}
public SearchFilter(List <CriminalEventType> inCriminalEventTypes,
List <string> inKeyWordsSearchAddress,
List <string> inKeyWordsSearchFamily,
DaysFilter inDays,
TimeFilter inTime,
DateFilter inDate,
QueryLogic logic)
{
Days = inDays;
Time = inTime;
Date = inDate;
DaysFilterOn = (inDays == null) ? false : true;
TimeFilterOn = (inTime == null) ? false : true;
DateFilterOn = (inDate == null) ? false : true;
KeyWordsSearchAddress = inKeyWordsSearchAddress;
KeyWordsSearchAddressOn = (KeyWordsSearchAddress != null);
KeyWordsSearchFamily = inKeyWordsSearchFamily;
KeyWordsSearchFamilyOn = (KeyWordsSearchFamily != null);
CriminalEventTypes = inCriminalEventTypes;
CriminalEventTypesSearchOn = (CriminalEventTypes != null);
Logic = logic;
}
public static UserQueryEntity ToUserQuery(QueryRequest request)
{
return(request.ToUserQuery(
DynamicQueryManager.Current.QueryDescription(request.QueryName),
QueryLogic.GetQueryEntity(request.QueryName),
FindOptions.DefaultPagination,
withoutFilters: false /*Implement Simple Filter Builder*/));
}
public List <Lite <EmailTemplateEntity> > GetWordTemplates(string queryKey, EmailTemplateVisibleOn visibleOn, Lite <Entity> lite)
{
object queryName = QueryLogic.ToQueryName(queryKey);
var entity = lite?.RetrieveAndForget();
return(EmailTemplateLogic.GetApplicableEmailTemplates(queryName, entity, visibleOn));
}
public List <Lite <EmailTemplateEntity> > GetEmailTemplates(string queryKey, EmailTemplateVisibleOn visibleOn, [Required, FromBody] GetEmailTemplatesRequest request)
{
object queryName = QueryLogic.ToQueryName(queryKey);
var entity = request.lite?.RetrieveAndForget();
return(EmailTemplateLogic.GetApplicableEmailTemplates(queryName, entity, visibleOn));
}
public List<Lite<WordTemplateEntity>> GetWordTemplates(string queryKey, WordTemplateVisibleOn visibleOn, [Required, FromBody]GetWordTemplatesRequest request)
{
object type = QueryLogic.ToQueryName(queryKey);
var entity = request.lite?.RetrieveAndForget();
return WordTemplateLogic.GetApplicableWordTemplates(type, entity, visibleOn);
}
static void Newsletter_PreSaving(NewsletterEntity newsletter, ref bool graphModified)
{
var queryname = QueryLogic.ToQueryName(newsletter.Query.Key);
QueryDescription qd = DynamicQueryManager.Current.QueryDescription(queryname);
newsletter.Subject = EmailTemplateParser.Parse(newsletter.Subject, qd, null).ToString();
newsletter.Text = EmailTemplateParser.Parse(newsletter.Text, qd, null).ToString();
}
public void TestSearchMultipleMailForEachField(QueryLogic logic, FieldQueryParameters field, Operations op)
{
var handler = new DefaultManager();
var request = GenerateSearchMailForEachFieldRequest(logic, field, op, DateListMultipleMail.ElementAt(NumberOfMail / 2), 1);
var response = handler.Send <Dictionary <string, object> >(SearchEndPoint, JsonConvert.SerializeObject(request), HttpMethod.POST);
VerifyDataForEachField(response, field, 1, op, true);
}
public List <QueryTokenTS> ParseTokens(ParseTokensRequest request)
{
var qn = QueryLogic.ToQueryName(request.queryKey);
var qd = DynamicQueryManager.Current.QueryDescription(qn);
var tokens = request.tokens.Select(tr => QueryUtils.Parse(tr.token, qd, tr.options)).ToList();
return(tokens.Select(qt => new QueryTokenTS(qt, recursive: true)).ToList());
}
public List <QueryTokenTS> ParseTokens([Required, FromBody] ParseTokensRequest request)
{
var qn = QueryLogic.ToQueryName(request.queryKey);
var qd = QueryLogic.Queries.QueryDescription(qn);
var tokens = request.tokens.Select(tr => QueryUtils.Parse(tr.token, qd, tr.options)).ToList();
return(tokens.Select(qt => new QueryTokenTS(qt, recursive: true)).ToList());
}
public List <Lite <Entity> > GetEntitiesWithFilter(QueryEntitiesRequestTS request)
{
var qn = QueryLogic.ToQueryName(request.queryKey);
var qd = DynamicQueryManager.Current.QueryDescription(qn);
var filters = request.filters.EmptyIfNull().Select(f => f.ToFilter(qd, canAggregate: false)).ToList();
return(DynamicQueryManager.Current.GetEntities(qn, filters).Take(request.count).ToList());
}
public static FindOptions ToFindOptions(this UserQueryEntity userQuery)
{
object queryName = QueryLogic.ToQueryName(userQuery.Query.Key);
var result = new FindOptions(queryName);
result.ApplyUserQuery(userQuery);
return(result);
}
public static ImportAction Load(XDocument document)
{
XElement element = document.Element(_Query) !;
var ci = CultureInfoLogic.CultureInfoToEntity.Value.GetOrThrow(element.Attribute(_Culture) !.Value);
var queryName = SelectInteractive(element.Attribute(_Key) !.Value, QueryLogic.QueryNames, "queries");
if (queryName == null)
{
return(ImportAction.Skipped);
}
var query = QueryLogic.GetQueryEntity(queryName);
var entity = Database.Query <QueryHelpEntity>().SingleOrDefaultEx(a => a.Culture.Is(ci) && a.Query.Is(query)) ??
new QueryHelpEntity
{
Culture = ci,
Query = query,
};
entity.Description = element.Element(_Description)?.Value;
var cols = element.Element(_Columns);
if (cols != null)
{
var queryColumns = QueryLogic.Queries.GetQuery(queryName).Core.Value.StaticColumns.Select(a => a.Name).ToDictionary(a => a);
foreach (var item in cols.Elements(_Column))
{
string?name = item.Attribute(_Name) !.Value;
name = SelectInteractive(name, queryColumns, "columns of {0}".FormatWith(queryName));
if (name == null)
{
continue;
}
var col = entity.Columns.SingleOrDefaultEx(c => c.ColumnName == name);
if (col != null)
{
col.Description = item.Value;
}
else
{
entity.Columns.Add(new QueryColumnHelpEmbedded
{
ColumnName = name,
Description = item.Value
});
}
}
}
return(Save(entity));
}
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);
}
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));
}
}
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 List <Lite <Entity> > FindLiteLikeWithFilters(AutocompleteQueryRequestTS request)
{
var qn = QueryLogic.ToQueryName(request.queryKey);
var qd = DynamicQueryManager.Current.QueryDescription(qn);
var filters = request.filters.Select(a => a.ToFilter(qd, false)).ToList();
var entitiesQuery = DynamicQueryManager.Current.GetEntities(qn, filters);
var entityType = qd.Columns.Single(a => a.IsEntity).Implementations.Value.Types.SingleEx();
return(entitiesQuery.AutocompleteUntyped(request.subString, request.count, entityType));
}
QueryEntity?IFromXmlContext.TryGetQuery(string queryKey)
{
var qn = QueryLogic.TryToQueryName(queryKey);
if (qn == null)
{
return(null);
}
return(QueryLogic.GetQueryEntity(qn));
}
public static void ImportWordReportTemplateForOrder()
{
new WordTemplateEntity
{
Name = "Order template",
Query = QueryLogic.GetQueryEntity(typeof(OrderEntity)),
Culture = CultureInfo.GetCultureInfo("en").ToCultureInfoEntity(),
Template = new FileEntity("../../WordTemplates/Order.docx").ToLiteFat(),
FileName = "Order.docx"
}.Save();
}
public List <QueryTokenTS> SubTokens([Required, FromBody] SubTokensRequest request)
{
var qn = QueryLogic.ToQueryName(request.queryKey);
var qd = QueryLogic.Queries.QueryDescription(qn);
var token = request.token == null ? null: QueryUtils.Parse(request.token, qd, request.options);
var tokens = QueryUtils.SubTokens(token, qd, request.options);
return(tokens.Select(qt => new QueryTokenTS(qt, recursive: false)).ToList());
}
public List <QueryTokenTS> SubTokens(SubTokensRequest request)
{
var qn = QueryLogic.ToQueryName(request.queryKey);
var qd = DynamicQueryManager.Current.QueryDescription(qn);
var token = request.token == null ? null: QueryUtils.Parse(request.token, qd, request.options);
var tokens = QueryUtils.SubTokens(token, qd, request.options);
return(tokens.Select(qt => new QueryTokenTS(qt, recursive: false)).ToList());
}
private Lucene.Net.Search.BooleanQuery QueryOperator(QueryLogic logic, Lucene.Net.Search.Query curQuery, Lucene.Net.Search.BooleanQuery targetQuery)
{
switch (logic)
{
case QueryLogic.MUST:
targetQuery = targetQuery.Must(curQuery);
break;
case QueryLogic.SHOULD:
targetQuery = targetQuery.Should(curQuery);
break;
case QueryLogic.MUST_NOT:
targetQuery = targetQuery.MustNot(curQuery);
break;
default:
break;
}
return targetQuery;
}
/// <summary>
/// create an operation node
/// </summary>
/// <param name="logic"></param>
/// <param name="relateNodes"></param>
/// <returns></returns>
public static QueryNode CreateOperNode(QueryLogic logic, QueryNode[] relateNodes)
{
return new QueryNode(logic, relateNodes);
}
/// <summary>
/// craete an query node
/// </summary>
/// <param name="fieldName"></param>
/// <param name="fieldValue"></param>
/// <param name="logic"></param>
/// <returns></returns>
public static QueryNode CreateQueryNode(string fieldName, IFieldValue fieldValue, QueryLogic logic)
{
return new QueryNode(fieldName, fieldValue, logic);
}
public OperationNode(QueryLogic logic, INode[] relateionQueries)
{
this.RelationQuerys = relateionQueries;
this.Logic = logic;
}
/// <summary>
/// initiaize an operation node
/// </summary>
/// <param name="logic"></param>
/// <param name="relationNodes"></param>
public QueryNode(QueryLogic logic, QueryNode[] relationNodes)
: this(string.Empty, null, logic, QueryType.Operation)
{
this.RelationQuerys = relationNodes;
}
/// <summary>
/// initialize an query node
/// </summary>
/// <param name="fieldName"></param>
/// <param name="fieldValue"></param>
/// <param name="logic"></param>
/// <param name="type"></param>
public QueryNode(string fieldName, IFieldValue fieldValue, QueryLogic logic)
: this(fieldName, fieldValue, logic, QueryType.QueryField)
{
}
