public void VerifyNullableIsWrittenInChildReturnTypeElementForCollectionElementType()
{
var action = new EdmAction("Default.Namespace", "Checkout", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(isUnbounded: false, maxLength: 10, isUnicode: false, isNullable: false)));
VisitAndVerifyXml(
(visitor) => visitor.VisitSchemaElement(action),
@"<Action Name=""Checkout""><ReturnType Type=""Collection(Edm.String)"" Nullable=""false"" MaxLength=""10"" Unicode=""false"" /></Action>");
}
public void VerifyNoReturnTypeElementIsWrittenWhenNoReturnTypeIsProvided()
{
var action = new EdmAction("Default.Namespace", "Checkout", null);
VisitAndVerifyXml(
(visitor) => visitor.VisitSchemaElement(action),
@"<Action Name=""Checkout"" />");
}
public void VerifyPrimitiveReturnTypeDefinedInChildReturnTypeElement()
{
var action = new EdmAction("Default.Namespace", "Checkout", EdmCoreModel.Instance.GetString(false));
VisitAndVerifyXml(
(visitor) => visitor.VisitSchemaElement(action),
@"<Action Name=""Checkout""><ReturnType Type=""Edm.String"" Nullable=""false"" /></Action>");
}
public void EdmActionConstructorWithNullReturnTypeShouldNotThrow()
{
var edmAction = new EdmAction(defaultNamespaceName, checkout, null);
edmAction.Namespace.Should().Be(defaultNamespaceName);
edmAction.Name.Should().Be(checkout);
edmAction.ReturnType.Should().BeNull();
}
public Task ExtendModelAsync(
ModelContext context,
CancellationToken cancellationToken)
{
var model = context.Model;
var entityContainer = model.EntityContainer as EdmEntityContainer;
foreach (ActionMethodInfo actionInfo in this.ActionInfos)
{
var returnTypeReference = ConventionalActionProvider.GetReturnTypeReference(actionInfo.Method.ReturnType);
var action = new EdmAction(entityContainer.Namespace, actionInfo.ActionName, returnTypeReference);
foreach (ParameterInfo parameter in actionInfo.Method.GetParameters())
{
EdmOperationParameter actionParam = new EdmOperationParameter(
action,
parameter.Name,
ConventionalActionProvider.GetTypeReference(parameter.ParameterType));
action.AddParameter(actionParam);
}
model.AddElement(action);
if (!action.IsBound)
{
EdmActionImport actionImport = new EdmActionImport(entityContainer, action.Name, action);
entityContainer.AddElement(actionImport);
}
}
return Task.FromResult<object>(null);
}
public void VerifyOperationParameterWritten()
{
var action = new EdmAction("Default.Namespace", "Checkout", null);
action.AddParameter("firstParameter", EdmCoreModel.Instance.GetSingle(true));
VisitAndVerifyXml(
(visitor) => visitor.VisitSchemaElement(action),
@"<Action Name=""Checkout""><Parameter Name=""firstParameter"" Type=""Edm.Single"" /></Action>");
}
public void VerifyEntityReturnTypeDefinedInChildReturnTypeElement()
{
var entityType = new EdmEntityType("NS.ds", "EntityType");
var action = new EdmAction("Default.Namespace", "Checkout", new EdmEntityTypeReference(entityType, false));
VisitAndVerifyXml(
(visitor) => visitor.VisitSchemaElement(action),
@"<Action Name=""Checkout""><ReturnType Type=""NS.ds.EntityType"" Nullable=""false"" /></Action>");
}
public ODataJsonLightParameterReaderTests()
{
referencedModel = new EdmModel();
referencedModel.Fixup();
this.action = new EdmAction("FQ.NS", "ActionImport", null);
referencedModel.AddElement(this.action);
this.model = TestUtils.WrapReferencedModelsToMainModel("TestModel", "DefaultContainer", referencedModel);
}
public void Init()
{
referencedModel = new EdmModel();
referencedModel.Fixup();
this.action = new EdmAction("FQ.NS", "ActionImport", null);
referencedModel.AddElement(this.action);
this.model = TestUtils.WrapReferencedModelsToMainModel("TestModel", "DefaultContainer", referencedModel);
}
public void EdmActionImportConstructorShouldDefaultNonSpecifiedPropertiesCorrectly()
{
var edmAction = new EdmAction("DefaultNamespace", "Checkout", this.boolType);
var edmActionImport = new EdmActionImport(this.entityContainer, "CheckoutImport", edmAction, null);
edmActionImport.Name.Should().Be("CheckoutImport");
edmActionImport.EntitySet.Should().BeNull();
edmActionImport.Container.Should().Be(this.entityContainer);
edmActionImport.Action.Should().Be(edmAction);
}
public void GetActionLinkBuilder_ReturnsDefaultActionLinkBuilder_IfNotSet()
{
// Arrange
IEdmModel model = new EdmModel();
IEdmEntityContainer container = new EdmEntityContainer("NS", "Container");
IEdmAction action = new EdmAction("NS", "Action", returnType: null);
Assert.NotNull(model.GetActionLinkBuilder(action));
}
public static IEdmModel CreateServiceEdmModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "PerfInMemoryContainer");
model.AddElement(defaultContainer);
var personType = new EdmEntityType(ns, "Person");
var personIdProperty = new EdmStructuralProperty(personType, "PersonID", EdmCoreModel.Instance.GetInt32(false));
personType.AddProperty(personIdProperty);
personType.AddKeys(new IEdmStructuralProperty[] { personIdProperty });
personType.AddProperty(new EdmStructuralProperty(personType, "FirstName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "LastName", EdmCoreModel.Instance.GetString(false)));
personType.AddProperty(new EdmStructuralProperty(personType, "MiddleName", EdmCoreModel.Instance.GetString(true)));
personType.AddProperty(new EdmStructuralProperty(personType, "Age", EdmCoreModel.Instance.GetInt32(false)));
model.AddElement(personType);
var simplePersonSet = new EdmEntitySet(defaultContainer, "SimplePeopleSet", personType);
defaultContainer.AddElement(simplePersonSet);
var largetPersonSet = new EdmEntitySet(defaultContainer, "LargePeopleSet", personType);
defaultContainer.AddElement(largetPersonSet);
var addressType = new EdmComplexType(ns, "Address");
addressType.AddProperty(new EdmStructuralProperty(addressType, "Street", EdmCoreModel.Instance.GetString(false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "City", EdmCoreModel.Instance.GetString(false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "PostalCode", EdmCoreModel.Instance.GetString(false)));
model.AddElement(addressType);
var companyType = new EdmEntityType(ns, "Company");
var companyId = new EdmStructuralProperty(companyType, "CompanyID", EdmCoreModel.Instance.GetInt32(false));
companyType.AddProperty(companyId);
companyType.AddKeys(companyId);
companyType.AddProperty(new EdmStructuralProperty(companyType, "Name", EdmCoreModel.Instance.GetString(true)));
companyType.AddProperty(new EdmStructuralProperty(companyType, "Address", new EdmComplexTypeReference(addressType, true)));
companyType.AddProperty(new EdmStructuralProperty(companyType, "Revenue", EdmCoreModel.Instance.GetInt32(false)));
model.AddElement(companyType);
var companySet = new EdmEntitySet(defaultContainer, "CompanySet", companyType);
defaultContainer.AddElement(companySet);
var companyEmployeeNavigation = companyType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Employees",
Target = personType,
TargetMultiplicity = EdmMultiplicity.Many
});
companySet.AddNavigationTarget(companyEmployeeNavigation, largetPersonSet);
// ResetDataSource
var resetDataSourceAction = new EdmAction(ns, "ResetDataSource", null, false, null);
model.AddElement(resetDataSourceAction);
defaultContainer.AddActionImport(resetDataSourceAction);
return model;
}
public void EnsureActionImportIsAddedAndWithCorrectSuppliedName()
{
EdmEntityContainer container = new EdmEntityContainer("Default", "Container");
EdmAction action = new EdmAction("DS", "TestAction", EdmCoreModel.Instance.GetBoolean(false));
var actionImport = container.AddActionImport("OtherName", action);
actionImport.Action.Should().Be(action);
actionImport.Name.Should().Be("OtherName");
container.Elements.ToArray()[0].Should().Be(actionImport);
}
public void EdmActionConstructorShouldDefaultNonSpecifiedPropertiesCorrectly()
{
var edmAction = new EdmAction(defaultNamespaceName, checkout, this.boolType);
edmAction.Namespace.Should().Be(defaultNamespaceName);
edmAction.Name.Should().Be(checkout);
edmAction.ReturnType.Should().Be(this.boolType);
edmAction.EntitySetPath.Should().BeNull();
edmAction.IsBound.Should().BeFalse();
edmAction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Action);
}
public void EdmActionConstructorShouldHaveSpecifiedConstructorValues()
{
var entitySetPath = new EdmPathExpression("Param1/Nav");
var edmAction = new EdmAction(defaultNamespaceName, checkout, this.boolType, true, entitySetPath);
edmAction.AddParameter(new EdmOperationParameter(edmAction, "Param1", new EdmEntityTypeReference(personType, false)));
edmAction.Namespace.Should().Be(defaultNamespaceName);
edmAction.Name.Should().Be(checkout);
edmAction.ReturnType.Should().Be(this.boolType);
edmAction.EntitySetPath.Should().Be(entitySetPath);
edmAction.IsBound.Should().BeTrue();
edmAction.SchemaElementKind.Should().Be(EdmSchemaElementKind.Action);
}
public ODataSwaggerUtilitiesTest()
{
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
_customer = model.Customer;
_customers = model.Customers;
IEdmAction action = new EdmAction("NS", "GetCustomers", null, false, null);
_getCustomers = new EdmActionImport(model.Container, "GetCustomers", action);
_isAnyUpgraded = model.Model.SchemaElements.OfType<IEdmFunction>().FirstOrDefault(e => e.Name == "IsAnyUpgraded");
_isCustomerUpgradedWithParam = model.Model.SchemaElements.OfType<IEdmFunction>().FirstOrDefault(e => e.Name == "IsUpgradedWithParam");
}
public void EnsureActionImportIsAddedAndWithCorrectEntitySetExpression()
{
EdmEntityContainer container = new EdmEntityContainer("Default", "Container");
EdmAction action = new EdmAction("DS", "TestAction", EdmCoreModel.Instance.GetBoolean(false));
var edmEntitySet = new EdmEntitySet(container, "EntitySet", new EdmEntityType("DS", "TestEntity"));
var entitySetExpression = new EdmEntitySetReferenceExpression(edmEntitySet);
var actionImport = container.AddActionImport("OtherName", action, entitySetExpression);
actionImport.Action.Should().Be(action);
actionImport.Name.Should().Be("OtherName");
actionImport.EntitySet.Should().Be(entitySetExpression);
container.Elements.ToArray()[0].Should().Be(actionImport);
}
public void EdmActionImportConstructorShouldHaveSpecifiedConstructorValues()
{
var actionEntitySetPath = new EdmPathExpression("Param1/Nav");
var edmAction = new EdmAction("DefaultNamespace", "Checkout", this.boolType, true, actionEntitySetPath);
edmAction.AddParameter(new EdmOperationParameter(edmAction, "Param1", new EdmEntityTypeReference(personType, true)));
var actionImportEntitySetPath = new EdmPathExpression("Param1/Nav2");
var edmActionImport = new EdmActionImport(this.entityContainer, "checkoutImport", edmAction, actionImportEntitySetPath);
edmActionImport.Name.Should().Be("checkoutImport");
edmActionImport.Container.Should().Be(this.entityContainer);
edmActionImport.EntitySet.Should().Be(actionImportEntitySetPath);
edmActionImport.Action.Should().Be(edmAction);
}
public void AmbigiousOperationBindingShouldReferToFirstOperationAlwaysWhenNotNull()
{
var action1 = new EdmAction("DS", "name", EdmCoreModel.Instance.GetBoolean(false));
action1.AddParameter("param", EdmCoreModel.Instance.GetBoolean(false));
var function = new EdmFunction("DS2", "name2", EdmCoreModel.Instance.GetBoolean(false), true, new EdmPathExpression("path1"), true);
AmbiguousOperationBinding ambigiousOperationBinding = new AmbiguousOperationBinding(action1, function);
ambigiousOperationBinding.Namespace.Should().Be("DS");
ambigiousOperationBinding.Name.Should().Be("name");
ambigiousOperationBinding.ReturnType.Should().BeNull();
ambigiousOperationBinding.Parameters.Should().HaveCount(1);
ambigiousOperationBinding.SchemaElementKind.Should().Be(EdmSchemaElementKind.Action);
ambigiousOperationBinding.IsBound.Should().BeFalse();
ambigiousOperationBinding.EntitySetPath.Should().BeNull();
}
public void Initialize()
{
this.edmModel = new EdmModel();
this.defaultContainer = new EdmEntityContainer("TestModel", "DefaultContainer");
this.edmModel.AddElement(this.defaultContainer);
this.townType = new EdmEntityType("TestModel", "Town");
this.edmModel.AddElement(townType);
EdmStructuralProperty townIdProperty = townType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/false));
townType.AddKeys(townIdProperty);
townType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(/*isNullable*/false));
townType.AddStructuralProperty("Size", EdmCoreModel.Instance.GetInt32(/*isNullable*/false));
this.cityType = new EdmEntityType("TestModel", "City", this.townType);
cityType.AddStructuralProperty("Photo", EdmCoreModel.Instance.GetStream(/*isNullable*/false));
this.edmModel.AddElement(cityType);
this.districtType = new EdmEntityType("TestModel", "District");
EdmStructuralProperty districtIdProperty = districtType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/false));
districtType.AddKeys(districtIdProperty);
districtType.AddStructuralProperty("Zip", EdmCoreModel.Instance.GetInt32(/*isNullable*/false));
districtType.AddStructuralProperty("Thumbnail", EdmCoreModel.Instance.GetStream(/*isNullable*/false));
this.edmModel.AddElement(districtType);
cityType.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo { Name = "Districts", Target = districtType, TargetMultiplicity = EdmMultiplicity.Many },
new EdmNavigationPropertyInfo { Name = "City", Target = cityType, TargetMultiplicity = EdmMultiplicity.One });
this.defaultContainer.AddEntitySet("Cities", cityType);
this.defaultContainer.AddEntitySet("Districts", districtType);
this.metropolisType = new EdmEntityType("TestModel", "Metropolis", this.cityType);
this.metropolisType.AddStructuralProperty("MetropolisStream", EdmCoreModel.Instance.GetStream(/*isNullable*/false));
this.edmModel.AddElement(metropolisType);
metropolisType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "MetropolisNavigation", Target = districtType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne });
this.action = new EdmAction("TestModel", "Action", new EdmEntityTypeReference(this.cityType, true));
this.action.AddParameter("Param", EdmCoreModel.Instance.GetInt32(false));
this.edmModel.AddElement(action);
this.actionImport = new EdmActionImport(this.defaultContainer, "Action", action);
this.actionConflictingWithPropertyName = new EdmAction("TestModel", "Zip", new EdmEntityTypeReference(this.districtType, true));
this.actionConflictingWithPropertyName.AddParameter("Param", EdmCoreModel.Instance.GetInt32(false));
this.edmModel.AddElement(actionConflictingWithPropertyName);
this.actionImportConflictingWithPropertyName = new EdmActionImport(this.defaultContainer, "Zip", actionConflictingWithPropertyName);
this.openType = new EdmEntityType("TestModel", "OpenCity", this.cityType, false, true);
}
public MissingOperationGeneratorTests()
{
this.model = new EdmModel();
this.container = new EdmEntityContainer("Fake", "Container");
this.functionEdmMetadata = new EdmFunction("Fake", "FakeFunction", EdmCoreModel.Instance.GetInt32(false), true /*isBound*/, null, true /*isComposable*/);
this.actionEdmMetadata = new EdmAction("Fake", "FakeAction", EdmCoreModel.Instance.GetInt32(false), true/*isBound*/, null /*entitySetPath*/);
this.model.AddElement(this.container);
this.model.AddElement(this.actionEdmMetadata);
this.model.AddElement(this.functionEdmMetadata);
this.allOperations = new EdmOperation[] { this.actionEdmMetadata, this.functionEdmMetadata };
this.odataAction = new ODataAction {Metadata = new Uri("http://temp.org/$metadata#Fake.FakeAction")};
this.odataFunction = new ODataFunction {Metadata = new Uri("http://temp.org/$metadata#Fake.FakeFunction")};
}
public void AddOperationWhileTypeHasSameNameButOneIsAction()
{
EdmModel model = new EdmModel();
EdmComplexType c1 = new EdmComplexType("Ambiguous", "Binding");
IEdmOperation o1 = new EdmFunction("Ambiguous", "Binding", EdmCoreModel.Instance.GetInt16(true));
IEdmOperation o2 = new EdmAction("Ambiguous", "Binding", EdmCoreModel.Instance.GetInt16(true));
IEdmOperation o3 = new EdmFunction("Ambiguous", "Binding", EdmCoreModel.Instance.GetInt16(true));
model.AddElement(o1);
Assert.AreEqual(1, model.FindOperations("Ambiguous.Binding").Count(), "First function was correctly added to operation group");
model.AddElement(o2);
Assert.AreEqual(2, model.FindOperations("Ambiguous.Binding").Count(), "Second function was correctly added to operation group");
model.AddElement(c1);
model.AddElement(o3);
Assert.AreEqual(3, model.FindOperations("Ambiguous.Binding").Count(), "Third function was correctly added to operation group");
Assert.AreEqual(c1, model.FindType("Ambiguous.Binding"), "Single item resolved");
}
private IEdmModel CreateTestModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "Default");
model.AddElement(defaultContainer);
var productType = new EdmEntityType("TestModel", "Product");
EdmStructuralProperty idProperty = new EdmStructuralProperty(productType, "Id", EdmCoreModel.Instance.GetInt32(false));
productType.AddProperty(idProperty);
productType.AddKeys(idProperty);
productType.AddProperty(new EdmStructuralProperty(productType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(productType);
var customerType = new EdmEntityType("TestModel", "Customer");
idProperty = new EdmStructuralProperty(customerType, "Id", EdmCoreModel.Instance.GetInt32(false));
customerType.AddProperty(idProperty);
customerType.AddKeys(idProperty);
customerType.AddProperty(new EdmStructuralProperty(customerType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(productType);
defaultContainer.AddEntitySet("Products", productType);
defaultContainer.AddEntitySet("Customers", customerType);
defaultContainer.AddSingleton("SingleProduct", productType);
defaultContainer.AddSingleton("SingleCustomer", customerType);
EdmAction action = new EdmAction("TestModel", "SimpleAction", null/*returnType*/, false /*isBound*/, null /*entitySetPath*/);
model.AddElement(action);
defaultContainer.AddActionImport("SimpleActionImport", action);
EdmFunction function1 = new EdmFunction("TestModel", "SimpleFunction1", EdmCoreModel.Instance.GetInt32(false), false /*isbound*/, null, true);
function1.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false));
defaultContainer.AddFunctionImport("SimpleFunctionImport1", function1);
EdmFunction function2 = new EdmFunction("TestModel", "SimpleFunction2", EdmCoreModel.Instance.GetInt32(false), false /*isbound*/, null, true);
function2.AddParameter("p1", EdmCoreModel.Instance.GetInt32(false));
defaultContainer.AddFunctionImport("SimpleFunctionImport2", function1, null, true /*IncludeInServiceDocument*/);
return model;
}
static ODataEntryMetadataContextTest()
{
ActualEntityType = new EdmEntityType("ns", "TypeName");
ActualEntityType.AddKeys(new IEdmStructuralProperty[] {ActualEntityType.AddStructuralProperty("ID2", EdmPrimitiveTypeKind.Int32), ActualEntityType.AddStructuralProperty("ID3", EdmPrimitiveTypeKind.Int32)});
ActualEntityType.AddStructuralProperty("Name2", EdmCoreModel.Instance.GetString(isNullable:true), /*defaultValue*/null, EdmConcurrencyMode.Fixed);
ActualEntityType.AddStructuralProperty("Name3", EdmCoreModel.Instance.GetString(isNullable: true), /*defaultValue*/null, EdmConcurrencyMode.Fixed);
ActualEntityType.AddStructuralProperty("StreamProp1", EdmPrimitiveTypeKind.Stream);
ActualEntityType.AddStructuralProperty("StreamProp2", EdmPrimitiveTypeKind.Stream);
var navProp1 = ActualEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = ActualEntityType,
TargetMultiplicity = EdmMultiplicity.Many,
Name = "NavProp1"
});
var navProp2 = ActualEntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Target = ActualEntityType,
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
Name = "NavProp2"
});
var container = new EdmEntityContainer("Namespace", "Container");
EdmEntitySet entitySet = container.AddEntitySet("EntitySet", ActualEntityType);
entitySet.AddNavigationTarget(navProp1, entitySet);
entitySet.AddNavigationTarget(navProp2, entitySet);
Action1 = new EdmAction("Namespace", "Action1", null, true /*isBound*/, null /*entitySetPath*/);
Action2 = new EdmAction("Namespace", "Action2", null, true /*isBound*/, null /*entitySetPath*/);
ActionImport1 = new EdmActionImport(container, "ActionImport1", Action1);
ActionImport2 = new EdmActionImport(container, "ActionImport2", Action2);
Function1 = new EdmFunction("Namespace", "Function1", EdmCoreModel.Instance.GetString(isNullable: true), true /*isBound*/, null /*entitySetPath*/, true /*isComposable*/);
Function2 = new EdmFunction("Namespace", "Function2", EdmCoreModel.Instance.GetString(isNullable: true), true /*isBound*/, null /*entitySetPath*/, true /*isComposable*/);
FunctionImport1 = new EdmFunctionImport(container, "FunctionImport1", Function1);
FunctionImport2 = new EdmFunctionImport(container, "FunctionImport2", Function2);
}
static ODataJsonLightEntryAndFeedDeserializerTests()
{
EdmModel tmpModel = new EdmModel();
EdmComplexType complexType = new EdmComplexType("TestNamespace", "TestComplexType");
complexType.AddProperty(new EdmStructuralProperty(complexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
tmpModel.AddElement(complexType);
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
tmpModel.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
tmpModel.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType);
defaultContainer.AddElement(EntitySet);
Action = new EdmAction("TestNamespace", "DoSomething", null, true, null);
Action.AddParameter("p1", new EdmEntityTypeReference(EntityType, false));
tmpModel.AddElement(Action);
ActionImport = defaultContainer.AddActionImport("DoSomething", Action);
var serviceOperationFunction = new EdmFunction("TestNamespace", "ServiceOperation", EdmCoreModel.Instance.GetInt32(true));
defaultContainer.AddFunctionImport("ServiceOperation", serviceOperationFunction);
tmpModel.AddElement(serviceOperationFunction);
tmpModel.AddElement(new EdmTerm("custom", "DateTimeOffsetAnnotation", EdmPrimitiveTypeKind.DateTimeOffset));
tmpModel.AddElement(new EdmTerm("custom", "DateAnnotation", EdmPrimitiveTypeKind.Date));
tmpModel.AddElement(new EdmTerm("custom", "TimeOfDayAnnotation", EdmPrimitiveTypeKind.TimeOfDay));
EdmModel = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", tmpModel);
MessageReaderSettingsReadAndValidateCustomInstanceAnnotations = new ODataMessageReaderSettings { ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*") };
MessageReaderSettingsIgnoreInstanceAnnotations = new ODataMessageReaderSettings();
}
private static IEdmModel BuildModel()
{
EdmModel model = new EdmModel();
var movieType = new EdmEntityType("TestModel", "Movie");
EdmStructuralProperty idProperty = new EdmStructuralProperty(movieType, "Id", EdmCoreModel.Instance.GetInt32(false));
movieType.AddProperty(idProperty);
movieType.AddKeys(idProperty);
movieType.AddProperty(new EdmStructuralProperty(movieType, "Name", EdmCoreModel.Instance.GetString(true)));
model.AddElement(movieType);
var tvMovieType = new EdmEntityType("TestModel", "TVMovie", movieType);
tvMovieType.AddProperty(new EdmStructuralProperty(tvMovieType, "Channel", EdmCoreModel.Instance.GetString(false)));
model.AddElement(tvMovieType);
EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "Default");
defaultContainer.AddEntitySet("Movies", movieType);
model.AddElement(defaultContainer);
EdmAction simpleAction = new EdmAction("TestModel", "SimpleAction", null /*returnType*/, false /*isBound*/, null /*entitySetPath*/);
model.AddElement(simpleAction);
defaultContainer.AddActionImport(simpleAction);
EdmAction checkoutAction1 = new EdmAction("TestModel", "Checkout", EdmCoreModel.Instance.GetInt32(false), false /*isBound*/, null /*entitySetPath*/);
checkoutAction1.AddParameter("movie", movieType.ToTypeReference());
checkoutAction1.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutAction1);
EdmAction rateAction1 = new EdmAction("TestModel", "Rate", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
rateAction1.AddParameter("movie", movieType.ToTypeReference());
rateAction1.AddParameter("rating", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(rateAction1);
EdmAction changeChannelAction1 = new EdmAction("TestModel", "ChangeChannel", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
changeChannelAction1.AddParameter("movie", tvMovieType.ToTypeReference());
changeChannelAction1.AddParameter("channel", EdmCoreModel.Instance.GetString(false));
model.AddElement(changeChannelAction1);
EdmAction checkoutAction = new EdmAction("TestModel", "Checkout", EdmCoreModel.Instance.GetInt32(false) /*returnType*/, false /*isBound*/, null /*entitySetPath*/);
checkoutAction.AddParameter("movie", movieType.ToTypeReference());
checkoutAction.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutAction);
var movieCollectionTypeReference = (new EdmCollectionType(movieType.ToTypeReference(nullable: false))).ToTypeReference(nullable:false);
EdmAction checkoutMultiple1Action = new EdmAction("TestModel", "CheckoutMultiple", EdmCoreModel.Instance.GetInt32(false), false /*isBound*/, null /*entitySetPath*/);
checkoutMultiple1Action.AddParameter("movies", movieCollectionTypeReference);
checkoutMultiple1Action.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutMultiple1Action);
EdmAction rateMultiple1Action = new EdmAction("TestModel", "RateMultiple", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
rateMultiple1Action.AddParameter("movies", movieCollectionTypeReference);
rateMultiple1Action.AddParameter("rating", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(rateMultiple1Action);
EdmAction checkoutMultiple2Action = new EdmAction("TestModel", "CheckoutMultiple", EdmCoreModel.Instance.GetInt32(false) /*returnType*/, false /*isBound*/, null /*entitySetPath*/);
checkoutMultiple2Action.AddParameter("movies", movieCollectionTypeReference);
checkoutMultiple2Action.AddParameter("duration", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(checkoutMultiple2Action);
EdmAction rateMultiple2Action = new EdmAction("TestModel", "RateMultiple", null /*returnType*/, true /*isBound*/, null /*entitySetPath*/);
rateMultiple2Action.AddParameter("movies", movieCollectionTypeReference);
rateMultiple2Action.AddParameter("rating", EdmCoreModel.Instance.GetInt32(false));
model.AddElement(rateMultiple2Action);
return model;
}
private void BoundActionTestSetting()
{
EdmAction action = new EdmAction("NS", "SingletonAction", null, true, null);
action.AddParameter(new EdmOperationParameter(action, "p", new EdmEntityTypeReference(this.webType, false)));
this.referencedModel.AddElement(action);
}
private static EdmOperationImport CreateActionImport(
ProcedureConfiguration procedure,
EdmEntityContainer container,
IEdmTypeReference returnReference,
IEdmExpression expression,
IEdmPathExpression pathExpression)
{
EdmAction operation = new EdmAction(
container.Namespace,
procedure.Name,
returnReference,
procedure.IsBindable,
pathExpression);
return new EdmActionImport(container, procedure.Name, operation, expression);
}
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;
}
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;
}