Merge branch 'staging' into 10554-data-cleanup

scripts/run-once-scripts/postgres-migration/batch-delete-dynamo-items.ts

@@ -0,0 +1,63 @@
+import {
+  BatchWriteCommand,
+  DynamoDBDocumentClient,
+} from '@aws-sdk/lib-dynamodb';
+
+export async function batchDeleteDynamoItems(
+  itemsToDelete: { DeleteRequest: { Key: { pk: string; sk: string } } }[],
+  client: DynamoDBDocumentClient,
+  tableNameInput: string,
+): Promise<number> {
+  const BATCH_SIZE = 25;
+  const RETRY_DELAY_MS = 5000; // Set the delay between retries (in milliseconds)
+  let totalItemsDeleted = 0;
+
+  for (let i = 0; i < itemsToDelete.length; i += BATCH_SIZE) {
+    const batch = itemsToDelete.slice(i, i + BATCH_SIZE);
+
+    const batchWriteParams = {
+      RequestItems: {
+        [tableNameInput]: batch,
+      },
+    };
+
+    try {
+      let unprocessedItems: any[] = batch;
+      let retryCount = 0;
+      const MAX_RETRIES = 5;
+
+      // Retry logic for unprocessed items
+      while (unprocessedItems.length > 0 && retryCount < MAX_RETRIES) {
+        const response = await client.send(
+          new BatchWriteCommand(batchWriteParams),
+        );
+
+        totalItemsDeleted +=
+          unprocessedItems.length -
+          (response.UnprocessedItems?.[tableNameInput]?.length || 0);
+
+        unprocessedItems = response.UnprocessedItems?.[tableNameInput] ?? [];
+
+        if (unprocessedItems.length > 0) {
+          console.log(
+            `Retrying unprocessed items: ${unprocessedItems.length}, attempt ${retryCount + 1}`,
+          );
+          batchWriteParams.RequestItems[tableNameInput] = unprocessedItems;
+          retryCount++;
+
+          // Add delay before the next retry
+          await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+        }
+      }
+
+      if (unprocessedItems.length > 0) {
+        console.error(
+          `Failed to delete ${unprocessedItems.length} items after ${MAX_RETRIES} retries.`,
+        );
+      }
+    } catch (error) {
+      console.error('Error in batch delete:', error);
+    }
+  }
+  return totalItemsDeleted;
+}

scripts/run-once-scripts/postgres-migration/delete-case-notes.ts

@@ -0,0 +1,60 @@
+/**
+ * HOW TO RUN
+ * npx ts-node --transpileOnly scripts/run-once-scripts/postgres-migration/delete-case-notes.ts
+ */
+
+import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { getDbReader } from '../../../web-api/src/database';
+import { isEmpty } from 'lodash';
+import { batchDeleteDynamoItems } from './batch-delete-dynamo-items';
+import { environment } from '../../../web-api/src/environment';
+
+const caseUserNotesPageSize = 10000;
+const dynamoDbClient = new DynamoDBClient({ region: 'us-east-1' });
+const dynamoDbDocClient = DynamoDBDocumentClient.from(dynamoDbClient);
+
+// We set the environment as 'production' (= "a deployed environment") to get the RDS connection to work properly
+environment.nodeEnv = 'production';
+
+const getCaseNotesToDelete = async (offset: number) => {
+  const caseNotes = await getDbReader(reader =>
+    reader
+      .selectFrom('dwUserCaseNote')
+      .select(['docketNumber', 'userId'])
+      .orderBy(['docketNumber', 'userId'])
+      .limit(caseUserNotesPageSize)
+      .offset(offset)
+      .execute(),
+  );
+  return caseNotes;
+};
+
+let totalItemsDeleted = 0;
+
+async function main() {
+  let offset = 0;
+  let caseNotesToDelete = await getCaseNotesToDelete(offset);
+
+  while (!isEmpty(caseNotesToDelete)) {
+    const dynamoItemsToDelete = caseNotesToDelete.map(c => ({
+      DeleteRequest: {
+        Key: {
+          pk: `user-case-note|${c.docketNumber}`,
+          sk: `user|${c.userId}`,
+        },
+      },
+    }));
+    totalItemsDeleted += await batchDeleteDynamoItems(
+      dynamoItemsToDelete,
+      dynamoDbDocClient,
+      environment.dynamoDbTableName,
+    );
+    console.log(`Total case notes deleted so far: ${totalItemsDeleted}`);
+    offset += caseUserNotesPageSize;
+    caseNotesToDelete = await getCaseNotesToDelete(offset);
+  }
+  console.log('Done deleting case notes from Dynamo');
+}
+
+main().catch(console.error);

