ETM-Schurig/powersync-core
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

switch json api to better type system and enhance error reporting

Browse Source
This commit is contained in:
Michael Zanetti 2014-10-12 00:28:59 +02:00 committed by Michael Zanetti
parent 1aba1643f8
commit aad334c799
38 changed files with 659 additions and 710 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
libguh/devicemanager.cpp
View File

@ -139,14 +139,14 @@ DevicePlugin *DeviceManager::plugin(const PluginId &id) const
return m_devicePlugins.value(id);
}
QPair<DeviceManager::DeviceError, QString> 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<DeviceError, QString> 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::DeviceError, QString> DeviceManager::pairDevice(const DeviceClassId &deviceClassId, const ParamList &params)
DeviceManager::DeviceError DeviceManager::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
{
DeviceClass deviceClass = findDeviceClass(deviceClassId);
if (deviceClass.id().isNull()) {
qWarning() << "cannot find a device class with id" << deviceClassId;
return qMakePair<DeviceError, QString>(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<DeviceError, QString>(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, ParamList>(deviceClassId, params));
if (deviceClass.setupMethod() == DeviceClass::SetupMethodDisplayPin) {
// TODO: fetch PIN from device plugin
qWarning() << "SetupMethodDisplayPin not implemented yet";
return qMakePair<DeviceError, QString>(DeviceErrorSetupFailed, "SetupMethodDisplayPin Not implemented yet.");
}
return qMakePair<DeviceError, QString>(DeviceErrorNoError, pairingTransactionId.toString());
return DeviceErrorNoError;
}
QPair<DeviceManager::DeviceError, QString> 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<DeviceError, QString>(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<DeviceError, QString>(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<DeviceError, QString>(DeviceErrorDeviceDescriptorNotFound, deviceDescriptorId.toString());
return DeviceErrorDeviceDescriptorNotFound;
}
QUuid pairingTransactionId = QUuid::createUuid();
m_pairingsDiscovery.insert(pairingTransactionId, qMakePair<DeviceClassId, DeviceDescriptorId>(deviceClassId, deviceDescriptorId));
if (deviceClass.setupMethod() == DeviceClass::SetupMethodDisplayPin) {
// TODO: fetch PIN from device plugin
qWarning() << "SetupMethodDisplayPin not implemented yet";
return qMakePair<DeviceError, QString>(DeviceErrorSetupFailed, "SetupMethodDisplayPin Not implemented yet.");
return DeviceErrorSetupFailed;
}
return qMakePair<DeviceError, QString>(DeviceErrorNoError, pairingTransactionId.toString());
return DeviceErrorNoError;
}
QPair<DeviceManager::DeviceError, QString> 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<DeviceError, QString>(DeviceErrorSetupFailed, "Not implemented yet");
return DeviceErrorSetupFailed;
}
if (m_pairingsDiscovery.contains(pairingTransactionId)) {
@ -330,23 +330,23 @@ QPair<DeviceManager::DeviceError, QString> 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<DeviceSetupStatus, QString> 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 &params, const DeviceId id)
@ -381,8 +381,8 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDeviceInternal(const Devi
device->setName(deviceClass.name());
device->setParams(effectiveParams);
QPair<DeviceSetupStatus, QString> 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::DeviceError, QString> DeviceManager::removeConfiguredDevice(const DeviceId &deviceId)
DeviceManager::DeviceError DeviceManager::removeConfiguredDevice(const DeviceId &deviceId)
{
Device *device = findConfiguredDevice(deviceId);
if (!device) {
return qMakePair<DeviceError, QString>(DeviceErrorDeviceNotFound, deviceId.toString());
return DeviceErrorDeviceNotFound;
}
m_configuredDevices.removeAll(device);
@ -423,7 +423,7 @@ QPair<DeviceManager::DeviceError, QString> DeviceManager::removeConfiguredDevice
settings.remove("");
settings.endGroup();
return qMakePair<DeviceError, QString>(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<DevicePlugin*>(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<DeviceId> newDevices;
QString setupErrorMessage;
Device *device = new Device(plugin->pluginId(), id, deviceClassId, this);
device->setName(deviceClass.name());
device->setParams(params);
QPair<DeviceSetupStatus, QString> 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<DeviceDescriptor> &deviceDescriptors)
@ -805,18 +802,18 @@ void DeviceManager::autoDevicesAppeared(const DeviceClassId &deviceClassId, cons
device->setName(deviceClass.name());
device->setParams(deviceDescriptor.params());
QPair<DeviceSetupStatus, QString> 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::DeviceSetupStatus,QString> 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<DeviceSetupStatus, QString>(DeviceSetupStatusFailure, "Can't find a plugin for this device");
qWarning() << "Can't find a plugin for this device" << device->id();
return DeviceSetupStatusFailure;
}
QList<State> states;
@ -901,8 +899,8 @@ QPair<DeviceManager::DeviceSetupStatus,QString> DeviceManager::setupDevice(Devic
}
device->setStates(states);
QPair<DeviceSetupStatus, QString> 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 &paramType
qWarning() << "Parameter name" << param.name() << "does not match with ParamType name" << paramType.name();
return DeviceErrorInvalidParameter;
}
QPair<DeviceManager::DeviceError, QString> DeviceManager::report(DeviceManager::DeviceError error, const QString &message)
{
return qMakePair<DeviceManager::DeviceError, QString>(error, message);
}

35
libguh/devicemanager.h
View File

@ -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<DevicePlugin*> plugins() const;
DevicePlugin* plugin(const PluginId &id) const;
QPair<DeviceError, QString> setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig);
DeviceError setPluginConfig(const PluginId &pluginId, const ParamList &pluginConfig);
QList<Vendor> supportedVendors() const;
QList<DeviceClass> supportedDevices(const VendorId &vendorId = VendorId()) const;
@ -86,10 +89,10 @@ public:
QList<Device*> configuredDevices() const;
DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const ParamList &params, const DeviceId id = DeviceId::createDeviceId());
DeviceError addConfiguredDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId, const DeviceId &id = DeviceId::createDeviceId());
QPair<DeviceError, QString> pairDevice(const DeviceClassId &deviceClassId, const ParamList &params);
QPair<DeviceError, QString> pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId);
QPair<DeviceError, QString> confirmPairing(const QUuid &pairingTransactionId, const QString &secret = QString());
QPair<DeviceError, QString> removeConfiguredDevice(const DeviceId &deviceId);
DeviceError pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params);
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<Device*> 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<DeviceDescriptor> &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<DeviceDescriptor> 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<DeviceDescriptor> &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 &params, const DeviceId id = DeviceId::createDeviceId());
QPair<DeviceSetupStatus, QString> setupDevice(Device *device);
DeviceSetupStatus setupDevice(Device *device);
DeviceError verifyParams(const QList<ParamType> paramTypes, ParamList &params, bool requireAll = true);
DeviceError verifyParam(const QList<ParamType> paramTypes, const Param &param);
DeviceError verifyParam(const ParamType &paramType, const Param &param);
QPair<DeviceError, QString> report(DeviceError error = DeviceErrorNoError, const QString &message = QString());
private:
QHash<VendorId, Vendor> m_supportedVendors;

