public void CanCreateEdmModel_WithNonBindableFunction()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
// Act
FunctionConfiguration functionConfiguration = builder.Function("FunctionName");
functionConfiguration.ReturnsFromEntitySet <Customer>("Customers");
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmEntityContainer container = model.EntityContainer;
Assert.NotNull(container);
Assert.Single(container.Elements.OfType <IEdmFunctionImport>());
Assert.Single(container.Elements.OfType <IEdmEntitySet>());
IEdmFunctionImport functionImport = Assert.Single(container.Elements.OfType <IEdmFunctionImport>());
IEdmFunction function = functionImport.Function;
Assert.False(function.IsComposable);
Assert.False(function.IsBound);
Assert.Equal("FunctionName", function.Name);
Assert.NotNull(function.ReturnType);
Assert.NotNull(functionImport.EntitySet);
Assert.Equal("Customers", (functionImport.EntitySet as IEdmPathExpression).Path);
Assert.Empty(function.Parameters);
}
private static IEdmModel getEdmModel()
{
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
EntitySetConfiguration <Person> peopleEntitySet = modelBuilder.EntitySet <Person>("People");
EntityTypeConfiguration <Person> personType = peopleEntitySet.EntityType;
personType.Ignore(p => p.CreatedTime);
personType.Ignore(p => p.LastModifiedTime);
EntitySetConfiguration <Account> accountEntitySet = modelBuilder.EntitySet <Account>("Accounts");
EntityTypeConfiguration <Account> accountType = accountEntitySet.EntityType;
accountType.Ignore(a => a.LastModifyTime);
accountType.Ignore(a => a.CreateTime);
FunctionConfiguration getPersonAndDescendants = modelBuilder.Function("GetPersonAndDescendants");
getPersonAndDescendants.ReturnsFromEntitySet <Person>("People");
getPersonAndDescendants.Parameter <long>("Id"); // The id of the root person.
getPersonAndDescendants.Parameter <long>("TotalLevels"); // How many levels will be loaded and the root person is included.
getPersonAndDescendants.IsComposable = true;
FunctionConfiguration getPersonAndAncestors = modelBuilder.Function("GetPersonAndAncestors");
getPersonAndAncestors.ReturnsCollectionFromEntitySet <Person>("People");
getPersonAndAncestors.Parameter <long>("Id"); // The id of the root person.
getPersonAndAncestors.Parameter <long>("TotalLevels"); // How many levels will be loaded and the root person is included.
getPersonAndAncestors.IsComposable = true;
modelBuilder.Namespace = typeof(Person).Namespace;
return(modelBuilder.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 void MapWorkflowOData(ODataModelBuilder builder)
{
builder
.EntitySet <WorkflowStatusModel>("Workflows")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <WorkflowActivityModel>("WorkflowActivities")
.EntityType.HasKey(p => p.IdWorkflowActivity);
#region [ Functions ]
FunctionConfiguration myInstances = builder
.EntityType <WorkflowStatusModel>().Collection
.Function("MyInstances");
myInstances.Namespace = "WorkflowService";
myInstances.ReturnsCollectionFromEntitySet <WorkflowStatusModel>("Workflows");
myInstances.Parameter <string>("workflowName");
FunctionConfiguration myActivities = builder
.EntityType <WorkflowActivityModel>().Collection
.Function("MyActivities");
myActivities.Namespace = "WorkflowService";
myActivities.ReturnsCollectionFromEntitySet <WorkflowActivityModel>("WorkflowActivities");
myActivities.Parameter <WorkflowActivityFinderModel>("finder");
FunctionConfiguration getLastWorkflowActivityFromDocumentUnit = builder
.EntityType <WorkflowActivityModel>().Collection
.Function("GetLastWorkflowActivityFromDocumentUnit");
getLastWorkflowActivityFromDocumentUnit.Namespace = "WorkflowService";
getLastWorkflowActivityFromDocumentUnit.ReturnsFromEntitySet <WorkflowActivityModel>("WorkflowActivities");
getLastWorkflowActivityFromDocumentUnit.Parameter <Guid>("idDocumentUnit");
FunctionConfiguration currentWorkflowActivityFromDocumentUnit = builder
.EntityType <WorkflowActivityModel>().Collection
.Function("CurrentWorkflowActivityFromDocumentUnit");
currentWorkflowActivityFromDocumentUnit.Namespace = "WorkflowService";
currentWorkflowActivityFromDocumentUnit.ReturnsFromEntitySet <WorkflowActivityModel>("WorkflowActivities");
currentWorkflowActivityFromDocumentUnit.Parameter <Guid>("idDocumentUnit");
FunctionConfiguration getUserAuthorizedWorkflowActivitiesCount = builder
.EntityType <WorkflowActivityModel>().Collection
.Function("CountUserAuthorizedWorkflowActivities");
getUserAuthorizedWorkflowActivitiesCount.Namespace = "WorkflowService";
getUserAuthorizedWorkflowActivitiesCount.Returns <long>();
getUserAuthorizedWorkflowActivitiesCount.Parameter <WorkflowActivityFinderModel>("finder");
#endregion
#region [ Navigation Properties ]
#endregion
}
public UnboundFunctionPathSegmentTest()
{
ODataModelBuilder builder = new ODataModelBuilder();
builder.EntityType <MyCustomer>().HasKey(c => c.Id).Property(c => c.Name);
builder.EntitySet <MyCustomer>("Customers");
FunctionConfiguration function = builder.Function("TopCustomer");
function.ReturnsFromEntitySet <MyCustomer>("Customers");
builder.Function("MyFunction").Returns <string>();
_model = builder.GetEdmModel();
_container = _model.EntityContainer;
}
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());
}
public static IEdmModel CreateModel()
{
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EnableLowerCamelCase();
#region ENTITY TYPE
var searchEntity = modelBuilder.EntityType <SearchViewModel>();
searchEntity.Name = Camelize(searchEntity.Name);
searchEntity.Namespace = "search";
searchEntity.HasKey(entity => entity.Count);
#endregion
#region COMPLEX TYPE
modelBuilder.ComplexType <SearchResultViewModel>();
#endregion
#region ENITY SET
modelBuilder.EntitySet <SearchViewModel>("search");
#endregion
#region FUNCTIONS
FunctionConfiguration frontiersResult = modelBuilder.EntityType <SearchViewModel>().Collection.Function("frontiers");
frontiersResult.Parameter <string>("type");
frontiersResult.Namespace = GET_FUNCTION_NAMESPACE;
frontiersResult.ReturnsFromEntitySet <SearchViewModel>("search");
frontiersResult.Namespace = GET_FUNCTION_NAMESPACE;
#endregion
return(modelBuilder.GetEdmModel());
}
public static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "D";
builder.ContainerName = "Default";
EntitySetConfiguration <City> cities = builder.EntitySet <City>("City");
EntitySetConfiguration <Stadium> stadiums = builder.EntitySet <Stadium>("Stadium");
// Per Collection Stadium
FunctionConfiguration getStadiumsWithFunction = stadiums.EntityType.Collection.Function("GetStadiumsWithFunction");
getStadiumsWithFunction.ReturnsCollectionFromEntitySet <Stadium>("Stadium");
// Per Collection Stadium, returns single entity
FunctionConfiguration getStadiumsTest = stadiums.EntityType.Collection.Function("GetStadiumTest");
getStadiumsTest.Parameter <string>("test");
getStadiumsTest.Parameter <string>("name");
getStadiumsTest.ReturnsFromEntitySet <Stadium>("Stadium");
// Per Entity (Single key property) City
FunctionConfiguration getStadiumFromCityWithFunction = cities.EntityType.Function("GetStadiumsFromCityWithFunction");
getStadiumFromCityWithFunction.ReturnsCollectionFromEntitySet <Stadium>("Stadium");
// Per Entity composite key Stadium
FunctionConfiguration getCityFromStadiumWithFunction = stadiums.EntityType.Function("GetCityFromStadiumWithFunction");
getCityFromStadiumWithFunction.ReturnsFromEntitySet <City>("City");
// Global Function
builder.Function("GlobalFunction").ReturnsCollectionFromEntitySet <Stadium>("Stadium");
return(builder.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);
}
// 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());
}
