public void NonPrimitiveIsXXXMethods()
{
IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "MyEntity");
IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false);
Assert.IsTrue(entityRef.IsEntity(), "Entity is Entity");
IEdmPrimitiveTypeReference bad = entityRef.AsPrimitive();
Assert.IsTrue(bad.Definition.IsBad(), "bad TypeReference is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, bad.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.IsTrue(bad.Definition.IsBad(), "Bad definition is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, bad.Definition.Errors().First().ErrorCode, "Definition is bad from conversion");
IEdmPrimitiveType intDef = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32);
IEdmPrimitiveTypeReference intRef = new EdmPrimitiveTypeReference(intDef, false);
IEdmCollectionTypeReference intCollection = new EdmCollectionTypeReference(new EdmCollectionType(intRef));
Assert.IsTrue(intCollection.IsCollection(), "Collection is collection");
IEdmComplexType complexDef = new EdmComplexType("MyNamespace", "MyComplex");
IEdmComplexTypeReference complexRef = new EdmComplexTypeReference(complexDef, false);
Assert.IsTrue(complexRef.IsComplex(), "Complex is Complex");
Assert.IsTrue(entityRef.IsStructured(), "Entity is Structured");
Assert.IsTrue(complexRef.IsStructured(), "Complex is stuctured");
Assert.IsFalse(intCollection.IsStructured(), "Collection is not structured");
}
public void CreateCollectionWriterWithEntityCollectionTypeShouldFail()
{
var writer = new ODataMessageWriter(new DummyRequestMessage());
var entityElementType = new EdmEntityTypeReference(new EdmEntityType("Fake", "Fake"), true);
Action createWriterWithEntityCollectionType = () => writer.CreateODataCollectionWriter(entityElementType);
createWriterWithEntityCollectionType.ShouldThrow<ODataException>().WithMessage(Strings.ODataMessageWriter_NonCollectionType("Fake.Fake"));
}
public void GetEdmType_Returns_EdmTypeInitializedByCtor()
{
IEdmEntityTypeReference _entityReferenceType = new EdmEntityTypeReference(new EdmEntityType("NS", "Entity"), isNullable: false);
var edmObject = new EdmDeltaCollectionType(_entityReferenceType);
Assert.Same(_entityReferenceType, edmObject.ElementType);
}
public void GetEdmType_Returns_EdmTypeInitializedByCtor()
{
IEdmTypeReference elementType = new EdmEntityTypeReference(new EdmEntityType("NS", "Entity"), isNullable: false);
IEdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType));
var edmObject = new EdmEntityObjectCollection(collectionType);
Assert.Same(collectionType, edmObject.GetEdmType());
}
private static void BuildFilterWithBinaryOperator()
{
var personTypeRef = new EdmEntityTypeReference(TripPinModel.Person, false);
var friendsProp = (IEdmNavigationProperty)TripPinModel.Person.FindProperty("Friends");
var firstNameProp = TripPinModel.Person.FindProperty("FirstName");
var lastNameProp = TripPinModel.Person.FindProperty("LastName");
var topIt = new EntityRangeVariable("$it", personTypeRef, TripPinModel.PeopleSet);
var topItRef = new EntityRangeVariableReferenceNode("$it", topIt);
var friendsNavNode = new CollectionNavigationNode(friendsProp, topItRef);
var e0 = new EntityRangeVariable("e0", personTypeRef, friendsNavNode);
var e0Ref = new EntityRangeVariableReferenceNode("e0", e0);
var fun1 = new SingleValueFunctionCallNode(
"startswith",
new QueryNode[]
{
new SingleValuePropertyAccessNode(e0Ref, firstNameProp),
new ConstantNode("var1", "'var1'")
},
EdmCoreModel.Instance.GetBoolean(false));
var friendsNavNode2 = new CollectionNavigationNode(friendsProp, e0Ref);
var e1 = new EntityRangeVariable("e1", personTypeRef, friendsNavNode2);
var e1Ref = new EntityRangeVariableReferenceNode("e1", e1);
var fun2 = new SingleValueFunctionCallNode(
"contains",
new QueryNode[]
{
new SingleValuePropertyAccessNode(e1Ref, lastNameProp),
new ConstantNode("var2", "'var2'")
},
EdmCoreModel.Instance.GetBoolean(false));
// Actually $it also needed, but would not be used in UriBuilder, so omit it here.
var any2 = new AnyNode(new Collection<RangeVariable> { e1 }, e1)
{
Body = fun2,
Source = friendsNavNode2
};
var any1 = new AnyNode(new Collection<RangeVariable> { e0 }, e0)
{
Body = new BinaryOperatorNode(BinaryOperatorKind.And, fun1, any2),
Source = friendsNavNode
};
var odataUri = new ODataUri
{
Path = new ODataPath(new EntitySetSegment(TripPinModel.PeopleSet)),
ServiceRoot = TripPinRoot,
Filter = new FilterClause(any1, topIt)
};
var builder = new ODataUriBuilder(ODataUrlConventions.Default, odataUri);
Console.WriteLine(builder.BuildUri());
// http://services.odata.org/V4/TripPinService/People?$filter=Friends%2Fany(
// e0:startswith(e0%2FFirstName%2C'var1') and e0%2FFriends%2Fany(e1:contains(e1%2FLastName%2C'var2')))
}
public void GetPropertyValue_ThrowsInvalidOperation_IfPropertyIsNotFound()
{
IEdmEntityTypeReference entityType = new EdmEntityTypeReference(new EdmEntityType("NS", "Name"), isNullable: false);
Mock<IEdmStructuredObject> edmObject = new Mock<IEdmStructuredObject>();
edmObject.Setup(o => o.GetEdmType()).Returns(entityType);
EntityInstanceContext instanceContext = new EntityInstanceContext(_serializerContext, entityType, edmObject.Object);
Assert.Throws<InvalidOperationException>(
() => instanceContext.GetPropertyValue("NotPresentProperty"),
"The EDM instance of type '[NS.Name Nullable=False]' is missing the property 'NotPresentProperty'.");
}
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 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);
}
private static void BuildOrderBy()
{
var productTypeRef = new EdmEntityTypeReference(V4Model.Product, false);
var supplierProperty = (IEdmNavigationProperty)V4Model.Product.FindProperty("Supplier");
var nameProperty = V4Model.Supplier.FindProperty("Name");
var topIt = new EntityRangeVariable("$it", productTypeRef, V4Model.ProductsSet);
var topItRef = new EntityRangeVariableReferenceNode("$it", topIt);
var supplierNavNode = new SingleNavigationNode(supplierProperty, topItRef);
var nameNode = new SingleValuePropertyAccessNode(supplierNavNode, nameProperty);
var orderby = new OrderByClause(null, nameNode, OrderByDirection.Ascending, topIt);
var odataUri = new ODataUri
{
Path = new ODataPath(new EntitySetSegment(V4Model.ProductsSet)),
ServiceRoot = V4Root,
OrderBy = orderby
};
var builder = new ODataUriBuilder(ODataUrlConventions.Default, odataUri);
Console.WriteLine(builder.BuildUri());
// http://services.odata.org/V4/OData/OData.svc/Products?$orderby=Supplier%2FName
}
/// <summary>
/// Deserializes the given <paramref name="entryWrapper"/> under the given <paramref name="readContext"/>.
/// </summary>
/// <param name="entryWrapper">The OData entry to deserialize.</param>
/// <param name="entityType">The entity type of the entry to deserialize.</param>
/// <param name="readContext">The deserializer context.</param>
/// <returns>The deserialized entity.</returns>
public virtual object ReadEntry(ODataEntryWithNavigationLinks entryWrapper, IEdmEntityTypeReference entityType,
ODataDeserializerContext readContext)
{
if (entryWrapper == null)
{
throw Error.ArgumentNull("entryWrapper");
}
if (readContext == null)
{
throw Error.ArgumentNull("readContext");
}
if (!String.IsNullOrEmpty(entryWrapper.Entry.TypeName) && entityType.FullName() != entryWrapper.Entry.TypeName)
{
// received a derived type in a base type deserializer. delegate it to the appropriate derived type deserializer.
IEdmModel model = readContext.Model;
if (model == null)
{
throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
}
IEdmEntityType actualType = model.FindType(entryWrapper.Entry.TypeName) as IEdmEntityType;
if (actualType == null)
{
throw new ODataException(Error.Format(SRResources.EntityTypeNotInModel, entryWrapper.Entry.TypeName));
}
if (actualType.IsAbstract)
{
string message = Error.Format(SRResources.CannotInstantiateAbstractEntityType, entryWrapper.Entry.TypeName);
throw new ODataException(message);
}
IEdmTypeReference actualEntityType = new EdmEntityTypeReference(actualType, isNullable: false);
ODataEdmTypeDeserializer deserializer = DeserializerProvider.GetEdmTypeDeserializer(actualEntityType);
if (deserializer == null)
{
throw new SerializationException(
Error.Format(SRResources.TypeCannotBeDeserialized, actualEntityType.FullName(), typeof(ODataMediaTypeFormatter).Name));
}
object resource = deserializer.ReadInline(entryWrapper, actualEntityType, readContext);
EdmStructuredObject structuredObject = resource as EdmStructuredObject;
if (structuredObject != null)
{
structuredObject.ExpectedEdmType = entityType.EntityDefinition();
}
return resource;
}
else
{
object resource = CreateEntityResource(entityType, readContext);
ApplyEntityProperties(resource, entryWrapper, entityType, readContext);
return resource;
}
}
static FullPayloadValidateTests()
{
EntityType = new EdmEntityType("Namespace", "EntityType", null, false, false, false);
EntityType.AddKeys(EntityType.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
EntityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(isNullable: true), null, EdmConcurrencyMode.Fixed);
DerivedType = new EdmEntityType("Namespace", "DerivedType", EntityType, false, true);
var expandedCollectionNavProp = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.Many,
Name = "ExpandedCollectionNavProp"
});
var expandedNavProp = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.One,
Name = "ExpandedNavProp"
});
EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.Many,
Name = "ContainedCollectionNavProp",
ContainsTarget = true
});
EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = EntityType,
TargetMultiplicity = EdmMultiplicity.One,
Name = "ContainedNavProp",
ContainsTarget = true
});
var container = new EdmEntityContainer("Namespace", "Container");
EntitySet = container.AddEntitySet("EntitySet", EntityType);
EntitySet.AddNavigationTarget(expandedNavProp, EntitySet);
EntitySet.AddNavigationTarget(expandedCollectionNavProp, EntitySet);
Model = new EdmModel();
Model.AddElement(EntityType);
Model.AddElement(DerivedType);
Model.AddElement(container);
ModelWithFunction = new EdmModel();
ModelWithFunction.AddElement(EntityType);
ModelWithFunction.AddElement(DerivedType);
ModelWithFunction.AddElement(container);
EdmEntityTypeReference entityTypeReference = new EdmEntityTypeReference(EntityType, false);
EdmCollectionTypeReference typeReference = new EdmCollectionTypeReference(new EdmCollectionType(entityTypeReference));
EdmFunction function = new EdmFunction("Namespace", "Function", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
function.AddParameter("bindingParameter", typeReference);
ModelWithFunction.AddElement(function);
EdmAction action = new EdmAction("Namespace", "Action", EdmCoreModel.Instance.GetBoolean(true), true, null);
action.AddParameter("bindingParameter", typeReference);
ModelWithFunction.AddElement(action);
}
private IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("NS", "Name");
model.AddElement(container);
var entityType = new EdmEntityType("NS", "EntityTypeName");
model.AddElement(entityType);
container.AddEntitySet("EntitySet", entityType);
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference parameterType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference stringType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false);
// unbound function without parameter
container.AddFunctionImport(new EdmFunction("NS", "FunctionWithoutParams", returnType));
// unbound function with one parameter
var functionWithOneParam = new EdmFunction("NS", "FunctionWithOneParam", returnType);
functionWithOneParam.AddParameter("Parameter", parameterType);
container.AddFunctionImport(functionWithOneParam);
// unbound function with multiple parameters
var functionWithMultipleParams = new EdmFunction("NS", "FunctionWithMultipleParams", returnType);
functionWithMultipleParams.AddParameter("Parameter1", parameterType);
functionWithMultipleParams.AddParameter("Parameter2", parameterType);
functionWithMultipleParams.AddParameter("Parameter3", parameterType);
container.AddFunctionImport(functionWithMultipleParams);
// unbound overload function
container.AddFunctionImport(new EdmFunction("NS", "FunctionWithOverloads", returnType));
var functionWithOverloads2 = new EdmFunction("NS", "FunctionWithOverloads", returnType);
functionWithOverloads2.AddParameter("Parameter", parameterType);
container.AddFunctionImport(functionWithOverloads2);
var functionWithOverloads3 = new EdmFunction("NS", "FunctionWithOverloads", returnType);
functionWithOverloads3.AddParameter("Parameter1", parameterType);
functionWithOverloads3.AddParameter("Parameter2", parameterType);
functionWithOverloads3.AddParameter("Parameter3", parameterType);
container.AddFunctionImport(functionWithOverloads3);
// bound function with only binding parameter
IEdmTypeReference bindingParamterType = new EdmEntityTypeReference(entityType, isNullable: false);
var boundFunction = new EdmFunction("NS", "BoundFunctionWithoutParams", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
model.AddElement(boundFunction);
// bound function with binding and one non-binding parameter
boundFunction = new EdmFunction("NS", "BoundFunctionWithOneParam", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("Parameter", parameterType);
model.AddElement(boundFunction);
// bound function with binding and multiple non-binding parameters
boundFunction = new EdmFunction("NS", "BoundFunctionWithMultipleParams", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("Parameter1", parameterType);
boundFunction.AddParameter("Parameter2", parameterType);
boundFunction.AddParameter("Parameter3", parameterType);
model.AddElement(boundFunction);
// bound overload function with only binding parameter
boundFunction = new EdmFunction("NS", "BoundFunctionOverload", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
model.AddElement(boundFunction);
// bound overload function with binding and one non-binding parameter
boundFunction = new EdmFunction("NS", "BoundFunctionOverload", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("Parameter", parameterType);
model.AddElement(boundFunction);
// bound overload function with binding and multiple non-binding parameters
boundFunction = new EdmFunction("NS", "BoundFunctionOverload", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("Parameter1", parameterType);
boundFunction.AddParameter("Parameter2", parameterType);
boundFunction.AddParameter("Parameter3", parameterType);
model.AddElement(boundFunction);
// the following two bound functions have the same function name, same binding type and the same parameter name,
// but the non-binding parameter type is different.
boundFunction = new EdmFunction("NS", "BoundOverloadFailed", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("FunctionParameter", parameterType);
model.AddElement(boundFunction);
boundFunction = new EdmFunction("NS", "BoundOverloadFailed", returnType, true, null, true);
boundFunction.AddParameter("bindingParameter", bindingParamterType);
boundFunction.AddParameter("FunctionParameter", stringType);
model.AddElement(boundFunction);
// the following two unbound functions have the same function name and the same parameter name,
// but the parameter type is different.
var function = new EdmFunction("NS", "UnboundOverloadFailed", returnType);
function.AddParameter("FunctionParameter", parameterType);
container.AddFunctionImport(function);
function = new EdmFunction("NS", "UnboundOverloadFailed", returnType);
function.AddParameter("FunctionParameter", stringType);
container.AddFunctionImport(function);
return model;
}
private static IList<IEdmFunction> EdmOperationsWithNamedStructuralDataType(IEdmModel model)
{
var complexTypes = model.SchemaElements.OfType<IEdmComplexType>();
var testData = new List<IEdmFunction>();
int index = 0;
var getName = new Func<string, string>((n) => n + (++index).ToString());
var functions = complexTypes.Select(t =>
{
var typeReference = new EdmComplexTypeReference(t, true);
var function = new EdmFunction(DefaultNamespaceName, getName("FunctionsWithNamedStructuralDataType"), typeReference);
function.AddParameter(getName("ComplexTypeParameter"), typeReference);
return function;
});
foreach (var edmFunction in functions)
{
testData.Add(edmFunction);
}
var entityTypes = model.SchemaElements.OfType<IEdmEntityType>();
functions = entityTypes.Select(t =>
{
var typeReference = new EdmEntityTypeReference(t, false);
var function = new EdmFunction(DefaultNamespaceName, getName("FunctionsWithNamedStructuralDataType"), typeReference);
function.AddParameter(getName("EntityTypeParameter"), typeReference);
return function;
});
foreach (var edmFunction in functions)
{
testData.Add(edmFunction);
}
return testData;
}
private static void GetModel(out IEdmModel model, out IEdmEntityTypeReference reference)
{
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock<ODataConventionModelBuilder>();
EntityTypeConfiguration<TestEntity> entity = builder.EntityType<TestEntity>();
entity.Namespace = "Test";
entity.Name = "Entity";
NavigationPropertyConfiguration property = entity.HasOptional(p => p.Property);
property.Name = "Alias";
model = builder.GetEdmModel();
reference = new EdmEntityTypeReference((IEdmEntityType)model.FindType("Test.Entity"), false);
}
private static IEdmModel GetUnTypedEdmModel()
{
EdmModel model = new EdmModel();
// Enum type "Color"
EdmEnumType colorEnum = new EdmEnumType("NS", "Color");
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Red", new EdmIntegerConstant(0)));
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Blue", new EdmIntegerConstant(1)));
colorEnum.AddMember(new EdmEnumMember(colorEnum, "Green", new EdmIntegerConstant(2)));
model.AddElement(colorEnum);
// complex type "Address"
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String);
model.AddElement(address);
// derived complex type "SubAddress"
EdmComplexType subAddress = new EdmComplexType("NS", "SubAddress", address);
subAddress.AddStructuralProperty("Code", EdmPrimitiveTypeKind.Double);
model.AddElement(subAddress);
// entity type "Customer"
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
customer.AddStructuralProperty("Location", new EdmComplexTypeReference(address, isNullable: true));
model.AddElement(customer);
// derived entity type special customer
EdmEntityType specialCustomer = new EdmEntityType("NS", "SpecialCustomer", customer);
specialCustomer.AddStructuralProperty("Title", EdmPrimitiveTypeKind.Guid);
model.AddElement(specialCustomer);
// entity sets
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
model.AddElement(container);
container.AddEntitySet("FCustomers", customer);
EdmComplexTypeReference complexType = new EdmComplexTypeReference(address, isNullable: false);
EdmCollectionTypeReference complexCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(complexType));
EdmEnumTypeReference enumType = new EdmEnumTypeReference(colorEnum, isNullable: false);
EdmCollectionTypeReference enumCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(enumType));
EdmEntityTypeReference entityType = new EdmEntityTypeReference(customer, isNullable: false);
EdmCollectionTypeReference entityCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(entityType));
IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: true);
EdmCollectionTypeReference primitiveCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(intType));
// bound functions
BoundFunction(model, "IntCollectionFunction", "intValues", primitiveCollectionType, entityType);
BoundFunction(model, "ComplexFunction", "address", complexType, entityType);
BoundFunction(model, "ComplexCollectionFunction", "addresses", complexCollectionType, entityType);
BoundFunction(model, "EnumFunction", "color", enumType, entityType);
BoundFunction(model, "EnumCollectionFunction", "colors", enumCollectionType, entityType);
BoundFunction(model, "EntityFunction", "customer", entityType, entityType);
BoundFunction(model, "CollectionEntityFunction", "customers", entityCollectionType, entityType);
// unbound functions
UnboundFunction(container, "UnboundIntCollectionFunction", "intValues", primitiveCollectionType);
UnboundFunction(container, "UnboundComplexFunction", "address", complexType);
UnboundFunction(container, "UnboundComplexCollectionFunction", "addresses", complexCollectionType);
UnboundFunction(container, "UnboundEnumFunction", "color", enumType);
UnboundFunction(container, "UnboundEnumCollectionFunction", "colors", enumCollectionType);
UnboundFunction(container, "UnboundEntityFunction", "customer", entityType);
UnboundFunction(container, "UnboundCollectionEntityFunction", "customers", entityCollectionType);
model.SetAnnotationValue<BindableProcedureFinder>(model, new BindableProcedureFinder(model));
return model;
}
public void ToDictionary_ContainsAllStructuralProperties_IfInstanceIsNotNull()
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "Name");
model.AddElement(entityType);
model.SetAnnotationValue(entityType, new ClrTypeAnnotation(typeof(TestEntity)));
entityType.AddStructuralProperty("SampleProperty", EdmPrimitiveTypeKind.Int32);
IEdmTypeReference edmType = new EdmEntityTypeReference(entityType, isNullable: false);
SelectExpandWrapper<TestEntity> testWrapper = new SelectExpandWrapper<TestEntity>
{
Instance = new TestEntity { SampleProperty = 42 },
ModelID = ModelContainer.GetModelID(model)
};
// Act
var result = testWrapper.ToDictionary();
// Assert
Assert.Equal(42, result["SampleProperty"]);
}
public void WriteObjectInline_Can_WriteCollectionOfIEdmObjects()
{
// Arrange
IEdmTypeReference edmType = new EdmEntityTypeReference(new EdmEntityType("NS", "Name"), isNullable: false);
IEdmCollectionTypeReference feedType = new EdmCollectionTypeReference(new EdmCollectionType(edmType));
Mock<IEdmObject> edmObject = new Mock<IEdmObject>();
edmObject.Setup(e => e.GetEdmType()).Returns(edmType);
var mockWriter = new Mock<ODataWriter>();
Mock<ODataEdmTypeSerializer> customSerializer = new Mock<ODataEdmTypeSerializer>(ODataPayloadKind.Entry);
customSerializer.Setup(s => s.WriteObjectInline(edmObject.Object, edmType, mockWriter.Object, _writeContext)).Verifiable();
Mock<ODataSerializerProvider> serializerProvider = new Mock<ODataSerializerProvider>();
serializerProvider.Setup(s => s.GetEdmTypeSerializer(edmType)).Returns(customSerializer.Object);
ODataFeedSerializer serializer = new ODataFeedSerializer(serializerProvider.Object);
// Act
serializer.WriteObjectInline(new[] { edmObject.Object }, feedType, mockWriter.Object, _writeContext);
// Assert
customSerializer.Verify();
}
public void GetDefaultValue_NonNullableEntityCollection()
{
IEdmTypeReference elementType = new EdmEntityTypeReference(new EdmEntityType("NS", "Entity"), isNullable: true);
IEdmCollectionTypeReference entityCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType));
var result = EdmStructuredObject.GetDefaultValue(entityCollectionType);
var entityCollectionObject = Assert.IsType<EdmEntityObjectCollection>(result);
Assert.Equal(entityCollectionType, entityCollectionObject.GetEdmType(), new EdmTypeReferenceEqualityComparer());
}
public void ConstructableTypeReferenceToStringTest()
{
IEdmEntityType astonishing = new EdmEntityType("AwesomeNamespace", "AstonishingEntity", null, false, false);
IEdmComplexType breathTaking = new EdmComplexType("AwesomeNamespace", "BreathtakingComplex", null, false);
IEdmEntityTypeReference entity = new EdmEntityTypeReference(astonishing, true);
IEdmComplexTypeReference complex = new EdmComplexTypeReference(breathTaking, true);
IEdmPrimitiveTypeReference primitive = EdmCoreModel.Instance.GetInt32(true);
IEdmStringTypeReference stringType = EdmCoreModel.Instance.GetString(false, 128, false, true);
IEdmBinaryTypeReference binary = EdmCoreModel.Instance.GetBinary(true, null, true);
IEdmTemporalTypeReference temporal = EdmCoreModel.Instance.GetTemporal(EdmPrimitiveTypeKind.DateTimeOffset, 1, true);
IEdmDecimalTypeReference decimalType = EdmCoreModel.Instance.GetDecimal(3, 2, true);
IEdmSpatialTypeReference spatial = EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.Geography, 1, true);
IEdmEntityReferenceTypeReference entityRef = new EdmEntityReferenceTypeReference(new EdmEntityReferenceType(astonishing), true);
IEdmCollectionTypeReference collection = EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt32(true));
IEdmTypeReference type = new EdmEntityTypeReference(astonishing, true);
Assert.AreEqual("[AwesomeNamespace.AstonishingEntity Nullable=True]", entity.ToString(), "To string correct");
Assert.AreEqual("[AwesomeNamespace.BreathtakingComplex Nullable=True]", complex.ToString(), "To string correct");
Assert.AreEqual("[Edm.Int32 Nullable=True]", primitive.ToString(), "To string correct");
Assert.AreEqual("[Edm.String Nullable=True MaxLength=128 Unicode=False]", stringType.ToString(), "To string correct");
Assert.AreEqual("[Edm.Binary Nullable=True MaxLength=max]", binary.ToString(), "To string correct");
Assert.AreEqual("[Edm.DateTimeOffset Nullable=True Precision=1]", temporal.ToString(), "To string correct");
Assert.AreEqual("[Edm.Decimal Nullable=True Precision=3 Scale=2]", decimalType.ToString(), "To string correct");
Assert.AreEqual("[Edm.Geography Nullable=True SRID=1]", spatial.ToString(), "To string correct");
Assert.AreEqual("[Collection([Edm.Int32 Nullable=True]) Nullable=True]", collection.ToString(), "To string correct");
Assert.AreEqual("[EntityReference(AwesomeNamespace.AstonishingEntity) Nullable=True]", entityRef.ToString(), "To string correct");
Assert.AreEqual("[AwesomeNamespace.AstonishingEntity Nullable=True]", type.ToString(), "To string correct");
}
public void ExerciseBadtypes()
{
IEdmModel model = new EdmModel();
IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "BadEntity");
IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false);
IEdmComplexType complexDef = new EdmComplexType("MyNamespace", "BadComplex");
IEdmComplexTypeReference complexRef = new EdmComplexTypeReference(complexDef, false);
IEdmCollectionTypeReference badCollectionRef = entityRef.AsCollection();
IEdmEntityTypeReference badEntityRef = complexRef.AsEntity();
IEdmComplexTypeReference badComplexRef = entityRef.AsComplex();
IEdmEntityReferenceTypeReference badEntityRefRef = entityRef.AsEntityReference();
IEdmPrimitiveTypeReference badTemporal = entityRef.AsTemporal();
IEdmPrimitiveTypeReference badDecimal = entityRef.AsDecimal();
IEdmPrimitiveTypeReference badString = entityRef.AsString();
IEdmPrimitiveTypeReference badSpatial = entityRef.AsSpatial();
IEdmPrimitiveTypeReference badBinary = entityRef.AsBinary();
IEdmPrimitiveTypeReference badPrimitive = entityRef.AsPrimitive();
IEdmEnumTypeReference badEnum = entityRef.AsEnum();
Assert.IsTrue(badCollectionRef.IsCollection(), "Bad collection is collection");
Assert.IsTrue(badEntityRef.IsEntity(), "Bad Entity is Entity");
Assert.AreEqual(0, badEntityRef.Key().Count(), "Bad Entity has no key");
Assert.AreEqual("MyNamespace.BadComplex", badEntityRef.FullName(), "Bad named refs keep name");
Assert.AreEqual(EdmSchemaElementKind.TypeDefinition, badEntityRef.EntityDefinition().SchemaElementKind, "Bad named type definitions are still type definitions");
Assert.IsNull(badEntityRef.EntityDefinition().BaseType, "Bad Entity has no base type");
Assert.AreEqual(Enumerable.Empty<IEdmProperty>(), badEntityRef.EntityDefinition().DeclaredProperties, "Bad structured types have no properties");
Assert.IsFalse(badEntityRef.EntityDefinition().IsAbstract, "Bad structured types are not abstract");
Assert.IsFalse(badEntityRef.EntityDefinition().IsOpen, "Bad structured types are not open");
model.SetAnnotationValue(badEntityRef.Definition, "foo", "bar", new EdmStringConstant(new EdmStringTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), false), "baz"));
Assert.AreEqual(1, model.DirectValueAnnotations(badEntityRef.Definition).Count(), "Bad Entity can hold annotations");
Assert.IsNotNull(model.GetAnnotationValue(badEntityRef.Definition, "foo", "bar"), "Bad Entity can find annotations");
Assert.AreEqual(EdmTermKind.Type, badEntityRef.EntityDefinition().TermKind, "EntityType has correct term kind");
Assert.IsTrue(badComplexRef.IsComplex(), "Bad Complex is Bad");
Assert.IsNull(badComplexRef.ComplexDefinition().FindProperty("PropertyName"), "Bad structured types return null for find property");
Assert.AreEqual(EdmTypeKind.EntityReference, badEntityRefRef.TypeKind(), "Bad Entity Reference is Entity Reference");
Assert.AreEqual(String.Empty, badEntityRefRef.EntityType().Name, "Bad Entity Reference has empty named EntityType");
model.SetAnnotationValue(badEntityRefRef.Definition, "foo", "bar", new EdmStringConstant(new EdmStringTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), false), "baz"));
Assert.AreEqual(1, model.DirectValueAnnotations(badEntityRefRef.Definition).Count(), "Bad Entity Reference can hold annotations");
Assert.IsNotNull(model.GetAnnotationValue(badEntityRefRef.Definition, "foo", "bar"), "Bad Entity Reference can find annotations");
Assert.AreEqual(EdmPrimitiveTypeKind.None, badPrimitive.PrimitiveKind(), "Bad Primitive has no primitive kind");
Assert.AreEqual(EdmTypeKind.Primitive, badPrimitive.TypeKind(), "Bad Primitive has primitive type kind");
Assert.AreEqual(EdmSchemaElementKind.TypeDefinition, badPrimitive.PrimitiveDefinition().SchemaElementKind, "Bad Primitive is still Type Definition");
Assert.AreEqual("BadEntity", badPrimitive.PrimitiveDefinition().Name, "Bad Primitive retains name");
Assert.AreEqual("MyNamespace", badPrimitive.PrimitiveDefinition().Namespace, "Bad Primitive retains namespace name");
Assert.AreEqual(EdmTypeKind.Enum, badEnum.TypeKind(), "Bad enum has right kind.");
Assert.AreEqual(EdmPrimitiveTypeKind.Int32, badEnum.EnumDefinition().UnderlyingType.PrimitiveKind, "Underlying type has correct kind.");
Assert.AreEqual(0, badEnum.EnumDefinition().Members.Count(), "bad enum has no members.");
Assert.AreEqual(false, badEnum.EnumDefinition().IsFlags, "bad enum not treated as bits.");
Assert.AreEqual(EdmSchemaElementKind.TypeDefinition, badEnum.EnumDefinition().SchemaElementKind, "bad enum is type definition.");
Assert.AreEqual("BadEntity", badEnum.EnumDefinition().Name, "Bad enum retains name");
Assert.AreEqual("MyNamespace", badEnum.EnumDefinition().Namespace, "Bad enum retains namespace name");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badSpatial.Definition.Errors().First().ErrorCode, "Bad spatial has correct error code.");
}
public void PrimitiveAsXXXMethods()
{
IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "BadEntity");
IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false);
IEdmTemporalTypeReference badTemporal = entityRef.AsTemporal();
IEdmDecimalTypeReference badDecimal = entityRef.AsDecimal();
IEdmStringTypeReference badString = entityRef.AsString();
IEdmPrimitiveTypeReference badStream = entityRef.AsPrimitive();
IEdmBinaryTypeReference badBinary = entityRef.AsBinary();
IEdmSpatialTypeReference badSpatial = entityRef.AsSpatial();
IEdmPrimitiveTypeReference badPrimitive = entityRef.AsPrimitive();
Assert.IsTrue(badTemporal.IsBad(), "Bad Temporal is Bad");
Assert.IsTrue(badTemporal.Definition.IsBad(), "Bad Temporal Definition is Bad");
Assert.AreEqual(EdmErrorCode.InterfaceCriticalKindValueMismatch, badTemporal.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badTemporal.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.BadEntity Nullable=False]", badTemporal.ToString(), "Correct tostring");
Assert.IsTrue(badDecimal.IsBad(), "Bad Decimal is Bad");
Assert.IsTrue(badDecimal.Definition.IsBad(), "Bad Decimal definition is Bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badDecimal.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.BadEntity Nullable=False]", badDecimal.ToString(), "Correct tostring");
Assert.IsTrue(badString.IsBad(), "Bad String is Bad");
Assert.IsTrue(badString.Definition.IsBad(), "Bad String Definition is Bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badString.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.BadEntity Nullable=False Unicode=False]", badString.ToString(), "Correct tostring");
Assert.IsTrue(badStream.IsBad(), "Bad Stream is Bad");
Assert.IsTrue(badStream.Definition.IsBad(), "Bad Stream Definition is Bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badStream.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.BadEntity Nullable=False]", badStream.ToString(), "Correct tostring");
Assert.IsTrue(badBinary.IsBad(), "Bad Binary is Bad");
Assert.IsTrue(badBinary.Definition.IsBad(), "Bad Binary Definition is Bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badBinary.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.BadEntity Nullable=False]", badBinary.ToString(), "Correct tostring");
Assert.IsTrue(badSpatial.IsBad(), "Bad Spatial is Bad");
Assert.IsTrue(badSpatial.Definition.IsBad(), "Bad Spatial Definition is Bad");
Assert.AreEqual(EdmErrorCode.InterfaceCriticalKindValueMismatch, badSpatial.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badSpatial.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.BadEntity Nullable=False]", badSpatial.ToString(), "Correct tostring");
Assert.IsTrue(badPrimitive.IsBad(), "Bad Primitive is Bad");
Assert.IsTrue(badPrimitive.Definition.IsBad(), "Bad Primitive Definition is Bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badPrimitive.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.BadEntity Nullable=False]", badPrimitive.ToString(), "Correct tostring");
}
public void NonPrimitiveAsXXXMethods()
{
IEdmPrimitiveType intDef = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32);
IEdmPrimitiveTypeReference intRef = new EdmPrimitiveTypeReference(intDef, false);
IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "MyEntity");
IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false);
IEdmComplexType complexDef = new EdmComplexType("MyNamespace", "MyComplex");
IEdmComplexTypeReference complexRef = new EdmComplexTypeReference(complexDef, false);
IEdmCollectionType collectionDef = new EdmCollectionType(intRef);
IEdmCollectionTypeReference collectionRef = new EdmCollectionTypeReference(collectionDef);
IEdmCollectionTypeReference badCollectionRef = entityRef.AsCollection();
IEdmEntityTypeReference badEntityRef = collectionRef.AsEntity();
IEdmComplexTypeReference badComplexRef = entityRef.AsComplex();
IEdmEntityReferenceTypeReference badEntityRefRef= entityRef.AsEntityReference();
Assert.IsTrue(badCollectionRef.IsBad(), "Bad Collection is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badCollectionRef.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("[Collection([UnknownType Nullable=True]) Nullable=True]", badCollectionRef.ToString(), "Correct tostring");
Assert.IsTrue(badComplexRef.IsBad(), "Bad Complex is Bad");
Assert.IsTrue(badComplexRef.Definition.IsBad(), "Bad Complex definition is Bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badComplexRef.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.MyEntity Nullable=False]", badComplexRef.ToString(), "Correct tostring");
Assert.IsTrue(badEntityRef.IsBad(), "Bad Entity is bad");
Assert.IsTrue(badEntityRef.Definition.IsBad(), "Bad Entity Definition is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badEntityRef.Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[Collection(Edm.Int32) Nullable=False]", badEntityRef.ToString(), "Correct tostring");
Assert.IsTrue(badEntityRefRef.IsBad(), "Bad Entity Reference is Bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badEntityRefRef.Errors().First().ErrorCode, "Reference is bad from conversion");
Assert.AreEqual("[EntityReference(.) Nullable=False]", badEntityRefRef.ToString(), "Correct tostring");
Assert.IsFalse(entityRef.AsEntity().IsBad(), "Entity converted to Entity is good");
Assert.IsFalse(complexRef.AsComplex().IsBad(), "Complex converted to complex is good");
Assert.IsFalse(collectionRef.AsCollection().IsBad(), "Collection converted to collection is good");
Assert.IsTrue(entityRef.AsStructured().IsEntity(), "Entity as structured is entity");
Assert.IsFalse(entityRef.AsStructured().IsBad(), "Entity as structured is good");
Assert.IsTrue(complexRef.AsStructured().IsComplex(), "Complex as structured is complex");
Assert.IsFalse(complexRef.AsStructured().IsBad(), "Complex as structured is good");
Assert.IsFalse(collectionRef.AsStructured().IsCollection(), "Collection as structured is not collection");
Assert.IsTrue(collectionRef.AsStructured().IsBad(), "Collection as structured is bad");
Assert.IsTrue(collectionRef.AsStructured().Definition.IsBad(), "Collection as structured definition is bad");
Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, collectionRef.AsStructured().Definition.Errors().First().ErrorCode, "Reference is bad from conversion");
}
private static IEdmActionImport AddUnboundAction(EdmEntityContainer container, string name, IEdmEntityType bindingType, bool isCollection)
{
var action = new EdmAction(
container.Namespace, name, returnType: null, isBound: true, entitySetPathExpression: null);
IEdmTypeReference bindingParamterType = new EdmEntityTypeReference(bindingType, isNullable: false);
if (isCollection)
{
bindingParamterType = new EdmCollectionTypeReference(new EdmCollectionType(bindingParamterType));
}
action.AddParameter("bindingParameter", bindingParamterType);
var actionImport = container.AddActionImport(action);
return actionImport;
}
internal static IEdmModel GetEdmModel()
{
var model = new EdmModel();
#region Type Definitions
var FullyQualifiedNamespaceIdType = new EdmTypeDefinition("Fully.Qualified.Namespace", "IdType", EdmPrimitiveTypeKind.Double);
var FullyQualifiedNamespaceIdTypeReference = new EdmTypeDefinitionReference(FullyQualifiedNamespaceIdType, false);
model.AddElement(FullyQualifiedNamespaceIdType);
var FullyQualifiedNamespaceNameType = new EdmTypeDefinition("Fully.Qualified.Namespace", "NameType", EdmPrimitiveTypeKind.String);
var FullyQualifiedNamespaceNameTypeReference = new EdmTypeDefinitionReference(FullyQualifiedNamespaceNameType, false);
model.AddElement(FullyQualifiedNamespaceNameType);
var FullyQualifiedNamespaceUInt16Reference = model.GetUInt16("Fully.Qualified.Namespace", false);
var FullyQualifiedNamespaceUInt32Reference = model.GetUInt32("Fully.Qualified.Namespace", false);
var FullyQualifiedNamespaceUInt64Reference = model.GetUInt64("Fully.Qualified.Namespace", false);
#endregion
#region Enum Types
var colorType = new EdmEnumType("Fully.Qualified.Namespace", "ColorPattern", EdmPrimitiveTypeKind.Int64, true);
colorType.AddMember("Red", new EdmIntegerConstant(1L));
colorType.AddMember("Blue", new EdmIntegerConstant(2L));
colorType.AddMember("Yellow", new EdmIntegerConstant(4L));
colorType.AddMember("Solid", new EdmIntegerConstant(8L));
colorType.AddMember("Striped", new EdmIntegerConstant(16L));
colorType.AddMember("SolidRed", new EdmIntegerConstant(9L));
colorType.AddMember("SolidBlue", new EdmIntegerConstant(10L));
colorType.AddMember("SolidYellow", new EdmIntegerConstant(12L));
colorType.AddMember("RedBlueStriped", new EdmIntegerConstant(19L));
colorType.AddMember("RedYellowStriped", new EdmIntegerConstant(21L));
colorType.AddMember("BlueYellowStriped", new EdmIntegerConstant(22L));
model.AddElement(colorType);
var colorTypeReference = new EdmEnumTypeReference(colorType, false);
var nullableColorTypeReference = new EdmEnumTypeReference(colorType, true);
var NonFlagShapeType = new EdmEnumType("Fully.Qualified.Namespace", "NonFlagShape", EdmPrimitiveTypeKind.SByte, false);
NonFlagShapeType.AddMember("Rectangle", new EdmIntegerConstant(1));
NonFlagShapeType.AddMember("Triangle", new EdmIntegerConstant(2));
NonFlagShapeType.AddMember("foursquare", new EdmIntegerConstant(3));
model.AddElement(NonFlagShapeType);
#endregion
#region Structured Types
var FullyQualifiedNamespacePerson = new EdmEntityType("Fully.Qualified.Namespace", "Person", null, false, false);
var FullyQualifiedNamespaceEmployee = new EdmEntityType("Fully.Qualified.Namespace", "Employee", FullyQualifiedNamespacePerson, false, false);
var FullyQualifiedNamespaceManager = new EdmEntityType("Fully.Qualified.Namespace", "Manager", FullyQualifiedNamespaceEmployee, false, false);
var FullyQualifiedNamespaceOpenEmployee = new EdmEntityType("Fully.Qualified.Namespace", "OpenEmployee", FullyQualifiedNamespaceEmployee, false, true);
var FullyQualifiedNamespaceDog = new EdmEntityType("Fully.Qualified.Namespace", "Dog", null, false, false);
var FullyQualifiedNamespaceLion = new EdmEntityType("Fully.Qualified.Namespace", "Lion", null, false, false);
var FullyQualifiedNamespaceChimera = new EdmEntityType("Fully.Qualified.Namespace", "Chimera", null, false, true);
var FullyQualifiedNamespacePainting = new EdmEntityType("Fully.Qualified.Namespace", "Painting", null, false, true);
var FullyQualifiedNamespaceFramedPainting = new EdmEntityType("Fully.Qualified.Namespace", "FramedPainting", FullyQualifiedNamespacePainting, false, true);
var FullyQualifiedNamespaceUserAccount = new EdmEntityType("Fully.Qualified.Namespace", "UserAccount", null, false, false);
var FullyQualifiedNamespacePet1 = new EdmEntityType("Fully.Qualified.Namespace", "Pet1", null, false, false);
var FullyQualifiedNamespacePet2 = new EdmEntityType("Fully.Qualified.Namespace", "Pet2", null, false, false);
var FullyQualifiedNamespacePet3 = new EdmEntityType("Fully.Qualified.Namespace", "Pet3", null, false, false);
var FullyQualifiedNamespacePet4 = new EdmEntityType("Fully.Qualified.Namespace", "Pet4", null, false, false);
var FullyQualifiedNamespacePet5 = new EdmEntityType("Fully.Qualified.Namespace", "Pet5", null, false, false);
var FullyQualifiedNamespacePet6 = new EdmEntityType("Fully.Qualified.Namespace", "Pet6", null, false, false);
var FullyQualifiedNamespaceAddress = new EdmComplexType("Fully.Qualified.Namespace", "Address");
var FullyQualifiedNamespaceOpenAddress = new EdmComplexType("Fully.Qualified.Namespace", "OpenAddress", null, false, true);
var FullyQualifiedNamespaceHomeAddress = new EdmComplexType("Fully.Qualified.Namespace", "HomeAddress", FullyQualifiedNamespaceAddress);
var FullyQualifiedNamespacePersonTypeReference = new EdmEntityTypeReference(FullyQualifiedNamespacePerson, true);
var FullyQualifiedNamespaceEmployeeTypeReference = new EdmEntityTypeReference(FullyQualifiedNamespaceEmployee, true);
var FullyQualifiedNamespaceManagerTypeReference = new EdmEntityTypeReference(FullyQualifiedNamespaceManager, true);
var FullyQualifiedNamespaceOpenEmployeeTypeReference = new EdmEntityTypeReference(FullyQualifiedNamespaceOpenEmployee, true);
var FullyQualifiedNamespaceDogTypeReference = new EdmEntityTypeReference(FullyQualifiedNamespaceDog, true);
var FullyQualifiedNamespaceLionTypeReference = new EdmEntityTypeReference(FullyQualifiedNamespaceLion, true);
var FullyQualifiedNamespacePet1TypeReference = new EdmEntityTypeReference(FullyQualifiedNamespacePet1, true);
var FullyQualifiedNamespacePet2TypeReference = new EdmEntityTypeReference(FullyQualifiedNamespacePet2, true);
var FullyQualifiedNamespacePet3TypeReference = new EdmEntityTypeReference(FullyQualifiedNamespacePet3, true);
var FullyQualifiedNamespacePet4TypeReference = new EdmEntityTypeReference(FullyQualifiedNamespacePet4, true);
var FullyQualifiedNamespacePet5TypeReference = new EdmEntityTypeReference(FullyQualifiedNamespacePet5, true);
var FullyQualifiedNamespacePet6TypeReference = new EdmEntityTypeReference(FullyQualifiedNamespacePet6, true);
var FullyQualifiedNamespacePaintingTypeReference = new EdmEntityTypeReference(FullyQualifiedNamespacePainting, true);
var FullyQualifiedNamespaceFramedPaintingTypeReference = new EdmEntityTypeReference(FullyQualifiedNamespaceFramedPainting, true);
var FullyQualifiedNamespaceUserAccountTypeReference = new EdmEntityTypeReference(FullyQualifiedNamespaceUserAccount, true);
var FullyQualifiedNamespaceLion_ID1 = FullyQualifiedNamespaceLion.AddStructuralProperty("ID1", EdmCoreModel.Instance.GetInt32(false));
var FullyQualifiedNamespaceLion_ID2 = FullyQualifiedNamespaceLion.AddStructuralProperty("ID2", EdmCoreModel.Instance.GetInt32(false));
FullyQualifiedNamespaceLion.AddStructuralProperty("AngerLevel", EdmCoreModel.Instance.GetDouble(true));
FullyQualifiedNamespaceLion.AddStructuralProperty("AttackDates", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetDateTimeOffset(true))));
FullyQualifiedNamespaceLion.AddKeys(new IEdmStructuralProperty[] { FullyQualifiedNamespaceLion_ID1, FullyQualifiedNamespaceLion_ID2, });
model.AddElement(FullyQualifiedNamespaceLion);
var FullyQualifiedNamespaceAddressTypeReference = new EdmComplexTypeReference(FullyQualifiedNamespaceAddress, true);
var FullyQualifiedNamespaceOpenAddressTypeReference = new EdmComplexTypeReference(FullyQualifiedNamespaceOpenAddress, true);
var FullyQualifiedNamespacePerson_ID = FullyQualifiedNamespacePerson.AddStructuralProperty("ID", EdmCoreModel.Instance.GetInt32(false));
var FullyQualifiedNamespacePerson_SSN = FullyQualifiedNamespacePerson.AddStructuralProperty("SSN", EdmCoreModel.Instance.GetString(true));
FullyQualifiedNamespacePerson.AddStructuralProperty("Shoe", EdmCoreModel.Instance.GetString(true));
FullyQualifiedNamespacePerson.AddStructuralProperty("GeographyPoint", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeographyPoint, true));
FullyQualifiedNamespacePerson.AddStructuralProperty("GeographyLineString", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeographyLineString, true));
FullyQualifiedNamespacePerson.AddStructuralProperty("GeographyPolygon", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeographyPolygon, true));
FullyQualifiedNamespacePerson.AddStructuralProperty("GeometryPoint", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeometryPoint, true));
FullyQualifiedNamespacePerson.AddStructuralProperty("GeometryLineString", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeometryLineString, true));
FullyQualifiedNamespacePerson.AddStructuralProperty("GeometryPolygon", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeometryPolygon, true));
FullyQualifiedNamespacePerson.AddStructuralProperty("GeographyCollection", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeographyPoint, true))));
FullyQualifiedNamespacePerson.AddStructuralProperty("GeometryCollection", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeometryPoint, true))));
var FullyQualifiedNamespacePerson_Name = FullyQualifiedNamespacePerson.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
var FullyQualifiedNamespacePerson_FirstName = FullyQualifiedNamespacePerson.AddStructuralProperty("FirstName", FullyQualifiedNamespaceNameTypeReference);
FullyQualifiedNamespacePerson.AddStructuralProperty("Prop.With.Periods", EdmCoreModel.Instance.GetString(true));
FullyQualifiedNamespacePerson.AddStructuralProperty("MyDate", EdmCoreModel.Instance.GetDate(false));
FullyQualifiedNamespacePerson.AddStructuralProperty("MyDates", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetDate(true))));
FullyQualifiedNamespacePerson.AddStructuralProperty("MyTimeOfDay", EdmCoreModel.Instance.GetTimeOfDay(false));
FullyQualifiedNamespacePerson.AddStructuralProperty("MyTimeOfDays", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetTimeOfDay(true))));
FullyQualifiedNamespacePerson.AddStructuralProperty("Birthdate", EdmCoreModel.Instance.GetDateTimeOffset(false));
FullyQualifiedNamespacePerson.AddStructuralProperty("FavoriteDate", EdmCoreModel.Instance.GetDateTimeOffset(true));
FullyQualifiedNamespacePerson.AddStructuralProperty("TimeEmployed", EdmCoreModel.Instance.GetDuration(true));
FullyQualifiedNamespacePerson.AddStructuralProperty("MyAddress", FullyQualifiedNamespaceAddressTypeReference);
FullyQualifiedNamespacePerson.AddStructuralProperty("MyOpenAddress", FullyQualifiedNamespaceOpenAddressTypeReference);
FullyQualifiedNamespacePerson.AddStructuralProperty("PreviousAddresses", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceAddressTypeReference)));
FullyQualifiedNamespacePerson.AddStructuralProperty("FavoriteColors", new EdmCollectionTypeReference(new EdmCollectionType(colorTypeReference)));
FullyQualifiedNamespacePerson.AddStructuralProperty("FavoriteNumber", FullyQualifiedNamespaceUInt16Reference);
FullyQualifiedNamespacePerson.AddStructuralProperty("StockQuantity", FullyQualifiedNamespaceUInt32Reference);
FullyQualifiedNamespacePerson.AddStructuralProperty("LifeTime", FullyQualifiedNamespaceUInt64Reference);
FullyQualifiedNamespacePerson.AddKeys(FullyQualifiedNamespacePerson_ID);
var FullyQualifiedNamespacePerson_MyDog = FullyQualifiedNamespacePerson.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "MyDog", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = FullyQualifiedNamespaceDog });
var FullyQualifiedNamespacePerson_MyRelatedDogs = FullyQualifiedNamespacePerson.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "MyFriendsDogs", TargetMultiplicity = EdmMultiplicity.Many, Target = FullyQualifiedNamespaceDog });
var FullyQualifiedNamespacePerson_MyPaintings = FullyQualifiedNamespacePerson.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "MyPaintings", TargetMultiplicity = EdmMultiplicity.Many, Target = FullyQualifiedNamespacePainting });
var FullyQualifiedNamespacePerson_MyFavoritePainting = FullyQualifiedNamespacePerson.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "MyFavoritePainting", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = FullyQualifiedNamespacePainting });
var FullyQualifiedNamespacePerson_MyLions = FullyQualifiedNamespacePerson.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "MyLions",
TargetMultiplicity = EdmMultiplicity.Many,
Target = FullyQualifiedNamespaceLion,
DependentProperties = new List<IEdmStructuralProperty>()
{
FullyQualifiedNamespacePerson_ID
},
PrincipalProperties = new List<IEdmStructuralProperty>()
{
FullyQualifiedNamespaceLion_ID1
}
});
FullyQualifiedNamespacePerson.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "MyContainedDog",
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
Target = FullyQualifiedNamespaceDog,
ContainsTarget = true
});
FullyQualifiedNamespacePerson.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "MyContainedChimeras",
TargetMultiplicity = EdmMultiplicity.Many,
Target = FullyQualifiedNamespaceChimera,
ContainsTarget = true
});
var FullyQualifiedNamespacePerson_MyPet2Set = FullyQualifiedNamespacePerson.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "MyPet2Set", TargetMultiplicity = EdmMultiplicity.Many, Target = FullyQualifiedNamespacePet2, });
model.AddAlternateKeyAnnotation(FullyQualifiedNamespacePerson, new Dictionary<string, IEdmProperty>()
{
{"SocialSN", FullyQualifiedNamespacePerson_SSN}
});
model.AddAlternateKeyAnnotation(FullyQualifiedNamespacePerson, new Dictionary<string, IEdmProperty>()
{
{"NameAlias", FullyQualifiedNamespacePerson_Name},
{"FirstNameAlias", FullyQualifiedNamespacePerson_FirstName}
});
model.AddElement(FullyQualifiedNamespacePerson);
FullyQualifiedNamespaceEmployee.AddStructuralProperty("WorkEmail", EdmCoreModel.Instance.GetString(true));
var FullyQualifiedNamespaceEmployee_PaintingsInOffice = FullyQualifiedNamespaceEmployee.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "PaintingsInOffice", TargetMultiplicity = EdmMultiplicity.Many, Target = FullyQualifiedNamespacePainting });
var FullyQualifiedNamespaceEmployee_Manager = FullyQualifiedNamespaceEmployee.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Manager", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = FullyQualifiedNamespaceManager });
var FullyQualifiedNamespaceEmployee_OfficeDog = FullyQualifiedNamespaceDog.AddBidirectionalNavigation
(
new EdmNavigationPropertyInfo()
{
Name = "EmployeeOwner",
TargetMultiplicity = EdmMultiplicity.One,
Target = FullyQualifiedNamespaceEmployee
},
new EdmNavigationPropertyInfo()
{
Name = "OfficeDog",
TargetMultiplicity = EdmMultiplicity.One,
Target = FullyQualifiedNamespaceDog
}
);
model.AddElement(FullyQualifiedNamespaceEmployee);
FullyQualifiedNamespaceManager.AddStructuralProperty("NumberOfReports", EdmCoreModel.Instance.GetInt32(true));
var FullyQualifiedNamespaceManager_DirectReports = FullyQualifiedNamespaceManager.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "DirectReports", TargetMultiplicity = EdmMultiplicity.Many, Target = FullyQualifiedNamespaceEmployee });
model.AddElement(FullyQualifiedNamespaceManager);
model.AddElement(FullyQualifiedNamespaceOpenEmployee);
var FullyQualifiedNamespaceDog_ID = FullyQualifiedNamespaceDog.AddStructuralProperty("ID", EdmCoreModel.Instance.GetInt32(false));
FullyQualifiedNamespaceDog.AddStructuralProperty("Color", EdmCoreModel.Instance.GetString(true));
FullyQualifiedNamespaceDog.AddStructuralProperty("Nicknames", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true))));
FullyQualifiedNamespaceDog.AddStructuralProperty("Breed", EdmCoreModel.Instance.GetString(true));
FullyQualifiedNamespaceDog.AddStructuralProperty("NamedStream", EdmCoreModel.Instance.GetStream(true));
FullyQualifiedNamespaceDog.AddKeys(new IEdmStructuralProperty[] { FullyQualifiedNamespaceDog_ID, });
var FullyQualifiedNamespaceDog_MyPeople = FullyQualifiedNamespaceDog.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "MyPeople", TargetMultiplicity = EdmMultiplicity.Many, Target = FullyQualifiedNamespacePerson });
var FullyQualifiedNamespaceDog_FastestOwner = FullyQualifiedNamespaceDog.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "FastestOwner", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = FullyQualifiedNamespacePerson });
var FullyQualifiedNamespaceDog_LionWhoAteMe = FullyQualifiedNamespaceDog.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "LionWhoAteMe",
TargetMultiplicity = EdmMultiplicity.One,
Target = FullyQualifiedNamespaceLion,
},
new EdmNavigationPropertyInfo()
{
Name = "DogThatIAte",
TargetMultiplicity = EdmMultiplicity.One,
Target = FullyQualifiedNamespaceDog,
DependentProperties = new List<IEdmStructuralProperty>()
{
FullyQualifiedNamespaceLion_ID1
},
PrincipalProperties = new List<IEdmStructuralProperty>()
{
FullyQualifiedNamespaceDog_ID
}
});
var FullyQualifiedNamespaceDog_LionsISaw = FullyQualifiedNamespaceDog.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "LionsISaw",
TargetMultiplicity = EdmMultiplicity.Many,
Target = FullyQualifiedNamespaceLion,
},
new EdmNavigationPropertyInfo()
{
Name = "DogsSeenMe",
TargetMultiplicity = EdmMultiplicity.Many,
Target = FullyQualifiedNamespaceDog,
DependentProperties = new List<IEdmStructuralProperty>()
{
FullyQualifiedNamespaceLion_ID1
},
PrincipalProperties = new List<IEdmStructuralProperty>()
{
FullyQualifiedNamespaceDog_ID
}
});
var FullyQualifiedNamespaceLion_Friends = FullyQualifiedNamespaceLion.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo()
{
Name = "Friends",
TargetMultiplicity = EdmMultiplicity.Many,
Target = FullyQualifiedNamespaceLion,
DependentProperties = new List<IEdmStructuralProperty>()
{
FullyQualifiedNamespaceLion_ID2
},
PrincipalProperties = new List<IEdmStructuralProperty>()
{
FullyQualifiedNamespaceLion_ID1
}
});
model.AddElement(FullyQualifiedNamespaceDog);
var fullyQualifiedNamespaceChimeraKey1 = FullyQualifiedNamespaceChimera.AddStructuralProperty("Rid", EdmCoreModel.Instance.GetInt32(false));
var fullyQualifiedNamespaceChimeraKey2 = FullyQualifiedNamespaceChimera.AddStructuralProperty("Gid", EdmPrimitiveTypeKind.Guid);
var fullyQualifiedNamespaceChimeraKey3 = FullyQualifiedNamespaceChimera.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
var fullyQualifiedNamespaceChimeraKey4 = FullyQualifiedNamespaceChimera.AddStructuralProperty("Upgraded", EdmPrimitiveTypeKind.Boolean);
FullyQualifiedNamespaceChimera.AddStructuralProperty("Level", EdmPrimitiveTypeKind.Int32);
FullyQualifiedNamespaceChimera.AddKeys(new IEdmStructuralProperty[] { fullyQualifiedNamespaceChimeraKey1, fullyQualifiedNamespaceChimeraKey2, fullyQualifiedNamespaceChimeraKey3, fullyQualifiedNamespaceChimeraKey4 });
model.AddElement(FullyQualifiedNamespaceChimera);
var FullyQualifiedNamespacePainting_ID = FullyQualifiedNamespacePainting.AddStructuralProperty("ID", EdmCoreModel.Instance.GetInt32(false));
FullyQualifiedNamespacePainting.AddStructuralProperty("Artist", EdmCoreModel.Instance.GetString(true));
FullyQualifiedNamespacePainting.AddStructuralProperty("Value", EdmCoreModel.Instance.GetDecimal(true));
FullyQualifiedNamespacePainting.AddStructuralProperty("Colors", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true))));
FullyQualifiedNamespacePainting.AddKeys(new IEdmStructuralProperty[] { FullyQualifiedNamespacePainting_ID, });
var FullyQualifiedNamespacePainting_Owner = FullyQualifiedNamespacePainting.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Owner", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = FullyQualifiedNamespacePerson });
model.AddElement(FullyQualifiedNamespacePainting);
FullyQualifiedNamespaceFramedPainting.AddStructuralProperty("FrameColor", EdmCoreModel.Instance.GetString(true));
model.AddElement(FullyQualifiedNamespaceFramedPainting);
var FullyQualifiedNamespaceUserAccount_UserName = FullyQualifiedNamespaceUserAccount.AddStructuralProperty("UserName", EdmCoreModel.Instance.GetString(true));
FullyQualifiedNamespaceUserAccount.AddKeys(new IEdmStructuralProperty[] { FullyQualifiedNamespaceUserAccount_UserName, });
model.AddElement(FullyQualifiedNamespaceUserAccount);
FullyQualifiedNamespaceAddress.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(true));
FullyQualifiedNamespaceAddress.AddStructuralProperty("City", EdmCoreModel.Instance.GetString(true));
FullyQualifiedNamespaceAddress.AddStructuralProperty("NextHome", FullyQualifiedNamespaceAddressTypeReference);
FullyQualifiedNamespaceAddress.AddStructuralProperty("MyNeighbors", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true))));
model.AddElement(FullyQualifiedNamespaceAddress);
FullyQualifiedNamespaceHomeAddress.AddStructuralProperty("HomeNO", EdmCoreModel.Instance.GetString(true));
model.AddElement(FullyQualifiedNamespaceHomeAddress);
model.AddElement(FullyQualifiedNamespaceOpenAddress);
FullyQualifiedNamespacePet1.AddKeys(FullyQualifiedNamespacePet1.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int64, false));
FullyQualifiedNamespacePet1.AddStructuralProperty("SingleID", EdmPrimitiveTypeKind.Single, false);
FullyQualifiedNamespacePet1.AddStructuralProperty("DoubleID", EdmPrimitiveTypeKind.Double, false);
FullyQualifiedNamespacePet1.AddStructuralProperty("DecimalID", EdmPrimitiveTypeKind.Decimal, false);
FullyQualifiedNamespacePet1.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String);
model.AddElement(FullyQualifiedNamespacePet1);
FullyQualifiedNamespacePet2.AddKeys(FullyQualifiedNamespacePet2.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Single, false));
FullyQualifiedNamespacePet2.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String);
FullyQualifiedNamespacePet2.AddStructuralProperty("PetColorPattern", colorTypeReference);
model.AddElement(FullyQualifiedNamespacePet2);
FullyQualifiedNamespacePet3.AddKeys(FullyQualifiedNamespacePet3.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Double, false));
FullyQualifiedNamespacePet3.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String);
model.AddElement(FullyQualifiedNamespacePet3);
FullyQualifiedNamespacePet4.AddKeys(FullyQualifiedNamespacePet4.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Decimal, false));
FullyQualifiedNamespacePet4.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String);
model.AddElement(FullyQualifiedNamespacePet4);
FullyQualifiedNamespacePet5.AddKeys(FullyQualifiedNamespacePet5.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Boolean, false));
FullyQualifiedNamespacePet5.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String);
model.AddElement(FullyQualifiedNamespacePet5);
FullyQualifiedNamespacePet6.AddKeys(FullyQualifiedNamespacePet6.AddStructuralProperty("ID", FullyQualifiedNamespaceIdTypeReference));
FullyQualifiedNamespacePet6.AddStructuralProperty("Color", EdmPrimitiveTypeKind.String);
model.AddElement(FullyQualifiedNamespacePet6);
#endregion
#region Operations
var FullyQualifiedNamespaceGetPet1Function = new EdmFunction("Fully.Qualified.Namespace", "GetPet1", FullyQualifiedNamespacePet1TypeReference, false, null, true);
FullyQualifiedNamespaceGetPet1Function.AddParameter("id", EdmCoreModel.Instance.GetInt64(false));
model.AddElement(FullyQualifiedNamespaceGetPet1Function);
var FullyQualifiedNamespaceGetPet2Function = new EdmFunction("Fully.Qualified.Namespace", "GetPet2", FullyQualifiedNamespacePet2TypeReference, false, null, true);
FullyQualifiedNamespaceGetPet2Function.AddParameter("id", EdmCoreModel.Instance.GetSingle(false));
model.AddElement(FullyQualifiedNamespaceGetPet2Function);
var FullyQualifiedNamespaceGetPet3Function = new EdmFunction("Fully.Qualified.Namespace", "GetPet3", FullyQualifiedNamespacePet3TypeReference, false, null, true);
FullyQualifiedNamespaceGetPet3Function.AddParameter("id", EdmCoreModel.Instance.GetDouble(false));
model.AddElement(FullyQualifiedNamespaceGetPet3Function);
var FullyQualifiedNamespaceGetPet4Function = new EdmFunction("Fully.Qualified.Namespace", "GetPet4", FullyQualifiedNamespacePet4TypeReference, false, null, true);
FullyQualifiedNamespaceGetPet4Function.AddParameter("id", EdmCoreModel.Instance.GetDecimal(false));
model.AddElement(FullyQualifiedNamespaceGetPet4Function);
var FullyQualifiedNamespaceGetPet5Function = new EdmFunction("Fully.Qualified.Namespace", "GetPet5", FullyQualifiedNamespacePet5TypeReference, false, null, true);
FullyQualifiedNamespaceGetPet5Function.AddParameter("id", EdmCoreModel.Instance.GetBoolean(false));
model.AddElement(FullyQualifiedNamespaceGetPet5Function);
var FullyQualifiedNamespaceGetPet6Function = new EdmFunction("Fully.Qualified.Namespace", "GetPet6", FullyQualifiedNamespacePet6TypeReference, false, null, true);
FullyQualifiedNamespaceGetPet6Function.AddParameter("id", FullyQualifiedNamespaceIdTypeReference);
model.AddElement(FullyQualifiedNamespaceGetPet6Function);
var FullyQualifiedNamespaceGetPetCountFunction = new EdmFunction("Fully.Qualified.Namespace", "GetPetCount", FullyQualifiedNamespacePet5TypeReference, false, null, true);
FullyQualifiedNamespaceGetPetCountFunction.AddParameter("colorPattern", colorTypeReference);
model.AddElement(FullyQualifiedNamespaceGetPetCountFunction);
var FullyQualifiedNamespaceTryGetPetCountFunction = new EdmFunction("Fully.Qualified.Namespace", "TryGetPetCount", FullyQualifiedNamespacePet5TypeReference, false, null, true);
FullyQualifiedNamespaceGetPetCountFunction.AddParameter("colorPattern", nullableColorTypeReference);
model.AddElement(FullyQualifiedNamespaceTryGetPetCountFunction);
var FullyQualifiedNamespaceWalkAction = new EdmAction("Fully.Qualified.Namespace", "Walk", FullyQualifiedNamespaceAddressTypeReference, true, null);
FullyQualifiedNamespaceWalkAction.AddParameter("dog", FullyQualifiedNamespaceDogTypeReference);
model.AddElement(FullyQualifiedNamespaceWalkAction);
var FullyQualifiedNamespaceFindMyOwnerFunction = new EdmFunction("Fully.Qualified.Namespace", "FindMyOwner", FullyQualifiedNamespacePersonTypeReference, false, null, false);
FullyQualifiedNamespaceFindMyOwnerFunction.AddParameter("dogsName", EdmCoreModel.Instance.GetString(true));
model.AddElement(FullyQualifiedNamespaceFindMyOwnerFunction);
var FullyQualifiedNamespaceHasHatFunction = new EdmFunction("Fully.Qualified.Namespace", "HasHat", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceHasHatFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceHasHatFunction);
var FullyQualifiedNamespaceHasHatFunction2 = new EdmFunction("Fully.Qualified.Namespace", "HasHat", EdmCoreModel.Instance.GetInt32(true), true, null, false);
FullyQualifiedNamespaceHasHatFunction2.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceHasHatFunction2.AddParameter("onCat", EdmCoreModel.Instance.GetBoolean(true));
model.AddElement(FullyQualifiedNamespaceHasHatFunction2);
var FullyQualifiedNamespaceHasJobFunction = new EdmFunction("Fully.Qualified.Namespace", "HasJob", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceHasJobFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceHasJobFunction);
var FullyQualifiedNamespaceAllHaveDogFunction = new EdmFunction("Fully.Qualified.Namespace", "AllHaveDog", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceAllHaveDogFunction.AddParameter("people", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespacePersonTypeReference)));
model.AddElement(FullyQualifiedNamespaceAllHaveDogFunction);
var FullyQualifiedNamespaceAllHaveDogFunction2 = new EdmFunction("Fully.Qualified.Namespace", "AllHaveDog", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceAllHaveDogFunction2.AddParameter("people", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespacePersonTypeReference)));
FullyQualifiedNamespaceAllHaveDogFunction2.AddParameter("inOffice", EdmCoreModel.Instance.GetBoolean(true));
model.AddElement(FullyQualifiedNamespaceAllHaveDogFunction2);
var FullyQualifiedNamespaceFireAllAction = new EdmAction("Fully.Qualified.Namespace", "FireAll", EdmCoreModel.Instance.GetBoolean(true), true, null);
FullyQualifiedNamespaceFireAllAction.AddParameter("employees", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespacePersonTypeReference)));
model.AddElement(FullyQualifiedNamespaceFireAllAction);
var FullyQualifiedNamespaceHasDogFunction = new EdmFunction("Fully.Qualified.Namespace", "HasDog", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceHasDogFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceHasDogFunction);
var FullyQualifiedNamespaceHasDogFunction2 = new EdmFunction("Fully.Qualified.Namespace", "HasDog", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceHasDogFunction2.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceHasDogFunction2.AddParameter("inOffice", EdmCoreModel.Instance.GetBoolean(true));
model.AddElement(FullyQualifiedNamespaceHasDogFunction2);
var FullyQualifiedNamespaceHasDogFunction3 = new EdmFunction("Fully.Qualified.Namespace", "HasDog", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceHasDogFunction3.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceHasDogFunction3.AddParameter("inOffice", EdmCoreModel.Instance.GetBoolean(true));
FullyQualifiedNamespaceHasDogFunction3.AddParameter("name", EdmCoreModel.Instance.GetString(true));
model.AddElement(FullyQualifiedNamespaceHasDogFunction3);
var FullyQualifiedNamespaceHasDogFunction4 = new EdmFunction("Fully.Qualified.Namespace", "HasDog", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceHasDogFunction4.AddParameter("person", FullyQualifiedNamespaceEmployeeTypeReference);
FullyQualifiedNamespaceHasDogFunction4.AddParameter("inOffice", EdmCoreModel.Instance.GetBoolean(true));
model.AddElement(FullyQualifiedNamespaceHasDogFunction4);
var FullyQualifiedNamespaceGetMyDogFunction = new EdmFunction("Fully.Qualified.Namespace", "GetMyDog", FullyQualifiedNamespaceDogTypeReference, true, new EdmPathExpression("person/MyDog"), true);
FullyQualifiedNamespaceGetMyDogFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceGetMyDogFunction);
var FullyQualifiedNamespaceAllMyFriendsDogsFunction = new EdmFunction("Fully.Qualified.Namespace", "AllMyFriendsDogs", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceDogTypeReference)), true, new EdmPathExpression("person/MyFriendsDogs"), true);
FullyQualifiedNamespaceAllMyFriendsDogsFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceAllMyFriendsDogsFunction);
var FullyQualifiedNamespaceAllMyFriendsDogsNonComposableFunction = new EdmFunction("Fully.Qualified.Namespace", "AllMyFriendsDogsNonComposable", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceDogTypeReference)), true, new EdmPathExpression("person/MyFriendsDogs"), false);
FullyQualifiedNamespaceAllMyFriendsDogsNonComposableFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceAllMyFriendsDogsNonComposableFunction);
var FullyQualifiedNamespaceAllMyFriendsDogsFunction2 = new EdmFunction("Fully.Qualified.Namespace", "AllMyFriendsDogs", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceDogTypeReference)), true, new EdmPathExpression("person/MyFriendsDogs"), true);
FullyQualifiedNamespaceAllMyFriendsDogsFunction2.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceAllMyFriendsDogsFunction2.AddParameter("inOffice", EdmCoreModel.Instance.GetBoolean(true));
model.AddElement(FullyQualifiedNamespaceAllMyFriendsDogsFunction2);
var FullyQualifiedNamespaceAllMyFriendsDogs_NoSetFunction = new EdmFunction("Fully.Qualified.Namespace", "AllMyFriendsDogs_NoSet", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceDogTypeReference)), true, null, false);
FullyQualifiedNamespaceAllMyFriendsDogs_NoSetFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceAllMyFriendsDogs_NoSetFunction);
var FullyQualifiedNamespaceOwnerOfFastestDogFunction = new EdmFunction("Fully.Qualified.Namespace", "OwnerOfFastestDog", FullyQualifiedNamespacePersonTypeReference, true, new EdmPathExpression("dogs/FastestOwner"), true);
FullyQualifiedNamespaceOwnerOfFastestDogFunction.AddParameter("dogs", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceDogTypeReference)));
model.AddElement(FullyQualifiedNamespaceOwnerOfFastestDogFunction);
var FullyQualifiedNamespaceOwnsTheseDogsFunction = new EdmFunction("Fully.Qualified.Namespace", "OwnsTheseDogs", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceOwnsTheseDogsFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceOwnsTheseDogsFunction.AddParameter("dogNames", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true))));
model.AddElement(FullyQualifiedNamespaceOwnsTheseDogsFunction);
var FullyQualifiedNamespaceIsInTheUSFunction = new EdmFunction("Fully.Qualified.Namespace", "IsInTheUS", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceIsInTheUSFunction.AddParameter("address", FullyQualifiedNamespaceAddressTypeReference);
model.AddElement(FullyQualifiedNamespaceIsInTheUSFunction);
var FullyQualifiedNamespaceMoveAction = new EdmAction("Fully.Qualified.Namespace", "Move", EdmCoreModel.Instance.GetBoolean(true), true, null);
FullyQualifiedNamespaceMoveAction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceMoveAction.AddParameter("streetAddress", EdmCoreModel.Instance.GetString(true));
var FullyQualifiedNamespaceCanMoveToAddressFunction = new EdmFunction("Fully.Qualified.Namespace", "CanMoveToAddress", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceCanMoveToAddressFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceCanMoveToAddressFunction.AddParameter("address", FullyQualifiedNamespaceAddressTypeReference);
model.AddElement(FullyQualifiedNamespaceCanMoveToAddressFunction);
var FullyQualifiedNamespaceIsAddressGoodFunction = new EdmFunction("Fully.Qualified.Namespace", "IsAddressGood", EdmCoreModel.Instance.GetBoolean(true), false, null, false);
FullyQualifiedNamespaceIsAddressGoodFunction.AddParameter("address", FullyQualifiedNamespaceAddressTypeReference);
model.AddElement(FullyQualifiedNamespaceIsAddressGoodFunction);
var FullyQualifiedNamespaceCanMoveToAddressesFunction = new EdmFunction("Fully.Qualified.Namespace", "CanMoveToAddresses", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceCanMoveToAddressesFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceCanMoveToAddressesFunction.AddParameter("addresses", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceAddressTypeReference)));
model.AddElement(FullyQualifiedNamespaceCanMoveToAddressesFunction);
var FullyQualifiedNamespaceIsOlderThanByteFunction = new EdmFunction("Fully.Qualified.Namespace", "IsOlderThanByte", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceIsOlderThanByteFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceIsOlderThanByteFunction.AddParameter("age", EdmCoreModel.Instance.GetByte(true));
model.AddElement(FullyQualifiedNamespaceIsOlderThanByteFunction);
var FullyQualifiedNamespaceIsOlderThanSByteFunction = new EdmFunction("Fully.Qualified.Namespace", "IsOlderThanSByte", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceIsOlderThanSByteFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceIsOlderThanSByteFunction.AddParameter("age", EdmCoreModel.Instance.GetSByte(true));
model.AddElement(FullyQualifiedNamespaceIsOlderThanSByteFunction);
var FullyQualifiedNamespaceIsOlderThanShortFunction = new EdmFunction("Fully.Qualified.Namespace", "IsOlderThanShort", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceIsOlderThanShortFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceIsOlderThanShortFunction.AddParameter("age", EdmCoreModel.Instance.GetInt16(true));
model.AddElement(FullyQualifiedNamespaceIsOlderThanShortFunction);
var FullyQualifiedNamespaceIsOlderThanSingleFunction = new EdmFunction("Fully.Qualified.Namespace", "IsOlderThanSingle", EdmCoreModel.Instance.GetBoolean(true), true, null, false);
FullyQualifiedNamespaceIsOlderThanSingleFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceIsOlderThanSingleFunction.AddParameter("age", EdmCoreModel.Instance.GetSingle(true));
model.AddElement(FullyQualifiedNamespaceIsOlderThanSingleFunction);
var FullyQualifiedNamespacePaintAction = new EdmAction("Fully.Qualified.Namespace", "Paint", FullyQualifiedNamespacePaintingTypeReference, true, new EdmPathExpression("person/MyPaintings"));
FullyQualifiedNamespacePaintAction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespacePaintAction);
var FullyQualifiedNamespaceMoveAction2 = new EdmAction("Fully.Qualified.Namespace", "Move", EdmCoreModel.Instance.GetBoolean(true), true, null);
FullyQualifiedNamespaceMoveAction2.AddParameter("employee", FullyQualifiedNamespaceEmployeeTypeReference);
FullyQualifiedNamespaceMoveAction2.AddParameter("building", EdmCoreModel.Instance.GetInt32(true));
FullyQualifiedNamespaceMoveAction2.AddParameter("room", EdmCoreModel.Instance.GetInt32(true));
model.AddElement(FullyQualifiedNamespaceMoveAction2);
var FullyQualifiedNamespaceRestoreAction = new EdmAction("Fully.Qualified.Namespace", "Restore", EdmCoreModel.Instance.GetBoolean(true), true, null);
FullyQualifiedNamespaceRestoreAction.AddParameter("painting", FullyQualifiedNamespacePaintingTypeReference);
model.AddElement(FullyQualifiedNamespaceRestoreAction);
var FullyQualifiedNamespaceChangeStateAction = new EdmAction("Fully.Qualified.Namespace", "ChangeState", EdmCoreModel.Instance.GetBoolean(true), true, null);
FullyQualifiedNamespaceChangeStateAction.AddParameter("address", FullyQualifiedNamespaceAddressTypeReference);
FullyQualifiedNamespaceChangeStateAction.AddParameter("newState", EdmCoreModel.Instance.GetString(true));
model.AddElement(FullyQualifiedNamespaceChangeStateAction);
var FullyQualifiedNamespaceGetMyPersonFunction = new EdmFunction("Fully.Qualified.Namespace", "GetMyPerson", FullyQualifiedNamespacePersonTypeReference, true, null, false);
FullyQualifiedNamespaceGetMyPersonFunction.AddParameter("dog", FullyQualifiedNamespaceDogTypeReference);
model.AddElement(FullyQualifiedNamespaceGetMyPersonFunction);
model.AddElement(FullyQualifiedNamespaceMoveAction);
var FullyQualifiedNamespaceGetCoolPeopleAction = new EdmFunction("Fully.Qualified.Namespace", "GetCoolPeople", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespacePersonTypeReference)), false, null, true /*isComposable*/);
FullyQualifiedNamespaceGetCoolPeopleAction.AddParameter("id", EdmCoreModel.Instance.GetInt32(true));
FullyQualifiedNamespaceGetCoolPeopleAction.AddParameter("limit", EdmCoreModel.Instance.GetInt32(true));
model.AddElement(FullyQualifiedNamespaceGetCoolPeopleAction);
var FullyQualifiedNamespaceGetHotPeopleAction = new EdmFunction("Fully.Qualified.Namespace", "GetHotPeople", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespacePersonTypeReference)), true, new EdmPathExpression("person"), true /*isComposable*/);
FullyQualifiedNamespaceGetHotPeopleAction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceGetHotPeopleAction.AddParameter("limit", EdmCoreModel.Instance.GetInt32(true));
model.AddElement(FullyQualifiedNamespaceGetHotPeopleAction);
var FullyQualifiedNamespaceGetCoolestPersonAction = new EdmFunction("Fully.Qualified.Namespace", "GetCoolestPerson", FullyQualifiedNamespacePersonTypeReference, false, null, true /*isComposable*/);
model.AddElement(FullyQualifiedNamespaceGetCoolestPersonAction);
var FullyQualifiedNamespaceGetCoolestPersonWithStyleAction = new EdmFunction("Fully.Qualified.Namespace", "GetCoolestPersonWithStyle", FullyQualifiedNamespacePersonTypeReference, false, null, true /*isComposable*/);
FullyQualifiedNamespaceGetCoolestPersonWithStyleAction.AddParameter("styleID", EdmCoreModel.Instance.GetInt32(true));
model.AddElement(FullyQualifiedNamespaceGetCoolestPersonWithStyleAction);
var FullyQualifiedNamespaceGetBestManagerAction = new EdmFunction("Fully.Qualified.Namespace", "GetBestManager", FullyQualifiedNamespaceManagerTypeReference, false, null, true /*isComposable*/);
model.AddElement(FullyQualifiedNamespaceGetBestManagerAction);
var FullyQualifiedNamespaceGetNothingAction = new EdmAction("Fully.Qualified.Namespace", "GetNothing", null, false, null);
model.AddElement(FullyQualifiedNamespaceGetNothingAction);
var FullyQualifiedNamespaceGetSomeNumberAction = new EdmFunction("Fully.Qualified.Namespace", "GetSomeNumber", EdmCoreModel.Instance.GetInt32(true), false, null, true /*isComposable*/);
model.AddElement(FullyQualifiedNamespaceGetSomeNumberAction);
var FullyQualifiedNamespaceGetSomeAddressAction = new EdmFunction("Fully.Qualified.Namespace", "GetSomeAddress", FullyQualifiedNamespaceAddressTypeReference, false, null, true /*isComposable*/);
model.AddElement(FullyQualifiedNamespaceGetSomeAddressAction);
var FullyQualifiedNamespaceGetSomeNumbersAction = new EdmFunction("Fully.Qualified.Namespace", "GetSomeNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(true))), false, null, true /*isComposable*/);
model.AddElement(FullyQualifiedNamespaceGetSomeNumbersAction);
var FullyQualifiedNamespaceGetSomeColorsFunction = new EdmFunction("Fully.Qualified.Namespace", "GetSomeColors", new EdmCollectionTypeReference(new EdmCollectionType(colorTypeReference)), false, null, true /*isComposable*/);
model.AddElement(FullyQualifiedNamespaceGetSomeColorsFunction);
var FullyQualifiedNamespaceGetSomeColorFunction = new EdmFunction("Fully.Qualified.Namespace", "GetSomeColor", colorTypeReference, false, null, true /*isComposable*/);
model.AddElement(FullyQualifiedNamespaceGetSomeColorFunction);
var FullyQualifiedNamespaceGetSomeAddressesAction = new EdmFunction("Fully.Qualified.Namespace", "GetSomeAddresses", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceAddressTypeReference)), false, null, true /*isComposable*/);
model.AddElement(FullyQualifiedNamespaceGetSomeAddressesAction);
var FullyQualifiedNamespaceResetAllDataAction = new EdmAction("Fully.Qualified.Namespace", "ResetAllData", null, false, null);
model.AddElement(FullyQualifiedNamespaceResetAllDataAction);
var FullyQualifiedNamespaceGetMostImporantPersonFunction = new EdmFunction("Fully.Qualified.Namespace", "GetMostImporantPerson", FullyQualifiedNamespacePersonTypeReference, false, null, false);
model.AddElement(FullyQualifiedNamespaceGetMostImporantPersonFunction);
var FullyQualifiedNamespaceGetMostImporantPersonFunction2 = new EdmFunction("Fully.Qualified.Namespace", "GetMostImporantPerson", FullyQualifiedNamespacePersonTypeReference, false, null, false);
FullyQualifiedNamespaceGetMostImporantPersonFunction2.AddParameter("city", EdmCoreModel.Instance.GetString(true));
model.AddElement(FullyQualifiedNamespaceGetMostImporantPersonFunction2);
var FullyQualifiedNamespaceGetPriorNumbersFunction = new EdmFunction("Fully.Qualified.Namespace", "GetPriorNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetInt32(true))), true, null, true);
FullyQualifiedNamespaceGetPriorNumbersFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceGetPriorNumbersFunction);
var FullyQualifiedNamespaceGetPriorAddressesFunction = new EdmFunction("Fully.Qualified.Namespace", "GetPriorAddresses", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceAddressTypeReference)), true, null, true);
FullyQualifiedNamespaceGetPriorAddressesFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceGetPriorAddressesFunction);
var FullyQualifiedNamespaceGetPriorAddressFunction = new EdmFunction("Fully.Qualified.Namespace", "GetPriorAddress", FullyQualifiedNamespaceAddressTypeReference, true, null, true);
FullyQualifiedNamespaceGetPriorAddressFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceGetPriorAddressFunction);
var FullyQualifiedNamespaceGetFavoriteColorsFunction = new EdmFunction("Fully.Qualified.Namespace", "GetFavoriteColors", new EdmCollectionTypeReference(new EdmCollectionType(colorTypeReference)), true, null, true);
FullyQualifiedNamespaceGetFavoriteColorsFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceGetFavoriteColorsFunction);
var FullyQualifiedNamespaceGetFavoriteColorFunction = new EdmFunction("Fully.Qualified.Namespace", "GetFavoriteColor", colorTypeReference, true, null, true);
FullyQualifiedNamespaceGetFavoriteColorFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
model.AddElement(FullyQualifiedNamespaceGetFavoriteColorFunction);
var FullyQualifiedNamespaceGetNearbyPriorAddressesFunction = new EdmFunction("Fully.Qualified.Namespace", "GetNearbyPriorAddresses", new EdmCollectionTypeReference(new EdmCollectionType(FullyQualifiedNamespaceAddressTypeReference)), true, null, false);
FullyQualifiedNamespaceGetNearbyPriorAddressesFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceGetNearbyPriorAddressesFunction.AddParameter("currentLocation", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeographyPoint, true));
FullyQualifiedNamespaceGetNearbyPriorAddressesFunction.AddParameter("limit", EdmCoreModel.Instance.GetInt32(true));
model.AddElement(FullyQualifiedNamespaceGetNearbyPriorAddressesFunction);
var FullyQualifiedNamespaceGetColorAtPositionFunction = new EdmFunction("Fully.Qualified.Namespace", "GetColorAtPosition", EdmCoreModel.Instance.GetString(true), true, null, false);
FullyQualifiedNamespaceGetColorAtPositionFunction.AddParameter("painting", FullyQualifiedNamespacePaintingTypeReference);
FullyQualifiedNamespaceGetColorAtPositionFunction.AddParameter("position", EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.GeometryPoint, true));
FullyQualifiedNamespaceGetColorAtPositionFunction.AddParameter("includeAlpha", EdmCoreModel.Instance.GetBoolean(true));
model.AddElement(FullyQualifiedNamespaceGetColorAtPositionFunction);
var FullyQualifiedNamespaceMoveEveryoneAction = new EdmAction("Fully.Qualified.Namespace", "MoveEveryone", EdmCoreModel.Instance.GetBoolean(true), false, null);
FullyQualifiedNamespaceMoveEveryoneAction.AddParameter("streetAddress", EdmCoreModel.Instance.GetString(true));
model.AddElement(FullyQualifiedNamespaceMoveEveryoneAction);
var FullyQualifiedNamespaceGetFullNameFunction = new EdmFunction("Fully.Qualified.Namespace", "GetFullName", FullyQualifiedNamespaceNameTypeReference, true, null, true);
FullyQualifiedNamespaceGetNearbyPriorAddressesFunction.AddParameter("person", FullyQualifiedNamespacePersonTypeReference);
FullyQualifiedNamespaceGetFullNameFunction.AddParameter("nickname", FullyQualifiedNamespaceNameTypeReference);
model.AddElement(FullyQualifiedNamespaceGetFullNameFunction);
#endregion
#region Context Container
var FullyQualifiedNamespaceContext = new EdmEntityContainer("Fully.Qualified.Namespace", "Context");
model.AddElement(FullyQualifiedNamespaceContext);
var FullyQualifiedNamespaceContextPeople = FullyQualifiedNamespaceContext.AddEntitySet("People", FullyQualifiedNamespacePerson);
var FullyQualifiedNamespaceContextDogs = FullyQualifiedNamespaceContext.AddEntitySet("Dogs", FullyQualifiedNamespaceDog);
var FullyQualifiedNamespaceContextLions = FullyQualifiedNamespaceContext.AddEntitySet("Lions", FullyQualifiedNamespaceLion);
var FullyQualifiedNamespaceContextPaintings = FullyQualifiedNamespaceContext.AddEntitySet("Paintings", FullyQualifiedNamespacePainting);
var FullyQualifiedNamespaceContextUsers = FullyQualifiedNamespaceContext.AddEntitySet("Users", FullyQualifiedNamespaceUserAccount);
var FullyQualifiedNamespaceContextPet1Set = FullyQualifiedNamespaceContext.AddEntitySet("Pet1Set", FullyQualifiedNamespacePet1);
var FullyQualifiedNamespaceContextPet2Set = FullyQualifiedNamespaceContext.AddEntitySet("Pet2Set", FullyQualifiedNamespacePet2);
var FullyQualifiedNamespaceContextPet3Set = FullyQualifiedNamespaceContext.AddEntitySet("Pet3Set", FullyQualifiedNamespacePet3);
var FullyQualifiedNamespaceContextPet4Set = FullyQualifiedNamespaceContext.AddEntitySet("Pet4Set", FullyQualifiedNamespacePet4);
var FullyQualifiedNamespaceContextPet5Set = FullyQualifiedNamespaceContext.AddEntitySet("Pet5Set", FullyQualifiedNamespacePet5);
var FullyQualifiedNamespaceContextPet6Set = FullyQualifiedNamespaceContext.AddEntitySet("Pet6Set", FullyQualifiedNamespacePet6);
var FullyQualifiedNamespaceContextChimera = FullyQualifiedNamespaceContext.AddEntitySet("Chimeras", FullyQualifiedNamespaceChimera);
FullyQualifiedNamespaceContextPeople.AddNavigationTarget(FullyQualifiedNamespacePerson_MyDog, FullyQualifiedNamespaceContextDogs);
FullyQualifiedNamespaceContextPeople.AddNavigationTarget(FullyQualifiedNamespacePerson_MyRelatedDogs, FullyQualifiedNamespaceContextDogs);
FullyQualifiedNamespaceContextPeople.AddNavigationTarget(FullyQualifiedNamespacePerson_MyLions, FullyQualifiedNamespaceContextLions);
FullyQualifiedNamespaceContextPeople.AddNavigationTarget(FullyQualifiedNamespacePerson_MyPaintings, FullyQualifiedNamespaceContextPaintings);
FullyQualifiedNamespaceContextPeople.AddNavigationTarget(FullyQualifiedNamespacePerson_MyFavoritePainting, FullyQualifiedNamespaceContextPaintings);
FullyQualifiedNamespaceContextPeople.AddNavigationTarget(FullyQualifiedNamespaceEmployee_PaintingsInOffice, FullyQualifiedNamespaceContextPaintings);
FullyQualifiedNamespaceContextPeople.AddNavigationTarget(FullyQualifiedNamespaceEmployee_Manager, FullyQualifiedNamespaceContextPeople);
FullyQualifiedNamespaceContextPeople.AddNavigationTarget(FullyQualifiedNamespaceManager_DirectReports, FullyQualifiedNamespaceContextPeople);
FullyQualifiedNamespaceContextPeople.AddNavigationTarget(FullyQualifiedNamespacePerson_MyPet2Set, FullyQualifiedNamespaceContextPet2Set);
FullyQualifiedNamespaceContextDogs.AddNavigationTarget(FullyQualifiedNamespaceDog_MyPeople, FullyQualifiedNamespaceContextPeople);
FullyQualifiedNamespaceContextDogs.AddNavigationTarget(FullyQualifiedNamespaceDog_FastestOwner, FullyQualifiedNamespaceContextPeople);
FullyQualifiedNamespaceContextDogs.AddNavigationTarget(FullyQualifiedNamespaceDog_LionsISaw, FullyQualifiedNamespaceContextLions);
FullyQualifiedNamespaceContextLions.AddNavigationTarget(FullyQualifiedNamespaceLion_Friends, FullyQualifiedNamespaceContextLions);
FullyQualifiedNamespaceContextPaintings.AddNavigationTarget(FullyQualifiedNamespacePainting_Owner, FullyQualifiedNamespaceContextPeople);
// Add singleton
var FullQualifiedNamespaceSingletonBoss = FullyQualifiedNamespaceContext.AddSingleton("Boss", FullyQualifiedNamespacePerson);
FullQualifiedNamespaceSingletonBoss.AddNavigationTarget(FullyQualifiedNamespacePerson_MyDog, FullyQualifiedNamespaceContextDogs);
FullQualifiedNamespaceSingletonBoss.AddNavigationTarget(FullyQualifiedNamespacePerson_MyPaintings, FullyQualifiedNamespaceContextPaintings);
FullyQualifiedNamespaceContext.AddFunctionImport("GetPet1", FullyQualifiedNamespaceGetPet1Function, new EdmEntitySetReferenceExpression(FullyQualifiedNamespaceContextPet1Set));
FullyQualifiedNamespaceContext.AddFunctionImport("GetPet2", FullyQualifiedNamespaceGetPet2Function, new EdmEntitySetReferenceExpression(FullyQualifiedNamespaceContextPet2Set));
FullyQualifiedNamespaceContext.AddFunctionImport("GetPet3", FullyQualifiedNamespaceGetPet3Function, new EdmEntitySetReferenceExpression(FullyQualifiedNamespaceContextPet3Set));
FullyQualifiedNamespaceContext.AddFunctionImport("GetPet4", FullyQualifiedNamespaceGetPet4Function, new EdmEntitySetReferenceExpression(FullyQualifiedNamespaceContextPet4Set));
FullyQualifiedNamespaceContext.AddFunctionImport("GetPet5", FullyQualifiedNamespaceGetPet5Function, new EdmEntitySetReferenceExpression(FullyQualifiedNamespaceContextPet5Set));
FullyQualifiedNamespaceContext.AddFunctionImport("GetPet6", FullyQualifiedNamespaceGetPet6Function, new EdmEntitySetReferenceExpression(FullyQualifiedNamespaceContextPet6Set));
FullyQualifiedNamespaceContext.AddFunctionImport("GetPetCount", FullyQualifiedNamespaceGetPetCountFunction, new EdmEntitySetReferenceExpression(FullyQualifiedNamespaceContextPet5Set));
FullyQualifiedNamespaceContext.AddFunctionImport("FindMyOwner", FullyQualifiedNamespaceFindMyOwnerFunction, new EdmEntitySetReferenceExpression(model.FindEntityContainer("Fully.Qualified.Namespace.Context").FindEntitySet("People")));
FullyQualifiedNamespaceContext.AddFunctionImport("IsAddressGood", FullyQualifiedNamespaceIsAddressGoodFunction, null);
FullyQualifiedNamespaceContext.AddFunctionImport("GetCoolPeople", FullyQualifiedNamespaceGetCoolPeopleAction, new EdmEntitySetReferenceExpression(model.FindEntityContainer("Fully.Qualified.Namespace.Context").FindEntitySet("People")));
FullyQualifiedNamespaceContext.AddFunctionImport("GetCoolestPerson", FullyQualifiedNamespaceGetCoolestPersonAction, new EdmEntitySetReferenceExpression(model.FindEntityContainer("Fully.Qualified.Namespace.Context").FindEntitySet("People")));
FullyQualifiedNamespaceContext.AddFunctionImport("GetCoolestPersonWithStyle", FullyQualifiedNamespaceGetCoolestPersonWithStyleAction, new EdmEntitySetReferenceExpression(model.FindEntityContainer("Fully.Qualified.Namespace.Context").FindEntitySet("People")));
FullyQualifiedNamespaceContext.AddFunctionImport("GetBestManager", FullyQualifiedNamespaceGetBestManagerAction, new EdmEntitySetReferenceExpression(model.FindEntityContainer("Fully.Qualified.Namespace.Context").FindEntitySet("People")));
FullyQualifiedNamespaceContext.AddActionImport("GetNothing", FullyQualifiedNamespaceGetNothingAction);
FullyQualifiedNamespaceContext.AddFunctionImport("GetSomeNumber", FullyQualifiedNamespaceGetSomeNumberAction);
FullyQualifiedNamespaceContext.AddFunctionImport("GetSomeAddress", FullyQualifiedNamespaceGetSomeAddressAction);
FullyQualifiedNamespaceContext.AddFunctionImport("GetSomeNumbers", FullyQualifiedNamespaceGetSomeNumbersAction);
FullyQualifiedNamespaceContext.AddFunctionImport("GetSomeAddresses", FullyQualifiedNamespaceGetSomeAddressesAction);
FullyQualifiedNamespaceContext.AddActionImport("ResetAllData", FullyQualifiedNamespaceResetAllDataAction);
FullyQualifiedNamespaceContext.AddFunctionImport("GetMostImporantPerson", FullyQualifiedNamespaceGetMostImporantPersonFunction);
FullyQualifiedNamespaceContext.AddFunctionImport("GetMostImporantPerson", FullyQualifiedNamespaceGetMostImporantPersonFunction2);
FullyQualifiedNamespaceContext.AddActionImport("MoveEveryone", FullyQualifiedNamespaceMoveEveryoneAction);
#endregion
try
{
// serialize edm
XDocument document = new XDocument();
IEnumerable<EdmError> errors;
using (var writer = document.CreateWriter())
{
EdmxWriter.TryWriteEdmx(model, writer, EdmxTarget.OData, out errors).Should().BeTrue();
}
string doc = document.ToString();
// deserialize edm xml
// TODO: remove the above model building codes.
IEdmModel parsedModel;
if (EdmxReader.TryParse(XmlReader.Create(new StringReader(HardCodedTestModelXml.MainModelXml)), (Uri uri) =>
{
if (string.Equals(uri.AbsoluteUri, "http://submodel1/"))
{
return XmlReader.Create(new StringReader(HardCodedTestModelXml.SubModelXml1));
}
else if (string.Equals(uri.AbsoluteUri, "http://submodel2/"))
{
return XmlReader.Create(new StringReader(HardCodedTestModelXml.SubModelXml2));
}
else if (string.Equals(uri.AbsoluteUri, "http://submodel3/"))
{
return XmlReader.Create(new StringReader(HardCodedTestModelXml.SubModelXml3));
}
else if (string.Equals(uri.AbsoluteUri, "http://submodel4/"))
{
return XmlReader.Create(new StringReader(HardCodedTestModelXml.SubModelXml4));
}
throw new Exception("edmx:refernece must have a valid url." + uri.AbsoluteUri);
}, out parsedModel, out errors))
{
return parsedModel;
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return null;
}
private static IEdmAction AddBindableAction(EdmModel model, string name, IEdmEntityType bindingType, bool isCollection)
{
IEdmEntityContainer container = model.EntityContainer;
var action = new EdmAction(
container.Namespace, name, returnType: null, isBound: true, entitySetPathExpression: null);
IEdmTypeReference bindingParamterType = new EdmEntityTypeReference(bindingType, isNullable: false);
if (isCollection)
{
bindingParamterType = new EdmCollectionTypeReference(new EdmCollectionType(bindingParamterType));
}
action.AddParameter("bindingParameter", bindingParamterType);
model.AddElement(action);
return action;
}
internal void WriteNamespace(string fullNamespace)
{
WriteNamespaceStart(Context.GetPrefixedNamespace(fullNamespace, this, true, false));
var schemaElements = Context.GetSchemaElements(fullNamespace).ToArray();
if (schemaElements.OfType<IEdmEntityContainer>().Any())
{
var container = schemaElements.OfType<IEdmEntityContainer>().Single();
WriteEntityContainer(container, fullNamespace);
}
var boundOperationsMap = new Dictionary<IEdmStructuredType, List<IEdmOperation>>();
foreach (var operation in schemaElements.OfType<IEdmOperation>())
{
if (operation.IsBound)
{
var edmType = operation.Parameters.First().Type.Definition;
var edmStructuredType = edmType as IEdmStructuredType;
if (edmStructuredType != null)
{
List<IEdmOperation> operationList;
if (!boundOperationsMap.TryGetValue(edmStructuredType, out operationList))
{
operationList = new List<IEdmOperation>();
}
operationList.Add(operation);
boundOperationsMap[edmStructuredType] = operationList;
}
}
}
var structuredBaseTypeMap = new Dictionary<IEdmStructuredType, List<IEdmStructuredType>>();
foreach (var type in schemaElements.OfType<IEdmSchemaType>())
{
var enumType = type as IEdmEnumType;
if (enumType != null)
{
WriteEnumType(enumType);
}
else
{
var complexType = type as IEdmComplexType;
if (complexType != null)
{
WriteComplexType(complexType, boundOperationsMap);
}
else
{
var entityType = type as IEdmEntityType;
WriteEntityType(entityType, boundOperationsMap);
}
var structuredType = type as IEdmStructuredType;
if (structuredType.BaseType != null)
{
List<IEdmStructuredType> derivedTypes;
if (!structuredBaseTypeMap.TryGetValue(structuredType.BaseType, out derivedTypes))
{
structuredBaseTypeMap[structuredType.BaseType] = new List<IEdmStructuredType>();
}
structuredBaseTypeMap[structuredType.BaseType].Add(structuredType);
}
}
}
if (schemaElements.OfType<IEdmEntityType>().Any() ||
schemaElements.OfType<IEdmOperation>().Any(o => o.IsBound))
{
WriteExtensionMethodsStart();
foreach (var type in schemaElements.OfType<IEdmEntityType>())
{
var entityTypeName = type.Name;
entityTypeName = Context.EnableNamingAlias ? Customization.CustomizeNaming(entityTypeName) : entityTypeName;
var entityTypeFullName = Context.GetPrefixedFullName(type, GetFixedName(entityTypeName), this);
var returnTypeName = Context.GetPrefixedFullName(type, GetFixedName(entityTypeName + SingleSuffix), this);
var keyProperties = type.Key();
if (keyProperties != null && keyProperties.Any())
{
var keyParameters = new List<string>();
var keyDictionaryItems = new List<string>();
var keyNames = new List<string>();
foreach (IEdmProperty key in keyProperties)
{
var typeName = Utils.GetClrTypeName(key.Type, Context.UseDataServiceCollection, this, Context);
var keyName = Utils.CamelCase(key.Name);
keyNames.Add(keyName);
keyParameters.Add(string.Format(ParameterDeclarationTemplate, typeName, GetFixedName(keyName)));
keyDictionaryItems.Add(string.Format(DictionaryItemConstructor, "\"" + key.Name + "\"", GetFixedName(keyName)));
}
var keyParametersString = string.Join(KeyParameterSeparator, keyParameters);
var keyDictionaryItemsString = string.Join(KeyDictionaryItemSeparator, keyDictionaryItems);
WriteByKeyMethods(entityTypeFullName, returnTypeName, keyNames, keyParametersString, keyDictionaryItemsString);
}
var current = (IEdmEntityType)type.BaseType;
while (current != null)
{
var baseTypeName = current.Name;
baseTypeName = Context.EnableNamingAlias ? Customization.CustomizeNaming(baseTypeName) : baseTypeName;
baseTypeName = Context.GetPrefixedFullName(current, GetFixedName(baseTypeName), this);
WriteCastToMethods(baseTypeName, entityTypeName, entityTypeFullName, returnTypeName);
current = (IEdmEntityType)current.BaseType;
}
}
var boundOperations = new HashSet<string>(StringComparer.Ordinal);
foreach (var function in schemaElements.OfType<IEdmFunction>())
{
if (function.IsBound)
{
var edmTypeReference = function.Parameters.First().Type;
var functionName = Context.EnableNamingAlias ? Customization.CustomizeNaming(function.Name) : function.Name;
string parameterString, parameterExpressionString, parameterTypes, parameterValues;
bool useEntityReference;
GetParameterStrings(function.IsBound, false, function.Parameters.ToArray(), out parameterString, out parameterTypes, out parameterExpressionString, out parameterValues, out useEntityReference);
var sourceTypeName = GetSourceOrReturnTypeName(edmTypeReference);
sourceTypeName = string.Format(edmTypeReference.IsCollection() ? DataServiceQueryStructureTemplate : DataServiceQuerySingleStructureTemplate, sourceTypeName);
var returnTypeName = GetSourceOrReturnTypeName(function.ReturnType);
var fixedFunctionName = GetFixedName(functionName);
var func = string.Format("{0}({1},{2})", fixedFunctionName, sourceTypeName, parameterTypes);
if (!boundOperations.Contains(func))
{
boundOperations.Add(func);
if (function.ReturnType.IsCollection())
{
WriteBoundFunctionReturnCollectionResultAsExtension(fixedFunctionName, function.Name, sourceTypeName, returnTypeName, parameterString, function.Namespace, parameterValues, function.IsComposable, useEntityReference);
}
else
{
WriteBoundFunctionReturnSingleResultAsExtension(fixedFunctionName, function.Name, sourceTypeName, returnTypeName, parameterString, function.Namespace, parameterValues, function.IsComposable, function.ReturnType.IsEntity(), useEntityReference);
}
}
IEdmStructuredType structuredType;
if (edmTypeReference.IsCollection())
{
var collectionType = edmTypeReference.Definition as IEdmCollectionType;
structuredType = (IEdmStructuredType)collectionType.ElementType.Definition;
}
else
{
structuredType = (IEdmStructuredType)edmTypeReference.Definition;
}
List<IEdmStructuredType> derivedTypes;
if (structuredBaseTypeMap.TryGetValue(structuredType, out derivedTypes))
{
foreach (var type in derivedTypes)
{
IEdmTypeReference derivedTypeReference = new EdmEntityTypeReference((IEdmEntityType)type, true);
var currentParameters = function.Parameters.Select(p => p.Type).ToList();
currentParameters[0] = derivedTypeReference;
sourceTypeName = string.Format(edmTypeReference.IsCollection() ? DataServiceQueryStructureTemplate : DataServiceQuerySingleStructureTemplate, GetSourceOrReturnTypeName(derivedTypeReference));
var currentFunc = string.Format("{0}({1},{2})", fixedFunctionName, sourceTypeName, parameterTypes);
if (!boundOperations.Contains(currentFunc))
{
boundOperations.Add(currentFunc);
if (function.ReturnType.IsCollection())
{
WriteBoundFunctionReturnCollectionResultAsExtension(fixedFunctionName, function.Name, sourceTypeName, returnTypeName, parameterString, function.Namespace, parameterValues, function.IsComposable, useEntityReference);
}
else
{
WriteBoundFunctionReturnSingleResultAsExtension(fixedFunctionName, function.Name, sourceTypeName, returnTypeName, parameterString, function.Namespace, parameterValues, function.IsComposable, function.ReturnType.IsEntity(), useEntityReference);
}
}
}
}
}
}
foreach (var action in schemaElements.OfType<IEdmAction>())
{
if (action.IsBound)
{
var edmTypeReference = action.Parameters.First().Type;
var actionName = Context.EnableNamingAlias ? Customization.CustomizeNaming(action.Name) : action.Name;
string parameterString, parameterExpressionString, parameterTypes, parameterValues;
bool useEntityReference;
GetParameterStrings(action.IsBound, true, action.Parameters.ToArray(), out parameterString, out parameterTypes, out parameterExpressionString, out parameterValues, out useEntityReference);
var sourceTypeName = GetSourceOrReturnTypeName(edmTypeReference);
sourceTypeName = string.Format(edmTypeReference.IsCollection() ? DataServiceQueryStructureTemplate : DataServiceQuerySingleStructureTemplate, sourceTypeName);
string returnTypeName;
if (action.ReturnType != null)
{
returnTypeName = GetSourceOrReturnTypeName(action.ReturnType);
if (action.ReturnType.IsCollection())
{
returnTypeName = string.Format(DataServiceActionQueryOfTStructureTemplate, returnTypeName);
}
else
{
returnTypeName = string.Format(DataServiceActionQuerySingleOfTStructureTemplate, returnTypeName);
}
}
else
{
returnTypeName = DataServiceActionQueryTypeName;
}
var fixedActionName = GetFixedName(actionName);
var ac = string.Format("{0}({1},{2})", fixedActionName, sourceTypeName, parameterTypes);
if (!boundOperations.Contains(ac))
{
boundOperations.Add(ac);
WriteBoundActionAsExtension(fixedActionName, action.Name, sourceTypeName, returnTypeName, parameterString, action.Namespace, parameterValues);
}
IEdmStructuredType structuredType;
if (edmTypeReference.IsCollection())
{
var collectionType = edmTypeReference.Definition as IEdmCollectionType;
structuredType = (IEdmStructuredType)collectionType.ElementType.Definition;
}
else
{
structuredType = (IEdmStructuredType)edmTypeReference.Definition;
}
List<IEdmStructuredType> derivedTypes;
if (structuredBaseTypeMap.TryGetValue(structuredType, out derivedTypes))
{
foreach (var type in derivedTypes)
{
IEdmTypeReference derivedTypeReference = new EdmEntityTypeReference((IEdmEntityType)type, true);
var currentParameters = action.Parameters.Select(p => p.Type).ToList();
currentParameters[0] = derivedTypeReference;
sourceTypeName = string.Format(edmTypeReference.IsCollection() ? DataServiceQueryStructureTemplate : DataServiceQuerySingleStructureTemplate, GetSourceOrReturnTypeName(derivedTypeReference));
var currentAc = string.Format("{0}({1},{2})", fixedActionName, sourceTypeName, parameterTypes);
if (!boundOperations.Contains(currentAc))
{
boundOperations.Add(currentAc);
WriteBoundActionAsExtension(fixedActionName, action.Name, sourceTypeName, returnTypeName, parameterString, action.Namespace, parameterValues);
}
}
}
}
}
WriteExtensionMethodsEnd();
}
WriteNamespaceEnd();
}
public void GetParameterValue_Returns_FunctionParameterValue()
{
// Arrange
string parameterName = "Parameter";
EdmModel model = new EdmModel();
var entityType = new EdmEntityType("NS", "Customer");
model.AddElement(entityType);
IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false);
IEdmTypeReference parameterType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false);
IEdmTypeReference bindingParamterType = new EdmEntityTypeReference(entityType, isNullable: false);
EdmFunction function = new EdmFunction("NS", "Function", returnType);
function.AddParameter("bindingParameter", bindingParamterType);
function.AddParameter(parameterName, parameterType);
model.AddElement(function);
IDictionary<string, string> parameterValues = new Dictionary<string, string>();
parameterValues.Add(parameterName, "101");
// Act
BoundFunctionPathSegment segment = new BoundFunctionPathSegment(function, model, parameterValues);
var result = segment.GetParameterValue(parameterName);
// Assert
Assert.Equal("System.Int32", result.GetType().FullName);
Assert.Equal("101", result.ToString());
}
public Object ParseAsync(HttpResponseMessage response)
{
using (Stream stream = response.Content.ReadAsStreamAsync().Result)
{
var responseMessage = new ODataResponseMessage(stream);
var context = new ODataDeserializerContext() { Model = Model, Request = response.RequestMessage };
using (var messageReader = new ODataMessageReader(responseMessage, _settings, Model))
{
ODataResult result = GetODataResult(messageReader);
while (result.ODataReader.Read())
{
if (result.ODataReader.State == ODataReaderState.EntryEnd)
{
var entry = (ODataEntry)result.ODataReader.Item;
var entityType = (IEdmEntityType)Model.FindType(entry.TypeName);
var entityTypeReference = new EdmEntityTypeReference(entityType, false);
var navigationLinks = new ODataEntryWithNavigationLinks(entry);
result.AddResult(_deserializer.ReadEntry(navigationLinks, entityTypeReference, context));
}
}
return result.Result;
}
}
}
public void GetDefaultValue_NonNullableEntity()
{
IEdmTypeReference nonNullableEntityType = new EdmEntityTypeReference(new EdmEntityType("NS", "Entity"), isNullable: false);
var result = EdmStructuredObject.GetDefaultValue(nonNullableEntityType);
var entityObject = Assert.IsType<EdmEntityObject>(result);
Assert.Equal(nonNullableEntityType, entityObject.GetEdmType(), new EdmTypeReferenceEqualityComparer());
}
public void PrimitiveIsXXXMethods()
{
IEdmPrimitiveTypeReference binaryRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Binary), false);
IEdmPrimitiveTypeReference booleanRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Boolean), false);
IEdmPrimitiveTypeReference byteRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Byte), false);
IEdmPrimitiveTypeReference dateTimeOffsetRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.DateTimeOffset), false);
IEdmPrimitiveTypeReference decimalRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Decimal), false);
IEdmPrimitiveTypeReference doubleRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Double), false);
IEdmPrimitiveTypeReference guidRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Guid), false);
IEdmPrimitiveTypeReference int16Ref = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int16), false);
IEdmPrimitiveTypeReference int32Ref = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32), false);
IEdmPrimitiveTypeReference int64Ref = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int64), false);
IEdmPrimitiveTypeReference sByteRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.SByte), false);
IEdmPrimitiveTypeReference singleRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Single), false);
IEdmPrimitiveTypeReference stringRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), false);
IEdmPrimitiveTypeReference streamRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Stream), false);
IEdmPrimitiveTypeReference timeRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Duration), false);
IEdmPrimitiveTypeReference dateRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Date), false);
IEdmPrimitiveTypeReference timeOfDayRef = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.TimeOfDay), false);
Assert.IsTrue(binaryRef.IsPrimitive(), "Binary is Primitive");
Assert.IsTrue(binaryRef.IsBinary(), "Binary is Binary");
Assert.IsTrue(booleanRef.IsBoolean(), "Boolean is Boolean");
Assert.IsTrue(byteRef.IsByte(), "Byte is Byte");
Assert.IsTrue(dateTimeOffsetRef.IsDateTimeOffset(), "DateTimeOffset is DateTimeOffset");
Assert.IsTrue(decimalRef.IsDecimal(), "Decimal is Decimal");
Assert.IsTrue(doubleRef.IsDouble(), "Double is Double");
Assert.IsTrue(guidRef.IsGuid(), "Guid is Guid");
Assert.IsTrue(int16Ref.IsInt16(), "Int16 is Int16");
Assert.IsTrue(int32Ref.IsInt32(), "Int32 is Int32");
Assert.IsTrue(int64Ref.IsInt64(), "Int64 is Int64");
Assert.IsTrue(sByteRef.IsSByte(), "SByte is SByte");
Assert.IsTrue(singleRef.IsSingle(), "Single is Single");
Assert.IsTrue(stringRef.IsString(), "String is String");
Assert.IsTrue(streamRef.IsStream(), "Stream is Stream");
Assert.IsTrue(timeRef.IsDuration(), "Duration is Duration");
Assert.IsTrue(dateRef.IsDate(), "Date is Date");
Assert.IsTrue(timeOfDayRef.IsTimeOfDay(), "TimeOfDay is TimeOfDay");
Assert.IsTrue(binaryRef.AsPrimitive().IsPrimitive(), "Binary as primitive is Primitive");
Assert.IsTrue(binaryRef.AsPrimitive().IsBinary(), "Binary as primitive is Binary");
Assert.IsTrue(booleanRef.AsPrimitive().IsBoolean(), "Boolean as primitive is Boolean");
Assert.IsTrue(byteRef.AsPrimitive().IsByte(), "Byte as primitive is Byte");
Assert.IsTrue(dateTimeOffsetRef.AsPrimitive().IsDateTimeOffset(), "DateTimeOffset as primitive is DateTimeOffset");
Assert.IsTrue(decimalRef.AsPrimitive().IsDecimal(), "Decimal as primitive is Decimal");
Assert.IsTrue(doubleRef.AsPrimitive().IsDouble(), "Double as primitive is Double");
Assert.IsTrue(guidRef.AsPrimitive().IsGuid(), "Guid as primitive is Guid");
Assert.IsTrue(int16Ref.AsPrimitive().IsInt16(), "Int16 as primitive is Int16");
Assert.IsTrue(int32Ref.AsPrimitive().IsInt32(), "Int32 as primitive is Int32");
Assert.IsTrue(int64Ref.AsPrimitive().IsInt64(), "Int64 as primitive is Int64");
Assert.IsTrue(sByteRef.AsPrimitive().IsSByte(), "SByte as primitive is SByte");
Assert.IsTrue(singleRef.AsPrimitive().IsSingle(), "Single as primitive is Single");
Assert.IsTrue(stringRef.AsPrimitive().IsString(), "String as primitive is String");
Assert.IsTrue(streamRef.AsPrimitive().IsStream(), "Stream as primitive is Stream");
Assert.IsTrue(timeRef.AsPrimitive().IsDuration(), "Duration as primitive is Duration");
Assert.IsTrue(dateRef.AsPrimitive().IsDate(), "Date as primitive is Date");
Assert.IsTrue(timeOfDayRef.AsPrimitive().IsTimeOfDay(), "TimeOfDay as primitive is TimeOfDay");
Assert.IsTrue(dateTimeOffsetRef.IsTemporal(), "DateTimeOffset is Temporal");
Assert.IsTrue(timeRef.IsTemporal(), "Duration is Temporal");
Assert.IsTrue(timeOfDayRef.IsTemporal(), "TimeOfDay is Temporal");
Assert.IsFalse(int32Ref.IsTemporal(), "Int is not Temporal");
Assert.IsTrue(doubleRef.IsFloating(), "Double is floating");
Assert.IsTrue(singleRef.IsFloating(), "Single is floating");
Assert.IsFalse(int32Ref.IsFloating(), "Int is not floating");
Assert.IsTrue(sByteRef.IsSignedIntegral(), "SByte is signed integral");
Assert.IsTrue(int16Ref.IsSignedIntegral(), "Int16 is signed integral");
Assert.IsTrue(int32Ref.IsSignedIntegral(), "Int32 is signed integral");
Assert.IsTrue(int64Ref.IsSignedIntegral(), "Int64 is signed integral");
Assert.IsFalse(stringRef.IsSignedIntegral(), "String is not signed integral");
IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "MyEntity");
IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false);
Assert.AreEqual(EdmPrimitiveTypeKind.None, entityRef.PrimitiveKind(), "Non-Primitive Type has primitivetypekind of none");
Assert.AreEqual(EdmSchemaElementKind.TypeDefinition, int16Ref.PrimitiveDefinition().SchemaElementKind,"SchemaElementKind of primitive type is correct.");
}