62
libguh/plugin/deviceplugin.cpp
View File

@ -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<DeviceClass> 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<DeviceClass> DevicePlugin::supportedDevices() const
deviceClass.setParamTypes(parseParamTypes(jo.value("paramTypes").toArray()));
QList<StateType> 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<DeviceClass> 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<DeviceManager::DeviceSetupStatus, QString> 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<DeviceManager::DeviceSetupStatus, QString> DevicePlugin::confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
DeviceManager::DeviceSetupStatus DevicePlugin::confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
{
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<ParamType> DevicePlugin::configurationDescription() const
@ -340,58 +338,62 @@ QVariant DevicePlugin::configValue(const QString &paramName) const
/*!
Will be called by the DeviceManager to set a plugin's \a configuration.
*/
QPair<DeviceManager::DeviceError, QString> DevicePlugin::setConfiguration(const ParamList &configuration)
DeviceManager::DeviceError DevicePlugin::setConfiguration(const ParamList &configuration)
{
foreach (const Param &param, configuration) {
qDebug() << "setting config" << param;
QPair<DeviceManager::DeviceError, QString> 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<DeviceManager::DeviceError, QString> DevicePlugin::setConfigValue(const QString &paramName, const QVariant &value)
DeviceManager::DeviceError DevicePlugin::setConfigValue(const QString &paramName, const QVariant &value)
{
bool found = false;
foreach (const ParamType &paramType, 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<int> 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<DeviceManager::DeviceError, QString> DevicePlugin::report(DeviceManager::DeviceError error, const QString &message)
{
return qMakePair<DeviceManager::DeviceError, QString>(error, message);
}
QPair<DeviceManager::DeviceSetupStatus, QString> DevicePlugin::reportDeviceSetup(DeviceManager::DeviceSetupStatus status, const QString &message)
{
return qMakePair<DeviceManager::DeviceSetupStatus, QString>(status, message);
}

16
libguh/plugin/deviceplugin.h
View File

@ -53,10 +53,10 @@ public:
virtual void startMonitoringAutoDevices();
virtual DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params);
virtual QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device);
virtual DeviceManager::DeviceSetupStatus setupDevice(Device *device);
virtual void deviceRemoved(Device *device);
virtual QPair<DeviceManager::DeviceSetupStatus, QString> confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params);
virtual DeviceManager::DeviceSetupStatus confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params);
// Hardware input
virtual void radioData(const QList<int> &rawData) {Q_UNUSED(rawData)}
@ -64,10 +64,10 @@ public:
// Configuration
virtual QList<ParamType> configurationDescription() const;
QPair<DeviceManager::DeviceError, QString> setConfiguration(const ParamList &configuration);
DeviceManager::DeviceError setConfiguration(const ParamList &configuration);
ParamList configuration() const;
QVariant configValue(const QString &paramName) const;
QPair<DeviceManager::DeviceError, QString> setConfigValue(const QString &paramName, const QVariant &value);
DeviceManager::DeviceError setConfigValue(const QString &paramName, 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<DeviceDescriptor> &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 &paramName, const QVariant &value);
void autoDevicesAppeared(const DeviceClassId &deviceClassId, const QList<DeviceDescriptor> &deviceDescriptors);
@ -91,8 +91,6 @@ protected:
bool transmitData(int delay, QList<int> rawData);
QPair<DeviceManager::DeviceError, QString> report(DeviceManager::DeviceError error = DeviceManager::DeviceErrorNoError, const QString &message = QString());
QPair<DeviceManager::DeviceSetupStatus, QString> reportDeviceSetup(DeviceManager::DeviceSetupStatus status = DeviceManager::DeviceSetupStatusSuccess, const QString &message = QString());
private:
void initPlugin(const QJsonObject &metaData, DeviceManager *deviceManager);

2
libguh/typeutils.h
View File

@ -50,6 +50,8 @@ DECLARE_TYPE_ID(Action)
DECLARE_TYPE_ID(Plugin)
DECLARE_TYPE_ID(Rule)
DECLARE_TYPE_ID(PairingTransaction)
class Types
{
Q_GADGET

16
plugins/deviceplugins/eq-3/deviceplugineq-3.cpp
View File

@ -261,7 +261,7 @@ void DevicePluginEQ3::startMonitoringAutoDevices()
}
QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginEQ3::setupDevice(Device *device)
DeviceManager::DeviceSetupStatus DevicePluginEQ3::setupDevice(Device *device)
{
qDebug() << "setupDevice" << device->params();
@ -269,7 +269,7 @@ QPair<DeviceManager::DeviceSetupStatus, QString> 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<DeviceManager::DeviceSetupStatus, QString> 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<MaxCube*>(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<MaxCube *> &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);
}
}

