Add basic structure for zigbee nodes on jsonrpc api

libnymea-core/jsonrpc/zigbeehandler.cpp

@@ -44,6 +44,8 @@ ZigbeeHandler::ZigbeeHandler(ZigbeeManager *zigbeeManager, QObject *parent) :
     qRegisterMetaType<nymeaserver::ZigbeeAdapter>();
     registerEnum<ZigbeeManager::ZigbeeNetworkState>();
     registerEnum<ZigbeeManager::ZigbeeError>();
+    registerEnum<ZigbeeManager::ZigbeeNodeType>();
+    registerEnum<ZigbeeManager::ZigbeeNodeState>();
     registerObject<ZigbeeAdapter, ZigbeeAdapters>();
 
     // Network object describing a network instance
@@ -64,6 +66,22 @@ ZigbeeHandler::ZigbeeHandler(ZigbeeManager *zigbeeManager, QObject *parent) :
     zigbeeNetworkDescription.insert("networkState", enumRef<ZigbeeManager::ZigbeeNetworkState>());
     registerObject("ZigbeeNetwork", zigbeeNetworkDescription);
 
+    // Zigbee node description
+    QVariantMap zigbeeNodeDescription;
+    zigbeeNodeDescription.insert("networkUuid", enumValueName(Uuid));
+    zigbeeNodeDescription.insert("ieeeAddress", enumValueName(String));
+    zigbeeNodeDescription.insert("networkAddress", enumValueName(Uint));
+    zigbeeNodeDescription.insert("type", enumRef<ZigbeeManager::ZigbeeNodeType>());
+    zigbeeNodeDescription.insert("state", enumRef<ZigbeeManager::ZigbeeNodeState>());
+    zigbeeNodeDescription.insert("manufacturer", enumValueName(String));
+    zigbeeNodeDescription.insert("model", enumValueName(String));
+    zigbeeNodeDescription.insert("version", enumValueName(String));
+    zigbeeNodeDescription.insert("receiverOnWhileIdle", enumValueName(Bool));
+    zigbeeNodeDescription.insert("reachable", enumValueName(Bool));
+    zigbeeNodeDescription.insert("lqi", enumValueName(Uint));
+    zigbeeNodeDescription.insert("lastSeen", enumValueName(Uint));
+    registerObject("ZigbeeNode", zigbeeNodeDescription);
+
     QVariantMap params, returns;
     QString description;
 
@@ -163,6 +181,23 @@ ZigbeeHandler::ZigbeeHandler(ZigbeeManager *zigbeeManager, QObject *parent) :
     returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
     registerMethod("SetPermitJoin", description, params, returns);
 
+    // GetNodes
+    params.clear(); returns.clear();
+    description = "Returns the list of ZigBee nodes from the network the given \'networkUuid\' in the system.";
+    params.insert("networkUuid", enumValueName(Uuid));
+    returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
+    returns.insert("o:zigbeeNodes", QVariantList() << objectRef("ZigbeeNode"));
+    registerMethod("GetNodes", description, params, returns);
+
+    // RemoveNode
+    params.clear(); returns.clear();
+    description = "Remove a ZigBee node with the given \'ieeeAddress\' from the network with the given \'networkUuid\'. "
+                  "If there is a thing configured for this node, also the thing will be removed from the system. "
+                  "The coordinator node cannot be removed.";
+    params.insert("networkUuid", enumValueName(Uuid));
+    params.insert("ieeeAddress", enumValueName(String));
+    returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
+    registerMethod("RemoveNode", description, params, returns);
 
     connect(m_zigbeeManager, &ZigbeeManager::availableAdapterAdded, this, [this](const ZigbeeAdapter &adapter){
         QVariantMap params;
@@ -278,6 +313,53 @@ JsonReply *ZigbeeHandler::SetPermitJoin(const QVariantMap &params)
     return createReply(returnMap);
 }
 
+JsonReply *ZigbeeHandler::GetNodes(const QVariantMap &params)
+{
+    QVariantMap returnMap;
+    QUuid networkUuid = params.value("networkUuid").toUuid();
+    ZigbeeNetwork *network = m_zigbeeManager->zigbeeNetworks().value(networkUuid);
+    if (!network) {
+        returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNetworkUuidNotFound));
+        return createReply(returnMap);
+    }
+
+    QVariantList nodeList;
+    foreach (ZigbeeNode *node, network->nodes()) {
+        nodeList << packNode(node);
+    }
+
+    returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNoError));
+    returnMap.insert("zigbeeNodes", nodeList);
+    return createReply(returnMap);
+}
+
+JsonReply *ZigbeeHandler::RemoveNode(const QVariantMap &params)
+{
+    QVariantMap returnMap;
+    QUuid networkUuid = params.value("networkUuid").toUuid();
+    ZigbeeAddress nodeAddress(params.value("ieeeAddress").toString());
+    ZigbeeNetwork *network = m_zigbeeManager->zigbeeNetworks().value(networkUuid);
+    if (!network) {
+        returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNetworkUuidNotFound));
+        return createReply(returnMap);
+    }
+
+    if (!network->hasNode(nodeAddress)) {
+        returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNodeNotFound));
+        return createReply(returnMap);
+    }
+
+    ZigbeeNode *node = network->getZigbeeNode(nodeAddress);
+    if (node->shortAddress() == 0x0000) {
+        returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorForbidden));
+        return createReply(returnMap);
+    }
+
+    network->removeZigbeeNode(nodeAddress);
+    returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNoError));
+    return createReply(returnMap);
+}
+
 JsonReply *ZigbeeHandler::GetNetworks(const QVariantMap &params)
 {
     Q_UNUSED(params)
@@ -338,4 +420,44 @@ QVariantMap ZigbeeHandler::packNetwork(ZigbeeNetwork *network)
     return networkMap;
 }
 
