Add player control-plane and dashboard updates

2026-08-07 22:35:27 +01:00
parent a4f8a807ff
commit 2bd47fb96a
36 changed files with 5081 additions and 263 deletions
@@ -0,0 +1,470 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+require('../src/common');
+
+const registerScreenCommandRoutes = require('../src/web/routes/admin/client-commands');
+
+function createHandlers() {
+  const handlers = {};
+  const app = {
+    post(path, ...routeHandlers) {
+      handlers[path] = routeHandlers;
+    }
+  };
+
+  return { app, handlers };
+}
+
+test('move client rebinding redirects the live player to the target screen', async () => {
+  const calls = [];
+  const { app, handlers } = createHandlers();
+
+  registerScreenCommandRoutes(app, {
+    pool: {
+      async query(sql, params) {
+        calls.push({ kind: 'query', sql, params });
+
+        if (sql.includes('SELECT slug FROM d_screens ORDER BY slug ASC')) {
+          return [[{ slug: 'source-screen' }, { slug: 'target-screen' }]];
+        }
+        if (sql.includes('SELECT id, name, slug FROM d_screens WHERE slug = ?') && params && params[0] === 'source-screen') {
+          return [[{ id: 12, name: 'Source Screen', slug: 'source-screen' }]];
+        }
+        if (sql.includes('SELECT d.client_name, s.slug AS current_screen_slug')) {
+          return [[{ client_name: 'Lobby Client', current_screen_slug: 'source-screen' }]];
+        }
+        if (sql.includes('SELECT id, name, slug FROM d_screens WHERE slug = ?') && params && params[0] === 'target-screen') {
+          return [[{ id: 27, name: 'Target Screen', slug: 'target-screen' }]];
+        }
+        if (sql.includes('INSERT INTO d_onboarding_devices')) {
+          return [{ affectedRows: 1 }];
+        }
+
+        return [[]];
+      }
+    },
+    common: {},
+    forwardPlayerCommand(slug, payload, connectionId) {
+      calls.push({ kind: 'forwardPlayerCommand', slug, payload, connectionId });
+      return { ok: true };
+    },
+    forwardPlayerCommandToBaseUrl(baseUrl, slug, payload, connectionId) {
+      calls.push({ kind: 'forwardPlayerCommandToBaseUrl', baseUrl, slug, payload, connectionId });
+      return { ok: true };
+    },
+    getScreenConnections: async (slug) => {
+      if (slug === 'source-screen') {
+        return {
+          connections: [
+            {
+              id: 'conn-1',
+              clientId: 'conn-1',
+              deviceId: 'device-123',
+              playerPublicBaseUrl: 'http://remote-player.example'
+            }
+          ]
+        };
+      }
+
+      return { connections: [] };
+    },
+    isClientNameAvailable: async () => true,
+    withClientNameReservation: async (_pool, _name, callback) => callback(),
+    broadcastDashboardState: async () => {
+      calls.push({ kind: 'broadcastDashboardState' });
+    },
+    requirePermission() {
+      return function (_req, _res, next) {
+        next();
+      };
+    }
+  });
+
+  const routeHandlers = handlers['/clients/:slug/commands'];
+  assert.equal(Array.isArray(routeHandlers), true);
+
+  const response = {
+    statusCode: 200,
+    body: null,
+    status(code) {
+      this.statusCode = code;
+      return this;
+    },
+    json(value) {
+      this.body = value;
+      return this;
+    }
+  };
+
+  await routeHandlers[1]({
+    params: { slug: 'source-screen' },
+    body: {
+      command: 'moveclient',
+      deviceId: 'device-123',
+      clientName: 'Lobby Client',
+      targetScreenSlug: 'target-screen',
+      connectionId: 'conn-1',
+      playerBaseUrl: 'http://remote-player.example'
+    },
+    query: {}
+  }, response, () => {});
+
+  assert.equal(response.statusCode, 200);
+  assert.equal(response.body.ok, true);
+  assert.equal(response.body.targetScreenSlug, 'target-screen');
+  assert.equal(response.body.playerUrl, 'http://remote-player.example/screen/target-screen');
+  assert.equal(calls.some((entry) => entry.kind === 'broadcastDashboardState'), true);
+  assert.equal(calls.some((entry) => entry.kind === 'forwardPlayerCommandToBaseUrl' && entry.baseUrl === 'http://remote-player.example' && entry.payload && entry.payload.command === 'redirect'), true);
+});
+
+test('screen control commands can target all screens', async () => {
+  const calls = [];
+  const { app, handlers } = createHandlers();
+
+  registerScreenCommandRoutes(app, {
+    pool: {
+      async query(sql) {
+        calls.push({ kind: 'query', sql });
+
+        if (String(sql || '').includes('SELECT id, name, slug FROM d_screens WHERE slug IS NOT NULL ORDER BY slug ASC')) {
+          return [[
+            { id: 1, name: 'Alpha', slug: 'alpha' },
+            { id: 2, name: 'Beta', slug: 'beta' }
+          ]];
+        }
+
+        return [[]];
+      }
+    },
+    common: {},
+    forwardPlayerCommand(slug, payload) {
+      calls.push({ kind: 'forwardPlayerCommand', slug, payload });
+      return { ok: true };
+    },
+    getScreenConnections: async () => ({ connections: [] }),
+    isClientNameAvailable: async () => true,
+    withClientNameReservation: async (_pool, _name, callback) => callback(),
+    broadcastDashboardState: async () => {
+      calls.push({ kind: 'broadcastDashboardState' });
+    },
+    requirePermission() {
+      return function (_req, _res, next) {
+        next();
+      };
+    }
+  });
+
+  const routeHandlers = handlers['/clients/:slug/commands'];
+  assert.equal(Array.isArray(routeHandlers), true);
+
+  const response = {
+    statusCode: 200,
+    body: null,
+    status(code) {
+      this.statusCode = code;
+      return this;
+    },
+    json(value) {
+      this.body = value;
+      return this;
+    }
+  };
+
+  await routeHandlers[1]({
+    params: { slug: '__all__' },
+    body: {
+      command: 'pause',
+      paused: 'true'
+    },
+    query: {}
+  }, response, () => {});
+
+  assert.equal(response.statusCode, 200);
+  assert.equal(response.body.ok, true);
+  assert.equal(response.body.allScreens, true);
+  assert.equal(response.body.targetScreenCount, 2);
+  assert.deepEqual(calls.filter((entry) => entry.kind === 'forwardPlayerCommand').map((entry) => entry.slug), ['alpha', 'beta']);
+  assert.equal(calls.some((entry) => entry.kind === 'broadcastDashboardState'), true);
+});
+
+test('screen control commands use the live connection player url when available', async () => {
+  const calls = [];
+  const { app, handlers } = createHandlers();
+
+  registerScreenCommandRoutes(app, {
+    pool: {
+      async query(sql, params) {
+        calls.push({ kind: 'query', sql, params });
+
+        if (sql.includes('SELECT id, name, slug FROM d_screens WHERE slug = ?') && params && params[0] === 'source-screen') {
+          return [[{ id: 12, name: 'Source Screen', slug: 'source-screen' }]];
+        }
+
+        return [[]];
+      }
+    },
+    common: {},
+    forwardPlayerCommand(slug, payload, connectionId) {
+      calls.push({ kind: 'forwardPlayerCommand', slug, payload, connectionId });
+      return { ok: true };
+    },
+    forwardPlayerCommandToBaseUrl(baseUrl, slug, payload, connectionId) {
+      calls.push({ kind: 'forwardPlayerCommandToBaseUrl', baseUrl, slug, payload, connectionId });
+      return { ok: true };
+    },
+    getScreenConnections: async (slug) => {
+      if (slug === 'source-screen') {
+        return {
+          connections: [
+            {
+              id: 'conn-1',
+              clientId: 'conn-1',
+              deviceId: 'device-123',
+              playerPublicBaseUrl: 'http://local-player.example'
+            }
+          ]
+        };
+      }
+
+      return { connections: [] };
+    },
+    isClientNameAvailable: async () => true,
+    withClientNameReservation: async (_pool, _name, callback) => callback(),
+    broadcastDashboardState: async () => {
+      calls.push({ kind: 'broadcastDashboardState' });
+    },
+    requirePermission() {
+      return function (_req, _res, next) {
+        next();
+      };
+    }
+  });
+
+  const routeHandlers = handlers['/clients/:slug/commands'];
+  assert.equal(Array.isArray(routeHandlers), true);
+
+  const response = {
+    statusCode: 200,
+    body: null,
+    status(code) {
+      this.statusCode = code;
+      return this;
+    },
+    json(value) {
+      this.body = value;
+      return this;
+    }
+  };
+
+  await routeHandlers[1]({
+    params: { slug: 'source-screen' },
+    body: {
+      command: 'pause',
+      connectionId: 'conn-1'
+    },
+    query: {}
+  }, response, () => {});
+
+  assert.equal(response.statusCode, 200);
+  assert.equal(response.body.ok, true);
+  assert.equal(calls.some((entry) => entry.kind === 'forwardPlayerCommandToBaseUrl' && entry.baseUrl === 'http://local-player.example'), true);
+  assert.equal(calls.some((entry) => entry.kind === 'forwardPlayerCommand'), false);
+});
+
+test('screen control commands fan out to every live player for the selected screen', async () => {
+  const calls = [];
+  const { app, handlers } = createHandlers();
+
+  registerScreenCommandRoutes(app, {
+    pool: {
+      async query(sql, params) {
+        calls.push({ kind: 'query', sql, params });
+
+        if (sql.includes('SELECT id, name, slug FROM d_screens WHERE slug = ?') && params && params[0] === 'source-screen') {
+          return [[{ id: 12, name: 'Source Screen', slug: 'source-screen' }]];
+        }
+
+        return [[]];
+      }
+    },
+    common: {},
+    forwardPlayerCommand(slug, payload, connectionId) {
+      calls.push({ kind: 'forwardPlayerCommand', slug, payload, connectionId });
+      return { ok: true };
+    },
+    forwardPlayerCommandToBaseUrl(baseUrl, slug, payload, connectionId) {
+      calls.push({ kind: 'forwardPlayerCommandToBaseUrl', baseUrl, slug, payload, connectionId });
+      return { ok: true };
+    },
+    getScreenConnections: async (slug) => {
+      if (slug === 'source-screen') {
+        return {
+          connections: [
+            {
+              id: 'conn-1',
+              clientId: 'conn-1',
+              deviceId: 'device-123',
+              playerPublicBaseUrl: 'http://local-player-a.example'
+            },
+            {
+              id: 'conn-2',
+              clientId: 'conn-2',
+              deviceId: 'device-456',
+              playerPublicBaseUrl: 'http://local-player-b.example'
+            }
+          ]
+        };
+      }
+
+      return { connections: [] };
+    },
+    isClientNameAvailable: async () => true,
+    withClientNameReservation: async (_pool, _name, callback) => callback(),
+    broadcastDashboardState: async () => {
+      calls.push({ kind: 'broadcastDashboardState' });
+    },
+    requirePermission() {
+      return function (_req, _res, next) {
+        next();
+      };
+    }
+  });
+
+  const routeHandlers = handlers['/clients/:slug/commands'];
+  assert.equal(Array.isArray(routeHandlers), true);
+
+  const response = {
+    statusCode: 200,
+    body: null,
+    status(code) {
+      this.statusCode = code;
+      return this;
+    },
+    json(value) {
+      this.body = value;
+      return this;
+    }
+  };
+
+  await routeHandlers[1]({
+    params: { slug: 'source-screen' },
+    body: {
+      command: 'pause'
+    },
+    query: {}
+  }, response, () => {});
+
+  assert.equal(response.statusCode, 200);
+  assert.equal(response.body.ok, true);
+  assert.deepEqual(
+    calls.filter((entry) => entry.kind === 'forwardPlayerCommandToBaseUrl').map((entry) => entry.baseUrl),
+    ['http://local-player-a.example', 'http://local-player-b.example']
+  );
+  assert.equal(calls.some((entry) => entry.kind === 'forwardPlayerCommand'), false);
+});
+
+test('all screens commands fan out across the live player for each screen', async () => {
+  const calls = [];
+  const { app, handlers } = createHandlers();
+
+  registerScreenCommandRoutes(app, {
+    pool: {
+      async query(sql) {
+        calls.push({ kind: 'query', sql });
+
+        if (String(sql || '').includes('SELECT id, name, slug FROM d_screens WHERE slug IS NOT NULL ORDER BY slug ASC')) {
+          return [[
+            { id: 1, name: 'Alpha', slug: 'alpha' },
+            { id: 2, name: 'Beta', slug: 'beta' }
+          ]];
+        }
+
+        return [[]];
+      }
+    },
+    common: {},
+    forwardPlayerCommand(slug, payload) {
+      calls.push({ kind: 'forwardPlayerCommand', slug, payload });
+      return { ok: true };
+    },
+    forwardPlayerCommandToBaseUrl(baseUrl, slug, payload) {
+      calls.push({ kind: 'forwardPlayerCommandToBaseUrl', baseUrl, slug, payload });
+      return { ok: true };
+    },
+    getScreenConnections: async (slug) => {
+      if (slug === 'alpha') {
+        return {
+          connections: [
+            {
+              id: 'alpha-1',
+              clientId: 'alpha-1',
+              deviceId: 'alpha-device',
+              playerPublicBaseUrl: 'http://player-a.example'
+            }
+          ]
+        };
+      }
+
+      if (slug === 'beta') {
+        return {
+          connections: [
+            {
+              id: 'beta-1',
+              clientId: 'beta-1',
+              deviceId: 'beta-device',
+              playerPublicBaseUrl: 'http://player-b.example'
+            }
+          ]
+        };
+      }
+
+      return { connections: [] };
+    },
+    isClientNameAvailable: async () => true,
+    withClientNameReservation: async (_pool, _name, callback) => callback(),
+    broadcastDashboardState: async () => {
+      calls.push({ kind: 'broadcastDashboardState' });
+    },
+    requirePermission() {
+      return function (_req, _res, next) {
+        next();
+      };
+    }
+  });
+
+  const routeHandlers = handlers['/clients/:slug/commands'];
+  assert.equal(Array.isArray(routeHandlers), true);
+
+  const response = {
+    statusCode: 200,
+    body: null,
+    status(code) {
+      this.statusCode = code;
+      return this;
+    },
+    json(value) {
+      this.body = value;
+      return this;
+    }
+  };
+
+  await routeHandlers[1]({
+    params: { slug: '__all__' },
+    body: {
+      command: 'pause'
+    },
+    query: {}
+  }, response, () => {});
+
+  assert.equal(response.statusCode, 200);
+  assert.equal(response.body.ok, true);
+  assert.equal(response.body.allScreens, true);
+  assert.equal(response.body.targetScreenCount, 2);
+  assert.equal(calls.some((entry) => entry.kind === 'broadcastDashboardState'), true);
+  assert.deepEqual(
+    calls.filter((entry) => entry.kind === 'forwardPlayerCommandToBaseUrl').map((entry) => entry.baseUrl),
+    ['http://player-a.example', 'http://player-b.example']
+  );
+  assert.equal(calls.some((entry) => entry.kind === 'forwardPlayerCommand'), false);
+});