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