private static string GenerateCSharpClasses(ModelMetadata modelMetadata)
{
JsonMetadataParser modelGenerator = new JsonMetadataParser();
string classes = modelGenerator.CreateModelFromMetadata(modelMetadata);
return(classes);
}
public void ConvertServiceModel()
{
Dictionary <string, Dictionary <string, string> > textDictionary = new Dictionary <string, Dictionary <string, string> >();
Mock <IRepository> moqRepository = new Mock <IRepository>();
moqRepository
.Setup(r => r.GetServiceTexts(It.IsAny <string>(), It.IsAny <string>())).Returns(textDictionary);
var seresParser = new SeresXsdParser(moqRepository.Object);
XDocument mainXsd = XDocument.Load("Common/xsd/ServiceModel.xsd");
ServiceMetadata serviceMetadata = seresParser.ParseXsdToServiceMetadata("123", "app", mainXsd, null);
string metadataAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(serviceMetadata);
File.WriteAllText("service-model.json", metadataAsJson);
JsonMetadataParser metadataParser = new JsonMetadataParser();
string classMeta = metadataParser.CreateModelFromMetadata(serviceMetadata);
File.WriteAllText("service-model.cs", classMeta);
File.WriteAllText("servcie-model-texts.txt", Newtonsoft.Json.JsonConvert.SerializeObject(textDictionary));
}
private static TableGroup ParseMetadata(string jsonPath, Uri baseUri)
{
var metadataParser = new JsonMetadataParser(new DefaultResolver(), baseUri ?? new Uri("http://localhost/example.json"));
using var fileStream = File.OpenText(jsonPath);
return(metadataParser.Parse(fileStream));
}
public void ConvertNæringsoppgave()
{
string xsdFileName = "Common/xsd/melding-2-12186.xsd";
string outName = "melding-2-12186-output";
Dictionary <string, Dictionary <string, string> > textDictionary = new Dictionary <string, Dictionary <string, string> >();
Mock <IRepository> moqRepository = new Mock <IRepository>();
moqRepository
.Setup(r => r.GetServiceTexts(It.IsAny <string>(), It.IsAny <string>())).Returns(textDictionary);
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
var doc = XmlReader.Create(xsdFileName, settings);
XDocument mainXsd = XDocument.Load(doc);
var seresParser = new SeresXsdParser(moqRepository.Object);
ServiceMetadata serviceMetadata = seresParser.ParseXsdToServiceMetadata("123", "app", mainXsd, null);
string metadataAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(serviceMetadata);
File.WriteAllText(outName + ".json", metadataAsJson);
JsonMetadataParser metadataParser = new JsonMetadataParser();
string classMeta = metadataParser.CreateModelFromMetadata(serviceMetadata);
File.WriteAllText(outName + ".cs", classMeta);
File.WriteAllText(outName + "-texts.json", Newtonsoft.Json.JsonConvert.SerializeObject(textDictionary));
}
private static TableGroup ParseMetadataFromJson(string json, Uri baseUri)
{
var metadataParser = new JsonMetadataParser(new DefaultResolver(), baseUri ?? new Uri("http://localhost/example.json"));
using var reader = new StringReader(json);
return(metadataParser.Parse(reader));
}
public void CreateModelFromMetadata_InputModelSpecifiedModelName_GenerateDataAnnotationForRoomElement()
{
// Arrange
ModelMetadata testData = LoadTestData("Designer.Tests._TestData.Model.Metadata.RA-0678_M.metadata.json");
JsonMetadataParser target = new JsonMetadataParser();
// Act
string modelClass = target.CreateModelFromMetadata(testData);
// Assert
Assert.NotNull(modelClass);
Assert.Contains("[XmlRoot(ElementName=\"melding\")]", modelClass);
}
public void CreateModelFromMetadata_InputModelWithRestrictionMinimumAndMaximum_GenerateDataAnnotationWithRangeFromMinToMax()
{
// Arrange
ModelMetadata testData = LoadTestData("Designer.Tests._TestData.Model.Metadata.restriction-total-digits.metadata.json");
JsonMetadataParser target = new JsonMetadataParser();
// Act
string modelClass = target.CreateModelFromMetadata(testData);
// Assert
Assert.NotNull(modelClass);
Assert.Contains("[Range(-7.766279631452242E+18, 7.766279631452242E+18)]", modelClass);
}
public void CreateModelFromMetadata_InputModelWithRestrictionMinLengthAndMaxLength_GenerateDataAnnotationWithMinLengthAndMaxLengthAttributes()
{
// Arrange
ModelMetadata testData = LoadTestData("Designer.Tests._TestData.Model.Metadata.restriction-total-digits.metadata.json");
JsonMetadataParser target = new JsonMetadataParser();
// Act
string modelClass = target.CreateModelFromMetadata(testData);
// Assert
Assert.NotNull(modelClass);
Assert.Contains("[MinLength(1)]", modelClass);
Assert.Contains("[MaxLength(20)]", modelClass);
}
public void ConvertRecursiveSchemaJsonMetadata()
{
Mock <IRepository> moqRepository = new Mock <IRepository>();
var seresParser = new SeresXsdParser(moqRepository.Object);
XDocument mainXsd = XDocument.Load("Common/xsd/schema-w-recursion.xsd");
ServiceMetadata serviceMetadata = seresParser.ParseXsdToServiceMetadata("123", "app", mainXsd, null);
string metadataAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(serviceMetadata);
File.WriteAllText("metadata-recursive.json", metadataAsJson);
JsonMetadataParser metadataParser = new JsonMetadataParser();
string classMeta = metadataParser.CreateModelFromMetadata(serviceMetadata);
File.WriteAllText("classdata-recursive.cs", classMeta);
}
public void ConvertExistingEdagSchemaToJsonMetadataAndCsharp()
{
Mock <IRepository> moqRepository = new Mock <IRepository>();
var seresParser = new SeresXsdParser(moqRepository.Object);
XDocument mainXsd = XDocument.Load("Common/xsd/schema.xsd");
ServiceMetadata serviceMetadata = seresParser.ParseXsdToServiceMetadata("123", "app", mainXsd, null);
string metadataAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(serviceMetadata);
File.WriteAllText("edag.original.metadata.json", metadataAsJson);
JsonMetadataParser metadataParser = new JsonMetadataParser();
string classMeta = metadataParser.CreateModelFromMetadata(serviceMetadata);
File.WriteAllText("edag.original.csharp.cs", classMeta);
}
public void ConvertSkatteetatenBSU()
{
Mock <IRepository> moqRepository = new Mock <IRepository>();
var seresParser = new SeresXsdParser(moqRepository.Object);
XDocument mainXsd = XDocument.Load("Common/xsd/boligsparingForUngdom_v1_1.xsd");
ServiceMetadata serviceMetadata = seresParser.ParseXsdToServiceMetadata("123", "app", mainXsd, null);
string metadataAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(serviceMetadata);
File.WriteAllText("boligsparingForUngdom.json", metadataAsJson);
JsonMetadataParser metadataParser = new JsonMetadataParser();
string classMeta = metadataParser.CreateModelFromMetadata(serviceMetadata);
File.WriteAllText("boligsparingForUngdom.cs", classMeta);
}
public void Convert_FromSeresSchema_ShouldConvert(string xsdSchemaPath, string expectedMetamodelPath)
{
// Arrange
// Convert the Seres XSD to JSON Schema
XmlSchema originalXsd = TestDataHelper.LoadXmlSchemaTestData(xsdSchemaPath);
var xsdToJsonConverter = new XmlSchemaToJsonSchemaConverter();
JsonSchema convertedJsonSchema = xsdToJsonConverter.Convert(originalXsd);
var convertedJsonSchemaString = JsonSerializer.Serialize(convertedJsonSchema, new JsonSerializerOptions()
{
Encoder = JavaScriptEncoder.Create(UnicodeRanges.BasicLatin, UnicodeRanges.Latin1Supplement), WriteIndented = true
});
// Convert to Metadata model
var metamodelConverter = new JsonSchemaToMetamodelConverter(new SeresJsonSchemaAnalyzer());
metamodelConverter.KeywordProcessed += KeywordProcessedHandler;
metamodelConverter.SubSchemaProcessed += SubSchemaProcessedHandler;
// Act
var actualMetamodel = metamodelConverter.Convert("melding", convertedJsonSchemaString);
// Leaving this for easy access/manual verification
var actualMetamodelJson = JsonSerializer.Serialize(actualMetamodel, new JsonSerializerOptions()
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase, WriteIndented = true, Converters = { new JsonStringEnumConverter() }
});
// Assert
var expectedMetamodelJson = TestDataHelper.LoadTestDataFromFileAsString(expectedMetamodelPath);
var expectedMetamodel = JsonSerializer.Deserialize <ModelMetadata>(expectedMetamodelJson, new JsonSerializerOptions()
{
PropertyNameCaseInsensitive = true, Converters = { new JsonStringEnumConverter() }
});
MetadataAssertions.IsEquivalentTo(expectedMetamodel, actualMetamodel);
actualMetamodel.Elements.Values.Where(e => e.ParentElement == null).ToList().Count.Should().Be(1);
// Compile the generated class to verify it compiles without errors
var classes = new JsonMetadataParser().CreateModelFromMetadata(actualMetamodel);
var compiledAssembly = Compiler.CompileToAssembly(classes);
compiledAssembly.Should().NotBeNull();
}
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 async void TestValidConversions(string tableMetadataPath, string csvFilePath,
string expectedOutputGraphPath)
{
var metadataParser =
new JsonMetadataParser(new DefaultResolver(), new Uri("http://example.org/metadata.json"));
tableMetadataPath = Path.Combine("data", tableMetadataPath);
csvFilePath = Path.Combine("data", csvFilePath);
expectedOutputGraphPath = Path.Combine("data", expectedOutputGraphPath);
TableGroup tableGroup;
using (var metadataReader = File.OpenText(tableMetadataPath))
{
tableGroup = metadataParser.Parse(metadataReader);
}
tableGroup.Should().NotBeNull();
tableGroup.Tables.Should().HaveCount(1);
var tableMeta = tableGroup.Tables[0];
tableMeta.Should().NotBeNull(because: "The metadata file should parse as table metadata");
var outputGraph = new Graph();
var graphHandler = new GraphHandler(outputGraph);
var resolverMock = new Mock <ITableResolver>();
resolverMock.Setup(x => x.ResolveAsync(It.IsAny <Uri>())).Returns(Task.FromResult(File.OpenRead(csvFilePath) as Stream));
var converter = new Converter(graphHandler, resolverMock.Object, ConverterMode.Minimal);
await converter.ConvertAsync(tableMeta.Parent as TableGroup);
converter.Errors.Count.Should().Be(0, "Expected 0 errors. Got {0}. Error listing is:\n{1}", converter.Errors.Count, string.Join("\n", converter.Errors));
var turtleParser = new TurtleParser(TurtleSyntax.W3C);
var expectGraph = new Graph();
turtleParser.Load(expectGraph, expectedOutputGraphPath);
var diff = new GraphDiff();
var diffReport = diff.Difference(expectGraph, outputGraph);
diffReport.AreEqual.Should().BeTrue("Graphs differ");
}
private async Task <Graph> GenerateDatasetGraphAsync(string csvPath, JObject metadataJson, Uri metadataUri)
{
var parser = new JsonMetadataParser(null, metadataUri);
var tableGroup = new TableGroup();
try
{
var tableMeta = parser.ParseTable(tableGroup, metadataJson);
if (tableMeta == null)
{
throw new WorkerException("CSV Conversion failed. Unable to read CSV table metadata.");
}
}
catch (MetadataParseException ex)
{
Log.Error(ex, "Invalid CSV table metadata: " + ex.Message);
throw new WorkerException(ex, "CSV conversion failed. Invalid CSV table metadata: " + ex.Message);
}
var graph = new Graph();
ProgressLog.Info("Running CSV to RDF conversion");
var graphHandler = new GraphHandler(graph);
var tableResolver = new LocalTableResolver(tableGroup.Tables[0].Url, csvPath);
var converter = new Converter(graphHandler, tableResolver, ConverterMode.Minimal, (msg) => ProgressLog.Error(msg), this, reportInterval: CsvConversionReportInterval);
await converter.ConvertAsync(tableGroup);
if (converter.Errors.Any())
{
foreach (var e in converter.Errors)
{
ProgressLog.Error(e);
}
throw new WorkerException("One or more errors where encountered during the CSV to RDF conversion.");
}
return(graph);
}
public async Task <IActionResult> UpdateDatamodel(string org, string repository, string modelName)
{
SchemaKeywordCatalog.Add <InfoKeyword>();
try
{
modelName = modelName.AsFileName();
}
catch
{
return(BadRequest("Invalid model name value."));
}
string filePath = $"App/models/{modelName}";
using (Stream resource = Request.Body)
{
// Read the request body and deserialize to Json Schema
using StreamReader streamReader = new StreamReader(resource);
string content = await streamReader.ReadToEndAsync();
TextReader textReader = new StringReader(content);
JsonValue jsonValue = await JsonValue.ParseAsync(textReader);
JsonSchema jsonSchemas = new Manatee.Json.Serialization.JsonSerializer().Deserialize <JsonSchema>(jsonValue);
// Create the directory if it does not exist
string appPath = _repository.GetAppPath(org, repository);
string directory = appPath + Path.GetDirectoryName(filePath);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
// Serialize and store the Json Schema
var serializer = new Manatee.Json.Serialization.JsonSerializer();
JsonValue toar = serializer.Serialize(jsonSchemas);
byte[] byteArray = Encoding.UTF8.GetBytes(toar.ToString());
MemoryStream jsonstream = new MemoryStream(byteArray);
await _repository.WriteData(org, repository, $"{filePath}.schema.json", jsonstream);
// update meta data
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator(org, repository, jsonSchemas);
ModelMetadata modelMetadata = converter.GetModelMetadata();
string root = modelMetadata.Elements != null && modelMetadata.Elements.Count > 0 ? modelMetadata.Elements.Values.First(e => e.ParentElement == null).TypeName : null;
_repository.UpdateApplicationWithAppLogicModel(org, repository, modelName, "Altinn.App.Models." + root);
_repository.UpdateModelMetadata(org, repository, modelMetadata, modelName);
// Convert to XML Schema and store in repository
JsonSchemaToXsd jsonSchemaToXsd = new JsonSchemaToXsd();
XmlSchema xmlschema = jsonSchemaToXsd.CreateXsd(jsonSchemas);
MemoryStream xsdStream = new MemoryStream();
XmlTextWriter xwriter = new XmlTextWriter(xsdStream, new UpperCaseUtf8Encoding());
xwriter.Formatting = Formatting.Indented;
xwriter.WriteStartDocument(false);
xmlschema.Write(xsdStream);
await _repository.WriteData(org, repository, $"{filePath}.xsd", xsdStream);
// Generate updated C# model
JsonMetadataParser modelGenerator = new JsonMetadataParser();
string classes = modelGenerator.CreateModelFromMetadata(modelMetadata);
byteArray = Encoding.UTF8.GetBytes(classes);
MemoryStream stream = new MemoryStream(byteArray);
await _repository.WriteData(org, repository, $"{filePath}.cs", stream);
}
return(Ok());
}
private TableGroup ParseCsvMetadata(Uri baseUri, string metadata)
{
var parser = new JsonMetadataParser(_resolver, baseUri);
return(parser.Parse(new StringReader(metadata)));
}
private async static Task UpdateCSharpClasses(AltinnAppGitRepository altinnAppGitRepository, ModelMetadata modelMetadata, string schemaName)
{
JsonMetadataParser modelGenerator = new JsonMetadataParser();
string classes = modelGenerator.CreateModelFromMetadata(modelMetadata);
await altinnAppGitRepository.UpdateCSharpClasses(classes, schemaName);
}