2
plugins/deviceplugins/eq-3/deviceplugineq-3.h
View File

@ -43,7 +43,7 @@ public:
void startMonitoringAutoDevices() override;
QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
void deviceRemoved(Device *device) override;
void guhTimer() override;

12
plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.cpp
View File

@ -78,7 +78,7 @@ DeviceManager::DeviceError DevicePluginLgSmartTv::discoverDevices(const DeviceCl
return DeviceManager::DeviceErrorAsync;
}
QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginLgSmartTv::setupDevice(Device *device)
DeviceManager::DeviceSetupStatus DevicePluginLgSmartTv::setupDevice(Device *device)
{
device->setName("LG Smart Tv (" + device->paramValue("model").toString() + ")");
@ -102,7 +102,7 @@ QPair<DeviceManager::DeviceSetupStatus, QString> 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);
}
}

2
plugins/deviceplugins/lgsmarttv/devicepluginlgsmarttv.h
View File

@ -35,7 +35,7 @@ public:
TvDiscovery *m_discovery;
DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
DeviceManager::HardwareResources requiredHardware() const override;
DeviceManager::DeviceError executeAction(Device *device, const Action &action) override;

4
plugins/deviceplugins/mailnotification/devicepluginmailnotification.cpp
View File

@ -245,7 +245,7 @@ DevicePluginMailNotification::~DevicePluginMailNotification()
m_smtpClient->deleteLater();
}
QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginMailNotification::setupDevice(Device *device)
DeviceManager::DeviceSetupStatus DevicePluginMailNotification::setupDevice(Device *device)
{
// Google mail
// if(device->deviceClassId() == googleMailDeviceClassId){
@ -255,7 +255,7 @@ QPair<DeviceManager::DeviceSetupStatus, QString> 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

2
plugins/deviceplugins/mailnotification/devicepluginmailnotification.h
View File

@ -33,7 +33,7 @@ public:
explicit DevicePluginMailNotification();
~DevicePluginMailNotification();
QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
DeviceManager::HardwareResources requiredHardware() const override;
DeviceManager::DeviceError executeAction(Device *device, const Action &action) override;

23
plugins/deviceplugins/mock/devicepluginmock.cpp
View File

@ -58,20 +58,21 @@ DeviceManager::DeviceError DevicePluginMock::discoverDevices(const DeviceClassId
return DeviceManager::DeviceErrorAsync;
}
QPair<DeviceManager::DeviceSetupStatus, QString> 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<DeviceManager::DeviceSetupStatus, QString> 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<ParamType> 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, Device*> 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);
}
}

