Add queue kiosk and display devices for Care Queue management.

Register walk-up kiosks and waiting-room display devices under Devices, with public kiosk ticket issue and linked TV boards surfaced in sidebar and Queue shortcuts.

Co-authored-by: Cursor <cursoragent@cursor.com>

app/Http/Controllers/Care/DeviceController.php

@@ -2,11 +2,15 @@
 
 namespace App\Http\Controllers\Care;
 
-use App\Http\Controllers\Controller;
 use App\Http\Controllers\Care\Concerns\ScopesToAccount;
+use App\Http\Controllers\Controller;
 use App\Models\Branch;
+use App\Models\CareDisplayScreen;
+use App\Models\CareServiceQueue;
 use App\Models\Device;
+use App\Services\Care\CarePermissions;
 use App\Services\Care\DeviceService;
+use App\Services\Care\KioskService;
 use App\Services\Care\OrganizationResolver;
 use App\Services\Care\PlanService;
 use Illuminate\Http\RedirectResponse;
@@ -20,6 +24,7 @@ class DeviceController extends Controller
     public function __construct(
         protected DeviceService $devices,
         protected PlanService $plans,
+        protected KioskService $kiosk,
     ) {}
 
     public function index(Request $request): View
@@ -35,14 +40,14 @@ class DeviceController extends Controller
             ->orderBy('name');
 
         $devices = (clone $query)->paginate(25);
+        $all = (clone $query)->get();
 
         $heroStats = [
-            'total' => (clone $query)->count(),
-            'online' => (clone $query)
-                ->where('status', Device::STATUS_ACTIVE)
-                ->where('last_seen_at', '>=', now()->subMinutes(10))
-                ->count(),
-            'agent' => (clone $query)->where('connection_mode', Device::MODE_AGENT)->count(),
+            'total' => $all->count(),
+            'online' => $all->filter(fn (Device $d) => $d->isOnline())->count(),
+            'kiosks' => $all->where('type', 'kiosk')->count(),
+            'displays' => $all->where('type', 'display')->count(),
+            'agent' => $all->where('connection_mode', Device::MODE_AGENT)->count(),
         ];
 
         return view('care.devices.index', [
@@ -51,9 +56,10 @@ class DeviceController extends Controller
             'deviceTypes' => config('care.device_types'),
             'connectionModes' => config('care.device_connection_modes'),
             'heroStats' => $heroStats,
-            'canManage' => app(\App\Services\Care\CarePermissions::class)
+            'canManage' => app(CarePermissions::class)
                 ->can($this->member($request), 'devices.manage'),
             'hasAgentDevices' => $this->plans->hasPaidPlan($organization),
+            'hasQueueDevices' => $this->plans->hasPaidPlan($organization),
         ]);
     }
 
@@ -61,18 +67,29 @@ class DeviceController extends Controller
     {
         $this->authorizeAbility($request, 'devices.manage');
         $organization = $this->organization($request);
+        $owner = $this->ownerRef($request);
+        $paid = $this->plans->hasPaidPlan($organization);
 
         return view('care.devices.create', [
             'organization' => $organization,
             'deviceTypes' => config('care.device_types'),
             'connectionModes' => config('care.device_connection_modes'),
             'branches' => $this->branches($request, $organization->id),
-            'hasAgentDevices' => $this->plans->hasPaidPlan($organization),
+            'queues' => CareServiceQueue::owned($owner)
+                ->where('organization_id', $organization->id)
+                ->where('is_active', true)
+                ->orderBy('name')
+                ->get(),
+            'layouts' => config('care.display_layouts'),
+            'hasAgentDevices' => $paid,
+            'hasQueueDevices' => $paid,
             'agentTypes' => config('care.device_agent_types'),
+            'queueDeviceTypes' => config('care.queue_device_types', []),
             'defaultModes' => collect(config('care.device_types'))
                 ->keys()
                 ->mapWithKeys(fn ($type) => [$type => $this->devices->defaultConnectionMode($type)])
                 ->all(),
+            'prefillType' => $request->query('type'),
         ]);
     }
 
