Add AppSelector trait for TV

functions/commands/appselect.js

@@ -0,0 +1,49 @@
+const DefaultCommand = require('./default.js');
+const TV = require('../devices/tv.js');
+
+class AppSelect extends DefaultCommand {
+  static get type() {
+    return 'action.devices.commands.appSelect';
+  }
+
+  static validateParams(params) {
+    return (
+      ('newApplication' in params && typeof params.newApplication === 'string') ||
+      ('newApplicationName' in params && typeof params.newApplicationName === 'string')
+    );
+  }
+
+  static requiresItem() {
+    return true;
+  }
+
+  static getItemName(item) {
+    const members = TV.getMembers(item);
+    if ('tvApplication' in members) {
+      return members.tvApplication.name;
+    }
+    throw { statusCode: 400 };
+  }
+
+  static convertParamsToValue(params, item) {
+    const applicationMap = TV.getApplicationMap(item);
+    if (params.newApplication && params.newApplication in applicationMap) {
+      return params.newApplication;
+    }
+    const search = params.newApplicationName;
+    for (const key in applicationMap) {
+      if (applicationMap[key].includes(search)) {
+        return key;
+      }
+    }
+    throw { errorCode: 'noAvailableApp' };
+  }
+
+  static getResponseStates(params, item) {
+    return {
+      currentApplication: this.convertParamsToValue(params, item)
+    };
+  }
+}
+
+module.exports = AppSelect;

functions/commands/default.js

@@ -184,7 +184,13 @@ class DefaultCommand {
             ids: [device.id],
             status: 'ERROR',
             errorCode:
-              error.statusCode == 404 ? 'deviceNotFound' : error.statusCode == 400 ? 'notSupported' : 'deviceOffline'
+              typeof error.errorCode === 'string'
+                ? error.errorCode
+                : error.statusCode == 404
+                ? 'deviceNotFound'
+                : error.statusCode == 400
+                ? 'notSupported'
+                : 'deviceOffline'
           });
         });
     });

functions/commands/selectchannel.js

@@ -27,16 +27,17 @@ class SelectChannel extends DefaultCommand {
   }
 
   static convertParamsToValue(params, item) {
-    if (params.channelNumber) {
+    const channelMap = TV.getChannelMap(item);
+    if (params.channelNumber && params.channelNumber in channelMap) {
       return params.channelNumber;
     }
     const search = params.channelName || params.channelCode;
-    const channelMap = TV.getChannelMap(item);
     for (const number in channelMap) {
       if (channelMap[number].includes(search)) {
         return number;
       }
     }
+    throw { errorCode: 'noAvailableChannel' };
   }
 
   static getResponseStates(params, item) {

functions/devices/tv.js

@@ -13,6 +13,7 @@ class TV extends DefaultDevice {
     if ('tvChannel' in members) traits.push('action.devices.traits.Channel');
     if ('tvInput' in members) traits.push('action.devices.traits.InputSelector');
     if ('tvTransport' in members) traits.push('action.devices.traits.TransportControl');
+    if ('tvApplication' in members) traits.push('action.devices.traits.AppSelector');
     return traits;
   }
 
@@ -70,6 +71,21 @@ class TV extends DefaultDevice {
         });
       });
     }
+    if ('tvApplication' in members && 'availableApplications' in config) {
+      attributes.availableApplications = [];
+      config.availableApplications.split(',').forEach((application) => {
+        const [key, synonyms] = application.split('=');
+        attributes.availableApplications.push({
+          key: key,
+          names: [
+            {
+              name_synonym: synonyms.split(':'),
+              lang: config.lang || 'en'
+            }
+          ]
+        });
+      });
+    }
     return attributes;
   }
 
@@ -96,13 +112,15 @@ class TV extends DefaultDevice {
             state.channelName = this.getChannelMap(item)[members[member].state][0];
           } catch {}
           break;
