public void Apply(OperationConfiguration configuration, ODataModelBuilder model)
{
FunctionConfiguration function = configuration as FunctionConfiguration;
if (function == null || !function.IsBindable)
{
return;
}
// You only need to create links for bindable functions that bind to a single entity.
if (function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity && function.GetFunctionLink() == null)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFunctionLink(entityContext =>
entityContext.GenerateFunctionLink(bindingParamterType, function.FullyQualifiedName, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
else if (function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Collection && function.GetFeedFunctionLink() == null)
{
if (((CollectionTypeConfiguration)function.BindingParameter.TypeConfiguration).ElementType.Kind ==
EdmTypeKind.Entity)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFeedFunctionLink(
feedContext =>
feedContext.GenerateFunctionLink(bindingParamterType, function.FullyQualifiedName, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
}
}
private static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.Namespace = "NS";
builder.EntitySet <Customer>("Customers");
builder.EntitySet <Order>("Orders");
var specialCustomer = builder.EntityType <SpecialCustomer>();
var customer = builder.EntityType <Customer>();
FunctionConfiguration function = customer.Function("IsUpgradedWithParam").Returns <bool>();
function.Parameter <string>("city");
specialCustomer.Function("IsSpecialUpgraded").Returns <bool>();
// bound to collection
function = customer.Collection.Function("IsAllUpgraded").Returns <bool>();
function.Parameter <int>("param");
function = specialCustomer.Collection.Function("IsSpecialAllUpgraded").Returns <bool>();
function.Parameter <int>("param");
// actions
customer.Action("upgrade");
specialCustomer.Action("specialUpgrade");
// actions bound to collection
customer.Collection.Action("UpgradeAll");
specialCustomer.Collection.Action("UpgradeSpecialAll");
return(builder.GetEdmModel());
}
public void CanCreateEdmModel_WithBindableFunction()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntityType <Customer>();
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
// Act
FunctionConfiguration sendEmail = customer.Function("FunctionName");
sendEmail.Returns <bool>();
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
IEdmFunction function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
Assert.False(function.IsComposable);
Assert.True(function.IsBound);
Assert.Equal("FunctionName", function.Name);
Assert.NotNull(function.ReturnType);
Assert.Single(function.Parameters);
Assert.Equal(BindingParameterConfiguration.DefaultBindingParameterName, function.Parameters.Single().Name);
Assert.Equal(typeof(Customer).FullName, function.Parameters.Single().Type.FullName());
}
public void WhenFeedActionLinksNotManuallyConfigured_ConventionBasedBuilderUsesConventions()
{
// Arrange
Uri expectedUri = new Uri("http://server/Movies/Default.Watch(param=@param)");
ODataModelBuilder builder = ODataConventionModelBuilderFactory.Create();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
FunctionConfiguration watch = movie.Collection.Function("Watch").Returns <int>(); // function bound to collection
watch.Parameter <string>("param");
IEdmModel model = builder.GetEdmModel();
var configuration = RoutingConfigurationFactory.Create();
string routeName = "Route";
configuration.MapODataServiceRoute(routeName, null, model);
var request = RequestFactory.Create(HttpMethod.Get, "http://server/Movies", configuration, routeName);
// Act
IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
IEdmFunction watchFunction = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard
IEdmEntitySet entitySet = container.EntitySets().SingleOrDefault();
ODataSerializerContextFactory.Create(model, entitySet, request);
ResourceSetContext context = ResourceSetContextFactory.Create(entitySet, request);
OperationLinkBuilder functionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(watchFunction);
//Assert
Assert.Equal(expectedUri, watch.GetFeedFunctionLink()(context));
Assert.NotNull(functionLinkBuilder);
Assert.Equal(expectedUri, functionLinkBuilder.BuildLink(context));
}
private static IEdmModel getEdmModel()
{
ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder();
EntitySetConfiguration <Person> peopleEntitySet = modelBuilder.EntitySet <Person>("People");
EntityTypeConfiguration <Person> personType = peopleEntitySet.EntityType;
personType.Ignore(p => p.CreatedTime);
personType.Ignore(p => p.LastModifiedTime);
EntitySetConfiguration <Account> accountEntitySet = modelBuilder.EntitySet <Account>("Accounts");
EntityTypeConfiguration <Account> accountType = accountEntitySet.EntityType;
accountType.Ignore(a => a.LastModifyTime);
accountType.Ignore(a => a.CreateTime);
FunctionConfiguration getPersonAndDescendants = modelBuilder.Function("GetPersonAndDescendants");
getPersonAndDescendants.ReturnsFromEntitySet <Person>("People");
getPersonAndDescendants.Parameter <long>("Id"); // The id of the root person.
getPersonAndDescendants.Parameter <long>("TotalLevels"); // How many levels will be loaded and the root person is included.
getPersonAndDescendants.IsComposable = true;
FunctionConfiguration getPersonAndAncestors = modelBuilder.Function("GetPersonAndAncestors");
getPersonAndAncestors.ReturnsCollectionFromEntitySet <Person>("People");
getPersonAndAncestors.Parameter <long>("Id"); // The id of the root person.
getPersonAndAncestors.Parameter <long>("TotalLevels"); // How many levels will be loaded and the root person is included.
getPersonAndAncestors.IsComposable = true;
modelBuilder.Namespace = typeof(Person).Namespace;
return(modelBuilder.GetEdmModel());
}
public Task StartAFunctionsInstance(string path, int port, string runtime)
{
FunctionConfiguration configuration = FunctionsBindings.GetFunctionConfiguration(this.scenarioContext);
return(GetFunctionsController(this.scenarioContext)
.StartFunctionsInstance(path, port, runtime, "csharp", configuration));
}
public void Can_SetFunctionTitle_OnBindable_Functions()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntitySetConfiguration <Movie> movies = builder.EntitySet <Movie>("Movies");
movies.EntityType.HasKey(m => m.ID);
FunctionConfiguration entityAction = movies.EntityType.Function("Checkout");
entityAction.Returns <int>();
entityAction.Title = "Check out";
FunctionConfiguration collectionAction = movies.EntityType.Collection.Function("RemoveOld");
collectionAction.Returns <int>();
collectionAction.Title = "Remove Old Movies";
// Act
IEdmModel model = builder.GetEdmModel();
IEdmOperation checkout = model.FindOperations("Default.Checkout").Single();
IEdmOperation removeOld = model.FindOperations("Default.RemoveOld").Single();
OperationTitleAnnotation checkoutTitle = model.GetOperationTitleAnnotation(checkout);
OperationTitleAnnotation removeOldTitle = model.GetOperationTitleAnnotation(removeOld);
// Assert
Assert.NotNull(checkoutTitle);
Assert.Equal("Check out", checkoutTitle.Title);
Assert.NotNull(removeOldTitle);
Assert.Equal("Remove Old Movies", removeOldTitle.Title);
}
public void CanCreateFunctionWithEntityReturnType()
{
// Arrange & Act
ODataModelBuilder builder = new ODataModelBuilder();
FunctionConfiguration createGoodCustomer = builder.Function("CreateGoodCustomer").ReturnsFromEntitySet <Customer>("GoodCustomers");
FunctionConfiguration createBadCustomers = builder.Function("CreateBadCustomers").ReturnsCollectionFromEntitySet <Customer>("BadCustomers");
// Assert
EntityTypeConfiguration customer = createGoodCustomer.ReturnType as EntityTypeConfiguration;
Assert.NotNull(customer);
Assert.Equal(typeof(Customer).FullName, customer.FullName);
EntitySetConfiguration goodCustomers = builder.EntitySets.SingleOrDefault(s => s.Name == "GoodCustomers");
Assert.NotNull(goodCustomers);
Assert.Same(createGoodCustomer.NavigationSource, goodCustomers);
CollectionTypeConfiguration customers = createBadCustomers.ReturnType as CollectionTypeConfiguration;
Assert.NotNull(customers);
customer = customers.ElementType as EntityTypeConfiguration;
Assert.NotNull(customer);
EntitySetConfiguration badCustomers = builder.EntitySets.SingleOrDefault(s => s.Name == "BadCustomers");
Assert.NotNull(badCustomers);
Assert.Same(createBadCustomers.NavigationSource, badCustomers);
}
public void CanCreateFunctionWithNonbindingParametersAsNullable()
{
// Arrange & Act
ODataModelBuilder builder = new ODataModelBuilder();
FunctionConfiguration function = builder.Function("MyFunction");
function.Parameter <string>("p0");
function.Parameter <string>("p1").Nullable = false;
function.Parameter <int>("p2").Nullable = true;
function.Parameter <int>("p3");
function.Parameter <Address>("p4");
function.Parameter <Address>("p5").Nullable = false;
function.CollectionParameter <ZipCode>("p6");
function.CollectionParameter <ZipCode>("p7").Nullable = false;
Dictionary <string, ParameterConfiguration> parameters = function.Parameters.ToDictionary(e => e.Name, e => e);
// Assert
Assert.True(parameters["p0"].Nullable);
Assert.False(parameters["p1"].Nullable);
Assert.True(parameters["p2"].Nullable);
Assert.False(parameters["p3"].Nullable);
Assert.True(parameters["p4"].Nullable);
Assert.False(parameters["p5"].Nullable);
Assert.True(parameters["p6"].Nullable);
Assert.False(parameters["p7"].Nullable);
}
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 async Task ShouldReturnIntervalServerErrorIfUnhandledException()
{
var config = new FunctionConfiguration
{
Recipient = "*****@*****.**",
FallbackSubject = "You got mail!",
UseRedirectResponse = true,
AllowUserRedirectUrls = true
};
var requestReader = CreateRequestReader(
"name", "Captain Test",
"email", "*****@*****.**",
"message", "Test message!");
var smtpClientMock = new Mock <ISmtpClient>();
smtpClientMock
.Setup(sc => sc.SendAsync(It.IsAny <MailMessage>()))
.ThrowsAsync(new InvalidOperationException("BOOM"));
var function = new SendEmailFunction(
config,
requestReader,
() => smtpClientMock.Object);
var result = await function.Run(Mock.Of <HttpRequest>(), Mock.Of <ILogger>());
Assert.IsType <InternalServerErrorResult>(result);
}
public IHttpActionResult PutCalcFunction(int id, FunctionConfiguration calcFunction)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != calcFunction.ID)
{
return(BadRequest());
}
calcFunction.UpdateDate = DateTime.Now;
calcFunction.User = HttpContext.Current.User.Identity.Name.ToString();
db.Entry(calcFunction).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!CalcFunctionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
private IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntitySetConfiguration <Department> departments = builder.EntitySet <Department>("Departments");
EntitySetConfiguration <Party> parties = builder.EntitySet <Party>("Parties");
EntitySetConfiguration <ObjectPermission> objectPermissions = builder.EntitySet <ObjectPermission>("ObjectPermissions");
EntitySetConfiguration <MemberPermission> memberPermissions = builder.EntitySet <MemberPermission>("MemberPermissions");
EntitySetConfiguration <TypePermission> typePermissions = builder.EntitySet <TypePermission>("TypePermissions");
employees.EntityType.HasKey(t => t.Oid);
departments.EntityType.HasKey(t => t.Oid);
parties.EntityType.HasKey(t => t.Oid);
FunctionConfiguration login = builder.Function("Login");
login.Returns <int>();
login.Parameter <string>("userName");
login.Parameter <string>("password");
builder.Action("Logout");
ActionConfiguration getPermissions = builder.Action("GetPermissions");
getPermissions.Parameter <string>("typeName");
getPermissions.CollectionParameter <string>("keys");
ActionConfiguration getTypePermissions = builder.Action("GetTypePermissions");
getTypePermissions.Parameter <string>("typeName");
getTypePermissions.ReturnsFromEntitySet <TypePermission>("TypePermissions");
return(builder.GetEdmModel());
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
EntityTypeConfiguration <Order> order = builder.EntitySet <Order>("Orders").EntityType;
// Add unbound function for get special customer.
FunctionConfiguration getCustomersWithNameContaining = builder.Function("GetCustomersWithNameContaining");
getCustomersWithNameContaining.Parameter <string>("ContainedString");
getCustomersWithNameContaining.ReturnsCollectionFromEntitySet <Customer>("Customers");
// Add bound action for updating order price.
ActionConfiguration updateOrderPrice = order.Action("UpdateOrderPrice");
updateOrderPrice.Parameter <string>("Price");
updateOrderPrice.ReturnsFromEntitySet <Order>("Orders");
// Add bound function for delete order from customer and return the rest orders.
FunctionConfiguration deleteOrderFromCustomer = customer.Function("DeleteOrderFromCustomer");
deleteOrderFromCustomer.Parameter <int>("OrderId");
deleteOrderFromCustomer.ReturnsCollectionFromEntitySet <Order>("Orders");
return(builder.GetEdmModel());
}
public HttpResponseMessage SetConfig(int id, JObject config)
{
//Deserialise the JSON to C# object
dynamic json = config;
//Save configuration to calcConfigurations
FunctionConfiguration calcFunction = db.FunctionConfiguration.Find(id);
calcFunction.Configuration = Convert.ToString(json.data);
calcFunction.User = HttpContext.Current.User.Identity.Name.ToString();
calcFunction.UpdateDate = DateTime.Now;
calcFunction.Version = calcFunction.Version + (decimal)0.001;
db.Entry(calcFunction).State = EntityState.Modified;
db.SaveChanges();
////Build CalcHistory object
FunctionHistory.CalcID = calcFunction.ID;
FunctionHistory.Name = calcFunction.Name;
FunctionHistory.Scheme = calcFunction.Scheme;
FunctionHistory.Configuration = calcFunction.Configuration;
FunctionHistory.Comment = Convert.ToString(json.comment);
FunctionHistory.UpdateDate = DateTime.Now;
FunctionHistory.User = calcFunction.User;
FunctionHistory.Version = calcFunction.Version;
////Save calcHistory object
FunctionHistories.PostFunctionHistory(FunctionHistory);
//Return the response
var response = Request.CreateResponse();
response.Content = new StringContent(JsonConvert.SerializeObject(json.data));
return(response);
}
public HttpResponseMessage Get(int?id)
{
var response = Request.CreateResponse();
FunctionConfiguration calcFunction = db.FunctionConfiguration.Find(id);
if (calcFunction == null)
{
List <CategoryViewModel> json = repo.GetConfig(null);
response.Content = new StringContent(JsonConvert.SerializeObject(json));
}
else
{
if (calcFunction.Configuration == null)
{
HttpContext.Current.Cache.Remove("config");
List <CategoryViewModel> json = repo.GetConfig(null);
response.Content = new StringContent(JsonConvert.SerializeObject(json));
}
else
{
response.Content = new StringContent(calcFunction.Configuration);
}
}
return(response);
}
public void CanManuallyConfigureFunctionLinkFactory()
{
// Arrange
string uriTemplate = "http://server/service/Customers({0})/Reward";
Uri expectedUri = new Uri(string.Format(uriTemplate, 1));
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.EntitySet <Customer>("Customers").EntityType;
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
// Act
FunctionConfiguration reward = customer.Function("Reward");
reward.HasFunctionLink(ctx => new Uri(string.Format(uriTemplate, ctx.GetPropertyValue("CustomerId"))),
followsConventions: false);
reward.Returns <bool>();
IEdmModel model = builder.GetEdmModel();
IEdmEntityType customerType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault();
ODataSerializerContext serializerContext = new ODataSerializerContext {
Model = model
};
ResourceContext context = new ResourceContext(serializerContext, customerType.AsReference(), new Customer {
CustomerId = 1
});
IEdmFunction rewardFunction = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); // Guard
OperationLinkBuilder functionLinkBuilder = model.GetAnnotationValue <OperationLinkBuilder>(rewardFunction);
//Assert
Assert.Equal(expectedUri, reward.GetFunctionLink()(context));
Assert.NotNull(functionLinkBuilder);
Assert.Equal(expectedUri, functionLinkBuilder.BuildLink(context));
}
public static Microsoft.OData.Edm.IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Address>("Address");
builder.EntitySet <AddressType>("AddressType");
builder.EntitySet <BusinessEntity>("BusinessEntity");
builder.EntitySet <BusinessEntityAddress>("BusinessEntityAddress");
builder.EntitySet <BusinessEntityContact>("BusinessEntityContact");
builder.EntitySet <ContactType>("ContactType");
builder.EntitySet <CountryRegion>("CountryRegion");
builder.EntitySet <EmailAddress>("EmailAddress");
builder.EntitySet <Password>("Password");
builder.EntitySet <Person>("Person");
builder.EntitySet <PersonPhone>("PersonPhone");
builder.EntitySet <PhoneNumberType>("PhoneNumberType");
builder.EntitySet <StateProvince>("StateProvince");
EntitySetConfiguration <Person> persons = builder.EntitySet <Person>("Person");
FunctionConfiguration myFirstFunction = persons.EntityType.Collection.Function("MyFirstFunction");
myFirstFunction.ReturnsCollectionFromEntitySet <Person>("Person");
return(builder.GetEdmModel());
}
public async Task ShouldReturnBadRequestIfSuppliedUrlRequiredAndNotSupplied()
{
var config = new FunctionConfiguration
{
Recipient = "*****@*****.**",
FallbackSubject = "You got mail!",
UseRedirectResponse = true,
AllowUserRedirectUrls = true
};
var requestReader = CreateRequestReader(
"name", "Captain Test",
"email", "*****@*****.**",
"message", "Test message!");
var function = new SendEmailFunction(
config,
requestReader,
Mock.Of <ISmtpClient>);
var result = await function.Run(Mock.Of <HttpRequest>(), Mock.Of <ILogger>());
var badRequestResult = Assert.IsType <BadRequestErrorMessageResult>(result);
Assert.Equal("Missing redirect URL.", badRequestResult.Message);
}
public FunctionParameterConfiguration(FunctionConfiguration configuration)
{
this.configuration = configuration;
attributes = new ParameterAttributes();
sqlType = PrimitiveTypes.Numeric();
}
public void FunctionLink_PreservesFollowsConventions(bool value)
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
FunctionConfiguration configuration = new FunctionConfiguration(builder, "IgnoreFunction");
configuration.Returns <int>();
Mock <IEdmTypeConfiguration> bindingParameterTypeMock = new Mock <IEdmTypeConfiguration>();
bindingParameterTypeMock.Setup(o => o.Kind).Returns(EdmTypeKind.Entity);
Type entityType = typeof(object);
bindingParameterTypeMock.Setup(o => o.ClrType).Returns(entityType);
configuration.SetBindingParameter("IgnoreParameter", bindingParameterTypeMock.Object);
configuration.HasFunctionLink((a) => { throw new NotImplementedException(); }, followsConventions: value);
builder.AddOperation(configuration);
builder.AddEntityType(entityType);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
var function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
OperationLinkBuilder functionLinkBuilder = model.GetOperationLinkBuilder(function);
Assert.NotNull(functionLinkBuilder);
Assert.Equal(value, functionLinkBuilder.FollowsConventions);
}
public void CanCreateEdmModel_WithNonBindableFunction()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
// Act
FunctionConfiguration functionConfiguration = builder.Function("FunctionName");
functionConfiguration.ReturnsFromEntitySet <Customer>("Customers");
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmEntityContainer container = model.EntityContainer;
Assert.NotNull(container);
Assert.Single(container.Elements.OfType <IEdmFunctionImport>());
Assert.Single(container.Elements.OfType <IEdmEntitySet>());
IEdmFunctionImport functionImport = Assert.Single(container.Elements.OfType <IEdmFunctionImport>());
IEdmFunction function = functionImport.Function;
Assert.False(function.IsComposable);
Assert.False(function.IsBound);
Assert.Equal("FunctionName", function.Name);
Assert.NotNull(function.ReturnType);
Assert.NotNull(functionImport.EntitySet);
Assert.Equal("Customers", (functionImport.EntitySet as IEdmPathExpression).Path);
Assert.Empty(function.Parameters);
}
public void CanCreateFunctionWithNoArguments()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
builder.Namespace = "MyNamespace";
builder.ContainerName = "MyContainer";
FunctionConfiguration function = builder.Function("Format");
ActionConfiguration functionII = builder.Action("FormatII");
functionII.Namespace = "MyNamespaceII";
// Assert
Assert.Equal("Format", function.Name);
Assert.Equal(OperationKind.Function, function.Kind);
Assert.NotNull(function.Parameters);
Assert.Empty(function.Parameters);
Assert.Null(function.ReturnType);
Assert.False(function.IsSideEffecting);
Assert.False(function.IsComposable);
Assert.False(function.IsBindable);
Assert.False(function.SupportedInFilter);
Assert.False(function.SupportedInOrderBy);
Assert.Equal("MyNamespace", function.Namespace);
Assert.Equal("MyNamespace.Format", function.FullyQualifiedName);
Assert.Equal("MyNamespaceII", functionII.Namespace);
Assert.Equal("MyNamespaceII.FormatII", functionII.FullyQualifiedName);
Assert.NotNull(builder.Operations);
Assert.Equal(2, builder.Operations.Count());
}
private IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntitySetConfiguration <Party> parties = builder.EntitySet <Party>("Parties");
EntitySetConfiguration <PermissionContainer> permissions = builder.EntitySet <PermissionContainer>("Permissions");
EntitySetConfiguration <Department> departments = builder.EntitySet <Department>("Departments");
permissions.EntityType.HasKey(t => t.Key);
employees.EntityType.HasKey(t => t.Oid);
parties.EntityType.HasKey(t => t.Oid);
departments.EntityType.HasKey(t => t.Oid);
FunctionConfiguration logon = builder.Function("Login");
logon.Returns <int>();
logon.Parameter <string>("userName");
logon.Parameter <string>("password");
builder.Action("Logoff");
ActionConfiguration getPermissions = builder.Action("GetPermissions");
getPermissions.Parameter <string>("typeName");
getPermissions.CollectionParameter <string>("keys");
return(builder.GetEdmModel());
}
private IEdmModel GetEdmModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
EntitySetConfiguration <WorkflowBase> workflowBases = builder.EntitySet <WorkflowBase>("WorkflowBases");
EntitySetConfiguration <Employee> employees = builder.EntitySet <Employee>("Employees");
EntitySetConfiguration <Project> projects = builder.EntitySet <Project>("Projects");
EntitySetConfiguration <Quote> quotes = builder.EntitySet <Quote>("Quotes");
EntitySetConfiguration <JobCard> jobcards = builder.EntitySet <JobCard>("JobCards");
EntitySetConfiguration <Party> parties = builder.EntitySet <Party>("Parties");
EntitySetConfiguration <PermissionContainer> permissions = builder.EntitySet <PermissionContainer>("Permissions");
permissions.EntityType.HasKey(t => t.Key);
workflowBases.EntityType.HasKey(t => t.Oid);
employees.EntityType.HasKey(t => t.Oid);
projects.EntityType.HasKey(t => t.Oid);
quotes.EntityType.HasKey(t => t.Oid);
jobcards.EntityType.HasKey(t => t.Oid);
parties.EntityType.HasKey(t => t.Oid);
FunctionConfiguration logon = builder.Function("Login");
logon.Returns <int>();
logon.Parameter <string>("userName");
logon.Parameter <string>("password");
builder.Action("Logoff");
ActionConfiguration getPermissions = builder.Action("GetPermissions");
getPermissions.Parameter <string>("typeName");
getPermissions.CollectionParameter <string>("keys");
return(builder.GetEdmModel());
}
public Task StartFunctionWithAdditionalConfigurationAsync(ScenarioContext scenarioContext)
{
FunctionConfiguration functionConfiguration = FunctionsBindings.GetFunctionConfiguration(scenarioContext);
functionConfiguration.EnvironmentVariables.Add("ResponseMessage", "Welcome, {name}");
return(this.StartFunctionsAsync(scenarioContext));
}
public static Task StartFunctionWithAdditionalConfigurationAsync(FeatureContext featureContext)
{
FunctionConfiguration functionConfiguration = FunctionsBindings.GetFunctionConfiguration(featureContext);
functionConfiguration.EnvironmentVariables.Add("ResponseMessage", "Welcome, {name}");
return(StartFunctionsAsync(featureContext));
}
public SendEmailFunction(
FunctionConfiguration configuration,
IRequestReader requestReader,
Func <ISmtpClient> smtpClientFactory)
{
_configuration = configuration;
_requestReader = requestReader;
_smtpClientFactory = smtpClientFactory;
}
public void CanCreateFunctionWithReturnTypeAsNullableByDefault()
{
// Arrange & Act
ODataModelBuilder builder = new ODataModelBuilder();
FunctionConfiguration function = builder.Function("MyFunction").Returns <Address>();
// Assert
Assert.True(function.ReturnNullable);
}
public static IEdmModel GetModel()
{
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Address>("Address");
builder.EntitySet <AddressType>("AddressType");
builder.EntitySet <BusinessEntity>("BusinessEntity");
builder.EntitySet <BusinessEntityAddress>("BusinessEntityAddress");
builder.EntitySet <BusinessEntityContact>("BusinessEntityContact");
builder.EntitySet <ContactType>("ContactType");
builder.EntitySet <CountryRegion>("CountryRegion");
builder.EntitySet <EmailAddress>("EmailAddress");
builder.EntitySet <Password>("Password");
builder.EntitySet <Person>("Person");
builder.EntitySet <PersonPhone>("PersonPhone");
builder.EntitySet <PhoneNumberType>("PhoneNumberType");
builder.EntitySet <StateProvince>("StateProvince");
EntitySetConfiguration <EntityWithEnum> entitesWithEnum
= builder.EntitySet <EntityWithEnum>("EntityWithEnum");
FunctionConfiguration functionEntitesWithEnum
= entitesWithEnum.EntityType.Collection.Function("PersonSearchPerPhoneType");
functionEntitesWithEnum.Parameter <PhoneNumberTypeEnum>("PhoneNumberTypeEnum");
functionEntitesWithEnum.ReturnsCollectionFromEntitySet <EntityWithEnum>("EntityWithEnum");
EntitySetConfiguration <ContactType> contactType = builder.EntitySet <ContactType>("ContactType");
var actionY = contactType.EntityType.Action("ChangePersonStatus");
actionY.Parameter <string>("Level");
actionY.Returns <bool>();
var changePersonStatusAction = contactType.EntityType.Collection.Action("ChangePersonStatus");
changePersonStatusAction.Parameter <string>("Level");
changePersonStatusAction.Returns <bool>();
EntitySetConfiguration <Person> persons = builder.EntitySet <Person>("Person");
FunctionConfiguration myFirstFunction = persons.EntityType.Collection.Function("MyFirstFunction");
myFirstFunction.ReturnsCollectionFromEntitySet <Person>("Person");
builder.ContainerName = "SqliteContext";
builder.EntitySet <AnimalType>("AnimalType");
builder.EntitySet <EventData>("EventData");
builder.EntitySet <Player>("Player");
builder.EntityType <PlayerStats>();
SingletonConfiguration <SkillLevels> skillLevels = builder.Singleton <SkillLevels>("SkillLevels");
builder.EntityType <SkillLevel>();
return(builder.GetEdmModel());
}
private static EdmOperationImport CreateFunctionImport(
FunctionConfiguration function,
EdmEntityContainer container,
IEdmTypeReference returnReference,
IEdmExpression expression,
IEdmPathExpression pathExpression)
{
EdmFunction operation = new EdmFunction(
container.Namespace,
function.Name,
returnReference,
function.IsBindable,
pathExpression,
function.IsComposable);
return new EdmFunctionImport(container, function.Name, operation, expression, includeInServiceDocument: function.IncludeInServiceDocument);
}
public void HasFunctionLink_SetsFollowsConventions(bool value)
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
FunctionConfiguration function = new FunctionConfiguration(builder, "IgnoreFunction");
Mock<IEdmTypeConfiguration> bindingParameterTypeMock = new Mock<IEdmTypeConfiguration>();
bindingParameterTypeMock.Setup(o => o.Kind).Returns(EdmTypeKind.Entity);
IEdmTypeConfiguration bindingParameterType = bindingParameterTypeMock.Object;
function.SetBindingParameter("IgnoreParameter", bindingParameterType, alwaysBindable: false);
// Act
function.HasFunctionLink((a) => { throw new NotImplementedException(); }, followsConventions: value);
// Assert
Assert.Equal(value, function.FollowsConventions);
}
public void FunctionLink_PreservesFollowsConventions(bool value)
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock<ODataModelBuilder>();
FunctionConfiguration configuration = new FunctionConfiguration(builder, "IgnoreFunction");
configuration.Returns<int>();
Mock<IEdmTypeConfiguration> bindingParameterTypeMock = new Mock<IEdmTypeConfiguration>();
bindingParameterTypeMock.Setup(o => o.Kind).Returns(EdmTypeKind.Entity);
Type entityType = typeof(object);
bindingParameterTypeMock.Setup(o => o.ClrType).Returns(entityType);
configuration.SetBindingParameter("IgnoreParameter", bindingParameterTypeMock.Object);
configuration.HasFunctionLink((a) => { throw new NotImplementedException(); }, followsConventions: value);
builder.AddProcedure(configuration);
builder.AddEntityType(entityType);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
var function = Assert.Single(model.SchemaElements.OfType<IEdmFunction>());
FunctionLinkBuilder functionLinkBuilder = model.GetFunctionLinkBuilder(function);
Assert.NotNull(functionLinkBuilder);
Assert.Equal(value, functionLinkBuilder.FollowsConventions);
}
protected void Register(Func<IFunctionConfiguration, IFunctionConfiguration> config)
{
if (config == null)
return;
var configuration = new FunctionConfiguration(this);
config(configuration);
var functionInfos = configuration.FunctionInfo;
foreach (var functionInfo in functionInfos) {
Register(functionInfo, configuration.ExecuteFunc, configuration.ReturnTypeFunc);
}
}
public FunctionParameterConfiguration(FunctionConfiguration configuration)
{
this.configuration = configuration;
attributes = new ParameterAttributes();
sqlType = PrimitiveTypes.Numeric();
}
public void Apply_FollowsConventions()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
FunctionConfiguration function = new FunctionConfiguration(builder, "IgnoreAction");
Mock<IEdmTypeConfiguration> mockBindingParameterType = new Mock<IEdmTypeConfiguration>();
mockBindingParameterType.Setup(o => o.Kind).Returns(EdmTypeKind.Entity);
mockBindingParameterType.Setup(o => o.ClrType).Returns(typeof(int));
function.SetBindingParameter("IgnoreParameter", mockBindingParameterType.Object);
FunctionLinkGenerationConvention convention = new FunctionLinkGenerationConvention();
// Act
convention.Apply(function, builder);
// Assert
Assert.True(function.FollowsConventions);
}