2
plugins/deviceplugins/mock/devicepluginmock.h
View File

@ -39,7 +39,7 @@ public:
DeviceManager::HardwareResources requiredHardware() const override;
DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
void deviceRemoved(Device *device) override;
void startMonitoringAutoDevices() override;

1
plugins/deviceplugins/mock/httpdaemon.cpp
View File

@ -160,7 +160,6 @@ QString HttpDaemon::generateWebPage()
body.append("<table>");
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(
"<tr>"

7
plugins/deviceplugins/openweathermap/devicepluginopenweathermap.cpp
View File

@ -325,18 +325,19 @@ DeviceManager::DeviceError DevicePluginOpenweathermap::discoverDevices(const Dev
return DeviceManager::DeviceErrorAsync;
}
QPair<DeviceManager::DeviceSetupStatus, QString> 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

2
plugins/deviceplugins/openweathermap/devicepluginopenweathermap.h
View File

@ -36,7 +36,7 @@ public:
OpenWeatherMap *m_openweaher;
DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
DeviceManager::HardwareResources requiredHardware() const override;
DeviceManager::DeviceError executeAction(Device *device, const Action &action) override;

28
plugins/deviceplugins/philipshue/devicepluginphilipshue.cpp
View File

@ -77,7 +77,7 @@ DeviceManager::DeviceError DevicePluginPhilipsHue::discoverDevices(const DeviceC
return DeviceManager::DeviceErrorAsync;
}
QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::setupDevice(Device *device)
DeviceManager::DeviceSetupStatus DevicePluginPhilipsHue::setupDevice(Device *device)
{
qDebug() << "setupDevice" << device->params();
@ -90,7 +90,8 @@ QPair<DeviceManager::DeviceSetupStatus, QString> 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<DeviceManager::DeviceSetupStatus, QString> 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<DeviceDescriptor>, 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<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
DeviceManager::DeviceSetupStatus DevicePluginPhilipsHue::confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
{
Param ipParam;
foreach (const Param &param, params) {
@ -143,7 +143,8 @@ QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginPhilipsHue::confirm
}
}
if (!ipParam.isValid()) {
return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure, "Missing parameter: ip");
qWarning() << "Missing parameter: ip";
return DeviceManager::DeviceSetupStatusFailure;
}
Param usernameParam;
foreach (const Param &param, params) {
@ -152,7 +153,8 @@ QPair<DeviceManager::DeviceSetupStatus, QString> 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<DeviceManager::DeviceSetupStatus, QString> 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 &params)
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 &params)
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);
}

