Merge pull request #506 from bcgov/feature/bf-refactor

refactor: bring forward handling

Author: qhanson55

.github/workflows/unit-tests.yaml

@@ -88,14 +88,14 @@ jobs:
         env:
           CI: true
       - name: Save Coverage Results
-        if: matrix.node-version == '22.x'
+        if: matrix.node-version == '24.x'
         uses: actions/upload-artifact@v7
         with:
           name: coverage-app
           path: ${{ github.workspace }}/app/coverage
           retention-days: 1
       - name: Monitor Coverage
-        if: "matrix.node-version == '22.x' &&  github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork"
+        if: "matrix.node-version == '24.x' &&  github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork"
         uses: slavcodev/coverage-monitor-action@398c4cbbb710e549a8407fdef96ae8b9454d0463 # 1.10.0
         with:
           comment_mode: update
@@ -153,14 +153,14 @@ jobs:
         env:
           CI: true
       - name: Save Coverage Results
-        if: matrix.node-version == '22.x'
+        if: matrix.node-version == '24.x'
         uses: actions/upload-artifact@v7
         with:
           name: coverage-frontend
           path: ${{ github.workspace }}/frontend/coverage
           retention-days: 1
       - name: Monitor Coverage
-        if: "matrix.node-version == '22.x' &&  github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork"
+        if: "matrix.node-version == '24.x' &&  github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork"
         uses: slavcodev/coverage-monitor-action@398c4cbbb710e549a8407fdef96ae8b9454d0463 # 1.10.0
         with:
           comment_mode: update

app/src/controllers/noteHistory.ts

@@ -6,7 +6,7 @@ import {
   updateNoteHistoryService
 } from '../services/noteHistory.ts';
 
-import { Resource } from '../utils/enums/application.ts';
+import { Initiative, Resource } from '../utils/enums/application.ts';
 import { BringForwardType } from '../utils/enums/projectCommon.ts';
 
 import type { Request, Response } from 'express';
@@ -30,7 +30,11 @@ export const listBringForwardsController = async (
   req: Request<never, never, never, { bringForwardState?: BringForwardType }>,
   res: Response<BringForward[], LocalContext>
 ) => {
-  const response = await listBringForwardsService(res.locals.currentContext.initiative, req.query.bringForwardState);
+  const initiativeCode = res.locals.currentContext.initiative;
+  const response = await listBringForwardsService(
+    initiativeCode !== Initiative.PCNS ? initiativeCode : undefined,
+    req.query.bringForwardState
+  );
   res.status(200).json(response);
 };
 
