Add maintenance mode

nicholasdalhaug · nicholasdalhaug · commit 504ddc047e75 · 2025-11-13T14:19:41.000+01:00
diff --git a/backend/api.test/Mocks/IsarServiceMock.cs b/backend/api.test/Mocks/IsarServiceMock.cs
@@ -67,5 +67,15 @@ public async Task ReleaseFromLockdown(string robotIsarUri)
         {
             await Task.Run(() => Thread.Sleep(1));
         }
+
+        public async Task SetMaintenanceMode(string robotIsarUri)
+        {
+            await Task.Run(() => Thread.Sleep(1));
+        }
+
+        public async Task ReleaseMaintenanceMode(string robotIsarUri)
+        {
+            await Task.Run(() => Thread.Sleep(1));
+        }
     }
 }
diff --git a/backend/api/Controllers/MaintenanceModeController.cs b/backend/api/Controllers/MaintenanceModeController.cs
@@ -0,0 +1,91 @@
+using Api.Controllers.Models;
+using Api.Services;
+using Api.Utilities;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Api.Controllers
+{
+    [ApiController]
+    [Route("robots")]
+    public class MaintenanceModeController(
+        ILogger<RobotController> logger,
+        IRobotService robotService,
+        IIsarService isarService
+    ) : ControllerBase
+    {
+        /// <summary>
+        ///     Send the robot to maintenance mode.
+        /// </summary>
+        [HttpPost("set-maintenance-mode/{robotId}")]
+        [Authorize(Roles = Role.User)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status403Forbidden)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [ProducesResponseType(StatusCodes.Status409Conflict)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<ActionResult> SetMaintenanceMode([FromRoute] string robotId)
+        {
+            robotId = Sanitize.SanitizeUserInput(robotId);
+
+            var robot = await robotService.ReadById(robotId, readOnly: true);
+            if (robot is null)
+            {
+                logger.LogWarning("Could not find robot with id {Id}", robotId);
+                return NotFound();
+            }
+
+            try
+            {
+                await isarService.SetMaintenanceMode(robot.IsarUri);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to set maintenance mode for robot {RobotId}", robot.Id);
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+
+            return NoContent();
+        }
+
+        /// <summary>
+        ///     Release the robot from maintenance mode.
+        /// </summary>
+        [HttpPost("release-maintenance-mode/{robotId}")]
+        [Authorize(Roles = Role.User)]
+        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status403Forbidden)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [ProducesResponseType(StatusCodes.Status409Conflict)]
+        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+        public async Task<ActionResult> ReleaseMaintenanceMode([FromRoute] string robotId)
+        {
+            robotId = Sanitize.SanitizeUserInput(robotId);
+
+            var robot = await robotService.ReadById(robotId, readOnly: true);
+            if (robot is null)
+            {
+                logger.LogWarning("Could not find robot with id {Id}", robotId);
+                return NotFound();
+            }
+
+            try
+            {
+                await isarService.ReleaseMaintenanceMode(robot.IsarUri);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(
+                    ex,
+                    "Failed to release maintenance mode for robot {RobotId}",
+                    robot.Id
+                );
+                return StatusCode(StatusCodes.Status500InternalServerError);
+            }
+
+            return NoContent();
+        }
+    }
+}
diff --git a/backend/api/Database/Models/Robot.cs b/backend/api/Database/Models/Robot.cs
@@ -142,6 +142,7 @@ public enum RobotStatus
         Lockdown,
         GoingToLockdown,
         GoingToRecharging,
+        Maintenance,
     }
 
     public enum RobotCapabilitiesEnum
diff --git a/backend/api/Services/IsarService.cs b/backend/api/Services/IsarService.cs
@@ -26,6 +26,10 @@ public interface IIsarService
         public Task SendToLockdown(string robotIsarUri);
 
         public Task ReleaseFromLockdown(string robotIsarUri);
+
+        public Task SetMaintenanceMode(string robotIsarUri);
+
+        public Task ReleaseMaintenanceMode(string robotIsarUri);
     }
 
     public class IsarService(IDownstreamApi isarApi, ILogger<IsarService> logger) : IIsarService
@@ -353,6 +357,68 @@ public async Task ReleaseFromLockdown(string robotIsarUri)
             }
         }
 
