Introduce inspection area polygon

backend/api.test/Controllers/InspectionAreaControllerTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
 using System.Net.Http;
 using System.Net.Http.Json;
 using System.Text.Json;
@@ -152,5 +153,118 @@ public async Task CheckThatMissionDefinitionIsCreatedInInspectionAreaWhenSchedul
                 )
             );
         }
+
+        [Fact]
+        public async Task TestUpdatingInspectionAreaPolygon()
+        {
+            // Arrange
+            var installation = await DatabaseUtilities.NewInstallation();
+            var plant = await DatabaseUtilities.NewPlant(installation.InstallationCode);
+            var inspectionArea = await DatabaseUtilities.NewInspectionArea(
+                installation.InstallationCode,
+                plant.PlantCode
+            );
+
+            var jsonString =
+                @"{
+                    ""zmin"": 0,
+                    ""zmax"": 10,
+                    ""positions"": [
+                        { ""x"": 0, ""y"": 0 },
+                        { ""x"": 0, ""y"": 10 },
+                        { ""x"": 10, ""y"": 10 },
+                        { ""x"": 10, ""y"": 0 }
+                    ]
+                }";
+
+            var content = new StringContent(jsonString, null, "application/json");
+
+            var expecedJsonString = await content.ReadAsStringAsync();
+            expecedJsonString = expecedJsonString.Replace("\n", "").Replace(" ", "");
+
+            // Act
+            var response = await Client.PatchAsync(
+                $"/inspectionAreas/{inspectionArea.Id}/area-polygon",
+                content
+            );
+            var inspectionAreaResponse = await response.Content.ReadFromJsonAsync<InspectionArea>(
+                SerializerOptions
+            );
+
+            // Assert
+            Assert.True(response.IsSuccessStatusCode);
+            Assert.Equal(expecedJsonString, inspectionAreaResponse!.AreaPolygonJson!);
+        }
+
+        [Fact]
+        public async Task ScheduleMissionOutsideInspectionAreaPolygonFails()
+        {
+            // Arrange
+            var installation = await DatabaseUtilities.NewInstallation();
+            var plant = await DatabaseUtilities.NewPlant(installation.InstallationCode);
+            var inspectionArea = await DatabaseUtilities.NewInspectionArea(
+                installation.InstallationCode,
+                plant.PlantCode
+            );
+            var jsonString =
+                @"{
+                    ""zmin"": 0,
+                    ""zmax"": 10,
+                    ""positions"": [
+                        { ""x"": 0, ""y"": 0 },
+                        { ""x"": 0, ""y"": 10 },
+                        { ""x"": 10, ""y"": 10 },
+                        { ""x"": 10, ""y"": 0 }
+                    ]
+                }";
+
+            var content = new StringContent(jsonString, null, "application/json");
+            var response = await Client.PatchAsync(
+                $"/inspectionAreas/{inspectionArea.Id}/area-polygon",
+                content
+            );
+
+            Assert.True(response.IsSuccessStatusCode);
+
+            var robot = await DatabaseUtilities.NewRobot(RobotStatus.Available, installation);
+
+            var inspection = new CustomInspectionQuery
+            {
+                AnalysisType = AnalysisType.CarSeal,
+                InspectionTarget = new Position(),
+                InspectionType = InspectionType.Image,
+            };
+            var tasks = new List<CustomTaskQuery>
+            {
+                new()
+                {
+                    Inspection = inspection,
+                    TagId = "test",
+                    RobotPose = new Pose(11, 11, 11, 0, 0, 0, 1), // Position outside polygon
+                    TaskOrder = 0,
+                },
+            };
+            var missionQuery = new CustomMissionQuery
+            {
+                RobotId = robot.Id,
+                DesiredStartTime = DateTime.UtcNow,
+                InstallationCode = installation.InstallationCode,
+                InspectionAreaName = inspectionArea.Name,
+                Name = "TestMission",
+                Tasks = tasks,
+            };
+
+            var missionContent = new StringContent(
+                JsonSerializer.Serialize(missionQuery),
+                null,
+                "application/json"
+            );
+
+            // Act
+            var missionResponse = await Client.PostAsync("/missions/custom", missionContent);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.BadRequest, missionResponse.StatusCode);
+        }
     }
 }

