private IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create(); builder.EntityType <Customer>().Namespace = "NS"; builder.ComplexType <Address>().Namespace = "NS"; FunctionConfiguration getEnum = builder.Function("GetEnum"); getEnum.Parameter <SimpleEnum>("simpleEnum"); getEnum.Returns <SimpleEnum>(); FunctionConfiguration getFlagsEnum = builder.Function("GetFlagsEnum"); getFlagsEnum.Parameter <FlagsEnum>("flagsEnum"); getFlagsEnum.Returns <FlagsEnum>(); FunctionConfiguration function = builder.Function("GetNullableFlagsEnum").Returns <bool>(); function.Parameter <FlagsEnum?>("flagsEnum"); builder.Function("GetAddress").Returns <bool>().Parameter <Address>("address"); builder.Function("GetCustomer").Returns <bool>().Parameter <Customer>("customer"); return(builder.GetEdmModel()); }
private static IEdmModel GetConventionModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); EntitySetConfiguration<ModelAliasingMetadataCustomer> customers = builder.EntitySet<ModelAliasingMetadataCustomer>("ModelAliasingQueryCustomers"); customers.EntityType.Name = "Customer"; customers.EntityType.Namespace = "ModelAliasing"; customers.EntityType.ComplexProperty(c => c.BillingAddress).Name = "FinancialAddress"; customers.EntityType.Property(c => c.Name).Name = "ClientName"; customers.EntityType.HasMany(c => c.Orders).Name = "Purchases"; EntitySetConfiguration<ModelAliasingMetadataOrder> orders = builder.EntitySet<ModelAliasingMetadataOrder>("Orders"); orders.EntityType.Name = "Order"; orders.EntityType.Namespace = "AliasedNamespace"; EntityTypeConfiguration<ModelAliasingMetadataExpressOrder> expressOrder = builder.EntityType<ModelAliasingMetadataExpressOrder>().DerivesFrom<ModelAliasingMetadataOrder>(); expressOrder.Name = "ExpressOrder"; expressOrder.Namespace = "Purchasing"; expressOrder.Property(eo => eo.ExpressFee).Name = "Fee"; EntityTypeConfiguration<ModelAliasingMetadataFreeDeliveryOrder> freeDeliveryOrder = builder.EntityType<ModelAliasingMetadataFreeDeliveryOrder>().DerivesFrom<ModelAliasingMetadataOrder>(); freeDeliveryOrder.Name = "FreeDeliveryOrder"; freeDeliveryOrder.Namespace = "Purchasing"; EntitySetConfiguration<ModelAliasingMetadataProduct> products = builder.EntitySet<ModelAliasingMetadataProduct>("Products"); EntitySetConfiguration<ModelAliasingMetadataOrderLine> ordersLines = builder.EntitySet<ModelAliasingMetadataOrderLine>("OrdersLines"); ordersLines.EntityType.Property(ol => ol.Price).Name = "Cost"; ComplexTypeConfiguration<ModelAliasingMetadataRegion> region = builder.ComplexType<ModelAliasingMetadataRegion>(); region.Name = "PoliticalRegion"; region.Namespace = "Location"; ComplexTypeConfiguration<ModelAliasingMetadataAddress> address = builder.ComplexType<ModelAliasingMetadataAddress>(); address.Name = "Direction"; address.Namespace = "Location"; address.ComplexProperty<ModelAliasingMetadataRegion>(c => c.Country).Name = "Reign"; return builder.GetEdmModel(); }
protected void RegisterCatalog(ODataConventionModelBuilder builder) { #region Category model builder.EntitySet <CategoryDto>("Category"); builder.EntityType <CategoryDto>().Count().Filter().OrderBy().Page(); #endregion #region Manufacturer model builder.EntitySet <ManufacturerDto>("Manufacturer"); builder.EntityType <ManufacturerDto>().Count().Filter().OrderBy().Page(); #endregion #region Product attribute model builder.EntitySet <ProductAttributeDto>("ProductAttribute"); builder.EntityType <ProductAttributeDto>().Count().Filter().OrderBy().Page(); builder.ComplexType <PredefinedProductAttributeValueDto>(); #endregion #region Product attribute model builder.EntitySet <SpecificationAttributeDto>("SpecificationAttribute"); builder.EntityType <SpecificationAttributeDto>().Count().Filter().OrderBy().Page(); builder.ComplexType <SpecificationAttributeOptionDto>(); #endregion }
private static ODataConventionModelBuilder AddStudents(this ODataConventionModelBuilder builder) { builder.EntitySet <StudentResponseModel>("Student"); builder.ComplexType <StudentGradeResponseModel>(); builder.ComplexType <StudentCourseResponseModel>(); return(builder); }
private IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create(); builder.ComplexType <EnumComplexWithRequiredEnum>(); builder.ComplexType <EnumComplexWithNullableEnum>(); return(builder.GetEdmModel()); }
private IEdmModel GetEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EnumType <Genre>(); builder.ComplexType <Address>(); builder.ComplexType <NextOfKin>(); builder.EntitySet <Director>("Directors"); return(builder.GetEdmModel()); }
private static IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var auctionsSet = builder.EntitySet <Auction>("Auctions"); var usersSet = builder.EntitySet <User>("Users"); builder.ComplexType <Vehicle>(); builder.ComplexType <Engine>(); //usersSet.EntityType.ContainsMany(item => item.Auctions); //usersSet.EntityType.ContainsRequired(item => item.Address); //usersSet.HasManyBinding(item => item.Auctions, auctionsSet); //builder.EntityType<Auction>(); return(builder.GetEdmModel()); }
public void NamespaceAssignment_AutoAssignsNamespaceToStructuralType_DefaultNamespace() { // Arrange & Act. ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder(); modelBuilder.EntitySet <Client>("clients"); modelBuilder.ComplexType <ZipCode>(); // Assert Assert.Equal(typeof(Client).Namespace, modelBuilder.EntityType <Client>().Namespace); Assert.Equal(typeof(MyOrder).Namespace, modelBuilder.EntityType <MyOrder>().Namespace); Assert.Equal(typeof(OrderLine).Namespace, modelBuilder.EntityType <OrderLine>().Namespace); Assert.Equal(typeof(OrderHeader).Namespace, modelBuilder.EntityType <OrderHeader>().Namespace); Assert.Equal(typeof(ZipCode).Namespace, modelBuilder.ComplexType <ZipCode>().Namespace); }
protected override void Initialize(HttpConfiguration configuration) { var builder = new ODataConventionModelBuilder(); builder.Namespace = "Unit.Test"; builder.EnableLowerCamelCase(); var address = builder.ComplexType <Address>(); var people = builder.EntitySet <Person>("People"); var person = people.EntityType; address.Namespace = builder.Namespace; address.HasAnnotation(a => a.IsPrimary); people.HasAnnotation("Version", 2.0); people.HasComplexAnnotations("Links", new[] { new Link("help", new Uri("http://localhost/api/help")) }); person.Namespace = builder.Namespace; person.HasKey(p => p.Id); person.HasAnnotation(p => p.Timestamp); person.HasAnnotation(p => p.Flags); person.HasAnnotations(p => p.SeoTerms); person.HasComplexAnnotations(p => p.Links); person.Ignore(p => p.PhotoImage); person.Ignore(p => p.PhotoImageType); person.HasAnnotation(p => p.Birthday).ForProperty(p => p.Age); person.HasComplexAnnotation(p => p.DisplayStyle).ForProperty(p => p.FirstName); var model = builder.GetEdmModelWithAnnotations(); configuration.EnableCaseInsensitive(true); configuration.EnableInstanceAnnotations(); configuration.MapODataServiceRoute("odata", "api", model); }
private static IEdmModel GetSampleModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType <Person>(); return(builder.GetEdmModel()); }
public static IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<InheritanceCustomer>("InheritanceCustomers"); builder.ComplexType<InheritanceLocation>(); return builder.GetEdmModel(); }
public static void Register(HttpConfiguration config) { // Web API configuration and services // Web API routes //config.MapHttpAttributeRoutes(); //config.Routes.MapHttpRoute( // name: "DefaultApi", // routeTemplate: "api/{controller}/{id}", // defaults: new { id = RouteParameter.Optional }); // New code: ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <Game>("Games"); builder.EntitySet <Store>("Stores"); builder.ComplexType <CardShirt>(); builder.Function("GetAvailableCardShirts").ReturnsCollection <CardShirt>(); config.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: builder.GetEdmModel()); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env) { var builder = new ODataConventionModelBuilder(app.ApplicationServices); builder.EntitySet <Product>("Products"); builder.EntitySet <Product>("products"); //builder.EntitySet<ProductDetail>("Detail"); builder.ComplexType <ProductCategory>(); // Convert all query data to lower case builder.EnableLowerCamelCase(); // with this option, "Products({Id})/Detail" must change to "Products({Id})/detail" if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } //app.UseMvc(); app.UseMvc(routeBuilder => { // Enable query operators in the routing routeBuilder.Count().Filter().OrderBy().Expand().Select().MaxTop(null); // Odata Route: ~/odata/~ routeBuilder.MapODataServiceRoute("OData", "odata", builder.GetEdmModel()); // Workaround: https://github.com/OData/WebApi/issues/1175 routeBuilder.EnableDependencyInjection(); }); }
private static ODataConventionModelBuilder AddCourse(this ODataConventionModelBuilder builder) { builder.EntitySet <CourseResponseModel>("Course"); builder.ComplexType <CourseTeacherResponseModel>(); return(builder); }
private static ODataConventionModelBuilder AddGrade(this ODataConventionModelBuilder builder) { builder.EntitySet <GradeResponseModel>("Grade"); builder.ComplexType <GradeCourseResponseModel>(); return(builder); }
private static IEdmModel BuildEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet <Customer>("Customers"); builder.ComplexType <Address>(); var function = builder.Function("UnboundFunction").Returns <string>(); function.Parameter <int>("p1"); function.Parameter <string>("p2"); function.Parameter <Address>("location"); function = builder.Function("ConventionUnboundFunction").Returns <string>(); function.Parameter <int>("p1"); function.Parameter <string>("p2"); function.Parameter <Address>("location"); function = builder.Function("RetrieveCustomersByFilter").ReturnsCollectionFromEntitySet <Customer>("Customers"); function.Parameter <string>("name"); function.Parameter <string>("lastName"); function.Parameter <CustomerType>("customerType"); return(builder.GetEdmModel()); }
static void AddODataSupport(ServerHost server) { var objectModelBuilder = new ODataConventionModelBuilder(); var bornInfo = objectModelBuilder.ComplexType <BornInfoView>(); bornInfo.Property(bi => bi.When); bornInfo.Property(bi => bi.Where); var person = objectModelBuilder.EntitySet <PersonView>("PeopleView") .EntityType.HasKey(p => p.Id); person.Property(p => p.Name); person.Property(p => p.Version); person.ComplexProperty(p => p.BornInfo); var address = objectModelBuilder.EntitySet <AddressView>("AddressesView") .EntityType.HasKey(a => a.AddressId); address.Property(a => a.Street); address.Property(a => a.PersonId); server.AddHttpConfigurationCustomization(cfg => { cfg.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: objectModelBuilder.GetEdmModel() ); }); }
public async Task WriteObjectAsync_CanWrite_TopLevelResourceSet_ContainsEmptyCollectionOfDynamicComplexElement() { // Arrange ODataSerializerProvider serializerProvider = GetServiceProvider().GetService <ODataSerializerProvider>(); ODataResourceSetSerializer serializer = new ODataResourceSetSerializer(serializerProvider); MemoryStream stream = new MemoryStream(); IODataResponseMessageAsync message = new ODataMessageWrapper(stream); ODataMessageWriterSettings settings = new ODataMessageWriterSettings { ODataUri = new ODataUri { ServiceRoot = new Uri("http://any/"), } }; settings.SetContentType(ODataFormat.Json); ODataMessageWriter writer = new ODataMessageWriter(message, settings); IList <SimpleOpenAddress> addresses = new[] { new SimpleOpenAddress { City = "Redmond", Street = "Microsoft Rd", Properties = new Dictionary <string, object> { { "StringProp", "abc" }, { "Locations", new SimpleOpenAddress[] {} } // empty collection of complex } } }; var builder = new ODataConventionModelBuilder(); builder.ComplexType <SimpleOpenAddress>(); IEdmModel model = builder.GetEdmModel(); ODataSerializerContext writeContext = new ODataSerializerContext { Model = model }; // Act await serializer.WriteObjectAsync(addresses, typeof(IList <SimpleOpenAddress>), writer, writeContext); stream.Seek(0, SeekOrigin.Begin); JObject result = JObject.Parse(await new StreamReader(stream).ReadToEndAsync());//.ToString(); // Assert Assert.Equal(JObject.Parse(@"{ ""@odata.context"": ""http://any/$metadata#Collection(Microsoft.AspNetCore.OData.Tests.Formatter.Models.SimpleOpenAddress)"", ""value"": [ { ""Street"": ""Microsoft Rd"", ""City"": ""Redmond"", ""StringProp"": ""abc"", ""*****@*****.**"": ""#Collection(Microsoft.AspNetCore.OData.Tests.Formatter.Models.SimpleOpenAddress)"", ""Locations"": [] } ] }"), result); }
public void LowerCamelCaser_RespectExplicitProperties() { // Arrange var builder = new ODataConventionModelBuilder(); EntityTypeConfiguration<LowerCamelCaserEntity> entityTypeConfiguration = builder.EntitySet<LowerCamelCaserEntity>("Entities").EntityType; entityTypeConfiguration.Property(b => b.ID).Name = "iD"; entityTypeConfiguration.Property(d => d.Name).Name = "Name"; entityTypeConfiguration.EnumProperty(d => d.Color).Name = "Something"; ComplexTypeConfiguration<LowerCamelCaserComplex> complexTypeConfiguration = builder.ComplexType<LowerCamelCaserComplex>(); complexTypeConfiguration.CollectionProperty(c => c.Notes).Name = "MyNotes"; builder.OnModelCreating += new LowerCamelCaser(NameResolverOptions.RespectExplicitProperties).Apply; // Act IEdmModel model = builder.GetEdmModel(); // Assert IEdmEntityType lowerCamelCaserEntity = Assert.Single(model.SchemaElements.OfType<IEdmEntityType>().Where(e => e.Name == "LowerCamelCaserEntity")); IEdmComplexType lowerCamelCaserComplex = Assert.Single(model.SchemaElements.OfType<IEdmComplexType>().Where(e => e.Name == "LowerCamelCaserComplex")); Assert.Equal(5, lowerCamelCaserEntity.Properties().Count()); Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "iD")); Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "Name")); Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "details")); Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "Something")); Assert.Single(lowerCamelCaserEntity.Properties().Where(p => p.Name == "complexProperty")); Assert.Equal(2, lowerCamelCaserComplex.Properties().Count()); Assert.Single(lowerCamelCaserComplex.Properties().Where(p => p.Name == "price")); Assert.Single(lowerCamelCaserComplex.Properties().Where(p => p.Name == "MyNotes")); }
private static HttpServer CreateServer(string customersEntitySet) { HttpConfiguration configuration = new HttpConfiguration(); ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <EnableQueryCustomer>(customersEntitySet); builder.Entity <PremiumEnableQueryCustomer>(); builder.EntitySet <EnableQueryCategory>("EnableQueryCategories"); builder.Entity <PremiumEnableQueryCategory>(); builder.EntitySet <EnableQueryOrder>("EnableQueryOrders"); builder.Entity <DiscountedEnableQueryOrder>(); builder.EntitySet <EnableQueryOrderLine>("EnableQueryOrderLines"); builder.ComplexType <EnableQueryAddress>(); IEdmModel model = builder.GetEdmModel(); configuration.Routes.MapODataServiceRoute("odata", "odata", model); return(new HttpServer(configuration)); }
static void AddODataSupport( ServerHost server ) { var objectModelBuilder = new ODataConventionModelBuilder(); var bornInfo = objectModelBuilder.ComplexType<BornInfoView>(); bornInfo.Property( bi => bi.When ); bornInfo.Property( bi => bi.Where ); var person = objectModelBuilder.EntitySet<PersonView>( "PeopleView" ) .EntityType.HasKey( p => p.Id ); person.Property( p => p.Name ); person.Property( p => p.Version ); person.ComplexProperty( p => p.BornInfo ); var address = objectModelBuilder.EntitySet<AddressView>( "AddressesView" ) .EntityType.HasKey( a => a.AddressId ); address.Property( a => a.Street ); address.Property( a => a.PersonId ); server.AddHttpConfigurationCustomization( cfg => { cfg.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: objectModelBuilder.GetEdmModel() ); } ); }
public void CreateResource_CreateDeltaWith_OpenComplexType() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType <SimpleOpenAddress>(); IEdmModel model = builder.GetEdmModel(); IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex(); ODataDeserializerContext readContext = new ODataDeserializerContext { Model = model, ResourceType = typeof(Delta <SimpleOpenAddress>) }; var structuralProperties = addressTypeReference.StructuralProperties().Select(p => p.Name); // Act Delta <SimpleOpenAddress> resource = ODataComplexTypeDeserializer.CreateResource(addressTypeReference, readContext) as Delta <SimpleOpenAddress>; // Assert Assert.NotNull(resource); Assert.Equal(structuralProperties, resource.GetUnchangedPropertyNames()); }
public static void Register(HttpConfiguration httpConfiguration) { ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.Namespace = "ODataV4TestService.Models"; builder.EntitySet<Product>("Products"); builder.EntitySet<SuppliedProduct>("SuppliedProducts"); builder.EntitySet<Supplier>("Suppliers"); builder.EntitySet<Product>("OtherProducts"); builder.ComplexType<Description>(); builder.EntityType<Product>() .Action("Rate") .Parameter<int>("Rating"); builder.EntityType<Product>().Collection .Function("Best") .ReturnsCollectionFromEntitySet<Product>("Products"); var funcConfig = builder .EntityType<Product>() .Function("RelatedProducts") .SetBindingParameter("product", builder.GetTypeConfigurationOrNull(typeof(Product))) //.AddParameter("start", new PrimitiveTypeConfiguration(builder, builder.GetTypeConfigurationOrNull(typeof(DateTimeOffset)), typeof(DateTimeOffset)). .ReturnsCollectionFromEntitySet<Product>("Products"); funcConfig .Parameter<DateTimeOffset>("start"); funcConfig .Parameter<DateTimeOffset>("end"); //builder.Function("GetSalesTaxRate") // .Returns<double>() // .Parameter<int>("PostalCode"); builder.EntitySet<Account>("Accounts"); builder.EntityType<PaymentInstrument>() .Collection .Function("GetCount") .Returns<int>() .Parameter<string>("NameContains"); var model = builder.GetEdmModel(); var conventions = ODataRoutingConventions.CreateDefault(); conventions.Insert(0, new AttributeRoutingConvention(model, httpConfiguration)); var server = new BatchServer(httpConfiguration); httpConfiguration.MapODataServiceRoute( routeName: "ODataRoute", routePrefix: null, model: model, pathHandler: new DefaultODataPathHandler(), routingConventions: conventions, batchHandler: new DefaultODataBatchHandler(server)); httpConfiguration.MessageHandlers.Add(new TracingMessageHandler()); }
public static void ConfigureSsisService(this IAppBuilder app) { Debug.Assert(app != null); //// build EDM model var builder = new ODataConventionModelBuilder() { Namespace = typeof(SsisController).Namespace, ContainerName = "DefaultContainer" }; builder.ComplexType<JobParameter>(); builder.ComplexType<JobStatusResult>(); builder.EnumType<JobStatus>(); builder.EnumType<JobParameterType>(); { var function = builder.Function("GetStatus"); function.Parameter<string>("name").OptionalParameter = false; function.Returns<JobStatusResult>(); } { var action = builder.Action("Run"); action.Parameter<string>("name").OptionalParameter = false; action.CollectionParameter<JobParameter>("parameters").OptionalParameter = false; action.Returns<string>(); } { var action = builder.Action("Stop"); action.Parameter<string>("name").OptionalParameter = false; action.Returns<string>(); } var edmModel = builder.GetEdmModel(); //// configure web API var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always }; config.MapODataServiceRoute("SsisService", "ssisservice", edmModel); config.Services.Replace(typeof(IHttpControllerSelector), new ClientHttpControllerSelector(config, typeof(SsisServiceHelper))); config.EnsureInitialized(); app.UseWebApi(config); }
private static IEdmModel CreatEdmModel() { var builder = new ODataConventionModelBuilder(); var addressModel = builder.ComplexType <Address>(); addressModel.Property(o => o.City); addressModel.Property(o => o.Country); addressModel.Property(o => o.Fax); addressModel.Property(o => o.PhoneNumber); addressModel.Property(o => o.PostalCode); addressModel.Property(o => o.Region); addressModel.Property(o => o.Street); var customerModel = builder.EntitySet <Customer>(nameof(Customer)); customerModel.EntityType.HasKey(o => o.CustomerId); customerModel.EntityType.Property(o => o.CompanyName); customerModel.EntityType.Property(o => o.ContactTitle); customerModel.EntityType.ComplexProperty(o => o.Address); customerModel.EntityType.HasMany(o => o.Orders); var orderLineModel = builder.EntitySet <OrderLine>(nameof(OrderLine)); orderLineModel.EntityType.HasKey(o => o.Id); orderLineModel.EntityType.Property(o => o.Discount); orderLineModel.EntityType.Property(o => o.Quantity); orderLineModel.EntityType.Property(o => o.UnitPrice); orderLineModel.EntityType.HasRequired(o => o.Order); var orderModel = builder.EntitySet <Order>(nameof(Order)); orderModel.EntityType.HasKey(o => o.OrderId); orderModel.EntityType.Property(o => o.Freight); orderModel.EntityType.Property(o => o.OrderDate); orderModel.EntityType.Property(o => o.RequiredDate); orderModel.EntityType.Property(o => o.ShippedTo); orderModel.EntityType.Property(o => o.ShippingDate); orderModel.EntityType.ComplexProperty(o => o.ShippingAddress); orderModel.EntityType.HasRequired(o => o.Customer); orderModel.EntityType.HasOptional(o => o.Employee); orderModel.EntityType.HasMany(o => o.OrderLines); var employeeModel = builder.EntitySet <Employee>(nameof(Employee)); employeeModel.EntityType.HasKey(o => o.EmployeeId); employeeModel.EntityType.Property(o => o.BirthDate); employeeModel.EntityType.Property(o => o.Extension); employeeModel.EntityType.Property(o => o.FirstName); employeeModel.EntityType.Property(o => o.HireDate); employeeModel.EntityType.Property(o => o.LastName); employeeModel.EntityType.Property(o => o.Notes); employeeModel.EntityType.Property(o => o.Title); employeeModel.EntityType.HasMany(o => o.Orders); builder.EntitySet <CustomerVm>(nameof(CustomerVm)); return(builder.GetEdmModel()); }
public static IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <InheritanceCustomer>("InheritanceCustomers"); builder.ComplexType <InheritanceLocation>(); return(builder.GetEdmModel()); }
public static IEdmModel GetEdmModel(WebRouteConfiguration configuration) { ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder(); builder.EntitySet <InheritanceCustomer>("InheritanceCustomers"); builder.ComplexType <InheritanceLocation>(); return(builder.GetEdmModel()); }
private static IEdmModel GetEdmModel() { ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <OpenCustomer>("OpenCustomers"); builder.ComplexType <Building>(); return(builder.GetEdmModel()); }
private IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet <Customer>("customers"); builder.ComplexType <Address>(); return(builder.GetEdmModel()); }
public void ReadFromStreamAsync_ForComplexType_WithNestedComplexType() { // Arrange const string content = "{\"value\":{" + "\"City\":\"UpdatedCity\"," + "\"Location\": {" + "\"Latitude\": 30.6," + "\"Longitude\": 101.313" + "}," + "\"SubLocation\": {" + // dynamic property "\"@odata.type\":\"#System.Web.OData.Formatter.Deserialization.Location\"," + "\"Latitude\": 15.5," + "\"Longitude\": 130.88" + "}" + "}}"; ODataComplexTypeDeserializer deserializer = new ODataComplexTypeDeserializer(new DefaultODataDeserializerProvider()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType <Region>(); IEdmModel model = builder.GetEdmModel(); ODataDeserializerContext readContext = new ODataDeserializerContext { Model = model, ResourceType = typeof(Delta <Region>) }; // Act object value = deserializer.Read(GetODataMessageReader(GetODataMessage(content), model), typeof(Delta <Region>), readContext); // Assert Delta <Region> region = Assert.IsType <Delta <Region> >(value); Assert.NotNull(region); Assert.Equal(new[] { "City", "Location" }, region.GetChangedPropertyNames()); Assert.Empty(region.GetUnchangedPropertyNames()); object propertyValue; Assert.True(region.TryGetPropertyValue("City", out propertyValue)); string cityValue = Assert.IsType <string>(propertyValue); Assert.Equal("UpdatedCity", cityValue); Assert.True(region.TryGetPropertyValue("Location", out propertyValue)); Location locationValue = Assert.IsType <Location>(propertyValue); Assert.Equal(30.6, locationValue.Latitude); Assert.Equal(101.313, locationValue.Longitude); // dynamic property Assert.True(region.TryGetPropertyValue("SubLocation", out propertyValue)); locationValue = Assert.IsType <Location>(propertyValue); Assert.Equal(15.5, locationValue.Latitude); Assert.Equal(130.88, locationValue.Longitude); }
public static IEdmModel GetEdmModel() { var odataBuilder = new ODataConventionModelBuilder(); odataBuilder.EntitySet <Person>("People"); odataBuilder.ComplexType <Car>(); return(odataBuilder.GetEdmModel()); }
public static IEdmModel GetEdmModel() { var builder = new ODataConventionModelBuilder(); builder.EntitySet <Customer>("Customers"); builder.EntitySet <Order>("Orders"); builder.ComplexType <MyComplexType <int> >(); return(builder.GetEdmModel()); }
private static IEdmModel GetEdmModel() { ODataConventionModelBuilder model = new ODataConventionModelBuilder(); model.EntitySet <Customer>("Customers"); model.Singleton <Customer>("Me"); model.ComplexType <Address>(); return(model.GetEdmModel()); }
private IEdmModel GetEdmModel(ODataConventionModelBuilder builder) { builder.EntitySet <ConventionCustomer>("ConventionCustomers"); builder.EntitySet <ConventionOrder>("ConventionOrders"); builder.ComplexType <ConventionPerson>(); builder.EntityType <ConventionCustomer>().ComplexProperty <ConventionAddress>(c => c.Address); // Top level action import ActionConfiguration createConventionCustomerById = builder.Action("CreateConventionCustomerById"); createConventionCustomerById.Parameter <int>("ID"); createConventionCustomerById.ReturnsFromEntitySet <ConventionCustomer>("ConventionCustomers"); // Top level action import without parameter and with a collection of primitive return type ActionConfiguration topCollectionPrimitiveAction = builder.Action("CreateCollectionMessages"); topCollectionPrimitiveAction.ReturnsCollection <string>(); // Top level function import FunctionConfiguration getAllCustomers = builder.Function("GetAllConventionCustomers"); getAllCustomers.ReturnsCollectionFromEntitySet <ConventionCustomer>("ConventionCustomers"); // Top level function import with one parameter FunctionConfiguration getCustomersById = builder.Function("GetConventionCustomerById"); getCustomersById.IsComposable = true; getCustomersById.Parameter <int>("CustomerId"); getCustomersById.ReturnsFromEntitySet <ConventionCustomer>("ConventionCustomers"); // Top level function import with two parameters FunctionConfiguration getOrder = builder.Function("GetConventionOrderByCustomerIdAndOrderName"); getOrder.Parameter <int>("CustomerId"); getOrder.Parameter <string>("OrderName"); getOrder.ReturnsFromEntitySet <ConventionOrder>("ConventionOrders"); // Top level function import with complex parameter FunctionConfiguration complexFunction = builder.Function("ComplexFunction"); complexFunction.Parameter <ConventionAddress>("address"); complexFunction.Returns <string>(); // Top level function import with entity parameter FunctionConfiguration entityFunction = builder.Function("EntityFunction"); entityFunction.Parameter <ConventionOrder>("order"); entityFunction.Returns <string>(); // Top level function import with optional parameter FunctionConfiguration optionalFunction = builder.Function("OptionalFunction"); optionalFunction.Parameter <int>("param").HasDefaultValue("9"); optionalFunction.Returns <string>(); return(builder.GetEdmModel()); }
public void ModelBuilder_CanBuild_HttpErrorAsComplextype() { ODataModelBuilder modelBuilder = new ODataConventionModelBuilder(); modelBuilder.ComplexType <HttpError>(); var model = modelBuilder.GetEdmModel(); Assert.NotNull(model); }
public void Register(ODataConventionModelBuilder builder, ApiConfig apiConfig) { #region Category model builder.EntitySet <OrderDto>("Order"); builder.EntityType <OrderDto>().Count().Filter().OrderBy().Page(); builder.ComplexType <OrderDto.OrderItemDto>(); #endregion }
private static IEdmModel GetSampleModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<Person>(); // Employee is derived from Person. Employee has a property named manager it's Employee type. // It's not allowed to build inheritance complex type because a recursive loop of complex types is not allowed. builder.Ignore<Employee>(); return builder.GetEdmModel(); }
public void ReadFromStreamAsync_ForComplexType_WithNestedComplexType() { // Arrange const string content = "{\"value\":{" + "\"City\":\"UpdatedCity\"," + "\"Location\": {" + "\"Latitude\": 30.6," + "\"Longitude\": 101.313" + "}," + "\"SubLocation\": {" + // dynamic property "\"@odata.type\":\"#System.Web.OData.Formatter.Deserialization.Location\"," + "\"Latitude\": 15.5," + "\"Longitude\": 130.88" + "}" + "}}"; ODataComplexTypeDeserializer deserializer = new ODataComplexTypeDeserializer(new DefaultODataDeserializerProvider()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<Region>(); IEdmModel model = builder.GetEdmModel(); ODataDeserializerContext readContext = new ODataDeserializerContext { Model = model, ResourceType = typeof(Delta<Region>) }; // Act object value = deserializer.Read(GetODataMessageReader(GetODataMessage(content), model), typeof(Delta<Region>), readContext); // Assert Delta<Region> region = Assert.IsType<Delta<Region>>(value); Assert.NotNull(region); Assert.Equal(new[] { "City", "Location" }, region.GetChangedPropertyNames()); Assert.Empty(region.GetUnchangedPropertyNames()); object propertyValue; Assert.True(region.TryGetPropertyValue("City", out propertyValue)); string cityValue = Assert.IsType<string>(propertyValue); Assert.Equal("UpdatedCity", cityValue); Assert.True(region.TryGetPropertyValue("Location", out propertyValue)); Location locationValue = Assert.IsType<Location>(propertyValue); Assert.Equal(30.6, locationValue.Latitude); Assert.Equal(101.313, locationValue.Longitude); // dynamic property Assert.True(region.TryGetPropertyValue("SubLocation", out propertyValue)); locationValue = Assert.IsType<Location>(propertyValue); Assert.Equal(15.5, locationValue.Latitude); Assert.Equal(130.88, locationValue.Longitude); }
public void ReadFromStreamAsync_ForDerivedComplexType() { // Arrange const string content = "{" + "\"@odata.type\":\"System.Web.OData.Formatter.Serialization.Models.CnAddress\"," + "\"Street\":\"StreetValue\"," + "\"City\":\"CityValue\"," + "\"State\":\"MyState\"," + "\"ZipCode\":\"160202\"," + "\"Country\":\"MyCountry\"," + "\"CnProp\":\"8E8375AA-D348-49DD-94A0-46E4FB42973C\"" + "}"; ODataComplexTypeDeserializer deserializer = new ODataComplexTypeDeserializer(new DefaultODataDeserializerProvider()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<Address>(); IEdmModel model = builder.GetEdmModel(); ODataDeserializerContext readContext = new ODataDeserializerContext { Model = model, ResourceType = typeof(Address) }; // Act object value = deserializer.Read(GetODataMessageReader(GetODataMessage(content), model), typeof(Address), readContext); // Assert CnAddress address = Assert.IsType<CnAddress>(value); Assert.NotNull(address); Assert.Equal("StreetValue", address.Street); Assert.Equal("CityValue", address.City); Assert.Equal("MyState", address.State); Assert.Equal("160202", address.ZipCode); Assert.Equal("MyCountry", address.Country); Assert.Equal(new Guid("8E8375AA-D348-49DD-94A0-46E4FB42973C"), address.CnProp); }
private IEdmModel GetEdmModel(HttpConfiguration configuration) { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(configuration); builder.EntitySet<ConventionCustomer>("ConventionCustomers"); builder.EntitySet<ConventionOrder>("ConventionOrders"); builder.ComplexType<ConventionPerson>(); builder.Entity<ConventionCustomer>().ComplexProperty<ConventionAddress>(c => c.Address); // Top level action import ActionConfiguration createConventionCustomerById = builder.Action("CreateConventionCustomerById"); createConventionCustomerById.Parameter<int>("ID"); createConventionCustomerById.ReturnsFromEntitySet<ConventionCustomer>("ConventionCustomers"); // Top level action import without parameter and with a collection of primitive return type ActionConfiguration topCollectionPrimitiveAction = builder.Action("CreateCollectionMessages"); topCollectionPrimitiveAction.ReturnsCollection<string>(); // Top level function import FunctionConfiguration getAllCustomers = builder.Function("GetAllConventionCustomers"); getAllCustomers.ReturnsCollectionFromEntitySet<ConventionCustomer>("ConventionCustomers"); // Top level function import with one parameter FunctionConfiguration getCustomersById = builder.Function("GetConventionCustomerById"); getCustomersById.Parameter<int>("CustomerId"); getCustomersById.ReturnsFromEntitySet<ConventionCustomer>("ConventionCustomers"); // Top level function import with two parameters FunctionConfiguration getOrder = builder.Function("GetConventionOrderByCustomerIdAndOrderName"); getOrder.Parameter<int>("CustomerId"); getOrder.Parameter<string>("OrderName"); getOrder.ReturnsFromEntitySet<ConventionOrder>("ConventionOrders"); return builder.GetEdmModel(); }
public void DollarMetadata_Works_WithInheritanceOpenComplexType() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<FormatterAddress>(); IEdmModel model = builder.GetEdmModel(); var config = new[] { typeof(MetadataController) }.GetHttpConfiguration(); config.MapODataServiceRoute(model); HttpServer server = new HttpServer(config); HttpClient client = new HttpClient(server); // Act var response = client.GetAsync("http://localhost/$metadata").Result; // Assert Assert.True(response.IsSuccessStatusCode); Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType); Assert.Contains("<ComplexType Name=\"FormatterUsAddress\" BaseType=\"System.Web.OData.Formatter.FormatterAddress\" OpenType=\"true\">", response.Content.ReadAsStringAsync().Result); }
private static IEdmModel GetSampleModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<EnumComplex>(); FunctionConfiguration function = builder.Function("NullableEnumFunction").Returns<bool>(); function.Parameter<Color?>("ColorParameter"); return builder.GetEdmModel(); }
public void CreateResource_CreateDeltaWith_OpenComplexType() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<SimpleOpenAddress>(); IEdmModel model = builder.GetEdmModel(); IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex(); ODataDeserializerContext readContext = new ODataDeserializerContext { Model = model, ResourceType = typeof(Delta<SimpleOpenAddress>) }; var structuralProperties = addressTypeReference.StructuralProperties().Select(p => p.Name); // Act Delta<SimpleOpenAddress> resource = ODataComplexTypeDeserializer.CreateResource(addressTypeReference, readContext) as Delta<SimpleOpenAddress>; // Assert Assert.NotNull(resource); Assert.Equal(structuralProperties, resource.GetUnchangedPropertyNames()); }
public void ReadComplexValue_CanReadDerivedComplexValue() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<Address>(); IEdmModel model = builder.GetEdmModel(); IEdmComplexTypeReference addressEdmType = model.GetEdmTypeReference(typeof(Address)).AsComplex(); DefaultODataDeserializerProvider deserializerProvider = new DefaultODataDeserializerProvider(); ODataComplexTypeDeserializer deserializer = new ODataComplexTypeDeserializer(deserializerProvider); ODataComplexValue complexValue = new ODataComplexValue { Properties = new[] { new ODataProperty { Name = "Street", Value = "12"}, new ODataProperty { Name = "City", Value = "Redmond"}, new ODataProperty { Name = "UsProp", Value = "UsPropertyValue"} }, TypeName = typeof(UsAddress).FullName }; ODataDeserializerContext readContext = new ODataDeserializerContext { Model = model }; // Act object address = deserializer.ReadComplexValue(complexValue, addressEdmType, readContext); // Assert Assert.NotNull(address); UsAddress usAddress = Assert.IsType<UsAddress>(address); Assert.Equal(usAddress.Street, "12"); Assert.Equal(usAddress.City, "Redmond"); Assert.Null(usAddress.Country); Assert.Null(usAddress.State); Assert.Null(usAddress.ZipCode); Assert.Equal("UsPropertyValue", usAddress.UsProp); }
public void ReadFromStreamAsync_ForOpenComplexType() { // Arrange const string content = "{\"value\":{" + "\"Street\":\"MyStreet\"," + "\"City\":\"MyCity\"," + "\"[email protected]\":\"#Date\"," + "\"Publish\":\"2016-02-22\"" + "}}"; ODataComplexTypeDeserializer deserializer = new ODataComplexTypeDeserializer(new DefaultODataDeserializerProvider()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<SimpleOpenAddress>(); IEdmModel model = builder.GetEdmModel(); ODataDeserializerContext readContext = new ODataDeserializerContext { Model = model, ResourceType = typeof(SimpleOpenAddress) }; // Act object value = deserializer.Read(GetODataMessageReader(GetODataMessage(content), model), typeof(SimpleOpenAddress), readContext); // Assert SimpleOpenAddress address = Assert.IsType<SimpleOpenAddress>(value); Assert.NotNull(address); Assert.Equal("MyStreet", address.Street); Assert.Equal("MyCity", address.City); Assert.NotNull(address.Properties); KeyValuePair<string, object> dynamicProperty = Assert.Single(address.Properties); Assert.Equal("Publish", dynamicProperty.Key); Assert.Equal(new Date(2016, 2, 22), dynamicProperty.Value); }
public void DollarMetadata_Works_WithDerivedOpenComplexType() { // Arrange const string expectMetadata = @"<?xml version='1.0' encoding='utf-8'?> <edmx:Edmx Version='4.0' xmlns:edmx='http://docs.oasis-open.org/odata/ns/edmx'> <edmx:DataServices> <Schema Namespace='System.Web.OData.Formatter' xmlns='http://docs.oasis-open.org/odata/ns/edm'> <ComplexType Name='ComplexBaseType'> <Property Name='BaseProperty' Type='Edm.String' /> </ComplexType> <ComplexType Name='ComplexDerivedOpenType' BaseType='System.Web.OData.Formatter.ComplexBaseType' OpenType='true'> <Property Name='DerivedProperty' Type='Edm.String' /> </ComplexType> </Schema> <Schema Namespace='Default' xmlns='http://docs.oasis-open.org/odata/ns/edm'> <EntityContainer Name='Container' /> </Schema> </edmx:DataServices> </edmx:Edmx>"; ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<ComplexBaseType>(); IEdmModel model = builder.GetEdmModel(); var config = new[] { typeof(MetadataController) }.GetHttpConfiguration(); config.MapODataServiceRoute(model); HttpServer server = new HttpServer(config); HttpClient client = new HttpClient(server); // Act var response = client.GetAsync("http://localhost/$metadata").Result; // Assert Assert.True(response.IsSuccessStatusCode); Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType); Assert.Equal(expectMetadata.Replace("'", "\""), response.Content.ReadAsStringAsync().Result); }
private IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<EnumComplexWithRequiredEnum>(); builder.ComplexType<EnumComplexWithNullableEnum>(); return builder.GetEdmModel(); }
private static IEdmModel GetSampleModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<EnumComplex>(); return builder.GetEdmModel(); }
private IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.EntityType<Customer>().Namespace = "NS"; builder.ComplexType<Address>().Namespace = "NS"; FunctionConfiguration getEnum = builder.Function("GetEnum"); getEnum.Parameter<SimpleEnum>("simpleEnum"); getEnum.Returns<SimpleEnum>(); FunctionConfiguration getFlagsEnum = builder.Function("GetFlagsEnum"); getFlagsEnum.Parameter<FlagsEnum>("flagsEnum"); getFlagsEnum.Returns<FlagsEnum>(); FunctionConfiguration function = builder.Function("GetNullableFlagsEnum").Returns<bool>(); function.Parameter<FlagsEnum?>("flagsEnum"); builder.Function("GetAddress").Returns<bool>().Parameter<Address>("address"); builder.Function("GetCustomer").Returns<bool>().Parameter<Customer>("customer"); return builder.GetEdmModel(); }
public void ModelBuilder_CanBuild_HttpErrorAsComplextype() { ODataModelBuilder modelBuilder = new ODataConventionModelBuilder(); modelBuilder.ComplexType<HttpError>(); var model = modelBuilder.GetEdmModel(); Assert.NotNull(model); }
public void ReadFromStreamAsync_ForOpenComplexType_ForPatchModel() { // Arrange const string content = "{\"value\":{" + "\"Street\":\"UpdateStreet\"," + "\"[email protected]\":\"#Date\"," + "\"Publish\":\"2016-02-22\"" + "}}"; ODataComplexTypeDeserializer deserializer = new ODataComplexTypeDeserializer(new DefaultODataDeserializerProvider()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<SimpleOpenAddress>(); IEdmModel model = builder.GetEdmModel(); ODataDeserializerContext readContext = new ODataDeserializerContext { Model = model, ResourceType = typeof(Delta<SimpleOpenAddress>) }; // Act object value = deserializer.Read(GetODataMessageReader(GetODataMessage(content), model), typeof(Delta<SimpleOpenAddress>), readContext); // Assert Delta<SimpleOpenAddress> address = Assert.IsType<Delta<SimpleOpenAddress>>(value); Assert.NotNull(address); Assert.Equal(new[] { "Street" }, address.GetChangedPropertyNames()); Assert.Equal(new[] { "City" }, address.GetUnchangedPropertyNames()); SimpleOpenAddress origin = new SimpleOpenAddress(); Assert.Null(origin.Street); // guard Assert.Null(origin.City); // guard Assert.Null(origin.Properties); // guard address.Patch(origin); // DO PATCH Assert.Equal("UpdateStreet", origin.Street); Assert.Null(origin.City); // not changed KeyValuePair<string, object> dynamicProperty = Assert.Single(origin.Properties); Assert.Equal("Publish", dynamicProperty.Key); Assert.Equal(new Date(2016, 2, 22), dynamicProperty.Value); }
public void ODataConventionModelBuilder_CreateArrayEnumTypeCollectionPropertyWithInComplexType() { // Arrange var builder = new ODataConventionModelBuilder(); builder.ComplexType<ArrayEnumTypePropertyTestModel>(); IEdmModel model = builder.GetEdmModel(); IEdmComplexType complexType = model.SchemaElements.OfType<IEdmComplexType>().Single(); // Act & Assert Assert.Equal(3, complexType.Properties().Count()); var colors = complexType.Properties().SingleOrDefault(p => p.Name == "Colors"); Assert.NotNull(colors); Assert.True(colors.Type.IsCollection()); Assert.False(colors.Type.IsNullable); Assert.True(((IEdmCollectionTypeReference)colors.Type).ElementType().IsEnum()); var nullableColors = complexType.Properties().SingleOrDefault(p => p.Name == "NullableColors"); Assert.NotNull(nullableColors); Assert.True(nullableColors.Type.IsCollection()); Assert.True(nullableColors.Type.IsNullable); Assert.True(((IEdmCollectionTypeReference)nullableColors.Type).ElementType().IsEnum()); }
public void ReadComplexValue_CanReadDynamicPropertiesForOpenComplexType() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<SimpleOpenAddress>(); builder.EnumType<SimpleEnum>(); IEdmModel model = builder.GetEdmModel(); IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex(); var deserializerProvider = new Mock<ODataDeserializerProvider>().Object; var deserializer = new ODataComplexTypeDeserializer(deserializerProvider); ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName); ODataComplexValue complexValue = new ODataComplexValue { Properties = new[] { // declared properties new ODataProperty { Name = "Street", Value = "My Way #599" }, new ODataProperty { Name = "City", Value = "Redmond & Shanghai" }, // dynamic properties new ODataProperty { Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA") }, new ODataProperty { Name = "EnumValue", Value = enumValue }, new ODataProperty { Name = "DateTimeProperty", Value = new DateTimeOffset(new DateTime(1992, 1, 1)) } }, TypeName = typeof(SimpleOpenAddress).FullName }; ODataDeserializerContext readContext = new ODataDeserializerContext() { Model = model }; // Act SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext) as SimpleOpenAddress; // Assert Assert.NotNull(address); // Verify the declared properties Assert.Equal("My Way #599", address.Street); Assert.Equal("Redmond & Shanghai", address.City); // Verify the dynamic properties Assert.NotNull(address.Properties); Assert.Equal(3, address.Properties.Count()); Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), address.Properties["GuidProperty"]); Assert.Equal(SimpleEnum.Third, address.Properties["EnumValue"]); Assert.Equal(new DateTimeOffset(new DateTime(1992, 1, 1)), address.Properties["DateTimeProperty"]); }
public void ReadComplexValue_CanReadDateTimeRelatedProperties() { // Arrange var builder = new ODataConventionModelBuilder(); builder.ComplexType<MyAddress>().Namespace = "NS"; IEdmModel model = builder.GetEdmModel(); var addressEdmType = model.GetEdmTypeReference(typeof(MyAddress)).AsComplex(); var deserializerProvider = new Mock<ODataDeserializerProvider>().Object; var deserializer = new ODataComplexTypeDeserializer(deserializerProvider); ODataComplexValue complexValue = new ODataComplexValue { Properties = new[] { new ODataProperty { Name = "CreatedDay", Value = new Date(2015, 12, 12)}, new ODataProperty { Name = "EndTime", Value = new TimeOfDay(1, 2, 3, 4)} }, TypeName = "NS.MyAddress" }; ODataDeserializerContext readContext = new ODataDeserializerContext() { Model = model }; // Act var address = deserializer.ReadComplexValue(complexValue, addressEdmType, readContext) as MyAddress; // Assert Assert.NotNull(address); Assert.Equal(new DateTime(2015, 12, 12), address.CreatedDay); Assert.Equal(new TimeSpan(0, 1, 2, 3, 4), address.EndTime); }
private IEdmStructuredType AddComplexTypeWithODataConventionModelBuilder() { var builder = new ODataConventionModelBuilder(); builder.ComplexType<ComplexTypeWithEnumTypePropertyTestModel>(); IEdmModel model = builder.GetEdmModel(); return model.SchemaElements.OfType<IEdmStructuredType>().Single(); }
public void ReadComplexValue_CanReadNestedOpenComplexType() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<SimpleOpenAddress>(); builder.ComplexType<SimpleOpenZipCode>(); IEdmModel model = builder.GetEdmModel(); IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex(); var deserializerProvider = new DefaultODataDeserializerProvider(); var deserializer = new ODataComplexTypeDeserializer(deserializerProvider); ODataComplexValue zipCodeComplexValue = new ODataComplexValue { Properties = new[] { // declared property new ODataProperty { Name = "Code", Value = 101 }, // dynamic property new ODataProperty { Name = "DateTimeProperty", Value = new DateTimeOffset(new DateTime(2014, 4, 22)) } }, TypeName = typeof(SimpleOpenZipCode).FullName }; ODataComplexValue addressComplexValue = new ODataComplexValue { Properties = new[] { // declared properties new ODataProperty { Name = "Street", Value = "TopStreet" }, new ODataProperty { Name = "City", Value = "TopCity" }, // dynamic properties new ODataProperty { Name = "DoubleProperty", Value = 1.179 }, new ODataProperty { Name = "ZipCodeProperty", Value = zipCodeComplexValue } }, TypeName = typeof(SimpleOpenAddress).FullName }; ODataDeserializerContext readContext = new ODataDeserializerContext() { Model = model }; // Act SimpleOpenAddress address = deserializer.ReadComplexValue(addressComplexValue, addressTypeReference, readContext) as SimpleOpenAddress; // Assert Assert.NotNull(address); // Verify the declared properties Assert.Equal("TopStreet", address.Street); Assert.Equal("TopCity", address.City); // Verify the dynamic properties Assert.NotNull(address.Properties); Assert.Equal(2, address.Properties.Count()); Assert.Equal(1.179, address.Properties["DoubleProperty"]); // nested open complex type SimpleOpenZipCode zipCode = Assert.IsType<SimpleOpenZipCode>(address.Properties["ZipCodeProperty"]); Assert.Equal(101, zipCode.Code); Assert.Equal(1, zipCode.Properties.Count()); Assert.Equal(new DateTimeOffset(new DateTime(2014, 4, 22)), zipCode.Properties["DateTimeProperty"]); }
public void ReadComplexValue_CanReadDynamicCollectionPropertiesForOpenComplexType() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<SimpleOpenAddress>(); builder.EnumType<SimpleEnum>(); IEdmModel model = builder.GetEdmModel(); IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex(); var deserializerProvider = new DefaultODataDeserializerProvider(); var deserializer = new ODataComplexTypeDeserializer(deserializerProvider); ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName); ODataCollectionValue collectionValue = new ODataCollectionValue { TypeName = "Collection(" + typeof(SimpleEnum).FullName + ")", Items = new[] { enumValue, enumValue } }; ODataComplexValue complexValue = new ODataComplexValue { Properties = new[] { // declared properties new ODataProperty { Name = "Street", Value = "My Way #599" }, // dynamic properties new ODataProperty { Name = "CollectionProperty", Value = collectionValue } }, TypeName = typeof(SimpleOpenAddress).FullName }; ODataDeserializerContext readContext = new ODataDeserializerContext() { Model = model }; // Act SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext) as SimpleOpenAddress; // Assert Assert.NotNull(address); // Verify the declared properties Assert.Equal("My Way #599", address.Street); Assert.Null(address.City); // Verify the dynamic properties Assert.NotNull(address.Properties); Assert.Equal(1, address.Properties.Count()); var collectionValues = Assert.IsType<List<SimpleEnum>>(address.Properties["CollectionProperty"]); Assert.NotNull(collectionValues); Assert.Equal(2, collectionValues.Count()); Assert.Equal(SimpleEnum.Third, collectionValues[0]); Assert.Equal(SimpleEnum.Third, collectionValues[1]); }
public void ReadComplexValue_Throws_IfDuplicateDynamicPropertyNameFound() { // Arrange ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.ComplexType<SimpleOpenAddress>(); IEdmModel model = builder.GetEdmModel(); IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex(); var deserializerProvider = new Mock<ODataDeserializerProvider>().Object; var deserializer = new ODataComplexTypeDeserializer(deserializerProvider); ODataComplexValue complexValue = new ODataComplexValue { Properties = new[] { // declared properties new ODataProperty { Name = "Street", Value = "My Way #599" }, new ODataProperty { Name = "City", Value = "Redmond & Shanghai" }, // dynamic properties new ODataProperty { Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA") }, new ODataProperty { Name = "GuidProperty", Value = new DateTimeOffset(new DateTime(1992, 1, 1)) } }, TypeName = typeof(SimpleOpenAddress).FullName }; ODataDeserializerContext readContext = new ODataDeserializerContext() { Model = model }; // Act & Assert Assert.Throws<InvalidOperationException>(() => deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext), "Duplicate dynamic property name 'GuidProperty' found in open type 'System.Web.OData.SimpleOpenAddress'. " + "Each dynamic property name must be unique."); }
public static IEdmModel GetEdmModel() { ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); EntitySetConfiguration<Employee> entitySetConfiguration = builder.EntitySet<Employee>("Employees"); EntityTypeConfiguration<Manager> entityTypeConfigurationOfManager = builder.EntityType<Manager>(); EntityTypeConfiguration<Employee> entityTypeConfigurationOfEmployee = builder.EntityType<Employee>(); #region functions // Function bound to a collection of base EntityType. entityTypeConfigurationOfEmployee.Collection.Function("GetCount") .Returns<int>(); // Overload entityTypeConfigurationOfEmployee.Collection.Function("GetCount") .Returns<int>() .Parameter<string>("Name"); // Function bound to a collection of derived EntityType. entityTypeConfigurationOfManager.Collection.Function("GetCount") .Returns<int>(); // Function bound to an base EntityType entityTypeConfigurationOfEmployee.Function("GetEmailsCount") .Returns<int>(); entityTypeConfigurationOfEmployee.Function("GetOptionalAddresses") .ReturnsCollection<Address>() .IsComposable = true; entityTypeConfigurationOfEmployee.Function("GetEmails") .ReturnsCollection<string>() .IsComposable = false; // Function bound to a derived EntityType entityTypeConfigurationOfManager.Function("GetEmailsCount") .Returns<int>(); // Function with primitive and collection of primitive parameters var function = entityTypeConfigurationOfEmployee.Collection.Function("PrimitiveFunction").Returns<string>(); function.Parameter<int>("param"); function.Parameter<double?>("price"); // nullable function.Parameter<string>("name"); // nullable function.CollectionParameter<string>("names"); // collection with nullable element // Function with Enum and collection of Enum parameters function = entityTypeConfigurationOfEmployee.Collection.Function("EnumFunction").Returns<string>(); function.Parameter<Color>("bkColor"); function.Parameter<Color?>("frColor"); // nullable function.CollectionParameter<Color>("colors"); // collection with non-nullable element // Function with complex and collection of complex parameters function = entityTypeConfigurationOfEmployee.Collection.Function("ComplexFunction").ReturnsCollection<Address>(); function.Parameter<Address>("address").OptionalParameter = false; function.Parameter<Address>("location"); // nullable function.CollectionParameter<Address>("addresses"); // collection with nullable element // Function with entity and collection of entity parameters function = entityTypeConfigurationOfEmployee.Collection.Function("EntityFunction").Returns<string>(); function.EntityParameter<Employee>("person").OptionalParameter = false; function.EntityParameter<Employee>("guard"); // nullable function.CollectionEntityParameter<Employee>("staff"); // collection with nullable element #endregion #region actions // Action bound to a collection of base EntityType entityTypeConfigurationOfEmployee.Collection.Action("IncreaseSalary") .ReturnsCollectionFromEntitySet(entitySetConfiguration) .Parameter<string>("Name"); // Action bound to a collection of derived EntityType entityTypeConfigurationOfManager.Collection.Action("IncreaseSalary") .ReturnsCollectionFromEntitySet(entitySetConfiguration) .Parameter<string>("Name"); // Action bound to a base EntityType entityTypeConfigurationOfEmployee.Action("IncreaseSalary") .Returns<int>(); // Action bound to a derived EntityType entityTypeConfigurationOfManager.Action("IncreaseSalary") .Returns<int>(); // Action with primitive and collection of primitive parameters var action = entityTypeConfigurationOfEmployee.Collection.Action("PrimitiveAction"); action.Parameter<int>("param"); action.Parameter<double?>("price"); // nullable action.Parameter<string>("name"); // nullable action.CollectionParameter<string>("names"); // collection with nullable element // Action with Enum and collection of Enum parameters action = entityTypeConfigurationOfEmployee.Collection.Action("EnumAction"); action.Parameter<Color>("bkColor"); action.Parameter<Color?>("frColor"); // nullable action.CollectionParameter<Color>("colors"); // collection with non-nullable element // Action with complex and collection of complex parameters action = entityTypeConfigurationOfEmployee.Collection.Action("ComplexAction"); action.Parameter<Address>("address").OptionalParameter = false; action.Parameter<Address>("location"); // nullable action.CollectionParameter<Address>("addresses"); // collection with nullable element // Action with entity and collection of entity parameters action = entityTypeConfigurationOfEmployee.Collection.Action("EntityAction"); action.EntityParameter<Employee>("person").OptionalParameter = false; action.EntityParameter<Employee>("guard"); // nullable action.CollectionEntityParameter<Employee>("staff"); // collection with nullable element #endregion builder.Action("ResetDataSource"); builder.EnumType<Color>().Namespace = "NS"; builder.ComplexType<Address>().Namespace = "NS"; builder.ComplexType<SubAddress>().Namespace = "NS"; builder.EntityType<Employee>().Namespace = "NS"; builder.EntityType<Manager>().Namespace = "NS"; return builder.GetEdmModel(); }
private static HttpServer CreateServer(string customersEntitySet) { HttpConfiguration configuration = new HttpConfiguration(); // We need to do this to avoid controllers with incorrect attribute // routing configuration in this assembly that cause an exception to // be thrown at runtime. With this, we restrict the test to the following // set of controllers. configuration.Services.Replace( typeof(IAssembliesResolver), new TestAssemblyResolver( typeof(OnlyFilterAllowedCustomersController), typeof(OnlyFilterAndEqualsAllowedCustomersController), typeof(FilterDisabledCustomersController), typeof(EverythingAllowedCustomersController), typeof(OtherLimitationsCustomersController))); ODataModelBuilder builder = new ODataConventionModelBuilder(); builder.EntitySet<EnableQueryCustomer>(customersEntitySet); builder.EntityType<PremiumEnableQueryCustomer>(); builder.EntitySet<EnableQueryCategory>("EnableQueryCategories"); builder.EntityType<PremiumEnableQueryCategory>(); builder.EntitySet<EnableQueryOrder>("EnableQueryOrders"); builder.EntityType<DiscountedEnableQueryOrder>(); builder.EntitySet<EnableQueryOrderLine>("EnableQueryOrderLines"); builder.ComplexType<EnableQueryAddress>(); IEdmModel model = builder.GetEdmModel(); configuration.MapODataServiceRoute("odata", "odata", model); return new HttpServer(configuration); }