/// <summary>
/// Writes the metadata document as the message body.
/// </summary>
/// <remarks>It is the responsibility of this method to flush the output before the method returns.</remarks>
internal override void WriteMetadataDocument()
{
this.AssertSynchronous();
IEnumerable <EdmError> errors;
CsdlJsonWriterSettings writerSettings = new CsdlJsonWriterSettings
{
IsIeee754Compatible = MessageWriterSettings.IsIeee754Compatible
};
if (!CsdlWriter.TryWriteCsdl(this.Model, this.jsonWriter, writerSettings, 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.ODataMetadataOutputContext_ErrorWritingMetadata(builder.ToString()));
}
this.Flush();
}
/// <summary>
/// Returns the payload to be used for this test case and the specified test configuration.
/// </summary>
/// <param name="testConfiguration">The test configuration to use.</param>
/// <returns>The payload to use for testing.</returns>
private byte[] GetPayload(ReaderTestConfiguration testConfiguration)
{
if (testConfiguration.Format != null && testConfiguration.Format != ODataFormat.Metadata)
{
// NOTE: metadata reading is not supported in other formats; return an empty payload for error tests
return(new byte[0]);
}
TestStream testStream = new TestStream(new MemoryStream(), ignoreDispose: true);
if (this.PayloadEdmModel != null)
{
using (XmlWriter xmlWriter = XmlWriter.Create(testStream))
{
IEnumerable <EdmError> errors;
if (!CsdlWriter.TryWriteCsdl(this.PayloadEdmModel, xmlWriter, CsdlTarget.OData, out errors))
{
var errorBuilder = new StringBuilder();
foreach (var error in errors)
{
errorBuilder.AppendLine(error.ToString());
}
throw new Exception("TryWriteEdmx Error:" + errorBuilder);
}
}
}
byte[] payload = new byte[testStream.Length];
testStream.Seek(0, SeekOrigin.Begin);
testStream.Read(payload, 0, (int)testStream.Length);
return(payload);
}
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 EdmVocabularyAnnotation(
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 = CsdlWriter.TryWriteCsdl(edmModel, xw, CsdlTarget.OData, out errors);
xw.Flush();
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
using (var sr = new StreamReader(ms))
{
var metadata = sr.ReadToEnd();
loadedEdmModel = CsdlReader.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 static string SerializeAsJson(this IEdmModel model, bool indented = true, bool isIeee754Compatible = false)
{
using (MemoryStream memStream = new MemoryStream())
{
JsonWriterOptions options = new JsonWriterOptions
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
Indented = indented,
SkipValidation = false
};
using (Utf8JsonWriter jsonWriter = new Utf8JsonWriter(memStream, options))
{
CsdlJsonWriterSettings settings = new CsdlJsonWriterSettings();
settings.IsIeee754Compatible = isIeee754Compatible;
IEnumerable <EdmError> errors;
bool ok = CsdlWriter.TryWriteCsdl(model, jsonWriter, settings, out errors);
jsonWriter.Flush();
Assert.True(ok);
}
memStream.Seek(0, SeekOrigin.Begin);
return(new StreamReader(memStream).ReadToEnd());
}
}
public IHttpActionResult GetMetadata()
{
DataTable Source = TestData.GetData();
Tuple <IEdmModel, IEdmType> InferredEntityModel = Source.BuildEdmModel("Test", "Test");
StringWriter Writer = new StringWriter();
XmlWriter XWriter = XmlWriter.Create(Writer);
XWriter.WriteProcessingInstruction("xml", "version='1.0'");
if (CsdlWriter.TryWriteCsdl(InferredEntityModel.Item1, XWriter, CsdlTarget.OData, out IEnumerable <EdmError> errors))
{
XWriter.Flush();
String XmlOutput = Writer.ToString();
if (!String.IsNullOrWhiteSpace(XmlOutput))
{
HttpResponseMessage Output = new HttpResponseMessage();
Output.StatusCode = HttpStatusCode.OK;
Output.Content = new StringContent(XmlOutput);
Output.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/xml");
Output.Content.Headers.TryAddWithoutValidation(
ODataReturnNegotiatedContentResult.ODataServiceVersionHeader,
ODataUtils.ODataVersionToString(ODataVersion.V4));
return(ResponseMessage(Output));
}
}
return(InternalServerError());
}
private IEdmModel LoadAndTransformRsdlModel(string rsdlPath)
{
var model = parser.Parse(File.ReadAllText(rsdlPath), System.IO.Path.GetFileNameWithoutExtension(rsdlPath));
var referencedModels = new Dictionary <string, RdmDataModel>();
var transformer = new ModelTransformer(NullLogger.Instance);
if (transformer.TryTransform(model, referencedModels, out var result))
{
// to work arround the problem of comparing generated models with the ones loaded from a file
// we will save and load this in-memory model.
using (var xml = XmlWriter.Create(rsdlPath + ".actual.csdl.xml"))
{
CsdlWriter.TryWriteCsdl(result, xml, CsdlTarget.OData, out var errors);
}
using (var reader = XmlReader.Create(rsdlPath + ".actual.csdl.xml"))
{
var loaded = CsdlReader.Parse(reader);
return(loaded);
}
}
else
{
throw new System.Exception("failed to transform model");
}
}
void VerifyResult(string[] inputText, string expectedResult, CsdlTarget target, Action <IEdmModel> visitModel)
{
IEdmModel model;
IEnumerable <EdmError> errors;
List <XmlReader> readers = new List <XmlReader>();
foreach (string s in inputText)
{
readers.Add(XmlReader.Create(new StringReader(s)));
}
bool parsed = SchemaReader.TryParse(readers, out model, out errors);
Assert.IsTrue(parsed, "Model Parsed");
Assert.IsTrue(errors.Count() == 0, "No Errors");
if (visitModel != null)
{
visitModel(model);
}
StringWriter sw = new StringWriter();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.Encoding = System.Text.Encoding.UTF8;
XmlWriter xw = XmlWriter.Create(sw, settings);
CsdlWriter.TryWriteCsdl(model, xw, target, out errors);
xw.Flush();
xw.Close();
string outputText = sw.ToString();
Assert.AreEqual(expectedResult, outputText, "Expected Result = Output");
}
private void WriteMetadata(TextWriter writer, IEdmModel model)
{
using (var xmlWriter = XmlWriter.Create(writer))
{
IEnumerable <EdmError> errors;
CsdlWriter.TryWriteCsdl(model, xmlWriter, CsdlTarget.OData, out errors);
}
}
private static bool GetCsdlSchema(IEdmModel edmModel, Stream stream)
{
using (XmlWriter xmlWriter = XmlWriter.Create(stream))
if (CsdlWriter.TryWriteCsdl(edmModel, xmlWriter, CsdlTarget.OData, out IEnumerable <EdmError> errors))
{
return(true);
}
return(false);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
//services.AddApiVersioning(options =>
//{
// options.ReportApiVersions = true;
// options.DefaultApiVersion = new ApiVersion(1, 0);
// //options.AssumeDefaultVersionWhenUnspecified = true;
//});
//services.AddVersionedApiExplorer(options =>
//{
// options.GroupNameFormat = "'v'VVV";
// options.SubstituteApiVersionInUrl = true;
//});
// >>>> setup NRestGen services
services.AddNRestGen();
AddODataFormatters(services);
// >>>> Set JSON serialization options
services.AddMvc()
.AddJsonOptions(options =>
{
options.JsonSerializerOptions.IgnoreNullValues = true;
options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
#if DEBUG
options.JsonSerializerOptions.WriteIndented = true;
#endif
});
// Register the Swagger Generator service. This service is responsible for genrating Swagger Documents.
// Note: Add this service at the end after AddMvc() or AddMvcCore().
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo
{
Title = "NRestGen Demo API",
Version = "v1",
Description = "This API is generated by NRestGen.",
Contact = new OpenApiContact
{
Name = "Marc Jacobi",
Email = "*****@*****.**",
Url = new Uri("https://github.com/obiwanjacobi/NRestGen"),
},
});
});
#if DEBUG
var resourceModel = ResourceModelBuilder.Build();
using var writer = XmlWriter.Create("ResourceModel.xml");
CsdlWriter.TryWriteCsdl(resourceModel, writer, CsdlTarget.OData, out var errors);
#endif
}
public CsdlParModel()
{
#region parse Model
StringBuilder builder = new StringBuilder();
TextWriter tw = null;
try
{
tw = new StringWriter(builder);
using (var xw = XmlWriter.Create(tw))
{
IEnumerable <EdmError> errors;
CsdlWriter.TryWriteCsdl(BaseModel, xw, CsdlTarget.OData, out errors);
}
}
catch (Exception)
{
if (tw != null)
{
tw.Dispose();
}
}
TextReader tr = null;
try
{
tr = new StringReader(builder.ToString());
using (var xr = XmlReader.Create(tr))
{
Model = CsdlReader.Parse(xr);
}
}
catch (Exception)
{
if (tr != null)
{
tr.Dispose();
}
}
Debug.Assert(Model != null);
#endregion
Person = Model.FindEntityType("NS.Person");
Debug.Assert(Person != null);
PersonSet = Model.FindDeclaredEntitySet("PersonSet");
Debug.Assert(PersonSet != null);
PersonNavPetCon = Person.GetNavigationProperty("NavPetCon");
Debug.Assert(PersonNavPetCon != null);
PersonNavPetUnknown = Person.GetNavigationProperty("NavPetUnknown");
Debug.Assert(PersonNavPetUnknown != null);
}
private static bool GetCsdlSchema(IEdmModel edmModel, Stream stream)
{
using (XmlWriter xmlWriter = XmlWriter.Create(stream, new XmlWriterSettings()
{
Indent = true
}))
if (CsdlWriter.TryWriteCsdl(edmModel, xmlWriter, CsdlTarget.OData, out _))
{
return(true);
}
return(false);
}
public void CheckEdmxUnsupportedVersion()
{
const string edmx =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<edmx:Edmx Version=""4.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 = CsdlReader.TryParse(XmlReader.Create(new StringReader(edmx)), out model, out errors);
Assert.IsTrue(parsed, "Model Parsed");
Assert.IsTrue(errors.Count() == 0, "No Errors");
Assert.AreEqual(EdmConstants.EdmVersion4, model.GetEdmVersion(), "Model version check 1");
Assert.AreEqual(CsdlConstants.EdmxVersion4, model.GetEdmxVersion(), "EDMX version check 1");
StringWriter sw = new StringWriter();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.Encoding = System.Text.Encoding.UTF8;
using (XmlWriter xw = XmlWriter.Create(sw, settings))
{
model.SetEdmxVersion(new Version(1, 123));
try
{
CsdlWriter.TryWriteCsdl(model, xw, CsdlTarget.OData, out errors);
}
catch (Exception e)
{
Assert.IsTrue(e is InvalidOperationException, "e is InvalidOperationException");
}
}
}
public static string GetCSDL(IEdmModel model)
{
StringWriter writer = new StringWriter();
var xwriter = XmlWriter.Create(writer);
IEnumerable <EdmError> errors;
if (CsdlWriter.TryWriteCsdl(model, xwriter, CsdlTarget.OData, out errors))
{
xwriter.Flush();
return(writer.ToString());
}
else
{
throw new Exception(errors.First().ErrorMessage);
}
}
private static bool GetCsdlSchema(IEdmModel edmModel, Stream stream)
{
using (var memoryStream = new MemoryStream()) //kestrel allow only async operation
{
using (XmlWriter xmlWriter = XmlWriter.Create(memoryStream))
if (!CsdlWriter.TryWriteCsdl(edmModel, xmlWriter, CsdlTarget.OData, out IEnumerable <EdmError> errors))
{
return(false);
}
memoryStream.Position = 0;
memoryStream.CopyToAsync(stream);
}
return(false);
}
public void i_can_generate_csdl()
{
IEdmModel model = NewModel();
using (var writer = XmlWriter.Create(TestContext.Out))
{
IEnumerable <EdmError> errors;
if (!CsdlWriter.TryWriteCsdl(model, writer, CsdlTarget.OData, out errors))
{
foreach (EdmError error in errors)
{
TestContext.WriteLine(error);
}
Assert.Fail("unable to generate CSDL");
}
}
}
private void WriteMetadataDocumentImplementation()
{
IEnumerable <EdmError> errors;
if (!CsdlWriter.TryWriteCsdl(this.Model, this.xmlWriter, CsdlTarget.OData, 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.ODataMetadataOutputContext_ErrorWritingMetadata(builder.ToString()));
}
}
public void WriteModelToCsdl(IEdmModel model)
{
IEnumerable <Microsoft.OData.Edm.Validation.EdmError> errors;
var writer = XmlWriter.Create($"{_appDataPath}/ODataModel.csdl.xml");
CsdlWriter.TryWriteCsdl(model, writer, CsdlTarget.OData, out errors);
writer.Flush();
writer.Close();
writer.Dispose();
var edmErrors = errors as IList <Microsoft.OData.Edm.Validation.EdmError> ?? errors.ToList();
if (edmErrors.Any())
{
throw new Exception(edmErrors.First().ErrorMessage);
}
}
public static String GetCsdlSchema(IEdmModel edmModel)
{
using (var stream = new MemoryStream())
{
using (XmlWriter xmlWriter = XmlWriter.Create(stream, new XmlWriterSettings()
{
Indent = true
}))
{
if (!CsdlWriter.TryWriteCsdl(edmModel, xmlWriter, CsdlTarget.OData, out IEnumerable <EdmError> errors))
{
return(null);
}
}
return(Encoding.UTF8.GetString(stream.ToArray()));
}
}
public void WriterShouldContinueToWork()
{
var builder = new StringBuilder();
using (var writer = XmlWriter.Create(builder))
{
IEnumerable <EdmError> errors;
CsdlWriter.TryWriteCsdl(this.representativeModel, writer, CsdlTarget.OData, out errors).Should().BeTrue();
errors.Should().BeEmpty();
writer.Flush();
}
string actual = builder.ToString();
var actualXml = XElement.Parse(actual);
var actualNormalized = actualXml.ToString();
actualNormalized.Should().Be(RepresentativeEdmxDocument);
}
public void VerifyRepresentativeModelWrittenOutCorrectly()
{
var builder = new StringBuilder();
using (var writer = XmlWriter.Create(builder))
{
IEnumerable <EdmError> errors;
Assert.True(CsdlWriter.TryWriteCsdl(this.TestModel.RepresentativeModel, writer, CsdlTarget.OData, out errors));
Assert.Empty(errors);
writer.Flush();
}
string actual = builder.ToString();
var actualXml = XElement.Parse(actual);
var actualNormalized = actualXml.ToString();
Assert.Equal(DefaultTestModel.RepresentativeEdmxDocument, actualNormalized);
}
private static string GetCsdl(IEdmModel model)
{
using (StringWriter sw = new StringWriter())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = System.Text.Encoding.UTF8;
settings.Indent = true;
using (XmlWriter xw = XmlWriter.Create(sw, settings))
{
IEnumerable <EdmError> errors;
CsdlWriter.TryWriteCsdl(model, xw, CsdlTarget.OData, out errors);
xw.Flush();
}
string actual = sw.ToString();
return(actual);
}
}
public void TestNullArgChecks()
{
const string inputText =
@"<?xml version=""1.0"" encoding=""utf-16""?>
<edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx"">
<edmx:DataServices xmlns:m=""http://docs.oasis-open.org/odata/ns/metadata"">
<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:DataServices>
</edmx:Edmx>";
IEdmModel model;
IEnumerable <EdmError> errors;
CsdlReader.TryParse(XmlReader.Create(new StringReader(inputText)), out model, out errors);
try
{
CsdlWriter.TryWriteCsdl(null, XmlWriter.Create(new StringWriter()), CsdlTarget.EntityFramework, out errors);
}
catch (Exception e)
{
Assert.IsTrue(e is ArgumentNullException, "e is ArgumentNullException");
}
try
{
CsdlWriter.TryWriteCsdl(model, null, CsdlTarget.EntityFramework, out errors);
}
catch (Exception e)
{
Assert.IsTrue(e is ArgumentNullException, "e is ArgumentNullException");
}
}
public static bool WriteCsdl(IEdmModel model, string path)
{
using (var file = new StreamWriter(path))
using (var writer = XmlWriter.Create(file, new XmlWriterSettings()
{
Indent = true
}))
{
IEnumerable <EdmError> errors;
if (!CsdlWriter.TryWriteCsdl(model, writer, CsdlTarget.OData, out errors))
{
foreach (EdmError error in errors)
{
Console.WriteLine(error);
}
return(false);
}
}
return(true);
}
private string GetCsdl(IEdmModel model, CsdlTarget target)
{
string edmx = string.Empty;
using (StringWriter sw = new StringWriter())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = System.Text.Encoding.UTF8;
using (XmlWriter xw = XmlWriter.Create(sw, settings))
{
IEnumerable <EdmError> errors;
CsdlWriter.TryWriteCsdl(model, xw, target, out errors);
xw.Flush();
}
edmx = sw.ToString();
}
return(edmx);
}
public static string GetCsdl(IEdmModel model)
{
string edmx = String.Empty;
using (StringWriter sw = new StringWriter())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
settings.Indent = true;
using (XmlWriter xw = XmlWriter.Create(sw, settings))
{
IEnumerable <EdmError> errors;
CsdlWriter.TryWriteCsdl(model, xw, CsdlTarget.OData, out errors);
xw.Flush();
}
edmx = sw.ToString();
}
return(edmx);
}
void VerifyResult(string inputText, string expectedResult, CsdlTarget target)
{
IEdmModel model;
IEnumerable <EdmError> errors;
bool parsed = SchemaReader.TryParse(new XmlReader[] { XmlReader.Create(new StringReader(inputText)) }, out model, out errors);
Assert.IsTrue(parsed, "Model Parsed");
Assert.IsTrue(errors.Count() == 0, "No Errors");
StringWriter sw = new StringWriter();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.Encoding = System.Text.Encoding.UTF8;
XmlWriter xw = XmlWriter.Create(sw, settings);
CsdlWriter.TryWriteCsdl(model, xw, target, out errors);
xw.Flush();
xw.Close();
string outputText = sw.ToString();
Assert.AreEqual(expectedResult, outputText, "Expected Result = Output");
}
public void i_can_generate_csdl()
{
var builder = new SampleModelBuilder();
IEdmModel model = builder
//.BuildAddressType()
//.BuildCategoryType()
//.BuildCustomerType()
//.BuildDefaultContainer()
.BuildCustomerSet()
.Model;
using (var writer = XmlWriter.Create(TestContext.Out))
{
IEnumerable <EdmError> errors;
if (!CsdlWriter.TryWriteCsdl(model, writer, CsdlTarget.OData, out errors))
{
foreach (EdmError error in errors)
{
TestContext.WriteLine(error);
}
Assert.Fail("unable to generate CSDL");
}
}
}
