public void EdmModelAddComplexTypeTest()
{
var model = new EdmModel();
var complexTypeA = model.AddComplexType("NS", "ComplexA");
var complexTypeB = model.AddComplexType("NS", "ComplexB", complexTypeA);
var complexTypeC = model.AddComplexType("NS", "ComplexC", complexTypeB, false);
var complexTypeD = model.AddComplexType("NS", "ComplexD", complexTypeC, false, true);
Assert.Equal(complexTypeA, model.FindDeclaredType("NS.ComplexA"));
Assert.Equal(complexTypeB, model.FindDeclaredType("NS.ComplexB"));
Assert.Equal(complexTypeC, model.FindDeclaredType("NS.ComplexC"));
Assert.Equal(complexTypeD, model.FindDeclaredType("NS.ComplexD"));
}
public void GetStructuralOrEnumType_should_return_correct_type_for_ComplexType()
{
var model = new EdmModel(DataSpace.CSpace);
var complexType = model.AddComplexType("Foo");
Assert.Same(complexType, model.GetStructuralOrEnumType("Foo"));
}
private EdmStructuredType AddStructuredType(RdmStructuredType definition)
{
// base type, the Build method ensure that the base type was added before the
// sub-type and therefore FindType will succeed.
IEdmStructuredType edmBaseType = null;
if (definition.BaseType != null)
{
edmBaseType = edmModel.FindType(rdmModel.Namespace.NamespaceName + "." + definition.BaseType) as EdmStructuredType;
if (edmBaseType == null)
{
throw new TransformationException($"unable to find base type {definition.BaseType} for type {definition.Name}");
}
}
if (definition.Keys.Any() || HasSingletonOfType(definition) || (edmBaseType != null && edmBaseType.TypeKind == EdmTypeKind.Entity))
{
var entity = edmModel.AddEntityType(rdmModel.Namespace.NamespaceName, definition.Name, (IEdmEntityType)edmBaseType, definition.IsAbstract, true);
foreach (var annotation in definition.Annotations)
{
annotationBuilder.AddAnnotation(edmModel, entity, annotation);
}
return(entity);
}
else
{
var complex = edmModel.AddComplexType(rdmModel.Namespace.NamespaceName, definition.Name, (IEdmComplexType)edmBaseType, definition.IsAbstract, true);
foreach (var annotation in definition.Annotations)
{
annotationBuilder.AddAnnotation(edmModel, complex, annotation);
}
return(complex);
}
}
public void GetStructuralType_should_return_entity_or_complex_type()
{
var model = new EdmModel(DataSpace.CSpace);
var entityType = model.AddEntityType("E");
var complexType = model.AddComplexType("C");
Assert.Same(entityType, model.GetStructuralType("E"));
Assert.Same(complexType, model.GetStructuralType("C"));
}
public void GetComplexType_should_return_correct_type()
{
var model = new EdmModel(DataSpace.CSpace);
var complexType = model.AddComplexType("Foo");
var foundComplexType = model.GetComplexType("Foo");
Assert.NotNull(foundComplexType);
Assert.Same(complexType, foundComplexType);
}
public void AddComplexType_should_create_and_add_to_default_namespace()
{
var model = new EdmModel().Initialize();
var complexType = model.AddComplexType("Foo");
Assert.NotNull(complexType);
Assert.Equal("Foo", complexType.Name);
Assert.True(model.Namespaces.Single().ComplexTypes.Contains(complexType));
}
public void AddComplexType_should_create_and_add_when_custom_namespace()
{
var model = new EdmModel(DataSpace.CSpace);
var complexType = model.AddComplexType("Foo", "Bar");
Assert.NotNull(complexType);
Assert.Equal("Foo", complexType.Name);
Assert.Equal("Bar", complexType.NamespaceName);
Assert.True(model.ComplexTypes.Contains(complexType));
}
public void AddComplexType_should_create_and_add_with_default_namespace()
{
var model = new EdmModel(DataSpace.CSpace);
var complexType = model.AddComplexType("Foo");
Assert.NotNull(complexType);
Assert.Equal("Foo", complexType.Name);
Assert.Equal(EdmModelExtensions.DefaultModelNamespace, complexType.NamespaceName);
Assert.True(model.ComplexTypes.Contains(complexType));
}
public void Apply(EdmModel model)
{
Check.NotNull(model, "model");
// Query the model for candidate complex types.
// - The rules for complex type discovery are as follows:
// 1) The entity does not have a key or base type.
// 2) The entity does not have explicit configuration or has only structural type configuration.
// 3) The entity does not have any outbound navigation properties.
// The entity only has inbound associations where:
// 4) The association does not have a constraint defined.
// 5) The association does not have explicit configuration.
// 6) The association is not self-referencing.
// 7) The other end of the association is Optional.
// 8) Any inbound navigation properties do not have explicit configuration.
var candidates
= from entityType in model.EntityTypes
where entityType.KeyProperties.Count == 0 && // (1)
entityType.BaseType == null
// (1)
let entityTypeConfiguration = entityType.GetConfiguration() as EntityTypeConfiguration
where ((entityTypeConfiguration == null) || // (2)
(!entityTypeConfiguration.IsExplicitEntity &&
entityTypeConfiguration.IsStructuralConfigurationOnly)) && // (2)
!entityType.NavigationProperties.Any()
// (3)
let matchingAssociations
= from associationType in model.AssociationTypes
where associationType.SourceEnd.GetEntityType() == entityType ||
associationType.TargetEnd.GetEntityType() == entityType
let declaringEnd
= associationType.SourceEnd.GetEntityType() == entityType
? associationType.SourceEnd
: associationType.TargetEnd
let declaringEntity
= associationType.GetOtherEnd(declaringEnd).GetEntityType()
let navigationProperties
= declaringEntity.NavigationProperties
.Where(n => n.ResultEnd.GetEntityType() == entityType)
select new
{
DeclaringEnd = declaringEnd,
AssociationType = associationType,
DeclaringEntityType = declaringEntity,
NavigationProperties = navigationProperties.ToList()
}
where matchingAssociations.All(
a => a.AssociationType.Constraint == null && // (4)
a.AssociationType.GetConfiguration() == null && // (5)
!a.AssociationType.IsSelfReferencing() && // (6)
a.DeclaringEnd.IsOptional() && // (7)
a.NavigationProperties.All(n => n.GetConfiguration() == null))
// (8)
select new
{
EntityType = entityType,
MatchingAssociations = matchingAssociations.ToList(),
};
// Transform candidate entities into complex types
foreach (var candidate in candidates.ToList())
{
var complexType = model.AddComplexType(candidate.EntityType.Name, candidate.EntityType.NamespaceName);
foreach (var property in candidate.EntityType.DeclaredProperties)
{
complexType.AddMember(property);
}
foreach (var annotation in candidate.EntityType.Annotations)
{
complexType.Annotations.Add(annotation);
}
foreach (var association in candidate.MatchingAssociations)
{
foreach (var navigationProperty in association.NavigationProperties)
{
if (association.DeclaringEntityType.NavigationProperties.Contains(navigationProperty))
{
association.DeclaringEntityType.RemoveMember(navigationProperty);
var complexProperty
= association.DeclaringEntityType
.AddComplexProperty(navigationProperty.Name, complexType);
foreach (var annotation in navigationProperty.Annotations)
{
complexProperty.Annotations.Add(annotation);
}
}
}
model.RemoveAssociationType(association.AssociationType);
}
model.RemoveEntityType(candidate.EntityType);
}
}