Refactor config API

libsrc/db/AuthTable.cpp

@@ -0,0 +1,176 @@
+
+// hyperion
+#include <db/AuthTable.h>
+#include <QCryptographicHash>
+
+// qt
+#include <QDateTime>
+#include <QUuid>
+
+/// construct wrapper with auth table
+AuthTable::AuthTable(QObject* parent)
+	: DBManager(parent)
+{
+	// init Auth table
+	setTable("auth");
+	// create table columns
+	createTable(QStringList()<<"user TEXT"<<"password BLOB"<<"token BLOB"<<"salt BLOB"<<"comment TEXT"<<"id TEXT"<<"created_at TEXT"<<"last_use TEXT");
+};
+
+bool AuthTable::createUser(const QString& user, const QString& password)
+{
+	// new salt
+	QByteArray salt = QCryptographicHash::hash(QUuid::createUuid().toByteArray(), QCryptographicHash::Sha512).toHex();
+	QVariantMap map;
+	map["user"] = user;
+	map["salt"] = salt;
+	map["password"] = hashPasswordWithSalt(password,salt);
+	map["created_at"] = QDateTime::currentDateTimeUtc().toString(Qt::ISODate);
+
+	return createRecord({{"user",user}}, map);
+}
+
+bool AuthTable::userExist(const QString& user)
+{
+	return recordExists({{"user",user}});
+}
+
+bool AuthTable::isUserAuthorized(const QString& user, const QString& password)
+{
+	if(userExist(user) && (calcPasswordHashOfUser(user,  password) == getPasswordHashOfUser(user)))
+	{
+		updateUserUsed(user);
+		return true;
+	}
+	return false;
+}
+
+bool AuthTable::isUserTokenAuthorized(const QString& usr, const QString& token)
+{
+	if(getUserToken(usr) == token.toUtf8())
+	{
+		updateUserUsed(usr);
+		return true;
+	}
+	return false;
+}
+
+bool AuthTable::setUserToken(const QString& user)
+{
+	QVariantMap map;
+	map["token"] = QCryptographicHash::hash(QUuid::createUuid().toByteArray(), QCryptographicHash::Sha512).toHex();
+
+	return updateRecord({{"user",user}}, map);
+}
+
+const QByteArray AuthTable::getUserToken(const QString& user)
+{
+	QVariantMap results;
+	getRecord({{"user",user}}, results, QStringList()<<"token");
+
+	return results["token"].toByteArray();
+}
+
+bool AuthTable::updateUserPassword(const QString& user, const QString& newPassword)
+{
+	QVariantMap map;
+	map["password"] = calcPasswordHashOfUser(user, newPassword);
+
+	return updateRecord({{"user",user}}, map);
+}
+
+bool AuthTable::resetHyperionUser()
+{
+	QVariantMap map;
+	map["password"] = calcPasswordHashOfUser(hyperion::DEFAULT_USER, hyperion::DEFAULT_PASSWORD);
+
+	return updateRecord({{"user", hyperion::DEFAULT_USER}}, map);
+}
+
+void AuthTable::updateUserUsed(const QString& user)
+{
+	QVariantMap map;
+	map["last_use"] = QDateTime::currentDateTimeUtc().toString(Qt::ISODate);
+
+	updateRecord({{"user",user}}, map);
+}
+
+bool AuthTable::tokenExist(const QString& token)
+{
+	QVariantMap map;
+	map["last_use"] = QDateTime::currentDateTimeUtc().toString(Qt::ISODate);
+
+	VectorPair cond;
+	cond.append(CPair("token", hashToken(token)));
+	if(recordExists(cond))
+	{
+		// update it
+		createRecord(cond,map);
+		return true;
+	}
+	return false;
+}
+
+bool AuthTable::createToken(const QString& token, const QString& comment, const QString& identifier)
+{
+	QVariantMap map;
+	map["comment"] = comment;
+	map["id"] = identifierExist(identifier) ? QUuid::createUuid().toString().remove("{").remove("}").left(5) : identifier;
+	map["created_at"] = QDateTime::currentDateTimeUtc().toString(Qt::ISODate);
+
+	return createRecord({{"token", hashToken(token)}}, map);
+}
+
+bool AuthTable::deleteToken(const QString& identifier)
+{
+	return deleteRecord({{"id", identifier}});
+}
+
+bool AuthTable::renameToken(const QString &identifier, const QString &comment)
+{
+	QVariantMap map;
+	map["comment"] = comment;
+
+	return updateRecord({{"id", identifier}}, map);
+}
+
+const QVector<QVariantMap> AuthTable::getTokenList()
+{
+	QVector<QVariantMap> results;
+	getRecords(results, QStringList() << "comment" << "id" << "last_use");
+
+	return results;
+}
+
+bool AuthTable::identifierExist(const QString& identifier)
+{
+	return recordExists({{"id", identifier}});
+}
+
+const QByteArray AuthTable::getPasswordHashOfUser(const QString& user)
+{
+	QVariantMap results;
+	getRecord({{"user",user}}, results, QStringList()<<"password");
+
+	return results["password"].toByteArray();
+}
+
+const QByteArray AuthTable::calcPasswordHashOfUser(const QString& user, const QString&  password)
+{
+	// get salt
+	QVariantMap results;
+	getRecord({{"user",user}}, results, QStringList()<<"salt");
+
+	// calc
+	return hashPasswordWithSalt(password,results["salt"].toByteArray());
+}
+
+const QByteArray AuthTable::hashPasswordWithSalt(const QString&  password, const QByteArray& salt)
+{
+	return QCryptographicHash::hash(password.toUtf8().append(salt), QCryptographicHash::Sha512).toHex();
+}
+
+const QByteArray AuthTable::hashToken(const QString& token)
+{
+	return QCryptographicHash::hash(token.toUtf8(), QCryptographicHash::Sha512).toHex();
+}

libsrc/db/CMakeLists.txt