@@ -80,33 +97,77 @@ class DeviceController extends Controller
     {
         $this->authorizeAbility($request, 'devices.manage');
         $organization = $this->organization($request);
+        $owner = $this->ownerRef($request);
 
         $validated = $this->validatedDevice($request, $organization);
 
         if (! $this->devices->canRegisterType($organization, $validated['type'], $this->plans)) {
-            return back()->withInput()->with(
-                'error',
-                'Agent-connected clinical devices require Care Pro or Enterprise. USB barcode/QR scanners work on Free.',
-            );
+            $message = $this->devices->isQueueDeviceType($validated['type'])
+                ? 'Queue kiosks and displays require Care Pro or Enterprise.'
+                : 'Agent-connected clinical devices require Care Pro or Enterprise. USB barcode/QR scanners work on Free.';
+
+            return back()->withInput()->with('error', $message);
         }
 
         $mode = $validated['connection_mode']
             ?? $this->devices->defaultConnectionMode($validated['type']);
 
+        $metadata = [];
+        if ($validated['type'] === 'kiosk') {
+            $allowed = CareServiceQueue::owned($owner)
+                ->where('organization_id', $organization->id)
+                ->pluck('id')
+                ->all();
+            $metadata = $this->kiosk->buildMetadata($validated, $allowed);
+        }
+
+        if ($validated['type'] === 'display') {
+            if (empty($validated['branch_id'])) {
+                return back()->withInput()->with('error', 'Queue displays require a branch.');
+            }
+
+            $queueIds = array_map('intval', $validated['queue_ids'] ?? []);
+            $allowed = CareServiceQueue::owned($owner)
+                ->where('organization_id', $organization->id)
+                ->whereIn('id', $queueIds)
+                ->pluck('id')
+                ->all();
+
+            $screen = CareDisplayScreen::create([
+                'owner_ref' => $owner,
+                'organization_id' => $organization->id,
+                'branch_id' => $validated['branch_id'],
+                'name' => $validated['name'],
+                'layout' => $validated['layout'] ?? 'standard',
+                'service_queue_ids' => array_values($allowed),
+                'is_active' => true,
+            ]);
+
+            $metadata = [
+                'display_screen_id' => $screen->id,
+                'display_screen_uuid' => $screen->uuid,
+                'service_queue_ids' => array_values($allowed),
+            ];
+        }
+
         $device = Device::create([
-            'owner_ref' => $this->ownerRef($request),
+            'owner_ref' => $owner,
             'organization_id' => $organization->id,
             'branch_id' => $validated['branch_id'] ?? null,
             'name' => $validated['name'],
             'type' => $validated['type'],
             'connection_mode' => $mode,
             'status' => Device::STATUS_OFFLINE,
-            'metadata' => [],
+            'metadata' => $metadata,
         ]);
 
         $plainToken = null;
-        if ($mode === Device::MODE_AGENT || in_array($validated['type'], config('care.device_agent_types', []), true)) {
-            $plainToken = $this->devices->issueToken($device);
+        $needsToken = $this->devices->isQueueDeviceType($validated['type'])
+            || $mode === Device::MODE_AGENT
+            || in_array($validated['type'], config('care.device_agent_types', []), true);
+
+        if ($needsToken) {
+            $plainToken = $this->devices->issueToken($device->fresh());
         }
 
         $redirect = redirect()->route('care.devices.edit', $device)
@@ -123,18 +184,49 @@ class DeviceController extends Controller
     {
         $this->authorizeAbility($request, 'devices.manage');
         $this->authorizeDevice($request, $device);
+        $organization = $this->organization($request);
+        $owner = $this->ownerRef($request);
+
+        $displayScreen = null;
+        $displayPublicUrl = null;
+        if ($device->type === 'display' && ! empty($device->metadata['display_screen_id'])) {
+            $displayScreen = CareDisplayScreen::query()->find($device->metadata['display_screen_id']);
+            if ($displayScreen) {
+                $displayPublicUrl = route('care.display.public', $displayScreen->access_token);
+            }
+        }
+
+        $kioskUrl = null;
+        if ($device->type === 'kiosk') {
+            $token = $this->devices->publicAccessToken($device) ?? session('device_token');
+            if ($token) {
+                $kioskUrl = route('care.kiosk.device', $token);
+            }
+        }
 
         return view('care.devices.edit', [
             'device' => $device,
-            'organization' => $this->organization($request),
+            'organization' => $organization,
             'deviceTypes' => config('care.device_types'),
             'connectionModes' => config('care.device_connection_modes'),
             'deviceStatuses' => config('care.device_statuses'),
             'branches' => $this->branches($request, $device->organization_id),
-            'hasAgentDevices' => $this->plans->hasPaidPlan($this->organization($request)),
+            'queues' => CareServiceQueue::owned($owner)
+                ->where('organization_id', $organization->id)
+                ->where('is_active', true)
+                ->orderBy('name')
+                ->get(),
+            'layouts' => config('care.display_layouts'),
+            'hasAgentDevices' => $this->plans->hasPaidPlan($organization),
+            'hasQueueDevices' => $this->plans->hasPaidPlan($organization),
             'agentTypes' => config('care.device_agent_types'),
+            'queueDeviceTypes' => config('care.queue_device_types', []),
             'connectionHint' => $this->devices->connectionHint($device->type, $device->connection_mode),
             'plainToken' => session('device_token'),
+            'kioskUrl' => $kioskUrl,
+            'displayScreen' => $displayScreen,
+            'displayPublicUrl' => $displayPublicUrl,
+            'kioskSettings' => $device->type === 'kiosk' ? $this->kiosk->settings($device) : null,
         ]);
     }
 
@@ -143,6 +235,7 @@ class DeviceController extends Controller
         $this->authorizeAbility($request, 'devices.manage');
         $this->authorizeDevice($request, $device);
         $organization = $this->organization($request);
+        $owner = $this->ownerRef($request);
 
         $validated = $this->validatedDevice($request, $organization, updating: true);
 
@@ -153,10 +246,44 @@ class DeviceController extends Controller
         ) {
             return back()->withInput()->with(
                 'error',
-                'Agent-connected clinical devices require Care Pro or Enterprise.',
+                'That device type requires Care Pro or Enterprise.',
             );
         }
 
+        $metadata = $device->metadata ?? [];
+        if (($validated['type'] ?? $device->type) === 'kiosk') {
+            $allowed = CareServiceQueue::owned($owner)
+                ->where('organization_id', $organization->id)
+                ->pluck('id')
+                ->all();
+            $metadata = array_merge(
+                $metadata,
+                $this->kiosk->buildMetadata($validated, $allowed),
+            );
+            if ($access = $this->devices->publicAccessToken($device)) {
+                $metadata['access_token'] = $access;
+            }
+        }
+
+        if (($validated['type'] ?? $device->type) === 'display') {
+            $queueIds = array_map('intval', $validated['queue_ids'] ?? ($metadata['service_queue_ids'] ?? []));
+            $allowed = CareServiceQueue::owned($owner)
+                ->where('organization_id', $organization->id)
+                ->whereIn('id', $queueIds)
+                ->pluck('id')
+                ->all();
+            $metadata['service_queue_ids'] = array_values($allowed);
+
+            if (! empty($metadata['display_screen_id'])) {
+                CareDisplayScreen::query()->where('id', $metadata['display_screen_id'])->update([
+                    'name' => $validated['name'],
+                    'branch_id' => $validated['branch_id'] ?? null,
+                    'layout' => $validated['layout'] ?? 'standard',
+                    'service_queue_ids' => array_values($allowed),
+                ]);
+            }
+        }
+
         $device->update([
             'name' => $validated['name'],
             'type' => $validated['type'],
@@ -165,6 +292,7 @@ class DeviceController extends Controller
                 ?? $device->connection_mode
                 ?? $this->devices->defaultConnectionMode($validated['type']),
             'status' => $validated['status'] ?? $device->status,
+            'metadata' => $metadata,
         ]);
 
         return redirect()->route('care.devices.index')->with('success', 'Device updated.');
@@ -221,6 +349,13 @@ class DeviceController extends Controller
             'type' => ['required', 'string', 'in:'.implode(',', array_keys(config('care.device_types')))],
             'branch_id' => ['nullable', 'integer', 'exists:care_branches,id'],
             'connection_mode' => ['nullable', 'string', 'in:'.implode(',', array_keys(config('care.device_connection_modes')))],
+            'queue_ids' => ['nullable', 'array'],
+            'queue_ids.*' => ['integer', 'exists:care_service_queues,id'],
+            'collect_name' => ['nullable', 'boolean'],
+            'collect_phone' => ['nullable', 'boolean'],
+            'reset_seconds' => ['nullable', 'integer', 'min:5', 'max:120'],
+            'welcome_message' => ['nullable', 'string', 'max:255'],
+            'layout' => ['nullable', 'string', 'in:'.implode(',', array_keys(config('care.display_layouts', ['standard' => 'Standard'])))],
         ];
 
         if ($updating) {
@@ -237,6 +372,9 @@ class DeviceController extends Controller
             abort_unless($ok, 422);
         }
 