+        public async Task SetMaintenanceMode(string robotIsarUri)
+        {
+            HttpResponseMessage? response;
+            try
+            {
+                response = await CallApi(
+                    HttpMethod.Post,
+                    robotIsarUri,
+                    "schedule/maintenance-mode"
+                );
+            }
+            catch (Exception e)
+            {
+                logger.LogError(
+                    "Encountered an exception when making an API call to ISAR: {Message}",
+                    e.Message
+                );
+                throw new IsarCommunicationException(e.Message);
+            }
+
+            if (!response.IsSuccessStatusCode)
+            {
+                (string message, int statusCode) = GetErrorDescriptionForFailedIsarRequest(
+                    response
+                );
+                string errorResponse = await response.Content.ReadAsStringAsync();
+                logger.LogError("{Message}: {ErrorResponse}", message, errorResponse);
+                throw new IsarCommunicationException(message);
+            }
+        }
+
+        public async Task ReleaseMaintenanceMode(string robotIsarUri)
+        {
+            HttpResponseMessage? response;
+            try
+            {
+                response = await CallApi(
+                    HttpMethod.Post,
+                    robotIsarUri,
+                    "schedule/release-maintenance-mode"
+                );
+            }
+            catch (Exception e)
+            {
+                logger.LogError(
+                    "Encountered an exception when making an API call to ISAR: {Message}",
+                    e.Message
+                );
+                throw new IsarCommunicationException(e.Message);
+            }
+
+            if (!response.IsSuccessStatusCode)
+            {
+                (string message, int statusCode) = GetErrorDescriptionForFailedIsarRequest(
+                    response
+                );
+                string errorResponse = await response.Content.ReadAsStringAsync();
+                logger.LogError("{Message}: {ErrorResponse}", message, errorResponse);
+                throw new IsarCommunicationException(message);
+            }
+        }
+
         /// <summary>
         ///     Helper method to call the downstream API
         /// </summary>
diff --git a/frontend/src/api/ApiCaller.tsx b/frontend/src/api/ApiCaller.tsx
@@ -387,6 +387,28 @@ export class BackendAPICaller {
         return result.content
     }
 
