CAMS-442 update mongo keys and refactor case assigment

.github/workflows/continuous-deployment.yml

@@ -125,11 +125,6 @@ jobs:
       [
         setup,
         build,
-        accessibility-test,
-        security-scan,
-        unit-test-frontend,
-        unit-test-backend,
-        unit-test-common,
       ]
     if: ((github.ref == 'refs/heads/main') || (github.ref == 'refs/heads/dependency-updates-auto') || (inputs.deployBranch == 'true'))
     with:

backend/functions/lib/adapters/gateways/mongo/case-assignment.mongo.repository.test.ts

@@ -55,9 +55,9 @@ describe('offices repo', () => {
         MockData.getAttorneyAssignment({ caseId }),
       ];
       jest.spyOn(MongoCollectionAdapter.prototype, 'find').mockResolvedValue(mockAssignments);
-      const actualAssignment = await repo.findAssignmentsByCaseId(caseId);
+      const actualAssignment = await repo.findAssignmentsByCaseId([caseId]);
 
-      expect(actualAssignment).toEqual(mockAssignments);
+      expect(actualAssignment).toEqual(new Map([[caseId, mockAssignments]]));
     });
   });
 
@@ -105,7 +105,7 @@ describe('offices repo', () => {
     test('should handle error on findAssignmentsByCaseId', async () => {
       const caseId = '111-22-33333';
       jest.spyOn(MongoCollectionAdapter.prototype, 'find').mockRejectedValue(error);
-      await expect(async () => await repo.findAssignmentsByCaseId(caseId)).rejects.toThrow(
+      await expect(async () => await repo.findAssignmentsByCaseId([caseId])).rejects.toThrow(
         getCamsError(
           error,
           'MONGO_COSMOS_DB_REPOSITORY_ASSIGNMENTS',

backend/functions/lib/adapters/gateways/mongo/case-assignment.mongo.repository.ts

@@ -8,7 +8,7 @@ import { BaseMongoRepository } from './utils/base-mongo-repository';
 const MODULE_NAME: string = 'CASE_ASSIGNMENT_MONGO_REPOSITORY';
 const COLLECTION_NAME = 'assignments';
 
-const { and, equals, exists } = QueryBuilder;
+const { and, equals, exists, contains } = QueryBuilder;
 
 export class CaseAssignmentMongoRepository
   extends BaseMongoRepository
@@ -35,16 +35,28 @@ export class CaseAssignmentMongoRepository
     }
   }
 
-  async findAssignmentsByCaseId(caseId: string): Promise<CaseAssignment[]> {
+  async findAssignmentsByCaseId(caseIds: string[]): Promise<Map<string, CaseAssignment[]>> {
     const query = QueryBuilder.build(
       and(
         equals<CaseAssignment['documentType']>('documentType', 'ASSIGNMENT'),
-        equals<CaseAssignment['caseId']>('caseId', caseId),
+        contains<string[]>('caseId', caseIds),
         exists<CaseAssignment>('unassignedOn', false),
       ),
     );
     try {
-      return await this.getAdapter<CaseAssignment>().find(query);
+      const assignments = await this.getAdapter<CaseAssignment>().find(query);
+      const assignmentsMap = new Map();
+      assignments.forEach((assignment) => {
+        if (assignmentsMap.has(assignment.caseId)) {
+          assignmentsMap.set(assignment.caseId, [
+            ...assignmentsMap.get(assignment.caseId),
+            assignment,
+          ]);
+        } else {
+          assignmentsMap.set(assignment.caseId, [assignment]);
+        }
+      });
+      return assignmentsMap;
     } catch (originalError) {
       throw getCamsError(originalError, MODULE_NAME, 'Unable to retrieve assignment.');
     }

backend/functions/lib/adapters/gateways/mongo/offices.mongo.repository.ts

@@ -1,5 +1,5 @@
 import { ApplicationContext } from '../../types/basic';
-import { AttorneyUser, CamsUserReference } from '../../../../../../common/src/cams/users';
+import { AttorneyUser, CamsUserReference, Staff } from '../../../../../../common/src/cams/users';
 import { Auditable, createAuditRecord } from '../../../../../../common/src/cams/auditable';
 import { CamsRole } from '../../../../../../common/src/cams/roles';
 import { getCamsUserReference } from '../../../../../../common/src/cams/session';
@@ -13,7 +13,7 @@ const COLLECTION_NAME = 'offices';
 
 const { and, equals, contains } = QueryBuilder;
 
-export type OfficeStaff = CamsUserReference &
+export type OfficeStaff = Staff &
   Auditable & {
     documentType: 'OFFICE_STAFF';
     officeCode: string;

backend/functions/lib/adapters/gateways/mongo/utils/mongo-adapter.ts

@@ -29,6 +29,7 @@ export class MongoCollectionAdapter<T> implements DocumentCollectionAdapter<T> {
 
   public async find(query: ConditionOrConjunction, sort?: Sort): Promise<T[]> {
     const mongoQuery = toMongoQuery(query);
+    console.log(mongoQuery);
     const mongoSort = sort ? toMongoSort(sort) : undefined;
     try {
       const findPromise = this.collectionHumble.find(mongoQuery);

backend/functions/lib/controllers/case-assignment/case.assignment.controller.test.ts

@@ -140,11 +140,18 @@ describe('Case Assignment Creation Tests', () => {
   });
 
   test('should fetch a list of assignments when a GET request is called', async () => {
-    const assignments = MockData.buildArray(MockData.getAttorneyAssignment, 3);
+    const caseId = '111-22-33333';
+    const assignments = MockData.buildArray(() => MockData.getAttorneyAssignment({ caseId }), 3);
     const camsHttpResponse = httpSuccess({ body: { data: assignments } });
+    const expectedMap = new Map([[caseId, assignments]]);
+    applicationContext.request = mockCamsHttpRequest({
+      method: 'GET',
+      params: { id: caseId },
+    });
+
     jest
       .spyOn(CaseAssignmentUseCase.prototype, 'findAssignmentsByCaseId')
-      .mockResolvedValue(assignments);
+      .mockResolvedValue(expectedMap);
 
     const assignmentController = new CaseAssignmentController(applicationContext);
     const result = await assignmentController.handleRequest(applicationContext);

backend/functions/lib/controllers/case-assignment/case.assignment.controller.ts

@@ -43,9 +43,10 @@ export class CaseAssignmentController implements CamsController {
           statusCode: HttpStatusCodes.CREATED,
         });
       } else {
-        const assignments = await assignmentUseCase.findAssignmentsByCaseId(
+        const assignmentsMap = await assignmentUseCase.findAssignmentsByCaseId([
           context.request.params['id'],
-        );
+        ]);
+        const assignments = assignmentsMap.get(context.request.params['id']);
         return httpSuccess({
           body: {
             data: assignments,

backend/functions/lib/controllers/cases/cases.controller.test.ts

@@ -310,7 +310,7 @@ describe('cases controller test', () => {
         body: expected,
       });
       await controller.searchCases(camsHttpRequest);
-      expect(useCaseSpy).toHaveBeenCalledWith(expect.anything(), expected);
+      expect(useCaseSpy).toHaveBeenCalledWith(expect.anything(), expected, false);
     });
 
     test('should return an error if an error is encountered', async () => {

backend/functions/lib/controllers/cases/cases.controller.ts

@@ -32,7 +32,7 @@ export class CasesController implements CamsController {
       if (context.request.method === 'GET' && context.request.params.caseId) {
         data = await this.getCaseDetails({ caseId: context.request.params.caseId });
       } else {
-        data = await this.searchCases(context.request);
+        data = await this.searchCases(context.request, context.request.query ?? {});
       }
       return httpSuccess({ body: data });
     } catch (originalError) {
@@ -50,23 +50,36 @@ export class CasesController implements CamsController {
     return { data };
   }
 
-  public async searchCases(request: CamsHttpRequest) {
+  public async searchCases(
+    request: CamsHttpRequest,
+    options: { includeAssignments?: boolean } = {},
+  ) {
     const predicate = request.body as CasesSearchPredicate;
-    const body = await this.paginateSearchCases(predicate, request.url);
+    const body = await this.paginateSearchCases(
+      predicate,
+      request.url,
+      options.includeAssignments ?? false,
+    );
     return body;
   }
 
   async paginateSearchCases(
     predicate: CasesSearchPredicate,
     url: string,
+    includeAssignments: boolean,
   ): Promise<ResponseBody<ResourceActions<CaseBasics>[]>> {
-    const cases = await this.caseManagement.searchCases(this.applicationContext, predicate);
+    const cases = await this.caseManagement.searchCases(
+      this.applicationContext,
+      predicate,
+      includeAssignments,
+    );
 
     const pagination: Pagination = {
       count: cases.length,
       limit: predicate.limit,
       currentPage: getCurrentPage(cases.length, predicate),
     };
+
     if (cases.length > predicate.limit) {
       const next = new URL(url);
       next.searchParams.set('limit', predicate.limit.toString());
@@ -75,12 +88,14 @@ export class CasesController implements CamsController {
       cases.pop();
       pagination.count = cases.length;
     }
+
     if (predicate.offset > 0) {
       const previous = new URL(url);
       previous.searchParams.set('limit', predicate.limit.toString());
       previous.searchParams.set('offset', (predicate.offset - predicate.limit).toString());
       pagination.previous = previous.href;
     }
+
     return {
       meta: {
         self: url,

backend/functions/lib/use-cases/case-assignment.test.ts

@@ -98,14 +98,16 @@ describe('Case assignment tests', () => {
           assignedOn: new Date().toISOString(),
         },
       ];
-      findAssignmentsByCaseId.mockResolvedValue(assignments);
+
+      const expectedMap = new Map([[caseId, assignments]]);
+      findAssignmentsByCaseId.mockResolvedValue(expectedMap);
 
       const assignmentUseCase = new CaseAssignmentUseCase(applicationContext);
 
-      const actualAssignments = await assignmentUseCase.findAssignmentsByCaseId(caseId);
+      const actualAssignments = await assignmentUseCase.findAssignmentsByCaseId([caseId]);
 
-      expect(actualAssignments.length).toEqual(2);
-      expect(actualAssignments).toEqual(expect.arrayContaining(assignments));
+      expect(actualAssignments.get(caseId).length).toEqual(2);
+      expect(actualAssignments).toEqual(expectedMap);
     });
   });
 
@@ -145,6 +147,8 @@ describe('Case assignment tests', () => {
         role,
       };
 
+      findAssignmentsByCaseId.mockResolvedValue(new Map([[caseId, []]]));
+
       expect(createAssignment.mock.calls[0][0]).toEqual(expect.objectContaining(assignmentOne));
       expect(createAssignment.mock.calls[1][0]).toEqual(expect.objectContaining(assignmentTwo));
     });
@@ -172,9 +176,7 @@ describe('Case assignment tests', () => {
         role,
       };
 
-      jest
-        .spyOn(MockMongoRepository.prototype, 'findAssignmentsByCaseId')
-        .mockResolvedValue([assignmentOne]);
+      findAssignmentsByCaseId.mockResolvedValue(new Map([[caseId, [assignmentOne]]]));
 
       await assignmentUseCase.createTrialAttorneyAssignments(
         applicationContext,
@@ -205,7 +207,7 @@ describe('Case assignment tests', () => {
         role,
       };
 
-      findAssignmentsByCaseId.mockResolvedValue([assignmentOne]);
+      findAssignmentsByCaseId.mockResolvedValue(new Map([[caseId, [assignmentOne]]]));
 
       await assignmentUseCase.createTrialAttorneyAssignments(
         applicationContext,

backend/functions/lib/use-cases/case-assignment.ts

@@ -85,8 +85,10 @@ export class CaseAssignmentUseCase {
     });
     const listOfAssignmentIdsCreated: string[] = [];
 
-    const existingAssignmentRecords =
-      await this.assignmentRepository.findAssignmentsByCaseId(caseId);
+    const existingAssignmentRecordsMap = await this.assignmentRepository.findAssignmentsByCaseId([
+      caseId,
+    ]);
+    const existingAssignmentRecords = existingAssignmentRecordsMap.get(caseId) ?? [];
     for (const existingAssignment of existingAssignmentRecords) {
       const stillAssigned = listOfAssignments.find((newAssignment) => {
         return (
@@ -113,7 +115,10 @@ export class CaseAssignmentUseCase {
       }
     }
 
-    const newAssignmentRecords = await this.assignmentRepository.findAssignmentsByCaseId(caseId);
+    const newAssignmentRecordsMap = await this.assignmentRepository.findAssignmentsByCaseId([
+      caseId,
+    ]);
+    const newAssignmentRecords = newAssignmentRecordsMap.get(caseId);
     const history = createAuditRecord<CaseAssignmentHistory>(
       {
         caseId,
@@ -135,8 +140,8 @@ export class CaseAssignmentUseCase {
     return listOfAssignmentIdsCreated;
   }
 
-  public async findAssignmentsByCaseId(caseId: string): Promise<CaseAssignment[]> {
-    return await this.assignmentRepository.findAssignmentsByCaseId(caseId);
+  public async findAssignmentsByCaseId(caseIds: string[]): Promise<Map<string, CaseAssignment[]>> {
+    return await this.assignmentRepository.findAssignmentsByCaseId(caseIds);
   }
 
   public async getCaseLoad(userId: string): Promise<number> {