public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var newFormater = new CsvTextMediaFormatter();
newFormater.MediaTypeMappings.Add(new QueryStringMapping("frmt", "fwt", new MediaTypeHeaderValue("text/plain")));
config.Formatters.Add(newFormater);
config.Formatters.JsonFormatter.MediaTypeMappings.Add(
new QueryStringMapping("frmt", "json",
new MediaTypeHeaderValue("application/json")));
config.Formatters.XmlFormatter.MediaTypeMappings.Add(
new QueryStringMapping("frmt", "xml",
new MediaTypeHeaderValue("application/xml")));
// Serialize les types complexes qui sont rattachés à l'objet
//var json = config.Formatters.JsonFormatter;
//json.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects;
//config.Formatters.Remove(config.Formatters.XmlFormatter);
// New code:
// Odata
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Individual>("Individuals");
builder.EntitySet<Contract>("Contracts");
ODataHttpRouteCollectionExtensions.MapODataRoute(config.Routes, routeName: "ODataRoute", routePrefix: "odata", model: builder.GetEdmModel());
builder.Entity<Individual>().Ignore(item => item.Contracts);
builder.Entity<Contract>().Ignore(item => item.Individual);
}
internal static void ModelBuilder(ODataConventionModelBuilder builder)
{
var EntitySetName = "Jobs";
builder.EntitySet<Job>(EntitySetName);
builder.Entity<Job>().Action("Run").Returns<String>();
builder.Entity<Job>().Action("Finish").Returns<String>();
}
internal static void ModelBuilder(ODataConventionModelBuilder builder)
{
var EntitySetName = "LifeCycles";
builder.EntitySet<LifeCycle>(EntitySetName);
builder.Entity<LifeCycle>().Action("Next").Returns<String>();
builder.Entity<LifeCycle>().Action("Cancel").Returns<String>();
builder.Entity<LifeCycle>().Action("Allow").Returns<String>();
builder.Entity<LifeCycle>().Action("Decline").Returns<String>();
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.ContainerName = "Container";
builder.Namespace = "org.odata";
// Action with no overloads
builder.EntitySet<Vehicle>("Vehicles").EntityType.Action("Drive");
// Valid overloads of "Wash" bound to different entities
builder.Entity<Motorcycle>().Action("Wash");
builder.Entity<Car>().Action("Wash");
// Invalid overloads of "Park"
builder.Entity<Car>().Action("Park");
builder.Entity<Car>().Action("Park").Parameter<string>("mood");
return builder.GetEdmModel();
}
public static void Register(HttpConfiguration config)
{
// standard Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// OData
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Invoice>("Invoices");
// OData Action
ActionConfiguration purchase = builder.Entity<Customer>().Action("Purchase");
purchase.Parameter<int>("AmountOfShoes");
purchase.ReturnsFromEntitySet<Invoice>("Invoices");
config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel());
// OData with fixed metadata
// see: http://www.getbreezenow.com/documentation/odata-server
config.Routes.MapODataServiceRoute("odataFixed", "odataFixed", EdmBuilder.GetEdm<DataContext>(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
var pets = builder.EntitySet<Pet>("Pets");
builder.Entity<BigPet>();
return builder.GetEdmModel();
}
private static IEdmModel GetInheritanceModel(HttpConfiguration config)
{
ODataModelBuilder builder = new ODataConventionModelBuilder(config);
var baseEntitySet = builder.EntitySet<BaseEntity>("BaseEntity");
var derivedEntityType = builder.Entity<DerivedEntity>().DerivesFrom<BaseEntity>();
return builder.GetEdmModel();
}
public static void Register( HttpConfiguration config ) {
config.EnableCors();
config.MapHttpAttributeRoutes();
// To prevent Error: Self referencing loop
config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Serialize;
config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<IUser>( "Users" );
builder.EntitySet<WebUser>( "WebUsers" );
builder.EntitySet<Guest>( "Guests" );
builder.EntitySet<Login>( "LoginSet" );
builder.EntitySet<Permission>( "PermissionSet" );
builder.EntitySet<Role>( "RoleSet" );
builder.EntitySet<Address>( "AddressSet" );
builder.EntitySet<Credential>( "CredentialSet" );
builder.EntitySet<Task>( "TaskSet" );
builder.Namespace = "OdataApi.Controllers";
builder.Entity<WebUser>().Action( "Post" ).Parameter<int>( "Rating" );
config.Routes.MapODataServiceRoute( "odata", "odata", builder.GetEdmModel() );
}
internal static ODataQueryContext CreateCustomerContext()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<QueryCompositionCustomer>("Customer");
builder.Entity<QueryCompositionCustomerBase>();
IEdmModel model = builder.GetEdmModel();
return new ODataQueryContext(model, typeof(QueryCompositionCustomer));
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<AROCustomer>("AROCustomers");
builder.Entity<AROVipCustomer>().DerivesFrom<AROCustomer>();
builder.EntitySet<AROAddress>("AROAddresses");
builder.EntitySet<AROOrder>("Orders");
return builder.GetEdmModel();
}
public void ShouldIgnoreStaticProperty()
{
ODataModelBuilder modelBuilder = new ODataConventionModelBuilder();
modelBuilder.Entity<ImplicitModelBuilder_EntityWithStaticProperty>();
var model = modelBuilder.GetEdmModel();
var actual = model.SchemaElements.Where(e => e.Name == typeof(ImplicitModelBuilder_EntityWithStaticProperty).Name).OfType<EdmEntityType>().Single();
Assert.Equal(1, actual.Properties().Count());
}
private static IEdmModel GetCustomersModel()
{
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(typeof(QueryCompositionCustomer)));
ODataConventionModelBuilder builder = new ODataConventionModelBuilder(configuration);
builder.EntitySet<QueryCompositionCustomer>("Customer");
builder.Entity<QueryCompositionCustomerBase>();
return builder.GetEdmModel();
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration<Customer> customers = builder.EntitySet<Customer>("Customers");
EntityTypeConfiguration<VipCustomer> vipCustoemer = builder.Entity<VipCustomer>().DerivesFrom<Customer>();
EntitySetConfiguration<Order> orders = builder.EntitySet<Order>("Orders");
EntitySetConfiguration<Address> address = builder.EntitySet<Address>("Addresses");
EntitySetConfiguration<PersonalInformation> information = builder.EntitySet<PersonalInformation>("Informations");
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel(HttpConfiguration configuration)
{
ODataModelBuilder builder = new ODataConventionModelBuilder(configuration);
EntitySetConfiguration<SingleResultCustomer> customers = builder.EntitySet<SingleResultCustomer>("SingleResultCustomers");
EntitySetConfiguration<SingleResultOrderDetail> orderDetails = builder.EntitySet<SingleResultOrderDetail>("SingleResultOrderDetail");
EntityTypeConfiguration<SingleResultPremiumCustomer> premiumCustomer = builder.Entity<SingleResultPremiumCustomer>();
customers.EntityType.Action("CreditRating").Returns<double>();
EntitySetConfiguration<SingleResultOrder> orders = builder.EntitySet<SingleResultOrder>("SingleResultOrder");
EntitySetConfiguration<SingleResultBonus> bonuses = builder.EntitySet<SingleResultBonus>("SingleResultBonus");
IEdmModel model = builder.GetEdmModel();
return model;
}
public static IEdmModel GetActionsModel(HttpConfiguration config)
{
ODataModelBuilder builder = new ODataConventionModelBuilder(config);
var baseEntitySet = builder.EntitySet<BaseEntity>("BaseEntity");
var alwaysAvailableActionBaseType = baseEntitySet.EntityType.Action("AlwaysAvailableActionBaseType");
var transientActionBaseType = baseEntitySet.EntityType.TransientAction("TransientActionBaseType");
Func<EntityInstanceContext, Uri> transientActionBaseTypeLinkFactory = eic =>
{
IEdmEntityType baseType = eic.EdmModel.FindType(typeof(BaseEntity).FullName) as IEdmEntityType;
object id;
eic.EdmObject.TryGetPropertyValue("Id", out id);
if (!eic.EntityType.IsOrInheritsFrom(baseType) || (int)id % 2 == 1)
{
return null;
}
else
{
IList<ODataPathSegment> segments = new List<ODataPathSegment>();
segments.Add(new EntitySetPathSegment(eic.EntitySet));
segments.Add(new KeyValuePathSegment(id.ToString()));
segments.Add(new ActionPathSegment("TransientActionBaseType"));
string link = eic.Url.CreateODataLink("Actions", eic.Request.ODataProperties().PathHandler, segments);
return new Uri(link);
}
};
transientActionBaseType.HasActionLink(transientActionBaseTypeLinkFactory, true);
var derivedEntityType = builder.Entity<DerivedEntity>().DerivesFrom<BaseEntity>();
var alwaysAvailableActionDerivedType = derivedEntityType.Action("AlwaysAvailableActionDerivedType");
var transientActionDerivedType = derivedEntityType.TransientAction("TransientActionDerivedType");
Func<EntityInstanceContext, Uri> transientActionDerivedTypeLinkFactory = eic =>
{
IEdmEntityType derivedType = eic.EdmModel.FindType(typeof(DerivedEntity).FullName) as IEdmEntityType;
object id;
eic.EdmObject.TryGetPropertyValue("Id", out id);
if (!eic.EntityType.IsOrInheritsFrom(derivedType) || (int)id % 2 == 1)
{
return null;
}
else
{
IList<ODataPathSegment> segments = new List<ODataPathSegment>();
segments.Add(new EntitySetPathSegment(eic.EntitySet));
segments.Add(new KeyValuePathSegment(id.ToString()));
segments.Add(new CastPathSegment(derivedType.FullName()));
segments.Add(new ActionPathSegment("TransientActionDerivedType"));
string link = eic.Url.CreateODataLink("Actions", eic.Request.ODataProperties().PathHandler, segments);
return new Uri(link);
}
};
transientActionDerivedType.HasActionLink(transientActionDerivedTypeLinkFactory, true);
return builder.GetEdmModel();
}
public static void Register(HttpConfiguration config)
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Product>("Products");
builder.EntitySet<Supplier>("Suppliers");
builder.EntitySet<ProductRating>("Ratings");
ActionConfiguration rateProduct = builder.Entity<Product>().Action("RateProduct");
rateProduct.Parameter<int>("Rating");
rateProduct.Returns<double>();
config.Routes.MapODataRoute("odata", "odata", builder.GetEdmModel());
}
private void SetAction(ODataConventionModelBuilder modelBuilder)
{
//管理员登陆
var signin = modelBuilder.Entity<User>().Action("Signin");
signin.Parameter<string>("Username");
signin.Parameter<string>("Password");
signin.Parameter<bool>("IsRemember");
//管理员注销
var signout = modelBuilder.Entity<User>().Action("Signout");
//增加文章浏览数
var browsed = modelBuilder.Entity<Post>().Action("Browsed");
//增加文章评论数
var commented = modelBuilder.Entity<Post>().Action("Commented");
modelBuilder.Entity<Post>().Action("Remove");
modelBuilder.Entity<Post>().Action("Recover");
modelBuilder.Entity<Comment>().Action("Remove");
modelBuilder.Entity<Comment>().Action("Recover");
modelBuilder.Entity<Board>().Action("Remove");
modelBuilder.Entity<Board>().Action("Recover");
}
private static IEdmModel GenerateEntityDataModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Employee>("Employees");
builder.EntitySet<Address>("Addresses");
var companies = builder.EntitySet<Company>("Companies");
// Define a custom action on Companies
var addCompanyEmployeeByIdAction = builder.Entity<Company>().Action("AddCompanyEmployee");
addCompanyEmployeeByIdAction.Parameter<string>("name");
addCompanyEmployeeByIdAction.Parameter<string>("surname");
addCompanyEmployeeByIdAction.Parameter<string>("email");
addCompanyEmployeeByIdAction.Parameter<int>("address");
addCompanyEmployeeByIdAction.ReturnsFromEntitySet<Employee>("Employees");
return builder.GetEdmModel();
}
public static void PreStart() {
var builderV3 = new ODataConventionModelBuilder();
var entitySetConfigV3 = builderV3.EntitySet<ODataTodoItem>("ODataTodos");
entitySetConfigV3.EntityType.HasKey(t => t.Id);
// Add the reset action to the EDM
var reset = builderV3.Entity<ODataTodoItem>().Collection.Action("Reset");
reset.Returns<string>();
GlobalConfiguration.Configuration.Routes.MapODataServiceRoute(
routeName: "odata",
routePrefix: "odata",
model: builderV3.GetEdmModel(),
batchHandler: new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
}
public static void Register(HttpConfiguration config)
{
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.Namespace = "MyNamespace";
modelBuilder.ContainerName = "MyContainer";
modelBuilder.EntitySet<MyEntity>("MyEntities");
var action = modelBuilder.Entity<MyEntity>().Action("MyAction");
action.Returns<string>();
foreach (var structuralType in modelBuilder.StructuralTypes)
{
// Resets the namespace so that the service contains only 1 namespace.
structuralType.GetType().GetProperty("Namespace").SetValue(structuralType, "MyNamespace");
}
var model = modelBuilder.GetEdmModel();
config.Routes.MapODataServiceRoute("OData", "odata", model);
}
public void DollarMetadata_Works_WithPrincipalKeyOnBaseType_ButBaseTypeNotInEdmModel(Type entityType)
{
// Arrange
const string expect =
" <Association Name=\"System_Web_Http_OData_Formatter_DependentEntity_DerivedProp_System_Web_Http_OData_Formatter_DerivedPrincipalEntity_DerivedPropPartner\">\r\n" +
" <End Type=\"System.Web.Http.OData.Formatter.DerivedPrincipalEntity\" Role=\"DerivedProp\" Multiplicity=\"0..1\" />\r\n" +
" <End Type=\"System.Web.Http.OData.Formatter.DependentEntity\" Role=\"DerivedPropPartner\" Multiplicity=\"0..1\" />\r\n" +
" <ReferentialConstraint>\r\n" +
" <Principal Role=\"DerivedProp\">\r\n" +
" <PropertyRef Name=\"Id\" />\r\n" +
" </Principal>\r\n" +
" <Dependent Role=\"DerivedPropPartner\">\r\n" +
" <PropertyRef Name=\"DerivedPrincipalEntityId\" />\r\n" +
" </Dependent>\r\n" +
" </ReferentialConstraint>\r\n" +
" </Association>";
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.AddEntity(entityType);
builder.Entity <DependentEntity>();
IEdmModel model = builder.GetEdmModel();
HttpServer server = new HttpServer();
server.Configuration.Routes.MapODataServiceRoute("odata", "odata", model);
HttpClient client = new HttpClient(server);
// Act
HttpResponseMessage response = client.GetAsync("http://localhost/odata/$metadata").Result;
// Assert
Assert.True(response.IsSuccessStatusCode);
Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
Assert.Contains(expect, response.Content.ReadAsStringAsync().Result);
}
public void SelectExpandClause_CanParse_ModelBuiltForQueryable(string select, string expand)
{
// Arrange
HttpConfiguration config = new HttpConfiguration();
config.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver());
ODataConventionModelBuilder builder = new ODataConventionModelBuilder(new HttpConfiguration(), isQueryCompositionMode: true);
builder.Entity<Customer>();
IEdmModel model = builder.GetEdmModel();
ODataQueryContext context = new ODataQueryContext(model, typeof(Customer));
SelectExpandQueryOption option = new SelectExpandQueryOption(select, expand, context);
// Act & Assert
Assert.DoesNotThrow(() => option.SelectExpandClause.ToString());
}
public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi2",
routeTemplate: "api/{controller}/TestItemTypes/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "DefaultApi3",
routeTemplate: "api/{controller}/CollectionProps/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
var cset = modelBuilder.EntitySet<Category>("Categories");
cset.EntityType.HasKey(a => a.Id);
var aset = modelBuilder.EntitySet<Article>("Articles");
aset.EntityType.HasKey(a => a.Id);
var uset = modelBuilder.EntitySet<User>("Users");
uset.EntityType.HasKey(a => a.Id);
var tcset = modelBuilder.EntitySet<TagConnection>("TagConnections");
tcset.EntityType.HasKey(a => a.Id);
var tset = modelBuilder.EntitySet<Tag>("Tags");
tset.EntityType.HasKey(a => a.Id);
var upset = modelBuilder.EntitySet<UserProfile>("UserProfiles");
upset.EntityType.HasKey(a => a.Id);
var action = modelBuilder.Entity<Category>().Action("GetFirstArticleTitle");
action.Parameter<string>("contains");
action.Returns<string>();
//var action2 = modelBuilder.Entity<Category>().TransientAction("GetFirstArticleTitle2");
//action2.Parameter<string>("contains");
//action2.Returns<string>();
var action3 = modelBuilder.Entity<Category>().Collection.Action("GetFirstArticleTitle");
action3.Parameter<string>("contains");
action3.Returns<string>();
//var action4 = modelBuilder.Action("GetFirstArticleTitle4");
//action4.Parameter<string>("contains");
//action4.Returns<string>();
var action5 = modelBuilder.Entity<Category>().Action("LocationSwipe");
action5.Parameter<GeographyPoint>("Loc");
action5.Returns<GeographyPoint>();
IEdmModel model = modelBuilder.GetEdmModel();
config.Routes.MapODataRoute(routeName: "OData", routePrefix: "odata", model: model);
ODataConventionModelBuilder modelBuilderInheriance = new ODataConventionModelBuilder();
var car = modelBuilderInheriance.EntitySet<Car>("Cars");
car.EntityType.DerivesFrom<Vehicle>();
var carAction = car.EntityType.Collection.Action("Reset");
carAction.Returns<bool>();
var bike = modelBuilderInheriance.EntitySet<Bike>("Bikes");
bike.EntityType.DerivesFrom<Vehicle>();
var ship = modelBuilderInheriance.EntitySet<Ship>("Ships");
IEdmModel modelInheritance = modelBuilderInheriance.GetEdmModel();
config.Routes.MapODataRoute(routeName: "ODataInheritance", routePrefix: "odatainheritance", model: modelInheritance);
ODataConventionModelBuilder modelBuilderGeoData = new ODataConventionModelBuilder();
var place = modelBuilderGeoData.EntitySet<Place>("Places");
IEdmModel modelGeoData = modelBuilderGeoData.GetEdmModel();
config.Routes.MapODataRoute(routeName: "ODataGeoData", routePrefix: "odatageo", model: modelGeoData);
ODataConventionModelBuilder modelBuilderPrimitives = new ODataConventionModelBuilder();
var prim = modelBuilderPrimitives.EntitySet<TestItemType>("TestItemTypes");
IEdmModel modelprim = modelBuilderPrimitives.GetEdmModel();
config.Routes.MapODataRoute(routeName: "ODataprim", routePrefix: "odataprim", model: modelprim);
ODataConventionModelBuilder modelBuilderColl = new ODataConventionModelBuilder();
var coll = modelBuilderColl.EntitySet<TestEntity>("CollectionProps");
IEdmModel modelcoll = modelBuilderColl.GetEdmModel();
config.Routes.MapODataRoute(routeName: "ODatacoll", routePrefix: "odatacoll", model: modelcoll);
}
public void DollarMetadata_Works_WithPrincipalKeyOnBaseType_ButBaseTypeNotInEdmModel(Type entityType)
{
// Arrange
const string expect =
" <Association Name=\"System_Web_Http_OData_Formatter_DependentEntity_DerivedProp_System_Web_Http_OData_Formatter_DerivedPrincipalEntity_DerivedPropPartner\">\r\n" +
" <End Type=\"System.Web.Http.OData.Formatter.DerivedPrincipalEntity\" Role=\"DerivedProp\" Multiplicity=\"0..1\" />\r\n" +
" <End Type=\"System.Web.Http.OData.Formatter.DependentEntity\" Role=\"DerivedPropPartner\" Multiplicity=\"0..1\" />\r\n" +
" <ReferentialConstraint>\r\n" +
" <Principal Role=\"DerivedProp\">\r\n" +
" <PropertyRef Name=\"Id\" />\r\n" +
" </Principal>\r\n" +
" <Dependent Role=\"DerivedPropPartner\">\r\n" +
" <PropertyRef Name=\"DerivedPrincipalEntityId\" />\r\n" +
" </Dependent>\r\n" +
" </ReferentialConstraint>\r\n" +
" </Association>";
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.AddEntity(entityType);
builder.Entity<DependentEntity>();
IEdmModel model = builder.GetEdmModel();
HttpServer server = new HttpServer();
server.Configuration.Routes.MapODataServiceRoute("odata", "odata", model);
HttpClient client = new HttpClient(server);
// Act
HttpResponseMessage response = client.GetAsync("http://localhost/odata/$metadata").Result;
// Assert
Assert.True(response.IsSuccessStatusCode);
Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
Assert.Contains(expect, response.Content.ReadAsStringAsync().Result);
}
public void ChangeBaseTypeShouldWork()
{
HttpConfiguration config = new HttpConfiguration();
ODataConventionModelBuilder mb = new ODataConventionModelBuilder(config);
mb.EntitySet<Vehicle>("Vehicles");
mb.Entity<SportBike>().DerivesFrom<Vehicle>();
var model = mb.GetEdmModel();
var sportBike = model.SchemaElements.First(e => e.Name == typeof(SportBike).Name) as EdmEntityType;
Assert.Equal(typeof(Vehicle).Name, ((EdmEntityType)sportBike.BaseType).Name);
}
public void ChangeRequiredOnNavigationPropertyShouldWork()
{
HttpConfiguration config = new HttpConfiguration();
ODataConventionModelBuilder mb = new ODataConventionModelBuilder(config);
mb.Entity<Product>().HasRequired(p => p.Family);
//mb.EntitySet<Product>("Products");
var model = mb.GetEdmModel();
var product = model.SchemaElements.First(e => e.Name == typeof(Product).Name) as EdmEntityType;
var familyProperty = product.Properties().Single(p => p.Name == "Family") as EdmNavigationProperty;
Assert.Equal(EdmMultiplicity.One, familyProperty.Partner.Multiplicity());
}
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);
}
private static IEdmModel SetupModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
// Different types of navigation sources and navigation properties.
builder.EntitySet<ETagCustomer>("Customers");
builder.EntitySet<ETagOrder>("Orders");
builder.Entity<ETagSpecialOrder>().DerivesFrom<ETagOrder>();
builder.EntitySet<ETagAddress>("Addresses");
// Entity without ETag to test that we only write entities with ETag.
builder.EntitySet<NonEtagEntity>("NonEtagEntity");
IEdmModel model = builder.GetEdmModel();
return model;
}
/// <summary>
/// Generates a model from a few seeds (i.e. the names and types of the entity sets)
/// by applying conventions.
/// </summary>
/// <returns>An implicitly configured model</returns>
static IEdmModel GetImplicitEdmModel()
{
ODataModelBuilder modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet<Product>("Products");
modelBuilder.Entity<RatedProduct>().DerivesFrom<Product>();
modelBuilder.EntitySet<ProductFamily>("ProductFamilies");
modelBuilder.EntitySet<Supplier>("Suppliers");
ActionConfiguration createProduct = modelBuilder.Entity<ProductFamily>().Action("CreateProduct");
createProduct.Parameter<string>("Name");
createProduct.Returns<int>();
return modelBuilder.GetEdmModel();
}
// Builds the EDM model for the OData service, including the OData action definitions.
private static IEdmModel GetModel()
{
ODataModelBuilder modelBuilder = new ODataConventionModelBuilder();
var moviesEntitySet = modelBuilder.EntitySet<Movie>("Movies");
moviesEntitySet.EntityType.Ignore(m => m.TimeStamp); // Don't expose timestamp to clients
// Now add actions to the EDM.
// CheckOut
// URI: ~/odata/Movies(1)/CheckOut
// Transient action. It is not available when the item is already checked out.
ActionConfiguration checkout = modelBuilder.Entity<Movie>().TransientAction("CheckOut");
// Provide a function that returns a link to the action, when the action is available, or
// returns null when the action is not available.
checkout.HasActionLink(ctx =>
{
Movie movie = ctx.EntityInstance as Movie;
// Note: In some cases, checking whether the action is available may be relatively expensive.
// For example, it might require a DB lookup.
// Avoid doing expensive checks inside a loop (i.e., when serializing a feed). Instead, simply
// mark the action as available, by returning an action link.
// The SkipExpensiveAvailabilityChecks flag says whether to skip expensive checks. If this flag
// is true AND your availability check is expensive, skip the check and return a link.
// In this sample, the check is not really expensive, but we honor the flag to show how it works.
bool createLink = true;
if (ctx.SkipExpensiveAvailabilityChecks)
{
// Caller asked us to skip the availability check.
createLink = true;
}
else if (!movie.IsCheckedOut) // Here is the "expensive" check
{
createLink = true;
}
if (createLink)
{
// Return the URI of the action.
return new Uri(ctx.Url.ODataLink(
new EntitySetPathSegment(ctx.EntitySet),
new KeyValuePathSegment(ODataUriUtils.ConvertToUriLiteral(movie.ID, ODataVersion.V3)),
new ActionPathSegment(checkout.Name)));
}
else
{
return null;
}
}, followsConventions: true); // "followsConventions" means the action follows OData conventions.
checkout.ReturnsFromEntitySet<Movie>("Movies");
// ReturnMovie
// URI: ~/odata/Movies(1)/Return
// Always bindable. If the movie is not checked out, the action is a no-op.
// Binds to a single entity; no parameters.
var returnAction = modelBuilder.Entity<Movie>().Action("Return");
returnAction.ReturnsFromEntitySet<Movie>("Movies");
// SetDueDate action
// URI: ~/odata/Movies(1)/SetDueDate
// Binds to a single entity; takes an action parameter.
var setDueDate = modelBuilder.Entity<Movie>().Action("SetDueDate");
setDueDate.Parameter<DateTime>("DueDate");
setDueDate.ReturnsFromEntitySet<Movie>("Movies");
// CheckOut action
// URI: ~/odata/Movies/CheckOut
// Shows how to bind to a collection, instead of a single entity.
// This action also accepts $filter queries. For example:
// ~/odata/Movies/CheckOut?$filter=Year eq 2005
var checkOutFromCollection = modelBuilder.Entity<Movie>().Collection.Action("CheckOut");
checkOutFromCollection.ReturnsCollectionFromEntitySet<Movie>("Movies");
// CheckOutMany action
// URI: ~/odata/Movies/CheckOutMany
// Shows an action that takes a collection parameter.
ActionConfiguration checkoutMany = modelBuilder.Entity<Movie>().Collection.Action("CheckOutMany");
checkoutMany.CollectionParameter<int>("MovieIDs");
checkoutMany.ReturnsCollectionFromEntitySet<Movie>("Movies");
// CreateMovie action
// URI: ~/odata/CreateMovie
// Non-bindable action. You invoke it from the service root.
ActionConfiguration createMovie = modelBuilder.Action("CreateMovie");
createMovie.Parameter<string>("Title");
createMovie.ReturnsFromEntitySet<Movie>("Movies");
return modelBuilder.GetEdmModel();
}
public void ReadEntry_ThrowsODataException_CannotInstantiateAbstractEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity<BaseType>().Abstract();
IEdmModel model = builder.GetEdmModel();
var deserializer = new ODataEntityDeserializer(_productEdmType, _deserializerProvider);
ODataEntryWithNavigationLinks entry = new ODataEntryWithNavigationLinks(new ODataEntry { TypeName = "System.Web.Http.OData.Formatter.Deserialization.BaseType" });
Assert.Throws<ODataException>(
() => deserializer.ReadEntry(entry, new ODataDeserializerContext { Model = model }),
"An instance of the abstract entity type 'System.Web.Http.OData.Formatter.Deserialization.BaseType' was found. Abstract entity types cannot be instantiated.");
}