6
plugins/deviceplugins/philipshue/devicepluginphilipshue.h
View File

@ -43,10 +43,10 @@ public:
QList<ParamType> configurationDescription() const override;
DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
void deviceRemoved(Device *device) override;
QPair<DeviceManager::DeviceSetupStatus, QString> confirmPairing(const QUuid &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params) override;
DeviceManager::DeviceSetupStatus confirmPairing(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params) override;
void guhTimer() override;
@ -67,7 +67,7 @@ private:
class PairingInfo {
public:
QUuid pairingTransactionId;
PairingTransactionId pairingTransactionId;
Param ipParam;
Param usernameParam;
};

12
plugins/deviceplugins/wemo/devicepluginwemo.cpp
View File

@ -157,13 +157,13 @@ DeviceManager::DeviceError DevicePluginWemo::discoverDevices(const DeviceClassId
return DeviceManager::DeviceErrorAsync;
}
QPair<DeviceManager::DeviceSetupStatus, QString> 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<DeviceManager::DeviceSetupStatus, QString> 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);
}
}

2
plugins/deviceplugins/wemo/devicepluginwemo.h
View File

@ -33,7 +33,7 @@ public:
explicit DevicePluginWemo();
DeviceManager::DeviceError discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
DeviceManager::DeviceSetupStatus setupDevice(Device *device) override;
DeviceManager::HardwareResources requiredHardware() const override;
DeviceManager::DeviceError executeAction(Device *device, const Action &action) override;

19
server/guhcore.cpp
View File

@ -63,7 +63,7 @@ QList<DevicePlugin *> GuhCore::plugins() const
return m_deviceManager->plugins();
}
QPair<DeviceManager::DeviceError, QString> GuhCore::setPluginConfig(const PluginId &pluginId, const ParamList &params)
DeviceManager::DeviceError GuhCore::setPluginConfig(const PluginId &pluginId, const ParamList &params)
{
return m_deviceManager->setPluginConfig(pluginId, params);
}
@ -78,7 +78,7 @@ QList<DeviceClass> GuhCore::supportedDevices(const VendorId &vendorId) const
return m_deviceManager->supportedDevices(vendorId);
}
QPair<DeviceManager::DeviceError, QString> GuhCore::removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList)
DeviceManager::DeviceError GuhCore::removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList)
{
QHash<RuleId, RuleEngine::RemovePolicy> toBeChanged;
QList<RuleId> unhandledRules;
@ -97,7 +97,8 @@ QPair<DeviceManager::DeviceError, QString> GuhCore::removeConfiguredDevice(const
}
if (!unhandledRules.isEmpty()) {
return qMakePair<DeviceManager::DeviceError, QString>(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<DeviceManager::DeviceError, QString> GuhCore::removeConfiguredDevice(const
return m_deviceManager->removeConfiguredDevice(deviceId);
}
QPair<DeviceManager::DeviceError, QString> 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<DeviceManager::DeviceError, QString> GuhCore::pairDevice(const DeviceClassId &deviceClassId, const ParamList &params)
DeviceManager::DeviceError GuhCore::pairDevice(const PairingTransactionId &pairingTransactionId, const DeviceClassId &deviceClassId, const ParamList &params)
{
return m_deviceManager->pairDevice(deviceClassId, params);
return m_deviceManager->pairDevice(pairingTransactionId, deviceClassId, params);
}
QPair<DeviceManager::DeviceError, QString> 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:

14
server/guhcore.h
View File

@ -43,7 +43,7 @@ public:
void destroy();
QList<DevicePlugin *> plugins() const;
QPair<DeviceManager::DeviceError, QString> setPluginConfig(const PluginId &pluginId, const ParamList &params);
DeviceManager::DeviceError setPluginConfig(const PluginId &pluginId, const ParamList &params);
// Device handling
QList<Vendor> supportedVendors() const;
@ -55,11 +55,11 @@ public:
QList<Device*> configuredDevices() const;
Device *findConfiguredDevice(const DeviceId &deviceId) const;
QList<Device*> findConfiguredDevices(const DeviceClassId &deviceClassId) const;
QPair<DeviceManager::DeviceError, QString> removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList);
DeviceManager::DeviceError removeConfiguredDevice(const DeviceId &deviceId, const QHash<RuleId, RuleEngine::RemovePolicy> &removePolicyList);
QPair<DeviceManager::DeviceError, QString> pairDevice(const DeviceClassId &deviceClassId, const DeviceDescriptorId &deviceDescriptorId);
QPair<DeviceManager::DeviceError, QString> pairDevice(const DeviceClassId &deviceClassId, const ParamList &params);
QPair<DeviceManager::DeviceError, QString> 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 &params);
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<DeviceDescriptor> 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;

29
server/jsonrpc/actionhandler.cpp
View File

@ -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 &params)
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 &params)
return reply;
}
QVariantMap returns;
returns.insert("deviceError", status);
return createReply(returns);
return createReply(statusToReply(status));
}
JsonReply *ActionHandler::GetActionType(const QVariantMap &params) const
@ -84,32 +78,29 @@ JsonReply *ActionHandler::GetActionType(const QVariantMap &params) 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;
}