+        $validated['collect_name'] = $request->boolean('collect_name');
+        $validated['collect_phone'] = $request->boolean('collect_phone');
+
         return $validated;
     }
 

app/Http/Controllers/Care/KioskDeviceController.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Http\Controllers\Care;
+
+use App\Http\Controllers\Controller;
+use App\Models\CareServiceQueue;
+use App\Services\Care\CareQueueEngine;
+use App\Services\Care\DeviceService;
+use App\Services\Care\KioskService;
+use App\Support\OrganizationBranding;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\View\View;
+
+class KioskDeviceController extends Controller
+{
+    public function __construct(
+        protected CareQueueEngine $engine,
+        protected DeviceService $devices,
+        protected KioskService $kiosk,
+    ) {}
+
+    public function show(Request $request): View
+    {
+        $device = $request->attributes->get('care.device');
+        $device->loadMissing('organization');
+        $queues = $this->kiosk->queuesFor($device);
+        $settings = $this->kiosk->settings($device);
+        $organization = $device->organization;
+        $token = $this->devices->publicAccessToken($device) ?? (string) $request->route('token');
+
+        $this->devices->recordHeartbeat($device);
+
+        return view('care.kiosk.device', [
+            'device' => $device,
+            'organization' => $organization,
+            'queues' => $queues,
+            'settings' => $settings,
+            'kioskToken' => $token,
+            'logoUrl' => $organization
+                ? OrganizationBranding::logoUrl($organization)
+                : asset(OrganizationBranding::DEFAULT_LOGO),
+            'logoAlt' => $organization
+                ? OrganizationBranding::logoAlt($organization)
+                : 'Ladill Care',
+        ]);
+    }
+
+    public function issue(Request $request): JsonResponse
+    {
+        $device = $request->attributes->get('care.device');
+        $this->devices->recordHeartbeat($device);
+
+        $validated = $request->validate([
+            'queue_id' => ['required', 'integer', 'exists:care_service_queues,id'],
+            'customer_name' => ['nullable', 'string', 'max:255'],
+            'customer_phone' => ['nullable', 'string', 'max:50'],
+            'priority' => ['nullable', 'string', 'max:50'],
+        ]);
+
+        abort_unless($this->kiosk->queueAllowedForIssue($device, (int) $validated['queue_id']), 403);
+
+        $queue = CareServiceQueue::query()->findOrFail($validated['queue_id']);
+        abort_unless($queue->is_active, 422, 'This queue is not accepting tickets right now.');
+
+        $ticket = $this->engine->issueTicket($device->organization, [
+            'service_queue_id' => $queue->uuid,
+            'customer_name' => $validated['customer_name'] ?? null,
+            'customer_phone' => $validated['customer_phone'] ?? null,
+            'priority' => $validated['priority'] ?? 'walk_in',
+            'source' => 'kiosk',
+            'metadata' => [
+                'device_id' => $device->id,
+                'device_name' => $device->name,
+            ],
+        ]);
+
+        $ticket['queue'] = [
+            'uuid' => $queue->uuid,
+            'name' => $queue->name,
+            'prefix' => $queue->prefix,
+        ];
+
+        return response()->json(['data' => $ticket]);
+    }
+}