@@ -50,7 +54,7 @@ export const updateNoteHistoryController = async (
   const response = await updateNoteHistoryService(
     res.locals.currentAuthorization,
     res.locals.currentContext,
-    history,
+    { ...history, noteHistoryId: req.params.noteHistoryId },
     note,
     resource
   );

app/src/repositories/noteHistory.ts

@@ -1,9 +1,83 @@
 import { WritableRepository } from './writable.ts';
+import { Initiative } from '../utils/enums/application.ts';
+import { BringForwardType } from '../utils/enums/projectCommon.ts';
 
 import type { PrismaTransactionClient } from '../db/database.ts';
 
 export class NoteHistoryRepository extends WritableRepository<PrismaTransactionClient['note_history']> {
   constructor(tx: PrismaTransactionClient, principal: string) {
     super(tx.note_history, principal, true);
   }
+
+  public async listBringForwards(
+    initiativeCode: Exclude<Initiative, Initiative.PCNS> | undefined,
+    state: BringForwardType
+  ) {
+    return await this.findMany({
+      where: {
+        bringForwardState: state,
+        activity: {
+          initiative: {
+            code: initiativeCode
+          }
+        }
+      },
+      orderBy: {
+        createdAt: 'desc'
+      },
+      select: {
+        noteHistoryId: true,
+        activityId: true,
+        createdBy: true,
+        bringForwardDate: true,
+        bringForwardState: true,
+        escalateToSupervisor: true,
+        escalateToDirector: true,
+        title: true,
+        activity: {
+          select: {
+            enquiry: {
+              select: {
+                activityId: true,
+                enquiryId: true
+              }
+            },
+            electrificationProject: {
+              select: {
+                projectId: true,
+                projectName: true
+              }
+            },
+            generalProject: {
+              select: {
+                projectId: true,
+                projectName: true
+              }
+            },
+            housingProject: {
+              select: {
+                projectId: true,
+                projectName: true
+              }
+            }
+          }
+        },
+        note: { orderBy: { createdAt: 'desc' } }
+      }
+    });
+  }
+
+  public async listNoteHistories(activityId: string) {
+    return await this.findMany({
+      where: {
+        activityId
+      },
+      orderBy: {
+        createdAt: 'desc'
+      },
+      include: {
+        note: { orderBy: { createdAt: 'desc' } }
+      }
+    });
+  }
 }

app/src/services/noteHistory.ts

@@ -2,15 +2,13 @@ import { v4 as uuidv4 } from 'uuid';
 
 import { unitOfWork } from '../db/unitOfWork.ts';
 import { emailBringForwardNotification } from '../domains/noteHistory.ts';
-import { SYSTEM_ID } from '../utils/constants/application.ts';
 import { BringForwardType } from '../utils/enums/projectCommon.ts';
 import { GroupName, Initiative, Resource } from '../utils/enums/application.ts';
 
 import type {
   BringForward,
   CurrentAuthorization,
   CurrentContext,
-  Enquiry,
   NoteHistory,
   NoteHistoryBase
 } from '../types/index.ts';
@@ -55,112 +53,46 @@ export const deleteNoteHistoryService = async (noteHistoryId: string): Promise<v
 
 /**
  * Retrieve a list of bring forward type note histories by the given state
- * @param initiative The initiative for which the note history belongs to
+ * @param initiativeCode The initiative for which the note history belongs to
  * @param state The state to search for
  * @returns A Promise that resolves to the note histories for the given parameters
  */
 export const listBringForwardsService = async (
-  initiative: Initiative,
+  initiativeCode: Exclude<Initiative, Initiative.PCNS> | undefined,
   state: BringForwardType = BringForwardType.UNRESOLVED
 ): Promise<BringForward[]> => {
-  return await unitOfWork.execute(
-    async ({ electrificationProject, enquiry, generalProject, housingProject, noteHistory, user }) => {
-      const history = await noteHistory.findMany({
-        where: {
-          bringForwardState: state,
-          activity: {
-            initiative: {
-              code: initiative
-            }
-          }
-        },
-        orderBy: {
-          createdAt: 'desc'
-        },
-        include: {
-          note: { orderBy: { createdAt: 'desc' } }
-        }
+  return await unitOfWork.execute(async ({ noteHistory, user }) => {
+    const history = await noteHistory.listBringForwards(initiativeCode, state);
+
+    if (history.length) {
+      const users = await user.search({
+        userId: history
+          .map((x) => x.createdBy)
+          .filter((x) => !!x)
+          .map((x) => x!)
       });
 
-      if (history.length) {
-        const [elecProj, generalProj, housingProj] = await Promise.all([
-          electrificationProject.search({
-            activityId: history.map((x) => x.activityId)
-          }),
-          generalProject.search({
-            activityId: history.map((x) => x.activityId)
-          }),
-          housingProject.search({
-            activityId: history.map((x) => x.activityId)
-          })
-        ]);
-
-        const users = await user.findMany({
-          where: {
-            AND: [
-              {
-                userId: {
-                  in: history
-                    .map((x) => x.createdBy)
-                    .filter((x) => !!x)
-                    .map((x) => x!)
-                }
-              }
-            ],
-            NOT: [
-              {
-                userId: SYSTEM_ID
-              }
-            ]
-          }
-        });
+      return history.map((h) => {
+        const project = h.activity.housingProject ?? h.activity.generalProject ?? h.activity.electrificationProject;
 
-        const enquiries: Enquiry[] = (
-          await Promise.all([
-            enquiry.search(
-              {
-                activityId: history.map((x) => x.activityId)
-              },
-              Initiative.ELECTRIFICATION
-            ),
-            enquiry.search(
-              {
-                activityId: history.map((x) => x.activityId)
-              },
-              Initiative.GENERAL
-            ),
-            enquiry.search(
-              {
-                activityId: history.map((x) => x.activityId)
-              },
-              Initiative.HOUSING
-            )
-          ])
-        ).flat();
-
-        return history.map((h) => ({
+        return {
           activityId: h.activityId,
-          noteId: h.noteHistoryId,
-          electrificationProjectId: elecProj.find((s) => s.activityId === h.activityId)?.electrificationProjectId,
-          generalProjectId: generalProj.find((s) => s.activityId === h.activityId)?.generalProjectId,
-          housingProjectId: housingProj.find((s) => s.activityId === h.activityId)?.housingProjectId,
-          enquiryId: enquiries.find((s) => s.activityId === h.activityId)?.enquiryId,
+          noteHistoryId: h.noteHistoryId,
+          projectId: project?.projectId,
+          enquiryId: h.activity.enquiry?.find((e) => e.activityId === h.activityId)?.enquiryId,
+          initiative: initiativeCode,
           title: h.title,
-          projectName:
-            elecProj.find((s) => s.activityId === h.activityId)?.projectName ??
-            generalProj.find((s) => s.activityId === h.activityId)?.projectName ??
-            housingProj.find((s) => s.activityId === h.activityId)?.projectName ??
-            null,
+          projectName: project?.projectName ?? null,
           createdByFullName: users.find((u) => u?.userId === h.createdBy)?.fullName ?? null,
           bringForwardDate: h.bringForwardDate?.toISOString(),
           escalateToSupervisor: h.escalateToSupervisor,
           escalateToDirector: h.escalateToDirector
-        }));
-      } else {
-        return [];
-      }
+        } satisfies BringForward;
+      });
+    } else {
+      return [];
     }
-  );
+  });
 };
 
 /**
@@ -174,17 +106,7 @@ export const listNoteHistoriesService = async (
   activityId: string
 ): Promise<NoteHistory[]> => {
   return await unitOfWork.execute(async ({ noteHistory }) => {
-    const result = await noteHistory.findMany({
-      where: {
-        activityId: activityId
-      },
-      orderBy: {
-        createdAt: 'desc'
-      },
-      include: {
-        note: { orderBy: { createdAt: 'desc' } }
-      }
-    });
+    const result = await noteHistory.listNoteHistories(activityId);
 
     if (currentAuthorization?.attributes.includes('scope:self')) {
       return result.filter((x) => x.shownToProponent);

app/src/types/stuff.d.ts

@@ -68,14 +68,16 @@ export interface AtsUserSearchParameters extends ParsedQs {
 
 export interface BringForward {
   activityId: string;
-  noteId: string;
-  electrificationProjectId?: string;
-  housingProjectId?: string;
+  noteHistoryId: string;
+  projectId?: string;
   enquiryId?: string;
+  initiative?: Initiative;
   title: string;
   projectName: string | null;
   bringForwardDate?: string;
   createdByFullName: string | null;
+  escalateToSupervisor: boolean;
+  escalateToDirector: boolean;
 }
 
 export interface ContactSearchParameters {

app/tests/unit/controllers/noteHistory.test.ts

@@ -138,7 +138,7 @@ describe('updateNoteHistoryController', () => {
     expect(updateSpy).toHaveBeenCalledWith(
       TEST_CURRENT_AUTH_CONTEXT_NAVIGATOR,
       TEST_CURRENT_CONTEXT,
-      expect.objectContaining({ noteHistoryId: TEST_NOTE_HISTORY_1.noteHistoryId }),
+      expect.objectContaining({ noteHistoryId: 'nh-123' }),
       'updated note',
       Resource.ENQUIRY
     );