change how actions are stored. they don't belong to a device but into the rules engine

libhive/action.cpp

@@ -1,7 +1,8 @@
 #include "action.h"
 
-Action::Action(const QUuid &id) :
+Action::Action(const QUuid &id, const QUuid &deviceId) :
-    m_id(id)
+    m_id(id),
+    m_deviceId(deviceId)
 {
 }
 
@@ -15,6 +16,11 @@ QUuid Action::id() const
     return m_id;
 }
 
+QUuid Action::deviceId() const
+{
+    return m_deviceId;
+}
+
 QString Action::name() const
 {
     return m_name;
@@ -34,4 +40,3 @@ void Action::setParams(const QVariantList &params)
 {
     m_params = params;
 }
-

libhive/action.h

@@ -7,10 +7,11 @@
 class Action
 {
 public:
-    Action(const QUuid &id = QUuid());
+    Action(const QUuid &id = QUuid(), const QUuid &deviceId = QUuid());
     bool isValid() const;
 
     QUuid id() const;
+    QUuid deviceId() const;
 
     QString name() const;
     void setName(const QString &name);
@@ -20,6 +21,7 @@ public:
 
 private:
     QUuid m_id;
+    QUuid m_deviceId;
     QString m_name;
     QVariantList m_params;
 };

libhive/devicemanager.cpp

@@ -62,14 +62,6 @@ DeviceManager::DeviceError DeviceManager::addConfiguredDevice(const QUuid &devic
         triggers.append(trigger);
     }
     device->setTriggers(triggers);
-    QList<Action> actions;
-    foreach (const ActionType &actionType, deviceClass.actions()) {
-        Action action(QUuid::createUuid());
-        action.setName(actionType.name());
-        action.setParams(actionType.parameters());
-        actions.append(action);
-    }
-    device->setActions(actions);
     m_configuredDevices.append(device);
 
     storeConfiguredDevices();
@@ -127,21 +119,31 @@ Action DeviceManager::findAction(const QUuid &actionId)
     return Action();
 }
 
+QList<Action> DeviceManager::allActions() const
+{
+    QList<Action> ret;
+    foreach (Device *device, m_configuredDevices) {
+        foreach (const Action &action, device->actions()) {
+            ret << action;
+        }
+    }
+    return ret;
+}
+
 Radio433 *DeviceManager::radio433() const
 {
     return m_radio433;
 }
 
-void DeviceManager::executeAction(const QUuid &actionId, const QVariantMap &params)
+DeviceManager::DeviceError DeviceManager::executeAction(const Action &action)
 {
     foreach (Device *device, m_configuredDevices) {
-        foreach (const Action &action, device->actions()) {
+        if (action.deviceId() == device->id()) {
-            if (action.id() == actionId) {
+            m_devicePlugins.value(device->pluginId())->executeAction(device, action);
-                m_devicePlugins.value(device->pluginId())->executeAction(device, action);
+            return DeviceErrorNoError;
-                return;
-            }
         }
     }
+    return DeviceErrorDeviceNotFound;
 }
 
 void DeviceManager::loadPlugins()
@@ -185,19 +187,6 @@ void DeviceManager::loadConfiguredDevices()
         }
         device->setTriggers(triggerList);
         settings.endGroup();
-        settings.beginGroup("actions");
-        QList<Action> actionList;
-        foreach (const QString &actionId, settings.childGroups()) {
-            settings.beginGroup(actionId);
-            QUuid id(actionId);
-            Action action(id);
-            action.setName(settings.value("actionname").toString());
-            action.setParams(settings.value("params").toList());
-            settings.endGroup();
-            actionList.append(action);
-        }
-        device->setActions(actionList);
-        settings.endGroup();
         settings.endGroup();
         m_configuredDevices.append(device);
     }
@@ -220,14 +209,6 @@ void DeviceManager::storeConfiguredDevices()
             settings.endGroup();
         }
         settings.endGroup();
-        settings.beginGroup("actions");
-        foreach (const Action &action, device->actions()) {
-            settings.beginGroup(action.id().toString());
-            settings.setValue("actionname", action.name());
-            settings.setValue("params", action.params());
-            settings.endGroup();
-        }
-        settings.endGroup();
         settings.endGroup();
     }
 }

