From 2ede8849595e75fc3fb6a2169fee2cb1e6d4aee6 Mon Sep 17 00:00:00 2001
From: Jeppe Bundgaard <jb@truckwash.dk>
Date: Thu, 19 Feb 2026 11:39:36 +0100
Subject: [PATCH] Add force enable/disable machine functionality for department
 lanes

- Introduced endpoints to handle force enable/disable machine actions (`/modules/self-serve/lane/force/machine/enable`, `/disable`).
- Updated OpenAPI spec to document the new endpoints.
- Extended `DepartmentLane.vue` and `departmentLanesTable.vue` with buttons for force enable/disable, including loading states and toast notifications.
- Added corresponding i18n translations for force control actions.
- Created E2E tests to verify translation keys, non-empty values, and source file functionality in `department-lane-force-machine.spec.js`.
---
 openapi.yaml                                  | 106 +++++++++++++
 .../superuser/tables/departmentLanesTable.vue |  61 ++++++++
 .../SessionUser/Objects/DepartmentLanes.vue   |  20 +++
 src/i18n/locales/da.json                      |   7 +-
 .../department/lanes/DepartmentLane.vue       |  43 ++++++
 .../department-lane-force-machine.spec.js     | 144 ++++++++++++++++++
 6 files changed, 380 insertions(+), 1 deletion(-)
 create mode 100644 test/specs/department-lane-force-machine.spec.js

diff --git a/openapi.yaml b/openapi.yaml
index a365da7e..504cfe3f 100644
--- a/openapi.yaml
+++ b/openapi.yaml
@@ -5257,6 +5257,112 @@ paths:
               schema:
                 $ref: '#/components/schemas/Error'
 
+  /modules/self-serve/lane/force/machine/enable:
+    post:
+      tags:
+        - Modules
+      summary: Force enable MACHINE relay and mark lane as in-wash (superusers only)
+      description: |
+        Superuser/emergency endpoint. Bypasses the allowed services gating and directly turns on the MACHINE relay.
+        Also ensures the lane is marked as OCCUPIED and IN_WASH with a wash start timestamp if not already set.
+      operationId: forceEnableSelfServeLaneMachine
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - lane_id
+              properties:
+                lane_id:
+                  type: integer
+                duration:
+                  type: integer
+                  nullable: true
+                  description: Optional number of seconds after which the relay should automatically turn off
+                license_plate:
+                  type: string
+                  nullable: true
+                  description: Optional license plate to associate with the lane
+      responses:
+        '200':
+          description: MACHINE relay force-enabled and lane marked in-wash
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  lane_id:
+                    type: integer
+                  forced:
+                    type: boolean
+                  machine:
+                    type: string
+                    enum: [ENABLED]
+                  duration:
+                    type: integer
+                    nullable: true
+                  status:
+                    type: string
+                  state:
+                    type: string
+                  wash_start_time:
+                    type: integer
+        '401':
+          $ref: '#/components/responses/Unauthorized'
+        '403':
+          $ref: '#/components/responses/Forbidden'
+
+  /modules/self-serve/lane/force/machine/disable:
+    post:
+      tags:
+        - Modules
+      summary: Force disable MACHINE relay but keep lane as in-wash (superusers only)
+      description: |
+        Superuser/emergency endpoint. Turns off the MACHINE relay while ensuring the lane remains in an IN_WASH state
+        (simulating a started wash without machine assistance).
+      operationId: forceDisableSelfServeLaneMachine
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              required:
+                - lane_id
+              properties:
+                lane_id:
+                  type: integer
+                license_plate:
+                  type: string
+                  nullable: true
+      responses:
+        '200':
+          description: MACHINE relay force-disabled and lane ensured in-wash
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  lane_id:
+                    type: integer
+                  forced:
+                    type: boolean
+                  machine:
+                    type: string
+                    enum: [DISABLED]
+                  status:
+                    type: string
+                  state:
+                    type: string
+                  wash_start_time:
+                    type: integer
+        '401':
+          $ref: '#/components/responses/Unauthorized'
+        '403':
+          $ref: '#/components/responses/Forbidden'
+
   # Module - Other Integration Endpoints
   /modules/motorapi/lookup:
     get:
diff --git a/src/components/displays/superuser/tables/departmentLanesTable.vue b/src/components/displays/superuser/tables/departmentLanesTable.vue
index 5948158f..03c5f5f2 100644
--- a/src/components/displays/superuser/tables/departmentLanesTable.vue
+++ b/src/components/displays/superuser/tables/departmentLanesTable.vue
@@ -1,7 +1,10 @@
 <script setup>
 import { useI18n } from 'vue-i18n';
