feat(DTFS2-7793): add update amendment status endpoint to dtfs-central

dtfs-central-api/api-tests/helpers/create-portal-facility-amendment.ts

@@ -1,12 +1,12 @@
 import { Response } from 'supertest';
 import * as z from 'zod';
 import { PORTAL_FACILITY_AMENDMENT_USER_VALUES } from '@ukef/dtfs2-common/schemas';
-import { PortalFacilityAmendment } from '@ukef/dtfs2-common';
+import { PortalFacilityAmendmentWithUkefId } from '@ukef/dtfs2-common';
 import { generatePortalAuditDetails } from '@ukef/dtfs2-common/change-stream';
 import { testApi } from '../test-api';
 
 interface FacilityAmendmentResponse extends Response {
-  body: PortalFacilityAmendment;
+  body: PortalFacilityAmendmentWithUkefId;
 }
 
 /**
@@ -32,5 +32,13 @@ export const createPortalFacilityAmendment = async ({
   const { body } = (await testApi
     .put({ dealId, amendment, auditDetails: generatePortalAuditDetails(userId) })
     .to(`/v1/portal/facilities/${facilityId}/amendments/`)) as FacilityAmendmentResponse;
+
+  // Eligibility Criteria is overwritten in the PUT request
+  if (amendment.eligibilityCriteria) {
+    await testApi
+      .patch({ update: { eligibilityCriteria: amendment.eligibilityCriteria }, auditDetails: generatePortalAuditDetails(userId) })
+      .to(`/v1/portal/facilities/${facilityId}/amendments/${body.amendmentId}`);
+  }
+
   return body;
 };

dtfs-central-api/api-tests/v1/portal-facility-amendments/amendment-patch.api-test.ts

@@ -29,7 +29,7 @@ const newDeal = aDeal({
   submissionType: DEAL_SUBMISSION_TYPE.AIN,
 }) as AnyObject;
 
-describe('PATCH /v1/portal/facilities/:facilityId/amendments/', () => {
+describe('PATCH /v1/portal/facilities/:facilityId/amendments/:amendmentId', () => {
   let dealId: string;
   let facilityId: string;
   let portalUserId: string;
@@ -164,9 +164,9 @@ describe('PATCH /v1/portal/facilities/:facilityId/amendments/', () => {
     });
 
     it(`should return ${HttpStatusCode.Ok} when the payload is valid & the amendment exists`, async () => {
-      const { status } = (await testApi
+      const { status } = await testApi
         .patch({ update: aPortalFacilityAmendmentUserValues(), auditDetails: generatePortalAuditDetails(portalUserId) })
-        .to(generateUrl(facilityId, amendmentId))) as ErrorResponse;
+        .to(generateUrl(facilityId, amendmentId));
 
       expect(status).toEqual(HttpStatusCode.Ok);
     });

dtfs-central-api/api-tests/v1/portal-facility-amendments/amendment-status-patch.api-test.ts

@@ -0,0 +1,233 @@
+import { Response } from 'supertest';
+import { ObjectId } from 'mongodb';
+import { HttpStatusCode } from 'axios';
+import { AnyObject, API_ERROR_CODE, DEAL_SUBMISSION_TYPE, DEAL_TYPE, FACILITY_TYPE, MONGO_DB_COLLECTIONS, PORTAL_AMENDMENT_STATUS } from '@ukef/dtfs2-common';
+import { generatePortalAuditDetails } from '@ukef/dtfs2-common/change-stream';
+import { aPortalFacilityAmendmentUserValues } from '@ukef/dtfs2-common/mock-data-backend';
+import wipeDB from '../../wipeDB';
+import { testApi } from '../../test-api';
+import { createDeal, submitDealToTfm } from '../../helpers/create-deal';
+import aDeal from '../deal-builder';
+import { aPortalUser } from '../../mocks/test-users/portal-user';
+import { createPortalUser } from '../../helpers/create-portal-user';
+import { createPortalFacilityAmendment } from '../../helpers/create-portal-facility-amendment';
+import { mongoDbClient as db } from '../../../src/drivers/db-client';
+import { amendmentsEligibilityCriteria } from '../../../test-helpers/test-data/eligibility-criteria-amendments';
+
+const originalEnv = { ...process.env };
+
+interface ErrorResponse extends Response {
+  body: { status?: number; message: string; code?: string };
+}
+
+const generateUrl = (facilityId: string, amendmentId: string): string => {
+  return `/v1/portal/facilities/${facilityId}/amendments/${amendmentId}/status`;
+};
+
+const newDeal = aDeal({
+  dealType: DEAL_TYPE.GEF,
+  submissionType: DEAL_SUBMISSION_TYPE.AIN,
+}) as AnyObject;
+
+describe('PATCH /v1/portal/facilities/:facilityId/amendments/:amendmentId/status', () => {
+  let dealId: string;
+  let facilityId: string;
+  let portalUserId: string;
+
+  beforeAll(async () => {
+    await wipeDB.wipe([MONGO_DB_COLLECTIONS.FACILITIES, MONGO_DB_COLLECTIONS.TFM_FACILITIES, MONGO_DB_COLLECTIONS.ELIGIBILITY_CRITERIA_AMENDMENTS]);
+    await db
+      .getCollection(MONGO_DB_COLLECTIONS.ELIGIBILITY_CRITERIA_AMENDMENTS)
+      .then((collection) => collection.insertOne(amendmentsEligibilityCriteria(1, [FACILITY_TYPE.CASH, FACILITY_TYPE.CONTINGENT])));
+
+    portalUserId = (await createPortalUser())._id;
+  });
+
+  beforeEach(async () => {
+    const createDealResponse: { body: { _id: string } } = await createDeal({ deal: newDeal, user: aPortalUser() });
+    dealId = createDealResponse.body._id;
+
+    const createFacilityResponse: { body: { _id: string } } = await testApi
+      .post({ dealId, type: FACILITY_TYPE.CASH, hasBeenIssued: false })
+      .to('/v1/portal/gef/facilities');
+
+    facilityId = createFacilityResponse.body._id;
+
+    await submitDealToTfm({ dealId, dealSubmissionType: DEAL_SUBMISSION_TYPE.AIN, dealType: DEAL_TYPE.GEF });
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  describe('when FF_PORTAL_FACILITY_AMENDMENTS_ENABLED is set to `false`', () => {
+    beforeAll(() => {
+      process.env.FF_PORTAL_FACILITY_AMENDMENTS_ENABLED = 'false';
+    });
+
+    it(`should return ${HttpStatusCode.NotFound}`, async () => {
+      const amendmentId = new ObjectId().toString();
+
+      const { status } = await testApi
+        .patch({ dealId, auditDetails: generatePortalAuditDetails(portalUserId), newStatus: 'a new status' })
+        .to(generateUrl(facilityId, amendmentId));
+
+      expect(status).toEqual(HttpStatusCode.NotFound);
+    });
+  });
+
+  describe('when FF_PORTAL_FACILITY_AMENDMENTS_ENABLED is set to `true`', () => {
+    let amendmentId: string;
+
+    beforeAll(() => {
+      process.env.FF_PORTAL_FACILITY_AMENDMENTS_ENABLED = 'true';
+    });
+
+    beforeEach(async () => {
+      const existingAmendment = await createPortalFacilityAmendment({
+        facilityId,
+        dealId,
+        userId: portalUserId,
+        amendment: {
+          ...aPortalFacilityAmendmentUserValues(),
+          eligibilityCriteria: {
+            criteria: [{ id: 1, text: 'item 1', answer: true }],
+            version: 1,
+          },
+        },
+      });
+
+      amendmentId = existingAmendment.amendmentId.toString();
+    });
+
+    it(`should return ${HttpStatusCode.BadRequest} when the facility id is invalid`, async () => {
+      const anInvalidFacilityId = 'InvalidId';
+
+      const { body, status } = (await testApi
+        .patch({ dealId, auditDetails: generatePortalAuditDetails(portalUserId), newStatus: 'a new status' })
+        .to(generateUrl(anInvalidFacilityId, amendmentId))) as ErrorResponse;
+
+      expect(status).toEqual(HttpStatusCode.BadRequest);
+
+      expect(body).toEqual({
+        message: "Expected path parameter 'facilityId' to be a valid mongo id",
+        code: API_ERROR_CODE.INVALID_MONGO_ID_PATH_PARAMETER,
+      });
+    });
+
+    it(`should return ${HttpStatusCode.BadRequest} when the amendment id is invalid`, async () => {
+      const anInvalidAmendmentId = 'InvalidId';
+
+      const { body, status } = (await testApi
+        .patch({ dealId, auditDetails: generatePortalAuditDetails(portalUserId), newStatus: 'a new status' })
+        .to(generateUrl(facilityId, anInvalidAmendmentId))) as ErrorResponse;
+
+      expect(status).toEqual(HttpStatusCode.BadRequest);
+
+      expect(body).toEqual({
+        message: "Expected path parameter 'amendmentId' to be a valid mongo id",
+        code: API_ERROR_CODE.INVALID_MONGO_ID_PATH_PARAMETER,
+      });
+    });
+
+    it(`should return ${HttpStatusCode.BadRequest} when the deal id is invalid`, async () => {
+      const anInvalidDealId = 'dealId';
+
+      const { body, status } = (await testApi
+        .patch({
+          dealId: anInvalidDealId,
+          auditDetails: generatePortalAuditDetails(portalUserId),
+          newStatus: PORTAL_AMENDMENT_STATUS.READY_FOR_CHECKERS_APPROVAL,
+        })
+        .to(generateUrl(facilityId, amendmentId))) as ErrorResponse;
+
+      expect(status).toEqual(HttpStatusCode.BadRequest);
+
+      expect(body).toEqual({
+        status: HttpStatusCode.BadRequest,
+        message: ['dealId: _id must be a valid mongo object id (custom)'],
+        code: API_ERROR_CODE.INVALID_PAYLOAD,
+      });
+    });
+
+    it(`should return ${HttpStatusCode.BadRequest} when the new status is invalid`, async () => {
+      const anInvalidStatus = 'a new status';
+
+      const { body, status } = (await testApi
+        .patch({ dealId, auditDetails: generatePortalAuditDetails(portalUserId), newStatus: anInvalidStatus })
+        .to(generateUrl(facilityId, amendmentId))) as ErrorResponse;
+
+      expect(status).toEqual(HttpStatusCode.BadRequest);
+
+      expect(body).toEqual({
+        status: HttpStatusCode.BadRequest,
+        code: 'INVALID_PAYLOAD',
+        message: [
+          `newStatus: Invalid enum value. Expected '${PORTAL_AMENDMENT_STATUS.READY_FOR_CHECKERS_APPROVAL}', received '${anInvalidStatus}' (invalid_enum_value)`,
+        ],
+      });
+    });
+
+    describe(`when newStatus is ${PORTAL_AMENDMENT_STATUS.READY_FOR_CHECKERS_APPROVAL}`, () => {
+      const newStatus = PORTAL_AMENDMENT_STATUS.READY_FOR_CHECKERS_APPROVAL;
+
+      it(`should return ${HttpStatusCode.NotFound} when the facility does not exist`, async () => {
+        const aValidButNonExistentFacilityId = new ObjectId().toString();
+
+        const { body, status } = (await testApi
+          .patch({ dealId, auditDetails: generatePortalAuditDetails(portalUserId), newStatus })
+          .to(generateUrl(aValidButNonExistentFacilityId, amendmentId))) as ErrorResponse;
+
+        expect(status).toEqual(HttpStatusCode.NotFound);
+        expect(body).toEqual({
+          status: HttpStatusCode.NotFound,
+          message: `Facility not found: ${aValidButNonExistentFacilityId}`,
+        });
+      });
+
+      it(`should return ${HttpStatusCode.NotFound} when the amendment does not exist`, async () => {
+        const aValidButNonExistentAmendmentId = new ObjectId().toString();
+
+        const { body, status } = (await testApi
+          .patch({ dealId, auditDetails: generatePortalAuditDetails(portalUserId), newStatus })
+          .to(generateUrl(facilityId, aValidButNonExistentAmendmentId))) as ErrorResponse;
+
+        expect(status).toEqual(HttpStatusCode.NotFound);
+        expect(body).toEqual({
+          status: HttpStatusCode.NotFound,
+          message: `Amendment not found: ${aValidButNonExistentAmendmentId} on facility: ${facilityId}`,
+        });
+      });
+
+      it(`should return ${HttpStatusCode.Conflict} when the amendment is incomplete`, async () => {
+        // Arrange
+        const anIncompleteAmendment = await createPortalFacilityAmendment({
+          facilityId,
+          dealId,
+          userId: portalUserId,
+        });
+        const incompleteAmendmentId = anIncompleteAmendment.amendmentId.toString();
+
+        // Act
+        const { body, status } = (await testApi
+          .patch({ dealId, auditDetails: generatePortalAuditDetails(portalUserId), newStatus })
+          .to(generateUrl(facilityId, incompleteAmendmentId))) as ErrorResponse;
+
+        // Assert
+        expect(status).toEqual(HttpStatusCode.Conflict);
+        expect(body).toEqual({
+          status: HttpStatusCode.Conflict,
+          message: `Amendment ${incompleteAmendmentId} on facility ${facilityId} is incomplete: neither changeCoverEndDate nor changeFacilityValue is true`,
+        });
+      });
+
+      it(`should return ${HttpStatusCode.Ok} when the payload is valid & the amendment exists`, async () => {
+        const { status } = await testApi
+          .patch({ dealId, auditDetails: generatePortalAuditDetails(portalUserId), newStatus })
+          .to(generateUrl(facilityId, amendmentId));
+
+        expect(status).toEqual(HttpStatusCode.Ok);
+      });
+    });
+  });
+});

dtfs-central-api/src/repositories/tfm-facilities-repo/tfm-facilities.repo.ts

@@ -399,6 +399,7 @@ export class TfmFacilitiesRepo {
    * @param updatePortalFacilityAmendmentByAmendmentIdParams.facilityId - the facility id
    * @param updatePortalFacilityAmendmentByAmendmentIdParams.update - the update to apply
    * @param updatePortalFacilityAmendmentByAmendmentIdParams.auditDetails - the users audit details
+   * @param updatePortalFacilityAmendmentByAmendmentIdParams.allowedStatuses - the statuses of the amendment
    *
    * @returns The update result.
    */
