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