backend/api.test/Controllers/MissionSchedulingControllerTests.cs

@@ -10,6 +10,7 @@
 using Api.Controllers.Models;
 using Api.Database.Models;
 using Api.Services;
+using Api.Services.Models;
 using Api.Test.Database;
 using Microsoft.Extensions.DependencyInjection;
 using Testcontainers.PostgreSql;
@@ -325,16 +326,42 @@ public async Task CheckThatMissionFailsIfRobotIsNotInSameInspectionAreaAsMission
             var installation = await DatabaseUtilities.NewInstallation();
             var plant = await DatabaseUtilities.NewPlant(installation.InstallationCode);
 
+            var inspectionPolygonOne = new InspectionAreaPolygon
+            {
+                ZMin = 0,
+                ZMax = 10,
+                Positions =
+                [
+                    new XYPosition { X = 0, Y = 0 },
+                    new XYPosition { X = 0, Y = 10 },
+                    new XYPosition { X = 10, Y = 10 },
+                    new XYPosition { X = 10, Y = 0 },
+                ],
+            };
             var inspectionAreaOne = await DatabaseUtilities.NewInspectionArea(
                 installation.InstallationCode,
                 plant.PlantCode,
-                "InspectionAreaOne"
+                "InspectionAreaOne",
+                inspectionPolygonOne
             );
 
