public async Task WriteJsonAsync(JsonTextWriter writer, object entity, IExpressionTree fields)
{
var content = entity as Metadata;
await writer.WriteStartObjectAsync();
{
await writer.WritePropertyNameAsync(GetKey(nameof(Metadata.Header)), true);
await writer.WriteStartObjectAsync();
{
await writer.WritePropertyNameAsync(GetKey(nameof(MetadataHeader.Generated)), true);
await writer.WriteValueAsync(DateTime.SpecifyKind(content.Header.Generated, DateTimeKind.Unspecified));
await writer.WritePropertyNameAsync(GetKey(nameof(MetadataHeader.Principal)), true);
await writer.WriteValueAsync(content.Header.Principal);
}
await writer.WriteEndObjectAsync();
await writer.WritePropertyNameAsync(GetKey(nameof(Metadata.Data)), true);
await SerializerProvider.ResolveSerializer(content.Data).WriteJsonAsync(writer, content.Data, fields);
}
await writer.WriteEndObjectAsync();
}
protected async Task WriteJsonAsync(JsonTextWriter writer, IDictionary dico, IExpressionTree fields)
{
await writer.WriteStartObjectAsync();
if (fields.Children.Count != 0)
{
foreach (var child in fields.Children)
{
var concreteChild = child.Node as ItemExpression;
await WriteKvpAsync(writer, NamingStrategy.GetDictionaryKey(concreteChild.Name), dico[concreteChild.Name], child);
}
}
else
{
// Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations.
var enumerator = dico.GetEnumerator();
while (enumerator.MoveNext())
{
var entry = enumerator.Entry;
await WriteKvpAsync(writer, NamingStrategy.GetDictionaryKey(entry.Key.ToString()), entry.Value, fields);
}
}
await writer.WriteEndObjectAsync();
}
/// <summary>
/// Getters the specified property expression.
/// </summary>
/// <param name="propertyExpression">The property expression.</param>
/// <param name="tree">The tree.</param>
/// <param name="parameter1">The parameter1.</param>
/// <param name="parameter2">The parameter2.</param>
/// <returns>
/// Getter.
/// </returns>
private static Func <TResult?> Getter(
Expression <Func <TParameter1, TParameter2, TResult> > propertyExpression,
IExpressionTree tree,
TParameter1 parameter1,
TParameter2 parameter2) =>
() => ExpressionGetter.CreateValueGetter <TParameter1, TParameter2, TResult>(
propertyExpression.Parameters,
tree)(parameter1, parameter2);
public TreeVisitor(IExpressionTree tree, bool visit = true)
{
Tree = tree;
if (visit)
{
VisitTree();
}
}
protected virtual IExpressionTree CorrectFields(object entity, IExpressionTree fields)
{
if (fields == null || fields.Children.Count == 0)
{
return(DefaultFields.GetOrAdd(entity.GetType(), t => new ExpressionParser().ParseTree(t, string.Join(",", t.GetProperties().Select(p => p.Name)))));
}
return(fields);
}
/// <summary>
/// Getters the specified property expression.
/// </summary>
/// <param name="propertyExpression">The property expression.</param>
/// <param name="tree">The tree.</param>
/// <param name="fallback">The fallback.</param>
/// <returns>
/// Getter.
/// </returns>
private static Func <TResult> Getter(
Expression <Func <TResult> > propertyExpression,
IExpressionTree tree,
TResult fallback)
{
var get = ExpressionGetter.CreateGetter(propertyExpression.Parameters, tree, fallback);
return(() => get());
}
public Query(IExpressionTree <TEntity> fields, List <OrderBy <TEntity> > orderBys, Page page, Filter <TEntity> filters, HttpVerbs httpVerbs)
{
Fields = fields;
OrderBys = orderBys;
Page = page;
Filter = filters;
Verb = httpVerbs;
Options = new Options();
}
protected override IExpressionTree CorrectFields(object entity, IExpressionTree fields)
{
if (fields == null || fields.Children.Count == 0)
{
return(DefaultFields.GetOrAdd(entity.GetType(), t => new ExpressionParser().ParseTree(t, "id,name,url")));
}
return(base.CorrectFields(entity, fields));
}
/// <summary>
/// Getters the specified property expression.
/// </summary>
/// <param name="propertyExpression">The property expression.</param>
/// <param name="tree">The tree.</param>
/// <param name="parameter1">The parameter1.</param>
/// <returns>Getter.</returns>
private static Func <TResult?> Getter(
Expression <Func <TParameter1, TResult> > propertyExpression,
IExpressionTree tree,
TParameter1 parameter1)
{
var get = ExpressionGetter.CreateValueGetter <TParameter1, TResult>(propertyExpression.Parameters, tree);
return(() => get(parameter1));
}
protected override object GetRawValue(object entity, IExpressionTree fields, PropertyExpression property)
{
if (property.Name == nameof(IEntityBase.Url))
{
return(UrlProvider?.GetEntityApiUri(entity as IPrimaryKey));
}
return(base.GetRawValue(entity, fields, property));
}
public static Func <TResult?> CreateReferenceGetter <TResult>(
[NotNull] ReadOnlyCollection <ParameterExpression> parameters,
[NotNull] IExpressionTree expressionTree)
where TResult : class
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (expressionTree == null)
{
throw new ArgumentNullException(nameof(expressionTree));
}
var body = ExpressionCreator.CreateValueBody(typeof(TResult), expressionTree);
var lambda = Expression.Lambda <Func <TResult?> >(body, parameters);
return(lambda.Compile());
}
public static Func <TParameter1, TResult> CreateGetter <TParameter1, TResult>(
[NotNull] ReadOnlyCollection <ParameterExpression> parameters,
[NotNull] IExpressionTree expressionTree,
TResult fallback)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (expressionTree == null)
{
throw new ArgumentNullException(nameof(expressionTree));
}
var body = ExpressionCreator.CreateValueBody(typeof(TResult), expressionTree, Fallback(fallback));
var lambda = Expression.Lambda <Func <TParameter1, TResult> >(body, parameters);
return(lambda.Compile());
}
///// <summary>
///// Creates the chain.
///// </summary>
///// <param name="parameter1">The parameter1.</param>
///// <param name="tree">The nodes.</param>
///// <exception cref="NotSupportedException">Expression Tree Node not supported.</exception>
//protected void CreateChain(INotifyPropertyChanged parameter1, IExpressionTree tree)
//{
// foreach (var treeRoot in tree.Roots)
// {
// switch (treeRoot)
// {
// case ParameterNode parameterElement:
// {
// if (!(parameterElement.Next is PropertyNode propertyElement))
// {
// continue;
// }
// var root = new RootPropertyObserverNode(
// propertyElement.PropertyInfo,
// this.OnAction,
// parameter1);
// this.LoopTree(propertyElement, root);
// this.RootNodes.Add(root);
// break;
// }
// case ConstantNode constantElement when treeRoot.Next is FieldNode fieldElement:
// {
// if (!(fieldElement.Next is PropertyNode propertyElement))
// {
// continue;
// }
// var root = new RootPropertyObserverNode(
// propertyElement.PropertyInfo,
// this.OnAction,
// (INotifyPropertyChanged)fieldElement.FieldInfo.GeTResult(constantElement.Value));
// this.LoopTree(propertyElement, root);
// this.RootNodes.Add(root);
// break;
// }
// case ConstantNode constantElement:
// {
// if (!(treeRoot.Next is PropertyNode propertyElement))
// {
// continue;
// }
// var root = new RootPropertyObserverNode(
// propertyElement.PropertyInfo,
// this.OnAction,
// (INotifyPropertyChanged)constantElement.Value);
// this.LoopTree(propertyElement, root);
// this.RootNodes.Add(root);
// break;
// }
// default:
// throw new NotSupportedException();
// }
// }
//}
/// <summary>
/// Creates the chain.
/// </summary>
/// <param name="tree">The nodes.</param>
/// <exception cref="System.NotSupportedException">Expression Tree Node not supported.</exception>
protected void CreateChain(IExpressionTree tree)
{
foreach (var treeRoot in tree.Roots)
{
switch (treeRoot)
{
case IConstantNode constantElement when treeRoot.Next is IFieldNode fieldElement:
{
if (!(fieldElement.Next is IPropertyNode propertyElement))
{
continue;
}
var root = this.CreateParameterObserverChain(
fieldElement.FieldInfo.GetValue(constantElement.Value),
propertyElement);
this.RootNodes.Add(root);
break;
}
case IConstantNode constantElement:
{
if (!(treeRoot.Next is IPropertyNode propertyElement))
{
continue;
}
var root = this.CreateParameterObserverChain(constantElement.Value, propertyElement);
this.RootNodes.Add(root);
break;
}
default:
throw new NotSupportedException($"{treeRoot}");
}
}
}
/// <summary>
/// Creates the chain.
/// </summary>
/// <param name="parameter1">The parameter1.</param>
/// <param name="nodes">The nodes.</param>
/// <exception cref="System.NotSupportedException"></exception>
/// <exception cref="NotSupportedException">Expression Tree Node not supported.</exception>
private void CreateChain(TParameter1 parameter1, IExpressionTree nodes)
{
foreach (var treeRoot in nodes.Roots)
{
switch (treeRoot)
{
case IParameterNode parameterElement:
{
if (!(parameterElement is { Next: IPropertyNode propertyElement }))
{
continue;
}
var parameterGetter = ExpressionGetter.CreateParameterGetter(
parameterElement,
this.propertyExpression);
var owner = parameterGetter(parameter1);
var root = this.CreateParameterObserverChain(owner,
propertyElement);
this.RootNodes.Add(root);
break;
}
protected override Task SerializePropertyAsync(JsonTextWriter writer, object entity, IExpressionTree fields, PropertyExpression property)
{
if (_allowedProperties.Contains(property.Name))
{
return(base.SerializePropertyAsync(writer, entity, fields, property));
}
return(Task.CompletedTask);
}
public LanguageGeneratorContext(IExpressionTree tree) : base(tree)
{
}
public TreeVisitorContext(IExpressionTree tree)
{
Tree = tree;
}
protected virtual object GetRawValue(object entity, IExpressionTree fields, PropertyExpression property) => property.ValueProvider.GetValue(entity);
protected virtual string GetKey(object entity, IExpressionTree fields, PropertyExpression property) => NamingStrategy.GetPropertyName(property.Name, false);
protected virtual async Task WriteKvpAsync(JsonTextWriter writer, string key, object value, IExpressionTree fields, PropertyExpression property)
{
await writer.WritePropertyNameAsync(key, true);
await SerializerProvider.ResolveSerializer(value).WriteJsonAsync(writer, value, fields);
}
protected virtual Task SerializePropertyAsync(JsonTextWriter writer, object entity, IExpressionTree fields, PropertyExpression property)
{
return(WriteKvpAsync(writer, GetKey(entity, fields, property), GetRawValue(entity, fields, property), fields, property));
}
protected virtual Task SerializePropertyAsync(JsonTextWriter writer, object entity, IExpressionTree fields)
{
return(SerializePropertyAsync(writer, entity, fields, fields.Node as PropertyExpression));
}
public TileGenerator(IExpressionTree tree) : base(tree)
{
Context = new TileGeneratorContext(tree);
Writer = new TileWriter();
this.VisitTree();
}
public static Task WriteJsonAsync(this ISerializerProvider serializerProvider, JsonTextWriter writer, object entity, IExpressionTree fields) => serializerProvider.ResolveSerializer(entity).WriteJsonAsync(writer, entity, fields);
/// <summary>
/// Getters the specified property expression.
/// </summary>
/// <param name="propertyExpression">The property expression.</param>
/// <param name="tree">The tree.</param>
/// <returns>
/// Getter.
/// </returns>
private static Func <TResult?> Getter(Expression <Func <TResult> > propertyExpression, IExpressionTree tree)
{
var get = ExpressionGetter.CreateReferenceGetter <TResult>(propertyExpression.Parameters, tree);
return(() => get());
}
public Task WriteJsonAsync(JsonTextWriter writer, object entity, IExpressionTree fields) => WriteJsonAsync(writer, entity as IDictionary, fields);
public virtual async Task WriteJsonAsync(JsonTextWriter writer, object entity, IExpressionTree fields)
{
await writer.WriteStartObjectAsync();
foreach (var subSelector in CorrectFields(entity, fields).Children)
{
await SerializePropertyAsync(writer, entity, subSelector);
}
await writer.WriteEndObjectAsync();
}
protected async virtual Task WriteJsonAsync(JsonTextWriter writer, IEnumerable entities, IExpressionTree fields)
{
await writer.WriteStartArrayAsync();
foreach (object entity in entities)
{
await SerializerProvider.ResolveSerializer(entity).WriteJsonAsync(writer, entity, fields);
}
await writer.WriteEndArrayAsync();
}
public IQueryable <TEntity> ApplyIncludes <TEntity>(IQueryable <TEntity> entities, Query <TEntity> query, IExpressionTree includeWhiteList) where TEntity : class
{
if (includeWhiteList == null || query.Fields == null)
{
return(entities);
}
if (query.GetOptimizeIncludes())
{
foreach (var prop in query.Fields.Intersection(includeWhiteList))
{
entities = entities.IncludeOptimizedByPath(prop.Name);
}
}
else
{
foreach (var prop in query.Fields.Intersection(includeWhiteList))
{
entities = entities.Include(prop.Name);
}
}
return(entities);
}
public virtual Task WriteJsonAsync(JsonTextWriter writer, object entity, IExpressionTree fields)
{
return(WriteJsonAsync(writer, (IEnumerable)entity, fields));
}