libhive/devicemanager.h

@@ -36,13 +36,15 @@ public:
     Trigger findTrigger(const QUuid &triggerId);
     Action findAction(const QUuid &actionId);
 
+    QList<Action> allActions() const;
+
     Radio433 *radio433() const;
 
 signals:
     void emitTrigger(const QUuid &triggerId, const QVariantMap &params);
 
 public slots:
-    void executeAction(const QUuid &actionId, const QVariantMap &params);
+    DeviceError executeAction(const Action &action);
 
 private slots:
     void loadPlugins();

server/hivecore.cpp

@@ -54,7 +54,7 @@ void HiveCore::gotSignal(const QUuid &triggerId, const QVariantMap &params)
     qDebug() << "id: " << triggerId;
     qDebug() << params;
 
-    foreach (const QUuid &actionId, m_ruleEngine->evaluateTrigger(triggerId)) {
+    foreach (const Action &action, m_ruleEngine->evaluateTrigger(triggerId)) {
-        m_deviceManager->executeAction(actionId, params);
+        m_deviceManager->executeAction(action);
     }
 }

server/jsonrpcserver.cpp

@@ -45,14 +45,14 @@ void JsonRPCServer::processData(int clientId, const QByteArray &jsonData)
         return;
     }
 
-    QString targetNamspace = commandList.first();
+    QString targetNamespace = commandList.first();
     QString method = commandList.last();
     QVariantMap params = message.value("params").toMap();
 
-    qDebug() << "got:" << targetNamspace << method << params;
+    qDebug() << "got:" << targetNamespace << method << params;
-    emit commandReceived(targetNamspace, method, params);
+    emit commandReceived(targetNamespace, method, params);
 
-    if (targetNamspace == "Devices") {
+    if (targetNamespace == "Devices") {
         if (method == "GetSupportedDevices") {
             QVariantMap params;
             QVariantList supportedDeviceList;
@@ -87,10 +87,12 @@ void JsonRPCServer::processData(int clientId, const QByteArray &jsonData)
         } else {
             sendErrorResponse(clientId, commandId, "No such method");
         }
-    } else if (targetNamspace == "Rules") {
+    } else if (targetNamespace == "Rules") {
         handleRulesMessage(clientId, commandId, method, params);
+    } else if (targetNamespace == "Actions") {
+        handleActionMessage(clientId, commandId, method, params);
     } else {
-        qDebug() << "got unknown namespace" << targetNamspace;
+        qDebug() << "got unknown namespace" << targetNamespace;
     }
 }
 
@@ -102,7 +104,7 @@ void JsonRPCServer::handleRulesMessage(int clientId, int commandId, const QStrin
             QVariantMap ruleMap;
             ruleMap.insert("id", rule.id());
             ruleMap.insert("triggerId", rule.triggerId());
-            ruleMap.insert("actionId", rule.actionId());
+            ruleMap.insert("action", packAction(rule.action()));
             rulesList.append(ruleMap);
         }
         QVariantMap rspParams;
@@ -125,6 +127,20 @@ void JsonRPCServer::handleRulesMessage(int clientId, int commandId, const QStrin
     }
 }
 
+void JsonRPCServer::handleActionMessage(int clientId, int commandId, const QString &method, const QVariantMap &params)
+{
+    if (method == "ExecuteAction") {
+        QUuid deviceId = QUuid(params.value("deviceId").toUuid());
+        QVariantList actionParams = params.value("params").toList();
+
+        Action action(QUuid::createUuid(), deviceId);
+        action.setParams(actionParams);
+
+        HiveCore::instance()->deviceManager()->executeAction(action);
+
+    }
+}
+
 QVariantMap JsonRPCServer::packDeviceClass(const DeviceClass &deviceClass)
 {
     QVariantMap variant;
@@ -175,6 +191,16 @@ QVariantMap JsonRPCServer::packDevice(Device *device)
     return variant;
 }
 
