private static 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");
}
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 }
);
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Product>("Products");
builder.EntitySet <Supplier>("Suppliers");
builder.EntitySet <ProductRating>("Ratings");
//new code: Add an action to the EDM, and define the parameter and return type
ActionConfiguration rateProduct = builder.Entity <Product>().Action("RateProduct");
rateProduct.Parameter <int>("Rating");
rateProduct.Returns <double>();
var rateAllProducts = builder.Entity <Product>().Collection.Action("RateAllProducts");
rateAllProducts.CollectionParameter <int>("Ratings");
config.Routes.MapODataRoute("odata", "odata", builder.GetEdmModel());
}
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 GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
var products1 = builder.EntitySet <ODataActionTests_Product>("ODataActionTests_Products1");
var products2 = builder.EntitySet <ODataActionTests_Product>("ODataActionTests_Products2");
// ExtendSupportDate of a single Product
var extendSupportDate1 = products1.EntityType.TransientAction("ExtendSupportDate1");
extendSupportDate1.Parameter <DateTime>("newDate");
extendSupportDate1.ReturnsFromEntitySet <ODataActionTests_Product>("ODataActionTests_Products1");
// ExtendSupportDates on multiple Products
var extendSupportDates1 = products1.EntityType.Collection.TransientAction("ExtendSupportDates1");
extendSupportDates1.CollectionParameter <int>("productIds");
extendSupportDates1.Parameter <DateTime>("newDate");
extendSupportDates1.ReturnsCollectionFromEntitySet <ODataActionTests_Product>("ODataActionTests_Products1");
// UpdateRating of a single RatedProduct
var updateRating1 = builder.Entity <ODataActionTests_RatedProduct>().TransientAction("UpdateRating1");
updateRating1.Parameter <int>("newRating");
updateRating1.ReturnsFromEntitySet <ODataActionTests_Product>("ODataActionTests_Products1");
// UpdateRatings of a single RatedProduct
var updateRatings1 = builder.Entity <ODataActionTests_RatedProduct>().Collection.TransientAction("UpdateRatings1");
updateRatings1.CollectionParameter <int>("productIds");
updateRatings1.Parameter <int>("newRating");
updateRatings1.ReturnsCollectionFromEntitySet <ODataActionTests_Product>("ODataActionTests_Products1");
// ExtendSupportDate of a single Product
var extendSupportDate2 = products1.EntityType.TransientAction("ExtendSupportDate2");
extendSupportDate2.Parameter <DateTime>("newDate");
extendSupportDate2.ReturnsFromEntitySet <ODataActionTests_Product>("ODataActionTests_Products2");
// ExtendSupportDates on multiple Products
var extendSupportDates2 = products1.EntityType.Collection.TransientAction("ExtendSupportDates2");
extendSupportDates2.CollectionParameter <int>("productIds");
extendSupportDates2.Parameter <DateTime>("newDate");
extendSupportDates2.ReturnsCollectionFromEntitySet <ODataActionTests_Product>("ODataActionTests_Products2");
// UpdateRating of a single RatedProduct
var updateRating2 = builder.Entity <ODataActionTests_RatedProduct>().TransientAction("UpdateRating2");
updateRating2.Parameter <int>("newRating");
updateRating2.ReturnsFromEntitySet <ODataActionTests_Product>("ODataActionTests_Products2");
// UpdateRatings of a single RatedProduct
var updateRatings2 = builder.Entity <ODataActionTests_RatedProduct>().Collection.TransientAction("UpdateRatings2");
updateRatings2.CollectionParameter <int>("productIds");
updateRatings2.Parameter <int>("newRating");
updateRatings2.ReturnsCollectionFromEntitySet <ODataActionTests_Product>("ODataActionTests_Products2");
return(builder.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Stavka>("Stavke");
builder.EntitySet <Zaposlenik>("Zaposlenici");
builder.EntitySet <Racun>("Racuni");
//Configure action of adding stavka to racun on Post: ~odata/Racuni(1)/AddStavkaById
var addStavkaByIdToRacunAction = builder.Entity <Racun>().Action("AddStavkaById");
addStavkaByIdToRacunAction.Parameter <int>("Value");
//Configure action of adding stavka to racun on Post: ~odata/Racuni(1)/AddStavka
var addStavkaToRacunAction = builder.Entity <Racun>().Action("AddStavka");
addStavkaToRacunAction.Parameter <StavkaDTO>("Value");
IList <IODataRoutingConvention> routingConventions = ODataRoutingConventions.CreateDefault();
routingConventions.Insert(0, new CountODataRoutingConvention());
config.MessageHandlers.Add(new LoggingRequestHandler());
config.EnableQuerySupport();
config.Routes.MapODataServiceRoute(
"ODataRoute",
null,
builder.GetEdmModel(),
new CountODataPathHandler(),
routingConventions
);
}
public static IEdmModel GetModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <category>("category");
builder.EntitySet <company>("company");
builder.EntitySet <companySubscription>("companySubscription");
builder.EntitySet <images>("images");
builder.EntitySet <offer>("offer");
builder.EntitySet <preHomeImages>("prehomeimages");
builder.EntitySet <product>("product");
builder.EntitySet <occasion>("occasion");
builder.EntitySet <profile>("profile");
builder.EntitySet <state>("state");
builder.EntitySet <store>("store");
builder.EntitySet <storeCategory>("storeCategory");
builder.EntitySet <subcategory>("subcategory");
builder.EntitySet <subscription>("subscription");
builder.EntitySet <geoRequest>("georequest");
builder.EntitySet <UserProfile>("userprofile");
builder.EntitySet <userCompany>("userCompany");
builder.EntitySet <webpages_Roles>("webpages_Roles");
builder.EntitySet <webpages_OAuthMembership>("webpages_OAuthMembership");
builder.EntitySet <webpages_Membership>("webpages_Membership");
builder.EntitySet <GetNearestStores>("GetNearestStores");
/* Custom rules */
builder.Entity <category>().Action("Activate");
builder.Entity <company>().Action("Activate");
return(builder.GetEdmModel());
}
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>();
}
public void ModelBuilder_CanAddEntitiesInAnyOrder()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity <SportBike>();
builder.Entity <Car>();
builder.Entity <Vehicle>();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel, model.SchemaElements.Count());
}
public void ModelBuilder_Doesnot_Override_AbstractnessOfEntityTypes_IfSet()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity <Vehicle>();
builder.Entity <Motorcycle>().Abstract();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel, model.SchemaElements.Count());
Assert.True(model.AssertHasEntityType(typeof(Motorcycle)).IsAbstract);
Assert.False(model.AssertHasEntityType(typeof(SportBike)).IsAbstract);
}
public void ModelBuilder_CanHaveAnAbstractDerivedTypeOfConcreteBaseType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity <Vehicle>();
builder.Entity <SportBike>().Abstract();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel, model.SchemaElements.Count());
Assert.False(model.AssertHasEntityType(typeof(Motorcycle)).IsAbstract);
Assert.True(model.AssertHasEntityType(typeof(SportBike)).IsAbstract);
Assert.Equal(model.AssertHasEntityType(typeof(SportBike)).BaseEntityType(), model.AssertHasEntityType(typeof(Motorcycle)));
}
public static IEdmModel GetEdmModel(HttpConfiguration configuration)
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder(configuration);
builder.EntitySet <MovingObject>("InheritanceTests_MovingObjects");
var vehicle = builder.EntitySet <Vehicle>("InheritanceTests_Vehicles").EntityType;
var cars = builder.EntitySet <Car>("InheritanceTests_Cars");
cars.EntityType.Action("Wash");
// Skip: http://aspnetwebstack.codeplex.com/workitem/780
builder.OnModelCreating = mb =>
{
//cars = builder.EntitySets.OfType<EntitySetConfiguration<Car>>().First();
cars.HasNavigationPropertiesLink(
cars.EntityType.NavigationProperties,
(entityContext, navigationProperty) =>
{
object id;
entityContext.EdmObject.TryGetPropertyValue("Id", out id);
return(new Uri(entityContext.Url.CreateODataLink(
new EntitySetPathSegment("InheritanceTests_Cars"),
new KeyValuePathSegment(id.ToString()),
new NavigationPathSegment(navigationProperty.Name))));
},
false);
};
builder.Entity <SportBike>().Action("Wash");
builder.EntitySet <Customer>("InheritanceTests_Customers");
return(builder.GetEdmModel());
}
public void GenerateActionLink_GeneratesLinkWithoutCast_IfEntitySetTypeDerivesFromActionEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var cars = builder.EntitySet<Car>("cars");
var paintAction = builder.Entity<Vehicle>().Action("Paint");
IEdmModel model = builder.GetEdmModel();
var carsEdmSet = model.EntityContainers().Single().FindEntitySet("cars");
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.Routes.MapODataRoute(routeName, null, model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
request.SetODataRouteName(routeName);
Uri link = ActionLinkGenerationConvention.GenerateActionLink(
new EntityInstanceContext()
{
EdmModel = model,
EntitySet = carsEdmSet,
EntityType = carsEdmSet.ElementType,
Url = request.GetUrlHelper(),
EntityInstance = new Car { Model = 2009, Name = "Accord" }
},
paintAction);
Assert.Equal("http://localhost/cars(Model=2009,Name='Accord')/Paint", link.AbsoluteUri);
}
public void GenerateActionLink_GeneratesLinkWithCast_IfEntitySetTypeDoesnotMatchActionEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var vehicles = builder.EntitySet <Vehicle>("vehicles");
var car = builder.Entity <Car>();
var paintAction = car.Action("Paint");
IEdmModel model = builder.GetEdmModel();
var vehiclesEdmSet = model.EntityContainers().Single().FindEntitySet("vehicles");
var carEdmType = model.FindDeclaredType("System.Web.Http.OData.Builder.TestModels.Car") as IEdmEntityType;
HttpConfiguration configuration = new HttpConfiguration();
configuration.Routes.MapHttpRoute(ODataRouteNames.InvokeBoundActionWithCast, "{controller}({boundId})/{entityType}/{odataAction}");
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());
Uri link = ActionLinkGenerationConvention.GenerateActionLink(
new EntityInstanceContext(model, vehiclesEdmSet, carEdmType, request.GetUrlHelper(), new Car {
Model = 2009, Name = "Accord"
}),
paintAction);
Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/System.Web.Http.OData.Builder.TestModels.Car/Paint", link.AbsoluteUri);
}
public void GenerateActionLink_GeneratesLinkWithoutCast_IfEntitySetTypeDerivesFromActionEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var cars = builder.EntitySet <Car>("cars");
var paintAction = builder.Entity <Vehicle>().Action("Paint");
IEdmModel model = builder.GetEdmModel();
var carsEdmSet = model.EntityContainers().Single().FindEntitySet("cars");
HttpConfiguration configuration = new HttpConfiguration();
configuration.Routes.MapHttpRoute(ODataRouteNames.InvokeBoundAction, "{controller}({boundId})/{odataAction}");
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());
Uri link = ActionLinkGenerationConvention.GenerateActionLink(
new EntityInstanceContext(model, carsEdmSet, carsEdmSet.ElementType, request.GetUrlHelper(), new Car {
Model = 2009, Name = "Accord"
}),
paintAction);
Assert.Equal("http://localhost/cars(Model=2009,Name='Accord')/Paint", link.AbsoluteUri);
}
public void GenerateActionLink_GeneratesLinkWithoutCast_IfEntitySetTypeDerivesFromActionEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var cars = builder.EntitySet<Car>("cars");
var paintAction = builder.Entity<Vehicle>().Action("Paint");
IEdmModel model = builder.GetEdmModel();
var carsEdmSet = model.EntityContainers().Single().FindEntitySet("cars");
HttpConfiguration configuration = new HttpConfiguration();
configuration.EnableOData(model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());
Uri link = ActionLinkGenerationConvention.GenerateActionLink(
new EntityInstanceContext() {
EdmModel = model,
EntitySet = carsEdmSet,
EntityType = carsEdmSet.ElementType,
UrlHelper = request.GetUrlHelper(),
PathHandler = new DefaultODataPathHandler(model),
EntityInstance = new Car { Model = 2009, Name = "Accord" }
},
paintAction);
Assert.Equal("http://localhost/cars(Model=2009,Name='Accord')/Paint", link.AbsoluteUri);
}
public void GenerateActionLink_GeneratesLinkWithoutCast_IfEntitySetTypeDerivesFromActionEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var cars = builder.EntitySet <Car>("cars");
var paintAction = builder.Entity <Vehicle>().Action("Paint");
IEdmModel model = builder.GetEdmModel();
var carsEdmSet = model.EntityContainers().Single().FindEntitySet("cars");
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.Routes.MapODataRoute(routeName, null, model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
request.SetODataRouteName(routeName);
Uri link = ActionLinkGenerationConvention.GenerateActionLink(
new EntityInstanceContext()
{
EdmModel = model,
EntitySet = carsEdmSet,
EntityType = carsEdmSet.ElementType,
Url = request.GetUrlHelper(),
EntityInstance = new Car {
Model = 2009, Name = "Accord"
}
},
paintAction);
Assert.Equal("http://localhost/cars(Model=2009,Name='Accord')/Paint", link.AbsoluteUri);
}
public void GenerateActionLink_GeneratesLinkWithCast_IfEntitySetTypeDoesnotMatchActionEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var vehicles = builder.EntitySet<Vehicle>("vehicles");
var car = builder.Entity<Car>();
var paintAction = car.Action("Paint");
IEdmModel model = builder.GetEdmModel();
var vehiclesEdmSet = model.EntityContainers().Single().FindEntitySet("vehicles");
var carEdmType = model.FindDeclaredType("System.Web.Http.OData.Builder.TestModels.Car") as IEdmEntityType;
HttpConfiguration configuration = new HttpConfiguration();
configuration.EnableOData(model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());
Uri link = ActionLinkGenerationConvention.GenerateActionLink(
new EntityInstanceContext()
{
EdmModel = model,
EntitySet = vehiclesEdmSet,
EntityType = carEdmType,
UrlHelper = request.GetUrlHelper(),
PathHandler = new DefaultODataPathHandler(model),
EntityInstance = new Car { Model = 2009, Name = "Accord" }
},
paintAction);
Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/System.Web.Http.OData.Builder.TestModels.Car/Paint", link.AbsoluteUri);
}
public static void Register(HttpConfiguration config)
{
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Product>("Products");
builder.EntitySet <Product>("Products").EntityType.Collection.Action("GetProductSalesInfo").ReturnsCollectionFromEntitySet <ProductSaleInfo>("GetProductSalesInfo");
builder.EntitySet <Order_Items>("Order_Items");
builder.EntitySet <Product_Catalogs>("Product_Catalogs");
builder.EntitySet <Product_Images>("Product_Images");
builder.EntitySet <Quote_Items>("Quote_Items");
builder.EntitySet <Task>("Tasks");
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Customer_Employees>("Customer_Employees");
builder.Entity <Product>().Action("SalesAndOpportunities").ReturnsCollectionFromEntitySet <SalesAndOpportunities>("SalesAndOpportunities");
builder.EntitySet <Customer_Store_Locations>("Customer_Store_Locations");
builder.EntitySet <Employee>("Employees");
builder.EntitySet <Customer_Communications>("Customer_Communications");
builder.EntitySet <Department>("Departments");
builder.EntitySet <Order>("Orders");
builder.EntitySet <Quote>("Quote");
builder.EntitySet <State>("States");
builder.EntitySet <Crest>("Crests");
builder.EntitySet <Evaluation>("Evaluations");
config.Routes.MapODataRoute("odata", "odata", builder.GetEdmModel());
}
private static IEdmModel CreateModel()
{
ODataConventionModelBuilder model = new ODataConventionModelBuilder();
model.Entity <SampleType>();
return(model.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));
}
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 }
* );*/
var builder = new ODataConventionModelBuilder();
builder.EntitySet <VmDeploymentRequest>("VmDeployments");
builder.EntitySet <VmMigrationRequest>("VmMigrations");
builder.EntitySet <Reboot>("Reboots");
// New code: Add an action to the EDM, and define the parameter and return type.
var reboot = builder.Entity <Reboot>().Action("Reboot");
reboot.Parameter <int>("Param");
reboot.Returns <int>();
config.Routes.MapODataRoute("odata", "odata", builder.GetEdmModel());
}
public void GenerateActionLink_GeneratesLinkWithoutCast_IfEntitySetTypeDerivesFromActionEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var cars = builder.EntitySet <Car>("cars");
var paintAction = builder.Entity <Vehicle>().Action("Paint");
IEdmModel model = builder.GetEdmModel();
var carsEdmSet = model.EntityContainers().Single().FindEntitySet("cars");
HttpConfiguration configuration = new HttpConfiguration();
configuration.EnableOData(model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());
Uri link = ActionLinkGenerationConvention.GenerateActionLink(
new EntityInstanceContext()
{
EdmModel = model,
EntitySet = carsEdmSet,
EntityType = carsEdmSet.ElementType,
UrlHelper = request.GetUrlHelper(),
PathHandler = new DefaultODataPathHandler(model),
EntityInstance = new Car {
Model = 2009, Name = "Accord"
}
},
paintAction);
Assert.Equal("http://localhost/cars(Model=2009,Name='Accord')/Paint", link.AbsoluteUri);
}
private static IEdmModel CreateModelWithEntity <T>() where T : class
{
ODataConventionModelBuilder model = new ODataConventionModelBuilder();
model.Entity <T>();
return(model.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Employee>("Employees");
builder.EntitySet <Designation>("Designations");
builder.EntitySet <EmployeeLanguages>("EmployeeLanguages");
var isemailUnique = builder.Entity <Employee>().Action("IsEmailUnique");
isemailUnique.Parameter <string>("email");
isemailUnique.Returns <bool>();
config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel());
//// Web API configuration and services
//// Web API routes
config.MapHttpAttributeRoutes();
////singleton
//var cache = new DemoMemoryCache();
//config.CacheOutputConfiguration().RegisterCacheOutputProvider(() => cache);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
}
private Microsoft.Data.Edm.IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity <ODataQueryOptions_Todo>();
return(builder.GetEdmModel());
}
public void GenerateActionLink_GeneratesLinkWithCast_IfEntitySetTypeDoesnotMatchActionEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var vehicles = builder.EntitySet<Vehicle>("vehicles");
var car = builder.Entity<Car>();
var paintAction = car.Action("Paint");
IEdmModel model = builder.GetEdmModel();
var vehiclesEdmSet = model.EntityContainers().Single().FindEntitySet("vehicles");
var carEdmType = model.FindDeclaredType("System.Web.Http.OData.Builder.TestModels.Car") as IEdmEntityType;
HttpConfiguration configuration = new HttpConfiguration();
string routeName = "Route";
configuration.Routes.MapODataRoute(routeName, null, model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.SetConfiguration(configuration);
request.SetODataRouteName(routeName);
var serializerContext = new ODataSerializerContext { Model = model, EntitySet = vehiclesEdmSet, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, carEdmType.AsReference(), new Car { Model = 2009, Name = "Accord" });
Uri link = ActionLinkGenerationConvention.GenerateActionLink(entityContext, paintAction);
Assert.Equal("http://localhost/vehicles(Model=2009,Name='Accord')/System.Web.Http.OData.Builder.TestModels.Car/Paint", link.AbsoluteUri);
}
/// <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());
}
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());
}
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());
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
var pets = builder.EntitySet <Pet>("Pets");
builder.Entity <BigPet>();
return(builder.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Configure Web API to use only bearer token authentication.
config.EnableCors();
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Class>("Classes");
builder.EntitySet <Student>("Students");
builder.EntitySet <Admission>("Admissions");
builder.EntitySet <Exam>("Exams");
builder.EntitySet <ExamTerm>("ExamTerms");
builder.EntitySet <ExamYear>("ExamYears");
builder.EntitySet <Subject>("Subjects");
builder.EntitySet <Teacher>("Teachers");
builder.EntitySet <Result>("Results");
////bound action
var smvm = builder.Entity <Student>().Collection.Action("GetStudentMark").ReturnsCollection <StudentMarkVM>();
smvm.Parameter <int>("ExamId");
smvm.Parameter <int>("ClassId");
var cusroll = builder.Entity <Student>().Collection.Action("NextRoll");
cusroll.Parameter <int>("ClassId");
cusroll.Returns <int>();
var rvm = builder.Entity <Result>().Collection.Action("ResultSave");
rvm.CollectionParameter <ResultVM>("results");
config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel());
config.SuppressDefaultHostAuthentication();
config.Filters.Add(new HostAuthenticationFilter(OAuthDefaults.AuthenticationType));
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
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();
builder.EntitySet <AROCustomer>("AROCustomers");
builder.Entity <AROVipCustomer>().DerivesFrom <AROCustomer>();
builder.EntitySet <AROAddress>("AROAddresses");
builder.EntitySet <AROOrder>("Orders");
return(builder.GetEdmModel());
}
public override ODataMediaTypeFormatter CreateFormatter()
{
ODataConventionModelBuilder model = new ODataConventionModelBuilder();
model.Entity <SampleType>();
return(new ODataMediaTypeFormatter(model.GetEdmModel())
{
IsClient = true
});
}
public void GenerateActionLink_GeneratesLinkWithoutCast_IfEntitySetTypeDerivesFromActionEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var cars = builder.EntitySet<Car>("cars");
var paintAction = builder.Entity<Vehicle>().Action("Paint");
IEdmModel model = builder.GetEdmModel();
var carsEdmSet = model.EntityContainers().Single().FindEntitySet("cars");
HttpConfiguration configuration = new HttpConfiguration();
configuration.Routes.MapHttpRoute(ODataRouteNames.InvokeBoundAction, "{controller}({boundId})/{odataAction}");
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost");
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute());
Uri link = ActionLinkGenerationConvention.GenerateActionLink(
new EntityInstanceContext(model, carsEdmSet, carsEdmSet.ElementType, request.GetUrlHelper(), new Car { Model = 2009, Name = "Accord" }),
paintAction);
Assert.Equal("http://localhost/cars(Model=2009,Name='Accord')/Paint", link.AbsoluteUri);
}
public void ModelBuilder_ProductsWithFilterSortable()
{
var modelBuilder = new ODataConventionModelBuilder();
var entityTypeConf = modelBuilder.Entity<ProductWithFilterSortable>();
modelBuilder.EntitySet<ProductWithFilterSortable>("Products");
var model = modelBuilder.GetEdmModel();
var prop = entityTypeConf.Properties.FirstOrDefault(p => p.Name == "Name");
Assert.False(prop.NonFilterable);
prop = entityTypeConf.Properties.FirstOrDefault(p => p.Name == "NonFilterableProperty");
Assert.True(prop.NonFilterable);
prop = entityTypeConf.Properties.FirstOrDefault(p => p.Name == "UnsortableProperty");
Assert.True(prop.Unsortable);
prop = entityTypeConf.Properties.FirstOrDefault(p => p.Name == "Category");
Assert.True(prop.NotNavigable);
Assert.True(prop.NotExpandable);
}
public void ReadEntry_ThrowsODataException_CannotInstantiateAbstractEntityType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity<BaseType>().Abstract();
IEdmModel model = builder.GetEdmModel();
var deserializer = new ODataEntityDeserializer(_deserializerProvider);
ODataEntryWithNavigationLinks entry = new ODataEntryWithNavigationLinks(new ODataEntry { TypeName = "System.Web.OData.Formatter.Deserialization.BaseType" });
Assert.Throws<ODataException>(
() => deserializer.ReadEntry(entry, _productEdmType, new ODataDeserializerContext { Model = model }),
"An instance of the abstract entity type 'System.Web.OData.Formatter.Deserialization.BaseType' was found. Abstract entity types cannot be instantiated.");
}
public void ModelBuilder_CanHaveAnAbstractDerivedTypeOfConcreteBaseType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity<Vehicle>();
builder.Entity<SportBike>().Abstract();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel, model.SchemaElements.Count());
Assert.False(model.AssertHasEntityType(typeof(Motorcycle)).IsAbstract);
Assert.True(model.AssertHasEntityType(typeof(SportBike)).IsAbstract);
Assert.Equal(model.AssertHasEntityType(typeof(SportBike)).BaseEntityType(), model.AssertHasEntityType(typeof(Motorcycle)));
}
public void ModelBuilder_Doesnot_Override_AbstractnessOfEntityTypes_IfSet()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity<Vehicle>();
builder.Entity<Motorcycle>().Abstract();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel, model.SchemaElements.Count());
Assert.True(model.AssertHasEntityType(typeof(Motorcycle)).IsAbstract);
Assert.False(model.AssertHasEntityType(typeof(SportBike)).IsAbstract);
}
public void ModelBuilder_Figures_AbstractnessOfEntityTypes()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity<Vehicle>();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel, model.SchemaElements.Count());
Assert.True(model.AssertHasEntityType(typeof(Vehicle)).IsAbstract);
Assert.False(model.AssertHasEntityType(typeof(Motorcycle)).IsAbstract);
Assert.False(model.AssertHasEntityType(typeof(Car)).IsAbstract);
Assert.False(model.AssertHasEntityType(typeof(SportBike)).IsAbstract);
Assert.False(model.AssertHasEntityType(typeof(CarManufacturer)).IsAbstract);
Assert.False(model.AssertHasEntityType(typeof(MotorcycleManufacturer)).IsAbstract);
}
public void ModelBuilder_DoesnotPatch_BaseType_IfBaseTypeIsExplicitlySet()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity<Vehicle>();
builder.Entity<Car>().DerivesFromNothing();
builder.Entity<Motorcycle>().DerivesFromNothing();
builder.Entity<SportBike>();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel, model.SchemaElements.Count());
var vehicle = model.AssertHasEntityType(typeof(Vehicle));
Assert.Equal(null, vehicle.BaseEntityType());
Assert.Equal(2, vehicle.Key().Count());
var motorcycle = model.AssertHasEntityType(typeof(Motorcycle));
Assert.Equal(null, motorcycle.BaseEntityType());
Assert.Equal(2, motorcycle.Key().Count());
Assert.Equal(5, motorcycle.Properties().Count());
var car = model.AssertHasEntityType(typeof(Car));
Assert.Equal(null, car.BaseEntityType());
Assert.Equal(2, car.Key().Count());
Assert.Equal(5, car.Properties().Count());
var sportbike = model.AssertHasEntityType(typeof(SportBike));
Assert.Equal(motorcycle, sportbike.BaseEntityType());
Assert.Equal(2, sportbike.Key().Count());
Assert.Equal(5, sportbike.Properties().Count());
}
public void ModelBuilder_Patches_BaseType_IfBaseTypeIsNotExplicitlySet()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity<Vehicle>();
builder.Entity<Car>();
builder.Entity<Motorcycle>();
builder.Entity<SportBike>();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel, model.SchemaElements.Count());
var vehicle = model.AssertHasEntityType(typeof(Vehicle));
Assert.Equal(null, vehicle.BaseEntityType());
var motorcycle = model.AssertHasEntityType(typeof(Motorcycle));
Assert.Equal(vehicle, motorcycle.BaseEntityType());
var car = model.AssertHasEntityType(typeof(Car));
Assert.Equal(vehicle, car.BaseEntityType());
var sportbike = model.AssertHasEntityType(typeof(SportBike));
Assert.Equal(motorcycle, sportbike.BaseEntityType());
var motorcycleManufacturer = model.AssertHasEntityType(typeof(MotorcycleManufacturer));
Assert.Null(motorcycleManufacturer.BaseEntityType());
var carManufacturer = model.AssertHasEntityType(typeof(CarManufacturer));
Assert.Null(carManufacturer.BaseEntityType());
}
public void ModelBuilder_Can_Add_DerivedTypeOfAnIgnoredType()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Vehicle>("Vehicles");
builder.Ignore<Motorcycle>();
builder.Entity<SportBike>();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel - 1, model.SchemaElements.Count());
Assert.Equal(1, model.EntityContainers().Single().EntitySets().Count());
model.AssertHasEntitySet("Vehicles", typeof(Vehicle));
var vehicle = model.AssertHasEntityType(typeof(Vehicle));
Assert.Equal(2, vehicle.Key().Count());
Assert.Equal(3, vehicle.Properties().Count());
vehicle.AssertHasKey(model, "Model", EdmPrimitiveTypeKind.Int32);
vehicle.AssertHasKey(model, "Name", EdmPrimitiveTypeKind.String);
vehicle.AssertHasPrimitiveProperty(model, "WheelCount", EdmPrimitiveTypeKind.Int32, isNullable: false);
var car = model.AssertHasEntityType(typeof(Car));
Assert.Equal(vehicle, car.BaseEntityType());
Assert.Equal(2, car.Key().Count());
Assert.Equal(5, car.Properties().Count());
car.AssertHasPrimitiveProperty(model, "SeatingCapacity", EdmPrimitiveTypeKind.Int32, isNullable: false);
car.AssertHasNavigationProperty(model, "Manufacturer", typeof(CarManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
var sportbike = model.AssertHasEntityType(typeof(SportBike));
Assert.Equal(vehicle, sportbike.BaseEntityType());
Assert.Equal(2, sportbike.Key().Count());
Assert.Equal(5, sportbike.Properties().Count());
sportbike.AssertHasNavigationProperty(model, "Manufacturer", typeof(MotorcycleManufacturer), isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne);
}
public void ModelBuilder_CanAddEntitiesInAnyOrder()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Entity<SportBike>();
builder.Entity<Car>();
builder.Entity<Vehicle>();
IEdmModel model = builder.GetEdmModel();
Assert.Equal(_totalExpectedSchemaTypesForVehiclesModel, model.SchemaElements.Count());
}
public void ModelBuilder_DerivedClassPropertyNotAliased_IfPropertyAddedExplicitly()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder { ModelAliasingEnabled = true };
EntityTypeConfiguration<PropertyAliasDerived> derived = builder.Entity<PropertyAliasDerived>()
.DerivesFrom<PropertyAlias>();
derived.Property(p => p.LastName).Name = "FamilyName";
derived.Property(p => p.Age).Name = "CurrentAge";
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmEntityType entityType = model.AssertHasEntityType(typeof(PropertyAliasDerived));
entityType.AssertHasKey(model, "Id", EdmPrimitiveTypeKind.Int32);
entityType.AssertHasPrimitiveProperty(model, "FamilyName", EdmPrimitiveTypeKind.String, true);
entityType.AssertHasPrimitiveProperty(model, "CurrentAge", EdmPrimitiveTypeKind.Int32, false);
}
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 void BoundFunction_ForEnumTypeInODataConventionModelBuilder()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration<EnumModel> entityTypeConfiguration = builder.Entity<EnumModel>();
FunctionConfiguration functionConfiguration = entityTypeConfiguration.Function("BoundFunction");
functionConfiguration.CollectionParameter<Color?>("Colors");
functionConfiguration.Returns<Color>();
// Act & Assert
IEdmModel model = builder.GetEdmModel();
IEdmFunction function = model.FindDeclaredOperations("Default.BoundFunction").Single() as IEdmFunction;
IEdmTypeReference colors = function.Parameters.Single(p => p.Name == "Colors").Type;
IEdmTypeReference returnType = function.ReturnType;
IEdmEnumType colorType = model.SchemaElements.OfType<IEdmEnumType>().Single(e => e.Name == "Color");
Assert.True(colors.IsCollection());
Assert.True(colors.AsCollection().ElementType().IsNullable);
Assert.Same(colorType, colors.AsCollection().ElementType().Definition);
Assert.Same(colorType, returnType.Definition);
}
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());
}
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();
}
