Fix group action executions

Fixes: #522

libnymea-app/thinggroup.cpp

@@ -36,7 +36,6 @@
 
 ThingGroup::ThingGroup(DeviceManager *deviceManager, DeviceClass *deviceClass, DevicesProxy *devices, QObject *parent):
     Device(deviceManager, deviceClass, QUuid::createUuid(), parent),
-    m_thingManager(deviceManager),
     m_things(devices)
 {
     deviceClass->setParent(this);
@@ -45,7 +44,7 @@ ThingGroup::ThingGroup(DeviceManager *deviceManager, DeviceClass *deviceClass, D
     for (int i = 0; i < deviceClass->stateTypes()->rowCount(); i++) {
         StateType *st = deviceClass->stateTypes()->get(i);
         State *state = new State(id(), st->id(), QVariant(), this);
-        qDebug() << "Adding state" << st->name();
+        qDebug() << "Adding state" << st->name() << st->minValue() << st->maxValue();
         states->addState(state);
     }
     setStates(states);
@@ -56,14 +55,15 @@ ThingGroup::ThingGroup(DeviceManager *deviceManager, DeviceClass *deviceClass, D
         syncStates();
     });
 
-    connect(m_thingManager, &DeviceManager::executeActionReply, this, [this](int commandId, const QVariantMap &/*params*/){
+    connect(m_thingManager, &DeviceManager::executeActionReply, this, [this](int commandId, const QVariantMap &params){
-        // This should maybe check the params and only emit NoError if there is at least one thing that returned without error?
+        // This should maybe check the params and create a sensible group result instead of just forwarding the result of the last reply
-        foreach (int id, m_pendingActions.keys()) {
+        qDebug() << "action reply:" << commandId;
-            if (m_pendingActions.value(id).contains(commandId)) {
+        foreach (int id, m_pendingGroupActions.keys()) {
-                m_pendingActions[id].removeAll(commandId);
+            if (m_pendingGroupActions.value(id).contains(commandId)) {
-                if (m_pendingActions[id].isEmpty()) {
+                m_pendingGroupActions[id].removeAll(commandId);
-                    m_pendingActions.remove(id);
+                if (m_pendingGroupActions[id].isEmpty()) {
-                    emit actionExecutionFinished(id, "DeviceErrorNoError");
+                    m_pendingGroupActions.remove(id);
+                    emit executeActionReply(id, params);
                 }
                 return;
             }
@@ -76,35 +76,51 @@ int ThingGroup::executeAction(const QString &actionName, const QVariantList &par
 {
     QList<int> pendingIds;
 
+    ActionType *groupActionType = m_thingClass->actionTypes()->findByName(actionName);
+    if (!groupActionType) {
+        qWarning() << "Group has no action" << actionName;
+        return -1;
+    }
+
     qDebug() << "Execute action for group:" << this;
     for (int i = 0; i < m_things->rowCount(); i++) {
-        Device *device = m_things->get(i);
+        Device *thing = m_things->get(i);
-        if (device->setupStatus() != Device::ThingSetupStatusComplete) {
+        if (thing->setupStatus() != Device::ThingSetupStatusComplete) {
             continue;
         }
-        ActionType *actionType = device->thingClass()->actionTypes()->findByName(actionName);
+        ActionType *actionType = thing->thingClass()->actionTypes()->findByName(actionName);
         if (!actionType) {
+            qWarning() << "Cannot send action to thing" << thing->name() << "because according action can't be found";
             continue;
         }
 
 
         QVariantList finalParams;
         foreach (const QVariant &paramVariant, params) {
-            ParamType *paramType = actionType->paramTypes()->findByName(paramVariant.toMap().value("paramName").toString());
+            QString paramName = paramVariant.toMap().value("paramName").toString();
-            if (paramType) {
+            ParamType *groupParamType = groupActionType->paramTypes()->findByName(paramName);
-                QVariantMap finalParam;
+            if (!groupParamType) {
-                finalParam.insert("paramTypeId", paramType->id());
+                qWarning() << "Not adding param" << paramName << "to action" << actionName << "because group action param can't be found";
-                finalParam.insert("value", paramVariant.toMap().value("value"));
+                continue;
-                finalParams.append(finalParam);
             }
+            ParamType *paramType = actionType->paramTypes()->findByName(paramName);
+            if (!paramType) {
+                qWarning() << "Not adding param" << paramName << "to action" << actionName << "because according action params can't be found";
+                continue;
+            }
+
+            QVariantMap finalParam;
+            finalParam.insert("paramTypeId", paramType->id());
+            finalParam.insert("value", mapValue(paramVariant.toMap().value("value"), groupParamType, paramType));
+            finalParams.append(finalParam);
         }
 
         qDebug() << "Initial params" << params;
-        qDebug() << "Executing" << device->id() << actionType->name() << finalParams;
+        qDebug() << "Executing" << thing->id() << actionType->name() << finalParams;
-        int id = m_thingManager->executeAction(device->id(), actionType->id(), finalParams);
+        int id = m_thingManager->executeAction(thing->id(), actionType->id(), finalParams);
         pendingIds.append(id);
     }
-    m_pendingActions.insert(++m_idCounter, pendingIds);
+    m_pendingGroupActions.insert(++m_idCounter, pendingIds);
     return m_idCounter;
 }
 
@@ -114,7 +130,7 @@ void ThingGroup::syncStates()
         StateType *stateType = thingClass()->stateTypes()->get(i);
         State *state = states()->getState(stateType->id());
 
-        qDebug() << "syncing state" << stateType->name();
+        qDebug() << "syncing state" << stateType->name() << stateType->type();
 
         QVariant value;
         int count = 0;
@@ -142,6 +158,9 @@ void ThingGroup::syncStates()
             } else if (stateType->type().toLower() == "int") {
                 value = value.toInt() + d->stateValue(ds->id()).toInt();
                 count++;
+            } else if (stateType->type().toLower() == "qcolor") {
+                value = d->stateValue(ds->id());
+                break;
             }
         }
         if (count > 0) {
@@ -150,3 +169,23 @@ void ThingGroup::syncStates()
         state->setValue(value);
     }
 }
+
+QVariant ThingGroup::mapValue(const QVariant &value, ParamType *fromParamType, ParamType *toParamType) const
+{
+    qDebug() << "Mapping:" << value << fromParamType->minValue() << fromParamType->maxValue() << toParamType->minValue() << toParamType->maxValue();
+
+    if (!fromParamType->minValue().isValid()
+            || !fromParamType->maxValue().isValid()
+            || !toParamType->minValue().isValid()
+            || !toParamType->maxValue().isValid()) {
+        return value;
+    }
+    double fromMin = fromParamType->minValue().toDouble();
+    double fromMax = fromParamType->maxValue().toDouble();
+    double toMin = toParamType->minValue().toDouble();
+    double toMax = toParamType->maxValue().toDouble();
+    double fromValue = value.toDouble();
+    double fromPercent = (fromValue - fromMin) / (fromMax - fromMin);
+    double toValue = toMin + (toMax - toMin) * fromPercent;
+    return toValue;
+}

libnymea-app/thinggroup.h

@@ -37,6 +37,7 @@
 
 class DevicesProxy;
 class DeviceManager;
+class ParamType;
 
 class ThingGroup : public Device
 {
@@ -49,15 +50,13 @@ public:
 private:
     void syncStates();
 
-signals:
+    QVariant mapValue(const QVariant &value, ParamType *fromParamType, ParamType *toParamType) const;
-    void actionExecutionFinished(int id, const QString &status);
 
-private:
+private:    
-    DeviceManager* m_thingManager = nullptr;
     DevicesProxy* m_things = nullptr;
 
     int m_idCounter = 0;
-    QHash<int, QList<int>> m_pendingActions;
+    QHash<int, QList<int>> m_pendingGroupActions;
 };
 
 #endif // THINGGROUP_H

libnymea-app/types/device.cpp

@@ -40,6 +40,12 @@ Device::Device(DeviceManager *thingManager, DeviceClass *thingClass, const QUuid
     m_parentId(parentId),
     m_thingClass(thingClass)
 {
+    connect(thingManager, &DeviceManager::executeActionReply, this, [=](int commandId, const QVariantMap &params){
+        if (m_pendingActions.contains(commandId)) {
+            m_pendingActions.removeAll(commandId);
+            emit executeActionReply(commandId, params);
+        }
+    });
 }
 
 QString Device::name() const
@@ -229,7 +235,9 @@ int Device::executeAction(const QString &actionName, const QVariantList &params)
         }
         finalParams.append(param);
     }
-    return m_thingManager->executeAction(m_id, actionType->id(), finalParams);
+    int commandId = m_thingManager->executeAction(m_id, actionType->id(), finalParams);
+    m_pendingActions.append(commandId);
+    return commandId;
 }
 
 QDebug operator<<(QDebug &dbg, Device *thing)

libnymea-app/types/device.h

@@ -114,6 +114,9 @@ signals:
     void statesChanged();
     void eventTriggered(const QUuid &eventTypeId, const QVariantMap &params);
 
+signals:
+    void executeActionReply(int commandId, const QVariantMap &params);
+
 protected:
     DeviceManager *m_thingManager = nullptr;
     QString m_name;
@@ -125,6 +128,8 @@ protected:
     Params *m_settings = nullptr;
     States *m_states = nullptr;
     DeviceClass *m_thingClass = nullptr;
+
+    QList<int> m_pendingActions;
 };
 
 QDebug operator<<(QDebug &dbg, Device* thing);

libnymea-app/types/interfaces.cpp

@@ -417,7 +417,7 @@ void Interfaces::addStateType(const QString &interfaceName, const QString &name,
     st->setMinValue(min);
     st->setMaxValue(max);
     iface->stateTypes()->addStateType(st);
-    ParamTypes *pts = createParamTypes(name, displayName, type);
+    ParamTypes *pts = createParamTypes(name, displayName, type, QVariant(), min, max);
     addEventType(interfaceName, name, displayNameEvent, pts);
     if (writable) {
         addActionType(interfaceName, name, displayNameAction, pts);

nymea-app/ui/delegates/InterfaceTile.qml

@@ -200,11 +200,10 @@ MainPageTile {
             onClicked: {
                 switch (iface.name) {
                 case "light":
-                    var group = engine.deviceManager.createGroup(Interfaces.findByName("colorlight"), devicesProxy);
+                    var group = engine.thingManager.createGroup(Interfaces.findByName("colorlight"), devicesProxy);
                     print("opening lights page for group", group)
-                    pageStack.push("../devicepages/LightDevicePage.qml", {device: group})
+                    pageStack.push("../devicepages/LightDevicePage.qml", {thing: group})
                 }
-
             }
         }
     }

nymea-app/ui/devicepages/LightDevicePage.qml

@@ -118,16 +118,16 @@ DevicePageBase {
                             var absoluteCtValue = (model.ct * (root.ctStateType.maxValue - root.ctStateType.minValue) / 100) + root.ctStateType.minValue
                             var params = [];
                             var param1 = {};
-                            param1["paramTypeId"] = root.ctActionType.paramTypes.get(0).id;
+                            param1["paramName"] = root.ctActionType.paramTypes.get(0).name;
                             param1["value"] = absoluteCtValue;
                             params.push(param1)
-                            engine.deviceManager.executeAction(root.device.id, root.ctActionType.id, params)
+                            root.thing.executeAction(root.ctActionType.name, params)
                             params = [];
                             param1 = {};
-                            param1["paramTypeId"] = root.brightnessActionType.paramTypes.get(0).id;
+                            param1["paramName"] = root.brightnessActionType.paramTypes.get(0).name;
                             param1["value"] = model.bri;
                             params.push(param1)
-                            engine.deviceManager.executeAction(root.device.id, root.brightnessActionType.id, params)
+                            root.thing.executeAction(root.brightnessActionType.name, params)
                         }
                     }
                 }
@@ -176,7 +176,7 @@ DevicePageBase {
                 MouseArea {
                     anchors.fill: parent
                     onClicked: {
-                        engine.thingManager.executeAction(root.thing.id, root.powerStateType.id, [{paramTypeId: root.powerStateType.id, value: !root.powerState.value}])
+                        root.thing.executeAction("power", [{paramName: "power", value: !root.powerState.value}])
                     }
                 }
             }

nymea-app/ui/utils/ActionQueue.qml

@@ -16,10 +16,9 @@ Item {
             return;
         }
         d.pendingValue = value;
-        d.pendingCommand = engine.thingManager.executeAction(root.thing.id,
+        d.pendingCommand = root.thing.executeAction(root.stateType.name,
-                                          root.stateType.id,
                                           [{
-                                               paramTypeId: root.stateType.id,
+                                               paramName: root.stateType.name,
                                                value: value
                                            }])
         d.queuedValue = null
@@ -33,7 +32,7 @@ Item {
     }
 
     Connections {
-        target: engine.thingManager
+        target: root.thing
         onExecuteActionReply: {
             if (d.pendingCommand == commandId) {
                 d.pendingCommand = -1;