public static IEdmModel MultipleSchemasWithDifferentNamespacesEdm() { var namespaces = new string[] { "FindMethodsTestModelBuilder.MultipleSchemasWithDifferentNamespaces.first", "FindMethodsTestModelBuilder.MultipleSchemasWithDifferentNamespaces.second" }; var model = new EdmModel(); foreach (var namespaceName in namespaces) { var entityType1 = new EdmEntityType(namespaceName, "validEntityType1"); entityType1.AddKeys(entityType1.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); var entityType2 = new EdmEntityType(namespaceName, "VALIDeNTITYtYPE2"); entityType2.AddKeys(entityType2.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); var entityType3 = new EdmEntityType(namespaceName, "VALIDeNTITYtYPE3"); entityType3.AddKeys(entityType3.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); entityType1.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {Name = "Mumble", Target = entityType2, TargetMultiplicity = EdmMultiplicity.Many}); var complexType = new EdmComplexType(namespaceName, "ValidNameComplexType1"); complexType.AddStructuralProperty("aPropertyOne", new EdmComplexTypeReference(complexType, false)); model.AddElements(new IEdmSchemaElement[] { entityType1, entityType2, entityType3, complexType }); var function1 = new EdmFunction(namespaceName, "ValidFunction1", EdmCoreModel.Instance.GetSingle(false)); var function2 = new EdmFunction(namespaceName, "ValidFunction1", EdmCoreModel.Instance.GetSingle(false)); function2.AddParameter("param1", new EdmEntityTypeReference(entityType1, false)); var function3 = new EdmFunction(namespaceName, "ValidFunction1", EdmCoreModel.Instance.GetSingle(false)); function3.AddParameter("param1", EdmCoreModel.Instance.GetSingle(false)); model.AddElements(new IEdmSchemaElement[] {function1, function2, function3}); } return model; }
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); }
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 BatchReaderPayloadTest() { var model = new EdmModel(); IEnumerable<PayloadTestDescriptor> batchRequestDescriptors = TestBatches.CreateBatchRequestTestDescriptors(this.RequestManager, model, /*withTypeNames*/ true); IEnumerable<PayloadReaderTestDescriptor> requestTestDescriptors = batchRequestDescriptors.Select(bd => new PayloadReaderTestDescriptor(this.PayloadReaderSettings) { PayloadDescriptor = bd, SkipTestConfiguration = tc => !tc.IsRequest || (tc.Format != ODataFormat.Json && tc.Format != ODataFormat.Atom) }); IEnumerable<PayloadTestDescriptor> batchResponseDescriptors = TestBatches.CreateBatchResponseTestDescriptors(this.RequestManager, model, /*withTypeNames*/ true); IEnumerable<PayloadReaderTestDescriptor> responseTestDescriptors = batchResponseDescriptors.Select(bd => new PayloadReaderTestDescriptor(this.PayloadReaderSettings) { PayloadDescriptor = bd, SkipTestConfiguration = tc => tc.IsRequest || (tc.Format != ODataFormat.Json && tc.Format != ODataFormat.Atom) }); IEnumerable<PayloadReaderTestDescriptor> testDescriptors = requestTestDescriptors.Concat(responseTestDescriptors); this.CombinatorialEngineProvider.RunCombinations( testDescriptors, this.ReaderTestConfigurationProvider.DefaultFormatConfigurations, (testDescriptor, testConfiguration) => { testDescriptor.RunTest(testConfiguration); }); }
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; }
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 void VerifyTimeOfDayValueReader(string payload, string edmTypeName, object expectedResult) { IEdmModel model = new EdmModel(); IEdmPrimitiveTypeReference typeReference = new EdmPrimitiveTypeReference((IEdmPrimitiveType)model.FindType(edmTypeName), true); MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(payload)); object actualValue; using (ODataJsonLightInputContext inputContext = new ODataJsonLightInputContext( ODataFormat.Json, stream, JsonLightUtils.JsonLightStreamingMediaType, Encoding.UTF8, new ODataMessageReaderSettings(), /*readingResponse*/ true, /*synchronous*/ true, model, /*urlResolver*/ null)) { ODataJsonLightPropertyAndValueDeserializer deserializer = new ODataJsonLightPropertyAndValueDeserializer(inputContext); deserializer.JsonReader.Read(); actualValue = deserializer.ReadNonEntityValue( /*payloadTypeName*/ null, typeReference, /*duplicatePropertyNamesChecker*/ null, /*collectionValidator*/ null, /*validateNullValue*/ true, /*isTopLevelPropertyValue*/ true, /*insideComplexValue*/ false, /*propertyName*/ null); } actualValue.Should().Be(expectedResult, "payload ->{0}<- for type '{1}'", payload, edmTypeName); }
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(); }); }
public static ComplexInstance GetComplexInstanceWithManyPrimitiveProperties(EdmModel model) { var primitiveValues = TestValues.CreatePrimitiveValuesWithMetadata(true).Where( (v) => { var edmPrimitiveType = v.Annotations.OfType<EntityModelTypeAnnotation>().Single().EdmModelType as IEdmPrimitiveTypeReference; var edmPrimitiveKind = edmPrimitiveType.PrimitiveKind(); if (edmPrimitiveKind != EdmPrimitiveTypeKind.None) return edmPrimitiveKind != EdmPrimitiveTypeKind.DateTimeOffset; return false; }).ToArray(); string typeName = "ComplexTypeWithManyPrimitiveProperties"; var complexType = model.ComplexType(typeName); for (int i = 0; i < primitiveValues.Count(); ++i) { complexType.Property("property" + i, primitiveValues[i].GetAnnotation<EntityModelTypeAnnotation>().EdmModelType); } var complexValue = PayloadBuilder.ComplexValue("TestModel." + typeName).WithTypeAnnotation(complexType); for (int j = 0; j < primitiveValues.Count(); ++j) { complexValue.PrimitiveProperty("property" + j, primitiveValues[j].ClrValue); } return complexValue; }
public void GetModelID_Returns_DifferentIDForDifferentModels() { EdmModel model1 = new EdmModel(); EdmModel model2 = new EdmModel(); Assert.NotEqual(ModelContainer.GetModelID(model1), ModelContainer.GetModelID(model2)); }
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; }
static ODataAtomPropertyAndValueDeserializerTests() { EdmModel = new EdmModel(); ComplexType = new EdmComplexType("TestNamespace", "TestComplexType"); StringProperty = ComplexType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); EdmModel.AddElement(ComplexType); }
/// <summary> /// Generates extra operations to go into a request changeset /// </summary> /// <param name="random">For generating the payloads to go in the extra operations</param> /// <param name="requestManager">For building the operations</param> /// <param name="model">To add any new types to.</param> /// <param name="baseUri">Base uri for the extra operations.</param> /// <param name="version">Maximum version for </param> /// <returns>An array of extra request operations.</returns> public static IHttpRequest[] ExtraRequestChangesetOperations( IRandomNumberGenerator random, IODataRequestManager requestManager, EdmModel model, ODataUri baseUri, ODataVersion version = ODataVersion.V4) { ExceptionUtilities.CheckArgumentNotNull(random, "random"); ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager"); ExceptionUtilities.CheckArgumentNotNull(baseUri, "baseUri"); var headers = new Dictionary<string, string> { { "RequestHeader", "RequestHeaderValue" } }; string mergeContentType = HttpUtilities.BuildContentType(MimeTypes.ApplicationXml, Encoding.UTF8.WebName, null); List<IHttpRequest> requests = new List<IHttpRequest>(); ODataRequest request = null; for (int i = 0; i < 4; i++) { request = requestManager.BuildRequest(baseUri, HttpVerb.Post, headers); request.Body = requestManager.BuildBody(mergeContentType, baseUri, RandomPayloadBuilder.GetRandomPayload(random, model, version)); requests.Add(request); request = requestManager.BuildRequest(baseUri, HttpVerb.Put, headers); request.Body = requestManager.BuildBody(mergeContentType, baseUri, RandomPayloadBuilder.GetRandomPayload(random, model, version)); requests.Add(request); request = requestManager.BuildRequest(baseUri, HttpVerb.Patch, headers); request.Body = requestManager.BuildBody(mergeContentType, baseUri, RandomPayloadBuilder.GetRandomPayload(random, model, version)); requests.Add(request); request = requestManager.BuildRequest(baseUri, HttpVerb.Delete, headers); requests.Add(request); } return requests.ToArray(); }
public void WriteComplexParameterWithoutTypeInformationErrorTest() { EdmModel edmModel = new EdmModel(); var container = new EdmEntityContainer("DefaultNamespace", "DefaultContainer"); edmModel.AddElement(container); var testDescriptors = new PayloadWriterTestDescriptor<ODataParameters>[] { new PayloadWriterTestDescriptor<ODataParameters>( this.Settings, new ODataParameters() { new KeyValuePair<string, object>("p1", new ODataComplexValue()) }, tc => new WriterTestExpectedResults(this.ExpectedResultSettings) { ExpectedException2 = ODataExpectedExceptions.ODataException("ODataJsonLightPropertyAndValueSerializer_NoExpectedTypeOrTypeNameSpecifiedForComplexValueRequest") }) { DebugDescription = "Complex value without expected type or type name.", Model = edmModel }, }; this.CombinatorialEngineProvider.RunCombinations( testDescriptors, this.WriterTestConfigurationProvider.JsonLightFormatConfigurations.Where(tc => tc.IsRequest), (testDescriptor, testConfiguration) => { TestWriterUtils.WriteAndVerifyODataParameterPayload(testDescriptor, testConfiguration, this.Assert, this.Logger); }); }
public void EdmSingletonAnnotationTests() { EdmModel model = new EdmModel(); EdmStructuralProperty customerProperty = new EdmStructuralProperty(customerType, "Name", EdmCoreModel.Instance.GetString(false)); customerType.AddProperty(customerProperty); model.AddElement(this.customerType); EdmSingleton vipCustomer = new EdmSingleton(this.entityContainer, "VIP", this.customerType); EdmTerm term = new EdmTerm(myNamespace, "SingletonAnnotation", EdmPrimitiveTypeKind.String); var annotation = new EdmAnnotation(vipCustomer, term, new EdmStringConstant("Singleton Annotation")); model.AddVocabularyAnnotation(annotation); var singletonAnnotation = vipCustomer.VocabularyAnnotations(model).Single(); Assert.Equal(vipCustomer, singletonAnnotation.Target); Assert.Equal("SingletonAnnotation", singletonAnnotation.Term.Name); singletonAnnotation = model.FindDeclaredVocabularyAnnotations(vipCustomer).Single(); Assert.Equal(vipCustomer, singletonAnnotation.Target); Assert.Equal("SingletonAnnotation", singletonAnnotation.Term.Name); EdmTerm propertyTerm = new EdmTerm(myNamespace, "SingletonPropertyAnnotation", EdmPrimitiveTypeKind.String); var propertyAnnotation = new EdmAnnotation(customerProperty, propertyTerm, new EdmStringConstant("Singleton Property Annotation")); model.AddVocabularyAnnotation(propertyAnnotation); var singletonPropertyAnnotation = customerProperty.VocabularyAnnotations(model).Single(); Assert.Equal(customerProperty, singletonPropertyAnnotation.Target); Assert.Equal("SingletonPropertyAnnotation", singletonPropertyAnnotation.Term.Name); }
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 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); }
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)); }
public ODataJsonLightValueSerializerTests() { model = new EdmModel(); stream = new MemoryStream(); settings = new ODataMessageWriterSettings { DisableMessageStreamDisposal = true, Version = ODataVersion.V4 }; settings.SetServiceDocumentUri(new Uri("http://example.com")); }
public SQLDataSource(string name, string connectionString, Func<MethodType, string, bool> permissionCheck = null, string modelCommand = "GetEdmModelInfo", string funcCommand = "GetEdmSPInfo", string tvfCommand = "GetEdmTVFInfo", string relationCommand = "GetEdmRelationship", string storedProcedureResultSetCommand = "GetEdmSPResultSet", string userDefinedTableCommand = "GetEdmUDTInfo", string tableValuedResultSetCommand = "GetEdmTVFResultSet") { this.Name = name; this.ConnectionString = connectionString; this.PermissionCheck = permissionCheck; _Model = new Lazy<EdmModel>(() => { ModelCommand = modelCommand; FuncCommand = funcCommand; TableValuedCommand = tvfCommand; RelationCommand = relationCommand; StoredProcedureResultSetCommand = storedProcedureResultSetCommand; UserDefinedTableCommand = userDefinedTableCommand; TableValuedResultSetCommand = tableValuedResultSetCommand; var model = new EdmModel(); var container = new EdmEntityContainer("ns", "container"); model.AddElement(container); AddEdmElement(model); AddEdmFunction(model); AddTableValueFunction(model); BuildRelation(model); return model; }); }
public void AdvancedMapODataServiceRoute_ConfiguresARoute_WithAnODataRouteAndVersionConstraints() { // Arrange HttpRouteCollection routes = new HttpRouteCollection(); HttpConfiguration config = new HttpConfiguration(routes); IEdmModel model = new EdmModel(); string routeName = "name"; string routePrefix = "prefix"; var pathHandler = new DefaultODataPathHandler(); var conventions = new List<IODataRoutingConvention>(); // Act config.MapODataServiceRoute(routeName, routePrefix, model, pathHandler, conventions); // Assert IHttpRoute odataRoute = routes[routeName]; Assert.Single(routes); Assert.Equal(routePrefix + "/{*odataPath}", odataRoute.RouteTemplate); Assert.Equal(2, odataRoute.Constraints.Count); var odataPathConstraint = Assert.Single(odataRoute.Constraints.Values.OfType<ODataPathRouteConstraint>()); Assert.Same(model, odataPathConstraint.EdmModel); Assert.IsType<DefaultODataPathHandler>(odataPathConstraint.PathHandler); Assert.NotNull(odataPathConstraint.RoutingConventions); var odataVersionConstraint = Assert.Single(odataRoute.Constraints.Values.OfType<ODataVersionConstraint>()); Assert.NotNull(odataVersionConstraint.Version); Assert.Equal(ODataVersion.V4, odataVersionConstraint.Version); }
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; }
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 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 static IEdmModel BuildEdmModel(ODataModelBuilder builder) { if (builder == null) { throw Error.ArgumentNull("builder"); } EdmModel model = new EdmModel(); EdmEntityContainer container = new EdmEntityContainer(builder.Namespace, builder.ContainerName); // add types and sets, building an index on the way. Dictionary<Type, IEdmType> edmTypeMap = model.AddTypes(builder.StructuralTypes, builder.EnumTypes); Dictionary<string, EdmEntitySet> edmEntitySetMap = model.AddEntitySets(builder, container, edmTypeMap); // add procedures model.AddProcedures(builder.Procedures, container, edmTypeMap, edmEntitySetMap); // finish up model.AddElement(container); // build the map from IEdmEntityType to IEdmFunctionImport model.SetAnnotationValue<BindableProcedureFinder>(model, new BindableProcedureFinder(model)); // set the data service version annotations. model.SetDataServiceVersion(builder.DataServiceVersion); model.SetMaxDataServiceVersion(builder.MaxDataServiceVersion); return model; }
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." ); }
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); }
public void NullValueNonPropertyErrorTests() { EdmModel model = new EdmModel(); var entityType = model.EntityType("OwningType", "TestModel").KeyProperty("ID", EdmCoreModel.Instance.GetInt32(false) as EdmTypeReference); model.EntityContainer("DefaultContainer"); var entitySet = model.EntitySet("EntitySet", entityType); IEnumerable<PayloadReaderTestDescriptor> testDescriptors = new[] { new PayloadReaderTestDescriptor(this.Settings) { DebugDescription = "null collection - should fail.", PayloadEdmModel = model, PayloadElement = PayloadBuilder.PrimitiveCollection().ExpectedCollectionItemType(EdmDataTypes.Int32) .JsonRepresentation( "{" + "\"@odata.context\":\"http://odata.org/test/$metadata#Edm.Null\"" + "}"), ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightContextUriParser_ContextUriDoesNotMatchExpectedPayloadKind", "http://odata.org/test/$metadata#Edm.Null", "Collection") }, new PayloadReaderTestDescriptor(this.Settings) { DebugDescription = "null entry - should fail.", PayloadEdmModel = model, PayloadElement = PayloadBuilder.NullEntity().ExpectedEntityType(entityType, entitySet) .JsonRepresentation( "{" + "\"@odata.context\":\"http://odata.org/test/$metadata#Edm.Null\"" + "}"), ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightContextUriParser_ContextUriDoesNotMatchExpectedPayloadKind", "http://odata.org/test/$metadata#Edm.Null", "Entry") }, new PayloadReaderTestDescriptor(this.Settings) { DebugDescription = "null feed - should fail.", PayloadEdmModel = model, PayloadElement = PayloadBuilder.EntitySet().ExpectedEntityType(entityType, entitySet) .JsonRepresentation( "{" + "\"@odata.context\":\"http://odata.org/test/$metadata#Edm.Null\"" + "}"), ExpectedException = ODataExpectedExceptions.ODataException("ODataJsonLightContextUriParser_ContextUriDoesNotMatchExpectedPayloadKind", "http://odata.org/test/$metadata#Edm.Null", "Feed") }, }; this.CombinatorialEngineProvider.RunCombinations( testDescriptors, this.ReaderTestConfigurationProvider.JsonLightFormatConfigurations, (testDescriptor, testConfiguration) => { if (testConfiguration.IsRequest) { return; } // These descriptors are already tailored specifically for Json Light and // do not require normalization. testDescriptor.TestDescriptorNormalizers.Clear(); testDescriptor.RunTest(testConfiguration); }); }
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 void Init() { EdmModel model = new EdmModel(); EdmComplexType complex1 = new EdmComplexType("ns", "complex1"); complex1.AddProperty(new EdmStructuralProperty(complex1, "p1", EdmCoreModel.Instance.GetInt32(isNullable: false))); model.AddElement(complex1); EdmComplexType complex2 = new EdmComplexType("ns", "complex2"); complex2.AddProperty(new EdmStructuralProperty(complex2, "p1", EdmCoreModel.Instance.GetInt32(isNullable: false))); model.AddElement(complex2); EdmComplexTypeReference complex2Reference = new EdmComplexTypeReference(complex2, isNullable: false); EdmCollectionType primitiveCollectionType = new EdmCollectionType(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false)); EdmCollectionType complexCollectionType = new EdmCollectionType(complex2Reference); EdmCollectionTypeReference primitiveCollectionTypeReference = new EdmCollectionTypeReference(primitiveCollectionType); EdmCollectionTypeReference complexCollectionTypeReference = new EdmCollectionTypeReference(complexCollectionType); model.AddElement(new EdmTerm("custom", "int", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false))); model.AddElement(new EdmTerm("custom", "string", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false))); model.AddElement(new EdmTerm("custom", "double", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, isNullable: false))); model.AddElement(new EdmTerm("custom", "bool", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: true))); model.AddElement(new EdmTerm("custom", "decimal", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Decimal, isNullable: false))); model.AddElement(new EdmTerm("custom", "timespan", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Duration, isNullable: false))); model.AddElement(new EdmTerm("custom", "guid", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Guid, isNullable: false))); model.AddElement(new EdmTerm("custom", "complex", complex2Reference)); model.AddElement(new EdmTerm("custom", "primitiveCollection", primitiveCollectionTypeReference)); model.AddElement(new EdmTerm("custom", "complexCollection", complexCollectionTypeReference)); this.stream = new MemoryStream(); this.settings = new ODataMessageWriterSettings { Version = ODataVersion.V4, ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*") }; this.settings.SetServiceDocumentUri(ServiceDocumentUri); this.serializer = new ODataAtomPropertyAndValueSerializer(this.CreateAtomOutputContext(model, this.stream)); }
public void GetModelID_AndThen_GetModel_ReturnsOriginalModel() { EdmModel model = new EdmModel(); string modelID = ModelContainer.GetModelID(model); Assert.Same(model, ModelContainer.GetModel(modelID)); }
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); }
private static void SetComputedAnnotation(EdmModel model, IEdmProperty target) { // when 'target' is <Key> property, V4's 'Computed' also has the meaning of OData V3's 'Identity'. var val = new EdmBooleanConstant(value: true); var annotation = new EdmAnnotation(target, CoreVocabularyModel.ComputedTerm, val); annotation.SetSerializationLocation(model, EdmVocabularyAnnotationSerializationLocation.Inline); model.SetVocabularyAnnotation(annotation); }
private static IEdmEntityType CreateEntityType( IModel efModel, IEntityType efEntityType, EdmModel model, out List <EdmStructuralProperty> concurrencyProperties) { // TODO GitHubIssue#36 : support complex and entity inheritance var entityType = new EdmEntityType( efEntityType.ClrType.Namespace, efEntityType.ClrType.Name); concurrencyProperties = null; foreach (var efProperty in efEntityType.GetProperties()) { var type = ModelProducer.GetPrimitiveTypeReference(efProperty); if (type != null) { string defaultValue = null; RelationalPropertyAnnotations annotations = new RelationalPropertyAnnotations(efProperty, null); if (annotations.DefaultValue != null) { defaultValue = annotations.DefaultValue.ToString(); } var property = entityType.AddStructuralProperty( efProperty.Name, type, defaultValue, EdmConcurrencyMode.None); // alway None:replaced by OptimisticConcurrency annotation // TODO GitHubIssue#57: Complete EF7 to EDM model mapping if (efProperty.StoreGeneratedAlways) { SetComputedAnnotation(model, property); } if (efProperty.IsConcurrencyToken) { concurrencyProperties = concurrencyProperties ?? new List <EdmStructuralProperty>(); concurrencyProperties.Add(property); } } } var key = efEntityType.GetPrimaryKey(); if (key != null) { entityType.AddKeys(key.Properties .Select(p => entityType.FindProperty(p.Name)) .Cast <IEdmStructuralProperty>()); } return(entityType); }
private static IEdmEntityType CreateEntityType( MetadataWorkspace efModel, EntityType efEntityType, EdmModel model, IDictionary <MetadataItem, IEdmElement> elementMap, out List <EdmStructuralProperty> concurrencyProperties) { // TODO GitHubIssue#36 : support complex and entity inheritance var objectSpaceType = efModel.GetObjectSpaceType(efEntityType) as EntityType; var entityType = new EdmEntityType(objectSpaceType.NamespaceName, objectSpaceType.Name); concurrencyProperties = null; foreach (var efProperty in efEntityType.Properties) { var type = GetTypeReference(efProperty, model, elementMap); if (type != null) { string defaultValue = null; if (efProperty.DefaultValue != null) { defaultValue = efProperty.DefaultValue.ToString(); } var property = entityType.AddStructuralProperty( efProperty.Name, type, defaultValue, EdmConcurrencyMode.None); // alway None:replaced by OptimisticConcurrency annotation MetadataProperty storeGeneratedPattern = null; efProperty.MetadataProperties.TryGetValue( AnnotationSchema + StoreGeneratedPatternKey, true, out storeGeneratedPattern); if (storeGeneratedPattern != null && (string)storeGeneratedPattern.Value == StoreGeneratedPatternValueComputed) { SetComputedAnnotation(model, property); } if (efProperty.ConcurrencyMode == ConcurrencyMode.Fixed) { concurrencyProperties = concurrencyProperties ?? new List <EdmStructuralProperty>(); concurrencyProperties.Add(property); } } } entityType.AddKeys(efEntityType.KeyProperties .Select(p => entityType.FindProperty(p.Name)) .Cast <IEdmStructuralProperty>()); return(entityType); }
/// <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 IEdmTypeReference GetTypeReference( EdmProperty efProperty, EdmModel model, IDictionary <MetadataItem, IEdmElement> elementMap) { if (efProperty.IsPrimitiveType) { return(GetPrimitiveTypeReference(efProperty)); } else if (efProperty.IsComplexType) { return(GetComplexTypeReference(efProperty, model, elementMap)); } // TODO GitHubIssue#103 : Choose property error message for unknown type return(null); }
/// <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)); }
private static void AddNavigationProperties( IModel efModel, INavigation navigation, EdmModel model, IDictionary <IAnnotatable, IEdmElement> elementMap) { if (!navigation.PointsToPrincipal()) { return; } var naviPair = new INavigation[] { navigation, navigation.FindInverse() }; var navPropertyInfos = new EdmNavigationPropertyInfo[2]; for (var i = 0; i < 2; i++) { var navi = naviPair[i]; if (navi == null) { continue; } var efEntityType = navi.DeclaringEntityType; if (!elementMap.ContainsKey(efEntityType)) { continue; } var entityType = elementMap[efEntityType] as IEdmEntityType; var efTargetEntityType = navi.GetTargetType(); if (!elementMap.ContainsKey(efTargetEntityType)) { continue; } var targetEntityType = elementMap[efTargetEntityType] as IEdmEntityType; navPropertyInfos[i] = new EdmNavigationPropertyInfo() { ContainsTarget = false, Name = navi.Name, Target = targetEntityType, TargetMultiplicity = ModelProducer.GetEdmMultiplicity(navi), }; var foreignKey = navi.ForeignKey; if (foreignKey != null && navi.PointsToPrincipal()) { navPropertyInfos[i].OnDelete = foreignKey.DeleteBehavior == DeleteBehavior.Cascade ? EdmOnDeleteAction.Cascade : EdmOnDeleteAction.None; navPropertyInfos[i].DependentProperties = foreignKey.Properties .Select(p => entityType.FindProperty(p.Name) as IEdmStructuralProperty); navPropertyInfos[i].PrincipalProperties = foreignKey.PrincipalKey.Properties .Select(p => targetEntityType.FindProperty(p.Name) as IEdmStructuralProperty); } } if (navPropertyInfos[0] == null && navPropertyInfos[1] != null) { var efEntityType = navigation.GetTargetType(); var entityType = elementMap[efEntityType] as EdmEntityType; if (entityType.FindProperty(navPropertyInfos[1].Name) == null) { entityType.AddUnidirectionalNavigation(navPropertyInfos[1]); } } if (navPropertyInfos[0] != null && navPropertyInfos[1] == null) { var efEntityType = navigation.DeclaringEntityType; var entityType = elementMap[efEntityType] as EdmEntityType; if (entityType.FindProperty(navPropertyInfos[0].Name) == null) { entityType.AddUnidirectionalNavigation(navPropertyInfos[0]); } } if (navPropertyInfos[0] != null && navPropertyInfos[1] != null) { var efEntityType = navigation.DeclaringEntityType; var entityType = elementMap[efEntityType] as EdmEntityType; if (entityType.FindProperty(navPropertyInfos[0].Name) == null) { entityType.AddBidirectionalNavigation( navPropertyInfos[0], navPropertyInfos[1]); } } }