public void GetModelMetadata_RestrictIntegers()
{
// Arrange
JsonSchema testData = TestDataHelper.LoadDataFromEmbeddedResourceAsJsonSchema("Designer.Tests._TestData.Model.JsonSchema.restriction-max-min-integer.schema.json");
// Act
JsonSchemaToInstanceModelGenerator target =
new JsonSchemaToInstanceModelGenerator("parse", "test", testData);
ModelMetadata actual = target.GetModelMetadata();
// Assert
Assert.Equal(BaseValueType.NonNegativeInteger, actual.Elements["RestrictedIntegersTests.RestrictedInteger0IncTo999Incl"].XsdValueType);
Assert.Equal("999", actual.Elements["RestrictedIntegersTests.RestrictedInteger0IncTo999Incl"].Restrictions["maximum"].Value);
Assert.Equal("0", actual.Elements["RestrictedIntegersTests.RestrictedInteger0IncTo999Incl"].Restrictions["minimum"].Value);
Assert.Equal(BaseValueType.PositiveInteger, actual.Elements["RestrictedIntegersTests.RestrictedInteger1IncTo999Incl"].XsdValueType);
Assert.Equal("999", actual.Elements["RestrictedIntegersTests.RestrictedInteger1IncTo999Incl"].Restrictions["maximum"].Value);
Assert.Equal("1", actual.Elements["RestrictedIntegersTests.RestrictedInteger1IncTo999Incl"].Restrictions["minimum"].Value);
Assert.Equal(BaseValueType.Integer, actual.Elements["RestrictedIntegersTests.RestrictedIntegerNegative1IncToMax"].XsdValueType);
Assert.False(actual.Elements["RestrictedIntegersTests.RestrictedIntegerNegative1IncToMax"].Restrictions.ContainsKey("maximum"));
Assert.Equal("-1", actual.Elements["RestrictedIntegersTests.RestrictedIntegerNegative1IncToMax"].Restrictions["minimum"].Value);
Assert.Equal(BaseValueType.NonNegativeInteger, actual.Elements["RestrictedIntegersTests.RestrictedInteger0IncToMax"].XsdValueType);
Assert.False(actual.Elements["RestrictedIntegersTests.RestrictedInteger0IncToMax"].Restrictions.ContainsKey("maximum"));
Assert.Equal("0", actual.Elements["RestrictedIntegersTests.RestrictedInteger0IncToMax"].Restrictions["minimum"].Value);
Assert.Equal(BaseValueType.PositiveInteger, actual.Elements["RestrictedIntegersTests.RestrictedInteger1IncToMax"].XsdValueType);
Assert.False(actual.Elements["RestrictedIntegersTests.RestrictedInteger1IncToMax"].Restrictions.ContainsKey("maximum"));
Assert.Equal("1", actual.Elements["RestrictedIntegersTests.RestrictedInteger1IncToMax"].Restrictions["minimum"].Value);
}
public async Task <IActionResult> UpdateDatamodel(string org, string app, 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, app);
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, app, $"{filePath}.schema.json", jsonstream);
// update meta data
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator(org, app, 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, app, modelName, "Altinn.App.Models." + root);
// 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, app, $"{filePath}.xsd", xsdStream);
}
return(Ok());
}
public void GetModelMetadata_RepeatingGroupHasCorrectDataBinding()
{
// Arrange
JsonSchema testData = LoadTestData("Designer.Tests._TestData.Model.JsonSchema.melding-1603-12392.json");
JsonSchemaToInstanceModelGenerator target =
new JsonSchemaToInstanceModelGenerator("parse", "test", testData);
// Act
ModelMetadata actual = target.GetModelMetadata();
// Assert
Assert.NotNull(actual);
ElementMetadata repeatingGroup = actual.Elements["Skjema.Endringsmeldinggrp9786.OversiktOverEndringenegrp9788"];
Assert.NotNull(repeatingGroup);
Assert.Equal(999, repeatingGroup.MaxOccurs);
Assert.Equal("Endringsmelding-grp-9786.OversiktOverEndringene-grp-9788", repeatingGroup.DataBindingName);
ElementMetadata nonRepeatingGroup = actual.Elements["Skjema.Endringsmeldinggrp9786.Avgivergrp9787"];
Assert.NotNull(nonRepeatingGroup);
Assert.Equal(1, nonRepeatingGroup.MaxOccurs);
Assert.Null(nonRepeatingGroup.DataBindingName);
}
private async static Task <ModelMetadata> UpdateModelMetadata(AltinnAppGitRepository altinnAppGitRepository, JsonSchema jsonSchema, string schemaName)
{
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator(altinnAppGitRepository.Org, altinnAppGitRepository.Repository, jsonSchema);
ModelMetadata modelMetadata = converter.GetModelMetadata();
await altinnAppGitRepository.UpdateModelMetadata(modelMetadata, schemaName);
return(modelMetadata);
}
private static ModelMetadata GenerateModelMetadata(string org, string app, JsonSchema jsonSchema)
{
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator(org, app, jsonSchema);
ModelMetadata modelMetadata = converter.GetModelMetadata();
string root = modelMetadata.Elements != null && modelMetadata.Elements.Count > 0 ? modelMetadata.Elements.Values.First(e => e.ParentElement == null).TypeName : null;
string model = converter.GetInstanceModel().ToString();
return(modelMetadata);
}
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);
ModelMetadata serviceMetadata = converter.GetModelMetadata();
string actualDatabinding = serviceMetadata.Elements["Skjema.Skattyterinforgrp5801.Kontaktgrp5803.KontaktpersonPoststeddatadef10442.value"].DataBindingName;
Assert.Equal("skattyterinforgrp5801.kontaktgrp5803.kontaktpersonPoststeddatadef10442.value", actualDatabinding);
}
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);
}
public void GetModelMetadata_LoadSchema()
{
// Arrange
JsonSchema testData = LoadTestData("Designer.Tests._TestData.Model.JsonSchema.melding-1603-12392.json");
JsonSchemaToInstanceModelGenerator target =
new JsonSchemaToInstanceModelGenerator("parse", "test", testData);
// Act
ModelMetadata actual = target.GetModelMetadata();
// Assert
Assert.NotNull(actual);
}
public void GetModelMetadata_LoadSchema()
{
// Arrange
JsonSchema testData = TestDataHelper.LoadDataFromEmbeddedResourceAsJsonSchema("Designer.Tests._TestData.Model.JsonSchema.Skjema-1603-12392.json");
JsonSchemaToInstanceModelGenerator target =
new JsonSchemaToInstanceModelGenerator("parse", "test", testData);
// Act
ModelMetadata actual = target.GetModelMetadata();
// Assert
Assert.NotNull(actual);
}
public void TextGenerationOk()
{
var schemaText = File.ReadAllText("Common/jsd/service-model.schema.json");
var schemaJson = JsonValue.Parse(schemaText);
var schema = new JsonSerializer().Deserialize <JsonSchema>(schemaJson);
JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator("TestOrg", "ServiceModel", schema);
ModelMetadata serviceMetadata = converter.GetModelMetadata();
Assert.NotNull(serviceMetadata);
// get a chosen text identifier
string placeholder = serviceMetadata.Elements["Skjema.Skattyterinforgrp5801.klagefristgrp5804.KlageUtloptKlagefristBegrunnelsedatadef25456.value"].Texts["PlaceHolder"];
Assert.Equal("25456.KlageUtloptKlagefristBegrunnelsedatadef25456.PlaceHolder", placeholder);
}
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 GetModelMetadata_RootNameCorrectlyTransferedToModelMetadata()
{
// Arrange
JsonSchema testData = TestDataHelper.LoadDataFromEmbeddedResourceAsJsonSchema("Designer.Tests._TestData.Model.JsonSchema.RA-0678_M.schema.json");
JsonSchemaToInstanceModelGenerator target =
new JsonSchemaToInstanceModelGenerator("parse", "test", testData);
// Act
ModelMetadata actual = target.GetModelMetadata();
// Assert
Assert.NotNull(actual);
ElementMetadata rootElement = actual.Elements["melding"];
Assert.NotNull(rootElement);
Assert.Equal("melding", rootElement.ID);
Assert.Equal("melding", rootElement.Name);
Assert.Equal("RA0678_M", rootElement.TypeName);
}