static ODataResourceTypeContextTests() { Model = new EdmModel(); EntitySetElementType = new EdmEntityType("ns", "Customer"); ExpectedEntityType = new EdmEntityType("ns", "VipCustomer", EntitySetElementType); ActualEntityType = new EdmEntityType("ns", "DerivedVipCustomer", ExpectedEntityType); ComplexType = new EdmComplexType("ns", "Address"); EdmEntityContainer defaultContainer = new EdmEntityContainer("ns", "DefaultContainer"); Model.AddElement(defaultContainer); EntitySet = new EdmEntitySet(defaultContainer, "Customers", EntitySetElementType); Model.AddElement(EntitySetElementType); Model.AddElement(ExpectedEntityType); Model.AddElement(ActualEntityType); defaultContainer.AddElement(EntitySet); SerializationInfo = new ODataResourceSerializationInfo { NavigationSourceName = "MyCustomers", NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer" }; SerializationInfoWithEdmUnknowEntitySet = new ODataResourceSerializationInfo() { NavigationSourceName = null, NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer", NavigationSourceKind = EdmNavigationSourceKind.UnknownEntitySet }; TypeContextWithoutModel = ODataResourceTypeContext.Create(SerializationInfo, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: true); TypeContextWithModel = ODataResourceTypeContext.Create(/*serializationInfo*/ null, EntitySet, EntitySetElementType, ExpectedEntityType, throwIfMissingTypeInfo: true); TypeContextWithEdmUnknowEntitySet = ODataResourceTypeContext.Create(SerializationInfoWithEdmUnknowEntitySet, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: true); BaseTypeContextThatThrows = ODataResourceTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: true); BaseTypeContextThatWillNotThrow = ODataResourceTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: false); }
public void GetFirstNonTypeCastSegment_WorksForExpandPathWithPropertySegment() { // Arrange EdmEntityType entityType = new EdmEntityType("NS", "Customer"); IEdmStructuralProperty property = entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.String); var navProperty = entityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Nav", Target = entityType, TargetMultiplicity = EdmMultiplicity.One }); EdmEntityContainer container = new EdmEntityContainer("NS", "Container"); EdmEntitySet set = new EdmEntitySet(container, "set", entityType); NavigationPropertySegment navSegment = new NavigationPropertySegment(navProperty, set); TypeSegment typeSegment = new TypeSegment(entityType, null); ODataPathSegment propertySegment = new PropertySegment(property); ODataExpandPath expandPath = new ODataExpandPath(typeSegment, propertySegment, navSegment); // Act IList<ODataPathSegment> remainingSegments; ODataPathSegment firstNonTypeSegment = expandPath.GetFirstNonTypeCastSegment(out remainingSegments); // Assert Assert.NotNull(firstNonTypeSegment); Assert.Same(propertySegment, firstNonTypeSegment); Assert.NotNull(remainingSegments); Assert.Same(navSegment, Assert.Single(remainingSegments)); }
private string WriterEntry(IEdmModel userModel, ODataEntry entry, EdmEntitySet entitySet, IEdmEntityType entityType, bool fullMetadata = false) { var message = new InMemoryMessage() { Stream = new MemoryStream() }; var writerSettings = new ODataMessageWriterSettings { DisableMessageStreamDisposal = true, AutoComputePayloadMetadataInJson = true }; writerSettings.SetContentType(ODataFormat.Json); writerSettings.SetServiceDocumentUri(new Uri("http://www.example.com")); writerSettings.SetContentType(fullMetadata ? "application/json;odata.metadata=full;odata.streaming=false" : "application/json;odata.metadata=minimal;odata.streaming=false", "utf-8"); using (var msgReader = new ODataMessageWriter((IODataResponseMessage)message, writerSettings, userModel)) { var writer = msgReader.CreateODataEntryWriter(entitySet, entityType); writer.WriteStart(entry); writer.WriteEnd(); } message.Stream.Seek(0, SeekOrigin.Begin); using (StreamReader reader = new StreamReader(message.Stream)) { return(reader.ReadToEnd()); } }
public ODataJsonLightEntryAndFeedSerializerUndeclaredTests() { this.serverModel = new EdmModel(); var addressType = new EdmComplexType("Server.NS", "Address"); addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String); this.serverModel.AddElement(addressType); // non-open entity type this.serverEntityType = new EdmEntityType("Server.NS", "ServerEntityType"); this.serverModel.AddElement(this.serverEntityType); this.serverEntityType.AddKeys(this.serverEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); this.serverEntityType.AddStructuralProperty("Address", new EdmComplexTypeReference(addressType, true)); // open entity type this.serverOpenEntityType = new EdmEntityType("Server.NS", "ServerOpenEntityType", baseType: null, isAbstract: false, isOpen: true); this.serverModel.AddElement(this.serverOpenEntityType); this.serverOpenEntityType.AddKeys(this.serverOpenEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); this.serverOpenEntityType.AddStructuralProperty("Address", new EdmComplexTypeReference(addressType, true)); EdmEntityContainer container = new EdmEntityContainer("Server.NS", "container1"); this.serverEntitySet = container.AddEntitySet("serverEntitySet", this.serverEntityType); this.serverOpenEntitySet = container.AddEntitySet("serverOpenEntitySet", this.serverOpenEntityType); this.serverModel.AddElement(container); }
public void VerifyAnnotationComputedConcurrency() { var model = new EdmModel(); var entity = new EdmEntityType("NS1", "Product"); var entityId = entity.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false)); entity.AddKeys(entityId); EdmStructuralProperty name1 = entity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false)); EdmStructuralProperty timeVer = entity.AddStructuralProperty("UpdatedTime", EdmCoreModel.Instance.GetDate(false)); model.AddElement(entity); SetComputedAnnotation(model, entityId); // semantic meaning is V3's 'Identity' for Key profperty SetComputedAnnotation(model, timeVer); // semantic meaning is V3's 'Computed' for non-key profperty var entityContainer = new EdmEntityContainer("NS1", "Container"); model.AddElement(entityContainer); EdmEntitySet set1 = new EdmEntitySet(entityContainer, "Products", entity); model.SetOptimisticConcurrencyAnnotation(set1, new IEdmStructuralProperty[] { entityId, timeVer }); entityContainer.AddElement(set1); string csdlStr = GetEdmx(model, EdmxTarget.OData); Assert.AreEqual(@"<?xml version=""1.0"" encoding=""utf-16""?><edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx""><edmx:DataServices><Schema Namespace=""NS1"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""><EntityType Name=""Product""><Key><PropertyRef Name=""Id"" /></Key><Property Name=""Id"" Type=""Edm.Int32"" Nullable=""false""><Annotation Term=""Org.OData.Core.V1.Computed"" Bool=""true"" /></Property><Property Name=""Name"" Type=""Edm.String"" Nullable=""false"" /><Property Name=""UpdatedTime"" Type=""Edm.Date"" Nullable=""false""><Annotation Term=""Org.OData.Core.V1.Computed"" Bool=""true"" /></Property></EntityType><EntityContainer Name=""Container""><EntitySet Name=""Products"" EntityType=""NS1.Product""><Annotation Term=""Org.OData.Core.V1.OptimisticConcurrency""><Collection><PropertyPath>Id</PropertyPath><PropertyPath>UpdatedTime</PropertyPath></Collection></Annotation></EntitySet></EntityContainer></Schema></edmx:DataServices></edmx:Edmx>", csdlStr); }
private static IEdmModel GetEdmModel() { EdmModel _builder = new EdmModel(); // Create Car Entity EdmEntityType car = new EdmEntityType("Part12.Models", "Car"); car.AddKeys(car.AddStructuralProperty("Make", EdmPrimitiveTypeKind.String), car.AddStructuralProperty("Model", EdmPrimitiveTypeKind.String)); car.AddStructuralProperty("Colour", EdmPrimitiveTypeKind.String); car.AddStructuralProperty("Price", EdmPrimitiveTypeKind.Double); var cat = car.AddStructuralProperty("Category", EdmPrimitiveTypeKind.String, false); _builder.AddAlternateKeyAnnotation(car, new Dictionary <string, IEdmProperty> { { "Category", cat } }); _builder.AddElement(car); // Create Container EdmEntityContainer container = new EdmEntityContainer("default", "Container"); // Add the Cars Entity into the Container EdmEntitySet cars = container.AddEntitySet("Cars", car); _builder.AddElement(container); return(_builder); }
public void Init() { this.clientEdmModel = new ClientEdmModel(ODataProtocolVersion.V4); this.entityDescriptor = new EntityDescriptor(this.clientEdmModel) { Entity = new Customer() }; var serverType = new EdmEntityType("FQ.NS", "MyServerType"); serverType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Navigation", Target = serverType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne }); this.serverTypeName = ((IEdmSchemaElement)serverType).FullName(); var serverContainer = new EdmEntityContainer("FQ.NS", "MyContainer"); this.serverEntitySet = serverContainer.AddEntitySet("MyEntitySet", serverType); var serverModel = new EdmModel(); serverModel.AddElement(serverType); serverModel.AddElement(serverContainer); this.ctx = new DataServiceContext(new Uri("http://temp.org/"), ODataProtocolVersion.V4, this.clientEdmModel); this.ctx.Format.UseJson(serverModel); this.testSubject = new RequestInfo(ctx); }
public void GetModel(EdmModel model, EdmEntityContainer container) { EdmEntityType product = new EdmEntityType("ns", "Product"); product.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); EdmStructuralProperty key = product.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32); product.AddKeys(key); model.AddElement(product); EdmEntitySet products = container.AddEntitySet("Products", product); EdmEntityType detailInfo = new EdmEntityType("ns", "DetailInfo"); detailInfo.AddKeys(detailInfo.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32)); detailInfo.AddStructuralProperty("Title", EdmPrimitiveTypeKind.String); model.AddElement(detailInfo); EdmEntitySet detailInfos = container.AddEntitySet("DetailInfos", product); EdmNavigationProperty detailInfoNavProp = product.AddUnidirectionalNavigation( new EdmNavigationPropertyInfo { Name = "DetailInfo", TargetMultiplicity = EdmMultiplicity.One, Target = detailInfo }); products.AddNavigationTarget(detailInfoNavProp, detailInfos); }
public void ReadingNullValueForDynamicCollectionPropertyInOpenStructuralTypeShouldWork() { EdmModel model = new EdmModel(); EdmComplexType complexType = new EdmComplexType("NS", "Address", null, false, true); complexType.AddStructuralProperty("CountryRegion", EdmPrimitiveTypeKind.String); model.AddElement(complexType); EdmEntityType entityType = new EdmEntityType("NS", "Person", null, false, true); entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); entityType.AddStructuralProperty("Address", new EdmComplexTypeReference(complexType, false)); model.AddElement(entityType); EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer"); EdmEntitySet entitySet = container.AddEntitySet("People", entityType); model.AddElement(container); const string payload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.People/$entity\"," + "\"@odata.id\":\"http://mytest\"," + "\"Id\":0," + "\"[email protected]\":\"#Collection(Edm.String)\"," + "\"Test\":null," + "\"Address\":{\"CountryRegion\":\"China\",\"[email protected]\":\"#Collection(Edm.Int32)\",\"Test1\":null}" + "}"; ODataEntry entry = null; this.ReadEntryPayload(model, payload, entitySet, entityType, reader => { entry = entry ?? reader.Item as ODataEntry; }); }
public void ReadingNullValueForDeclaredCollectionPropertyInComplexTypeShouldFail() { EdmModel model = new EdmModel(); EdmComplexType complexType = new EdmComplexType("NS", "Address"); complexType.AddStructuralProperty("CountriesOrRegions", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true)))); model.AddElement(complexType); EdmEntityType entityType = new EdmEntityType("NS", "Person"); entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); entityType.AddStructuralProperty("Address", new EdmComplexTypeReference(complexType, true)); model.AddElement(entityType); EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer"); EdmEntitySet entitySet = container.AddEntitySet("People", entityType); model.AddElement(container); const string payload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.People/$entity\"," + "\"@odata.id\":\"http://mytest\"," + "\"Id\":0," + "\"Address\":{\"CountriesOrRegions\":null}" + "}"; Action read = () => this.ReadEntryPayload(model, payload, entitySet, entityType, reader => { }); read.ShouldThrow <ODataException>().WithMessage("A null value was found for the property named 'CountriesOrRegions', which has the expected type 'Collection(Edm.String)[Nullable=False]'. The expected type 'Collection(Edm.String)[Nullable=False]' does not allow null values."); }
public void ReadingTypeDefinitionPayloadWithIncompatibleEdmTypeShouldFail() { EdmModel model = new EdmModel(); EdmEntityType entityType = new EdmEntityType("NS", "Person"); entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32); EdmTypeDefinition weightType = new EdmTypeDefinition("NS", "Weight", EdmPrimitiveTypeKind.Double); entityType.AddStructuralProperty("Height", EdmPrimitiveTypeKind.Int32); model.AddElement(weightType); model.AddElement(entityType); EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer"); EdmEntitySet entitySet = container.AddEntitySet("People", entityType); model.AddElement(container); const string payload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.People/$entity\"," + "\"@odata.id\":\"http://mytest\"," + "\"Id\":0," + "\"[email protected]\":\"#NS.Weight\"," + "\"Height\":180" + "}"; Action read = () => this.ReadEntryPayload(model, payload, entitySet, entityType, reader => { }); read.ShouldThrow <ODataException>().WithMessage(Strings.ValidationUtils_IncompatibleType("NS.Weight", "Edm.Int32")); }
static ODataFeedAndEntryTypeContextTests() { Model = new EdmModel(); EntitySetElementType = new EdmEntityType("ns", "Customer"); ExpectedEntityType = new EdmEntityType("ns", "VipCustomer", EntitySetElementType); ActualEntityType = new EdmEntityType("ns", "DerivedVipCustomer", ExpectedEntityType); EdmEntityContainer defaultContainer = new EdmEntityContainer("ns", "DefaultContainer"); Model.AddElement(defaultContainer); Model.AddVocabularyAnnotation(new EdmAnnotation(defaultContainer, UrlConventionsConstants.ConventionTerm, UrlConventionsConstants.KeyAsSegmentAnnotationValue)); EntitySet = new EdmEntitySet(defaultContainer, "Customers", EntitySetElementType); Model.AddElement(EntitySetElementType); Model.AddElement(ExpectedEntityType); Model.AddElement(ActualEntityType); defaultContainer.AddElement(EntitySet); SerializationInfo = new ODataFeedAndEntrySerializationInfo { NavigationSourceName = "MyCustomers", NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer" }; SerializationInfoWithEdmUnknowEntitySet = new ODataFeedAndEntrySerializationInfo() { NavigationSourceName = null, NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer", NavigationSourceKind = EdmNavigationSourceKind.UnknownEntitySet }; TypeContextWithoutModel = ODataFeedAndEntryTypeContext.Create(SerializationInfo, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true); TypeContextWithModel = ODataFeedAndEntryTypeContext.Create(/*serializationInfo*/ null, EntitySet, EntitySetElementType, ExpectedEntityType, Model, throwIfMissingTypeInfo: true); TypeContextWithEdmUnknowEntitySet = ODataFeedAndEntryTypeContext.Create(SerializationInfoWithEdmUnknowEntitySet, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true); BaseTypeContextThatThrows = ODataFeedAndEntryTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true); BaseTypeContextThatWillNotThrow = ODataFeedAndEntryTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: false); }
public ExpandAndSelectPathExtractingTests() { this.baseType = new EdmEntityType("FQ.NS", "Base"); this.baseType.AddKeys(this.baseType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); var baseNavigation1 = this.baseType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Navigation1", Target = this.baseType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne }); var baseNavigation2 = this.baseType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Navigation2", Target = this.baseType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne }); this.derivedType = new EdmEntityType("FQ.NS", "Derived", this.baseType); this.derivedType.AddStructuralProperty("Derived", EdmPrimitiveTypeKind.Int32); var derivedNavigation = this.derivedType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "DerivedNavigation", Target = this.derivedType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne }); var container = new EdmEntityContainer("FQ.NS", "Container"); this.entitySet = container.AddEntitySet("Entities", this.baseType); this.entitySet.AddNavigationTarget(baseNavigation1, this.entitySet); this.entitySet.AddNavigationTarget(baseNavigation2, this.entitySet); this.entitySet.AddNavigationTarget(derivedNavigation, this.entitySet); this.model = new EdmModel(); this.model.AddElement(this.baseType); this.model.AddElement(this.derivedType); this.model.AddElement(container); }
public void ReadPayloadThrowExceptionWithConflictBetweenInputformatAndIeee754CompatibleValueForIntDecimal() { EdmModel model = new EdmModel(); EdmEntityType entityType = new EdmEntityType("NS", "MyTestEntity"); entityType.AddStructuralProperty("DecimalId", EdmPrimitiveTypeKind.Decimal, false); model.AddElement(entityType); EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer_sub"); EdmEntitySet entitySet = container.AddEntitySet("MyTestEntitySet", entityType); model.AddElement(container); const string payload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.MyTestEntitySet/$entity\"," + "\"@odata.id\":\"http://MyTestEntity\"," + "\"DecimalId\":78.62" + "}"; IEdmModel mainModel = TestUtils.WrapReferencedModelsToMainModel("EntityNs", "MyContainer", model); ODataEntry entry = null; Action test = () => this.ReadEntryPayload(mainModel, payload, entitySet, entityType, reader => { entry = entry ?? reader.Item as ODataEntry; }); test.ShouldThrow <ODataException>().WithMessage(ODataErrorStrings.ODataJsonReaderUtils_ConflictBetweenInputFormatAndParameter("Edm.Decimal")); }
private static Dictionary <string, EdmEntitySet> AddEntitySets(this EdmModel model, ODataModelBuilder builder, EdmEntityContainer container, Dictionary <Type, IEdmStructuredType> edmTypeMap) { IEnumerable <EntitySetConfiguration> configurations = builder.EntitySets; // build the entitysets and their annotations IEnumerable <Tuple <EdmEntitySet, EntitySetConfiguration> > entitySets = AddEntitySets(configurations, container, edmTypeMap); var entitySetAndAnnotations = entitySets.Select(e => new { EntitySet = e.Item1, Configuration = e.Item2, Annotations = new { LinkBuilder = new EntitySetLinkBuilderAnnotation(e.Item2), Url = new EntitySetUrlAnnotation { Url = e.Item2.GetUrl() } } }).ToArray(); // index the entitySets by name Dictionary <string, EdmEntitySet> edmEntitySetMap = entitySetAndAnnotations.ToDictionary(e => e.EntitySet.Name, e => e.EntitySet); // apply the annotations foreach (var iter in entitySetAndAnnotations) { EdmEntitySet entitySet = iter.EntitySet; model.SetAnnotationValue <EntitySetUrlAnnotation>(entitySet, iter.Annotations.Url); model.SetEntitySetLinkBuilder(entitySet, iter.Annotations.LinkBuilder); AddNavigationBindings(iter.Configuration, iter.EntitySet, iter.Annotations.LinkBuilder, builder, edmTypeMap, edmEntitySetMap); } return(edmEntitySetMap); }
private static IEdmExpression GetEdmEntitySetExpression(IDictionary <string, EdmNavigationSource> navigationSources, OperationConfiguration operationConfiguration) { if (operationConfiguration.NavigationSource != null) { EdmNavigationSource navigationSource; if (navigationSources.TryGetValue(operationConfiguration.NavigationSource.Name, out navigationSource)) { EdmEntitySet entitySet = navigationSource as EdmEntitySet; if (entitySet != null) { return(new EdmPathExpression(entitySet.Name)); } } else { throw Error.InvalidOperation(SRResources.EntitySetNotFoundForName, operationConfiguration.NavigationSource.Name); } } else if (operationConfiguration.EntitySetPath != null) { return(new EdmPathExpression(operationConfiguration.EntitySetPath)); } return(null); }
public void WriteDynamicPropertyOfUIntIsNotSupported() { EdmModel model = new EdmModel(); EdmEntityType entityType = new EdmEntityType("NS", "Person", null, false, true); entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); model.AddElement(entityType); EdmEntityContainer container = new EdmEntityContainer("Ns", "MyContainer"); EdmEntitySet entitySet = container.AddEntitySet("People", entityType); model.AddElement(container); ODataResource entry = new ODataResource() { TypeName = "NS.Person", Properties = new[] { new ODataProperty { Name = "Id", Value = 1 }, new ODataProperty { Name = "Guid", Value = UInt64.MaxValue } } }; Action write = () => this.WriterEntry(model, entry, entitySet, entityType); write.ShouldThrow <ODataException>().WithMessage("The value of type 'System.UInt64' is not supported and cannot be converted to a JSON representation."); }
public void ReadingTypeDefinitionPayloadWithEdmTypeAnnotationJsonLight() { EdmModel model = new EdmModel(); EdmEntityType entityType = new EdmEntityType("NS", "Person"); entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32); EdmTypeDefinition weightType = new EdmTypeDefinition("NS", "Weight", EdmPrimitiveTypeKind.Double); EdmTypeDefinitionReference weightTypeRef = new EdmTypeDefinitionReference(weightType, false); entityType.AddStructuralProperty("Weight", weightTypeRef); EdmTypeDefinition heightType = new EdmTypeDefinition("NS", "Height", EdmPrimitiveTypeKind.Double); EdmComplexType complexType = new EdmComplexType("NS", "OpenAddress"); EdmComplexTypeReference complexTypeRef = new EdmComplexTypeReference(complexType, true); EdmTypeDefinition addressType = new EdmTypeDefinition("NS", "Address", EdmPrimitiveTypeKind.String); EdmTypeDefinitionReference addressTypeRef = new EdmTypeDefinitionReference(addressType, false); complexType.AddStructuralProperty("CountryRegion", addressTypeRef); entityType.AddStructuralProperty("Address", complexTypeRef); model.AddElement(weightType); model.AddElement(heightType); model.AddElement(addressType); model.AddElement(complexType); model.AddElement(entityType); EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer"); EdmEntitySet entitySet = container.AddEntitySet("People", entityType); model.AddElement(container); const string payload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.People/$entity\"," + "\"@odata.id\":\"http://mytest\"," + "\"Id\":0," + "\"[email protected]\":\"#Edm.Double\"," + "\"Weight\":60.5," + "\"Address\":{\"[email protected]\":\"#Edm.String\",\"CountryRegion\":\"China\"}" + "}"; ODataEntry entry = null; this.ReadEntryPayload(model, payload, entitySet, entityType, reader => { entry = entry ?? reader.Item as ODataEntry; }); Assert.NotNull(entry); IList <ODataProperty> propertyList = entry.Properties.ToList(); propertyList[1].Name.Should().Be("Weight"); propertyList[1].Value.Should().Be(60.5); var address = propertyList[2].Value as ODataComplexValue; address.Properties.FirstOrDefault(s => string.Equals(s.Name, "CountryRegion", StringComparison.OrdinalIgnoreCase)).Value.Should().Be("China"); }
static CustomInstanceAnnotationAcceptanceTests() { Model = new EdmModel(); EntityType = new EdmEntityType("TestNamespace", "TestEntityType"); Model.AddElement(EntityType); var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false)); EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty }); EntityType.AddProperty(keyProperty); var resourceNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "ResourceNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne }); var resourceSetNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "ResourceSetNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many }); var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer"); Model.AddElement(defaultContainer); EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType); EntitySet.AddNavigationTarget(resourceNavigationProperty, EntitySet); EntitySet.AddNavigationTarget(resourceSetNavigationProperty, EntitySet); defaultContainer.AddElement(EntitySet); ComplexType = new EdmComplexType("TestNamespace", "TestComplexType"); ComplexType.AddProperty(new EdmStructuralProperty(ComplexType, "StringProperty", EdmCoreModel.Instance.GetString(false))); Model.AddElement(ComplexType); }
private static object ConvertResource(ODataMessageReader oDataMessageReader, IEdmTypeReference edmTypeReference, ODataDeserializerContext readContext) { EdmEntitySet tempEntitySet = null; if (edmTypeReference.IsEntity()) { IEdmEntityTypeReference entityType = edmTypeReference.AsEntity(); tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp", entityType.EntityDefinition()); } // TODO: Sam xu, can we use the parameter-less overload ODataReader resourceReader = oDataMessageReader.CreateODataUriParameterResourceReader(tempEntitySet, edmTypeReference.ToStructuredType()); object item = resourceReader.ReadResourceOrResourceSet(); ODataResourceWrapper topLevelResource = item as ODataResourceWrapper; Contract.Assert(topLevelResource != null); IODataDeserializerProvider deserializerProvider = readContext.Request.GetDeserializerProvider(); ODataResourceDeserializer entityDeserializer = (ODataResourceDeserializer)deserializerProvider.GetEdmTypeDeserializer(edmTypeReference); return(entityDeserializer.ReadInline(topLevelResource, edmTypeReference, readContext)); }
public void WriteEntryWithStringEscapeOptionShouldWork() { EdmModel model = new EdmModel(); EdmEntityType entityType = new EdmEntityType("NS", "Person"); entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); entityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); model.AddElement(entityType); EdmEntityContainer container = new EdmEntityContainer("Ns", "MyContainer"); EdmEntitySet entitySet = container.AddEntitySet("People", entityType); model.AddElement(container); ODataResource entry = new ODataResource() { TypeName = "NS.Person", Properties = new[] { new ODataProperty { Name = "Id", Value = 1 }, new ODataProperty { Name = "Name", Value = "и\nя" } } }; // 1. without string escape option string outputPayload = this.WriterEntry(model, entry, entitySet, entityType, false, null, stringEscapeOption: null); const string expectedEscapedNonAsciiPayload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#People/$entity\"," + "\"Id\":1," + "\"Name\":\"\\u0438\\n\\u044f\"" + "}"; Assert.Equal(expectedEscapedNonAsciiPayload, outputPayload); // 2. With EscapeNonAscii escape option outputPayload = this.WriterEntry(model, entry, entitySet, entityType, false, null, ODataStringEscapeOption.EscapeNonAscii); Assert.Equal(expectedEscapedNonAsciiPayload, outputPayload); // 3. With EscapeOnlyControls escape option outputPayload = this.WriterEntry(model, entry, entitySet, entityType, false, null, ODataStringEscapeOption.EscapeOnlyControls); const string expectedEscapedOnlyControlPayload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#People/$entity\"," + "\"Id\":1," + "\"Name\":\"и\\nя\"" + "}"; Assert.Equal(expectedEscapedOnlyControlPayload, outputPayload); }
private static EntitySetSegmentTemplate GetSegmentTemplate(out EdmEntitySet entitySet) { EdmEntityType entityType = new EdmEntityType("NS", "entity"); EdmEntityContainer container = new EdmEntityContainer("NS", "default"); entitySet = new EdmEntitySet(container, "entities", entityType); return(new EntitySetSegmentTemplate(entitySet)); }
internal void AddEntitySet(string entitySetName, ResourceSetWrapper resourceSet) { IEdmEntityType elementType = (IEdmEntityType)this.model.EnsureSchemaType(resourceSet.ResourceType); IEdmEntitySet target = new EdmEntitySet(this, entitySetName, elementType); MetadataProviderUtils.ConvertCustomAnnotations(this.model, resourceSet.CustomAnnotations, target); this.entitySetCache.Add(entitySetName, target); }
public void GetEntitySetLinkBuilder_ReturnsDefaultEntitySetBuilder_IfNotSet() { IEdmModel model = new EdmModel(); EdmEntityContainer container = new EdmEntityContainer("NS", "Container"); EdmEntityType entityType = new EdmEntityType("NS", "Entity"); IEdmEntitySet entitySet = new EdmEntitySet(container, "EntitySet", entityType); Assert.NotNull(model.GetEntitySetLinkBuilder(entitySet)); }
private void InitializeEdmModel() { this.edmModel = new EdmModel(); EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "DefaultContainer"); this.edmModel.AddElement(defaultContainer); EdmComplexType addressType = new EdmComplexType("TestModel", "Address"); addressType.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(/*isNullable*/ false)); addressType.AddStructuralProperty("Zip", EdmCoreModel.Instance.GetString(/*isNullable*/ false)); this.cityType = new EdmEntityType("TestModel", "City"); EdmStructuralProperty cityIdProperty = cityType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false)); cityType.AddKeys(cityIdProperty); cityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(/*isNullable*/ false)); cityType.AddStructuralProperty("Size", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false)); cityType.AddStructuralProperty("Restaurants", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(/*isNullable*/ false))); cityType.AddStructuralProperty("Address", new EdmComplexTypeReference(addressType, true)); this.edmModel.AddElement(cityType); this.capitolCityType = new EdmEntityType("TestModel", "CapitolCity", cityType); capitolCityType.AddStructuralProperty("CapitolType", EdmCoreModel.Instance.GetString(/*isNullable*/ false)); this.edmModel.AddElement(capitolCityType); EdmEntityType districtType = new EdmEntityType("TestModel", "District"); EdmStructuralProperty districtIdProperty = districtType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false)); districtType.AddKeys(districtIdProperty); districtType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(/*isNullable*/ false)); districtType.AddStructuralProperty("Zip", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false)); this.edmModel.AddElement(districtType); cityType.AddBidirectionalNavigation( new EdmNavigationPropertyInfo { Name = "Districts", Target = districtType, TargetMultiplicity = EdmMultiplicity.Many }, new EdmNavigationPropertyInfo { Name = "City", Target = cityType, TargetMultiplicity = EdmMultiplicity.One }); cityType.NavigationProperties().Single(np => np.Name == "Districts"); capitolCityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "CapitolDistrict", Target = districtType, TargetMultiplicity = EdmMultiplicity.One }); capitolCityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "OutlyingDistricts", Target = districtType, TargetMultiplicity = EdmMultiplicity.Many }); this.citySet = defaultContainer.AddEntitySet("Cities", cityType); defaultContainer.AddEntitySet("Districts", districtType); this.singletonCity = defaultContainer.AddSingleton("SingletonCity", cityType); }
static ODataReaderExtensionsTests() { Model = new EdmModel(); // Address EdmComplexType address = new EdmComplexType("NS", "Address"); address.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(false)); Model.AddElement(address); // Customer EdmEntityType customer = new EdmEntityType("NS", "Customer"); Model.AddElement(customer); customer.AddKeys(customer.AddStructuralProperty("CustomerID", EdmCoreModel.Instance.GetInt32(false))); customer.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true)); customer.AddStructuralProperty("Location", new EdmComplexTypeReference(address, false)); // Order EdmEntityType order = new EdmEntityType("NS", "Order"); Model.AddElement(order); order.AddKeys(order.AddStructuralProperty("OrderId", EdmCoreModel.Instance.GetInt32(false))); order.AddStructuralProperty("Price", EdmCoreModel.Instance.GetInt32(false)); // VipOrder EdmEntityType vipOrder = new EdmEntityType("NS", "VipOrder", order); Model.AddElement(vipOrder); vipOrder.AddKeys(vipOrder.AddStructuralProperty("Email", EdmCoreModel.Instance.GetString(false))); var orderNav = customer.AddUnidirectionalNavigation( new EdmNavigationPropertyInfo { Name = "Order", Target = order, TargetMultiplicity = EdmMultiplicity.ZeroOrOne }); var ordresNav = customer.AddUnidirectionalNavigation( new EdmNavigationPropertyInfo { Name = "Orders", Target = order, TargetMultiplicity = EdmMultiplicity.Many }); EdmEntityContainer defaultContainer = new EdmEntityContainer("NS", "Container"); Model.AddElement(defaultContainer); EdmEntitySet customers = defaultContainer.AddEntitySet("Customers", customer); EdmEntitySet orders = defaultContainer.AddEntitySet("Orders", order); customers.AddNavigationTarget(orderNav, orders); customers.AddNavigationTarget(ordresNav, orders); }
public void WriteUIntPayloadShouldWork() { EdmModel model = new EdmModel(); EdmEntityType entityType = new EdmEntityType("NS", "Person"); entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); entityType.AddStructuralProperty("Guid", model.GetUInt64("NS", false)); model.AddElement(entityType); EdmEntityContainer container = new EdmEntityContainer("Ns", "MyContainer"); EdmEntitySet entitySet = container.AddEntitySet("People", entityType); model.AddElement(container); ODataResource entry = new ODataResource() { TypeName = "NS.Person", Properties = new[] { new ODataProperty { Name = "Id", Value = 1 }, new ODataProperty { Name = "Guid", Value = UInt64.MaxValue } } }; string outputPayload = this.WriterEntry(model, entry, entitySet, entityType); const string expectedMinimalPayload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#People/$entity\"," + "\"Id\":1," + "\"Guid\":18446744073709551615" + "}"; Assert.Equal(expectedMinimalPayload, outputPayload); outputPayload = this.WriterEntry(model, entry, entitySet, entityType, true); const string expectedFullPayload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#People/$entity\"," + "\"@odata.type\":\"#NS.Person\"," + "\"@odata.id\":\"People(1)\"," + "\"@odata.editLink\":\"People(1)\"," + "\"Id\":1," + "\"Guid\":18446744073709551615" + "}"; Assert.Equal(expectedFullPayload, outputPayload); }
private static object ConvertResourceSet(ODataMessageReader oDataMessageReader, IEdmTypeReference edmTypeReference, ODataDeserializerContext readContext) { IEdmCollectionTypeReference collectionType = edmTypeReference.AsCollection(); EdmEntitySet tempEntitySet = null; if (collectionType.ElementType().IsEntity()) { tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp", collectionType.ElementType().AsEntity().EntityDefinition()); } // TODO: Sam xu, can we use the parameter-less overload ODataReader odataReader = oDataMessageReader.CreateODataUriParameterResourceSetReader(tempEntitySet, collectionType.ElementType().AsStructured().StructuredDefinition()); ODataResourceSetWrapper resourceSet = odataReader.ReadResourceOrResourceSet() as ODataResourceSetWrapper; ODataDeserializerProvider deserializerProvider = readContext.Request.GetDeserializerProvider(); ODataResourceSetDeserializer resourceSetDeserializer = (ODataResourceSetDeserializer)deserializerProvider.GetEdmTypeDeserializer(collectionType); object result = resourceSetDeserializer.ReadInline(resourceSet, collectionType, readContext); IEnumerable enumerable = result as IEnumerable; if (enumerable != null) { IEnumerable newEnumerable = enumerable; if (collectionType.ElementType().IsEntity()) { newEnumerable = CovertResourceSetIds(enumerable, resourceSet, collectionType, readContext); } if (readContext.IsUntyped) { return(newEnumerable.ConvertToEdmObject(collectionType)); } else { IEdmTypeReference elementTypeReference = collectionType.ElementType(); Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference, readContext.Model); IEnumerable castedResult = CastMethodInfo.MakeGenericMethod(elementClrType) .Invoke(null, new object[] { newEnumerable }) as IEnumerable; return(castedResult); } } return(null); }
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 TestEntityType() { var container = new EdmEntityContainer("NS", "C"); var entityType = new EdmEntityType("NS", "People"); var entitySet = new EdmEntitySet(container, "Peoples", entityType); Assert.AreEqual(entityType, entitySet.EntityType()); var singleton = new EdmSingleton(container, "Boss", entityType); Assert.AreEqual(entityType, singleton.EntityType()); }
internal void WriteAssociationSetEndElement(EdmEntitySet end, string roleName) { _xmlWriter.WriteStartElement(CsdlConstants.Element_End); _xmlWriter.WriteAttributeString(CsdlConstants.Attribute_Role, roleName); _xmlWriter.WriteAttributeString(CsdlConstants.Attribute_EntitySet, end.Name); _xmlWriter.WriteEndElement(); }
protected virtual void VisitEdmAssociationSetEnd(EdmEntitySet item) { VisitEdmNamedMetadataItem(item); }
protected virtual void VisitEdmEntitySet(EdmEntitySet item) { VisitEdmNamedMetadataItem(item); }
internal void WriteEntitySetElementHeader(EdmEntitySet entitySet) { _xmlWriter.WriteStartElement(CsdlConstants.Element_EntitySet); _xmlWriter.WriteAttributeString(CsdlConstants.Attribute_Name, entitySet.Name); _xmlWriter.WriteAttributeString( CsdlConstants.Attribute_EntityType, GetQualifiedTypeName(CsdlConstants.Value_Self, entitySet.ElementType.Name)); }
protected override void VisitEdmEntitySet(EdmEntitySet item) { _schemaWriter.WriteEntitySetElementHeader(item); base.VisitEdmEntitySet(item); _schemaWriter.WriteEndElement(); }