/// <inheritdoc />
public override bool Matches(IBindingMetadata metadata)
{
_ = metadata ?? throw new ArgumentNullException(nameof(metadata));
return(metadata.Has(nameof(ContentSource)) &&
metadata.Get <ContentSource>(nameof(ContentSource)) == this.Source);
}
private static Node AddDynamicNode(NodeTree tree, MetadataIdentity identity, IBindingMetadata metadata)
{
AddStaticNode(tree, metadata);
Node thisNode = tree.FindNode(identity);
MetadataIdentity parentIdentity = identity.Pop();
if (thisNode != null)
{
return(thisNode);
}
else if (parentIdentity != null)
{
Node parentNode = tree.FindNode(parentIdentity) ?? AddDynamicNode(tree, parentIdentity, metadata);
if (parentNode != null)
{
thisNode = new Node(identity, metadata)
{
IsDynamic = true,
};
parentNode.Properties.Add(thisNode);
tree.Nodes.Add(thisNode);
}
}
return(thisNode);
}
public AggregateNode Build()
{
IBindingMetadata metadata = this.Schema.GetMetadata <IBindingMetadata>();
AggregateNode aggrNode = new AggregateNode()
{
Metadata = metadata,
Index = this.State.Indexer.GetListIndex(metadata.Item.Identity),
};
if (this.State.Aggregate.Targets.Count > 0)
{
aggrNode.Item = new MetadataNode(metadata.Item);
}
foreach (MetadataIdentity identity in this.State.Aggregate.Targets)
{
IBindingMetadata targetMetadata = identity.GetMetadata <IBindingMetadata>();
IBindingMetadata valueMetadata = targetMetadata.HasFlag(BindingMetadataFlags.Item) ? targetMetadata.Parent : targetMetadata;
MetadataNode valueNode = new MetadataNode(valueMetadata)
{
ListIndex = this.State.Indexer.GetListIndex(identity),
};
this.AddListNode(aggrNode, valueNode);
}
return(aggrNode);
}
public void Build(IDbDataParameter adoParameter)
{
IBindingMetadata metadata = this.Field?.Identity.GetMetadata <IBindingMetadata>();
IBindingParameterContract contract = metadata?.Parameter;
adoParameter.ParameterName = this.Name;
if (contract?.Convert != null)
{
adoParameter.Value = contract.Convert(this.Field?.Value);
}
else if (this.Field != null)
{
adoParameter.Value = this.Field.Value;
}
else
{
adoParameter.Value = DBNull.Value;
}
if (contract?.Write != null)
{
BindingParameterInfo paramInfo = new BindingParameterInfo()
{
Metadata = metadata,
Parameter = adoParameter,
Field = this.Field,
};
contract.Write(paramInfo);
}
}
public void Build(IDbDataParameter adoParameter)
{
IBindingMetadata metadata = this.Source?.Identity.Metadata.Require <IBindingMetadata>();
IBindingParameterContract contract = metadata?.Parameter;
adoParameter.ParameterName = this.Name;
if (contract?.Convert != null)
{
adoParameter.Value = contract.Convert(this.Source?.Snapshot);
}
else if (this.Source != null)
{
adoParameter.Value = this.Source.Snapshot;
}
else
{
adoParameter.Value = DBNull.Value;
}
if (contract?.Write != null)
{
BindingParameterInfo paramInfo = new BindingParameterInfo()
{
Metadata = metadata,
Parameter = adoParameter,
Field = this.Source,
};
contract.Write(paramInfo);
}
}
public BufferWriter Compile(IEnumerable <ColumnName> columnNames)
{
List <Expression> body = new List <Expression>();
int index = 0;
foreach (ColumnName columnName in columnNames)
{
IBindingMetadata metadata = columnName.Metadata.Lookup <IBindingMetadata>();
Expression value = this.GetValueExpression(metadata, columnName.Column);
Expression writer = this.GetWriterExpression(index++, value);
body.Add(writer);
}
if (!body.Any())
{
return (dr, buf) => { }
}
;
ParameterExpression[] arguments = new[] { Arguments.DataReader, Arguments.Buffers };
Expression block = Expression.Block(body);
return(Expression.Lambda <BufferWriter>(block, arguments).Compile());
}
private IEnumerable <IReference> GetValidReferences(IBindingMetadata metadata)
{
IReferenceMetadata referenceMetadata = metadata.Identity.Lookup <IReferenceMetadata>();
if (referenceMetadata != null)
{
return(referenceMetadata.References.Where(IsValid).OrderBy(r => r.Priority));
}
return(Array.Empty <IReference>());
bool IsValid(IReference reference)
{
if (!reference.HasFlag(ReferenceFlags.Many) && !reference.Other.HasFlag(ReferenceFlags.Many))
{
return(false);
}
IBindingMetadata metadata = reference.Find(ReferenceFlags.Child).Metadata.Identity.Lookup <IBindingMetadata>();
if (this.QueryType == QueryType.Aggregate && this.IsAggregateList(metadata))
{
return(false);
}
return(true);
}
}
public IBindingValueContract GetValueContract(IBindingMetadata metadata)
{
if (metadata.Type.IsOpenGeneric(typeof(CustomList <>), out Type itemType))
{
return(new BindingValueContract()
{
Read = null,
Convert = info =>
{
var listType = typeof(CustomList <>).MakeGenericType(itemType);
var collectionType = typeof(ICollection <>).MakeGenericType(itemType);
var newList = Expression.New(listType);
var addMethod = collectionType.GetMethod("Add");
var variable = Expression.Variable(listType);
var assignList = Expression.Assign(variable, newList);
var addDefault = Expression.Call(variable, addMethod, Expression.Default(itemType));
return Expression.Block(new[] { variable }, assignList, addDefault, variable);
}
});
}
return(null);
}
private static void AddDataNode(NodeTree tree, DataAttribute attribute)
{
MetadataIdentity identity = new MetadataIdentity(tree.Schema, attribute.Name);
IBindingMetadata metadata = identity.Lookup <IBindingMetadata>() ?? FindDynamicMetadata(identity);
if (metadata != null)
{
Node node;
if (metadata.HasFlag(BindingMetadataFlags.Dynamic))
{
node = AddDynamicNode(tree, identity, metadata);
}
else
{
node = AddStaticNode(tree, metadata);
}
if (node != null)
{
node.Data = attribute;
tree.Data.Add(node);
}
}
}
public IBindingValueContract GetValueContract(IBindingMetadata metadata)
{
return(new BindingValueContract()
{
Read = this.GetRecordReaderMethod,
Convert = metadata.Value.Convert,
});
}
private Type GetOpenType(IBindingMetadata metadata)
{
if (metadata.Type.IsGenericType)
{
return(metadata.Type.GetGenericTypeDefinition());
}
return(null);
}
public IBindingCompositionContract GetCompositionContract(IBindingMetadata metadata)
{
return(new BindingCompositionContract()
{
Add = this.GetAddMethod(metadata),
AddDynamic = this.GetAddDynamicMethod(metadata),
Construct = this.GetConstructor(metadata),
});
}
private void AddAggregateTargets(IEnumerable <ElementNode> elementNodes)
{
IBindingMetadata resultItem = this.Schema.GetMetadata <IBindingMetadata>().Item;
foreach (ElementNode elementNode in elementNodes.Where(n => n.ListIndex != null && n.Value.Metadata.Parent.MemberOf.Equals(resultItem)))
{
this.State.Aggregate.Add(elementNode.Value.Metadata.Identity);
}
}
public IBindingHelperContract GetHelperContract(IBindingMetadata metadata)
{
if (!this.HasJsonAttribute(metadata))
{
return(null);
}
return(this.helper);
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="provider"></param>
/// <param name="scope"></param>
/// <param name="metadata"></param>
/// <param name="constructorArguments"></param>
/// <param name="propertyValues"></param>
public Binding(Type type, IProvider provider, IScope scope, IBindingMetadata metadata, ParameterMap constructorArguments, ParameterMap propertyValues)
{
Type = type;
Provider = provider;
Scope = scope;
Metadata = metadata ?? EmptyBindingMetadata;
ConstructorArguments = constructorArguments ?? new ParameterMap(null);
PropertyValues = propertyValues ?? new ParameterMap(null);
}
public IBindingValueContract GetValueContract(IBindingMetadata metadata)
{
IBindingValueContract fallback = metadata.Value;
return(new BindingValueContract()
{
Read = ci => this.GetRecordReaderMethod(ci, fallback),
Convert = fallback?.Convert,
});
}
public IBindingValueContract GetValueContract(IBindingMetadata metadata)
{
IBindingValueContract fallback = metadata.Value;
return(new BindingValueContract()
{
Convert = fallback.Convert,
Read = ci => this.GetValueReaderProxy(ci, fallback),
});
}
private Type GetOneValueType(IBindingMetadata metadata)
{
Type openType = this.GetOpenType(metadata);
if (openType == typeof(One <>))
{
return(metadata.Type.GetGenericArguments()[0]);
}
return(null);
}
private MethodInfo GetAddMethod(IBindingMetadata metadata)
{
Type elementType = this.GetListElementType(metadata);
if (elementType != null)
{
return(typeof(ICollection <>).MakeGenericType(elementType).GetMethod("Add"));
}
return(null);
}
private MethodInfo GetAddDynamicMethod(IBindingMetadata metadata)
{
if (metadata.HasFlag(BindingMetadataFlags.Dynamic))
{
Type dictionaryType = typeof(IDictionary <string, object>);
return(dictionaryType.GetMethod("Add", new[] { typeof(string), typeof(object) }));
}
return(null);
}
public static BindingException Create(IBindingMetadata metadata, string message = null, Exception innerException = null)
{
message ??= innerException?.Message;
if (message != null)
{
return(new BindingException($"Cannot bind to {metadata.Identity}: {message}", innerException));
}
return(new BindingException($"Cannot bind to {metadata.Identity}.", innerException));
}
internal static BindingException NoReferenceFound(IBindingMetadata metadata)
{
if (metadata.HasFlag(BindingMetadataFlags.Item))
{
return(NoReferenceFound(metadata.Identity, metadata.Parent.Parent.Identity));
}
else
{
return(NoReferenceFound(metadata.Identity, metadata.Parent.Identity));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Binding"/> class.
/// </summary>
/// <param name="service">The service that is controlled by the binding.</param>
/// <param name="metadata">The binding's metadata container.</param>
public Binding(Type service, IBindingMetadata metadata)
{
Ensure.ArgumentNotNull(service, "service");
Ensure.ArgumentNotNull(metadata, "metadata");
Service = service;
Metadata = metadata;
Parameters = new List<IParameter>();
ActivationActions = new List<Action<IContext, object>>();
DeactivationActions = new List<Action<IContext, object>>();
ScopeCallback = StandardScopeCallbacks.Transient;
}
/// <summary>
/// Initializes a new instance of the <see cref="Binding"/> class.
/// </summary>
/// <param name="service">The service that is controlled by the binding.</param>
/// <param name="metadata">The binding's metadata container.</param>
public Binding(Type service, IBindingMetadata metadata)
{
Ensure.ArgumentNotNull(service, "service");
Ensure.ArgumentNotNull(metadata, "metadata");
Service = service;
Metadata = metadata;
Parameters = new List <IParameter>();
ActivationActions = new List <Action <object> >();
DeactivationActions = new List <Action <object> >();
ScopeCallback = StandardScopeCallbacks.Transient;
}
public IBindingParameterContract GetParameterContract(IBindingMetadata metadata)
{
if (!this.HasJsonAttribute(metadata))
{
return(null);
}
return(new BindingParameterContract()
{
Convert = o => o != null ? (object)JsonConvert.SerializeObject(o, this.Settings) : DBNull.Value,
});
}
public IBindingParameterContract GetParameterContract(IBindingMetadata metadata)
{
if (!this.HasJsonAttribute(metadata))
{
return(null);
}
return(new BindingParameterContract()
{
Convert = o => o != null ? (object)JsonSerializer.Serialize(o, metadata.Type, this.Options) : DBNull.Value,
});
}
public IBindingCompositionContract GetCompositionContract(IBindingMetadata metadata)
{
if (metadata.Type.IsOpenGeneric(typeof(CustomList <>), out Type itemType))
{
return(new BindingCompositionContract()
{
Construct = Expression.New(typeof(CustomList <>).MakeGenericType(itemType)),
Add = typeof(ICollection <>).MakeGenericType(itemType).GetMethod("Add"),
});
}
return(null);
}
private static bool HasValidReference(IBindingMetadata metadata)
{
IReferenceMetadata referenceMetadata = metadata.Identity.Lookup <IReferenceMetadata>();
if (referenceMetadata != null)
{
IEnumerable <IReference> childReferences = referenceMetadata.References.Where(r => r.HasFlag(ReferenceFlags.Child));
return(childReferences.Any(r => r.HasFlag(ReferenceFlags.Many) || r.Other.HasFlag(ReferenceFlags.Many)));
}
return(false);
}
public int GetListIndex(IBindingMetadata metadata)
{
if (metadata.HasFlag(BindingMetadataFlags.Model))
{
return(ResultIndex);
}
else if (metadata.HasFlag(BindingMetadataFlags.Item) && metadata.Parent.HasFlag(BindingMetadataFlags.Model))
{
return(ResultIndex);
}
return(this.GetListIndex(new BufferCacheKey(metadata.Identity)));
}
public IBindingValueContract GetValueContract(IBindingMetadata metadata)
{
if (!this.HasJsonAttribute(metadata))
{
return(null);
}
return(new BindingValueContract()
{
Convert = this.GetValueReaderProxy,
Read = this.GetColumnReaderProxy,
});
}
private IBindingMetadata FindDynamicMetadata(MetadataIdentity identity)
{
IBindingMetadata metadata = identity.GetMetadata <IBindingMetadata>();
while (metadata == null && (identity = identity.Pop()) != null)
{
metadata = identity.GetMetadata <IBindingMetadata>();
}
if (metadata != null && metadata.HasFlag(BindingMetadataFlags.Dynamic))
{
return(metadata);
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="WebBinding"/> class.
/// </summary>
/// <param name="service">The service that is controlled by the binding.</param>
/// <param name="metadata">The binding's metadata container.</param>
public WebBinding(Type service, IBindingMetadata metadata) : base(service, metadata)
{ }
public bool Match(IBindingMetadata metadata)
{
return name == metadata.Name;
}
public override bool Matches (IBindingMetadata metadata)
{
return metadata.Has ("IsSomething") && metadata.Get<bool> ("IsSomething");
}
public bool Match(IBindingMetadata metadata)
{
return constraints.All(c => c.Match(metadata));
}
public override bool Matches(IBindingMetadata metadata)
{
return metadata.Has("CanSwim") && metadata.Get<bool>("CanSwim");
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="metadata"></param>
public Binding(Type type, IBindingMetadata metadata)
{
Type = type;
Metadata = metadata;
}
/// <summary> /// Determines whether the specified binding metadata matches the constraint. /// </summary> /// <param name="metadata">The metadata in question.</param> /// <returns><c>True</c> if the metadata matches; otherwise <c>false</c>.</returns> public abstract bool Matches(IBindingMetadata metadata);
/// <summary>
/// Determines whether the specified binding metadata matches the constraint.
/// </summary>
/// <param name="metadata">The metadata in question.</param>
/// <returns><c>True</c> if the metadata matches; otherwise <c>false</c>.</returns>
public override bool Matches(IBindingMetadata metadata)
{
Contract.Requires(metadata != null);
return metadata.Name == this.Name;
}
/// <summary>
/// Determines whether the specified binding metadata matches the constraint.
/// </summary>
/// <param name="metadata">The metadata in question.</param>
/// <returns>
/// <c>True</c> if the metadata matches; otherwise <c>false</c>.
/// </returns>
public override bool Matches(IBindingMetadata metadata)
{
Ensure.ArgumentNotNull(metadata, "metadata");
return metadata.Name == Name;
}
