public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.DataServiceVersion = new Version(2, 0);
builder.MaxDataServiceVersion = new Version(2, 0);
builder.Namespace = "NuGetGallery";
builder.ContainerName = "V1FeedContext";
var packagesCollection = builder.EntitySet <V1FeedPackage>("Packages");
packagesCollection.EntityType.HasKey(pkg => pkg.Id);
packagesCollection.EntityType.HasKey(pkg => pkg.Version);
var searchAction = builder.Action("Search");
searchAction.Parameter <string>("searchTerm");
searchAction.Parameter <string>("targetFramework");
searchAction.ReturnsCollectionFromEntitySet <V1FeedPackage>("Packages");
var findPackagesAction = builder.Action("FindPackagesById");
findPackagesAction.Parameter <string>("id");
findPackagesAction.ReturnsCollectionFromEntitySet <V1FeedPackage>("Packages");
var model = builder.GetEdmModel();
model.SetEdmVersion(new Version(1, 0));
model.SetEdmxVersion(new Version(1, 0));
model.SetHasDefaultStream(model.FindDeclaredType(typeof(V1FeedPackage).FullName) as IEdmEntityType, hasStream: true);
return(model);
}
private IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <WorkflowBase> workflowBases = builder.EntitySet <WorkflowBase>("WorkflowBases");
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntitySetConfiguration <Project> projects = builder.EntitySet <Project>("Projects");
EntitySetConfiguration <Quote> quotes = builder.EntitySet <Quote>("Quotes");
EntitySetConfiguration <JobCard> jobcards = builder.EntitySet <JobCard>("JobCards");
EntitySetConfiguration <Party> parties = builder.EntitySet <Party>("Parties");
EntitySetConfiguration <PermissionContainer> permissions = builder.EntitySet <PermissionContainer>("Permissions");
permissions.EntityType.HasKey(t => t.Key);
workflowBases.EntityType.HasKey(t => t.Oid);
employees.EntityType.HasKey(t => t.Oid);
projects.EntityType.HasKey(t => t.Oid);
quotes.EntityType.HasKey(t => t.Oid);
jobcards.EntityType.HasKey(t => t.Oid);
parties.EntityType.HasKey(t => t.Oid);
FunctionConfiguration logon = builder.Function("Login");
logon.Returns <int>();
logon.Parameter <string>("userName");
logon.Parameter <string>("password");
builder.Action("Logoff");
ActionConfiguration getPermissions = builder.Action("GetPermissions");
getPermissions.Parameter <string>("typeName");
getPermissions.CollectionParameter <string>("keys");
return(builder.GetEdmModel());
}
public void Build()
{
var builder = new ODataConventionModelBuilder();
var entity = builder.EntitySet <IInternalPackage>("Packages");
entity.EntityType.HasKey(pkg => pkg.Id);
entity.EntityType.HasKey(pkg => pkg.Version);
var searchAction = builder.Action("Search");
searchAction.Parameter <string>("searchTerm");
searchAction.Parameter <string>("targetFramework");
searchAction.Parameter <bool>("includePrerelease");
searchAction.ReturnsCollectionFromEntitySet <IInternalPackage>("Packages");
var findPackagesAction = builder.Action("FindPackagesById");
findPackagesAction.Parameter <string>("id");
findPackagesAction.ReturnsCollectionFromEntitySet <IInternalPackage>("Packages");
var getUpdatesAction = builder.Action("GetUpdates");
getUpdatesAction.Parameter <string>("packageIds");
getUpdatesAction.Parameter <bool>("includePrerelease");
getUpdatesAction.Parameter <bool>("includeAllVersions");
getUpdatesAction.Parameter <string>("targetFrameworks");
getUpdatesAction.Parameter <string>("versionConstraints");
getUpdatesAction.ReturnsCollectionFromEntitySet <IInternalPackage>("Packages");
_model = builder.GetEdmModel();
_model.SetHasDefaultStream(_model.FindDeclaredType(typeof(IInternalPackage).FullName) as IEdmEntityType, true);
}
private static IEdmModel GetEdmModel(HttpConfiguration configuration)
{
var builder = new ODataConventionModelBuilder(configuration);
EntitySetConfiguration <SelectCustomer> customers = builder.EntitySet <SelectCustomer>("SelectCustomer");
customers.EntityType.Action("CreditRating").Returns <double>();
customers.EntityType.Collection.Action("PremiumCustomers").ReturnsCollectionFromEntitySet <SelectCustomer>("SelectCustomer");
builder.EntitySet <EFSelectCustomer>("EFSelectCustomers");
builder.EntitySet <EFSelectOrder>("EFSelectOrders");
builder.EntitySet <SelectOrderDetail>("SelectOrderDetail");
builder.EntityType <SelectPremiumCustomer>();
builder.EntitySet <SelectOrder>("SelectOrder");
builder.EntitySet <SelectBonus>("SelectBonus");
builder.EntitySet <EFWideCustomer>("EFWideCustomers");
builder.Action("ResetDataSource");
builder.Action("ResetDataSource-Order");
IEdmModel model = builder.GetEdmModel();
for (int idx = 1; idx <= 5; idx++)
{
IEdmSchemaType nestedType = model.FindDeclaredType("WebStack.QA.Test.OData.QueryComposition.CustomProperties" + idx);
model.SetAnnotationValue(nestedType, new System.Web.OData.Query.ModelBoundQuerySettings()
{
DefaultSelectType = SelectExpandType.Automatic
});
}
return(model);
}
internal static IEdmModel BuildNuGetODataModel()
{
var builder = new ODataConventionModelBuilder
{
DataServiceVersion = new Version(2, 0),
MaxDataServiceVersion = new Version(2, 0)
};
var packagesCollection = builder.EntitySet <ODataPackage>("Packages");
packagesCollection.EntityType.HasKey(pkg => pkg.Id);
packagesCollection.EntityType.HasKey(pkg => pkg.Version);
var downloadPackageAction = packagesCollection.EntityType.Action("Download");
var searchAction = builder.Action("Search");
searchAction.Parameter <string>("searchTerm");
searchAction.Parameter <bool>("includePrerelease");
searchAction.ReturnsCollectionFromEntitySet(packagesCollection);
var findPackagesAction = builder.Action("FindPackagesById");
findPackagesAction.Parameter <string>("id");
findPackagesAction.ReturnsCollectionFromEntitySet(packagesCollection);
var retValue = builder.GetEdmModel();
retValue.SetHasDefaultStream(retValue.FindDeclaredType(typeof(ODataPackage).FullName) as IEdmEntityType, true);
return(retValue);
}
public static IEdmModel GetConventionModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration<Employee> employees = builder.EntitySet<Employee>("Employees");
EntityTypeConfiguration<Employee> employee = employees.EntityType;
employee.EnumProperty<Gender>(e => e.Sex).Name = "Gender";
employee.Collection.Function("GetEarliestTwoEmployees").ReturnsCollectionFromEntitySet<Employee>("Employees");
var functionConfiguration = builder.Function("GetAddress");
functionConfiguration.Parameter<int>("id");
functionConfiguration.Returns<Address>();
var actionConfiguration = builder.Action("SetAddress");
actionConfiguration.Parameter<int>("id");
actionConfiguration.Parameter<Address>("address");
actionConfiguration.ReturnsFromEntitySet(employees);
var resetDataSource = builder.Action("ResetDataSource");
builder.Namespace = typeof(Employee).Namespace;
builder.EnableLowerCamelCase();
var edmModel = builder.GetEdmModel();
return edmModel;
}
private IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntitySetConfiguration <Party> parties = builder.EntitySet <Party>("Parties");
EntitySetConfiguration <PermissionContainer> permissions = builder.EntitySet <PermissionContainer>("Permissions");
EntitySetConfiguration <Department> departments = builder.EntitySet <Department>("Departments");
permissions.EntityType.HasKey(t => t.Key);
employees.EntityType.HasKey(t => t.Oid);
parties.EntityType.HasKey(t => t.Oid);
departments.EntityType.HasKey(t => t.Oid);
FunctionConfiguration logon = builder.Function("Login");
logon.Returns <int>();
logon.Parameter <string>("userName");
logon.Parameter <string>("password");
builder.Action("Logoff");
ActionConfiguration getPermissions = builder.Action("GetPermissions");
getPermissions.Parameter <string>("typeName");
getPermissions.CollectionParameter <string>("keys");
return(builder.GetEdmModel());
}
public void Build()
{
var builder = new ODataConventionModelBuilder();
var entity = builder.EntitySet <ODataPackage>("Packages");
entity.EntityType.HasKey(pkg => pkg.Id);
entity.EntityType.HasKey(pkg => pkg.Version);
var searchAction = builder.Action("Search");
searchAction.Parameter <string>("searchTerm");
searchAction.Parameter <string>("targetFramework");
searchAction.Parameter <bool>("includePrerelease");
searchAction.ReturnsCollectionFromEntitySet <ODataPackage>("Packages");
var findPackagesAction = builder.Action("FindPackagesById");
findPackagesAction.Parameter <string>("id");
findPackagesAction.ReturnsCollectionFromEntitySet <ODataPackage>("Packages");
var getUpdatesAction = builder.Action("GetUpdates");
getUpdatesAction.Parameter <string>("packageIds");
getUpdatesAction.Parameter <bool>("includePrerelease");
getUpdatesAction.Parameter <bool>("includeAllVersions");
getUpdatesAction.Parameter <string>("targetFrameworks");
getUpdatesAction.Parameter <string>("versionConstraints");
getUpdatesAction.ReturnsCollectionFromEntitySet <ODataPackage>("Packages");
model = builder.GetEdmModel();
}
public static IEdmModel GetConventionModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntityTypeConfiguration <Employee> employee = employees.EntityType;
employee.EnumProperty <Gender>(e => e.Sex).Name = "Gender";
employee.Collection.Function("GetEarliestTwoEmployees").ReturnsCollectionFromEntitySet <Employee>("Employees");
var functionConfiguration = builder.Function("GetAddress");
functionConfiguration.Parameter <int>("id");
functionConfiguration.Returns <Address>();
var actionConfiguration = builder.Action("SetAddress");
actionConfiguration.Parameter <int>("id");
actionConfiguration.Parameter <Address>("address");
actionConfiguration.ReturnsFromEntitySet(employees);
var resetDataSource = builder.Action("ResetDataSource");
builder.Namespace = typeof(Employee).Namespace;
builder.EnableLowerCamelCase();
var edmModel = builder.GetEdmModel();
return(edmModel);
}
private IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntitySetConfiguration <Department> departments = builder.EntitySet <Department>("Departments");
EntitySetConfiguration <Party> parties = builder.EntitySet <Party>("Parties");
EntitySetConfiguration <ObjectPermission> objectPermissions = builder.EntitySet <ObjectPermission>("ObjectPermissions");
EntitySetConfiguration <MemberPermission> memberPermissions = builder.EntitySet <MemberPermission>("MemberPermissions");
EntitySetConfiguration <TypePermission> typePermissions = builder.EntitySet <TypePermission>("TypePermissions");
employees.EntityType.HasKey(t => t.Oid);
departments.EntityType.HasKey(t => t.Oid);
parties.EntityType.HasKey(t => t.Oid);
ActionConfiguration login = builder.Action("Login");
login.Parameter <string>("userName");
login.Parameter <string>("password");
builder.Action("Logout");
ActionConfiguration getPermissions = builder.Action("GetPermissions");
getPermissions.Parameter <string>("typeName");
getPermissions.CollectionParameter <string>("keys");
ActionConfiguration getTypePermissions = builder.Action("GetTypePermissions");
getTypePermissions.Parameter <string>("typeName");
getTypePermissions.ReturnsFromEntitySet <TypePermission>("TypePermissions");
return(builder.GetEdmModel());
}
public static IEdmModel GetModel()
{
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver());
ODataConventionModelBuilder builder = new ODataConventionModelBuilder(configuration);
builder.EntitySet <RoutingCustomer>("RoutingCustomers");
builder.EntitySet <Product>("Products");
builder.EntitySet <SalesPerson>("SalesPeople");
builder.EntitySet <EmailAddress>("EmailAddresses");
builder.EntitySet <üCategory>("üCategories");
ActionConfiguration getRoutingCustomerById = builder.Action("GetRoutingCustomerById");
getRoutingCustomerById.Parameter <int>("RoutingCustomerId");
getRoutingCustomerById.ReturnsFromEntitySet <RoutingCustomer>("RoutingCustomers");
ActionConfiguration getSalesPersonById = builder.Action("GetSalesPersonById");
getSalesPersonById.Parameter <int>("salesPersonId");
getSalesPersonById.ReturnsFromEntitySet <SalesPerson>("SalesPeople");
ActionConfiguration getAllVIPs = builder.Action("GetAllVIPs");
ActionReturnsCollectionFromEntitySet <VIP>(builder, getAllVIPs, "RoutingCustomers");
builder.Entity <RoutingCustomer>().ComplexProperty <Address>(c => c.Address);
builder.Entity <RoutingCustomer>().Action("GetRelatedRoutingCustomers").ReturnsCollectionFromEntitySet <RoutingCustomer>("RoutingCustomers");
ActionConfiguration getBestRelatedRoutingCustomer = builder.Entity <RoutingCustomer>().Action("GetBestRelatedRoutingCustomer");
ActionReturnsFromEntitySet <VIP>(builder, getBestRelatedRoutingCustomer, "RoutingCustomers");
ActionConfiguration getVIPS = builder.Entity <RoutingCustomer>().Collection.Action("GetVIPs");
ActionReturnsCollectionFromEntitySet <VIP>(builder, getVIPS, "RoutingCustomers");
builder.Entity <RoutingCustomer>().Collection.Action("GetProducts").ReturnsCollectionFromEntitySet <Product>("Products");
builder.Entity <VIP>().Action("GetSalesPerson").ReturnsFromEntitySet <SalesPerson>("SalesPeople");
builder.Entity <VIP>().Collection.Action("GetSalesPeople").ReturnsCollectionFromEntitySet <SalesPerson>("SalesPeople");
ActionConfiguration getMostProfitable = builder.Entity <VIP>().Collection.Action("GetMostProfitable");
ActionReturnsFromEntitySet <VIP>(builder, getMostProfitable, "RoutingCustomers");
ActionConfiguration getVIPRoutingCustomers = builder.Entity <SalesPerson>().Action("GetVIPRoutingCustomers");
ActionReturnsCollectionFromEntitySet <VIP>(builder, getVIPRoutingCustomers, "RoutingCustomers");
ActionConfiguration getVIPRoutingCustomersOnCollection = builder.Entity <SalesPerson>().Collection.Action("GetVIPRoutingCustomers");
ActionReturnsCollectionFromEntitySet <VIP>(builder, getVIPRoutingCustomersOnCollection, "RoutingCustomers");
builder.Entity <VIP>().HasRequired(v => v.RelationshipManager);
builder.Entity <ImportantProduct>().HasRequired(ip => ip.LeadSalesPerson);
return(builder.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());
}
private static IEdmModel GetModel()
{
HttpConfiguration config = new HttpConfiguration();
config.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(typeof(Customer)));
ODataModelBuilder builder = new ODataConventionModelBuilder(config);
builder.ContainerName = "C";
builder.Namespace = "A.B";
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
// bound actions
ActionConfiguration primitive = customer.Action("Primitive");
primitive.Parameter <int>("Quantity");
primitive.Parameter <string>("ProductCode");
ActionConfiguration complex = customer.Action("Complex");
complex.Parameter <int>("Quantity");
complex.Parameter <MyAddress>("Address");
ActionConfiguration primitiveCollection = customer.Action("PrimitiveCollection");
primitiveCollection.Parameter <string>("Name");
primitiveCollection.CollectionParameter <int>("Ratings");
ActionConfiguration complexCollection = customer.Action("ComplexCollection");
complexCollection.Parameter <string>("Name");
complexCollection.CollectionParameter <MyAddress>("Addresses");
// unbound actions
ActionConfiguration unboundPrimitive = builder.Action("UnboundPrimitive");
unboundPrimitive.Parameter <int>("Quantity");
unboundPrimitive.Parameter <string>("ProductCode");
ActionConfiguration unboundComplex = builder.Action("UnboundComplex");
unboundComplex.Parameter <int>("Quantity");
unboundComplex.Parameter <MyAddress>("Address");
ActionConfiguration unboundPrimitiveCollection = builder.Action("UnboundPrimitiveCollection");
unboundPrimitiveCollection.Parameter <string>("Name");
unboundPrimitiveCollection.CollectionParameter <int>("Ratings");
ActionConfiguration unboundComplexCollection = builder.Action("UnboundComplexCollection");
unboundComplexCollection.Parameter <string>("Name");
unboundComplexCollection.CollectionParameter <MyAddress>("Addresses");
return(builder.GetEdmModel());
}
// private static IEdmModel _edmModel;
public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Product>("Products");
// function with optional parameters
var functionWithOptional = builder.EntityType <Product>().Collection.Function("GetWholeSalary").ReturnsCollectionFromEntitySet <Order>("Orders");
functionWithOptional.Parameter <int>("minSalary");
functionWithOptional.Parameter <int>("maxSalary").Optional();
functionWithOptional.Parameter <string>("aveSalary").HasDefaultValue("129");
// overload
functionWithOptional = builder.EntityType <Product>().Collection.Function("GetWholeSalary").ReturnsCollectionFromEntitySet <Order>("Orders");
functionWithOptional.Parameter <int>("minSalary");
functionWithOptional.Parameter <double>("name");
// overload
functionWithOptional = builder.EntityType <Product>().Collection.Function("GetWholeSalary").ReturnsCollectionFromEntitySet <Order>("Orders");
functionWithOptional.Parameter <string>("order");
functionWithOptional.Parameter <string>("name");
builder.Action("ResetData");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel(HttpConfiguration config)
{
var modelBuilder = new ODataConventionModelBuilder(config);
var moviesEntitySet = modelBuilder.EntitySet<Movie>("Movies");
// Now add actions.
// CheckOut
// URI: ~/odata/Movies(1)/ODataActionsSample.Models.CheckOut
ActionConfiguration checkOutAction = modelBuilder.EntityType<Movie>().Action("CheckOut");
checkOutAction.ReturnsFromEntitySet<Movie>("Movies");
// ReturnMovie
// URI: ~/odata/Movies(1)/ODataActionsSample.Models.Return
// Binds to a single entity; no parameters.
ActionConfiguration returnAction = modelBuilder.EntityType<Movie>().Action("Return");
returnAction.ReturnsFromEntitySet<Movie>("Movies");
// CheckOutMany action
// URI: ~/odata/Movies/ODataActionsSample.Models.CheckOutMany
// Binds to a collection of entities. This action accepts a collection of parameters.
ActionConfiguration checkOutManyAction = modelBuilder.EntityType<Movie>().Collection.Action("CheckOutMany");
checkOutManyAction.CollectionParameter<int>("MovieIDs");
checkOutManyAction.ReturnsCollectionFromEntitySet<Movie>("Movies");
// CreateMovie action
// URI: ~/odata/CreateMovie
// Unbound action. It is invoked from the service root.
ActionConfiguration createMovieAction = modelBuilder.Action("CreateMovie");
createMovieAction.Parameter<string>("Title");
createMovieAction.ReturnsFromEntitySet<Movie>("Movies");
modelBuilder.Namespace = typeof(Movie).Namespace;
return modelBuilder.GetEdmModel();
}
private static void RegisterOData(HttpConfiguration httpConfiguration)
{
httpConfiguration.AddODataQueryFilter();
var builder = new ODataConventionModelBuilder();
var packages = builder.EntitySet <V2FeedPackage>("Packages");
var search = builder.Action("Search");
search.ReturnsCollectionFromEntitySet <V2FeedPackage>("Packages");
search.Parameter <string>("searchTerm");
var model = builder.GetEdmModel();
var packageType = model.FindDeclaredType(typeof(V2FeedPackage).FullName);
model.SetHasDefaultStream((IEdmEntityType)packageType, true);
var handler = new DefaultODataPathHandler();
var conventions = ODataRoutingConventions.CreateDefault();
conventions.Insert(0, new NonBindableActionRoutingConvention("Packages"));
httpConfiguration.Routes.MapODataServiceRoute("ODataDefault", "", model, handler, conventions);
httpConfiguration.Routes.MapODataServiceRoute("ODataNamed", "{feedName}", model, handler, conventions);
}
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 GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
builder.Action("ResetDataSource");
builder.Namespace = typeof(Customer).Namespace;
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
builder.Action("UnboundAction").Parameter<double>("param");
builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
return builder.GetEdmModel();
}
static StoreModel()
{
var builder = new ODataConventionModelBuilder();
builder.Namespace = "Microsoft.Restier.WebApi.Test";
builder.EntitySet<Product>("Products");
builder.Function("GetBestProduct").ReturnsFromEntitySet<Product>("Products");
builder.Action("RemoveWorstProduct").ReturnsFromEntitySet<Product>("Products");
Model = (EdmModel)builder.GetEdmModel();
Product = (IEdmEntityType)Model.FindType("Microsoft.Restier.WebApi.Test.Product");
}
// private static IEdmModel _edmModel;
public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Product>("Products");
builder.Action("ResetData");
return(builder.GetEdmModel());
}
public ODataSwaggerConverterTest()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
builder.Action("UnboundAction").Parameter<double>("param");
builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
_model = builder.GetEdmModel();
}
static StoreModel()
{
var builder = new ODataConventionModelBuilder();
builder.Namespace = "Microsoft.Restier.WebApi.Test";
builder.EntitySet <Product>("Products");
builder.Function("GetBestProduct").ReturnsFromEntitySet <Product>("Products");
builder.Action("RemoveWorstProduct").ReturnsFromEntitySet <Product>("Products");
Model = (EdmModel)builder.GetEdmModel();
Product = (IEdmEntityType)Model.FindType("Microsoft.Restier.WebApi.Test.Product");
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
builder.Function("UnboundFunction").Returns <string>().Parameter <int>("param");
builder.Action("UnboundAction").Parameter <double>("param");
builder.EntityType <Customer>().Function("BoundFunction").Returns <double>().Parameter <string>("name");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Employee>("Employees");
builder.ComplexType <Address>();
builder.EntitySet <Message>("Messages");
builder.Action("ResetEF");
return(builder.GetEdmModel());
}
public static void AddODataServerFieldValidation(this ODataConventionModelBuilder builder)
{
var validateField =
builder
.Action("ValidateField")
.Returns <string>();
validateField.Parameter <string>("SetName");
validateField.Parameter <string>("Name");
validateField.Parameter <string>("Value");
}
public ODataSwaggerConverterTest()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
builder.Function("UnboundFunction").Returns <string>().Parameter <int>("param");
builder.Action("UnboundAction").Parameter <double>("param");
builder.EntityType <Customer>().Function("BoundFunction").Returns <double>().Parameter <string>("name");
_model = builder.GetEdmModel();
}
private IEdmModel GetEdmModel(HttpConfiguration configuration)
{
ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>(configuration);
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");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
builder.Action("UnboundAction").Parameter<double>("param");
builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
builder.EntitySet<CompositeKeyItem>("CompositeKeyItems");
builder.EntityType<CompositeKeyItem>().HasKey(x => new { x.FirstKey, x.SecondKey });
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel(HttpConfiguration configuration)
{
var builder = new ODataConventionModelBuilder(configuration);
EntitySetConfiguration <SelectCustomer> customers = builder.EntitySet <SelectCustomer>("SelectCustomer");
customers.EntityType.Action("CreditRating").Returns <double>();
customers.EntityType.Collection.Action("PremiumCustomers").ReturnsCollectionFromEntitySet <SelectCustomer>("SelectCustomer");
builder.EntitySet <EFSelectCustomer>("EFSelectCustomers");
builder.EntitySet <EFSelectOrder>("EFSelectOrders");
builder.EntitySet <SelectOrderDetail>("SelectOrderDetail");
builder.EntityType <SelectPremiumCustomer>();
builder.EntitySet <SelectOrder>("SelectOrder");
builder.EntitySet <SelectBonus>("SelectBonus");
builder.EntitySet <EFWideCustomer>("EFWideCustomers");
builder.Action("ResetDataSource");
builder.Action("ResetDataSource-Order");
IEdmModel model = builder.GetEdmModel();
var wideType = model.EntityContainer.EntitySets().First(e => e.Name == "EFWideCustomers").EntityType() as EdmEntityType;
for (var idx = 1; idx <= 5; idx++)
{
var containerProperty = typeof(EFWideCustomer).GetProperty($"Custom{idx}");
for (int i = (idx - 1) * 400 + 1; i <= idx * 400; i++)
{
var prop = wideType.AddStructuralProperty($"Prop{i:0000}", EdmPrimitiveTypeKind.String);
model.SetAnnotationValue(prop, new ClrPropertyInfoAnnotation(containerProperty.PropertyType.GetProperty($"Prop{i:0000}"))
{
PropertiesPath = new List <PropertyInfo>()
{
containerProperty
}
});
}
}
return(model);
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <string>();
var action = builder.Action("RateByName");
action.Parameter <string>("name");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel(HttpConfiguration configuration)
{
var builder = new ODataConventionModelBuilder(configuration);
EntitySetConfiguration <SelectCustomer> customers = builder.EntitySet <SelectCustomer>("SelectCustomer");
customers.EntityType.Action("CreditRating").Returns <double>();
customers.EntityType.Collection.Action("PremiumCustomers").ReturnsCollectionFromEntitySet <SelectCustomer>("SelectCustomer");
builder.EntitySet <EFSelectCustomer>("EFSelectCustomers");
builder.EntitySet <EFSelectOrder>("EFSelectOrders");
builder.EntitySet <SelectOrderDetail>("SelectOrderDetail");
builder.EntityType <SelectPremiumCustomer>();
builder.EntitySet <SelectOrder>("SelectOrder");
builder.EntitySet <SelectBonus>("SelectBonus");
builder.Action("ResetDataSource");
builder.Action("ResetDataSource-Order");
IEdmModel model = builder.GetEdmModel();
return(model);
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
builder.Function("UnboundFunction").Returns <string>().Parameter <int>("param");
builder.Action("UnboundAction").Parameter <double>("param");
builder.EntityType <Customer>().Function("BoundFunction").Returns <double>().Parameter <string>("name");
builder.EntitySet <CompositeKeyItem>("CompositeKeyItems");
builder.EntityType <CompositeKeyItem>().HasKey(x => new { x.FirstKey, x.SecondKey });
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.Namespace = "AirVinyl";
builder.ContainerName = "AirVinylContainer";
builder.EntitySet <Person>("People");
//builder.EntitySet<VinylRecord>("VinylRecords");
builder.EntitySet <RecordStore>("RecordStores");
var isHighRatedFunction = builder.EntityType <RecordStore>().Function("IsHighRated");
isHighRatedFunction.Returns <bool>();
isHighRatedFunction.Parameter <int>("minimumRating");
isHighRatedFunction.Namespace = "AirVinyl.Functions";
var areRatedByFunction = builder.EntityType <RecordStore>().Collection.Function("AreRatedBy");
areRatedByFunction.ReturnsCollectionFromEntitySet <RecordStore>("RecordStore");
areRatedByFunction.CollectionParameter <int>("personIds");
areRatedByFunction.Namespace = "AirVinyl.Functions";
var getHighRatedRecordStoresFunction = builder.Function("GetHighRatedRecordStores");
getHighRatedRecordStoresFunction.Parameter <int>("minimumRating");
getHighRatedRecordStoresFunction.ReturnsCollectionFromEntitySet <RecordStore>("RecordStores");
getHighRatedRecordStoresFunction.Namespace = "AirVinyl.Functions";
var rateAction = builder.EntityType <RecordStore>().Action("Rate");
rateAction.Returns <bool>();
rateAction.Parameter <int>("rating");
rateAction.Parameter <int>("personId");
rateAction.Namespace = "AirVinyl.Actions";
var removeRatingsAction = builder.EntityType <RecordStore>().Collection.Action("RemoveRatings");
removeRatingsAction.Returns <bool>();
removeRatingsAction.Parameter <int>("personId");
removeRatingsAction.Namespace = "AirVinyl.Actions";
var removeRecordStoreRatingsAction = builder.Action("RemoveRecordStoreRatings");
removeRecordStoreRatingsAction.Parameter <int>("personId");
removeRecordStoreRatingsAction.Namespace = "AirVinyl.Actions";
builder.Singleton <Person>("Tim");
return(builder.GetEdmModel());
}
static StoreModel()
{
var builder = new ODataConventionModelBuilder
{
Namespace = "Microsoft.Restier.Tests.AspNet"
};
builder.EntitySet <Product>("Products");
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Store>("Stores");
builder.Function("GetBestProduct").ReturnsFromEntitySet <Product>("Products");
builder.Action("RemoveWorstProduct").ReturnsFromEntitySet <Product>("Products");
Model = (EdmModel)builder.GetEdmModel();
Product = (IEdmEntityType)Model.FindType("Microsoft.Restier.Tests.AspNet.Product");
}
public static IEdmModel GetModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration<Employee> employees = builder.EntitySet<Employee>("Employees");
EntityTypeConfiguration<Employee> employee = employees.EntityType;
employee.EnumProperty<Gender>(e => e.Sex).Name = "Gender";
var resetDataSource = builder.Action("ResetDataSource");
builder.Namespace = typeof(Employee).Namespace;
// All the property names in the generated Edm Model will become camel case if EnableLowerCamelCase() is called.
builder.EnableLowerCamelCase();
var edmModel = builder.GetEdmModel();
return edmModel;
}
public static IEdmModel GetModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var paymentInstrumentType = builder.EntityType<PaymentInstrument>();
builder.EntitySet<Account>("Accounts");
var functionConfiguration = paymentInstrumentType.Collection.Function("GetCount");
functionConfiguration.Parameter<string>("NameContains");
functionConfiguration.Returns<int>();
builder.Action("ResetDataSource");
builder.Namespace = typeof(Account).Namespace;
return builder.GetEdmModel();
}
public static IEdmModel GetEdmModel()
{
if (_edmModel != null)
{
return(_edmModel);
}
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Person>("People");
// add action
builder.Action("AddPerson");
//
_edmModel = builder.GetEdmModel();
return(_edmModel);
}
public void Apply_SetsActionLinkBuilder_OnlyIfActionIsBindable()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var vehicles = builder.EntitySet<Vehicle>("vehicles");
var paintAction = builder.Action("Paint");
ActionLinkGenerationConvention convention = new ActionLinkGenerationConvention();
// Act
convention.Apply(paintAction, builder);
// Assert
IEdmModel model = builder.GetEdmModel();
var paintEdmAction = model.EntityContainer.Elements.OfType<IEdmActionImport>().Single();
ActionLinkBuilder actionLinkBuilder = model.GetAnnotationValue<ActionLinkBuilder>(paintEdmAction);
Assert.Null(actionLinkBuilder);
}
private static IEdmModel GetEdmModel(HttpConfiguration configuration)
{
var builder = new ODataConventionModelBuilder(configuration);
EntitySetConfiguration<SelectCustomer> customers = builder.EntitySet<SelectCustomer>("SelectCustomer");
customers.EntityType.Action("CreditRating").Returns<double>();
customers.EntityType.Collection.Action("PremiumCustomers").ReturnsCollectionFromEntitySet<SelectCustomer>("SelectCustomer");
builder.EntitySet<EFSelectCustomer>("EFSelectCustomers");
builder.EntitySet<EFSelectOrder>("EFSelectOrders");
builder.EntitySet<SelectOrderDetail>("SelectOrderDetail");
builder.EntityType<SelectPremiumCustomer>();
builder.EntitySet<SelectOrder>("SelectOrder");
builder.EntitySet<SelectBonus>("SelectBonus");
builder.Action("ResetDataSource");
IEdmModel model = builder.GetEdmModel();
return model;
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Action("ResetDataSource");
builder.Namespace = typeof(Customer).Namespace;
return builder.GetEdmModel();
}
public void UnboundAction_ForEnumTypeInODataConventionModelBuilder()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
ActionConfiguration actionConfiguration = builder.Action("UnboundAction");
actionConfiguration.CollectionParameter<Color>("Colors");
actionConfiguration.Returns<Color?>();
// Act & Assert
IEdmModel model = builder.GetEdmModel();
IEdmActionImport actionImport = model.EntityContainer.OperationImports().Single(o => o.Name == "UnboundAction") as IEdmActionImport;
IEdmTypeReference colors = actionImport.Action.Parameters.Single(p => p.Name == "Colors").Type;
IEdmTypeReference returnType = actionImport.Action.ReturnType;
IEdmEnumType colorType = model.SchemaElements.OfType<IEdmEnumType>().Single(e => e.Name == "Color");
Assert.True(colors.IsCollection());
Assert.False(colors.AsCollection().ElementType().IsNullable);
Assert.Same(colorType, colors.AsCollection().ElementType().Definition);
Assert.True(returnType.IsNullable);
Assert.Same(colorType, returnType.Definition);
}
public void UnboundAction_ForEnumWithShortUnderlyingTypeInODataConventionModelBuilder()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
ActionConfiguration actionConfiguration = builder.Action("UnboundAction");
actionConfiguration.Returns<ShortEnum>();
// Act & Assert
IEdmModel model = builder.GetEdmModel();
IEdmAction action = model.FindDeclaredOperations("Default.UnboundAction").Single() as IEdmAction;
IEdmTypeReference returnType = action.ReturnType;
IEdmEnumType shortEnumType = model.SchemaElements.OfType<IEdmEnumType>().Single(e => e.Name == "ShortEnum");
Assert.Same(shortEnumType, returnType.Definition);
Assert.Equal(EdmPrimitiveTypeKind.Int16, returnType.AsEnum().EnumDefinition().UnderlyingType.PrimitiveKind);
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<ConventionCustomer>("ConventionCustomers");
builder.EntitySet<ConventionOrder>("ConventionOrders");
EnumTypeConfiguration<ConventionGender> enumType = builder.EnumType<ConventionGender>();
enumType.Member(ConventionGender.Female);
enumType.Member(ConventionGender.Male);
#region functions
FunctionConfiguration getAllCustomers = builder.Function("GetAllConventionCustomers");
getAllCustomers.ReturnsCollectionFromEntitySet<ConventionCustomer>("ConventionCustomers");
getAllCustomers.IsComposable = true;
// Return all the customers whose name contains CustomerName
FunctionConfiguration getAllCustomersOverload = builder.Function("GetAllConventionCustomers");
getAllCustomersOverload.ReturnsCollectionFromEntitySet<ConventionCustomer>("ConventionCustomers");
getAllCustomersOverload.Parameter<string>("CustomerName");
getAllCustomersOverload.IsComposable = true;
FunctionConfiguration getCustomersById = builder.Function("GetConventionCustomerById");
getCustomersById.Parameter<int>("CustomerId");
getCustomersById.ReturnsFromEntitySet<ConventionCustomer>("ConventionCustomers");
getCustomersById.IsComposable = true;
FunctionConfiguration getOrder = builder.Function("GetConventionOrderByCustomerIdAndOrderName");
getOrder.Parameter<int>("CustomerId");
getOrder.Parameter<string>("OrderName");
getOrder.ReturnsFromEntitySet<ConventionOrder>("ConventionOrders");
FunctionConfiguration getCustomerNameById = builder.Function("GetConventionCustomerNameById");
getCustomerNameById.Parameter<int>("CustomerId");
getCustomerNameById.Returns<string>();
FunctionConfiguration getDefinedGenders = builder.Function("GetDefinedGenders");
getDefinedGenders.ReturnsCollection<ConventionGender>()
.IsComposable = true;
FunctionConfiguration function = builder.Function("AdvancedFunction").Returns<bool>();
function.CollectionParameter<int>("nums");
function.CollectionParameter<ConventionGender>("genders");
function.Parameter<ConventionAddress>("location");
function.CollectionParameter<ConventionAddress>("addresses");
function.EntityParameter<ConventionCustomer>("customer");
function.CollectionEntityParameter<ConventionCustomer>("customers");
#endregion
#region actions
ActionConfiguration resetDataSource = builder.Action("ResetDataSource");
// bug: error message: non-binding parameter type must be either Primitive, Complex, Collection of Primitive or a Collection of Complex.
/*
ActionConfiguration createCustomer = builder.Action("CreateCustomer");
createCustomer.Parameter<ConventionCustomer>("Customer");
createCustomer.ReturnsFromEntitySet<ConventionCustomer>("ConventionCustomers");
*/
ActionConfiguration udpateAddress = builder.Action("UpdateAddress");
udpateAddress.Parameter<ConventionAddress>("Address");
udpateAddress.Parameter<int>("ID");
udpateAddress.ReturnsCollectionFromEntitySet<ConventionCustomer>("ConventionCustomers");
ActionConfiguration action = builder.Action("AdvancedAction");
action.CollectionParameter<int>("nums");
action.CollectionParameter<ConventionGender>("genders");
action.Parameter<ConventionAddress>("location");
action.CollectionParameter<ConventionAddress>("addresses");
action.EntityParameter<ConventionCustomer>("customer");
action.CollectionEntityParameter<ConventionCustomer>("customers");
#endregion
var schemaNamespace = typeof(ConventionCustomer).Namespace;
builder.Namespace = schemaNamespace;
var edmModel = builder.GetEdmModel();
var container = edmModel.EntityContainer as EdmEntityContainer;
#region function imports
var entitySet = container.FindEntitySet("ConventionCustomers");
var getCustomersByIdOfEdmFunction = edmModel.FindDeclaredOperations(schemaNamespace + ".GetConventionCustomerById").First() as EdmFunction;
container.AddFunctionImport("GetConventionCustomerByIdImport", getCustomersByIdOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet));
var functionsOfGetAllConventionCustomers = edmModel.FindDeclaredOperations(schemaNamespace + ".GetAllConventionCustomers");
var getAllConventionCustomersOfEdmFunction = functionsOfGetAllConventionCustomers.FirstOrDefault(f => f.Parameters.Count() == 0) as EdmFunction;
container.AddFunctionImport("GetAllConventionCustomersImport", getAllConventionCustomersOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet));
// TODO delete this overload after bug 1640 is fixed: It can not find the correct overload function if the the function is exposed as a function import.
var getAllConventionCustomersOverloadOfEdmFunction = functionsOfGetAllConventionCustomers.FirstOrDefault(f => f.Parameters.Count() > 0) as EdmFunction;
container.AddFunctionImport("GetAllConventionCustomersImport", getAllConventionCustomersOverloadOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet));
var entitySet1 = container.FindEntitySet("ConventionOrders");
var GetConventionOrderByCustomerIdAndOrderNameOfEdmFunction = edmModel.FindDeclaredOperations(schemaNamespace + ".GetConventionOrderByCustomerIdAndOrderName").First() as EdmFunction;
container.AddFunctionImport("GetConventionOrderByCustomerIdAndOrderNameImport", GetConventionOrderByCustomerIdAndOrderNameOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet1));
var getConventionCustomerNameByIdOfEdmFunction = edmModel.FindDeclaredOperations(schemaNamespace + ".GetConventionCustomerNameById").First() as EdmFunction;
container.AddFunctionImport("GetConventionCustomerNameByIdImport", getConventionCustomerNameByIdOfEdmFunction, null);
#endregion
#region action imports
var resetDataSourceOfEdmAction = edmModel.FindDeclaredOperations(schemaNamespace + ".ResetDataSource").FirstOrDefault() as EdmAction;
container.AddActionImport("ResetDataSourceImport", resetDataSourceOfEdmAction);
// TODO: it is a potential issue that entity can not be used as an un-bound parameter.
/*
var createCustomerOfEdmAction = edmModel.FindDeclaredOperations(schemaNamespace + ".CreateCustomer").FirstOrDefault() as EdmAction;
container.AddActionImport("CreateCustomerImport", createCustomerOfEdmAction);
*/
var updateAddressOfEdmAction = edmModel.FindDeclaredOperations(schemaNamespace + ".UpdateAddress").FirstOrDefault() as EdmAction;
container.AddActionImport("UpdateAddressImport", updateAddressOfEdmAction, new EdmEntitySetReferenceExpression(entitySet));
#endregion
return edmModel;
}
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();
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "ODataSamples.WebApiService.Models";
builder.ContainerName = "DefaultContainer";
builder.EntitySet<Person>("People");
builder.EntitySet<Airport>("Airports");
builder.EntitySet<Airline>("Airlines");
builder.Singleton<Person>("Me");
// Customer - Order scenarios
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
#region Unbound Function & Action
builder.Action("ResetDataSource");
//TODO : Double type has some issue.
var GetNearestAirportFun = builder.Function("GetNearestAirport");
GetNearestAirportFun.Parameter<double>("lat");
GetNearestAirportFun.Parameter<double>("lon");
GetNearestAirportFun.ReturnsFromEntitySet<Airport>("Airports");
#endregion
#region Person Function & Action
var personType = builder.EntityType<Person>();
personType.Function("GetFavoriteAirline")
.ReturnsFromEntitySet<Airline>("Airlines");
//TODO: Fix this issue, the return type can't be "Trip".
personType.Function("GetFriendsTrips")
.ReturnsCollectionFromEntitySet<Airline>("Airlines")
.Parameter<string>("userName");
var shareTripAction = personType.Action("ShareTrip");
shareTripAction.Parameter<string>("userName");
shareTripAction.Parameter<int>("tripId");
#endregion
#region Trip Function & Action
// TODO: The request will fail, should fix this issue.
// GET odata/People('russellwhyte')/Trips(1001)/ODataSamples.WebApiService.Models.GetInvolvedPeople()
var tripType = builder.EntityType<Trip>();
tripType.Function("GetInvolvedPeople")
.ReturnsCollectionFromEntitySet<Person>("People");
#endregion
#region Add Navigation Target
var edmModel = builder.GetEdmModel();
var peopleEntitySet = edmModel.EntityContainer.FindEntitySet("People") as EdmEntitySet;
var meSingleton = edmModel.EntityContainer.FindSingleton("Me") as EdmSingleton;
var flightEntityType = edmModel.FindDeclaredType("ODataSamples.WebApiService.Models.Flight") as EdmEntityType;
var propertyAriline = flightEntityType.FindProperty("Airline") as EdmNavigationProperty;
var propertyFrom = flightEntityType.FindProperty("From") as EdmNavigationProperty;
var propertyTo = flightEntityType.FindProperty("To") as EdmNavigationProperty;
var targetAirlines = edmModel.EntityContainer.FindEntitySet("Airlines");
var targetAirports = edmModel.EntityContainer.FindEntitySet("Airports");
peopleEntitySet.AddNavigationTarget(propertyAriline, targetAirlines);
peopleEntitySet.AddNavigationTarget(propertyFrom, targetAirports);
peopleEntitySet.AddNavigationTarget(propertyTo, targetAirports);
meSingleton.AddNavigationTarget(propertyAriline, targetAirlines);
meSingleton.AddNavigationTarget(propertyFrom, targetAirports);
meSingleton.AddNavigationTarget(propertyTo, targetAirports);
#endregion
return edmModel;
}
// Builds the EDM model for the OData service, including the OData action definitions.
private static IEdmModel GetEdmModel()
{
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet<Vedio>("Vedios");
ActionConfiguration returnAcAction = modelBuilder.Action("ReturnAc");
returnAcAction.Parameter<int>("key");
returnAcAction.ReturnsFromEntitySet<Vedio>("Vedios");
FunctionConfiguration checkOutAction = modelBuilder.Function("CheckOut");
checkOutAction.Parameter<int>("key");
checkOutAction.ReturnsFromEntitySet<Vedio>("Vedios");
ActionConfiguration createMovieAction = modelBuilder.Action("CreateVedio");
createMovieAction.Parameter<Vedio>("vedio");
createMovieAction.ReturnsFromEntitySet<Vedio>("Vedios");
ActionConfiguration ListAcAction = modelBuilder.Action("ListAc");
ListAcAction.Parameter<Window>("windows");
ListAcAction.Returns<int>();
ActionConfiguration checkOutManyAction = modelBuilder.Action("CheckOutMany");
checkOutManyAction.CollectionParameter<int>("MovieIDs");
checkOutManyAction.ReturnsCollectionFromEntitySet<Vedio>("Vedios");
//######################################################################################################//
modelBuilder.EntitySet<QueryResult>("QueryResults");
FunctionConfiguration GetRunningTasks = modelBuilder.Function("GetRunningTasks");
GetRunningTasks.Parameter<QueryEntity>("query");
GetRunningTasks.ReturnsCollectionFromEntitySet<QueryResult>("QueryResults");
FunctionConfiguration GetReadyTasks = modelBuilder.Function("GetReadyTasks");
GetReadyTasks.Parameter<QueryEntity>("query");
GetReadyTasks.ReturnsCollectionFromEntitySet<QueryResult>("QueryResults");
//######################################################################################################//
ActionConfiguration StartProcess = modelBuilder.Action("StartProcess");
StartProcess.Parameter<WfRunner>("WfRunner");
StartProcess.Returns<int>();
ActionConfiguration RunProcess = modelBuilder.Action("RunProcess");
RunProcess.Parameter<WfRunner>("WfRunner");
RunProcess.Returns<string>();
ActionConfiguration WithdrawProcess = modelBuilder.Action("WithdrawProcess");
WithdrawProcess.Parameter<WfRunner>("WfRunner");
WithdrawProcess.Returns<string>();
ActionConfiguration SendBackProcess = modelBuilder.Action("SendBackProcess");
SendBackProcess.Parameter<WfRunner>("WfRunner");
SendBackProcess.Returns<string>();
ActionConfiguration JumpProcess = modelBuilder.Action("JumpProcess");
JumpProcess.Parameter<WfRunner>("WfRunner");
JumpProcess.Returns<string>();
ActionConfiguration ReverseProcess = modelBuilder.Action("ReverseProcess");
ReverseProcess.Parameter<WfRunner>("WfRunner");
ReverseProcess.Returns<string>();
ActionConfiguration DiscardProcess = modelBuilder.Action("DiscardProcess");
DiscardProcess.Parameter<WfRunner>("WfRunner");
DiscardProcess.Returns<string>();
modelBuilder.Namespace = "WF";
return modelBuilder.GetEdmModel();
}
private static IEdmModel GetModel()
{
HttpConfiguration config = new HttpConfiguration();
config.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(typeof(Customer)));
ODataModelBuilder builder = new ODataConventionModelBuilder(config);
builder.ContainerName = "C";
builder.Namespace = "A.B";
EntityTypeConfiguration<Customer> customer = builder.EntitySet<Customer>("Customers").EntityType;
// bound actions
ActionConfiguration primitive = customer.Action("Primitive");
primitive.Parameter<int>("Quantity");
primitive.Parameter<string>("ProductCode");
ActionConfiguration complex = customer.Action("Complex");
complex.Parameter<int>("Quantity");
complex.Parameter<MyAddress>("Address");
ActionConfiguration primitiveCollection = customer.Action("PrimitiveCollection");
primitiveCollection.Parameter<string>("Name");
primitiveCollection.CollectionParameter<int>("Ratings");
ActionConfiguration complexCollection = customer.Action("ComplexCollection");
complexCollection.Parameter<string>("Name");
complexCollection.CollectionParameter<MyAddress>("Addresses");
// unbound actions
ActionConfiguration unboundPrimitive = builder.Action("UnboundPrimitive");
unboundPrimitive.Parameter<int>("Quantity");
unboundPrimitive.Parameter<string>("ProductCode");
ActionConfiguration unboundComplex = builder.Action("UnboundComplex");
unboundComplex.Parameter<int>("Quantity");
unboundComplex.Parameter<MyAddress>("Address");
ActionConfiguration unboundPrimitiveCollection = builder.Action("UnboundPrimitiveCollection");
unboundPrimitiveCollection.Parameter<string>("Name");
unboundPrimitiveCollection.CollectionParameter<int>("Ratings");
ActionConfiguration unboundComplexCollection = builder.Action("UnboundComplexCollection");
unboundComplexCollection.Parameter<string>("Name");
unboundComplexCollection.CollectionParameter<MyAddress>("Addresses");
return builder.GetEdmModel();
}
private static IEdmModel GetModel()
{
HttpConfiguration config = new HttpConfiguration();
config.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(typeof(Customer)));
ODataModelBuilder builder = new ODataConventionModelBuilder(config);
builder.ContainerName = "C";
builder.Namespace = "A.B";
EntityTypeConfiguration<Customer> customer = builder.EntitySet<Customer>("Customers").EntityType;
// bound actions
ActionConfiguration primitive = customer.Action("Primitive");
primitive.Parameter<int>("Quantity");
primitive.Parameter<string>("ProductCode");
primitive.Parameter<Date>("Birthday");
primitive.Parameter<AColor>("BkgColor");
primitive.Parameter<AColor?>("InnerColor");
ActionConfiguration complex = customer.Action("Complex");
complex.Parameter<int>("Quantity");
complex.Parameter<MyAddress>("Address");
ActionConfiguration enumType = customer.Action("Enum");
enumType.Parameter<AColor>("Color");
ActionConfiguration primitiveCollection = customer.Action("PrimitiveCollection");
primitiveCollection.Parameter<string>("Name");
primitiveCollection.CollectionParameter<int>("Ratings");
primitiveCollection.CollectionParameter<TimeOfDay>("Time");
primitiveCollection.CollectionParameter<AColor?>("Colors");
ActionConfiguration complexCollection = customer.Action("ComplexCollection");
complexCollection.Parameter<string>("Name");
complexCollection.CollectionParameter<MyAddress>("Addresses");
ActionConfiguration enumCollection = customer.Action("EnumCollection");
enumCollection.CollectionParameter<AColor>("Colors");
ActionConfiguration entity = customer.Action("Entity");
entity.Parameter<int>("Id");
entity.EntityParameter<Customer>("Customer");
entity.EntityParameter<Customer>("NullableCustomer");
ActionConfiguration entityCollection = customer.Action("EntityCollection");
entityCollection.Parameter<int>("Id");
entityCollection.CollectionEntityParameter<Customer>("Customers");
// unbound actions
ActionConfiguration unboundPrimitive = builder.Action("UnboundPrimitive");
unboundPrimitive.Parameter<int>("Quantity");
unboundPrimitive.Parameter<string>("ProductCode");
unboundPrimitive.Parameter<Date>("Birthday");
unboundPrimitive.Parameter<AColor>("BkgColor");
unboundPrimitive.Parameter<AColor?>("InnerColor");
ActionConfiguration unboundComplex = builder.Action("UnboundComplex");
unboundComplex.Parameter<int>("Quantity");
unboundComplex.Parameter<MyAddress>("Address");
ActionConfiguration unboundEnum = builder.Action("UnboundEnum");
unboundEnum.Parameter<AColor>("Color");
ActionConfiguration unboundPrimitiveCollection = builder.Action("UnboundPrimitiveCollection");
unboundPrimitiveCollection.Parameter<string>("Name");
unboundPrimitiveCollection.CollectionParameter<int>("Ratings");
unboundPrimitiveCollection.CollectionParameter<TimeOfDay>("Time");
unboundPrimitiveCollection.CollectionParameter<AColor?>("Colors");
ActionConfiguration unboundComplexCollection = builder.Action("UnboundComplexCollection");
unboundComplexCollection.Parameter<string>("Name");
unboundComplexCollection.CollectionParameter<MyAddress>("Addresses");
ActionConfiguration unboundEnumCollection = builder.Action("UnboundEnumCollection");
unboundEnumCollection.CollectionParameter<AColor>("Colors");
ActionConfiguration unboundEntity = builder.Action("UnboundEntity");
unboundEntity.Parameter<int>("Id");
unboundEntity.EntityParameter<Customer>("Customer").OptionalParameter = false;
unboundEntity.EntityParameter<Customer>("NullableCustomer");
ActionConfiguration unboundEntityCollection = builder.Action("UnboundEntityCollection");
unboundEntityCollection.Parameter<int>("Id");
unboundEntityCollection.CollectionEntityParameter<Customer>("Customers");
return builder.GetEdmModel();
}
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();
}
public static IEdmModel GetEdmModel()
{
if (_edmModel == null)
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
// two overload function import
var function = builder.Function("CalcByRating");
function.Parameter <int>("order");
function.ReturnsFromEntitySet <Customer>("Customers");
function = builder.Function("CalcByRating");
function.Parameter <string>("name");
function.ReturnsFromEntitySet <Customer>("Customers");
// action import
var action = builder.Action("CalcByRatingAction");
action.Parameter <int>("order");
action.ReturnsFromEntitySet <Customer>("Customers");
_edmModel = builder.GetEdmModel();
}
return(_edmModel);
}