@@ -407,18 +408,26 @@ export class TfmFacilitiesRepo {
     facilityId,
     update,
     auditDetails,
+    allowedStatuses,
   }: {
     update: Partial<PortalFacilityAmendment>;
     amendmentId: ObjectId;
     facilityId: ObjectId;
     auditDetails: AuditDetails;
+    allowedStatuses: PortalAmendmentStatus[];
   }): Promise<UpdateResult> {
     try {
       const collection = await this.getCollection();
 
       const findFilter: Filter<TfmFacility> = {
         _id: { $eq: new ObjectId(facilityId) },
-        amendments: { $elemMatch: { amendmentId: { $eq: new ObjectId(amendmentId) }, type: AMENDMENT_TYPES.PORTAL } },
+        amendments: {
+          $elemMatch: {
+            amendmentId: { $eq: new ObjectId(amendmentId) },
+            type: { $eq: AMENDMENT_TYPES.PORTAL },
+            status: { $in: allowedStatuses },
+          },
+        },
       };
 
       const updateFilter: UpdateFilter<TfmFacility> = flatten({

dtfs-central-api/src/repositories/tfm-facilities-repo/tfm-facilities.repo.updatePortalFacilityAmendmentByAmendmentId.test.ts

@@ -1,6 +1,6 @@
 import { ObjectId, UpdateResult } from 'mongodb';
 import { flatten } from 'mongo-dot-notation';
-import { MONGO_DB_COLLECTIONS, AMENDMENT_TYPES, AmendmentNotFoundError } from '@ukef/dtfs2-common';
+import { MONGO_DB_COLLECTIONS, AMENDMENT_TYPES, AmendmentNotFoundError, PORTAL_AMENDMENT_STATUS } from '@ukef/dtfs2-common';
 import { generateAuditDatabaseRecordFromAuditDetails, generatePortalAuditDetails } from '@ukef/dtfs2-common/change-stream';
 import { TfmFacilitiesRepo } from './tfm-facilities.repo';
 import { mongoDbClient } from '../../drivers/db-client';
@@ -16,6 +16,7 @@ const update = {
 };
 const amendmentId = new ObjectId();
 const auditDetails = generatePortalAuditDetails(aPortalUser()._id);
+const allowedStatuses = [PORTAL_AMENDMENT_STATUS.DRAFT];
 
 const mockUpdateResult = {
   modifiedCount: 1,
@@ -48,7 +49,7 @@ describe('TfmFacilitiesRepo', () => {
 
     it(`should call getCollection with ${MONGO_DB_COLLECTIONS.TFM_FACILITIES}`, async () => {
       // Act
-      await TfmFacilitiesRepo.updatePortalFacilityAmendmentByAmendmentId({ amendmentId, facilityId, update, auditDetails });
+      await TfmFacilitiesRepo.updatePortalFacilityAmendmentByAmendmentId({ amendmentId, facilityId, update, auditDetails, allowedStatuses });
 
       // Assert
       expect(mockGetCollection).toHaveBeenCalledTimes(1);
@@ -57,13 +58,19 @@ describe('TfmFacilitiesRepo', () => {
 
     it(`should call updateOne with the correct parameters`, async () => {
       // Act
-      await TfmFacilitiesRepo.updatePortalFacilityAmendmentByAmendmentId({ amendmentId, facilityId, update, auditDetails });
+      await TfmFacilitiesRepo.updatePortalFacilityAmendmentByAmendmentId({ amendmentId, facilityId, update, auditDetails, allowedStatuses });
 
       // Assert
 
       const expectedFindFilter = {
         _id: { $eq: new ObjectId(facilityId) },
-        amendments: { $elemMatch: { amendmentId: { $eq: new ObjectId(amendmentId) }, type: AMENDMENT_TYPES.PORTAL } },
+        amendments: {
+          $elemMatch: {
+            amendmentId: { $eq: new ObjectId(amendmentId) },
+            type: { $eq: AMENDMENT_TYPES.PORTAL },
+            status: { $in: allowedStatuses },
+          },
+        },
       };
 
       const expectedUpdateFilter = flatten({
@@ -77,7 +84,7 @@ describe('TfmFacilitiesRepo', () => {
 
     it(`should return the updateResult`, async () => {
       // Act
-      const response = await TfmFacilitiesRepo.updatePortalFacilityAmendmentByAmendmentId({ amendmentId, facilityId, update, auditDetails });
+      const response = await TfmFacilitiesRepo.updatePortalFacilityAmendmentByAmendmentId({ amendmentId, facilityId, update, auditDetails, allowedStatuses });
 
       // Assert
       expect(response).toEqual(mockUpdateResult);
@@ -88,9 +95,9 @@ describe('TfmFacilitiesRepo', () => {
       mockUpdateOne.mockResolvedValue({ ...mockUpdateResult, modifiedCount: 0 });
 
       // Act + Assert
-      await expect(() => TfmFacilitiesRepo.updatePortalFacilityAmendmentByAmendmentId({ amendmentId, facilityId, update, auditDetails })).rejects.toThrow(
-        AmendmentNotFoundError,
-      );
+      await expect(() =>
+        TfmFacilitiesRepo.updatePortalFacilityAmendmentByAmendmentId({ amendmentId, facilityId, update, auditDetails, allowedStatuses }),
+      ).rejects.toThrow(AmendmentNotFoundError);
     });
   });
 });