+QVariantMap JsonRPCServer::packAction(const Action &action)
+{
+    QVariantMap variant;
+    variant.insert("id", action.id());
+    variant.insert("deviceId", action.deviceId());
+    variant.insert("name", action.name());
+    variant.insert("params", action.params());
+    return variant;
+}
+
 void JsonRPCServer::sendResponse(int clientId, int commandId, const QVariantMap &params)
 {
     QVariantMap rsp;

server/jsonrpcserver.h

@@ -2,6 +2,7 @@
 #define JSONRPCSERVER_H
 
 #include "deviceclass.h"
+#include "action.h"
 
 #include <QObject>
 #include <QVariantMap>
@@ -24,9 +25,11 @@ private slots:
 
 private:
     void handleRulesMessage(int clientId, int commandId, const QString &method, const QVariantMap &params);
+    void handleActionMessage(int clientId, int commandId, const QString &method, const QVariantMap &params);
 
     QVariantMap packDeviceClass(const DeviceClass &deviceClass);
     QVariantMap packDevice(Device *device);
+    QVariantMap packAction(const Action &action);
 
     void sendResponse(int clientId, int commandId, const QVariantMap &params = QVariantMap());
     void sendErrorResponse(int clientId, int commandId, const QString &error);

server/rule.cpp

@@ -1,9 +1,9 @@
 #include "rule.h"
 
-Rule::Rule(const QUuid &id, const QUuid &triggerId, const QUuid &actionId):
+Rule::Rule(const QUuid &id, const QUuid &triggerId, const Action &action):
     m_id(id),
     m_triggerId(triggerId),
-    m_actionId(actionId)
+    m_action(action)
 {
 }
 
@@ -17,7 +17,7 @@ QUuid Rule::triggerId() const
     return m_triggerId;
 }
 
-QUuid Rule::actionId() const
+Action Rule::action() const
 {
-    return m_actionId;
+    return m_action;
 }

server/rule.h

@@ -1,21 +1,23 @@
 #ifndef RULE_H
 #define RULE_H
 
+#include "action.h"
+
 #include <QUuid>
 
 class Rule
 {
 public:
-    Rule(const QUuid &id, const QUuid &triggerId, const QUuid &actionId);
+    Rule(const QUuid &id, const QUuid &triggerId, const Action &action);
 
     QUuid id() const;
     QUuid triggerId() const;
-    QUuid actionId() const;
+    Action action() const;
 
 private:
     QUuid m_id;
     QUuid m_triggerId;
-    QUuid m_actionId;
+    Action m_action;
 };
 
 #endif // RULE_H

server/ruleengine.cpp

@@ -25,12 +25,12 @@ RuleEngine::RuleEngine(QObject *parent) :
 
 }
 
-QList<QUuid> RuleEngine::evaluateTrigger(const QUuid &triggerId)
+QList<Action> RuleEngine::evaluateTrigger(const QUuid &triggerId)
 {
-    QList<QUuid> actions;
+    QList<Action> actions;
     for (int i = 0; i < m_rules.count(); ++i) {
         if (m_rules.at(i).triggerId() == triggerId) {
-            actions << m_rules.at(i).actionId();
+            actions << m_rules.at(i).action();
         }
     }
     return actions;
@@ -53,7 +53,13 @@ RuleEngine::RuleError RuleEngine::addRule(const QUuid &triggerId, const QUuid &a
     QSettings settings(rulesFileName);
     settings.beginGroup(rule.id().toString());
     settings.setValue("triggerId", rule.triggerId());
-    settings.setValue("actionId", rule.actionId());
+
+    settings.beginGroup("action");
+    settings.setValue("id", rule.action().id());
+    settings.setValue("deviceId", rule.action().deviceId());
+    settings.setValue("name", rule.action().name());
+    settings.setValue("params", rule.action().params());
+    settings.endGroup();
 
     return RuleErrorNoError;
 }

server/ruleengine.h

@@ -19,7 +19,7 @@ public:
 
     explicit RuleEngine(QObject *parent = 0);
 
-    QList<QUuid> evaluateTrigger(const QUuid &triggerId);
+    QList<Action> evaluateTrigger(const QUuid &triggerId);
 
     RuleError addRule(const QUuid &triggerId, const QUuid &actionId);
     QList<Rule> rules() const;