store current allocations

Author: nhsd-david-wass

internal/datastore/src/supplier-quotas-repository.ts

@@ -95,7 +95,7 @@ export class SupplierQuotasRepository {
   async getDailyAllocation(
     groupId: string,
     date: string,
-  ): Promise<DailyAllocation> {
+  ): Promise<DailyAllocation | undefined> {
     const result = await this.ddbClient.send(
       new GetCommand({
         TableName: this.config.supplierQuotasTableName,
@@ -106,9 +106,7 @@ export class SupplierQuotasRepository {
       }),
     );
     if (!result.Item) {
-      throw new Error(
-        `No daily allocation found for volume group id ${groupId} and date ${date}`,
-      );
+      return undefined;
     }
     return $DailyAllocation.parse(result.Item);
   }
@@ -133,7 +131,8 @@ export class SupplierQuotasRepository {
     newAllocation: number,
   ): Promise<void> {
     const dailyAllocation = await this.getDailyAllocation(groupId, date);
-    const currentAllocation = dailyAllocation.allocations[supplierId] ?? 0;
+    const allocations = dailyAllocation?.allocations ?? {};
+    const currentAllocation = allocations[supplierId] ?? 0;
     const updatedAllocation = currentAllocation + newAllocation;
 
     await this.ddbClient.send(

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

@@ -23,7 +23,10 @@ import {
   getVariantDetails,
   getVolumeGroupDetails,
 } from "../services/supplier-config";
-import { calculateSupplierAllocatedFactor } from "../services/supplier-quotas";
+import {
+  calculateSupplierAllocatedFactor,
+  updateSupplierAllocation,
+} from "../services/supplier-quotas";
 import { Deps } from "../config/deps";
 
 type SupplierSpec = {
@@ -32,6 +35,12 @@ type SupplierSpec = {
   priority: number;
   billingId: string;
 };
+
+type SupplierDetails = {
+  supplierSpec: SupplierSpec;
+  volumeGroupId: string;
+};
+
 type PreparedEvents = LetterRequestPreparedEventV2 | LetterRequestPreparedEvent;
 
 // small envelope that must exist in all inputs
@@ -71,7 +80,10 @@ function validateType(event: unknown) {
   }
 }
 
-async function getSupplierFromConfig(letterEvent: PreparedEvents, deps: Deps) {
+async function getSupplierFromConfig(
+  letterEvent: PreparedEvents,
+  deps: Deps,
+): Promise<SupplierDetails | undefined> {
   try {
     const variantDetails: LetterVariant = await getVariantDetails(
       letterEvent.data.letterVariantId,
@@ -119,7 +131,7 @@ async function getSupplierFromConfig(letterEvent: PreparedEvents, deps: Deps) {
 
     let supplierAllocationsForPack: SupplierAllocation[] = [];
     let supplierFactors: { supplierId: string; factor: number }[] = [];
-
+    let selectedSupplierId = "unknown"; // Default to first supplier if no allocations or factors can be calculated
     if (suppliersForPack && suppliersForPack.length > 0) {
       supplierAllocationsForPack = supplierAllocations.filter((alloc) =>
         suppliersForPack.some((supplier) => supplier.id === alloc.supplier),
@@ -137,6 +149,16 @@ async function getSupplierFromConfig(letterEvent: PreparedEvents, deps: Deps) {
       console.log("Supplier factors calculated for allocation", {
         supplierFactors,
       });
+
+      // Get the supplierid with the lowest factor
+      selectedSupplierId = supplierFactors[0].supplierId;
+      let lowestFactor = supplierFactors[0].factor;
+      for (const supplierFactor of supplierFactors) {
+        if (supplierFactor.factor < lowestFactor) {
+          lowestFactor = supplierFactor.factor;
+          selectedSupplierId = supplierFactor.supplierId;
+        }
+      }
     }
 
     deps.logger.info({
@@ -152,16 +174,26 @@ async function getSupplierFromConfig(letterEvent: PreparedEvents, deps: Deps) {
       suppliersForPack,
       supplierAllocationsForPack,
       supplierFactors,
+      selectedSupplierId,
     });
 
-    return allocatedSuppliers;
+    const supplierDetails: SupplierDetails = {
+      supplierSpec: {
+        supplierId: selectedSupplierId,
+        specId: preferredPack.id,
+        priority: 0,
+        billingId: preferredPack.billingId,
+      },
+      volumeGroupId: volumeGroupDetails.id,
+    };
+    return supplierDetails;
   } catch (error) {
     deps.logger.error({
       description: "Error fetching supplier from config",
       err: error,
       variantId: letterEvent.data.letterVariantId,
     });
-    return [];
+    return undefined;
   }
 }
 
@@ -170,6 +202,7 @@ function getSupplier(letterEvent: PreparedEvents, deps: Deps): SupplierSpec {
 }
 
 type AllocationMetrics = Map<string, Map<string, number>>;
+type VolumeGroupAllocation = Map<string, Record<string, number>>;
 
 function incrementMetric(
   map: AllocationMetrics,
@@ -203,12 +236,40 @@ function emitMetrics(
   }
 }
 
+function incrementAllocation(
+  map: VolumeGroupAllocation,
+  volumeGroupId: string,
+  supplierId: string,
+  allocation: number,
+) {
+  const groupAllocations = map.get(volumeGroupId) ?? {};
+  groupAllocations[supplierId] =
+    (groupAllocations[supplierId] ?? 0) + allocation;
+  map.set(volumeGroupId, groupAllocations);
+}
+
+async function saveAllocations(
+  deps: Deps,
+  volumeGroupAllocations: VolumeGroupAllocation,
+) {
+  for (const [volumeGroupId, allocations] of volumeGroupAllocations) {
+    for (const [supplierId, allocation] of Object.entries(allocations)) {
+      await updateSupplierAllocation(
+        volumeGroupId,
+        supplierId,
+        allocation,
+        deps,
+      );
+    }
+  }
+}
+
 export default function createSupplierAllocatorHandler(deps: Deps): SQSHandler {
   return async (event: SQSEvent) => {
     const batchItemFailures: SQSBatchItemFailure[] = [];
     const perAllocationSuccess: AllocationMetrics = new Map();
     const perAllocationFailure: AllocationMetrics = new Map();
-
+    const volumeGroupAllocations: VolumeGroupAllocation = new Map(); // Map of volume group id to supplier allocations for that group, used to track the allocations calculated in this batch for emitting metrics and updating the quotas after processing the batch
     // Initialise the supplier quotas.
 
     const tasks = event.Records.map(async (record) => {
@@ -225,7 +286,17 @@ export default function createSupplierAllocatorHandler(deps: Deps): SQSHandler {
         validateType(letterEvent);
 
         const supplierSpec = getSupplier(letterEvent as PreparedEvents, deps);
-        await getSupplierFromConfig(letterEvent as PreparedEvents, deps);
+        const supplierDetails = await getSupplierFromConfig(
+          letterEvent as PreparedEvents,
+          deps,
+        );
+
+        incrementAllocation(
+          volumeGroupAllocations,
+          supplierDetails?.volumeGroupId ?? "unknown",
+          supplierSpec.supplierId,
+          1,
+        );
 
         supplier = supplierSpec.supplierId;
         priority = String(supplierSpec.priority);
@@ -276,6 +347,7 @@ export default function createSupplierAllocatorHandler(deps: Deps): SQSHandler {
 
     emitMetrics(perAllocationSuccess, MetricStatus.Success, deps);
     emitMetrics(perAllocationFailure, MetricStatus.Failure, deps);
+    await saveAllocations(deps, volumeGroupAllocations);
     return { batchItemFailures };
   };
 }

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

@@ -1,4 +1,4 @@
-import { OverallAllocation } from "@internal/datastore";
+import { DailyAllocation, OverallAllocation } from "@internal/datastore";
 import { SupplierAllocation } from "@nhsdigital/nhs-notify-event-schemas-supplier-config";
 import { Deps } from "../config/deps";
 
@@ -33,34 +33,54 @@ export async function calculateSupplierAllocatedFactor(
   });
 }
 
-export async function updateSupplierQuota(
-  groupId: string,
+// function to either update or create a new overall allocation and daily allocation for a given supplier, volume group and allocation amount
+// if the overall allocation for the volume group does not exist, it will be created with the new allocation for the supplier and 0 for the other suppliers
+
+export async function updateSupplierAllocation(
+  volumeGroupId: string,
   supplierId: string,
   newAllocation: number,
   deps: Deps,
 ): Promise<void> {
   const overallAllocation =
-    await deps.supplierQuotasRepo.getOverallAllocation(groupId);
-
-  const updatedAllocations = overallAllocation
-    ? {
-        ...overallAllocation.allocations,
+    await deps.supplierQuotasRepo.getOverallAllocation(volumeGroupId);
+  if (overallAllocation) {
+    await deps.supplierQuotasRepo.updateOverallAllocation(
+      volumeGroupId,
+      supplierId,
+      newAllocation,
+    );
+  } else {
+    const newOverallAllocation: OverallAllocation = {
+      id: volumeGroupId,
+      volumeGroup: volumeGroupId,
+      allocations: {
         [supplierId]: newAllocation,
-      }
-    : {
+      },
+    };
+    await deps.supplierQuotasRepo.putOverallAllocation(newOverallAllocation);
+  }
+  const dailyAllocationDate = new Date().toISOString().split("T")[0]; // Get current date in YYYY-MM-DD format
+  const dailyAllocation = await deps.supplierQuotasRepo.getDailyAllocation(
+    volumeGroupId,
+    dailyAllocationDate,
+  );
+  if (dailyAllocation) {
+    await deps.supplierQuotasRepo.updateDailyAllocation(
+      volumeGroupId,
+      dailyAllocationDate,
+      supplierId,
+      newAllocation,
+    );
+  } else {
+    const newDailyAllocation: DailyAllocation = {
+      id: `${volumeGroupId}#DATE#${dailyAllocationDate}`,
+      date: dailyAllocationDate,
+      volumeGroup: volumeGroupId,
+      allocations: {
         [supplierId]: newAllocation,
-      };
-
-  const updatedOverallAllocation: OverallAllocation = overallAllocation
-    ? {
-        ...overallAllocation,
-        allocations: updatedAllocations,
-      }
-    : {
-        id: groupId,
-        volumeGroup: groupId,
-        allocations: updatedAllocations,
-      };
-
-  await deps.supplierQuotasRepo.putOverallAllocation(updatedOverallAllocation);
+      },
+    };
+    await deps.supplierQuotasRepo.putDailyAllocation(newDailyAllocation);
+  }
 }