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);
}
