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