public void FunctionImportShouldProduceCorrectFullyQualifiedNameAndNotHaveParameters() { var function = new EdmFunction("d.s", "testFunction", EdmCoreModel.Instance.GetString(true)); function.AddParameter("param1", EdmCoreModel.Instance.GetString(false)); var functionImport = new EdmFunctionImport(new EdmEntityContainer("d.s", "container"), "testFunction", function); EdmUtil.FullyQualifiedName(functionImport).Should().Be("d.s.container/testFunction"); }
public OperationImportSegmentUnitTests() { nullableIntType = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32), true); nullableDecimalType = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Decimal), true); nullableBinaryType = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Binary), true); nullableStringType = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), true); container = ModelBuildingHelpers.BuildValidEntityContainer(); model = new EdmModel(); model.AddElement(container); this.functionIntToInt = new EdmFunction("Name.Space", "Function", this.nullableIntType); this.functionIntToInt.AddParameter("Parameter1", this.nullableIntType); this.functionImportIntToInt = new EdmFunctionImport(this.container, "Function", this.functionIntToInt); this.functionDecimalToInt = new EdmFunction("Name.Space", "Function", this.nullableIntType); this.functionDecimalToInt.AddParameter("Parameter1", this.nullableDecimalType); this.functionImportDecimalToInt = new EdmFunctionImport(this.container, "Function", this.functionDecimalToInt); this.functionBinaryToInt = new EdmFunction("Name.Space", "Function", this.nullableIntType); this.functionBinaryToInt.AddParameter("Parameter1", this.nullableBinaryType); this.functionImportBinaryToInt = new EdmFunctionImport(this.container, "Function", this.functionBinaryToInt); this.functionIntToString = new EdmFunction("Name.Space", "Function", this.nullableStringType); this.functionIntToString.AddParameter("Parameter1", this.nullableIntType); this.functionImportIntToString = new EdmFunctionImport(this.container, "Function", this.functionIntToString); model.AddElement(functionIntToInt); model.AddElement(functionDecimalToInt); model.AddElement(functionBinaryToInt); model.AddElement(functionIntToString); }
public void Ctor_InitializeParameterMappingsProperty_UnboundFunction() { // Arrange IEdmModel model = new Mock<IEdmModel>().Object; IEdmEntityType returnType = new Mock<IEdmEntityType>().Object; EdmEntityContainer container = new EdmEntityContainer("NS", "Container"); EdmFunctionImport function = new EdmFunctionImport( container, "Function", new EdmFunction( "NS", "Function", new EdmEntityTypeReference(returnType, isNullable: false))); Dictionary<string, string> parameterMappings = new Dictionary<string, string> { { "Parameter1", "{param1}" }, { "Parameter2", "{param2}" } }; // Act var template = new UnboundFunctionPathSegmentTemplate( new UnboundFunctionPathSegment(function, model, parameterMappings)); // Assert Assert.Equal(2, template.ParameterMappings.Count); }
/// <summary> /// Creates and adds a function import to this entity container. /// </summary> /// <param name="name">Name of the function import.</param> /// <param name="function">The function of the specified function import.</param> /// <returns>Created function import.</returns> public virtual EdmFunctionImport AddFunctionImport(string name, IEdmFunction function) { EdmFunctionImport functionImport = new EdmFunctionImport(this, name, function); this.AddElement(functionImport); return(functionImport); }
/// <summary> /// Creates and adds a function import to this entity container. /// </summary> /// <param name="name">Name of the function import.</param> /// <param name="function">The function of the specified function import.</param> /// <param name="entitySet">An entity set containing entities returned by this function import. /// The two expression kinds supported are <see cref="IEdmEntitySetReferenceExpression"/> and <see cref="IEdmPathExpression"/>.</param> /// <param name="includeInServiceDocument">A value indicating whether this function import will be in the service document.</param> /// <returns>Created operation import.</returns> public virtual EdmOperationImport AddFunctionImport(string name, IEdmFunction function, IEdmExpression entitySet, bool includeInServiceDocument) { EdmOperationImport functionImport = new EdmFunctionImport(this, name, function, entitySet, includeInServiceDocument); this.AddElement(functionImport); return(functionImport); }
public void AmbigiousOperationBindingShouldReferToFirstOperationAlwaysWhenNotNull() { var container1 =new EdmEntityContainer("n", "d"); var container2 =new EdmEntityContainer("n", "d"); var action1Import = new EdmActionImport(container1, "name", new EdmAction("n", "name", null)); var functionImport = new EdmFunctionImport(container2, "name", new EdmFunction("n", "name", EdmCoreModel.Instance.GetString(true))); var ambigiousOperationBinding = new AmbiguousOperationImportBinding(action1Import, functionImport); ambigiousOperationBinding.ContainerElementKind.Should().Be(EdmContainerElementKind.ActionImport); ambigiousOperationBinding.Name.Should().Be("name"); ambigiousOperationBinding.EntitySet.Should().BeNull(); ambigiousOperationBinding.Container.Should().Be(container1); }
public void TestInitialize() { this.MetadataDocumentUri = new Uri("http://www.myhost.com/myservice.svc/$metadata"); this.model = new EdmModel(); EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "DefaultContainer"); this.model.AddElement(defaultContainer); this.cityType = new EdmEntityType("TestModel", "City"); EdmStructuralProperty cityIdProperty = cityType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/false)); cityType.AddKeys(cityIdProperty); cityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(/*isNullable*/false)); cityType.AddStructuralProperty("Size", EdmCoreModel.Instance.GetInt32(/*isNullable*/false)); this.model.AddElement(cityType); EdmComplexType complexType = new EdmComplexType("TestModel", "MyComplexType"); this.model.AddElement(complexType); this.operationWithNoOverload = new EdmFunction("TestModel", "FunctionImportWithNoOverload", EdmCoreModel.Instance.GetInt32(true)); this.operationImportWithNoOverload = defaultContainer.AddFunctionImport("FunctionImportWithNoOverload", operationWithNoOverload); this.model.AddElement(operationWithNoOverload); this.operationWithOverloadAnd0Param = new EdmFunction("TestModel", "FunctionImportWithOverload", EdmCoreModel.Instance.GetInt32(true)); this.operationImportWithOverloadAnd0Param = defaultContainer.AddFunctionImport("FunctionImportWithOverload", operationWithOverloadAnd0Param); this.operationWithOverloadAnd1Param = new EdmFunction("TestModel", "FunctionImportWithOverload", EdmCoreModel.Instance.GetInt32(true)); this.operationWithOverloadAnd1Param.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false)); this.model.AddElement(operationWithOverloadAnd1Param); this.operationImportWithOverloadAnd1Param = defaultContainer.AddFunctionImport("FunctionImportWithOverload", operationWithOverloadAnd1Param); this.operationWithOverloadAnd2Params = new EdmFunction("TestModel", "FunctionImportWithOverload", EdmCoreModel.Instance.GetInt32(true)); var cityTypeReference = new EdmEntityTypeReference(this.cityType, isNullable: false); this.operationWithOverloadAnd2Params.AddParameter("p1", cityTypeReference); this.operationWithOverloadAnd2Params.AddParameter("p2", EdmCoreModel.Instance.GetString(true)); this.model.AddElement(operationWithOverloadAnd2Params); this.operationImportWithOverloadAnd2Params = defaultContainer.AddFunctionImport("FunctionImportWithOverload", operationWithOverloadAnd2Params); this.operationWithOverloadAnd5Params = new EdmFunction("TestModel", "FunctionImportWithOverload", EdmCoreModel.Instance.GetInt32(true)); this.operationWithOverloadAnd5Params.AddParameter("p1", new EdmCollectionTypeReference(new EdmCollectionType(cityTypeReference))); this.operationWithOverloadAnd5Params.AddParameter("p2", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(isNullable: false)))); this.operationWithOverloadAnd5Params.AddParameter("p3", EdmCoreModel.Instance.GetString(isNullable: true)); EdmComplexTypeReference complexTypeReference = new EdmComplexTypeReference(complexType, isNullable: false); this.operationWithOverloadAnd5Params.AddParameter("p4", complexTypeReference); this.operationWithOverloadAnd5Params.AddParameter("p5", new EdmCollectionTypeReference(new EdmCollectionType(complexTypeReference))); this.model.AddElement(operationWithOverloadAnd5Params); this.operationImportWithOverloadAnd5Params = defaultContainer.AddFunctionImport("FunctionImportWithOverload", operationWithOverloadAnd5Params); }
public void GetEdmType_Returns_FunctionReturnType() { // Arrange IEdmEntityType returnType = new Mock<IEdmEntityType>().Object; EdmEntityContainer container = new EdmEntityContainer("NS", "Container"); EdmFunctionImport function = new EdmFunctionImport( container, "Function", new EdmFunction("NS", "Function", new EdmEntityTypeReference(returnType, isNullable: false))); FunctionPathSegment segment = new FunctionPathSegment(function, model: null, parameterValues: null); // Act var result = segment.GetEdmType(previousEdmType: null); // Assert Assert.Same(returnType, result); }
public EdmLibraryExtensionsTests() { this.model = TestModel.BuildDefaultTestModel(); this.defaultContainer = (EdmEntityContainer)this.model.FindEntityContainer("Default"); this.productsSet = this.defaultContainer.FindEntitySet("Products"); this.productType = (IEdmEntityType)this.model.FindDeclaredType("TestModel.Product"); this.productTypeReference = new EdmEntityTypeReference(this.productType, false); EdmComplexType complexType = new EdmComplexType("TestModel", "MyComplexType"); this.operationWithNoOverload = new EdmFunction("TestModel", "FunctionImportWithNoOverload", EdmCoreModel.Instance.GetInt32(true)); this.operationWithNoOverload.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false)); this.model.AddElement(operationWithNoOverload); this.operationImportWithNoOverload = this.defaultContainer.AddFunctionImport("FunctionImportWithNoOverload", operationWithNoOverload); this.operationWithOverloadAnd0Param = new EdmFunction("TestModel", "FunctionImportWithNoOverload", EdmCoreModel.Instance.GetInt32(true)); this.model.AddElement(operationWithOverloadAnd0Param); this.operationImportWithOverloadAnd0Param = defaultContainer.AddFunctionImport("FunctionImportWithOverload", operationWithOverloadAnd0Param); this.operationWithOverloadAnd1Param = new EdmFunction("TestModel", "FunctionImportWithNoOverload", EdmCoreModel.Instance.GetInt32(true)); this.operationWithOverloadAnd1Param.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false)); this.model.AddElement(operationWithOverloadAnd1Param); this.operationImportWithOverloadAnd1Param = defaultContainer.AddFunctionImport("FunctionImportWithOverload", operationWithOverloadAnd1Param); this.operationWithOverloadAnd2Params = new EdmFunction("TestModel", "FunctionImportWithNoOverload", EdmCoreModel.Instance.GetInt32(true)); var productTypeReference = new EdmEntityTypeReference(productType, isNullable: false); this.operationWithOverloadAnd2Params.AddParameter("p1", productTypeReference); this.operationWithOverloadAnd2Params.AddParameter("p2", EdmCoreModel.Instance.GetString(true)); this.model.AddElement(operationWithOverloadAnd2Params); this.operationImportWithOverloadAnd2Params = defaultContainer.AddFunctionImport("FunctionImportWithOverload", operationWithOverloadAnd2Params); this.operationWithOverloadAnd5Params = new EdmFunction("TestModel", "FunctionImportWithNoOverload", EdmCoreModel.Instance.GetInt32(true)); this.operationWithOverloadAnd5Params.AddParameter("p1", new EdmCollectionTypeReference(new EdmCollectionType(productTypeReference))); this.operationWithOverloadAnd5Params.AddParameter("p2", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(isNullable: false)))); this.operationWithOverloadAnd5Params.AddParameter("p3", EdmCoreModel.Instance.GetString(isNullable: true)); EdmComplexTypeReference complexTypeReference = new EdmComplexTypeReference(complexType, isNullable: false); this.operationWithOverloadAnd5Params.AddParameter("p4", complexTypeReference); this.operationWithOverloadAnd5Params.AddParameter("p5", new EdmCollectionTypeReference(new EdmCollectionType(complexTypeReference))); this.model.AddElement(operationWithOverloadAnd5Params); this.operationImportWithOverloadAnd5Params = defaultContainer.AddFunctionImport("FunctionImportWithOverload", operationWithOverloadAnd5Params); }
public void TryMatch_ReturnTrue_IfSameUnboundFunction() { // Arrange IEdmModel model = new Mock<IEdmModel>().Object; IEdmEntityType returnType = new Mock<IEdmEntityType>().Object; EdmEntityContainer container = new EdmEntityContainer("NS", "Container"); EdmFunction func = new EdmFunction("NS", "Function", new EdmEntityTypeReference(returnType, isNullable: false)); func.AddParameter("Parameter1", EdmCoreModel.Instance.GetInt32(isNullable: false)); func.AddParameter("Parameter2", EdmCoreModel.Instance.GetInt32(isNullable: false)); EdmFunctionImport function = new EdmFunctionImport(container, "Function", func); Dictionary<string, string> parameterValues = new Dictionary<string, string> { { "Parameter1", "1" }, { "Parameter2", "2" } }; Dictionary<string, string> parameterMappings = new Dictionary<string, string> { { "Parameter1", "{param1}" }, { "Parameter2", "{param2}" } }; UnboundFunctionPathSegment segment = new UnboundFunctionPathSegment(function, model, parameterValues); UnboundFunctionPathSegmentTemplate template = new UnboundFunctionPathSegmentTemplate( new UnboundFunctionPathSegment(function, model, parameterMappings)); // Act Dictionary<string, object> values = new Dictionary<string,object>(); bool result = template.TryMatch(segment, values); // Assert Assert.True(result); Assert.Equal(4, values.Count); Assert.Equal("1", values["param1"]); Assert.Equal("2", values["param2"]); Assert.Equal(1, (values[ODataParameterValue.ParameterValuePrefix + "param1"] as ODataParameterValue).Value); Assert.Equal(2, (values[ODataParameterValue.ParameterValuePrefix + "param2"] as ODataParameterValue).Value); }
public void TryMatch_ReturnsTrue_IfSameFunction() { // Arrange IEdmEntityType returnType = new Mock<IEdmEntityType>().Object; EdmEntityContainer container = new EdmEntityContainer("NS", "Container"); EdmFunctionImport function = new EdmFunctionImport( container, "Function", new EdmFunction("NS", "Function", new EdmEntityTypeReference(returnType, isNullable: false))); FunctionPathSegment template = new FunctionPathSegment(function, model: null, parameterValues: null); FunctionPathSegment segment = new FunctionPathSegment(function, model: null, parameterValues: null); // Act Dictionary<string, object> values = new Dictionary<string,object>(); bool result = template.TryMatch(segment, values); // Assert Assert.True(result); Assert.Empty(values); }
public void TryMatch_ReturnTrue_IfSameFunction() { // Arrange IEdmEntityType returnType = new Mock<IEdmEntityType>().Object; EdmEntityContainer container = new EdmEntityContainer("NS", "Container"); EdmFunctionImport function = new EdmFunctionImport( container, "Function", new EdmFunction( "NS", "Function", new EdmEntityTypeReference(returnType, isNullable: false))); Dictionary<string, string> parameterValues = new Dictionary<string, string>() { { "Parameter1", "1" }, { "Parameter2", "2" } }; Dictionary<string, string> parameterMappings = new Dictionary<string, string>() { { "Parameter1", "{param1}" }, { "Parameter2", "{param2}" } }; FunctionPathSegment segment = new FunctionPathSegment(function, model: null, parameterValues: parameterValues); FunctionPathSegmentTemplate template = new FunctionPathSegmentTemplate( new FunctionPathSegment(function, model: null, parameterValues: parameterMappings)); // Act Dictionary<string, object> values = new Dictionary<string,object>(); bool result = template.TryMatch(segment, values); // Assert Assert.True(result); Assert.Equal(2, values.Count); Assert.Equal("1", values["param1"]); Assert.Equal("2", values["param2"]); }
static ODataEntryMetadataContextTest() { ActualEntityType = new EdmEntityType("ns", "TypeName"); ActualEntityType.AddKeys(new IEdmStructuralProperty[] {ActualEntityType.AddStructuralProperty("ID2", EdmPrimitiveTypeKind.Int32), ActualEntityType.AddStructuralProperty("ID3", EdmPrimitiveTypeKind.Int32)}); ActualEntityType.AddStructuralProperty("Name2", EdmCoreModel.Instance.GetString(isNullable:true), /*defaultValue*/null, EdmConcurrencyMode.Fixed); ActualEntityType.AddStructuralProperty("Name3", EdmCoreModel.Instance.GetString(isNullable: true), /*defaultValue*/null, EdmConcurrencyMode.Fixed); ActualEntityType.AddStructuralProperty("StreamProp1", EdmPrimitiveTypeKind.Stream); ActualEntityType.AddStructuralProperty("StreamProp2", EdmPrimitiveTypeKind.Stream); var navProp1 = ActualEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = ActualEntityType, TargetMultiplicity = EdmMultiplicity.Many, Name = "NavProp1" }); var navProp2 = ActualEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = ActualEntityType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Name = "NavProp2" }); var container = new EdmEntityContainer("Namespace", "Container"); EdmEntitySet entitySet = container.AddEntitySet("EntitySet", ActualEntityType); entitySet.AddNavigationTarget(navProp1, entitySet); entitySet.AddNavigationTarget(navProp2, entitySet); Action1 = new EdmAction("Namespace", "Action1", null, true /*isBound*/, null /*entitySetPath*/); Action2 = new EdmAction("Namespace", "Action2", null, true /*isBound*/, null /*entitySetPath*/); ActionImport1 = new EdmActionImport(container, "ActionImport1", Action1); ActionImport2 = new EdmActionImport(container, "ActionImport2", Action2); Function1 = new EdmFunction("Namespace", "Function1", EdmCoreModel.Instance.GetString(isNullable: true), true /*isBound*/, null /*entitySetPath*/, true /*isComposable*/); Function2 = new EdmFunction("Namespace", "Function2", EdmCoreModel.Instance.GetString(isNullable: true), true /*isBound*/, null /*entitySetPath*/, true /*isComposable*/); FunctionImport1 = new EdmFunctionImport(container, "FunctionImport1", Function1); FunctionImport2 = new EdmFunctionImport(container, "FunctionImport2", Function2); }
public void ValidateFunctionIncludeInServiceDocumentWrittenAsTrue() { EdmFunctionImport functionImport = new EdmFunctionImport(defaultContainer, "GetStuff", defaultGetStuffFunction, new EdmPathExpression("Customers", "Orders"), true); TestWriteFunctionImportElementHeaderMethod(functionImport, @"<FunctionImport Name=""GetStuff"" Action=""Default.NameSpace2.GetStuff"" EntitySet=""Customers/Orders"" IncludeInServiceDocument=""true"""); }
/// <summary> /// Creates and adds a function import to this entity container. /// </summary> /// <param name="name">Name of the function import.</param> /// <param name="function">The function of the specified function import.</param> /// <returns>Created function import.</returns> public virtual EdmFunctionImport AddFunctionImport(string name, IEdmFunction function) { EdmFunctionImport functionImport = new EdmFunctionImport(this, name, function); this.AddElement(functionImport); return functionImport; }
/// <summary> /// Creates and adds a function import to this entity container. /// </summary> /// <param name="name">Name of the function import.</param> /// <param name="function">The function of the specified function import.</param> /// <param name="entitySet">An entity set containing entities returned by this function import. /// The two expression kinds supported are <see cref="IEdmEntitySetReferenceExpression"/> and <see cref="IEdmPathExpression"/>.</param> /// <param name="includeInServiceDocument">A value indicating whether this function import will be in the service document.</param> /// <returns>Created operation import.</returns> public virtual EdmOperationImport AddFunctionImport(string name, IEdmFunction function, IEdmExpression entitySet, bool includeInServiceDocument) { EdmOperationImport functionImport = new EdmFunctionImport(this, name, function, entitySet, includeInServiceDocument); this.AddElement(functionImport); return functionImport; }
public void ValidateCorrectEntitySetPathOnOperationImport() { EdmFunction function = new EdmFunction("ns", "GetStuff", EdmCoreModel.Instance.GetString(false), true /*isBound*/, null, false); function.AddParameter("param", DefaultValidCollectionEntityTypeRef); EdmFunctionImport functionImport = new EdmFunctionImport(new EdmEntityContainer("ds", "d"), "GetStuff", function, new EdmPathExpression("param"), false); EdmModel model = new EdmModel(); model.AddElement(function); IEnumerable<EdmError> errorsFound = null; IEdmOperationParameter operationParameter = null; IEnumerable<IEdmNavigationProperty> navigationProperties = null; functionImport.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out errorsFound).Should().BeTrue(); errorsFound.ToList().Should().HaveCount(0); operationParameter.Should().NotBeNull(); navigationProperties.Should().HaveCount(0); }
public void EdmFunctionImportShouldBeFunctionImport() { var function = new EdmFunction("d.s", "checkout", EdmCoreModel.Instance.GetString(true)); var functionImport = new EdmFunctionImport(new EdmEntityContainer("d", "c"), "checkout", function); functionImport.IsActionImport().Should().BeFalse(); functionImport.IsFunctionImport().Should().BeTrue(); }
public ODataConventionalEntityMetadataBuilderTests() { #region Product Entry this.productEntry = new ODataEntry(); this.sinlgeKeyCollection = new Dictionary<string, object>() { { "Id", 42 } }; this.multiKeysCollection = new Dictionary<string, object>() { { "KeyA", "keya" }, { "KeyB", 1 } }; TestFeedAndEntryTypeContext productTypeContext = new TestFeedAndEntryTypeContext { NavigationSourceName = EntitySetName, NavigationSourceEntityTypeName = EntityTypeName, ExpectedEntityTypeName = EntityTypeName, IsMediaLinkEntry = false, UrlConvention = UrlConvention.CreateWithExplicitValue(/*generateKeyAsSegment*/ false), IsFromCollection = false, NavigationSourceKind = EdmNavigationSourceKind.EntitySet }; TestEntryMetadataContext productEntryMetadataContext = new TestEntryMetadataContext { TypeContext = productTypeContext, Entry = this.productEntry, ETagProperties = new[] { new KeyValuePair<string, object>("Name", "Value") }, KeyProperties = this.sinlgeKeyCollection, ActualEntityTypeName = EntityTypeName, SelectedBindableOperations = new IEdmOperation[0], SelectedNavigationProperties = new IEdmNavigationProperty[0], SelectedStreamProperties = new Dictionary<string, IEdmStructuralProperty>() }; this.productConventionalEntityMetadataBuilder = new ODataConventionalEntityMetadataBuilder(productEntryMetadataContext, this.metadataContext, this.uriBuilder); this.productEntry.MetadataBuilder = this.productConventionalEntityMetadataBuilder; #endregion Product Entry #region Derived, MultiKey, Multi ETag, MLE Entry var action = new EdmAction("TestModel", "Action", /*returnType*/ null, /*isBindable*/ true, /*entitySet*/ null); var actionImport = new EdmActionImport(TestModel.Container, "Action", action); var function = new EdmFunction("TestModel", "Function", /*returnType*/ EdmCoreModel.Instance.GetInt32(true), /*isBindable*/ true, /*entitySet*/ null, false /*isComposable*/); var functionImport = new EdmFunctionImport(TestModel.Container, "Function", function); this.derivedMultiKeyMultiEtagMleEntry = new ODataEntry(); TestFeedAndEntryTypeContext derivedMultiKeyMultiEtagMleTypeContext = new TestFeedAndEntryTypeContext { NavigationSourceName = EntitySetName, NavigationSourceEntityTypeName = EntityTypeName, ExpectedEntityTypeName = DerivedEntityTypeName, IsMediaLinkEntry = true, UrlConvention = UrlConvention.CreateWithExplicitValue(/*generateKeyAsSegment*/ false), IsFromCollection = false }; TestEntryMetadataContext derivedProductMleEntryMetadataContext = new TestEntryMetadataContext { TypeContext = derivedMultiKeyMultiEtagMleTypeContext, Entry = this.derivedMultiKeyMultiEtagMleEntry, ETagProperties = new[] { new KeyValuePair<string, object>("ETag1", "ETagValue1"), new KeyValuePair<string, object>("ETag2", "ETagValue2") }, KeyProperties = this.multiKeysCollection, ActualEntityTypeName = DerivedMleEntityTypeName, SelectedBindableOperations = new IEdmOperation[] { action, function }, SelectedNavigationProperties = TestModel.ProductWithNavPropsType.NavigationProperties(), SelectedStreamProperties = new Dictionary<string, IEdmStructuralProperty> { {"Photo", new EdmStructuralProperty(TestModel.ProductType, "Photo", EdmCoreModel.Instance.GetStream( /*isNullable*/true))} }, }; this.derivedMultiKeyMultiEtagMleConventionalEntityMetadataBuilder = new ODataConventionalEntityMetadataBuilder(derivedProductMleEntryMetadataContext, this.metadataContext, this.uriBuilder); this.derivedMultiKeyMultiEtagMleEntry.MetadataBuilder = this.derivedMultiKeyMultiEtagMleConventionalEntityMetadataBuilder; #endregion Derived, MultiKey, Multi ETag, MLE Entry #region Contained Product Entry this.containedCollectionProductEntry = new ODataEntry(); this.containedSinlgeKeyCollection = new Dictionary<string, object>() { { "Id", 43 } }; this.containedMultiKeysCollection = new Dictionary<string, object>() { { "KeyA", "keya" }, { "KeyB", 2 } }; TestFeedAndEntryTypeContext containedCollectionProductTypeContext = new TestFeedAndEntryTypeContext { NavigationSourceName = EntitySetName, NavigationSourceEntityTypeName = EntityTypeName, ExpectedEntityTypeName = EntityTypeName, IsMediaLinkEntry = false, UrlConvention = UrlConvention.CreateWithExplicitValue(/*generateKeyAsSegment*/ false), NavigationSourceKind = EdmNavigationSourceKind.ContainedEntitySet, IsFromCollection = true }; TestEntryMetadataContext containedCollectionProductEntryMetadataContext = new TestEntryMetadataContext { TypeContext = containedCollectionProductTypeContext, Entry = this.containedCollectionProductEntry, ETagProperties = new[] { new KeyValuePair<string, object>("Name", "Value") }, KeyProperties = this.containedSinlgeKeyCollection, ActualEntityTypeName = EntityTypeName, SelectedBindableOperations = new IEdmOperation[0], SelectedNavigationProperties = new IEdmNavigationProperty[0], SelectedStreamProperties = new Dictionary<string, IEdmStructuralProperty>() }; this.containedCollectionProductConventionalEntityMetadataBuilder = new ODataConventionalEntityMetadataBuilder(containedCollectionProductEntryMetadataContext, this.metadataContext, this.uriBuilder); this.containedCollectionProductEntry.MetadataBuilder = this.containedCollectionProductConventionalEntityMetadataBuilder; this.containedCollectionProductEntry.MetadataBuilder.ParentMetadataBuilder = this.productConventionalEntityMetadataBuilder; this.containedProductEntry = new ODataEntry(); this.containedSinlgeKeyCollection = new Dictionary<string, object>() { { "Id", 43 } }; this.containedMultiKeysCollection = new Dictionary<string, object>() { { "KeyA", "keya" }, { "KeyB", 2 } }; TestFeedAndEntryTypeContext containedProductTypeContext = new TestFeedAndEntryTypeContext { NavigationSourceName = EntitySetName, NavigationSourceEntityTypeName = EntityTypeName, ExpectedEntityTypeName = EntityTypeName, IsMediaLinkEntry = false, UrlConvention = UrlConvention.CreateWithExplicitValue(/*generateKeyAsSegment*/ false), NavigationSourceKind = EdmNavigationSourceKind.ContainedEntitySet, IsFromCollection = false }; TestEntryMetadataContext containedProductEntryMetadataContext = new TestEntryMetadataContext { TypeContext = containedProductTypeContext, Entry = this.containedCollectionProductEntry, ETagProperties = new[] { new KeyValuePair<string, object>("Name", "Value") }, KeyProperties = this.containedSinlgeKeyCollection, ActualEntityTypeName = EntityTypeName, SelectedBindableOperations = new IEdmOperation[0], SelectedNavigationProperties = new IEdmNavigationProperty[0], SelectedStreamProperties = new Dictionary<string, IEdmStructuralProperty>() }; this.containedProductConventionalEntityMetadataBuilder = new ODataConventionalEntityMetadataBuilder(containedProductEntryMetadataContext, this.metadataContext, this.uriBuilder); this.containedProductEntry.MetadataBuilder = this.containedProductConventionalEntityMetadataBuilder; this.containedProductEntry.MetadataBuilder.ParentMetadataBuilder = this.productConventionalEntityMetadataBuilder; #endregion }
/// <summary> /// Initializes a new <see cref="IEdmOperationImport"/> instance. /// </summary> /// <param name="name">name of the service operation.</param> /// <param name="function">Function imported in.</param> /// <param name="resultSet">EntitySet of the result expected from this operation.</param> public EdmFunctionImport AddFunctionAndFunctionImport(string name, IEdmTypeReference bindingType, IEdmTypeReference resultType, IEdmEntitySet resultSet, bool isBindable) { var edmFunction = new EdmFunction(this.Namespace, name, resultType, isBindable, null, false /*isComposable*/); if (isBindable) { edmFunction.AddParameter("bindingparameter", bindingType); } EdmEntitySetReferenceExpression entitySetExpression = null; if (resultSet != null) { entitySetExpression = new EdmEntitySetReferenceExpression(resultSet); } this.AddOperation(edmFunction); var functionImport = new EdmFunctionImport(this, name, edmFunction, entitySetExpression, false); this.AddOperationImport(name, functionImport); return functionImport; }
private static void AddProcedure( this IEdmModel model, ProcedureConfiguration procedure, EdmEntityContainer container, Dictionary<Type, IEdmStructuredType> edmTypeMap, Dictionary<string, EdmEntitySet> edmEntitySetMap, bool isAction) { IEdmTypeReference returnReference = GetEdmTypeReference(edmTypeMap, procedure.ReturnType, nullable: true); IEdmExpression expression = GetEdmEntitySetExpression(edmEntitySetMap, procedure); IEdmPathExpression pathExpression = procedure.EntitySetPath != null ? new EdmPathExpression(procedure.EntitySetPath) : null; EdmOperation operation; EdmOperationImport operationImport; if (isAction) { EdmAction action = new EdmAction( container.Namespace, procedure.Name, returnReference, procedure.IsBindable, pathExpression); operation = action; operationImport = new EdmActionImport(container, procedure.Name, action, expression); } else { EdmFunction function = new EdmFunction( container.Namespace, procedure.Name, returnReference, procedure.IsBindable, pathExpression, procedure.IsComposable); operation = function; operationImport = new EdmFunctionImport( container, procedure.Name, function, expression, includeInServiceDocument: true); } AddProcedureParameters(operation, procedure, edmTypeMap); if (procedure.IsBindable) { model.SetIsAlwaysBindable(operation, procedure.IsAlwaysBindable); AddProcedureLinkBuilder(model, operation, procedure); ValidateProcedureEntitySetPath(model, operationImport, procedure); } EdmModel edmModel = model as EdmModel; if (edmModel != null) { edmModel.AddElement(operation); } container.AddElement(operationImport); }
public void VerifyFunctionImportWrittenCorrectly() { var functionImport = new EdmFunctionImport(defaultContainer, "GetStuff", defaultGetStuffFunction, null, true); VisitAndVerifyXml( (visitor) => visitor.VisitEntityContainerElements(new IEdmEntityContainerElement[] { functionImport }), @"<FunctionImport Name=""GetStuff"" Function=""Default.NameSpace2.GetStuff"" IncludeInServiceDocument=""true"" />"); }
public void VerifyTwoIdenticalNamedFunctionImportsWithSameEntitySetPathValueOnlyWrittenOnce() { var functionImport = new EdmFunctionImport(defaultContainer, "GetStuff", defaultGetStuffFunction, new EdmPathExpression("path1", "path2"), true); var functionImport2 = new EdmFunctionImport(defaultContainer, "GetStuff", defaultGetStuffFunction, new EdmPathExpression("path1", "path2"), true); VisitAndVerifyXml( (visitor) => visitor.VisitEntityContainerElements(new IEdmEntityContainerElement[] { functionImport, functionImport2 }), @"<FunctionImport Name=""GetStuff"" Function=""Default.NameSpace2.GetStuff"" EntitySet=""path1/path2"" IncludeInServiceDocument=""true"" />"); }
static AutoComputePayloadMetadataInJsonIntegrationTests() { EntityType = new EdmEntityType("Namespace", "EntityType", null, false, false, true); EntityType.AddKeys(EntityType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32)); EntityType.AddStructuralProperty("StreamProp1", EdmPrimitiveTypeKind.Stream); EntityType.AddStructuralProperty("StreamProp2", EdmPrimitiveTypeKind.Stream); EntityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isNullable: true), null, EdmConcurrencyMode.Fixed); DerivedType = new EdmEntityType("Namespace", "DerivedType", EntityType, false, true); AnotherEntityType = new EdmEntityType("Namespace", "AnotherEntityType", null, false, false, true); AnotherEntityType.AddKeys(AnotherEntityType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32)); AnotherEntityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isNullable: true), null, EdmConcurrencyMode.Fixed); var deferredNavLinkProp = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many, Name = "DeferredNavLink" }); var expandedNavLinkProp = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many, Name = "ExpandedNavLink" }); var navLinkDeclaredOnlyInModelProp = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many, Name = "NavLinkDeclaredOnlyInModel" }); EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many, Name = "ContainedNavProp", ContainsTarget = true }); DerivedType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many, Name = "DerivedContainedNavProp", ContainsTarget = true }); EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = EntityType, TargetMultiplicity = EdmMultiplicity.One, Name = "ContainedNonCollectionNavProp", ContainsTarget = true }); EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = AnotherEntityType, TargetMultiplicity = EdmMultiplicity.Many, Name = "AnotherContainedNavProp", ContainsTarget = true }); EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = AnotherEntityType, TargetMultiplicity = EdmMultiplicity.One, Name = "AnotherContainedNonCollectionNavProp", ContainsTarget = true }); EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = EntityType, TargetMultiplicity = EdmMultiplicity.One, Name = "UnknownNonCollectionNavProp", ContainsTarget = false }); EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many, Name = "UnknownCollectionNavProp", ContainsTarget = false }); var container = new EdmEntityContainer("Namespace", "Container"); EntitySet = container.AddEntitySet("EntitySet", EntityType); EntitySet.AddNavigationTarget(deferredNavLinkProp, EntitySet); EntitySet.AddNavigationTarget(expandedNavLinkProp, EntitySet); EntitySet.AddNavigationTarget(navLinkDeclaredOnlyInModelProp, EntitySet); Model = new EdmModel(); Model.AddElement(EntityType); Model.AddElement(DerivedType); Model.AddElement(AnotherEntityType); Model.AddElement(container); var alwaysBindableAction1 = new EdmAction("Namespace", "AlwaysBindableAction1", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/); alwaysBindableAction1.AddParameter(new EdmOperationParameter(alwaysBindableAction1, "p", new EdmEntityTypeReference(EntityType, isNullable: true))); Model.AddElement(alwaysBindableAction1); var alwaysBindableActionImport1 = new EdmActionImport(container, "AlwaysBindableAction1", alwaysBindableAction1); container.AddElement(alwaysBindableActionImport1); var alwaysBindableAction2 = new EdmAction("Namespace", "AlwaysBindableAction2", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/); alwaysBindableAction2.AddParameter(new EdmOperationParameter(alwaysBindableAction2, "p", new EdmEntityTypeReference(EntityType, isNullable: true))); Model.AddElement(alwaysBindableAction2); var alwaysBindableActionImport2 = new EdmActionImport(container, "AlwaysBindableAction2", alwaysBindableAction2); container.AddElement(alwaysBindableActionImport2); var action1 = new EdmAction("Namespace", "Action1", null /*returnType*/, false /*isBound*/, null /*entitySetPath*/); action1.AddParameter(new EdmOperationParameter(action1, "p", new EdmEntityTypeReference(EntityType, isNullable: true))); Model.AddElement(action1); var actionImport1 = new EdmActionImport(container, "Action1", action1); container.AddElement(actionImport1); var action2 = new EdmAction("Namespace", "Action1", null /*returnType*/, false /*isBound*/, null /*entitySetPath*/); action2.AddParameter(new EdmOperationParameter(action2, "p", new EdmEntityTypeReference(EntityType, isNullable: true))); Model.AddElement(action2); var actionImport2 = new EdmActionImport(container, "Action1", action2); container.AddElement(actionImport2); var alwaysBindableFunction1 = new EdmFunction("Namespace", "AlwaysBindableFunction1", EdmCoreModel.Instance.GetString(isNullable: true), true /*isBound*/, null /*entitySetPath*/, false /*iscomposable*/); alwaysBindableFunction1.AddParameter("p", new EdmEntityTypeReference(EntityType, isNullable: true)); Model.AddElement(alwaysBindableFunction1); var alwaysBindableFunctionImport1 = new EdmFunctionImport(container, "AlwaysBindableFunction1", alwaysBindableFunction1); container.AddElement(alwaysBindableFunctionImport1); var alwaysBindableFunction2 = new EdmFunction("Namespace", "AlwaysBindableFunction2", EdmCoreModel.Instance.GetString(isNullable: true), true /*isBound*/, null /*entitySetPath*/, false /*iscomposable*/); alwaysBindableFunction2.AddParameter("p", new EdmEntityTypeReference(EntityType, isNullable: true)); Model.AddElement(alwaysBindableFunction2); var alwaysBindableFunctionImport2 = new EdmFunctionImport(container, "AlwaysBindableFunction2", alwaysBindableFunction2); container.AddElement(alwaysBindableFunctionImport2); var function1 = new EdmFunction("Namespace", "Function1", EdmCoreModel.Instance.GetString(isNullable: true), false /*isBound*/, null /*entitySetPath*/, false /*iscomposable*/); function1.AddParameter("p", new EdmEntityTypeReference(EntityType, isNullable: true)); Model.AddElement(function1); var functionImport1 = new EdmFunctionImport(container, "Function1", function1); container.AddElement(functionImport1); var function2 = new EdmFunction("Namespace", "Function1", EdmCoreModel.Instance.GetString(isNullable: true), false /*isBound*/, null /*entitySetPath*/, false /*iscomposable*/); function2.AddParameter("p", new EdmEntityTypeReference(EntityType, isNullable: true)); Model.AddElement(function2); var functionImport2 = new EdmFunctionImport(container, "Function1", function2); container.AddElement(functionImport2); var function3 = new EdmFunction("Namespace", "Function3", new EdmEntityTypeReference(EntityType, false), true /*isBound*/, new EdmPathExpression("p/ContainedNonCollectionNavProp"), false /*iscomposable*/); function3.AddParameter("p", new EdmEntityTypeReference(EntityType, isNullable: true)); Model.AddElement(function3); }
public void VerifyIdenticalNamedFunctionImportsWithDifferentEntitySetPropertiesAreWritten() { var functionImportOnSet = new EdmFunctionImport(defaultContainer, "Checkout", defaultGetStuffFunction, new EdmEntitySetReferenceExpression(new EdmEntitySet(defaultContainer, "Set", new EdmEntityType("foo", "type"))), false); var functionImportOnSet2 = new EdmFunctionImport(defaultContainer, "Checkout", defaultGetStuffFunction, new EdmEntitySetReferenceExpression(new EdmEntitySet(defaultContainer, "Set2", new EdmEntityType("foo", "type"))), false); var functionmportWithNoEntitySet = new EdmFunctionImport(defaultContainer, "Checkout", defaultGetStuffFunction, null, false); var functionImportWithUniqueEdmPath = new EdmFunctionImport(defaultContainer, "Checkout", defaultGetStuffFunction, new EdmPathExpression("path1", "path2"), false); VisitAndVerifyXml( (visitor) => { visitor.VisitEntityContainerElements(new IEdmEntityContainerElement[] { functionImportOnSet, functionImportOnSet2, functionmportWithNoEntitySet, functionImportWithUniqueEdmPath }); }, @"<FunctionImport Name=""Checkout"" Function=""Default.NameSpace2.GetStuff"" EntitySet=""Set"" /><FunctionImport Name=""Checkout"" Function=""Default.NameSpace2.GetStuff"" EntitySet=""Set2"" /><FunctionImport Name=""Checkout"" Function=""Default.NameSpace2.GetStuff"" /><FunctionImport Name=""Checkout"" Function=""Default.NameSpace2.GetStuff"" EntitySet=""path1/path2"" />"); }
public void ValidateEntitySetAtttributeCorrectlyWritesEntitySetPath() { EdmFunctionImport functionImport = new EdmFunctionImport(defaultContainer, "GetStuff", defaultGetStuffFunction, new EdmPathExpression("Customers", "Orders"), false); TestWriteFunctionImportElementHeaderMethod(functionImport, @"<FunctionImport Name=""GetStuff"" Function=""Default.NameSpace2.GetStuff"" EntitySet=""Customers/Orders"""); }
public void TryMatch_ReturnsFalse_IfDifferentUnboundFunctionWithSameParamerters() { // Arrange IEdmModel model = new Mock<IEdmModel>().Object; IEdmEntityType returnType = new Mock<IEdmEntityType>().Object; EdmEntityContainer container = new EdmEntityContainer("NS", "Container"); EdmFunction function = new EdmFunction("NS", "Function", new EdmEntityTypeReference(returnType, isNullable: false)); EdmFunctionImport functionImport1 = new EdmFunctionImport(container,"FunctionImport1", function); EdmFunctionImport functionImport2 = new EdmFunctionImport(container,"FunctionImport2", function); Dictionary<string, string> parameterValues = new Dictionary<string, string>() { { "Parameter1", "1" }, { "Parameter2", "2" } }; Dictionary<string, string> parameterMappings = new Dictionary<string, string>() { { "Parameter1", "{param1}" }, { "Parameter2", "{param2}" } }; UnboundFunctionPathSegment segment = new UnboundFunctionPathSegment(functionImport1, model, parameterValues); var template = new UnboundFunctionPathSegmentTemplate( new UnboundFunctionPathSegment(functionImport2, model, parameterMappings)); Dictionary<string, object> values = new Dictionary<string, object>(); // Act bool result = template.TryMatch(segment, values); // Assert Assert.False(result); }
public static EdmModel AnnotationWithInvalidTargetModel(EdmVocabularyAnnotationSerializationLocation location) { EdmModel model = VocabularyTestModelBuilder.SimpleModel(); var simpleTerm = model.FindValueTerm("Foo.SimpleTerm"); var entityTerm = model.FindValueTerm("Foo.EntityTerm"); var entityType = model.FindType("Foo.SimpleEntity") as EdmEntityType; var entityTypeProperty = entityType.FindProperty("Int32Value"); var invalidType = new EdmComplexType("Foo", "InvalidType"); var invalidTypeProperty = invalidType.AddStructuralProperty("InvalidValue", EdmCoreModel.Instance.GetString(true)); var invalidTerm = new EdmTerm("Foo", "InvalidTerm", EdmCoreModel.Instance.GetString(false)); var invalidEntitySet = new EdmEntitySet(new EdmEntityContainer("", ""), "InvalidEntitySet", entityType); var invalidFunction = new EdmFunction("Foo", "InvalidFunction", EdmCoreModel.Instance.GetInt32(true)); var invalidFunctionParameter = invalidFunction.AddParameter("InvalidParameter", EdmCoreModel.Instance.GetInt32(true)); model.AddElement(invalidFunction); var invalidFunctionImport = new EdmFunctionImport(new EdmEntityContainer("", ""), "InvalidFunctionImport", invalidFunction); EdmAnnotation valueAnnotationOnContainer = new EdmAnnotation( new EdmEntityContainer("", ""), simpleTerm, new EdmIntegerConstant(1)); valueAnnotationOnContainer.SetSerializationLocation(model, location); model.AddVocabularyAnnotation(valueAnnotationOnContainer); EdmAnnotation valueAnnotationOnEntitySet = new EdmAnnotation( invalidEntitySet, simpleTerm, new EdmIntegerConstant(1)); valueAnnotationOnEntitySet.SetSerializationLocation(model, location); model.AddVocabularyAnnotation(valueAnnotationOnEntitySet); EdmAnnotation valueAnnotationOnType = new EdmAnnotation( invalidType, simpleTerm, new EdmIntegerConstant(1)); valueAnnotationOnType.SetSerializationLocation(model, location); model.AddVocabularyAnnotation(valueAnnotationOnType); EdmAnnotation valueAnnotationOnProperty = new EdmAnnotation( invalidTypeProperty, simpleTerm, new EdmIntegerConstant(1)); valueAnnotationOnProperty.SetSerializationLocation(model, location); model.AddVocabularyAnnotation(valueAnnotationOnProperty); EdmAnnotation valueAnnotationOnTerm = new EdmAnnotation( invalidTerm, simpleTerm, new EdmIntegerConstant(1)); valueAnnotationOnTerm.SetSerializationLocation(model, location); model.AddVocabularyAnnotation(valueAnnotationOnTerm); EdmAnnotation valueAnnotationOnFunction = new EdmAnnotation( invalidFunction, simpleTerm, new EdmIntegerConstant(1)); valueAnnotationOnFunction.SetSerializationLocation(model, location); model.AddVocabularyAnnotation(valueAnnotationOnFunction); EdmAnnotation valueAnnotationOnParameter = new EdmAnnotation( invalidFunctionParameter, simpleTerm, new EdmIntegerConstant(1)); valueAnnotationOnParameter.SetSerializationLocation(model, location); model.AddVocabularyAnnotation(valueAnnotationOnParameter); EdmAnnotation valueAnnotationOnFunctionImport = new EdmAnnotation( invalidFunctionImport, simpleTerm, new EdmIntegerConstant(1)); valueAnnotationOnFunctionImport.SetSerializationLocation(model, location); model.AddVocabularyAnnotation(valueAnnotationOnFunctionImport); EdmAnnotation valueAnnotation = new EdmAnnotation( new EdmEntityContainer("", ""), entityTerm, new EdmRecordExpression(new EdmPropertyConstructor(entityTypeProperty.Name, new EdmIntegerConstant(1)))); valueAnnotation.SetSerializationLocation(model, location); model.AddVocabularyAnnotation(valueAnnotation); return model; }
/// <summary> /// Initializes a new <see cref="IEdmOperationImport"/> instance. /// </summary> /// <param name="name">name of the service operation.</param> /// <param name="function">Function imported in.</param> /// <param name="resultSet">EntitySet of the result expected from this operation.</param> public EdmFunctionImport AddFunctionImport(string name, IEdmFunction function, IEdmEntitySet resultSet, bool includeInServiceDocument) { var functionImport = new EdmFunctionImport(this, name, function, new EdmEntitySetReferenceExpression(resultSet), includeInServiceDocument); this.AddOperationImport(name, functionImport); return functionImport; }