private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnumType <Color>().Namespace = "NS";
return(builder.GetEdmModel());
}
public void CreateODataEnumValue_ReturnsCorrectEnumMember()
{
// Arrange
var builder = new ODataConventionModelBuilder();
builder.EnumType <BookCategory>().Namespace = "NS";
IEdmModel model = builder.GetEdmModel();
IEdmEnumType enumType = model.SchemaElements.OfType <IEdmEnumType>().Single();
IServiceProvider serviceProvder = new Mock <IServiceProvider>().Object;
var provider = new DefaultODataSerializerProvider(serviceProvder);
ODataEnumSerializer serializer = new ODataEnumSerializer(provider);
ODataSerializerContext writeContext = new ODataSerializerContext
{
Model = model
};
// Act
ODataEnumValue value = serializer.CreateODataEnumValue(BookCategory.Newspaper,
new EdmEnumTypeReference(enumType, false), writeContext);
// Assert
Assert.NotNull(value);
Assert.Equal("news", value.Value);
}
public async Task ReadFromStreamAsync_ModelAlias()
{
// Arrange
string content = "{\"@odata.type\":\"#NS.level\",\"value\":\"veryhigh\"}";
var builder = new ODataConventionModelBuilder();
builder.EnumType <Level>().Namespace = "NS";
IEdmModel model = builder.GetEdmModel();
ODataEnumDeserializer deserializer = new ODataEnumDeserializer();
ODataDeserializerContext readContext = new ODataDeserializerContext
{
Model = model,
ResourceType = typeof(Level)
};
HttpRequest request = RequestFactory.Create("Post", "http://localhost/", _edmModel);
// Act
object value = await deserializer.ReadAsync(ODataTestUtil.GetODataMessageReader(request.GetODataMessage(content), model),
typeof(Level), readContext);
// Assert
Level level = Assert.IsType <Level>(value);
Assert.Equal(Level.High, level);
}
public static void ConfigureSecurityService(this IAppBuilder app)
{
Debug.Assert(app != null);
//// build EDM model
var builder = new ODataConventionModelBuilder()
{
Namespace = typeof(UsersController).Namespace,
ContainerName = "DefaultContainer"
};
builder.EnumType<Role>();
// TODO: how to mark the entity set as readonly
var userEntityType = builder.EntitySet<User>("Users").EntityType;
userEntityType.Ignore(c => c._Password);
userEntityType.Ignore(c => c._IsLocked);
userEntityType.Ignore(c => c._LockDateTimeUtc);
var edmModel = builder.GetEdmModel();
//// configure web API
var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
config.MessageHandlers.Add(new ETagMessageHandler());
config.MapODataServiceRoute("SecurityService", "securityservice", edmModel);
config.Services.Replace(typeof(IHttpControllerSelector), new ClientHttpControllerSelector(config, typeof(SecurityServiceHelper)));
config.EnsureInitialized();
app.UseWebApi(config);
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
builder.EnumType <Color>().Namespace = "NS";
return(builder.GetEdmModel());
}
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"]);
}
public ODataEnumDeserializerTests()
{
var builder = new ODataConventionModelBuilder();
builder.EnumType <Color>().Namespace = "NS";
_edmModel = builder.GetEdmModel();
}
public static void ConfigureSsisService(this IAppBuilder app)
{
Debug.Assert(app != null);
//// build EDM model
var builder = new ODataConventionModelBuilder()
{
Namespace = typeof(SsisController).Namespace,
ContainerName = "DefaultContainer"
};
builder.ComplexType<JobParameter>();
builder.ComplexType<JobStatusResult>();
builder.EnumType<JobStatus>();
builder.EnumType<JobParameterType>();
{
var function = builder.Function("GetStatus");
function.Parameter<string>("name").OptionalParameter = false;
function.Returns<JobStatusResult>();
}
{
var action = builder.Action("Run");
action.Parameter<string>("name").OptionalParameter = false;
action.CollectionParameter<JobParameter>("parameters").OptionalParameter = false;
action.Returns<string>();
}
{
var action = builder.Action("Stop");
action.Parameter<string>("name").OptionalParameter = false;
action.Returns<string>();
}
var edmModel = builder.GetEdmModel();
//// configure web API
var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
config.MapODataServiceRoute("SsisService", "ssisservice", edmModel);
config.Services.Replace(typeof(IHttpControllerSelector), new ClientHttpControllerSelector(config, typeof(SsisServiceHelper)));
config.EnsureInitialized();
app.UseWebApi(config);
}
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);
}
private IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder
{
Namespace = "API"
};
builder.EnumType <BibleVersion>();
builder.EnumType <BookList>();
builder.EntitySet <Book>("Books");
builder.EntitySet <Bible>("Bibles");
builder.EntitySet <BibleBook>("BibleBooks");
builder.EntitySet <Verse>("Verses");
//builder.EntityType<Bible>().ContainsMany(x => x.Chapters);
//builder.EntityType<Chapter>().ContainsMany(x => x.Verses);
return(builder.GetEdmModel());
}
public static IEdmModel GetModel(WebRouteConfiguration config)
{
ODataConventionModelBuilder builder = config.CreateConventionModelBuilder();
builder.EntitySet <Item>("Items");
builder.EntitySet <Item2>("Items2");
builder.EntitySet <ItemWithEnum>("ItemsWithEnum");
builder.EntitySet <ItemWithoutColumn>("ItemsWithoutColumn");
builder.EnumType <SmallNumber>();
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel()
{
if (_edmModel != null)
{
return(_edmModel);
}
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EnumType <Appliance>();
builder.EnumType <Color>();
builder.EnumType <Permission>();
_edmModel = builder.GetEdmModel();
AppendAnnotation(_edmModel);
AppendAnnotationForPermission(_edmModel);
return(_edmModel);
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Item>("Items");
builder.EntitySet <Item2>("Items2");
builder.EntitySet <ItemWithEnum>("ItemsWithEnum");
builder.EntitySet <ItemWithoutColumn>("ItemsWithoutColumn");
builder.EnumType <SmallNumber>();
return(builder.GetEdmModel());
}
private IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnumType <Genre>();
builder.ComplexType <Address>();
builder.ComplexType <NextOfKin>();
builder.EntitySet <Director>("Directors");
return(builder.GetEdmModel());
}
private static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.ComplexType <Address>();
builder.EnumType <Color>();
BuildFunction(builder);
BuildAction(builder);
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel()
{
var builder = new ODataConventionModelBuilder();
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
builder.EnumType <CustomerType>();
builder.EntityType <Customer>().Collection.Function("EnumFunction").Returns <Enum>();
IEdmModel model = builder.GetEdmModel();
return(model);
}
private static IEdmModel GetModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Account>("Accounts");
builder.EnumType <Gender>();
builder.Namespace = typeof(Account).Namespace;
var edmModel = builder.GetEdmModel();
return(edmModel);
}
public static IEdmModel GetModel()
{
if (_edmModel == null)
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Account>("Accounts");
builder.EnumType <Gender>();
builder.Namespace = typeof(Account).Namespace;
_edmModel = builder.GetEdmModel();
}
return(_edmModel);
}
public static IEdmModel GetTypedConventionModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
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 GetTypedConventionModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
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 NewConventionalBuildModel()
{
var builder = new ODataConventionModelBuilder();
builder.EnumType <Color>();
builder.ComplexType <Address>();
builder.EntityType <Order>();
builder.EntityType <Customer>();
builder.EntityType <Registration>().HasKey(r => new { r.ParticipantId, r.ThreadId });
builder.EntityType <Participant>().HasKey(p => p.Login);
builder.EntityType <Thread>().HasKey(t => t.Id);
builder.EntityType <Box>().HasKey(b => b.Id);
builder.EntitySet <Thread>("Threads");
builder.EntitySet <Box>("Boxes");
builder.EntitySet <Participant>("Participants");
return(builder.GetEdmModel());
}
private IEdmModel GetModel()
{
ODataConventionModelBuilder builder = ODataConventionModelBuilderFactory.Create();
var set = builder.EntitySet <SelectExpandTestCustomer>("SelectExpandTestCustomers");
builder.EntitySet <SelectExpandTestOrder>("SelectExpandTestOrders");
var set2 = builder.EntitySet <SelectExpandTestCustomerWithCustom>("SelectExpandTestCustomerWithCustoms");
builder.Ignore <SelectExpandTestSpecialCustomer>();
builder.Ignore <SelectExpandTestSpecialOrder>();
set.EntityType.Function("GetBestOrders").ReturnsCollectionFromEntitySet <SelectExpandTestOrder>("SelectExpandTestOrders");
set2.EntityType.Function("GetInstanceBestOrders").ReturnsCollectionFromEntitySet <SelectExpandTestOrder>("SelectExpandTestOrders");
set2.EntityType.Function("GetInt").Returns <int>().Parameter <int>("p");
set2.EntityType.Function("ConvertEnum").Returns <int>().Parameter <TestEnum>("p");
builder.EnumType <TestEnum>();
var model = builder.GetEdmModel();
var entityType = model.EntityContainer.EntitySets().First(e => e.Name == "SelectExpandTestCustomerWithCustoms").EntityType() as EdmEntityType;
var containerProperty = typeof(SelectExpandTestCustomerWithCustom).GetProperty(nameof(SelectExpandTestCustomerWithCustom.Custom));
var clrProperty = containerProperty.PropertyType.GetProperty(nameof(CustomFields.TestField));
var edmProperty = entityType.AddStructuralProperty("TestField", EdmPrimitiveTypeKind.String, true);
model.SetAnnotationValue(edmProperty, new ClrPropertyInfoAnnotation(clrProperty)
{
PropertiesPath = new List <PropertyInfo>()
{
containerProperty
}
});
var modelBound = model.GetAnnotationValue <ModelBoundQuerySettings>(entityType) ?? new ModelBoundQuerySettings();
modelBound.DefaultSelectType = SelectExpandType.Automatic;
modelBound.MaxTop = null; // Ensure that system wide settings are respected
model.SetAnnotationValue(entityType, modelBound);
BoundFunctions.RegisterFunctions(model.SchemaElements.OfType <EdmEnumType>().First(e => e.Name == "TestEnum").ToEdmTypeReference(false));
return(model);
}
public static IEdmModel GetEdmModel()
{
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.EntitySet <KnowledgeItem>("KnowledgeItems");
modelBuilder.EntitySet <ExerciseItem>("ExerciseItems");
modelBuilder.EntitySet <ExerciseItemAnswer>("ExerciseItemAnswers");
modelBuilder.EntitySet <KnowledgeTag>("KnowledgeTags");
modelBuilder.EntitySet <ExerciseTag>("ExerciseTags");
modelBuilder.EnumType <AwardRuleType>();
modelBuilder.EntitySet <AwardRule>("AwardRules");
modelBuilder.EntitySet <DailyTrace>("DailyTraces");
modelBuilder.EntitySet <AwardPoint>("AwardPoints");
modelBuilder.EntitySet <AwardPointReport>("AwardPointReports");
modelBuilder.EntitySet <Tag>("Tags");
modelBuilder.EntitySet <TagCount>("TagCounts");
modelBuilder.EntitySet <TagCountByRefType>("TagCountByRefTypes");
modelBuilder.EntitySet <OverviewInfo>("OverviewInfos");
modelBuilder.EntitySet <ExerciseItemWithTagView>("ExerciseItemWithTagViews");
modelBuilder.EntitySet <KnowledgeItemWithTagView>("KnowledgeItemWithTagViews");
// Action on Daily trace template documents
var awardPointEntity = modelBuilder.EntityType <AwardPoint>();
awardPointEntity.Property(prop => prop.RecordDate).AsDate();
var dailyTraceEntity = modelBuilder.EntityType <DailyTrace>();
dailyTraceEntity.Property(prop => prop.RecordDate).AsDate();
var simulatePointAction = dailyTraceEntity.Collection.Action("SimulatePoints");
simulatePointAction.Parameter <DailyTrace>("dt");
simulatePointAction.ReturnsCollectionFromEntitySet <AwardPoint>("AwardPoints");
//.Parameter<DailyTrace>("dt");
modelBuilder.Namespace = typeof(KnowledgeItem).Namespace;
return(modelBuilder.GetEdmModel());
}
private static IEdmModel GetModel()
{
var builder = new ODataConventionModelBuilder {
Namespace = Namespace
};
builder.EnumType <Issue.IssueStatus>().Namespace = Namespace;
var soissue = builder.EntityType <SOIssue>();
soissue.Namespace = Namespace;
soissue.Ignore(p => p.Type);
soissue.Ignore(p => p.Tag);
var user = builder.EntityType <User>();
user.Namespace = Namespace;
user.HasKey(p => p.Name);
builder.EntitySet <SOIssue>("SOIssues");
builder.EntitySet <User>("Users");
return(builder.GetEdmModel());
}
public static void ConfigureProductService(this IAppBuilder app)
{
Debug.Assert(app != null);
//// build EDM model
var builder = new ODataConventionModelBuilder()
{
Namespace = typeof(ProductController).Namespace,
ContainerName = "DefaultContainer"
};
builder.EnumType<ProductDiamondClarity>();
builder.EnumType<ProductDiamondColor>();
builder.EnumType<ProductDiamondCut>();
builder.EnumType<ProductDiamondPolish>();
builder.EnumType<ProductDiamondReport>();
builder.EnumType<ProductDiamondSymmetry>();
builder.EnumType<ProductStatus>();
builder.EntitySet<ProductDiamondImport>("DiamondImports");
{
var entityType = builder.EntitySet<ProductDiamond>("Diamonds").EntityType;
entityType.Ignore(c => c._Import);
entityType.Ignore(c => c._ImportId);
}
var edmModel = builder.GetEdmModel();
//// configure web API
var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
config.MessageHandlers.Add(new ETagMessageHandler());
config.MapODataServiceRoute("ProductService", "productservice", edmModel);
config.Services.Replace(typeof(IHttpControllerSelector), new ClientHttpControllerSelector(config, typeof(ProductServiceHelper)));
config.EnsureInitialized();
app.UseWebApi(config);
}
public static Microsoft.OData.Edm.IEdmModel GetEdmModel()
{
var modelBuilder = new ODataConventionModelBuilder();
modelBuilder.ContainerName = "storageApi";
modelBuilder.Namespace = "container";
modelBuilder.EnableLowerCamelCase();
#region ENTITY SETS
var expenseEntitySet = modelBuilder.EntitySet <Expense>("expenses");
var incomeEntitySet = modelBuilder.EntitySet <Income>("incomes");
var usersEntitySet = modelBuilder.EntitySet <User>("users");
#endregion
#region ENTITY TYPES
var expenseEntityType = modelBuilder.EntityType <Expense>();
expenseEntityType.Namespace = DefaultTypeNameSpace;
expenseEntityType.Name = Camelize(expenseEntityType.Name);
expenseEntityType.HasKey <int>(x => x.ExpenseId);
var incomeEntityType = modelBuilder.EntityType <Income>();
incomeEntityType.Namespace = DefaultTypeNameSpace;
incomeEntityType.Name = Camelize(incomeEntityType.Name);
incomeEntityType.HasKey <int>(i => i.Id);
incomeEntityType.Property(i => i.UserId);
incomeEntityType.Property(i => i.Amount);
var userEntityType = modelBuilder.EntityType <User>();
userEntityType.Namespace = DefaultTypeNameSpace;
userEntityType.Name = Camelize(userEntityType.Name);
userEntityType.HasKey <int>(x => x.Id);
#endregion
#region COMPLEX TYPES
var chartComplexType = modelBuilder.ComplexType <Chart>();
chartComplexType.Name = Camelize(chartComplexType.Name);
chartComplexType.Namespace = DefaultTypeNameSpace;
chartComplexType.Property(x => x.Amount).IsRequired();
var monthlyChartComplexType = modelBuilder.ComplexType <MonthlyChart>();
monthlyChartComplexType.Name = Camelize(monthlyChartComplexType.Name);
monthlyChartComplexType.Namespace = DefaultTypeNameSpace;
monthlyChartComplexType.Property(x => x.Name).IsRequired();
var expenseChartSummaryComplexType = modelBuilder.ComplexType <ChartSummary>();
expenseChartSummaryComplexType.Name = Camelize(expenseChartSummaryComplexType.Name);
expenseChartSummaryComplexType.Namespace = DefaultTypeNameSpace;
#endregion
#region ENUM TYPES
var chartTypeEnumType = modelBuilder.EnumType <ChartType>();
chartTypeEnumType.Name = Camelize(chartTypeEnumType.Name);
chartTypeEnumType.Namespace = DefaultTypeNameSpace;
#endregion
#region ACTIONS
#region EXPENSE
#endregion
#endregion
#region FUNCTIONS
var getYearlySummaryFunction = expenseEntityType.Collection.Function("yearlySummary");
getYearlySummaryFunction.Namespace = "get";
getYearlySummaryFunction.Parameter <int>("userId").OptionalParameter = false;
getYearlySummaryFunction.Parameter <int>("noOfLatestYears").OptionalParameter = true;
getYearlySummaryFunction.ReturnsCollection <Chart>().OptionalReturn = false;
var getMonthlySummaryFunction = expenseEntityType.Collection.Function("monthlySummary");
getMonthlySummaryFunction.Namespace = "get";
getMonthlySummaryFunction.Parameter <int>("userId").OptionalParameter = false;
getMonthlySummaryFunction.Parameter <int>("year").OptionalParameter = false;
getMonthlySummaryFunction.Returns <ChartSummary>().OptionalReturn = false;
var getWeeklySummaryFunction = expenseEntityType.Collection.Function("weeklySummary");
getWeeklySummaryFunction.Namespace = "get";
getWeeklySummaryFunction.Parameter <int>("userId").OptionalParameter = false;
getWeeklySummaryFunction.Parameter <int>("year").OptionalParameter = false;
getWeeklySummaryFunction.Parameter <int>("month").OptionalParameter = false;
getWeeklySummaryFunction.ReturnsCollection <Chart>().OptionalReturn = false;
var getInomesByFunction = incomeEntityType.Collection.Function("chartData");
getInomesByFunction.Namespace = "get";
getInomesByFunction.Parameter <int>("userId").OptionalParameter = false;
getInomesByFunction.Parameter <ChartType>("type").OptionalParameter = false;
getInomesByFunction.Parameter <string>("typeData").OptionalParameter = false;
getInomesByFunction.Returns <ChartSummary>().OptionalReturn = true;
var filterUsersByFunction = userEntityType.Function("by");
filterUsersByFunction.Namespace = "filter";
filterUsersByFunction.Parameter <string>("type").OptionalParameter = false;
filterUsersByFunction.Returns <bool>();
#endregion
return(modelBuilder.GetEdmModel());
}
public void ReadComplexValue_CanReadDynamicCollectionPropertiesForOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType<SimpleOpenAddress>();
builder.EnumType<SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference =
model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataCollectionValue collectionValue = new ODataCollectionValue
{
TypeName = "Collection(" + typeof(SimpleEnum).FullName + ")",
Items = new[] { enumValue, enumValue }
};
ODataComplexValue complexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty { Name = "Street", Value = "My Way #599" },
// dynamic properties
new ODataProperty { Name = "CollectionProperty", Value = collectionValue }
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("My Way #599", address.Street);
Assert.Null(address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(1, address.Properties.Count());
var collectionValues = Assert.IsType<List<SimpleEnum>>(address.Properties["CollectionProperty"]);
Assert.NotNull(collectionValues);
Assert.Equal(2, collectionValues.Count());
Assert.Equal(SimpleEnum.Third, collectionValues[0]);
Assert.Equal(SimpleEnum.Third, collectionValues[1]);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.EnvironmentName == "Development")
{
app.UseDeveloperExceptionPage();
}
else
{
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
#if DEBUG
#else
app.UseSerilogRequestLogging();
#endif
// app.UseHttpsRedirection();
app.UseAuthentication();
if (Environment.EnvironmentName != "IntegrationTest")
{
app.UseCors(MyAllowSpecificOrigins);
}
ODataModelBuilder modelBuilder = new ODataConventionModelBuilder(app.ApplicationServices);
modelBuilder.EntitySet <Currency>("Currencies");
modelBuilder.EntitySet <Language>("Languages");
modelBuilder.EntitySet <DBVersion>("DBVersions");
modelBuilder.EntitySet <CheckVersionResult>("CheckVersionResult");
modelBuilder.EnumType <HomeMemberRelationType>();
modelBuilder.EntitySet <HomeDefine>("HomeDefines");
modelBuilder.EntitySet <HomeMember>("HomeMembers");
modelBuilder.EntitySet <LearnCategory>("LearnCategories");
modelBuilder.EntitySet <LearnObject>("LearnObjects");
modelBuilder.EntitySet <FinanceAccountCategory>("FinanceAccountCategories");
modelBuilder.EntitySet <FinanceAssetCategory>("FinanceAssetCategories");
modelBuilder.EntitySet <FinanceDocumentType>("FinanceDocumentTypes");
modelBuilder.EntitySet <FinanceTransactionType>("FinanceTransactionTypes");
modelBuilder.EnumType <FinanceAccountStatus>();
modelBuilder.EnumType <RepeatFrequency>();
modelBuilder.EnumType <LoanRepaymentMethod>();
modelBuilder.EnumType <FinancePlanTypeEnum>();
modelBuilder.EntitySet <FinanceControlCenter>("FinanceControlCenters");
modelBuilder.EntitySet <FinanceAccount>("FinanceAccounts");
modelBuilder.EntitySet <FinanceAccountExtraDP>("FinanceAccountExtraDPs");
modelBuilder.EntitySet <FinanceAccountExtraAS>("FinanceAccountExtraASs");
modelBuilder.EntitySet <FinanceTmpDPDocument>("FinanceTmpDPDocuments");
modelBuilder.EntitySet <FinanceTmpLoanDocument>("FinanceTmpLoanDocuments");
modelBuilder.EntitySet <FinanceOrder>("FinanceOrders");
modelBuilder.EntitySet <FinanceOrderSRule>("FinanceOrderSRules");
modelBuilder.EntitySet <FinancePlan>("FinancePlans");
modelBuilder.EntitySet <FinanceDocument>("FinanceDocuments");
modelBuilder.EntitySet <FinanceDocumentItem>("FinanceDocumentItems");
modelBuilder.EntitySet <FinanceDocumentItemView>("FinanceDocumentItemViews");
var acntBalRpt = modelBuilder.EntitySet <FinanceReportByAccount>("FinanceReportByAccounts");
acntBalRpt.EntityType.HasKey(p => new {
p.HomeID,
p.AccountID,
});
var ccBalRpt = modelBuilder.EntitySet <FinanceReportByControlCenter>("FinanceReportByControlCenters");
ccBalRpt.EntityType.HasKey(p => new
{
p.HomeID,
p.ControlCenterID,
});
var ordBalRpt = modelBuilder.EntitySet <FinanceReportByOrder>("FinanceReportByOrders");
ordBalRpt.EntityType.HasKey(p => new
{
p.HomeID,
p.OrderID,
});
modelBuilder.ComplexType <RepeatedDates>();
modelBuilder.ComplexType <RepeatDatesCalculationInput>();
modelBuilder.ComplexType <RepeatedDatesWithAmount>();
modelBuilder.ComplexType <RepeatDatesWithAmountCalculationInput>();
// Function on root
modelBuilder.Function("GetRepeatedDates")
.ReturnsCollection <RepeatedDates>();
// .Parameter<RepeatDatesCalculationInput>("input");
var funcbuilder = modelBuilder.Function("GetRepeatedDates2")
.ReturnsCollection <RepeatedDates>();
funcbuilder.Parameter <string>("StartDate");
funcbuilder.Parameter <string>("EndDate");
funcbuilder.Parameter <int>("RepeatType");
modelBuilder.Function("GetRepeatedDatesWithAmount")
.ReturnsCollection <RepeatedDatesWithAmount>();
//.Parameter<RepeatDatesWithAmountCalculationInput>("input");
modelBuilder.Function("GetRepeatedDatesWithAmountAndInterest")
.ReturnsCollection <RepeatedDatesWithAmountAndInterest>();
//.Parameter<RepeatDatesWithAmountAndInterestCalInput>("input");
// Actions on Documents
var docEntity = modelBuilder.EntityType <FinanceDocument>();
docEntity.Property(c => c.TranDate).AsDate();
docEntity.Collection
.Action("PostDPDocument")
.ReturnsFromEntitySet <FinanceDocument>("FinanceDocuments");
//.Returns<FinanceDocument>();
//.Parameter<int>("HomeID");
docEntity.Collection
.Action("PostLoanDocument")
.ReturnsFromEntitySet <FinanceDocument>("FinanceDocuments");
// .Parameter<int>("HomeID");
docEntity.Collection
.Action("PostAssetBuyDocument")
.ReturnsFromEntitySet <FinanceDocument>("FinanceDocuments");
//.Parameter<int>("HomeID");
docEntity.Collection
.Action("PostAssetSellDocument")
.ReturnsFromEntitySet <FinanceDocument>("FinanceDocuments");
//.Parameter<int>("HomeID");
docEntity.Collection
.Action("PostAssetValueChangeDocument")
.ReturnsFromEntitySet <FinanceDocument>("FinanceDocuments");
modelBuilder.Namespace = typeof(Currency).Namespace;
// Function on DP template documents
var tmpTpDocEntity = modelBuilder.EntityType <FinanceTmpDPDocument>();
var tmpTpDocPostFunc =
tmpTpDocEntity.Collection.Action("PostDocument")
.ReturnsFromEntitySet <FinanceDocument>("FinanceDocuments");
//tmpTpDocPostFunc.Parameter<int>("DocumentID");
//tmpTpDocPostFunc.Parameter<int>("AccountID");
//tmpTpDocPostFunc.Parameter<int>("HomeID");
// Action on Loan template documents: Repay document
var tmpLoanDocEntity = modelBuilder.EntityType <FinanceTmpLoanDocument>();
tmpLoanDocEntity.Collection
.Action("PostRepayDocument")
.ReturnsFromEntitySet <FinanceDocument>("FinanceDocuments");
tmpLoanDocEntity.Collection
.Action("PostPrepaymentDocument")
.ReturnsFromEntitySet <FinanceDocument>("FinanceDocuments");
modelBuilder.EntitySet <BlogFormat>("BlogFormats");
modelBuilder.EntitySet <BlogUserSetting>("BlogUserSettings");
modelBuilder.EntitySet <BlogCollection>("BlogCollections");
modelBuilder.EntitySet <BlogPost>("BlogPosts");
modelBuilder.EntitySet <BlogPostCollection>("BlogPostCollections");
modelBuilder.EntitySet <BlogPostTag>("BlogPostTags");
// Functions
var postentity = modelBuilder.EntityType <BlogPost>();
postentity.Function("Deploy")
.Returns <string>()
;
postentity.Function("ClearDeploy")
.Returns <string>();
var blogsetting = modelBuilder.EntityType <BlogUserSetting>();
blogsetting.Function("Deploy")
.Returns <string>();
var model = modelBuilder.GetEdmModel();
app.UseODataBatching();
app.UseMiddleware(typeof(ErrorHandlingMiddleware));
app.UseMvc(routeBuilder => {
// and this line to enable OData query option, for example $filter
routeBuilder.Select().Expand().Filter().OrderBy().MaxTop(100).Count();
routeBuilder.MapODataServiceRoute("ODataRoute", "api", model);
});
app.UseResponseCaching();
var cachePeriod = env.EnvironmentName == "Development" ? "10" : "30";
app.UseStaticFiles(new StaticFileOptions
{
FileProvider = new PhysicalFileProvider(BlogFolder),
RequestPath = "/blogs",
OnPrepareResponse = ctx =>
{
// Requires the following import:
// using Microsoft.AspNetCore.Http;
ctx.Context.Response.Headers.Append("Cache-Control", $"public, max-age={cachePeriod}");
}
});
}
public void ReadEntry_CanReadDynamicPropertiesForOpenEntityType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType<SimpleOpenCustomer>();
builder.EnumType<SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityTypeReference customerTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenCustomer)).AsEntity();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataEntityDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataComplexValue[] complexValues =
{
new ODataComplexValue
{
TypeName = typeof(SimpleOpenAddress).FullName,
Properties = new[]
{
// declared properties
new ODataProperty { Name = "Street", Value = "Street 1" },
new ODataProperty { Name = "City", Value = "City 1" },
// dynamic properties
new ODataProperty
{
Name = "DateTimeProperty",
Value = new DateTimeOffset(new DateTime(2014, 5, 6))
}
}
},
new ODataComplexValue
{
TypeName = typeof(SimpleOpenAddress).FullName,
Properties = new[]
{
// declared properties
new ODataProperty { Name = "Street", Value = "Street 2" },
new ODataProperty { Name = "City", Value = "City 2" },
// dynamic properties
new ODataProperty
{
Name = "ArrayProperty",
Value = new ODataCollectionValue { TypeName = "Collection(Edm.Int32)", Items = new[] {1, 2, 3, 4} }
}
}
}
};
ODataCollectionValue collectionValue = new ODataCollectionValue
{
TypeName = "Collection(" + typeof(SimpleOpenAddress).FullName + ")",
Items = complexValues
};
ODataEntry odataEntry = new ODataEntry
{
Properties = new[]
{
// declared properties
new ODataProperty { Name = "CustomerId", Value = 991 },
new ODataProperty { Name = "Name", Value = "Name #991" },
// dynamic properties
new ODataProperty { Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA") },
new ODataProperty { Name = "EnumValue", Value = enumValue },
new ODataProperty { Name = "CollectionProperty", Value = collectionValue }
},
TypeName = typeof(SimpleOpenCustomer).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
ODataEntryWithNavigationLinks entry = new ODataEntryWithNavigationLinks(odataEntry);
// Act
SimpleOpenCustomer customer = deserializer.ReadEntry(entry, customerTypeReference, readContext)
as SimpleOpenCustomer;
// Assert
Assert.NotNull(customer);
// Verify the declared properties
Assert.Equal(991, customer.CustomerId);
Assert.Equal("Name #991", customer.Name);
// Verify the dynamic properties
Assert.NotNull(customer.CustomerProperties);
Assert.Equal(3, customer.CustomerProperties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), customer.CustomerProperties["GuidProperty"]);
Assert.Equal(SimpleEnum.Third, customer.CustomerProperties["EnumValue"]);
// Verify the dynamic collection property
var collectionValues = Assert.IsType<List<SimpleOpenAddress>>(customer.CustomerProperties["CollectionProperty"]);
Assert.NotNull(collectionValues);
Assert.Equal(2, collectionValues.Count());
Assert.Equal(new DateTimeOffset(new DateTime(2014, 5, 6)), collectionValues[0].Properties["DateTimeProperty"]);
Assert.Equal(new List<int> { 1, 2, 3, 4 }, collectionValues[1].Properties["ArrayProperty"]);
}
public void ReadComplexValue_CanReadDynamicPropertiesForOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType<SimpleOpenAddress>();
builder.EnumType<SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new Mock<ODataDeserializerProvider>().Object;
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataComplexValue complexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty { Name = "Street", Value = "My Way #599" },
new ODataProperty { Name = "City", Value = "Redmond & Shanghai" },
// dynamic properties
new ODataProperty { Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA") },
new ODataProperty { Name = "EnumValue", Value = enumValue },
new ODataProperty { Name = "DateTimeProperty", Value = new DateTimeOffset(new DateTime(1992, 1, 1)) }
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("My Way #599", address.Street);
Assert.Equal("Redmond & Shanghai", address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(3, address.Properties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), address.Properties["GuidProperty"]);
Assert.Equal(SimpleEnum.Third, address.Properties["EnumValue"]);
Assert.Equal(new DateTimeOffset(new DateTime(1992, 1, 1)), address.Properties["DateTimeProperty"]);
}
public void ReadResource_CanReadDynamicPropertiesForOpenEntityType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType <SimpleOpenCustomer>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityTypeReference customerTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenCustomer)).AsEntity();
var deserializer = new ODataResourceDeserializer(_deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataResource[] complexResources =
{
new ODataResource
{
TypeName = typeof(SimpleOpenAddress).FullName,
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "Street 1"
},
new ODataProperty {
Name = "City", Value = "City 1"
},
// dynamic properties
new ODataProperty
{
Name = "DateTimeProperty",
Value = new DateTimeOffset(new DateTime(2014, 5, 6))
}
}
},
new ODataResource
{
TypeName = typeof(SimpleOpenAddress).FullName,
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "Street 2"
},
new ODataProperty {
Name = "City", Value = "City 2"
},
// dynamic properties
new ODataProperty
{
Name = "ArrayProperty",
Value = new ODataCollectionValue{
TypeName = "Collection(Edm.Int32)", Items = new[]{ 1, 2, 3, 4 }.Cast <object>()
}
}
}
}
};
ODataResource odataResource = new ODataResource
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "CustomerId", Value = 991
},
new ODataProperty {
Name = "Name", Value = "Name #991"
},
// dynamic properties
new ODataProperty {
Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA")
},
new ODataProperty {
Name = "EnumValue", Value = enumValue
},
},
TypeName = typeof(SimpleOpenCustomer).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
ODataResourceWrapper topLevelResourceWrapper = new ODataResourceWrapper(odataResource);
ODataNestedResourceInfo resourceInfo = new ODataNestedResourceInfo
{
IsCollection = true,
Name = "CollectionProperty"
};
ODataNestedResourceInfoWrapper resourceInfoWrapper = new ODataNestedResourceInfoWrapper(resourceInfo);
ODataResourceSetWrapper resourceSetWrapper = new ODataResourceSetWrapper(new ODataResourceSet
{
TypeName = String.Format("Collection({0})", typeof(SimpleOpenAddress).FullName)
});
foreach (var complexResource in complexResources)
{
resourceSetWrapper.Resources.Add(new ODataResourceWrapper(complexResource));
}
resourceInfoWrapper.NestedItems.Add(resourceSetWrapper);
topLevelResourceWrapper.NestedResourceInfos.Add(resourceInfoWrapper);
// Act
SimpleOpenCustomer customer = deserializer.ReadResource(topLevelResourceWrapper, customerTypeReference, readContext)
as SimpleOpenCustomer;
// Assert
Assert.NotNull(customer);
// Verify the declared properties
Assert.Equal(991, customer.CustomerId);
Assert.Equal("Name #991", customer.Name);
// Verify the dynamic properties
Assert.NotNull(customer.CustomerProperties);
Assert.Equal(3, customer.CustomerProperties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), customer.CustomerProperties["GuidProperty"]);
Assert.Equal(SimpleEnum.Third, customer.CustomerProperties["EnumValue"]);
// Verify the dynamic collection property
var collectionValues = Assert.IsType <List <SimpleOpenAddress> >(customer.CustomerProperties["CollectionProperty"]);
Assert.NotNull(collectionValues);
Assert.Equal(2, collectionValues.Count());
Assert.Equal(new DateTimeOffset(new DateTime(2014, 5, 6)), collectionValues[0].Properties["DateTimeProperty"]);
Assert.Equal(new List <int> {
1, 2, 3, 4
}, collectionValues[1].Properties["ArrayProperty"]);
}
public void ODataConventionModelBuilder_DataContractAttribute_AllowsReferencingSameEnumTwice()
{
// Arrange
var builder = new ODataConventionModelBuilder();
builder.EnumType<Life>();
// Act
builder.EnumType<Life>();
IEdmModel model = builder.GetEdmModel();
}
public void ODataConventionModelBuilder_DataContractAttribute_WorksOnEnumType()
{
// Arrange
var builder = new ODataConventionModelBuilder();
builder.EnumType<Life>();
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmEnumType enumType = model.SchemaElements.OfType<IEdmEnumType>().Single();
Assert.NotNull(enumType);
Assert.Equal(2, enumType.Members.Count());
Assert.Equal("Feelings", enumType.Name);
Assert.Equal("Test", enumType.Namespace);
Assert.True(enumType.Members.Any(m => m.Name.Equals("happy")));
Assert.True(enumType.Members.Any(m => m.Name.Equals("sad")));
}
public void ReadComplexValue_CanReadDynamicPropertiesForOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType <SimpleOpenAddress>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new Mock <ODataDeserializerProvider>().Object;
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataComplexValue complexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "My Way #599"
},
new ODataProperty {
Name = "City", Value = "Redmond & Shanghai"
},
// dynamic properties
new ODataProperty {
Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA")
},
new ODataProperty {
Name = "EnumValue", Value = enumValue
},
new ODataProperty {
Name = "DateTimeProperty", Value = new DateTimeOffset(new DateTime(1992, 1, 1))
}
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("My Way #599", address.Street);
Assert.Equal("Redmond & Shanghai", address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(3, address.Properties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), address.Properties["GuidProperty"]);
Assert.Equal(SimpleEnum.Third, address.Properties["EnumValue"]);
Assert.Equal(new DateTimeOffset(new DateTime(1992, 1, 1)), address.Properties["DateTimeProperty"]);
}
public void ReadEntry_CanReadDynamicPropertiesForInheritanceOpenEntityType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType<SimpleOpenCustomer>();
builder.EnumType<SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityTypeReference vipCustomerTypeReference = model.GetEdmTypeReference(typeof(SimpleVipCustomer)).AsEntity();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataEntityDeserializer(deserializerProvider);
ODataEntry odataEntry = new ODataEntry
{
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
};
ODataEntryWithNavigationLinks entry = new ODataEntryWithNavigationLinks(odataEntry);
// Act
SimpleVipCustomer customer = deserializer.ReadEntry(entry, 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"]);
}
public ODataEnumDeserializerTests()
{
var builder = new ODataConventionModelBuilder();
builder.EnumType<Color>().Namespace = "NS";
_edmModel = builder.GetEdmModel();
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
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 EdmEntitySetReferenceExpression(entitySet));
var functionsOfGetAllConventionCustomers = edmModel.FindDeclaredOperations(schemaNamespace + ".GetAllConventionCustomers");
var getAllConventionCustomersOfEdmFunction = functionsOfGetAllConventionCustomers.FirstOrDefault(f => f.Parameters.Count() == 0) as EdmFunction;
container.AddFunctionImport("GetAllConventionCustomersImport", getAllConventionCustomersOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet));
// 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 EdmEntitySetReferenceExpression(entitySet));
var entitySet1 = container.FindEntitySet("ConventionOrders");
var GetConventionOrderByCustomerIdAndOrderNameOfEdmFunction = edmModel.FindDeclaredOperations(schemaNamespace + ".GetConventionOrderByCustomerIdAndOrderName").First() as EdmFunction;
container.AddFunctionImport("GetConventionOrderByCustomerIdAndOrderNameImport", GetConventionOrderByCustomerIdAndOrderNameOfEdmFunction, new EdmEntitySetReferenceExpression(entitySet1));
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 EdmEntitySetReferenceExpression(entitySet));
#endregion
return edmModel;
}
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 IEdmModel GetModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<Account>("Accounts");
builder.EnumType<Gender>();
builder.Namespace = typeof(Account).Namespace;
var edmModel = builder.GetEdmModel();
return edmModel;
}
public void ODataConventionModelBuilder_DataContractAttribute_WithAddedExplicitlyMember()
{
// Arrange
var builder = new ODataConventionModelBuilder();
builder.EnumType<Life>();
builder.EnumTypes.Single(e => e.Name == "Feelings").AddMember(Life.JustSoSo);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmEnumType enumType = model.SchemaElements.OfType<IEdmEnumType>().Single();
Assert.NotNull(enumType);
Assert.Equal(3, enumType.Members.Count());
Assert.Equal("Feelings", enumType.Name);
Assert.Equal("Test", enumType.Namespace);
Assert.True(enumType.Members.Any(m => m.Name.Equals("happy")));
Assert.True(enumType.Members.Any(m => m.Name.Equals("sad")));
Assert.True(enumType.Members.Any(m => m.Name.Equals("JustSoSo")));
}
private IEdmModel BuildEdmModel()
{
var builder = new ODataConventionModelBuilder();
// General Entities
builder.EntityType <House>();
builder.EntitySet <House>("Houses");
builder.EntityType <Room>();
builder.EntitySet <Room>("Rooms");
// Interior definition (user-defined properties)
builder.EntityType <InteriorDefinition>()
.HasMany(d => d.Properties).AutomaticallyExpand(true);
builder.EntitySet <InteriorDefinition>("InteriorDefinitions");
builder.EntityType <InteriorPropertyDefinition>();
builder.EnumType <InteriorPropertyType>();
// Register base type of interiors and ignore user-defined properties
// they are defined below according to the current DB confiuration
var interiorTypeConfiguration = builder.EntityType <Interior>();
interiorTypeConfiguration.Ignore(i => i.DefinitionID);
interiorTypeConfiguration.Ignore(i => i.Definition);
interiorTypeConfiguration.Ignore(i => i.StringProperty1);
interiorTypeConfiguration.Ignore(i => i.StringProperty2);
interiorTypeConfiguration.Ignore(i => i.StringProperty3);
interiorTypeConfiguration.Ignore(i => i.IntProperty1);
interiorTypeConfiguration.Ignore(i => i.IntProperty2);
interiorTypeConfiguration.Ignore(i => i.IntProperty3);
interiorTypeConfiguration.Ignore(i => i.DoubleProperty1);
interiorTypeConfiguration.Ignore(i => i.DoubleProperty2);
interiorTypeConfiguration.Ignore(i => i.DoubleProperty3);
builder.EntitySet <Interior>("Interior");
// Build the intermediate model and register all dynamic interior definitions
var model = (EdmModel)builder.GetEdmModel();
var entityType = (IEdmEntityType)model.FindDeclaredType(interiorTypeConfiguration.FullName);
var container = (EdmEntityContainer)model.EntityContainer;
var ns = model.SchemaElements.First().Namespace;
var propertyLookup = BuildPropertyLookup(typeof(IUserDefinedPropertyBag));
var definitions = _houseContext.InteriorDefinitions.Include(d => d.Properties).ToArray();
foreach (var definition in definitions)
{
// register type by name using the Interior as base type.
var type = new EdmEntityType(ns, definition.Name, entityType, false, false);
// define the correct CLR type as backstore
model.SetAnnotationValue(type, new ClrTypeAnnotation(typeof(Interior)));
// remember which interior definition represents this EDM type.
model.SetAnnotationValue(type, new InteriorDefinitionAnnotation(definition.ID));
// register user defined properties
foreach (var property in definition.Properties)
{
var edmProperty = type.AddStructuralProperty(property.Name, MapToEdmType(property.PropertyType));
model.SetAnnotationValue(edmProperty, new ClrPropertyInfoAnnotation(propertyLookup[property.PropertyName].Single()));
}
// add to model and register entity set
model.AddElement(type);
container.AddEntitySet(_pluralizer.Pluralize(definition.Name), type);
}
// Register type mapping handler which translates Interiors correctly.
model.SetAnnotationValue <IEdmModelClrTypeMappingHandler>(model, new InteriorDefinitionAwareClrTypeMappingHandler());
// validate the model again newly added entities
if (!model.Validate(out var errors))
{
Debug.Fail("EDM is not valid", string.Join(Environment.NewLine, errors.Select(e => e.ToString())));
}
return(model);
}
public void ReadComplexValue_CanReadDynamicCollectionPropertiesForOpenComplexType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.ComplexType <SimpleOpenAddress>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmComplexTypeReference addressTypeReference =
model.GetEdmTypeReference(typeof(SimpleOpenAddress)).AsComplex();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataComplexTypeDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataCollectionValue collectionValue = new ODataCollectionValue
{
TypeName = "Collection(" + typeof(SimpleEnum).FullName + ")",
Items = new[] { enumValue, enumValue }
};
ODataComplexValue complexValue = new ODataComplexValue
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "My Way #599"
},
// dynamic properties
new ODataProperty {
Name = "CollectionProperty", Value = collectionValue
}
},
TypeName = typeof(SimpleOpenAddress).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
// Act
SimpleOpenAddress address = deserializer.ReadComplexValue(complexValue, addressTypeReference, readContext)
as SimpleOpenAddress;
// Assert
Assert.NotNull(address);
// Verify the declared properties
Assert.Equal("My Way #599", address.Street);
Assert.Null(address.City);
// Verify the dynamic properties
Assert.NotNull(address.Properties);
Assert.Equal(1, address.Properties.Count());
var collectionValues = Assert.IsType <List <SimpleEnum> >(address.Properties["CollectionProperty"]);
Assert.NotNull(collectionValues);
Assert.Equal(2, collectionValues.Count());
Assert.Equal(SimpleEnum.Third, collectionValues[0]);
Assert.Equal(SimpleEnum.Third, collectionValues[1]);
}
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());
}
public void ReadEntry_CanReadDynamicPropertiesForOpenEntityType()
{
// Arrange
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntityType <SimpleOpenCustomer>();
builder.EnumType <SimpleEnum>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityTypeReference customerTypeReference = model.GetEdmTypeReference(typeof(SimpleOpenCustomer)).AsEntity();
var deserializerProvider = new DefaultODataDeserializerProvider();
var deserializer = new ODataEntityDeserializer(deserializerProvider);
ODataEnumValue enumValue = new ODataEnumValue("Third", typeof(SimpleEnum).FullName);
ODataComplexValue[] complexValues =
{
new ODataComplexValue
{
TypeName = typeof(SimpleOpenAddress).FullName,
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "Street 1"
},
new ODataProperty {
Name = "City", Value = "City 1"
},
// dynamic properties
new ODataProperty
{
Name = "DateTimeProperty",
Value = new DateTimeOffset(new DateTime(2014, 5, 6))
}
}
},
new ODataComplexValue
{
TypeName = typeof(SimpleOpenAddress).FullName,
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "Street", Value = "Street 2"
},
new ODataProperty {
Name = "City", Value = "City 2"
},
// dynamic properties
new ODataProperty
{
Name = "ArrayProperty",
Value = new ODataCollectionValue{
TypeName = "Collection(Edm.Int32)", Items = new[]{ 1, 2, 3, 4 }
}
}
}
}
};
ODataCollectionValue collectionValue = new ODataCollectionValue
{
TypeName = "Collection(" + typeof(SimpleOpenAddress).FullName + ")",
Items = complexValues
};
ODataEntry odataEntry = new ODataEntry
{
Properties = new[]
{
// declared properties
new ODataProperty {
Name = "CustomerId", Value = 991
},
new ODataProperty {
Name = "Name", Value = "Name #991"
},
// dynamic properties
new ODataProperty {
Name = "GuidProperty", Value = new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA")
},
new ODataProperty {
Name = "EnumValue", Value = enumValue
},
new ODataProperty {
Name = "CollectionProperty", Value = collectionValue
}
},
TypeName = typeof(SimpleOpenCustomer).FullName
};
ODataDeserializerContext readContext = new ODataDeserializerContext()
{
Model = model
};
ODataEntryWithNavigationLinks entry = new ODataEntryWithNavigationLinks(odataEntry);
// Act
SimpleOpenCustomer customer = deserializer.ReadEntry(entry, customerTypeReference, readContext)
as SimpleOpenCustomer;
// Assert
Assert.NotNull(customer);
// Verify the declared properties
Assert.Equal(991, customer.CustomerId);
Assert.Equal("Name #991", customer.Name);
// Verify the dynamic properties
Assert.NotNull(customer.CustomerProperties);
Assert.Equal(3, customer.CustomerProperties.Count());
Assert.Equal(new Guid("181D3A20-B41A-489F-9F15-F91F0F6C9ECA"), customer.CustomerProperties["GuidProperty"]);
Assert.Equal(SimpleEnum.Third, customer.CustomerProperties["EnumValue"]);
// Verify the dynamic collection property
var collectionValues = Assert.IsType <List <SimpleOpenAddress> >(customer.CustomerProperties["CollectionProperty"]);
Assert.NotNull(collectionValues);
Assert.Equal(2, collectionValues.Count());
Assert.Equal(new DateTimeOffset(new DateTime(2014, 5, 6)), collectionValues[0].Properties["DateTimeProperty"]);
Assert.Equal(new List <int> {
1, 2, 3, 4
}, collectionValues[1].Properties["ArrayProperty"]);
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
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");
// 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").OptionalParameter = 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").OptionalParameter = 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 primitive and collection of primitive parameters
var 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").OptionalParameter = 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").OptionalParameter = 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();
}
