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