CCM-13371 - Determine Eligible packs

Author: nhsd-david-wass

lambdas/supplier-allocator/.tool-versions

@@ -0,0 +1 @@
+nodejs 22.22.0

lambdas/supplier-allocator/src/handler/allocate-handler.ts

@@ -14,6 +14,7 @@ import z from "zod";
 import { Unit } from "aws-embedded-metrics";
 import { MetricEntry, MetricStatus, buildEMFObject } from "@internal/helpers";
 import {
+  filterPacksForLetter,
   getPackSpecification,
   getPreferredSupplierPacks,
   getSupplierAllocationsForVolumeGroup,
@@ -95,12 +96,14 @@ async function getSupplierFromConfig(letterEvent: PreparedEvents, deps: Deps) {
       deps,
     );
 
+    const eligiblePacks: string[] = await filterPacksForLetter(
+      letterEvent,
+      variantDetails.packSpecificationIds,
+      deps,
+    );
+
     const preferredSupplierPacks: SupplierPack[] =
-      await getPreferredSupplierPacks(
-        variantDetails.packSpecificationIds,
-        allocatedSuppliers,
-        deps,
-      );
+      await getPreferredSupplierPacks(eligiblePacks, allocatedSuppliers, deps);
 
     const preferredPack: PackSpecification = await getPackSpecification(
       preferredSupplierPacks[0].packSpecificationId,
@@ -119,7 +122,8 @@ async function getSupplierFromConfig(letterEvent: PreparedEvents, deps: Deps) {
       volumeGroupId: volumeGroupDetails.id,
       supplierAllocationIds: supplierAllocations.map((a) => a.id),
       allocatedSuppliers,
-      eligiblePacks: variantDetails.packSpecificationIds,
+      variantPacks: variantDetails.packSpecificationIds,
+      eligiblePacks,
       preferredSupplierPacks,
       preferredPack,
       suppliersForPack,

lambdas/supplier-allocator/src/services/__tests__/supplier-config.test.ts

@@ -1,4 +1,5 @@
 import {
+  filterPacksForLetter,
   getPackSpecification,
   getPreferredSupplierPacks,
   getSupplierAllocationsForVolumeGroup,
@@ -479,4 +480,129 @@ describe("supplier-config service", () => {
       ]);
     });
   });
+
+  describe("filterPacksForLetter", () => {
+    it("returns eligible packs for letter", async () => {
+      const deps = makeDeps();
+      deps.supplierConfigRepo.getPackSpecification = jest
+        .fn()
+        .mockResolvedValue({
+          id: "spec1",
+          constraints: {
+            sheets: { operator: "LESS_THAN", value: 2 },
+          },
+        } as any);
+      const letterEvent = {
+        data: {
+          pageCount: 1,
+        },
+      } as any;
+
+      const result = await filterPacksForLetter(letterEvent, ["spec1"], deps);
+
+      expect(result).toEqual(["spec1"]);
+    });
+    it("throws when no eligible packs found for letter", async () => {
+      const deps = makeDeps();
+      deps.supplierConfigRepo.getPackSpecification = jest
+        .fn()
+        .mockResolvedValue({
+          id: "spec1",
+          constraints: {
+            sheets: { operator: "LESS_THAN", value: 2 },
+          },
+        } as any);
+      const letterEvent = {
+        data: {
+          pageCount: 3,
+        },
+      } as any;
+
+      await expect(
+        filterPacksForLetter(letterEvent, ["spec1"], deps),
+      ).rejects.toThrow(
+        "No eligible pack specifications found for letter variant id undefined and pack specification ids spec1",
+      );
+      expect(deps.logger.error).toHaveBeenCalledWith(
+        expect.objectContaining({
+          description: "No eligible pack specifications found for letter",
+          letterVariantId: undefined,
+          packSpecificationIds: ["spec1"],
+        }),
+      );
+    });
+    it("returns eligible packs for all constraint types", async () => {
+      const deps = makeDeps();
+      const constraints: { operator: string; value: number }[] = [
+        { operator: "EQUALS", value: 2 },
+        { operator: "NOT_EQUALS", value: 1 },
+        { operator: "GREATER_THAN", value: 1 },
+        { operator: "LESS_THAN", value: 3 },
+        { operator: "GREATER_THAN_OR_EQUAL", value: 2 },
+        { operator: "LESS_THAN_OR_EQUAL", value: 2 },
+      ];
+      const letterEvent = {
+        data: {
+          pageCount: 2,
+        },
+      } as any;
+
+      for (const constraint of constraints) {
+        deps.supplierConfigRepo.getPackSpecification = jest
+          .fn()
+          .mockResolvedValue({
+            id: "spec1",
+            constraints: {
+              sheets: {
+                operator: constraint.operator,
+                value: constraint.value,
+              },
+            },
+          } as any);
+
+        const result = await filterPacksForLetter(letterEvent, ["spec1"], deps);
+
+        expect(result).toEqual(["spec1"]);
+      }
+    });
+    it("throws an error for unsupported operator", async () => {
+      const deps = makeDeps();
+      deps.supplierConfigRepo.getPackSpecification = jest
+        .fn()
+        .mockResolvedValue({
+          id: "spec1",
+          constraints: {
+            sheets: { operator: "UNSUPPORTED_OP", value: 2 },
+          },
+        } as any);
+      const letterEvent = {
+        data: {
+          pageCount: 2,
+        },
+      } as any;
+
+      await expect(
+        filterPacksForLetter(letterEvent, ["spec1"], deps),
+      ).rejects.toThrow(
+        "Unsupported operator UNSUPPORTED_OP in pack specification constraints",
+      );
+    });
+    it("returns all packs when no constraints defined", async () => {
+      const deps = makeDeps();
+      deps.supplierConfigRepo.getPackSpecification = jest
+        .fn()
+        .mockResolvedValue({
+          id: "spec1",
+        } as any);
+      const letterEvent = {
+        data: {
+          pageCount: 5,
+        },
+      } as any;
+
+      const result = await filterPacksForLetter(letterEvent, ["spec1"], deps);
+
+      expect(result).toEqual(["spec1"]);
+    });
+  });
 });