+            var inspectionPolygonTwo = new InspectionAreaPolygon
+            {
+                ZMin = 0,
+                ZMax = 10,
+                Positions =
+                [
+                    new XYPosition { X = 11, Y = 11 },
+                    new XYPosition { X = 11, Y = 20 },
+                    new XYPosition { X = 20, Y = 20 },
+                    new XYPosition { X = 20, Y = 11 },
+                ],
+            };
             var inspectionAreaTwo = await DatabaseUtilities.NewInspectionArea(
                 installation.InstallationCode,
                 plant.PlantCode,
-                "InspectionAreaTwo"
+                "InspectionAreaTwo",
+                inspectionPolygonTwo
             );
 
             var robot = await DatabaseUtilities.NewRobot(
@@ -357,7 +384,7 @@ public async Task CheckThatMissionFailsIfRobotIsNotInSameInspectionAreaAsMission
             // Act
             const string CustomMissionsUrl = "/missions/custom";
             var missionResponse = await Client.PostAsync(CustomMissionsUrl, content);
-            Assert.Equal(HttpStatusCode.Conflict, missionResponse.StatusCode);
+            Assert.Equal(HttpStatusCode.BadRequest, missionResponse.StatusCode);
         }
 
         private static CustomMissionQuery CreateDefaultCustomMissionQuery(

backend/api.test/Database/DatabaseUtilities.cs

@@ -4,6 +4,7 @@
 using Api.Database.Context;
 using Api.Database.Models;
 using Api.Services;
+using Api.Services.Models;
 using Api.Test.Mocks;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Logging;
@@ -33,7 +34,11 @@ public class DatabaseUtilities
         public DatabaseUtilities(FlotillaDbContext context)
         {
             _accessRoleService = new AccessRoleService(context, new HttpContextAccessor());
-            _installationService = new InstallationService(context, _accessRoleService);
+            _installationService = new InstallationService(
+                context,
+                _accessRoleService,
+                new Mock<ILogger<InstallationService>>().Object
+            );
             _missionTaskService = new MissionTaskService(
                 context,
                 new Mock<ILogger<MissionTaskService>>().Object
@@ -44,7 +49,8 @@ public DatabaseUtilities(FlotillaDbContext context)
                 _installationService,
                 _plantService,
                 _accessRoleService,
-                new MockSignalRService()
+                new MockSignalRService(),
+                new Mock<ILogger<InspectionAreaService>>().Object
             );
             _areaService = new AreaService(
                 context,
@@ -150,7 +156,8 @@ public async Task<Plant> NewPlant(string installationCode)
         public async Task<InspectionArea> NewInspectionArea(
             string installationCode,
             string plantCode,
-            string inspectionAreaName = ""
+            string inspectionAreaName = "",
+            InspectionAreaPolygon? areaPolygonJson = null
         )
         {
             if (string.IsNullOrEmpty(inspectionAreaName))
@@ -160,6 +167,7 @@ public async Task<InspectionArea> NewInspectionArea(
                 InstallationCode = installationCode,
                 PlantCode = plantCode,
                 Name = inspectionAreaName,
+                AreaPolygonJson = areaPolygonJson,
             };
 
             return await _inspectionAreaService.Create(createInspectionAreaQuery);

backend/api.test/Services/InspectionAreaService.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Api.Controllers.Models;
+using Api.Database.Models;
+using Api.Services;
+using Api.Test.Database;
+using Microsoft.Extensions.DependencyInjection;
+using Testcontainers.PostgreSql;
+using Xunit;
+
+namespace Api.Test.Services
+{
+    public class InspectionAreaServiceTest : IAsyncLifetime
+    {
+        public required DatabaseUtilities DatabaseUtilities;
+        public required PostgreSqlContainer Container;
+        public required IMissionRunService MissionRunService;
+        public required IInspectionAreaService InspectionAreaService;
+
+        public async Task InitializeAsync()
+        {
+            (Container, string connectionString, var connection) =
+                await TestSetupHelpers.ConfigurePostgreSqlDatabase();
+            var factory = TestSetupHelpers.ConfigureWebApplicationFactory(
+                postgreSqlConnectionString: connectionString
+            );
+            var serviceProvider = TestSetupHelpers.ConfigureServiceProvider(factory);
+
+            DatabaseUtilities = new DatabaseUtilities(
+                TestSetupHelpers.ConfigurePostgreSqlContext(connectionString)
+            );
+            MissionRunService = serviceProvider.GetRequiredService<IMissionRunService>();
+            InspectionAreaService = serviceProvider.GetRequiredService<IInspectionAreaService>();
+        }
+
+        public Task DisposeAsync() => Task.CompletedTask;
+
+        [Fact]
+        public async Task TestTasksInsidePolygon()
+        {
+            var installation = await DatabaseUtilities.NewInstallation();
+            var plant = await DatabaseUtilities.NewPlant(installation.InstallationCode);
+            var inspectionArea = await DatabaseUtilities.NewInspectionArea(
+                installation.InstallationCode,
+                plant.PlantCode
+            );
+            inspectionArea.AreaPolygonJson =
+                @"{
+                    ""zmin"": 0,
+                    ""zmax"": 10,
+                    ""positions"": [
+                        { ""x"": 0, ""y"": 0 },
+                        { ""x"": 0, ""y"": 10 },
+                        { ""x"": 10, ""y"": 10 },
+                        { ""x"": 10, ""y"": 0 }
+                    ]
+                }";
+
+            List<MissionTask> missionTasks =
+            [
+                new(new Pose(1, 1, 1, 0, 0, 0, 1), MissionTaskType.Inspection),
+                new(new Pose(2, 2, 2, 0, 0, 0, 1), MissionTaskType.ReturnHome),
+            ];
+
+            var testBool = InspectionAreaService.MissionTasksAreInsideInspectionAreaPolygon(
+                missionTasks,
+                inspectionArea
+            );
+            Assert.True(testBool);
+        }
+
+        [Fact]
+        public async Task TestTasksOutsidePolygon()
+        {
+            var installation = await DatabaseUtilities.NewInstallation();
+            var plant = await DatabaseUtilities.NewPlant(installation.InstallationCode);
+            var inspectionArea = await DatabaseUtilities.NewInspectionArea(
+                installation.InstallationCode,
+                plant.PlantCode
+            );
+            inspectionArea.AreaPolygonJson =
+                @"{
+                    ""zmin"": 0,
+                    ""zmax"": 10,
+                    ""positions"": [
+                        { ""x"": 0, ""y"": 0 },
+                        { ""x"": 0, ""y"": 10 },
+                        { ""x"": 10, ""y"": 10 },
+                        { ""x"": 10, ""y"": 0 }
+                    ]
+                }";
+            List<MissionTask> missionTasks =
+            [
+                new(new Pose(1, 1, 1, 0, 0, 0, 1), MissionTaskType.ReturnHome),
+                new(new Pose(11, 11, 11, 0, 0, 0, 1), MissionTaskType.ReturnHome),
+            ];
+
+            var testBool = InspectionAreaService.MissionTasksAreInsideInspectionAreaPolygon(
+                missionTasks,
+                inspectionArea
+            );
+            Assert.False(testBool);
+        }
+    }
+}