4
server/jsonrpc/actionhandler.h
View File

@ -35,10 +35,10 @@ public:
Q_INVOKABLE JsonReply* GetActionType(const QVariantMap &params) 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<ActionId, JsonReply*> m_asyncActionExecutions;

182
server/jsonrpc/devicehandler.cpp
View File

@ -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 &params) 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 &params) 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 &params) 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 &params)
QVariantMap returns;
PluginId pluginId = PluginId(params.value("pluginId").toString());
ParamList pluginParams = JsonTypes::unpackParams(params.value("configuration").toList());
QPair<DeviceManager::DeviceError, QString> 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 &params)
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 &params)
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 &params)
DeviceClassId deviceClassId(params.value("deviceClassId").toString());
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(deviceClassId);
QPair<DeviceManager::DeviceError, QString> 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 &params)
{
QUuid pairingTransactionId = params.value("pairingTransactionId").toUuid();
PairingTransactionId pairingTransactionId = PairingTransactionId(params.value("pairingTransactionId").toString());
QString secret = params.value("secret").toString();
QPair<DeviceManager::DeviceError, QString> 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 &params)
}
QVariantMap returns;
QPair<DeviceManager::DeviceError, QString> 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 &params) 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;

2
server/jsonrpc/devicehandler.h
View File

@ -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

18
server/jsonrpc/jsonrpcserver.cpp
View File

