Release v2.4.2

src/web/routes/admin/client-commands.js

@@ -1,12 +1,16 @@
 // Admin client command routes for connected screens.
 
+const { commitDeviceBinding } = require('#src/player/onboarding');
+
 module.exports = function registerScreenCommandRoutes(app, deps) {
   const pool = deps.pool;
+  const common = deps.common;
   const forwardPlayerCommand = deps.forwardPlayerCommand;
   const getScreenConnections = deps.getScreenConnections;
   const isClientNameAvailable = deps.isClientNameAvailable;
   const withClientNameReservation = deps.withClientNameReservation;
   const broadcastDashboardState = deps.broadcastDashboardState;
+  const playerPublicBaseUrl = String(deps.playerPublicBaseUrl || '').trim().replace(/\/$/, '');
   const requirePermission = deps.requirePermission;
 
   app.post('/clients/:slug/commands', requirePermission('clients.allow'), async function (req, res, next) {
@@ -138,6 +142,101 @@ module.exports = function registerScreenCommandRoutes(app, deps) {
         });
       }
 
+      if (command === 'moveclient') {
+        const deviceId = String((req.body && (req.body.deviceId || req.body.clientId)) || req.query.deviceId || req.query.clientId || '').trim();
+        const clientName = String((req.body && req.body.clientName) || req.query.clientName || '').trim();
+        const targetScreenSlug = String((req.body && (req.body.targetScreenSlug || req.body.screenSlug)) || req.query.targetScreenSlug || req.query.screenSlug || '').trim();
+
+        if (!deviceId) {
+          return res.status(400).json({ error: 'Device ID is required' });
+        }
+        if (!targetScreenSlug) {
+          return res.status(400).json({ error: 'Target screen is required' });
+        }
+
+        const [currentRows] = await pool.query(
+          `SELECT d.client_name, s.slug AS current_screen_slug
+           FROM d_onboarding_devices d
+           LEFT JOIN d_screens s ON s.id = d.screen_id
+           WHERE d.device_id = ?
+           LIMIT 1`,
+          [deviceId]
+        );
+        const onboardingRow = currentRows[0] || null;
+        const resolvedClientName = String(clientName || onboardingRow && onboardingRow.client_name || '').trim();
+        const currentScreenSlug = String(onboardingRow && onboardingRow.current_screen_slug || '').trim();
+
+        if (!resolvedClientName) {
+          return res.status(400).json({ error: 'Client name is required' });
+        }
+
+        if (currentScreenSlug && currentScreenSlug === targetScreenSlug) {
+          return res.json({
+            screen: screenRows[0],
+            screenSlug: slug,
+            command: command,
+            connectionId: connectionId || null,
+            deviceId: deviceId,
+            clientName: resolvedClientName,
+            targetScreenSlug: targetScreenSlug,
+            ok: true,
+            unchanged: true
+          });
+        }
+
+        if (typeof commitDeviceBinding !== 'function') {
+          return res.status(500).json({ error: 'Client binding is unavailable.' });
+        }
+
+        let liveConnections = [];
+        try {
+          const [screenSlugs] = await pool.query('SELECT slug FROM d_screens ORDER BY slug ASC');
+          const liveResults = await Promise.all((screenSlugs || []).map(async function (row) {
+            const screenSlug = String(row && row.slug ? row.slug : '').trim();
+            if (!screenSlug || typeof getScreenConnections !== 'function') {
+              return [];
+            }
+            try {
+              const liveResponse = await getScreenConnections(screenSlug);
+              return Array.isArray(liveResponse && liveResponse.connections) ? liveResponse.connections : [];
+            } catch (_error) {
+              return [];
+            }
+          }));
+          liveConnections = liveResults.flat();
+        } catch (_error) {
+          liveConnections = [];
+        }
+
+        const status = await commitDeviceBinding(pool, deviceId, resolvedClientName, targetScreenSlug, isClientNameAvailable, liveConnections);
+        const targetPlayerRecord = typeof common.fetchScreenPlayerRecord === 'function'
+          ? await common.fetchScreenPlayerRecord(pool, targetScreenSlug)
+          : null;
+        const targetBaseUrl = String(targetPlayerRecord && targetPlayerRecord.public_base_url || playerPublicBaseUrl || '').trim().replace(/\/$/, '');
+        const targetPlayerUrl = targetBaseUrl ? `${targetBaseUrl}/screen/${encodeURIComponent(targetScreenSlug)}` : `/screen/${encodeURIComponent(targetScreenSlug)}`;
+
+        await forwardPlayerCommand(slug, {
+          command: 'redirect',
+          url: targetPlayerUrl
+        }, connectionId || deviceId || undefined);
+
+        if (typeof broadcastDashboardState === 'function') {
+          await broadcastDashboardState();
+        }
+
+        return res.json({
+          screen: screenRows[0],
+          screenSlug: slug,
+          command: command,
+          connectionId: connectionId || null,
+          deviceId: deviceId,
+          clientName: status ? status.client_name : resolvedClientName,
+          targetScreenSlug: targetScreenSlug,
+          playerUrl: targetPlayerUrl,
+          ok: true
+        });
+      }
+
       const commandPayload = req.body && typeof req.body === 'object' && !Array.isArray(req.body)
         ? Object.assign({}, req.body, { command: command })
         : { command: command };