void ChartRenderer_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e) { if (!(DataContext is ChartRequest)) return; Settings = Finder.GetQuerySettings(Request.QueryName); Description = DynamicQueryServer.GetQueryDescription(Request.QueryName); }
public WordTemplateRenderer(WordprocessingDocument document, QueryDescription queryDescription, Entity entity, CultureInfo culture, ISystemWordTemplate systemWordTemplate) { this.document = document; this.entity = entity; this.culture = culture; this.systemWordTemplate = systemWordTemplate; this.queryDescription = queryDescription; }
public TemplateWalker(string text, QueryDescription qd, Type modelType) { if (qd == null) throw new ArgumentNullException("qd"); this.text = text ?? ""; this.qd = qd; this.modelType = modelType; }
public static QueryTokenBuilderSettings GetQueryTokenBuilderSettings(QueryDescription qd, SubTokensOptions options) { return new QueryTokenBuilderSettings(qd, options) { ControllerUrl = RouteHelper.New().Action("NewSubTokensCombo", "Word"), Decorators = TemplatingClient.TemplatingDecorators, RequestExtraJSonData = null, }; }
public EmailMessageBuilder(EmailTemplateEntity template, IEntity 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); }
void UserQuery_Loaded(object sender, RoutedEventArgs e) { if (QueryDescription == null) { UserQueryEntity uq = (UserQueryEntity)DataContext; QueryDescription = DynamicQueryServer.GetQueryDescription(QueryClient.GetQueryName(uq.Query.Key)); } tbCurrentEntity.Text = UserQueryMessage.Use0ToFilterCurrentEntity.NiceToString().FormatWith(CurrentEntityConverter.CurrentEntityKey); }
public static List<Signum.Entities.DynamicQuery.Filter> ExtractFilterOptions(HttpContextBase httpContext, QueryDescription queryDescription, bool canAggregate) { List<Signum.Entities.DynamicQuery.Filter> result = new List<Signum.Entities.DynamicQuery.Filter>(); NameValueCollection parameters = httpContext.Request.Params; string field = parameters["filters"]; if (!field.HasText()) return result; var matches = FindOptionsModelBinder.FilterRegex.Matches(field).Cast<Match>(); return matches.Select(m => { string name = m.Groups["token"].Value; var token = QueryUtils.Parse(name, queryDescription, SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)); return new Signum.Entities.DynamicQuery.Filter(token, EnumExtensions.ToEnum<FilterOperation>(m.Groups["op"].Value), FindOptionsModelBinder.Convert(FindOptionsModelBinder.DecodeValue(m.Groups["value"].Value), token.Type)); }).ToList(); }
public void ParseData(Entity context, QueryDescription description, SubTokensOptions options) { if (token != null) token.ParseData(context, description, options & ~SubTokensOptions.CanAnyAll); }
internal void ParseData(QueryDescription queryDescription) { if (Recipients != null) foreach (var r in Recipients.Where(r => r.Token != null)) r.Token.ParseData(this, queryDescription, SubTokensOptions.CanElement); if (From != null && From.Token != null) From.Token.ParseData(this, queryDescription, SubTokensOptions.CanElement); }
public static QueryToken SubToken(QueryToken token, QueryDescription qd, SubTokensOptions options, string key) { var result = SubTokenBasic(token, qd, options, key); if (result != null) return result; if ((options & SubTokensOptions.CanAggregate) != 0) return AggregateTokens(token, qd).SingleOrDefaultEx(a => a.Key == key); return null; }
public static QueryToken Parse(string tokenString, QueryDescription qd, bool canAggregate) { if (string.IsNullOrEmpty(tokenString)) throw new ArgumentNullException("tokenString"); string[] parts = tokenString.Split('.'); string firstPart = parts.FirstEx(); QueryToken result = SubToken(null, qd, canAggregate, firstPart); if (result == null) throw new FormatException("Column {0} not found on query {1}".Formato(firstPart, QueryUtils.GetCleanName(qd.QueryName))); foreach (var part in parts.Skip(1)) { var newResult = SubToken(result, qd, canAggregate, part); if (newResult == null) throw new FormatException("Token with key '{0}' not found on {1} of query {2}".Formato(part, result.FullKey(), QueryUtils.GetCleanName(qd.QueryName))); result = newResult; } return result; }
public Column ToColumn(QueryDescription qd, bool isVisible = true) { return new Column(Token, DisplayName.DefaultText(Token.NiceName())) { IsVisible = isVisible }; }
internal void ParseData(QueryDescription description) { if (Filters != null) foreach (var f in Filters) f.ParseData(this, description, SubTokensOptions.CanElement | SubTokensOptions.CanAnyAll | (this.GroupResults ? SubTokensOptions.CanAggregate : 0)); if (Columns != null) foreach (var c in Columns) c.ParseData(this, description, SubTokensOptions.CanElement | (c.IsGroupKey == false ? SubTokensOptions.CanAggregate : 0)); if (Orders != null) foreach (var o in Orders) o.ParseData(this, description, SubTokensOptions.CanElement | (this.GroupResults ? SubTokensOptions.CanAggregate : 0)); }
public static QueryToken SubToken(QueryToken token, QueryDescription qd, bool canAggregate, string key) { var result = SubTokenBasic(token, qd, key); if (result != null) return result; if (canAggregate) return AggregateTokens(token, qd).SingleOrDefaultEx(a => a.Key == key); return null; }
void SearchControl_Loaded(object sender, RoutedEventArgs e) { this.Loaded -= SearchControl_Loaded; if (DesignerProperties.GetIsInDesignMode(this) || QueryName == null) return; if (qd == null) qd = DynamicQueryServer.GetQueryDescription(QueryName); if (FilterColumn.HasText()) { FilterOptions.Add(new FilterOption { Path = FilterColumn, Operation = FilterOperation.EqualTo, Frozen = true, }.Bind(FilterOption.ValueProperty, new Binding("DataContext" + (FilterRoute.HasText() ? "." + FilterRoute : null)) { Source = this })); ColumnOptions.Add(new ColumnOption(FilterColumn)); ColumnOptionsMode = ColumnOptionsMode.Remove; } DynamicQueryServer.SetFilterTokens(FilterOptions, qd); AutomationProperties.SetName(this, QueryUtils.GetQueryUniqueKey(QueryName)); Search(); foreach (var item in FilterOptions) { item.BindingValueChanged += new DependencyPropertyChangedEventHandler(item_BindingValueChanged); } }
public static void SetColumnTokens(IEnumerable<ColumnOption> columns, QueryDescription qd, bool canAggregate = false) { var options = SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0); foreach (var c in columns) { c.Token = QueryUtils.Parse(c.ColumnName, qd, options); } }
public static List<Column> MergeColumns(IEnumerable<ColumnOption> columns, ColumnOptionsMode mode, QueryDescription qd) { switch (mode) { case ColumnOptionsMode.Add: return qd.Columns.Where(cd => !cd.IsEntity).Select(cd => new Column(cd, qd.QueryName)).Concat( columns.Select(co => co.ToColumn())).ToList(); case ColumnOptionsMode.Remove: return qd.Columns.Where(cd => !cd.IsEntity && !columns.Any(co => co.ColumnName == cd.Name)).Select(cd => new Column(cd, qd.QueryName)).ToList(); case ColumnOptionsMode.Replace: return columns.Select(co => co.ToColumn()).ToList(); default: throw new InvalidOperationException("{0} is not a valid ColumnOptionMode".FormatWith(mode)); } }
public static void SetOrderTokens(IEnumerable<OrderOption> orders, QueryDescription qd, bool canAggregate = false) { var options = SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0); foreach (var o in orders) { o.Token = QueryUtils.Parse(o.ColumnName, qd, options); } }
public static void SetFilterTokens(IEnumerable<FilterOption> filters, QueryDescription qd, bool canAggregate = false) { var options = SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0); foreach (var f in filters) { if (f.Token == null && f.ColumnName.HasText()) f.Token = QueryUtils.Parse(f.ColumnName, qd, options); f.RefreshRealValue(); } }
public static List<QueryToken> SubTokens(this QueryToken token, QueryDescription qd, SubTokensOptions options) { var result = SubTokensBasic(token, qd, options); if ((options & SubTokensOptions.CanAggregate) != 0) result.InsertRange(0, AggregateTokens(token, qd)); return result; }
public static void SetFilterTokens(List<FilterOption> filters, QueryDescription queryDescription, bool canAggregate) { foreach (var f in filters.Where(f => f.ColumnName.HasText() && f.Token == null)) f.Token = QueryUtils.Parse(f.ColumnName, queryDescription, SubTokensOptions.CanAnyAll | SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)); }
public static List<OrderOption> ExtractOrderOptions(HttpContextBase httpContext, QueryDescription qd, bool canAggregate = false) { List<OrderOption> result = new List<OrderOption>(); NameValueCollection parameters = httpContext.Request.Params; string field = parameters["orders"]; if (!field.HasText()) return result; var matches = OrderRegex.Matches(field).Cast<Match>(); return matches.Select(m => { var tokenCapture = m.Groups["token"].Value; OrderType orderType = tokenCapture.StartsWith("-") ? OrderType.Descending : OrderType.Ascending; string token = orderType == OrderType.Ascending ? tokenCapture : tokenCapture.Substring(1, tokenCapture.Length - 1); return new OrderOption { ColumnName = token, Token = QueryUtils.Parse(token, qd, SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)), OrderType = orderType }; }).ToList(); }
public static void SetOrderTokens(List<OrderOption> orders, QueryDescription queryDescription, bool canAggregate) { foreach (var o in orders.Where(o => o.ColumnName.HasText() && o.Token == null)) o.Token = QueryUtils.Parse(o.ColumnName, queryDescription, SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)); }
static QueryToken SubTokenBasic(QueryToken token, QueryDescription qd, string key) { if (token == null) { var column = qd.Columns.SingleOrDefaultEx(a=>a.Name == key); if (column == null) return null; return new ColumnToken(column, qd.QueryName); } else { return token.SubTokenInternal(key); } }
public static void SetColumnTokens(List<ColumnOption> columns, QueryDescription queryDescription, bool canAggregate) { foreach (var o in columns.Where(c => c.ColumnName.HasText() && c.Token == null)) o.Token = QueryUtils.Parse(o.ColumnName, queryDescription, SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)); }
static List<QueryToken> SubTokensBasic(QueryToken token, QueryDescription qd) { if (token == null) { if (MergeEntityColumns != null && !MergeEntityColumns()) return qd.Columns.Select(cd => (QueryToken)new ColumnToken(cd, qd.QueryName)).ToList(); var dictonary = qd.Columns.Where(a => !a.IsEntity).Select(cd => (QueryToken)new ColumnToken(cd, qd.QueryName)).ToDictionary(t => t.Key); var entity = new ColumnToken(qd.Columns.SingleEx(a => a.IsEntity), qd.QueryName); dictonary.Add(entity.Key, entity); foreach (var item in entity.SubTokensInternal().OrderBy(a => a.ToString())) { if (!dictonary.ContainsKey(item.Key)) { dictonary.Add(item.Key, item); } } return dictonary.Values.ToList(); } else return token.SubTokensInternal(); }
public static List<QueryToken> SubTokens(this QueryToken token, QueryDescription qd, bool canAggregate) { var result = SubTokensBasic(token, qd); if (canAggregate) result.AddRange(AggregateTokens(token, qd)); return result; }
public static List<ColumnOption> ExtractColumnsOptions(HttpContextBase httpContext, QueryDescription qd, bool canAggregate = false) { List<ColumnOption> result = new List<ColumnOption>(); NameValueCollection parameters = httpContext.Request.Params; string field = parameters["columns"]; if (!field.HasText()) return result; var matches = ColumnRegex.Matches(field).Cast<Match>(); return matches.Select(m => { var colName = m.Groups["token"].Value; var token = QueryUtils.Parse(colName, qd, SubTokensOptions.CanElement | (canAggregate ? SubTokensOptions.CanAggregate : 0)); return new ColumnOption { Token = token, ColumnName = colName, DisplayName =m.Groups["name"].Success ? DecodeValue(m.Groups["name"].Value) : null }; }).ToList(); }
public void Reinitialize(IEnumerable<FilterOption> filters, List<ColumnOption> columns, ColumnOptionsMode columnOptionsMode, List<OrderOption> orders) { if (qd == null) qd = DynamicQueryServer.GetQueryDescription(QueryName); ColumnOptions.Clear(); ColumnOptions.AddRange(columns); ColumnOptionsMode = columnOptionsMode; FilterOptions.Clear(); FilterOptions.AddRange(filters); DynamicQueryServer.SetFilterTokens(FilterOptions, qd); OrderOptions.Clear(); OrderOptions.AddRange(orders); DynamicQueryServer.SetOrderTokens(OrderOptions, qd); }
private static IEnumerable<QueryToken> AggregateTokens(QueryToken token, QueryDescription qd) { if (token == null) { yield return new AggregateToken(AggregateFunction.Count, qd.QueryName); } else if (!(token is AggregateToken)) { FilterType? ft = QueryUtils.TryGetFilterType(token.Type); if (ft == FilterType.Integer || ft == FilterType.Decimal || ft == FilterType.Boolean) { yield return new AggregateToken(AggregateFunction.Average, token); yield return new AggregateToken(AggregateFunction.Sum, token); yield return new AggregateToken(AggregateFunction.Min, token); yield return new AggregateToken(AggregateFunction.Max, token); } else if (ft == FilterType.DateTime) /*ft == FilterType.String || */ { yield return new AggregateToken(AggregateFunction.Min, token); yield return new AggregateToken(AggregateFunction.Max, token); } } }