@ -42,7 +42,7 @@
#include <QJsonDocument>
#include <QStringList>
#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 &params)
// 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 &params)
void JsonRPCServer::asyncReplyFinished()
{
JsonReply *reply = qobject_cast<JsonReply*>(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();

247
server/jsonrpc/jsontypes.cpp
View File

@ -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 &paramDescripto
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<bool, QString> 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<bool, QString> JsonTypes::validateMap(const QVariantMap &templateMap, cons
if (map.contains(strippedKey)) {
QPair<bool, QString> 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<bool, QString> JsonTypes::validateMap(const QVariantMap &templateMap, cons
QPair<bool, QString> 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<bool, QString> JsonTypes::validateVariant(const QVariant &templateVariant,
qDebug() << "evendescriptor not matching";
return result;
}
} else if (refName == basicTypesRef()) {
} else if (refName == basicTypeRef()) {
QPair<bool, QString> 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<bool, QString> result = validateStateOperatorType(variant);
} else if (refName == stateOperatorRef()) {
QPair<bool, QString> 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<bool, QString> result = validateCreateMethodType(variant);
} else if (refName == createMethodRef()) {
QPair<bool, QString> 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<bool, QString> result = validateSetupMethodType(variant);
} else if (refName == setupMethodRef()) {
QPair<bool, QString> 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<bool, QString> result = validateValueOperatorType(variant);
} else if (refName == valueOperatorRef()) {
QPair<bool, QString> 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<bool, QString> 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<bool, QString> 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<bool, QString> JsonTypes::validateBasicType(const QVariant &variant)
return report(false, QString("Error validating basic type %1.").arg(variant.toString()));
}
QPair<bool, QString> JsonTypes::validateStateOperatorType(const QVariant &variant)
QPair<bool, QString> 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<bool, QString> JsonTypes::validateCreateMethodType(const QVariant &variant)
QPair<bool, QString> 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<bool, QString> JsonTypes::validateSetupMethodType(const QVariant &variant)
QPair<bool, QString> 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<bool, QString> JsonTypes::validateValueOperatorType(const QVariant &variant)
QPair<bool, QString> 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<bool, QString> JsonTypes::validateDeviceError(const QVariant &variant)
{
return report(s_deviceError.contains(variant.toString()), QString("Unknown DeviceError: %1").arg(variant.toString()));
}
QPair<bool, QString> JsonTypes::validateRuleError(const QVariant &variant)
{
return report(s_ruleError.contains(variant.toString()), QString("Unknown RuleError: %1").arg(variant.toString()));
}

37
server/jsonrpc/jsontypes.h
View File

@ -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<bool, QString> validateList(const QVariantList &templateList, const QVariantList &list);
static QPair<bool, QString> validateVariant(const QVariant &templateVariant, const QVariant &variant);
static QPair<bool, QString> validateBasicType(const QVariant &variant);
static QPair<bool, QString> validateStateOperatorType(const QVariant &variant);
static QPair<bool, QString> validateCreateMethodType(const QVariant &variant);
static QPair<bool, QString> validateSetupMethodType(const QVariant &variant);
static QPair<bool, QString> validateValueOperatorType(const QVariant &variant);
static QPair<bool, QString> validateStateOperator(const QVariant &variant);
static QPair<bool, QString> validateCreateMethod(const QVariant &variant);
static QPair<bool, QString> validateSetupMethod(const QVariant &variant);
static QPair<bool, QString> validateValueOperator(const QVariant &variant);
static QPair<bool, QString> validateDeviceError(const QVariant &variant);
static QPair<bool, QString> validateRuleError(const QVariant &variant);
private:
static bool s_initialized;

24
server/jsonrpc/ruleshandler.cpp
View File

@ -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 &params)
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 &params)
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 &params)
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 &params)
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);
}

8
tests/auto/actions/testactions.cpp
View File

@ -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.");

288
tests/auto/api.json
View File

@ -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"
}
}
}

57
tests/auto/devices/testdevices.cpp
View File

@ -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>("deviceClassId");
QTest::addColumn<QVariantList>("deviceParams");
QTest::addColumn<bool>("success");
QTest::addColumn<DeviceManager::DeviceError>("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>("deviceId");
QTest::addColumn<bool>("success");
QTest::addColumn<DeviceManager::DeviceError>("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 &paramVariant, 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);
}
}

10
tests/auto/guhtestbase.cpp
View File

@ -20,6 +20,7 @@
#include "mocktcpserver.h"
#include "guhcore.h"
#include "devicemanager.h"
#include "jsontypes.h"
#include <QVariantMap>
#include <QJsonDocument>
@ -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...

24
tests/auto/guhtestbase.h
View File

@ -22,6 +22,8 @@
#include "typeutils.h"
#include "mocktcpserver.h"
#include "devicemanager.h"
#include "ruleengine.h"
#include "jsontypes.h"
#include <QObject>
#include <QUuid>
@ -58,7 +60,27 @@ protected slots:
protected:
QVariant injectAndWait(const QString &method, const QVariantMap &params = 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:

6
tests/auto/jsonrpc/testjsonrpc.cpp
View File

@ -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();

22
tests/auto/rules/testrules.cpp
View File

@ -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;

5
tests/auto/states/teststates.cpp
View File

@ -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"