lambdas/supplier-allocator/src/services/supplier-config.ts

@@ -6,8 +6,13 @@ import {
   SupplierPack,
   VolumeGroup,
 } from "@nhsdigital/nhs-notify-event-schemas-supplier-config";
+import { LetterRequestPreparedEventV2 } from "@nhsdigital/nhs-notify-event-schemas-letter-rendering";
+import { LetterRequestPreparedEvent } from "@nhsdigital/nhs-notify-event-schemas-letter-rendering-v1";
+
 import { Deps } from "../config/deps";
 
+type PreparedEvents = LetterRequestPreparedEventV2 | LetterRequestPreparedEvent;
+
 export async function getVariantDetails(
   variantId: string,
   deps: Deps,
@@ -188,3 +193,80 @@ export async function getSuppliersWithValidPack(
 
   return suppliersWithValidPack;
 }
+
+function evaluateContraint(
+  actualValue: number,
+  constraintValue: number,
+  operator: string,
+): boolean {
+  console.log(
+    `Evaluating constraint: actualValue ${actualValue}, constraintValue ${constraintValue}, operator ${operator}`,
+  );
+  switch (operator) {
+    case "EQUALS": {
+      return actualValue === constraintValue;
+    }
+    case "NOT_EQUALS": {
+      return actualValue !== constraintValue;
+    }
+    case "GREATER_THAN": {
+      return actualValue > constraintValue;
+    }
+    case "LESS_THAN": {
+      return actualValue < constraintValue;
+    }
+    case "GREATER_THAN_OR_EQUAL": {
+      return actualValue >= constraintValue;
+    }
+    case "LESS_THAN_OR_EQUAL": {
+      return actualValue <= constraintValue;
+    }
+    default: {
+      throw new Error(
+        `Unsupported operator ${operator} in pack specification constraints`,
+      );
+    }
+  }
+}
+
+// This function is used to filter the pack specifications for a letter based on the letter data pages and pack specification constraints sheets
+
+export async function filterPacksForLetter(
+  letterEvent: PreparedEvents,
+  packSpecificationIds: string[],
+  deps: Deps,
+): Promise<string[]> {
+  const filteredPackIds: string[] = [];
+  for (const packSpecId of packSpecificationIds) {
+    const packSpec =
+      await deps.supplierConfigRepo.getPackSpecification(packSpecId);
+    if (
+      !packSpec.constraints ||
+      !packSpec.constraints.sheets ||
+      !packSpec.constraints.sheets.value ||
+      !packSpec.constraints.sheets.operator
+    ) {
+      filteredPackIds.push(packSpecId);
+    } else {
+      const isValid = evaluateContraint(
+        letterEvent.data.pageCount,
+        packSpec.constraints.sheets.value,
+        packSpec.constraints.sheets.operator,
+      );
+      if (isValid) {
+        filteredPackIds.push(packSpecId);
+      }
+    }
+  }
+  if (filteredPackIds.length === 0) {
+    deps.logger.error({
+      description: "No eligible pack specifications found for letter",
+      letterVariantId: letterEvent.data.letterVariantId,
+      packSpecificationIds,
+    });
+    throw new Error(
+      `No eligible pack specifications found for letter variant id ${letterEvent.data.letterVariantId} and pack specification ids ${packSpecificationIds.join(", ")}`,
+    );
+  }
+  return filteredPackIds;
+}