public async Task <IActionResult> GetDatamodel(string org, string repository, string filepath)
{
try
{
Stream dataStream = await _repository.ReadData(org, repository, $"{filepath}.schema.json");
TextReader textReader = new StreamReader(dataStream);
JsonValue jsonValue = await JsonValue.ParseAsync(textReader);
return(Ok(jsonValue.ToString()));
}
catch
{
// Will fallback to checking for XSD. See below
}
try
{
Stream dataStream = await _repository.ReadData(org, repository, $"{filepath}.xsd");
XmlReader xsdReader = XmlReader.Create(dataStream);
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(xsdReader);
// Act
JsonSchema convertedSchema = xsdToJsonSchemaConverter.AsJsonSchema();
Manatee.Json.Serialization.JsonSerializer serializer = new Manatee.Json.Serialization.JsonSerializer();
JsonValue serializedConvertedSchema = serializer.Serialize(convertedSchema);
return(Ok(serializedConvertedSchema.ToString()));
}
catch
{
return(NotFound());
}
}
private string SanitizeName(string name)
{
if (string.IsNullOrEmpty(name))
{
return(null);
}
return(XsdToJsonSchema.SanitizeName(name));
}
private Manatee.Json.Schema.JsonSchema GenerateJsonSchema(Stream xsdStream)
{
var xmlReader = XmlReader.Create(xsdStream, new XmlReaderSettings {
IgnoreWhitespace = true
});
var xsdToJsonSchemaConverter = new XsdToJsonSchema(xmlReader, _loggerFactory.CreateLogger <XsdToJsonSchema>());
var jsonSchema = xsdToJsonSchemaConverter.AsJsonSchema();
return(jsonSchema);
}
public async void ConvertXsdToJsonSchemaAndBackViaString_CorrectNumberOfPropertiesAndDefinitions()
{
// string xsdName = "Designer.Tests._TestData.Model.Xsd.schema_3451_8_forms_4106_35721.xsd";
string xsdName = "Designer.Tests._TestData.Model.Xsd.schema_4581_100_forms_5245_41111.xsd";
SchemaKeywordCatalog.Add <InfoKeyword>();
// Arrange
XmlReader xsdReader = XmlReader.Create(LoadTestData(xsdName));
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(xsdReader);
// Act
JsonSchema convertedSchema = xsdToJsonSchemaConverter.AsJsonSchema();
JsonSerializer serializer = new JsonSerializer();
JsonValue serializedConvertedSchema = serializer.Serialize(convertedSchema);
byte[] byteArray = Encoding.UTF8.GetBytes(serializedConvertedSchema.ToString());
MemoryStream jsonstream = new MemoryStream(byteArray);
await WriteData(xsdName + ".json", jsonstream);
File.WriteAllText(xsdName + ".json", serializedConvertedSchema.ToString());
string savedJsonSchemaFileTextContent = File.ReadAllText(xsdName + ".json");
TextReader textReader = new StringReader(savedJsonSchemaFileTextContent);
JsonValue jsonValue = await JsonValue.ParseAsync(textReader);
JsonSchema jsonSchemaFromFile = new Manatee.Json.Serialization.JsonSerializer().Deserialize <JsonSchema>(jsonValue);
JsonSchemaToXsd jsonSchemaToXsd = new JsonSchemaToXsd();
XmlSchema xmlschema = jsonSchemaToXsd.CreateXsd(convertedSchema);
MemoryStream xmlStream = new MemoryStream();
XmlTextWriter xwriter = new XmlTextWriter(xmlStream, new UpperCaseUtf8Encoding());
xwriter.Formatting = Formatting.Indented;
xwriter.WriteStartDocument(false);
xmlschema.Write(xmlStream);
await WriteData(xsdName + ".new", xmlStream);
XmlSchema xmlschemaFromFile = jsonSchemaToXsd.CreateXsd(jsonSchemaFromFile);
MemoryStream xmlStreamFile = new MemoryStream();
XmlTextWriter xwriterFile = new XmlTextWriter(xmlStreamFile, new UpperCaseUtf8Encoding());
xwriterFile.Formatting = Formatting.Indented;
xwriterFile.WriteStartDocument(false);
xmlschemaFromFile.Write(xmlStreamFile);
await WriteData(xsdName + ".newfile", xmlStreamFile);
Assert.NotNull(convertedSchema);
}
public void ConvertXSDsToJsonSchema()
{
int failCount = 0;
string[] files = Directory.GetFiles("Common/xsd", "*.xsd", SearchOption.AllDirectories);
foreach (string file in files)
{
_logger.LogInformation("Converting file " + file + " to Json Schema");
try
{
// XSD to Json Schema
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(new XmlTextReader(file), TestLogger.Create <XsdToJsonSchema>());
JsonSchema schemaJsonSchema = xsdToJsonSchemaConverter.AsJsonSchema();
// Json Schema to XSD
JsonSchemaToXsd jsonSchemaToXsdConverter = new JsonSchemaToXsd();
XmlSchema xmlSchema = jsonSchemaToXsdConverter.CreateXsd(schemaJsonSchema);
// Load original file as XDocument
XDocument original = XDocument.Load(file);
// Load converted file as XDocument
XDocument converted;
StringBuilder sb = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(sb))
{
xmlSchema.Write(writer);
converted = XDocument.Load(new StringReader(sb.ToString()));
}
// Compare XDocuments
bool xsdsAreEqual = XNode.DeepEquals(original, converted);
if (!xsdsAreEqual && writeDifferXsdFiles)
{
File.Copy(file, "c:\\temp\\original.xsd", true);
SaveJsonSchema(schemaJsonSchema, "c:\\temp\\converted.schema.json");
SaveXmlSchema(xmlSchema, "c:\\temp\\converted.xsd");
}
/*Assert.True(xsdsAreEqual);*/
}
catch (Exception e)
{
_logger.LogError("Failed converting file " + file + ": " + e.Message);
failCount++;
}
}
Assert.Equal(0, failCount);
}
private void FromXsdToJsdAndBack()
{
int failCount = 0;
int equalityCount = 0;
string[] files = Directory.GetFiles("Common/xsd/", "*.xsd", SearchOption.AllDirectories);
foreach (string filePath in files)
{
Debug.WriteLine("Testing file " + filePath);
JsonSchema jsonSchema1 = null, jsonSchema2 = null;
XmlSchema xmlSchema2 = null, xmlSchema3 = null;
string fileName = filePath.Substring(filePath.LastIndexOf("/") + 1).Split(".")[0];
string jsd1FileName = "jsd1_" + fileName + ".schema.json";
string jsd2FileName = "jsd2_" + fileName + ".schema.json";
string xsd2FileName = "xsd2_" + fileName + ".xsd";
string xsd3FileName = "xsd3_" + fileName + ".xsd";
try
{
XsdToJsonSchema converter = new XsdToJsonSchema(new XmlTextReader(filePath), TestLogger.Create <XsdToJsonSchema>());
jsonSchema1 = converter.AsJsonSchema();
SaveJsonSchema(jsonSchema1, jsd1FileName);
}
catch (Exception e)
{
Debug.WriteLine("Failed XsdToJsd conversion: " + filePath + " Reason: " + e.Message);
failCount++;
}
xmlSchema2 = ConvertFromJsdToXsd(jsonSchema1, xsd2FileName);
jsonSchema2 = ConvertFromXsdToJsd(xmlSchema2, jsd2FileName);
xmlSchema3 = ConvertFromJsdToXsd(jsonSchema2, xsd3FileName);
try
{
Assert.True(XmlDiff(xsd2FileName, xsd3FileName), "xsd2 != xsd3");
Assert.True(JsonDiff(jsonSchema1, jsonSchema2), "jsd1 != jsd2");
}
catch (Exception e)
{
Debug.WriteLine("Failed equality test " + e.Message);
equalityCount++;
}
}
Assert.Equal(0, equalityCount);
Assert.Equal(0, failCount);
}
private static JsonSchema DownloadAndConvertXsdToJsonSchema(string xsdSchemaUrl)
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
XmlReader doc = XmlReader.Create(xsdSchemaUrl, settings);
// XSD to Json Schema
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(doc, null);
return(xsdToJsonSchemaConverter.AsJsonSchema());
}
public void ConvertServiceModelAndStripSchemaFromDataBindingName()
{
// XSD to Json Schema
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(new XmlTextReader("Common/xsd/ServiceModel.xsd"), TestLogger.Create <XsdToJsonSchema>());
JsonSchema schemaJsonSchema = xsdToJsonSchemaConverter.AsJsonSchema();
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator("TestOrg", "ServiceModel", schemaJsonSchema);
ServiceMetadata serviceMetadata = converter.GetServiceMetadata();
string actualDatabinding = serviceMetadata.Elements["Skjema.Skattyterinforgrp5801.Kontaktgrp5803.KontaktpersonPoststeddatadef10442.value"].DataBindingName;
Assert.Equal("skattyterinforgrp5801.kontaktgrp5803.kontaktpersonPoststeddatadef10442.value", actualDatabinding);
}
public ActionResult Upload(string org, string service, IFormFile thefile)
{
if (thefile == null)
{
throw new ApplicationException("Cannot upload empty file");
}
string mainFileName = ContentDispositionHeaderValue.Parse(new StringSegment(thefile.ContentDisposition)).FileName.ToString();
MemoryStream xsdMemoryStream = new MemoryStream();
thefile.OpenReadStream().CopyTo(xsdMemoryStream);
xsdMemoryStream.Position = 0;
XmlReader reader = XmlReader.Create(xsdMemoryStream, new XmlReaderSettings {
IgnoreWhitespace = true
});
XDocument mainXsd = XDocument.Load(reader, LoadOptions.None);
ServiceMetadata serviceMetadata = null;
bool useOldParser = false;
if (useOldParser)
{
var seresParser = new SeresXsdParser(_repository);
serviceMetadata = seresParser.ParseXsdToServiceMetadata(org, service, mainXsd, null);
}
else
{
xsdMemoryStream.Position = 0;
reader = XmlReader.Create(xsdMemoryStream, new XmlReaderSettings {
IgnoreWhitespace = true
});
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(reader, _loggerFactory.CreateLogger <XsdToJsonSchema>());
JsonSchema schemaJsonSchema = xsdToJsonSchemaConverter.AsJsonSchema();
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator(org, service, schemaJsonSchema);
serviceMetadata = converter.GetServiceMetadata();
HandleTexts(org, service, converter.GetTexts());
}
if (_repository.CreateModel(org, service, serviceMetadata, mainXsd))
{
return(RedirectToAction("Index", new { org, service }));
}
return(Json(false));
}
public async void ConvertXsdToJsonSchema_CorrectXmlParsed()
{
// Arrange
using XmlReader xsdReader = XmlReader.Create(LoadTestData("Model/Xsd/Brønnøysundregistrene_ReelleRettighetshavere_M_2021-11-22_6900_46864_SERES.xsd"));
XsdToJsonSchema target = new XsdToJsonSchema(xsdReader);
// Act
JsonSchema xsdasJsonSchema = target.AsJsonSchema();
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator("test", "test", xsdasJsonSchema);
ModelMetadata modelMetadata = converter.GetModelMetadata();
string classes = GenerateCSharpClasses(modelMetadata);
Assembly assembly = Compiler.CompileToAssembly(classes);
Type type = assembly.GetType("Altinn.App.Models.ReelleRettighetshavere_M");
assembly.CreateInstance(type.FullName);
Stream xmlStream = TestDataHelper.LoadDataFromEmbeddedResource("Designer.Tests._TestData.ModelData.Brønnøysundregistrene_ReelleRettighetshavere_M_2021-11-22_6900_46864_SERES.CorrectOrder.xml");
var xmlObject = await DeserializeXmlAsync(xmlStream, type);
XmlSerializer serializer = new XmlSerializer(type);
using MemoryStream stream = new MemoryStream();
serializer.Serialize(stream, xmlObject);
stream.Position = 0;
StreamReader reader = new StreamReader(stream);
string text = reader.ReadToEnd();
xmlStream = TestDataHelper.LoadDataFromEmbeddedResource("Designer.Tests._TestData.ModelData.Brønnøysundregistrene_ReelleRettighetshavere_M_2021-11-22_6900_46864_SERES.CorrectOrder.xml");
StreamReader orgXmlReader = new StreamReader(xmlStream);
string textOrgXml = orgXmlReader.ReadToEnd();
Stream classStream = TestDataHelper.LoadDataFromEmbeddedResource("Designer.Tests._TestData.Model.CSharp.Brønnøysundregistrene_ReelleRettighetshavere_M_2021-11-22_6900_46864_SERES.expected.csharp.txt");
StreamReader classReader = new StreamReader(classStream);
string orgClasses = classReader.ReadToEnd();
// Assert
Assert.NotNull(modelMetadata);
Assert.Contains($"[XmlElement(\"reelleRettigheter\", Order = 2)]", classes);
string expectedTextSanitized = Regex.Replace(textOrgXml, @">(\s+)<", "><");
Assert.Equal(expectedTextSanitized, text);
string expectedClassesSanitized = Regex.Replace(orgClasses, @"\s+", string.Empty);
string actualClassesSanitized = Regex.Replace(classes, @"\s+", string.Empty);
Assert.Equal(expectedClassesSanitized, actualClassesSanitized);
}
/// <summary>
/// Parses the XSD, generates Json Schema and generates the meta model using
/// the old classes.
/// </summary>
private static ModelMetadata CreateMetamodelOldWay(string xsdResource, string org, string app)
{
Stream xsdStream = TestDataHelper.LoadDataFromEmbeddedResource(xsdResource);
XmlReader xmlReader = XmlReader.Create(xsdStream, new XmlReaderSettings {
IgnoreWhitespace = true
});
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(xmlReader);
JsonSchema jsonSchema = xsdToJsonSchemaConverter.AsJsonSchema();
ModelMetadata modelMetadata = GenerateModelMetadata(org, app, jsonSchema);
return(modelMetadata);
}
public void AsJsonSchema_ConvertXsdToJsonSchema_CorrectModelName()
{
// Arrange
using XmlReader xsdReader = XmlReader.Create(LoadTestData("Model/Xsd/RA-0678_M.xsd"));
XsdToJsonSchema target = new XsdToJsonSchema(xsdReader);
// Act
JsonSchema actual = target.AsJsonSchema();
// Assert
Assert.NotNull(actual);
Assert.Single(actual.Properties());
Assert.True(actual.Properties().ContainsKey("melding"));
}
public void AsJsonSchema_ConvertXsdToJsonSchema_CorrectNumberOfPropertiesAndDefinitions(string xsdPath)
{
// Arrange
using XmlReader xsdReader = XmlReader.Create(TestDataHelper.LoadTestDataFromFile(xsdPath));
XsdToJsonSchema target = new XsdToJsonSchema(xsdReader);
// Act
JsonSchema actual = target.AsJsonSchema();
// Assert
Assert.NotNull(actual);
Assert.Single(actual.Properties());
Assert.Equal(6, actual.Definitions().Count);
}
public void AsJsonSchema_ConvertXsdToJsonSchema_CorrectNumberOfPropertiesAndDefinitions()
{
// Arrange
XmlReader xsdReader = XmlReader.Create(LoadTestData("Model/Xsd/melding-1603-12392.xsd"));
XsdToJsonSchema target = new XsdToJsonSchema(xsdReader);
// Act
JsonSchema actual = target.AsJsonSchema();
// Assert
Assert.NotNull(actual);
Assert.Equal(12, actual.Properties().Count);
Assert.Equal(19, actual.Definitions().Count);
}
public async Task <IActionResult> GetDatamodel(string org, string repository, string modelName)
{
try
{
modelName = modelName.AsFileName();
}
catch
{
return(BadRequest("Invalid model name value."));
}
string filePath = $"App/models/{modelName}";
try
{
using (Stream dataStream = await _repository.ReadData(org, repository, $"{filePath}.schema.json"))
{
TextReader textReader = new StreamReader(dataStream);
JsonValue jsonValue = await JsonValue.ParseAsync(textReader);
return(Ok(jsonValue.ToString()));
}
}
catch
{
// Will fallback to checking for XSD. See below
}
try
{
using (Stream dataStream = await _repository.ReadData(org, repository, $"{filePath}.xsd"))
{
XmlReader xsdReader = XmlReader.Create(dataStream);
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(xsdReader);
JsonSchema convertedSchema = xsdToJsonSchemaConverter.AsJsonSchema();
Manatee.Json.Serialization.JsonSerializer serializer = new Manatee.Json.Serialization.JsonSerializer();
JsonValue serializedConvertedSchema = serializer.Serialize(convertedSchema);
return(Ok(serializedConvertedSchema.ToString()));
}
}
catch
{
return(NotFound());
}
}
private static JsonSchema ConvertFromXsdToJsd(XmlSchema xmlSchema2, string fileName)
{
try
{
XsdToJsonSchema xsdConverter2 = new XsdToJsonSchema(xmlSchema2, TestLogger.Create <XsdToJsonSchema>());
JsonSchema jsonSchema2 = xsdConverter2.AsJsonSchema();
SaveJsonSchema(jsonSchema2, fileName);
return(jsonSchema2);
}
catch (Exception e)
{
Debug.WriteLine("Failed XsdToJsd conversion: " + fileName + " Reason: " + e.Message);
}
return(null);
}
public static Dictionary <string, string> Convert(Altinn2AppData a2, out string?modelName)
{
modelName = null;
var ret = new Dictionary <string, string>();
if (a2.XSNFiles.Count == 0)
{
return(ret);
}
// Get xsd from first xsn file (all languages are equal)
string xsd = a2.XSNFiles.First().Value.XSDDocument;
if (xsd == null)
{
return(ret);
}
ret.Add("model.xsd", xsd);
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(xsd)))
{
var reader = XmlReader.Create(stream);
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(reader);
JsonSchema schemaJsonSchema = xsdToJsonSchemaConverter.AsJsonSchema();
ret.Add("model.schema.json", new Manatee.Json.Serialization.JsonSerializer().Serialize(schemaJsonSchema).GetIndentedString(0));
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator(a2.Org, a2.App, schemaJsonSchema);
ModelMetadata modelMetadata = converter.GetModelMetadata();
ret.Add("model.metadata.json", JsonConvert.SerializeObject(modelMetadata, Newtonsoft.Json.Formatting.Indented));
modelName = modelMetadata.Elements["melding"].TypeName;
// generate c# model
JsonMetadataParser modelGenerator = new JsonMetadataParser();
string classes = modelGenerator.CreateModelFromMetadata(modelMetadata);
ret.Add("model.cs", classes);
// HandleTexts(org, app, converter.GetTexts());
}
return(ret);
}
public ActionResult Upload(string org, string app, IFormFile thefile)
{
if (thefile == null)
{
throw new ApplicationException("Cannot upload empty file");
}
string mainFileName = ContentDispositionHeaderValue.Parse(new StringSegment(thefile.ContentDisposition)).FileName.ToString();
MemoryStream xsdMemoryStream = new MemoryStream();
thefile.OpenReadStream().CopyTo(xsdMemoryStream);
xsdMemoryStream.Position = 0;
XmlReader reader = XmlReader.Create(xsdMemoryStream, new XmlReaderSettings {
IgnoreWhitespace = true
});
XDocument mainXsd = XDocument.Load(reader, LoadOptions.None);
xsdMemoryStream.Position = 0;
reader = XmlReader.Create(xsdMemoryStream, new XmlReaderSettings {
IgnoreWhitespace = true
});
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(reader, _loggerFactory.CreateLogger <XsdToJsonSchema>());
JsonSchema schemaJsonSchema = xsdToJsonSchemaConverter.AsJsonSchema();
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator(org, app, schemaJsonSchema);
ModelMetadata modelMetadata = converter.GetModelMetadata();
HandleTexts(org, app, converter.GetTexts());
string modelName = Path.GetFileNameWithoutExtension(mainFileName);
if (_repository.CreateModel(org, app, modelMetadata, mainXsd, modelName))
{
return(RedirectToAction("Index", new { org, app, modelName }));
}
return(Json(false));
}
public void JsonInstanceModelFromAutogenJson()
{
Mock <IRepository> moqRepository = new Mock <IRepository>();
int failCount = 0;
int mismatchCount = 0;
string[] files = Directory.GetFiles("Common/xsd", "*.xsd", SearchOption.AllDirectories);
foreach (string file in files)
{
try
{
// XSD to Json Schema metadata
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(new XmlTextReader(file), TestLogger.Create <XsdToJsonSchema>());
JsonSchema schemaJsonSchema = xsdToJsonSchemaConverter.AsJsonSchema();
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator("org", "service", schemaJsonSchema, string.Empty);
JsonObject instanceModel = converter.GetInstanceModel();
// XSD to Json Schema metadata using obsolete SeresXsdParser
ServiceMetadata serviceMetadata = SeresXSDParse(moqRepository, file);
JsonValue serviceMetadataValue = new JsonSerializer().Serialize <ServiceMetadata>(serviceMetadata);
if (!instanceModel["Elements"].Equals(serviceMetadataValue.Object["Elements"]))
{
mismatchCount++;
// File.WriteAllText(file + ".new.schema.json", instanceModel.GetIndentedString(0));
// File.WriteAllText(file + ".seresParser.schema.json", serviceMetadataValue.GetIndentedString(0));
}
}
catch (Exception)
{
failCount++;
}
}
Assert.Equal(0, failCount);
}
public async Task <IActionResult> Convert()
{
XmlReaderSettings settings = new XmlReaderSettings
{
IgnoreWhitespace = true,
};
if (Request.ContentType.Contains("text/xml"))
{
XmlReader doc = XmlReader.Create(Request.Body, settings);
// XSD to Json Schema
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(doc, null);
Manatee.Json.Serialization.JsonSerializer serializer = new Manatee.Json.Serialization.JsonSerializer();
JsonValue json = serializer.Serialize(xsdToJsonSchemaConverter.AsJsonSchema());
return(Ok(json.GetIndentedString()));
}
return(NotFound("Cannot read body. Needs to be XSD."));
}
public void SeresOrXmlSchema_ShouldSerializeToCSharp(string xsdResource, string modelName, string expectedJsonSchemaResource, string expectedCSharpResource)
{
SchemaKeywordCatalog.Add <InfoKeyword>();
var org = "yabbin";
var app = "hvem-er-hvem";
Stream xsdStream = TestDataHelper.LoadDataFromEmbeddedResource(xsdResource);
XmlReader xmlReader = XmlReader.Create(xsdStream, new XmlReaderSettings {
IgnoreWhitespace = true
});
// Compare generated JSON Schema
XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(xmlReader);
JsonSchema jsonSchema = xsdToJsonSchemaConverter.AsJsonSchema();
var expectedJsonSchema = TestDataHelper.LoadDataFromEmbeddedResourceAsJsonSchema(expectedJsonSchemaResource);
jsonSchema.Should().BeEquivalentTo(expectedJsonSchema);
// Compare generated C# classes
ModelMetadata modelMetadata = GenerateModelMetadata(org, app, jsonSchema);
string classes = GenerateCSharpClasses(modelMetadata);
Assembly assembly = Compiler.CompileToAssembly(classes);
Type type = assembly.GetType(modelName);
var modelInstance = assembly.CreateInstance(type.FullName);
string expectedClasses = TestDataHelper.LoadDataFromEmbeddedResourceAsString(expectedCSharpResource);
Assembly expectedAssembly = Compiler.CompileToAssembly(expectedClasses);
Type expectedType = expectedAssembly.GetType(modelName);
var expectedModelInstance = expectedAssembly.CreateInstance(expectedType.FullName);
expectedType.HasSameMetadataDefinitionAs(type);
modelInstance.Should().BeEquivalentTo(expectedModelInstance);
type.Should().BeDecoratedWith <XmlRootAttribute>();
}
public void ConvertXsdToJsonSchemaAndBack_CorrectNumberOfPropertiesAndDefinitions()
{
// Arrange
XmlReader xsdReader = XmlReader.Create(LoadTestData("Designer.Tests._TestData.xsd.melding-1603-12392.xsd"));
XsdToJsonSchema target = new XsdToJsonSchema(xsdReader);
// Act
JsonSchema actual = target.AsJsonSchema();
JsonSchemaToXsd jsonSchemaToXsd = new JsonSchemaToXsd();
XmlSchema xmlschema = jsonSchemaToXsd.CreateXsd(actual);
FileStream file = new FileStream("Designer.Tests._TestData.xsd.melding-1603-12392b.xsd", FileMode.Create, FileAccess.ReadWrite);
XmlTextWriter xwriter = new XmlTextWriter(file, new UTF8Encoding());
xwriter.Formatting = Formatting.Indented;
xmlschema.Write(xwriter);
// Assert
Assert.NotNull(actual);
Assert.Equal(12, actual.Properties().Count);
Assert.Equal(19, actual.Definitions().Count);
}
public async void ConvertXsdToJsonSchemaAndBack_CorrectNumberOfPropertiesAndDefinitions()
{
// string xsdName = "Designer.Tests._TestData.Model.Xsd.schema_3451_8_forms_4106_35721.xsd";
string xsdName = "Designer.Tests._TestData.Model.Xsd.schema_4581_100_forms_5245_41111.xsd";
// Arrange
XmlReader xsdReader = XmlReader.Create(LoadTestData(xsdName));
XsdToJsonSchema target = new XsdToJsonSchema(xsdReader);
// Act
JsonSchema actual = target.AsJsonSchema();
var serializer = new JsonSerializer();
JsonValue toar = serializer.Serialize(actual);
byte[] byteArray = Encoding.UTF8.GetBytes(toar.ToString());
MemoryStream jsonstream = new MemoryStream(byteArray);
await WriteData(xsdName + ".json", jsonstream);
File.WriteAllText(xsdName + ".json", toar.ToString());
JsonSchemaToXsd jsonSchemaToXsd = new JsonSchemaToXsd();
XmlSchema xmlschema = jsonSchemaToXsd.CreateXsd(actual);
MemoryStream xmlStream = new MemoryStream();
XmlTextWriter xwriter = new XmlTextWriter(xmlStream, new UpperCaseUtf8Encoding());
xwriter.Formatting = Formatting.Indented;
xwriter.WriteStartDocument(false);
xmlschema.Write(xmlStream);
await WriteData(xsdName + ".new", xmlStream);
Assert.NotNull(actual);
}
