homey-api 3.0.0-rc.2 → 3.0.0-rc.20

package/lib/HomeyAPI/HomeyAPIV3/ManagerDevices/DeviceCapability.js

@@ -108,7 +108,7 @@ class DeviceCapability extends EventEmitter {
     const capabilityReference = this.device.capabilitiesObj && this.device.capabilitiesObj[this.id];
     if (capabilityReference) {
       capabilityReference.value = value;
-      capabilityReference.lastUpdated = this.__lastChanged.toISOString();
+      capabilityReference.lastUpdated = this.__lastChanged;
     }
 
     this.__listener(value);

package/lib/HomeyAPI/HomeyAPIV3/ManagerDrivers/PairSession.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const Item = require('../Item');
+
+class PairSession extends Item {
+
+}
+
+module.exports = PairSession;

package/lib/HomeyAPI/HomeyAPIV3/ManagerDrivers.js

@@ -2,12 +2,14 @@
 
 const Manager = require('./Manager');
 const Driver = require('./ManagerDrivers/Driver');
+const PairSession = require('./ManagerDrivers/PairSession');
 
 class ManagerDrivers extends Manager {
 
   static CRUD = {
     ...super.CRUD,
     Driver,
+    PairSession,
   }
 
 }

package/lib/HomeyAPI/HomeyAPIV3/ManagerFlow/AdvancedFlow.js

@@ -1,9 +1,128 @@
+/* eslint-disable no-unused-vars */
+
 'use strict';
 
 const Item = require('../Item');
 
 class AdvancedFlow extends Item {
 
+  async isBroken() {
+    const managerFlow = this.homey.flow;
+    if (!managerFlow.isConnected()) {
+      throw new Error('Flow.isBroken requires ManagerFlow to be connected.');
+    }
+
+    const managerFlowToken = this.homey.flowtoken;
+    if (!managerFlowToken.isConnected()) {
+      throw new Error('Flow.isBroken requires ManagerFlowToken to be connected.');
+    }
+
+    // Array of local & global Token IDs.
+    // For example [ 'foo', 'homey:x:y|abc' ]
+    const tokenIds = [];
+
+    const checkToken = async tokenId => {
+      // If this is a global Token, fetch all FlowTokens
+      if (tokenId.includes('|')) {
+        const flowTokens = await managerFlowToken.getFlowTokens(); // Fill the cache
+        for (const flowTokenId of Object.keys(flowTokens)) {
+          tokenIds.push(flowTokenId);
+        }
+
+        tokenId = tokenId.replace('|', ':');
+      }
+
+      if (!tokenIds.includes(tokenId)) {
+        throw new Error(`Missing Token: ${tokenId}`);
+      }
+    };
+
+    const checkTokens = async card => {
+      // Check droptoken
+      if (card.droptoken) {
+        await checkToken(card.droptoken);
+      }
+
+      if (typeof card.args === 'object') {
+        for (const arg of Object.values(card.args)) {
+          if (typeof arg !== 'string') continue;
+          for (const [tokenMatch, tokenId] of arg.matchAll(/\[\[(.*?)\]\]/g)) {
+            await checkToken(tokenId);
+          }
+        }
+      }
+    };
+
+    // Check if FlowCards exist, and add Tokens
+    for (const [cardId, card] of Object.entries(this.cards)) {
+      switch (card.type) {
+        case 'trigger': {
+          try {
+            await managerFlow.getFlowCardTriggers(); // Fill the cache
+            const triggerCard = await this.manager.getFlowCardTrigger({ id: card.id });
+
+            // Add FlowCardTrigger.tokens to internal tokens cache
+            if (Array.isArray(triggerCard.tokens)) {
+              for (const token of Object.values(triggerCard.tokens)) {
+                tokenIds.push(`trigger::${cardId}::${token.id}`);
+              }
+            }
+
+            break;
+          } catch (err) {
+            this.__debug(err);
+            return true;
+          }
+        }
+        case 'condition': {
+          try {
+            await managerFlow.getFlowCardConditions(); // Fill the cache
+            const conditionCard = await this.manager.getFlowCardCondition({ id: card.id });
+
+            // Add Error Token
+            tokenIds.push(`card::${cardId}::error`);
+
+            break;
+          } catch (err) {
+            this.__debug(err);
+            return true;
+          }
+        }
+        case 'action': {
+          try {
+            await managerFlow.getFlowCardActions(); // Fill the cache
+            const actionCard = await this.manager.getFlowCardAction({ id: card.id });
+
+            // Add Error Token
+            tokenIds.push(`card::${cardId}::error`);
+
+            // Add FlowCardAction.tokens to internal tokens cache
+            if (Array.isArray(actionCard.tokens)) {
+              for (const token of Object.values(actionCard.tokens)) {
+                tokenIds.push(`action::${cardId}::${token.id}`);
+              }
+            }
+
+            break;
+          } catch (err) {
+            this.__debug(err);
+            return true;
+          }
+        }
+        default: {
+          // Do nothing
+        }
+      }
+    }
+
+    // Check Tokens
+    for (const card of Object.values(this.cards)) {
+      await checkTokens(card);
+    }
+
+    return false;
+  }
+
 }
 
 module.exports = AdvancedFlow;

package/lib/HomeyAPI/HomeyAPIV3/ManagerFlow/Flow.js

@@ -1,9 +1,112 @@
+/* eslint-disable no-unused-vars */
+
 'use strict';
 
 const Item = require('../Item');
 
 class Flow extends Item {
 
+  /**
+   * Check whether this Flow misses one or more {@link FlowCard} or {@link FlowToken}.
+   * @returns Promise<Boolean>
+   */
+  async isBroken() {
+    const managerFlow = this.homey.flow;
+    if (!managerFlow.isConnected()) {
+      throw new Error('Flow.isBroken requires ManagerFlow to be connected.');
+    }
+
+    const managerFlowToken = this.homey.flowtoken;
+    if (!managerFlowToken.isConnected()) {
+      throw new Error('Flow.isBroken requires ManagerFlowToken to be connected.');
+    }
+
+    // Array of local & global Token IDs.
+    // For example [ 'foo', 'homey:x:y|abc' ]
+    const tokenIds = [];
+
+    const checkToken = async tokenId => {
+      // If this is a global Token, fetch all FlowTokens
+      if (tokenId.includes('|')) {
+        const flowTokens = await managerFlowToken.getFlowTokens(); // Fill the cache
+        for (const flowTokenId of Object.keys(flowTokens)) {
+          tokenIds.push(flowTokenId);
+        }
+
+        tokenId = tokenId.replace('|', ':');
+      }
+
+      if (!tokenIds.includes(tokenId)) {
+        throw new Error(`Missing Token: ${tokenId}`);
+      }
+    };
+
+    const checkTokens = async card => {
+      // Check droptoken
+      if (card.droptoken) {
+        await checkToken(card.droptoken);
+      }
+
+      if (typeof card.args === 'object') {
+        for (const arg of Object.values(card.args)) {
+          if (typeof arg !== 'string') continue;
+          for (const [tokenMatch, tokenId] of arg.matchAll(/\[\[(.*?)\]\]/g)) {
+            await checkToken(tokenId);
+          }
+        }
+      }
+    };
+
+    // Check Trigger
+    if (this.trigger) {
+      try {
+        await managerFlow.getFlowCardTriggers(); // Fill the cache
+        const triggerCard = await this.manager.getFlowCardTrigger({ id: this.trigger.id });
+        await checkTokens(this.trigger);
+
+        // Add FlowCardTrigger.tokens to internal tokens cache
+        if (Array.isArray(triggerCard.tokens)) {
+          for (const tokenId of Object.keys(triggerCard.tokens)) {
+            tokenIds.push(tokenId);
+          }
+        }
+      } catch (err) {
+        this.__debug(err.message);
+        return true;
+      }
+    }
+
+    // Check Conditions
+    if (Array.isArray(this.conditions)) {
+      for (const condition of Object.values(this.conditions)) {
+        try {
+          await managerFlow.getFlowCardConditions(); // Fill the cache
+          const conditionCard = await this.manager.getFlowCardCondition({ id: condition.id });
+          await checkTokens(condition);
+        } catch (err) {
+          this.__debug(err.message);
+          return true;
+        }
+      }
+    }
+
+    // Check Actions
+    if (Array.isArray(this.actions)) {
+      for (const action of Object.values(this.actions)) {
+        try {
+          await managerFlow.getFlowCardActions(); // Fill the cache
+          const actionCard = await this.manager.getFlowCardAction({ id: action.id });
+          await checkTokens(action);
+        } catch (err) {
+          this.__debug(err.message);
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
 }
 
 module.exports = Flow;

package/lib/HomeyAPI/HomeyAPIV3/ManagerFlow/FlowCard.js

@@ -4,6 +4,14 @@ const Item = require('../Item');
 
 class FlowCard extends Item {
 
+  static transformGet(item) {
+    item = super.transformGet(item);
+
+    delete item.ownerName; // Prepare for back-end change
+
+    return item;
+  }
+
 }
 
 module.exports = FlowCard;

package/lib/HomeyAPI/HomeyAPIV3/ManagerFlowToken/FlowToken.js

@@ -4,11 +4,19 @@ const Item = require('../Item');
 
 class FlowToken extends Item {
 
-  // TODO: Remove when back-end has removed these properties.
-  static transform(item) {
-    delete item.uri;
-    delete item.id;
+  static transformGet(item) {
+    item = super.transformGet(item);
+
+    if (item.uri) {
+      item.id = `${item.uri}:${item.id}`;
+      delete item.uri;
+    }
+
+    // TODO: Remove when back-end has removed these properties.
     delete item.uriObj;
+    delete item.ownerName; // Prepare for back-end change
+
+    return item;
   }
 
 }

package/lib/HomeyAPI/HomeyAPIV3/ManagerInsights/Log.js

@@ -4,6 +4,20 @@ const Item = require('../Item');
 
 class Log extends Item {
 
+  async getEntries() {
+    return this.manager.getLogEntries({
+      id: this.id,
+    });
+  }
+
+  static transformGet(item) {
+    item = super.transformGet(item);
+
+    delete item.ownerName; // Prepare for back-end change
+
+    return item;
+  }
+
 }
 
 module.exports = Log;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homey-api",
-  "version": "3.0.0-rc.2",
+  "version": "3.0.0-rc.20",
   "description": "Homey API",
   "main": "index.js",
   "files": [