public static IEdmModel GetModel(this ConnectionProperties properties)
{
var uri = properties.Uri;
uri += uri.EndsWith("/") ? "$metadata" : "/$metadata";
IEdmModel model;
var settings = new XmlReaderSettings
{
XmlResolver = new XmlUrlResolver
{
Credentials = properties.GetCredentials(),
Proxy = properties.GetWebProxy()
},
DtdProcessing = DtdProcessing.Parse
};
using (var reader = XmlReader.Create(uri, settings))
{
model = EdmxReader.Parse(reader);
}
return(model);
}
private IEdmModel LoadModel()
{
var xmlTextReader = new XmlTextReader(GetMetadataUri().ToString());
IEdmModel model = EdmxReader.Parse(xmlTextReader);
return(model);
}
/// <summary>
/// This methods reads the metadata from the input and returns an <see cref="IEdmModel"/>
/// representing the read metadata information.
/// </summary>
/// <returns>An <see cref="IEdmModel"/> instance representing the read metadata.</returns>
private IEdmModel ReadMetadataDocumentImplementation()
{
IEdmModel model;
IEnumerable <EdmError> errors;
if (!EdmxReader.TryParse(this.xmlReader, out model, out errors))
{
Debug.Assert(errors != null, "errors != null");
StringBuilder builder = new StringBuilder();
foreach (EdmError error in errors)
{
builder.AppendLine(error.ToString());
}
throw new ODataException(Strings.ODataMetadataInputContext_ErrorReadingMetadata(builder.ToString()));
}
Debug.Assert(model != null, "model != null");
// Load all the OData annotations, i.e., translate them from their serializable form into the more usable in-memory form.
model.LoadODataAnnotations(this.MessageReaderSettings.MessageQuotas.MaxEntityPropertyMappingsPerType);
return(model);
}
public void AllElementsInExtendedContainerTest()
{
string mainModelxml = @"<?xml version=""1.0"" encoding=""utf-16""?>
<edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx"">
<edmx:Reference Uri=""http://host/schema/Location.xml"">
<edmx:Include Namespace=""Namespace1"" Alias=""A1"" />
</edmx:Reference>
<edmx:DataServices>
<Schema Namespace=""Namespace0"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityContainer Name=""DefaultContainer0"" Extends=""Namespace1.Container_sub"">
</EntityContainer>
</Schema>
</edmx:DataServices>
</edmx:Edmx>";
EdmModel model1 = new EdmModel();
EdmEntityType entityType1 = new EdmEntityType("Namespace1", "EntityType");
EdmEntityContainer edmEntityContainer1 = new EdmEntityContainer("Namespace1", "Container_sub");
edmEntityContainer1.AddEntitySet("EntitySet1", entityType1);
model1.AddElement(edmEntityContainer1);
IEdmModel mainModel;
IEnumerable <EdmError> errors;
bool parsed = EdmxReader.TryParse(XmlReader.Create(new StringReader(mainModelxml)), new IEdmModel[] { model1 }, out mainModel, out errors);
Assert.IsTrue(parsed);
var container = mainModel.EntityContainer;
Assert.AreEqual(1, container.AllElements().Count());
}
public void FindEntitySetInExtendedContainer_1stTest()
{
string mainModelxml = @"<?xml version=""1.0"" encoding=""utf-16""?>
<edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx"">
<edmx:Reference Uri=""http://host/schema/Location.xml"">
<edmx:Include Namespace=""Namespace1"" Alias=""A1"" />
</edmx:Reference>
<edmx:DataServices>
<Schema Namespace=""Namespace0"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityContainer Name=""DefaultContainer0"" Extends=""Namespace1.Container_sub"">
</EntityContainer>
</Schema>
</edmx:DataServices>
</edmx:Edmx>";
EdmModel model1 = new EdmModel();
EdmEntityType entityType1 = new EdmEntityType("Namespace1", "EntityType");
EdmEntityContainer edmEntityContainer1 = new EdmEntityContainer("Namespace1", "Container_sub");
edmEntityContainer1.AddEntitySet("EntitySet1", entityType1);
model1.AddElement(edmEntityContainer1);
IEdmModel mainModel;
IEnumerable <EdmError> errors;
bool parsed = EdmxReader.TryParse(XmlReader.Create(new StringReader(mainModelxml)), new IEdmModel[] { model1 }, out mainModel, out errors);
Assert.IsTrue(parsed);
IEdmEntitySet entitySet1 = mainModel.FindDeclaredEntitySet("EntitySet1");
IEdmEntitySet entitySet1FromContainer = mainModel.EntityContainer.FindEntitySetExtended("EntitySet1");
Assert.AreEqual(entitySet1, entitySet1FromContainer, "Should find the same entityset.");
Assert.IsNotNull(entitySet1, "Should find across model and get not-null entity set.");
Assert.AreEqual("Namespace1.Container_sub", entitySet1.Container.FullName(), "name should be correct.");
}
internal static object GetAnnotation(this IODataServiceContext context, params object[] customs)
{
if (false == (null != customs && customs.Count() <= 3))
{
return(null);
}
var serviceUri = customs[0] as Uri;
var requestUri = customs[1] as Uri;
var metadata = customs[2] as IODataServiceMetadata;
IEdmModel edmModel = EdmxReader.Parse(XmlReader.Create(serviceUri + "/$metadata"));
IEdmEntitySet edmEntitySet = edmModel.EntityContainers()
.First()
.EntitySets()
.FirstOrDefault(es =>
es.Name.ToLower() == requestUri.Segments.Last().ToLower() ||
requestUri.Segments.Last().ToLower().StartsWith(es.Name.ToLower() + "(")
);
IEdmEntityType edmEntityType = edmEntitySet.ElementType;
ODataUriParser internalParser = new ODataUriParser(edmModel, serviceUri);
var odataParser = new ODataParser()
{
EdmModel = edmModel,
EdmEntitySet = edmEntitySet,
EdmEntityType = edmEntityType,
InternalParser = internalParser,
Metadata = metadata,
};
return(odataParser);
}
public void ProvideOverloadToSupplyEntitySetConfiguration()
{
IEdmModel model = null;
Stream stream = Client.GetStreamAsync(BaseAddress + "/odata/$metadata").Result;
using (XmlReader reader = XmlReader.Create(stream))
{
model = EdmxReader.Parse(reader);
}
IEdmFunctionImport collection = model.FindDeclaredEntityContainer("Container").FindFunctionImports("GetProductsByCategory").SingleOrDefault();
IEdmEntityType expectedReturnType = model.FindDeclaredType(typeof(ActionProduct).FullName) as IEdmEntityType;
Assert.NotNull(expectedReturnType);
Assert.NotNull(collection);
Assert.True(collection.IsBindable);
Assert.NotNull(collection.ReturnType.AsCollection());
Assert.NotNull(collection.ReturnType.AsCollection().ElementType().AsEntity());
Assert.Equal(expectedReturnType, collection.ReturnType.AsCollection().ElementType().AsEntity().EntityDefinition());
IEdmFunctionImport single = model.FindDeclaredEntityContainer("Container").FindFunctionImports("GetSpecialProduct").SingleOrDefault();
Assert.NotNull(single);
Assert.True(single.IsBindable);
Assert.NotNull(single.ReturnType.AsEntity());
Assert.Equal(expectedReturnType, single.ReturnType.AsEntity().EntityDefinition());
}
public OdcmModel GenerateOdcmModel(IReadOnlyDictionary <string, string> serviceMetadata)
{
if (serviceMetadata == null)
{
throw new ArgumentNullException("serviceMetadata");
}
if (!serviceMetadata.ContainsKey(MetadataKey))
{
throw new ArgumentException("Argument must contain value for key \"$metadata\"", "serviceMetadata");
}
var edmx = XElement.Parse(serviceMetadata[MetadataKey]);
IEnumerable <EdmError> errors;
if (!EdmxReader.TryParse(edmx.CreateReader(ReaderOptions.None), out _edmModel, out errors))
{
Debug.Assert(errors != null, "errors != null");
if (errors.FirstOrDefault() == null)
{
throw new InvalidOperationException();
}
throw new InvalidOperationException(errors.FirstOrDefault().ErrorMessage);
}
_odcmModel = new OdcmModel(serviceMetadata);
WriteNamespaces();
return(_odcmModel);
}
public static void Register(HttpConfiguration config)
{
var model2 = EdmxReader.Parse(XmlReader.Create("http://localhost:9091/odata/$metadata"));
var model = new EdmModel();
model.AddReferencedModel(model2);
var reference = new EdmReference("http://localhost:9091/odata/$metadata");
reference.AddInclude(new EdmInclude("Model2", "SampleService2.Models"));
model.SetEdmReferences(new List <IEdmReference> {
reference
});
var container = new EdmEntityContainer("NS1", "Default");
var order = model2.FindDeclaredType("SampleService2.Models.Order") as IEdmEntityType;
model2.SetAnnotationValue <ClrTypeAnnotation>(order, new ClrTypeAnnotation(typeof(Order)));
container.AddEntitySet("Orders", order);
model.AddElement(container);
var product = new EdmEntityType("NS1", "Product");
product.AddKeys(product.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
product.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(product);
config.MapODataServiceRoute("odata", "odata", model);
}
public void Configure()
{
if (_ctx.ResolveName == null)
{
_ctx.ResolveName = t => t.FullName;
}
_ctx.Format.LoadServiceModel = () =>
{
Uri metadataUri = _ctx.GetMetadataUri();
if (!models.ContainsKey(metadataUri))
{
var xmlTextReader = new XmlTextReader(metadataUri.ToString());
IEdmModel edmModel = null;
IEnumerable <EdmError> errors = null;
if (EdmxReader.TryParse(xmlTextReader, out edmModel, out errors))
{
models[metadataUri] = edmModel;
}
else
{
var errorMessageBuilder = new StringBuilder("Model creation failed; please resolve the following errors in the metadata document:");
foreach (EdmError error in errors)
{
errorMessageBuilder.AppendLine(String.Format("t{0}", error.ErrorMessage));
}
throw new Exception(errorMessageBuilder.ToString());
}
}
return(models[metadataUri]);
};
_ctx.Format.UseJson();
_ctx.SendingRequest2 += ChangeAcceptHeader;
}
public void CanRenamePropertiesInRegularModelBuilder()
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, BaseAddress + "/explicit/$metadata");
HttpResponseMessage response = Client.SendAsync(request).Result;
IEdmModel model = EdmxReader.Parse(XmlReader.Create(response.Content.ReadAsStreamAsync().Result));
// Can change the name of regular, complex and navigation properties.
IEdmEntityType customer = model.FindDeclaredType("ModelAliasing.Customer") as IEdmEntityType;
Assert.NotNull(customer);
Assert.NotNull(customer.FindProperty("FinancialAddress"));
Assert.NotNull(customer.FindProperty("ClientName"));
Assert.NotNull(customer.FindProperty("Purchases"));
// Can change the name of properties on complex objects
IEdmComplexType address = model.FindDeclaredType("Location.Direction") as IEdmComplexType;
Assert.NotNull(address);
Assert.NotNull(address.FindProperty("Reign"));
//Can change the name of properties on derived entities.
IEdmEntityType expressOrder = model.FindDeclaredType("Purchasing.ExpressOrder") as IEdmEntityType;
Assert.NotNull(expressOrder);
//Can change the name of properties on derived entities when added explicitly.
Assert.NotNull(expressOrder.FindProperty("Fee"));
//Data contract attribute doesn't change the name of the property.
Assert.Null(expressOrder.FindProperty("DeliveryDate"));
Assert.Null(expressOrder.FindProperty("GuanteedDeliveryDate"));
// Data contract attribute doesn't change the names of the properties
IEdmEntityType ordersLines = model.FindDeclaredType("WebStack.QA.Test.OData.ModelAliasing.ModelAliasingMetadataOrderLine") as IEdmEntityType;
Assert.NotNull(ordersLines);
Assert.Null(ordersLines.FindProperty("Product"));
Assert.NotNull(ordersLines.FindProperty("Item"));
// Data contract attribute doesn't override any explicit configuration on the model builder
Assert.NotNull(ordersLines.FindProperty("Cost"));
}
public void CanRenameTypesAndNamespacesInRegularModelBuilder()
{
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, BaseAddress + "/explicit/$metadata");
HttpResponseMessage response = Client.SendAsync(request).Result;
IEdmModel model = EdmxReader.Parse(XmlReader.Create(response.Content.ReadAsStreamAsync().Result));
//Can rename an entity + namespace
IEdmEntityType customer = model.FindDeclaredType("ModelAliasing.Customer") as IEdmEntityType;
Assert.NotNull(customer);
//Explicit configuration on the model builder overrides any configuration on the DataContract attribute.
IEdmEntityType orders = model.FindDeclaredType("AliasedNamespace.Order") as IEdmEntityType;
Assert.NotNull(orders);
//Can rename a derived entity name + namespace
IEdmEntityType expressOrder = model.FindDeclaredType("Purchasing.ExpressOrder") as IEdmEntityType;
Assert.NotNull(expressOrder);
//DataContract doesn't rename the entity or the namespace
IEdmEntityType freeDeliveryOrder = model.FindDeclaredType("Purchasing.FreeOrder") as IEdmEntityType;
Assert.NotNull(freeDeliveryOrder);
//DataContract doesn't rename the entity or the namespace
IEdmEntityType ordersLines = model.FindDeclaredType("Billing.OrderLine") as IEdmEntityType;
Assert.Null(ordersLines);
//Can change the name and the namespaces for complex types
IEdmComplexType region = model.FindDeclaredType("Location.PoliticalRegion") as IEdmComplexType;
Assert.NotNull(region);
IEdmComplexType address = model.FindDeclaredType("Location.Direction") as IEdmComplexType;
Assert.NotNull(address);
}
private static IEdmModel GetEndpointModel(string modelUrl)
{
using (WebResponse response = ReaderUtils.CreateRequest(modelUrl).GetResponse())
{
return(EdmxReader.Parse(XmlReader.Create(response.GetResponseStream())));
}
}
private static async Task RunAsync(EntityMetadataCollection entities)
{
try
{
var webApiClient = new WebApiClient();
var webApiMetadata = await webApiClient.GetWebApiMetadata();
IEdmModel metadataModel;
IEnumerable <EdmError> errors;
bool parseSuccess = EdmxReader.TryParse(XmlReader.Create(new StringReader(webApiMetadata)), out metadataModel, out errors);
if (parseSuccess)
{
var edmSchemaElements = metadataModel.SchemaElements.Where(se =>
se.SchemaElementKind == EdmSchemaElementKind.TypeDefinition &&
ExcludedEntities.All(ee => ee.ToLowerInvariant() != se.Name.ToLowerInvariant()));
foreach (IEdmSchemaElement schemaElement in edmSchemaElements)
{
var entity = entities.FirstOrDefault(e => e.LogicalName == schemaElement.Name);
if (entity != null)
{
WriteEntityTsFile(schemaElement as IEdmEntityType, entity);
}
}
}
}
catch (Exception e)
{
Console.Out.WriteLine("Error in RunAsync(): " + e.Message);
}
Console.WriteLine("Done! Press any key to close the application");
Console.Read();
}
private void ParseBindingWithExpectedErrors(string bindingText, EdmErrorCode errorCode, params string[] messages)
{
const string template = @"<edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx"">
<edmx:DataServices>
<Schema Namespace=""Test"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityContainer Name=""Container"">
<EntitySet Name=""EntitySet"" EntityType=""Test.EntityType"">
{0}
</EntitySet>
</EntityContainer>
</Schema>
</edmx:DataServices>
</edmx:Edmx>";
string modelText = string.Format(template, bindingText);
IEdmModel model;
IEnumerable <EdmError> errors;
EdmxReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors).Should().BeFalse();
errors.Should().HaveCount(messages.Length);
foreach (var message in messages)
{
errors.Should().Contain(e => e.ErrorCode == errorCode && e.ErrorMessage == message);
}
}
public void FindVocabularyAnnotationInParallel()
{
int annotationCount = 30;
var edmModel = new EdmParModel().Model as EdmModel;
var container = edmModel.EntityContainer;
for (int i = 0; i < annotationCount; i++)
{
EdmTerm term = new EdmTerm("NS", "Test" + i, EdmPrimitiveTypeKind.String);
EdmVocabularyAnnotation annotation = new EdmAnnotation(
container,
term,
new EdmStringConstant("desc" + i));
edmModel.AddVocabularyAnnotation(annotation);
}
IEdmModel loadedEdmModel = null;
using (var ms = new MemoryStream())
{
var xw = XmlWriter.Create(ms, new XmlWriterSettings {
Indent = true
});
IEnumerable <EdmError> errors;
var res = EdmxWriter.TryWriteEdmx(edmModel, xw, EdmxTarget.OData, out errors);
xw.Flush();
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
using (var sr = new StreamReader(ms))
{
var metadata = sr.ReadToEnd();
loadedEdmModel = EdmxReader.Parse(XmlReader.Create(new MemoryStream(Encoding.UTF8.GetBytes(metadata))));
}
}
container = loadedEdmModel.EntityContainer;
int errorCount = 0;
int totalAnnotationCount = 0;
int taskCount = 100;
Parallel.ForEach(
Enumerable.Range(0, taskCount),
index =>
{
try
{
var count = loadedEdmModel.FindVocabularyAnnotations(container).ToList().Count();
Interlocked.Add(ref totalAnnotationCount, count);
}
catch (Exception ew)
{
Console.WriteLine(ew);
Interlocked.Increment(ref errorCount);
}
});
Assert.AreEqual(0, errorCount);
Assert.AreEqual(taskCount * annotationCount, totalAnnotationCount);
}
public void CheckEdmxVersionMismatch()
{
// Edmx namespace is for v 2.0 != Version="4.0"
const string edmx =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<edmx:Edmx Version=""2.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx"">
<edmx:Runtime>
<edmx:ConceptualModels>
<Schema Namespace=""NS1"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityType Name=""Customer"">
<Key>
<PropertyRef Name=""CustomerID"" />
</Key>
<Property Name=""CustomerID"" Type=""Edm.String"" Nullable=""false"" />
</EntityType>
<EntityContainer Name=""C1"">
<EntitySet Name=""Customers"" EntityType=""NS1.Customer"" />
</EntityContainer>
</Schema>
</edmx:ConceptualModels>
</edmx:Runtime>
</edmx:Edmx>";
IEdmModel model;
IEnumerable <EdmError> errors;
bool parsed = EdmxReader.TryParse(XmlReader.Create(new StringReader(edmx)), out model, out errors);
Assert.IsFalse(parsed, "Model failed to parse");
Assert.IsTrue(errors.Count() == 1, "1 Error");
Assert.AreEqual(EdmErrorCode.InvalidVersionNumber, errors.First().ErrorCode, "Error code check");
}
static void Main(string[] args)
{
Console.WriteLine("Reading from EDMX file...");
// reading from edmx file
var edmxPath = "./Sample_v3.edmx";
using (var reader = XmlReader.Create(edmxPath))
{
const string basePath = "bin/Output/Models";
Directory.CreateDirectory(basePath);
// select from all entity sets
var model = EdmxReader.Parse(reader);
var entityTypes = model.EntityContainers().First().EntitySets().Select(set => set.ElementType);
foreach (var entityType in entityTypes)
{
var entity = EntityDefinition.From(entityType);
File.WriteAllText(Path.Combine(basePath, $"{entityType.Name}.cs"), entity.NormalizeWhitespace().ToFullString());
Console.WriteLine($"{entityType.Name}");
}
}
Console.WriteLine("All done.");
}
public static IEdmModel GetModel()
{
if (_model == null)
{
IEdmModel edmModel;
IEnumerable <EdmError> edmErrors;
if (EdmxReader.TryParse(XmlReader.Create(new StringReader(GetEdmx())), out edmModel, out edmErrors))
{
_model = edmModel;
_model.SetAnnotationValue <ClrTypeAnnotation>(_model.FindDeclaredType("ODataDemo.Product"), new ClrTypeAnnotation(typeof(ODataEntityDeserializerTests.Product)));
_model.SetAnnotationValue <ClrTypeAnnotation>(_model.FindDeclaredType("ODataDemo.Supplier"), new ClrTypeAnnotation(typeof(ODataEntityDeserializerTests.Supplier)));
_model.SetAnnotationValue <ClrTypeAnnotation>(_model.FindDeclaredType("ODataDemo.Address"), new ClrTypeAnnotation(typeof(ODataEntityDeserializerTests.Address)));
_model.SetAnnotationValue <ClrTypeAnnotation>(_model.FindDeclaredType("ODataDemo.Category"), new ClrTypeAnnotation(typeof(ODataEntityDeserializerTests.Category)));
return(_model);
}
else
{
throw new NotSupportedException(string.Format("Parsing csdl failed with errors {0}", String.Join("\n", edmErrors.Select((edmError => edmError.ErrorMessage)))));
}
}
else
{
return(_model);
}
}
private IEdmModel LoadModelFromString(string xmlString)
{
var tr = new StringReader(MetaDataAsString);
var model2 = EdmxReader.Parse(XmlReader.Create(tr));
return(model2);
}
public OasisRelationshipChangesAcceptanceTests()
{
this.representativeModel = EdmxReader.Parse(XElement.Parse(RepresentativeEdmxDocument).CreateReader());
var container = this.representativeModel.EntityContainer;
this.entitySet1 = container.FindEntitySet("EntitySet1");
this.entitySet2 = container.FindEntitySet("EntitySet2");
this.entityType = this.representativeModel.FindType("Test.EntityType") as IEdmEntityType;
this.entitySet1.Should().NotBeNull();
this.entitySet2.Should().NotBeNull();
this.entityType.Should().NotBeNull();
this.navigation1 = this.entityType.FindProperty("navigation") as IEdmNavigationProperty;
this.navigation2 = this.entityType.FindProperty("NAVIGATION") as IEdmNavigationProperty;
nonKeyPrincipalNavigation = this.entityType.FindProperty("NonKeyPrincipalNavigation") as IEdmNavigationProperty;
var derivedType = this.representativeModel.FindType("Test.DerivedEntityType") as IEdmEntityType;
derivedType.Should().NotBeNull();
this.derivedNavigation = derivedType.FindProperty("DerivedNavigation") as IEdmNavigationProperty;
this.navigation1.Should().NotBeNull();
this.navigation2.Should().NotBeNull();
this.derivedNavigation.Should().NotBeNull();
}
private void ParseReferentialConstraintWithExpectedErrors(string referentialConstraintText, EdmErrorCode errorCode, params string[] messages)
{
const string template = @"<edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx"">
<edmx:DataServices>
<Schema Namespace=""Test"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityType Name=""EntityType"">
<Key>
<PropertyRef Name=""ID1"" />
<PropertyRef Name=""ID2"" />
</Key>
<Property Name=""ID1"" Type=""Edm.Int32"" Nullable=""false"" />
<Property Name=""ID2"" Type=""Edm.Int32"" Nullable=""false"" />
<Property Name=""ForeignKeyId1"" Type=""Edm.Int32"" />
<Property Name=""ForeignKeyId2"" Type=""Edm.Int32"" />
<NavigationProperty Name=""Navigation"" Type=""Test.EntityType"" Nullable=""true"">
{0}
</NavigationProperty>
</EntityType>
</Schema>
</edmx:DataServices>
</edmx:Edmx>";
string modelText = string.Format(template, referentialConstraintText);
IEdmModel model;
IEnumerable <EdmError> errors;
EdmxReader.TryParse(XElement.Parse(modelText).CreateReader(), out model, out errors).Should().BeFalse();
errors.Should().HaveCount(messages.Length);
foreach (var message in messages)
{
errors.Should().Contain(e => e.ErrorCode == errorCode && e.ErrorMessage == message);
}
}
/// <summary>
/// Easily wrap existing models as referenced models, and return a main model.
/// </summary>
/// <param name="namespaceOfContainerToExtend"></param>
/// <param name="nameOfContainerToExtend"></param>
/// <param name="referencedModels">Ths first one should have the container (of namespaceOfContainerToExtend) to extend.</param>
/// <returns>The main model.</returns>
public static IEdmModel WrapReferencedModelsToMainModel(string namespaceOfContainerToExtend, string nameOfContainerToExtend, params IEdmModel[] referencedModels)
{
Assert.True(nameOfContainerToExtend + "_sub" == referencedModels[0].EntityContainer.Name, "the container name of '" + nameOfContainerToExtend + "' will be used by main model, so the container name in referenced model must have been appended with '_sub'.");
string mainModelxml = @"<?xml version=""1.0"" encoding=""utf-16""?>
<edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx"">
<edmx:Reference Uri=""http://host/schema/Location.xml"">
<edmx:Include Namespace=""Test.Chh"" Alias=""NO_Alias"" />
</edmx:Reference>
<edmx:DataServices>
<Schema Namespace=""{0}"" xmlns=""http://docs.oasis-open.org/odata/ns/edm"">
<EntityContainer Name=""{1}"" Extends=""{0}.{1}_sub"">
</EntityContainer>
</Schema>
</edmx:DataServices>
</edmx:Edmx>";
mainModelxml = string.Format(mainModelxml, namespaceOfContainerToExtend, nameOfContainerToExtend);
IEdmModel ret;
IEnumerable <EdmError> errors;
if (EdmxReader.TryParse(XmlReader.Create(new StringReader(mainModelxml)), new List <IEdmModel>(referencedModels), out ret, out errors))
{
return(ret);
}
Assert.False(errors.Any(), "should be zero error.");
return(null);
}
public DefaultTestModel()
{
this.RepresentativeModel = EdmxReader.Parse(XElement.Parse(RepresentativeEdmxDocument).CreateReader());
this.EntityContainer = this.RepresentativeModel.EntityContainer;
this.EntityContainer.Should().NotBeNull();
this.EntityContainer.Name.Should().Be("Container");
this.AddAction = (IEdmAction)this.RepresentativeModel.FindDeclaredOperations("Test.Add").Single();
this.OtherAction = (IEdmAction)this.RepresentativeModel.FindDeclaredOperations("Test.Other").Single();
this.RemoveBadCarAction = (IEdmAction)this.RepresentativeModel.FindDeclaredOperations("Test.RemoveBadCar").Single();
this.Get1Function = (IEdmFunction)this.RepresentativeModel.FindDeclaredOperations("Test.Get1").Single();
this.Get2Function = (IEdmFunction)this.RepresentativeModel.FindDeclaredOperations("Test.Get2").Single();
var operations = this.RepresentativeModel.FindDeclaredOperations("Test.Get3").ToList();
this.Get3FunctionOneParam = (IEdmFunction)operations[0];
this.Get3FunctionNoParams = (IEdmFunction)operations[1];
this.Get1FunctionImport = (IEdmFunctionImport)this.EntityContainer.FindOperationImports("Get1").Single();
this.Get2FunctionImport = (IEdmFunctionImport)this.EntityContainer.FindOperationImports("Get2").Single();
var get3Imports = this.EntityContainer.FindOperationImports("Get3").ToList();
this.Get3FunctionImportWithOneParam = (IEdmFunctionImport)get3Imports[0];
this.Get3FunctionImportWithNoParams = (IEdmFunctionImport)get3Imports[1];
this.PersonType = this.RepresentativeModel.FindDeclaredType("Test.Person") as IEdmEntityType;
this.PersonType.Should().NotBeNull();
this.CarType = this.RepresentativeModel.FindDeclaredType("Test.Car") as IEdmEntityType;
this.CarType.Should().NotBeNull();
}
internal static IEdmModel GetDataEdmModel(this ServiceConfiguration serviceConfiguration, ConnectedServiceHandlerContext context = null)
{
using (var reader = serviceConfiguration.GetXmlReaderForEndpoint())
{
if (EdmxReader.TryParse(reader, out var model, out var parseErrors))
{
return(model);
}
internal virtual IEdmModel LoadModelFromString()
{
var tr = new StringReader(MetaDataAsString);
Model = EdmxReader.Parse(XmlReader.Create(tr));
EntitySets = GetEntitySets(Model);
return(Model);
}
private IEdmModel LoadModel()
{
using (var reader = new XmlTextReader(GetMetadataUri().ToString()))
{
IEdmModel model = EdmxReader.Parse(reader);
return(model);
}
}
public ODataAdapter(ISession session, string protocolVersion, string metadataString)
: this(session, protocolVersion)
{
var reader = XmlReader.Create(new StringReader(metadataString));
reader.MoveToContent();
Model = EdmxReader.Parse(reader);
}
public ODataModelAdapter(string protocolVersion, string metadataString)
: this(protocolVersion)
{
using (var reader = XmlReader.Create(new StringReader(metadataString)))
{
reader.MoveToContent();
Model = EdmxReader.Parse(reader);
}
}
public void KeyAsSegmentEndToEndSmokeTestInJsonLight()
{
RunEndToEndSmokeTestWithClient(ctx =>
{
ctx.ResolveName = t => t.FullName;
ctx.ResolveType = n => n.Contains("Customer") ? typeof(Customer) : null;
ctx.Format.UseJson(EdmxReader.Parse(XmlReader.Create(ctx.GetMetadataUri().AbsoluteUri)));
});
}