@@ -1,10 +1,17 @@
 add_library(database
 	${CMAKE_SOURCE_DIR}/include/db/AuthTable.h
 	${CMAKE_SOURCE_DIR}/include/db/DBManager.h
+	${CMAKE_SOURCE_DIR}/include/db/ConfigImportExport.h
 	${CMAKE_SOURCE_DIR}/include/db/InstanceTable.h
 	${CMAKE_SOURCE_DIR}/include/db/MetaTable.h
 	${CMAKE_SOURCE_DIR}/include/db/SettingsTable.h
+	${CMAKE_SOURCE_DIR}/libsrc/db/AuthTable.cpp
 	${CMAKE_SOURCE_DIR}/libsrc/db/DBManager.cpp
+	${CMAKE_SOURCE_DIR}/libsrc/db/ConfigImportExport.cpp
+	${CMAKE_SOURCE_DIR}/libsrc/db/InstanceTable.cpp
+	${CMAKE_SOURCE_DIR}/libsrc/db/MetaTable.cpp
+	${CMAKE_SOURCE_DIR}/libsrc/db/SettingsTable.cpp
+	${CMAKE_SOURCE_DIR}/libsrc/db/DB_schemas.qrc
 )
 
 target_link_libraries(database

libsrc/db/ConfigImportExport.cpp

@@ -0,0 +1,261 @@
+#include "db/SettingsTable.h"
+#include <db/MetaTable.h>
+#include <db/ConfigImportExport.h>
+
+#include <db/InstanceTable.h>
+#include <hyperion/SettingsManager.h>
+
+#include <utils/JsonUtils.h>
+#include <utils/jsonschema/QJsonFactory.h>
+
+#include <HyperionConfig.h>
+
+#include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QSqlError>
+#include <QDir>
+
+ConfigImportExport::ConfigImportExport(QObject* parent)
+	: DBManager(parent)
+{
+	Q_INIT_RESOURCE(DB_schemas);
+}
+
+QPair<bool, QStringList> ConfigImportExport::importJson(const QString& configFile)
+{
+	Info(_log,"Import configuration file '%s'", QSTRING_CSTR(configFile));
+
+	QJsonObject config;
+	QPair<bool, QStringList> result = JsonUtils::readFile(configFile, config, _log, false);
+
+	if (!result.first)
+	{
+		QString errorText = QString("Import configuration file '%s' failed!").arg(configFile);
+		result.second.prepend(errorText);
+		Error(_log, "'%s'", QSTRING_CSTR(errorText));
+		return result;
+	}
+	return setConfiguration(config);
+}
+
+bool ConfigImportExport::exportJson(const QString& path) const
+{
+	bool isExported {false};
+
+	QDir exportPath{path};
+	if (path.isEmpty())
+	{
+		exportPath.setPath(getDataDirectory().absoluteFilePath("archive"));
+	}
+
+	QString jsonFile;
+	if (QDir().mkpath(exportPath.absolutePath()))
+	{
+		const QJsonObject configurtion = getConfiguration();
+		if (!configurtion.isEmpty())
+		{
+			const QJsonObject generalSettings = configurtion.value("global").toObject().value("settings").toObject().value("general").toObject();
+			const QString configVersion = generalSettings.value("configVersion").toString();
+
+			jsonFile = exportPath.absoluteFilePath(QString("HyperionBackup_%1_v%2.json").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd_hh:mm:ss:zzz"), configVersion ));
+			if (FileUtils::writeFile(jsonFile, QJsonDocument(configurtion).toJson(QJsonDocument::Indented), _log))
+			{
+				isExported = true;
+			}
+		}
+	}
+
+	if (isExported)
+	{
+		Info(_log, "Successfully exported configuration to '%s'", QSTRING_CSTR(jsonFile));
+	}
+	else
+	{
+		Error(_log, "Failed to export configuration to '%s'", QSTRING_CSTR(jsonFile));
+	}
+
+	return isExported;
+}
+
+QPair<bool, QStringList> ConfigImportExport::setConfiguration(const QJsonObject& config)
+{
+	Debug(_log, "Start import JSON configuration");
+
+	QStringList errorList;
+	if (config.isEmpty())
+	{
+		QString errorText {"No configuration data provided!"};
+		Error(_log, "'%s'", QSTRING_CSTR(errorText));
+		errorList.append(errorText);
+		return qMakePair (false, errorList );
+	}
+
+	// check basic message
+	QJsonObject schema = QJsonFactory::readSchema(":schema-config-exchange");
+	QPair<bool, QStringList> validationResult = JsonUtils::validate("importConfig", config, schema, _log);
+	if (!validationResult.first)
+	{
+		Error(_log, "Invalid JSON configuration data provided!");
+		return qMakePair (false, validationResult.second );
+	}
+
+	Info(_log, "Create backup of current configuration");
+	if (!exportJson())
+	{
+		Warning(_log, "Backup of current configuration failed");
+	}
+
+	QSqlDatabase idb = getDB();
+	if (!idb.transaction())
+	{
+		QString errorText = QString("Could not create a database transaction. Error: %1").arg(idb.lastError().text());
+		Error(_log, "'%s'", QSTRING_CSTR(errorText));
+		errorList.append(errorText);
+		return qMakePair (false, errorList );
+	}
+
+	bool errorOccured {false};
+	if (!deleteTable("instances") || !deleteTable("settings"))
+	{
+		QString errorText = "Failed to clear tables before import";
+		Error(_log, "'%s'", QSTRING_CSTR(errorText));
+		errorList.append(errorText);
+		errorOccured = true;
+	}
+	else
+	{
+		SettingsTable settingsTableGlobal(GLOABL_INSTANCE_ID);
+		const QJsonObject globalConfig = config.value("global").toObject();
+		const QJsonObject globalSettings = globalConfig.value("settings").toObject();
+
+		for (QJsonObject::const_iterator it = globalSettings.constBegin(); it != globalSettings.constEnd(); ++it)
+		{
+			if (!settingsTableGlobal.createSettingsRecord(it.key(), JsonUtils::jsonValueToQString(it.value())))
+			{
+				errorOccured = true;
+			}
+		}
+
+		InstanceTable instanceTable;
+		const QJsonArray instancesConfig = config.value("instances").toArray();
+		quint8 instanceIdx {0};
+
+		for (auto instanceItem : instancesConfig)
+		{
+			QJsonObject instanceConfig = instanceItem.toObject();
+			QString instanceName = instanceConfig.value("name").toString(QString("Instance %1").arg(instanceIdx));
+			bool isInstanceEnabled = instanceConfig.value("enabled").toBool(true);
+
+			if (instanceIdx == 0)
+			{
+				isInstanceEnabled = true;
+			}
+
+			if (!instanceTable.createInstance(instanceName, instanceIdx) ||
+				!instanceTable.setEnable(instanceIdx, isInstanceEnabled))
+			{
+				errorOccured = true;
+			}
+
+			SettingsTable settingsTableInstance(instanceIdx);
+			const QJsonObject instanceSettings = instanceConfig.value("settings").toObject();
+			for (QJsonObject::const_iterator it = instanceSettings.constBegin(); it != instanceSettings.constEnd(); ++it)
+			{
+				if (!settingsTableInstance.createSettingsRecord(it.key(), JsonUtils::jsonValueToQString(it.value())))
+				{
+					errorOccured = true;
+				}
+			}
+			++instanceIdx;
+		}
+
+		if (errorOccured)
+		{
+			QString errorText = "Errors occured during instances' and/or settings' configuration";
+			Error(_log, "'%s'", QSTRING_CSTR(errorText));
+			errorList.append(errorText);
+		}
+	}
+
+	if (errorOccured)
+	{
+		if (!idb.rollback())
+		{
+			QString errorText = QString("Could not create a database transaction. Error: %1").arg(idb.lastError().text());
+			Error(_log, "'%s'", QSTRING_CSTR(errorText));
+			errorList.append(errorText);
+		}
+	}
+
+	if (!idb.commit())
+	{
+		QString errorText = QString("Could not finalise the database changes. Error: %1").arg(idb.lastError().text());
+		Error(_log, "'%s'", QSTRING_CSTR(errorText));
+		errorList.append(errorText);
+	}
+
+	if(errorList.isEmpty())
+	{
+		Info(_log, "Successfully imported new configuration");
+	}
+
+	return qMakePair (errorList.isEmpty(), errorList );
+}
+
+QJsonObject ConfigImportExport::getConfiguration(const QList<quint8>& instancesFilter, bool addGlobalConfig, const QStringList& instanceFilteredTypes, const QStringList& globalFilterTypes ) const
+{
+	QSqlDatabase idb = getDB();
+	if (!idb.transaction())
+	{
+		Error(_log, "Could not create a database transaction. Error: %s", QSTRING_CSTR(idb.lastError().text()));
+		return {};
+	}
+
+	InstanceTable instanceTable;
+	SettingsManager settingsManager(0, nullptr);
+
+	QJsonObject config;
+
+	if (addGlobalConfig)
+	{
+		QJsonObject globalConfig;
+
+		MetaTable metaTable;
+		globalConfig.insert("uuid", metaTable.getUUID());
+		globalConfig.insert("settings", settingsManager.getSettings({}, globalFilterTypes));
+		config.insert("global", globalConfig);
+	}
+
+	QList<quint8> instances {instancesFilter};
+	if (instances.isEmpty())
+	{
+		instances = instanceTable.getAllInstanceIDs();
+	}
+
+	QList<quint8> sortedInstances = instances;
+	std::sort(sortedInstances.begin(), sortedInstances.end());
+
+	QJsonArray instanceIdList;
+	QJsonArray configInstanceList;
+	for (const quint8 instanceIdx : sortedInstances)
+	{
+		QJsonObject instanceConfig;
+		instanceConfig.insert("id",instanceIdx);
+		instanceConfig.insert("name", instanceTable.getNamebyIndex(instanceIdx));
+		instanceConfig.insert("enabled", instanceTable.isEnabled(instanceIdx));
+		instanceConfig.insert("settings", settingsManager.getSettings(static_cast<quint8>(instanceIdx), instanceFilteredTypes));
+		configInstanceList.append(instanceConfig);
+
+		instanceIdList.append(instanceIdx);
+	}
+
+	config.insert("instanceIds", instanceIdList);
+	config.insert("instances", configInstanceList);
+
+	if (!idb.commit())
+	{
+		Error(_log, "Could not finalise a database transaction. Error: %s", QSTRING_CSTR(idb.lastError().text()));
+	}
+
+	return config;
+}

libsrc/db/DBManager.cpp

@@ -1,38 +1,48 @@
+#include "utils/settings.h"
 #include <db/DBManager.h>
 
 #include <QSqlDatabase>
 #include <QSqlError>
 #include <QSqlQuery>
 #include <QSqlRecord>
-#include <QThreadStorage>
 #include <QUuid>
 #include <QDir>
 #include <QMetaType>
+#include <QJsonObject>
 
 #ifdef _WIN32
 	#include <stdexcept>
 #endif
 
-// not in header because of linking
-static QString _rootPath;
-static QThreadStorage<QSqlDatabase> _databasePool;
+#define NO_SQLQUERY_LOGGING
+
+// Constants
+namespace {
+	const char DATABASE_DIRECTORYNAME[] = "db";
+	const char DATABASE_FILENAME[] = "hyperion.db";
+
+} //End of constants
+
+
+QDir DBManager::_dataDirectory;
+QDir DBManager::_databaseDirectory;
+QFileInfo DBManager::_databaseFile;
+QThreadStorage<QSqlDatabase> DBManager::_databasePool;
+bool DBManager::_isReadOnly {false};
 
 DBManager::DBManager(QObject* parent)
 	: QObject(parent)
 	, _log(Logger::getInstance("DB"))
-	, _readonlyMode (false)
 {
 }
 
-DBManager::~DBManager()
+void DBManager::initializeDatabase(const QDir& dataDirectory, bool isReadOnly)
 {
-}
-
-void DBManager::setRootPath(const QString& rootPath)
-{
-	_rootPath = rootPath;
-	// create directory
-	QDir().mkpath(_rootPath+"/db");
+	_dataDirectory = dataDirectory;
+	_databaseDirectory.setPath(_dataDirectory.absoluteFilePath(DATABASE_DIRECTORYNAME));
+	QDir().mkpath(_databaseDirectory.absolutePath());
+	_databaseFile.setFile(_databaseDirectory,DATABASE_FILENAME);
+	_isReadOnly = isReadOnly;
 }
 
 void DBManager::setTable(const QString& table)
@@ -43,38 +53,39 @@ void DBManager::setTable(const QString& table)
 QSqlDatabase DBManager::getDB() const
 {
 	if(_databasePool.hasLocalData())
-		return _databasePool.localData();
-	else
 	{
-		auto db = QSqlDatabase::addDatabase("QSQLITE", QUuid::createUuid().toString());
-		_databasePool.setLocalData(db);
-		db.setDatabaseName(_rootPath+"/db/"+_dbn+".db");
-		if(!db.open())
+		return _databasePool.localData();
+	}
+		auto database = QSqlDatabase::addDatabase("QSQLITE", QUuid::createUuid().toString());
+
+		if (isReadOnly())
 		{
-			Error(_log, "%s", QSTRING_CSTR(db.lastError().text()));
+			database.setConnectOptions("QSQLITE_OPEN_READONLY");
+		}
+		Debug(Logger::getInstance("DB"), "Database is opened in %s mode", _isReadOnly ? "read-only" : "read/write");
+
+		_databasePool.setLocalData(database);
+		database.setDatabaseName(_databaseFile.absoluteFilePath());
+		if(!database.open())
+		{
+			Error(_log, "%s", QSTRING_CSTR(database.lastError().text()));
 			throw std::runtime_error("Failed to open database connection!");
 		}
-		return db;
-	}
+
+		return database;
 }
 
 bool DBManager::createRecord(const VectorPair& conditions, const QVariantMap& columns) const
 {
-	if ( _readonlyMode )
-	{
-		return false;
-	}
-
 	if(recordExists(conditions))
 	{
 		// if there is no column data, return
 		if(columns.isEmpty())
+		{
 			return true;
+		}
 
-		if(!updateRecord(conditions, columns))
-			return false;
-
-		return true;
+		return updateRecord(conditions, columns);
 	}
 
 	QSqlDatabase idb = getDB();
@@ -84,14 +95,15 @@ bool DBManager::createRecord(const VectorPair& conditions, const QVariantMap& co
 	QVariantList cValues;
 	QStringList prep;
 	QStringList placeh;
+
 	// prep merge columns & condition
-	QVariantMap::const_iterator i = columns.constBegin();
-	while (i != columns.constEnd()) {
-		prep.append(i.key());
-		cValues += i.value();
+	QVariantMap::const_iterator columnIter = columns.constBegin();
+	while (columnIter != columns.constEnd()) {
+		prep.append(columnIter.key());
+		cValues += columnIter.value();
 		placeh.append("?");
 
-		++i;
+		++columnIter;
 	}
 	for(const auto& pair : conditions)
 	{
@@ -101,21 +113,19 @@ bool DBManager::createRecord(const VectorPair& conditions, const QVariantMap& co
 		cValues << pair.second;
 		placeh.append("?");
 	}
-	query.prepare(QString("INSERT INTO %1 ( %2 ) VALUES ( %3 )").arg(_table,prep.join(", ")).arg(placeh.join(", ")));
+	query.prepare(QString("INSERT INTO %1 ( %2 ) VALUES ( %3 )").arg(_table,prep.join(", "), placeh.join(", ")));
 	// add column & condition values
-	doAddBindValue(query, cValues);
-	if(!query.exec())
-	{
-		Error(_log, "Failed to create record: '%s' in table: '%s' Error: %s", QSTRING_CSTR(prep.join(", ")), QSTRING_CSTR(_table), QSTRING_CSTR(idb.lastError().text()));
-		return false;
-	}
-	return true;
+	addBindValues(query, cValues);
+
+	return executeQuery(query);
 }
 
 bool DBManager::recordExists(const VectorPair& conditions) const
 {
 	if(conditions.isEmpty())
+	{
 		return false;
+	}
 
 	QSqlDatabase idb = getDB();
 	QSqlQuery query(idb);
@@ -127,35 +137,28 @@ bool DBManager::recordExists(const VectorPair& conditions) const
 
 	for(const auto& pair : conditions)
 	{
-		prepCond << pair.first+"=?";
+		prepCond << pair.first+"= ?";
 		bindVal << pair.second;
 	}
 	query.prepare(QString("SELECT * FROM %1 %2").arg(_table,prepCond.join(" ")));
-	doAddBindValue(query, bindVal);
-	if(!query.exec())
+	addBindValues(query, bindVal);
+
+	if (!executeQuery(query))
 	{
-		Error(_log, "Failed recordExists(): '%s' in table: '%s' Error: %s", QSTRING_CSTR(prepCond.join(" ")), QSTRING_CSTR(_table), QSTRING_CSTR(idb.lastError().text()));
 		return false;
 	}
 
 	int entry = 0;
-	while (query.next()) {
+	while (query.next())
+	{
 		entry++;
 	}
 
-	if(entry)
-		return true;
-
-	return false;
+	return entry > 0;
 }
 
 bool DBManager::updateRecord(const VectorPair& conditions, const QVariantMap& columns) const
 {
-	if ( _readonlyMode )
-	{
-		return false;
-	}
-
 	QSqlDatabase idb = getDB();
 	QSqlQuery query(idb);
 	query.setForwardOnly(true);
@@ -164,88 +167,75 @@ bool DBManager::updateRecord(const VectorPair& conditions, const QVariantMap& co
 	QStringList prep;
 
 	// prepare columns valus
-	QVariantMap::const_iterator i = columns.constBegin();
-	while (i != columns.constEnd()) {
-		prep += i.key()+"=?";
-		values += i.value();
+	QVariantMap::const_iterator columnIter = columns.constBegin();
+	while (columnIter != columns.constEnd()) {
+		prep += columnIter.key()+"= ?";
+		values += columnIter.value();
 
-		++i;
+		++columnIter;
 	}
 
 	// prepare condition values
 	QStringList prepCond;
 	QVariantList prepBindVal;
-	if(!conditions.isEmpty())
+	if(!conditions.isEmpty()) {
 		prepCond << "WHERE";
+	}
 
 	for(const auto& pair : conditions)
 	{
-		prepCond << pair.first+"=?";
+		prepCond << pair.first+"= ?";
 		prepBindVal << pair.second;
 	}
 
-	query.prepare(QString("UPDATE %1 SET %2 %3").arg(_table,prep.join(", ")).arg(prepCond.join(" ")));
+	query.prepare(QString("UPDATE %1 SET %2 %3").arg(_table,prep.join(", "), prepCond.join(" ")));
 	// add column values
-	doAddBindValue(query, values);
+	addBindValues(query, values);
 	// add condition values
-	doAddBindValue(query, prepBindVal);
-	if(!query.exec())
-	{
-		Error(_log, "Failed to update record: '%s' in table: '%s' Error: %s", QSTRING_CSTR(prepCond.join(" ")), QSTRING_CSTR(_table), QSTRING_CSTR(idb.lastError().text()));
-		return false;
-	}
-	return true;
+	addBindValues(query, prepBindVal);
+
+	return executeQuery(query);
 }
 
 bool DBManager::getRecord(const VectorPair& conditions, QVariantMap& results, const QStringList& tColumns, const QStringList& tOrder) const
 {
-	QSqlDatabase idb = getDB();
-	QSqlQuery query(idb);
-	query.setForwardOnly(true);
-
-	QString sColumns("*");
-	if(!tColumns.isEmpty())
-		sColumns = tColumns.join(", ");
-
-	QString sOrder("");
-	if(!tOrder.isEmpty())
-	{
-		sOrder = " ORDER BY ";
-		sOrder.append(tOrder.join(", "));
+	QVector<QVariantMap> resultVector{};
+	bool success = getRecords(conditions, resultVector, tColumns, tOrder);
+	if (success && !resultVector.isEmpty()) {
+		results = resultVector.first();
 	}
-	// prep conditions
-	QStringList prepCond;
-	QVariantList bindVal;
-	if(!conditions.isEmpty())
-		prepCond << " WHERE";
-
-	for(const auto& pair : conditions)
-	{
-		prepCond << pair.first+"=?";
-		bindVal << pair.second;
-	}
-	query.prepare(QString("SELECT %1 FROM %2%3%4").arg(sColumns,_table).arg(prepCond.join(" ")).arg(sOrder));
-	doAddBindValue(query, bindVal);
-
-	if(!query.exec())
-	{
-		Error(_log, "Failed to get record: '%s' in table: '%s' Error: %s", QSTRING_CSTR(prepCond.join(" ")), QSTRING_CSTR(_table), QSTRING_CSTR(idb.lastError().text()));
-		return false;
-	}
-
-	// go to first row
-	query.next();
-
-	QSqlRecord rec = query.record();
-	for(int i = 0; i<rec.count(); i++)
-	{
-		results[rec.fieldName(i)] = rec.value(i);
-	}
-
-	return true;
+	return success;
 }
 
 bool DBManager::getRecords(QVector<QVariantMap>& results, const QStringList& tColumns, const QStringList& tOrder) const
+{
+	return getRecords({}, results, tColumns, tOrder);
+}
+
+bool DBManager::getRecords(const VectorPair& conditions, QVector<QVariantMap>& results, const QStringList& tColumns, const QStringList& tOrder) const
+{
+	// prep conditions
+	QStringList conditionList;
+	QVariantList bindValues;
+
+	for(const auto& pair : conditions)
+	{
+		conditionList << pair.first;
+		if (pair.second.isNull())
+		{
+			conditionList << "IS NULL";
+		}
+		else
+		{
+			conditionList << "= ?";
+			bindValues << pair.second;
+		}
+	}
+
+	return getRecords(conditionList.join((" ")), bindValues, results, tColumns, tOrder);
+}
+
+bool DBManager::getRecords(const QString& condition, const QVariantList& bindValues, QVector<QVariantMap>& results, const QStringList& tColumns, const QStringList& tOrder) const
 {
 	QSqlDatabase idb = getDB();
 	QSqlQuery query(idb);
@@ -253,20 +243,28 @@ bool DBManager::getRecords(QVector<QVariantMap>& results, const QStringList& tCo
 
 	QString sColumns("*");
 	if(!tColumns.isEmpty())
+	{
 		sColumns = tColumns.join(", ");
+	}
 
 	QString sOrder("");
 	if(!tOrder.isEmpty())
 	{
-		sOrder = " ORDER BY ";
+		sOrder = "ORDER BY ";
 		sOrder.append(tOrder.join(", "));
 	}
 
-	query.prepare(QString("SELECT %1 FROM %2%3").arg(sColumns,_table,sOrder));
-
-	if(!query.exec())
+	// prep conditions
+	QString prepCond;
+	if(!condition.isEmpty())
+	{
+		prepCond = QString("WHERE %1").arg(condition);
+	}
+
+	query.prepare(QString("SELECT %1 FROM %2 %3 %4").arg(sColumns,_table, prepCond, sOrder));
+	addBindValues(query, bindValues);
+	if (!executeQuery(query))
 	{
-		Error(_log, "Failed to get records: '%s' in table: '%s' Error: %s", QSTRING_CSTR(sColumns), QSTRING_CSTR(_table), QSTRING_CSTR(idb.lastError().text()));
 		return false;
 	}
 
@@ -288,11 +286,6 @@ bool DBManager::getRecords(QVector<QVariantMap>& results, const QStringList& tCo
 
 bool DBManager::deleteRecord(const VectorPair& conditions) const
 {
-	if ( _readonlyMode )
-	{
-		return false;
-	}
-
 	if(conditions.isEmpty())
 	{
 		Error(_log, "Oops, a deleteRecord() call wants to delete the entire table (%s)! Denied it", QSTRING_CSTR(_table));
@@ -310,29 +303,20 @@ bool DBManager::deleteRecord(const VectorPair& conditions) const
 
 		for(const auto& pair : conditions)
 		{
-			prepCond << pair.first+"=?";
+			prepCond << pair.first+"= ?";
 			bindValues << pair.second;
 		}
 
 		query.prepare(QString("DELETE FROM %1 %2").arg(_table,prepCond.join(" ")));
-		doAddBindValue(query, bindValues);
-		if(!query.exec())
-		{
-			Error(_log, "Failed to delete record: '%s' in table: '%s' Error: %s", QSTRING_CSTR(prepCond.join(" ")), QSTRING_CSTR(_table), QSTRING_CSTR(idb.lastError().text()));
-			return false;
-		}
-		return true;
+		addBindValues(query, bindValues);
+
+		return executeQuery(query);
 	}
 	return false;
 }
 
 bool DBManager::createTable(QStringList& columns) const
 {
-	if ( _readonlyMode )
-	{
-		return false;
-	}
-
 	if(columns.isEmpty())
 	{
 		Error(_log,"Empty tables aren't supported!");
@@ -347,9 +331,9 @@ bool DBManager::createTable(QStringList& columns) const
 		// empty tables aren't supported by sqlite, add one column
 		QString tcolumn = columns.takeFirst();
 		// default CURRENT_TIMESTAMP is not supported by ALTER TABLE
-		if(!query.exec(QString("CREATE TABLE %1 ( %2 )").arg(_table,tcolumn)))
+		query.prepare(QString("CREATE TABLE %1 ( %2 )").arg(_table,tcolumn));
+		if (!executeQuery(query))
 		{
-			Error(_log, "Failed to create table: '%s' Error: %s", QSTRING_CSTR(_table), QSTRING_CSTR(idb.lastError().text()));
 			return false;
 		}
 	}
@@ -358,8 +342,8 @@ bool DBManager::createTable(QStringList& columns) const
 	int err = 0;
 	for(const auto& column : columns)
 	{
-		QStringList id = column.split(' ');
-		if(rec.indexOf(id.at(0)) == -1)
+		QStringList columName = column.split(' ');
+		if(rec.indexOf(columName.at(0)) == -1)
 		{
 			if(!createColumn(column))
 			{
@@ -367,79 +351,91 @@ bool DBManager::createTable(QStringList& columns) const
 			}
 		}
 	}
-	if(err)
-		return false;
-
-	return true;
+	return err == 0;
 }
 
 bool DBManager::createColumn(const QString& column) const
 {
-	if ( _readonlyMode )
-	{
-		return false;
-	}
-
 	QSqlDatabase idb = getDB();
 	QSqlQuery query(idb);
-	if(!query.exec(QString("ALTER TABLE %1 ADD COLUMN %2").arg(_table,column)))
-	{
-		Error(_log, "Failed to create column: '%s' in table: '%s' Error: %s", QSTRING_CSTR(column), QSTRING_CSTR(_table), QSTRING_CSTR(idb.lastError().text()));
-		return false;
-	}
-	return true;
+
+	query.prepare(QString("ALTER TABLE %1 ADD COLUMN %2").arg(_table,column));
+	return executeQuery(query);
 }
 
 bool DBManager::tableExists(const QString& table) const
 {
 	QSqlDatabase idb = getDB();
 	QStringList tables = idb.tables();
-	if(tables.contains(table))
-		return true;
-	return false;
+	return tables.contains(table);
 }
 
 bool DBManager::deleteTable(const QString& table) const
 {
-	if ( _readonlyMode )
-	{
-		return false;
-	}
-
 	if(tableExists(table))
 	{
 		QSqlDatabase idb = getDB();
 		QSqlQuery query(idb);
-		if(!query.exec(QString("DROP TABLE %1").arg(table)))
-		{
-			Error(_log, "Failed to delete table: '%s' Error: %s", QSTRING_CSTR(table), QSTRING_CSTR(idb.lastError().text()));
-			return false;
-		}
+
+		query.prepare(QString("DROP TABLE %1").arg(table));
+		return executeQuery(query);
 	}
 	return true;
 }
 
-void DBManager::doAddBindValue(QSqlQuery& query, const QVariantList& variants) const
+void DBManager::addBindValues(QSqlQuery& query, const QVariantList& bindValues) const
 {
-	for(const auto& variant : variants)
+	if (!bindValues.isEmpty())
 	{
-		auto t = variant.userType();
-		switch(t)
+		for(const auto& value : bindValues)
 		{
-			case QMetaType::UInt:
-			case QMetaType::Int:
-			case QMetaType::Bool:
-				query.addBindValue(variant.toInt());
-				break;
-			case QMetaType::Double:
-				query.addBindValue(variant.toFloat());
-				break;
-			case QMetaType::QByteArray:
-				query.addBindValue(variant.toByteArray());
-				break;
-			default:
-				query.addBindValue(variant.toString());
-				break;
+			query.addBindValue(value);
 		}
 	}
 }
+
+QString DBManager::constructExecutedQuery(const QSqlQuery& query) const
+{
+	QString executedQuery = query.executedQuery();
+
+	// Check if the query uses positional placeholders
+	if (executedQuery.contains('?')) {
+		QVariantList boundValues = query.boundValues(); // Get bound values as a list
+		// Iterate through the bound values and replace placeholders
+		for (const QVariant &value : boundValues) {
+			// Replace the first occurrence of '?' with the actual value
+			QString valueStr;
+			if (value.canConvert<QString>())
+			{
+				valueStr = value.toString();
+			}
+			else
+			{
+				valueStr = "Unkown";
+			}
+			executedQuery.replace(executedQuery.indexOf('?'), 1, valueStr);
+		}
+	}
+	return executedQuery;
+}
+
+bool DBManager::executeQuery(QSqlQuery& query) const
+{
+	if(!query.exec())
+	{
+		QString finalQuery = constructExecutedQuery(query);
+		QString errorText = query.lastError().text();
+
+		Debug(_log, "Database Error: '%s', SqlQuery: '%s'", QSTRING_CSTR(errorText), QSTRING_CSTR(finalQuery));
+		Error(_log, "Database Error: '%s'", QSTRING_CSTR(errorText));
+
+		return false;
+	}
+
+#ifdef SQLQUERY_LOGGING
+	QString finalQuery = constructExecutedQuery(query);
+	Debug(_log, "SqlQuery executed: '%s'", QSTRING_CSTR(finalQuery));
+#endif
+
+	return true;
+}

libsrc/db/DB_schema/schema-config-exchange.json

@@ -0,0 +1,70 @@
+{
+  "type": "object",
+  "required": true,
+  "properties": {
+	"global": {
+	  "type": "object",
+	  "properties": {
+		"settings": {
+		  "type": "object",
+		  "required": true,
+		  "additionalProperties": {
+			"type": [
+			  "object",
+			  "array"
+			],
+			"properties": {},
+			"additionalProperties": true
+		  }
+		},
+		"uuid": {
+		  "type": "string",
+		  "format": "uuid",
+		  "required": false
+		}
+	  }
+	},
+	"instanceIds": {
+	  "type": "array",
+	  "required": false,
+	  "items": {
+		"type": "integer"
+	  },
+	  "minItems": 1
+	},
+	"instances": {
+	  "type": "array",
+	  "required": false,
+	  "items": {
+		"type": "object",
+		"properties": {
+		  "enabled": {
+			"type": "boolean"
+		  },
+		  "id": {
+			"type": "integer",
+			"minimum": 0,
+			"maximum": 255
+		  },
+		  "name": {
+			"type": "string",
+			"minLength": 5
+		  },
+		  "settings": {
+			"type": "object",
+			"required": true,
+			"additionalProperties": {
+			  "type": [
+				"object",
+				"array"
+			  ],
+			  "properties": {},
+			  "additionalProperties": true
+			}
+		  }
+		}
+	  }
+	}
+  },
+  "additionalProperties": true
+}

libsrc/db/DB_schemas.qrc

@@ -0,0 +1,5 @@
+<RCC>
+	<qresource prefix="/">
+		<file alias="schema-config-exchange">DB_schema/schema-config-exchange.json</file>
+	</qresource>
+</RCC>

libsrc/db/InstanceTable.cpp

@@ -0,0 +1,142 @@
+
+// db
+#include <db/InstanceTable.h>
+#include <db/SettingsTable.h>
+
+// qt
+#include <QDateTime>
+
+InstanceTable::InstanceTable(QObject* parent)
+	: DBManager(parent)
+{
+	// Init instance table
+	setTable("instances");
+	createTable(QStringList()<<"instance INTEGER"<<"friendly_name TEXT"<<"enabled INTEGER DEFAULT 0"<<"last_use TEXT");
+}
+
+bool InstanceTable::createInstance(const QString& name, quint8& inst)
+{
+	// check duplicate
+	if(!recordExists({{"friendly_name", name}}))
+	{
+		QList<quint8> instanceList = getAllInstanceIDs(false);
+
+		inst = 0;
+		while (instanceList.contains(inst))
+		{
+			++inst;
+		}
+
+		// create
+		QVariantMap data;
+		data["friendly_name"] = name;
+		data["instance"] = inst;
+		return createRecord({}, data);
+	}
+
+	return false;
+}
+
+bool InstanceTable::deleteInstance(quint8 inst)
+{
+	Debug(_log,"");
+	if(deleteRecord({{"instance",inst}}))
+	{
+		// delete settings entries
+		SettingsTable settingsTable(inst);
+		settingsTable.deleteInstance();
+		return true;
+	}
+	return false;
+}
+
+bool InstanceTable::saveName(quint8 inst, const QString& name)
+{
+	// check duplicate
+	if(!recordExists({{"friendly_name", name}}))
+	{
+		if(instanceExist(inst))
+		{
+			return updateRecord({{"instance",inst}}, {{"friendly_name", name}});
+		}
+	}
+	return false;
+}
+
+QVector<QVariantMap> InstanceTable::getAllInstances(bool onlyEnabled)
+{
+	QVector<QVariantMap> results;
+
+	VectorPair onlyEnabledCondition {};
+	if (onlyEnabled)
+	{
+		onlyEnabledCondition = {{"enabled", true}};
+	}
+	getRecords(onlyEnabledCondition, results, {}, {"instance ASC"});
+	return results;
+}
+
+QList<quint8> InstanceTable::getAllInstanceIDs (bool onlyEnabled)
+{
+	QVector<QVariantMap> instanceList = getAllInstances(onlyEnabled);
+	QList<quint8> instanceIds;
+	for (const QVariantMap &idx : std::as_const(instanceList))
+	{
+		instanceIds.append(static_cast<quint8>(idx.value("instance").toInt()));
+	}
+
+	return instanceIds;
+}
+
+bool InstanceTable::instanceExist(quint8 inst)
+{
+	return recordExists({{"instance",inst}});
+}
+
+QString InstanceTable::getNamebyIndex(quint8 index)
+{
+	QVariantMap results;
+	getRecord({{"instance", index}}, results, {"friendly_name"});
+
+	QString name = results["friendly_name"].toString();
+	return name.isEmpty() ? "NOT FOUND" : name;
+}
+
+bool InstanceTable::setLastUse(quint8 inst)
+{
+	return updateRecord({{"instance", inst}}, {{"last_use", QDateTime::currentDateTimeUtc().toString(Qt::ISODate)}});
+}
+
+bool InstanceTable::setEnable(quint8 inst, bool newState)
+{
+	return updateRecord({{"instance", inst}}, {{"enabled", newState}});
+}
+
+bool InstanceTable::isEnabled(quint8 inst)
+{
+	QVariantMap results;
+	getRecord({{"instance", inst}}, results);
+
+	return results["enabled"].toBool();
+}
+
+void InstanceTable::createDefaultInstance()
+{
+	if(instanceExist(0))
+	{
+		setEnable(0, true);
+	}
+	else
+	{
+		if(createRecord({{"instance", 0}}, {{"friendly_name", "First LED Hardware instance"}}))
+		{
+			setEnable(0, true);
+		}
+		else
+		{
+			throw std::runtime_error("Failed to create Hyperion root instance in db! This should never be the case...");
+		}
+	}
+}
+
+

libsrc/db/MetaTable.cpp

@@ -0,0 +1,47 @@
+
+#include <db/MetaTable.h>
+
+// qt
+#include <QDateTime>
+#include <QUuid>
+#include <QNetworkInterface>
+#include <QCryptographicHash>
+
+MetaTable::MetaTable(QObject* parent)
+	: DBManager(parent)
+{
+	setTable("meta");
+	createTable(QStringList()<<"uuid TEXT"<<"created_at TEXT");
+};
+
+QString MetaTable::getUUID() const
+{
+	QVector<QVariantMap> results;
+	getRecords(results, QStringList() << "uuid");
+
+	for(const auto & entry : std::as_const(results))
+	{
+		if(!entry["uuid"].toString().isEmpty())
+		{
+			return entry["uuid"].toString();
+		}
+	}
+
+	// create new uuidv5 based on net adapter MAC, save to db and return
+	QString hash;
+	foreach(QNetworkInterface interface, QNetworkInterface::allInterfaces())
+	{
+		if (!(interface.flags() & QNetworkInterface::IsLoopBack))
+		{
+			hash = QCryptographicHash::hash(interface.hardwareAddress().toLocal8Bit(),QCryptographicHash::Sha1).toHex();
+			break;
+		}
+	}
+	const QString newUuid = QUuid::createUuidV5(QUuid(), hash).toString().mid(1, 36);
+	QVariantMap map;
+	map["created_at"] = QDateTime::currentDateTimeUtc().toString(Qt::ISODate);
+
+	createRecord({{"uuid",newUuid}}, map);
+
+	return newUuid;
+}

libsrc/db/SettingsTable.cpp

@@ -0,0 +1,99 @@
+#include <db/SettingsTable.h>
+
+#include <QDateTime>
+#include <QJsonDocument>
+
+SettingsTable::SettingsTable(quint8 instance, QObject* parent)
+	: DBManager(parent)
+	, _hyperion_inst(instance)
+{
+	setTable("settings");
+	// create table columns
+	createTable(QStringList()<<"type TEXT"<<"config TEXT"<<"hyperion_inst INTEGER"<<"updated_at TEXT");
+}
+
+bool SettingsTable::createSettingsRecord(const QString& type, const QString& config) const
+{
+	QVariantMap map;
+	map["config"] = config;
+	map["updated_at"] = QDateTime::currentDateTimeUtc().toString(Qt::ISODate);
+
+	VectorPair cond;
+	cond.append(CPair("type",type));
+	// when a setting is not global we are searching also for the instance
+	if(!isSettingGlobal(type))
+	{
+		cond.append(CPair("AND hyperion_inst",_hyperion_inst));
+	}
+	return createRecord(cond, map);
+}
+
+bool SettingsTable::recordExist(const QString& type) const
+{
+	VectorPair cond;
+	cond.append(CPair("type",type));
+	// when a setting is not global we are searching also for the instance
+	if(!isSettingGlobal(type))
+	{
+		cond.append(CPair("AND hyperion_inst",_hyperion_inst));
+	}
+	return recordExists(cond);
+}
+
+QJsonDocument SettingsTable::getSettingsRecord(const QString& type) const
+{
+	QVariantMap results;
+	VectorPair cond;
+	cond.append(CPair("type",type));
+	// when a setting is not global we are searching also for the instance
+	if(!isSettingGlobal(type))
+	{
+		cond.append(CPair("AND hyperion_inst",_hyperion_inst));
+	}
+	getRecord(cond, results, QStringList("config"));
+	return QJsonDocument::fromJson(results["config"].toByteArray());
+}
+
+QString SettingsTable::getSettingsRecordString(const QString& type) const
+{
+	QVariantMap results;
+	VectorPair cond;
+	cond.append(CPair("type",type));
+	// when a setting is not global we are searching also for the instance
+	if(!isSettingGlobal(type))
+	{
+		cond.append(CPair("AND hyperion_inst",_hyperion_inst));
+	}
+	getRecord(cond, results, QStringList("config"));
+	return results["config"].toString();
+}
+
+void SettingsTable::deleteInstance() const
+{
+	deleteRecord({{"hyperion_inst",_hyperion_inst}});
+}
+
+const QVector<QString>& SettingsTable::getGlobalSettingTypes() {
+	static const QVector<QString> globalSettingTypes = {
+		"jsonServer",
+		"protoServer",
+		"flatbufServer",
+		"forwarder",
+		"webConfig",
+		"network",
+		"framegrabber",
+		"grabberV4L2",
+		"grabberAudio",
+		"osEvents",
+		"cecEvents",
+		"schedEvents",
+		"general",
+		"logger"
+	};
+	return globalSettingTypes;
+}
+
+bool SettingsTable::isSettingGlobal(const QString& type)
+{
+	return getGlobalSettingTypes().contains(type);
+}