hyperion.ng/include/utils/jsonschema/QJsonFactory.h

#pragma once

#include <iostream>
#include <stdexcept>

// JSON-Schema includes
#include <utils/jsonschema/QJsonSchemaChecker.h>

#include <QFile>
#include <QString>
#include <QJsonObject>
#include <QJsonDocument>
#include <QRegularExpression>

class QJsonFactory
{
public:

	static int load(const QString& schema, const QString& config, QJsonObject& json)
	{
		// Load the schema and the config trees
		QJsonObject schemaTree = readSchema(schema);
		QJsonObject configTree = readConfig(config);

		// create the validator
		QJsonSchemaChecker schemaChecker;
		schemaChecker.setSchema(schemaTree);

		QStringList messages = schemaChecker.getMessages();

		if (!schemaChecker.validate(configTree).first)
		{
			for (int i = 0; i < messages.size(); ++i)
				std::cout << messages[i].toStdString() << std::endl;

			std::cerr << "Validation failed for configuration file: " << config.toStdString() << std::endl;
			return -3;
		}

		json = configTree;
		return 0;
	}

	static QJsonObject readConfig(const QString& path)
	{
		QFile file(path);
		QJsonParseError error;

		if (!file.open(QIODevice::ReadOnly))
		{
			throw std::runtime_error(QString("Configuration file not found: '" + path + "' ("  +  file.errorString() + ")").toStdString());
		}

		//Allow Comments in Config
		QString config = QString(file.readAll());
		config.remove(QRegularExpression("([^:]?\\/\\/.*)"));

		QJsonDocument doc = QJsonDocument::fromJson(config.toUtf8(), &error);
		file.close();

		if (error.error != QJsonParseError::NoError)
		{
			// report to the user the failure and their locations in the document.
			int errorLine(0), errorColumn(0);

			for( int i=0, count=qMin( error.offset,config.size()); i<count; ++i )
			{
				++errorColumn;
				if(config.at(i) == '\n' )
				{
					errorColumn = 0;
					++errorLine;
				}
			}

			throw std::runtime_error (
				QString("Failed to parse configuration: " + error.errorString() + " at Line: " + QString::number(errorLine) + ", Column: " + QString::number(errorColumn)).toStdString()
			);
		}

		return doc.object();
	}

	static QJsonObject readSchema(const QString& path)
	{
		QFile schemaData(path);
		QJsonParseError error;

		if (!schemaData.open(QIODevice::ReadOnly))
		{
			throw std::runtime_error(QString("Schema not found: '" + path + "' (" + schemaData.errorString() + ")").toStdString());
		}

		QByteArray schema = schemaData.readAll();
		QJsonDocument doc = QJsonDocument::fromJson(schema, &error);
		schemaData.close();

		if (error.error != QJsonParseError::NoError)
		{
			// report to the user the failure and their locations in the document.
			int errorLine(0), errorColumn(0);

			for( int i=0, count=qMin( error.offset,schema.size()); i<count; ++i )
			{
				++errorColumn;
				if(schema.at(i) == '\n' )
				{
					errorColumn = 0;
					++errorLine;
				}
			}

			throw std::runtime_error(QString("ERROR: Json schema wrong: " + error.errorString() +
											" at Line: " + QString::number(errorLine) +
											", Column: " + QString::number(errorColumn)).toStdString());
		}

		return resolveReferences(doc.object());
	}

	static QJsonObject resolveReferences(const QJsonObject& schema)
	{
		QJsonObject result;

		for (QJsonObject::const_iterator i = schema.begin(); i != schema.end(); ++i)
		{
			QString attribute = i.key();
			const QJsonValue & attributeValue = *i;

			if (attribute == "$ref" && attributeValue.isString())
			{
				try
				{
					result = readSchema(":/" + attributeValue.toString());
				}
				catch (std::runtime_error& error)
				{
					throw std::runtime_error(error.what());
				}
			}
			else if (attributeValue.isObject())
				result.insert(attribute, resolveReferences(attributeValue.toObject()));
			else
				result.insert(attribute, attributeValue);
		}

		return result;
	}

	static bool writeJson(const QString& filename, QJsonObject& jsonTree)
	{
		QJsonDocument doc;

		doc.setObject(jsonTree);
		QByteArray configData = doc.toJson(QJsonDocument::Indented);

		QFile configFile(filename);
		if (!configFile.open(QFile::WriteOnly | QFile::Truncate))
			return false;

		configFile.write(configData);

		QFile::FileError error = configFile.error();
		if (error != QFile::NoError)
			return false;

		configFile.close();

		return true;
	}
};