feat(scenario-pu): allow to reset lock status to default

api/apps/api/src/modules/scenarios/planning-units/scenario-planning-units.service.ts

@@ -1,9 +1,12 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { EntityManager, Repository } from 'typeorm';
 
 import { DbConnections } from '@marxan-api/ormconfig.connections';
-import { ScenariosPlanningUnitGeoEntity } from '@marxan/scenarios-planning-unit';
+import {
+  LockStatus,
+  ScenariosPlanningUnitGeoEntity,
+} from '@marxan/scenarios-planning-unit';
 
 @Injectable()
 export class ScenarioPlanningUnitsService {
@@ -13,6 +16,8 @@ export class ScenarioPlanningUnitsService {
       DbConnections.geoprocessingDB,
     )
     private readonly puRepo: Repository<ScenariosPlanningUnitGeoEntity>,
+    @InjectEntityManager(DbConnections.geoprocessingDB)
+    private readonly entityManager: EntityManager,
   ) {}
 
   async get(scenarioId: string): Promise<ScenariosPlanningUnitGeoEntity[]> {
@@ -22,4 +27,30 @@ export class ScenarioPlanningUnitsService {
       },
     });
   }
+
+  async resetLockStatus(scenarioId: string): Promise<void> {
+    return await this.entityManager.transaction(async (manager) => {
+      await manager.update(
+        ScenariosPlanningUnitGeoEntity,
+        {
+          scenarioId,
+          protectedByDefault: false,
+        },
+        {
+          lockStatus: LockStatus.Unstated,
+        },
+      );
+
+      await manager.update(
+        ScenariosPlanningUnitGeoEntity,
+        {
+          scenarioId,
+          protectedByDefault: true,
+        },
+        {
+          lockStatus: LockStatus.LockedIn,
+        },
+      );
+    });
+  }
 }

api/apps/api/src/modules/scenarios/scenarios.controller.ts

@@ -333,6 +333,15 @@ export class ScenariosController {
     return;
   }
 
+  @Delete(`:id/planning-units`)
+  @ApiOkResponse()
+  async resetPlanningUnitsLockStatus(
+    @Param('id', ParseUUIDPipe) id: string,
+  ): Promise<void> {
+    await this.service.resetLockStatus(id);
+    return;
+  }
+
   @Get(':id/planning-units')
   @ApiOkResponse({ type: ScenarioPlanningUnitDto, isArray: true })
   async getPlanningUnits(

api/apps/api/src/modules/scenarios/scenarios.service.ts

@@ -363,4 +363,9 @@ export class ScenariosService {
   getCostRange(scenarioId: string): Promise<CostRange> {
     return this.costService.getRange(scenarioId);
   }
+
+  async resetLockStatus(scenarioId: string) {
+    await this.assertScenario(scenarioId);
+    await this.planningUnitsService.resetLockStatus(scenarioId);
+  }
 }

api/apps/api/test/scenario-pu-change/scenario-pu-reset.integration.e2e-spec.ts

@@ -0,0 +1,65 @@
+import { bootstrapApplication } from '../utils/api-application';
+import { GivenScenarioPuDataExists } from '../steps/given-scenario-pu-data-exists';
+import { v4 } from 'uuid';
+import { Repository } from 'typeorm';
+import {
+  LockStatus,
+  ScenariosPlanningUnitGeoEntity,
+} from '@marxan/scenarios-planning-unit';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { DbConnections } from '@marxan-api/ormconfig.connections';
+import { ScenarioPlanningUnitsService } from '@marxan-api/modules/scenarios/planning-units/scenario-planning-units.service';
+import { FixtureType } from '@marxan/utils/tests/fixture-type';
+
+let fixtures: FixtureType<typeof getFixtures>;
+
+beforeEach(async () => {
+  fixtures = await getFixtures();
+});
+
+afterEach(async () => {
+  await fixtures?.cleanup();
+});
+
+test(`resetting lock status`, async () => {
+  await fixtures.GivenScenarioPlanningUnitsExist();
+  await fixtures.WhenRequestingToResetLockStatus();
+  await fixtures.ThenPlanningUnitsAreChangedToDefaultState();
+});
+
+const getFixtures = async () => {
+  const app = await bootstrapApplication();
+  const repo: Repository<ScenariosPlanningUnitGeoEntity> = app.get(
+    getRepositoryToken(
+      ScenariosPlanningUnitGeoEntity,
+      DbConnections.geoprocessingDB,
+    ),
+  );
+  const sut = app.get(ScenarioPlanningUnitsService);
+  const scenarioId = v4();
+
+  return {
+    GivenScenarioPlanningUnitsExist: async () =>
+      await GivenScenarioPuDataExists(repo, scenarioId),
+    WhenRequestingToResetLockStatus: async () =>
+      sut.resetLockStatus(scenarioId),
+    ThenPlanningUnitsAreChangedToDefaultState: async () => {
+      const lockStatuses = (
+        await repo.find({
+          where: {
+            scenarioId,
+          },
+        })
+      ).map((pu) => pu.lockStatus);
+      expect(
+        lockStatuses.every((status) => status === LockStatus.LockedIn),
+      ).toBeTruthy();
+    },
+    cleanup: async () => {
+      await repo.delete({
+        scenarioId,
+      });
+      await app.close();
+    },
+  };
+};

api/apps/api/test/steps/given-scenario-pu-data-exists.ts

@@ -19,18 +19,21 @@ export const GivenScenarioPuDataExists = async (
       lockStatus: LockStatus.Unstated,
       puGeometryId: v4(),
       planningUnitMarxanId: 1,
+      protectedByDefault: true,
     }),
     repo.create({
       scenarioId,
       lockStatus: LockStatus.LockedOut,
       puGeometryId: v4(),
       planningUnitMarxanId: 2,
+      protectedByDefault: true,
     }),
     repo.create({
       scenarioId,
       lockStatus: LockStatus.LockedIn,
       puGeometryId: v4(),
       planningUnitMarxanId: 3,
+      protectedByDefault: true,
     }),
   ]);
   return {