Add legacy division guard to transfer order actions

Jira ticket: CAMS-473

Co-authored-by: Fritz Madden <[email protected]>
Co-authored-by: James Brooks <[email protected]>
Co-authored-by: Brian Posey <[email protected]>,

Author: 3 people

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

@@ -8,6 +8,7 @@ import {
   getOrdersGateway,
   getOrdersRepository,
   getRuntimeStateRepository,
+  getStorageGateway,
 } from '../../factory';
 import { OrdersUseCase, SyncOrdersOptions, SyncOrdersStatus } from '../../use-cases/orders/orders';
 import {
@@ -46,6 +47,7 @@ export class OrdersController implements CamsController, CamsTimerController {
       getOrdersGateway(context),
       getRuntimeStateRepository<OrderSyncState>(context),
       getConsolidationOrdersRepository(context),
+      getStorageGateway(context),
     );
   }
 

backend/functions/lib/use-cases/orders/orders-consolidation-approval.test.ts

@@ -10,6 +10,7 @@ import {
   getCasesRepository,
   getCasesGateway,
   getConsolidationOrdersRepository,
+  getStorageGateway,
 } from '../../factory';
 import {
   ConsolidationOrderActionApproval,
@@ -56,6 +57,7 @@ describe('Orders use case', () => {
       ordersGateway,
       runtimeStateRepo,
       consolidationRepo,
+      getStorageGateway(mockContext),
     );
   });
 

backend/functions/lib/use-cases/orders/orders-local-gateway.test.ts

@@ -13,6 +13,7 @@ import {
   getOrdersGateway,
   getOrdersRepository,
   getRuntimeStateRepository,
+  getStorageGateway,
 } from '../../factory';
 import { CasesRepository, ConsolidationOrdersRepository } from '../gateways.types';
 import { ApplicationContext } from '../../adapters/types/basic';