+    static async setMaintenanceMode(robotId: string) {
+        const path: string = `robots/set-maintenance-mode/` + robotId
+        const body = {}
+
+        const result = await BackendAPICaller.POST<unknown, unknown>(path, body).catch((e) => {
+            console.error(`Failed to POST /${path}: ` + e)
+            throw e
+        })
+        return result.content
+    }
+
+    static async releaseMaintenanceMode(robotId: string) {
+        const path: string = `robots/release-maintenance-mode/` + robotId
+        const body = {}
+
+        const result = await BackendAPICaller.POST<unknown, unknown>(path, body).catch((e) => {
+            console.error(`Failed to POST /${path}: ` + e)
+            throw e
+        })
+        return result.content
+    }
+
     static async getInspection(isarInspectionId: string): Promise<Blob> {
         const path: string = 'inspection/' + isarInspectionId
 
diff --git a/frontend/src/components/Displays/RobotDisplays/RobotStatusIcon.tsx b/frontend/src/components/Displays/RobotDisplays/RobotStatusIcon.tsx
@@ -85,6 +85,10 @@ export const RobotStatusChip = ({ status, isarConnected, itemSize }: StatusProps
             status = RobotStatus.Busy
             break
         }
+        case RobotStatus.Maintenance: {
+            statusIcon = Icons.Warning
+            break
+        }
 
         default: {
             iconColor = tokens.colors.text.static_icons__default.hex
diff --git a/frontend/src/components/Pages/RobotPage/RobotPage.tsx b/frontend/src/components/Pages/RobotPage/RobotPage.tsx
@@ -29,7 +29,7 @@ const StyledRobotPage = styled(StyledPage)`
     background-color: ${tokens.colors.ui.background__light.hex};
     gap: 5px;
 `
-const StyledTextButton = styled(StyledButton)`
+const FullWidthButton = styled(StyledButton)`
     text-align: left;
     align-self: stretch;
 `
@@ -117,14 +117,14 @@ export const RobotPage = ({ robotId }: { robotId: string }) => {
 
     const stopButton =
         selectedRobot && selectedRobot.status in [RobotStatus.Busy, RobotStatus.Paused] ? (
-            <StyledTextButton variant="contained" onClick={toggleSkipMissionDialog}>
+            <FullWidthButton variant="contained" onClick={toggleSkipMissionDialog}>
                 <Icon
                     name={Icons.StopButton}
                     style={{ color: tokens.colors.interactive.icon_on_interactive_colors.rgba }}
                     size={24}
                 />
                 {TranslateText('Stop')} {selectedRobot.name}
-            </StyledTextButton>
+            </FullWidthButton>
         ) : (
             <></>
         )
@@ -170,6 +170,12 @@ export const RobotPage = ({ robotId }: { robotId: string }) => {
                                     {selectedRobot && selectedRobot.status == RobotStatus.InterventionNeeded && (
                                         <InterventionNeededButton robot={selectedRobot} />
                                     )}
+                                    {selectedRobot && (
+                                        <MaintenanceButton
+                                            robotId={selectedRobot.id}
+                                            robotStatus={selectedRobot.status}
+                                        />
+                                    )}
                                 </StyledLeftContent>
                                 <StatusContent>
                                     <StyledStatusElement>
@@ -250,3 +256,48 @@ export const RobotPage = ({ robotId }: { robotId: string }) => {
         </>
     )
 }
+
+interface MaintenanceButtonProps {
+    robotId: string
+    robotStatus: RobotStatus
+}
+
+const MaintenanceButton = ({ robotId, robotStatus }: MaintenanceButtonProps) => {
+    const { TranslateText } = useLanguageContext()
+    const [isStoppingDueToMaintenance, setIsStoppingDueToMaintenance] = useState(false)
+
+    const onSetMaintenenceMode = () => {
+        setIsStoppingDueToMaintenance(true)
+
+        BackendAPICaller.setMaintenanceMode(robotId)
+            .then(() => {
+                setIsStoppingDueToMaintenance(false)
+            })
+            .catch(() => {
+                console.log(`Unable to set maintenance mode on robot with id ${robotId}. `)
+                setIsStoppingDueToMaintenance(false)
+            })
+    }
+
+    const onReleaseMaintenanceMode = () => {
+        BackendAPICaller.releaseMaintenanceMode(robotId)
+            .then(() => {})
+            .catch(() => {
+                console.log(`Unable to release maintenance mode on robot with id ${robotId}. `)
+            })
+    }
+
+    return (
+        <>
+            {robotStatus == RobotStatus.Maintenance ? (
+                <FullWidthButton onClick={onReleaseMaintenanceMode}>
+                    {TranslateText(`Release maintenance mode`)}
+                </FullWidthButton>
+            ) : (
+                <FullWidthButton color="danger" disabled={isStoppingDueToMaintenance} onClick={onSetMaintenenceMode}>
+                    {TranslateText('Set maintenance mode')}
+                </FullWidthButton>
+            )}
+        </>
+    )
+}
diff --git a/frontend/src/index.tsx b/frontend/src/index.tsx
@@ -14,7 +14,7 @@ await msalInstance.initialize()
 
 // Add event callback to prevent multiple interactions
 msalInstance.addEventCallback((event) => {
-    if (event.eventType === EventType.LOGIN_SUCCESS || event.eventType === EventType.ACQUIRE_TOKEN_SUCCESS) {
+    if (event.eventType === EventType.LOGIN_SUCCESS) {
         console.log('Authentication successful')
     }
 })
diff --git a/frontend/src/language/en.json b/frontend/src/language/en.json
@@ -334,5 +334,8 @@
     "ReturnHomePaused": "Returning home paused",
     "Current Inspection Area": "Current Inspection Area",
     "GoingToRecharging": "Returning to recharge",
-    "GoingToLockdown": "Returning due to lockdown"
+    "GoingToLockdown": "Returning due to lockdown",
+    "Set maintenance mode": "Set maintenance mode",
+    "Maintenance": "Maintenance",
+    "Release maintenance mode": "Release maintenance mode"
 }
diff --git a/frontend/src/language/no.json b/frontend/src/language/no.json
@@ -334,5 +334,8 @@
     "ReturnHomePaused": "Kjøring hjem pauset",
     "Current Inspection Area": "Nåværende inspeksjonsområde",
     "GoingToRecharging": "Returnerer for å lade",
-    "GoingToLockdown": "Returnerer på grunn av lockdown"
+    "GoingToLockdown": "Returnerer på grunn av lockdown",
+    "Set maintenance mode": "Sett vedlikeholdsmodus",
+    "Maintenance": "Vedlikehold",
+    "Release maintenance mode": "Frigjør fra vedlikeholdsmodus"
 }
diff --git a/frontend/src/models/Robot.ts b/frontend/src/models/Robot.ts
@@ -20,6 +20,7 @@ export enum RobotStatus {
     Lockdown = 'Lockdown',
     GoingToLockdown = 'GoingToLockdown',
     GoingToRecharging = 'GoingToRecharging',
+    Maintenance = 'Maintenance',
 }
 
 export interface Robot {

Original file line number	Diff line number	Diff line change
`@@ -67,5 +67,15 @@ public async Task ReleaseFromLockdown(string robotIsarUri)`
`67`	`67`	`{`
`68`	`68`	`await Task.Run(() => Thread.Sleep(1));`
`69`	`69`	`}`
	`70`	`+`
	`71`	`+ public async Task SetMaintenanceMode(string robotIsarUri)`
	`72`	`+ {`
	`73`	`+ await Task.Run(() => Thread.Sleep(1));`
	`74`	`+ }`
	`75`	`+`
	`76`	`+ public async Task ReleaseMaintenanceMode(string robotIsarUri)`
	`77`	`+ {`
	`78`	`+ await Task.Run(() => Thread.Sleep(1));`
	`79`	`+ }`
`70`	`80`	`}`
`71`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -142,6 +142,7 @@ public enum RobotStatus`
`142`	`142`	`Lockdown,`
`143`	`143`	`GoingToLockdown,`
`144`	`144`	`GoingToRecharging,`
	`145`	`+ Maintenance,`
`145`	`146`	`}`
`146`	`147`
`147`	`148`	`public enum RobotCapabilitiesEnum`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ await msalInstance.initialize()`
`14`	`14`
`15`	`15`	`// Add event callback to prevent multiple interactions`
`16`	`16`	`msalInstance.addEventCallback((event) => {`
`17`		`- if (event.eventType === EventType.LOGIN_SUCCESS \|\| event.eventType === EventType.ACQUIRE_TOKEN_SUCCESS) {`
	`17`	`+ if (event.eventType === EventType.LOGIN_SUCCESS) {`
`18`	`18`	`console.log('Authentication successful')`
`19`	`19`	`}`
`20`	`20`	`})`