private static IEdmModel GetEdmModel(HttpConfiguration config)
{
var modelBuilder = new ODataConventionModelBuilder(config);
var moviesEntitySet = modelBuilder.EntitySet<Movie>("Movies");
// Now add actions.
// CheckOut
// URI: ~/odata/Movies(1)/ODataActionsSample.Models.CheckOut
ActionConfiguration checkOutAction = modelBuilder.EntityType<Movie>().Action("CheckOut");
checkOutAction.ReturnsFromEntitySet<Movie>("Movies");
// ReturnMovie
// URI: ~/odata/Movies(1)/ODataActionsSample.Models.Return
// Binds to a single entity; no parameters.
ActionConfiguration returnAction = modelBuilder.EntityType<Movie>().Action("Return");
returnAction.ReturnsFromEntitySet<Movie>("Movies");
// CheckOutMany action
// URI: ~/odata/Movies/ODataActionsSample.Models.CheckOutMany
// Binds to a collection of entities. This action accepts a collection of parameters.
ActionConfiguration checkOutManyAction = modelBuilder.EntityType<Movie>().Collection.Action("CheckOutMany");
checkOutManyAction.CollectionParameter<int>("MovieIDs");
checkOutManyAction.ReturnsCollectionFromEntitySet<Movie>("Movies");
// CreateMovie action
// URI: ~/odata/CreateMovie
// Unbound action. It is invoked from the service root.
ActionConfiguration createMovieAction = modelBuilder.Action("CreateMovie");
createMovieAction.Parameter<string>("Title");
createMovieAction.ReturnsFromEntitySet<Movie>("Movies");
modelBuilder.Namespace = typeof(Movie).Namespace;
return modelBuilder.GetEdmModel();
}
private static IEdmModel GetConventionModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
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.Country).Name = "Reign";
return builder.GetEdmModel();
}
public static void Register(HttpConfiguration httpConfiguration)
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "ODataV4TestService.Models";
builder.EntitySet<Product>("Products");
builder.EntitySet<SuppliedProduct>("SuppliedProducts");
builder.EntitySet<Supplier>("Suppliers");
builder.EntitySet<Product>("OtherProducts");
builder.ComplexType<Description>();
builder.EntityType<Product>()
.Action("Rate")
.Parameter<int>("Rating");
builder.EntityType<Product>().Collection
.Function("Best")
.ReturnsCollectionFromEntitySet<Product>("Products");
var funcConfig = builder
.EntityType<Product>()
.Function("RelatedProducts")
.SetBindingParameter("product", builder.GetTypeConfigurationOrNull(typeof(Product)))
//.AddParameter("start", new PrimitiveTypeConfiguration(builder, builder.GetTypeConfigurationOrNull(typeof(DateTimeOffset)), typeof(DateTimeOffset)).
.ReturnsCollectionFromEntitySet<Product>("Products");
funcConfig
.Parameter<DateTimeOffset>("start");
funcConfig
.Parameter<DateTimeOffset>("end");
//builder.Function("GetSalesTaxRate")
// .Returns<double>()
// .Parameter<int>("PostalCode");
builder.EntitySet<Account>("Accounts");
builder.EntityType<PaymentInstrument>()
.Collection
.Function("GetCount")
.Returns<int>()
.Parameter<string>("NameContains");
var model = builder.GetEdmModel();
var conventions = ODataRoutingConventions.CreateDefault();
conventions.Insert(0, new AttributeRoutingConvention(model, httpConfiguration));
var server = new BatchServer(httpConfiguration);
httpConfiguration.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: model,
pathHandler: new DefaultODataPathHandler(),
routingConventions: conventions,
batchHandler: new DefaultODataBatchHandler(server));
httpConfiguration.MessageHandlers.Add(new TracingMessageHandler());
}
public ParameterAliasNodeTranslatorTest()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<ParameterAliasCustomer>("Customers");
builder.EntitySet<ParameterAliasOrder>("Orders");
builder.EntityType<ParameterAliasCustomer>().Function("CollectionFunctionCall")
.ReturnsCollection<int>().Parameter<int>("p1");
builder.EntityType<ParameterAliasCustomer>().Function("EntityCollectionFunctionCall")
.ReturnsCollectionFromEntitySet<ParameterAliasCustomer>("Customers").Parameter<int>("p1");
builder.EntityType<ParameterAliasCustomer>().Function("SingleEntityFunctionCall")
.Returns<ParameterAliasCustomer>().Parameter<int>("p1");
builder.EntityType<ParameterAliasCustomer>().Function("SingleEntityFunctionCallWithoutParameters")
.Returns<ParameterAliasCustomer>();
builder.EntityType<ParameterAliasCustomer>().Function("SingleValueFunctionCall")
.Returns<int>().Parameter<int>("p1");
_model = builder.GetEdmModel();
_customersEntitySet = _model.FindDeclaredEntitySet("Customers");
_customerEntityType = _customersEntitySet.EntityType();
_parameterAliasMappedNode = new ConstantNode(123);
}
public static Microsoft.OData.Edm.IEdmModel GetModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Product>("Products");
builder.EntitySet<Supplier>("Suppliers");
//配置一个函数
//builder.EntitySet<Product>("Products").EntityType.Collection.Function("MostExpensive").Returns<double>(); //获取最贵产品价格的路由设置
//配置一个Action
//builder.EntitySet<Product>("Products").EntityType.Action("Rate").Parameter<int>("Rating");
#region 服务的另一种配置方法
//http://www.asp.net/web-api/overview/odata-support-in-aspnet-web-api/odata-v4/odata-actions-and-functions
builder.Namespace = "ProductService";
builder.EntityType<Product>().Collection
.Function("MostExpensive") //函数路由
.Returns<double>();
builder.Namespace = "ProductService";
builder.EntityType<Product>()
.Action("Rate") //Action路由
.Parameter<int>("Rating");
#endregion
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<ProjectSimpleResponseModel, SearchController>();
builder.EntityType<ProjectSimpleResponseModel>().Property(x => x.ShortDate);
builder.EntityType<ProjectSimpleResponseModel>().Property(x => x.TitleUrl);
builder.Namespace = typeof(ProjectSimpleResponseModel).Namespace;
builder.EnableLowerCamelCase();
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
builder.Action("UnboundAction").Parameter<double>("param");
builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
builder.EntitySet<CompositeKeyItem>("CompositeKeyItems");
builder.EntityType<CompositeKeyItem>().HasKey(x => new { x.FirstKey, x.SecondKey });
return builder.GetEdmModel();
}
public static IEdmModel GetEdmModel(HttpConfiguration configuration)
{
var builder = new ODataConventionModelBuilder(configuration);
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.EntitySet<People>("People");
IEdmModel model = builder.GetEdmModel();
return model;
}
private static IEdmModel GenerateEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet<Suggestion>("Suggestions");
builder.EntitySet<VoteUp>("VotesUp");
builder.EntitySet<VoteDown>("VotesDown");
builder.EntitySet<View>("Views");
builder.Namespace = "Actions";
builder.EntityType<Suggestion>().Action("VoteUp").Parameter<VoteUp>("vote");
builder.EntityType<Suggestion>().Action("VoteDown").Parameter<VoteDown>("vote");
builder.EntityType<Suggestion>().Action("CountView").Parameter<View>("view");
return builder.GetEdmModel();
}
public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
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();
}
private static IEdmModel GenerateEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnableLowerCamelCase();
builder.EntitySet<TranslatedComment>("Comments");
builder.EntitySet<TranslatedAbuse>("Abuses");
// TOOD: check why when I added lines below - author is no longer navigation property and I don't have to use: $expand=author
builder.Namespace = "Actions";
builder.EntityType<TranslatedComment>().Action("VoteUp").Parameter<VoteUp>("vote");
builder.EntityType<TranslatedComment>().Action("VoteDown").Parameter<VoteDown>("vote");
builder.EntityType<TranslatedComment>().Action("ReportAbuse").Parameter<Report>("report");
return builder.GetEdmModel();
}
public void Apply_SingleNullableForeignKeyOnNavigationProperty_Works()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntityType <PrincipalEntity>().HasKey(p => p.PrincipalIntId);
EntityTypeConfiguration dependentEntity = builder.AddEntityType(typeof(SingleNullableDependentEntity));
PropertyInfo expectPrincipal = typeof(PrincipalEntity).GetProperty("PrincipalIntId");
PropertyInfo expectDependent = typeof(SingleNullableDependentEntity).GetProperty("PrincipalId");
PrimitivePropertyConfiguration primitiveProperty = dependentEntity.AddProperty(expectDependent);
PropertyInfo propertyInfo = typeof(SingleNullableDependentEntity).GetProperty("Principal");
NavigationPropertyConfiguration navigation = dependentEntity.AddNavigationProperty(propertyInfo,
EdmMultiplicity.ZeroOrOne);
navigation.AddedExplicitly = false;
// Act
new ForeignKeyAttributeConvention().Apply(navigation, dependentEntity, builder);
// Assert
PropertyInfo actualPropertyInfo = Assert.Single(navigation.DependentProperties);
Assert.Same(expectDependent, actualPropertyInfo);
actualPropertyInfo = Assert.Single(navigation.PrincipalProperties);
Assert.Same(expectPrincipal, actualPropertyInfo);
Assert.True(primitiveProperty.OptionalProperty);
}
public void Apply_MultiForeignKeysOnForeignKeyProperty_Works()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntityType <PrincipalEntity>().HasKey(p => new { p.PrincipalStringId, p.PrincipalIntId });
EntityTypeConfiguration dependentEntity = builder.AddEntityType(typeof(MultiDependentEntity2));
PropertyInfo expectPropertyInfo1 = typeof(MultiDependentEntity2).GetProperty("PrincipalId1");
PrimitivePropertyConfiguration propertyConfig1 = dependentEntity.AddProperty(expectPropertyInfo1);
PropertyInfo expectPropertyInfo2 = typeof(MultiDependentEntity2).GetProperty("PrincipalId2");
PrimitivePropertyConfiguration propertyConfig2 = dependentEntity.AddProperty(expectPropertyInfo2);
PropertyInfo propertyInfo = typeof(MultiDependentEntity2).GetProperty("Principal");
NavigationPropertyConfiguration navigation = dependentEntity.AddNavigationProperty(propertyInfo,
EdmMultiplicity.One);
navigation.AddedExplicitly = false;
// Act
ForeignKeyAttributeConvention convention = new ForeignKeyAttributeConvention();
convention.Apply(propertyConfig1, dependentEntity, builder);
convention.Apply(propertyConfig2, dependentEntity, builder);
// Assert
Assert.Equal(2, navigation.DependentProperties.Count());
Assert.Same(expectPropertyInfo1, navigation.DependentProperties.First());
Assert.Same(expectPropertyInfo2, navigation.DependentProperties.Last());
Assert.Equal(2, navigation.PrincipalProperties.Count());
Assert.Equal("PrincipalIntId", navigation.PrincipalProperties.First().Name);
Assert.Equal("PrincipalStringId", navigation.PrincipalProperties.Last().Name);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Category>("Categories");
builder.EntitySet <Employee>("Employees").EntityType.Ignore(t => t.Photo);
builder.EntityType <Employee>().Collection.Function("TopEmployees").ReturnsCollectionFromEntitySet <Employee>("bindingParameter/Employees");
builder.EntitySet <Order>("Orders");
builder.EntitySet <Product>("Products");
builder.EntitySet <Region>("Regions");
builder.EntitySet <Shipper>("Shippers");
builder.EntitySet <Supplier>("Suppliers");
builder.EntitySet <Territory>("Territories");
config.EnableCors();
config.Count().Filter().OrderBy().Expand().Select().MaxTop(null);
config.MapODataServiceRoute("odata", "odata", builder.GetEdmModel(), new DefaultODataBatchHandler(GlobalConfiguration.DefaultServer));
}
public static void Register(HttpConfiguration config)
{
config.EnableCors();
config.Select().Expand().Filter().OrderBy().MaxTop(null).Count();
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <SalesOrderListItem>("Orders");
var entity = builder.EntityType <SalesOrderListItem>()
.HasKey(p => p.SalesOrderId);
entity.Property(p => p.Customer);
entity.Property(p => p.OrderDate);
entity.Property(p => p.OrderNumber);
entity.Property(p => p.SalesTerritoryId);
entity.CamelCase();
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: null,
model: builder.GetEdmModel())
;
}
public Task <IEdmModel> GetModelAsync(InvocationContext context, CancellationToken cancellationToken)
{
var services = new ODataConventionModelBuilder();
services.EntityType <Person>();
return(Task.FromResult(services.GetEdmModel()));
}
public void Convention_GeneratesUri_ForFunctionBoundToCollectionOfEntity()
{
// Arrange
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Customer>("Customers");
var function = builder.EntityType <Customer>().Collection.Function("MyFunction").Returns <int>();
function.Parameter <string>("param");
IEdmModel model = builder.GetEdmModel();
// Act
var configuration = RoutingConfigurationFactory.Create();
configuration.MapODataServiceRoute("odata", "odata", model);
var request = RequestFactory.Create(HttpMethod.Get, "http://*****:*****@param)",
link.AbsoluteUri);
}
public IEdmModel GetEdmModel()
{
var builder =
new ODataConventionModelBuilder
{
Namespace = typeof(Customer).Namespace
};
// Nicer syntax...
//
//_modelBuilder
// .AddEntitySet<Customer>()
// .AddEntitySet<Order>()
// ;
foreach (var modelType in new [] { typeof(Customer), typeof(Order) })
{
var entityType = builder.AddEntityType(modelType);
builder.AddEntitySet(string.Format("{0}s", modelType.Name), entityType);
}
// Add TopBuyer Function to the Customer collection
builder
.EntityType <Customer>()
.Collection
.Function("TopBuyer")
.ReturnsFromEntitySet <Customer>("Customers");
return(builder.GetEdmModel());
}
private static void ConfigOrder(ODataConventionModelBuilder builder)
{
var function = builder.EntityType <Order>().Function("SendTo").Returns <string>();
function.Parameter <double>("lat");
function.Parameter <double>("lon");
}
public static IEdmModel GetEdmModel(HttpConfiguration configuration)
{
var builder = new ODataConventionModelBuilder(configuration);
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.EntitySet <People>("People");
IEdmModel model = builder.GetEdmModel();
return(model);
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType <SelectExpandWrapperEntity>();
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Supplier>("Suppliers");
//builder.ComplexType<SupplierDto>();
var entityType = builder.EntityType <Supplier>();
var create = entityType.Collection.Action("Create");
create.ReturnsFromEntitySet <Supplier>("Suppliers");
create.Parameter <string>("code").OptionalParameter = false;
create.Parameter <string>("name").OptionalParameter = false;
create.Parameter <string>("description");
var createWithEnum = entityType.Collection.Action("CreateWithEnum");
createWithEnum.ReturnsFromEntitySet <Supplier>("Suppliers");
createWithEnum.Parameter <MyEnum?>("EnumValue");
var postArray = entityType.Collection.Action("PostArrayOfSuppliers");
postArray.ReturnsCollectionFromEntitySet <Supplier>("Suppliers");
postArray.CollectionParameter <SupplierDto>("suppliers");
entityType.Action("Rate")
.Parameter <int>("Rating");
return(builder.GetEdmModel());
}
public void StringParameterWithDot()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
var f = builder.EntityType <Customer>().Collection.Function("GetResource");
f.Parameter <string>("path");
f.Parameter <string>("culture");
f.Returns <string>();
IEdmModel model = builder.GetEdmModel();
var configuration = new[] { typeof(MetadataController), typeof(CustomersController) }.GetHttpConfiguration();
configuration.MapODataServiceRoute("odata", "odata", model);
HttpServer server = new HttpServer(configuration);
var client = new HttpClient(server);
var response = client.GetAsync("http://localhost/odata/Customers/Default.GetResource(path='foo.bar', culture='en-gb')").Result;
string payload = response.Content.ReadAsStringAsync().Result;
Console.WriteLine(payload);
JObject result = JObject.Parse(payload);
Assert.Equal("foo.baren-gb", result["value"]);
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
var pets = builder.EntitySet<Pet>("Pets");
builder.EntityType<BigPet>();
return builder.GetEdmModel();
}
private IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntityType <Customer>().Namespace = "NS";
builder.ComplexType <Address>().Namespace = "NS";
FunctionConfiguration getEnum = builder.Function("GetEnum");
getEnum.Parameter <SimpleEnum>("simpleEnum");
getEnum.Returns <SimpleEnum>();
FunctionConfiguration getFlagsEnum = builder.Function("GetFlagsEnum");
getFlagsEnum.Parameter <FlagsEnum>("flagsEnum");
getFlagsEnum.Returns <FlagsEnum>();
FunctionConfiguration function = builder.Function("GetNullableFlagsEnum").Returns <bool>();
function.Parameter <FlagsEnum?>("flagsEnum");
builder.Function("GetAddress").Returns <bool>().Parameter <Address>("address");
builder.Function("GetCustomer").Returns <bool>().Parameter <Customer>("customer");
return(builder.GetEdmModel());
}
public void EnumKeySimpleSerializerTest()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <EnumCustomer>("EnumKeyCustomers");
builder.EntityType <EnumCustomer>().HasKey(c => c.Color);
IEdmModel model = builder.GetEdmModel();
var controllers = new[] { typeof(EnumKeyCustomersController) };
HttpConfiguration configuration = controllers.GetHttpConfiguration();
configuration.MapODataServiceRoute("odata", routePrefix: null, model: model);
HttpServer host = new HttpServer(configuration);
HttpClient client = new HttpClient(host);
// Act
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get,
"http://localhost/EnumKeyCustomers(System.Web.OData.Builder.TestModels.Color'Red')");
HttpResponseMessage response = client.SendAsync(request).Result;
// Assert
Assert.True(response.IsSuccessStatusCode);
var customer = response.Content.ReadAsAsync <JObject>().Result;
Assert.Equal(9, customer["ID"]);
Assert.Equal(Color.Red, Enum.Parse(typeof(Color), customer["Color"].ToString()));
var colors = customer["Colors"].Select(c => Enum.Parse(typeof(Color), c.ToString()));
Assert.Equal(2, colors.Count());
Assert.Contains(Color.Blue, colors);
Assert.Contains(Color.Red, colors);
}
public void ReadSource_CanReadDynamicPropertiesForInheritanceOpenEntityType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType <SimpleOpenCustomer>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityTypeReference vipCustomerTypeReference = model.GetEdmTypeReference(typeof(SimpleVipCustomer)).AsEntity();
var deserializer = new ODataResourceDeserializer(_deserializerProvider);
ODataResource resource = new ODataResource
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "CustomerId", Value = 121
},
new ODataProperty {
Name = "Name", Value = "VipName #121"
},
new ODataProperty {
Name = "VipNum", Value = "Vip Num 001"
},
// dynamic properties
new ODataProperty {
Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA")
},
},
TypeName = typeof(SimpleVipCustomer).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
ODataResourceWrapper resourceWrapper = new ODataResourceWrapper(resource);
// Act
SimpleVipCustomer customer = deserializer.ReadResource(resourceWrapper, vipCustomerTypeReference, readContext)
as SimpleVipCustomer;
// Assert
Assert.NotNull(customer);
// Verify the declared properties
Assert.Equal(121, customer.CustomerId);
Assert.Equal("VipName #121", customer.Name);
Assert.Equal("Vip Num 001", customer.VipNum);
// Verify the dynamic properties
Assert.NotNull(customer.CustomerProperties);
Assert.Equal(1, customer.CustomerProperties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), customer.CustomerProperties["GuidProperty"]);
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder model = new ODataConventionModelBuilder();
model.EntityType <SampleType>();
return(model.GetEdmModel());
}
private Microsoft.OData.Edm.IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType <ODataQueryOptions_Todo>();
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
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 CreateConventionalEdm()
{
var builder = new ODataConventionModelBuilder();
builder.EntityType <Registration>()
.HasKey(r => new { r.ParticipantLogin, r.ThreadId }).Filter(QueryOptionSetting.Allowed).Expand(SelectExpandType.Allowed);
builder.EntityType <Participant>();
builder.EntityType <MessageThread>().Filter(QueryOptionSetting.Allowed).Expand(SelectExpandType.Allowed);
builder.EntityType <Box>().Filter(QueryOptionSetting.Allowed);
builder.EntitySet <MessageThread>("Threads");
builder.EntitySet <Box>("Boxes");
builder.EntitySet <Participant>("Participants");
builder.EntitySet <Registration>("Registrations");
return(builder.GetEdmModel());
}
public void type_should_match_edm_with_child_entity_substitution(Type originalType)
{
// arrange
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet <Contact>("Contacts");
modelBuilder.EntityType <Address>().Ignore(a => a.IsoCode);
var context = NewContext(modelBuilder.GetEdmModel());
// act
var substitutedType = originalType.SubstituteIfNecessary(context);
// assert
substitutedType.Should().NotBe(originalType);
var nextType = substitutedType.GetGenericArguments()[0];
nextType.GetRuntimeProperties().Should().HaveCount(6);
nextType.Should().HaveProperty <int>(nameof(Contact.ContactId));
nextType.Should().HaveProperty <string>(nameof(Contact.FirstName));
nextType.Should().HaveProperty <string>(nameof(Contact.LastName));
nextType.Should().HaveProperty <string>(nameof(Contact.Email));
nextType.Should().HaveProperty <string>(nameof(Contact.Phone));
nextType = nextType.GetRuntimeProperty(nameof(Contact.Addresses)).PropertyType.GetGenericArguments()[0];
nextType.GetRuntimeProperties().Should().HaveCount(5);
nextType.Should().HaveProperty <int>(nameof(Address.AddressId));
nextType.Should().HaveProperty <string>(nameof(Address.Street));
nextType.Should().HaveProperty <string>(nameof(Address.City));
nextType.Should().HaveProperty <string>(nameof(Address.State));
nextType.Should().HaveProperty <string>(nameof(Address.Zip));
}
public Task <IEdmModel> GetModelAsync(ModelContext context, CancellationToken cancellationToken)
{
var builder = new ODataConventionModelBuilder();
builder.EntityType <PersonWithAge>();
return(Task.FromResult(builder.GetEdmModel()));
}
private static IEdmModel CreateModelWithEntity <T>() where T : class
{
ODataConventionModelBuilder model = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>();
model.EntityType <T>();
return(model.GetEdmModel());
}
public static void Register(HttpConfiguration config)
{
config.MapHttpAttributeRoutes();
// TODO: Module 4: Exercise 1: Task 3.1: Register the BlueYonder Resolver
config.DependencyResolver = new BlueYonderResolver();
config.Formatters.Add(new AtomFormatter());
config.MessageHandlers.Add(new AtomHandler());
config.Routes.MapHttpRoute(
name: "atom",
routeTemplate: "atom/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <LocationDTO>("Locations");
builder.EntityType <LocationDTO>().Filter("City");
config.MapODataServiceRoute(
routeName: "ODataRoute",
routePrefix: "odata",
model: builder.GetEdmModel());
config.EnsureInitialized();
}
private static EdmModel GetModel()
{
const string ns = "ns";
var builder = new ODataConventionModelBuilder { Namespace = ns };
builder.EntityType<Product>().Namespace = ns;
return (EdmModel)builder.GetEdmModel();
}
public void Convention_GeneratesUri_ForActionBoundToEntity()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
var action = builder.EntityType<Customer>().Action("MyAction");
action.Parameter<string>("param");
IEdmModel model = builder.GetEdmModel();
// Act
HttpConfiguration configuration = new HttpConfiguration();
configuration.MapODataServiceRoute("odata", "odata", model);
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:123");
request.SetConfiguration(configuration);
request.ODataProperties().RouteName = "odata";
IEdmEntitySet customers = model.EntityContainer.FindEntitySet("Customers");
var edmType = model.SchemaElements.OfType<IEdmEntityType>().First(e => e.Name == "Customer");
var serializerContext = new ODataSerializerContext { Model = model, NavigationSource = customers, Url = request.GetUrlHelper() };
var entityContext = new EntityInstanceContext(serializerContext, edmType.AsReference(), new Customer { Id = 109 });
// Assert
var edmAction = model.SchemaElements.OfType<IEdmAction>().First(f => f.Name == "MyAction");
Assert.NotNull(edmAction);
ActionLinkBuilder actionLinkBuilder = model.GetActionLinkBuilder(edmAction);
Uri link = actionLinkBuilder.BuildActionLink(entityContext);
Assert.Equal("http://localhost:123/odata/Customers(109)/Default.MyAction", link.AbsoluteUri);
}
private static IEdmModel GenerateEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<User>("Users");
builder.EntitySet<UserClaim>("UserClaims");
builder.EntitySet<UserLogin>("UserLogins");
builder.EntitySet<Role>("Roles");
// builder.EntitySet<UserRole>("UserRole");
builder.EntitySet<Claim>("Claims");
builder.EntityType<Role>().Action("UpdateClaims").CollectionParameter<Guid>("ClaimIDs");
builder.EntityType<User>().Action("UpdateRoles").CollectionParameter<string>("RoleIDs");
return builder.GetEdmModel();
}
private static IEdmModel GetInheritanceModel(HttpConfiguration config)
{
ODataModelBuilder builder = new ODataConventionModelBuilder(config);
var baseEntitySet = builder.EntitySet<BaseEntity>("BaseEntity");
var derivedEntityType = builder.EntityType<DerivedEntity>().DerivesFrom<BaseEntity>();
return builder.GetEdmModel();
}
public void Apply_SingleNullableForeignKeyOnNavigationProperty_Works()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType<PrincipalEntity>().HasKey(p => p.PrincipalIntId);
EntityTypeConfiguration dependentEntity = builder.AddEntityType(typeof(SingleNullableDependentEntity));
PropertyInfo expectPrincipal = typeof(PrincipalEntity).GetProperty("PrincipalIntId");
PropertyInfo expectDependent = typeof(SingleNullableDependentEntity).GetProperty("PrincipalId");
PrimitivePropertyConfiguration primitiveProperty = dependentEntity.AddProperty(expectDependent);
PropertyInfo propertyInfo = typeof(SingleNullableDependentEntity).GetProperty("Principal");
NavigationPropertyConfiguration navigation = dependentEntity.AddNavigationProperty(propertyInfo,
EdmMultiplicity.ZeroOrOne);
navigation.AddedExplicitly = false;
// Act
new ForeignKeyAttributeConvention().Apply(navigation, dependentEntity, builder);
// Assert
PropertyInfo actualPropertyInfo = Assert.Single(navigation.DependentProperties);
Assert.Same(expectDependent, actualPropertyInfo);
actualPropertyInfo = Assert.Single(navigation.PrincipalProperties);
Assert.Same(expectPrincipal, actualPropertyInfo);
Assert.True(primitiveProperty.OptionalProperty);
}
public static IEdmModel BuildEdmModel()
{
var odataBuilder = new ODataConventionModelBuilder();
odataBuilder.EntitySet <Form>("Form");
odataBuilder.EntitySet <ValidationSchema>("ValidationSchema");
odataBuilder.EntitySet <SurveyResponse>("SurveyResponse");
// odataBuilder.EntitySet<SurveySummary>("Surveys");
// odataBuilder.EntitySet<SurveySummary>("SurveySummarys");
var pullRequestsByProjectByContributor = odataBuilder.EntityType <Form>().Collection
.Function("GetSurvey")
.ReturnsCollectionFromEntitySet <Form>("Forms");
var applicationTypeListing = odataBuilder.EntityType <Form>().Collection
.Function("GetApplicationTypes")
.ReturnsCollectionFromEntitySet <FormType>("FormTypes");
//pullRequestsByProjectByContributor.Parameter<Microsoft.AspNet.OData.Query.ODataQueryOptions>("oquery").Required();
//var pullRequestsByProjectByContributor = odataBuilder.EntityType<Form>().Collection
//.Function("GetMamarSurvey")
//.ReturnsCollectionFromEntitySet<Form>("Form");
//pullRequestsByProjectByContributor.Parameter<string>("appName").Required();
//pullRequestsByProjectByContributor.Parameter<string>("userName").Required();
// var submissionRequests = odataBuilder.EntityType<SurveyResponse>().Collection
//.Function("GetSubmissionList")
//.ReturnsCollectionFromEntitySet<SurveyResponse>("SurveyResponse");
// submissionRequests.Parameter<string>("appName").Required();
// submissionRequests.Parameter<string>("companyName").Required();
// submissionRequests.Parameter<string>("userName").Required();
var surveySummaryReq = odataBuilder.EntityType <SurveyResponse>().Collection
.Function("GetSurveySummary")
.ReturnsCollection <SurveyResponsDetail>();
surveySummaryReq.Parameter <string>("surveyId").Required();
return(odataBuilder.GetEdmModel());
}
public static IEdmModel GetEdmModelV1()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Organization>("Organizations");
builder.EntitySet <Department>("Departments");
builder.EntitySet <Company>("Companies");
builder.EntitySet <Customer>("Customers");
builder.Singleton <Customer>("Me");
var function = builder.Function("RateByOrder");
function.Parameter <int>("order");
function.Returns <int>();
var action = builder.EntityType <Customer>().Action("RateByName");
action.Parameter <string>("name");
action.Parameter <int>("age");
action.Returns <string>();
// bound action
ActionConfiguration boundAction = builder.EntityType <Customer>().Action("BoundAction");
boundAction.Parameter <int>("p1");
boundAction.Parameter <Address>("p2");
boundAction.Parameter <Color?>("color");
boundAction.CollectionParameter <string>("p3");
boundAction.CollectionParameter <Address>("p4");
boundAction.CollectionParameter <Color?>("colors");
// bound function for organization
var productPrice = builder.EntityType <Organization>().Collection.
Function("GetPrice").Returns <string>();
productPrice.Parameter <string>("organizationId").Required();
productPrice.Parameter <string>("partId").Required();
productPrice = builder.EntityType <Organization>().Collection.
Function("GetPrice2").ReturnsCollectionFromEntitySet <Organization>("Organizations");
productPrice.Parameter <string>("organizationId").Required();
productPrice.Parameter <string>("partId").Required();
productPrice.IsComposable = true;
return(builder.GetEdmModel());
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
var pets = builder.EntitySet <Pet>("Pets");
builder.EntityType <BigPet>();
return(builder.GetEdmModel());
}
private static IEdmModel GetCustomersModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <QueryCompositionCustomer>("Customer");
builder.EntityType <QueryCompositionCustomerBase>();
return(builder.GetEdmModel());
}
private IEdmModel GetModelWithProcedures()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Player>("Players");
// Actions
builder.EntityType <Player>().Action("PlayerAction1");
builder.EntityType <Player>().Action("PlayerAction2");
builder.EntityType <Player>().Action("PlayerAction3");
// Functions
builder.EntityType <Player>().Function("PlayerFunction1").Returns <int>();
builder.EntityType <Player>().Function("PlayerFunction2").Returns <int>();
return(builder.GetEdmModel());
}
private IEdmModel GetModelWithOperations()
{
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EntitySet <Player>("Players");
// Actions
builder.EntityType <Player>().Action("PlayerAction1");
builder.EntityType <Player>().Action("PlayerAction2");
builder.EntityType <Player>().Action("PlayerAction3");
// Functions
builder.EntityType <Player>().Function("PlayerFunction1").Returns <int>();
builder.EntityType <Player>().Function("PlayerFunction2").Returns <int>();
return(builder.GetEdmModel());
}
private static IEdmModel GetInheritanceModel(HttpConfiguration config)
{
ODataModelBuilder builder = new ODataConventionModelBuilder(config);
var baseEntitySet = builder.EntitySet <BaseEntity>("BaseEntity");
var derivedEntityType = builder.EntityType <DerivedEntity>().DerivesFrom <BaseEntity>();
return(builder.GetEdmModel());
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<AROCustomer>("AROCustomers");
builder.EntityType<AROVipCustomer>().DerivesFrom<AROCustomer>();
builder.EntitySet<AROAddress>("AROAddresses");
builder.EntitySet<AROOrder>("Orders");
return builder.GetEdmModel();
}
public void ShouldIgnoreStaticProperty()
{
ODataModelBuilder modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntityType<ImplicitModelBuilder_EntityWithStaticProperty>();
var model = modelBuilder.GetEdmModel();
var actual = model.SchemaElements.Where(e => e.Name == typeof(ImplicitModelBuilder_EntityWithStaticProperty).Name).OfType<EdmEntityType>().Single();
Assert.Equal(1, actual.Properties().Count());
}
private static IEdmModel GetCustomersModel()
{
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(typeof(QueryCompositionCustomer)));
ODataConventionModelBuilder builder = new ODataConventionModelBuilder(configuration);
builder.EntitySet<QueryCompositionCustomer>("Customer");
builder.EntityType<QueryCompositionCustomerBase>();
return builder.GetEdmModel();
}
public static void ConfigureSalesService(this IAppBuilder app)
{
Debug.Assert(app != null);
//// build EDM model
var builder = new ODataConventionModelBuilder()
{
Namespace = typeof(SalesController).Namespace,
ContainerName = "DefaultContainer"
};
builder.EnumType<ContactMethod>();
builder.EnumType<SaleStatus>();
{
var entityType = builder.EntityType<Contact>();
entityType.Ignore(c => c._SaleHeaderId);
entityType.Ignore(c => c._SaleHeader);
}
{
var entityType = builder.EntityType<SaleLineItem>();
entityType.Ignore(c => c._DynamicProperties);
entityType.Ignore(c => c._SaleHeaderId);
entityType.Ignore(c => c._SaleHeader);
}
{
builder.EntitySet<SaleHeader>("Sales");
}
var edmModel = builder.GetEdmModel();
//// configure web API
var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
config.MessageHandlers.Add(new ETagMessageHandler());
config.MapODataServiceRoute("SalesService", "salesservice", edmModel);
config.Services.Replace(typeof(IHttpControllerSelector), new ClientHttpControllerSelector(config, typeof(SaleServiceHelper)));
config.EnsureInitialized();
app.UseWebApi(config);
}
public ODataSwaggerConverterTest()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
builder.Action("UnboundAction").Parameter<double>("param");
builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
_model = builder.GetEdmModel();
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntityType<VipCustomer>().DerivesFrom<Customer>();
builder.EntitySet<Order>("Orders");
builder.EntitySet<Address>("Addresses");
builder.EntitySet<PersonalInformation>("Informations");
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Customer>("Customers");
builder.EntitySet<Order>("Orders");
builder.Function("UnboundFunction").Returns<string>().Parameter<int>("param");
builder.Action("UnboundAction").Parameter<double>("param");
builder.EntityType<Customer>().Function("BoundFunction").Returns<double>().Parameter<string>("name");
return builder.GetEdmModel();
}
private static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<DerivedTypeA>("SetA");
builder.EntitySet<DerivedTypeB>("SetB");
builder.EntityType<BaseType>(); // this line is necessary.
builder.Function("ReturnAll").ReturnsCollection<BaseType>();
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Account>("Accounts");
builder.EntitySet<PaymentInstrument>("Payments");
builder.EntityType<Account>().Collection.Action("Clear").Parameter<int>("p1");
builder.EntityType<Account>()
.Collection.Function("MyCollectionFunction")
.Returns<string>()
.Parameter<int>("land");
builder.EntityType<PreminumAccount>().Collection.Function("MyCollectionFunction")
.Returns<string>()
.Parameter<int>("land");
builder.EntityType<Account>().Action("ClearSingle").Parameter<string>("pa");
builder.EntityType<Account>().Function("MyFunction").Returns<string>().Parameter<string>("p1");
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Pin>("Pins");
builder.Function("Foo").Returns<int>();
builder.EntityType<Pin>().Collection.Function("Archived").ReturnsCollection<Pin>();
return builder.GetEdmModel();
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration<Product> employees = builder.EntitySet<Product>("Products");
var airPlaneType=builder.EntityType<AirPlane>();
airPlaneType.DerivesFrom<Product>();
builder.Namespace = typeof(Product).Namespace;
var edmModel = builder.GetEdmModel();
return edmModel;
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet<Brand>("Brands");
builder.EnableLowerCamelCase(NameResolverOptions.ProcessReflectedPropertyNames | NameResolverOptions.ProcessExplicitPropertyNames);
builder.EntityType<Brand>().Ignore(brand => brand.Name);
return builder.GetEdmModel();
}
private static IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<ByteParameter>("ByteParameters");
var testType = builder.EntityType<ByteParameter>();
testType.Collection.Function("ResponseTest").Returns<byte>().Parameter<byte>("param");
return builder.GetEdmModel();
}