+        case 'tvApplication':
+          state.currentApplication = members[member].state;
       }
     }
     return state;
   }
 
   static getMembers(item) {
-    const supportedMembers = ['tvChannel', 'tvVolume', 'tvInput', 'tvTransport', 'tvPower', 'tvMute'];
+    const supportedMembers = ['tvApplication', 'tvChannel', 'tvVolume', 'tvInput', 'tvTransport', 'tvPower', 'tvMute'];
     const members = Object();
     if (item.members && item.members.length) {
       item.members.forEach((member) => {
@@ -128,6 +146,18 @@ class TV extends DefaultDevice {
     }
     return channelMap;
   }
+
+  static getApplicationMap(item) {
+    const config = this.getConfig(item);
+    const applicationMap = {};
+    if ('availableApplications' in config) {
+      config.availableApplications.split(',').forEach((application) => {
+        const [key, synonyms] = application.split('=');
+        applicationMap[key] = [...synonyms.split(':'), key];
+      });
+    }
+    return applicationMap;
+  }
 }
 
 module.exports = TV;

tests/commands/appselect.test.js

@@ -0,0 +1,70 @@
+const Command = require('../../functions/commands/appselect.js');
+
+describe('appSelect Command', () => {
+  const paramsKey = { newApplication: 'netflix' };
+  const paramsName = { newApplicationName: 'Net Flix' };
+
+  test('validateParams', () => {
+    expect(Command.validateParams({})).toBe(false);
+    expect(Command.validateParams(paramsKey)).toBe(true);
+    expect(Command.validateParams(paramsName)).toBe(true);
+  });
+
+  test('requiresItem', () => {
+    expect(Command.requiresItem()).toBe(true);
+  });
+
+  test('getItemName', () => {
+    expect(() => {
+      Command.getItemName({ name: 'Item' });
+    }).toThrow();
+    const item = {
+      members: [
+        {
+          name: 'ApplicationItem',
+          metadata: {
+            ga: {
+              value: 'tvApplication'
+            }
+          }
+        }
+      ]
+    };
+    expect(Command.getItemName(item)).toBe('ApplicationItem');
+  });
+
+  test('convertParamsToValue', () => {
+    const item = {
+      metadata: {
+        ga: {
+          config: {
+            availableApplications: 'youtube=YouTube:Tube,netflix=Net Flix:Flix'
+          }
+        }
+      }
+    };
+    expect(Command.convertParamsToValue(paramsKey, item)).toBe('netflix');
+    expect(Command.convertParamsToValue(paramsName, item)).toBe('netflix');
+    expect(Command.convertParamsToValue({ newApplicationName: 'Tube' }, item)).toBe('youtube');
+    expect(() => {
+      Command.convertParamsToValue({ newApplication: 'wrong' }, item);
+    }).toThrow();
+    expect(() => {
+      Command.convertParamsToValue({ newApplicationName: 'wrong' }, item);
+    }).toThrow();
+  });
+
+  test('getResponseStates', () => {
+    const item = {
+      metadata: {
+        ga: {
+          config: {
+            availableApplications: 'youtube=YouTube,netflix=Net Flix'
+          }
+        }
+      }
+    };
+    expect(Command.getResponseStates(paramsKey, item)).toStrictEqual({ currentApplication: 'netflix' });
+    expect(Command.getResponseStates(paramsName, item)).toStrictEqual({ currentApplication: 'netflix' });
+  });
+});

tests/commands/default.test.js

@@ -308,5 +308,20 @@ describe('Default Command', () => {
         }
       ]);
     });
+
+    test('execute with errorCode', async () => {
+      sendCommandMock.mockReturnValue(Promise.reject({ errorCode: 'noAvailableChannel' }));
+      const devices = [{ id: 'Item1' }];
+      const result = await TestCommand1.execute(apiHandler, devices, { on: true }, {});
+      expect(getItemMock).toHaveBeenCalledTimes(0);
+      expect(sendCommandMock).toHaveBeenCalledTimes(1);
+      expect(result).toStrictEqual([
+        {
+          errorCode: 'noAvailableChannel',
+          ids: ['Item1'],
+          status: 'ERROR'
+        }
+      ]);
+    });
   });
 });

tests/commands/selectchannel.test.js

@@ -44,6 +44,12 @@ describe('selectChannel Command', () => {
     expect(Command.convertParamsToValue({ channelCode: 'channel1' }, item)).toBe('1');
     expect(Command.convertParamsToValue({ channelName: 'ARD' }, item)).toBe('1');
     expect(Command.convertParamsToValue({ channelNumber: '1' }, item)).toBe('1');
+    expect(() => {
+      Command.convertParamsToValue({ channelNumber: '0' }, item);
+    }).toThrow();
+    expect(() => {
+      Command.convertParamsToValue({ channelName: 'wrong' }, item);
+    }).toThrow();
   });
 
   test('getResponseStates', () => {