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) { }