public static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
builder.EntityType <Customer>().Function("CalculateSalary").Returns <int>().Parameter <int>("month");
builder.EntityType <Customer>().Action("UpdateAddress");
builder.EntityType <Customer>()
.Collection.Function("GetCustomerByGender")
.ReturnsCollectionFromEntitySet <Customer>("Customers")
.Parameter <Gender>("gender");
return(builder.GetEdmModel());
}
public static IEdmModel GetTypedConventionModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <Employee>("Employees");
builder.EntitySet <Account>("Accounts");
builder.EnumType <Gender>();
AddBoundActionsAndFunctions(builder.EntityType <Account>());
AddUnboundActionsAndFunctions(builder);
builder.Namespace = typeof(Account).Namespace;
return(builder.GetEdmModel());
}
public static IEdmModel GetModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
var singerConfiguration = builder.EntitySet <Singer>("Singers");
singerConfiguration.EntityType.Collection.Action("ResetDataSource");
var albumConfiguration = builder.EntitySet <Album>("Albums");
albumConfiguration.EntityType.Collection.Action("ResetDataSource");
albumConfiguration.EntityType.Function("GetSingers").ReturnsCollectionFromEntitySet <Singer>("Singers").IsComposable = true;
builder.Namespace = typeof(Singer).Namespace;
return(builder.GetEdmModel());
}
public static IEdmModel GetConventionModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
var paymentInstrumentType = builder.EntityType <PaymentInstrument>();
builder.EntitySet <Account>("Accounts");
builder.EntitySet <Account>("PaginatedAccounts");
builder.Singleton <Account>("AnonymousAccount");
AddBoundActionsAndFunctions(builder);
builder.Namespace = typeof(Account).Namespace;
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
foreach (var type in Creator.EntityTypes)
{
var entity = builder.AddEntityType(type);
builder.AddEntitySet(type.Name, entity);
}
foreach (var type in Creator.ComplexTypes.Where(type => type.IsEnum))
{
var entity = builder.AddEnumType(type);
}
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
EntitySetConfiguration <ETagsCustomer> eTagsCustomersSet = builder.EntitySet <ETagsCustomer>("ETagsCustomers");
eTagsCustomersSet.HasRequiredBinding(c => c.RelatedCustomer, eTagsCustomersSet);
eTagsCustomersSet.HasRequiredBinding(c => c.ContainedCustomer, eTagsCustomersSet);
EntitySetConfiguration <ETagsCustomer> eTagsDerivedCustomersSet = builder.EntitySet <ETagsCustomer>("ETagsDerivedCustomers");
eTagsDerivedCustomersSet.HasRequiredBinding(c => c.RelatedCustomer, eTagsCustomersSet);
eTagsDerivedCustomersSet.HasRequiredBinding(c => c.ContainedCustomer, eTagsCustomersSet);
SingletonConfiguration <ETagsCustomer> eTagsCustomerSingleton = builder.Singleton <ETagsCustomer>("ETagsDerivedCustomersSingleton");
eTagsCustomerSingleton.HasRequiredBinding(c => c.RelatedCustomer, eTagsCustomersSet);
eTagsCustomerSingleton.HasRequiredBinding(c => c.ContainedCustomer, eTagsCustomersSet);
return(builder.GetEdmModel());
}
public static IEdmModel GetConventionModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntityTypeConfiguration <Employee> employee = employees.EntityType;
// maybe following lines are not required once bug #1587 is fixed.
// 1587: It's better to support automatically adding actions and functions in ODataConventionModelBuilder.
AddBoundActionsAndFunctions(employee);
AddUnboundActionsAndFunctions(builder);
builder.Namespace = typeof(Employee).Namespace;
var edmModel = builder.GetEdmModel();
return(edmModel);
}
public static IEdmModel GetConventionModel(WebRouteConfiguration configuration, string singletonName)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
EntitySetConfiguration <Partner> partnersConfiguration = builder.EntitySet <Partner>("Partners");
EntityTypeConfiguration <Partner> partnerConfiguration = partnersConfiguration.EntityType;
partnerConfiguration.Collection.Action("ResetDataSource");
SingletonConfiguration <Company> companyConfiguration = builder.Singleton <Company>(singletonName);
companyConfiguration.EntityType.Action("ResetDataSource");
companyConfiguration.EntityType.Function("GetPartnersCount").Returns <int>();
builder.Namespace = typeof(Company).Namespace;
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
IEdmModel model = builder.GetEdmModel();
var stdDevMethods = GetCustomMethods(typeof(DbFunctions), StdDevMethodLabel);
CustomAggregateMethodAnnotation customMethods = new CustomAggregateMethodAnnotation();
customMethods.AddMethod(StdDevMethodToken, stdDevMethods);
model.SetAnnotationValue(model, customMethods);
return(model);
}
protected override void UpdateConfiguration(WebRouteConfiguration configuration)
{
var controllers = new[] {
typeof(ConventionCustomersController),
typeof(MetadataController)
};
configuration.AddControllers(controllers);
configuration.Routes.Clear();
configuration.Count().Filter().OrderBy().Expand().MaxTop(null).Select();
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
configuration.MapODataServiceRoute("unboundFunctionConvention", "odata", UnboundFunctionEdmModel.GetEdmModel(builder));
configuration.EnsureInitialized();
}
private static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <SingleResultCustomer>("SingleResultCustomers")
.EntityType
.Action("CreditRating")
.Returns <double>();
builder.EntitySet <SingleResultOrderDetail>("SingleResultOrderDetail");
builder.EntityType <SingleResultPremiumCustomer>();
builder.EntitySet <SingleResultOrder>("SingleResultOrder");
builder.EntitySet <SingleResultBonus>("SingleResultBonus");
IEdmModel model = builder.GetEdmModel();
return(model);
}
public static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
builder.EntityType <SpecialOrder>();
builder.EntityType <VipOrder>();
builder.EntitySet <ChoiceOrder>("OrderChoices");
builder.EntitySet <NormalOrder>("NormalOrders");
builder.EntityType <DerivedOrder>();
builder.EntityType <DerivedOrder2>();
builder.EntitySet <OrderDetail>("OrderDetails");
builder.EntitySet <People>("People");
IEdmModel model = builder.GetEdmModel();
return(model);
}
public static IEdmModel GetEdmModelByModelBoundAPI(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntityType <Customer>().HasMany(c => c.Orders).Select("Id");
builder.EntitySet <Order>("Orders").EntityType.Select().Select(SelectExpandType.Disabled, "Id");
builder.EntityType <Order>().HasMany(o => o.Customers).Select();
builder.EntitySet <Car>("Cars")
.EntityType.Select("Name")
.Select("Id");
// Need call API just like Order for SepcialOrder because model bound API doesn't support inheritance
builder.EntityType <SpecialOrder>()
.Select()
.Select(SelectExpandType.Disabled, "Id")
.Select(SelectExpandType.Disabled, "Name");
builder.EntitySet <AutoSelectCustomer>("AutoSelectCustomers")
.EntityType.Select(SelectExpandType.Automatic, "Name")
.Expand(SelectExpandType.Automatic, "Order");
builder.EntityType <SpecialCustomer>()
.Select(SelectExpandType.Automatic, "Name", "VIPNumber")
.Expand(SelectExpandType.Automatic, "Order");
builder.EntityType <AutoSelectCustomer>()
.HasOptional(c => c.Order)
.Select(SelectExpandType.Automatic, "Name");
builder.EntitySet <AutoSelectOrder>("AutoSelectOrders")
.EntityType.Select(SelectExpandType.Automatic, "Id");
builder.EntitySet <AutoSelectCar>("AutoSelectCars")
.EntityType.Select(SelectExpandType.Disabled, "Name")
.Select(SelectExpandType.Automatic);
IEdmModel model = builder.GetEdmModel();
return(model);
}
private static IEdmModel GetConventionModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
EntitySetConfiguration <ModelAliasingMetadataCustomer> customers = builder.EntitySet <ModelAliasingMetadataCustomer>("ModelAliasingQueryCustomers");
customers.EntityType.Name = "Customer";
customers.EntityType.Namespace = "ModelAliasing";
customers.EntityType.ComplexProperty(c => c.BillingAddress).Name = "FinancialAddress";
customers.EntityType.Property(c => c.Name).Name = "ClientName";
customers.EntityType.HasMany(c => c.Orders).Name = "Purchases";
EntitySetConfiguration <ModelAliasingMetadataOrder> orders = builder.EntitySet <ModelAliasingMetadataOrder>("Orders");
orders.EntityType.Name = "Order";
orders.EntityType.Namespace = "AliasedNamespace";
EntityTypeConfiguration <ModelAliasingMetadataExpressOrder> expressOrder = builder.EntityType <ModelAliasingMetadataExpressOrder>().DerivesFrom <ModelAliasingMetadataOrder>();
expressOrder.Name = "ExpressOrder";
expressOrder.Namespace = "Purchasing";
expressOrder.Property(eo => eo.ExpressFee).Name = "Fee";
EntityTypeConfiguration <ModelAliasingMetadataFreeDeliveryOrder> freeDeliveryOrder = builder.EntityType <ModelAliasingMetadataFreeDeliveryOrder>().DerivesFrom <ModelAliasingMetadataOrder>();
freeDeliveryOrder.Name = "FreeDeliveryOrder";
freeDeliveryOrder.Namespace = "Purchasing";
EntitySetConfiguration <ModelAliasingMetadataProduct> products = builder.EntitySet <ModelAliasingMetadataProduct>("Products");
EntitySetConfiguration <ModelAliasingMetadataOrderLine> ordersLines = builder.EntitySet <ModelAliasingMetadataOrderLine>("OrdersLines");
ordersLines.EntityType.Property(ol => ol.Price).Name = "Cost";
ComplexTypeConfiguration <ModelAliasingMetadataRegion> region = builder.ComplexType <ModelAliasingMetadataRegion>();
region.Name = "PoliticalRegion";
region.Namespace = "Location";
ComplexTypeConfiguration <ModelAliasingMetadataAddress> address = builder.ComplexType <ModelAliasingMetadataAddress>();
address.Name = "Direction";
address.Namespace = "Location";
address.ComplexProperty <ModelAliasingMetadataRegion>(c => c.CountryOrRegion).Name = "Reign";
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModelByModelBoundAPI(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <Customer>("Customers")
.EntityType.Expand(10, "Orders", "Friend", "CountableOrders")
.Expand(8, SelectExpandType.Automatic, "AutoExpandOrder")
.Page(5, 2);
builder.EntityType <Customer>()
.HasMany(p => p.Orders)
.Expand(2, "Customers")
.Page(2, 1)
.Count(QueryOptionSetting.Disabled);
builder.EntityType <Customer>()
.HasMany(p => p.CountableOrders)
.Count();
builder.EntityType <Customer>()
.HasOptional(p => p.Order)
.Expand(SelectExpandType.Disabled);
builder.EntitySet <Order>("Orders")
.EntityType.Expand(6)
.Expand(SelectExpandType.Disabled, "NoExpandCustomers")
.Count()
.Filter()
.Filter(QueryOptionSetting.Disabled, "Id")
.OrderBy()
.OrderBy(QueryOptionSetting.Disabled, "Id");
builder.EntityType <Order>()
.HasMany(p => p.Customers)
.Expand("Orders")
.Page(2, 1)
.Count(QueryOptionSetting.Disabled);
builder.EntityType <Order>().HasMany(p => p.Customers2).Expand("Order").Page(1, null).Count();
IEdmModel model = builder.GetEdmModel();
return(model);
}
public static IEdmModel GetEdmModelByModelBoundAPI(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <Customer>("Customers")
.EntityType.Expand(10, "Orders", "Friend")
.Expand(8, SelectExpandType.Automatic, "AutoExpandOrder");
builder.EntityType <Customer>().HasMany(p => p.Orders).Expand(2, "Customers");
builder.EntityType <SpecialCustomer>()
.HasOptional(p => p.SpecialOrder)
.Expand(SelectExpandType.Automatic, "SpecialOrder");
builder.EntitySet <Order>("Orders")
.EntityType.Expand(6)
.Expand(SelectExpandType.Disabled, "NoExpandCustomers");
builder.EntityType <Order>().HasMany(p => p.Customers).Expand("Orders");
builder.EntityType <Order>().HasMany(p => p.Customers2).Expand("Order");
IEdmModel model = builder.GetEdmModel();
return(model);
}
private static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
EntitySetConfiguration <ETagsCustomer> eTagsCustomersSet = builder.EntitySet <ETagsCustomer>("ETagsCustomers");
EntityTypeConfiguration <ETagsCustomer> eTagsCustomers = eTagsCustomersSet.EntityType;
eTagsCustomers.Property(c => c.Id).IsConcurrencyToken();
eTagsCustomers.Property(c => c.Name).IsConcurrencyToken();
eTagsCustomers.Property(c => c.BoolProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.ByteProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.CharProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.DecimalProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.DoubleProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.ShortProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.LongProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.SbyteProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.FloatProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.UshortProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.UintProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.UlongProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.GuidProperty).IsConcurrencyToken();
eTagsCustomers.Property(c => c.DateTimeOffsetProperty).IsConcurrencyToken();
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModelByModelBoundAPI(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <Customer>("Customers").EntityType.Filter("AutoExpandOrder", "Address");
builder.EntityType <Customer>().HasMany(c => c.Orders).Filter("Id");
builder.EntityType <Customer>().ComplexProperty(c => c.Address).Filter();
builder.EntitySet <Order>("Orders").EntityType.Filter().Filter(QueryOptionSetting.Disabled, "Id");
builder.EntityType <Order>().HasMany(o => o.Customers).Filter();
builder.EntitySet <Car>("Cars")
.EntityType.Filter("Name")
.Filter(QueryOptionSetting.Disabled)
.Filter("Id");
// Need call API just like Order for SepcialOrder because model bound API doesn't support inheritance
builder.EntityType <SpecialOrder>()
.Filter()
.Filter(QueryOptionSetting.Disabled, "Id")
.Filter(QueryOptionSetting.Disabled, "Name");
IEdmModel model = builder.GetEdmModel();
return(model);
}
public static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntityType <Customer>().EnumProperty(c => c.Bucket);
builder.EntitySet <Order>("Orders");
var func = builder.Function("GetLastCommand");
func.Returns <string>();
var clean = builder.Function("CleanCommands").Returns <bool>();
IEdmModel model = builder.GetEdmModel();
var stdDevMethods = GetCustomMethods(typeof(DbFunctions), StdDevMethodLabel);
CustomAggregateMethodAnnotation customMethods = new CustomAggregateMethodAnnotation();
customMethods.AddMethod(StdDevMethodToken, stdDevMethods);
model.SetAnnotationValue(model, customMethods);
return(model);
}
private static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
var builder = configuration.CreateConventionModelBuilder();
builder.EntitySet <EFSelectCustomer>("EFSelectCustomers");
builder.EntitySet <EFSelectOrder>("EFSelectOrders");
builder.EntitySet <EFWideCustomer>("EFWideCustomers");
builder.Action("ResetDataSource-Customer");
builder.Action("ResetDataSource-WideCustomer");
builder.Action("ResetDataSource-Order");
IEdmModel model = builder.GetEdmModel();
for (int idx = 1; idx <= 5; idx++)
{
IEdmSchemaType nestedType = model.FindDeclaredType("Microsoft.Test.E2E.AspNet.OData.QueryComposition.CustomProperties" + idx);
model.SetAnnotationValue(nestedType, new Microsoft.AspNet.OData.Query.ModelBoundQuerySettings()
{
DefaultSelectType = SelectExpandType.Automatic
});
}
return(model);
}
private static IEdmModel GetActionsModel(WebRouteConfiguration configuration)
{
ODataModelBuilder builder = configuration.CreateConventionModelBuilder();
var baseEntitySet = builder.EntitySet <BaseEntity>("BaseEntity");
var alwaysAvailableActionBaseType = baseEntitySet.EntityType.Action("AlwaysAvailableActionBaseType");
var transientActionBaseType = baseEntitySet.EntityType.Action("TransientActionBaseType");
Func <ResourceContext, Uri> transientActionBaseTypeLinkFactory = eic =>
{
IEdmEntityType baseType = eic.EdmModel.FindType(typeof(BaseEntity).FullName) as IEdmEntityType;
object id;
eic.EdmObject.TryGetPropertyValue("Id", out id);
if (!eic.StructuredType.IsOrInheritsFrom(baseType) || (int)id % 2 == 1)
{
return(null);
}
else
{
// find the action
var action = eic.EdmModel.SchemaElements
.Where(elem => elem.Name == "TransientActionBaseType")
.Cast <EdmAction>()
.FirstOrDefault();
var segments = new List <ODataPathSegment>();
segments.Add(new EntitySetSegment(eic.NavigationSource as IEdmEntitySet));
segments.Add(new KeySegment(new[] { new KeyValuePair <string, object>("Id", id) }, eic.StructuredType as IEdmEntityType, null));
var pathHandler = eic.Request.GetPathHandler();
string link = ResourceContextHelper.CreateODataLink(eic, "Actions", pathHandler, segments);
link += "/" + action.FullName();
return(new Uri(link));
}
};
transientActionBaseType.HasActionLink(transientActionBaseTypeLinkFactory, true);
var derivedEntityType = builder.EntityType <DerivedEntity>().DerivesFrom <BaseEntity>();
var alwaysAvailableActionDerivedType = derivedEntityType.Action("AlwaysAvailableActionDerivedType");
var transientActionDerivedType = derivedEntityType.Action("TransientActionDerivedType");
Func <ResourceContext, Uri> transientActionDerivedTypeLinkFactory = eic =>
{
IEdmEntityType derivedType = eic.EdmModel.FindType(typeof(DerivedEntity).FullName) as IEdmEntityType;
object id;
eic.EdmObject.TryGetPropertyValue("Id", out id);
if (!eic.StructuredType.IsOrInheritsFrom(derivedType) || (int)id % 2 == 1)
{
return(null);
}
else
{
// find the action
var action = eic.EdmModel.SchemaElements
.Where(elem => elem.Name == "TransientActionDerivedType")
.Cast <EdmAction>()
.FirstOrDefault();
var segments = new List <ODataPathSegment>();
segments.Add(new EntitySetSegment(eic.NavigationSource as IEdmEntitySet));
segments.Add(new KeySegment(new[] { new KeyValuePair <string, object>("Id", id) }, eic.StructuredType as IEdmEntityType, null));
segments.Add(new TypeSegment(derivedType, null));
// bug 1985: Make the internal constructor as public in BoundActionPathSegment
//segments.Add(new BoundActionPathSegment(action));
var pathHandler = eic.Request.GetPathHandler();
string link = ResourceContextHelper.CreateODataLink(eic, "Actions", pathHandler, segments);
link += "/" + action.FullName();
return(new Uri(link));
}
};
transientActionDerivedType.HasActionLink(transientActionDerivedTypeLinkFactory, true);
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
ODataConventionModelBuilder builder = configuration.CreateConventionModelBuilder();
EntitySetConfiguration <Employee> entitySetConfiguration = builder.EntitySet <Employee>("Employees");
EntityTypeConfiguration <Manager> entityTypeConfigurationOfManager = builder.EntityType <Manager>();
EntityTypeConfiguration <Employee> entityTypeConfigurationOfEmployee = builder.EntityType <Employee>();
#region functions
// Function bound to a collection of base EntityType.
entityTypeConfigurationOfEmployee.Collection.Function("GetCount")
.Returns <int>();
// Overload
entityTypeConfigurationOfEmployee.Collection.Function("GetCount")
.Returns <int>()
.Parameter <string>("Name");
// Overload with one optional parameter
var salaryRangeCount = entityTypeConfigurationOfEmployee.Collection.Function("GetWholeSalary")
.Returns <int>();
salaryRangeCount.Parameter <double>("minSalary");
salaryRangeCount.Parameter <double>("maxSalary").Optional();
salaryRangeCount.Parameter <double>("aveSalary").HasDefaultValue("8.9");
// Function bound to a collection of derived EntityType.
entityTypeConfigurationOfManager.Collection.Function("GetCount")
.Returns <int>();
// Function bound to an base EntityType
entityTypeConfigurationOfEmployee.Function("GetEmailsCount")
.Returns <int>();
entityTypeConfigurationOfEmployee.Function("GetOptionalAddresses")
.ReturnsCollection <Address>()
.IsComposable = true;
entityTypeConfigurationOfEmployee.Function("GetEmails")
.ReturnsCollection <string>()
.IsComposable = false;
// Function bound to a derived EntityType
entityTypeConfigurationOfManager.Function("GetEmailsCount")
.Returns <int>();
// Function with primitive and collection of primitive parameters
var function = entityTypeConfigurationOfEmployee.Collection.Function("PrimitiveFunction").Returns <string>();
function.Parameter <int>("param");
function.Parameter <double?>("price"); // nullable
function.Parameter <string>("name"); // nullable
function.CollectionParameter <string>("names"); // collection with nullable element
// Function with Enum and collection of Enum parameters
function = entityTypeConfigurationOfEmployee.Collection.Function("EnumFunction").Returns <string>();
function.Parameter <Color>("bkColor");
function.Parameter <Color?>("frColor"); // nullable
function.CollectionParameter <Color>("colors"); // collection with non-nullable element
// Function with complex and collection of complex parameters
function = entityTypeConfigurationOfEmployee.Collection.Function("ComplexFunction").ReturnsCollection <Address>();
function.Parameter <Address>("address").Nullable = false;
function.Parameter <Address>("location"); // nullable
function.CollectionParameter <Address>("addresses"); // collection with nullable element
// Function with entity and collection of entity parameters
function = entityTypeConfigurationOfEmployee.Collection.Function("EntityFunction").Returns <string>();
function.EntityParameter <Employee>("person").Nullable = false;
function.EntityParameter <Employee>("guard"); // nullable
function.CollectionEntityParameter <Employee>("staff"); // collection with nullable element
#endregion
#region actions
// Action bound to a collection of base EntityType
entityTypeConfigurationOfEmployee.Collection.Action("IncreaseSalary")
.ReturnsCollectionFromEntitySet(entitySetConfiguration)
.Parameter <string>("Name");
// Action bound to a collection of derived EntityType
entityTypeConfigurationOfManager.Collection.Action("IncreaseSalary")
.ReturnsCollectionFromEntitySet(entitySetConfiguration)
.Parameter <string>("Name");
// Action bound to a base EntityType
entityTypeConfigurationOfEmployee.Action("IncreaseSalary")
.Returns <int>();
// Action bound to a derived EntityType
entityTypeConfigurationOfManager.Action("IncreaseSalary")
.Returns <int>();
// Action with optional parameters
var action = entityTypeConfigurationOfManager.Action("IncreaseWholeSalary")
.Returns <int>();
action.Parameter <double>("minSalary");
action.Parameter <double>("maxSalary").Optional();
action.Parameter <double>("aveSalary").HasDefaultValue("8.9");
// Action with primitive and collection of primitive parameters
action = entityTypeConfigurationOfEmployee.Collection.Action("PrimitiveAction");
action.Parameter <int>("param");
action.Parameter <double?>("price"); // nullable
action.Parameter <string>("name"); // nullable
action.CollectionParameter <string>("names"); // collection with nullable element
// Action with Enum and collection of Enum parameters
action = entityTypeConfigurationOfEmployee.Collection.Action("EnumAction");
action.Parameter <Color>("bkColor");
action.Parameter <Color?>("frColor"); // nullable
action.CollectionParameter <Color>("colors"); // collection with non-nullable element
// Action with complex and collection of complex parameters
action = entityTypeConfigurationOfEmployee.Collection.Action("ComplexAction");
action.Parameter <Address>("address").Nullable = false;
action.Parameter <Address>("location"); // nullable
action.CollectionParameter <Address>("addresses"); // collection with nullable element
// Action with entity and collection of entity parameters
action = entityTypeConfigurationOfEmployee.Collection.Action("EntityAction");
action.EntityParameter <Employee>("person").Nullable = false;
action.EntityParameter <Employee>("guard"); // nullable
action.CollectionEntityParameter <Employee>("staff"); // collection with nullable element
#endregion
builder.Action("ResetDataSource");
builder.EnumType <Color>().Namespace = "NS";
builder.ComplexType <Address>().Namespace = "NS";
builder.ComplexType <SubAddress>().Namespace = "NS";
builder.EntityType <Employee>().Namespace = "NS";
builder.EntityType <Manager>().Namespace = "NS";
return(builder.GetEdmModel());
}
protected static IEdmModel GetEdmModel(WebRouteConfiguration configuration)
{
ODataModelBuilder builder = configuration.CreateConventionModelBuilder();
return(builder.GetEdmModel());
}
