From aad334c799f619ee0969023a9bbe0a22d9e7c226 Mon Sep 17 00:00:00 2001 From: Michael Zanetti Date: Sun, 12 Oct 2014 00:28:59 +0200 Subject: [PATCH] switch json api to better type system and enhance error reporting --- libguh/devicemanager.cpp | 137 ++++----- libguh/devicemanager.h | 35 +-- libguh/plugin/deviceplugin.cpp | 62 ++-- libguh/plugin/deviceplugin.h | 16 +- libguh/typeutils.h | 2 + .../deviceplugins/eq-3/deviceplugineq-3.cpp | 16 +- plugins/deviceplugins/eq-3/deviceplugineq-3.h | 2 +- .../lgsmarttv/devicepluginlgsmarttv.cpp | 12 +- .../lgsmarttv/devicepluginlgsmarttv.h | 2 +- .../devicepluginmailnotification.cpp | 4 +- .../devicepluginmailnotification.h | 2 +- .../deviceplugins/mock/devicepluginmock.cpp | 23 +- plugins/deviceplugins/mock/devicepluginmock.h | 2 +- plugins/deviceplugins/mock/httpdaemon.cpp | 1 - .../devicepluginopenweathermap.cpp | 7 +- .../devicepluginopenweathermap.h | 2 +- .../philipshue/devicepluginphilipshue.cpp | 28 +- .../philipshue/devicepluginphilipshue.h | 6 +- .../deviceplugins/wemo/devicepluginwemo.cpp | 12 +- plugins/deviceplugins/wemo/devicepluginwemo.h | 2 +- server/guhcore.cpp | 19 +- server/guhcore.h | 14 +- server/jsonrpc/actionhandler.cpp | 29 +- server/jsonrpc/actionhandler.h | 4 +- server/jsonrpc/devicehandler.cpp | 182 ++++------- server/jsonrpc/devicehandler.h | 2 +- server/jsonrpc/jsonrpcserver.cpp | 18 +- server/jsonrpc/jsontypes.cpp | 247 ++++++++------- server/jsonrpc/jsontypes.h | 37 +-- server/jsonrpc/ruleshandler.cpp | 24 +- tests/auto/actions/testactions.cpp | 8 +- tests/auto/api.json | 288 +++++++++--------- tests/auto/devices/testdevices.cpp | 57 ++-- tests/auto/guhtestbase.cpp | 10 +- tests/auto/guhtestbase.h | 24 +- tests/auto/jsonrpc/testjsonrpc.cpp | 6 +- tests/auto/rules/testrules.cpp | 22 +- tests/auto/states/teststates.cpp | 5 +- 38 files changed, 659 insertions(+), 710 deletions(-) diff --git a/libguh/devicemanager.cpp b/libguh/devicemanager.cpp index 332dc6e2..b582d659 100644 --- a/libguh/devicemanager.cpp +++ b/libguh/devicemanager.cpp @@ -139,14 +139,14 @@ DevicePlugin *DeviceManager::plugin(const PluginId &id) const return m_devicePlugins.value(id); } -QPair DeviceManager::setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig) +DeviceManager::DeviceError DeviceManager::setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig) { DevicePlugin *plugin = m_devicePlugins.value(pluginId); if (!plugin) { - return report(DeviceErrorPluginNotFound, QString("No plugin with id % 1").arg(pluginId.toString())); + return DeviceErrorPluginNotFound; } - QPair result = plugin->setConfiguration(pluginConfig); - if (result.first != DeviceErrorNoError) { + DeviceError result = plugin->setConfiguration(pluginConfig); + if (result != DeviceErrorNoError) { return result; } QSettings settings; @@ -257,67 +257,67 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const DeviceClassI return addConfiguredDeviceInternal(deviceClassId, descriptor.params(), deviceId); } -QPair DeviceManager::pairDevice(const DeviceClassId &deviceClassId, const ParamList ¶ms) +DeviceManager::DeviceError DeviceManager::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms) { DeviceClass deviceClass = findDeviceClass(deviceClassId); if (deviceClass.id().isNull()) { qWarning() << "cannot find a device class with id" << deviceClassId; - return qMakePair(DeviceErrorDeviceClassNotFound, deviceClassId.toString()); + return DeviceErrorDeviceClassNotFound; } - if (deviceClass.setupMethod() == DeviceClass::SetupMethodJustAdd) { + switch (deviceClass.setupMethod()) { + case DeviceClass::SetupMethodJustAdd: qWarning() << "Cannot setup this device this way. No need to pair this device."; - return qMakePair(DeviceErrorCreationMethodNotSupported, "No need to pair this device."); + return DeviceErrorSetupMethodNotSupported; + case DeviceClass::SetupMethodDisplayPin: + qWarning() << "SetupMethodDisplayPin not implemented yet for this CreateMethod"; + return DeviceErrorSetupFailed; + case DeviceClass::SetupMethodEnterPin: + qWarning() << "SetupMethodEnterPin not implemented yet for this CreateMethod"; + return DeviceErrorSetupFailed; + case DeviceClass::SetupMethodPushButton: + qWarning() << "SetupMethodPushButton not implemented yet for this CreateMethod"; + return DeviceErrorSetupFailed; } - QUuid pairingTransactionId = QUuid::createUuid(); - m_pairingsJustAdd.insert(pairingTransactionId, qMakePair(deviceClassId, params)); - - if (deviceClass.setupMethod() == DeviceClass::SetupMethodDisplayPin) { - // TODO: fetch PIN from device plugin - qWarning() << "SetupMethodDisplayPin not implemented yet"; - return qMakePair(DeviceErrorSetupFailed, "SetupMethodDisplayPin Not implemented yet."); - } - - return qMakePair(DeviceErrorNoError, pairingTransactionId.toString()); + return DeviceErrorNoError; } -QPair DeviceManager::pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId) +DeviceManager::DeviceError DeviceManager::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId) { DeviceClass deviceClass = findDeviceClass(deviceClassId); if (deviceClass.id().isNull()) { qWarning() << "cannot find a device class with id" << deviceClassId; - return qMakePair(DeviceErrorDeviceClassNotFound, deviceClassId.toString()); + return DeviceErrorDeviceClassNotFound; } if (deviceClass.setupMethod() == DeviceClass::SetupMethodJustAdd) { qWarning() << "Cannot setup this device this way. No need to pair this device."; - return qMakePair(DeviceErrorCreationMethodNotSupported, "No need to pair this device."); + return DeviceErrorCreationMethodNotSupported; } if (!m_discoveredDevices.contains(deviceDescriptorId)) { qWarning() << "Cannot find a DeviceDescriptor with ID" << deviceClassId.toString(); - return qMakePair(DeviceErrorDeviceDescriptorNotFound, deviceDescriptorId.toString()); + return DeviceErrorDeviceDescriptorNotFound; } - QUuid pairingTransactionId = QUuid::createUuid(); m_pairingsDiscovery.insert(pairingTransactionId, qMakePair(deviceClassId, deviceDescriptorId)); if (deviceClass.setupMethod() == DeviceClass::SetupMethodDisplayPin) { // TODO: fetch PIN from device plugin qWarning() << "SetupMethodDisplayPin not implemented yet"; - return qMakePair(DeviceErrorSetupFailed, "SetupMethodDisplayPin Not implemented yet."); + return DeviceErrorSetupFailed; } - return qMakePair(DeviceErrorNoError, pairingTransactionId.toString()); + return DeviceErrorNoError; } -QPair DeviceManager::confirmPairing(const QUuid &pairingTransactionId, const QString &secret) +DeviceManager::DeviceError DeviceManager::confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret) { if (m_pairingsJustAdd.contains(pairingTransactionId)) { qWarning() << "this SetupMethod is not implemented yet"; m_pairingsJustAdd.remove(pairingTransactionId); - return qMakePair(DeviceErrorSetupFailed, "Not implemented yet"); + return DeviceErrorSetupFailed; } if (m_pairingsDiscovery.contains(pairingTransactionId)) { @@ -330,23 +330,23 @@ QPair DeviceManager::confirmPairing(const Q if (!plugin) { qWarning() << "Can't find a plugin for this device class"; - return report(DeviceErrorPluginNotFound, m_supportedDevices.value(deviceClassId).pluginId().toString()); + return DeviceErrorPluginNotFound; } - QPair status = plugin->confirmPairing(pairingTransactionId, deviceClassId, deviceDescriptor.params()); - switch (status.first) { + DeviceSetupStatus status = plugin->confirmPairing(pairingTransactionId, deviceClassId, deviceDescriptor.params()); + switch (status) { case DeviceSetupStatusSuccess: m_pairingsDiscovery.remove(pairingTransactionId); - return report(DeviceErrorNoError); + return DeviceErrorNoError; case DeviceSetupStatusFailure: m_pairingsDiscovery.remove(pairingTransactionId); - return report(DeviceErrorSetupFailed, status.second); + return DeviceErrorSetupFailed; case DeviceSetupStatusAsync: - return report(DeviceErrorAsync); + return DeviceErrorAsync; } } - return report(DeviceErrorPairingTransactionIdNotFound, pairingTransactionId.toString()); + return DeviceErrorPairingTransactionIdNotFound; } DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const DeviceClassId &deviceClassId, const ParamList ¶ms, const DeviceId id) @@ -381,8 +381,8 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const Devi device->setName(deviceClass.name()); device->setParams(effectiveParams); - QPair status = setupDevice(device); - switch (status.first) { + DeviceSetupStatus status = setupDevice(device); + switch (status) { case DeviceSetupStatusFailure: qWarning() << "Device setup failed. Not adding device to system."; delete device; @@ -400,11 +400,11 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const Devi return DeviceErrorNoError; } -QPair DeviceManager::removeConfiguredDevice(const DeviceId &deviceId) +DeviceManager::DeviceError DeviceManager::removeConfiguredDevice(const DeviceId &deviceId) { Device *device = findConfiguredDevice(deviceId); if (!device) { - return qMakePair(DeviceErrorDeviceNotFound, deviceId.toString()); + return DeviceErrorDeviceNotFound; } m_configuredDevices.removeAll(device); @@ -423,7 +423,7 @@ QPair DeviceManager::removeConfiguredDevice settings.remove(""); settings.endGroup(); - return qMakePair(DeviceErrorNoError, QString()); + return DeviceErrorNoError; } /*! Returns the \l{Device} with the given \a id. Null if the id couldn't be found. */ @@ -473,7 +473,6 @@ DeviceClass DeviceManager::findDeviceClass(const DeviceClassId &deviceClassId) c DeviceManager::DeviceError DeviceManager::executeAction(const Action &action) { Action finalAction = action; - qDebug() << "should execute action"; foreach (Device *device, m_configuredDevices) { if (action.deviceId() == device->id()) { // found device @@ -482,7 +481,6 @@ DeviceManager::DeviceError DeviceManager::executeAction(const Action &action) DeviceClass deviceClass = findDeviceClass(device->deviceClassId()); bool found = false; foreach (const ActionType &actionType, deviceClass.actionTypes()) { - qDebug() << "checking" << actionType.id() << action.actionTypeId(); if (actionType.id() == action.actionTypeId()) { ParamList finalParams = action.params(); DeviceError paramCheck = verifyParams(actionType.paramTypes(), finalParams); @@ -573,6 +571,12 @@ void DeviceManager::loadPlugins() if (status.first != DeviceErrorNoError) { qWarning() << "Error setting params to plugin. Broken configuration?" << status.second; } + } + settings.endGroup(); + DeviceError status = pluginIface->setConfiguration(params); + if (status != DeviceErrorNoError) { + qWarning() << "Error setting params to plugin. Broken configuration?"; + } m_devicePlugins.insert(pluginIface->pluginId(), pluginIface); connect(pluginIface, &DevicePlugin::emitEvent, this, &DeviceManager::eventTriggered); @@ -607,8 +611,6 @@ void DeviceManager::loadConfiguredDevices() settings.endGroup(); settings.endGroup(); - //qDebug() << "found stored device" << device->id() << device->name() << device->deviceClassId() << device->pluginId(); - // We always add the device to the list in this case. If its in the storedDevices // it means that it was working at some point so lets still add it as there might // be rules associated with this device. Device::setupCompleted() will be false. @@ -655,7 +657,7 @@ void DeviceManager::slotDevicesDiscovered(const DeviceClassId &deviceClassId, co emit devicesDiscovered(deviceClassId, deviceDescriptors); } -void DeviceManager::slotDeviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status, const QString &errorMessage) +void DeviceManager::slotDeviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status) { Q_ASSERT_X(device, "DeviceManager", "Device must be a valid pointer."); if (!device) { @@ -677,11 +679,11 @@ void DeviceManager::slotDeviceSetupFinished(Device *device, DeviceManager::Devic if (status == DeviceSetupStatusFailure) { if (m_configuredDevices.contains(device)) { qWarning() << QString("Error in device setup. Device %1 (%2) will not be functional.").arg(device->name()).arg(device->id().toString()); - emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed, QString("Device setup failed: %1").arg(errorMessage)); + emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed); return; } else { qWarning() << QString("Error in device setup. Device %1 (%2) will not be added to the configured devices.").arg(device->name()).arg(device->id().toString()); - emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed, QString("Device setup failed: %1").arg(errorMessage)); + emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed); return; } } @@ -706,10 +708,10 @@ void DeviceManager::slotDeviceSetupFinished(Device *device, DeviceManager::Devic connect(device, SIGNAL(stateValueChanged(QUuid,QVariant)), this, SLOT(slotDeviceStateValueChanged(QUuid,QVariant))); device->setupCompleted(); - emit deviceSetupFinished(device, DeviceManager::DeviceErrorNoError, QString()); + emit deviceSetupFinished(device, DeviceManager::DeviceErrorNoError); } -void DeviceManager::slotPairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceSetupStatus status, const QString &errorMessage) +void DeviceManager::slotPairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceSetupStatus status) { if (!m_pairingsJustAdd.contains(pairingTransactionId) && !m_pairingsDiscovery.contains(pairingTransactionId)) { DevicePlugin *plugin = dynamic_cast(sender()); @@ -741,11 +743,8 @@ void DeviceManager::slotPairingFinished(const QUuid &pairingTransactionId, Devic params = descriptor.params(); } - - qDebug() << "pairingfinsihed!" << errorMessage; if (status != DeviceSetupStatusSuccess) { - qDebug() << "emitting shit"; - emit pairingFinished(pairingTransactionId, DeviceErrorSetupFailed, errorMessage); + emit pairingFinished(pairingTransactionId, DeviceErrorSetupFailed); return; } @@ -759,20 +758,18 @@ void DeviceManager::slotPairingFinished(const QUuid &pairingTransactionId, Devic // Ok... pairing went fine... Let consumers know about it and inform them about the ongoing setup with a deviceId. DeviceId id = DeviceId::createDeviceId(); - emit pairingFinished(pairingTransactionId, DeviceErrorNoError, QString(), id); + emit pairingFinished(pairingTransactionId, DeviceErrorNoError, id); QList newDevices; - QString setupErrorMessage; Device *device = new Device(plugin->pluginId(), id, deviceClassId, this); device->setName(deviceClass.name()); device->setParams(params); - QPair setupStatus = setupDevice(device); - switch (setupStatus.first) { + DeviceSetupStatus setupStatus = setupDevice(device); + switch (setupStatus) { case DeviceSetupStatusFailure: qWarning() << "Device setup failed. Not adding device to system."; - setupErrorMessage = setupStatus.second; - emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed, QString("Device setup failed: %1").arg(errorMessage)); + emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed); delete device; break; case DeviceSetupStatusAsync: @@ -786,7 +783,7 @@ void DeviceManager::slotPairingFinished(const QUuid &pairingTransactionId, Devic m_configuredDevices.append(device); storeConfiguredDevices(); - emit deviceSetupFinished(device, DeviceError::DeviceErrorNoError, QString()); + emit deviceSetupFinished(device, DeviceError::DeviceErrorNoError); } void DeviceManager::autoDevicesAppeared(const DeviceClassId &deviceClassId, const QList &deviceDescriptors) @@ -805,18 +802,18 @@ void DeviceManager::autoDevicesAppeared(const DeviceClassId &deviceClassId, cons device->setName(deviceClass.name()); device->setParams(deviceDescriptor.params()); - QPair setupStatus = setupDevice(device); - switch (setupStatus.first) { + DeviceSetupStatus setupStatus = setupDevice(device); + switch (setupStatus) { case DeviceSetupStatusFailure: qWarning() << "Device setup failed. Not adding device to system."; - emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed, QString("Device setup failed: %1").arg(setupStatus.second)); + emit deviceSetupFinished(device, DeviceError::DeviceErrorSetupFailed); delete device; break; case DeviceSetupStatusAsync: break; case DeviceSetupStatusSuccess: qDebug() << "Device setup complete."; - emit deviceSetupFinished(device, DeviceError::DeviceErrorNoError, QString()); + emit deviceSetupFinished(device, DeviceError::DeviceErrorNoError); m_configuredDevices.append(device); storeConfiguredDevices(); break; @@ -884,13 +881,14 @@ bool DeviceManager::verifyPluginMetadata(const QJsonObject &data) return true; } -QPair DeviceManager::setupDevice(Device *device) +DeviceManager::DeviceSetupStatus DeviceManager::setupDevice(Device *device) { DeviceClass deviceClass = findDeviceClass(device->deviceClassId()); DevicePlugin *plugin = m_devicePlugins.value(deviceClass.pluginId()); if (!plugin) { - return qMakePair(DeviceSetupStatusFailure, "Can't find a plugin for this device"); + qWarning() << "Can't find a plugin for this device" << device->id(); + return DeviceSetupStatusFailure; } QList states; @@ -901,8 +899,8 @@ QPair DeviceManager::setupDevice(Devic } device->setStates(states); - QPair status = plugin->setupDevice(device); - if (status.first != DeviceSetupStatusSuccess) { + DeviceSetupStatus status = plugin->setupDevice(device); + if (status != DeviceSetupStatusSuccess) { return status; } @@ -995,8 +993,3 @@ DeviceManager::DeviceError DeviceManager::verifyParam(const ParamType ¶mType qWarning() << "Parameter name" << param.name() << "does not match with ParamType name" << paramType.name(); return DeviceErrorInvalidParameter; } - -QPair DeviceManager::report(DeviceManager::DeviceError error, const QString &message) -{ - return qMakePair(error, message); -} diff --git a/libguh/devicemanager.h b/libguh/devicemanager.h index 259381c4..9c777759 100644 --- a/libguh/devicemanager.h +++ b/libguh/devicemanager.h @@ -49,21 +49,24 @@ public: enum DeviceError { DeviceErrorNoError, + DeviceErrorPluginNotFound, DeviceErrorDeviceNotFound, DeviceErrorDeviceClassNotFound, DeviceErrorActionTypeNotFound, + DeviceErrorStateTypeNotFound, + DeviceErrorEventTypeNotFound, + DeviceErrorDeviceDescriptorNotFound, DeviceErrorMissingParameter, DeviceErrorInvalidParameter, - DeviceErrorPluginNotFound, DeviceErrorSetupFailed, DeviceErrorDuplicateUuid, DeviceErrorCreationMethodNotSupported, - DeviceErrorActionParameterError, + DeviceErrorSetupMethodNotSupported, DeviceErrorHardwareNotAvailable, - DeviceErrorDeviceDescriptorNotFound, + DeviceErrorHardwareFailure, DeviceErrorAsync, + DeviceErrorDeviceInUse, DeviceErrorPairingTransactionIdNotFound, - // Don't forget to update JsonTypes! }; enum DeviceSetupStatus { @@ -77,7 +80,7 @@ public: QList plugins() const; DevicePlugin* plugin(const PluginId &id) const; - QPair setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig); + DeviceError setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig); QList supportedVendors() const; QList supportedDevices(const VendorId &vendorId = VendorId()) const; @@ -86,10 +89,10 @@ public: QList configuredDevices() const; DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const ParamList ¶ms, const DeviceId id = DeviceId::createDeviceId()); DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &id = DeviceId::createDeviceId()); - QPair pairDevice(const DeviceClassId &deviceClassId, const ParamList ¶ms); - QPair pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId); - QPair confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString()); - QPair removeConfiguredDevice(const DeviceId &deviceId); + DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms); + DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId); + DeviceError confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret = QString()); + DeviceError removeConfiguredDevice(const DeviceId &deviceId); Device* findConfiguredDevice(const DeviceId &id) const; QList findConfiguredDevices(const DeviceClassId &deviceClassId) const; @@ -100,9 +103,9 @@ signals: void eventTriggered(const Event &event); void deviceStateChanged(Device *device, const QUuid &stateTypeId, const QVariant &value); void devicesDiscovered(const DeviceClassId &deviceClassId, const QList &devices); - void deviceSetupFinished(Device *device, DeviceError status, const QString &errorMessage); - void pairingFinished(const QUuid &pairingTransactionId, DeviceError status, const QString &errorMessage, const DeviceId &deviceId = DeviceId()); - void actionExecutionFinished(const ActionId, DeviceError status, const QString &errorMessage); + void deviceSetupFinished(Device *device, DeviceError status); + void pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceError status, const DeviceId &deviceId = DeviceId()); + void actionExecutionFinished(const ActionId, DeviceError status); public slots: DeviceError executeAction(const Action &action); @@ -113,8 +116,8 @@ private slots: void storeConfiguredDevices(); void startMonitoringAutoDevices(); void slotDevicesDiscovered(const DeviceClassId &deviceClassId, const QList deviceDescriptors); - void slotDeviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status, const QString &errorMessage); - void slotPairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceSetupStatus status, const QString &errorMessage); + void slotDeviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status); + void slotPairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceSetupStatus status); void autoDevicesAppeared(const DeviceClassId &deviceClassId, const QList &deviceDescriptors); // Only connect this to Devices. It will query the sender() @@ -126,13 +129,11 @@ private slots: private: bool verifyPluginMetadata(const QJsonObject &data); DeviceError addConfiguredDeviceInternal(const DeviceClassId &deviceClassId, const ParamList ¶ms, const DeviceId id = DeviceId::createDeviceId()); - QPair setupDevice(Device *device); + DeviceSetupStatus setupDevice(Device *device); DeviceError verifyParams(const QList paramTypes, ParamList ¶ms, bool requireAll = true); DeviceError verifyParam(const QList paramTypes, const Param ¶m); DeviceError verifyParam(const ParamType ¶mType, const Param ¶m); - QPair report(DeviceError error = DeviceErrorNoError, const QString &message = QString()); - private: QHash m_supportedVendors; diff --git a/libguh/plugin/deviceplugin.cpp b/libguh/plugin/deviceplugin.cpp index cf193a25..e679b3f0 100644 --- a/libguh/plugin/deviceplugin.cpp +++ b/libguh/plugin/deviceplugin.cpp @@ -78,7 +78,7 @@ pure virtual methods: \l{DevicePlugin::pluginName()}, \l{DevicePlugin::pluginId( */ /*! - \fn void DevicePlugin::actionExecutionFinished(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage) + \fn void DevicePlugin::actionExecutionFinished(const ActionId &id, DeviceManager::DeviceError status) This signal is to be emitted when you previously have returned DeviceManager::DeviceErrorAsync in a call of executeAction(). It is used to deliver the return value that previously has been omitted by filling in DeviceErrorAsync. @@ -163,7 +163,6 @@ QList DevicePlugin::supportedDevices() const deviceClass.setCreateMethods(createMethods); deviceClass.setDiscoveryParamTypes(parseParamTypes(jo.value("discoveryParamTypes").toArray())); - qDebug() << "loaded deviceClass" << deviceClass.discoveryParamTypes(); QString setupMethod = jo.value("setupMethod").toString(); if (setupMethod == "pushButton") { @@ -179,7 +178,6 @@ QList DevicePlugin::supportedDevices() const deviceClass.setParamTypes(parseParamTypes(jo.value("paramTypes").toArray())); QList stateTypes; - qDebug() << "############### s" << jo; foreach (const QJsonValue &stateTypesJson, jo.value("stateTypes").toArray()) { QJsonObject st = stateTypesJson.toObject(); QVariant::Type t = QVariant::nameToType(st.value("type").toString().toLatin1().data()); @@ -197,7 +195,6 @@ QList DevicePlugin::supportedDevices() const ActionType actionType(at.value("id").toString()); actionType.setName(at.value("name").toString()); actionType.setParamTypes(parseParamTypes(at.value("paramTypes").toArray())); - qDebug() << "***got actionType" << actionType.id(); actionTypes.append(actionType); } deviceClass.setActionTypes(actionTypes); @@ -250,10 +247,10 @@ DeviceManager::DeviceError DevicePlugin::discoverDevices(const DeviceClassId &de \l{deviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status)} to report the status. */ -QPair DevicePlugin::setupDevice(Device *device) +DeviceManager::DeviceSetupStatus DevicePlugin::setupDevice(Device *device) { Q_UNUSED(device) - return reportDeviceSetup(); + return DeviceManager::DeviceSetupStatusSuccess; } /*! This will be called when a device removed. The plugin has the chance to do some teardown. @@ -265,13 +262,14 @@ void DevicePlugin::deviceRemoved(Device *device) Q_UNUSED(device) } -QPair DevicePlugin::confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms) +DeviceManager::DeviceSetupStatus DevicePlugin::confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms) { Q_UNUSED(pairingTransactionId) Q_UNUSED(deviceClassId) Q_UNUSED(params) - return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "Plugin does not implement pairing."); + qWarning() << "Plugin does not implement pairing."; + return DeviceManager::DeviceSetupStatusFailure; } QList DevicePlugin::configurationDescription() const @@ -340,58 +338,62 @@ QVariant DevicePlugin::configValue(const QString ¶mName) const /*! Will be called by the DeviceManager to set a plugin's \a configuration. */ -QPair DevicePlugin::setConfiguration(const ParamList &configuration) +DeviceManager::DeviceError DevicePlugin::setConfiguration(const ParamList &configuration) { foreach (const Param ¶m, configuration) { qDebug() << "setting config" << param; - QPair result = setConfigValue(param.name(), param.value()); - if (result.first != DeviceManager::DeviceErrorNoError) { + DeviceManager::DeviceError result = setConfigValue(param.name(), param.value()); + if (result != DeviceManager::DeviceErrorNoError) { return result; } } - return report(); + return DeviceManager::DeviceErrorNoError; } /*! Will be called by the DeviceManager to set a plugin's \a configuration. */ -QPair DevicePlugin::setConfigValue(const QString ¶mName, const QVariant &value) +DeviceManager::DeviceError DevicePlugin::setConfigValue(const QString ¶mName, const QVariant &value) { bool found = false; foreach (const ParamType ¶mType, configurationDescription()) { if (paramType.name() == paramName) { if (!value.canConvert(paramType.type())) { - return report(DeviceManager::DeviceErrorInvalidParameter, QString("Wrong parameter type for param %1. Got %2. Expected %3.") - .arg(paramName).arg(value.toString()).arg(QVariant::typeToName(paramType.type()))); + qWarning() << QString("Wrong parameter type for param %1. Got %2. Expected %3.") + .arg(paramName).arg(value.toString()).arg(QVariant::typeToName(paramType.type())); + return DeviceManager::DeviceErrorInvalidParameter; } if (paramType.maxValue().isValid() && value > paramType.maxValue()) { - return report(DeviceManager::DeviceErrorInvalidParameter, QString("Value out of range for param %1. Got %2. Max: %3.") - .arg(paramName).arg(value.toString()).arg(paramType.maxValue().toString())); + qWarning() << QString("Value out of range for param %1. Got %2. Max: %3.") + .arg(paramName).arg(value.toString()).arg(paramType.maxValue().toString()); + return DeviceManager::DeviceErrorInvalidParameter; } if (paramType.minValue().isValid() && value < paramType.minValue()) { - return report(DeviceManager::DeviceErrorInvalidParameter, QString("Value out of range for param %1. Got: %2. Min: %3.") - .arg(paramName).arg(value.toString()).arg(paramType.minValue().toString())); + qWarning() << QString("Value out of range for param %1. Got: %2. Min: %3.") + .arg(paramName).arg(value.toString()).arg(paramType.minValue().toString()); + return DeviceManager::DeviceErrorInvalidParameter; } found = true; break; } } if (!found) { - return report(DeviceManager::DeviceErrorInvalidParameter, QString("Invalid parameter %1.").arg(paramName)); + qWarning() << QString("Invalid parameter %1.").arg(paramName); + return DeviceManager::DeviceErrorInvalidParameter; } for (int i = 0; i < m_config.count(); i++) { if (m_config.at(i).name() == paramName) { m_config[i].setValue(value); emit configValueChanged(paramName, value); - return report(); + return DeviceManager::DeviceErrorNoError; } } // Still here? need to create the param Param newParam(paramName, value); m_config.append(newParam); emit configValueChanged(paramName, value); - return report(); + return DeviceManager::DeviceErrorNoError; } /*! @@ -463,19 +465,3 @@ bool DevicePlugin::transmitData(int delay, QList rawData) } return false; } - -/*! - Constructs a status report to be returned. By default (when called without - arguments) this will report \l{DeviceManager::DeviceErrorNoError} and an - empty message. - Keep the message short, the DeviceManager will format it for you. - */ -QPair DevicePlugin::report(DeviceManager::DeviceError error, const QString &message) -{ - return qMakePair(error, message); -} - -QPair DevicePlugin::reportDeviceSetup(DeviceManager::DeviceSetupStatus status, const QString &message) -{ - return qMakePair(status, message); -} diff --git a/libguh/plugin/deviceplugin.h b/libguh/plugin/deviceplugin.h index ab0cfefd..a50a168a 100644 --- a/libguh/plugin/deviceplugin.h +++ b/libguh/plugin/deviceplugin.h @@ -53,10 +53,10 @@ public: virtual void startMonitoringAutoDevices(); virtual DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList ¶ms); - virtual QPair setupDevice(Device *device); + virtual DeviceManager::DeviceSetupStatus setupDevice(Device *device); virtual void deviceRemoved(Device *device); - virtual QPair confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms); + virtual DeviceManager::DeviceSetupStatus confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms); // Hardware input virtual void radioData(const QList &rawData) {Q_UNUSED(rawData)} @@ -64,10 +64,10 @@ public: // Configuration virtual QList configurationDescription() const; - QPair setConfiguration(const ParamList &configuration); + DeviceManager::DeviceError setConfiguration(const ParamList &configuration); ParamList configuration() const; QVariant configValue(const QString ¶mName) const; - QPair setConfigValue(const QString ¶mName, const QVariant &value); + DeviceManager::DeviceError setConfigValue(const QString ¶mName, const QVariant &value); public slots: virtual DeviceManager::DeviceError executeAction(Device *device, const Action &action) { @@ -78,9 +78,9 @@ public slots: signals: void emitEvent(const Event &event); void devicesDiscovered(const DeviceClassId &deviceClassId, const QList &deviceDescriptors); - void deviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status, const QString &errorMessage); - void pairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceSetupStatus status, const QString &errorMessage); - void actionExecutionFinished(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage); + void deviceSetupFinished(Device *device, DeviceManager::DeviceSetupStatus status); + void pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceSetupStatus status); + void actionExecutionFinished(const ActionId &id, DeviceManager::DeviceError status); void configValueChanged(const QString ¶mName, const QVariant &value); void autoDevicesAppeared(const DeviceClassId &deviceClassId, const QList &deviceDescriptors); @@ -91,8 +91,6 @@ protected: bool transmitData(int delay, QList rawData); - QPair report(DeviceManager::DeviceError error = DeviceManager::DeviceErrorNoError, const QString &message = QString()); - QPair reportDeviceSetup(DeviceManager::DeviceSetupStatus status = DeviceManager::DeviceSetupStatusSuccess, const QString &message = QString()); private: void initPlugin(const QJsonObject &metaData, DeviceManager *deviceManager); diff --git a/libguh/typeutils.h b/libguh/typeutils.h index 2edfc03c..7f8494aa 100644 --- a/libguh/typeutils.h +++ b/libguh/typeutils.h @@ -50,6 +50,8 @@ DECLARE_TYPE_ID(Action) DECLARE_TYPE_ID(Plugin) DECLARE_TYPE_ID(Rule) +DECLARE_TYPE_ID(PairingTransaction) + class Types { Q_GADGET diff --git a/plugins/deviceplugins/eq-3/deviceplugineq-3.cpp b/plugins/deviceplugins/eq-3/deviceplugineq-3.cpp index 1fc7ddfb..53c08123 100644 --- a/plugins/deviceplugins/eq-3/deviceplugineq-3.cpp +++ b/plugins/deviceplugins/eq-3/deviceplugineq-3.cpp @@ -261,7 +261,7 @@ void DevicePluginEQ3::startMonitoringAutoDevices() } -QPair DevicePluginEQ3::setupDevice(Device *device) +DeviceManager::DeviceSetupStatus DevicePluginEQ3::setupDevice(Device *device) { qDebug() << "setupDevice" << device->params(); @@ -269,7 +269,7 @@ QPair DevicePluginEQ3::setupDevice(De foreach (MaxCube *cube, m_cubes.keys()) { if(cube->serialNumber() == device->paramValue("serial number").toString()){ qDebug() << cube->serialNumber() << " allready exists..."; - return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure,QString("Cube allready in added")); + return DeviceManager::DeviceSetupStatusFailure; } } @@ -286,13 +286,13 @@ QPair DevicePluginEQ3::setupDevice(De cube->connectToCube(); - return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync); + return DeviceManager::DeviceSetupStatusAsync; } if(device->deviceClassId() == wallThermostateDeviceClassId){ device->setName("Max! Wall Thermostat (" + device->paramValue("serial number").toString() + ")"); } - return reportDeviceSetup(); + return DeviceManager::DeviceSetupStatusSuccess; } void DevicePluginEQ3::deviceRemoved(Device *device) @@ -354,7 +354,7 @@ void DevicePluginEQ3::cubeConnectionStatusChanged(const bool &connected) device = m_cubes.value(cube); device->setName("Max! Cube " + cube->serialNumber()); device->setStateValue(connectionStateTypeId,true); - emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess, QString()); + emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess); } }else{ MaxCube *cube = static_cast(sender()); @@ -362,7 +362,7 @@ void DevicePluginEQ3::cubeConnectionStatusChanged(const bool &connected) if (m_cubes.contains(cube)){ device = m_cubes.value(cube); device->setStateValue(connectionStateTypeId,false); - emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusFailure, QString("Could not connect to cube.")); + emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusFailure); } } } @@ -391,9 +391,9 @@ void DevicePluginEQ3::discoveryDone(const QList &cubeList) void DevicePluginEQ3::commandActionFinished(const bool &succeeded, const ActionId &actionId) { if(succeeded){ - emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorNoError,QString()); + emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorNoError); }else{ - emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorSetupFailed,QString("Could not execute action on cube, unknown error")); + emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorSetupFailed); } } diff --git a/plugins/deviceplugins/eq-3/deviceplugineq-3.h b/plugins/deviceplugins/eq-3/deviceplugineq-3.h index 282a26a1..20adf451 100644 --- a/plugins/deviceplugins/eq-3/deviceplugineq-3.h +++ b/plugins/deviceplugins/eq-3/deviceplugineq-3.h @@ -43,7 +43,7 @@ public: void startMonitoringAutoDevices() override; - QPair setupDevice(Device *device) override; + DeviceManager::DeviceSetupStatus setupDevice(Device *device) override; void deviceRemoved(Device *device) override; void guhTimer() override; diff --git a/plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.cpp b/plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.cpp index 1af08e52..88eec420 100644 --- a/plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.cpp +++ b/plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.cpp @@ -78,7 +78,7 @@ DeviceManager::DeviceError DevicePluginLgSmartTv::discoverDevices(const DeviceCl return DeviceManager::DeviceErrorAsync; } -QPair DevicePluginLgSmartTv::setupDevice(Device *device) +DeviceManager::DeviceSetupStatus DevicePluginLgSmartTv::setupDevice(Device *device) { device->setName("LG Smart Tv (" + device->paramValue("model").toString() + ")"); @@ -102,7 +102,7 @@ QPair DevicePluginLgSmartTv::setupDev tvDevice->requestPairing(); m_tvList.insert(tvDevice,device); - return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync); + return DeviceManager::DeviceSetupStatusAsync; } DeviceManager::HardwareResources DevicePluginLgSmartTv::requiredHardware() const @@ -201,19 +201,19 @@ void DevicePluginLgSmartTv::pairingFinished(const bool &success) Device *device = m_tvList.value(tvDevice); if(success){ - emit deviceSetupFinished(device,DeviceManager::DeviceSetupStatusSuccess,QString("")); + emit deviceSetupFinished(device,DeviceManager::DeviceSetupStatusSuccess); tvDevice->refresh(); }else{ - emit deviceSetupFinished(device,DeviceManager::DeviceSetupStatusFailure,QString("Could not pair with tv.")); + emit deviceSetupFinished(device,DeviceManager::DeviceSetupStatusFailure); } } void DevicePluginLgSmartTv::sendingCommandFinished(const bool &success, const ActionId &actionId) { if(success){ - emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorNoError,QString()); + emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorNoError); }else{ - emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorActionTypeNotFound,QString("Could not send command")); + emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorHardwareFailure); } } diff --git a/plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.h b/plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.h index e1131059..32787ee8 100644 --- a/plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.h +++ b/plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.h @@ -35,7 +35,7 @@ public: TvDiscovery *m_discovery; DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList ¶ms) override; - QPair setupDevice(Device *device) override; + DeviceManager::DeviceSetupStatus setupDevice(Device *device) override; DeviceManager::HardwareResources requiredHardware() const override; DeviceManager::DeviceError executeAction(Device *device, const Action &action) override; diff --git a/plugins/deviceplugins/mailnotification/devicepluginmailnotification.cpp b/plugins/deviceplugins/mailnotification/devicepluginmailnotification.cpp index 6a1b297d..26cb3a62 100644 --- a/plugins/deviceplugins/mailnotification/devicepluginmailnotification.cpp +++ b/plugins/deviceplugins/mailnotification/devicepluginmailnotification.cpp @@ -245,7 +245,7 @@ DevicePluginMailNotification::~DevicePluginMailNotification() m_smtpClient->deleteLater(); } -QPair DevicePluginMailNotification::setupDevice(Device *device) +DeviceManager::DeviceSetupStatus DevicePluginMailNotification::setupDevice(Device *device) { // Google mail // if(device->deviceClassId() == googleMailDeviceClassId){ @@ -255,7 +255,7 @@ QPair DevicePluginMailNotification::s // m_smtpClient->setHost("smtp.gmail.com"); // m_smtpClient->login(device->paramValue("user").toString(), device->paramValue("password").toString()); // } - return reportDeviceSetup(); + return DeviceManager::DeviceSetupStatusSuccess; } DeviceManager::HardwareResources DevicePluginMailNotification::requiredHardware() const diff --git a/plugins/deviceplugins/mailnotification/devicepluginmailnotification.h b/plugins/deviceplugins/mailnotification/devicepluginmailnotification.h index d67981ba..2c2bef64 100644 --- a/plugins/deviceplugins/mailnotification/devicepluginmailnotification.h +++ b/plugins/deviceplugins/mailnotification/devicepluginmailnotification.h @@ -33,7 +33,7 @@ public: explicit DevicePluginMailNotification(); ~DevicePluginMailNotification(); - QPair setupDevice(Device *device) override; + DeviceManager::DeviceSetupStatus setupDevice(Device *device) override; DeviceManager::HardwareResources requiredHardware() const override; DeviceManager::DeviceError executeAction(Device *device, const Action &action) override; diff --git a/plugins/deviceplugins/mock/devicepluginmock.cpp b/plugins/deviceplugins/mock/devicepluginmock.cpp index 7bf3d176..8cb43184 100644 --- a/plugins/deviceplugins/mock/devicepluginmock.cpp +++ b/plugins/deviceplugins/mock/devicepluginmock.cpp @@ -58,20 +58,21 @@ DeviceManager::DeviceError DevicePluginMock::discoverDevices(const DeviceClassId return DeviceManager::DeviceErrorAsync; } -QPair DevicePluginMock::setupDevice(Device *device) +DeviceManager::DeviceSetupStatus DevicePluginMock::setupDevice(Device *device) { qDebug() << "Mockdevice created returning true" << device->paramValue("httpport").toInt() << device->paramValue("async").toBool() << device->paramValue("broken").toBool(); if (device->paramValue("broken").toBool()) { - return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "This device is intentionally broken."); + qWarning() << "This device is intentionally broken."; + return DeviceManager::DeviceSetupStatusFailure; } HttpDaemon *daemon = new HttpDaemon(device, this); m_daemons.insert(device, daemon); if (!daemon->isListening()) { - qDebug() << "HTTP port opening failed."; - return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, QString("Could not bind port.")); + qWarning() << "HTTP port opening failed."; + return DeviceManager::DeviceSetupStatusFailure; } connect(daemon, &HttpDaemon::triggerEvent, this, &DevicePluginMock::triggerEvent); @@ -80,9 +81,9 @@ QPair DevicePluginMock::setupDevice(D if (device->paramValue("async").toBool()) { m_asyncSetupDevices.append(device); QTimer::singleShot(1000, this, SLOT(emitDeviceSetupFinished())); - return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync); + return DeviceManager::DeviceSetupStatusAsync; } - return reportDeviceSetup(); + return DeviceManager::DeviceSetupStatusSuccess; } void DevicePluginMock::deviceRemoved(Device *device) @@ -129,7 +130,6 @@ QList DevicePluginMock::configurationDescription() const DeviceManager::DeviceError DevicePluginMock::executeAction(Device *device, const Action &action) { if (!myDevices().contains(device)) { - qWarning() << "Should execute action for a device which doesn't seem to be mine."; return DeviceManager::DeviceErrorDeviceNotFound; } @@ -143,7 +143,6 @@ DeviceManager::DeviceError DevicePluginMock::executeAction(Device *device, const return DeviceManager::DeviceErrorSetupFailed; } - qDebug() << "Should execute action" << action.actionTypeId(); m_daemons.value(device)->actionExecuted(action.actionTypeId()); return DeviceManager::DeviceErrorNoError; } @@ -204,9 +203,9 @@ void DevicePluginMock::emitDeviceSetupFinished() qDebug() << "emitting setup finised"; Device *device = m_asyncSetupDevices.takeFirst(); if (device->paramValue("broken").toBool()) { - emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusFailure, QString("This device is intentionally broken")); + emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusFailure); } else { - emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess, QString()); + emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess); } } @@ -215,8 +214,8 @@ void DevicePluginMock::emitActionExecuted() QPair action = m_asyncActions.takeFirst(); if (action.first.actionTypeId() == mockActionIdAsync) { m_daemons.value(action.second)->actionExecuted(action.first.actionTypeId()); - emit actionExecutionFinished(action.first.id(), DeviceManager::DeviceErrorNoError, QString()); + emit actionExecutionFinished(action.first.id(), DeviceManager::DeviceErrorNoError); } else if (action.first.actionTypeId() == mockActionIdAsyncFailing) { - emit actionExecutionFinished(action.first.id(), DeviceManager::DeviceErrorSetupFailed, QString()); + emit actionExecutionFinished(action.first.id(), DeviceManager::DeviceErrorSetupFailed); } } diff --git a/plugins/deviceplugins/mock/devicepluginmock.h b/plugins/deviceplugins/mock/devicepluginmock.h index 1897707e..c328a5cc 100644 --- a/plugins/deviceplugins/mock/devicepluginmock.h +++ b/plugins/deviceplugins/mock/devicepluginmock.h @@ -39,7 +39,7 @@ public: DeviceManager::HardwareResources requiredHardware() const override; DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList ¶ms) override; - QPair setupDevice(Device *device) override; + DeviceManager::DeviceSetupStatus setupDevice(Device *device) override; void deviceRemoved(Device *device) override; void startMonitoringAutoDevices() override; diff --git a/plugins/deviceplugins/mock/httpdaemon.cpp b/plugins/deviceplugins/mock/httpdaemon.cpp index e19666e8..555a2854 100644 --- a/plugins/deviceplugins/mock/httpdaemon.cpp +++ b/plugins/deviceplugins/mock/httpdaemon.cpp @@ -160,7 +160,6 @@ QString HttpDaemon::generateWebPage() body.append(""); for (int i = 0; i < deviceClass.eventTypes().count(); ++i) { - qDebug() << "adding eventType" << deviceClass.eventTypes().at(i).name(); const EventType &eventType = deviceClass.eventTypes().at(i); body.append(QString( "" diff --git a/plugins/deviceplugins/openweathermap/devicepluginopenweathermap.cpp b/plugins/deviceplugins/openweathermap/devicepluginopenweathermap.cpp index 63c466c0..c3001bd2 100644 --- a/plugins/deviceplugins/openweathermap/devicepluginopenweathermap.cpp +++ b/plugins/deviceplugins/openweathermap/devicepluginopenweathermap.cpp @@ -325,18 +325,19 @@ DeviceManager::DeviceError DevicePluginOpenweathermap::discoverDevices(const Dev return DeviceManager::DeviceErrorAsync; } -QPair DevicePluginOpenweathermap::setupDevice(Device *device) +DeviceManager::DeviceSetupStatus DevicePluginOpenweathermap::setupDevice(Device *device) { foreach (Device *deviceListDevice, deviceManager()->findConfiguredDevices(openweathermapDeviceClassId)) { if(deviceListDevice->paramValue("id").toString() == device->paramValue("id").toString()){ - return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure,QString("Location " + device->paramValue("location").toString() + " already added.")); + qWarning() << QString("Location " + device->paramValue("location").toString() + "already in added"); + return DeviceManager::DeviceSetupStatusFailure; } } device->setName("Weather from OpenWeatherMap (" + device->paramValue("location").toString() + ")"); m_openweaher->update(device->paramValue("id").toString(), device->id()); - return reportDeviceSetup(DeviceManager::DeviceSetupStatusSuccess); + return DeviceManager::DeviceSetupStatusSuccess; } DeviceManager::HardwareResources DevicePluginOpenweathermap::requiredHardware() const diff --git a/plugins/deviceplugins/openweathermap/devicepluginopenweathermap.h b/plugins/deviceplugins/openweathermap/devicepluginopenweathermap.h index 97235d64..91de8183 100644 --- a/plugins/deviceplugins/openweathermap/devicepluginopenweathermap.h +++ b/plugins/deviceplugins/openweathermap/devicepluginopenweathermap.h @@ -36,7 +36,7 @@ public: OpenWeatherMap *m_openweaher; DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList ¶ms) override; - QPair setupDevice(Device *device) override; + DeviceManager::DeviceSetupStatus setupDevice(Device *device) override; DeviceManager::HardwareResources requiredHardware() const override; DeviceManager::DeviceError executeAction(Device *device, const Action &action) override; diff --git a/plugins/deviceplugins/philipshue/devicepluginphilipshue.cpp b/plugins/deviceplugins/philipshue/devicepluginphilipshue.cpp index 5df7a45e..465b74ff 100644 --- a/plugins/deviceplugins/philipshue/devicepluginphilipshue.cpp +++ b/plugins/deviceplugins/philipshue/devicepluginphilipshue.cpp @@ -77,7 +77,7 @@ DeviceManager::DeviceError DevicePluginPhilipsHue::discoverDevices(const DeviceC return DeviceManager::DeviceErrorAsync; } -QPair DevicePluginPhilipsHue::setupDevice(Device *device) +DeviceManager::DeviceSetupStatus DevicePluginPhilipsHue::setupDevice(Device *device) { qDebug() << "setupDevice" << device->params(); @@ -90,7 +90,8 @@ QPair DevicePluginPhilipsHue::setupDe device->setParamValue("number", light->id()); } else { // this shouldn't ever happen - return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "Device not configured yet and no discovered devices around."); + qWarning() << "Device not configured yet and no discovered devices around. This should not happen."; + return DeviceManager::DeviceSetupStatusFailure; } } else { // In this case it most likely comes from the config. Just read all values from there... @@ -116,11 +117,10 @@ QPair DevicePluginPhilipsHue::setupDe descriptorList.append(descriptor); } if (!descriptorList.isEmpty()) { - qDebug() << "adding" << descriptorList.count() << "autodevices"; metaObject()->invokeMethod(this, "autoDevicesAppeared", Qt::QueuedConnection, Q_ARG(DeviceClassId, hueDeviceClassId), Q_ARG(QList, descriptorList)); } - return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync); + return DeviceManager::DeviceSetupStatusAsync; } void DevicePluginPhilipsHue::deviceRemoved(Device *device) @@ -134,7 +134,7 @@ void DevicePluginPhilipsHue::deviceRemoved(Device *device) m_unconfiguredLights.append(light); } -QPair DevicePluginPhilipsHue::confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms) +DeviceManager::DeviceSetupStatus DevicePluginPhilipsHue::confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms) { Param ipParam; foreach (const Param ¶m, params) { @@ -143,7 +143,8 @@ QPair DevicePluginPhilipsHue::confirm } } if (!ipParam.isValid()) { - return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "Missing parameter: ip"); + qWarning() << "Missing parameter: ip"; + return DeviceManager::DeviceSetupStatusFailure; } Param usernameParam; foreach (const Param ¶m, params) { @@ -152,7 +153,8 @@ QPair DevicePluginPhilipsHue::confirm } } if (!usernameParam.isValid()) { - return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "Missing parameter: username"); + qWarning() << "Missing parameter: username"; + return DeviceManager::DeviceSetupStatusFailure; } int id = m_bridge->createUser(QHostAddress(ipParam.value().toString()), usernameParam.value().toString()); @@ -161,7 +163,7 @@ QPair DevicePluginPhilipsHue::confirm pi.ipParam = ipParam; pi.usernameParam = usernameParam; m_pairings.insert(id, pi); - return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync); + return DeviceManager::DeviceSetupStatusAsync; } void DevicePluginPhilipsHue::guhTimer() @@ -173,8 +175,6 @@ void DevicePluginPhilipsHue::guhTimer() DeviceManager::DeviceError DevicePluginPhilipsHue::executeAction(Device *device, const Action &action) { - qDebug() << "Should execute action in hue plugin"; - Light *light = m_lights.key(device); if (!light) { return DeviceManager::DeviceErrorDeviceNotFound; @@ -222,7 +222,7 @@ void DevicePluginPhilipsHue::createUserFinished(int id, const QVariant &response PairingInfo pairingInfo = m_pairings.take(id); if (response.toMap().contains("error")) { qDebug() << "Failed to pair Hue bridge:" << response.toMap().value("error").toMap().value("description"); - emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusFailure, "Pairing failed:" + response.toMap().value("error").toMap().value("description").toString()); + emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusFailure); return; } @@ -240,7 +240,7 @@ void DevicePluginPhilipsHue::getLightsFinished(int id, const QVariant ¶ms) if (params.toMap().count() == 0) { qWarning() << "No light bulbs found on this hue bridge... Cannot proceed with pairing."; - emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusFailure, "No light bulbs found on this Hue bridge."); + emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusFailure); return; } @@ -250,7 +250,7 @@ void DevicePluginPhilipsHue::getLightsFinished(int id, const QVariant ¶ms) m_unconfiguredLights.insert(lightId.toInt(), light); } - emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusSuccess, QString()); + emit pairingFinished(pairingInfo.pairingTransactionId, DeviceManager::DeviceSetupStatusSuccess); // If we have more than one device on that bridge, tell DeviceManager that there are more. if (params.toMap().count() > 1) { @@ -271,7 +271,7 @@ void DevicePluginPhilipsHue::lightStateChanged() if (m_asyncSetups.contains(light)) { device = m_asyncSetups.take(light); device->setName(light->name()); - emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess, QString()); + emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusSuccess); } else { device = m_lights.value(light); } diff --git a/plugins/deviceplugins/philipshue/devicepluginphilipshue.h b/plugins/deviceplugins/philipshue/devicepluginphilipshue.h index 65c8637b..50f1e78c 100644 --- a/plugins/deviceplugins/philipshue/devicepluginphilipshue.h +++ b/plugins/deviceplugins/philipshue/devicepluginphilipshue.h @@ -43,10 +43,10 @@ public: QList configurationDescription() const override; DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList ¶ms) override; - QPair setupDevice(Device *device) override; + DeviceManager::DeviceSetupStatus setupDevice(Device *device) override; void deviceRemoved(Device *device) override; - QPair confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms) override; + DeviceManager::DeviceSetupStatus confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms) override; void guhTimer() override; @@ -67,7 +67,7 @@ private: class PairingInfo { public: - QUuid pairingTransactionId; + PairingTransactionId pairingTransactionId; Param ipParam; Param usernameParam; }; diff --git a/plugins/deviceplugins/wemo/devicepluginwemo.cpp b/plugins/deviceplugins/wemo/devicepluginwemo.cpp index be2ce8c4..a51f068a 100644 --- a/plugins/deviceplugins/wemo/devicepluginwemo.cpp +++ b/plugins/deviceplugins/wemo/devicepluginwemo.cpp @@ -157,13 +157,13 @@ DeviceManager::DeviceError DevicePluginWemo::discoverDevices(const DeviceClassId return DeviceManager::DeviceErrorAsync; } -QPair DevicePluginWemo::setupDevice(Device *device) +DeviceManager::DeviceSetupStatus DevicePluginWemo::setupDevice(Device *device) { if(device->deviceClassId() == wemoSwitchDeviceClassId){ foreach (WemoSwitch *wemoSwitch, m_wemoSwitches.keys()) { if(wemoSwitch->serialNumber() == device->paramValue("serial number").toString()){ qWarning() << wemoSwitch->serialNumber() << " allready exists..."; - return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure,QString("Device allready added")); + return DeviceManager::DeviceSetupStatusFailure; } } @@ -186,9 +186,9 @@ QPair DevicePluginWemo::setupDevice(D m_wemoSwitches.insert(wemoSwitch,device); wemoSwitch->refresh(); - return reportDeviceSetup(); + return DeviceManager::DeviceSetupStatusSuccess; } - return reportDeviceSetup(DeviceManager::DeviceSetupStatusSuccess); + return DeviceManager::DeviceSetupStatusSuccess; } DeviceManager::HardwareResources DevicePluginWemo::requiredHardware() const @@ -267,9 +267,9 @@ void DevicePluginWemo::wemoSwitchStateChanged() void DevicePluginWemo::setPowerFinished(const bool &succeeded, const ActionId &actionId) { if(succeeded){ - emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorNoError,QString()); + emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorNoError); }else{ - emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorDeviceNotFound,QString("Action could not be executed.")); + emit actionExecutionFinished(actionId,DeviceManager::DeviceErrorHardwareFailure); } } diff --git a/plugins/deviceplugins/wemo/devicepluginwemo.h b/plugins/deviceplugins/wemo/devicepluginwemo.h index 6605f40c..7e2fa376 100644 --- a/plugins/deviceplugins/wemo/devicepluginwemo.h +++ b/plugins/deviceplugins/wemo/devicepluginwemo.h @@ -33,7 +33,7 @@ public: explicit DevicePluginWemo(); DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList ¶ms) override; - QPair setupDevice(Device *device) override; + DeviceManager::DeviceSetupStatus setupDevice(Device *device) override; DeviceManager::HardwareResources requiredHardware() const override; DeviceManager::DeviceError executeAction(Device *device, const Action &action) override; diff --git a/server/guhcore.cpp b/server/guhcore.cpp index 129d831d..debf8da5 100644 --- a/server/guhcore.cpp +++ b/server/guhcore.cpp @@ -63,7 +63,7 @@ QList GuhCore::plugins() const return m_deviceManager->plugins(); } -QPair GuhCore::setPluginConfig(const PluginId &pluginId, const ParamList ¶ms) +DeviceManager::DeviceError GuhCore::setPluginConfig(const PluginId &pluginId, const ParamList ¶ms) { return m_deviceManager->setPluginConfig(pluginId, params); } @@ -78,7 +78,7 @@ QList GuhCore::supportedDevices(const VendorId &vendorId) const return m_deviceManager->supportedDevices(vendorId); } -QPair GuhCore::removeConfiguredDevice(const DeviceId &deviceId, const QHash &removePolicyList) +DeviceManager::DeviceError GuhCore::removeConfiguredDevice(const DeviceId &deviceId, const QHash &removePolicyList) { QHash toBeChanged; QList unhandledRules; @@ -97,7 +97,8 @@ QPair GuhCore::removeConfiguredDevice(const } if (!unhandledRules.isEmpty()) { - return qMakePair(DeviceManager::DeviceErrorMissingParameter, "There are unhandled rules which depend on this device."); + qWarning() << "There are unhandled rules which depend on this device."; + return DeviceManager::DeviceErrorDeviceInUse; } // Update the rules... @@ -112,17 +113,17 @@ QPair GuhCore::removeConfiguredDevice(const return m_deviceManager->removeConfiguredDevice(deviceId); } -QPair GuhCore::pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId) +DeviceManager::DeviceError GuhCore::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId) { - return m_deviceManager->pairDevice(deviceClassId, deviceDescriptorId); + return m_deviceManager->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId); } -QPair GuhCore::pairDevice(const DeviceClassId &deviceClassId, const ParamList ¶ms) +DeviceManager::DeviceError GuhCore::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms) { - return m_deviceManager->pairDevice(deviceClassId, params); + return m_deviceManager->pairDevice(pairingTransactionId, deviceClassId, params); } -QPair GuhCore::confirmPairing(const QUuid &pairingTransactionId, const QString &secret) +DeviceManager::DeviceError GuhCore::confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret) { return m_deviceManager->confirmPairing(pairingTransactionId, secret); } @@ -259,7 +260,7 @@ void GuhCore::gotEvent(const Event &event) case DeviceManager::DeviceErrorSetupFailed: qDebug() << "Error executing action. Device setup failed."; break; - case DeviceManager::DeviceErrorActionParameterError: + case DeviceManager::DeviceErrorInvalidParameter: qDebug() << "Error executing action. Invalid action parameter."; break; default: diff --git a/server/guhcore.h b/server/guhcore.h index f7e74fc7..cb74798b 100644 --- a/server/guhcore.h +++ b/server/guhcore.h @@ -43,7 +43,7 @@ public: void destroy(); QList plugins() const; - QPair setPluginConfig(const PluginId &pluginId, const ParamList ¶ms); + DeviceManager::DeviceError setPluginConfig(const PluginId &pluginId, const ParamList ¶ms); // Device handling QList supportedVendors() const; @@ -55,11 +55,11 @@ public: QList configuredDevices() const; Device *findConfiguredDevice(const DeviceId &deviceId) const; QList findConfiguredDevices(const DeviceClassId &deviceClassId) const; - QPair removeConfiguredDevice(const DeviceId &deviceId, const QHash &removePolicyList); + DeviceManager::DeviceError removeConfiguredDevice(const DeviceId &deviceId, const QHash &removePolicyList); - QPair pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId); - QPair pairDevice(const DeviceClassId &deviceClassId, const ParamList ¶ms); - QPair confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString()); + DeviceManager::DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId); + DeviceManager::DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList ¶ms); + DeviceManager::DeviceError confirmPairing(const PairingTransactionId &pairingTransactionId, const QString &secret = QString()); DeviceManager::DeviceError executeAction(const Action &action); @@ -73,11 +73,11 @@ public: signals: void eventTriggered(const Event &event); void deviceStateChanged(Device *device, const QUuid &stateTypeId, const QVariant &value); - void actionExecuted(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage); + void actionExecuted(const ActionId &id, DeviceManager::DeviceError status); void devicesDiscovered(const DeviceClassId &deviceClassId, const QList deviceDescriptors); void deviceSetupFinished(Device *device, DeviceManager::DeviceError status); - void pairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceError status, const QString &errorMessage, const DeviceId &deviceId); + void pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceError status, const DeviceId &deviceId); private: RuleEngine *ruleEngine() const; diff --git a/server/jsonrpc/actionhandler.cpp b/server/jsonrpc/actionhandler.cpp index eba91d44..da8a2872 100644 --- a/server/jsonrpc/actionhandler.cpp +++ b/server/jsonrpc/actionhandler.cpp @@ -33,15 +33,14 @@ ActionHandler::ActionHandler(QObject *parent) : params.clear(); returns.clear(); setDescription("ExecuteAction", "Execute a single action."); setParams("ExecuteAction", JsonTypes::actionDescription()); - returns.insert("success", "bool"); - returns.insert("errorMessage", "string"); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); setReturns("ExecuteAction", returns); params.clear(); returns.clear(); setDescription("GetActionType", "Get the ActionType for the given ActionTypeId"); - params.insert("actionTypeId", "uuid"); + params.insert("actionTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("GetActionType", params); - returns.insert("deviceError", "int"); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); returns.insert("o:actionType", JsonTypes::actionTypeDescription()); setReturns("GetActionType", returns); @@ -63,9 +62,6 @@ JsonReply* ActionHandler::ExecuteAction(const QVariantMap ¶ms) Action action(actionTypeId, deviceId); action.setParams(actionParams); - qDebug() << "actions params in json" << action.params() << params; - - DeviceManager::DeviceError status = GuhCore::instance()->executeAction(action); if (status == DeviceManager::DeviceErrorAsync) { JsonReply *reply = createAsyncReply("ExecuteAction"); @@ -73,9 +69,7 @@ JsonReply* ActionHandler::ExecuteAction(const QVariantMap ¶ms) return reply; } - QVariantMap returns; - returns.insert("deviceError", status); - return createReply(returns); + return createReply(statusToReply(status)); } JsonReply *ActionHandler::GetActionType(const QVariantMap ¶ms) const @@ -84,32 +78,29 @@ JsonReply *ActionHandler::GetActionType(const QVariantMap ¶ms) const foreach (const DeviceClass &deviceClass, GuhCore::instance()->supportedDevices()) { foreach (const ActionType &actionType, deviceClass.actionTypes()) { if (actionType.id() == actionTypeId) { - QVariantMap data; - data.insert("deviceError", DeviceManager::DeviceErrorNoError); + QVariantMap data = statusToReply(DeviceManager::DeviceErrorNoError); data.insert("actionType", JsonTypes::packActionType(actionType)); return createReply(data); } } } - QVariantMap data; - data.insert("deviceError", DeviceManager::DeviceErrorActionTypeNotFound); - return createReply(data); + return createReply(statusToReply(DeviceManager::DeviceErrorActionTypeNotFound)); } -void ActionHandler::actionExecuted(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage) +void ActionHandler::actionExecuted(const ActionId &id, DeviceManager::DeviceError status) { if (!m_asyncActionExecutions.contains(id)) { return; // Not the action we are waiting for. } JsonReply *reply = m_asyncActionExecutions.take(id); - reply->setData(statusToReply(status, errorMessage)); + reply->setData(statusToReply(status)); reply->finished(); } -QVariantMap ActionHandler::statusToReply(DeviceManager::DeviceError status, const QString &errorMessage) +QVariantMap ActionHandler::statusToReply(DeviceManager::DeviceError status) const { QVariantMap returns; - returns.insert("deviceError", status); + returns.insert("deviceError", JsonTypes::deviceErrorToString(status)); return returns; } diff --git a/server/jsonrpc/actionhandler.h b/server/jsonrpc/actionhandler.h index 9288e040..173bd4d7 100644 --- a/server/jsonrpc/actionhandler.h +++ b/server/jsonrpc/actionhandler.h @@ -35,10 +35,10 @@ public: Q_INVOKABLE JsonReply* GetActionType(const QVariantMap ¶ms) const; private slots: - void actionExecuted(const ActionId &id, DeviceManager::DeviceError status, const QString &errorMessage); + void actionExecuted(const ActionId &id, DeviceManager::DeviceError status); private: - QVariantMap statusToReply(DeviceManager::DeviceError status, const QString &errorMessage); + QVariantMap statusToReply(DeviceManager::DeviceError status) const; private: QHash m_asyncActionExecutions; diff --git a/server/jsonrpc/devicehandler.cpp b/server/jsonrpc/devicehandler.cpp index bf6e162a..b259e93f 100644 --- a/server/jsonrpc/devicehandler.cpp +++ b/server/jsonrpc/devicehandler.cpp @@ -41,7 +41,7 @@ DeviceHandler::DeviceHandler(QObject *parent) : params.clear(); returns.clear(); setDescription("GetSupportedDevices", "Returns a list of supported Device classes, optionally filtered by vendorId."); - params.insert("o:vendorId", "uuid"); + params.insert("o:vendorId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("GetSupportedDevices", params); QVariantList deviceClasses; deviceClasses.append(JsonTypes::deviceClassRef()); @@ -58,20 +58,20 @@ DeviceHandler::DeviceHandler(QObject *parent) : params.clear(); returns.clear(); setDescription("GetPluginConfiguration", "Get a plugin's params."); - params.insert("pluginId", "uuid"); + params.insert("pluginId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("GetPluginConfiguration", params); QVariantList pluginParams; pluginParams.append(JsonTypes::paramRef()); - returns.insert("deviceError", "DeviceError"); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); returns.insert("o:configuration", pluginParams); setReturns("GetPluginConfiguration", returns); params.clear(); returns.clear(); setDescription("SetPluginConfiguration", "Set a plugin's params."); - params.insert("pluginId", "uuid"); + params.insert("pluginId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); params.insert("configuration", pluginParams); setParams("SetPluginConfiguration", params); - returns.insert("deviceError", "DeviceError"); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); setReturns("SetPluginConfiguration", returns); params.clear(); returns.clear(); @@ -81,14 +81,14 @@ DeviceHandler::DeviceHandler(QObject *parent) : "CreateMethodJustAdd takes the parameters you want to have with that device. " "CreateMethodDiscovery requires the use of a deviceDescriptorId." ); - params.insert("deviceClassId", "uuid"); - params.insert("o:deviceDescriptorId", "uuid"); + params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); + params.insert("o:deviceDescriptorId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); QVariantList deviceParams; deviceParams.append(JsonTypes::paramRef()); params.insert("o:deviceParams", deviceParams); setParams("AddConfiguredDevice", params); - returns.insert("deviceError", "DeviceError"); - returns.insert("o:deviceId", "uuid"); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); + returns.insert("o:deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setReturns("AddConfiguredDevice", returns); returns.clear(); // Reused params from above! @@ -102,19 +102,19 @@ DeviceHandler::DeviceHandler(QObject *parent) : " or PairDevice." ); setParams("PairDevice", params); - returns.insert("deviceError", "DeviceError"); - returns.insert("o:pairingTransactionId", "uuid"); - returns.insert("o:displayMessage", "string"); - returns.insert("o:setupMethod", JsonTypes::setupMethodTypesRef()); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); + returns.insert("o:pairingTransactionId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); + returns.insert("o:displayMessage", JsonTypes::basicTypeToString(JsonTypes::String)); + returns.insert("o:setupMethod", JsonTypes::setupMethodRef()); setReturns("PairDevice", returns); params.clear(); returns.clear(); setDescription("ConfirmPairing", "Confirm an ongoing pairing. In case of SetupMethodEnterPin also provide the pin in the params."); - params.insert("pairingTransactionId", "uuid"); - params.insert("o:secret", "string"); + params.insert("pairingTransactionId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); + params.insert("o:secret", JsonTypes::basicTypeToString(JsonTypes::String)); setParams("ConfirmPairing", params); - returns.insert("deviceError", "DeviceError"); - returns.insert("o:deviceId", "uuid"); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); + returns.insert("o:deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setReturns("ConfirmPairing", returns); params.clear(); returns.clear(); @@ -127,12 +127,12 @@ DeviceHandler::DeviceHandler(QObject *parent) : params.clear(); returns.clear(); setDescription("GetDiscoveredDevices", "Performs a device discovery and returns the results. This function may take a while to return."); - params.insert("deviceClassId", "uuid"); + params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); QVariantList discoveryParams; discoveryParams.append(JsonTypes::paramRef()); params.insert("o:discoveryParams", discoveryParams); setParams("GetDiscoveredDevices", params); - returns.insert("deviceError", "DeviceError"); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); QVariantList deviceDescriptors; deviceDescriptors.append(JsonTypes::deviceDescriptorRef()); returns.insert("o:deviceDescriptors", deviceDescriptors); @@ -140,20 +140,20 @@ DeviceHandler::DeviceHandler(QObject *parent) : params.clear(); returns.clear(); setDescription("RemoveConfiguredDevice", "Remove a device from the system."); - params.insert("deviceId", "uuid"); + params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); QVariantList removePolicyList; QVariantMap policy; - policy.insert("ruleId", "uuid"); - policy.insert("policy", JsonTypes::removePolicyTypesRef()); + policy.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); + policy.insert("policy", JsonTypes::removePolicyRef()); removePolicyList.append(policy); params.insert("o:removePolicyList", removePolicyList); setParams("RemoveConfiguredDevice", params); - returns.insert("deviceError", "DeviceError"); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); setReturns("RemoveConfiguredDevice", returns); params.clear(); returns.clear(); setDescription("GetEventTypes", "Get event types for a specified deviceClassId."); - params.insert("deviceClassId", "uuid"); + params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("GetEventTypes", params); QVariantList events; events.append(JsonTypes::eventTypeRef()); @@ -162,7 +162,7 @@ DeviceHandler::DeviceHandler(QObject *parent) : params.clear(); returns.clear(); setDescription("GetActionTypes", "Get action types for a specified deviceClassId."); - params.insert("deviceClassId", "uuid"); + params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("GetActionTypes", params); QVariantList actions; actions.append(JsonTypes::actionTypeRef()); @@ -171,7 +171,7 @@ DeviceHandler::DeviceHandler(QObject *parent) : params.clear(); returns.clear(); setDescription("GetStateTypes", "Get state types for a specified deviceClassId."); - params.insert("deviceClassId", "uuid"); + params.insert("deviceClassId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("GetStateTypes", params); QVariantList states; states.append(JsonTypes::stateTypeRef()); @@ -180,19 +180,19 @@ DeviceHandler::DeviceHandler(QObject *parent) : params.clear(); returns.clear(); setDescription("GetStateValue", "Get the value of the given device and the given stateType"); - params.insert("deviceId", "uuid"); - params.insert("stateTypeId", "uuid"); + params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); + params.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("GetStateValue", params); - returns.insert("deviceError", "DeviceError"); - returns.insert("o:value", "variant"); + returns.insert("deviceError", JsonTypes::deviceErrorRef()); + returns.insert("o:value", JsonTypes::basicTypeToString(JsonTypes::Variant)); setReturns("GetStateValue", returns); // Notifications params.clear(); returns.clear(); setDescription("StateChanged", "Emitted whenever a State of a device changes."); - params.insert("deviceId", "uuid"); - params.insert("stateTypeId", "uuid"); - params.insert("variant", "value"); + params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); + params.insert("stateTypeId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); + params.insert("value", JsonTypes::basicTypeToString(JsonTypes::Variant)); setParams("StateChanged", params); connect(GuhCore::instance(), &GuhCore::deviceStateChanged, this, &DeviceHandler::deviceStateChanged); @@ -249,7 +249,7 @@ JsonReply *DeviceHandler::GetDiscoveredDevices(const QVariantMap ¶ms) const m_discoverRequests.insert(deviceClassId, reply); return reply; } - returns.insert("deviceError", status); + returns.insert("deviceError", JsonTypes::deviceErrorToString(status)); return createReply(returns); } @@ -284,8 +284,7 @@ JsonReply *DeviceHandler::GetPluginConfiguration(const QVariantMap ¶ms) cons QVariantMap returns; if (!plugin) { - returns.insert("success", false); - returns.insert("errorMessage", QString("Plugin not found: %1").arg(params.value("pluginId").toString())); + returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorPluginNotFound)); return createReply(returns); } @@ -294,8 +293,7 @@ JsonReply *DeviceHandler::GetPluginConfiguration(const QVariantMap ¶ms) cons paramVariantList.append(JsonTypes::packParam(param)); } returns.insert("configuration", paramVariantList); - returns.insert("success", true); - returns.insert("errorMessage", QString()); + returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorNoError)); return createReply(returns); } @@ -304,9 +302,8 @@ JsonReply* DeviceHandler::SetPluginConfiguration(const QVariantMap ¶ms) QVariantMap returns; PluginId pluginId = PluginId(params.value("pluginId").toString()); ParamList pluginParams = JsonTypes::unpackParams(params.value("configuration").toList()); - QPair result = GuhCore::instance()->setPluginConfig(pluginId, pluginParams); - returns.insert("success", result.first == DeviceManager::DeviceErrorNoError); - returns.insert("errorMessage", result.second); + DeviceManager::DeviceError result = GuhCore::instance()->setPluginConfig(pluginId, pluginParams); + returns.insert("deviceError", JsonTypes::deviceErrorToString(result)); return createReply(returns); } @@ -318,10 +315,8 @@ JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap ¶ms) DeviceId newDeviceId = DeviceId::createDeviceId(); DeviceManager::DeviceError status; if (deviceDescriptorId.isNull()) { - qDebug() << "adding a manual device."; status = GuhCore::instance()->addConfiguredDevice(deviceClass, deviceParams, newDeviceId); } else { - qDebug() << "adding a discovered device."; status = GuhCore::instance()->addConfiguredDevice(deviceClass, deviceDescriptorId, newDeviceId); } QVariantMap returns; @@ -334,7 +329,7 @@ JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap ¶ms) case DeviceManager::DeviceErrorNoError: returns.insert("deviceId", newDeviceId); default: - returns.insert("deviceError", status); + returns.insert("deviceError", JsonTypes::deviceErrorToString(status)); } return createReply(returns); } @@ -344,65 +339,40 @@ JsonReply *DeviceHandler::PairDevice(const QVariantMap ¶ms) DeviceClassId deviceClassId(params.value("deviceClassId").toString()); DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(deviceClassId); - QPair status; + DeviceManager::DeviceError status; + PairingTransactionId pairingTransactionId = PairingTransactionId::createPairingTransactionId(); if (params.contains("deviceDescriptorId")) { DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString()); - status = GuhCore::instance()->pairDevice(deviceClassId, deviceDescriptorId); + status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId); } else { ParamList deviceParams = JsonTypes::unpackParams(params.value("deviceParams").toList()); - status = GuhCore::instance()->pairDevice(deviceClassId, deviceParams); + status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceParams); } QVariantMap returns; - switch (status.first) { - case DeviceManager::DeviceErrorNoError: - returns.insert("success", true); - returns.insert("errorMessage", ""); + returns.insert("deviceError", JsonTypes::deviceErrorToString(status)); + if (status == DeviceManager::DeviceErrorNoError) { returns.insert("displayMessage", deviceClass.pairingInfo()); - returns.insert("pairingTransactionId", status.second); - returns.insert("setupMethod", JsonTypes::setupMethodTypes().at(deviceClass.setupMethod())); - break; - case DeviceManager::DeviceErrorDeviceClassNotFound: - returns.insert("errorMessage", QString("Error pairing device. Device class not found: %1").arg(status.second)); - returns.insert("success", false); - break; - case DeviceManager::DeviceErrorDeviceDescriptorNotFound: - returns.insert("errorMessage", QString("Error pairing device. Device descriptor not found: %1").arg(status.second)); - returns.insert("success", false); - break; - case DeviceManager::DeviceErrorCreationMethodNotSupported: - returns.insert("errorMessage", QString("Error pairing device. This device can't be created this way: %1").arg(status.second)); - returns.insert("success", false); - break; - case DeviceManager::DeviceErrorPairingTransactionIdNotFound: - returns.insert("errorMessage", QString("Error pairing device. PairingTransactionId not found: %1").arg(status.second)); - returns.insert("success", false); - break; + returns.insert("pairingTransactionId", pairingTransactionId.toString()); + returns.insert("setupMethod", JsonTypes::setupMethod().at(deviceClass.setupMethod())); } return createReply(returns); } JsonReply *DeviceHandler::ConfirmPairing(const QVariantMap ¶ms) { - QUuid pairingTransactionId = params.value("pairingTransactionId").toUuid(); + PairingTransactionId pairingTransactionId = PairingTransactionId(params.value("pairingTransactionId").toString()); QString secret = params.value("secret").toString(); - QPair status = GuhCore::instance()->confirmPairing(pairingTransactionId, secret); + DeviceManager::DeviceError status = GuhCore::instance()->confirmPairing(pairingTransactionId, secret); JsonReply *reply = 0; - QVariantMap returns; - switch (status.first) { - case DeviceManager::DeviceErrorAsync: + if (status == DeviceManager::DeviceErrorAsync) { reply = createAsyncReply("ConfirmPairing"); m_asyncPairingRequests.insert(pairingTransactionId, reply); return reply; - case DeviceManager::DeviceErrorNoError: - returns.insert("success", true); - returns.insert("errorMessage", QString()); - case DeviceManager::DeviceErrorSetupFailed: - default: - returns.insert("success", false); - returns.insert("errorMessage", status.second); } + QVariantMap returns; + returns.insert("deviceError", JsonTypes::deviceErrorToString(status)); reply = createReply(returns); return reply; } @@ -430,25 +400,8 @@ JsonReply* DeviceHandler::RemoveConfiguredDevice(const QVariantMap ¶ms) } QVariantMap returns; - QPair status = GuhCore::instance()->removeConfiguredDevice(deviceId, removePolicyList); - switch(status.first) { - case DeviceManager::DeviceErrorNoError: - returns.insert("success", true); - returns.insert("errorMessage", ""); - break; - case DeviceManager::DeviceErrorDeviceNotFound: - returns.insert("success", false); - returns.insert("errorMessage", QString("No such device: %1").arg(status.second)); - break; - case DeviceManager::DeviceErrorMissingParameter: - returns.insert("success", false); - returns.insert("errorMessage", QString("Missing Parameter: %1").arg(status.second)); - break; - default: - returns.insert("success", false); - returns.insert("errorMessage", "Unknown error."); - break; - } + DeviceManager::DeviceError status = GuhCore::instance()->removeConfiguredDevice(deviceId, removePolicyList); + returns.insert("deviceError", JsonTypes::deviceErrorToString(status)); return createReply(returns); } @@ -497,19 +450,16 @@ JsonReply* DeviceHandler::GetStateValue(const QVariantMap ¶ms) const Device *device = GuhCore::instance()->findConfiguredDevice(DeviceId(params.value("deviceId").toString())); if (!device) { - returns.insert("success", false); - returns.insert("errorMessage", "No such device"); + returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorDeviceNotFound)); return createReply(returns); } if (!device->hasState(StateTypeId(params.value("stateTypeId").toString()))) { - returns.insert("success", false); - returns.insert("errorMessage", QString("Device %1 %2 doesn't have such a state.").arg(device->name()).arg(device->id().toString())); + returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorStateTypeNotFound)); return createReply(returns); } QVariant stateValue = device->stateValue(StateTypeId(params.value("stateTypeId").toString())); - returns.insert("success", true); - returns.insert("errorMessage", ""); + returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorNoError)); returns.insert("value", stateValue); return createReply(returns); } @@ -537,8 +487,7 @@ void DeviceHandler::devicesDiscovered(const DeviceClassId &deviceClassId, const } QVariantMap returns; returns.insert("deviceDescriptors", list); - returns.insert("success", true); - returns.insert("errorMessage", ""); + returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorNoError)); reply->setData(returns); reply->finished(); @@ -554,24 +503,16 @@ void DeviceHandler::deviceSetupFinished(Device *device, DeviceManager::DeviceErr JsonReply *reply = m_asynDeviceAdditions.take(device->id()); QVariantMap returns; + returns.insert("deviceError", JsonTypes::deviceErrorToString(status)); if(status == DeviceManager::DeviceErrorNoError) { - returns.insert("success", true); - returns.insert("errorMessage", ""); returns.insert("deviceId", device->id()); - } else if (status == DeviceManager::DeviceErrorSetupFailed) { - returns.insert("errorMessage", QString("Error creating device. Device setup failed.")); - returns.insert("success", false); - } else { - Q_ASSERT_X(false, "DeviceHandler", "Unhandled status code for deviceSetupFinished"); - returns.insert("errorMessage", "Unknown error."); - returns.insert("success", false); } reply->setData(returns); reply->finished(); } -void DeviceHandler::pairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceError status, const QString &errorMessage, const DeviceId &deviceId) +void DeviceHandler::pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceError status, const DeviceId &deviceId) { qDebug() << "handler: pairing finished"; JsonReply *reply = m_asyncPairingRequests.take(pairingTransactionId); @@ -582,8 +523,7 @@ void DeviceHandler::pairingFinished(const QUuid &pairingTransactionId, DeviceMan if (status != DeviceManager::DeviceErrorNoError) { QVariantMap returns; - returns.insert("success", false); - returns.insert("errorMessage", errorMessage); + returns.insert("deviceError", JsonTypes::deviceErrorToString(status)); reply->setData(returns); reply->finished(); return; diff --git a/server/jsonrpc/devicehandler.h b/server/jsonrpc/devicehandler.h index 978f4e91..d083299e 100644 --- a/server/jsonrpc/devicehandler.h +++ b/server/jsonrpc/devicehandler.h @@ -70,7 +70,7 @@ private slots: void deviceSetupFinished(Device *device, DeviceManager::DeviceError status); - void pairingFinished(const QUuid &pairingTransactionId, DeviceManager::DeviceError status, const QString &errorMessage, const DeviceId &deviceId); + void pairingFinished(const PairingTransactionId &pairingTransactionId, DeviceManager::DeviceError status, const DeviceId &deviceId); private: // A cache for async replies diff --git a/server/jsonrpc/jsonrpcserver.cpp b/server/jsonrpc/jsonrpcserver.cpp index 4aeb37f9..98f4a392 100644 --- a/server/jsonrpc/jsonrpcserver.cpp +++ b/server/jsonrpc/jsonrpcserver.cpp @@ -42,7 +42,7 @@ #include #include -#define JSON_PROTOCOL_VERSION 5 +#define JSON_PROTOCOL_VERSION 6 JsonRPCServer::JsonRPCServer(QObject *parent): JsonHandler(parent), @@ -60,23 +60,22 @@ JsonRPCServer::JsonRPCServer(QObject *parent): params.clear(); returns.clear(); setDescription("Introspect", "Introspect this API."); setParams("Introspect", params); - returns.insert("methods", "object"); - returns.insert("types", "object"); + returns.insert("methods", JsonTypes::basicTypeToString(JsonTypes::Object)); + returns.insert("types", JsonTypes::basicTypeToString(JsonTypes::Object)); setReturns("Introspect", returns); params.clear(); returns.clear(); setDescription("Version", "Version of this Guh/JSONRPC interface."); setParams("Version", params); - returns.insert("version", "string"); - returns.insert("protocol version", "string"); + returns.insert("version", JsonTypes::basicTypeToString(JsonTypes::String)); + returns.insert("protocol version", JsonTypes::basicTypeToString(JsonTypes::String)); setReturns("Version", returns); params.clear(); returns.clear(); setDescription("SetNotificationStatus", "Enable/Disable notifications for this connections."); - params.insert("enabled", "bool"); + params.insert("enabled", JsonTypes::basicTypeToString(JsonTypes::Bool)); setParams("SetNotificationStatus", params); - returns.insert("success", "bool"); - returns.insert("enabled", "bool"); + returns.insert("enabled", JsonTypes::basicTypeToString(JsonTypes::Bool)); setReturns("SetNotificationStatus", returns); // Now set up the logic @@ -130,7 +129,6 @@ JsonReply* JsonRPCServer::SetNotificationStatus(const QVariantMap ¶ms) // qDebug() << "got client socket" << clientId; m_clients[clientId] = params.value("enabled").toBool(); QVariantMap returns; - returns.insert("success", "true"); returns.insert("enabled", m_clients[clientId]); return createReply(returns); } @@ -198,7 +196,6 @@ void JsonRPCServer::processData(const QUuid &clientId, const QByteArray &jsonDat JsonReply *reply; QMetaObject::invokeMethod(handler, method.toLatin1().data(), Q_RETURN_ARG(JsonReply*, reply), Q_ARG(QVariantMap, params)); if (reply->type() == JsonReply::TypeAsync) { - qDebug() << "got an async reply..."; reply->setClientId(clientId); reply->setCommandId(commandId); connect(reply, &JsonReply::finished, this, &JsonRPCServer::asyncReplyFinished); @@ -238,7 +235,6 @@ void JsonRPCServer::sendNotification(const QVariantMap ¶ms) void JsonRPCServer::asyncReplyFinished() { JsonReply *reply = qobject_cast(sender()); - qDebug() << "got async reply:" << reply->method() << reply->data(); Q_ASSERT(reply->handler()->validateReturns(reply->method(), reply->data()).first); sendResponse(reply->clientId(), reply->commandId(), reply->data()); reply->deleteLater(); diff --git a/server/jsonrpc/jsontypes.cpp b/server/jsonrpc/jsontypes.cpp index 4e12c6e4..f89fd1d6 100644 --- a/server/jsonrpc/jsontypes.cpp +++ b/server/jsonrpc/jsontypes.cpp @@ -30,14 +30,14 @@ bool JsonTypes::s_initialized = false; QString JsonTypes::s_lastError; -QVariantList JsonTypes::s_basicTypes; -QVariantList JsonTypes::s_stateOperatorTypes; -QVariantList JsonTypes::s_valueOperatorTypes; -QVariantList JsonTypes::s_createMethodTypes; -QVariantList JsonTypes::s_setupMethodTypes; -QVariantList JsonTypes::s_removePolicyTypes; -QVariantList JsonTypes::s_deviceErrorTypes; -QVariantList JsonTypes::s_ruleErrorTypes; +QVariantList JsonTypes::s_basicType; +QVariantList JsonTypes::s_stateOperator; +QVariantList JsonTypes::s_valueOperator; +QVariantList JsonTypes::s_createMethod; +QVariantList JsonTypes::s_setupMethod; +QVariantList JsonTypes::s_removePolicy; +QVariantList JsonTypes::s_deviceError; +QVariantList JsonTypes::s_ruleError; QVariantMap JsonTypes::s_paramType; QVariantMap JsonTypes::s_param; @@ -61,114 +61,114 @@ QVariantMap JsonTypes::s_rule; void JsonTypes::init() { // BasicTypes - s_basicTypes = enumToStrings(JsonTypes::staticMetaObject, "BasicTypes"); - s_stateOperatorTypes = enumToStrings(Types::staticMetaObject, "StateOperator"); - s_valueOperatorTypes = enumToStrings(Types::staticMetaObject, "ValueOperator"); - s_createMethodTypes = enumToStrings(DeviceClass::staticMetaObject, "CreateMethod"); - s_setupMethodTypes = enumToStrings(DeviceClass::staticMetaObject, "SetupMethod"); - s_removePolicyTypes = enumToStrings(RuleEngine::staticMetaObject, "RemovePolicy"); - s_deviceErrorTypes = enumToStrings(DeviceManager::staticMetaObject, "DeviceError"); - s_ruleErrorTypes = enumToStrings(RuleEngine::staticMetaObject, "RuleError"); + s_basicType = enumToStrings(JsonTypes::staticMetaObject, "BasicTypes"); + s_stateOperator = enumToStrings(Types::staticMetaObject, "StateOperator"); + s_valueOperator = enumToStrings(Types::staticMetaObject, "ValueOperator"); + s_createMethod = enumToStrings(DeviceClass::staticMetaObject, "CreateMethod"); + s_setupMethod = enumToStrings(DeviceClass::staticMetaObject, "SetupMethod"); + s_removePolicy = enumToStrings(RuleEngine::staticMetaObject, "RemovePolicy"); + s_deviceError = enumToStrings(DeviceManager::staticMetaObject, "DeviceError"); + s_ruleError = enumToStrings(RuleEngine::staticMetaObject, "RuleError"); // ParamType - s_paramType.insert("name", "string"); - s_paramType.insert("type", basicTypesRef()); - s_paramType.insert("o:defaultValue", "variant"); - s_paramType.insert("o:minValue", "variant"); - s_paramType.insert("o:maxValue", "variant"); - s_paramType.insert("o:allowedValues", QVariantList() << "variant"); + s_paramType.insert("name", basicTypeToString(String)); + s_paramType.insert("type", basicTypeRef()); + s_paramType.insert("o:defaultValue", basicTypeToString(Variant)); + s_paramType.insert("o:minValue", basicTypeToString(Variant)); + s_paramType.insert("o:maxValue", basicTypeToString(Variant)); + s_paramType.insert("o:allowedValues", QVariantList() << basicTypeToString(Variant)); // Param - s_param.insert("name", "string"); - s_param.insert("value", basicTypesRef()); + s_param.insert("name", basicTypeToString(String)); + s_param.insert("value", basicTypeRef()); // ParamDescriptor - s_paramDescriptor.insert("name", "string"); - s_paramDescriptor.insert("value", basicTypesRef()); - s_paramDescriptor.insert("operator", valueOperatorTypesRef()); + s_paramDescriptor.insert("name", basicTypeToString(String)); + s_paramDescriptor.insert("value", basicTypeRef()); + s_paramDescriptor.insert("operator", valueOperatorRef()); // StateType - s_stateType.insert("id", "uuid"); - s_stateType.insert("name", "string"); - s_stateType.insert("type", basicTypesRef()); - s_stateType.insert("defaultValue", "variant"); + s_stateType.insert("id", basicTypeToString(Uuid)); + s_stateType.insert("name", basicTypeToString(String)); + s_stateType.insert("type", basicTypeRef()); + s_stateType.insert("defaultValue", basicTypeToString(Variant)); // State - s_state.insert("stateTypeId", "uuid"); - s_state.insert("deviceId", "uuid"); - s_state.insert("value", "variant"); + s_state.insert("stateTypeId", basicTypeToString(Uuid)); + s_state.insert("deviceId", basicTypeToString(Uuid)); + s_state.insert("value", basicTypeToString(Variant)); // StateDescriptor - s_stateDescriptor.insert("stateTypeId", "uuid"); - s_stateDescriptor.insert("deviceId", "uuid"); - s_stateDescriptor.insert("value", "variant"); - s_stateDescriptor.insert("operator", valueOperatorTypesRef()); + s_stateDescriptor.insert("stateTypeId", basicTypeToString(Uuid)); + s_stateDescriptor.insert("deviceId", basicTypeToString(Uuid)); + s_stateDescriptor.insert("value", basicTypeToString(Variant)); + s_stateDescriptor.insert("operator", valueOperatorRef()); // StateEvaluator s_stateEvaluator.insert("o:stateDescriptor", stateDescriptorRef()); s_stateEvaluator.insert("o:childEvaluators", QVariantList() << stateEvaluatorRef()); - s_stateEvaluator.insert("o:operator", stateOperatorTypesRef()); + s_stateEvaluator.insert("o:operator", stateOperatorRef()); // EventType - s_eventType.insert("id", "uuid"); - s_eventType.insert("name", "string"); + s_eventType.insert("id", basicTypeToString(Uuid)); + s_eventType.insert("name", basicTypeToString(String)); s_eventType.insert("paramTypes", QVariantList() << paramTypeRef()); // Event - s_event.insert("eventTypeId", "uuid"); - s_event.insert("deviceId", "uuid"); + s_event.insert("eventTypeId", basicTypeToString(Uuid)); + s_event.insert("deviceId", basicTypeToString(Uuid)); s_event.insert("o:params", QVariantList() << paramRef()); // EventDescriptor - s_eventDescriptor.insert("eventTypeId", "uuid"); - s_eventDescriptor.insert("deviceId", "uuid"); + s_eventDescriptor.insert("eventTypeId", basicTypeToString(Uuid)); + s_eventDescriptor.insert("deviceId", basicTypeToString(Uuid)); s_eventDescriptor.insert("o:paramDescriptors", QVariantList() << paramDescriptorRef()); // ActionType - s_actionType.insert("id", "uuid"); - s_actionType.insert("name", "string"); + s_actionType.insert("id", basicTypeToString(Uuid)); + s_actionType.insert("name", basicTypeToString(Uuid)); s_actionType.insert("paramTypes", QVariantList() << paramTypeRef()); // Action - s_action.insert("actionTypeId", "uuid"); - s_action.insert("deviceId", "uuid"); + s_action.insert("actionTypeId", basicTypeToString(Uuid)); + s_action.insert("deviceId", basicTypeToString(Uuid)); s_action.insert("o:params", QVariantList() << paramRef()); // Pugin - s_plugin.insert("id", "uuid"); - s_plugin.insert("name", "string"); + s_plugin.insert("id", basicTypeToString(Uuid)); + s_plugin.insert("name", basicTypeToString(String)); s_plugin.insert("params", QVariantList() << paramRef()); // Vendor - s_vendor.insert("id", "uuid"); - s_vendor.insert("name", "string"); + s_vendor.insert("id", basicTypeToString(Uuid)); + s_vendor.insert("name", basicTypeToString(String)); // DeviceClass - s_deviceClass.insert("id", "uuid"); - s_deviceClass.insert("vendorId", "uuid"); - s_deviceClass.insert("name", "string"); + s_deviceClass.insert("id", basicTypeToString(Uuid)); + s_deviceClass.insert("vendorId", basicTypeToString(Uuid)); + s_deviceClass.insert("name", basicTypeToString(String)); s_deviceClass.insert("stateTypes", QVariantList() << stateTypeRef()); s_deviceClass.insert("eventTypes", QVariantList() << eventTypeRef()); s_deviceClass.insert("actionTypes", QVariantList() << actionTypeRef()); s_deviceClass.insert("paramTypes", QVariantList() << paramTypeRef()); s_deviceClass.insert("discoveryParamTypes", QVariantList() << paramTypeRef()); - s_deviceClass.insert("setupMethod", setupMethodTypesRef()); - s_deviceClass.insert("createMethods", createMethodTypesRef()); + s_deviceClass.insert("setupMethod", setupMethodRef()); + s_deviceClass.insert("createMethods", QVariantList() << createMethodRef()); // Device - s_device.insert("id", "uuid"); - s_device.insert("deviceClassId", "uuid"); - s_device.insert("name", "string"); + s_device.insert("id", basicTypeToString(Uuid)); + s_device.insert("deviceClassId", basicTypeToString(Uuid)); + s_device.insert("name", basicTypeToString(String)); s_device.insert("params", QVariantList() << paramRef()); - s_device.insert("setupComplete", "bool"); + s_device.insert("setupComplete", basicTypeToString(Bool)); // DeviceDescription - s_deviceDescriptor.insert("id", "uuid"); - s_deviceDescriptor.insert("title", "string"); - s_deviceDescriptor.insert("description", "string"); + s_deviceDescriptor.insert("id", basicTypeToString(Uuid)); + s_deviceDescriptor.insert("title", basicTypeToString(String)); + s_deviceDescriptor.insert("description", basicTypeToString(String)); // Rule - s_rule.insert("id", "uuid"); + s_rule.insert("id", basicTypeToString(Uuid)); s_rule.insert("eventDescriptors", QVariantList() << eventDescriptorRef()); s_rule.insert("actions", QVariantList() << actionRef()); s_rule.insert("stateEvaluator", stateEvaluatorRef()); @@ -186,7 +186,6 @@ QVariantList JsonTypes::enumToStrings(const QMetaObject &metaObject, const QStri int enumIndex = metaObject.indexOfEnumerator(enumName.toLatin1().data()); QMetaEnum metaEnum = metaObject.enumerator(enumIndex); - qDebug() << "*** have enum" << metaEnum.name(); QVariantList enumStrings; for (int i = 0; i < metaEnum.keyCount(); i++) { enumStrings << metaEnum.valueToKey(metaEnum.value(i)); @@ -197,15 +196,15 @@ QVariantList JsonTypes::enumToStrings(const QMetaObject &metaObject, const QStri QVariantMap JsonTypes::allTypes() { QVariantMap allTypes; - allTypes.insert("BasicType", basicTypes()); + allTypes.insert("BasicType", basicType()); allTypes.insert("ParamType", paramTypeDescription()); - allTypes.insert("CreateMethodType", createMethodTypes()); - allTypes.insert("SetupMethodType", setupMethodTypes()); - allTypes.insert("ValueOperatorType", valueOperatorTypes()); - allTypes.insert("StateOperatorType", stateOperatorTypes()); - allTypes.insert("RemovePolicyType", removePolicyTypes()); - allTypes.insert("DeviceError", deviceErrorTypes()); - allTypes.insert("RuleError", ruleErrorTypes()); + allTypes.insert("CreateMethod", createMethod()); + allTypes.insert("SetupMethod", setupMethod()); + allTypes.insert("ValueOperator", valueOperator()); + allTypes.insert("StateOperator", stateOperator()); + allTypes.insert("RemovePolicy", removePolicy()); + allTypes.insert("DeviceError", deviceError()); + allTypes.insert("RuleError", ruleError()); allTypes.insert("StateType", stateTypeDescription()); allTypes.insert("StateDescriptor", stateDescriptorDescription()); allTypes.insert("StateEvaluator", stateEvaluatorDescription()); @@ -307,7 +306,7 @@ QVariantMap JsonTypes::packStateDescriptor(const StateDescriptor &stateDescripto variantMap.insert("stateTypeId", stateDescriptor.stateTypeId().toString()); variantMap.insert("deviceId", stateDescriptor.deviceId().toString()); variantMap.insert("value", stateDescriptor.stateValue()); - variantMap.insert("operator", valueOperatorTypes().at(stateDescriptor.operatorType())); + variantMap.insert("operator", valueOperator().at(stateDescriptor.operatorType())); return variantMap; } @@ -337,7 +336,7 @@ QVariantMap JsonTypes::packParamDescriptor(const ParamDescriptor ¶mDescripto QVariantMap variantMap; variantMap.insert("name", paramDescriptor.name()); variantMap.insert("value", paramDescriptor.value()); - variantMap.insert("operator", s_valueOperatorTypes.at(paramDescriptor.operatorType())); + variantMap.insert("operator", s_valueOperator.at(paramDescriptor.operatorType())); return variantMap; } @@ -403,7 +402,7 @@ QVariantMap JsonTypes::packDeviceClass(const DeviceClass &deviceClass) variant.insert("eventTypes", eventTypes); variant.insert("actionTypes", actionTypes); variant.insert("createMethods", packCreateMethods(deviceClass.createMethods())); - variant.insert("setupMethod", s_setupMethodTypes.at(deviceClass.setupMethod())); + variant.insert("setupMethod", s_setupMethod.at(deviceClass.setupMethod())); return variant; } @@ -525,7 +524,7 @@ EventDescriptor JsonTypes::unpackEventDescriptor(const QVariantMap &eventDescrip QPair JsonTypes::validateMap(const QVariantMap &templateMap, const QVariantMap &map) { s_lastError.clear(); - qDebug() << "validating Map" << templateMap << map; + // qDebug() << "validating Map" << templateMap << map; // Make sure all values defined in the template are around foreach (const QString &key, templateMap.keys()) { @@ -541,7 +540,7 @@ QPair JsonTypes::validateMap(const QVariantMap &templateMap, cons if (map.contains(strippedKey)) { QPair result = validateVariant(templateMap.value(key), map.value(strippedKey)); if (!result.first) { - qDebug() << "Object not matching template or object not matching" << templateMap.value(key) << map.value(strippedKey); + qDebug() << "Object not matching template" << templateMap.value(key) << map.value(strippedKey); return result; } } @@ -563,25 +562,25 @@ QPair JsonTypes::validateMap(const QVariantMap &templateMap, cons QPair JsonTypes::validateProperty(const QVariant &templateValue, const QVariant &value) { - qDebug() << "validating property. template:" << templateValue << "got:" << value; + //qDebug() << "validating property. template:" << templateValue << "got:" << value; QString strippedTemplateValue = templateValue.toString(); - if (strippedTemplateValue == "variant") { + if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::Variant)) { return report(true, ""); } - if (strippedTemplateValue == "uuid") { + if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::Uuid)) { QString errorString = QString("Param %1 is not a uuid.").arg(value.toString()); return report(value.canConvert(QVariant::Uuid), errorString); } - if (strippedTemplateValue == "string") { + if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::String)) { QString errorString = QString("Param %1 is not a string.").arg(value.toString()); return report(value.canConvert(QVariant::String), errorString); } - if (strippedTemplateValue == "bool") { + if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::Bool)) { QString errorString = QString("Param %1 is not a bool.").arg(value.toString()); return report(value.canConvert(QVariant::Bool), errorString); } - if (strippedTemplateValue == "int") { + if (strippedTemplateValue == JsonTypes::basicTypeToString(JsonTypes::Int)) { QString errorString = QString("Param %1 is not a int.").arg(value.toString()); return report(value.canConvert(QVariant::Int), errorString); } @@ -714,38 +713,50 @@ QPair JsonTypes::validateVariant(const QVariant &templateVariant, qDebug() << "evendescriptor not matching"; return result; } - } else if (refName == basicTypesRef()) { + } else if (refName == basicTypeRef()) { QPair result = validateBasicType(variant); if (!result.first) { - qDebug() << "value not allowed in" << basicTypesRef(); + qDebug() << "value not allowed in" << basicTypeRef(); return result; } - } else if (refName == stateOperatorTypesRef()) { - QPair result = validateStateOperatorType(variant); + } else if (refName == stateOperatorRef()) { + QPair result = validateStateOperator(variant); if (!result.first) { - qDebug() << "value not allowed in" << stateOperatorTypesRef(); + qDebug() << "value not allowed in" << stateOperatorRef(); return result; } - } else if (refName == createMethodTypesRef()) { - QPair result = validateCreateMethodType(variant); + } else if (refName == createMethodRef()) { + QPair result = validateCreateMethod(variant); if (!result.first) { - qDebug() << "value not allowed in" << createMethodTypesRef() << variant; + qDebug() << "value not allowed in" << createMethodRef() << variant; return result; } - } else if (refName == setupMethodTypesRef()) { - QPair result = validateSetupMethodType(variant); + } else if (refName == setupMethodRef()) { + QPair result = validateSetupMethod(variant); if (!result.first) { - qDebug() << "value not allowed in" << createMethodTypesRef(); + qDebug() << "value not allowed in" << createMethodRef(); return result; } - } else if (refName == valueOperatorTypesRef()) { - QPair result = validateValueOperatorType(variant); + } else if (refName == valueOperatorRef()) { + QPair result = validateValueOperator(variant); if (!result.first) { - qDebug() << QString("value %1 not allowed in %2").arg(variant.toString()).arg(valueOperatorTypesRef()); + qDebug() << QString("value %1 not allowed in %2").arg(variant.toString()).arg(valueOperatorRef()); + return result; + } + } else if (refName == deviceErrorRef()) { + QPair result = validateDeviceError(variant); + if (!result.first) { + qDebug() << QString("value %1 not allowed in %2").arg(variant.toString()).arg(deviceErrorRef()); + return result; + } + } else if (refName == ruleErrorRef()) { + QPair result = validateRuleError(variant); + if (!result.first) { + qDebug() << QString("value %1 not allowed in %2").arg(variant.toString()).arg(ruleErrorRef()); return result; } } else { - qDebug() << "unhandled ref:" << refName; + Q_ASSERT_X(false, "JsonTypes", QString("Unhandled ref: %1").arg(refName).toLatin1().data()); return report(false, QString("Unhandled ref %1. Server implementation incomplete.").arg(refName)); } @@ -798,30 +809,32 @@ QPair JsonTypes::validateBasicType(const QVariant &variant) return report(false, QString("Error validating basic type %1.").arg(variant.toString())); } -QPair JsonTypes::validateStateOperatorType(const QVariant &variant) +QPair JsonTypes::validateStateOperator(const QVariant &variant) { - return report(s_stateOperatorTypes.contains(variant.toString()), QString("Unknown state operator %1").arg(variant.toString())); + return report(s_stateOperator.contains(variant.toString()), QString("Unknown state operator %1").arg(variant.toString())); } -QPair JsonTypes::validateCreateMethodType(const QVariant &variant) +QPair JsonTypes::validateCreateMethod(const QVariant &variant) { - if (variant.toList().isEmpty()) { - return report(false, QString("No createMethod given.")); - } - foreach (const QVariant &method, variant.toList()) { - if (!s_createMethodTypes.contains(method.toString())) { - return report(false, QString("Unknwon createMethod type %1").arg(method.toString())); - } - } - return report(true, QString()); + return report(s_createMethod.contains(variant.toString()), QString("Unknwon createMethod type %1").arg(variant.toString())); } -QPair JsonTypes::validateSetupMethodType(const QVariant &variant) +QPair JsonTypes::validateSetupMethod(const QVariant &variant) { - return report(s_setupMethodTypes.contains(variant.toString()), QString("Unknwon setupMethod type %1").arg(variant.toString())); + return report(s_setupMethod.contains(variant.toString()), QString("Unknwon SetupMethod: %1").arg(variant.toString())); } -QPair JsonTypes::validateValueOperatorType(const QVariant &variant) +QPair JsonTypes::validateValueOperator(const QVariant &variant) { - return report(s_valueOperatorTypes.contains(variant.toString()), QString("Unknown value operator type %1").arg(variant.toString())); + return report(s_valueOperator.contains(variant.toString()), QString("Unknown ValueOperator: %1").arg(variant.toString())); +} + +QPair JsonTypes::validateDeviceError(const QVariant &variant) +{ + return report(s_deviceError.contains(variant.toString()), QString("Unknown DeviceError: %1").arg(variant.toString())); +} + +QPair JsonTypes::validateRuleError(const QVariant &variant) +{ + return report(s_ruleError.contains(variant.toString()), QString("Unknown RuleError: %1").arg(variant.toString())); } diff --git a/server/jsonrpc/jsontypes.h b/server/jsonrpc/jsontypes.h index 82b42749..1e5b8ebf 100644 --- a/server/jsonrpc/jsontypes.h +++ b/server/jsonrpc/jsontypes.h @@ -71,27 +71,29 @@ class Device; class JsonTypes { Q_GADGET - Q_ENUMS(BasicTypes) + Q_ENUMS(BasicType) + Q_ENUMS(JsonError) public: - enum BasicTypes { + enum BasicType { Uuid, String, Int, Double, - Bool + Bool, + Variant, + Object }; - static QVariantMap allTypes(); - DECLARE_TYPE(basicTypes, "BasicType", JsonTypes, BasicTypes) - DECLARE_TYPE(stateOperatorTypes, "StateOperator", Types, StateOperator) - DECLARE_TYPE(valueOperatorTypes, "ValueOperator", Types, ValueOperator) - DECLARE_TYPE(createMethodTypes, "CreateMethod", DeviceClass, CreateMethod) - DECLARE_TYPE(setupMethodTypes, "SetupMethod", DeviceClass, SetupMethod) - DECLARE_TYPE(deviceErrorTypes, "DeviceError", DeviceManager, DeviceError) - DECLARE_TYPE(removePolicyTypes, "RemovePolicy", RuleEngine, RemovePolicy) - DECLARE_TYPE(ruleErrorTypes, "RuleError", RuleEngine, RuleError) + DECLARE_TYPE(basicType, "BasicType", JsonTypes, BasicType) + DECLARE_TYPE(stateOperator, "StateOperator", Types, StateOperator) + DECLARE_TYPE(valueOperator, "ValueOperator", Types, ValueOperator) + DECLARE_TYPE(createMethod, "CreateMethod", DeviceClass, CreateMethod) + DECLARE_TYPE(setupMethod, "SetupMethod", DeviceClass, SetupMethod) + DECLARE_TYPE(deviceError, "DeviceError", DeviceManager, DeviceError) + DECLARE_TYPE(removePolicy, "RemovePolicy", RuleEngine, RemovePolicy) + DECLARE_TYPE(ruleError, "RuleError", RuleEngine, RuleError) DECLARE_OBJECT(paramType, "ParamType") DECLARE_OBJECT(param, "Param") DECLARE_OBJECT(paramDescriptor, "ParamDescriptor") @@ -141,11 +143,12 @@ public: static QPair validateList(const QVariantList &templateList, const QVariantList &list); static QPair validateVariant(const QVariant &templateVariant, const QVariant &variant); static QPair validateBasicType(const QVariant &variant); - static QPair validateStateOperatorType(const QVariant &variant); - static QPair validateCreateMethodType(const QVariant &variant); - static QPair validateSetupMethodType(const QVariant &variant); - static QPair validateValueOperatorType(const QVariant &variant); - + static QPair validateStateOperator(const QVariant &variant); + static QPair validateCreateMethod(const QVariant &variant); + static QPair validateSetupMethod(const QVariant &variant); + static QPair validateValueOperator(const QVariant &variant); + static QPair validateDeviceError(const QVariant &variant); + static QPair validateRuleError(const QVariant &variant); private: static bool s_initialized; diff --git a/server/jsonrpc/ruleshandler.cpp b/server/jsonrpc/ruleshandler.cpp index a80dbb79..2188b084 100644 --- a/server/jsonrpc/ruleshandler.cpp +++ b/server/jsonrpc/ruleshandler.cpp @@ -32,12 +32,12 @@ RulesHandler::RulesHandler(QObject *parent) : params.clear(); returns.clear(); setDescription("GetRules", "Get all configured rules"); setParams("GetRules", params); - returns.insert("ruleIds", QVariantList() << "uuid"); + returns.insert("ruleIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid)); setReturns("GetRules", returns); params.clear(); returns.clear(); setDescription("GetRuleDetails", "Get details for the rule identified by ruleId"); - params.insert("ruleId", "uuid"); + params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("GetRuleDetails", params); returns.insert("rule", JsonTypes::ruleRef()); setReturns("GetRuleDetails", returns); @@ -52,22 +52,22 @@ RulesHandler::RulesHandler(QObject *parent) : actions.append(JsonTypes::actionRef()); params.insert("actions", actions); setParams("AddRule", params); - returns.insert("ruleError", "int"); - returns.insert("o:ruleId", "uuid"); + returns.insert("ruleError", JsonTypes::ruleErrorRef()); + returns.insert("o:ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setReturns("AddRule", returns); params.clear(); returns.clear(); setDescription("RemoveRule", "Remove a rule"); - params.insert("ruleId", "uuid"); + params.insert("ruleId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("RemoveRule", params); - returns.insert("ruleError", "int"); + returns.insert("ruleError", JsonTypes::ruleErrorRef()); setReturns("RemoveRule", returns); params.clear(); returns.clear(); setDescription("FindRules", "Find a list of rules containing any of the given parameters."); - params.insert("deviceId", "uuid"); + params.insert("deviceId", JsonTypes::basicTypeToString(JsonTypes::Uuid)); setParams("FindRules", params); - returns.insert("ruleIds", QVariantList() << "uuid"); + returns.insert("ruleIds", QVariantList() << JsonTypes::basicTypeToString(JsonTypes::Uuid)); setReturns("FindRules", returns); } @@ -106,7 +106,7 @@ JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) if (params.contains("eventDescriptor") && params.contains("eventDescriptorList")) { QVariantMap returns; qWarning() << "Only one of eventDesciptor or eventDescriptorList may be used."; - returns.insert("ruleError", RuleEngine::RuleErrorInvalidParameter); + returns.insert("ruleError", JsonTypes::ruleErrorToString(RuleEngine::RuleErrorInvalidParameter)); return createReply(returns); } @@ -132,7 +132,7 @@ JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) QVariantMap returns; if (actions.count() == 0) { - returns.insert("ruleErorr", RuleEngine::RuleErrorMissingParameter); + returns.insert("ruleErorr", JsonTypes::ruleErrorToString(RuleEngine::RuleErrorMissingParameter)); return createReply(returns); } @@ -141,7 +141,7 @@ JsonReply* RulesHandler::AddRule(const QVariantMap ¶ms) if (status == RuleEngine::RuleErrorNoError) { returns.insert("ruleId", newRuleId.toString()); } - returns.insert("ruleError", status); + returns.insert("ruleError", JsonTypes::ruleErrorToString(status)); return createReply(returns); } @@ -150,7 +150,7 @@ JsonReply* RulesHandler::RemoveRule(const QVariantMap ¶ms) QVariantMap returns; RuleId ruleId(params.value("ruleId").toString()); RuleEngine::RuleError status = GuhCore::instance()->removeRule(ruleId); - returns.insert("ruleError", status); + returns.insert("ruleError", JsonTypes::ruleErrorToString(status)); return createReply(returns); } diff --git a/tests/auto/actions/testactions.cpp b/tests/auto/actions/testactions.cpp index 6e0f6aaa..d3ba631d 100644 --- a/tests/auto/actions/testactions.cpp +++ b/tests/auto/actions/testactions.cpp @@ -64,8 +64,8 @@ void TestActions::executeAction_data() QTest::newRow("invalid actionTypeId") << m_mockDeviceId << ActionTypeId::createActionTypeId() << params << DeviceManager::DeviceErrorActionTypeNotFound; QTest::newRow("missing params") << m_mockDeviceId << mockActionIdWithParams << QVariantList() << DeviceManager::DeviceErrorMissingParameter; QTest::newRow("async action") << m_mockDeviceId << mockActionIdAsync << QVariantList() << DeviceManager::DeviceErrorNoError; - QTest::newRow("broken action") << m_mockDeviceId << mockActionIdFailing << QVariantList() << DeviceManager::DeviceErrorActionParameterError; - QTest::newRow("async broken action") << m_mockDeviceId << mockActionIdAsyncFailing << QVariantList() << DeviceManager::DeviceErrorActionParameterError; + QTest::newRow("broken action") << m_mockDeviceId << mockActionIdFailing << QVariantList() << DeviceManager::DeviceErrorSetupFailed; + QTest::newRow("async broken action") << m_mockDeviceId << mockActionIdAsyncFailing << QVariantList() << DeviceManager::DeviceErrorSetupFailed; } void TestActions::executeAction() @@ -81,7 +81,7 @@ void TestActions::executeAction() params.insert("params", actionParams); QVariant response = injectAndWait("Actions.ExecuteAction", params); qDebug() << "executeActionresponse" << response; - verifyError(response, "deviceError", error); + verifyDeviceError(response, error); // Fetch action execution history from mock device QNetworkAccessManager nam; @@ -138,7 +138,7 @@ void TestActions::getActionTypes() params.insert("actionTypeId", actionTypeId.toString()); QVariant response = injectAndWait("Actions.GetActionType", params); - verifyError(response, "deviceError", error); + verifyDeviceError(response, error); if (error == DeviceManager::DeviceErrorNoError) { QVERIFY2(ActionTypeId(response.toMap().value("params").toMap().value("actionType").toMap().value("id").toString()) == actionTypeId, "Didnt get reply for same actionTypeId as requested."); diff --git a/tests/auto/api.json b/tests/auto/api.json index 6ff8a345..ca9f3bbc 100644 --- a/tests/auto/api.json +++ b/tests/auto/api.json @@ -1,68 +1,64 @@ -5 +6 { "methods": { "Actions.ExecuteAction": { "description": "Execute a single action.", "params": { - "actionTypeId": "uuid", - "deviceId": "uuid", + "actionTypeId": "Uuid", + "deviceId": "Uuid", "o:params": [ "$ref:Param" ] }, "returns": { - "errorMessage": "string", - "success": "bool" + "deviceError": "$ref:DeviceError" } }, "Actions.GetActionType": { "description": "Get the ActionType for the given ActionTypeId", "params": { - "actionTypeId": "uuid" + "actionTypeId": "Uuid" }, "returns": { - "errorMessage": "string", + "deviceError": "$ref:DeviceError", "o:actionType": { - "id": "uuid", - "name": "string", + "id": "Uuid", + "name": "Uuid", "paramTypes": [ "$ref:ParamType" ] - }, - "success": "bool" + } } }, "Devices.AddConfiguredDevice": { "description": "Add a configured device with a setupMethod of SetupMethodJustAdd. For devices with a setupMethod different than SetupMethodJustAdd, use PairDevice. Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. CreateMethodJustAdd takes the parameters you want to have with that device. CreateMethodDiscovery requires the use of a deviceDescriptorId.", "params": { - "deviceClassId": "uuid", - "o:deviceDescriptorId": "uuid", + "deviceClassId": "Uuid", + "o:deviceDescriptorId": "Uuid", "o:deviceParams": [ "$ref:Param" ] }, "returns": { - "errorMessage": "string", - "o:deviceId": "uuid", - "success": "bool" + "deviceError": "$ref:DeviceError", + "o:deviceId": "Uuid" } }, "Devices.ConfirmPairing": { "description": "Confirm an ongoing pairing. In case of SetupMethodEnterPin also provide the pin in the params.", "params": { - "o:secret": "string", - "pairingTransactionId": "uuid" + "o:secret": "String", + "pairingTransactionId": "Uuid" }, "returns": { - "errorMessage": "string", - "o:deviceId": "uuid", - "success": "bool" + "deviceError": "$ref:DeviceError", + "o:deviceId": "Uuid" } }, "Devices.GetActionTypes": { "description": "Get action types for a specified deviceClassId.", "params": { - "deviceClassId": "uuid" + "deviceClassId": "Uuid" }, "returns": { "actionTypes": [ @@ -83,23 +79,22 @@ "Devices.GetDiscoveredDevices": { "description": "Performs a device discovery and returns the results. This function may take a while to return.", "params": { - "deviceClassId": "uuid", + "deviceClassId": "Uuid", "o:discoveryParams": [ "$ref:Param" ] }, "returns": { - "errorMessage": "string", + "deviceError": "$ref:DeviceError", "o:deviceDescriptors": [ "$ref:DeviceDescriptor" - ], - "success": "bool" + ] } }, "Devices.GetEventTypes": { "description": "Get event types for a specified deviceClassId.", "params": { - "deviceClassId": "uuid" + "deviceClassId": "Uuid" }, "returns": { "eventTypes": [ @@ -110,14 +105,13 @@ "Devices.GetPluginConfiguration": { "description": "Get a plugin's params.", "params": { - "pluginId": "uuid" + "pluginId": "Uuid" }, "returns": { - "errorMessage": "string", + "deviceError": "$ref:DeviceError", "o:configuration": [ "$ref:Param" - ], - "success": "bool" + ] } }, "Devices.GetPlugins": { @@ -133,7 +127,7 @@ "Devices.GetStateTypes": { "description": "Get state types for a specified deviceClassId.", "params": { - "deviceClassId": "uuid" + "deviceClassId": "Uuid" }, "returns": { "stateTypes": [ @@ -144,19 +138,18 @@ "Devices.GetStateValue": { "description": "Get the value of the given device and the given stateType", "params": { - "deviceId": "uuid", - "stateTypeId": "uuid" + "deviceId": "Uuid", + "stateTypeId": "Uuid" }, "returns": { - "errorMessage": "string", - "o:value": "variant", - "success": "bool" + "deviceError": "$ref:DeviceError", + "o:value": "Variant" } }, "Devices.GetSupportedDevices": { "description": "Returns a list of supported Device classes, optionally filtered by vendorId.", "params": { - "o:vendorId": "uuid" + "o:vendorId": "Uuid" }, "returns": { "deviceClasses": [ @@ -177,34 +170,32 @@ "Devices.PairDevice": { "description": "Pair a device. Use this for DeviceClasses with a setupMethod different than SetupMethodJustAdd.Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. CreateMethodJustAdd takes the parameters you want to have with that device. CreateMethodDiscovery requires the use of a deviceDescriptorId. If success is true, the return values will contain a pairingTransactionId, a displayMessage and the setupMethod. Depending on the setupMethod you should either proceed with AddConfiguredDevice or PairDevice.", "params": { - "deviceClassId": "uuid", - "o:deviceDescriptorId": "uuid", + "deviceClassId": "Uuid", + "o:deviceDescriptorId": "Uuid", "o:deviceParams": [ "$ref:Param" ] }, "returns": { - "errorMessage": "string", - "o:displayMessage": "string", - "o:pairingTransactionId": "uuid", - "o:setupMethod": "$ref:SetupMethodType", - "success": "bool" + "deviceError": "$ref:DeviceError", + "o:displayMessage": "String", + "o:pairingTransactionId": "Uuid", + "o:setupMethod": "$ref:SetupMethod" } }, "Devices.RemoveConfiguredDevice": { "description": "Remove a device from the system.", "params": { - "deviceId": "uuid", + "deviceId": "Uuid", "o:removePolicyList": [ { - "policy": "$ref:RemovePolicyType", - "ruleId": "uuid" + "policy": "$ref:RemovePolicy", + "ruleId": "Uuid" } ] }, "returns": { - "errorMessage": "string", - "success": "bool" + "deviceError": "$ref:DeviceError" } }, "Devices.SetPluginConfiguration": { @@ -213,11 +204,10 @@ "configuration": [ "$ref:Param" ], - "pluginId": "uuid" + "pluginId": "Uuid" }, "returns": { - "errorMessage": "string", - "success": "bool" + "deviceError": "$ref:DeviceError" } }, "JSONRPC.Introspect": { @@ -225,19 +215,17 @@ "params": { }, "returns": { - "methods": "object", - "types": "object" + "methods": "Object", + "types": "Object" } }, "JSONRPC.SetNotificationStatus": { "description": "Enable/Disable notifications for this connections.", "params": { - "enabled": "bool" + "enabled": "Bool" }, "returns": { - "enabled": "bool", - "errorMessage": "string", - "success": "bool" + "enabled": "Bool" } }, "JSONRPC.Version": { @@ -245,12 +233,12 @@ "params": { }, "returns": { - "protocol version": "string", - "version": "string" + "protocol version": "String", + "version": "String" } }, "Rules.AddRule": { - "description": "Add a rule.", + "description": "Add a rule. You can describe rules by one or many EventDesciptors and a StateEvaluator. Note that onlyone of either eventDescriptor or eventDescriptorList may be passed at a time.", "params": { "actions": [ "$ref:Action" @@ -262,26 +250,25 @@ "o:stateEvaluator": "$ref:StateEvaluator" }, "returns": { - "errorMessage": "string", - "o:ruleId": "uuid", - "success": "bool" + "o:ruleId": "Uuid", + "ruleError": "$ref:RuleError" } }, "Rules.FindRules": { "description": "Find a list of rules containing any of the given parameters.", "params": { - "deviceId": "uuid" + "deviceId": "Uuid" }, "returns": { "ruleIds": [ - "uuid" + "Uuid" ] } }, "Rules.GetRuleDetails": { "description": "Get details for the rule identified by ruleId", "params": { - "ruleId": "uuid" + "ruleId": "Uuid" }, "returns": { "rule": "$ref:Rule" @@ -293,18 +280,17 @@ }, "returns": { "ruleIds": [ - "uuid" + "Uuid" ] } }, "Rules.RemoveRule": { "description": "Remove a rule", "params": { - "ruleId": "uuid" + "ruleId": "Uuid" }, "returns": { - "errorMessage": "string", - "success": "bool" + "ruleError": "$ref:RuleError" } } }, @@ -312,9 +298,9 @@ "Devices.StateChanged": { "description": "Emitted whenever a State of a device changes.", "params": { - "deviceId": "uuid", - "stateTypeId": "uuid", - "variant": "value" + "deviceId": "Uuid", + "stateTypeId": "Uuid", + "value": "Variant" } }, "Events.EventTriggered": { @@ -326,115 +312,133 @@ }, "types": { "Action": { - "actionTypeId": "uuid", - "deviceId": "uuid", + "actionTypeId": "Uuid", + "deviceId": "Uuid", "o:params": [ "$ref:Param" ] }, "ActionType": { - "id": "uuid", - "name": "string", + "id": "Uuid", + "name": "Uuid", "paramTypes": [ "$ref:ParamType" ] }, "BasicType": [ - "uuid", - "string", - "integer", - "double", - "bool" ], - "CreateMethodType": [ + "CreateMethod": [ "CreateMethodUser", "CreateMethodAuto", "CreateMethodDiscovery" ], "Device": { - "deviceClassId": "uuid", - "id": "uuid", - "name": "string", + "deviceClassId": "Uuid", + "id": "Uuid", + "name": "String", "params": [ "$ref:Param" ], - "setupComplete": "bool" + "setupComplete": "Bool" }, "DeviceClass": { "actionTypes": [ "$ref:ActionType" ], - "createMethods": "$ref:CreateMethodType", + "createMethods": [ + "$ref:CreateMethod" + ], "discoveryParamTypes": [ "$ref:ParamType" ], "eventTypes": [ "$ref:EventType" ], - "id": "uuid", - "name": "string", + "id": "Uuid", + "name": "String", "paramTypes": [ "$ref:ParamType" ], - "setupMethod": "$ref:SetupMethodType", + "setupMethod": "$ref:SetupMethod", "stateTypes": [ "$ref:StateType" ], - "vendorId": "uuid" + "vendorId": "Uuid" }, "DeviceDescriptor": { - "description": "string", - "id": "uuid", - "title": "string" + "description": "String", + "id": "Uuid", + "title": "String" }, + "DeviceError": [ + "DeviceErrorNoError", + "DeviceErrorPluginNotFound", + "DeviceErrorDeviceNotFound", + "DeviceErrorDeviceClassNotFound", + "DeviceErrorActionTypeNotFound", + "DeviceErrorStateTypeNotFound", + "DeviceErrorEventTypeNotFound", + "DeviceErrorDeviceDescriptorNotFound", + "DeviceErrorMissingParameter", + "DeviceErrorInvalidParameter", + "DeviceErrorSetupFailed", + "DeviceErrorDuplicateUuid", + "DeviceErrorCreationMethodNotSupported", + "DeviceErrorSetupMethodNotSupported", + "DeviceErrorHardwareNotAvailable", + "DeviceErrorHardwareFailure", + "DeviceErrorAsync", + "DeviceErrorDeviceInUse", + "DeviceErrorPairingTransactionIdNotFound" + ], "Event": { - "deviceId": "uuid", - "eventTypeId": "uuid", + "deviceId": "Uuid", + "eventTypeId": "Uuid", "o:params": [ "$ref:Param" ] }, "EventDescriptor": { - "deviceId": "uuid", - "eventTypeId": "uuid", + "deviceId": "Uuid", + "eventTypeId": "Uuid", "o:paramDescriptors": [ "$ref:ParamDescriptor" ] }, "EventType": { - "id": "uuid", - "name": "string", + "id": "Uuid", + "name": "String", "paramTypes": [ "$ref:ParamType" ] }, "Param": { - "name": "string", + "name": "String", "value": "$ref:BasicType" }, "ParamDescriptor": { - "name": "string", - "operator": "$ref:ValueOperatorType", + "name": "String", + "operator": "$ref:ValueOperator", "value": "$ref:BasicType" }, "ParamType": { - "name": "string", + "name": "String", "o:allowedValues": [ - "variant" + "Variant" ], - "o:defaultValue": "variant", - "o:maxValue": "variant", - "o:minValue": "variant", + "o:defaultValue": "Variant", + "o:maxValue": "Variant", + "o:minValue": "Variant", "type": "$ref:BasicType" }, "Plugin": { - "id": "uuid", - "name": "string", + "id": "Uuid", + "name": "String", "params": [ "$ref:Param" ] }, - "RemovePolicyType": [ + "RemovePolicy": [ "RemovePolicyCascade", "RemovePolicyUpdate" ], @@ -445,54 +449,64 @@ "eventDescriptors": [ "$ref:EventDescriptor" ], - "id": "uuid", + "id": "Uuid", "stateEvaluator": "$ref:StateEvaluator" }, - "SetupMethodType": [ + "RuleError": [ + "RuleErrorNoError", + "RuleErrorInvalidRuleId", + "RuleErrorRuleNotFound", + "RuleErrorDeviceNotFound", + "RuleErrorEventTypeNotFound", + "RuleErrorActionTypeNotFound", + "RuleErrorInvalidParameter", + "RuleErrorMissingParameter" + ], + "SetupMethod": [ "SetupMethodJustAdd", "SetupMethodDisplayPin", "SetupMethodEnterPin", "SetupMethodPushButton" ], "State": { - "deviceId": "uuid", - "stateTypeId": "uuid", - "value": "variant" + "deviceId": "Uuid", + "stateTypeId": "Uuid", + "value": "Variant" }, "StateDescriptor": { - "deviceId": "uuid", - "operator": "$ref:ValueOperatorType", - "stateTypeId": "uuid", - "value": "variant" + "deviceId": "Uuid", + "operator": "$ref:ValueOperator", + "stateTypeId": "Uuid", + "value": "Variant" }, "StateEvaluator": { "o:childEvaluators": [ "$ref:StateEvaluator" ], - "o:operator": "$ref:StateOperatorType", + "o:operator": "$ref:StateOperator", "o:stateDescriptor": "$ref:StateDescriptor" }, - "StateOperatorType": [ + "StateOperator": [ "StateOperatorAnd", "StateOperatorOr" ], "StateType": { - "defaultValue": "variant", - "id": "uuid", - "name": "string", + "defaultValue": "Variant", + "id": "Uuid", + "name": "String", "type": "$ref:BasicType" }, - "ValueOperatorType": [ - "OperatorTypeEquals", - "OperatorTypeNotEquals", - "OperatorTypeLess", - "OperatorTypeGreater", - "OperatorTypeLessThan", - "OperatorTypeGreaterThan" + "ValueOperator": [ + "ValueOperatorEquals", + "ValueOperatorNotEquals", + "ValueOperatorLess", + "ValueOperatorGreater", + "ValueOperatorLessOrEqual", + "ValueOperatorGreaterOrEqual" ], "Vendor": { - "id": "uuid", - "name": "string" + "id": "Uuid", + "name": "String" } } } diff --git a/tests/auto/devices/testdevices.cpp b/tests/auto/devices/testdevices.cpp index 98592efb..171d2e6d 100644 --- a/tests/auto/devices/testdevices.cpp +++ b/tests/auto/devices/testdevices.cpp @@ -98,7 +98,7 @@ void TestDevices::getPluginConfig() QVariantMap params; params.insert("pluginId", pluginId); QVariant response = injectAndWait("Devices.GetPluginConfiguration", params); - verifyError(response, "deviceError", error); + verifyDeviceError(response, error); } void TestDevices::setPluginConfig_data() @@ -130,13 +130,13 @@ void TestDevices::setPluginConfig() configuration.append(configParam); params.insert("configuration", configuration); QVariant response = injectAndWait("Devices.SetPluginConfiguration", params); - verifyError(response, "deviceError", error); + verifyDeviceError(response, error); if (error == DeviceManager::DeviceErrorNoError) { params.clear(); params.insert("pluginId", pluginId); response = injectAndWait("Devices.GetPluginConfiguration", params); - verifyError(response, "deviceError"); + verifyDeviceError(response); qDebug() << "222" << response.toMap().value("params").toMap().value("configuration").toList().first(); QVERIFY2(response.toMap().value("params").toMap().value("configuration").toList().first().toMap().value("name") == "configParamInt", "Value not set correctly"); QVERIFY2(response.toMap().value("params").toMap().value("configuration").toList().first().toMap().value("value") == value, "Value not set correctly"); @@ -199,7 +199,7 @@ void TestDevices::addConfiguredDevice_data() { QTest::addColumn("deviceClassId"); QTest::addColumn("deviceParams"); - QTest::addColumn("success"); + QTest::addColumn("deviceError"); QVariantMap httpportParam; httpportParam.insert("name", "httpport"); @@ -214,27 +214,27 @@ void TestDevices::addConfiguredDevice_data() QVariantList deviceParams; deviceParams.clear(); deviceParams << httpportParam; - QTest::newRow("User, JustAdd") << mockDeviceClassId << deviceParams << true; + QTest::newRow("User, JustAdd") << mockDeviceClassId << deviceParams << DeviceManager::DeviceErrorNoError; deviceParams.clear(); deviceParams << httpportParam << asyncParam; - QTest::newRow("User, JustAdd, Async") << mockDeviceClassId << deviceParams << true; - QTest::newRow("Invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << deviceParams << false; + QTest::newRow("User, JustAdd, Async") << mockDeviceClassId << deviceParams << DeviceManager::DeviceErrorNoError; + QTest::newRow("Invalid DeviceClassId") << DeviceClassId::createDeviceClassId() << deviceParams << DeviceManager::DeviceErrorDeviceClassNotFound; deviceParams.clear(); deviceParams << httpportParam << brokenParam; - QTest::newRow("Setup failure") << mockDeviceClassId << deviceParams << false; + QTest::newRow("Setup failure") << mockDeviceClassId << deviceParams << DeviceManager::DeviceErrorSetupFailed; deviceParams.clear(); deviceParams << httpportParam << asyncParam << brokenParam; - QTest::newRow("Setup failure, Async") << mockDeviceClassId << deviceParams << false; + QTest::newRow("Setup failure, Async") << mockDeviceClassId << deviceParams << DeviceManager::DeviceErrorSetupFailed; QVariantList invalidDeviceParams; - QTest::newRow("User, JustAdd, missing params") << mockDeviceClassId << invalidDeviceParams << false; + QTest::newRow("User, JustAdd, missing params") << mockDeviceClassId << invalidDeviceParams << DeviceManager::DeviceErrorMissingParameter; QVariantMap fakeparam; fakeparam.insert("name", "tropptth"); invalidDeviceParams.append(fakeparam); - QTest::newRow("User, JustAdd, invalid param") << mockDeviceClassId << invalidDeviceParams << false; + QTest::newRow("User, JustAdd, invalid param") << mockDeviceClassId << invalidDeviceParams << DeviceManager::DeviceErrorInvalidParameter; fakeparam.insert("value", "buhuu"); invalidDeviceParams.clear(); invalidDeviceParams.append(fakeparam); - QTest::newRow("User, JustAdd, wrong param") << mockDeviceClassId << invalidDeviceParams << false; + QTest::newRow("User, JustAdd, wrong param") << mockDeviceClassId << invalidDeviceParams << DeviceManager::DeviceErrorInvalidParameter; } @@ -242,7 +242,7 @@ void TestDevices::addConfiguredDevice() { QFETCH(DeviceClassId, deviceClassId); QFETCH(QVariantList, deviceParams); - QFETCH(bool, success); + QFETCH(DeviceManager::DeviceError, deviceError); QVariantMap params; params.insert("deviceClassId", deviceClassId); @@ -250,14 +250,14 @@ void TestDevices::addConfiguredDevice() QVariant response = injectAndWait("Devices.AddConfiguredDevice", params); qDebug() << "response is" << response; - verifyError(response, "deviceError", success); + verifyDeviceError(response, deviceError); - if (success) { + if (deviceError == DeviceManager::DeviceErrorNoError) { QUuid deviceId(response.toMap().value("params").toMap().value("deviceId").toString()); params.clear(); params.insert("deviceId", deviceId.toString()); response = injectAndWait("Devices.RemoveConfiguredDevice", params); - verifyError(response, "deviceError"); + verifyDeviceError(response); } } @@ -272,20 +272,20 @@ void TestDevices::getConfiguredDevices() void TestDevices::removeDevice_data() { QTest::addColumn("deviceId"); - QTest::addColumn("success"); + QTest::addColumn("deviceError"); - QTest::newRow("Existing Device") << m_mockDeviceId << true; - QTest::newRow("Not existing Device") << DeviceId::createDeviceId() << false; + QTest::newRow("Existing Device") << m_mockDeviceId << DeviceManager::DeviceErrorNoError; + QTest::newRow("Not existing Device") << DeviceId::createDeviceId() << DeviceManager::DeviceErrorDeviceNotFound; } void TestDevices::removeDevice() { QFETCH(DeviceId, deviceId); - QFETCH(bool, success); + QFETCH(DeviceManager::DeviceError, deviceError); QSettings settings(m_deviceSettings); settings.beginGroup("DeviceConfig"); - if (success) { + if (deviceError == DeviceManager::DeviceErrorNoError) { settings.beginGroup(m_mockDeviceId.toString()); // Make sure we have some config values for this device QVERIFY(settings.allKeys().count() > 0); @@ -296,9 +296,9 @@ void TestDevices::removeDevice() QVariant response = injectAndWait("Devices.RemoveConfiguredDevice", params); - verifyError(response, "deviceError", success); + verifyDeviceError(response, deviceError); - if (success) { + if (DeviceManager::DeviceErrorNoError) { // Make sure the device is gone from settings too QCOMPARE(settings.allKeys().count(), 0); } @@ -323,7 +323,7 @@ void TestDevices::storedDevices() deviceParams.append(httpportParam); params.insert("deviceParams", deviceParams); QVariant response = injectAndWait("Devices.AddConfiguredDevice", params); - verifyError(response, "deviceError"); + verifyDeviceError(response); DeviceId addedDeviceId = DeviceId(response.toMap().value("params").toMap().value("deviceId").toString()); QVERIFY(!addedDeviceId.isNull()); @@ -334,7 +334,6 @@ void TestDevices::storedDevices() bool found = false; foreach (const QVariant device, response.toMap().value("params").toMap().value("devices").toList()) { - qDebug() << "found stored device" << device; if (DeviceId(device.toMap().value("id").toString()) == addedDeviceId) { // foreach (const QVariant ¶mVariant, device.toMap().value("params").toList()) { // if () @@ -352,7 +351,7 @@ void TestDevices::storedDevices() params.clear(); params.insert("deviceId", addedDeviceId); response = injectAndWait("Devices.RemoveConfiguredDevice", params); - verifyError(response, "deviceError"); + verifyDeviceError(response); } void TestDevices::discoverDevices_data() @@ -385,7 +384,7 @@ void TestDevices::discoverDevices() params.insert("discoveryParams", discoveryParams); QVariant response = injectAndWait("Devices.GetDiscoveredDevices", params); - verifyError(response, "deviceError", error); + verifyDeviceError(response, error); if (error == DeviceManager::DeviceErrorNoError) { QCOMPARE(response.toMap().value("params").toMap().value("deviceDescriptors").toList().count(), resultCount); } @@ -399,13 +398,13 @@ void TestDevices::discoverDevices() params.insert("deviceDescriptorId", descriptorId.toString()); response = injectAndWait("Devices.AddConfiguredDevice", params); - verifyError(response, "deviceError"); + verifyDeviceError(response); DeviceId deviceId(response.toMap().value("params").toMap().value("deviceId").toString()); params.clear(); params.insert("deviceId", deviceId.toString()); response = injectAndWait("Devices.RemoveConfiguredDevice", params); - verifyError(response, "deviceError"); + verifyDeviceError(response); } } diff --git a/tests/auto/guhtestbase.cpp b/tests/auto/guhtestbase.cpp index 487970e7..bbd0ac4a 100644 --- a/tests/auto/guhtestbase.cpp +++ b/tests/auto/guhtestbase.cpp @@ -20,6 +20,7 @@ #include "mocktcpserver.h" #include "guhcore.h" #include "devicemanager.h" +#include "jsontypes.h" #include #include @@ -91,7 +92,7 @@ void GuhTestBase::initTestCase() QVariant response = injectAndWait("Devices.AddConfiguredDevice", params); - verifyError(response, "deviceError"); + verifyDeviceError(response); m_mockDeviceId = DeviceId(response.toMap().value("params").toMap().value("deviceId").toString()); QVERIFY2(!m_mockDeviceId.isNull(), "Newly created mock device must not be null."); @@ -125,13 +126,6 @@ QVariant GuhTestBase::injectAndWait(const QString &method, const QVariantMap &pa return jsonDoc.toVariant(); } -void GuhTestBase::verifyError(const QVariant &response, const QString &fieldName, int error) -{ - QJsonDocument jsonDoc = QJsonDocument::fromVariant(response); - QVERIFY2(response.toMap().value("status").toString() == QString("success"), jsonDoc.toJson().data()); - QVERIFY2(response.toMap().value("params").toMap().value(fieldName).toInt() == error, jsonDoc.toJson().data()); -} - void GuhTestBase::restartServer() { // Destroy and recreate the core instance... diff --git a/tests/auto/guhtestbase.h b/tests/auto/guhtestbase.h index 1062b94f..1e52c881 100644 --- a/tests/auto/guhtestbase.h +++ b/tests/auto/guhtestbase.h @@ -22,6 +22,8 @@ #include "typeutils.h" #include "mocktcpserver.h" #include "devicemanager.h" +#include "ruleengine.h" +#include "jsontypes.h" #include #include @@ -58,7 +60,27 @@ protected slots: protected: QVariant injectAndWait(const QString &method, const QVariantMap ¶ms = QVariantMap()); - void verifyError(const QVariant &response, const QString &fieldName, int error = 0); + + inline void verifyError(const QVariant &response, const QString &fieldName, const QString &error) + { + QJsonDocument jsonDoc = QJsonDocument::fromVariant(response); + QVERIFY2(response.toMap().value("status").toString() == QString("success"), jsonDoc.toJson().data()); + QVERIFY2(response.toMap().value("params").toMap().value(fieldName).toString() == error, + QString("\nExpected: %1\nGot: %2\nFull message: %3\n") + .arg(error) + .arg(response.toMap().value("params").toMap().value(fieldName).toString()) + .arg(jsonDoc.toJson().data()) + .toLatin1().data()); + } + + inline void verifyRuleError(const QVariant &response, RuleEngine::RuleError error = RuleEngine::RuleErrorNoError) { + verifyError(response, "ruleError", JsonTypes::ruleErrorToString(error)); + } + + inline void verifyDeviceError(const QVariant &response, DeviceManager::DeviceError error = DeviceManager::DeviceErrorNoError) { + verifyError(response, "deviceError", JsonTypes::deviceErrorToString(error)); + } + void restartServer(); protected: diff --git a/tests/auto/jsonrpc/testjsonrpc.cpp b/tests/auto/jsonrpc/testjsonrpc.cpp index e3229e27..6a05c95a 100644 --- a/tests/auto/jsonrpc/testjsonrpc.cpp +++ b/tests/auto/jsonrpc/testjsonrpc.cpp @@ -181,9 +181,7 @@ void TestJSONRPC::enableDisableNotifications() params.insert("enabled", enabled); QVariant response = injectAndWait("JSONRPC.SetNotificationStatus", params); - verifyError(response, "error"); QCOMPARE(response.toMap().value("params").toMap().value("enabled").toString(), enabled); - } void TestJSONRPC::stateChangeEmitsNotifications() @@ -191,7 +189,7 @@ void TestJSONRPC::stateChangeEmitsNotifications() QVariantMap params; params.insert("enabled", true); QVariant response = injectAndWait("JSONRPC.SetNotificationStatus", params); - verifyError(response, "serverError"); + QCOMPARE(response.toMap().value("params").toMap().value("enabled").toBool(), true); // Setup connection to mock client QNetworkAccessManager nam; @@ -226,7 +224,7 @@ void TestJSONRPC::stateChangeEmitsNotifications() params.clear(); params.insert("enabled", false); response = injectAndWait("JSONRPC.SetNotificationStatus", params); - verifyError(response, "serverError"); + QCOMPARE(response.toMap().value("params").toMap().value("enabled").toBool(), false); // Fire the a statechange once again clientSpy.clear(); diff --git a/tests/auto/rules/testrules.cpp b/tests/auto/rules/testrules.cpp index a2d83be5..c0814876 100644 --- a/tests/auto/rules/testrules.cpp +++ b/tests/auto/rules/testrules.cpp @@ -65,7 +65,7 @@ void TestRules::addRemoveRules_data() QVariantMap stateDescriptor; stateDescriptor.insert("stateTypeId", mockIntStateId); stateDescriptor.insert("deviceId", m_mockDeviceId); - stateDescriptor.insert("operator", "OperatorTypeLess"); + stateDescriptor.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorLess)); stateDescriptor.insert("value", "20"); QVariantMap validStateEvaluator; @@ -87,7 +87,7 @@ void TestRules::addRemoveRules_data() QVariantMap param1; param1.insert("name", "mockParamInt"); param1.insert("value", 3); - param1.insert("operator", "OperatorTypeEquals"); + param1.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorEquals)); params.append(param1); validEventDescriptor2.insert("paramDescriptors", params); @@ -111,7 +111,7 @@ void TestRules::addRemoveRules_data() QTest::newRow("valid rule. 2 EventDescriptors, 1 Action") << validActionNoParams << QVariantMap() << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorNoError; QTest::newRow("invalid rule: eventDescriptor and eventDescriptorList used") << validActionNoParams << validEventDescriptor1 << eventDescriptorList << validStateEvaluator << RuleEngine::RuleErrorInvalidParameter; QTest::newRow("invalid action") << invalidAction << validEventDescriptor1 << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorActionTypeNotFound; - QTest::newRow("invalid event descriptor") << validActionNoParams << invalidEventDescriptor << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorInvalidParameter; + QTest::newRow("invalid event descriptor") << validActionNoParams << invalidEventDescriptor << QVariantList() << validStateEvaluator << RuleEngine::RuleErrorDeviceNotFound; // QTest::newRow("invalid state evaluator") << validActionNoParams << invalidEventDescriptor << QVariantList() << invalidStateEvaluator << false; } @@ -137,7 +137,7 @@ void TestRules::addRemoveRules() } params.insert("stateEvaluator", stateEvaluator); QVariant response = injectAndWait("Rules.AddRule", params); - verifyError(response, "ruleError", error); + verifyRuleError(response, error); RuleId newRuleId = RuleId(response.toMap().value("params").toMap().value("ruleId").toString()); @@ -185,7 +185,7 @@ void TestRules::addRemoveRules() params.clear(); params.insert("ruleId", newRuleId); response = injectAndWait("Rules.RemoveRule", params); - verifyError(response, "ruleError"); + verifyRuleError(response); response = injectAndWait("Rules.GetRules"); rules = response.toMap().value("params").toMap().value("rules").toList(); @@ -197,7 +197,7 @@ void TestRules::removeInvalidRule() QVariantMap params; params.insert("ruleId", RuleId::createRuleId()); QVariant response = injectAndWait("Rules.RemoveRule", params); - verifyError(response, "ruleError", RuleEngine::RuleErrorInvalidRuleId); + verifyRuleError(response, RuleEngine::RuleErrorRuleNotFound); } void TestRules::loadStoreConfig() @@ -215,7 +215,7 @@ void TestRules::loadStoreConfig() QVariantMap eventParam1; eventParam1.insert("name", "mockParamInt"); eventParam1.insert("value", 3); - eventParam1.insert("operator", "OperatorTypeEquals"); + eventParam1.insert("operator", JsonTypes::valueOperatorToString(Types::ValueOperatorEquals)); eventParamDescriptors.append(eventParam1); eventDescriptor2.insert("paramDescriptors", eventParamDescriptors); @@ -253,7 +253,7 @@ void TestRules::loadStoreConfig() QVariant response = injectAndWait("Rules.AddRule", params); RuleId newRuleId = RuleId(response.toMap().value("params").toMap().value("ruleId").toString()); - verifyError(response, "ruleError"); + verifyRuleError(response); restartServer(); @@ -291,8 +291,6 @@ void TestRules::loadStoreConfig() if (actionVariant.toMap().value("actionTypeId") == replyActionVariant.toMap().value("actionTypeId") && actionVariant.toMap().value("deviceId") == replyActionVariant.toMap().value("deviceId")) { found = true; - qDebug() << "AAA:" << actionVariant; - qDebug() << "BBB:" << replyActionVariant; QVERIFY2(actionVariant == replyActionVariant, "Action doesn't match after loading from config."); } } @@ -302,7 +300,7 @@ void TestRules::loadStoreConfig() params.clear(); params.insert("ruleId", newRuleId); response = injectAndWait("Rules.RemoveRule", params); - verifyError(response, "ruleError"); + verifyRuleError(response); restartServer(); @@ -329,7 +327,7 @@ void TestRules::evaluateEvent() actions.append(action); addRuleParams.insert("actions", actions); QVariant response = injectAndWait("Rules.AddRule", addRuleParams); - verifyError(response, "ruleError"); + verifyRuleError(response); // Trigger an event QNetworkAccessManager nam; diff --git a/tests/auto/states/teststates.cpp b/tests/auto/states/teststates.cpp index c607dc2e..d0e7ff1e 100644 --- a/tests/auto/states/teststates.cpp +++ b/tests/auto/states/teststates.cpp @@ -36,6 +36,7 @@ class TestStates: public GuhTestBase private slots: void getStateValue_data(); void getStateValue(); + }; void TestStates::getStateValue_data() @@ -50,7 +51,7 @@ void TestStates::getStateValue_data() QTest::newRow("existing state") << device->id() << mockIntStateId << DeviceManager::DeviceErrorNoError; QTest::newRow("invalid device") << DeviceId::createDeviceId() << mockIntStateId << DeviceManager::DeviceErrorDeviceNotFound; - QTest::newRow("invalid statetype") << device->id() << StateTypeId::createStateTypeId() << DeviceManager::DeviceErrorInvalidParameter; + QTest::newRow("invalid statetype") << device->id() << StateTypeId::createStateTypeId() << DeviceManager::DeviceErrorStateTypeNotFound; } void TestStates::getStateValue() @@ -65,7 +66,7 @@ void TestStates::getStateValue() QVariant response = injectAndWait("Devices.GetStateValue", params); - verifyError(response, "deviceError", error); + verifyDeviceError(response, error); } #include "teststates.moc"