scripts/run-once-scripts/delete-messages.ts → scripts/run-once-scripts/postgres-migration/delete-messages.ts

@@ -10,7 +10,7 @@ import {
   ScanCommand,
 } from '@aws-sdk/lib-dynamodb';
 import { DynamoDBClient, ScanCommandInput } from '@aws-sdk/client-dynamodb';
-import { requireEnvVars } from '../../shared/admin-tools/util';
+import { requireEnvVars } from '../../../shared/admin-tools/util';
 
 requireEnvVars(['TABLE_NAME']);
 

shared/src/business/entities/factories/UserFactory.test.ts

@@ -0,0 +1,36 @@
+import { Practitioner } from '@shared/business/entities/Practitioner';
+import { ROLES } from '@shared/business/entities/EntityConstants';
+import { User } from '@shared/business/entities/User';
+import { UserFactory } from '@shared/business/entities/factories/UserFactory';
+
+describe('UserFactory', () => {
+  describe('getClass', () => {
+    it('should return "Practitioner" class type if role is "privatePractitioner"', () => {
+      const TEST_USER = { role: ROLES.privatePractitioner };
+      const userFactory = new UserFactory(TEST_USER);
+      const classInstance = userFactory.getClass();
+      expect(classInstance).toEqual(Practitioner);
+    });
+
+    it('should return "Practitioner" class type if role is "irsPractitioner"', () => {
+      const TEST_USER = { role: ROLES.irsPractitioner };
+      const userFactory = new UserFactory(TEST_USER);
+      const classInstance = userFactory.getClass();
+      expect(classInstance).toEqual(Practitioner);
+    });
+
+    it('should return "Practitioner" class type if role is "inactivePractitioner"', () => {
+      const TEST_USER = { role: ROLES.inactivePractitioner };
+      const userFactory = new UserFactory(TEST_USER);
+      const classInstance = userFactory.getClass();
+      expect(classInstance).toEqual(Practitioner);
+    });
+
+    it('should return "User" class type if role is "admin"', () => {
+      const TEST_USER = { role: ROLES.admin };
+      const userFactory = new UserFactory(TEST_USER);
+      const classInstance = userFactory.getClass();
+      expect(classInstance).toEqual(User);
+    });
+  });
+});

shared/src/business/entities/factories/UserFactory.ts

@@ -0,0 +1,27 @@
+import { Practitioner } from '@shared/business/entities/Practitioner';
+import { ROLES, Role } from '@shared/business/entities/EntityConstants';
+import { User } from '@shared/business/entities/User';
+
+type MinimalFactoryInfo = {
+  role: Role;
+};
+
+export class UserFactory {
+  private rawUser: MinimalFactoryInfo;
+
+  constructor(rawUser: MinimalFactoryInfo) {
+    this.rawUser = rawUser;
+  }
+
+  public getClass(): typeof User | typeof Practitioner {
+    if (
+      this.rawUser.role === ROLES.privatePractitioner ||
+      this.rawUser.role === ROLES.irsPractitioner ||
+      this.rawUser.role === ROLES.inactivePractitioner
+    ) {
+      return Practitioner;
+    }
+
+    return User;
+  }
+}

