iobroker.acinfinity 0.4.2 → 0.5.2

package/README.md

@@ -37,7 +37,7 @@ The developer accepts no responsibility for any harm or issues arising from the
 ## Setup
 
 1. Enter your AC Infinity email and password
-2. Set the polling interval (minimum 5 seconds)
+2. Set the polling interval (minimum 10 seconds)
 3. Click Save & Close
 
 ## Usage
@@ -58,7 +58,10 @@ After installation, the adapter will create device objects for each of your AC I
 
 ## Changelog
 
-### 0.4.1 (2025-03-28)
+### 0.5.1 (2025-04-08)
+* more bug fixes and improvements
+
+### 0.4.3 (2025-03-28)
 * Bug fixes and improvements
 
 ### 0.3.1 (2025-03-27)

package/io-package.json

@@ -1,9 +1,22 @@
 {
     "common": {
         "name": "acinfinity",
-        "version": "0.4.2",
+        "version": "0.5.2",
         "news": {
-            "0.4.2": {
+            "0.5.2": {
+                "en": "Bug fixes and improvements",
+                "de": "Fehlerbehebungen und Verbesserungen",
+                "ru": "Исправления ошибок и улучшения",
+                "pt": "Correções de bugs e melhorias",
+                "nl": "Bugfixes en verbeteringen",
+                "fr": "Corrections de bugs et améliorations",
+                "it": "Correzioni di bug e miglioramenti",
+                "es": "Correcciones de errores y mejoras",
+                "pl": "Poprawki błędów i ulepszenia",
+                "uk": "Виправлення помилок та вдосконалення",
+                "zh-cn": "错误修复和改进"
+            },
+            "0.4.3": {
                 "en": "Bug fixes and improvements",
                 "de": "Fehlerbehebungen und Verbesserungen",
                 "ru": "Исправления ошибок и улучшения",

package/lib/client.js

@@ -1,5 +1,5 @@
 /**
- * AC Infinity API Client
+ * AC Infinity API Client new
  * Handles all API communication with AC Infinity servers
  */
 

package/lib/constants.js

@@ -17,7 +17,7 @@ const API_ENDPOINTS = {
 
 // Polling intervals
 const DEFAULT_POLLING_INTERVAL = 30; // seconds
-const MINIMUM_POLLING_INTERVAL = 5; // seconds
+const MINIMUM_POLLING_INTERVAL = 10; // seconds
 
 // Controller property keys
 const CONTROLLER_PROPERTY_KEY = {

package/lib/handlers/portModeHandler.js

@@ -205,7 +205,32 @@ class PortModeHandler {
                     break;
                 }
                 
-                // Rest der Methode wie bisher...
+                case 'offSpeed': {
+                    const speedValue = parseInt(value);
+                    if (!isNaN(speedValue) && speedValue >= 0 && speedValue <= 10) {
+                        // Verwende die spezielle Methode für offSpeed
+                        const success = await this.handleOffSpeedChange(deviceId, portId, speedValue);
+                        
+                        // Bestätige den State, wenn erfolgreich
+                        if (success) {
+                            await this.adapter.setStateAsync(`devices.${deviceId}.ports.${portId}.mode.offSpeed`, 
+                                { val: speedValue, ack: true });
+                        }
+                    } else {
+                        this.adapter.log.warn(`Ungültiger offSpeed-Wert: ${value}`);
+                    }
+                    break;
+                }
+                
+                // Verschachtelte Einstellungen verarbeiten
+                default:
+                    if (['timer', 'cycle', 'schedule', 'auto', 'vpd'].includes(settingType) && path.length > 1) {
+                        const category = settingType;
+                        const subPath = path.slice(1); // Alle Elemente nach dem Kategorienamen
+                        await this.handleNestedPortSettingsChange(deviceId, portId, category, subPath, value);
+                    } else {
+                        this.adapter.log.warn(`Unbekannter Port-Modus-Einstellungstyp: ${settingType}`);
+                    }
             }
             
             // Aktualisierung der Daten mit Verzögerung auslösen
@@ -221,84 +246,190 @@ class PortModeHandler {
     }
 
     /**
- * Spezialisierte Methode für den Moduswechsel (besonders für Ein/Aus)
- * @param {string} deviceId - Geräte-ID
- * @param {number} portId - Port-ID
- * @param {string} value - Neuer Moduswert
- * @returns {Promise<boolean>} - True bei Erfolg
- */
-async handleActiveMode(deviceId, portId, value) {
-    // UI sofort aktualisieren, um Flackern zu vermeiden
-    await this.stateManager.updateUIState(`devices.${deviceId}.ports.${portId}.mode.active`, value);
-    
-    const turnOn = (value === "On");
-    this.adapter.log.info(`Setting device ${deviceId}, port ${portId} to ${turnOn ? 'On' : 'Off'}`);
-    
-    try {
-        // Verwende direkt curl für zuverlässige Steuerung
-        // Settings holen für die modeSetid
-        const settings = await this.client.getDeviceModeSettings(deviceId, portId);
-        const modeSetid = settings.modeSetid;
-        const vpdnums = settings.vpdnums || 107;
+     * Spezialisierte Methode für den Moduswechsel (besonders für Ein/Aus)
+     * @param {string} deviceId - Geräte-ID
+     * @param {number} portId - Port-ID
+     * @param {string} value - Neuer Moduswert
+     * @returns {Promise<boolean>} - True bei Erfolg
+     */
+    async handleActiveMode(deviceId, portId, value) {
+        // UI sofort aktualisieren, um Flackern zu vermeiden
+        await this.stateManager.updateUIState(`devices.${deviceId}.ports.${portId}.mode.active`, value);
         
-        // Parameter festlegen
-        const mode = turnOn ? 2 : 1;      // 1=Aus, 2=Ein
+        const turnOn = (value === "On");
+        this.adapter.log.info(`Setting device ${deviceId}, port ${portId} to ${turnOn ? 'On' : 'Off'}`);
         
-        // Wichtig: Hier ist die Änderung - wir holen den aktuellen onSpeed-Wert
-        let speed;
-        if (turnOn) {
-            // Wenn eingeschaltet, dann nutze den gespeicherten onSpeed-Wert (oder Standard 3)
+        try {
+            // Verwende direkt curl für zuverlässige Steuerung
+            // Settings holen für die modeSetid
+            const settings = await this.client.getDeviceModeSettings(deviceId, portId);
+            const modeSetid = settings.modeSetid;
+            const vpdnums = settings.vpdnums || 107;
+            
+            // Parameter festlegen
+            const mode = turnOn ? 2 : 1;      // 1=Aus, 2=Ein
+            
+            // Hole den aktuellen onSpeed-Wert
             const onSpeedState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.onSpeed`);
-            speed = (onSpeedState && typeof onSpeedState.val === 'number' && onSpeedState.val > 0) ? 
+            const onSpeed = (onSpeedState && typeof onSpeedState.val === 'number' && onSpeedState.val > 0) ? 
                 onSpeedState.val : 3; // Fallback auf 3 (mittlere Geschwindigkeit)
-        } else {
-            // Wenn ausgeschaltet, im API-Aufruf "speak" auf 0 setzen, aber nicht den onSpeed-Wert aktualisieren
-            speed = 0;
+            
+            // WICHTIGE ÄNDERUNG: 
+            // Verwende "speak=0" wenn ausgeschaltet, aber behalte den onSpeed-Wert bei
+            const speakValue = turnOn ? onSpeed : 0;
+            const onSpeedValue = onSpeed; // Behalte den onSpeed Wert immer bei
+            
+            this.adapter.log.debug(`Mode change - onSpeed: ${onSpeedValue}, speak: ${speakValue}, Mode: ${mode}, turnOn: ${turnOn}`);
+            
+            // Hole offSpeed Wert
+            const offSpeedState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.offSpeed`);
+            const offSpeedValue = (offSpeedState && typeof offSpeedState.val === 'number') ? 
+                offSpeedState.val : 0;
+            
+            const cmd = `curl -X POST "http://www.acinfinityserver.com/api/dev/addDevMode" -H "User-Agent: ACController/1.8.5 (com.acinfinity.humiture; build:500; iOS 17.0.1) Alamofire/5.7.1" -H "Content-Type: application/x-www-form-urlencoded; charset=utf-8" -H "token: ${this.client.token}" -d "modeSetid=${modeSetid}&devId=${deviceId}&externalPort=${portId}&offSpead=${offSpeedValue}&onSpead=${onSpeedValue}&atType=${mode}&speak=${speakValue}&curMode=${mode}&vpdstatus=0&vpdnums=${vpdnums}"`;
+            
+            this.adapter.log.debug(`Executing curl command: ${cmd}`);
+            
+            return new Promise((resolve, reject) => {
+                require('child_process').exec(cmd, async (error, stdout, stderr) => {
+                    if (error) {
+                        this.adapter.log.error(`Curl command error: ${error.message}`);
+                        reject(error);
+                        return;
+                    }
+                    
+                    try {
+                        const response = JSON.parse(stdout);
+                        if (response && response.code === 200) {
+                            this.adapter.log.info(`Successfully set device ${deviceId}, port ${portId} to ${turnOn ? 'On' : 'Off'}`);
+                            
+                            // State als bestätigt markieren
+                            await this.adapter.setStateAsync(`devices.${deviceId}.ports.${portId}.mode.active`, 
+                                { val: value, ack: true });
+                            
+                            // Hier NICHT den onSpeed-Wert aktualisieren, wenn wir ausschalten
+                            // Wir aktualisieren nur den Gerätestatus
+                            
+                            resolve(true);
+                        } else {
+                            this.adapter.log.error(`API error: ${JSON.stringify(response)}`);
+                            reject(new Error(`API error: ${response.msg || 'Unknown error'}`));
+                        }
+                    } catch (parseError) {
+                        this.adapter.log.error(`Error parsing API response: ${parseError.message}`);
+                        reject(parseError);
+                    }
+                });
+            });
+        } catch (error) {
+            this.adapter.log.error(`Error controlling device ${deviceId}, port ${portId}: ${error.message}`);
+            throw error;
         }
+    }
+    
+    /**
+     * Spezialisierte Methode für die Änderung der Aus-Geschwindigkeit
+     * @param {string} deviceId - Geräte-ID
+     * @param {number} portId - Port-ID
+     * @param {number} value - Neuer Geschwindigkeitswert
+     * @returns {Promise<boolean>} - True bei Erfolg
+     */
+    async handleOffSpeedChange(deviceId, portId, value) {
+        // UI sofort aktualisieren, um Flackern zu vermeiden
+        await this.stateManager.updateUIState(`devices.${deviceId}.ports.${portId}.mode.offSpeed`, parseInt(value));
         
-        this.adapter.log.debug(`Mode change - Speed: ${speed}, Mode: ${mode}, turnOn: ${turnOn}`);
-        
-        const cmd = `curl -X POST "http://www.acinfinityserver.com/api/dev/addDevMode" -H "User-Agent: ACController/1.8.5 (com.acinfinity.humiture; build:500; iOS 17.0.1) Alamofire/5.7.1" -H "Content-Type: application/x-www-form-urlencoded; charset=utf-8" -H "token: ${this.client.token}" -d "modeSetid=${modeSetid}&devId=${deviceId}&externalPort=${portId}&offSpead=0&onSpead=${speed}&atType=${mode}&speak=${speed}&curMode=${mode}&vpdstatus=0&vpdnums=${vpdnums}"`;
-        
-        this.adapter.log.debug(`Executing curl command: ${cmd}`);
-        
-        return new Promise((resolve, reject) => {
-            require('child_process').exec(cmd, async (error, stdout, stderr) => {
-                if (error) {
-                    this.adapter.log.error(`Curl command error: ${error.message}`);
-                    reject(error);
-                    return;
-                }
-                
-                try {
-                    const response = JSON.parse(stdout);
-                    if (response && response.code === 200) {
-                        this.adapter.log.info(`Successfully set device ${deviceId}, port ${portId} to ${turnOn ? 'On' : 'Off'}`);
-                        
-                        // State als bestätigt markieren
-                        await this.adapter.setStateAsync(`devices.${deviceId}.ports.${portId}.mode.active`, 
-                            { val: value, ack: true });
-                        
-                        // Hier NICHT den onSpeed-Wert aktualisieren, wenn wir ausschalten
-                        // Wir aktualisieren nur den Gerätestatus
-                        
-                        resolve(true);
-                    } else {
-                        this.adapter.log.error(`API error: ${JSON.stringify(response)}`);
-                        reject(new Error(`API error: ${response.msg || 'Unknown error'}`));
+        try {
+            // Settings holen für die modeSetid
+            const settings = await this.client.getDeviceModeSettings(deviceId, portId);
+            const modeSetid = settings.modeSetid;
+            const vpdnums = settings.vpdnums || 107;
+            
+            // Hole den aktuellen Modus und onSpeed-Wert
+            const currentModeState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.active`);
+            const currentMode = currentModeState && currentModeState.val ? 
+                MODE_OPTIONS.indexOf(currentModeState.val) + 1 : 1; // Default zu "Off" (1) wenn nicht bekannt
+            
+            const onSpeedState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.onSpeed`);
+            const onSpeed = (onSpeedState && typeof onSpeedState.val === 'number') ? 
+                onSpeedState.val : 3; // Default zu 3 wenn nicht bekannt
+            
+            // Aktuelle Sprechgeschwindigkeit basierend auf Modus
+            const speakValue = currentMode === 2 ? onSpeed : 0;
+            
+            // Neuer offSpeed-Wert vom Benutzer
+            const offSpeedValue = parseInt(value);
+            
+            this.adapter.log.debug(`Changing offSpeed - offSpeed: ${offSpeedValue}, onSpeed: ${onSpeed}, speak: ${speakValue}, Mode: ${currentMode}`);
+            
+            // API-Aufruf mit explizitem offSpead-Parameter
+            const cmd = `curl -X POST "http://www.acinfinityserver.com/api/dev/addDevMode" -H "User-Agent: ACController/1.8.5 (com.acinfinity.humiture; build:500; iOS 17.0.1) Alamofire/5.7.1" -H "Content-Type: application/x-www-form-urlencoded; charset=utf-8" -H "token: ${this.client.token}" -d "modeSetid=${modeSetid}&devId=${deviceId}&externalPort=${portId}&offSpead=${offSpeedValue}&onSpead=${onSpeed}&atType=${currentMode}&speak=${speakValue}&curMode=${currentMode}&vpdstatus=0&vpdnums=${vpdnums}"`;
+            
+            this.adapter.log.debug(`Executing curl command for offSpeed change: ${cmd}`);
+            
+            return new Promise((resolve, reject) => {
+                require('child_process').exec(cmd, async (error, stdout, stderr) => {
+                    if (error) {
+                        this.adapter.log.error(`Curl command error: ${error.message}`);
+                        reject(error);
+                        return;
                     }
-                } catch (parseError) {
-                    this.adapter.log.error(`Error parsing API response: ${parseError.message}`);
-                    reject(parseError);
-                }
+                    
+                    try {
+                        const response = JSON.parse(stdout);
+                        if (response && response.code === 200) {
+                            this.adapter.log.info(`Successfully set offSpeed for device ${deviceId}, port ${portId} to ${offSpeedValue}`);
+                            
+                            // Wichtig: Setze den State als bestätigt mit dem neuen Wert
+                            await this.adapter.setStateAsync(
+                                `devices.${deviceId}.ports.${portId}.mode.offSpeed`, 
+                                { val: offSpeedValue, ack: true }
+                            );
+                            
+                            // Erzeuge offSpeedCache-State, falls er noch nicht existiert
+                            const stateObj = {
+                                type: 'state',
+                                common: {
+                                    name: 'Cached Off Speed',
+                                    type: 'number',
+                                    role: 'level',
+                                    read: true,
+                                    write: false
+                                },
+                                native: {}
+                            };
+                            
+                            try {
+                                await this.adapter.setObjectNotExistsAsync(
+                                    `devices.${deviceId}.ports.${portId}.mode.offSpeedCache`, 
+                                    stateObj
+                                );
+                            } catch (objError) {
+                                this.adapter.log.warn(`Couldn't create offSpeedCache state: ${objError.message}`);
+                            }
+                            
+                            // Verhindere, dass der nächste Update-Zyklus den Wert überschreibt
+                            // Speichere den Wert in den lokalen Cache
+                            await this.adapter.setStateAsync(
+                                `devices.${deviceId}.ports.${portId}.mode.offSpeedCache`, 
+                                { val: offSpeedValue, ack: true }
+                            );
+                            
+                            resolve(true);
+                        } else {
+                            this.adapter.log.error(`API error: ${JSON.stringify(response)}`);
+                            reject(new Error(`API error: ${response.msg || 'Unknown error'}`));
+                        }
+                    } catch (parseError) {
+                        this.adapter.log.error(`Error parsing API response: ${parseError.message}`);
+                        reject(parseError);
+                    }
+                });
             });
-        });
-    } catch (error) {
-        this.adapter.log.error(`Error controlling device ${deviceId}, port ${portId}: ${error.message}`);
-        throw error;
+        } catch (error) {
+            this.adapter.log.error(`Error setting offSpeed for device ${deviceId}, port ${portId}: ${error.message}`);
+            throw error;
+        }
     }
-}
-
 
     /**
      * Verarbeitet Änderungen an verschachtelten Port-Einstellungen

package/lib/updaters/deviceUpdater.js

@@ -67,13 +67,38 @@ class DeviceUpdater {
         await this.stateManager.updateState(`devices.${deviceId}.info.online`, device.online === 1);
         await this.stateManager.updateState(`devices.${deviceId}.info.mac`, device.devMacAddr);
         
-        // Wandle den numerischen Gerätetyp in einen benutzerfreundlichen Namen um
+        // Ermittle die numerische Gerätetypnummer
+        let deviceTypeNum = 0;
         if (typeof device.devType === 'number') {
-            const deviceTypeStr = this.getDeviceModelByType(device.devType);
-            await this.stateManager.updateState(`devices.${deviceId}.info.deviceType`, deviceTypeStr);
-        } else {
-            // Fallback, falls devType nicht als Zahl vorliegt
-            await this.stateManager.updateState(`devices.${deviceId}.info.deviceType`, device.devType);
+            deviceTypeNum = device.devType;
+        } else if (typeof device.devType === 'string') {
+            // Versuche, die Zahl zu extrahieren
+            const match = device.devType.match(/\d+/);
+            if (match) {
+                deviceTypeNum = parseInt(match[0], 10);
+            }
+        }
+        
+        // Verwende zusätzlich den beschreibenden Namen als Text-Beschreibung
+        const deviceTypeStr = this.getDeviceModelByType(deviceTypeNum);
+        
+        // Setze den numerischen Gerätetyp
+        await this.stateManager.updateState(`devices.${deviceId}.info.deviceType`, deviceTypeNum);
+        
+        // Optional: Füge eine zusätzliche Beschreibung hinzu
+        if (deviceTypeStr !== `UIS Controller Typ ${deviceTypeNum}`) {
+            await this.adapter.setObjectNotExistsAsync(`devices.${deviceId}.info.deviceTypeDescription`, {
+                type: 'state',
+                common: {
+                    name: 'Device Type Description',
+                    type: 'string',
+                    role: 'text',
+                    read: true,
+                    write: false
+                },
+                native: {}
+            });
+            await this.stateManager.updateState(`devices.${deviceId}.info.deviceTypeDescription`, deviceTypeStr);
         }
         
         // Prüfen, wo die Firmware- und Hardwaredaten zu finden sind

package/lib/updaters/portUpdater.js

@@ -104,6 +104,23 @@ class PortUpdater {
                 }
             }
         }
+        
+        // WICHTIG: Prüfe, ob es einen gecachten offSpeed-Wert gibt, bevor wir aktualisieren
+        const offSpeedCacheState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.offSpeedCache`);
+        if (offSpeedCacheState && offSpeedCacheState.val !== undefined) {
+            // Wenn ein gecachter Wert existiert, verwende diesen anstelle des API-Werts
+            await this.stateManager.updateState(`devices.${deviceId}.ports.${portId}.mode.offSpeed`, offSpeedCacheState.val);
+            this.adapter.log.debug(`offSpeed aus Cache verwendet: ${offSpeedCacheState.val} anstelle von API-Wert`);
+        } else if (portData.offSpead !== undefined) {
+            // Nur aktualisieren, wenn kein Cache existiert
+            await this.stateManager.updateState(`devices.${deviceId}.ports.${portId}.mode.offSpeed`, portData.offSpead);
+            this.adapter.log.debug(`offSpeed aktualisiert von portData.offSpead: ${portData.offSpead}`);
+        } else if (portData.onSpead !== undefined && typeof portData.onSpead === 'number') {
+            // Wenn der onSpead-Wert existiert, könnte der offSpeed-Wert ebenfalls dort sein
+            const offSpeed = portData.offSpead !== undefined ? portData.offSpead : 0;
+            await this.stateManager.updateState(`devices.${deviceId}.ports.${portId}.mode.offSpeed`, offSpeed);
+            this.adapter.log.debug(`offSpeed aktualisiert auf Basis von onSpead: ${offSpeed}`);
+        }
     }
 
     /**
@@ -122,6 +139,17 @@ class PortUpdater {
         this.adapter.log.debug(`Aktualisiere Port-Einstellungen für ${deviceId}.${portId}: ${JSON.stringify(settings).substring(0, 500)}...`);
         
         try {
+            // Explizit nach offSpead im settings-Objekt suchen und aktualisieren
+            if (settings.offSpead !== undefined) {
+                // Prüfe, ob es einen gecachten Wert gibt
+                const offSpeedCacheState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.offSpeedCache`);
+                if (!offSpeedCacheState || offSpeedCacheState.val === undefined) {
+                    // Nur aktualisieren, wenn kein Cache existiert
+                    await this.stateManager.updateState(`devices.${deviceId}.ports.${portId}.mode.offSpeed`, settings.offSpead);
+                    this.adapter.log.debug(`offSpeed aktualisiert aus Settings: ${settings.offSpead}`);
+                }
+            }
+            
             // Aktualisiere Gerätetyp
             if (typeof settings[PORT_CONTROL_KEY.DEVICE_LOAD_TYPE] === 'number') {
                 const deviceTypeId = settings[PORT_CONTROL_KEY.DEVICE_LOAD_TYPE];
@@ -160,6 +188,27 @@ class PortUpdater {
      * @returns {Promise<void>}
      */
     async updatePortModeSettings(deviceId, portId, settings) {
+        // Überprüfe und aktualisiere offSpead/onSpead direkt aus den Einstellungen
+        if (settings[PORT_CONTROL_KEY.OFF_SPEED] !== undefined) {
+            // Prüfe, ob es einen gecachten Wert gibt
+            const offSpeedCacheState = await this.adapter.getStateAsync(`devices.${deviceId}.ports.${portId}.mode.offSpeedCache`);
+            if (!offSpeedCacheState || offSpeedCacheState.val === undefined) {
+                // Nur aktualisieren, wenn kein Cache existiert
+                await this.stateManager.updateState(
+                    `devices.${deviceId}.ports.${portId}.mode.offSpeed`, 
+                    settings[PORT_CONTROL_KEY.OFF_SPEED]
+                );
+                this.adapter.log.debug(`offSpeed aktualisiert aus PORT_CONTROL_KEY.OFF_SPEED: ${settings[PORT_CONTROL_KEY.OFF_SPEED]}`);
+            }
+        }
+        
+        if (settings[PORT_CONTROL_KEY.ON_SPEED] !== undefined) {
+            await this.stateManager.updateState(
+                `devices.${deviceId}.ports.${portId}.mode.onSpeed`, 
+                settings[PORT_CONTROL_KEY.ON_SPEED]
+            );
+        }
+        
         // Aktualisiere Timer-Einstellungen
         if (typeof settings[PORT_CONTROL_KEY.TIMER_DURATION_TO_ON] === 'number') {
             await this.stateManager.updateState(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.acinfinity",
-  "version": "0.4.2",
+  "version": "0.5.2",
   "description": "Monitor and control AC Infinity devices",
   "author": {
     "name": "laurent Standard",
@@ -54,7 +54,8 @@
   ],
   "scripts": {
     "test": "mocha test/unit --exit",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "build": "npm run lint && npm test"
   },
   "bugs": {
     "url": "https://github.com/raspilaurent/ioBroker.acinfinity/issues"