public ODataSingletonDeserializerTest()
{
EdmModel model = new EdmModel();
var employeeType = new EdmEntityType("NS", "Employee");
employeeType.AddStructuralProperty("EmployeeId", EdmPrimitiveTypeKind.Int32);
employeeType.AddStructuralProperty("EmployeeName", EdmPrimitiveTypeKind.String);
model.AddElement(employeeType);
EdmEntityContainer defaultContainer = new EdmEntityContainer("NS", "Default");
model.AddElement(defaultContainer);
_singleton = new EdmSingleton(defaultContainer, "CEO", employeeType);
defaultContainer.AddElement(_singleton);
model.SetAnnotationValue<ClrTypeAnnotation>(employeeType, new ClrTypeAnnotation(typeof(EmployeeModel)));
_edmModel = model;
_edmContainer = defaultContainer;
_readContext = new ODataDeserializerContext
{
Path = new ODataPath(new SingletonPathSegment(_singleton)),
Model = _edmModel,
ResourceType = typeof(EmployeeModel)
};
_deserializerProvider = new DefaultODataDeserializerProvider();
}
public static IEdmModel GetEdmModel()
{
EdmModel model = new EdmModel();
// Create and add product entity type.
EdmEntityType product = new EdmEntityType("NS", "Product");
product.AddKeys(product.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
product.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
product.AddStructuralProperty("Price", EdmPrimitiveTypeKind.Double);
model.AddElement(product);
// Create and add category entity type.
EdmEntityType category = new EdmEntityType("NS", "Category");
category.AddKeys(category.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
category.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(category);
// Set navigation from product to category.
EdmNavigationPropertyInfo propertyInfo = new EdmNavigationPropertyInfo();
propertyInfo.Name = "Category";
propertyInfo.TargetMultiplicity = EdmMultiplicity.One;
propertyInfo.Target = category;
EdmNavigationProperty productCategory = product.AddUnidirectionalNavigation(propertyInfo);
// Create and add entity container.
EdmEntityContainer container = new EdmEntityContainer("NS", "DefaultContainer");
model.AddElement(container);
// Create and add entity set for product and category.
EdmEntitySet products = container.AddEntitySet("Products", product);
EdmEntitySet categories = container.AddEntitySet("Categories", category);
products.AddNavigationTarget(productCategory, categories);
return model;
}
public NonPrimitiveTypeRoundtripAtomTests()
{
this.model = new EdmModel();
EdmComplexType personalInfo = new EdmComplexType(MyNameSpace, "PersonalInfo");
personalInfo.AddStructuralProperty("Age", EdmPrimitiveTypeKind.Int16);
personalInfo.AddStructuralProperty("Email", EdmPrimitiveTypeKind.String);
personalInfo.AddStructuralProperty("Tel", EdmPrimitiveTypeKind.String);
personalInfo.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Guid);
EdmComplexType subjectInfo = new EdmComplexType(MyNameSpace, "Subject");
subjectInfo.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
subjectInfo.AddStructuralProperty("Score", EdmPrimitiveTypeKind.Int16);
EdmCollectionTypeReference subjectsCollection = new EdmCollectionTypeReference(new EdmCollectionType(new EdmComplexTypeReference(subjectInfo, isNullable:true)));
EdmEntityType studentInfo = new EdmEntityType(MyNameSpace, "Student");
studentInfo.AddStructuralProperty("Info", new EdmComplexTypeReference(personalInfo, isNullable: false));
studentInfo.AddProperty(new EdmStructuralProperty(studentInfo, "Subjects", subjectsCollection));
EdmCollectionTypeReference hobbiesCollection = new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(isNullable: false)));
studentInfo.AddProperty(new EdmStructuralProperty(studentInfo, "Hobbies", hobbiesCollection));
model.AddElement(studentInfo);
model.AddElement(personalInfo);
model.AddElement(subjectInfo);
}
public OperationImportSegmentUnitTests()
{
nullableIntType = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32), true);
nullableDecimalType = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Decimal), true);
nullableBinaryType = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Binary), true);
nullableStringType = new EdmPrimitiveTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), true);
container = ModelBuildingHelpers.BuildValidEntityContainer();
model = new EdmModel();
model.AddElement(container);
this.functionIntToInt = new EdmFunction("Name.Space", "Function", this.nullableIntType);
this.functionIntToInt.AddParameter("Parameter1", this.nullableIntType);
this.functionImportIntToInt = new EdmFunctionImport(this.container, "Function", this.functionIntToInt);
this.functionDecimalToInt = new EdmFunction("Name.Space", "Function", this.nullableIntType);
this.functionDecimalToInt.AddParameter("Parameter1", this.nullableDecimalType);
this.functionImportDecimalToInt = new EdmFunctionImport(this.container, "Function", this.functionDecimalToInt);
this.functionBinaryToInt = new EdmFunction("Name.Space", "Function", this.nullableIntType);
this.functionBinaryToInt.AddParameter("Parameter1", this.nullableBinaryType);
this.functionImportBinaryToInt = new EdmFunctionImport(this.container, "Function", this.functionBinaryToInt);
this.functionIntToString = new EdmFunction("Name.Space", "Function", this.nullableStringType);
this.functionIntToString.AddParameter("Parameter1", this.nullableIntType);
this.functionImportIntToString = new EdmFunctionImport(this.container, "Function", this.functionIntToString);
model.AddElement(functionIntToInt);
model.AddElement(functionDecimalToInt);
model.AddElement(functionBinaryToInt);
model.AddElement(functionIntToString);
}
public CraftModel()
{
model = new EdmModel();
var address = new EdmComplexType("NS", "Address");
model.AddElement(address);
var mail = new EdmEntityType("NS", "Mail");
var mailId = mail.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
mail.AddKeys(mailId);
model.AddElement(mail);
var person = new EdmEntityType("NS", "Person");
model.AddElement(person);
var personId = person.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
person.AddKeys(personId);
person.AddStructuralProperty("Addr", new EdmComplexTypeReference(address, /*Nullable*/false));
MailBox = person.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
ContainsTarget = true,
Name = "Mails",
TargetMultiplicity = EdmMultiplicity.Many,
Target = mail,
});
var container = new EdmEntityContainer("NS", "DefaultContainer");
model.AddElement(container);
MyLogin = container.AddSingleton("MyLogin", person);
}
static ODataFeedAndEntryTypeContextTests()
{
Model = new EdmModel();
EntitySetElementType = new EdmEntityType("ns", "Customer");
ExpectedEntityType = new EdmEntityType("ns", "VipCustomer", EntitySetElementType);
ActualEntityType = new EdmEntityType("ns", "DerivedVipCustomer", ExpectedEntityType);
EdmEntityContainer defaultContainer = new EdmEntityContainer("ns", "DefaultContainer");
Model.AddElement(defaultContainer);
Model.AddVocabularyAnnotation(new EdmAnnotation(defaultContainer, UrlConventionsConstants.ConventionTerm, UrlConventionsConstants.KeyAsSegmentAnnotationValue));
EntitySet = new EdmEntitySet(defaultContainer, "Customers", EntitySetElementType);
Model.AddElement(EntitySetElementType);
Model.AddElement(ExpectedEntityType);
Model.AddElement(ActualEntityType);
defaultContainer.AddElement(EntitySet);
SerializationInfo = new ODataFeedAndEntrySerializationInfo { NavigationSourceName = "MyCustomers", NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer" };
SerializationInfoWithEdmUnknowEntitySet = new ODataFeedAndEntrySerializationInfo() { NavigationSourceName = null, NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer", NavigationSourceKind = EdmNavigationSourceKind.UnknownEntitySet };
TypeContextWithoutModel = ODataFeedAndEntryTypeContext.Create(SerializationInfo, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true);
TypeContextWithModel = ODataFeedAndEntryTypeContext.Create(/*serializationInfo*/null, EntitySet, EntitySetElementType, ExpectedEntityType, Model, throwIfMissingTypeInfo: true);
TypeContextWithEdmUnknowEntitySet = ODataFeedAndEntryTypeContext.Create(SerializationInfoWithEdmUnknowEntitySet, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true);
BaseTypeContextThatThrows = ODataFeedAndEntryTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true);
BaseTypeContextThatWillNotThrow = ODataFeedAndEntryTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: false);
}
private static void ReferentialConstraintDemo()
{
Console.WriteLine("ReferentialConstraintDemo");
EdmModel model = new EdmModel();
var customer = new EdmEntityType("ns", "Customer");
model.AddElement(customer);
var customerId = customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
customer.AddKeys(customerId);
var address = new EdmComplexType("ns", "Address");
model.AddElement(address);
var code = address.AddStructuralProperty("gid", EdmPrimitiveTypeKind.Guid);
customer.AddStructuralProperty("addr", new EdmComplexTypeReference(address, true));
var order = new EdmEntityType("ns", "Order");
model.AddElement(order);
var oId = order.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
order.AddKeys(oId);
var orderCustomerId = order.AddStructuralProperty("CustomerId", EdmPrimitiveTypeKind.Int32, false);
var nav = new EdmNavigationPropertyInfo()
{
Name = "NavCustomer",
Target = customer,
TargetMultiplicity = EdmMultiplicity.One,
DependentProperties = new[] { orderCustomerId },
PrincipalProperties = new[] { customerId }
};
order.AddUnidirectionalNavigation(nav);
ShowModel(model);
}
public void TestModelWithTypeDefinition()
{
var model = new EdmModel();
var addressType = new EdmTypeDefinition("MyNS", "Address", EdmPrimitiveTypeKind.String);
model.AddElement(addressType);
var weightType = new EdmTypeDefinition("MyNS", "Weight", EdmPrimitiveTypeKind.Decimal);
model.AddElement(weightType);
var personType = new EdmEntityType("MyNS", "Person");
var addressTypeReference = new EdmTypeDefinitionReference(addressType, false);
personType.AddStructuralProperty("Address", addressTypeReference);
addressTypeReference.Definition.Should().Be(addressType);
addressTypeReference.IsNullable.Should().BeFalse();
var weightTypeReference = new EdmTypeDefinitionReference(weightType, true);
personType.AddStructuralProperty("Weight", weightTypeReference);
weightTypeReference.Definition.Should().Be(weightType);
weightTypeReference.IsNullable.Should().BeTrue();
var personId = personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
personType.AddKeys(personId);
}
private static void EnumMemberExpressionDemo()
{
Console.WriteLine("EnumMemberExpressionDemo");
var model = new EdmModel();
var personType = new EdmEntityType("TestNS", "Person");
model.AddElement(personType);
var pid = personType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32, false);
personType.AddKeys(pid);
personType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
var colorType = new EdmEnumType("TestNS2", "Color", true);
model.AddElement(colorType);
colorType.AddMember("Cyan", new EdmIntegerConstant(1));
colorType.AddMember("Blue", new EdmIntegerConstant(2));
var outColorTerm = new EdmTerm("TestNS", "OutColor", new EdmEnumTypeReference(colorType, true));
model.AddElement(outColorTerm);
var exp = new EdmEnumMemberExpression(
new EdmEnumMember(colorType, "Blue", new EdmIntegerConstant(2))
);
var annotation = new EdmAnnotation(personType, outColorTerm, exp);
annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline);
model.SetVocabularyAnnotation(annotation);
ShowModel(model);
var ann = model.FindVocabularyAnnotations<IEdmValueAnnotation>(personType, "TestNS.OutColor").First();
var memberExp = (IEdmEnumMemberExpression)ann.Value;
foreach (var member in memberExp.EnumMembers)
{
Console.WriteLine(member.Name);
}
}
public void AmbiguousValueTermTest()
{
EdmModel model = new EdmModel();
IEdmValueTerm term1 = new EdmTerm("Foo", "Bar", EdmPrimitiveTypeKind.Byte);
IEdmValueTerm term2 = new EdmTerm("Foo", "Bar", EdmPrimitiveTypeKind.Decimal);
IEdmValueTerm term3 = new EdmTerm("Foo", "Bar", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, false));
Assert.AreEqual(EdmTermKind.Value, term1.TermKind, "EdmTermKind is correct.");
model.AddElement(term1);
Assert.AreEqual(term1, model.FindValueTerm("Foo.Bar"), "Correct item.");
model.AddElement(term2);
model.AddElement(term3);
IEdmValueTerm ambiguous = model.FindValueTerm("Foo.Bar");
Assert.IsTrue(ambiguous.IsBad(), "Ambiguous binding is bad");
Assert.AreEqual(EdmSchemaElementKind.ValueTerm, ambiguous.SchemaElementKind, "Correct schema element kind.");
Assert.AreEqual("Foo", ambiguous.Namespace, "Correct Namespace");
Assert.AreEqual("Bar", ambiguous.Name, "Correct Name");
Assert.AreEqual(EdmTermKind.Value, ambiguous.TermKind, "Correct term kind.");
Assert.IsTrue(ambiguous.Type.IsBad(), "Type is bad.");
}
public void CreateAmbiguousBinding()
{
EdmModel model = new EdmModel();
EdmComplexType c1 = new EdmComplexType("Ambiguous", "Binding");
EdmComplexType c2 = new EdmComplexType("Ambiguous", "Binding");
EdmComplexType c3 = new EdmComplexType("Ambiguous", "Binding");
model.AddElement(c1);
Assert.AreEqual(c1, model.FindType("Ambiguous.Binding"), "Single item resolved");
model.AddElement(c2);
model.AddElement(c3);
IEdmNamedElement ambiguous = model.FindType("Ambiguous.Binding");
Assert.IsTrue(ambiguous.IsBad(), "Ambiguous binding is bad");
Assert.AreEqual(EdmErrorCode.BadAmbiguousElementBinding, ambiguous.Errors().First().ErrorCode, "Ambiguous");
c1 = null;
c2 = new EdmComplexType("Ambiguous", "Binding2");
Assert.IsTrue
(
model.SchemaElements.OfType<IEdmComplexType>().Count() == 3 && model.SchemaElements.OfType<IEdmComplexType>().All(n => n.FullName() == "Ambiguous.Binding"),
"The model must be immutable."
);
}
public void GetModel(EdmModel model, EdmEntityContainer container)
{
EdmEntityType student = new EdmEntityType("ns", "Student");
student.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
EdmStructuralProperty key = student.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32);
student.AddKeys(key);
model.AddElement(student);
EdmEntitySet students = container.AddEntitySet("Students", student);
EdmEntityType school = new EdmEntityType("ns", "School");
school.AddKeys(school.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
school.AddStructuralProperty("CreatedDay", EdmPrimitiveTypeKind.DateTimeOffset);
model.AddElement(school);
EdmEntitySet schools = container.AddEntitySet("Schools", student);
EdmNavigationProperty schoolNavProp = student.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "School",
TargetMultiplicity = EdmMultiplicity.One,
Target = school
});
students.AddNavigationTarget(schoolNavProp, schools);
_school = school;
}
public WriterTypeNameEndToEndTests()
{
var model = new EdmModel();
var type = new EdmEntityType("TestModel", "TestEntity", /* baseType */ null, /* isAbstract */ false, /* isOpen */ true);
var keyProperty = type.AddStructuralProperty("DeclaredInt16", EdmPrimitiveTypeKind.Int16);
type.AddKeys(new[] { keyProperty });
// Note: DerivedPrimitive is declared as a Geography, but its value below will be set to GeographyPoint, which is derived from Geography.
type.AddStructuralProperty("DerivedPrimitive", EdmPrimitiveTypeKind.Geography);
var container = new EdmEntityContainer("TestModel", "Container");
var set = container.AddEntitySet("Set", type);
model.AddElement(type);
model.AddElement(container);
var writerStream = new MemoryStream();
this.settings = new ODataMessageWriterSettings();
this.settings.SetServiceDocumentUri(ServiceDocumentUri);
// Make the message writer and entry writer lazy so that individual tests can tweak the settings before the message writer is created.
this.messageWriter = new Lazy<ODataMessageWriter>(() =>
new ODataMessageWriter(
(IODataResponseMessage)new InMemoryMessage { Stream = writerStream },
this.settings,
model));
var entryWriter = new Lazy<ODataWriter>(() => this.messageWriter.Value.CreateODataEntryWriter(set, type));
var valueWithAnnotation = new ODataPrimitiveValue(45);
valueWithAnnotation.SetAnnotation(new SerializationTypeNameAnnotation { TypeName = "TypeNameFromSTNA" });
var propertiesToWrite = new List<ODataProperty>
{
new ODataProperty
{
Name = "DeclaredInt16", Value = (Int16)42
},
new ODataProperty
{
Name = "UndeclaredDecimal", Value = (Decimal)4.5
},
new ODataProperty
{
// Note: value is more derived than the declared type.
Name = "DerivedPrimitive", Value = Microsoft.Spatial.GeographyPoint.Create(42, 45)
},
new ODataProperty()
{
Name = "PropertyWithSTNA", Value = valueWithAnnotation
}
};
this.writerOutput = new Lazy<string>(() =>
{
entryWriter.Value.WriteStart(new ODataEntry { Properties = propertiesToWrite });
entryWriter.Value.WriteEnd();
entryWriter.Value.Flush();
writerStream.Seek(0, SeekOrigin.Begin);
return new StreamReader(writerStream).ReadToEnd();
});
}
static InstanceAnnotationsReaderIntegrationTests()
{
EdmModel modelTmp = new EdmModel();
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
modelTmp.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var resourceNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "ResourceNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne });
var resourceSetNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "ResourceSetNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many });
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer_sub");
modelTmp.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType);
EntitySet.AddNavigationTarget(resourceNavigationProperty, EntitySet);
EntitySet.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(EntitySet);
Singleton = new EdmSingleton(defaultContainer, "TestSingleton", EntityType);
Singleton.AddNavigationTarget(resourceNavigationProperty, EntitySet);
Singleton.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(Singleton);
ComplexType = new EdmComplexType("TestNamespace", "TestComplexType");
ComplexType.AddProperty(new EdmStructuralProperty(ComplexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
modelTmp.AddElement(ComplexType);
Model = TestUtils.WrapReferencedModelsToMainModel("TestNamespace", "DefaultContainer", modelTmp);
}
private static ODataEntry CreateEntryWithKeyAsSegmentConvention(bool addAnnotation, bool? useKeyAsSegment)
{
var model = new EdmModel();
var container = new EdmEntityContainer("Fake", "Container");
model.AddElement(container);
if (addAnnotation)
{
model.AddVocabularyAnnotation(new EdmAnnotation(container, UrlConventionsConstants.ConventionTerm, UrlConventionsConstants.KeyAsSegmentAnnotationValue));
}
EdmEntityType entityType = new EdmEntityType("Fake", "FakeType");
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
model.AddElement(entityType);
var entitySet = new EdmEntitySet(container, "FakeSet", entityType);
container.AddElement(entitySet);
var metadataContext = new ODataMetadataContext(
true,
ODataReaderBehavior.DefaultBehavior.OperationsBoundToEntityTypeMustBeContainerQualified,
new EdmTypeReaderResolver(model, ODataReaderBehavior.DefaultBehavior),
model,
new Uri("http://temp.org/$metadata"),
null /*requestUri*/);
var thing = new ODataEntry {Properties = new[] {new ODataProperty {Name = "Id", Value = 1}}};
thing.SetAnnotation(new ODataTypeAnnotation(entitySet, entityType));
thing.MetadataBuilder = metadataContext.GetEntityMetadataBuilderForReader(new TestJsonLightReaderEntryState { Entry = thing, SelectedProperties = new SelectedPropertiesNode("*")}, useKeyAsSegment);
return thing;
}
public static IEdmModel GetEdmModel()
{
if (_edmModel != null)
{
return _edmModel;
}
EdmModel model = new EdmModel();
// entity type 'Customer' with single alternate keys
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
var ssn = customer.AddStructuralProperty("SSN", EdmPrimitiveTypeKind.String);
model.AddAlternateKeyAnnotation(customer, new Dictionary<string, IEdmProperty>
{
{"SSN", ssn}
});
model.AddElement(customer);
// entity type 'Order' with multiple alternate keys
EdmEntityType order = new EdmEntityType("NS", "Order");
order.AddKeys(order.AddStructuralProperty("OrderId", EdmPrimitiveTypeKind.Int32));
var orderName = order.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
var orderToken = order.AddStructuralProperty("Token", EdmPrimitiveTypeKind.Guid);
order.AddStructuralProperty("Amount", EdmPrimitiveTypeKind.Int32);
model.AddAlternateKeyAnnotation(order, new Dictionary<string, IEdmProperty>
{
{"Name", orderName}
});
model.AddAlternateKeyAnnotation(order, new Dictionary<string, IEdmProperty>
{
{"Token", orderToken}
});
model.AddElement(order);
// entity type 'Person' with composed alternate keys
EdmEntityType person = new EdmEntityType("NS", "Person");
person.AddKeys(person.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
var country = person.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String);
var passport = person.AddStructuralProperty("Passport", EdmPrimitiveTypeKind.String);
model.AddAlternateKeyAnnotation(person, new Dictionary<string, IEdmProperty>
{
{"Country", country},
{"Passport", passport}
});
model.AddElement(person);
// entity sets
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
model.AddElement(container);
container.AddEntitySet("Customers", customer);
container.AddEntitySet("Orders", order);
container.AddEntitySet("People", person);
return _edmModel = model;
}
public void ComplexValueTest()
{
EdmModel model = new EdmModel();
var emptyComplexType = new EdmComplexType(DefaultNamespaceName, "EmptyComplexType");
model.AddElement(emptyComplexType);
var complexTypeWithStringProperty = new EdmComplexType(DefaultNamespaceName, "ComplexTypeWithStringProperty");
complexTypeWithStringProperty.AddStructuralProperty("stringProperty", EdmCoreModel.Instance.GetString(isNullable: true));
complexTypeWithStringProperty.AddStructuralProperty("numberProperty", EdmCoreModel.Instance.GetInt32(isNullable: false));
model.AddElement(complexTypeWithStringProperty);
model.Fixup();
IEnumerable<PayloadReaderTestDescriptor> testDescriptors = new[]
{
// Empty element is a valid complex value
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexValue("TestModel.EmptyComplexType")
.XmlValueRepresentation(new XNode[0])
.WithTypeAnnotation(emptyComplexType),
PayloadEdmModel = model
},
};
testDescriptors = testDescriptors.Concat(
PropertiesElementAtomValues.CreatePropertiesElementPaddingPayloads<ComplexInstance>(
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.ComplexValue("TestModel.ComplexTypeWithStringProperty")
.WithTypeAnnotation(complexTypeWithStringProperty),
PayloadEdmModel = model
},
(complexInstance, xmlValue) => complexInstance.XmlValueRepresentation(xmlValue)));
testDescriptors = testDescriptors.Select(td => td.InProperty());
testDescriptors = testDescriptors.Concat(new []
{
// Top-level property without expected type and no type name - this is read as primitive string!
new PayloadReaderTestDescriptor(this.Settings)
{
PayloadElement = PayloadBuilder.Property(null, PayloadBuilder.PrimitiveValue(string.Empty))
.XmlRepresentation("<m:value/>"),
PayloadEdmModel = model,
},
});
this.CombinatorialEngineProvider.RunCombinations(
testDescriptors,
this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
(testDescriptor, testConfiguration) =>
{
testDescriptor.RunTest(testConfiguration);
});
}
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 static IEdmModel CreateModel(string ns)
{
EdmModel model = new EdmModel();
var defaultContainer = new EdmEntityContainer(ns, "DefaultContainer");
model.AddElement(defaultContainer);
var addressType = new EdmComplexType(ns, "Address");
addressType.AddProperty(new EdmStructuralProperty(addressType, "Road", EdmCoreModel.Instance.GetString(false)));
addressType.AddProperty(new EdmStructuralProperty(addressType, "City", EdmCoreModel.Instance.GetString(false)));
model.AddElement(addressType);
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, "Address", new EdmComplexTypeReference(addressType, true)));
personType.AddProperty(new EdmStructuralProperty(personType, "Descriptions", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(false)))));
model.AddElement(personType);
var peopleSet = new EdmEntitySet(defaultContainer, "People", personType);
defaultContainer.AddElement(peopleSet);
var numberComboType = new EdmComplexType(ns, "NumberCombo");
numberComboType.AddProperty(new EdmStructuralProperty(numberComboType, "Small", EdmCoreModel.Instance.GetInt32(false)));
numberComboType.AddProperty(new EdmStructuralProperty(numberComboType, "Middle", EdmCoreModel.Instance.GetInt64(false)));
numberComboType.AddProperty(new EdmStructuralProperty(numberComboType, "Large", EdmCoreModel.Instance.GetDecimal(false)));
model.AddElement(numberComboType);
var productType = new EdmEntityType(ns, "Product");
var productIdProperty = new EdmStructuralProperty(productType, "ProductId", EdmCoreModel.Instance.GetInt32(false));
productType.AddProperty(productIdProperty);
productType.AddKeys(new IEdmStructuralProperty[] { productIdProperty });
productType.AddProperty(new EdmStructuralProperty(productType, "Quantity", EdmCoreModel.Instance.GetInt64(false)));
productType.AddProperty(new EdmStructuralProperty(productType, "LifeTimeInSeconds", EdmCoreModel.Instance.GetDecimal(false)));
productType.AddProperty(new EdmStructuralProperty(productType, "TheCombo", new EdmComplexTypeReference(numberComboType, true)));
productType.AddProperty(new EdmStructuralProperty(productType, "LargeNumbers", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetDecimal(false)))));
model.AddElement(productType);
var productsSet = new EdmEntitySet(defaultContainer, "Products", productType);
defaultContainer.AddElement(productsSet);
var productsProperty = personType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Products",
Target = productType,
TargetMultiplicity = EdmMultiplicity.Many
});
peopleSet.AddNavigationTarget(productsProperty, productsSet);
IEnumerable<EdmError> errors;
model.Validate(out errors);
return model;
}
public Task<IEdmModel> GetModelAsync(InvocationContext context, CancellationToken cancellationToken)
{
var model = new EdmModel();
var dummyType = new EdmEntityType("NS", "Dummy");
model.AddElement(dummyType);
var container = new EdmEntityContainer("NS", "DefaultContainer");
container.AddEntitySet("Test", dummyType);
model.AddElement(container);
return Task.FromResult((IEdmModel)model);
}
public AutoGeneratedUrlsShouldPutKeyValueInDedicatedSegmentTests()
{
this.model = new EdmModel();
this.entityContainer = new EdmEntityContainer("Namespace", "Container");
this.personType = new EdmEntityType("Namespace", "Person");
this.personType.AddKeys(this.personType.AddStructuralProperty("Key", EdmPrimitiveTypeKind.String));
this.peopleSet = this.entityContainer.AddEntitySet("People", personType);
model.AddElement(this.entityContainer);
model.AddElement(this.personType);
}
public void Initialize()
{
this.model = new EdmModel();
this.entityContainer = new EdmEntityContainer("Namespace", "Container");
this.personType = new EdmEntityType("Namespace", "Person");
this.personType.AddKeys(this.personType.AddStructuralProperty("Key", EdmPrimitiveTypeKind.String));
this.peopleSet = this.entityContainer.AddEntitySet("People", personType);
model.AddElement(this.entityContainer);
model.AddElement(this.personType);
}
static ODataAtomWriterIntegrationTests()
{
Model = new EdmModel();
EntityType = new EdmEntityType("Namespace", "EntityType");
Model.AddElement(EntityType);
var entityContainer = new EdmEntityContainer("Namespace", "Container");
EntitySet = entityContainer.AddEntitySet("EntitySet", EntityType);
Model.AddElement(entityContainer);
Model.Fixup();
}
public void DuplicateFunctionOverloadsWithDifferentBindingTypesAndSameNameWithDifferentReturnTypesShouldNotError()
{
var edmFunction = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetString(true), true /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction.AddParameter("bindingParameter", EdmCoreModel.Instance.GetInt16(true));
var edmFunction2 = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetInt16(true), true /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction2.AddParameter("bindingParameter", EdmCoreModel.Instance.GetInt32(true));
EdmModel model = new EdmModel();
model.AddElement(edmFunction);
model.AddElement(edmFunction2);
ValidateNoError(model);
}
public void DuplicateUnBoundFunctionOverloadsSameParameterNamesShouldError()
{
var edmFunction = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetString(true), false /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction.AddParameter("bindingParameter1", EdmCoreModel.Instance.GetInt16(true));
var edmFunction2 = new EdmFunction("n.s", "GetStuff", EdmCoreModel.Instance.GetInt16(true), false /*isBound*/, null /*entitySetPath*/, false /*isComposable*/);
edmFunction2.AddParameter("bindingParameter1", EdmCoreModel.Instance.GetInt32(true));
EdmModel model = new EdmModel();
model.AddElement(edmFunction);
model.AddElement(edmFunction2);
ValidateError(model, EdmErrorCode.DuplicateFunctions, Strings.EdmModel_Validator_Semantic_ModelDuplicateUnBoundFunctionsParameterNames("n.s.GetStuff"));
}
public ODataJsonLightReaderEnumIntegrationTests()
{
EdmModel tmpModel = new EdmModel();
// enum without flags
var enumType = new EdmEnumType("NS", "Color");
var red = new EdmEnumMember(enumType, "Red", new EdmIntegerConstant(1));
enumType.AddMember(red);
enumType.AddMember("Green", new EdmIntegerConstant(2));
enumType.AddMember("Blue", new EdmIntegerConstant(3));
tmpModel.AddElement(enumType);
// enum with flags
var enumFlagsType = new EdmEnumType("NS", "ColorFlags", isFlags: true);
enumFlagsType.AddMember("Red", new EdmIntegerConstant(1));
enumFlagsType.AddMember("Green", new EdmIntegerConstant(2));
enumFlagsType.AddMember("Blue", new EdmIntegerConstant(4));
tmpModel.AddElement(enumFlagsType);
this.entityType = new EdmEntityType("NS", "MyEntityType", isAbstract: false, isOpen: true, baseType: null);
EdmStructuralProperty floatId = new EdmStructuralProperty(this.entityType, "FloatId", EdmCoreModel.Instance.GetSingle(false));
this.entityType.AddKeys(floatId);
this.entityType.AddProperty(floatId);
var enumTypeReference = new EdmEnumTypeReference(enumType, true);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "Color", enumTypeReference));
var enumFlagsTypeReference = new EdmEnumTypeReference(enumFlagsType, false);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "ColorFlags", enumFlagsTypeReference));
// enum in complex type
EdmComplexType myComplexType = new EdmComplexType("NS", "MyComplexType");
myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "MyColorFlags", enumFlagsTypeReference));
myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "Height", EdmCoreModel.Instance.GetDouble(false)));
tmpModel.AddElement(myComplexType);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyComplexType", new EdmComplexTypeReference(myComplexType, true)));
// enum in derived complex type
EdmComplexType myDerivedComplexType = new EdmComplexType("NS", "MyDerivedComplexType", myComplexType, false);
myDerivedComplexType.AddProperty(new EdmStructuralProperty(myDerivedComplexType, "MyDerivedColorFlags", new EdmEnumTypeReference(enumFlagsType, false)));
tmpModel.AddElement(myDerivedComplexType);
// enum in collection type
EdmCollectionType myCollectionType = new EdmCollectionType(enumFlagsTypeReference);
this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyCollectionType", new EdmCollectionTypeReference(myCollectionType)));
tmpModel.AddElement(this.entityType);
var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer_sub");
this.entitySet = new EdmEntitySet(defaultContainer, "MySet", this.entityType);
defaultContainer.AddEntitySet(this.entitySet.Name, this.entityType);
tmpModel.AddElement(defaultContainer);
this.userModel = TestUtils.WrapReferencedModelsToMainModel("NS", "DefaultContainer", tmpModel);
}
public void Initialize()
{
EdmModel tmp = new EdmModel();
this.type = new EdmEntityType("Namespace", "Type");
this.type.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo() { Target = this.type, TargetMultiplicity = EdmMultiplicity.Many, Name = "NavProp" });
this.type.AddProperty(new EdmStructuralProperty(this.type, "PrimitiveProp", EdmCoreModel.Instance.GetInt32(false)));
tmp.AddElement(this.type);
EdmEntityContainer edmEntityContainer = new EdmEntityContainer("Namespace", "Container_sub");
this.entitySet = edmEntityContainer.AddEntitySet("EntitySet", this.type);
tmp.AddElement(edmEntityContainer);
this.model = TestUtils.WrapReferencedModelsToMainModel("Namespace", "Container", tmp);
}
private static EdmModel CreateTestModel()
{
var objectType = new EdmEntityType("DefaultNamespace", "Object");
var personType = new EdmEntityType("DefaultNamespace", "Person", objectType);
var container = new EdmEntityContainer("DefaultNamespace", "Container");
container.AddEntitySet("Objects", objectType);
container.AddEntitySet("People", personType);
var model = new EdmModel();
model.AddElement(objectType);
model.AddElement(personType);
model.AddElement(container);
return model;
}
public Task<IEdmModel> GetModelAsync(InvocationContext context, CancellationToken cancellationToken)
{
var model = new EdmModel();
var entityType = new EdmEntityType(
"TestNamespace", "TestName");
var entityContainer = new EdmEntityContainer(
"TestNamespace", "Entities");
entityContainer.AddEntitySet("TestEntitySet", entityType);
model.AddElement(entityType);
model.AddElement(entityContainer);
return Task.FromResult<IEdmModel>(model);
}
static ExapndOptionFunctionalTests()
{
string namespaceA = "NS";
EdmModel edmModel = new EdmModel();
EdmEntityType type1 = new EdmEntityType(namespaceA, "T1");
EdmEntityType type2 = new EdmEntityType(namespaceA, "T2", type1);
EdmEntityType type3 = new EdmEntityType(namespaceA, "T3", type2);
EdmNavigationProperty nav21 = type2.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Nav21",
ContainsTarget = false,
Target = type1,
TargetMultiplicity = EdmMultiplicity.ZeroOrOne,
});
EdmNavigationProperty nav22 = type2.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Nav22",
ContainsTarget = false,
Target = type2,
TargetMultiplicity = EdmMultiplicity.One,
});
EdmNavigationProperty nav23 = type2.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo()
{
Name = "Nav23",
ContainsTarget = false,
Target = type3,
TargetMultiplicity = EdmMultiplicity.Many,
});
edmModel.AddElement(type1);
edmModel.AddElement(type2);
edmModel.AddElement(type3);
EdmEntityContainer container = new EdmEntityContainer(namespaceA, "Con1");
var set1 = container.AddEntitySet(namespaceA, type1);
var set2 = container.AddEntitySet(namespaceA, type2);
var set3 = container.AddEntitySet(namespaceA, type3);
edmModel.AddElement(container);
set2.AddNavigationTarget(nav21, set1);
set2.AddNavigationTarget(nav22, set2);
set2.AddNavigationTarget(nav23, set3);
Model = edmModel;
T2Type = type2;
T3Type = type3;
T2Set = set2;
T3Set = set3;
}
/// <summary>
/// Asynchronously produces a base model.
/// </summary>
/// <param name="context">
/// The model context.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token.
/// </param>
/// <returns>
/// A task that represents the asynchronous
/// operation whose result is the base model.
/// </returns>
public Task <IEdmModel> GetModelAsync(
InvocationContext context,
CancellationToken cancellationToken)
{
Ensure.NotNull(context, "context");
var model = new EdmModel();
var dbContext = context.GetApiService <DbContext>();
var elementMap = new Dictionary <IAnnotatable, IEdmElement>();
var entityTypes = dbContext.Model.GetEntityTypes();
string namespaceName = CalcNamespace(dbContext, entityTypes);
var entityContainer = new EdmEntityContainer(
namespaceName, "Container");
Dictionary <Type, PropertyInfo> dbSetProperties = GetDbSetPropeties(dbContext);
// TODO GitHubIssue#36 : support complex and entity inheritance
foreach (var efEntityType in entityTypes)
{
if (elementMap.ContainsKey(efEntityType))
{
continue;
}
List <EdmStructuralProperty> concurrencyProperties;
var entityType = ModelProducer.CreateEntityType(
efEntityType, model, out concurrencyProperties);
model.AddElement(entityType);
PropertyInfo propInfo;
if (dbSetProperties.TryGetValue(efEntityType.ClrType, out propInfo))
{
var entitySet = entityContainer.AddEntitySet(propInfo.Name, entityType);
if (concurrencyProperties != null)
{
model.SetOptimisticConcurrencyAnnotation(entitySet, concurrencyProperties);
}
}
elementMap.Add(efEntityType, entityType);
}
CreateNavigations(entityContainer, entityTypes, elementMap);
// TODO GitHubIssue#36 : support function imports
model.AddElement(entityContainer);
return(Task.FromResult <IEdmModel>(model));
}
private static IEdmEnumTypeReference GetEnumTypeReference(
EdmProperty efProperty,
EdmModel model,
IDictionary <MetadataItem, IEdmElement> elementMap)
{
var efEnumType = efProperty.EnumType;
EdmEnumType enumType;
IEdmElement element;
if (elementMap.TryGetValue(efEnumType, out element))
{
enumType = (EdmEnumType)element;
}
else
{
enumType = new EdmEnumType(efEnumType.NamespaceName, efEnumType.Name);
elementMap.Add(efEnumType, enumType);
model.AddElement(enumType);
foreach (var member in efEnumType.Members)
{
var longValue = Convert.ToInt64(member.Value, CultureInfo.InvariantCulture);
enumType.AddMember(member.Name, new EdmIntegerConstant(longValue));
}
}
return(new EdmEnumTypeReference(enumType, efProperty.Nullable));
}
private static IEdmComplexTypeReference GetComplexTypeReference(
EdmProperty efProperty,
EdmModel model,
IDictionary <MetadataItem, IEdmElement> elementMap)
{
var efComplexType = efProperty.ComplexType;
EdmComplexType complexType;
IEdmElement element;
if (elementMap.TryGetValue(efComplexType, out element))
{
complexType = (EdmComplexType)element;
}
else
{
complexType = new EdmComplexType(efComplexType.NamespaceName, efComplexType.Name);
elementMap.Add(efComplexType, complexType);
model.AddElement(complexType);
foreach (var property in efComplexType.Properties)
{
var propertyTypeRef = GetTypeReference(property, model, elementMap);
if (propertyTypeRef != null)
{
complexType.AddStructuralProperty(property.Name, propertyTypeRef);
}
}
}
return(new EdmComplexTypeReference(complexType, efProperty.Nullable));
}
/// <summary>
/// Asynchronously produces a base model.
/// </summary>
/// <param name="context">
/// The model context.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token.
/// </param>
/// <returns>
/// A task that represents the asynchronous
/// operation whose result is the base model.
/// </returns>
public Task <IEdmModel> GetModelAsync(
InvocationContext context,
CancellationToken cancellationToken)
{
var model = new EdmModel();
var domainContext = context.ApiContext;
var dbContext = domainContext.GetApiService <DbContext>();
var elementMap = new Dictionary <IAnnotatable, IEdmElement>();
var efModel = dbContext.Model;
var namespaceName = efModel.EntityTypes
.Select(t => t.HasClrType() ? t.ClrType.Namespace : null)
.Where(t => t != null)
.GroupBy(nameSpace => nameSpace)
.Select(group => new
{
NameSpace = group.Key,
Count = group.Count(),
})
.OrderByDescending(nsItem => nsItem.Count)
.Select(nsItem => nsItem.NameSpace)
.FirstOrDefault();
if (namespaceName == null)
{
// When dbContext has not a namespace, just use its type name as namespace.
namespaceName = dbContext.GetType().Namespace ?? dbContext.GetType().Name;
}
var entityTypes = efModel.EntityTypes;
var entityContainer = new EdmEntityContainer(
namespaceName, "Container");
var dbSetProperties = dbContext.GetType()
.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
.Where(e => e.PropertyType.IsGenericType &&
e.PropertyType.GetGenericTypeDefinition() == typeof(DbSet <>))
.ToDictionary(e => e.PropertyType.GetGenericArguments()[0]);
// TODO GitHubIssue#36 : support complex and entity inheritance
foreach (var efEntityType in entityTypes)
{
if (elementMap.ContainsKey(efEntityType))
{
continue;
}
List <EdmStructuralProperty> concurrencyProperties;
var entityType = ModelProducer.CreateEntityType(
efModel, efEntityType, model, out concurrencyProperties);
model.AddElement(entityType);
elementMap.Add(efEntityType, entityType);
System.Reflection.PropertyInfo propInfo;
if (dbSetProperties.TryGetValue(efEntityType.ClrType, out propInfo))
{
var entitySet = entityContainer.AddEntitySet(propInfo.Name, entityType);
if (concurrencyProperties != null)
{
model.SetOptimisticConcurrencyAnnotation(entitySet, concurrencyProperties);
}
}
}
foreach (var efEntityType in entityTypes)
{
foreach (var navi in efEntityType.GetNavigations())
{
ModelProducer.AddNavigationProperties(
efModel, navi, model, elementMap);
ModelProducer.AddNavigationPropertyBindings(
efModel, navi, entityContainer, elementMap);
}
}
// TODO GitHubIssue#36 : support function imports
model.AddElement(entityContainer);
return(Task.FromResult <IEdmModel>(model));
}
/// <summary>
/// Asynchronously produces a base model.
/// </summary>
/// <param name="context">
/// The model context.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token.
/// </param>
/// <returns>
/// A task that represents the asynchronous
/// operation whose result is the base model.
/// </returns>
public Task <EdmModel> ProduceModelAsync(
ModelContext context,
CancellationToken cancellationToken)
{
Ensure.NotNull(context);
var model = new EdmModel();
var domainContext = context.DomainContext;
var dbContext = domainContext.GetProperty <DbContext>("DbContext");
var elementMap = new Dictionary <MetadataItem, IEdmElement>();
var efModel = (dbContext as IObjectContextAdapter)
.ObjectContext.MetadataWorkspace;
var namespaceName = efModel.GetItems <EntityType>(DataSpace.CSpace)
.Select(t => efModel.GetObjectSpaceType(t).NamespaceName)
.GroupBy(nameSpace => nameSpace)
.Select(group => new
{
NameSpace = group.Key,
Count = group.Count(),
})
.OrderByDescending(nsItem => nsItem.Count)
.Select(nsItem => nsItem.NameSpace)
.FirstOrDefault();
if (namespaceName == null)
{
// When dbContext has not a namespace, just use its type name as namespace.
namespaceName = dbContext.GetType().Namespace ?? dbContext.GetType().Name;
}
var efEntityContainer = efModel.GetItems <EntityContainer>(DataSpace.CSpace).Single();
var entityContainer = new EdmEntityContainer(namespaceName, efEntityContainer.Name);
elementMap.Add(efEntityContainer, entityContainer);
// TODO GitHubIssue#36 : support complex and enumeration types
foreach (var efEntitySet in efEntityContainer.EntitySets)
{
var efEntityType = efEntitySet.ElementType;
if (elementMap.ContainsKey(efEntityType))
{
continue;
}
List <EdmStructuralProperty> concurrencyProperties;
var entityType = CreateEntityType(efModel, efEntityType, model, elementMap, out concurrencyProperties);
model.AddElement(entityType);
elementMap.Add(efEntityType, entityType);
var entitySet = entityContainer.AddEntitySet(efEntitySet.Name, entityType);
if (concurrencyProperties != null)
{
model.SetOptimisticConcurrencyAnnotation(entitySet, concurrencyProperties);
}
elementMap.Add(efEntitySet, entitySet);
}
foreach (var efAssociationSet in efEntityContainer.AssociationSets)
{
AddNavigationProperties(efAssociationSet, elementMap);
AddNavigationPropertyBindings(efAssociationSet, elementMap);
}
// TODO GitHubIssue#36 : support function imports
model.AddElement(entityContainer);
return(Task.FromResult(model));
}
