public CsdlSemanticsPrimitiveTypeReference(CsdlSemanticsSchema schema, CsdlPrimitiveTypeReference reference)
: base(reference)
{
this.schema = schema;
this.Reference = reference;
this.definition = EdmCoreModel.Instance.GetPrimitiveType(this.Reference.Kind);
}
public void ParseCsdlEntityTypeWithMembersWorksAsExpected()
{
string json = @"""Supplier"": {
""$Kind"": ""EntityType"",
""$Key"": [
""ID""
],
""ID"": {},
""Name"": {
""$Nullable"": true
},
""Address"": {
""$Type"": ""self.Address""
},
""Concurrency"": {
""$Type"": ""Edm.Int32""
},
""Products"": {
""$Kind"": ""NavigationProperty"",
""$Partner"": ""Supplier"",
""$Collection"": true,
""$Type"": ""self.Product""
}
}";
CsdlEntityType entityType = ParseCsdlSchemaElement(json, SchemaJsonParser.ParseCsdlEntityType);
Assert.NotNull(entityType);
Assert.Equal("Supplier", entityType.Name);
Assert.False(entityType.IsAbstract);
Assert.False(entityType.IsOpen);
Assert.Null(entityType.BaseTypeName);
Assert.False(entityType.HasStream);
CsdlPropertyReference propertyRef = Assert.Single(entityType.Key.Properties);
Assert.Equal("ID", propertyRef.PropertyName);
Assert.Equal(4, entityType.StructuralProperties.Count());
// ID
CsdlProperty id = entityType.StructuralProperties.FirstOrDefault(p => p.Name == "ID");
Assert.NotNull(id);
CsdlStringTypeReference stringType = Assert.IsType <CsdlStringTypeReference>(id.Type);
Assert.False(stringType.IsUnbounded);
Assert.Null(stringType.IsUnicode);
Assert.Null(stringType.MaxLength);
Assert.False(stringType.IsNullable);
// Name
CsdlProperty name = entityType.StructuralProperties.FirstOrDefault(p => p.Name == "Name");
Assert.NotNull(name);
stringType = Assert.IsType <CsdlStringTypeReference>(name.Type);
Assert.True(stringType.IsNullable);
// Address
CsdlProperty address = entityType.StructuralProperties.FirstOrDefault(p => p.Name == "Address");
Assert.NotNull(address);
CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(address.Type);
Assert.Equal("self.Address", namedType.FullName);
// Concurrency
CsdlProperty concurrency = entityType.StructuralProperties.FirstOrDefault(p => p.Name == "Concurrency");
Assert.NotNull(concurrency);
CsdlPrimitiveTypeReference primitiveType = Assert.IsType <CsdlPrimitiveTypeReference>(concurrency.Type);
Assert.Equal(EdmPrimitiveTypeKind.Int32, primitiveType.Kind);
Assert.False(primitiveType.IsNullable);
// Products
CsdlNavigationProperty products = Assert.Single(entityType.NavigationProperties);
Assert.Equal("Products", products.Name);
Assert.Equal("Collection(self.Product)", products.Type);
Assert.Equal("Supplier", products.PartnerPath.Path);
}
public void ParseCsdlComplexTypeWithMembersWorksAsExpected()
{
string json = @"""CountRestrictionsType"": {
""$Kind"": ""ComplexType"",
""Countable"": {
""$Type"": ""Edm.Boolean"",
""$DefaultValue"": true,
""@Core.Description"": ""Entities can be counted (only valid if targeting an entity set)""
},
""NonCountableProperties"": {
""$Collection"": true,
""$Type"": ""Edm.PropertyPath"",
""@Core.Description"": ""Members of these collection properties cannot be counted""
},
""NonCountableNavigationProperties"": {
""$Collection"": true,
""$Type"": ""Edm.NavigationPropertyPath"",
""@Core.Description"": ""Members of these navigation properties cannot be counted""
}
}";
CsdlComplexType complexType = ParseCsdlSchemaElement(json, SchemaJsonParser.ParseCsdlComplexType);
Assert.NotNull(complexType);
Assert.Equal("CountRestrictionsType", complexType.Name);
Assert.False(complexType.IsAbstract);
Assert.False(complexType.IsOpen);
Assert.Null(complexType.BaseTypeName);
Assert.Empty(complexType.NavigationProperties);
Assert.Equal(3, complexType.StructuralProperties.Count());
// Countable
CsdlProperty countable = complexType.StructuralProperties.FirstOrDefault(p => p.Name == "Countable");
Assert.NotNull(countable);
CsdlPrimitiveTypeReference primitiveType = Assert.IsType <CsdlPrimitiveTypeReference>(countable.Type);
Assert.Equal(EdmPrimitiveTypeKind.Boolean, primitiveType.Kind);
Assert.Equal("true", countable.DefaultValue);
Assert.IsType <CsdlConstantExpression>(Assert.Single(countable.VocabularyAnnotations).Expression);
// NonCountableProperties
CsdlProperty nonCountable = complexType.StructuralProperties.FirstOrDefault(p => p.Name == "NonCountableProperties");
Assert.NotNull(nonCountable);
CsdlExpressionTypeReference expressionType = Assert.IsType <CsdlExpressionTypeReference>(nonCountable.Type);
CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(Assert.IsType <CsdlCollectionType>(expressionType.TypeExpression).ElementType);
Assert.Equal("Edm.PropertyPath", namedType.FullName);
Assert.Null(nonCountable.DefaultValue);
Assert.IsType <CsdlConstantExpression>(Assert.Single(nonCountable.VocabularyAnnotations).Expression);
// NonCountableNavigationProperties
CsdlProperty nonCountableNav = complexType.StructuralProperties.FirstOrDefault(p => p.Name == "NonCountableNavigationProperties");
Assert.NotNull(nonCountableNav);
expressionType = Assert.IsType <CsdlExpressionTypeReference>(nonCountableNav.Type);
namedType = Assert.IsType <CsdlNamedTypeReference>(Assert.IsType <CsdlCollectionType>(expressionType.TypeExpression).ElementType);
Assert.Equal("Edm.NavigationPropertyPath", namedType.FullName);
Assert.Null(nonCountableNav.DefaultValue);
Assert.IsType <CsdlConstantExpression>(Assert.Single(nonCountableNav.VocabularyAnnotations).Expression);
}
internal static IEdmTypeReference WrapTypeReference(CsdlSemanticsSchema schema, CsdlTypeReference type)
{
CsdlNamedTypeReference reference = type as CsdlNamedTypeReference;
if (reference != null)
{
CsdlPrimitiveTypeReference reference2 = reference as CsdlPrimitiveTypeReference;
if (reference2 != null)
{
switch (reference2.Kind)
{
case EdmPrimitiveTypeKind.Binary:
return(new CsdlSemanticsBinaryTypeReference(schema, (CsdlBinaryTypeReference)reference2));
case EdmPrimitiveTypeKind.Boolean:
case EdmPrimitiveTypeKind.Byte:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Guid:
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.SByte:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Stream:
return(new CsdlSemanticsPrimitiveTypeReference(schema, reference2));
case EdmPrimitiveTypeKind.DateTime:
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Time:
return(new CsdlSemanticsTemporalTypeReference(schema, (CsdlTemporalTypeReference)reference2));
case EdmPrimitiveTypeKind.Decimal:
return(new CsdlSemanticsDecimalTypeReference(schema, (CsdlDecimalTypeReference)reference2));
case EdmPrimitiveTypeKind.String:
return(new CsdlSemanticsStringTypeReference(schema, (CsdlStringTypeReference)reference2));
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
return(new CsdlSemanticsSpatialTypeReference(schema, (CsdlSpatialTypeReference)reference2));
}
}
return(new CsdlSemanticsNamedTypeReference(schema, reference));
}
CsdlExpressionTypeReference expressionUsage = type as CsdlExpressionTypeReference;
if (expressionUsage != null)
{
CsdlRowType typeExpression = expressionUsage.TypeExpression as CsdlRowType;
if (typeExpression != null)
{
return(new CsdlSemanticsRowTypeExpression(expressionUsage, new CsdlSemanticsRowTypeDefinition(schema, typeExpression)));
}
CsdlCollectionType collection = expressionUsage.TypeExpression as CsdlCollectionType;
if (collection != null)
{
return(new CsdlSemanticsCollectionTypeExpression(expressionUsage, new CsdlSemanticsCollectionTypeDefinition(schema, collection)));
}
CsdlEntityReferenceType entityTypeReference = expressionUsage.TypeExpression as CsdlEntityReferenceType;
if (entityTypeReference != null)
{
return(new CsdlSemanticsEntityReferenceTypeExpression(expressionUsage, new CsdlSemanticsEntityReferenceTypeDefinition(schema, entityTypeReference)));
}
}
return(null);
}