shared/src/proxies/users/verifyUserPendingEmailProxy.ts

@@ -10,8 +10,8 @@ import { put } from '../requests';
  */
 export const verifyUserPendingEmailInteractor = (
   applicationContext,
-  { token },
-) => {
+  { token }: { token: string },
+): Promise<void> => {
   return put({
     applicationContext,
     body: {

types/TEntity.d.ts

@@ -27,12 +27,6 @@ type TPetitioner = {
   hasConsentedToEService?: boolean;
 };
 
-type TCaseNote = {
-  userId: string;
-  docketNumber: string;
-  notes: string;
-};
-
 interface IValidateRawCollection<I> {
   (collection: I[], options: { applicationContext: IApplicationContext }): I[];
 }

web-api/elasticsearch/efcms-case-mappings.ts

@@ -70,6 +70,9 @@ export const efcmsCaseMappings = {
     'indexedTimestamp.N': {
       type: 'text',
     },
+    'irsPractitioners.L.M.email.S': {
+      type: 'keyword',
+    },
     'irsPractitioners.L.M.userId.S': {
       type: 'keyword',
     },
@@ -89,6 +92,9 @@ export const efcmsCaseMappings = {
     'petitioners.L.M.countryType.S': {
       type: 'keyword',
     },
+    'petitioners.L.M.email.S': {
+      type: 'keyword',
+    },
     'petitioners.L.M.name.S': {
       type: 'text',
     },
@@ -104,6 +110,9 @@ export const efcmsCaseMappings = {
     'preferredTrialCity.S': {
       type: 'keyword',
     },
+    'privatePractitioners.L.M.email.S': {
+      type: 'keyword',
+    },
     'privatePractitioners.L.M.userId.S': {
       type: 'keyword',
     },

web-api/src/business/useCases/auth/changePasswordInteractor.test.ts

@@ -6,15 +6,18 @@ import {
   UserStatusType,
 } from '@aws-sdk/client-cognito-identity-provider';
 import { MESSAGE_TYPES } from '@web-api/gateways/worker/workerRouter';
-import { MOCK_PRACTITIONER } from '@shared/test/mockUsers';
+import { MOCK_PRACTITIONER, petitionerUser } from '@shared/test/mockUsers';
 import {
   ROLES,
   Role,
   SERVICE_INDICATOR_TYPES,
 } from '../../../../../shared/src/business/entities/EntityConstants';
 import { UserRecord } from '@web-api/persistence/dynamo/dynamoTypes';
 import { applicationContext } from '../../../../../shared/src/business/test/createTestApplicationContext';
-import { changePasswordInteractor } from './changePasswordInteractor';
+import {
+  changePasswordInteractor,
+  updateUserPendingEmailRecord,
+} from './changePasswordInteractor';
 import jwt from 'jsonwebtoken';
 
 describe('changePasswordInteractor', () => {
@@ -326,3 +329,45 @@ describe('changePasswordInteractor', () => {
     });
   });
 });
+
+describe('updateUserPendingEmailRecord', () => {
+  beforeEach(() => {
+    applicationContext
+      .getPersistenceGateway()
+      .updateUser.mockResolvedValue(null);
+  });
+
+  it('should set isUpdatingInformation to true if flag is enabled', async () => {
+    await updateUserPendingEmailRecord(applicationContext, {
+      setIsUpdatingInformation: true,
+      user: {
+        ...petitionerUser,
+        isUpdatingInformation: false,
+      },
+    });
+
+    const updateUserCalls =
+      applicationContext.getPersistenceGateway().updateUser.mock.calls;
+    expect(updateUserCalls.length).toEqual(1);
+    expect(updateUserCalls[0][0].user).toMatchObject({
+      isUpdatingInformation: true,
+    });
+  });
+
+  it('should not update isUpdatingInformation property when flag is disabled', async () => {
+    await updateUserPendingEmailRecord(applicationContext, {
+      setIsUpdatingInformation: false,
+      user: {
+        ...petitionerUser,
+        isUpdatingInformation: false,
+      },
+    });
+
+    const updateUserCalls =
+      applicationContext.getPersistenceGateway().updateUser.mock.calls;
+    expect(updateUserCalls.length).toEqual(1);
+    expect(updateUserCalls[0][0].user).toMatchObject({
+      isUpdatingInformation: false,
+    });
+  });
+});

web-api/src/business/useCases/auth/changePasswordInteractor.ts

@@ -123,7 +123,10 @@ export const changePasswordInteractor = async (
 
 export const updateUserPendingEmailRecord = async (
   applicationContext: ServerApplicationContext,
-  { user }: { user: RawUser },
+  {
+    setIsUpdatingInformation = false,
+    user,
+  }: { user: RawUser; setIsUpdatingInformation?: boolean },
 ): Promise<{ updatedUser: RawPractitioner | RawUser }> => {
   let userEntity;
 
@@ -150,6 +153,8 @@ export const updateUserPendingEmailRecord = async (
     });
   }
 
+  if (setIsUpdatingInformation) userEntity.isUpdatingInformation = true;
+
   const rawUser = userEntity.validate().toRawObject();
   await applicationContext.getPersistenceGateway().updateUser({
     applicationContext,

web-api/src/business/useCases/caseNote/deleteUserCaseNoteInteractor.test.ts

@@ -1,13 +1,17 @@
+import '@web-api/persistence/postgres/userCaseNotes/mocks.jest';
 import { ROLES } from '../../../../../shared/src/business/entities/EntityConstants';
 import { UnauthorizedError } from '@web-api/errors/errors';
 import { UnknownAuthUser } from '@shared/business/entities/authUser/AuthUser';
 import { User } from '../../../../../shared/src/business/entities/User';
 import { applicationContext } from '../../../../../shared/src/business/test/createTestApplicationContext';
 import { deleteUserCaseNoteInteractor } from './deleteUserCaseNoteInteractor';
+import { deleteUserCaseNote as deleteUserCaseNoteMock } from '@web-api/persistence/postgres/userCaseNotes/deleteUserCaseNote';
 import { mockJudgeUser } from '@shared/test/mockAuthUsers';
 import { omit } from 'lodash';
 
 describe('deleteUserCaseNoteInteractor', () => {
+  const deleteUserCaseNote = deleteUserCaseNoteMock as jest.Mock;
+
   it('throws an error if the user is not valid or authorized', async () => {
     let user = {} as UnknownAuthUser;
 
@@ -33,7 +37,7 @@ describe('deleteUserCaseNoteInteractor', () => {
     applicationContext
       .getPersistenceGateway()
       .getUserById.mockReturnValue(mockUser);
-    applicationContext.getPersistenceGateway().deleteUserCaseNote = v => v;
+    deleteUserCaseNote.mockImplementation(v => v);
     applicationContext
       .getUseCaseHelpers()
       .getJudgeInSectionHelper.mockReturnValue({
@@ -60,7 +64,6 @@ describe('deleteUserCaseNoteInteractor', () => {
     applicationContext
       .getPersistenceGateway()
       .getUserById.mockReturnValue(mockUser);
-    applicationContext.getPersistenceGateway().deleteUserCaseNote = jest.fn();
     applicationContext
       .getUseCaseHelpers()
       .getJudgeInSectionHelper.mockReturnValue(null);
@@ -72,9 +75,8 @@ describe('deleteUserCaseNoteInteractor', () => {
       omit(mockUser, 'section'),
     );
 
-    expect(
-      applicationContext.getPersistenceGateway().deleteUserCaseNote.mock
-        .calls[0][0].userId,
-    ).toEqual(mockJudgeUser.userId);
+    expect(deleteUserCaseNote.mock.calls[0][0].userId).toEqual(
+      mockJudgeUser.userId,
+    );
   });
 });