Refactor config API

libsrc/hyperion/AuthManager.cpp

@@ -10,10 +10,10 @@
 
 AuthManager *AuthManager::manager = nullptr;
 
-AuthManager::AuthManager(QObject *parent, bool readonlyMode)
+AuthManager::AuthManager(QObject *parent)
 	: QObject(parent)
-	, _authTable(new AuthTable("", this, readonlyMode))
-	, _metaTable(new MetaTable(this, readonlyMode))
+	, _authTable(new AuthTable(this))
+	, _metaTable(new MetaTable(this))
 	, _pendingRequests()
 	, _timer(new QTimer(this))
 	, _authBlockTimer(new QTimer(this))
@@ -209,7 +209,7 @@ QVector<AuthManager::AuthDefinition> AuthManager::getPendingRequests() const
 
 bool AuthManager::renameToken(const QString &id, const QString &comment)
 {
-	if (_authTable->idExist(id))
+	if (_authTable->identifierExist(id))
 	{
 		if (_authTable->renameToken(id, comment))
 		{
@@ -222,7 +222,7 @@ bool AuthManager::renameToken(const QString &id, const QString &comment)
 
 bool AuthManager::deleteToken(const QString &id)
 {
-	if (_authTable->idExist(id))
+	if (_authTable->identifierExist(id))
 	{
 		if (_authTable->deleteToken(id))
 		{

libsrc/hyperion/Hyperion.cpp

@@ -47,10 +47,10 @@
 #include <boblightserver/BoblightServer.h>
 #endif
 
-Hyperion::Hyperion(quint8 instance, bool readonlyMode)
+Hyperion::Hyperion(quint8 instance)
 	: QObject()
 	, _instIndex(instance)
-	, _settingsManager(new SettingsManager(instance, this, readonlyMode))
+	, _settingsManager(new SettingsManager(instance, this))
 	, _componentRegister(nullptr)
 	, _ledString(LedString::createLedString(getSetting(settings::LEDS).array(), hyperion::createColorOrder(getSetting(settings::DEVICE).object())))
 	, _imageProcessor(nullptr)
@@ -73,7 +73,6 @@ Hyperion::Hyperion(quint8 instance, bool readonlyMode)
 #if defined(ENABLE_BOBLIGHT_SERVER)
 	, _boblightServer(nullptr)
 #endif
-	, _readOnlyMode(readonlyMode)
 {
 	qRegisterMetaType<ComponentList>("ComponentList");
 
@@ -320,16 +319,22 @@ QJsonDocument Hyperion::getSetting(settings::type type) const
 	return _settingsManager->getSetting(type);
 }
 
+// TODO: Remove function, if UI is able to handle full configuration
+QJsonObject Hyperion::getQJsonConfig() const
+{
+	const QJsonObject instanceConfig = _settingsManager->getSettings();
+	const QJsonObject globalConfig = _settingsManager->getSettings({},QStringList());
+
+	QVariantMap map = instanceConfig.toVariantMap();
+	map.insert(globalConfig.toVariantMap());
+	return QJsonObject::fromVariantMap(map);
+}
+
 bool Hyperion::saveSettings(const QJsonObject& config, bool correct)
 {
 	return _settingsManager->saveSettings(config, correct);
 }
 
-bool Hyperion::restoreSettings(const QJsonObject& config, bool correct)
-{
-	return _settingsManager->restoreSettings(config, correct);
-}
-
 int Hyperion::getLatchTime() const
 {
 	return _ledDeviceWrapper->getLatchTime();
@@ -597,11 +602,6 @@ int Hyperion::setEffect(const QString &effectName, const QJsonObject &args, int
 }
 #endif
 
-QJsonObject Hyperion::getQJsonConfig() const
-{
-	return _settingsManager->getSettings();
-}
-
 void Hyperion::setLedMappingType(int mappingType)
 {
 	if(mappingType != _imageProcessor->getUserLedMappingType())

libsrc/hyperion/HyperionIManager.cpp

@@ -9,15 +9,14 @@
 
 HyperionIManager* HyperionIManager::HIMinstance;
 
-HyperionIManager::HyperionIManager(const QString& rootPath, QObject* parent, bool readonlyMode)
+HyperionIManager::HyperionIManager(QObject* parent)
 	: QObject(parent)
 	, _log(Logger::getInstance("HYPERION-INSTMGR"))
-	, _instanceTable( new InstanceTable(rootPath, this, readonlyMode) )
-	, _rootPath( rootPath )
-	, _readonlyMode(readonlyMode)
+	, _instanceTable( new InstanceTable())
 {
 	HIMinstance = this;
 	qRegisterMetaType<InstanceState>("InstanceState");
+	_instanceTable->createDefaultInstance();
 }
 
 Hyperion* HyperionIManager::getHyperionInstance(quint8 instance)
@@ -45,14 +44,32 @@ QVector<QVariantMap> HyperionIManager::getInstanceData() const
 	return instances;
 }
 
+QString HyperionIManager::getInstanceName(quint8 inst)
+{
+	return _instanceTable->getNamebyIndex(inst);
+}
+
 QList<quint8> HyperionIManager::getRunningInstanceIdx() const
 {
 	return _runningInstances.keys();
 }
 
+QList<quint8> HyperionIManager::getInstanceIds() const
+{
+	return _instanceTable->getAllInstanceIDs();
+}
+
+
 void HyperionIManager::startAll()
 {
-	for(const auto & entry : _instanceTable->getAllInstances(true))
+	const QVector<QVariantMap> instances = _instanceTable->getAllInstances(true);
+	if (instances.isEmpty())
+	{
+		Error(_log, "No enabled instances found to be started");
+		return;
+	}
+
+	for(const auto & entry : instances)
 	{
 		startInstance(entry["instance"].toInt());
 	}
@@ -62,7 +79,7 @@ void HyperionIManager::stopAll()
 {
 	// copy the instances due to loop corruption, even with .erase() return next iter
 	QMap<quint8, Hyperion*> instCopy = _runningInstances;
-	for(const auto instance : instCopy)
+	for(auto *const instance : instCopy)
 	{
 		instance->stop();
 	}
@@ -131,7 +148,7 @@ bool HyperionIManager::startInstance(quint8 inst, bool block, QObject* caller, i
 		{
 			QThread* hyperionThread = new QThread();
 			hyperionThread->setObjectName("HyperionThread");
-			Hyperion* hyperion = new Hyperion(inst, _readonlyMode);
+			Hyperion* hyperion = new Hyperion(inst);
 			hyperion->moveToThread(hyperionThread);
 			// setup thread management
 			connect(hyperionThread, &QThread::started, hyperion, &Hyperion::start);
@@ -156,7 +173,7 @@ bool HyperionIManager::startInstance(quint8 inst, bool block, QObject* caller, i
 
 			if(block)
 			{
-				while(!hyperionThread->isRunning()){};
+				while(!hyperionThread->isRunning()){}
 			}
 
 			if (!_pendingRequests.contains(inst) && caller != nullptr)
@@ -203,10 +220,10 @@ bool HyperionIManager::stopInstance(quint8 inst)
 
 bool HyperionIManager::createInstance(const QString& name, bool start)
 {
-	quint8 inst;
+	quint8 inst = 0;
 	if(_instanceTable->createInstance(name, inst))
 	{
-		Info(_log,"New Hyperion instance created with name '%s'",QSTRING_CSTR(name));
+		Info(_log,"New Hyperion instance [%d] created with name '%s'", inst, QSTRING_CSTR(name));
 		emit instanceStateChanged(InstanceState::H_CREATED, inst, name);
 		emit change();
 
@@ -221,7 +238,9 @@ bool HyperionIManager::deleteInstance(quint8 inst)
 {
 	// inst 0 can't be deleted
 	if(!isInstAllowed(inst))
+	{
 		return false;
+	}
 
 	// stop it if required as blocking and wait
 	stopInstance(inst);

libsrc/hyperion/SettingsManager.cpp

@@ -12,30 +12,20 @@
 #include <utils/jsonschema/QJsonFactory.h>
 #include <utils/jsonschema/QJsonSchemaChecker.h>
 
-// write config to filesystem
-#include <utils/JsonUtils.h>
-
 #include <utils/version.hpp>
 
 using namespace semver;
 
-// Constants
-namespace {
-	const char DEFAULT_VERSION[] = "2.0.0-alpha.8";
-} //End of constants
-
 QJsonObject SettingsManager::schemaJson;
 
-SettingsManager::SettingsManager(quint8 instance, QObject* parent, bool readonlyMode)
+SettingsManager::SettingsManager(quint8 instance, QObject* parent)
 	: QObject(parent)
 	, _log(Logger::getInstance("SETTINGSMGR", "I" + QString::number(instance)))
 	, _instance(instance)
 	, _sTable(new SettingsTable(instance, this))
 	, _configVersion(DEFAULT_VERSION)
 	, _previousVersion(DEFAULT_VERSION)
-	, _readonlyMode(readonlyMode)
 {
-	_sTable->setReadonlyMode(_readonlyMode);
 	// get schema
 	if (schemaJson.isEmpty())
 	{
@@ -188,26 +178,75 @@ SettingsManager::SettingsManager(quint8 instance, QObject* parent, bool readonly
 
 QJsonDocument SettingsManager::getSetting(settings::type type) const
 {
-	return _sTable->getSettingsRecord(settings::typeToString(type));
+	return getSetting(settings::typeToString(type));
 }
 
-QJsonObject SettingsManager::getSettings() const
+QJsonDocument SettingsManager::getSetting(const QString& type) const
 {
-	QJsonObject config;
-	for (const auto& key : _qconfig.keys())
+	return _sTable->getSettingsRecord(type);
+}
+
+QJsonObject SettingsManager::getSettings(const QStringList& filteredTypes ) const
+{
+	return getSettings(_instance, filteredTypes);
+}
+
+QJsonObject SettingsManager::getSettings(const QVariant& instance, const QStringList& filteredTypes ) const
+{
+	QJsonObject settingsObject;
+	QStringList settingsKeys({ "type", "config" });
+	QString settingsCondition;
+	QVariantList conditionValues;
+
+	if (instance.isNull() )
 	{
-		//Read all records from database to ensure that global settings are read across instances
-		QJsonDocument doc = _sTable->getSettingsRecord(key);
-		if (doc.isArray())
-		{
-			config.insert(key, doc.array());
+		settingsCondition = "hyperion_inst IS NULL";
+	}
+	else
+	{
+		settingsCondition = "hyperion_inst = ?";
+		conditionValues.append(instance);
+	}
+
+	if (!filteredTypes.isEmpty())
+	{
+		QStringList seletedSettingTypes;
+		for (const auto &type : filteredTypes) {
+			seletedSettingTypes << QString("%1=?").arg("type");
+			conditionValues.append(type);
 		}
-		else
+		settingsCondition += QString (" AND (%1)").arg(seletedSettingTypes.join(" OR "));
+	}
+
+	QVector<QVariantMap> settingsList;
+	if (_sTable->getRecords(settingsCondition, conditionValues, settingsList, settingsKeys))
+	{
+		for (const QVariantMap &setting : std::as_const(settingsList))
 		{
-			config.insert(key, doc.object());
+			QString type = setting.value("type").toString();
+			QByteArray configObject = setting.value("config").toByteArray();
+			QJsonDocument jsonDoc = QJsonDocument::fromJson(configObject);
+
+			if (!jsonDoc.isNull())
+			{
+				QJsonValue config;
+
+				if (jsonDoc.isArray())
+				{
+					config = jsonDoc.array();
+				}
+				else if (jsonDoc.isObject())
+				{
+					config = jsonDoc.object();
+				}
+				settingsObject.insert(type, config);
+			} else
+			{
+				qWarning() << "Failed to parse JSON string:" << configObject;
+			}
 		}
 	}
-	return config;
+	return settingsObject;
 }
 
 bool SettingsManager::restoreSettings(QJsonObject config, bool correct)
@@ -299,7 +338,7 @@ inline QString fixVersion(const QString& version)
 	return newVersion;
 }
 
-bool SettingsManager::resolveConfigVersion(QJsonObject& config)
+bool SettingsManager::resolveConfigVersion(const QJsonObject& config)
 {
 	bool isValid = false;
 	if (config.contains("general"))