public static IEdmModel GetEdmModelV1()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.Singleton <Customer>("Me");
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
var action = builder.EntityType <Customer>().Action("RateByName");
action.Parameter <string>("name");
action.Parameter <int>("age");
action.Returns <string>();
// bound action
ActionConfiguration boundAction = builder.EntityType <Customer>().Action("BoundAction");
boundAction.Parameter <int>("p1");
boundAction.Parameter <Address>("p2");
boundAction.Parameter <Color?>("color");
boundAction.CollectionParameter <string>("p3");
boundAction.CollectionParameter <Address>("p4");
boundAction.CollectionParameter <Color?>("colors");
return(builder.GetEdmModel());
}
private IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.ContainerName = "Container";
builder.Namespace = "org.odata";
EntityTypeConfiguration<Customer> customer = builder.EntitySet<Customer>("Customers").EntityType;
ActionConfiguration action = customer.Action("DoSomething");
action.Parameter<int>("p1");
action.Parameter<Address>("p2");
action.CollectionParameter<string>("p3");
action.CollectionParameter<Address>("p4");
return builder.GetEdmModel();
}
public void CanCreateActionWithNonbindingParameters()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = builder.Action("MyAction");
action.Parameter <string>("p0");
action.Parameter <int>("p1");
action.Parameter <Address>("p2");
action.CollectionParameter <string>("p3");
action.CollectionParameter <int>("p4");
action.CollectionParameter <ZipCode>("p5");
action.EntityParameter <Customer>("p6");
action.CollectionEntityParameter <Employee>("p7");
ParameterConfiguration[] parameters = action.Parameters.ToArray();
ComplexTypeConfiguration[] complexTypes = builder.StructuralTypes.OfType <ComplexTypeConfiguration>().ToArray();
EntityTypeConfiguration[] entityTypes = builder.StructuralTypes.OfType <EntityTypeConfiguration>().ToArray();
// Assert
Assert.Equal(2, complexTypes.Length);
Assert.Equal(typeof(Address).FullName, complexTypes[0].FullName);
Assert.Equal(typeof(ZipCode).FullName, complexTypes[1].FullName);
Assert.Equal(2, entityTypes.Length);
Assert.Equal(typeof(Customer).FullName, entityTypes[0].FullName);
Assert.Equal(typeof(Employee).FullName, entityTypes[1].FullName);
Assert.Equal(8, parameters.Length);
Assert.Equal("p0", parameters[0].Name);
Assert.Equal("Edm.String", parameters[0].TypeConfiguration.FullName);
Assert.Equal("p1", parameters[1].Name);
Assert.Equal("Edm.Int32", parameters[1].TypeConfiguration.FullName);
Assert.Equal("p2", parameters[2].Name);
Assert.Equal(typeof(Address).FullName, parameters[2].TypeConfiguration.FullName);
Assert.Equal("p3", parameters[3].Name);
Assert.Equal("Collection(Edm.String)", parameters[3].TypeConfiguration.FullName);
Assert.Equal("p4", parameters[4].Name);
Assert.Equal("Collection(Edm.Int32)", parameters[4].TypeConfiguration.FullName);
Assert.Equal("p5", parameters[5].Name);
Assert.Equal(string.Format("Collection({0})", typeof(ZipCode).FullName), parameters[5].TypeConfiguration.FullName);
Assert.Equal("p6", parameters[6].Name);
Assert.Equal(typeof(Customer).FullName, parameters[6].TypeConfiguration.FullName);
Assert.Equal("p7", parameters[7].Name);
Assert.Equal(string.Format("Collection({0})", typeof(Employee).FullName), parameters[7].TypeConfiguration.FullName);
}
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());
}
private IEdmModel GetModel()
{
if (_model == null)
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.ContainerName = "C";
builder.Namespace = "A.B";
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
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");
_model = builder.GetEdmModel();
}
return(_model);
}
private 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;
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");
return(builder.GetEdmModel());
}
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());
}
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 static IEdmModel GetEdmModelV1()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Organization>("Organizations");
builder.EntitySet <Department>("Departments");
builder.EntitySet <Company>("Companies");
builder.EntitySet <Customer>("Customers");
builder.Singleton <Customer>("Me");
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
var action = builder.EntityType <Customer>().Action("RateByName");
action.Parameter <string>("name");
action.Parameter <int>("age");
action.Returns <string>();
// bound action
ActionConfiguration boundAction = builder.EntityType <Customer>().Action("BoundAction");
boundAction.Parameter <int>("p1");
boundAction.Parameter <Address>("p2");
boundAction.Parameter <Color?>("color");
boundAction.CollectionParameter <string>("p3");
boundAction.CollectionParameter <Address>("p4");
boundAction.CollectionParameter <Color?>("colors");
// bound function for organization
var productPrice = builder.EntityType <Organization>().Collection.
Function("GetPrice").Returns <string>();
productPrice.Parameter <string>("organizationId").Required();
productPrice.Parameter <string>("partId").Required();
productPrice = builder.EntityType <Organization>().Collection.
Function("GetPrice2").ReturnsCollectionFromEntitySet <Organization>("Organizations");
productPrice.Parameter <string>("organizationId").Required();
productPrice.Parameter <string>("partId").Required();
productPrice.IsComposable = true;
return(builder.GetEdmModel());
}
public void CanCreateActionWithNonbindingParametersAsNullable()
{
// Arrange & Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = builder.Action("MyAction");
action.Parameter <string>("p0");
action.Parameter <string>("p1").Nullable = false;
action.Parameter <int>("p2").Nullable = true;
action.Parameter <int>("p3");
action.Parameter <Address>("p4");
action.Parameter <Address>("p5").Nullable = false;
action.CollectionParameter <ZipCode>("p6");
action.CollectionParameter <ZipCode>("p7").Nullable = false;
action.EntityParameter <Customer>("p8");
action.EntityParameter <Customer>("p9").Nullable = false;
action.CollectionEntityParameter <Customer>("p10");
action.CollectionEntityParameter <Customer>("p11").Nullable = false;
Dictionary <string, ParameterConfiguration> parameters = action.Parameters.ToDictionary(e => e.Name, e => e);
// Assert
Assert.True(parameters["p0"].Nullable);
Assert.False(parameters["p1"].Nullable);
Assert.True(parameters["p2"].Nullable);
Assert.False(parameters["p3"].Nullable);
Assert.True(parameters["p4"].Nullable);
Assert.False(parameters["p5"].Nullable);
Assert.True(parameters["p6"].Nullable);
Assert.False(parameters["p7"].Nullable);
Assert.True(parameters["p8"].Nullable);
Assert.False(parameters["p9"].Nullable);
Assert.True(parameters["p10"].Nullable);
Assert.False(parameters["p11"].Nullable);
}
private static void BuildActions(ODataModelBuilder builder)
{
ActionConfiguration action = builder.EntityType <DCustomer>().Action("BoundAction");
action.Parameter <Date>("modifiedDate");
action.Parameter <TimeOfDay>("modifiedTime");
action.Parameter <Date?>("nullableModifiedDate");
action.Parameter <TimeOfDay?>("nullableModifiedTime");
action.CollectionParameter <Date>("dates");
action = builder.Action("UnboundAction");
action.Parameter <Date>("modifiedDate");
action.Parameter <TimeOfDay>("modifiedTime");
action.Parameter <Date?>("nullableModifiedDate");
action.Parameter <TimeOfDay?>("nullableModifiedTime");
action.CollectionParameter <Date>("dates");
// just for reset the data source
builder.Action("ResetDataSource");
}
public override Task <ODataConventionModelBuilder> Run(
ODataConventionModelBuilder modelBuilder,
CommercePipelineExecutionContext context)
{
Condition.Requires(modelBuilder).IsNotNull(this.Name + ": The argument cannot be null.");
ActionConfiguration composerTemplatesByIdsActions = modelBuilder.Action("ComposerTemplatesByIds");
composerTemplatesByIdsActions.CollectionParameter <string>("rawIds");
composerTemplatesByIdsActions.ReturnsCollectionFromEntitySet <ComposerTemplate>("ComposerTemplates");
return(Task.FromResult(modelBuilder));
}
private IEdmModel GetModel()
{
ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.ContainerName = "Container";
builder.Namespace = "org.odata";
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
ActionConfiguration action = customer.Action("DoSomething");
action.Parameter <int>("p1");
action.Parameter <Address>("p2");
action.Parameter <Color?>("color");
action.CollectionParameter <string>("p3");
action.CollectionParameter <Address>("p4");
action.CollectionParameter <Color?>("colors");
action = customer.Collection.Action("MyAction");
action.EntityParameter <Customer>("Customer");
action.CollectionEntityParameter <Customer>("Customers");
action = customer.Action("CNSAction");
action.Namespace = "customize";
return(builder.GetEdmModel());
}
// Builds the EDM model for the OData service, including the OData action definitions.
private static IEdmModel GetEdmModel()
{
var modelBuilder = new ODataConventionModelBuilder();
var moviesEntitySet = modelBuilder.EntitySet <Movie>("Movies");
// Now add actions.
// http://odata.github.io/WebApi/#02-03-model-builder-nonconvention
// CheckOut
// URI: ~/odata/Movies(1)/ODataActionSample.Models.CheckOut
ActionConfiguration checkOutAction = modelBuilder.EntityType <Movie>().Action("CheckOut");
checkOutAction.ReturnsFromEntitySet <Movie>("Movies");
// ReturnMovie
// URI: ~/odata/Movies(1)/ODataActionSample.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/ODataActionSample.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());
}
// Builds the EDM model for the OData service, including the OData action definitions.
private static IEdmModel GetModel()
{
ODataModelBuilder modelBuilder = new ODataConventionModelBuilder();
var moviesEntitySet = modelBuilder.EntitySet <Movie>("Movies");
moviesEntitySet.EntityType.Ignore(m => m.TimeStamp); // Don't expose timestamp to clients
// Now add actions to the EDM.
// CheckOut
// URI: ~/odata/Movies(1)/CheckOut
// Transient action. It is not available when the item is already checked out.
ActionConfiguration checkout = modelBuilder.Entity <Movie>().TransientAction("CheckOut");
// Provide a function that returns a link to the action, when the action is available, or
// returns null when the action is not available.
checkout.HasActionLink(ctx =>
{
Movie movie = ctx.EntityInstance as Movie;
// Note: In some cases, checking whether the action is available may be relatively expensive.
// For example, it might require a DB lookup.
// Avoid doing expensive checks inside a loop (i.e., when serializing a feed). Instead, simply
// mark the action as available, by returning an action link.
// The SkipExpensiveAvailabilityChecks flag says whether to skip expensive checks. If this flag
// is true AND your availability check is expensive, skip the check and return a link.
// In this sample, the check is not really expensive, but we honor the flag to show how it works.
bool createLink = true;
if (ctx.SkipExpensiveAvailabilityChecks)
{
// Caller asked us to skip the availability check.
createLink = true;
}
else if (!movie.IsCheckedOut) // Here is the "expensive" check
{
createLink = true;
}
if (createLink)
{
// Return the URI of the action.
return(new Uri(ctx.Url.CreateODataLink(
new EntitySetPathSegment(ctx.EntitySet),
new KeyValuePathSegment(ODataUriUtils.ConvertToUriLiteral(movie.ID, ODataVersion.V3)),
new ActionPathSegment(checkout.Name))));
}
else
{
return(null);
}
}, followsConventions: true); // "followsConventions" means the action follows OData conventions.
checkout.ReturnsFromEntitySet <Movie>("Movies");
// ReturnMovie
// URI: ~/odata/Movies(1)/Return
// Always bindable. If the movie is not checked out, the action is a no-op.
// Binds to a single entity; no parameters.
var returnAction = modelBuilder.Entity <Movie>().Action("Return");
returnAction.ReturnsFromEntitySet <Movie>("Movies");
// SetDueDate action
// URI: ~/odata/Movies(1)/SetDueDate
// Binds to a single entity; takes an action parameter.
var setDueDate = modelBuilder.Entity <Movie>().Action("SetDueDate");
setDueDate.Parameter <DateTime>("DueDate");
setDueDate.ReturnsFromEntitySet <Movie>("Movies");
// CheckOut action
// URI: ~/odata/Movies/CheckOut
// Shows how to bind to a collection, instead of a single entity.
// This action also accepts $filter queries. For example:
// ~/odata/Movies/CheckOut?$filter=Year eq 2005
var checkOutFromCollection = modelBuilder.Entity <Movie>().Collection.Action("CheckOut");
checkOutFromCollection.ReturnsCollectionFromEntitySet <Movie>("Movies");
// CheckOutMany action
// URI: ~/odata/Movies/CheckOutMany
// Shows an action that takes a collection parameter.
ActionConfiguration checkoutMany = modelBuilder.Entity <Movie>().Collection.Action("CheckOutMany");
checkoutMany.CollectionParameter <int>("MovieIDs");
checkoutMany.ReturnsCollectionFromEntitySet <Movie>("Movies");
// CreateMovie action
// URI: ~/odata/CreateMovie
// Non-bindable action. You invoke it from the service root.
ActionConfiguration createMovie = modelBuilder.Action("CreateMovie");
createMovie.Parameter <string>("Title");
createMovie.ReturnsFromEntitySet <Movie>("Movies");
return(modelBuilder.GetEdmModel());
}
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 void Register(HttpConfiguration config)
{
IList <IODataRoutingConvention> routingConventions = ODataRoutingConventions.CreateDefault();
routingConventions.Insert(0, new CountODataRoutingConvention());
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <ApparatusType>("ApparatusTypes");
builder.EntitySet <App>("Apps");
builder.EntitySet <AppParam>("AppParams");
builder.EntitySet <ProjectPart>("ProjectParts");
builder.EntitySet <Remark>("Remarks");
builder.EntitySet <TaskApp>("TaskApps");
builder.EntitySet <MessureValue>("MessureValues");
builder.EntitySet <CalculateValue>("CalculateValues");
builder.EntitySet <Formula>("Formulae");
ActionConfiguration rateProduct = builder.Entity <App>().Action("RateProduct");
rateProduct.Parameter <int>("Rating");
rateProduct.Returns <int>();
ActionConfiguration actionRateAll = builder.Entity <App>().Collection.Action("RateAllProducts");
actionRateAll.Parameter <int>("Rating");
actionRateAll.Returns <int>();
ActionConfiguration actionCheckExistData = builder.Entity <App>().Action("CheckExistData");
actionCheckExistData.Parameter <DateTimeOffset>("date");
actionCheckExistData.Returns <bool>();
ActionConfiguration actionGetCalcValues = builder.Entity <App>().Collection.Action("GetCalcValues");
actionGetCalcValues.Parameter <int>("topNum");
actionGetCalcValues.Parameter <DateTimeOffset?>("startDate");
actionGetCalcValues.Parameter <DateTimeOffset?>("endDate");
actionGetCalcValues.CollectionParameter <Guid>("appids");
actionGetCalcValues.ReturnsCollectionFromEntitySet <CalculateValue>("CalculateValues");
ActionConfiguration actionGetMesValues = builder.Entity <App>().Collection.Action("GetMesValues");
actionGetMesValues.Parameter <int>("topNum");
actionGetMesValues.Parameter <DateTimeOffset?>("startDate");
actionGetMesValues.Parameter <DateTimeOffset?>("endDate");
actionGetMesValues.CollectionParameter <Guid>("appids");
actionGetMesValues.ReturnsCollectionFromEntitySet <MessureValue>("MessureValues");
ActionConfiguration actionGetRemarks = builder.Entity <App>().Collection.Action("GetRemarks");
actionGetRemarks.Parameter <int>("topNum");
actionGetRemarks.Parameter <DateTimeOffset?>("startDate");
actionGetRemarks.Parameter <DateTimeOffset?>("endDate");
actionGetRemarks.CollectionParameter <Guid>("appids");
actionGetRemarks.ReturnsCollectionFromEntitySet <Remark>("Remarks");
ActionConfiguration actionSearcyAppByName = builder.Entity <App>().Collection.Action("SearcyAppByName");
actionSearcyAppByName.Parameter <string>("match");
actionSearcyAppByName.ReturnsCollectionFromEntitySet <App>("Apps");
ActionConfiguration actionSearcyAppCalcName = builder.Entity <App>().Collection.Action("SearcyAppCalcName");
actionSearcyAppCalcName.Parameter <string>("match");
actionSearcyAppCalcName.ReturnsCollectionFromEntitySet <App>("Apps");
ActionConfiguration actionGetChildAppCalcName = builder.Entity <App>().Collection.Action("GetChildAppCalcName");
actionGetChildAppCalcName.Parameter <string>("appCalcName");
actionGetChildAppCalcName.Parameter <DateTimeOffset>("date");
actionGetChildAppCalcName.ReturnsCollection <string>();
ActionConfiguration actionGetAllFormulaeByAppID = builder.Entity <App>().Action("GetAllFormulaeByAppID");
actionGetAllFormulaeByAppID.ReturnsCollectionFromEntitySet <Formula>("Formulae");
ActionConfiguration actionUpdateAppsProject = builder.Entity <ProjectPart>().Action("UpdateAppsProject");
actionUpdateAppsProject.CollectionParameter <Guid>("appids");
actionUpdateAppsProject.Returns <bool>();
ActionConfiguration actionUpdateAppsProjectByNames = builder.Entity <ProjectPart>().Action("UpdateAppsProjectByNames");
actionUpdateAppsProjectByNames.CollectionParameter <string>("names");
actionUpdateAppsProjectByNames.Returns <bool>();
config.Routes.MapODataRoute("odata", "odata", builder.GetEdmModel(), new CountODataPathHandler(), routingConventions,
new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
}
public override Task <ODataConventionModelBuilder> Run(ODataConventionModelBuilder modelBuilder, CommercePipelineExecutionContext context)
{
Condition.Requires(modelBuilder).IsNotNull($"{this.Name}: The argument cannot be null.");
ActionConfiguration updateItemDefinitionAction = modelBuilder.Action("UpdateItemDefinition");
updateItemDefinitionAction.Parameter <string>("itemId");
updateItemDefinitionAction.Parameter <string>("itemDefinition");
updateItemDefinitionAction.ReturnsFromEntitySet <CommerceCommand>("Commands");
ActionConfiguration createPriceCardAction = modelBuilder.Action("CreatePriceCard");
createPriceCardAction.Parameter <string>("itemId");
createPriceCardAction.Parameter <decimal>("price");
createPriceCardAction.ReturnsFromEntitySet <CommerceCommand>("Commands");
ActionConfiguration updatePriceSnapshotAction = modelBuilder.Action("UpdatePriceSnapshot");
updatePriceSnapshotAction.Parameter <string>("itemId");
updatePriceSnapshotAction.Parameter <decimal>("price");
updatePriceSnapshotAction.ReturnsFromEntitySet <CommerceCommand>("Commands");
ActionConfiguration addNewPriceSnapshotAction = modelBuilder.Action("AddNewPriceSnapshot");
addNewPriceSnapshotAction.Parameter <string>("itemId");
addNewPriceSnapshotAction.Parameter <decimal>("price");
addNewPriceSnapshotAction.ReturnsFromEntitySet <CommerceCommand>("Commands");
ActionConfiguration getDeliveryTimeAction = modelBuilder.Action("GetDeliveryTime");
addNewPriceSnapshotAction.CollectionParameter <string>("itemIds");
addNewPriceSnapshotAction.Parameter <string>("primaryInventorySetId");
addNewPriceSnapshotAction.Parameter <string>("secondaryInventorySetId");
addNewPriceSnapshotAction.ReturnsCollection <DeliveryTime>();
ActionConfiguration addPartyAction = modelBuilder.Action("AddParty");
addPartyAction.Parameter <string>("cartId");
addPartyAction.Parameter <Party>("party");
addPartyAction.ReturnsFromEntitySet <CommerceCommand>("Commands");
ActionConfiguration removePartyAction = modelBuilder.Action("RemoveParty");
removePartyAction.Parameter <string>("cartId");
removePartyAction.Parameter <Party>("addressName");
removePartyAction.ReturnsFromEntitySet <CommerceCommand>("Commands");
// Counters
var createCounterValueAction = modelBuilder.Action("CreateCounter");
createCounterValueAction.Parameter <string>("counterName");
createCounterValueAction.Parameter <long>("startValue");
createCounterValueAction.ReturnsFromEntitySet <CommerceCommand>("Commands");
var getNextCounterValueAction = modelBuilder.Action("GetNextCounterValue");
getNextCounterValueAction.Parameter <string>("counterName");
getNextCounterValueAction.Returns <long>();
var getOrdernumberForCartAction = modelBuilder.Action("GetOrdernumberForCart");
getOrdernumberForCartAction.Parameter <string>("cartId");
getOrdernumberForCartAction.Returns <string>();
return(Task.FromResult(modelBuilder));
}
private static IEdmModel GetModel()
{
var config = RoutingConfigurationFactory.CreateWithTypes(typeof(Customer));
ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create(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").Nullable = false;
unboundEntity.EntityParameter <Customer>("NullableCustomer");
ActionConfiguration unboundEntityCollection = builder.Action("UnboundEntityCollection");
unboundEntityCollection.Parameter <int>("Id");
unboundEntityCollection.CollectionEntityParameter <Customer>("Customers");
return(builder.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
// Configuración y servicios de API web
// Rutas de API web
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Alerta>("Alertas");
builder.EntitySet <GrupoFlota>("GrupoFlota");
builder.EntitySet <HistorialCargaCombustible>("HistorialesCargaCombustible");
builder.EntitySet <HistorialIncidente>("HistorialesIncidente");
builder.EntitySet <HistorialMantencion>("HistorialesMantencion");
builder.EntitySet <Proveedor>("Proveedores");
builder.EntitySet <Recordatorio>("Recordatorio");
builder.EntitySet <Servicio>("Servicios");
builder.EntitySet <TipoVehiculo>("TipoVehiculo");
builder.EntitySet <Usuario>("Usuarios");
builder.EntitySet <Flota>("Flotas");
builder.EntitySet <Auto>("Autos");
builder.EntitySet <Operador>("Operadores");
builder.EntitySet <UsuarioFlota>("UsuarioFlotas");
builder.EntitySet <HistorialDiario>("HistorialesDiarios");
builder.EntitySet <HistorialVelocidad>("HistorialVelocidades");
builder.EntitySet <HistorialPosicion>("HistorialPosiciones");
builder.EntitySet <HistorialEnergia>("HistorialesEnergia");
builder.EntitySet <MantencionServicio>("MantencionServicios");
#region Actions testeos
ActionConfiguration obtCalle = builder.Entity <Usuario>().Collection.Action("NombreCalle");
obtCalle.Parameter <double>("lat");
obtCalle.Parameter <double>("lng");
obtCalle.Returns <string>();
ActionConfiguration obtDireccion = builder.Entity <Usuario>().Collection.Action("ObtenerDireccion");
obtDireccion.Parameter <double>("latInicio");
obtDireccion.Parameter <double>("lngInicio");
obtDireccion.Parameter <double>("latFinal");
obtDireccion.Parameter <double>("lngFinal");
obtDireccion.Returns <GDirections>();
ActionConfiguration fechaHoy = builder.Entity <Auto>().Collection.Action("FechaHoy");
fechaHoy.Returns <DateTime>();
ActionConfiguration distanciaPuntos = builder.Entity <Auto>().Collection.Action("DistanciaPuntos");
distanciaPuntos.Parameter <double>("latInicio");
distanciaPuntos.Parameter <double>("lngInicio");
distanciaPuntos.Parameter <double>("latFinal");
distanciaPuntos.Parameter <double>("lngFinal");
distanciaPuntos.Returns <double>();
#endregion
#region Actions Usuario
ActionConfiguration crearCuentaUsuario = builder.Entity <Usuario>().Collection.Action("CrearCuentaUsuario");
crearCuentaUsuario.Returns <RespuestaOdata>();
crearCuentaUsuario.Parameter <string>("Nombre");
crearCuentaUsuario.Parameter <string>("Email");
crearCuentaUsuario.Parameter <string>("Password");
ActionConfiguration inicioSesion = builder.Entity <Usuario>().Collection.Action("IniciarSesion");
inicioSesion.Returns <RespuestaOdata>();
inicioSesion.Parameter <string>("Email");
inicioSesion.Parameter <string>("Password");
ActionConfiguration proveedorsActivos = builder.Entity <Usuario>().Collection.Action("ProveedoresActuales");
proveedorsActivos.ReturnsCollectionFromEntitySet <Proveedor>("Proveedores");
proveedorsActivos.Parameter <int>("IdAuto");
ActionConfiguration cargarCombustible = builder.Entity <Usuario>().Collection.Action("CargarCombustible");
cargarCombustible.Returns <RespuestaOdata>();
cargarCombustible.Parameter <int>("IdAuto");
cargarCombustible.Parameter <string>("FechaHora");
cargarCombustible.Parameter <bool>("EstanqueLleno");
cargarCombustible.Parameter <float>("CantidadLitros");
cargarCombustible.Parameter <int>("CostoUnitario");
cargarCombustible.Parameter <int>("Kilometraje");
cargarCombustible.Parameter <int>("IdProveedor");
cargarCombustible.Parameter <string>("RutProveedor");
cargarCombustible.Parameter <int>("NumeroBoleta");
#endregion
#region Actions AUTO
ActionConfiguration fechaEjemplo = builder.Entity <Auto>().Collection.Action("FechaEjemplo");
fechaEjemplo.Returns <string>();
fechaEjemplo.Parameter <string>("Fecha");
ActionConfiguration asignarPatente = builder.Entity <Auto>().Collection.Action("AsignarPatente");
asignarPatente.Returns <RespuestaOdata>();
asignarPatente.Parameter <string>("NuevaPatente");
asignarPatente.Parameter <string>("Email");
asignarPatente.Parameter <string>("Password");
ActionConfiguration actualizarVelocidadListaDX = builder.Entity <Auto>().Collection.Action("ActualizarVelocidadListaDX");
actualizarVelocidadListaDX.Returns <string>();
actualizarVelocidadListaDX.Parameter <int>("Id");
actualizarVelocidadListaDX.CollectionParameter <RegistroHistorial>("Registros");
ActionConfiguration actualizarEnergia = builder.Entity <Auto>().Collection.Action("ActualizarEnergia");
actualizarEnergia.Returns <IHttpActionResult>();
actualizarEnergia.Parameter <int>("Id");
actualizarEnergia.Parameter <string>("HoraRegistro");
actualizarEnergia.Parameter <string>("HoraInicio");
actualizarEnergia.Parameter <string>("HoraFinal");
actualizarEnergia.Parameter <string>("HoraMenor");
actualizarEnergia.Parameter <string>("HoraMayor");
actualizarEnergia.Parameter <string>("HoraMitad");
actualizarEnergia.Parameter <float>("ValorInicio");
actualizarEnergia.Parameter <float>("ValorFinal");
actualizarEnergia.Parameter <float>("ValorMenor");
actualizarEnergia.Parameter <float>("ValorMayor");
actualizarEnergia.Parameter <float>("ValorMitad");
ActionConfiguration actualizarPosicionDX = builder.Entity <Auto>().Collection.Action("ActualizarPosicionListaDX");
actualizarPosicionDX.Returns <string>();
actualizarPosicionDX.Parameter <int>("Id");
actualizarPosicionDX.CollectionParameter <Posicion>("ListaPosiciones");
ActionConfiguration actualizarPosicionDXZ = builder.Entity <Auto>().Collection.Action("ActualizarPosicionListaDXZ");
actualizarPosicionDXZ.Returns <string>();
actualizarPosicionDXZ.Parameter <int>("Id");
actualizarPosicionDXZ.CollectionParameter <Posicion>("ListaPosiciones");
ActionConfiguration actualizarPosicionDXZgps = builder.Entity <Auto>().Collection.Action("ActualizarPosicionListaDXZGPS");
actualizarPosicionDXZgps.Returns <string>();
actualizarPosicionDXZgps.Parameter <int>("Id");
actualizarPosicionDXZgps.CollectionParameter <Posicion>("ListaPosiciones");
ActionConfiguration obtenerHistorialVel = builder.Entity <Auto>().Collection.Action("ObtenerHistorialesVelocidad");
obtenerHistorialVel.ReturnsCollectionFromEntitySet <HistorialVelocidad>("HistorialVelocidades");
obtenerHistorialVel.Parameter <int>("Id");
obtenerHistorialVel.Parameter <string>("Fecha");
ActionConfiguration obtenerHistorialPos = builder.Entity <Auto>().Collection.Action("ObtenerHistorialesPosicion");
obtenerHistorialPos.ReturnsCollectionFromEntitySet <HistorialPosicion>("HistorialPosiciones");
obtenerHistorialPos.Parameter <int>("Id");
obtenerHistorialPos.Parameter <string>("FechaInicio");
obtenerHistorialPos.Parameter <string>("FechaFinal");
#endregion
config.Routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel());
}
public void CanCreateActionWithNonBindingParameters()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = new ActionConfiguration(builder, "MyAction");
action.Parameter<string>("p0");
action.Parameter<int>("p1");
action.Parameter<Address>("p2");
action.CollectionParameter<string>("p3");
action.CollectionParameter<int>("p4");
action.CollectionParameter<ZipCode>("p5");
ParameterConfiguration[] parameters = action.Parameters.ToArray();
ComplexTypeConfiguration[] complexTypes = builder.StructuralTypes.OfType<ComplexTypeConfiguration>().ToArray();
// Assert
Assert.Equal(2, complexTypes.Length);
Assert.Equal(typeof(Address).FullName, complexTypes[0].FullName);
Assert.Equal(typeof(ZipCode).FullName, complexTypes[1].FullName);
Assert.Equal(6, parameters.Length);
Assert.Equal("p0", parameters[0].Name);
Assert.Equal("Edm.String", parameters[0].TypeConfiguration.FullName);
Assert.Equal("p1", parameters[1].Name);
Assert.Equal("Edm.Int32", parameters[1].TypeConfiguration.FullName);
Assert.Equal("p2", parameters[2].Name);
Assert.Equal(typeof(Address).FullName, parameters[2].TypeConfiguration.FullName);
Assert.Equal("p3", parameters[3].Name);
Assert.Equal("Collection(Edm.String)", parameters[3].TypeConfiguration.FullName);
Assert.Equal("p4", parameters[4].Name);
Assert.Equal("Collection(Edm.Int32)", parameters[4].TypeConfiguration.FullName);
Assert.Equal("p5", parameters[5].Name);
Assert.Equal(string.Format("Collection({0})", typeof(ZipCode).FullName), parameters[5].TypeConfiguration.FullName);
}
// 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());
}
public static IEdmModel GetEdmModel(ODataConventionModelBuilder builder)
{
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 EdmPathExpression(entitySet.Name));
var functionsOfGetAllConventionCustomers = edmModel.FindDeclaredOperations(schemaNamespace + ".GetAllConventionCustomers");
var getAllConventionCustomersOfEdmFunction = functionsOfGetAllConventionCustomers.FirstOrDefault(f => f.Parameters.Count() == 0) as EdmFunction;
container.AddFunctionImport("GetAllConventionCustomersImport", getAllConventionCustomersOfEdmFunction, new EdmPathExpression(entitySet.Name));
// 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 EdmPathExpression(entitySet.Name));
var entitySet1 = container.FindEntitySet("ConventionOrders");
var GetConventionOrderByCustomerIdAndOrderNameOfEdmFunction = edmModel.FindDeclaredOperations(schemaNamespace + ".GetConventionOrderByCustomerIdAndOrderName").First() as EdmFunction;
container.AddFunctionImport("GetConventionOrderByCustomerIdAndOrderNameImport", GetConventionOrderByCustomerIdAndOrderNameOfEdmFunction, new EdmPathExpression(entitySet1.Name));
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 EdmPathExpression(entitySet.Name));
#endregion
return(edmModel);
}