+QVariantMap ZigbeeHandler::packNode(ZigbeeNode *node)
+{
+    QVariantMap nodeMap;
+    nodeMap.insert("networkUuid", node->networkUuid());
+    nodeMap.insert("ieeeAddress", node->extendedAddress().toString());
+    nodeMap.insert("networkAddress", node->shortAddress());
+    switch (node->nodeDescriptor().nodeType) {
+    case ZigbeeDeviceProfile::NodeTypeCoordinator:
+        nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeCoordinator));
+        break;
+    case ZigbeeDeviceProfile::NodeTypeRouter:
+        nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeRouter));
+        break;
+    default:
+        nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeEndDevice));
+        break;
+    }
+
+    switch (node->state()) {
+    case ZigbeeNode::StateUninitialized:
+        nodeMap.insert("state", enumValueName<ZigbeeManager::ZigbeeNodeState>(ZigbeeManager::ZigbeeNodeStateUninitialized));
+        break;
+    case ZigbeeNode::StateInitializing:
+        nodeMap.insert("state", enumValueName<ZigbeeManager::ZigbeeNodeState>(ZigbeeManager::ZigbeeNodeStateInitializing));
+        break;
+    case ZigbeeNode::StateInitialized:
+        nodeMap.insert("state", enumValueName<ZigbeeManager::ZigbeeNodeState>(ZigbeeManager::ZigbeeNodeStateInitialized));
+        break;
+    }
+
+    nodeMap.insert("manufacturer", node->manufacturerName());
+    nodeMap.insert("model", node->modelName());
+    nodeMap.insert("version", node->version());
+    nodeMap.insert("receiverOnWhileIdle", node->macCapabilities().receiverOnWhenIdle);
+    nodeMap.insert("reachable", node->reachable());
+    nodeMap.insert("lqi", node->lqi());
+    nodeMap.insert("lastSeen", node->lastSeen().toMSecsSinceEpoch() / 1000);
+    return nodeMap;
+}
+
 }

libnymea-core/jsonrpc/zigbeehandler.h

@@ -51,13 +51,18 @@ public:
 
     Q_INVOKABLE JsonReply *GetAvailableBackends(const QVariantMap &params);
     Q_INVOKABLE JsonReply *GetAdapters(const QVariantMap &params);
+
     Q_INVOKABLE JsonReply *GetNetworks(const QVariantMap &params);
     Q_INVOKABLE JsonReply *AddNetwork(const QVariantMap &params);
     Q_INVOKABLE JsonReply *RemoveNetwork(const QVariantMap &params);
     Q_INVOKABLE JsonReply *FactoryResetNetwork(const QVariantMap &params);
     Q_INVOKABLE JsonReply *SetPermitJoin(const QVariantMap &params);
 
+    Q_INVOKABLE JsonReply *GetNodes(const QVariantMap &params);
+    Q_INVOKABLE JsonReply *RemoveNode(const QVariantMap &params);
+
     QVariantMap packNetwork(ZigbeeNetwork *network);
+    QVariantMap packNode(ZigbeeNode *node);
 
 private:
     ZigbeeManager *m_zigbeeManager = nullptr;
@@ -68,7 +73,9 @@ signals:
     void NetworkAdded(const QVariantMap &params);
     void NetworkRemoved(const QVariantMap &params);
     void NetworkChanged(const QVariantMap &params);
-
+    void NodeAdded(const QVariantMap &params);
+    void NodeRemoved(const QVariantMap &params);
+    void NodeChanged(const QVariantMap &params);
 };
 
 }

libnymea-core/zigbee/zigbeemanager.h

@@ -60,10 +60,28 @@ public:
         ZigbeeErrorNetworkUuidNotFound,
         ZigbeeErrorDurationOutOfRange,
         ZigbeeErrorNetworkOffline,
-        ZigbeeErrorUnknownBackend
+        ZigbeeErrorUnknownBackend,
+        ZigbeeErrorNodeNotFound,
+        ZigbeeErrorForbidden
     };
     Q_ENUM(ZigbeeError)
 
+    // Node information
+    enum ZigbeeNodeType {
+        ZigbeeNodeTypeCoordinator,
+        ZigbeeNodeTypeRouter,
+        ZigbeeNodeTypeEndDevice
+    };
+    Q_ENUM(ZigbeeNodeType)
+
+    enum ZigbeeNodeState {
+        ZigbeeNodeStateUninitialized,
+        ZigbeeNodeStateInitializing,
+        ZigbeeNodeStateInitialized,
+        ZigbeeNodeStateHandled
+    };
+    Q_ENUM(ZigbeeNodeState)
+
     explicit ZigbeeManager(QObject *parent = nullptr);
 
     bool available() const;