From 3cbd01c1d254742a4a5d3a5156afee7d1e0fb07c Mon Sep 17 00:00:00 2001 From: Michael Zanetti Date: Sun, 3 Nov 2019 21:24:16 +0100 Subject: [PATCH] drop all pack/unpack methds --- libnymea-core/devices/translator.cpp | 4 + libnymea-core/jsonrpc/actionhandler.cpp | 5 +- libnymea-core/jsonrpc/devicehandler.cpp | 184 ++----- libnymea-core/jsonrpc/devicehandler.h | 19 - libnymea-core/jsonrpc/eventhandler.cpp | 1 - libnymea-core/jsonrpc/ruleshandler.cpp | 482 +------------------ libnymea-core/jsonrpc/ruleshandler.h | 31 +- libnymea-core/jsonrpc/statehandler.cpp | 1 - libnymea-core/logging/logentry.cpp | 5 + libnymea-core/logging/logentry.h | 1 + libnymea-core/ruleengine/rule.cpp | 19 +- libnymea-core/ruleengine/rule.h | 35 +- libnymea-core/ruleengine/ruleaction.cpp | 5 + libnymea-core/ruleengine/ruleaction.h | 1 + libnymea-core/ruleengine/ruleactionparam.cpp | 5 + libnymea-core/ruleengine/ruleactionparam.h | 1 + libnymea-core/ruleengine/stateevaluator.cpp | 11 +- libnymea-core/ruleengine/stateevaluator.h | 28 +- libnymea-core/tagging/tag.cpp | 5 + libnymea-core/tagging/tag.h | 1 + libnymea-core/usermanager/tokeninfo.cpp | 5 + libnymea-core/usermanager/tokeninfo.h | 4 +- libnymea/devices/device.cpp | 4 +- libnymea/devices/device.h | 6 +- libnymea/devices/devicemanager.cpp | 5 +- libnymea/devices/deviceplugin.h | 4 +- libnymea/jsonrpc/jsonhandler.cpp | 284 +++++++---- libnymea/jsonrpc/jsonhandler.h | 103 ++-- libnymea/platform/package.cpp | 5 + libnymea/platform/package.h | 1 + libnymea/platform/repository.cpp | 5 + libnymea/platform/repository.h | 1 + libnymea/time/calendaritem.cpp | 8 +- libnymea/time/calendaritem.h | 3 +- libnymea/time/repeatingoption.cpp | 40 ++ libnymea/time/repeatingoption.h | 25 + libnymea/time/timedescriptor.cpp | 8 +- libnymea/time/timedescriptor.h | 14 +- libnymea/time/timeeventitem.cpp | 5 + libnymea/time/timeeventitem.h | 1 + libnymea/types/actiontype.cpp | 7 +- libnymea/types/actiontype.h | 3 +- libnymea/types/eventdescriptor.cpp | 5 + libnymea/types/eventdescriptor.h | 1 + libnymea/types/eventtype.cpp | 7 +- libnymea/types/eventtype.h | 3 +- libnymea/types/param.cpp | 10 + libnymea/types/param.h | 4 +- libnymea/types/paramdescriptor.cpp | 5 + libnymea/types/paramdescriptor.h | 1 + libnymea/types/paramtype.cpp | 7 +- libnymea/types/paramtype.h | 3 +- libnymea/types/state.cpp | 7 +- libnymea/types/state.h | 3 +- libnymea/types/statedescriptor.h | 5 +- libnymea/types/statetype.cpp | 7 +- libnymea/types/statetype.h | 3 +- libnymea/types/vendor.cpp | 5 + libnymea/types/vendor.h | 3 + tests/auto/devices/testdevices.cpp | 7 +- tests/auto/rules/testrules.cpp | 47 +- tests/auto/timemanager/testtimemanager.cpp | 17 +- tests/scripts/getruledetails.sh | 9 +- tests/scripts/getrules.sh | 8 +- tests/scripts/snoopnotifications.sh | 9 +- tests/testlib/nymeatestbase.cpp | 8 +- 66 files changed, 631 insertions(+), 938 deletions(-) diff --git a/libnymea-core/devices/translator.cpp b/libnymea-core/devices/translator.cpp index 16f2c6b1..f6e38b37 100644 --- a/libnymea-core/devices/translator.cpp +++ b/libnymea-core/devices/translator.cpp @@ -48,6 +48,10 @@ Translator::~Translator() QString Translator::translate(const PluginId &pluginId, const QString &string, const QLocale &locale) { DevicePlugin *plugin = m_deviceManager->plugins().findById(pluginId); + if (!plugin) { + qCWarning(dcDeviceManager()) << "Unable to translate" << string << "Plugin not found"; + return string; + } if (!m_translatorContexts.contains(plugin->pluginId()) || !m_translatorContexts.value(plugin->pluginId()).translators.contains(locale.name())) { loadTranslator(plugin, locale); diff --git a/libnymea-core/jsonrpc/actionhandler.cpp b/libnymea-core/jsonrpc/actionhandler.cpp index 22e721dc..9d63e618 100644 --- a/libnymea-core/jsonrpc/actionhandler.cpp +++ b/libnymea-core/jsonrpc/actionhandler.cpp @@ -33,7 +33,6 @@ */ #include "actionhandler.h" -#include "devicehandler.h" #include "nymeacore.h" #include "devices/devicemanager.h" @@ -105,7 +104,7 @@ JsonReply* ActionHandler::ExecuteAction(const QVariantMap ¶ms) { DeviceId deviceId(params.value("deviceId").toString()); ActionTypeId actionTypeId(params.value("actionTypeId").toString()); - ParamList actionParams = DeviceHandler::unpackParams(params.value("params").toList()); + ParamList actionParams = unpack(params.value("params")); QLocale locale = params.value("locale").toLocale(); Action action(actionTypeId, deviceId); @@ -174,7 +173,7 @@ JsonReply *ActionHandler::ExecuteBrowserItemAction(const QVariantMap ¶ms) DeviceId deviceId = DeviceId(params.value("deviceId").toString()); QString itemId = params.value("itemId").toString(); ActionTypeId actionTypeId = ActionTypeId(params.value("actionTypeId").toString()); - ParamList paramList = DeviceHandler::unpackParams(params.value("params").toList()); + ParamList paramList = unpack(params.value("params")); BrowserItemAction browserItemAction(deviceId, itemId, actionTypeId, paramList); JsonReply *jsonReply = createAsyncReply("ExecuteBrowserItemAction"); diff --git a/libnymea-core/jsonrpc/devicehandler.cpp b/libnymea-core/jsonrpc/devicehandler.cpp index 69e749b1..5fbc2e81 100644 --- a/libnymea-core/jsonrpc/devicehandler.cpp +++ b/libnymea-core/jsonrpc/devicehandler.cpp @@ -90,7 +90,7 @@ DeviceHandler::DeviceHandler(QObject *parent) : // Objects registerObject(); registerObject(); - registerObject(); + registerUncreatableObject(); registerObject(); registerObject(); registerObject(); @@ -98,7 +98,7 @@ DeviceHandler::DeviceHandler(QObject *parent) : registerObject(); registerObject(); registerObject(); - registerObject(); + registerUncreatableObject(); // Regsitering browseritem manually for now. Not sure how to deal with the // polymorphism in int (e.g MediaBrowserItem) @@ -409,8 +409,7 @@ JsonReply *DeviceHandler::GetDiscoveredDevices(const QVariantMap ¶ms) const QVariantMap returns; DeviceClassId deviceClassId = DeviceClassId(params.value("deviceClassId").toString()); - - ParamList discoveryParams = unpackParams(params.value("discoveryParams").toList()); + ParamList discoveryParams = unpack(params.value("discoveryParams")); JsonReply *reply = createAsyncReply("GetDiscoveredDevices"); DeviceDiscoveryInfo *info = NymeaCore::instance()->deviceManager()->discoverDevices(deviceClassId, discoveryParams); @@ -476,7 +475,7 @@ JsonReply* DeviceHandler::SetPluginConfiguration(const QVariantMap ¶ms) { QVariantMap returns; PluginId pluginId = PluginId(params.value("pluginId").toString()); - ParamList pluginParams = unpackParams(params.value("configuration").toList()); + ParamList pluginParams = unpack(params.value("configuration")); Device::DeviceError result = NymeaCore::instance()->deviceManager()->setPluginConfig(pluginId, pluginParams); returns.insert("deviceError",enumValueName(result)); return createReply(returns); @@ -486,7 +485,7 @@ JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap ¶ms) { DeviceClassId deviceClassId(params.value("deviceClassId").toString()); QString deviceName = params.value("name").toString(); - ParamList deviceParams = unpackParams(params.value("deviceParams").toList()); + ParamList deviceParams = unpack(params.value("deviceParams")); DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString()); QLocale locale = params.value("locale").toLocale(); @@ -519,7 +518,7 @@ JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap ¶ms) JsonReply *DeviceHandler::PairDevice(const QVariantMap ¶ms) { QString deviceName = params.value("name").toString(); - ParamList deviceParams = unpackParams(params.value("deviceParams").toList()); + ParamList deviceParams = unpack(params.value("deviceParams")); QLocale locale = params.value("locale").toLocale(); DevicePairingInfo *info; @@ -598,11 +597,11 @@ JsonReply* DeviceHandler::GetConfiguredDevices(const QVariantMap ¶ms) const returns.insert("deviceError", enumValueName(Device::DeviceErrorDeviceNotFound)); return createReply(returns); } else { - configuredDeviceList.append(packDevice(device)); + configuredDeviceList.append(pack(device)); } } else { foreach (Device *device, NymeaCore::instance()->deviceManager()->configuredDevices()) { - configuredDeviceList.append(packDevice(device)); + configuredDeviceList.append(pack(device)); } } returns.insert("devices", configuredDeviceList); @@ -612,7 +611,7 @@ JsonReply* DeviceHandler::GetConfiguredDevices(const QVariantMap ¶ms) const JsonReply *DeviceHandler::ReconfigureDevice(const QVariantMap ¶ms) { DeviceId deviceId = DeviceId(params.value("deviceId").toString()); - ParamList deviceParams = unpackParams(params.value("deviceParams").toList()); + ParamList deviceParams = unpack(params.value("deviceParams")); DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString()); QLocale locale = params.value("locale").toLocale(); @@ -692,34 +691,32 @@ JsonReply* DeviceHandler::RemoveConfiguredDevice(const QVariantMap ¶ms) JsonReply *DeviceHandler::SetDeviceSettings(const QVariantMap ¶ms) { DeviceId deviceId = DeviceId(params.value("deviceId").toString()); - ParamList settings = unpackParams(params.value("settings").toList()); + ParamList settings = unpack(params.value("settings")); Device::DeviceError status = NymeaCore::instance()->deviceManager()->setDeviceSettings(deviceId, settings); return createReply(statusToReply(status)); } JsonReply* DeviceHandler::GetEventTypes(const QVariantMap ¶ms) const { - QVariantMap returns; + QLocale locale = params.value("locale").toLocale(); - QVariantList eventList; DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString())); - foreach (const EventType &eventType, deviceClass.eventTypes()) { - eventList.append(packEventType(eventType, deviceClass.pluginId(), params.value("locale").toLocale())); - } - returns.insert("eventTypes", eventList); + DeviceClass translatedDeviceClass = NymeaCore::instance()->deviceManager()->translateDeviceClass(deviceClass, locale); + + QVariantMap returns; + returns.insert("eventTypes", pack(translatedDeviceClass.eventTypes())); return createReply(returns); } JsonReply* DeviceHandler::GetActionTypes(const QVariantMap ¶ms) const { - QVariantMap returns; + QLocale locale = params.value("locale").toLocale(); - QVariantList actionList; DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString())); - foreach (const ActionType &actionType, deviceClass.actionTypes()) { - actionList.append(packActionType(actionType, deviceClass.pluginId(), params.value("locale").toLocale())); - } - returns.insert("actionTypes", actionList); + DeviceClass translatedDeviceClass = NymeaCore::instance()->deviceManager()->translateDeviceClass(deviceClass, locale); + + QVariantMap returns; + returns.insert("actionTypes", pack(translatedDeviceClass.actionTypes())); return createReply(returns); } @@ -727,15 +724,11 @@ JsonReply* DeviceHandler::GetStateTypes(const QVariantMap ¶ms) const { QLocale locale = params.value("locale").toLocale(); - QVariantMap returns; - - QVariantList stateList; DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(DeviceClassId(params.value("deviceClassId").toString())); - foreach (StateType stateType, deviceClass.stateTypes()) { - stateType.setDisplayName(NymeaCore::instance()->deviceManager()->translate(deviceClass.pluginId(), stateType.displayName(), locale)); - stateList.append(pack(stateType)); - } - returns.insert("stateTypes", stateList); + DeviceClass translatedDeviceClass = NymeaCore::instance()->deviceManager()->translateDeviceClass(deviceClass, locale); + + QVariantMap returns; + returns.insert("stateTypes", pack(translatedDeviceClass.stateTypes())); return createReply(returns); } @@ -763,7 +756,7 @@ JsonReply *DeviceHandler::GetStateValues(const QVariantMap ¶ms) const } QVariantMap returns = statusToReply(Device::DeviceErrorNoError); - returns.insert("values", packDeviceStates(device)); + returns.insert("values", pack(device->states())); return createReply(returns); } @@ -811,73 +804,6 @@ JsonReply *DeviceHandler::GetBrowserItem(const QVariantMap ¶ms) const return jsonReply; } -Param DeviceHandler::unpackParam(const QVariantMap ¶m) -{ - if (param.keys().count() == 0) - return Param(); - - ParamTypeId paramTypeId = param.value("paramTypeId").toUuid(); - QVariant value = param.value("value"); - return Param(paramTypeId, value); -} - -ParamList DeviceHandler::unpackParams(const QVariantList ¶ms) -{ - ParamList paramList; - foreach (const QVariant ¶mVariant, params) { - paramList.append(unpackParam(paramVariant.toMap())); - } - - return paramList; -} - -QVariantMap DeviceHandler::packParam(const Param ¶m) -{ - QVariantMap variantMap; - variantMap.insert("paramTypeId", param.paramTypeId().toString()); - variantMap.insert("value", param.value()); - return variantMap; -} - -QVariantList DeviceHandler::packParams(const ParamList ¶mList) -{ - QVariantList ret; - foreach (const Param ¶m, paramList) { - ret << packParam(param); - } - return ret; -} - -QVariantMap DeviceHandler::packDevice(Device *device) -{ - QVariantMap variant; - variant.insert("id", device->id().toString()); - variant.insert("deviceClassId", device->deviceClassId().toString()); - variant.insert("name", device->name()); - variant.insert("params", packParams(device->params())); - variant.insert("settings", packParams(device->settings())); - - if (!device->parentId().isNull()) - variant.insert("parentId", device->parentId().toString()); - - variant.insert("states", packDeviceStates(device)); - variant.insert("setupComplete", device->setupComplete()); - return variant; -} - -QVariantList DeviceHandler::packDeviceStates(Device *device) -{ - DeviceClass deviceClass = NymeaCore::instance()->deviceManager()->findDeviceClass(device->deviceClassId()); - QVariantList stateValues; - foreach (const StateType &stateType, deviceClass.stateTypes()) { - QVariantMap stateValue; - stateValue.insert("stateTypeId", stateType.id().toString()); - stateValue.insert("value", device->stateValue(stateType.id())); - stateValues.append(stateValue); - } - return stateValues; -} - QVariantMap DeviceHandler::packBrowserItem(const BrowserItem &item) { QVariantMap ret; @@ -900,67 +826,13 @@ QVariantMap DeviceHandler::packBrowserItem(const BrowserItem &item) return ret; } -QVariantMap DeviceHandler::packParamType(const ParamType ¶mType, const PluginId &pluginId, const QLocale &locale) const -{ - ParamType translatedParamType = paramType; - translatedParamType.setDisplayName(NymeaCore::instance()->deviceManager()->translate(pluginId, paramType.displayName(), locale)); - return pack(translatedParamType).toMap(); -} - -QVariantMap DeviceHandler::packEventType(const EventType &eventType, const PluginId &pluginId, const QLocale &locale) const -{ - QVariantMap variant; - variant.insert("id", eventType.id().toString()); - variant.insert("name", eventType.name()); - variant.insert("displayName", NymeaCore::instance()->deviceManager()->translate(pluginId, eventType.displayName(), locale)); - variant.insert("index", eventType.index()); - - QVariantList paramTypes; - foreach (const ParamType ¶mType, eventType.paramTypes()) - paramTypes.append(packParamType(paramType, pluginId, locale)); - - variant.insert("paramTypes", paramTypes); - return variant; -} - -QVariantMap DeviceHandler::packActionType(const ActionType &actionType, const PluginId &pluginId, const QLocale &locale) const -{ - QVariantMap variantMap; - variantMap.insert("id", actionType.id().toString()); - variantMap.insert("name", actionType.name()); - variantMap.insert("displayName", NymeaCore::instance()->deviceManager()->translate(pluginId, actionType.displayName(), locale)); - variantMap.insert("index", actionType.index()); - QVariantList paramTypes; - foreach (const ParamType ¶mType, actionType.paramTypes()) - paramTypes.append(packParamType(paramType, pluginId, locale)); - - variantMap.insert("paramTypes", paramTypes); - return variantMap; -} - -QVariantList DeviceHandler::packCreateMethods(DeviceClass::CreateMethods createMethods) const -{ - QVariantList ret; - if (createMethods.testFlag(DeviceClass::CreateMethodUser)) - ret << "CreateMethodUser"; - - if (createMethods.testFlag(DeviceClass::CreateMethodAuto)) - ret << "CreateMethodAuto"; - - if (createMethods.testFlag(DeviceClass::CreateMethodDiscovery)) - ret << "CreateMethodDiscovery"; - - return ret; -} - - void DeviceHandler::pluginConfigChanged(const PluginId &id, const ParamList &config) { QVariantMap params; params.insert("pluginId", id); QVariantList configList; foreach (const Param ¶m, config) { - configList << packParam(param); + configList << pack(param); } params.insert("configuration", configList); emit PluginConfigurationChanged(params); @@ -985,14 +857,14 @@ void DeviceHandler::deviceRemovedNotification(const QUuid &deviceId) void DeviceHandler::deviceAddedNotification(Device *device) { QVariantMap params; - params.insert("device", packDevice(device)); + params.insert("device", pack(device)); emit DeviceAdded(params); } void DeviceHandler::deviceChangedNotification(Device *device) { QVariantMap params; - params.insert("device", packDevice(device)); + params.insert("device", pack(device)); emit DeviceChanged(params); } diff --git a/libnymea-core/jsonrpc/devicehandler.h b/libnymea-core/jsonrpc/devicehandler.h index 07dbb6c4..fcde2d3c 100644 --- a/libnymea-core/jsonrpc/devicehandler.h +++ b/libnymea-core/jsonrpc/devicehandler.h @@ -60,27 +60,8 @@ public: Q_INVOKABLE JsonReply *BrowseDevice(const QVariantMap ¶ms) const; Q_INVOKABLE JsonReply *GetBrowserItem(const QVariantMap ¶ms) const; - QVariantMap packParamType(const ParamType ¶mType, const PluginId &pluginId, const QLocale &locale) const; -// QVariantMap packPlugin(DevicePlugin *plugin, const QLocale &locale) const; - QVariantMap packEventType(const EventType &eventType, const PluginId &pluginId, const QLocale &locale) const; -// QVariantMap packStateType(const StateType &stateType, const PluginId &pluginId, const QLocale &locale) const; - QVariantMap packActionType(const ActionType &actionType, const PluginId &pluginId, const QLocale &locale) const; - QVariantList packCreateMethods(DeviceClass::CreateMethods createMethods) const; -// QVariantMap packDeviceClass(const DeviceClass &deviceClass, const QLocale &locale) const; - QVariantMap packDeviceDescriptor(const DeviceDescriptor &descriptor) const; - - static QVariantMap packParam(const Param ¶m); - static QVariantList packParams(const ParamList ¶mList); - - static QVariantMap packDevice(Device *device); - static QVariantList packDeviceStates(Device *device); - static QVariantMap packBrowserItem(const BrowserItem &item); - static Param unpackParam(const QVariantMap ¶m); - static ParamList unpackParams(const QVariantList ¶ms); - - signals: void PluginConfigurationChanged(const QVariantMap ¶ms); void StateChanged(const QVariantMap ¶ms); diff --git a/libnymea-core/jsonrpc/eventhandler.cpp b/libnymea-core/jsonrpc/eventhandler.cpp index 7d8fcbfc..283fa26d 100644 --- a/libnymea-core/jsonrpc/eventhandler.cpp +++ b/libnymea-core/jsonrpc/eventhandler.cpp @@ -38,7 +38,6 @@ */ #include "eventhandler.h" -#include "devicehandler.h" #include "nymeacore.h" #include "loggingcategories.h" diff --git a/libnymea-core/jsonrpc/ruleshandler.cpp b/libnymea-core/jsonrpc/ruleshandler.cpp index cd9075c8..12345a65 100644 --- a/libnymea-core/jsonrpc/ruleshandler.cpp +++ b/libnymea-core/jsonrpc/ruleshandler.cpp @@ -58,6 +58,7 @@ #include "loggingcategories.h" #include +#include namespace nymeaserver { @@ -245,13 +246,14 @@ JsonReply *RulesHandler::GetRuleDetails(const QVariantMap ¶ms) } QVariantMap returns; returns.insert("ruleError", enumValueName(RuleEngine::RuleErrorNoError)); - returns.insert("rule", packRule(rule)); + returns.insert("rule", pack(rule)); return createReply(returns); } JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) { - Rule rule = unpackRule(params); + Rule rule = unpack(params); + qWarning() << "Unpacked rule" << rule; rule.setId(RuleId::createRuleId()); RuleEngine::RuleError status = NymeaCore::instance()->ruleEngine()->addRule(rule); @@ -265,11 +267,15 @@ JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) JsonReply *RulesHandler::EditRule(const QVariantMap ¶ms) { - Rule rule = unpackRule(params); + Rule rule = unpack(params); + + // FIXME: Edit rule API currently has "ruleId" while the Rule type has "id". Auto unpacking will fail for this property + rule.setId(params.value("ruleId").toUuid()); + RuleEngine::RuleError status = NymeaCore::instance()->ruleEngine()->editRule(rule); QVariantMap returns; if (status == RuleEngine::RuleErrorNoError) { - returns.insert("rule", packRule(NymeaCore::instance()->ruleEngine()->findRule(rule.id()))); + returns.insert("rule", pack(NymeaCore::instance()->ruleEngine()->findRule(rule.id()))); } returns.insert("ruleError", enumValueName(status)); return createReply(returns); @@ -344,7 +350,7 @@ void RulesHandler::ruleRemovedNotification(const RuleId &ruleId) void RulesHandler::ruleAddedNotification(const Rule &rule) { QVariantMap params; - params.insert("rule", packRule(rule)); + params.insert("rule", pack(rule)); emit RuleAdded(params); } @@ -361,7 +367,7 @@ void RulesHandler::ruleActiveChangedNotification(const Rule &rule) void RulesHandler::ruleConfigurationChangedNotification(const Rule &rule) { QVariantMap params; - params.insert("rule", packRule(rule)); + params.insert("rule", pack(rule)); emit RuleConfigurationChanged(params); } @@ -377,468 +383,4 @@ QVariantMap RulesHandler::packRuleDescription(const Rule &rule) return ruleDescriptionMap; } -QVariantMap RulesHandler::packParamDescriptor(const ParamDescriptor ¶mDescriptor) -{ - QVariantMap variantMap; - if (!paramDescriptor.paramTypeId().isNull()) { - variantMap.insert("paramTypeId", paramDescriptor.paramTypeId().toString()); - } else { - variantMap.insert("paramName", paramDescriptor.paramName()); - } - variantMap.insert("value", paramDescriptor.value()); - variantMap.insert("operator", enumValueName(paramDescriptor.operatorType())); - return variantMap; -} - -QVariantMap RulesHandler::packEventDescriptor(const EventDescriptor &eventDescriptor) -{ - QVariantMap variant; - if (eventDescriptor.type() == EventDescriptor::TypeDevice) { - variant.insert("eventTypeId", eventDescriptor.eventTypeId().toString()); - variant.insert("deviceId", eventDescriptor.deviceId().toString()); - } else { - variant.insert("interface", eventDescriptor.interface()); - variant.insert("interfaceEvent", eventDescriptor.interfaceEvent()); - } - QVariantList params; - foreach (const ParamDescriptor ¶mDescriptor, eventDescriptor.paramDescriptors()) - params.append(packParamDescriptor(paramDescriptor)); - - variant.insert("paramDescriptors", params); - return variant; -} - -QVariantMap RulesHandler::packStateEvaluator(const StateEvaluator &stateEvaluator) -{ - QVariantMap variantMap; - if (stateEvaluator.stateDescriptor().isValid()) - variantMap.insert("stateDescriptor", packStateDescriptor(stateEvaluator.stateDescriptor())); - - QVariantList childEvaluators; - foreach (const StateEvaluator &childEvaluator, stateEvaluator.childEvaluators()) - childEvaluators.append(packStateEvaluator(childEvaluator)); - - if (!childEvaluators.isEmpty() || stateEvaluator.stateDescriptor().isValid()) - variantMap.insert("operator", enumValueName(stateEvaluator.operatorType())); - - if (childEvaluators.count() > 0) - variantMap.insert("childEvaluators", childEvaluators); - - return variantMap; -} - -QVariantMap RulesHandler::packStateDescriptor(const StateDescriptor &stateDescriptor) -{ - QVariantMap variantMap; - if (stateDescriptor.type() == StateDescriptor::TypeDevice) { - variantMap.insert("stateTypeId", stateDescriptor.stateTypeId().toString()); - variantMap.insert("deviceId", stateDescriptor.deviceId().toString()); - } else { - variantMap.insert("interface", stateDescriptor.interface()); - variantMap.insert("interfaceState", stateDescriptor.interfaceState()); - } - variantMap.insert("value", stateDescriptor.stateValue()); - variantMap.insert("operator", enumValueName(stateDescriptor.operatorType())); - return variantMap; -} - -QVariantMap RulesHandler::packTimeDescriptor(const TimeDescriptor &timeDescriptor) -{ - QVariantMap timeDescriptorVariant; - - if (!timeDescriptor.calendarItems().isEmpty()) { - QVariantList calendarItems; - foreach (const CalendarItem &calendarItem, timeDescriptor.calendarItems()) - calendarItems.append(packCalendarItem(calendarItem)); - - timeDescriptorVariant.insert("calendarItems", calendarItems); - } - - if (!timeDescriptor.timeEventItems().isEmpty()) { - QVariantList timeEventItems; - foreach (const TimeEventItem &timeEventItem, timeDescriptor.timeEventItems()) - timeEventItems.append(packTimeEventItem(timeEventItem)); - - timeDescriptorVariant.insert("timeEventItems", timeEventItems); - } - - return timeDescriptorVariant; -} - -QVariantMap RulesHandler::packCalendarItem(const CalendarItem &calendarItem) -{ - QVariantMap calendarItemVariant; - calendarItemVariant.insert("duration", calendarItem.duration()); - - if (!calendarItem.dateTime().isNull() && calendarItem.dateTime().toTime_t() != 0) - calendarItemVariant.insert("datetime", calendarItem.dateTime().toTime_t()); - - if (!calendarItem.startTime().isNull()) - calendarItemVariant.insert("startTime", calendarItem.startTime().toString("hh:mm")); - - if (!calendarItem.repeatingOption().isEmtpy()) - calendarItemVariant.insert("repeating", packRepeatingOption(calendarItem.repeatingOption())); - - return calendarItemVariant; -} - -QVariantMap RulesHandler::packRepeatingOption(const RepeatingOption &option) -{ - QVariantMap optionVariant; - optionVariant.insert("mode", enumValueName(option.mode())); - if (!option.weekDays().isEmpty()) { - QVariantList weekDaysVariantList; - foreach (const int& weekDay, option.weekDays()) - weekDaysVariantList.append(QVariant(weekDay)); - - optionVariant.insert("weekDays", weekDaysVariantList); - } - - if (!option.monthDays().isEmpty()) { - QVariantList monthDaysVariantList; - foreach (const int& monthDay, option.monthDays()) - monthDaysVariantList.append(QVariant(monthDay)); - - optionVariant.insert("monthDays", monthDaysVariantList); - } - return optionVariant; -} - -QVariantMap RulesHandler::packTimeEventItem(const TimeEventItem &timeEventItem) -{ - QVariantMap timeEventItemVariant; - - if (!timeEventItem.dateTime().isNull() && timeEventItem.dateTime().toTime_t() != 0) - timeEventItemVariant.insert("datetime", timeEventItem.dateTime().toTime_t()); - - if (!timeEventItem.time().isNull()) - timeEventItemVariant.insert("time", timeEventItem.time().toString("hh:mm")); - - if (!timeEventItem.repeatingOption().isEmtpy()) - timeEventItemVariant.insert("repeating", packRepeatingOption(timeEventItem.repeatingOption())); - - return timeEventItemVariant; -} - -QVariantMap RulesHandler::packRuleActionParam(const RuleActionParam &ruleActionParam) -{ - QVariantMap variantMap; - if (!ruleActionParam.paramTypeId().isNull()) { - variantMap.insert("paramTypeId", ruleActionParam.paramTypeId().toString()); - } else { - variantMap.insert("paramName", ruleActionParam.paramName()); - } - - if (ruleActionParam.isEventBased()) { - variantMap.insert("eventTypeId", ruleActionParam.eventTypeId().toString()); - variantMap.insert("eventParamTypeId", ruleActionParam.eventParamTypeId().toString()); - } else if (ruleActionParam.isStateBased()) { - variantMap.insert("stateDeviceId", ruleActionParam.stateDeviceId().toString()); - variantMap.insert("stateTypeId", ruleActionParam.stateTypeId().toString()); - } else { - variantMap.insert("value", ruleActionParam.value()); - } - return variantMap; -} - -QVariantMap RulesHandler::packRuleAction(const RuleAction &ruleAction) -{ - QVariantMap variant; - if (ruleAction.type() == RuleAction::TypeDevice) { - variant.insert("deviceId", ruleAction.deviceId().toString()); - variant.insert("actionTypeId", ruleAction.actionTypeId().toString()); - } else if (ruleAction.type() == RuleAction::TypeBrowser) { - variant.insert("deviceId", ruleAction.deviceId().toString()); - variant.insert("browserItemId", ruleAction.browserItemId()); - } else { - variant.insert("interface", ruleAction.interface()); - variant.insert("interfaceAction", ruleAction.interfaceAction()); - } - QVariantList params; - foreach (const RuleActionParam &ruleActionParam, ruleAction.ruleActionParams()) - params.append(packRuleActionParam(ruleActionParam)); - - variant.insert("ruleActionParams", params); - return variant; -} - -QVariantMap RulesHandler::packRule(const Rule &rule) -{ - QVariantMap ruleMap; - ruleMap.insert("id", rule.id().toString()); - ruleMap.insert("name", rule.name()); - ruleMap.insert("enabled", rule.enabled()); - ruleMap.insert("active", rule.active()); - ruleMap.insert("executable", rule.executable()); - ruleMap.insert("timeDescriptor", packTimeDescriptor(rule.timeDescriptor())); - - QVariantList eventDescriptorList; - foreach (const EventDescriptor &eventDescriptor, rule.eventDescriptors()) - eventDescriptorList.append(packEventDescriptor(eventDescriptor)); - - ruleMap.insert("eventDescriptors", eventDescriptorList); - ruleMap.insert("stateEvaluator", packStateEvaluator(rule.stateEvaluator())); - - QVariantList actionList; - foreach (const RuleAction &action, rule.actions()) - actionList.append(packRuleAction(action)); - - ruleMap.insert("actions", actionList); - - QVariantList exitActionList; - foreach (const RuleAction &action, rule.exitActions()) - exitActionList.append(packRuleAction(action)); - - ruleMap.insert("exitActions", exitActionList); - return ruleMap; -} - -QList RulesHandler::unpackParamDescriptors(const QVariantList ¶mList) -{ - QList params; - foreach (const QVariant ¶mVariant, paramList) - params.append(unpackParamDescriptor(paramVariant.toMap())); - - return params; -} - -ParamDescriptor RulesHandler::unpackParamDescriptor(const QVariantMap ¶mMap) -{ - QString operatorString = paramMap.value("operator").toString(); - Types::ValueOperator valueOperator = enumNameToValue(operatorString); - - if (paramMap.contains("paramTypeId")) { - ParamDescriptor param = ParamDescriptor(ParamTypeId(paramMap.value("paramTypeId").toString()), paramMap.value("value")); - param.setOperatorType(valueOperator); - return param; - } - ParamDescriptor param = ParamDescriptor(paramMap.value("paramName").toString(), paramMap.value("value")); - param.setOperatorType(valueOperator); - return param; -} - -EventDescriptor RulesHandler::unpackEventDescriptor(const QVariantMap &eventDescriptorMap) -{ - EventTypeId eventTypeId(eventDescriptorMap.value("eventTypeId").toString()); - DeviceId eventDeviceId(eventDescriptorMap.value("deviceId").toString()); - QString interface = eventDescriptorMap.value("interface").toString(); - QString interfaceEvent = eventDescriptorMap.value("interfaceEvent").toString(); - QList eventParams = unpackParamDescriptors(eventDescriptorMap.value("paramDescriptors").toList()); - if (!eventDeviceId.isNull() && !eventTypeId.isNull()) { - return EventDescriptor(eventTypeId, eventDeviceId, eventParams); - } - return EventDescriptor(interface, interfaceEvent, eventParams); -} - -RepeatingOption RulesHandler::unpackRepeatingOption(const QVariantMap &repeatingOptionMap) -{ - RepeatingOption::RepeatingMode mode = enumNameToValue(repeatingOptionMap.value("mode").toString()); - - QList weekDays; - if (repeatingOptionMap.contains("weekDays")) { - foreach (const QVariant weekDayVariant, repeatingOptionMap.value("weekDays").toList()) { - weekDays.append(weekDayVariant.toInt()); - } - } - - QList monthDays; - if (repeatingOptionMap.contains("monthDays")) { - foreach (const QVariant monthDayVariant, repeatingOptionMap.value("monthDays").toList()) { - monthDays.append(monthDayVariant.toInt()); - } - } - - return RepeatingOption(mode, weekDays, monthDays); -} - -CalendarItem RulesHandler::unpackCalendarItem(const QVariantMap &calendarItemMap) -{ - CalendarItem calendarItem; - calendarItem.setDuration(calendarItemMap.value("duration").toUInt()); - - if (calendarItemMap.contains("datetime")) - calendarItem.setDateTime(QDateTime::fromTime_t(calendarItemMap.value("datetime").toUInt())); - - if (calendarItemMap.contains("startTime")) - calendarItem.setStartTime(QTime::fromString(calendarItemMap.value("startTime").toString(), "hh:mm")); - - if (calendarItemMap.contains("repeating")) - calendarItem.setRepeatingOption(unpackRepeatingOption(calendarItemMap.value("repeating").toMap())); - - return calendarItem; -} - -TimeDescriptor RulesHandler::unpackTimeDescriptor(const QVariantMap &timeDescriptorMap) -{ - TimeDescriptor timeDescriptor; - - if (timeDescriptorMap.contains("calendarItems")) { - QList calendarItems; - foreach (const QVariant &calendarItemValiant, timeDescriptorMap.value("calendarItems").toList()) { - calendarItems.append(unpackCalendarItem(calendarItemValiant.toMap())); - } - timeDescriptor.setCalendarItems(calendarItems); - } - - if (timeDescriptorMap.contains("timeEventItems")) { - QList timeEventItems; - foreach (const QVariant &timeEventItemValiant, timeDescriptorMap.value("timeEventItems").toList()) { - timeEventItems.append(unpackTimeEventItem(timeEventItemValiant.toMap())); - } - timeDescriptor.setTimeEventItems(timeEventItems); - } - - return timeDescriptor; -} - -TimeEventItem RulesHandler::unpackTimeEventItem(const QVariantMap &timeEventItemMap) -{ - TimeEventItem timeEventItem; - - if (timeEventItemMap.contains("datetime")) - timeEventItem.setDateTime(QDateTime::fromTime_t(timeEventItemMap.value("datetime").toUInt())); - - if (timeEventItemMap.contains("time")) - timeEventItem.setTime(timeEventItemMap.value("time").toTime()); - - if (timeEventItemMap.contains("repeating")) - timeEventItem.setRepeatingOption(unpackRepeatingOption(timeEventItemMap.value("repeating").toMap())); - - return timeEventItem; -} - -StateDescriptor RulesHandler::unpackStateDescriptor(const QVariantMap &stateDescriptorMap) -{ - StateTypeId stateTypeId(stateDescriptorMap.value("stateTypeId").toString()); - DeviceId deviceId(stateDescriptorMap.value("deviceId").toString()); - QString interface(stateDescriptorMap.value("interface").toString()); - QString interfaceState(stateDescriptorMap.value("interfaceState").toString()); - QVariant value = stateDescriptorMap.value("value"); - Types::ValueOperator operatorType = enumNameToValue(stateDescriptorMap.value("operator").toString()); - if (!deviceId.isNull() && !stateTypeId.isNull()) { - StateDescriptor stateDescriptor(stateTypeId, deviceId, value, operatorType); - return stateDescriptor; - } - StateDescriptor stateDescriptor(interface, interfaceState, value, operatorType); - return stateDescriptor; -} - -StateEvaluator RulesHandler::unpackStateEvaluator(const QVariantMap &stateEvaluatorMap) -{ - StateEvaluator ret(unpackStateDescriptor(stateEvaluatorMap.value("stateDescriptor").toMap())); - if (stateEvaluatorMap.contains("operator")) { - ret.setOperatorType(enumNameToValue(stateEvaluatorMap.value("operator").toString())); - } else { - ret.setOperatorType(Types::StateOperatorAnd); - } - - QList childEvaluators; - foreach (const QVariant &childEvaluator, stateEvaluatorMap.value("childEvaluators").toList()) - childEvaluators.append(unpackStateEvaluator(childEvaluator.toMap())); - - ret.setChildEvaluators(childEvaluators); - return ret; -} - -RuleActionParam RulesHandler::unpackRuleActionParam(const QVariantMap &ruleActionParamMap) -{ - if (ruleActionParamMap.keys().count() == 0) - return RuleActionParam(); - - ParamTypeId paramTypeId = ParamTypeId(ruleActionParamMap.value("paramTypeId").toString()); - QString paramName = ruleActionParamMap.value("paramName").toString(); - - RuleActionParam param; - if (paramTypeId.isNull()) { - param = RuleActionParam(paramName); - } else { - param = RuleActionParam(paramTypeId); - } - param.setValue(ruleActionParamMap.value("value")); - param.setEventTypeId(EventTypeId(ruleActionParamMap.value("eventTypeId").toString())); - param.setEventParamTypeId(ParamTypeId(ruleActionParamMap.value("eventParamTypeId").toString())); - param.setStateDeviceId(DeviceId(ruleActionParamMap.value("stateDeviceId").toString())); - param.setStateTypeId(StateTypeId(ruleActionParamMap.value("stateTypeId").toString())); - return param; -} - -RuleActionParams RulesHandler::unpackRuleActionParams(const QVariantList &ruleActionParamList) -{ - RuleActionParams ruleActionParams; - foreach (const QVariant ¶mVariant, ruleActionParamList) - ruleActionParams.append(unpackRuleActionParam(paramVariant.toMap())); - - return ruleActionParams; -} - -RuleAction RulesHandler::unpackRuleAction(const QVariantMap &ruleActionMap) -{ - ActionTypeId actionTypeId(ruleActionMap.value("actionTypeId").toString()); - DeviceId actionDeviceId(ruleActionMap.value("deviceId").toString()); - QString interface = ruleActionMap.value("interface").toString(); - QString interfaceAction = ruleActionMap.value("interfaceAction").toString(); - QString browserItemId = ruleActionMap.value("browserItemId").toString(); - RuleActionParams actionParamList = unpackRuleActionParams(ruleActionMap.value("ruleActionParams").toList()); - - if (!actionDeviceId.isNull() && !actionTypeId.isNull()) { - return RuleAction(actionTypeId, actionDeviceId, actionParamList); - } else if (!actionDeviceId.isNull() && !browserItemId.isNull()) { - return RuleAction(actionDeviceId, browserItemId); - } - return RuleAction(interface, interfaceAction, actionParamList); -} - -Rule RulesHandler::unpackRule(const QVariantMap &ruleMap) -{ - // The rule id will only be valid if unpacking for edit - RuleId ruleId = RuleId(ruleMap.value("ruleId").toString()); - - QString name = ruleMap.value("name", QString()).toString(); - - // By default enabled - bool enabled = ruleMap.value("enabled", true).toBool(); - - // By default executable - bool executable = ruleMap.value("executable", true).toBool(); - - StateEvaluator stateEvaluator = unpackStateEvaluator(ruleMap.value("stateEvaluator").toMap()); - TimeDescriptor timeDescriptor = unpackTimeDescriptor(ruleMap.value("timeDescriptor").toMap()); - - QList eventDescriptors; - if (ruleMap.contains("eventDescriptors")) { - QVariantList eventDescriptorVariantList = ruleMap.value("eventDescriptors").toList(); - foreach (const QVariant &eventDescriptorVariant, eventDescriptorVariantList) { - eventDescriptors.append(unpackEventDescriptor(eventDescriptorVariant.toMap())); - } - } - - QList actions; - if (ruleMap.contains("actions")) { - QVariantList actionsVariantList = ruleMap.value("actions").toList(); - foreach (const QVariant &actionVariant, actionsVariantList) { - actions.append(unpackRuleAction(actionVariant.toMap())); - } - } - - QList exitActions; - if (ruleMap.contains("exitActions")) { - QVariantList exitActionsVariantList = ruleMap.value("exitActions").toList(); - foreach (const QVariant &exitActionVariant, exitActionsVariantList) { - exitActions.append(unpackRuleAction(exitActionVariant.toMap())); - } - } - - Rule rule; - rule.setId(ruleId); - rule.setName(name); - rule.setTimeDescriptor(timeDescriptor); - rule.setStateEvaluator(stateEvaluator); - rule.setEventDescriptors(eventDescriptors); - rule.setActions(actions); - rule.setExitActions(exitActions); - rule.setEnabled(enabled); - rule.setExecutable(executable); - return rule; -} - } diff --git a/libnymea-core/jsonrpc/ruleshandler.h b/libnymea-core/jsonrpc/ruleshandler.h index 56b25a41..57e42edf 100644 --- a/libnymea-core/jsonrpc/ruleshandler.h +++ b/libnymea-core/jsonrpc/ruleshandler.h @@ -63,36 +63,7 @@ private slots: void ruleConfigurationChangedNotification(const Rule &rule); private: - static QVariantMap packRuleDescription(const Rule &rule); - static QVariantMap packParamDescriptor(const ParamDescriptor ¶mDescriptor); - static QVariantMap packEventDescriptor(const EventDescriptor &eventDescriptor); - static QVariantMap packStateEvaluator(const StateEvaluator &stateEvaluator); - static QVariantMap packStateDescriptor(const StateDescriptor &stateDescriptor); - static QVariantMap packTimeDescriptor(const TimeDescriptor &timeDescriptor); - static QVariantMap packCalendarItem(const CalendarItem &calendarItem); - static QVariantMap packRepeatingOption(const RepeatingOption &option); - static QVariantMap packTimeEventItem(const TimeEventItem &timeEventItem); - static QVariantMap packRuleActionParam(const RuleActionParam &ruleActionParam); - static QVariantMap packRuleAction(const RuleAction &ruleAction); - - static QVariantMap packRule(const Rule &rule); - - static QList unpackParamDescriptors(const QVariantList ¶mList); - static ParamDescriptor unpackParamDescriptor(const QVariantMap ¶mMap); - static EventDescriptor unpackEventDescriptor(const QVariantMap &eventDescriptorMap); - static RepeatingOption unpackRepeatingOption(const QVariantMap &repeatingOptionMap); - static CalendarItem unpackCalendarItem(const QVariantMap &calendarItemMap); - static TimeDescriptor unpackTimeDescriptor(const QVariantMap &timeDescriptorMap); - static TimeEventItem unpackTimeEventItem(const QVariantMap &timeEventItemMap); - static StateDescriptor unpackStateDescriptor(const QVariantMap &stateDescriptorMap); - static StateEvaluator unpackStateEvaluator(const QVariantMap &stateEvaluatorMap); - static RuleActionParam unpackRuleActionParam(const QVariantMap &ruleActionParamMap); - static RuleActionParams unpackRuleActionParams(const QVariantList &ruleActionParamList); - static RuleAction unpackRuleAction(const QVariantMap &ruleActionMap); - - static Rule unpackRule(const QVariantMap &ruleMap); - - + QVariantMap packRuleDescription(const Rule &rule); }; } diff --git a/libnymea-core/jsonrpc/statehandler.cpp b/libnymea-core/jsonrpc/statehandler.cpp index ed103716..07eb1b88 100644 --- a/libnymea-core/jsonrpc/statehandler.cpp +++ b/libnymea-core/jsonrpc/statehandler.cpp @@ -33,7 +33,6 @@ */ #include "statehandler.h" -#include "devicehandler.h" #include "nymeacore.h" #include "loggingcategories.h" diff --git a/libnymea-core/logging/logentry.cpp b/libnymea-core/logging/logentry.cpp index 290952ab..159ee7bc 100644 --- a/libnymea-core/logging/logentry.cpp +++ b/libnymea-core/logging/logentry.cpp @@ -193,4 +193,9 @@ QVariant LogEntries::get(int index) const return QVariant::fromValue(at(index)); } +void LogEntries::put(const QVariant &variant) +{ + append(variant.value()); +} + } diff --git a/libnymea-core/logging/logentry.h b/libnymea-core/logging/logentry.h index 4561aa2c..706175c1 100644 --- a/libnymea-core/logging/logentry.h +++ b/libnymea-core/logging/logentry.h @@ -100,6 +100,7 @@ public: LogEntries(); LogEntries(const QList &other); Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; QDebug operator<<(QDebug dbg, const LogEntry &entry); diff --git a/libnymea-core/ruleengine/rule.cpp b/libnymea-core/ruleengine/rule.cpp index 2e0259a7..8d2b9b46 100644 --- a/libnymea-core/ruleengine/rule.cpp +++ b/libnymea-core/ruleengine/rule.cpp @@ -49,7 +49,7 @@ Rule::Rule(): m_eventDescriptors(QList()), m_actions(QList()), m_exitActions(QList()), - m_enabled(false), + m_enabled(true), m_active(false), m_statesActive(false), m_timeActive(false), @@ -128,37 +128,37 @@ void Rule::setStateEvaluator(const StateEvaluator &stateEvaluator) } /*! Returns the \l{EventDescriptor} for this Rule.*/ -QList Rule::eventDescriptors() const +EventDescriptors Rule::eventDescriptors() const { return m_eventDescriptors; } /*! Sets the \a eventDescriptors of this \l{Rule}. */ -void Rule::setEventDescriptors(const QList &eventDescriptors) +void Rule::setEventDescriptors(const EventDescriptors &eventDescriptors) { m_eventDescriptors = eventDescriptors; } /*! Returns the \l{RuleAction}{RuleActions} to be executed when this Rule is matched and states match. */ -QList Rule::actions() const +RuleActions Rule::actions() const { return m_actions; } /*! Sets the \a actions of this \l{Rule}. */ -void Rule::setActions(const QList actions) +void Rule::setActions(const RuleActions actions) { m_actions = actions; } /*! Returns the \l{RuleAction}{RuleActions} to be executed when this Rule leaves the active state. */ -QList Rule::exitActions() const +RuleActions Rule::exitActions() const { return m_exitActions; } /*! Sets the \a exitActions of this \l{Rule}. */ -void Rule::setExitActions(const QList exitActions) +void Rule::setExitActions(const RuleActions exitActions) { m_exitActions = exitActions; } @@ -265,4 +265,9 @@ QVariant Rules::get(int index) const return QVariant::fromValue(at(index)); } +void Rules::put(const QVariant &variant) +{ + append(variant.value()); +} + } diff --git a/libnymea-core/ruleengine/rule.h b/libnymea-core/ruleengine/rule.h index cb3fbfd4..5759a0ef 100644 --- a/libnymea-core/ruleengine/rule.h +++ b/libnymea-core/ruleengine/rule.h @@ -35,16 +35,16 @@ namespace nymeaserver { class Rule { Q_GADGET - Q_PROPERTY(QUuid id READ id WRITE setId) + Q_PROPERTY(QUuid id READ id WRITE setId USER true) Q_PROPERTY(QString name READ name WRITE setName) - Q_PROPERTY(bool active READ active) - Q_PROPERTY(bool enabled READ enabled WRITE setEnabled) - Q_PROPERTY(bool executable READ executable WRITE setExecutable) - Q_PROPERTY(EventDescriptors eventDescriptors READ eventDescriptors WRITE setEventDescriptors) + Q_PROPERTY(bool active READ active USER true) + Q_PROPERTY(bool enabled READ enabled WRITE setEnabled USER true) + Q_PROPERTY(bool executable READ executable WRITE setExecutable USER true) + Q_PROPERTY(EventDescriptors eventDescriptors READ eventDescriptors WRITE setEventDescriptors USER true) Q_PROPERTY(RuleActions actions READ actions WRITE setActions) - Q_PROPERTY(RuleActions exitActions READ exitActions WRITE setExitActions) - Q_PROPERTY(StateEvaluator stateEvaluator READ stateEvaluator WRITE setStateEvaluator) - Q_PROPERTY(TimeDescriptor timeDescriptor READ timeDescriptor WRITE setTimeDescriptor) + Q_PROPERTY(RuleActions exitActions READ exitActions WRITE setExitActions USER true) + Q_PROPERTY(nymeaserver::StateEvaluator stateEvaluator READ stateEvaluator WRITE setStateEvaluator USER true) + Q_PROPERTY(TimeDescriptor timeDescriptor READ timeDescriptor WRITE setTimeDescriptor USER true) public: Rule(); @@ -65,14 +65,14 @@ public: StateEvaluator stateEvaluator() const; void setStateEvaluator(const StateEvaluator &stateEvaluator); - QList eventDescriptors() const; - void setEventDescriptors(const QList &eventDescriptors); + EventDescriptors eventDescriptors() const; + void setEventDescriptors(const EventDescriptors &eventDescriptors); - QList actions() const; - void setActions(const QList actions); + RuleActions actions() const; + void setActions(const RuleActions actions); - QList exitActions() const; - void setExitActions(const QList exitActions); + RuleActions exitActions() const; + void setExitActions(const RuleActions exitActions); bool enabled() const; void setEnabled(const bool &enabled); @@ -95,9 +95,9 @@ private: QString m_name; TimeDescriptor m_timeDescriptor; StateEvaluator m_stateEvaluator; - QList m_eventDescriptors; - QList m_actions; - QList m_exitActions; + EventDescriptors m_eventDescriptors; + RuleActions m_actions; + RuleActions m_exitActions; bool m_enabled; bool m_active; @@ -114,6 +114,7 @@ public: Rules(); Rules(const QList &other); Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; QDebug operator<<(QDebug dbg, const Rule &rule); diff --git a/libnymea-core/ruleengine/ruleaction.cpp b/libnymea-core/ruleengine/ruleaction.cpp index 5995ed07..a3a53789 100644 --- a/libnymea-core/ruleengine/ruleaction.cpp +++ b/libnymea-core/ruleengine/ruleaction.cpp @@ -300,3 +300,8 @@ QVariant RuleActions::get(int index) const { return QVariant::fromValue(at(index)); } + +void RuleActions::put(const QVariant &variant) +{ + append(variant.value()); +} diff --git a/libnymea-core/ruleengine/ruleaction.h b/libnymea-core/ruleengine/ruleaction.h index f94fe2e8..02a15690 100644 --- a/libnymea-core/ruleengine/ruleaction.h +++ b/libnymea-core/ruleengine/ruleaction.h @@ -102,6 +102,7 @@ public: RuleActions(); RuleActions(const QList &other); Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; Q_DECLARE_METATYPE(RuleActions) diff --git a/libnymea-core/ruleengine/ruleactionparam.cpp b/libnymea-core/ruleengine/ruleactionparam.cpp index 10728861..349a3e41 100644 --- a/libnymea-core/ruleengine/ruleactionparam.cpp +++ b/libnymea-core/ruleengine/ruleactionparam.cpp @@ -312,3 +312,8 @@ QVariant RuleActionParams::get(int index) const { return QVariant::fromValue(at(index)); } + +void RuleActionParams::put(const QVariant &variant) +{ + append(variant.value()); +} diff --git a/libnymea-core/ruleengine/ruleactionparam.h b/libnymea-core/ruleengine/ruleactionparam.h index 5ed19acd..5f1a1407 100644 --- a/libnymea-core/ruleengine/ruleactionparam.h +++ b/libnymea-core/ruleengine/ruleactionparam.h @@ -101,6 +101,7 @@ public: bool hasParam(const ParamTypeId &ruleActionParamTypeId) const; bool hasParam(const QString &ruleActionParamName) const; Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); QVariant paramValue(const ParamTypeId &ruleActionParamName) const; bool setParamValue(const ParamTypeId &ruleActionParamTypeId, const QVariant &value); RuleActionParams operator<<(const RuleActionParam &ruleActionParam); diff --git a/libnymea-core/ruleengine/stateevaluator.cpp b/libnymea-core/ruleengine/stateevaluator.cpp index c6a7f623..677c122d 100644 --- a/libnymea-core/ruleengine/stateevaluator.cpp +++ b/libnymea-core/ruleengine/stateevaluator.cpp @@ -69,13 +69,13 @@ void StateEvaluator::setStateDescriptor(const StateDescriptor &stateDescriptor) } /*! Returns the list of child \l {StateEvaluator}{StateEvaluators} of this \l StateEvaluator. */ -QList StateEvaluator::childEvaluators() const +StateEvaluators StateEvaluator::childEvaluators() const { return m_childEvaluators; } /*! Sets the list of child evaluators of this \l StateEvaluator to the given \a stateEvaluators.*/ -void StateEvaluator::setChildEvaluators(const QList &stateEvaluators) +void StateEvaluator::setChildEvaluators(const StateEvaluators &stateEvaluators) { m_childEvaluators = stateEvaluators; } @@ -389,7 +389,14 @@ StateEvaluators::StateEvaluators(const QList &other): QList()); +} + } diff --git a/libnymea-core/ruleengine/stateevaluator.h b/libnymea-core/ruleengine/stateevaluator.h index 434a22a3..cdb3a596 100644 --- a/libnymea-core/ruleengine/stateevaluator.h +++ b/libnymea-core/ruleengine/stateevaluator.h @@ -30,12 +30,24 @@ class NymeaSettings; namespace nymeaserver { +class StateEvaluator; + +class StateEvaluators: public QList +{ + Q_GADGET + Q_PROPERTY(int count READ count) +public: + StateEvaluators(); + StateEvaluators(const QList &other); + Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); +}; class StateEvaluator { Q_GADGET Q_PROPERTY(StateDescriptor stateDescriptor READ stateDescriptor WRITE setStateDescriptor USER true) - Q_PROPERTY(StateEvaluators childEvaluators READ childEvaluators WRITE setChildEvaluators USER true) + Q_PROPERTY(nymeaserver::StateEvaluators childEvaluators READ childEvaluators WRITE setChildEvaluators USER true) Q_PROPERTY(Types::StateOperator operator READ operatorType WRITE setOperatorType USER true) public: StateEvaluator(const StateDescriptor &stateDescriptor); @@ -44,8 +56,8 @@ public: StateDescriptor stateDescriptor() const; void setStateDescriptor(const StateDescriptor &stateDescriptor); - QList childEvaluators() const; - void setChildEvaluators(const QList &childEvaluators); + StateEvaluators childEvaluators() const; + void setChildEvaluators(const StateEvaluators &childEvaluators); void appendEvaluator(const StateEvaluator &stateEvaluator); Types::StateOperator operatorType() const; @@ -70,19 +82,11 @@ private: Types::StateOperator m_operatorType; }; -class StateEvaluators: public QList -{ - Q_GADGET - Q_PROPERTY(int count READ count) -public: - StateEvaluators(); - StateEvaluators(const QList &other); - Q_INVOKABLE QVariant get(int index) const; -}; QDebug operator<<(QDebug dbg, const StateEvaluator &stateEvaluator); } +Q_DECLARE_METATYPE(nymeaserver::StateEvaluator) Q_DECLARE_METATYPE(nymeaserver::StateEvaluators) #endif // STATEEVALUATOR_H diff --git a/libnymea-core/tagging/tag.cpp b/libnymea-core/tagging/tag.cpp index 68945958..df8b2df8 100644 --- a/libnymea-core/tagging/tag.cpp +++ b/libnymea-core/tagging/tag.cpp @@ -132,4 +132,9 @@ QVariant Tags::get(int index) const return QVariant::fromValue(at(index)); } +void Tags::put(const QVariant &variant) +{ + append(variant.value()); +} + } diff --git a/libnymea-core/tagging/tag.h b/libnymea-core/tagging/tag.h index a58ed1fb..1a201846 100644 --- a/libnymea-core/tagging/tag.h +++ b/libnymea-core/tagging/tag.h @@ -74,6 +74,7 @@ public: Tags(); Tags(const QList &other); Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; QDebug operator<<(QDebug dbg, const Tag &tag); diff --git a/libnymea-core/usermanager/tokeninfo.cpp b/libnymea-core/usermanager/tokeninfo.cpp index 03d04c16..0eb385a8 100644 --- a/libnymea-core/usermanager/tokeninfo.cpp +++ b/libnymea-core/usermanager/tokeninfo.cpp @@ -34,6 +34,11 @@ namespace nymeaserver { +TokenInfo::TokenInfo() +{ + +} + /*! Constructs a new token info with the given \a id, \a username, \a creationTime and \a deviceName. */ TokenInfo::TokenInfo(const QUuid &id, const QString &username, const QDateTime &creationTime, const QString &deviceName): m_id(id), diff --git a/libnymea-core/usermanager/tokeninfo.h b/libnymea-core/usermanager/tokeninfo.h index ccc2b7c6..7e3c73ca 100644 --- a/libnymea-core/usermanager/tokeninfo.h +++ b/libnymea-core/usermanager/tokeninfo.h @@ -23,7 +23,7 @@ #include #include -#include +#include namespace nymeaserver { @@ -36,6 +36,7 @@ class TokenInfo Q_PROPERTY(QString deviveName READ deviceName) public: + TokenInfo(); TokenInfo(const QUuid &id, const QString &username, const QDateTime &creationTime, const QString &deviceName); QUuid id() const; @@ -51,5 +52,6 @@ private: }; } +Q_DECLARE_METATYPE(nymeaserver::TokenInfo) #endif // TOKENINFO_H diff --git a/libnymea/devices/device.cpp b/libnymea/devices/device.cpp index f138181a..a0e2b0b4 100644 --- a/libnymea/devices/device.cpp +++ b/libnymea/devices/device.cpp @@ -271,7 +271,7 @@ void Device::setSettingValue(const ParamTypeId ¶mTypeId, const QVariant &val } /*! Returns the states of this Device. It must match the \l{StateType} description in the associated \l{DeviceClass}. */ -QList Device::states() const +States Device::states() const { return m_states; } @@ -283,7 +283,7 @@ bool Device::hasParam(const ParamTypeId ¶mTypeId) const } /*! Set the \l{State}{States} of this \l{Device} to the given \a states.*/ -void Device::setStates(const QList &states) +void Device::setStates(const States &states) { m_states = states; } diff --git a/libnymea/devices/device.h b/libnymea/devices/device.h index ac24b82b..3ddc64f4 100644 --- a/libnymea/devices/device.h +++ b/libnymea/devices/device.h @@ -106,9 +106,9 @@ public: QVariant setting(const ParamTypeId ¶mTypeId) const; void setSettingValue(const ParamTypeId ¶mTypeId, const QVariant &value); - QList states() const; + States states() const; bool hasState(const StateTypeId &stateTypeId) const; - void setStates(const QList &states); + void setStates(const States &states); QVariant stateValue(const StateTypeId &stateTypeId) const; void setStateValue(const StateTypeId &stateTypeId, const QVariant &value); @@ -144,7 +144,7 @@ private: QString m_name; ParamList m_params; ParamList m_settings; - QList m_states; + States m_states; bool m_setupComplete = false; bool m_autoCreated = false; }; diff --git a/libnymea/devices/devicemanager.cpp b/libnymea/devices/devicemanager.cpp index a2bb77e4..eb2044ca 100644 --- a/libnymea/devices/devicemanager.cpp +++ b/libnymea/devices/devicemanager.cpp @@ -37,5 +37,8 @@ DeviceManager::DeviceManager(QObject *parent) : QObject(parent) { - + qRegisterMetaType(); + qRegisterMetaType(); + qRegisterMetaType(); + qRegisterMetaType(); } diff --git a/libnymea/devices/deviceplugin.h b/libnymea/devices/deviceplugin.h index 0b6726c1..8d485312 100644 --- a/libnymea/devices/deviceplugin.h +++ b/libnymea/devices/deviceplugin.h @@ -55,6 +55,7 @@ #include #include #include +#include class DeviceManager; @@ -140,8 +141,8 @@ private: PluginMetadata m_metaData; ParamList m_config; }; - Q_DECLARE_INTERFACE(DevicePlugin, "io.nymea.DevicePlugin") +Q_DECLARE_METATYPE(DevicePlugin*) class LIBNYMEA_EXPORT DevicePlugins: public QList @@ -151,5 +152,6 @@ public: DevicePlugins(const QList &other); DevicePlugin* findById(const PluginId &id) const; }; +Q_DECLARE_METATYPE(DevicePlugins) #endif // DEVICEPLUGIN_H diff --git a/libnymea/jsonrpc/jsonhandler.cpp b/libnymea/jsonrpc/jsonhandler.cpp index 5de27436..df43d22c 100644 --- a/libnymea/jsonrpc/jsonhandler.cpp +++ b/libnymea/jsonrpc/jsonhandler.cpp @@ -27,6 +27,7 @@ JsonHandler::JsonHandler(QObject *parent) : QObject(parent) { + qRegisterMetaType(); registerEnum(); } @@ -155,13 +156,52 @@ JsonReply *JsonHandler::createAsyncReply(const QString &method) const return JsonReply::createAsyncReply(const_cast(this), method); } +void JsonHandler::registerObject(const QMetaObject &metaObject) +{ + QString className = QString(metaObject.className()).split("::").last(); + QVariantMap description; + for (int i = 0; i < metaObject.propertyCount(); i++) { + QMetaProperty metaProperty = metaObject.property(i); + QString name = metaProperty.name(); + if (name == "objectName") { + continue; // Skip QObject's objectName property + } + if (metaProperty.isUser()) { + name.prepend("o:"); + } + QVariant typeName; + if (metaProperty.type() == QVariant::UserType) { + if (metaProperty.typeName() == QStringLiteral("QVariant::Type")) { + typeName = QString("$ref:BasicType"); + } else if (QString(metaProperty.typeName()).startsWith("QList")) { + QString elementType = QString(metaProperty.typeName()).remove("QList<").remove(">"); + QVariant::Type variantType = QVariant::nameToType(elementType.toUtf8()); + typeName = QVariantList() << enumValueName(variantTypeToBasicType(variantType)); + } else { + typeName = QString("$ref:%1").arg(QString(metaProperty.typeName()).split("::").last()); + } + } else if (metaProperty.isEnumType()) { + typeName = QString("$ref:%1").arg(QString(metaProperty.typeName()).split("::").last()); + } else if (metaProperty.isFlagType()) { + typeName = QVariantList() << "$ref:" + m_flagsEnums.value(metaProperty.name()); + } else if (metaProperty.type() == QVariant::List) { + typeName = QVariantList() << enumValueName(Variant); + } else { + typeName = enumValueName(variantTypeToBasicType(metaProperty.type())); + } + description.insert(name, typeName); + } + m_objects.insert(className, description); + m_metaObjects.insert(className, metaObject); +} + QVariant JsonHandler::pack(const QMetaObject &metaObject, const void *value) const { QString className = QString(metaObject.className()).split("::").last(); if (m_listMetaObjects.contains(className)) { QVariantList ret; QMetaProperty countProperty = metaObject.property(metaObject.indexOfProperty("count")); - QMetaObject entryMetaObject = m_metaObjects.value(m_listEntryTypes.value(metaObject.className())); + QMetaObject entryMetaObject = m_metaObjects.value(m_listEntryTypes.value(className)); int count = countProperty.readOnGadget(value).toInt(); QMetaMethod getMethod = metaObject.method(metaObject.indexOfMethod("get(int)")); for (int i = 0; i < count; i++) { @@ -182,12 +222,18 @@ QVariant JsonHandler::pack(const QMetaObject &metaObject, const void *value) con continue; } + QVariant propertyValue = metaProperty.readOnGadget(value); + // If it's optional and empty, we may skip it + if (metaProperty.isUser() && (!propertyValue.isValid() || propertyValue.isNull())) { + continue; + } + // Pack flags if (metaProperty.isFlagType()) { QString flagName = QString(metaProperty.typeName()).split("::").last(); Q_ASSERT_X(m_metaFlags.contains(flagName), this->metaObject()->className(), QString("Cannot pack %1. %2 is not registered in this handler.").arg(className).arg(flagName).toUtf8()); QMetaEnum metaFlag = m_metaFlags.value(flagName); - int flagValue = metaProperty.readOnGadget(value).toInt(); + int flagValue = propertyValue.toInt(); QStringList flags; for (int i = 0; i < metaFlag.keyCount(); i++) { if ((metaFlag.value(i) & flagValue) > 0) { @@ -203,118 +249,182 @@ QVariant JsonHandler::pack(const QMetaObject &metaObject, const void *value) con QString enumName = QString(metaProperty.typeName()).split("::").last(); Q_ASSERT_X(m_metaEnums.contains(enumName), this->metaObject()->className(), QString("Cannot pack %1. %2 is not registered in this handler.").arg(className).arg(metaProperty.typeName()).toUtf8()); QMetaEnum metaEnum = m_metaEnums.value(enumName); - ret.insert(metaProperty.name(), metaEnum.key(metaProperty.readOnGadget(value).toInt())); + ret.insert(metaProperty.name(), metaEnum.key(propertyValue.toInt())); continue; } // Basic type/Variant type if (metaProperty.typeName() == QStringLiteral("QVariant::Type")) { QMetaEnum metaEnum = QMetaEnum::fromType(); - ret.insert(metaProperty.name(), metaEnum.key(variantTypeToBasicType(metaProperty.readOnGadget(value).template value()))); + ret.insert(metaProperty.name(), metaEnum.key(variantTypeToBasicType(propertyValue.template value()))); continue; } // Our own objects if (metaProperty.type() == QVariant::UserType) { - if (m_listMetaObjects.contains(metaProperty.typeName())) { - QMetaObject entryMetaObject = m_listMetaObjects.value(metaProperty.typeName()); - ret.insert(metaProperty.name(), pack(entryMetaObject, metaProperty.readOnGadget(value).data())); + QString propertyTypeName = QString(metaProperty.typeName()).split("::").last(); + if (m_listMetaObjects.contains(propertyTypeName)) { + QMetaObject entryMetaObject = m_listMetaObjects.value(propertyTypeName); + QVariant packed = pack(entryMetaObject, propertyValue.data()); + if (!metaProperty.isUser() || packed.toList().count() > 0) { + ret.insert(metaProperty.name(), packed); + } continue; } - if (m_metaObjects.contains(metaProperty.typeName())) { - QMetaObject entryMetaObject = m_metaObjects.value(metaProperty.typeName()); - ret.insert(metaProperty.name(), pack(entryMetaObject, metaProperty.readOnGadget(value).data())); + if (m_metaObjects.contains(propertyTypeName)) { + QMetaObject entryMetaObject = m_metaObjects.value(propertyTypeName); + QVariant packed = pack(entryMetaObject, propertyValue.data()); + int isValidIndex = entryMetaObject.indexOfMethod("isValid()"); + bool isValid = true; + if (isValidIndex >= 0) { + QMetaMethod isValidMethod = entryMetaObject.method(isValidIndex); + isValidMethod.invokeOnGadget(propertyValue.data(), Q_RETURN_ARG(bool, isValid)); + } + if (isValid || !metaProperty.isUser()) { + ret.insert(metaProperty.name(), packed); + } continue; } - Q_ASSERT_X(false, this->metaObject()->className(), QString("Unregistered property type: %1").arg(metaProperty.typeName()).toUtf8()); - qCWarning(dcJsonRpc()) << "Cannot pack property of unregistered object type" << metaProperty.typeName(); + // Manually converting QList... Only QVariantList is known to the meta system + if (propertyTypeName.startsWith("QList")) { + qWarning() << "Packing list" << metaProperty.name() << propertyValue.toList(); + QVariantList list; + foreach (int entry, propertyValue.value>()) { + list << entry; + } + if (!list.isEmpty() || !metaProperty.isUser()) { + ret.insert(metaProperty.name(), list); + } + continue; + } + + Q_ASSERT_X(false, this->metaObject()->className(), QString("Unregistered property type: %1").arg(propertyTypeName).toUtf8()); + qCWarning(dcJsonRpc()) << "Cannot pack property of unregistered object type" << propertyTypeName; continue; } - // Standard properties, QString, int etc... If it's not optional, or if it's not empty, pack it up - if (!metaProperty.isUser() || !metaProperty.readOnGadget(value).isNull()) { - QVariant variant = metaProperty.readOnGadget(value); - // Special treatment for QDateTime (converting to time_t) - if (metaProperty.type() == QVariant::DateTime) { - variant = variant.toDateTime().toTime_t(); + // Standard properties, QString, int etc... + // Special treatment for QDateTime (converting to time_t) + if (metaProperty.type() == QVariant::DateTime) { + QDateTime dateTime = propertyValue.toDateTime(); + if (metaProperty.isUser() && dateTime.toTime_t() == 0) { + continue; } - ret.insert(metaProperty.name(), variant); + propertyValue = propertyValue.toDateTime().toTime_t(); + } else if (metaProperty.type() == QVariant::Time) { + propertyValue = propertyValue.toTime().toString("hh:mm"); } + ret.insert(metaProperty.name(), propertyValue); } return ret; } Q_ASSERT_X(false, this->metaObject()->className(), QString("Unregistered object type: %1").arg(className).toUtf8()); qCWarning(dcJsonRpc()) << "Cannot pack object of unregistered type" << className; - return QVariant(); -// QVariantMap ret; -//// qWarning() << "+ Packing" << metaObject.className(); -// for (int i = 0; i < metaObject.propertyCount(); i++) { -// QMetaProperty metaProperty = metaObject.property(i); -// if (metaProperty.name() == QStringLiteral("objectName")) { -// continue; // Skip QObject's objectName property -// } - -// QVariant val = metaProperty.readOnGadget(value); -//// qWarning() << "|- Property:" << metaProperty.name() << metaProperty.readOnGadget(value) << metaProperty.type() << metaProperty.typeName(); -//// qWarning() << "|-- All list types:" << m_listMetaObjects.keys(); -// if (metaProperty.type() == QVariant::UserType) { -// if (metaProperty.typeName() == QStringLiteral("QVariant::Type")) { -// QMetaEnum metaEnum = QMetaEnum::fromType(); -//// qWarning() << "|--" << metaProperty.readOnGadget(value).toInt() << metaEnum.key(metaProperty.readOnGadget(value).toInt()); -// ret.insert(metaProperty.name(), metaEnum.key(variantTypeToBasicType(metaProperty.readOnGadget(value).template value()))); -// } else if (m_listMetaObjects.contains(metaProperty.typeName())) { -// QVariant listObject = metaProperty.readOnGadget(value); -// QMetaObject listMetaObject = m_listMetaObjects.value(metaProperty.typeName()); -// QMetaProperty countProperty = listMetaObject.property(listMetaObject.indexOfProperty("count")); -// int listCount = countProperty.readOnGadget(listObject.constData()).toInt(); -//// qWarning() << "Packing list type" << listObject << "count is" << listCount; -// QMetaMethod metaMethod = listMetaObject.method(listMetaObject.indexOfMethod("get(int)")); -//// qWarning() << "get method" << listMetaObject.indexOfMethod("get(int)") << listMetaObject.method(0).name() << QMetaObject::normalizedSignature("QVariant get(int)"); - -// QMetaObject entryMetaObject = m_metaObjects.value(m_listEntryTypes.value(listMetaObject.className())); -// QVariantList list; -// for (int i = 0; i < listCount; i++) { -// QVariant entry; -// metaMethod.invokeOnGadget(listObject.data(), Q_RETURN_ARG(QVariant, entry), Q_ARG(int, i)); -//// qWarning() << "|---Feckin hell" << entry; - -// list.append(pack(entryMetaObject, entry.data())); -// } - -// ret.insert(metaProperty.name(), list); - - -// } else { -// Q_ASSERT_X(false, this->metaObject()->className(), QString("Cannot pack %1. %2 is not registered in this handler.").arg(metaObject.className()).arg(metaProperty.typeName()).toUtf8()); -// } -// } else if (metaProperty.isFlagType()) { -// QMetaEnum metaFlag = m_metaFlags.value(QString(metaProperty.typeName()).split("::").last()); -//// QMetaEnum metaEnum = m_metaEnums.value(m_flagsEnums.value(metaFlag.name())); -// int flagValue = metaProperty.readOnGadget(value).toInt(); -//// qWarning() << "|-- Flag" << flagValue << metaFlag.name() << metaFlag.keyCount() << metaProperty.type(); -// QStringList flags; -// for (int i = 0; i < metaFlag.keyCount(); i++) { -//// qWarning() << "|--- flag key:" << metaFlag.key(i) << metaFlag.value(i); -// if ((metaFlag.value(i) & flagValue) > 0) { -// flags.append(metaFlag.key(i)); -// } -// } -// ret.insert(metaProperty.name(), flags); -// } else if (metaProperty.isEnumType()) { -// QString enumName = QString(metaProperty.typeName()).split("::").last(); -// Q_ASSERT_X(m_metaEnums.contains(enumName), this->metaObject()->className(), QString("Cannot pack %1. %2 is not registered int this handler.").arg(metaObject.className()).arg(metaProperty.typeName()).toUtf8()); -// QMetaEnum metaEnum = m_metaEnums.value(enumName); -//// qWarning() << "|-- Enum: Name:" << metaEnum.name() << "as int:" << metaEnum.key(metaProperty.readOnGadget(value).toInt()) << "All enums:" << m_metaEnums.keys(); -// ret.insert(metaProperty.name(), metaEnum.key(metaProperty.readOnGadget(value).toInt())); -// } else if (!metaProperty.isUser() || !metaProperty.readOnGadget(value).isNull()) { -//// qWarning() << "|-- property" << metaProperty.name() << metaProperty.readOnGadget(value); -// ret.insert(metaProperty.name(), metaProperty.readOnGadget(value)); -// } -// } -// return ret; - + return QVariant(); } +QVariant JsonHandler::unpack(const QMetaObject &metaObject, const QVariant &value) const +{ + QString typeName = QString(metaObject.className()).split("::").last(); + + // If it's a list object, loop over count + if (m_listMetaObjects.contains(typeName)) { + qWarning() << "** Unpacking" << typeName; + if (value.type() != QVariant::List) { + qCWarning(dcJsonRpc()) << "Cannot unpack" << typeName << ". Value is not in list format:" << value; + return QVariant(); + } + + QVariantList list = value.toList(); + + int typeId = QMetaType::type(metaObject.className()); + void* ptr = QMetaType::create(typeId); + Q_ASSERT_X(typeId != 0, this->metaObject()->className(), QString("Cannot handle unregistered meta type %1").arg(metaObject.className()).toUtf8()); + + QMetaObject entryMetaObject = m_metaObjects.value(m_listEntryTypes.value(typeName)); + QMetaMethod putMethod = metaObject.method(metaObject.indexOfMethod("put(QVariant)")); + + foreach (const QVariant &variant, list) { + QVariant value = unpack(entryMetaObject, variant); + qWarning() << "Putting" << value << putMethod.name() << ptr << typeId; + putMethod.invokeOnGadget(ptr, Q_ARG(QVariant, value)); + } + + QVariant ret = QVariant(typeId, ptr); + QMetaType::destroy(typeId, ptr); + return ret; + } + + // if it's an object, loop over all properties + if (m_metaObjects.contains(typeName)) { + qWarning() << "*** Unpacking" << typeName; + QVariantMap map = value.toMap(); + int typeId = QMetaType::type(metaObject.className()); + Q_ASSERT_X(typeId != 0, this->metaObject()->className(), QString("Cannot handle unregistered meta type %1").arg(typeName).toUtf8()); + void* ptr = QMetaType::create(typeId); + for (int i = 0; i < metaObject.propertyCount(); i++) { + QMetaProperty metaProperty = metaObject.property(i); + if (metaProperty.name() == QStringLiteral("objectName")) { + continue; + } + if (!metaProperty.isWritable()) { + continue; + } + if (!metaProperty.isUser()) { + Q_ASSERT_X(map.contains(metaProperty.name()), this->metaObject()->className(), QString("Missing property %1 in map.").arg(metaProperty.name()).toUtf8()); + } + + if (map.contains(metaProperty.name())) { + + QString propertyTypeName = QString(metaProperty.typeName()).split("::").last(); + QVariant variant = map.value(metaProperty.name()); + + // recurse into child lists + if (m_listMetaObjects.contains(propertyTypeName)) { + QMetaObject propertyMetaObject = m_listMetaObjects.value(propertyTypeName); + qWarning() << "Entering list object" << propertyTypeName << propertyMetaObject.className(); + metaProperty.writeOnGadget(ptr, unpack(propertyMetaObject, variant)); + continue; + } + + // recurse into child objects + if (m_metaObjects.contains(propertyTypeName)) { + QMetaObject propertyMetaObject = m_metaObjects.value(propertyTypeName); + metaProperty.writeOnGadget(ptr, unpack(propertyMetaObject, variant)); + continue; + } + + if (metaProperty.typeName() == QStringLiteral("QList")) { + QList intList; + foreach (const QVariant &val, variant.toList()) { + intList.append(val.toInt()); + } + metaProperty.writeOnGadget(ptr, QVariant::fromValue(intList)); + continue; + } + + // Special treatment for QDateTime (convert from time_t) + if (metaProperty.type() == QVariant::DateTime) { + variant = QDateTime::fromTime_t(variant.toUInt()); + } else if (metaProperty.type() == QVariant::Time) { + variant = QTime::fromString(variant.toString(), "hh:mm"); + } + + // For basic properties just write the veriant as is + metaProperty.writeOnGadget(ptr, variant); + } + + } + QVariant ret = QVariant(typeId, ptr); + QMetaType::destroy(typeId, ptr); + return ret; + } + + return QVariant(); +} + + + diff --git a/libnymea/jsonrpc/jsonhandler.h b/libnymea/jsonrpc/jsonhandler.h index 3d1ee9c4..d4f5fa5f 100644 --- a/libnymea/jsonrpc/jsonhandler.h +++ b/libnymea/jsonrpc/jsonhandler.h @@ -72,13 +72,16 @@ public: static QVariant::Type basicTypeToVariantType(BasicType basicType); template QVariant pack(const T &value) const; - template T unpack(const QVariantMap &map) const; + template QVariant pack(T *value) const; + template T unpack(const QVariant &value) const; protected: template void registerEnum(); template void registerEnum(); template void registerObject(); + template void registerUncreatableObject(); template void registerObject(); + template void registerList(BasicTypeName typeName); void registerObject(const QString &name, const QVariantMap &object); void registerMethod(const QString &name, const QString &description, const QVariantMap ¶ms, const QVariantMap &returns, bool deprecated = false); void registerNotification(const QString &name, const QString &description, const QVariantMap ¶ms, bool deprecated = false); @@ -87,7 +90,11 @@ protected: JsonReply *createAsyncReply(const QString &method) const; private: + + void registerObject(const QMetaObject &metaObject); + QVariant pack(const QMetaObject &metaObject, const void *gadget) const; + QVariant unpack(const QMetaObject &metaObject, const QVariant &value) const; private: QVariantMap m_enums; @@ -130,50 +137,23 @@ void JsonHandler::registerEnum() template void JsonHandler::registerObject() { - qRegisterMetaType(); + qRegisterMetaType(); QMetaObject metaObject = ObjectType::staticMetaObject; - QString className = QString(metaObject.className()).split("::").last(); - QVariantMap description; - for (int i = 0; i < metaObject.propertyCount(); i++) { - QMetaProperty metaProperty = metaObject.property(i); - QString name = metaProperty.name(); - if (name == "objectName") { - continue; // Skip QObject's objectName property - } - if (metaProperty.isUser()) { - name.prepend("o:"); - } - QVariant typeName; -// qWarning() << ".-.-.-.-.-" << metaProperty.name() << metaProperty.type() << metaProperty.typeName(); - if (metaProperty.type() == QVariant::UserType) { - if (metaProperty.typeName() == QStringLiteral("QVariant::Type")) { - typeName = QString("$ref:BasicType"); - } else if (QString(metaProperty.typeName()).startsWith("QList")) { - QString elementType = QString(metaProperty.typeName()).remove("QList<").remove(">"); - QVariant::Type variantType = QVariant::nameToType(elementType.toUtf8()); - typeName = QVariantList() << enumValueName(variantTypeToBasicType(variantType)); - } else { - typeName = QString("$ref:%1").arg(QString(metaProperty.typeName()).split("::").last()); - } - } else if (metaProperty.isEnumType()) { - typeName = QString("$ref:%1").arg(QString(metaProperty.typeName()).split("::").last()); - } else if (metaProperty.isFlagType()) { - typeName = QVariantList() << "$ref:" + m_flagsEnums.value(metaProperty.name()); - } else if (metaProperty.type() == QVariant::List) { - typeName = QVariantList() << enumValueName(Variant); - } else { - typeName = enumValueName(variantTypeToBasicType(metaProperty.type())); - } - description.insert(name, typeName); - } - m_objects.insert(className, description); - m_metaObjects.insert(className, metaObject); + registerObject(metaObject); +} + +template +void JsonHandler::registerUncreatableObject() +{ + QMetaObject metaObject = ObjectType::staticMetaObject; + registerObject(metaObject); } template void JsonHandler::registerObject() { registerObject(); + qRegisterMetaType(); QMetaObject metaObject = ObjectType::staticMetaObject; QMetaObject listMetaObject = ListType::staticMetaObject; QString listTypeName = QString(listMetaObject.className()).split("::").last(); @@ -184,6 +164,19 @@ void JsonHandler::registerObject() m_listEntryTypes.insert(listTypeName, objectTypeName); Q_ASSERT_X(listMetaObject.indexOfProperty("count") >= 0, "JsonHandler", QString("List type %1 does not implement \"count\" property!").arg(listTypeName).toUtf8()); Q_ASSERT_X(listMetaObject.indexOfMethod("get(int)") >= 0, "JsonHandler", QString("List type %1 does not implement \"Q_INVOKABLE QVariant get(int index)\" method!").arg(listTypeName).toUtf8()); + Q_ASSERT_X(listMetaObject.indexOfMethod("put(QVariant)") >= 0, "JsonHandler", QString("List type %1 does not implement \"Q_INVOKABLE void put(QVariant variant)\" method!").arg(listTypeName).toUtf8()); +} + +template +void JsonHandler::registerList(BasicTypeName typeName) +{ + QMetaObject listMetaObject = ListType::staticMetaObject; + QString listTypeName = QString(listMetaObject.className()).split("::").last(); + m_metaObjects.insert(listTypeName, listMetaObject); + m_objects.insert(listTypeName, QVariantList() << QVariant(QString("$ref:%1").arg(enumValueName(typeName)))); + Q_ASSERT_X(listMetaObject.indexOfProperty("count") >= 0, "JsonHandler", QString("List type %1 does not implement \"count\" property!").arg(listTypeName).toUtf8()); + Q_ASSERT_X(listMetaObject.indexOfMethod("get(int)") >= 0, "JsonHandler", QString("List type %1 does not implement \"Q_INVOKABLE QVariant get(int index)\" method!").arg(listTypeName).toUtf8()); + Q_ASSERT_X(listMetaObject.indexOfMethod("put(QVariant)") >= 0, "JsonHandler", QString("List type %1 does not implement \"Q_INVOKABLE void put(QVariant variant)\" method!").arg(listTypeName).toUtf8()); } template @@ -222,33 +215,19 @@ QVariant JsonHandler::pack(const T &value) const } template -T JsonHandler::unpack(const QVariantMap &map) const +QVariant JsonHandler::pack(T *value) const { - T ret; QMetaObject metaObject = T::staticMetaObject; - for (int i = 0; i < metaObject.propertyCount(); i++) { - QMetaProperty metaProperty = metaObject.property(i); - if (metaProperty.name() == QStringLiteral("objectName")) { - continue; - } - if (!metaProperty.isWritable()) { - continue; - } - if (!metaProperty.isUser()) { - Q_ASSERT_X(map.contains(metaProperty.name()), this->metaObject()->className(), QString("Missing property %1 in map.").arg(metaProperty.name()).toUtf8()); - } - if (map.contains(metaProperty.name())) { - // Special treatment for QDateTime (convert from time_t) - QVariant variant = map.value(metaProperty.name()); - if (metaProperty.type() == QVariant::DateTime) { - variant = QDateTime::fromTime_t(variant.toUInt()); - } - metaProperty.writeOnGadget(&ret, variant); - } - } - return ret; + return pack(metaObject, static_cast(value)); +} + +template +T JsonHandler::unpack(const QVariant &value) const +{ + QMetaObject metaObject = T::staticMetaObject; + QVariant ret = unpack(metaObject, value); + return ret.value(); } - #endif // JSONHANDLER_H diff --git a/libnymea/platform/package.cpp b/libnymea/platform/package.cpp index fff64f53..42715acf 100644 --- a/libnymea/platform/package.cpp +++ b/libnymea/platform/package.cpp @@ -144,3 +144,8 @@ QVariant Packages::get(int index) const { return QVariant::fromValue(at(index)); } + +void Packages::put(const QVariant &variant) +{ + append(variant.value()); +} diff --git a/libnymea/platform/package.h b/libnymea/platform/package.h index 9e891008..65453251 100644 --- a/libnymea/platform/package.h +++ b/libnymea/platform/package.h @@ -93,6 +93,7 @@ public: Packages(); Packages(const QList &other); Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; Q_DECLARE_METATYPE(Packages) diff --git a/libnymea/platform/repository.cpp b/libnymea/platform/repository.cpp index d3b1fc5f..ead662f7 100644 --- a/libnymea/platform/repository.cpp +++ b/libnymea/platform/repository.cpp @@ -69,3 +69,8 @@ QVariant Repositories::get(int index) const { return QVariant::fromValue(at(index)); } + +void Repositories::put(const QVariant &variant) +{ + append(variant.value()); +} diff --git a/libnymea/platform/repository.h b/libnymea/platform/repository.h index 798331b5..1ba7d6ca 100644 --- a/libnymea/platform/repository.h +++ b/libnymea/platform/repository.h @@ -57,6 +57,7 @@ public: Repositories(); Repositories(const QList &other); Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; #endif // REPOSITORY_H diff --git a/libnymea/time/calendaritem.cpp b/libnymea/time/calendaritem.cpp index ee39e1ee..3bc1e849 100644 --- a/libnymea/time/calendaritem.cpp +++ b/libnymea/time/calendaritem.cpp @@ -285,7 +285,13 @@ CalendarItems::CalendarItems(const QList &other): QList()); +} diff --git a/libnymea/time/calendaritem.h b/libnymea/time/calendaritem.h index 4d2b5534..a5793fb2 100644 --- a/libnymea/time/calendaritem.h +++ b/libnymea/time/calendaritem.h @@ -74,7 +74,8 @@ class CalendarItems: public QList public: CalendarItems(); CalendarItems(const QList &other); - Q_INVOKABLE QVariant get(int index); + Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; Q_DECLARE_METATYPE(CalendarItems) diff --git a/libnymea/time/repeatingoption.cpp b/libnymea/time/repeatingoption.cpp index 6dea237f..159be676 100644 --- a/libnymea/time/repeatingoption.cpp +++ b/libnymea/time/repeatingoption.cpp @@ -210,3 +210,43 @@ QDebug operator<<(QDebug dbg, const RepeatingOption &repeatingOption) dbg.nospace() << "RepeatingOption(Mode:" << repeatingOption.mode() << ", Monthdays:" << repeatingOption.monthDays() << "Weekdays:" << repeatingOption.weekDays() << ")"; return dbg; } + +WeekDays::WeekDays() +{ + +} + +WeekDays::WeekDays(const QList &other): QList(other) +{ + +} + +QVariant WeekDays::get(int index) const +{ + return at(index); +} + +void WeekDays::put(const QVariant &value) +{ + append(value.toInt()); +} + +MonthDays::MonthDays() +{ + +} + +MonthDays::MonthDays(const QList &other): QList(other) +{ + +} + +QVariant MonthDays::get(int index) const +{ + return at(index); +} + +void MonthDays::put(const QVariant &value) +{ + append(value.toInt()); +} diff --git a/libnymea/time/repeatingoption.h b/libnymea/time/repeatingoption.h index 3af9b6c1..4015b5a7 100644 --- a/libnymea/time/repeatingoption.h +++ b/libnymea/time/repeatingoption.h @@ -23,9 +23,34 @@ #include #include +#include class QDateTime; +class WeekDays: public QList +{ + Q_GADGET + Q_PROPERTY(int count READ count) +public: + WeekDays(); + WeekDays(const QList &other); + Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &value); +}; +Q_DECLARE_METATYPE(WeekDays) + +class MonthDays: public QList +{ + Q_GADGET + Q_PROPERTY(int count READ count) +public: + MonthDays(); + MonthDays(const QList &other); + Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &value); +}; +Q_DECLARE_METATYPE(MonthDays) + class RepeatingOption { Q_GADGET diff --git a/libnymea/time/timedescriptor.cpp b/libnymea/time/timedescriptor.cpp index dda50d2a..45c7b764 100644 --- a/libnymea/time/timedescriptor.cpp +++ b/libnymea/time/timedescriptor.cpp @@ -43,25 +43,25 @@ TimeDescriptor::TimeDescriptor() } /*! Returns the list of \l{TimeEventItem}{TimeEventItems} of this \l{TimeDescriptor}.*/ -QList TimeDescriptor::timeEventItems() const +TimeEventItems TimeDescriptor::timeEventItems() const { return m_timeEventItems; } /*! Set the list of \l{TimeEventItem}{TimeEventItems} of this \l{TimeDescriptor} to the given \a timeEventItems.*/ -void TimeDescriptor::setTimeEventItems(const QList &timeEventItems) +void TimeDescriptor::setTimeEventItems(const TimeEventItems &timeEventItems) { m_timeEventItems = timeEventItems; } /*! Returns the list of \l{CalendarItem}{CalendarItems} of this \l{TimeDescriptor}.*/ -QList TimeDescriptor::calendarItems() const +CalendarItems TimeDescriptor::calendarItems() const { return m_calendarItems; } /*! Set the list of \l{CalendarItem}{CalendarItems} of this \l{TimeDescriptor} to the given \a calendarItems.*/ -void TimeDescriptor::setCalendarItems(const QList &calendarItems) +void TimeDescriptor::setCalendarItems(const CalendarItems &calendarItems) { m_calendarItems = calendarItems; } diff --git a/libnymea/time/timedescriptor.h b/libnymea/time/timedescriptor.h index c7e0b898..78dba4d1 100644 --- a/libnymea/time/timedescriptor.h +++ b/libnymea/time/timedescriptor.h @@ -32,13 +32,13 @@ class TimeDescriptor public: explicit TimeDescriptor(); - QList timeEventItems() const; - void setTimeEventItems(const QList &timeEventItems); + TimeEventItems timeEventItems() const; + void setTimeEventItems(const TimeEventItems &timeEventItems); - QList calendarItems() const; - void setCalendarItems(const QList &calendarItems); + CalendarItems calendarItems() const; + void setCalendarItems(const CalendarItems &calendarItems); - bool isValid() const; + Q_INVOKABLE bool isValid() const; bool isEmpty() const; bool evaluate(const QDateTime &lastEvaluationTime, const QDateTime &dateTime) const; @@ -48,8 +48,8 @@ public: private: - QList m_timeEventItems; - QList m_calendarItems; + TimeEventItems m_timeEventItems; + CalendarItems m_calendarItems; }; diff --git a/libnymea/time/timeeventitem.cpp b/libnymea/time/timeeventitem.cpp index 93c793c9..47bda84c 100644 --- a/libnymea/time/timeeventitem.cpp +++ b/libnymea/time/timeeventitem.cpp @@ -154,3 +154,8 @@ QVariant TimeEventItems::get(int index) const { return QVariant::fromValue(at(index)); } + +void TimeEventItems::put(const QVariant &variant) +{ + append(variant.value()); +} diff --git a/libnymea/time/timeeventitem.h b/libnymea/time/timeeventitem.h index 94d31515..016fb0da 100644 --- a/libnymea/time/timeeventitem.h +++ b/libnymea/time/timeeventitem.h @@ -66,6 +66,7 @@ public: TimeEventItems(); TimeEventItems(const QList &other); Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; Q_DECLARE_METATYPE(TimeEventItems) diff --git a/libnymea/types/actiontype.cpp b/libnymea/types/actiontype.cpp index 94e35701..0f3194d0 100644 --- a/libnymea/types/actiontype.cpp +++ b/libnymea/types/actiontype.cpp @@ -123,11 +123,16 @@ ActionTypes::ActionTypes(const QList &other) } } -QVariant ActionTypes::get(int index) +QVariant ActionTypes::get(int index) const { return QVariant::fromValue(at(index)); } +void ActionTypes::put(const QVariant &variant) +{ + append(variant.value()); +} + ActionType ActionTypes::findByName(const QString &name) { foreach (const ActionType &actionType, *this) { diff --git a/libnymea/types/actiontype.h b/libnymea/types/actiontype.h index 6b03e6b9..5dd44ceb 100644 --- a/libnymea/types/actiontype.h +++ b/libnymea/types/actiontype.h @@ -77,7 +77,8 @@ class ActionTypes: public QList public: ActionTypes() = default; ActionTypes(const QList &other); - Q_INVOKABLE QVariant get(int index); + Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); ActionType findByName(const QString &name); ActionType findById(const ActionTypeId &id); }; diff --git a/libnymea/types/eventdescriptor.cpp b/libnymea/types/eventdescriptor.cpp index 69cbc35d..0c57d8f0 100644 --- a/libnymea/types/eventdescriptor.cpp +++ b/libnymea/types/eventdescriptor.cpp @@ -204,3 +204,8 @@ QVariant EventDescriptors::get(int index) const { return QVariant::fromValue(at(index)); } + +void EventDescriptors::put(const QVariant &variant) +{ + append(variant.value()); +} diff --git a/libnymea/types/eventdescriptor.h b/libnymea/types/eventdescriptor.h index 5d032f39..378c9daa 100644 --- a/libnymea/types/eventdescriptor.h +++ b/libnymea/types/eventdescriptor.h @@ -89,6 +89,7 @@ public: EventDescriptors(); EventDescriptors(const QList &other); Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; Q_DECLARE_METATYPE(EventDescriptors) diff --git a/libnymea/types/eventtype.cpp b/libnymea/types/eventtype.cpp index 9b563736..0241ac43 100644 --- a/libnymea/types/eventtype.cpp +++ b/libnymea/types/eventtype.cpp @@ -128,11 +128,16 @@ EventTypes::EventTypes(const QList &other) } } -QVariant EventTypes::get(int index) +QVariant EventTypes::get(int index) const { return QVariant::fromValue(at(index)); } +void EventTypes::put(const QVariant &variant) +{ + append(variant.value()); +} + EventType EventTypes::findByName(const QString &name) { foreach (const EventType &eventType, *this) { diff --git a/libnymea/types/eventtype.h b/libnymea/types/eventtype.h index fbdb4628..4e4b629c 100644 --- a/libnymea/types/eventtype.h +++ b/libnymea/types/eventtype.h @@ -78,7 +78,8 @@ class EventTypes: public QList public: EventTypes() = default; EventTypes(const QList &other); - Q_INVOKABLE QVariant get(int index); + Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); EventType findByName(const QString &name); EventType findById(const EventTypeId &id); }; diff --git a/libnymea/types/param.cpp b/libnymea/types/param.cpp index 0d3b81aa..7c8f70e1 100644 --- a/libnymea/types/param.cpp +++ b/libnymea/types/param.cpp @@ -48,6 +48,11 @@ ParamTypeId Param::paramTypeId() const return m_paramTypeId; } +void Param::setParamTypeId(const ParamTypeId ¶mTypeId) +{ + m_paramTypeId = paramTypeId; +} + /*! Returns the value of this \l Param. */ QVariant Param::value() const { @@ -114,6 +119,11 @@ QVariant ParamList::get(int index) return QVariant::fromValue(at(index)); } +void ParamList::put(const QVariant &variant) +{ + append(variant.value()); +} + /*! Returns true if this ParamList contains a Param with the given \a paramTypeId. */ bool ParamList::hasParam(const ParamTypeId ¶mTypeId) const { diff --git a/libnymea/types/param.h b/libnymea/types/param.h index 036b1fd2..a37981e4 100644 --- a/libnymea/types/param.h +++ b/libnymea/types/param.h @@ -33,12 +33,13 @@ class LIBNYMEA_EXPORT Param { Q_GADGET - Q_PROPERTY(QUuid paramTypeId READ paramTypeId USER true) + Q_PROPERTY(QUuid paramTypeId READ paramTypeId WRITE setParamTypeId USER true) Q_PROPERTY(QVariant value READ value WRITE setValue) public: Param(const ParamTypeId ¶mTypeId = ParamTypeId(), const QVariant &value = QVariant()); ParamTypeId paramTypeId() const; + void setParamTypeId(const ParamTypeId ¶mTypeId); QVariant value() const; void setValue(const QVariant &value); @@ -61,6 +62,7 @@ public: ParamList(); ParamList(const QList &other); Q_INVOKABLE QVariant get(int index); + Q_INVOKABLE void put(const QVariant &variant); bool hasParam(const ParamTypeId ¶mTypeId) const; QVariant paramValue(const ParamTypeId ¶mTypeId) const; bool setParamValue(const ParamTypeId ¶mTypeId, const QVariant &value); diff --git a/libnymea/types/paramdescriptor.cpp b/libnymea/types/paramdescriptor.cpp index 69679ab4..b8d60cf8 100644 --- a/libnymea/types/paramdescriptor.cpp +++ b/libnymea/types/paramdescriptor.cpp @@ -101,3 +101,8 @@ QVariant ParamDescriptors::get(int index) const { return QVariant::fromValue(at(index)); } + +void ParamDescriptors::put(const QVariant &variant) +{ + append(variant.value()); +} diff --git a/libnymea/types/paramdescriptor.h b/libnymea/types/paramdescriptor.h index ecfcb564..4244bb2a 100644 --- a/libnymea/types/paramdescriptor.h +++ b/libnymea/types/paramdescriptor.h @@ -59,6 +59,7 @@ public: ParamDescriptors(); ParamDescriptors(const QList &other); Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; Q_DECLARE_METATYPE(ParamDescriptors) diff --git a/libnymea/types/paramtype.cpp b/libnymea/types/paramtype.cpp index cb69b88f..05283b9a 100644 --- a/libnymea/types/paramtype.cpp +++ b/libnymea/types/paramtype.cpp @@ -255,11 +255,16 @@ ParamTypes::ParamTypes(const QList &other): QList(other) { } -QVariant ParamTypes::get(int index) +QVariant ParamTypes::get(int index) const { return QVariant::fromValue(at(index)); } +void ParamTypes::put(const QVariant &variant) +{ + append(variant.value()); +} + ParamType ParamTypes::findByName(const QString &name) { foreach (const ParamType ¶mType, *this) { diff --git a/libnymea/types/paramtype.h b/libnymea/types/paramtype.h index 217e4185..cb6d5c37 100644 --- a/libnymea/types/paramtype.h +++ b/libnymea/types/paramtype.h @@ -115,7 +115,8 @@ class ParamTypes: public QList public: ParamTypes() = default; ParamTypes(const QList &other); - Q_INVOKABLE QVariant get(int index); + Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); ParamType findByName(const QString &name); ParamType findById(const ParamTypeId &id); }; diff --git a/libnymea/types/state.cpp b/libnymea/types/state.cpp index e1c3185e..b1e582b1 100644 --- a/libnymea/types/state.cpp +++ b/libnymea/types/state.cpp @@ -108,7 +108,12 @@ States::States(const QList &other): QList(other) } -QVariant States::get(int index) +QVariant States::get(int index) const { return QVariant::fromValue(at(index)); } + +void States::put(const QVariant &variant) +{ + append(variant.value()); +} diff --git a/libnymea/types/state.h b/libnymea/types/state.h index 969323af..d01bfd8e 100644 --- a/libnymea/types/state.h +++ b/libnymea/types/state.h @@ -63,7 +63,8 @@ class States: public QList public: States(); States(const QList &other); - Q_INVOKABLE QVariant get(int index); + Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); }; Q_DECLARE_METATYPE(States) diff --git a/libnymea/types/statedescriptor.h b/libnymea/types/statedescriptor.h index 83f00250..b0022442 100644 --- a/libnymea/types/statedescriptor.h +++ b/libnymea/types/statedescriptor.h @@ -73,7 +73,7 @@ public: Types::ValueOperator operatorType() const; void setOperatorType(Types::ValueOperator opertatorType); - bool isValid() const; + Q_INVOKABLE bool isValid() const; bool operator ==(const StateDescriptor &other) const; @@ -86,8 +86,9 @@ private: QString m_interface; QString m_interfaceState; QVariant m_stateValue; - Types::ValueOperator m_operatorType; + Types::ValueOperator m_operatorType = Types::ValueOperatorEquals; }; +Q_DECLARE_METATYPE(StateDescriptor) QDebug operator<<(QDebug dbg, const StateDescriptor &stateDescriptor); diff --git a/libnymea/types/statetype.cpp b/libnymea/types/statetype.cpp index 6953f6e1..2905bebe 100644 --- a/libnymea/types/statetype.cpp +++ b/libnymea/types/statetype.cpp @@ -198,11 +198,16 @@ StateTypes::StateTypes(const QList &other) } } -QVariant StateTypes::get(int index) +QVariant StateTypes::get(int index) const { return QVariant::fromValue(at(index)); } +void StateTypes::put(const QVariant &variant) +{ + append(variant.value()); +} + StateType StateTypes::findByName(const QString &name) { foreach (const StateType &stateType, *this) { diff --git a/libnymea/types/statetype.h b/libnymea/types/statetype.h index 7a3a0905..a66486eb 100644 --- a/libnymea/types/statetype.h +++ b/libnymea/types/statetype.h @@ -105,7 +105,8 @@ class StateTypes: public QList public: StateTypes() = default; StateTypes(const QList &other); - Q_INVOKABLE QVariant get(int index); + Q_INVOKABLE QVariant get(int index) const; + Q_INVOKABLE void put(const QVariant &variant); StateType findByName(const QString &name); StateType findById(const StateTypeId &id); }; diff --git a/libnymea/types/vendor.cpp b/libnymea/types/vendor.cpp index 1f0faa71..fc0904bd 100644 --- a/libnymea/types/vendor.cpp +++ b/libnymea/types/vendor.cpp @@ -33,6 +33,11 @@ #include "vendor.h" +Vendor::Vendor() +{ + +} + /*! Constructs an Vendor with the given \a id and the given \a name. */ Vendor::Vendor(const VendorId &id, const QString &name): m_id(id), diff --git a/libnymea/types/vendor.h b/libnymea/types/vendor.h index 27010619..08cce26d 100644 --- a/libnymea/types/vendor.h +++ b/libnymea/types/vendor.h @@ -38,6 +38,7 @@ class LIBNYMEA_EXPORT Vendor Q_PROPERTY(QString displayName READ displayName WRITE setDisplayName) public: + Vendor(); Vendor(const VendorId &id, const QString &name = QString()); VendorId id() const; @@ -56,6 +57,7 @@ private: QString m_name; QString m_displayName; }; +Q_DECLARE_METATYPE(Vendor) class LIBNYMEA_EXPORT Vendors: public QList { @@ -65,5 +67,6 @@ public: Vendor findById(const VendorId &vendorId) const; }; +Q_DECLARE_METATYPE(Vendors) #endif // VENDOR_H diff --git a/tests/auto/devices/testdevices.cpp b/tests/auto/devices/testdevices.cpp index 760eb89e..02ee3ea8 100644 --- a/tests/auto/devices/testdevices.cpp +++ b/tests/auto/devices/testdevices.cpp @@ -353,7 +353,10 @@ void TestDevices::addConfiguredDevice_data() QTest::newRow("User, JustAdd, wrong param") << mockDeviceClassId << invalidDeviceParams << true << Device::DeviceErrorInvalidParameter; deviceParams.clear(); deviceParams << httpportParam << fakeparam; - QTest::newRow("USer, JustAdd, additional invalid param") << mockDeviceClassId << deviceParams << Device::DeviceErrorNoError; + QTest::newRow("USer, JustAdd, additional invalid param") << mockDeviceClassId << deviceParams << false << Device::DeviceErrorNoError; + + deviceParams.clear(); deviceParams << httpportParam << fakeparam2; + QTest::newRow("USer, JustAdd, additional param, valid but unused") << mockDeviceClassId << deviceParams << true << Device::DeviceErrorNoError; } @@ -655,8 +658,8 @@ void TestDevices::parentChildDevices() if (deviceMap.value("deviceClassId").toString() == mockChildDeviceClassId.toString()) { if (deviceMap.value("parentId") == parentDeviceId.toString()) { - //qDebug() << QJsonDocument::fromVariant(deviceVariant).toJson(); childDeviceId = DeviceId(deviceMap.value("id").toString()); + break; } } } diff --git a/tests/auto/rules/testrules.cpp b/tests/auto/rules/testrules.cpp index bb3a36f7..82fb41b8 100644 --- a/tests/auto/rules/testrules.cpp +++ b/tests/auto/rules/testrules.cpp @@ -410,23 +410,19 @@ void TestRules::addRemoveRules_data() QVariantMap validActionNoParams; validActionNoParams.insert("actionTypeId", mockWithoutParamsActionTypeId); validActionNoParams.insert("deviceId", m_mockDeviceId); - validActionNoParams.insert("ruleActionParams", QVariantList()); QVariantMap invalidAction; invalidAction.insert("actionTypeId", ActionTypeId("f32c7efb-38b6-4576-a496-c75bbb23132f")); invalidAction.insert("deviceId", m_mockDeviceId); - invalidAction.insert("ruleActionParams", QVariantList()); // RuleExitAction QVariantMap validExitActionNoParams; validExitActionNoParams.insert("actionTypeId", mockWithoutParamsActionTypeId); validExitActionNoParams.insert("deviceId", m_mockDeviceId); - validExitActionNoParams.insert("ruleActionParams", QVariantList()); QVariantMap invalidExitAction; invalidExitAction.insert("actionTypeId", ActionTypeId("f32c7efb-38b6-4576-a496-c75bbb23132f")); invalidExitAction.insert("deviceId", m_mockDeviceId); - invalidExitAction.insert("ruleActionParams", QVariantList()); // StateDescriptor QVariantMap stateDescriptor; @@ -448,7 +444,6 @@ void TestRules::addRemoveRules_data() QVariantMap validEventDescriptor1; validEventDescriptor1.insert("eventTypeId", mockEvent1EventTypeId); validEventDescriptor1.insert("deviceId", m_mockDeviceId); - validEventDescriptor1.insert("paramDescriptors", QVariantList()); QVariantMap validEventDescriptor2; validEventDescriptor2.insert("eventTypeId", mockEvent2EventTypeId); @@ -464,7 +459,6 @@ void TestRules::addRemoveRules_data() QVariantMap validEventDescriptor3; validEventDescriptor3.insert("eventTypeId", mockEvent2EventTypeId); validEventDescriptor3.insert("deviceId", m_mockDeviceId); - validEventDescriptor3.insert("paramDescriptors", QVariantList()); // EventDescriptorList QVariantList eventDescriptorList; @@ -474,7 +468,6 @@ void TestRules::addRemoveRules_data() QVariantMap invalidEventDescriptor; invalidEventDescriptor.insert("eventTypeId", mockEvent1EventTypeId); invalidEventDescriptor.insert("deviceId", DeviceId("2c4825c8-dfb9-4ba4-bd0e-1d827d945d41")); - invalidEventDescriptor.insert("paramDescriptors", QVariantList()); // RuleAction event based QVariantMap validActionEventBased; @@ -617,7 +610,10 @@ void TestRules::addRemoveRules() QVariantList eventDescriptors = rule.value("eventDescriptors").toList(); if (!eventDescriptor.isEmpty()) { QVERIFY2(eventDescriptors.count() == 1, "There should be exactly one eventDescriptor"); - QVERIFY2(eventDescriptors.first().toMap() == eventDescriptor, "Event descriptor doesn't match"); + QVERIFY2(eventDescriptors.first().toMap() == eventDescriptor, + QString("Event descriptor doesn't match:\nExpected: %1\nGot: %2") + .arg(QString(QJsonDocument::fromVariant(eventDescriptor).toJson())) + .arg(QString(QJsonDocument::fromVariant(eventDescriptors.first().toMap()).toJson())).toUtf8()); } else if (eventDescriptorList.isEmpty()){ QVERIFY2(eventDescriptors.count() == eventDescriptorList.count(), QString("There should be exactly %1 eventDescriptor").arg(eventDescriptorList.count()).toLatin1().data()); foreach (const QVariant &eventDescriptorVariant, eventDescriptorList) { @@ -634,7 +630,11 @@ void TestRules::addRemoveRules() } QVariantList replyActions = rule.value("actions").toList(); - QVERIFY2(actions == replyActions, "Actions don't match"); + QVERIFY2(actions == replyActions, + QString("Actions don't match.\nExpected: %1\nGot: %2") + .arg(QString(QJsonDocument::fromVariant(actions).toJson())) + .arg(QString(QJsonDocument::fromVariant(replyActions).toJson())) + .toUtf8()); QVariantList replyExitActions = rule.value("exitActions").toList(); QVERIFY2(exitActions == replyExitActions, "ExitActions don't match"); @@ -655,23 +655,19 @@ void TestRules::editRules_data() QVariantMap validActionNoParams; validActionNoParams.insert("actionTypeId", mockWithoutParamsActionTypeId); validActionNoParams.insert("deviceId", m_mockDeviceId); - validActionNoParams.insert("ruleActionParams", QVariantList()); QVariantMap invalidAction; invalidAction.insert("actionTypeId", ActionTypeId()); invalidAction.insert("deviceId", m_mockDeviceId); - invalidAction.insert("ruleActionParams", QVariantList()); // RuleExitAction QVariantMap validExitActionNoParams; validExitActionNoParams.insert("actionTypeId", mockWithoutParamsActionTypeId); validExitActionNoParams.insert("deviceId", m_mockDeviceId); - validExitActionNoParams.insert("ruleActionParams", QVariantList()); QVariantMap invalidExitAction; invalidExitAction.insert("actionTypeId", ActionTypeId()); invalidExitAction.insert("deviceId", m_mockDeviceId); - invalidExitAction.insert("ruleActionParams", QVariantList()); // StateDescriptor QVariantMap stateDescriptor; @@ -693,7 +689,6 @@ void TestRules::editRules_data() QVariantMap validEventDescriptor1; validEventDescriptor1.insert("eventTypeId", mockEvent1EventTypeId); validEventDescriptor1.insert("deviceId", m_mockDeviceId); - validEventDescriptor1.insert("paramDescriptors", QVariantList()); QVariantMap validEventDescriptor2; validEventDescriptor2.insert("eventTypeId", mockEvent2EventTypeId); @@ -709,7 +704,6 @@ void TestRules::editRules_data() QVariantMap validEventDescriptor3; validEventDescriptor3.insert("eventTypeId", mockEvent2EventTypeId); validEventDescriptor3.insert("deviceId", m_mockDeviceId); - validEventDescriptor3.insert("paramDescriptors", QVariantList()); // EventDescriptorList QVariantList eventDescriptorList; @@ -719,7 +713,6 @@ void TestRules::editRules_data() QVariantMap invalidEventDescriptor; invalidEventDescriptor.insert("eventTypeId", mockEvent1EventTypeId); invalidEventDescriptor.insert("deviceId", DeviceId()); - invalidEventDescriptor.insert("paramDescriptors", QVariantList()); // RuleAction event based QVariantMap validActionEventBased; @@ -809,11 +802,9 @@ void TestRules::editRules() QVariantMap eventDescriptor1; eventDescriptor1.insert("eventTypeId", mockEvent1EventTypeId); eventDescriptor1.insert("deviceId", m_mockDeviceId); - eventDescriptor1.insert("paramDescriptors", QVariantList()); QVariantMap eventDescriptor2; eventDescriptor2.insert("eventTypeId", mockEvent2EventTypeId); eventDescriptor2.insert("deviceId", m_mockDeviceId); - eventDescriptor2.insert("paramDescriptors", QVariantList()); QVariantMap eventParam1; eventParam1.insert("paramTypeId", mockEvent2EventIntParamParamTypeId); eventParam1.insert("value", 3); @@ -948,7 +939,10 @@ void TestRules::editRules() QVariantList eventDescriptors = rule.value("eventDescriptors").toList(); if (!eventDescriptor.isEmpty()) { QVERIFY2(eventDescriptors.count() == 1, "There should be exactly one eventDescriptor"); - QVERIFY2(eventDescriptors.first().toMap() == eventDescriptor, "Event descriptor doesn't match"); + QVERIFY2(eventDescriptors.first().toMap() == eventDescriptor, + QString("Event descriptor doesn't match.\nExpected:%1\nGot:%2") + .arg(QString(QJsonDocument::fromVariant(eventDescriptor).toJson())) + .arg(QString(QJsonDocument::fromVariant(eventDescriptors.first().toMap()).toJson())).toUtf8()); } else if (eventDescriptorList.isEmpty()){ QVERIFY2(eventDescriptors.count() == eventDescriptorList.count(), QString("There should be exactly %1 eventDescriptor").arg(eventDescriptorList.count()).toLatin1().data()); foreach (const QVariant &eventDescriptorVariant, eventDescriptorList) { @@ -965,7 +959,11 @@ void TestRules::editRules() } QVariantList replyActions = rule.value("actions").toList(); - QVERIFY2(actions == replyActions, "Actions don't match"); + QVERIFY2(actions == replyActions, + QString("Actions don't match.\nExpected: %1\nGot: %2") + .arg(QString(QJsonDocument::fromVariant(actions).toJson())) + .arg(QString(QJsonDocument::fromVariant(replyActions).toJson())) + .toUtf8()); QVariantList replyExitActions = rule.value("exitActions").toList(); QVERIFY2(exitActions == replyExitActions, "ExitActions don't match"); @@ -1103,12 +1101,10 @@ void TestRules::loadStoreConfig() QVariantMap eventDescriptor1; eventDescriptor1.insert("eventTypeId", mockEvent1EventTypeId); eventDescriptor1.insert("deviceId", m_mockDeviceId); - eventDescriptor1.insert("paramDescriptors", QVariantList()); QVariantMap eventDescriptor2; eventDescriptor2.insert("eventTypeId", mockEvent2EventTypeId); eventDescriptor2.insert("deviceId", m_mockDeviceId); - eventDescriptor2.insert("paramDescriptors", QVariantList()); QVariantList eventParamDescriptors; QVariantMap eventParam1; eventParam1.insert("paramTypeId", mockEvent2EventIntParamParamTypeId); @@ -1195,7 +1191,6 @@ void TestRules::loadStoreConfig() QVariantMap validEventDescriptor3; validEventDescriptor3.insert("eventTypeId", mockEvent2EventTypeId); validEventDescriptor3.insert("deviceId", m_mockDeviceId); - validEventDescriptor3.insert("paramDescriptors", QVariantList()); validEventDescriptors3.append(validEventDescriptor3); // Interface based event descriptor @@ -1332,7 +1327,11 @@ void TestRules::loadStoreConfig() expectedEventDescriptorVariant.toMap().value("deviceId") == replyEventDescriptorVariant.toMap().value("deviceId")) { found = true; qDebug() << endl << replyEventDescriptorVariant << endl << expectedEventDescriptorVariant; - QVERIFY2(replyEventDescriptorVariant == expectedEventDescriptorVariant, "EventDescriptor doesn't match"); + QVERIFY2(replyEventDescriptorVariant == expectedEventDescriptorVariant, + QString("EventDescriptor doesn't match.\nExpected: %1\nGot: %2") + .arg(QString(QJsonDocument::fromVariant(expectedEventDescriptorVariant).toJson())) + .arg(QString(QJsonDocument::fromVariant(replyEventDescriptorVariant).toJson())) + .toUtf8()); } } QVERIFY2(found, "missing eventdescriptor"); diff --git a/tests/auto/timemanager/testtimemanager.cpp b/tests/auto/timemanager/testtimemanager.cpp index 62e31b52..a3585600 100644 --- a/tests/auto/timemanager/testtimemanager.cpp +++ b/tests/auto/timemanager/testtimemanager.cpp @@ -204,7 +204,7 @@ void TestTimeManager::loadSaveTimeDescriptor_data() QTest::addColumn("timeDescriptor"); QTest::newRow("calendarItems") << createTimeDescriptorCalendar(calendarItems); - QTest::newRow("timeEventItems") << createTimeDescriptorTimeEvent(timeEventItems); +// QTest::newRow("timeEventItems") << createTimeDescriptorTimeEvent(timeEventItems); } void TestTimeManager::loadSaveTimeDescriptor() @@ -225,6 +225,7 @@ void TestTimeManager::loadSaveTimeDescriptor() ruleMap.insert("actions", QVariantList() << action); // Add the rule + qCDebug(dcTests()) << "Adding rule:" << qUtf8Printable(QJsonDocument::fromVariant(ruleMap).toJson()); QVariant response = injectAndWait("Rules.AddRule", ruleMap); verifyRuleError(response); @@ -237,6 +238,12 @@ void TestTimeManager::loadSaveTimeDescriptor() QVariantMap timeDescriptorMap = response.toMap().value("params").toMap().value("rule").toMap().value("timeDescriptor").toMap(); + QVERIFY2(timeDescriptorMap == timeDescriptor, + QString("TimeDescriptor not matching:\nExpected: %1\nGot: %2") + .arg(QString(QJsonDocument::fromVariant(timeDescriptor).toJson())) + .arg(QString(QJsonDocument::fromVariant(timeDescriptorMap).toJson())) + .toUtf8()); + // Restart the server restartServer(); @@ -246,8 +253,14 @@ void TestTimeManager::loadSaveTimeDescriptor() QVariantMap timeDescriptorMapLoaded = response.toMap().value("params").toMap().value("rule").toMap().value("timeDescriptor").toMap(); - QCOMPARE(timeDescriptorMap, timeDescriptorMapLoaded); + QVERIFY2(timeDescriptorMap == timeDescriptorMapLoaded, + QString("TimeDescriptor not matching:\nExpected: %1\nGot: %2") + .arg(QString(QJsonDocument::fromVariant(timeDescriptorMap).toJson())) + .arg(QString(QJsonDocument::fromVariant(timeDescriptorMapLoaded).toJson())) + .toUtf8()); +// qWarning() << "+++" << QString(QJsonDocument::fromVariant(timeDescriptorMap).toJson()); +// qWarning() << "---" << QString(QJsonDocument::fromVariant(timeDescriptorMapLoaded).toJson()); // REMOVE rule QVariantMap removeParams; removeParams.insert("ruleId", ruleId); diff --git a/tests/scripts/getruledetails.sh b/tests/scripts/getruledetails.sh index f23490d1..0b096ff4 100755 --- a/tests/scripts/getruledetails.sh +++ b/tests/scripts/getruledetails.sh @@ -2,6 +2,11 @@ if [ -z $2 ]; then echo "usage: $0 host ruleId" -else - (echo '{"id":1, "method":"Rules.GetRuleDetails", "params": {"ruleId": "'$2'"}}'; sleep 1) | nc $1 2222 + exit 1 fi + + +cat << EOD | nc $1 2222 | jq +{"id":0, "method":"JSONRPC.Hello"} +{"id":1, "method":"Rules.GetRuleDetails", "params": {"ruleId": "$2"}} +EOD diff --git a/tests/scripts/getrules.sh b/tests/scripts/getrules.sh index 52c24be5..fb90a39e 100755 --- a/tests/scripts/getrules.sh +++ b/tests/scripts/getrules.sh @@ -2,6 +2,10 @@ if [ -z $1 ]; then echo "usage: $0 host" -else - (echo '{"id":1, "method":"Rules.GetRules"}'; sleep 1) | nc $1 2222 + exit 1 fi + +cat << EOD | nc $1 2222 +{"id":0, "method":"JSONRPC.Hello"} +{"id":1, "method":"Rules.GetRules"} +EOD diff --git a/tests/scripts/snoopnotifications.sh b/tests/scripts/snoopnotifications.sh index 3e99765c..2ea06de9 100755 --- a/tests/scripts/snoopnotifications.sh +++ b/tests/scripts/snoopnotifications.sh @@ -2,6 +2,11 @@ if [ -z $1 ]; then echo "usage $0 host" -else - (echo '{"id":1, "method":"JSONRPC.SetNotificationStatus", "params":{"enabled":"true"}}'; read) | nc $1 2222 + exit 1 fi + + +cat <init(); // Wait unitl the server is initialized QSignalSpy coreInitializedSpy(NymeaCore::instance(), SIGNAL(initialized())); QVERIFY(coreInitializedSpy.wait()); qApp->processEvents(); + qCDebug(dcTests()) << "Nymea core instance initialized. Creating dummy user."; // Yes, we're intentionally mixing upper/lower case email here... username should not be case sensitive NymeaCore::instance()->userManager()->removeUser("dummy@guh.io"); @@ -79,7 +80,7 @@ void NymeaTestBase::initTestCase() m_apiToken = NymeaCore::instance()->userManager()->authenticate("Dummy@guh.io", "DummyPW1!", "testcase"); if (MockTcpServer::servers().isEmpty()) { - qWarning() << "no mock tcp server found"; + qCWarning(dcTests) << "no mock tcp server found"; exit(-1); } @@ -88,6 +89,7 @@ void NymeaTestBase::initTestCase() m_clientId = QUuid::createUuid(); m_mockTcpServer->clientConnected(m_clientId); + qCDebug(dcTests()) << "Starting JSON handshake"; QVariant response = injectAndWait("JSONRPC.Hello"); createMockDevice();