Migrate handlers ProjectUpdatedEvent -> ProjectTransitionedEvent (#3254)

Author: CarsonF

src/components/budget/handlers/update-project-current-budget-status.handler.ts

@@ -1,58 +1,51 @@
 import { EventsHandler, IEventHandler } from '~/core';
 import { ProjectStatus, stepToStatus } from '../../project/dto';
-import { ProjectUpdatedEvent } from '../../project/events';
+import { ProjectTransitionedEvent } from '../../project/workflow/events/project-transitioned.event';
 import { BudgetService } from '../budget.service';
 import { BudgetStatus } from '../dto';
 
-@EventsHandler(ProjectUpdatedEvent)
+@EventsHandler(ProjectTransitionedEvent)
 export class UpdateProjectBudgetStatusHandler
-  implements IEventHandler<ProjectUpdatedEvent>
+  implements IEventHandler<ProjectTransitionedEvent>
 {
   constructor(private readonly budgets: BudgetService) {}
 
-  async handle({ previous, updates, session }: ProjectUpdatedEvent) {
-    // Continue if project just became active
-    if (!updates.step) {
-      return;
-    }
-    let budgetStatus: BudgetStatus = BudgetStatus.Current;
+  async handle(event: ProjectTransitionedEvent) {
+    const { project, session } = event;
+
+    const prevStatus = stepToStatus(event.previousStep);
+    const nextStatus = stepToStatus(event.workflowEvent.to);
+
+    let change: [from: BudgetStatus, to: BudgetStatus] | undefined;
     if (
-      stepToStatus(updates.step) !== ProjectStatus.Active ||
-      previous.status === ProjectStatus.Active
+      prevStatus === ProjectStatus.InDevelopment &&
+      nextStatus === ProjectStatus.Active
     ) {
-      // If Project status became In Dev from Active
-      if (
-        previous.status === ProjectStatus.Active &&
-        stepToStatus(updates.step) === ProjectStatus.InDevelopment
-      ) {
-        budgetStatus = BudgetStatus.Pending;
-      } else {
-        return;
-      }
+      change = [BudgetStatus.Pending, BudgetStatus.Current];
+    } else if (
+      prevStatus === ProjectStatus.Active &&
+      nextStatus === ProjectStatus.InDevelopment
+    ) {
+      change = [BudgetStatus.Current, BudgetStatus.Pending];
+    }
+    if (!change) {
+      return;
     }
 
     const budgets = await this.budgets.list(
       {
         filter: {
-          projectId: previous.id,
+          projectId: project.id,
         },
       },
       session,
     );
 
-    const budget = budgets.items.find(
-      (b) =>
-        b.status ===
-        (budgetStatus === BudgetStatus.Current
-          ? BudgetStatus.Pending
-          : BudgetStatus.Current),
-    );
+    const budget = budgets.items.find((b) => b.status === change![0]);
     if (!budget) {
-      // no pending or current budget, nothing to do
       return;
     }
 
-    // Set pending budget to current, now that the project is active
-    await this.budgets.update({ id: budget.id, status: budgetStatus }, session);
+    await this.budgets.update({ id: budget.id, status: change[1] }, session);
   }
 }

src/components/engagement/handlers/index.ts

@@ -1,4 +1,4 @@
 export * from './set-initial-end-date.handler';
-export * from './update-project-status.handler';
+export * from './update-engagement-status.handler';
 export * from './set-last-status-date.handler';
 export * from './apply-finalized-changeset-to-engagement.handler';

src/components/engagement/handlers/update-project-status.handler.ts renamed to src/components/engagement/handlers/update-engagement-status.handler.ts

@@ -6,8 +6,9 @@ import {
   ProjectStatus,
   ProjectStep,
   ProjectType,
+  stepToStatus,
 } from '../../project/dto';
-import { ProjectUpdatedEvent } from '../../project/events';
+import { ProjectTransitionedEvent } from '../../project/workflow/events/project-transitioned.event';
 import { EngagementStatus } from '../dto';
 import { EngagementRepository } from '../engagement.repository';
 import { EngagementService } from '../engagement.service';
@@ -72,39 +73,53 @@ type Condition = MergeExclusive<
   { step: ProjectStep }
 >;
 
-const changeMatcher =
-  (previous: UnsecuredDto<Project>, updated: UnsecuredDto<Project>) =>
-  ({ from, to }: Change) => {
+type ProjectState = Pick<UnsecuredDto<Project>, 'status' | 'step'>;
+const changeMatcher = (previousStep: ProjectStep, updatedStep: ProjectStep) => {
+  const previous: ProjectState = {
+    step: previousStep,
+    status: stepToStatus(previousStep),
+  };
+  const updated: ProjectState = {
+    step: updatedStep,
+    status: stepToStatus(updatedStep),
+  };
+  return ({ from, to }: Change) => {
     const toMatches = to ? matches(to, updated) : !matches(from!, updated);
     const fromMatches = from
       ? matches(from, previous)
       : !matches(to!, previous);
     return toMatches && fromMatches;
   };
-const matches = (cond: Condition, p: UnsecuredDto<Project>) =>
+};
+const matches = (cond: Condition, p: ProjectState) =>
   cond.step ? cond.step === p.step : cond.status === p.status;
 
-@EventsHandler(ProjectUpdatedEvent)
-export class UpdateProjectStatusHandler
-  implements IEventHandler<ProjectUpdatedEvent>
+@EventsHandler(ProjectTransitionedEvent)
+export class UpdateEngagementStatusHandler
+  implements IEventHandler<ProjectTransitionedEvent>
 {
   constructor(
     private readonly repo: EngagementRepository,
     private readonly engagementService: EngagementService,
   ) {}
 
-  async handle({ previous, updated, session }: ProjectUpdatedEvent) {
+  async handle({
+    project,
+    previousStep,
+    workflowEvent,
+    session,
+  }: ProjectTransitionedEvent) {
     const engagementStatus = changes.find(
-      changeMatcher(previous, updated),
+      changeMatcher(previousStep, workflowEvent.to),
     )?.newStatus;
     if (!engagementStatus) return;
 
-    const engagementIds = await this.repo.getOngoingEngagementIds(updated.id);
+    const engagementIds = await this.repo.getOngoingEngagementIds(project.id);
 
     await this.updateEngagements(
       engagementStatus,
       engagementIds,
-      updated.type,
+      project.type,
       session,
     );
   }

src/components/project/handlers/index.ts

@@ -1,4 +1,3 @@
 export * from './set-department-id.handler';
 export * from './set-initial-mou-end.handler';
-export * from './set-step-changed-at.handler';
 export * from './apply-finalized-changeset-to-project.handler';

src/components/project/handlers/set-department-id.handler.ts

@@ -1,12 +1,18 @@
 import { ClientException, ID, ServerException, UnsecuredDto } from '~/common';
 import { ConfigService, EventsHandler, IEventHandler } from '~/core';
 import { DatabaseService } from '~/core/database';
-import { Project, ProjectStep, ProjectType } from '../dto';
-import { ProjectUpdatedEvent } from '../events';
+import {
+  Project,
+  ProjectStatus,
+  ProjectStep,
+  ProjectType,
+  stepToStatus,
+} from '../dto';
+import { ProjectTransitionedEvent } from '../workflow/events/project-transitioned.event';
 
-type SubscribedEvent = ProjectUpdatedEvent;
+type SubscribedEvent = ProjectTransitionedEvent;
 
-@EventsHandler(ProjectUpdatedEvent)
+@EventsHandler(ProjectTransitionedEvent)
 export class SetDepartmentId implements IEventHandler<SubscribedEvent> {
   constructor(
     private readonly db: DatabaseService,
@@ -18,23 +24,33 @@ export class SetDepartmentId implements IEventHandler<SubscribedEvent> {
       return;
     }
 
+    const step = event.workflowEvent.to;
+    const status = stepToStatus(step);
+
     const shouldSetDepartmentId =
-      event.updates.step === ProjectStep.PendingFinanceConfirmation &&
-      !event.updated.departmentId;
+      !event.project.departmentId &&
+      ProjectStatus.entries.findIndex((s) => s.value === status) <=
+        ProjectStatus.entries.findIndex(
+          (s) => s.value === ProjectStatus.Active,
+        ) &&
+      ProjectStep.entries.findIndex((s) => s.value === step) >=
+        ProjectStep.entries.findIndex(
+          (s) => s.value === ProjectStep.PendingFinanceConfirmation,
+        );
     if (!shouldSetDepartmentId) {
       return;
     }
 
-    if (!event.updated.primaryLocation) {
+    if (!event.project.primaryLocation) {
       throw new ClientException('Primary Location on project must be set');
     }
 
     try {
       const departmentId = await this.assignDepartmentIdForProject(
-        event.updated,
+        event.project,
       );
-      event.updated = {
-        ...event.updated,
+      event.project = {
+        ...event.project,
         departmentId,
       };
     } catch (exception) {

src/components/project/handlers/set-initial-mou-end.handler.ts

@@ -2,11 +2,12 @@ import { ServerException } from '~/common';
 import { EventsHandler, IEventHandler, ILogger, Logger } from '~/core';
 import { DatabaseService } from '~/core/database';
 import { IProject, ProjectStatus } from '../dto';
-import { ProjectCreatedEvent, ProjectUpdatedEvent } from '../events';
+import { ProjectCreatedEvent } from '../events';
+import { ProjectTransitionedEvent } from '../workflow/events/project-transitioned.event';
 
-type SubscribedEvent = ProjectCreatedEvent | ProjectUpdatedEvent;
+type SubscribedEvent = ProjectCreatedEvent | ProjectTransitionedEvent;
 
-@EventsHandler(ProjectCreatedEvent, ProjectUpdatedEvent)
+@EventsHandler(ProjectCreatedEvent, ProjectTransitionedEvent)
 export class SetInitialMouEnd implements IEventHandler<SubscribedEvent> {
   constructor(
     private readonly db: DatabaseService,
@@ -19,10 +20,10 @@ export class SetInitialMouEnd implements IEventHandler<SubscribedEvent> {
       event: event.constructor.name,
     });
 
-    const project = 'project' in event ? event.project : event.updated;
+    const { project } = event;
 
     if (
-      event instanceof ProjectUpdatedEvent && // allow setting initial if creating with non-in-dev status
+      event instanceof ProjectTransitionedEvent && // allow setting initial if creating with non-in-dev status
       project.status !== ProjectStatus.InDevelopment
     ) {
       return;
@@ -40,8 +41,8 @@ export class SetInitialMouEnd implements IEventHandler<SubscribedEvent> {
         },
       });
 
-      if (event instanceof ProjectUpdatedEvent) {
-        event.updated = updatedProject;
+      if (event instanceof ProjectTransitionedEvent) {
+        event.project = updatedProject;
       } else {
         event.project = updatedProject;
       }

src/components/project/handlers/set-step-changed-at.handler.ts

@@ -1,13 +1,14 @@
-import type { UnsecuredDto } from '~/common';
+import type { Session, UnsecuredDto } from '~/common';
 import type { Project, ProjectStep } from '../../dto';
 import type { ProjectWorkflowEvent as WorkflowEvent } from '../dto';
 import type { ProjectWorkflow } from '../project-workflow';
 
 export class ProjectTransitionedEvent {
   constructor(
-    readonly project: Project,
+    public project: UnsecuredDto<Project>,
     readonly previousStep: ProjectStep,
     readonly next: (typeof ProjectWorkflow)['resolvedTransition'] | ProjectStep,
     readonly workflowEvent: UnsecuredDto<WorkflowEvent>,
+    readonly session: Session,
   ) {}
 }