app/Http/Middleware/AuthenticateCareDevice.php

@@ -13,7 +13,7 @@ class AuthenticateCareDevice
         protected DeviceService $devices,
     ) {}
 
-    public function handle(Request $request, Closure $next): Response
+    public function handle(Request $request, Closure $next, ?string $type = null): Response
     {
         $token = $this->extractToken($request);
 
@@ -22,6 +22,10 @@ class AuthenticateCareDevice
         $device = $this->devices->findByToken($token);
         abort_unless($device, 401, 'Invalid device token.');
 
+        if ($type !== null && $type !== '' && $device->type !== $type) {
+            abort(403, 'Device type mismatch.');
+        }
+
         $request->attributes->set('care.device', $device);
 
         return $next($request);
@@ -29,6 +33,11 @@ class AuthenticateCareDevice
 
     protected function extractToken(Request $request): ?string
     {
+        $routeToken = $request->route('token');
+        if (is_string($routeToken) && $routeToken !== '') {
+            return $routeToken;
+        }
+
         $header = $request->header('X-Care-Device-Token');
         if (is_string($header) && $header !== '') {
             return $header;

app/Services/Care/DeviceService.php

@@ -33,14 +33,28 @@ class DeviceService
     public function issueToken(Device $device): string
     {
         $plain = $this->generateToken();
-        $device->update(['device_token_hash' => $this->hashToken($plain)]);
+        $meta = $device->metadata ?? [];
+        if ($this->isQueueDeviceType($device->type)) {
+            $meta['access_token'] = $plain;
+        }
+
+        $device->update([
+            'device_token_hash' => $this->hashToken($plain),
+            'metadata' => $meta,
+        ]);
 
         return $plain;
     }
 
     public function revokeToken(Device $device): Device
     {
-        $device->update(['device_token_hash' => null]);
+        $meta = $device->metadata ?? [];
+        unset($meta['access_token']);
+
+        $device->update([
+            'device_token_hash' => null,
+            'metadata' => $meta,
+        ]);
 
         return $device->fresh();
     }
@@ -66,6 +80,7 @@ class DeviceService
     public function defaultConnectionMode(string $type): string
     {
         return match ($type) {
+            'kiosk', 'display' => Device::MODE_MANUAL,
             'barcode_scanner', 'qr_scanner' => Device::MODE_BROWSER_WEDGE,
             'badge_printer' => Device::MODE_MANUAL,
             'thermometer', 'bp_monitor', 'pulse_ox', 'weight_scale', 'lab_analyzer', 'agent' => Device::MODE_AGENT,
@@ -73,6 +88,11 @@ class DeviceService
         };
     }
 
+    public function isQueueDeviceType(string $type): bool
+    {
+        return in_array($type, config('care.queue_device_types', []), true);
+    }
+
     public function typeRequiresPro(string $type): bool
     {
         return in_array($type, config('care.device_agent_types', []), true);
@@ -80,6 +100,10 @@ class DeviceService
 
     public function canRegisterType(Organization $organization, string $type, PlanService $plans): bool
     {
+        if ($this->isQueueDeviceType($type)) {
+            return $plans->hasPaidPlan($organization);
+        }
+
         if (! $this->typeRequiresPro($type)) {
             return true;
         }
@@ -87,8 +111,23 @@ class DeviceService
         return $plans->hasPaidPlan($organization);
     }
 
+    public function publicAccessToken(Device $device): ?string
+    {
+        $token = $device->metadata['access_token'] ?? null;
+
+        return is_string($token) && $token !== '' ? $token : null;
+    }
+
     public function connectionHint(string $type, string $mode): string
     {
+        if ($type === 'kiosk') {
+            return 'Walk-up ticket kiosk. Open the public kiosk URL on a tablet in kiosk mode.';
+        }
+
+        if ($type === 'display') {
+            return 'Waiting-room / counter display. Opens the linked TV board URL on a screen or tablet.';
+        }
+
         return match ($mode) {
             Device::MODE_BROWSER_WEDGE => 'Works in the browser today as a USB keyboard wedge (scan into the focused field). No local agent required.',
             Device::MODE_AGENT => 'Needs the Care Device Agent on a local machine (serial / BLE / vendor SDK). Browser alone cannot talk to this hardware.',

app/Services/Care/KioskService.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace App\Services\Care;
+
+use App\Models\CareServiceQueue;
+use App\Models\Device;
+use Illuminate\Support\Collection;
+
+class KioskService
+{
+    /**
+     * @return array{service_queue_ids: list<int>, collect_name: bool, collect_phone: bool, reset_seconds: int, welcome_message: ?string}
+     */
+    public function settings(Device $device): array
+    {
+        $config = $device->metadata ?? [];
+
+        return [
+            'service_queue_ids' => array_values(array_filter(array_map(
+                'intval',
+                $config['service_queue_ids'] ?? [],
+            ))),
+            'collect_name' => (bool) ($config['collect_name'] ?? false),
+            'collect_phone' => (bool) ($config['collect_phone'] ?? false),
+            'reset_seconds' => max(5, (int) ($config['reset_seconds'] ?? 15)),
+            'welcome_message' => filled($config['welcome_message'] ?? null)
+                ? (string) $config['welcome_message']
+                : null,
+        ];
+    }
+
+    /**
+     * @return list<int>
+     */
+    public function assignedQueueIds(Device $device): array
+    {
+        return $this->settings($device)['service_queue_ids'];
+    }
+
+    /**
+     * @return Collection<int, CareServiceQueue>
+     */
+    public function queuesFor(Device $device): Collection
+    {
+        $ids = $this->assignedQueueIds($device);
+
+        return CareServiceQueue::query()
+            ->where('organization_id', $device->organization_id)
+            ->where('is_active', true)
+            ->when($device->branch_id, fn ($q) => $q->where('branch_id', $device->branch_id))
+            ->when($ids !== [], fn ($q) => $q->whereIn('id', $ids))
+            ->orderBy('name')
+            ->get();
+    }
+
+    public function queueAllowedForIssue(Device $device, int $queueId): bool
+    {
+        $ids = $this->assignedQueueIds($device);
+
+        return CareServiceQueue::query()
+            ->where('organization_id', $device->organization_id)
+            ->where('id', $queueId)
+            ->where('is_active', true)
+            ->when($device->branch_id, fn ($q) => $q->where('branch_id', $device->branch_id))
+            ->when($ids !== [], fn ($q) => $q->whereIn('id', $ids))
+            ->exists();
+    }
+
+    /**
+     * @param  array<string, mixed>  $input
+     * @return array<string, mixed>
+     */
+    public function buildMetadata(array $input, array $allowedQueueIds = []): array
+    {
+        $queueIds = array_values(array_intersect(
+            array_map('intval', $input['queue_ids'] ?? []),
+            $allowedQueueIds,
+        ));
+
+        return [
+            'service_queue_ids' => $queueIds,
+            'collect_name' => (bool) ($input['collect_name'] ?? false),
+            'collect_phone' => (bool) ($input['collect_phone'] ?? false),
+            'reset_seconds' => max(5, min(120, (int) ($input['reset_seconds'] ?? 15))),
+            'welcome_message' => filled($input['welcome_message'] ?? null)
+                ? (string) $input['welcome_message']
+                : null,
+        ];
+    }
+}