private IEnumerable <BindingMetadata> CreateProperties(IMetadataBuilderContext context, BindingMetadata parent)
{
foreach (IRelationMetadata attribute in parent.Relation.Properties)
{
yield return(this.CreateBaseMetadata(context, attribute, parent));
}
}
private IJsonMetadata GetMetadata(IMetadataBuilderContext context, MetadataIdentity identity)
{
MetadataIdentity parentIdentity = identity.Parent();
IJsonMetadata parent = context.GetMetadata <IJsonMetadata>(parentIdentity.Name) ?? this.GetMetadata(context, parentIdentity);
IRelationMetadata relation = identity.GetMetadata <IRelationMetadata>();
if (parent == null || relation == null)
{
return(null);
}
JsonMetadata metadata = new JsonMetadata(relation);
if (this.HasJsonAttribute(relation) || relation.HasFlag(RelationMetadataFlags.Item))
{
metadata.MemberOf = metadata;
metadata.IsRoot = true;
metadata.Path = "$";
}
else
{
metadata.MemberOf = parent.MemberOf;
metadata.IsRoot = false;
metadata.Path = $"{parent.Path}.{this.GetPropertyNameFromContract(metadata)}";
}
context.AddMetadata <IJsonMetadata>(metadata);
return(metadata);
}
private IEnumerable <ProjectionMetadata> CreateProperties(IMetadataBuilderContext context, ProjectionMetadata parent)
{
foreach (IRelationMetadata property in parent.Relation.Properties)
{
yield return(this.CreateAndAddMetadata(context, property));
}
}
private IEnumerable <TableMetadata> CreateProperties(IMetadataBuilderContext context, TableMetadata parent)
{
foreach (IRelationMetadata property in parent.Relation.Properties)
{
yield return(this.CreateBaseMetadata(context, property, parent));
}
}
private ProjectionMetadata CreateAndAddMetadata(IMetadataBuilderContext context, IRelationMetadata relation)
{
ProjectionMetadata metadata = this.CreateBaseMetadata(context, relation);
context.AddMetadata <IProjectionMetadata>(metadata);
return(metadata);
}
private TableMetadata CreateItem(IMetadataBuilderContext context, TableMetadata parent)
{
if (parent.Relation.Item == null)
{
return(null);
}
return(this.CreateMetadata(context, parent.Relation.Item, parent));
}
public CustomMetadata GetMetadata(IMetadataBuilderContext context)
{
if (context.Relation.Parent != null)
{
return(context.Relation.Parent.Identity.Schema.Lookup <CustomMetadata>());
}
return(null);
}
private IEnumerable <RelationMetadata> CreateProperties(IMetadataBuilderContext context, RelationMetadata parent)
{
IEnumerable <MemberInfo> members = parent.Type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (MemberInfo member in members.Where(m => this.IsFieldOrNonIndexedProperty(m)))
{
yield return(this.CreateProperty(context, parent, member));
}
}
public void Initialize(IMetadataBuilderContext context)
{
JsonMetadata metadata = new JsonMetadata(context.Relation);
metadata.MemberOf = metadata;
metadata.Path = "$";
metadata.IsRoot = true;
context.AddMetadata <IJsonMetadata>(metadata);
}
private ProjectionMetadata CreateBaseMetadata(IMetadataBuilderContext context, IRelationMetadata relation)
{
ProjectionMetadata metadata = new ProjectionMetadata(relation);
metadata.Properties = this.CreateLazy(() => this.CreateProperties(context, metadata));
metadata.Item = this.CreateItem(context, metadata);
metadata.Flags = this.GetFlags(metadata);
return(metadata);
}
public void Initialize(IMetadataBuilderContext context)
{
IRelationMetadata relation = context.Identity.GetMetadata <IRelationMetadata>();
if (relation == null)
{
throw MetadataNotFoundException.FromMetadata <IRelationMetadata>(context.Identity);
}
this.CreateAndAddMetadata(context, relation);
}
private IEnumerable <ReferenceMetadata> CreateProperties(IMetadataBuilderContext context, ReferenceMetadata parent)
{
foreach (IRelationMetadata attribute in parent.Relation.Properties)
{
ReferenceMetadata metadata = this.CreateBaseMetadata(context, attribute, parent);
context.AddMetadata <IReferenceMetadata>(metadata);
yield return(metadata);
}
}
public CustomMetadata GetMetadata(IMetadataBuilderContext context)
{
MetadataIdentity parentIdentity = context.Identity.Parent();
if (parentIdentity != null)
{
return(context.Schema.GetMetadata <CustomMetadata>(parentIdentity.Name));
}
return(null);
}
public void Initialize(IMetadataBuilderContext context)
{
IRelationMetadata relation = context.Schema.GetMetadata <IRelationMetadata>(context.Identity.Name);
if (relation == null)
{
throw MetadataNotFoundException.FromMetadata <IRelationMetadata>(context.Identity);
}
this.CreateBaseMetadata(context, relation, null);
}
private ProjectionMetadata CreateItem(IMetadataBuilderContext context, ProjectionMetadata parent)
{
if (parent.Relation.Item != null)
{
ProjectionMetadata metadata = this.GetMetadata(context, parent.Relation.Item, parent);
metadata.List = parent;
return(metadata);
}
return(null);
}
private ReferenceMetadata CreateItem(IMetadataBuilderContext context, ReferenceMetadata parent)
{
if (parent.Relation.Item != null)
{
ReferenceMetadata metadata = this.CreateBaseMetadata(context, parent.Relation.Item, parent);
context.AddMetadata <IReferenceMetadata>(metadata);
return(metadata);
}
return(null);
}
private TableMetadata CreateBaseMetadata(IMetadataBuilderContext context, IRelationMetadata attribute, TableMetadata parent)
{
TableMetadata metadata = new TableMetadata(attribute);
metadata.Item = this.CreateItem(context, metadata);
metadata.Properties = new Lazy <IReadOnlyList <TableMetadata> >(() => this.CreateProperties(context, metadata).ToList());
this.AddTableMetadata(metadata);
this.AddColumnMetadata(metadata, parent);
context.AddMetadata <ITableMetadata>(metadata);
return(metadata);
}
private TableMetadata CreateMetadata(IMetadataBuilderContext context, IRelationMetadata relation, TableMetadata parent)
{
TableMetadata metadata = new TableMetadata(relation);
metadata.Item = this.CreateItem(context, metadata);
this.ApplyContracts(metadata, parent);
metadata.Properties = new Lazy <IReadOnlyList <TableMetadata> >(() => this.CreateProperties(context, metadata).ToList());
context.AddMetadata <ITableMetadata>(metadata);
return(metadata);
}
private RelationMetadata CreateItem(IMetadataBuilderContext context, RelationMetadata parent)
{
IRelationListContract contract = this.GetListContract(parent);
if (contract == null)
{
return(null);
}
MetadataIdentity itemId = parent.Identity.Child(contract.ItemName ?? "Item");
RelationMetadata metadata = new RelationMetadata(itemId)
{
Parent = parent,
Type = contract.ItemType,
Flags = RelationMetadataFlags.Item | RelationMetadataFlags.Property,
ReadIndex = contract.ReadIndex,
WriteIndex = contract.WriteIndex,
};
metadata.MemberOf = metadata;
metadata.Item = this.CreateItem(context, metadata);
metadata.Properties = this.CreateLazy(() => this.CreateProperties(context, metadata));
metadata.Annotations = this.CreateAnnotations(metadata).ToList();
if (this.IsMetadataRecursive(metadata))
{
metadata.Flags |= RelationMetadataFlags.Recursive;
}
if (contract.ReadIndex != null)
{
metadata.Flags |= RelationMetadataFlags.Readable;
}
if (contract.WriteIndex != null)
{
metadata.Flags |= RelationMetadataFlags.Writable;
}
if (metadata.Item != null)
{
metadata.Flags |= RelationMetadataFlags.List;
}
context.AddMetadata <IRelationMetadata>(metadata);
return(metadata);
}
private ProjectionMetadata GetMetadata(IMetadataBuilderContext context, IRelationMetadata relation, IProjectionMetadata parent)
{
ProjectionMetadata metadata = new ProjectionMetadata(relation);
context.AddMetadata <IProjectionMetadata>(metadata);
metadata.Properties = this.CreateLazy(() => this.CreateProperties(context, metadata));
metadata.Item = this.CreateItem(context, metadata);
metadata.Flags = this.GetFlags(metadata);
this.CreateTableMetadata(metadata);
this.CreateInputMetadata(context, metadata, parent);
return(metadata);
}
private ITableMetadata GetMetadata(IMetadataBuilderContext context, IRelationMetadata relation)
{
ITableMetadata parent = context.GetMetadata <ITableMetadata>(relation.Parent.Identity.Name) ?? this.GetMetadata(context, relation.Parent);
if (parent == null)
{
return(null);
}
else if (parent.Item != null && parent.Item.Identity.Equals(relation.Identity))
{
return(parent.Item);
}
return(parent.Properties.FirstOrDefault(m => m.Identity.Equals(relation.Identity)));
}
private ProjectionMetadata CreateItem(IMetadataBuilderContext context, ProjectionMetadata parent)
{
if (parent.Relation.Item != null)
{
ProjectionMetadata metadata = this.CreateBaseMetadata(context, parent.Relation.Item);
metadata.List = parent;
context.AddMetadata <IProjectionMetadata>(metadata);
return(metadata);
}
return(null);
}
private RelationMetadata CreateProperty(IMetadataBuilderContext context, RelationMetadata parent, MemberInfo memberInfo)
{
MetadataIdentity attributeId = parent.Identity.Child(memberInfo.Name);
RelationMetadata metadata = new RelationMetadata(attributeId)
{
Type = this.GetMemberType(memberInfo),
Parent = parent,
Member = memberInfo,
MemberOf = parent.MemberOf,
Flags = RelationMetadataFlags.Property,
};
metadata.Item = this.CreateItem(context, metadata);
metadata.Properties = this.CreateLazy(() => this.CreateProperties(context, metadata));
metadata.Annotations = this.CreateAnnotations(metadata).ToList();
if (metadata.Item != null)
{
metadata.Flags |= RelationMetadataFlags.List;
}
if (this.IsMetadataRecursive(metadata))
{
metadata.Flags |= RelationMetadataFlags.Recursive;
}
if (memberInfo is PropertyInfo pi)
{
if (pi.CanRead)
{
metadata.Flags |= RelationMetadataFlags.Readable;
}
if (pi.CanWrite)
{
metadata.Flags |= RelationMetadataFlags.Writable;
}
}
else if (memberInfo is FieldInfo)
{
metadata.Flags |= RelationMetadataFlags.Readable | RelationMetadataFlags.Writable;
}
context.AddMetadata <IRelationMetadata>(metadata);
return(metadata);
}
private IRelationMetadata GetMetadata(IMetadataBuilderContext context, MetadataIdentity identity)
{
MetadataIdentity parentIdentity = identity.Parent();
IRelationMetadata parent = context.GetMetadata <IRelationMetadata>(parentIdentity.Name) ?? this.GetMetadata(context, parentIdentity);
if (parent == null)
{
return(null);
}
else if (parent.Item != null && parent.Item.Identity.Equals(identity))
{
return(parent.Item);
}
return(parent.Properties.FirstOrDefault(m => m.Identity.Equals(identity)));
}
private ReferenceMetadata CreateBaseMetadata(IMetadataBuilderContext context, IRelationMetadata relation, ReferenceMetadata parent)
{
ReferenceMetadata metadata = new ReferenceMetadata(relation)
{
Parent = parent,
};
metadata.Flags = this.CreateFlags(metadata);
metadata.Properties = this.CreateLazy(() => this.CreateProperties(context, metadata));
metadata.Keys = this.CreateLazy(() => this.CreateKeys(metadata));
metadata.Item = this.CreateItem(context, metadata);
metadata.ParentReferences = this.CreateLazy(() => this.CreateParentReferences(metadata).ToList());
metadata.ChildReferences = this.CreateLazy(() => this.CreateChildReferences(metadata));
return(metadata);
}
public void Initialize(IMetadataBuilderContext context)
{
IRelationMetadata relation = context.Identity.GetMetadata <IRelationMetadata>();
if (relation == null)
{
throw MetadataNotFoundException.FromMetadata <IRelationMetadata>(context.Identity);
}
JsonMetadata metadata = new JsonMetadata(relation);
metadata.MemberOf = metadata;
metadata.Path = "$";
metadata.IsRoot = true;
context.AddMetadata <IJsonMetadata>(metadata);
}
public void Initialize(IMetadataBuilderContext context)
{
RelationMetadata model = new RelationMetadata(context.Identity)
{
Flags = RelationMetadataFlags.Model | RelationMetadataFlags.Readable,
Type = context.Schema.Model,
};
model.MemberOf = model;
model.Properties = this.CreateLazy(() => this.CreateProperties(context, model));
model.Annotations = this.CreateAnnotations(model).ToList();
model.Item = this.CreateItem(context, model);
if (model.Item != null)
{
model.Flags |= RelationMetadataFlags.List;
}
context.AddMetadata <IRelationMetadata>(model);
}
private BindingMetadata CreateBaseMetadata(IMetadataBuilderContext context, IRelationMetadata attribute, BindingMetadata parent)
{
BindingMetadata metadata = new BindingMetadata(attribute)
{
Parent = parent,
MemberOf = parent?.MemberOf
};
if (metadata.MemberOf == null || metadata.HasFlag(RelationMetadataFlags.Item))
{
metadata.MemberOf = metadata;
}
metadata.Properties = this.CreateLazyProperties(context, metadata);
metadata.Item = this.CreateItem(context, metadata);
metadata.Flags = this.GetFlags(metadata);
context.AddMetadata <IBindingMetadata>(metadata);
this.ApplyContracts(metadata);
return(metadata);
}
private void CreateInputMetadata(IMetadataBuilderContext context, ProjectionMetadata metadata, IProjectionMetadata parent)
{
if (parent?.Reference != null)
{
IEnumerable <IReference> references = parent.Reference.References.Where(r => r.HasFlag(ReferenceFlags.Foreign) && !r.HasFlag(ReferenceFlags.Self));
foreach (IReference reference in references.OrderBy(r => r.Priority))
{
int valueIndex = reference.Key.Properties.IndexOf(m => m.Identity.Equals(metadata.Identity));
if (valueIndex > -1 && !reference.Other.Metadata.Relation.HasFlag(RelationMetadataFlags.Recursive))
{
IReferenceMetadata valueMetadata = reference.Other.Key.Properties[valueIndex];
metadata.Input = new Lazy <IProjectionMetadata>(() => this.GetMetadata(context, valueMetadata.Relation));
metadata.Flags |= ProjectionMetadataFlags.Cascade;
return;
}
}
}
metadata.Input = new Lazy <IProjectionMetadata>(() => metadata);
}
public IRelationMetadata GetMetadata(IMetadataBuilderContext context) => this.GetMetadata(context, context.Identity);