@@ -125,6 +126,8 @@ describe('orders use case tests', () => {
   let ordersRepo;
   let runtimeStateRepo;
   let casesGateway;
+  let storageGateway;
+
   const authorizedUser = MockData.getCamsUser({
     roles: [CamsRole.DataVerifier],
     offices: [REGION_02_GROUP_NY],
@@ -137,6 +140,7 @@ describe('orders use case tests', () => {
     runtimeStateRepo = getRuntimeStateRepository(mockContext);
     ordersRepo = getOrdersRepository(mockContext);
     casesGateway = getCasesGateway(mockContext);
+    storageGateway = getStorageGateway(mockContext);
   });
 
   test('should not create a second lead case for an existing consolidation', async () => {
@@ -159,6 +163,7 @@ describe('orders use case tests', () => {
       ordersGateway,
       runtimeStateRepo,
       localConsolidationsRepo,
+      storageGateway,
     );
 
     // attempt to set up a consolidation with a different lead case

backend/functions/lib/use-cases/orders/orders.test.ts

@@ -10,7 +10,9 @@ import {
   getCasesRepository,
   getCasesGateway,
   getConsolidationOrdersRepository,
+  getStorageGateway,
 } from '../../factory';
+import * as factory from '../../factory';
 import { OrderSyncState } from '../gateways.types';
 import {
   ConsolidationOrder,
@@ -41,6 +43,7 @@ import { CaseAssignmentUseCase } from '../case-assignment';
 import { REGION_02_GROUP_NY } from '../../../../../common/src/cams/test-utilities/mock-user';
 import { getCourtDivisionCodes } from '../../../../../common/src/cams/users';
 import { MockMongoRepository } from '../../testing/mock-gateways/mock-mongo.repository';
+import { UstpDivisionMeta } from '../../../../../common/src/cams/offices';
 
 describe('Orders use case', () => {
   const CASE_ID = '000-11-22222';
@@ -51,6 +54,8 @@ describe('Orders use case', () => {
   let runtimeStateRepo;
   let casesGateway;
   let consolidationRepo;
+  let storageGateway;
+
   let useCase: OrdersUseCase;
   const authorizedUser = MockData.getCamsUser({
     roles: [CamsRole.DataVerifier],
@@ -67,13 +72,15 @@ describe('Orders use case', () => {
     casesRepo = getCasesRepository(mockContext);
     casesGateway = getCasesGateway(mockContext);
     consolidationRepo = getConsolidationOrdersRepository(mockContext);
+    storageGateway = getStorageGateway(mockContext);
     useCase = new OrdersUseCase(
       casesRepo,
       casesGateway,
       ordersRepo,
       ordersGateway,
       runtimeStateRepo,
       consolidationRepo,
+      storageGateway,
     );
   });
 
@@ -639,4 +646,55 @@ describe('Orders use case', () => {
       expect.objectContaining({ updatedBy: getCamsUserReference(authorizedUser) }),
     );
   });
+
+  test('should fail to update to a legacy office', async () => {
+    const courtDivisionCode = '000';
+    jest.spyOn(factory, 'getStorageGateway').mockImplementation(() => {
+      return {
+        get: jest.fn(),
+        getRoleMapping: jest.fn(),
+        getUstpOffices: jest.fn(),
+        getUstpDivisionMeta: jest.fn().mockImplementation(() => {
+          return new Map<string, UstpDivisionMeta>([[courtDivisionCode, { isLegacy: true }]]);
+        }),
+      };
+    });
+
+    const localUseCase = new OrdersUseCase(
+      casesRepo,
+      casesGateway,
+      ordersRepo,
+      ordersGateway,
+      runtimeStateRepo,
+      consolidationRepo,
+      factory.getStorageGateway(mockContext),
+    );
+
+    const newCase = MockData.getCaseSummary({ override: { courtDivisionCode } });
+    const order: TransferOrder = MockData.getTransferOrder({
+      override: { status: 'approved', newCase },
+    });
+
+    const action: TransferOrderAction = {
+      id: order.id,
+      orderType: 'transfer',
+      caseId: order.caseId,
+      newCase: order.newCase,
+      status: 'approved',
+    };
+
+    const updateOrderFn = jest.spyOn(ordersRepo, 'update').mockResolvedValue({ id: 'mock-guid' });
+    const getOrderFn = jest.spyOn(ordersRepo, 'read').mockResolvedValue(order);
+    const transferToFn = jest.spyOn(casesRepo, 'createTransferTo');
+    const transferFromFn = jest.spyOn(casesRepo, 'createTransferFrom');
+    const auditFn = jest.spyOn(casesRepo, 'createCaseHistory');
+    mockContext.session = await createMockApplicationContextSession({ user: authorizedUser });
+
+    await expect(localUseCase.updateTransferOrder(mockContext, order.id, action)).rejects.toThrow();
+    expect(updateOrderFn).not.toHaveBeenCalled();
+    expect(getOrderFn).not.toHaveBeenCalled();
+    expect(transferToFn).not.toHaveBeenCalled();
+    expect(transferFromFn).not.toHaveBeenCalled();
+    expect(auditFn).not.toHaveBeenCalled();
+  });
 });

backend/functions/lib/use-cases/orders/orders.ts

@@ -47,6 +47,7 @@ import { UnauthorizedError } from '../../common-errors/unauthorized-error';
 import { createAuditRecord } from '../../../../../common/src/cams/auditable';
 import { OrdersSearchPredicate } from '../../../../../common/src/api/search';
 import { isNotFoundError } from '../../common-errors/not-found-error';
+import { StorageGateway } from '../../adapters/types/storage';
 
 const MODULE_NAME = 'ORDERS_USE_CASE';
 
@@ -70,6 +71,7 @@ export class OrdersUseCase {
   private readonly ordersRepo: OrdersRepository;
   private readonly consolidationsRepo: ConsolidationOrdersRepository;
   private readonly runtimeStateRepo: RuntimeStateRepository<OrderSyncState>;
+  private readonly storageGateway: StorageGateway;
 
   constructor(
     casesRepo: CasesRepository,
@@ -78,13 +80,15 @@ export class OrdersUseCase {
     ordersGateway: OrdersGateway,
     runtimeRepo: RuntimeStateRepository<OrderSyncState>,
     consolidationRepo: ConsolidationOrdersRepository,
+    storageGateway: StorageGateway,
   ) {
     this.casesRepo = casesRepo;
     this.casesGateway = casesGateway;
     this.ordersRepo = ordersRepo;
     this.ordersGateway = ordersGateway;
     this.runtimeStateRepo = runtimeRepo;
     this.consolidationsRepo = consolidationRepo;
+    this.storageGateway = storageGateway;
   }
 
   public async getOrders(context: ApplicationContext): Promise<Array<Order>> {
@@ -114,6 +118,18 @@ export class OrdersUseCase {
       throw new UnauthorizedError(MODULE_NAME);
     }
 
+    const divisionMeta = this.storageGateway.getUstpDivisionMeta();
+    const divisionCodeMaybe = data['newCase'] ? data['newCase'].courtDivisionCode : null;
+    if (
+      divisionCodeMaybe &&
+      divisionMeta.has(divisionCodeMaybe) &&
+      divisionMeta.get(divisionCodeMaybe).isLegacy
+    ) {
+      throw new BadRequestError(MODULE_NAME, {
+        message: 'Cannot transfer to legacy division.',
+      });
+    }
+
     context.logger.info(MODULE_NAME, 'Updating transfer order:', data);
     const initialOrder = await this.ordersRepo.read(id, data.caseId);
     let order: Order;