public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var entityCollection = builder.EntitySet <DollarCountEntity>("DollarCountEntities").EntityType.Collection;
// Add unbound functions that return collection.
FunctionConfiguration function = builder.Function("UnboundFunctionReturnsPrimitveCollection");
function.IsComposable = true;
function.ReturnsCollection <int>();
function = builder.Function("UnboundFunctionReturnsEnumCollection");
function.IsComposable = true;
function.ReturnsCollection <DollarColor>();
function = builder.Function("UnboundFunctionReturnsDateTimeOffsetCollection");
function.IsComposable = true;
function.ReturnsCollection <DateTimeOffset>();
function = builder.Function("UnboundFunctionReturnsDateCollection");
function.IsComposable = true;
function.ReturnsCollection <Date>();
function = builder.Function("UnboundFunctionReturnsComplexCollection");
function.IsComposable = true;
function.ReturnsCollection <DollarCountComplex>();
function = builder.Function("UnboundFunctionReturnsEntityCollection");
function.IsComposable = true;
function.ReturnsCollectionFromEntitySet <DollarCountEntity>("DollarCountEntities");
// Add bound functions that return collection.
function = entityCollection.Function("BoundFunctionReturnsPrimitveCollection");
function.IsComposable = true;
function.ReturnsCollection <DateTimeOffset>();
function = entityCollection.Function("BoundFunctionReturnsEnumCollection");
function.IsComposable = true;
function.ReturnsCollection <DollarColor>();
function = entityCollection.Function("BoundFunctionReturnsDateTimeOffsetCollection");
function.IsComposable = true;
function.ReturnsCollection <DateTimeOffset>();
function = entityCollection.Function("BoundFunctionReturnsComplexCollection");
function.IsComposable = true;
function.ReturnsCollection <DollarCountComplex>();
function = entityCollection.Function("BoundFunctionReturnsEntityCollection");
function.IsComposable = true;
function.ReturnsCollectionFromEntitySet <DollarCountEntity>("DollarCountEntities");
return(builder.GetEdmModel());
}
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());
}
public static Microsoft.OData.Edm.IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Address>("Address");
builder.EntitySet <AddressType>("AddressType");
builder.EntitySet <BusinessEntity>("BusinessEntity");
builder.EntitySet <BusinessEntityAddress>("BusinessEntityAddress");
builder.EntitySet <BusinessEntityContact>("BusinessEntityContact");
builder.EntitySet <ContactType>("ContactType");
builder.EntitySet <CountryRegion>("CountryRegion");
builder.EntitySet <EmailAddress>("EmailAddress");
builder.EntitySet <Password>("Password");
builder.EntitySet <Person>("Person");
builder.EntitySet <PersonPhone>("PersonPhone");
builder.EntitySet <PhoneNumberType>("PhoneNumberType");
builder.EntitySet <StateProvince>("StateProvince");
EntitySetConfiguration <Person> persons = builder.EntitySet <Person>("Person");
FunctionConfiguration myFirstFunction = persons.EntityType.Collection.Function("MyFirstFunction");
myFirstFunction.ReturnsCollectionFromEntitySet <Person>("Person");
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
EntityTypeConfiguration <Order> order = builder.EntitySet <Order>("Orders").EntityType;
// Add unbound function for get special customer.
FunctionConfiguration getCustomersWithNameContaining = builder.Function("GetCustomersWithNameContaining");
getCustomersWithNameContaining.Parameter <string>("ContainedString");
getCustomersWithNameContaining.ReturnsCollectionFromEntitySet <Customer>("Customers");
// Add bound action for updating order price.
ActionConfiguration updateOrderPrice = order.Action("UpdateOrderPrice");
updateOrderPrice.Parameter <string>("Price");
updateOrderPrice.ReturnsFromEntitySet <Order>("Orders");
// Add bound function for delete order from customer and return the rest orders.
FunctionConfiguration deleteOrderFromCustomer = customer.Function("DeleteOrderFromCustomer");
deleteOrderFromCustomer.Parameter <int>("OrderId");
deleteOrderFromCustomer.ReturnsCollectionFromEntitySet <Order>("Orders");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
var books = builder.EntitySet <Book>("Books");
FunctionConfiguration myFirstFunction = books.EntityType.Collection.Function("MyFirstFunction");
myFirstFunction.ReturnsCollectionFromEntitySet <Book>("Books");
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());
}
public static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Address>("Address");
builder.EntitySet <AddressType>("AddressType");
builder.EntitySet <BusinessEntity>("BusinessEntity");
builder.EntitySet <BusinessEntityAddress>("BusinessEntityAddress");
builder.EntitySet <BusinessEntityContact>("BusinessEntityContact");
builder.EntitySet <ContactType>("ContactType");
builder.EntitySet <CountryRegion>("CountryRegion");
builder.EntitySet <EmailAddress>("EmailAddress");
builder.EntitySet <Password>("Password");
builder.EntitySet <Person>("Person");
builder.EntitySet <PersonPhone>("PersonPhone");
builder.EntitySet <PhoneNumberType>("PhoneNumberType");
builder.EntitySet <StateProvince>("StateProvince");
EntitySetConfiguration <EntityWithEnum> entitesWithEnum
= builder.EntitySet <EntityWithEnum>("EntityWithEnum");
FunctionConfiguration functionEntitesWithEnum
= entitesWithEnum.EntityType.Collection.Function("PersonSearchPerPhoneType");
functionEntitesWithEnum.Parameter <PhoneNumberTypeEnum>("PhoneNumberTypeEnum");
functionEntitesWithEnum.ReturnsCollectionFromEntitySet <EntityWithEnum>("EntityWithEnum");
EntitySetConfiguration <ContactType> contactType = builder.EntitySet <ContactType>("ContactType");
var actionY = contactType.EntityType.Action("ChangePersonStatus");
actionY.Parameter <string>("Level");
actionY.Returns <bool>();
var changePersonStatusAction = contactType.EntityType.Collection.Action("ChangePersonStatus");
changePersonStatusAction.Parameter <string>("Level");
changePersonStatusAction.Returns <bool>();
EntitySetConfiguration <Person> persons = builder.EntitySet <Person>("Person");
FunctionConfiguration myFirstFunction = persons.EntityType.Collection.Function("MyFirstFunction");
myFirstFunction.ReturnsCollectionFromEntitySet <Person>("Person");
builder.ContainerName = "SqliteContext";
builder.EntitySet <AnimalType>("AnimalType");
builder.EntitySet <EventData>("EventData");
builder.EntitySet <Player>("Player");
builder.EntityType <PlayerStats>();
SingletonConfiguration <SkillLevels> skillLevels = builder.Singleton <SkillLevels>("SkillLevels");
builder.EntityType <SkillLevel>();
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
}
private static IEdmModel GetEdmModel(IServiceProvider serviceProvider)
{
ODataModelBuilder builder = new ODataConventionModelBuilder(serviceProvider);
//builder.EntitySet<visitorCarType>("visitorCarType")
// .EntityType
// .Filter()
// .Count()
// .Expand()
// .OrderBy()
// .Page()
// .Select();
builder.EntitySet <vtran>("Vtrans")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
//EntitySetConfiguration<ContactType> contactType = builder.EntitySet<ContactType>("ContactType");
//var actionY = contactType.EntityType.Action("ChangePersonStatus");
//actionY.Parameter<string>("Level");
//actionY.Returns<bool>();
//var changePersonStatusAction = contactType.EntityType.Collection.Action("ChangePersonStatus");
//changePersonStatusAction.Parameter<string>("Level");
//changePersonStatusAction.Returns<bool>();
//EntitySetConfiguration<visitorCarType> persons = builder.EntitySet<visitorCarType>("visitorCarType");
//FunctionConfiguration myFirstFunction = persons.EntityType.Collection.Function("MyFirstFunction");
//myFirstFunction.ReturnsCollectionFromEntitySet<visitorCarType>("visitorCarType");
EntitySetConfiguration <vtran> vtran = builder.EntitySet <vtran>("vtran");
FunctionConfiguration myFirstFunctiontrans = vtran.EntityType.Collection.Function("MyFirstFunctiontrans");
myFirstFunctiontrans.ReturnsCollectionFromEntitySet <vtran>("vtran");
//EntitySetConfiguration<EntityWithEnum> entitesWithEnum = builder.EntitySet<EntityWithEnum>("EntityWithEnum");
//FunctionConfiguration functionEntitesWithEnum = entitesWithEnum.EntityType.Collection.Function("PersonSearchPerPhoneType");
//functionEntitesWithEnum.Parameter<PhoneNumberTypeEnum>("PhoneNumberTypeEnum");
//functionEntitesWithEnum.ReturnsCollectionFromEntitySet<EntityWithEnum>("EntityWithEnum");
return(builder.GetEdmModel());
}
private static void MapCustomModules(ODataModelBuilder builder)
{
builder
.EntitySet <MenuModel>("AUSLRE_BandiDiGaraMenu")
.EntityType.HasKey(p => p.UniqueId);
builder
.EntitySet <ArchiveModel>("AUSLRE_BandiDiGaraArchives")
.EntityType.HasKey(p => p.UniqueId);
#region [ Functions ]
FunctionConfiguration getMenu = builder
.EntityType <MenuModel>().Collection
.Function("GetMenu");
getMenu.Namespace = "MenuModelService";
getMenu.ReturnsCollectionFromEntitySet <MenuModel>("AUSLRE_BandiDiGaraMenu");
ActionConfiguration countArchiveByGrid = builder
.EntityType <ArchiveModel>().Collection
.Action("CountArchiveByGrid");
countArchiveByGrid.Namespace = "ArchiveModelService";
countArchiveByGrid.ReturnsCollectionFromEntitySet <ArchiveModel>("AUSLRE_BandiDiGaraArchives");
countArchiveByGrid.Parameter <ArchiveFinderModel>("finder");
ActionConfiguration searchArchiveByGrid = builder
.EntityType <ArchiveModel>().Collection
.Action("SearchArchiveByGrid");
searchArchiveByGrid.Namespace = "ArchiveModelService";
searchArchiveByGrid.ReturnsCollectionFromEntitySet <ArchiveModel>("AUSLRE_BandiDiGaraArchives");
searchArchiveByGrid.Parameter <ArchiveFinderModel>("finder");
FunctionConfiguration getArchiveInfo = builder
.EntityType <ArchiveModel>().Collection
.Function("GetArchiveInfo");
getArchiveInfo.Namespace = "ArchiveModelService";
getArchiveInfo.Parameter <Guid>("uniqueId");
getArchiveInfo.ReturnsCollectionFromEntitySet <ArchiveModel>("AUSLRE_BandiDiGaraArchives");
#endregion
#region [ Navigation Properties ]
#endregion
}
private static void MapDossierOData(ODataModelBuilder builder)
{
builder
.EntitySet <DossierModel>("Dossiers")
.EntityType.HasKey(p => p.UniqueId);
builder
.EntitySet <DossierFolderTableValuedModel>("DossierFolders")
.EntityType.HasKey(p => p.IdDossierFolder);
#region [ Functions ]
FunctionConfiguration getDossierById = builder
.EntityType <DossierModel>().Collection
.Function("GetDossierById");
getDossierById.Namespace = "DossierService";
getDossierById.Parameter <Guid>("id");
getDossierById.ReturnsCollectionFromEntitySet <DossierModel>("Dossiers");
FunctionConfiguration getDossierByYearAndNumber = builder
.EntityType <DossierModel>().Collection
.Function("GetDossierByYearAndNumber");
getDossierByYearAndNumber.Namespace = "DossierService";
getDossierByYearAndNumber.Parameter <short>("year");
getDossierByYearAndNumber.Parameter <int>("number");
getDossierByYearAndNumber.ReturnsCollectionFromEntitySet <DossierModel>("Dossiers");
FunctionConfiguration getNextDossierFolders = builder
.EntityType <DossierFolderTableValuedModel>().Collection
.Function("GetNextDossierFolders");
getNextDossierFolders.Namespace = "DossierService";
getNextDossierFolders.Parameter <Guid>("id");
getNextDossierFolders.ReturnsCollectionFromEntitySet <DossierFolderTableValuedModel>("DossierFolders");
FunctionConfiguration hasChildren = builder
.EntityType <DossierFolderTableValuedModel>().Collection
.Function("HasChildren");
hasChildren.Namespace = "DossierService";
hasChildren.Parameter <Guid>("id");
hasChildren.Returns <bool>();
#endregion
#region [ Navigation Properties ]
#endregion
}
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 void MapCommonOData(ODataModelBuilder builder)
{
builder
.EntitySet <DocumentModel>("Documents")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <Core.Models.Workflows.Parameters.MetadataModel>("MetadataModel")
.EntityType.HasKey(p => new { p.KeyName, p.Value });
builder
.EntitySet <CategoryModel>("Categories")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <ContainerModel>("Containers")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <GenericDocumentUnitModel>("GenericDocumentUnits")
.EntityType.HasKey(p => p.Id);
#region [ Functions ]
FunctionConfiguration getProtocolDocumentsFunc = builder
.EntityType <DocumentModel>().Collection
.Function("GetDocuments");
getProtocolDocumentsFunc.Namespace = "DocumentUnitService";
getProtocolDocumentsFunc.ReturnsCollectionFromEntitySet <DocumentModel>("DocumentUnits");
getProtocolDocumentsFunc.Parameter <Guid>("uniqueId");
getProtocolDocumentsFunc.Parameter <Guid?>("workflowArchiveChainId");
FunctionConfiguration getActivityDocuments = builder
.EntityType <DocumentModel>().Collection
.Function("GetDocumentsByArchiveChain");
getActivityDocuments.Namespace = "DocumentUnitService";
getActivityDocuments.ReturnsCollectionFromEntitySet <DocumentModel>("DocumentUnits");
getActivityDocuments.Parameter <Guid>("idArchiveChain");
#endregion
}
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());
}
private static void MapPECMailOData(ODataModelBuilder builder)
{
builder
.EntitySet <PECMailModel>("PECMails")
.EntityType.HasKey(p => p.Id);
#region [ Functions ]
FunctionConfiguration getPECMailsFunc = builder
.EntityType <PECMailModel>().Collection
.Function("GetProtocolPECMails");
getPECMailsFunc.Namespace = "PECMailService";
getPECMailsFunc.ReturnsCollectionFromEntitySet <PECMailModel>("PECMails");
getPECMailsFunc.Parameter <short>("year");
getPECMailsFunc.Parameter <int>("number");
getPECMailsFunc.Parameter <short>("direction");
#endregion
#region [ Navigation Properties ]
#endregion
}
private IEdmModel GetEdmModel(IServiceProvider service)
{
ODataModelBuilder builder = new ODataConventionModelBuilder(service);
builder.EntitySet <Book>("Books")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <User>("Users")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <Category>("Categories")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <YearOld>("YearOlds")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
//Books
EntitySetConfiguration <Book> books = builder.EntitySet <Book>("Books");
FunctionConfiguration postBook = books.EntityType.Collection.Function("PostBook");
postBook.ReturnsCollectionFromEntitySet <Book>("Books");
FunctionConfiguration deleteBook = books.EntityType.Collection.Function("DeleteBook");
deleteBook.ReturnsCollectionFromEntitySet <Book>("Books");
FunctionConfiguration updateBook = books.EntityType.Collection.Function("UpdateBook");
updateBook.ReturnsCollectionFromEntitySet <Book>("Books");
//Users
EntitySetConfiguration <User> users = builder.EntitySet <User>("Users");
FunctionConfiguration register = users.EntityType.Collection.Function("Register");
register.ReturnsCollectionFromEntitySet <User>("Users");
FunctionConfiguration authenticate = users.EntityType.Collection.Function("Authenticate");
authenticate.ReturnsCollectionFromEntitySet <User>("Users");
FunctionConfiguration deleteUser = users.EntityType.Collection.Function("DeleteUser");
deleteUser.ReturnsCollectionFromEntitySet <User>("Users");
FunctionConfiguration updateUser = users.EntityType.Collection.Function("UpdateUser");
updateUser.ReturnsCollectionFromEntitySet <User>("Users");
//Categories
EntitySetConfiguration <Category> categories = builder.EntitySet <Category>("Categories");
FunctionConfiguration postCategory = categories.EntityType.Collection.Function("PostCategory");
postCategory.ReturnsCollectionFromEntitySet <Category>("Categories");
FunctionConfiguration deleteCategory = categories.EntityType.Collection.Function("DeleteCategory");
deleteCategory.ReturnsCollectionFromEntitySet <Category>("Categories");
FunctionConfiguration updateCategory = categories.EntityType.Collection.Function("UpdateCategory");
updateCategory.ReturnsCollectionFromEntitySet <Category>("Categories");
//Categories
EntitySetConfiguration <YearOld> yearOlds = builder.EntitySet <YearOld>("YearOlds");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel(IServiceProvider serviceProvider)
{
ODataModelBuilder builder = new ODataConventionModelBuilder(serviceProvider);
builder.EntitySet <Address>("Address")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <AddressType>("AddressType")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <BusinessEntity>("BusinessEntity")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <BusinessEntityAddress>("BusinessEntityAddress")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <BusinessEntityContact>("BusinessEntityContact")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <ContactType>("ContactType")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <CountryRegion>("CountryRegion")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <EmailAddress>("EmailAddress")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <Password>("Password")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <Person>("Person")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <PersonPhone>("PersonPhone")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <PhoneNumberType>("PhoneNumberType")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <StateProvince>("StateProvince")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
builder.EntitySet <EntityWithEnum>("EntityWithEnum")
.EntityType
.Filter()
.Count()
.Expand()
.OrderBy()
.Page()
.Select();
EntitySetConfiguration <ContactType> contactType = builder.EntitySet <ContactType>("ContactType");
var actionY = contactType.EntityType.Action("ChangePersonStatus");
actionY.Parameter <string>("Level");
actionY.Returns <bool>();
var changePersonStatusAction = contactType.EntityType.Collection.Action("ChangePersonStatus");
changePersonStatusAction.Parameter <string>("Level");
changePersonStatusAction.Returns <bool>();
EntitySetConfiguration <Person> persons = builder.EntitySet <Person>("Person");
FunctionConfiguration myFirstFunction = persons.EntityType.Collection.Function("MyFirstFunction");
myFirstFunction.ReturnsCollectionFromEntitySet <Person>("Person");
EntitySetConfiguration <EntityWithEnum> entitesWithEnum = builder.EntitySet <EntityWithEnum>("EntityWithEnum");
FunctionConfiguration functionEntitesWithEnum = entitesWithEnum.EntityType.Collection.Function("PersonSearchPerPhoneType");
functionEntitesWithEnum.Parameter <PhoneNumberTypeEnum>("PhoneNumberTypeEnum");
functionEntitesWithEnum.ReturnsCollectionFromEntitySet <EntityWithEnum>("EntityWithEnum");
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);
}
private static void MapFascilceOData(ODataModelBuilder builder)
{
builder
.EntitySet <FascicleModel>("Fascicles")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <FascicleContactModel>("FascicleContacts")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <GenericDocumentUnitModel>("FascicleDocumentUnits")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <FascicleFolderTableValuedModel>("FascicleFolders")
.EntityType.HasKey(p => p.IdFascicleFolder);
#region [ Functions ]
FunctionConfiguration getFascicleSummary = builder
.EntityType <FascicleModel>().Collection
.Function("GetFascicleSummary");
getFascicleSummary.Namespace = "FascicleService";
getFascicleSummary.ReturnsCollectionFromEntitySet <FascicleModel>("Fascicles");
getFascicleSummary.Parameter <Guid>("uniqueId");
FunctionConfiguration getFascicleSummaryByYearAndNumber = builder
.EntityType <FascicleModel>().Collection
.Function("GetFascicleSummaryByYearAndNumber");
getFascicleSummaryByYearAndNumber.Namespace = "FascicleService";
getFascicleSummaryByYearAndNumber.ReturnsCollectionFromEntitySet <FascicleModel>("Fascicles");
getFascicleSummaryByYearAndNumber.Parameter <short>("year");
getFascicleSummaryByYearAndNumber.Parameter <int>("number");
getFascicleSummaryByYearAndNumber.Parameter <short>("code");
FunctionConfiguration getFascicleSummaryByTitle = builder
.EntityType <FascicleModel>().Collection
.Function("GetFascicleSummaryByTitle");
getFascicleSummaryByTitle.Namespace = "FascicleService";
getFascicleSummaryByTitle.ReturnsCollectionFromEntitySet <FascicleModel>("Fascicles");
getFascicleSummaryByTitle.Parameter <string>("title");
FunctionConfiguration getFascicleDocumentUnits = builder
.EntityType <FascicleModel>().Collection
.Function("GetFascicleDocumentUnits");
getFascicleDocumentUnits.Namespace = "FascicleService";
getFascicleDocumentUnits.ReturnsCollectionFromEntitySet <FascicleModel>("Fascicles");
getFascicleDocumentUnits.Parameter <Guid>("uniqueId");
getFascicleDocumentUnits.Parameter <string>("filter");
FunctionConfiguration getFascicleDocuments = builder
.EntityType <FascicleModel>().Collection
.Function("GetFascicleDocuments");
getFascicleDocuments.Namespace = "FascicleService";
getFascicleDocuments.ReturnsCollectionFromEntitySet <FascicleModel>("Fascicles");
getFascicleDocuments.Parameter <Guid>("uniqueId");
FunctionConfiguration getNextFascicleFolders = builder
.EntityType <FascicleFolderTableValuedModel>().Collection
.Function("GetNextFascicleFolders");
getNextFascicleFolders.Namespace = "FascicleService";
getNextFascicleFolders.Parameter <Guid>("id");
getNextFascicleFolders.ReturnsCollectionFromEntitySet <FascicleFolderTableValuedModel>("FascicleFolders");
FunctionConfiguration getFascicleDocumentUnitFromFolder = builder
.EntityType <FascicleFolderTableValuedModel>().Collection
.Function("GetFascicleDocumentUnitFromFolder");
getFascicleDocumentUnitFromFolder.Namespace = "FascicleService";
getFascicleDocumentUnitFromFolder.Parameter <Guid>("id");
getFascicleDocumentUnitFromFolder.ReturnsCollection <GenericDocumentUnitModel>();
FunctionConfiguration getFascicleDocumentFromFolder = builder
.EntityType <FascicleFolderTableValuedModel>().Collection
.Function("GetFascicleDocumentFromFolder");
getFascicleDocumentFromFolder.Namespace = "FascicleService";
getFascicleDocumentFromFolder.Parameter <Guid>("id");
getFascicleDocumentFromFolder.ReturnsCollection <FascicleDocumentModel>();
FunctionConfiguration getFascicleFlatDocuments = builder
.EntityType <FascicleModel>().Collection
.Function("GetFascicleFlatDocuments");
getFascicleFlatDocuments.Namespace = "FascicleService";
getFascicleFlatDocuments.ReturnsCollectionFromEntitySet <FascicleModel>("Fascicles");
getFascicleFlatDocuments.Parameter <Guid>("uniqueId");
FunctionConfiguration getFasciclesByMetadataIdentifier = builder
.EntityType <FascicleModel>().Collection
.Function("GetFasciclesByMetadataIdentifier");
getFasciclesByMetadataIdentifier.Namespace = "FascicleService";
getFasciclesByMetadataIdentifier.ReturnsCollectionFromEntitySet <FascicleModel>("Fascicles");
getFasciclesByMetadataIdentifier.Parameter <string>("name");
getFasciclesByMetadataIdentifier.Parameter <string>("identifier");
#endregion
#region [ Navigation Properties ]
#endregion
}
private static void MapProtocolOData(ODataModelBuilder builder)
{
builder
.EntitySet <ProtocolModel>("Protocols")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <ProtocolModel>("ProtocolAuthorized")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <ProtocolContactModel>("ProtocolContacts")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <ProtocolSectorModel>("ProtocolSectors")
.EntityType.HasKey(p => p.Id);
builder
.EntitySet <ProtocolUserModel>("ProtocolUsers")
.EntityType.HasKey(p => p.Id);
#region [ Functions ]
FunctionConfiguration getProtocolSummaryFunc = builder
.EntityType <ProtocolModel>().Collection
.Function("GetProtocolSummary");
getProtocolSummaryFunc.Namespace = "ProtocolService";
getProtocolSummaryFunc.ReturnsCollectionFromEntitySet <ProtocolModel>("Protocols");
getProtocolSummaryFunc.Parameter <short>("year");
getProtocolSummaryFunc.Parameter <int>("number");
FunctionConfiguration getOutgoingPECCount = builder
.EntityType <ProtocolModel>().Collection
.Function("GetProtocolOutgoingPECCount")
.Returns <int>();
getOutgoingPECCount.Namespace = "ProtocolService";
getOutgoingPECCount.Parameter <short>("year");
getOutgoingPECCount.Parameter <int>("number");
FunctionConfiguration getIngoingPECCount = builder
.EntityType <ProtocolModel>().Collection
.Function("GetProtocolIngoingPECCount")
.Returns <int>();
getIngoingPECCount.Namespace = "ProtocolService";
getIngoingPECCount.Parameter <short>("year");
getIngoingPECCount.Parameter <int>("number");
FunctionConfiguration getProtocolSummaryNoAuthFunc = builder
.EntityType <ProtocolModel>().Collection
.Function("GetProtocolSummary");
getProtocolSummaryNoAuthFunc.Namespace = "ProtocolAuthorizedService";
getProtocolSummaryNoAuthFunc.ReturnsCollectionFromEntitySet <ProtocolModel>("Protocols");
getProtocolSummaryNoAuthFunc.Parameter <Guid>("id");
FunctionConfiguration getOutgoingPECCountNoAuth = builder
.EntityType <ProtocolModel>().Collection
.Function("GetProtocolOutgoingPECCount")
.Returns <int>();
getOutgoingPECCountNoAuth.Namespace = "ProtocolAuthorizedService";
getOutgoingPECCountNoAuth.Parameter <short>("year");
getOutgoingPECCountNoAuth.Parameter <int>("number");
FunctionConfiguration getIngoingPECCountNoAuth = builder
.EntityType <ProtocolModel>().Collection
.Function("GetProtocolIngoingPECCount")
.Returns <int>();
getIngoingPECCountNoAuth.Namespace = "ProtocolAuthorizedService";
getIngoingPECCountNoAuth.Parameter <short>("year");
getIngoingPECCountNoAuth.Parameter <int>("number");
FunctionConfiguration getUserAuthorized = builder
.EntityType <ProtocolModel>().Collection
.Function("GetUserAuthorizedProtocols")
.ReturnsCollectionFromEntitySet <ProtocolModel>("Protocol");
getUserAuthorized.Namespace = "ProtocolAuthorizedService";
getUserAuthorized.Parameter <int>("skip");
getUserAuthorized.Parameter <int>("top");
getUserAuthorized.Parameter <string>("subject");
getUserAuthorized.Parameter <DateTimeOffset?>("dateFrom");
getUserAuthorized.Parameter <DateTimeOffset?>("dateTo");
getUserAuthorized.Parameter <string>("contact");
FunctionConfiguration countUserAuthorized = builder
.EntityType <ProtocolModel>().Collection
.Function("GetUserAuthorizedProtocolsCount")
.Returns <int>();
countUserAuthorized.Namespace = "ProtocolAuthorizedService";
countUserAuthorized.Parameter <string>("subject");
countUserAuthorized.Parameter <DateTimeOffset?>("dateFrom");
countUserAuthorized.Parameter <DateTimeOffset?>("dateTo");
countUserAuthorized.Parameter <string>("contact");
#endregion
#region [ Navigation Properties ]
#endregion
}
private static void MapResolutionOData(ODataModelBuilder builder)
{
builder
.EntitySet <ResolutionModel>("Resolution")
.EntityType.HasKey(p => p.Id);
#region [ Functions ]
FunctionConfiguration getExecutiveResolutionsFunc = builder
.EntityType <ResolutionModel>().Collection
.Function("GetExecutiveResolutions");
getExecutiveResolutionsFunc.Namespace = "ResolutionService";
getExecutiveResolutionsFunc.ReturnsCollectionFromEntitySet <ResolutionModel>("Resolution");
getExecutiveResolutionsFunc.Parameter <int>("skip");
getExecutiveResolutionsFunc.Parameter <int>("top");
getExecutiveResolutionsFunc.Parameter <ResolutionType>("type");
getExecutiveResolutionsFunc.Parameter <short?>("year");
getExecutiveResolutionsFunc.Parameter <int?>("number");
getExecutiveResolutionsFunc.Parameter <string>("subject");
getExecutiveResolutionsFunc.Parameter <string>("adoptionDate");
getExecutiveResolutionsFunc.Parameter <string>("proposer");
FunctionConfiguration getPublishedResolutionsFunc = builder
.EntityType <ResolutionModel>().Collection
.Function("GetPublishedResolutions");
getPublishedResolutionsFunc.Namespace = "ResolutionService";
getPublishedResolutionsFunc.ReturnsCollectionFromEntitySet <ResolutionModel>("Resolution");
getPublishedResolutionsFunc.Parameter <int>("skip");
getPublishedResolutionsFunc.Parameter <int>("top");
getPublishedResolutionsFunc.Parameter <ResolutionType>("type");
getPublishedResolutionsFunc.Parameter <short?>("year");
getPublishedResolutionsFunc.Parameter <int?>("number");
getPublishedResolutionsFunc.Parameter <string>("subject");
getPublishedResolutionsFunc.Parameter <string>("adoptionDate");
getPublishedResolutionsFunc.Parameter <string>("proposer");
FunctionConfiguration getExecutiveReslCount = builder
.EntityType <ResolutionModel>().Collection
.Function("GetExecutiveResolutionsCount")
.Returns <int>();
getExecutiveReslCount.Namespace = "ResolutionService";
getExecutiveReslCount.Parameter <ResolutionType>("type");
getExecutiveReslCount.Parameter <short?>("year");
getExecutiveReslCount.Parameter <string>("subject");
getExecutiveReslCount.Parameter <int?>("number");
getExecutiveReslCount.Parameter <string>("adoptionDate");
getExecutiveReslCount.Parameter <string>("proposer");
FunctionConfiguration getPublishedReslCount = builder
.EntityType <ResolutionModel>().Collection
.Function("GetPublishedResolutionsCount")
.Returns <int>();
getPublishedReslCount.Namespace = "ResolutionService";
getPublishedReslCount.Parameter <ResolutionType>("type");
getPublishedReslCount.Parameter <short?>("year");
getPublishedReslCount.Parameter <int?>("number");
getPublishedReslCount.Parameter <string>("subject");
getPublishedReslCount.Parameter <string>("adoptionDate");
getPublishedReslCount.Parameter <string>("proposer");
FunctionConfiguration getOnlineResolutionsFunc = builder
.EntityType <ResolutionModel>().Collection
.Function("GetOnlinePublishedResolutions");
getOnlineResolutionsFunc.Namespace = "ResolutionService";
getOnlineResolutionsFunc.ReturnsCollectionFromEntitySet <ResolutionModel>("Resolution");
getOnlineResolutionsFunc.Parameter <ResolutionType>("type");
#endregion
#region [ Navigation Properties ]
#endregion
}
// 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());
}