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 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); }