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