public IEntityTypeBuilder Initialize(IBindableModelBuilder modelBuilder, IEntityTypeBuilder publicEntityType)
{
var valueRuleBuilder = modelBuilder.CreateEntityTypeBuilder(FactonModelKeywords.ValueRuleEntityTypeName).WithParentType(publicEntityType);
var valueRuleContainerBuilder = modelBuilder.CreateEntityTypeBuilder(FactonModelKeywords.ValueRuleContainerTypeName);
publicEntityType.KeyProperties.ForEach(keyProperty => valueRuleContainerBuilder.WithKeyProperty(keyProperty));
foreach (var valueProperty in this.GetDimensionDependingProperties())
{
var valueRuleProperty =
valueRuleContainerBuilder.CreateContainedNavigationProperty(valueRuleBuilder, valueProperty)
.WithMultiplicity(EdmMultiplicity.One, EdmMultiplicity.Many)
.WithSupportedOperations(Operation.Get | Operation.Post | Operation.Patch);
var binding = new ConcreteValueRuleContainerNavigationPropertyBinding(
this.valueRuleService,
this.valueRuleMetadataService,
valueProperty);
modelBuilder
.WithBinding(valueRuleProperty, binding)
.WithOptionalDependency(valueRuleProperty, publicEntityType.KeyProperties.First());
}
AddContainerNavigationProperty(modelBuilder, publicEntityType, valueRuleContainerBuilder);
return(valueRuleContainerBuilder);
}
public ContainedCostSharpNavigationPropertyBuilder(
IEntityTypeBuilder targetEntityTypeBuilder,
IProperty sourceProperty,
string sourcePropertyName)
: base(targetEntityTypeBuilder, sourcePropertyName)
{
this.SourceProperty = sourceProperty;
}
public IEntitySetBuilder InitializeSet(
IBindableModelBuilder modelBuilder,
IEntityTypeBuilder entityTypeBuilder,
ISignature signature,
IEnumerable <string> entityTypes)
{
return(this.InitializeSet(modelBuilder, entityTypeBuilder, signature, entityTypes, string.Empty));
}
public IUncontainedNavigationPropertyBuilder CreateUncontainedNavigationPropertyBuilder(
IEntityTypeBuilder targetEntityTypeBuilder,
IProperty sourceProperty)
{
return(new UncontainedCostSharpNavigationPropertyBuilder(
targetEntityTypeBuilder,
sourceProperty,
this.modelItemNamingService.GetSafeEdmPropertyName(sourceProperty)));
}
public IEntitySetBuilder CreateEntitySetBuilder(string name, IEntityTypeBuilder containedEntityTypeBuilder)
{
if (this.entitySetBuilders.ContainsKey(name))
{
throw new ArgumentException("Entity set builder already exists.", nameof(name));
}
return(this.entitySetBuilders[name] = new EntitySetBuilder(name, containedEntityTypeBuilder, this.edmModelUnderConstruction));
}
public DynamicAssemblyManager(DynamicAssembly dynamicAssembly)
{
_dynamicAssembly = dynamicAssembly;
_entityTypeBuilder = new EntityTypeBuilder(dynamicAssembly);
_mappingTypeBuilder = new MappingTypeBuilder(dynamicAssembly);
// TODO: should this use Thread.GetDomain()??
AppDomain.CurrentDomain.AssemblyResolve += ResolveAssembly;
}
private IReadOnlyDictionary <string, IStructuralProperty> GetEffectiveKeyProperties()
{
IEntityTypeBuilder entityType = this;
while (entityType.KeyProperties.IsEmpty())
{
entityType = entityType.ParentTypeBuilder;
}
return(entityType.KeyProperties.ToDictionary(p => p.EdmPropertyName, p => p));
}
public IContainedNavigationPropertyBuilder CreateContainedNavigationProperty(IEntityTypeBuilder targetTypeBuilder, IProperty propertyName)
{
this.ThrowIfAlreadyBuilt();
var builder = this.navigationPropertyBuilderFactory.CreateContainedNavigationPropertyBuilder(targetTypeBuilder, propertyName);
this.ThrowIfDuplicatePropertyName(builder.SourcePropertyName);
this.navigationPropertyBuilders.Add(builder.SourcePropertyName, builder);
return(builder);
}
private static void AddContainerNavigationProperty(
IBindableModelBuilder modelBuilder,
IEntityTypeBuilder publicEntityType,
IEntityTypeBuilder containerEntityType)
{
modelBuilder.WithBinding(
publicEntityType.CreateContainedNavigationProperty(containerEntityType, FactonModelKeywords.ValueRuleContainerNavigationPropertyName)
.WithMultiplicity(EdmMultiplicity.One, EdmMultiplicity.One)
.WithSupportedOperations(Operation.Get),
new VirtualValueRuleContainerNavigationPropertyBinding());
}
private void InitializeSignatureTypes(IBindableModelBuilder modelBuilder, IEntityTypeBuilder publicEntityTypeBuilder)
{
// create one entity type per every registered FACTON signature type
foreach (var signatureType in this.configurationRegistry.RegisteredSignatureTypeConfigurations)
{
var initializer =
this.entityTypeInitializerRegistry.GetAll()
.OfType <ISignatureTypeInitializer>()
.FirstOrDefault(i => i.CanHandleSignatureType(signatureType));
initializer?.Initialize(signatureType, modelBuilder, publicEntityTypeBuilder);
}
}
private IReadOnlyDictionary <string, IStructuralProperty> GetEffectiveProperties()
{
var effectiveProperties = new Dictionary <string, IStructuralProperty>();
IEntityTypeBuilder entityType = this;
do
{
entityType.Properties.ForEach(property => effectiveProperties[property.EdmPropertyName] = property);
entityType = entityType.ParentTypeBuilder;
}while (entityType != null);
return(effectiveProperties);
}
private static void RegisterVersionedEntityNavigationProperty(
IBindableModelBuilder modelBuilder,
IEntityTypeBuilder versionInfoTypeBuilder,
IEntityTypeBuilder publicEntityTypeBuilder)
{
modelBuilder.WithBinding(
versionInfoTypeBuilder.CreateContainedNavigationProperty(
publicEntityTypeBuilder,
FactonModelKeywords.VersionedEntityNavigationPropertyName)
.WithMultiplicity(EdmMultiplicity.One, EdmMultiplicity.One)
.WithSupportedOperations(Operation.Get),
new VersionedEntityNavigationPropertyBinding());
}
public IEntitySetBuilder InitializeSet(
IBindableModelBuilder modelBuilder,
IEntityTypeBuilder entityTypeBuilder,
ISignature signature,
IEnumerable <string> entityTypes,
string space)
{
var entitySetBuilder =
modelBuilder.CreateEntitySetBuilder(this.GetSetName(signature), entityTypeBuilder)
.WithSupportedOperations(Operation.Get | Operation.Post | Operation.Patch);
modelBuilder.WithBinding(entitySetBuilder, this.CreateEntitySetBinding(signature, entityTypes, space));
return(entitySetBuilder);
}
public IEntityTypeBuilder Initialize(
SignatureTypeConfiguration config,
IBindableModelBuilder modelBuilder,
IEntityTypeBuilder publicEntityType)
{
var typeBuilder = modelBuilder.CreateEntityTypeBuilder(config.SignatureType).WithParentType(publicEntityType);
foreach (var signature in this.signatureSetInitializer.GetRelevantSignaturesByType(config.SignatureType))
{
this.signatureSetInitializer.InitializeSingleton(
modelBuilder, typeBuilder, signature, config.RelevantEntityTypes, "GlobalMasterData");
}
return(typeBuilder);
}
/// <summary>
/// Determines whether this entity type is derived from or is equal to the the specified parent entity type.
/// </summary>
/// <param name="entityTypeBuilder">The derived entity type builder.</param>
/// <param name="parentEntityTypeBuilder">The parent entity type builder.</param>
public static bool IsDerivedFrom(this IEntityTypeBuilder entityTypeBuilder, IEntityTypeBuilder parentEntityTypeBuilder)
{
var parent = entityTypeBuilder.ParentTypeBuilder;
while (parent != null)
{
if (parent.Equals(parentEntityTypeBuilder))
{
return(true);
}
parent = parent.ParentTypeBuilder;
}
return(false);
}
/// <summary>
/// Fluent Mapping
/// </summary>
/// <param name="entityTypeBuilderTypes"></param>
public static void UseBuilders(params Type[] entityTypeBuilderTypes)
{
if (entityTypeBuilderTypes == null)
{
return;
}
List <TypeDefinition> typeDefinitions = new List <TypeDefinition>(entityTypeBuilderTypes.Length);
foreach (Type entityTypeBuilderType in entityTypeBuilderTypes)
{
IEntityTypeBuilder entityTypeBuilder = Activator.CreateInstance(entityTypeBuilderType) as IEntityTypeBuilder;
typeDefinitions.Add(entityTypeBuilder.EntityType.MakeDefinition());
}
Configure(typeDefinitions.ToArray());
}
public IEntityTypeBuilder Initialize(
SignatureTypeConfiguration config,
IBindableModelBuilder modelBuilder,
IEntityTypeBuilder publicEntityType)
{
var typeBuilder = modelBuilder.CreateEntityTypeBuilder(config.SignatureType).WithParentType(publicEntityType);
var versionInfoTypeBuilder = this.versionInfoTypeInitializer.GetOrCreateVersionInfoType(modelBuilder, publicEntityType);
this.versionInfoTypeInitializer.InitializeVersionsNavigationProperty(modelBuilder, typeBuilder, versionInfoTypeBuilder);
foreach (var signature in this.signatureSetInitializer.GetRelevantSignaturesByType(config.SignatureType))
{
this.signatureSetInitializer.InitializeSet(modelBuilder, typeBuilder, signature, config.RelevantEntityTypes);
}
return(typeBuilder);
}
public IEntitySetBuilder InitializeSingleton(
IBindableModelBuilder modelBuilder,
IEntityTypeBuilder entityTypeBuilder,
ISignature signature,
IEnumerable <string> entityTypes,
string space)
{
var singletonBuilder =
modelBuilder.CreateEntitySetBuilder(this.GetSetName(signature), entityTypeBuilder)
.AsSingleton()
.WithSupportedOperations(Operation.Get | Operation.Patch);
modelBuilder.WithBinding(
singletonBuilder,
new SignatureSingletonBinding(this.factonQueryService, this.queryBuilderFactory, signature, entityTypes, space));
return(singletonBuilder);
}
public static TypeDescriptor GetDescriptor(Type type)
{
PublicHelper.CheckNull(type, nameof(type));
TypeDescriptor instance;
if (!InstanceCache.TryGetValue(type, out instance))
{
lock (type)
{
if (!InstanceCache.TryGetValue(type, out instance))
{
IEntityTypeBuilder entityTypeBuilder = Activator.CreateInstance(typeof(InternalEntityTypeBuilder <>).MakeGenericType(type)) as IEntityTypeBuilder;
instance = new TypeDescriptor(entityTypeBuilder.EntityType.MakeDefinition());
InstanceCache.GetOrAdd(type, instance);
}
}
}
return(instance);
}
private void ThrowIfDuplicatePropertiesInHierarchy()
{
var names = new HashSet <string>();
IEntityTypeBuilder typeBuilder = this;
while (typeBuilder != null)
{
foreach (var keyProperty in typeBuilder.KeyProperties.Select(p => p.EdmPropertyName))
{
if (names.Contains(keyProperty))
{
throw new InvalidOperationException("Key property " + keyProperty + " is already contained in one of the parent types.");
}
names.Add(keyProperty);
}
foreach (var property in typeBuilder.Properties.Select(p => p.EdmPropertyName))
{
if (names.Contains(property))
{
throw new InvalidOperationException("Property " + property + " is already contained in one of the parent types.");
}
names.Add(property);
}
foreach (var navigationProperty in typeBuilder.NavigationPropertyBuilders.Select(n => n.SourcePropertyName))
{
if (names.Contains(navigationProperty))
{
throw new InvalidOperationException("Property " + navigationProperty + " is already contained in one of the parent types.");
}
names.Add(navigationProperty);
}
typeBuilder = typeBuilder.ParentTypeBuilder;
}
}
private void AddTreePropertiesToPublicEntityType(
ISignature treeSignature,
IBindableModelBuilder modelBuilder,
IEntityTypeBuilder dataTreeType,
IEntityTypeBuilder publicEntityType)
{
foreach (var property in this.propertyService.GetSelectionTreePropertiesByTreeSignature(treeSignature))
{
modelBuilder.WithBinding(
publicEntityType.CreateUncontainedNavigationProperty(dataTreeType, property)
.WithMultiplicity(EdmMultiplicity.One, EdmMultiplicity.One)
.WithSupportedOperations(Operation.Get),
new SelectionTreeValueNavigationPropertyBinding(property));
}
foreach (var property in this.propertyService.GetSelectionTreeValueListPropertiesByTreeSignature(treeSignature))
{
modelBuilder.WithBinding(
publicEntityType.CreateUncontainedNavigationProperty(dataTreeType, property)
.WithMultiplicity(EdmMultiplicity.One, EdmMultiplicity.Many)
.WithSupportedOperations(Operation.Get),
new SelectionTreeValueListValueNavigationPropertyBinding(property));
}
}
public IEntityTypeBuilder Initialize(
SignatureTypeConfiguration config,
IBindableModelBuilder modelBuilder,
IEntityTypeBuilder publicEntityType)
{
var dataTreeTypeBuilder = modelBuilder.CreateEntityTypeBuilder(config.SignatureType).WithParentType(publicEntityType);
var parentProperty =
dataTreeTypeBuilder.CreateUncontainedNavigationProperty(dataTreeTypeBuilder, FactonModelKeywords.TreeNodeParentNavigationPropertyName)
.WithMultiplicity(EdmMultiplicity.Many, EdmMultiplicity.One)
.WithSupportedOperations(Operation.Get);
modelBuilder.WithBinding(parentProperty, new TreeNodeParentNavigationPropertyBinding());
foreach (var signature in this.signatureSetInitializer.GetRelevantSignaturesByType(config.SignatureType))
{
var setBuilder =
this.signatureSetInitializer.InitializeSet(
modelBuilder, dataTreeTypeBuilder, signature, config.RelevantEntityTypes, this.space)
.WithUncontainedNavigationPropertySelfTarget(parentProperty);
IEntitySetBinding existingBinding;
if (!modelBuilder.TryGetBinding(setBuilder, out existingBinding))
{
throw new InvalidOperationException("No existing binding found for tree node entity set.");
}
modelBuilder
.WithBinding(setBuilder, new TreeNodeEntitySetBinding(existingBinding))
.WithDependency(setBuilder, parentProperty)
.WithOptionalDependency(setBuilder, publicEntityType.KeyProperties.First());
this.AddTreePropertiesToPublicEntityType(signature, modelBuilder, dataTreeTypeBuilder, publicEntityType);
}
return(dataTreeTypeBuilder);
}
public static IEnumerable <INavigationPropertyBuilder> GetEffectiveNavigationProperties(this IEntityTypeBuilder entityTypeBuilder)
{
var navigationProperties = new List <INavigationPropertyBuilder>();
do
{
navigationProperties.AddRange(entityTypeBuilder.NavigationPropertyBuilders);
entityTypeBuilder = entityTypeBuilder.ParentTypeBuilder;
}while (entityTypeBuilder != null);
return(navigationProperties);
}
private void AddDataTreePropertyNavigationTargets(IModelBuilder modelBuilder, IEntityTypeBuilder publicEntityType)
{
var entitySetsOfPublicEntityType =
modelBuilder.EntitySetBuilders.Where(entitySet => entitySet.ContainedEntityType.IsDerivedFrom(publicEntityType)).ToArray();
foreach (var navigationProperty in publicEntityType.NavigationPropertyBuilders.OfType <IUncontainedNavigationPropertyBuilder>())
{
IEntitySetBuilder targetEntitySet;
if (this.TryGetDataTreeTargetEntitySet(navigationProperty, modelBuilder, out targetEntitySet))
{
entitySetsOfPublicEntityType.ForEach(s => s.WithUncontainedNavigationPropertyTarget(navigationProperty, targetEntitySet));
}
}
}
public void PerformPostProcessing(IModelBuilder modelBuilder, IEntityTypeBuilder publicEntityType)
{
this.AddDataTreePropertyNavigationTargets(modelBuilder, publicEntityType);
}
public IEntityTypeBuilder Initialize(SignatureTypeConfiguration config, IBindableModelBuilder modelBuilder, IEntityTypeBuilder publicEntityType)
{
throw new NotImplementedException();
}
public bool TryGetEntityTypeBuilder(string name, out IEntityTypeBuilder entityTypeBuilder) => this.underlyingModelBuilder.TryGetEntityTypeBuilder(name, out entityTypeBuilder);
public bool TryGetEntityTypeBuilder(string name, out IEntityTypeBuilder entityTypeBuilder)
{
return(this.entityTypeBuilders.TryGetValue(name, out entityTypeBuilder));
}
private void PerformPostProcessing(IModelBuilder modelBuilder, IEntityTypeBuilder publicEntityTypeBuilder)
{
this.entityTypeInitializerRegistry.GetAll()
.OfType <IPostProcessor>()
.ForEach(p => p.PerformPostProcessing(modelBuilder, publicEntityTypeBuilder));
}
protected NavigationPropertyBuilderBase(IEntityTypeBuilder targetEntityTypeBuilder, string sourcePropertyName)
{
this.TargetEntityTypeBuilder = targetEntityTypeBuilder;
this.SourcePropertyName = sourcePropertyName;
}
public IEntitySetBuilder CreateEntitySetBuilder(string name, IEntityTypeBuilder containedEntityTypeBuilder) => this.underlyingModelBuilder.CreateEntitySetBuilder(name, containedEntityTypeBuilder);
