private IEdmProperty CreateStructuralTypeEnumPropertyBody(EdmStructuredType type, StructuralTypeConfiguration config, EnumPropertyConfiguration enumProperty) { Type enumPropertyType = TypeHelper.GetUnderlyingTypeOrSelf(enumProperty.RelatedClrType); IEdmType edmType = GetEdmType(enumPropertyType); if (edmType == null) { throw Error.InvalidOperation(SRResources.EnumTypeDoesNotExist, enumPropertyType.Name); } IEdmEnumType enumType = (IEdmEnumType)edmType; IEdmTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, enumProperty.OptionalProperty); // Set concurrency token if is entity type, and concurrency token is true EdmConcurrencyMode enumConcurrencyMode = EdmConcurrencyMode.None; if (config.Kind == EdmTypeKind.Entity && enumProperty.ConcurrencyToken) { enumConcurrencyMode = EdmConcurrencyMode.Fixed; } return(type.AddStructuralProperty( enumProperty.Name, enumTypeReference, defaultValue: null, concurrencyMode: enumConcurrencyMode)); }
public static void SetSearchRestrictionsCapabilitiesAnnotation(this EdmModel model, IEdmEntitySet entitySet, bool searchable, CapabilitiesSearchExpressions unsupported) { if (model == null) { throw new ArgumentNullException("model"); } if (entitySet == null) { throw new ArgumentNullException("entitySet"); } var target = entitySet; var term = SearchRestrictionsTerm; var name = new EdmEnumTypeReference(SearchExpressionsType, false).ToStringLiteral((long)unsupported); var properties = new IEdmPropertyConstructor[] { new EdmPropertyConstructor("Searchable", new EdmBooleanConstant(searchable)), new EdmPropertyConstructor("UnsupportedExpressions", new EdmEnumMemberReferenceExpression(SearchExpressionsType.Members.Single(m => m.Name == name))), }; var record = new EdmRecordExpression(properties); var annotation = new EdmAnnotation(target, term, record); annotation.SetSerializationLocation(model, entitySet.ToSerializationLocation()); model.AddVocabularyAnnotation(annotation); }
public void CreateODataCollectionValue_CanSerialize_IEdmObjects() { // Arrange Mock <IEdmEnumObject> edmEnumObject = new Mock <IEdmEnumObject>(); IEdmEnumObject[] collection = { edmEnumObject.Object }; ODataSerializerContext serializerContext = new ODataSerializerContext(); IEdmEnumTypeReference elementType = new EdmEnumTypeReference(new EdmEnumType("NS", "EnumType"), isNullable: true); edmEnumObject.Setup(s => s.GetEdmType()).Returns(elementType); Mock <ODataSerializerProvider> serializerProvider = new Mock <ODataSerializerProvider>(); Mock <ODataEnumSerializer> elementSerializer = new Mock <ODataEnumSerializer>(MockBehavior.Strict, serializerProvider.Object); serializerProvider.Setup(s => s.GetEdmTypeSerializer(elementType)).Returns(elementSerializer.Object); elementSerializer.Setup(s => s.CreateODataEnumValue(collection[0], elementType, serializerContext)).Returns(new ODataEnumValue("1", "NS.EnumType")).Verifiable(); ODataCollectionSerializer serializer = new ODataCollectionSerializer(serializerProvider.Object); // Act serializer.CreateODataCollectionValue(collection, elementType, serializerContext); // Assert elementSerializer.Verify(); }
public void ParseWithCustomFunction_EnumParameter() { try { var enumType = new EdmEnumType("Fully.Qualified.Namespace", "NonFlagShape", EdmPrimitiveTypeKind.SByte, false); enumType.AddMember("Rectangle", new EdmEnumMemberValue(1)); enumType.AddMember("Triangle", new EdmEnumMemberValue(2)); enumType.AddMember("foursquare", new EdmEnumMemberValue(3)); var enumTypeRef = new EdmEnumTypeReference(enumType, false); FunctionSignatureWithReturnType signature = new FunctionSignatureWithReturnType(EdmCoreModel.Instance.GetBoolean(false), enumTypeRef); CustomUriFunctions.AddCustomUriFunction("enumFunc", signature); var fullUri = new Uri("http://www.odata.com/OData/People" + "?$filter=enumFunc('Rectangle')"); ODataUriParser parser = new ODataUriParser(HardCodedTestModel.TestModel, new Uri("http://www.odata.com/OData/"), fullUri); var enumFuncWithArgs = parser.ParseFilter().Expression.ShouldBeSingleValueFunctionCallQueryNode("enumFunc").Parameters.ToList(); enumFuncWithArgs[0].ShouldBeEnumNode(enumType, "Rectangle"); } finally { Assert.True(CustomUriFunctions.RemoveCustomUriFunction("enumFunc")); } }
public async Task WriteItemAsync_WritesEnumCollectionItem(string enumValue, string expected) { var model = new EdmModel(); var colorEnumType = new EdmEnumType("NS", "Color"); colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "Black", new EdmEnumMemberValue(0))); colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "White", new EdmEnumMemberValue(0))); model.AddElement(colorEnumType); var collectionStart = new ODataCollectionStart { SerializationInfo = new ODataCollectionStartSerializationInfo { CollectionTypeName = "Collection(NS.Color)" } }; var itemTypeReference = new EdmEnumTypeReference(colorEnumType, true); var result = await SetupJsonLightCollectionWriterAndRunTestAsync( async (jsonLightCollectionWriter) => { await jsonLightCollectionWriter.WriteStartAsync(collectionStart); await jsonLightCollectionWriter.WriteItemAsync(new ODataEnumValue(enumValue)); await jsonLightCollectionWriter.WriteEndAsync(); }, model, itemTypeReference); Assert.Equal("{\"@odata.context\":\"http://odata.org/test/$metadata#Collection(NS.Color)\"," + $"\"value\":[{expected}]}}", result); }
private static object ConvertEnumValue(ODataEnumValue enumValue, ref IEdmTypeReference propertyType, IODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext) { IEdmEnumTypeReference edmEnumType; if (propertyType == null) { // dynamic enum property Contract.Assert(!String.IsNullOrEmpty(enumValue.TypeName), "ODataLib should have verified that dynamic enum value has a type name since we provided metadata."); IEdmModel model = readContext.Model; IEdmType edmType = model.FindType(enumValue.TypeName); Contract.Assert(edmType.TypeKind == EdmTypeKind.Enum, "ODataLib should have verified that enum value has a enum resource type."); edmEnumType = new EdmEnumTypeReference(edmType as IEdmEnumType, isNullable: true); propertyType = edmEnumType; } else { edmEnumType = propertyType.AsEnum(); } IODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(edmEnumType); return(deserializer.ReadInline(enumValue, propertyType, readContext)); }
public void CreateEdmTypeSchemaReturnSchemaForEnumType(bool isNullable) { // Arrange IEdmModel model = EdmModelHelper.TripServiceModel; IEdmEnumType enumType = model.SchemaElements.OfType <IEdmEnumType>().First(c => c.Name == "PersonGender"); Assert.NotNull(enumType); // guard IEdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, isNullable); ODataContext context = new ODataContext(model); // Act var schema = context.CreateEdmTypeSchema(enumTypeReference); // & Assert Assert.NotNull(schema); Assert.Equal(isNullable, schema.Nullable); Assert.Null(schema.Reference); Assert.NotNull(schema.AnyOf); Assert.NotEmpty(schema.AnyOf); var anyOf = Assert.Single(schema.AnyOf); Assert.NotNull(anyOf.Reference); Assert.Equal(ReferenceType.Schema, anyOf.Reference.Type); Assert.Equal(enumType.FullTypeName(), anyOf.Reference.Id); }
public static IEdmTypeReference GetEdmTypeReference(this IEdmModel edmModel, Type clrType) { IEdmTypeReference edmTypeRef; bool nullable; Type underlyingType = Nullable.GetUnderlyingType(clrType); if (underlyingType == null) { nullable = clrType.IsClass; } else { clrType = underlyingType; nullable = true; } IEdmPrimitiveType primitiveEdmType = PrimitiveTypeHelper.GetPrimitiveType(clrType); if (primitiveEdmType == null) { var edmEnumType = (IEdmEnumType)edmModel.FindType(clrType.FullName); edmTypeRef = new EdmEnumTypeReference(edmEnumType, nullable); } else { edmTypeRef = EdmCoreModel.Instance.GetPrimitive(primitiveEdmType.PrimitiveKind, nullable); } return(edmTypeRef); }
public void CreateCollectionWriterWithEnumAsItemType() { var writer = new ODataMessageWriter(new DummyRequestMessage()); var entityElementType = new EdmEnumTypeReference(new EdmEnumType("FakeNS", "FakeEnum"), true); var collectionWriter = writer.CreateODataCollectionWriter(entityElementType); Assert.True(collectionWriter != null, "CreateODataCollectionWriter with enum item type failed."); }
private static void VerifyEnumVsStringFilterExpressionReverse(FilterClause filter) { var enumtypeRef = new EdmEnumTypeReference(UriEdmHelpers.FindEnumTypeFromModel(HardCodedTestModel.TestModel, "Fully.Qualified.Namespace.ColorPattern"), true); var bin = filter.Expression.ShouldBeBinaryOperatorNode(BinaryOperatorKind.Equal).And; bin.Right.ShouldBeSingleValuePropertyAccessQueryNode(HardCodedTestModel.GetPet2PetColorPatternProperty()); bin.Left.ShouldBeEnumNode(new ODataEnumValue("2", enumtypeRef.ODataFullName())); }
private EdmStructuralProperty?BuildStructuralProperty(Dictionary <Type, EntityTypeInfo> entityTypes, Dictionary <Type, EdmEnumType> enumTypes, Dictionary <Type, EdmComplexType> complexTypes, PropertyInfo clrProperty) { bool isNullable = !_metadataProvider.IsRequired(clrProperty); IEdmTypeReference?typeRef = PrimitiveTypeHelper.GetPrimitiveTypeRef(clrProperty, isNullable); if (typeRef == null) { Type?underlyingType = null; if (clrProperty.PropertyType.IsEnum || (underlyingType = Nullable.GetUnderlyingType(clrProperty.PropertyType)) != null && underlyingType.IsEnum) { Type clrPropertyType = underlyingType ?? clrProperty.PropertyType; if (!enumTypes.TryGetValue(clrPropertyType, out EdmEnumType? edmEnumType)) { edmEnumType = OeEdmModelBuilder.CreateEdmEnumType(clrPropertyType); enumTypes.Add(clrPropertyType, edmEnumType); } typeRef = new EdmEnumTypeReference(edmEnumType, underlyingType != null); } else { if (complexTypes.TryGetValue(clrProperty.PropertyType, out EdmComplexType? edmComplexType)) { typeRef = new EdmComplexTypeReference(edmComplexType, clrProperty.PropertyType.IsClass); } else { FKeyInfo?fkeyInfo = FKeyInfo.Create(_metadataProvider, entityTypes, this, clrProperty); if (fkeyInfo != null) { _navigationClrProperties.Add(fkeyInfo); } return(null); } } } else { if (clrProperty.PropertyType == typeof(DateTime?) && enumTypes.ContainsKey(typeof(DateTime?))) { var edmType = enumTypes[typeof(DateTime?)]; typeRef = new EdmEnumTypeReference(edmType, true); } } EdmStructuralProperty edmProperty = clrProperty is Infrastructure.OeShadowPropertyInfo ? new OeEdmStructuralShadowProperty(EdmType, clrProperty.Name, typeRef, clrProperty) : new EdmStructuralProperty(EdmType, clrProperty.Name, typeRef); EdmType.AddProperty(edmProperty); if (_metadataProvider.IsKey(clrProperty)) { _keyProperties.Add(new KeyValuePair <PropertyInfo, EdmStructuralProperty>(clrProperty, edmProperty)); } return(edmProperty); }
public void CloneForEnumTypeShouldBeExpect(bool nullable) { EdmEnumType enumType = new EdmEnumType("NS", "MyEnum"); EdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, isNullable: nullable); IEdmTypeReference clonedType = enumTypeReference.Clone(nullable); Assert.IsType <EdmEnumTypeReference>(clonedType); Assert.Equal(nullable, clonedType.IsNullable); }
public void CloneForEnumTypeShouldBeExpect(bool nullable) { EdmEnumType enumType = new EdmEnumType("NS", "MyEnum"); EdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, isNullable: nullable); IEdmTypeReference clonedType = enumTypeReference.Clone(nullable); clonedType.Should().BeOfType <EdmEnumTypeReference>(); clonedType.IsNullable.Should().Be(nullable); }
private void BuildProperty(Dictionary <Type, EntityTypeInfo> entityTypes, Dictionary <Type, EdmEnumType> enumTypes, Dictionary <Type, EdmComplexType> complexTypes, PropertyDescriptor clrProperty) { IEdmTypeReference typeRef = PrimitiveTypeHelper.GetPrimitiveTypeRef(clrProperty); if (typeRef == null) { EdmEnumType edmEnumType; Type underlyingType = null; if (clrProperty.PropertyType.GetTypeInfo().IsEnum || (underlyingType = Nullable.GetUnderlyingType(clrProperty.PropertyType)) != null && underlyingType.GetTypeInfo().IsEnum) { Type clrPropertyType = underlyingType ?? clrProperty.PropertyType; if (!enumTypes.TryGetValue(clrPropertyType, out edmEnumType)) { edmEnumType = CreateEdmEnumType(clrPropertyType); enumTypes.Add(clrPropertyType, edmEnumType); } typeRef = new EdmEnumTypeReference(edmEnumType, underlyingType != null); } else { EdmComplexType edmComplexType; if (complexTypes.TryGetValue(clrProperty.PropertyType, out edmComplexType)) { typeRef = new EdmComplexTypeReference(edmComplexType, clrProperty.PropertyType.GetTypeInfo().IsClass); } else { FKeyInfo fkeyInfo = FKeyInfo.Create(_metadataProvider, entityTypes, this, clrProperty); if (fkeyInfo != null) { _navigationClrProperties.Add(fkeyInfo); } return; } } } else { if (clrProperty.PropertyType == typeof(DateTime?) && enumTypes.ContainsKey(typeof(DateTime?))) //zzz { var edmType = enumTypes[typeof(DateTime?)]; typeRef = new EdmEnumTypeReference(edmType, true); } } var edmProperty = new EdmStructuralProperty(_edmType, clrProperty.Name, typeRef); _edmType.AddProperty(edmProperty); if (_metadataProvider.IsKey(clrProperty)) { _keyProperties.Add(new KeyValuePair <PropertyDescriptor, EdmStructuralProperty>(clrProperty, edmProperty)); } }
public ODataAtomReaderEnumIntegrationTests() { this.userModel = new EdmModel(); // enum without flags var enumType = new EdmEnumType("NS", "Color"); var red = new EdmEnumMember(enumType, "Red", new EdmIntegerConstant(1)); enumType.AddMember(red); enumType.AddMember("Green", new EdmIntegerConstant(2)); enumType.AddMember("Blue", new EdmIntegerConstant(3)); this.userModel.AddElement(enumType); // enum with flags var enumFlagsType = new EdmEnumType("NS", "ColorFlags", isFlags: true); enumFlagsType.AddMember("Red", new EdmIntegerConstant(1)); enumFlagsType.AddMember("Green", new EdmIntegerConstant(2)); enumFlagsType.AddMember("Blue", new EdmIntegerConstant(4)); this.userModel.AddElement(enumFlagsType); this.entityType = new EdmEntityType("NS", "MyEntityType", isAbstract: false, isOpen: true, baseType: null); EdmStructuralProperty floatId = new EdmStructuralProperty(this.entityType, "FloatId", EdmCoreModel.Instance.GetSingle(false)); this.entityType.AddKeys(floatId); this.entityType.AddProperty(floatId); var enumTypeReference = new EdmEnumTypeReference(enumType, true); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "Color", enumTypeReference)); var enumFlagsTypeReference = new EdmEnumTypeReference(enumFlagsType, false); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "ColorFlags", enumFlagsTypeReference)); // enum in complex type EdmComplexType myComplexType = new EdmComplexType("NS", "MyComplexType"); myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "MyColorFlags", enumFlagsTypeReference)); myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "Height", EdmCoreModel.Instance.GetDouble(false))); this.userModel.AddElement(myComplexType); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyComplexType", new EdmComplexTypeReference(myComplexType, true))); // enum in collection type EdmCollectionType myCollectionType = new EdmCollectionType(enumFlagsTypeReference); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyCollectionType", new EdmCollectionTypeReference(myCollectionType))); this.userModel.AddElement(this.entityType); var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer"); this.entitySet = new EdmEntitySet(defaultContainer, "MySet", this.entityType); defaultContainer.AddEntitySet(this.entitySet.Name, this.entityType); this.userModel.AddElement(defaultContainer); }
public void CreateEdmTypeSchemaReturnSchemaForEnumType(bool isNullable, OpenApiSpecVersion specVersion) { // Arrange IEdmModel model = EdmModelHelper.TripServiceModel; IEdmEnumType enumType = model.SchemaElements.OfType <IEdmEnumType>().First(c => c.Name == "PersonGender"); Assert.NotNull(enumType); // guard IEdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, isNullable); ODataContext context = new ODataContext(model); context.Settings.OpenApiSpecVersion = specVersion; // Act var schema = context.CreateEdmTypeSchema(enumTypeReference); // & Assert Assert.NotNull(schema); if (specVersion == OpenApiSpecVersion.OpenApi2_0) { Assert.NotNull(schema.Reference); Assert.Null(schema.AnyOf); Assert.Equal(ReferenceType.Schema, schema.Reference.Type); Assert.Equal(enumType.FullTypeName(), schema.Reference.Id); Assert.Equal(isNullable, schema.Nullable); } else { if (isNullable) { Assert.NotNull(schema.AnyOf); Assert.NotEmpty(schema.AnyOf); Assert.Null(schema.Reference); Assert.Equal(2, schema.AnyOf.Count); var anyOfRef = schema.AnyOf.FirstOrDefault(); Assert.NotNull(anyOfRef.Reference); Assert.Equal(ReferenceType.Schema, anyOfRef.Reference.Type); Assert.Equal(enumType.FullTypeName(), anyOfRef.Reference.Id); var anyOfNull = schema.AnyOf.Skip(1).FirstOrDefault(); Assert.NotNull(anyOfNull.Type); Assert.Equal("object", anyOfNull.Type); Assert.True(anyOfNull.Nullable); } else { Assert.Null(schema.AnyOf); Assert.NotNull(schema.Reference); Assert.Equal(ReferenceType.Schema, schema.Reference.Type); Assert.Equal(enumType.FullTypeName(), schema.Reference.Id); } } }
public void GetEdmType_Returns_EdmTypeInitializedByCtor() { // Arrange IEdmTypeReference elementType = new EdmEnumTypeReference(new EdmEnumType("NS", "Enum"), isNullable: false); IEdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType)); // Act var edmObject = new EdmEnumObjectCollection(collectionType); // Assert Assert.Same(collectionType, edmObject.GetEdmType()); }
public void GetEdmTypeDeserializer_ReturnODataEnumDeserializer_ForEnumType() { // Arrange IEdmTypeReference edmType = new EdmEnumTypeReference(new EdmEnumType("TestModel", "Color"), isNullable: false); // Act ODataEdmTypeDeserializer deserializer = _deserializerProvider.GetEdmTypeDeserializer(edmType); // Assert Assert.NotNull(deserializer); Assert.IsType <ODataEnumDeserializer>(deserializer); }
public static IEdmModel InterfaceCriticalKindValueMismatchOnlyUsingEnumTypeReferenceModel() { var model = new EdmModel(); var badType = new CustomEnumType("NS", "Enum", EdmTypeKind.Complex); var badTypeRef = new EdmEnumTypeReference(badType, true); var valueTerm = new EdmTerm("NS", "Note", badTypeRef); model.AddElement(valueTerm); return(model); }
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingEnumTypeReferenceModel() { var model = new EdmModel(); var badType = new CustomEnumType("NS", "Enum", (IEdmPrimitiveType)null); var badTypeRef = new EdmEnumTypeReference(badType, true); var valueTerm = new EdmTerm("NS", "Note", badTypeRef); model.AddElement(valueTerm); return(model); }
public void GetODataSerializer_Enum() { var serializerProvider = new DefaultODataSerializerProvider(_edmModel); IEdmTypeReference edmEnumType = new EdmEnumTypeReference(new EdmEnumType("ODataDemo", "SupplierRating"), isNullable: false); var serializer = serializerProvider.GetEdmTypeSerializer(edmEnumType); Assert.NotNull(serializer); var enumSerializer = Assert.IsType <ODataEnumSerializer>(serializer); Assert.Equal(enumSerializer.EdmType, edmEnumType); Assert.Equal(enumSerializer.ODataPayloadKind, ODataPayloadKind.Property); Assert.Equal(enumSerializer.SerializerProvider, serializerProvider); }
public async Task WriteEnumValueAsync_WritesNullForEnumValueAsNull() { var colorEnumValue = new ODataEnumValue(null); var colorEdmEnumTypeReference = new EdmEnumTypeReference(this.colorEnumType, false); var result = await SetupJsonLightValueSerializerAndRunTestAsync( (jsonLightValueSerializer) => { return(jsonLightValueSerializer.WriteEnumValueAsync(colorEnumValue, colorEdmEnumTypeReference)); }); Assert.Equal("null", result); }
public static IEdmModel InterfaceCriticalPropertyValueMustNotBeNullUsingEnumMemberDeclaredTypeModel() { var model = new EdmModel(); var enumType = new EdmEnumType("NS", "Enum"); enumType.AddMember(new CustomEnumMember(null, "foo", new EdmIntegerConstant(5))); var enumTypeRef = new EdmEnumTypeReference(enumType, true); var valueTerm = new EdmTerm("NS", "Note", enumTypeRef); model.AddElement(valueTerm); return(model); }
/// <summary> /// Set Org.OData.Capabilities.V1.NavigationRestrictions to target. /// </summary> /// <param name="model">The model referenced to.</param> /// <param name="target">The target entity set to set the inline annotation.</param> /// <param name="navigability">This entity set supports navigability.</param> /// <param name="restrictedProperties">These properties have navigation restrictions on.</param> public static void SetNavigationRestrictionsAnnotation(this EdmModel model, IEdmEntitySet target, CapabilitiesNavigationType navigability, IEnumerable <Tuple <IEdmNavigationProperty, CapabilitiesNavigationType> > restrictedProperties) { if (model == null) { throw Error.ArgumentNull("model"); } if (target == null) { throw Error.ArgumentNull("target"); } IEdmEnumType navigationType = model.GetCapabilitiesNavigationType(); if (navigationType == null) { return; } restrictedProperties = restrictedProperties ?? new Tuple <IEdmNavigationProperty, CapabilitiesNavigationType> [0]; string type = new EdmEnumTypeReference(navigationType, false).ToStringLiteral((long)navigability); IEnumerable <EdmRecordExpression> propertiesExpression = restrictedProperties.Select(p => { var name = new EdmEnumTypeReference(navigationType, false).ToStringLiteral((long)p.Item2); return(new EdmRecordExpression(new IEdmPropertyConstructor[] { new EdmPropertyConstructor( CapabilitiesVocabularyConstants.NavigationPropertyRestrictionNavigationProperty, new EdmNavigationPropertyPathExpression(p.Item1.Name)), new EdmPropertyConstructor(CapabilitiesVocabularyConstants.NavigationRestrictionsNavigability, new EdmEnumMemberReferenceExpression(navigationType.Members.Single(m => m.Name == name))) })); }); IList <IEdmPropertyConstructor> properties = new List <IEdmPropertyConstructor> { new EdmPropertyConstructor(CapabilitiesVocabularyConstants.NavigationRestrictionsNavigability, new EdmEnumMemberReferenceExpression( navigationType.Members.Single(m => m.Name == type))), new EdmPropertyConstructor(CapabilitiesVocabularyConstants.NavigationRestrictionsRestrictedProperties, new EdmCollectionExpression(propertiesExpression)) }; model.SetVocabularyAnnotation(target, properties, CapabilitiesVocabularyConstants.NavigationRestrictions); }
public void AddTypeNameAnnotationAsNeeded_DoesNotAddAnnotation() { // Arrange ODataEnumValue enumValue = new ODataEnumValue("value"); IEdmEnumTypeReference enumType = new EdmEnumTypeReference( new EdmEnumType("TestModel", "EnumType"), isNullable: false); // Act ODataEnumSerializer.AddTypeNameAnnotationAsNeeded(enumValue, enumType, ODataMetadataLevel.Minimal); // Assert ODataTypeAnnotation annotation = enumValue.TypeAnnotation; Assert.Null(annotation); }
public void CreateODataValue_RetrunsNull_IfGraphNull() { // Arrange ODataSerializerContext writeContext = new ODataSerializerContext(); ODataSerializerProvider provider = new Mock <ODataSerializerProvider>().Object; ODataEnumSerializer serializer = new ODataEnumSerializer(provider); IEdmEnumType enumType = new EdmEnumType("NS", "Enum"); IEdmTypeReference expectedType = new EdmEnumTypeReference(enumType, false); // Act ODataValue actual = serializer.CreateODataValue(graph: null, expectedType: expectedType, writeContext); // Assert Assert.IsType <ODataNullValue>(actual); }
internal static bool TryBindIdentifier(string identifier, IEdmModel model, out QueryNode boundEnum) { boundEnum = null; string text = identifier; // parse the string, e.g., NS.Color'Green' // get type information, and also convert Green into an ODataEnumValue // find the first ', before that, it is namespace.type int indexOfSingleQuote = text.IndexOf('\''); if (indexOfSingleQuote < 0) { return(false); } string namespaceAndType = text.Substring(0, indexOfSingleQuote); // find the type from edm model IEdmEnumType enumType = UriEdmHelpers.FindEnumTypeFromModel(model, namespaceAndType); if (enumType == null) { return(false); } // now, find out the value UriPrimitiveTypeParser.TryRemovePrefix(namespaceAndType, ref text); UriPrimitiveTypeParser.TryRemoveQuotes(ref text); // parse string or int value to edm enum value string enumValueString = text; ODataEnumValue enumValue; enumType.TryParseEnum(enumValueString, out enumValue); if (enumValue == null) { return(false); } // create an enum node, enclosing an odata enum value EdmEnumTypeReference enumTypeReference = new EdmEnumTypeReference(enumType, false); boundEnum = new ConstantNode(enumValue, identifier, enumTypeReference); return(true); }
private IEdmProperty CreateStructuralTypeCollectionPropertyBody(EdmStructuredType type, CollectionPropertyConfiguration collectionProperty) { IEdmTypeReference elementTypeReference = null; Type clrType = TypeHelper.GetUnderlyingTypeOrSelf(collectionProperty.ElementType); if (clrType.GetTypeInfo().IsEnum) { IEdmType edmType = GetEdmType(clrType); if (edmType == null) { throw Error.InvalidOperation(SRResources.EnumTypeDoesNotExist, clrType.Name); } IEdmEnumType enumElementType = (IEdmEnumType)edmType; bool isNullable = collectionProperty.ElementType != clrType; elementTypeReference = new EdmEnumTypeReference(enumElementType, isNullable); } else { IEdmType edmType = GetEdmType(collectionProperty.ElementType); if (edmType != null) { IEdmComplexType elementType = edmType as IEdmComplexType; // Work around for primitive types (ex: Int32 would be typed to System.Int32 instead of EdmInt) if (elementType != null) { elementTypeReference = new EdmComplexTypeReference(elementType, collectionProperty.OptionalProperty); } else { elementTypeReference = EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(collectionProperty.ElementType); } } else { elementTypeReference = EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(collectionProperty.ElementType); } Contract.Assert(elementTypeReference != null); } return(type.AddStructuralProperty( collectionProperty.Name, new EdmCollectionTypeReference(new EdmCollectionType(elementTypeReference)))); }
public void AddTypeNameAnnotationAsNeeded_AddsNullAnnotation_InNoMetadataMode() { // Arrange ODataEnumValue enumValue = new ODataEnumValue("value"); IEdmEnumTypeReference enumType = new EdmEnumTypeReference( new EdmEnumType("TestModel", "EnumType"), isNullable: false); // Act ODataEnumSerializer.AddTypeNameAnnotationAsNeeded(enumValue, enumType, ODataMetadataLevel.NoMetadata); // Assert SerializationTypeNameAnnotation annotation = enumValue.GetAnnotation <SerializationTypeNameAnnotation>(); Assert.NotNull(annotation); Assert.Null(annotation.TypeName); }
public void AddTypeNameAnnotationAsNeeded_AddAnnotation_InFullMetadataMode() { // Arrange ODataEnumValue enumValue = new ODataEnumValue("value"); IEdmEnumTypeReference enumType = new EdmEnumTypeReference( new EdmEnumType("TestModel", "EnumType"), isNullable: false); // Act ODataEnumSerializer.AddTypeNameAnnotationAsNeeded(enumValue, enumType, ODataMetadataLevel.Full); // Assert ODataTypeAnnotation annotation = enumValue.TypeAnnotation; Assert.NotNull(annotation); Assert.Equal("TestModel.EnumType", annotation.TypeName); }