+import { useToast } from 'vue-toast-notification';
+import { ref } from 'vue';
 
 const { t } = useI18n();
+const toast = useToast();
 
 import ActionSettingsWheelButton from "@/components/displays/buttons/ActionSettingsWheelButton.vue";
 import { usePaginatedListInstance } from "@/components/pagination/paginatedList.vue";
@@ -10,6 +13,36 @@ import EditableTableColumn from "@/components/displays/buttons/EditableTableColu
 
 import { SessionUser } from "@/components/session/token/SessionUser.vue";
 
+const forceLoadingLaneId = ref(null);
+
+const forceEnableMachine = async (laneId) => {
+  forceLoadingLaneId.value = laneId;
+  try {
+    await SessionUser.objects.department_lanes.functions.forceEnableMachine(laneId);
+    toast.success(t('superuser.department_lane.force_enable_success'));
+    await loadList();
+  } catch (error) {
+    console.error("Failed to force enable machine:", error);
+    toast.error(t('superuser.department_lane.force_error'));
+  } finally {
+    forceLoadingLaneId.value = null;
+  }
+};
+
+const forceDisableMachine = async (laneId) => {
+  forceLoadingLaneId.value = laneId;
+  try {
+    await SessionUser.objects.department_lanes.functions.forceDisableMachine(laneId);
+    toast.success(t('superuser.department_lane.force_disable_success'));
+    await loadList();
+  } catch (error) {
+    console.error("Failed to force disable machine:", error);
+    toast.error(t('superuser.department_lane.force_error'));
+  } finally {
+    forceLoadingLaneId.value = null;
+  }
+};
+
 // Define the props
 const props = defineProps({
   objects: {
@@ -110,6 +143,34 @@ const redirect = (path) => {
         <!-- Actions -->
         <td class="has-text-right">
           <div class="columns is-mobile is-vcentered is-gapless is-justify-content-flex-end">
+            <div class="column is-narrow">
+              <!-- Force Enable button -->
+              <button
+                  class="button is-small is-success mr-1"
+                  :class="{ 'is-loading': forceLoadingLaneId === object.id }"
+                  :disabled="forceLoadingLaneId === object.id"
+                  @click="forceEnableMachine(object.id)"
+                  :title="$t('superuser.department_lane.force_enable_machine')"
+              >
+                <span class="icon is-small">
+                  <i class="fas fa-play"></i>
+                </span>
+              </button>
+            </div>
+            <div class="column is-narrow">
+              <!-- Force Disable button -->
+              <button
+                  class="button is-small is-danger mr-1"
+                  :class="{ 'is-loading': forceLoadingLaneId === object.id }"
+                  :disabled="forceLoadingLaneId === object.id"
+                  @click="forceDisableMachine(object.id)"
+                  :title="$t('superuser.department_lane.force_disable_machine')"
+              >
+                <span class="icon is-small">
+                  <i class="fas fa-stop"></i>
+                </span>
+              </button>
+            </div>
             <div class="column is-narrow">
               <!-- Stop button -->
               <button
diff --git a/src/components/session/token/SessionUser/Objects/DepartmentLanes.vue b/src/components/session/token/SessionUser/Objects/DepartmentLanes.vue
index eaef7ad8..3978965a 100644
--- a/src/components/session/token/SessionUser/Objects/DepartmentLanes.vue
+++ b/src/components/session/token/SessionUser/Objects/DepartmentLanes.vue
@@ -205,6 +205,26 @@ const t = (key) => i18n.global.t(key);
                 alert('Der opstod en fejl ved stop af vasken. Prøv igen senere.');
               });
 
+        },
+        /**
+         * Force enable the machine relay for a lane
+         * @param {number} laneId - The ID of the lane
+         * @returns {Promise} - The API response
+         */
+        forceEnableMachine: async (laneId) => {
+          return SessionUser.request('/modules/self-serve/lane/force/machine/enable', 'post', {
+            lane_id: parseInt(laneId)
+          });
+        },
+        /**
+         * Force disable the machine relay for a lane
+         * @param {number} laneId - The ID of the lane
+         * @returns {Promise} - The API response
+         */
+        forceDisableMachine: async (laneId) => {
+          return SessionUser.request('/modules/self-serve/lane/force/machine/disable', 'post', {
+            lane_id: parseInt(laneId)
+          });
         }
       },
       /**
diff --git a/src/i18n/locales/da.json b/src/i18n/locales/da.json
index 74c531d8..a8db831a 100644
--- a/src/i18n/locales/da.json
+++ b/src/i18n/locales/da.json
@@ -2841,7 +2841,12 @@
       "payment_overview": "Betalingsoversigt"
     },
     "department_lane": {
-      "back": "Tilbage"
+      "back": "Tilbage",
+      "force_enable_machine": "Tving aktiver maskine",
+      "force_disable_machine": "Tving deaktiver maskine",
+      "force_enable_success": "Maskine tvunget aktiveret",
+      "force_disable_success": "Maskine tvunget deaktiveret",
+      "force_error": "Fejl ved tvungen handling"
     },
     "form": {
       "locked": "Låst",
diff --git a/src/views/dashboards/superUserDashboard/department/lanes/DepartmentLane.vue b/src/views/dashboards/superUserDashboard/department/lanes/DepartmentLane.vue
index 91f5fca0..58370884 100644
--- a/src/views/dashboards/superUserDashboard/department/lanes/DepartmentLane.vue
+++ b/src/views/dashboards/superUserDashboard/department/lanes/DepartmentLane.vue
@@ -7,13 +7,16 @@ import SuperUserDashboardNavigation from "@/views/dashboards/superUserDashboard/
 import PageTitle from "@/components/global/PageTitle.vue";
 import ModulesPagination from "@/components/displays/pagination/models/SuperUser/ModulesPagination.vue";
 import { useI18n } from 'vue-i18n';
+import { useToast } from 'vue-toast-notification';
 
 const { t } = useI18n();
+const toast = useToast();
 const router = useRouter();
 const laneId = router.currentRoute.value.params.id;
 const lane = ref(null);
 const isLoading = ref(true);
 const departmentName = ref('');
+const isForceLoading = ref(false);
 
 const loadLane = async () => {
   isLoading.value = true;
@@ -29,6 +32,34 @@ const loadLane = async () => {
   }
 };
 
+const forceEnableMachine = async () => {
+  isForceLoading.value = true;
+  try {
+    await SessionUser.objects.department_lanes.functions.forceEnableMachine(laneId);
+    toast.success(t('superuser.department_lane.force_enable_success'));
+    await loadLane();
+  } catch (error) {
+    console.error("Failed to force enable machine:", error);
+    toast.error(t('superuser.department_lane.force_error'));
+  } finally {
+    isForceLoading.value = false;
+  }
+};
+
+const forceDisableMachine = async () => {
+  isForceLoading.value = true;
+  try {
+    await SessionUser.objects.department_lanes.functions.forceDisableMachine(laneId);
+    toast.success(t('superuser.department_lane.force_disable_success'));
+    await loadLane();
+  } catch (error) {
+    console.error("Failed to force disable machine:", error);
+    toast.error(t('superuser.department_lane.force_error'));
+  } finally {
+    isForceLoading.value = false;
+  }
+};
+
 onMounted(() => {
   loadLane();
 });
@@ -40,6 +71,18 @@ onMounted(() => {
     <div v-if="lane">
       <PageTitle :title="'Vaskebane: ' + lane.name" :subtitle="'ID: ' + lane.id">
         <template #buttons>
+          <button class="button is-success" :class="{ 'is-loading': isForceLoading }" :disabled="isForceLoading" @click="forceEnableMachine">
+            <span class="icon">
+              <i class="fas fa-play"></i>
+            </span>
+            <span>{{ t('superuser.department_lane.force_enable_machine') }}</span>
+          </button>
+          <button class="button is-danger" :class="{ 'is-loading': isForceLoading }" :disabled="isForceLoading" @click="forceDisableMachine">
+            <span class="icon">
+              <i class="fas fa-stop"></i>
+            </span>
+            <span>{{ t('superuser.department_lane.force_disable_machine') }}</span>
+          </button>
           <button class="button is-dark" @click="router.push('/superuser/department/lanes')">
             <span class="icon">
               <i class="fas fa-arrow-left"></i>
diff --git a/test/specs/department-lane-force-machine.spec.js b/test/specs/department-lane-force-machine.spec.js
new file mode 100644
index 00000000..be46e7db
--- /dev/null
+++ b/test/specs/department-lane-force-machine.spec.js
@@ -0,0 +1,144 @@
+/**
+ * Test to verify the force enable/disable machine functionality for department lanes.
+ * Tests i18n translations for the feature.
+ */
+
+describe('Department Lane Force Machine Controls', () => {
+    const translationKeys = [
+        'force_enable_machine',
+        'force_disable_machine',
+        'force_enable_success',
+        'force_disable_success',
+        'force_error'
+    ];
+
+    it('should have all force machine translations defined in Danish', async () => {
+        await browser.url('/');
+        
+        const result = await browser.executeAsync(async (keys, done) => {
+            try {
+                const response = await fetch('/src/i18n/locales/da.json');
+                const data = await response.json();
+                
+                if (!data.superuser || !data.superuser.department_lane) {
+                    done({ success: false, error: 'superuser.department_lane namespace not found' });
+                    return;
+                }
+                
+                const missingKeys = [];
+                for (const key of keys) {
+                    if (!data.superuser.department_lane[key]) {
+                        missingKeys.push(key);
+                    }
+                }
+                
+                if (missingKeys.length > 0) {
+                    done({ success: false, error: 'Missing keys: ' + missingKeys.join(', ') });
+                } else {
+                    done({ success: true, keyCount: Object.keys(data.superuser.department_lane).length });
+                }
+            } catch (e) {
+                done({ success: false, error: e.message });
+            }
+        }, translationKeys);
+        
+        console.log('Danish department_lane result:', JSON.stringify(result));
+        expect(result.success).toBe(true);
+    });
+
+    it('should have translation values that are non-empty strings', async () => {
+        await browser.url('/');
+        
+        const result = await browser.executeAsync(async (keys, done) => {
+            try {
+                const daResponse = await fetch('/src/i18n/locales/da.json');
+                const daData = await daResponse.json();
+                
+                const daDeptLane = daData.superuser?.department_lane || {};
+                
+                // Verify all translation values are non-empty strings
+                const emptyValues = [];
+                for (const key of keys) {
+                    const value = daDeptLane[key];
+                    if (typeof value !== 'string' || value.trim() === '') {
+                        emptyValues.push(key);
+                    }
+                }
+                
+                if (emptyValues.length > 0) {
+                    done({ success: false, error: 'Empty values for keys: ' + emptyValues.join(', ') });
+                    return;
+                }
+                
+                done({ success: true, translatedKeys: keys.length });
+            } catch (e) {
+                done({ success: false, error: e.message });
+            }
+        }, translationKeys);
+        
+        console.log('Translation values result:', JSON.stringify(result));
+        expect(result.success).toBe(true);
+    });
+
+    it('should have DepartmentLanes source file containing forceEnableMachine function', async () => {
+        await browser.url('/');
+        
+        const result = await browser.executeAsync(async (done) => {
+            try {
+                const response = await fetch('/src/components/session/token/SessionUser/Objects/DepartmentLanes.vue');
+                const sourceCode = await response.text();
+                
+                const hasForceEnableMachine = sourceCode.includes('forceEnableMachine');
+                const hasEndpoint = sourceCode.includes('/modules/self-serve/lane/force/machine/enable');
+                
+                if (!hasForceEnableMachine) {
+                    done({ success: false, error: 'forceEnableMachine function not found in source' });
+                    return;
+                }
+                
+                if (!hasEndpoint) {
+                    done({ success: false, error: 'force enable endpoint not found in source' });
+                    return;
+                }
+                
+                done({ success: true });
+            } catch (e) {
+                done({ success: false, error: e.message });
+            }
+        });
+        
+        console.log('forceEnableMachine source check result:', JSON.stringify(result));
+        expect(result.success).toBe(true);
+    });
+
+    it('should have DepartmentLanes source file containing forceDisableMachine function', async () => {
+        await browser.url('/');
+        
+        const result = await browser.executeAsync(async (done) => {
+            try {
+                const response = await fetch('/src/components/session/token/SessionUser/Objects/DepartmentLanes.vue');
+                const sourceCode = await response.text();
+                
+                const hasForceDisableMachine = sourceCode.includes('forceDisableMachine');
+                const hasEndpoint = sourceCode.includes('/modules/self-serve/lane/force/machine/disable');
+                
+                if (!hasForceDisableMachine) {
+                    done({ success: false, error: 'forceDisableMachine function not found in source' });
+                    return;
+                }
+                
+                if (!hasEndpoint) {
+                    done({ success: false, error: 'force disable endpoint not found in source' });
+                    return;
+                }
+                
+                done({ success: true });
+            } catch (e) {
+                done({ success: false, error: e.message });
+            }
+        });
+        
+        console.log('forceDisableMachine source check result:', JSON.stringify(result));
+        expect(result.success).toBe(true);
+    });
+});