Merge pull request #3447 from SeedCompany/director-change-members

Author: CarsonF

src/components/field-region/events/field-region-updated.event.ts

@@ -3,8 +3,8 @@ import { type FieldRegion, type UpdateFieldRegion } from '../dto';
 
 export class FieldRegionUpdatedEvent {
   constructor(
-    readonly updated: UnsecuredDto<FieldRegion>,
     readonly previous: UnsecuredDto<FieldRegion>,
+    readonly updated: UnsecuredDto<FieldRegion>,
     readonly input: UpdateFieldRegion,
   ) {}
 }

src/components/field-zone/events/field-zone-updated.event.ts

@@ -3,8 +3,8 @@ import { type FieldZone, type UpdateFieldZone } from '../dto';
 
 export class FieldZoneUpdatedEvent {
   constructor(
-    readonly updated: UnsecuredDto<FieldZone>,
     readonly previous: UnsecuredDto<FieldZone>,
+    readonly updated: UnsecuredDto<FieldZone>,
     readonly input: UpdateFieldZone,
   ) {}
 }

src/components/project/project-member/handlers/director-change-apply-to-project-members.handler.ts

@@ -0,0 +1,40 @@
+import { type Role } from '~/common';
+import { EventsHandler } from '~/core/events';
+import { ILogger, Logger } from '~/core/logger';
+import { FieldRegionUpdatedEvent } from '../../../field-region/events/field-region-updated.event';
+import { FieldZoneUpdatedEvent } from '../../../field-zone/events/field-zone-updated.event';
+import { ProjectMemberRepository } from '../project-member.repository';
+
+@EventsHandler(FieldZoneUpdatedEvent, FieldRegionUpdatedEvent)
+export class DirectorChangeApplyToProjectMembersHandler {
+  constructor(
+    private readonly repo: ProjectMemberRepository,
+    @Logger('project:members') private readonly logger: ILogger,
+  ) {}
+
+  async handle(event: FieldZoneUpdatedEvent | FieldRegionUpdatedEvent) {
+    const oldDirector = event.previous.director.id;
+    const newDirector = event.input.directorId;
+    if (!newDirector) {
+      return;
+    }
+    const role: Role =
+      event instanceof FieldZoneUpdatedEvent
+        ? 'FieldOperationsDirector'
+        : 'RegionalDirector';
+
+    const stats = await this.repo.replaceMembershipsOnOpenProjects(
+      oldDirector,
+      newDirector,
+      role,
+    );
+
+    this.logger.notice('Replaced director memberships on open projects', {
+      location: event.updated.id,
+      oldDirector,
+      newDirector,
+      role,
+      ...stats,
+    });
+  }
+}

src/components/project/project-member/project-member.gel.repository.ts

@@ -72,4 +72,65 @@ export class ProjectMemberGelRepository
         ),
     ];
   }
+
+  async replaceMembershipsOnOpenProjects(
+    oldDirector: ID<'User'>,
+    newDirector: ID<'User'>,
+    role: Role,
+  ) {
+    return await this.db.run(this.replaceMembershipsOnOpenProjectsQuery, {
+      oldDirector,
+      newDirector,
+      role,
+    });
+  }
+  private readonly replaceMembershipsOnOpenProjectsQuery = e.params(
+    {
+      oldDirector: e.uuid,
+      newDirector: e.uuid,
+      role: e.Role,
+    },
+    ($) => {
+      const oldDirector = e.cast(e.User, $.oldDirector);
+      const newDirector = e.cast(e.User, $.newDirector);
+
+      const members = e.select(e.Project.members, (member) => ({
+        filter: e.all(
+          e.set(
+            e.op(member.user, '=', oldDirector),
+            e.op(member.active, '=', true),
+            e.op($.role, 'in', member.roles),
+            e.op(member.project.status, 'in', e.set('Active', 'InDevelopment')),
+          ),
+        ),
+      }));
+      const inactivated = e.update(members, () => ({
+        set: {
+          inactiveAt: e.datetime_of_transaction(),
+        },
+      }));
+      const replacements = e.for(inactivated.project, (project) =>
+        e
+          .insert(e.Project.Member, {
+            project,
+            projectContext: project.projectContext,
+            user: newDirector,
+            roles: $.role,
+          })
+          .unlessConflict((member) => ({
+            on: member.user,
+            else: e.update(member, () => ({
+              set: {
+                roles: { '+=': $.role },
+                inactiveAt: null,
+              },
+            })),
+          })),
+      );
+      return e.select({
+        timestampId: e.datetime_of_transaction(),
+        projects: replacements.project.id,
+      });
+    },
+  );
 }

src/components/project/project-member/project-member.module.ts

@@ -4,6 +4,7 @@ import { AuthorizationModule } from '../../authorization/authorization.module';
 import { UserModule } from '../../user/user.module';
 import { ProjectModule } from '../project.module';
 import { AvailableRolesToProjectResolver } from './available-roles-to-project.resolver';
+import { DirectorChangeApplyToProjectMembersHandler } from './handlers/director-change-apply-to-project-members.handler';
 import { AddInactiveAtMigration } from './migrations/add-inactive-at.migration';
 import { ProjectMemberGelRepository } from './project-member.gel.repository';
 import { ProjectMemberLoader } from './project-member.loader';
@@ -24,6 +25,7 @@ import { ProjectMemberService } from './project-member.service';
     splitDb(ProjectMemberRepository, ProjectMemberGelRepository),
     ProjectMemberLoader,
     AddInactiveAtMigration,
+    DirectorChangeApplyToProjectMembersHandler,
   ],
   exports: [ProjectMemberService],
 })

src/components/project/project-member/project-member.repository.ts

@@ -1,5 +1,11 @@
 import { Injectable } from '@nestjs/common';
-import { type Node, node, type Query, relation } from 'cypher-query-builder';
+import {
+  type Node,
+  node,
+  not,
+  type Query,
+  relation,
+} from 'cypher-query-builder';
 import { DateTime } from 'luxon';
 import {
   CreationFailed,
@@ -13,14 +19,19 @@ import {
 import { DtoRepository } from '~/core/database';
 import {
   ACTIVE,
+  apoc,
   createNode,
   createRelationships,
   filter,
   matchPropsAndProjectSensAndScopedRoles,
   merge,
   oncePerProject,
   paginate,
+  path,
+  randomUUID,
   sorting,
+  updateProperty,
+  variable,
 } from '~/core/database/query';
 import { type FilterFn } from '~/core/database/query/filters';
 import { userFilters, UserRepository } from '../../user/user.repository';
@@ -183,6 +194,127 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
       ])
       .run();
   }
+
+  async replaceMembershipsOnOpenProjects(
+    oldDirector: ID<'User'>,
+    newDirector: ID<'User'>,
+    role: Role,
+  ) {
+    const nowVal = DateTime.now();
+    const now = variable('$now');
+    const createMember = await createNode(ProjectMember, {
+      baseNodeProps: {
+        id: variable(randomUUID()),
+        createdAt: now,
+      },
+      initialProps: {
+        roles: [role],
+        inactiveAt: null,
+        modifiedAt: now,
+      },
+    });
+    const result = await this.db
+      .query()
+      .raw('', { now: nowVal })
+      .match([
+        node('project', 'Project'),
+        relation('out', '', 'member', ACTIVE),
+        node('node', 'ProjectMember'),
+      ])
+      .apply(
+        projectMemberFilters({
+          user: { id: oldDirector },
+          active: true,
+          roles: [role],
+          project: { status: ['Active', 'InDevelopment'] },
+        }),
+      )
+      .apply(
+        updateProperty({
+          resource: ProjectMember,
+          key: 'inactiveAt',
+          value: now,
+          permanentAfter: 0,
+        }),
+      )
+      .with('project')
+      .subQuery('project', (sub) =>
+        sub
+          .match([
+            [
+              node('project'),
+              relation('out', '', 'member', ACTIVE),
+              node('node', 'ProjectMember'),
+              relation('out', '', 'user', ACTIVE),
+              node('', 'User', { id: newDirector }),
+            ],
+            [
+              node('node', 'ProjectMember'),
+              relation('out', '', 'roles', ACTIVE),
+              node('roles', 'Property'),
+            ],
+          ])
+          .apply(
+            updateProperty({
+              resource: ProjectMember,
+              key: 'roles',
+              value: variable(apoc.coll.union('roles.value', [`"${role}"`])),
+              now,
+              permanentAfter: 0,
+              outputStatsVar: 'inactiveStats',
+            }),
+          )
+          .apply(
+            updateProperty({
+              resource: ProjectMember,
+              key: 'inactiveAt',
+              value: null,
+              now,
+              permanentAfter: 0,
+              outputStatsVar: 'rolesStats',
+            }),
+          )
+          .apply(
+            updateProperty({
+              resource: ProjectMember,
+              key: 'modifiedAt',
+              value: now,
+              now,
+              permanentAfter: 0,
+              outputStatsVar: 'modifiedAtStats',
+            }),
+          )
+          .return('node as member')
+          .union()
+          .with('project')
+          .with('project')
+          .where(
+            not(
+              path([
+                node('project'),
+                relation('out', '', 'member', ACTIVE),
+                node('', 'ProjectMember'),
+                relation('out', '', 'user', ACTIVE),
+                node('', 'User', { id: newDirector }),
+              ]),
+            ),
+          )
+          .apply(createMember)
+          .apply(
+            createRelationships(ProjectMember, {
+              in: { member: variable('project') },
+              out: { user: ['User', newDirector] },
+            }),
+          )
+          .return('node as member'),
+      )
+      .return<{ id: ID }>('project.id as id')
+      .run();
+    return {
+      projects: result.map(({ id }) => id) as readonly ID[],
+      timestampId: nowVal,
+    };
+  }
 }
 
 export const projectMemberFilters = filter.define(() => ProjectMemberFilters, {

src/core/database/query-augmentation/subquery.ts

@@ -69,4 +69,4 @@ class SubQueryClause extends SubClauseCollection {
 export const varInExp = (variable: string | Variable) =>
   variable.toString().startsWith('$')
     ? ''
-    : /(?:.+\()?([^.]+)\.?.*/.exec(variable.toString())?.[1] ?? '';
+    : /(?:.+\()?\)?([^.]*)\.?.*/.exec(variable.toString())?.[1] ?? '';

src/core/database/query/cypher-functions.ts

@@ -16,6 +16,10 @@ const fn =
 /** Create a function with a name that takes a single argument */
 const fn1 = (name: string) => (arg: ExpressionInput) => fn(name)(arg);
 
+/** Create a function with a name that takes two arguments */
+const fn2 = (name: string) => (arg1: ExpressionInput, arg2: ExpressionInput) =>
+  fn(name)(arg1, arg2);
+
 const fn0 = (name: string) => () => fn(name)();
 
 /**
@@ -78,6 +82,11 @@ export const apoc = {
   coll: {
     flatten: fn1('apoc.coll.flatten'),
     indexOf: fn('apoc.coll.indexOf'),
+    /**
+     * Returns the distinct union of the two given LIST<ANY> values.
+     * @see https://neo4j.com/docs/apoc/current/overview/apoc.coll/apoc.coll.union/
+     */
+    union: fn2('apoc.coll.union'),
   },
   convert: {
     /** Converts Neo4j node to object/map of the node's properties */

src/core/database/query/properties/update-properties.ts

@@ -7,7 +7,7 @@ import {
   type ResourceShape,
 } from '~/common';
 import { type DbChanges } from '../../changes';
-import { apoc, collect, merge, type Variable, variable } from '../index';
+import { apoc, collect, merge, Variable, variable } from '../index';
 import { type PropUpdateStat, updateProperty } from './update-property';
 
 export interface UpdatePropertiesOptions<
@@ -21,6 +21,7 @@ export interface UpdatePropertiesOptions<
   changeset?: Variable;
   nodeName?: string;
   outputStatsVar?: string;
+  now?: DateTime | Variable;
 }
 
 export const updateProperties =
@@ -35,6 +36,7 @@ export const updateProperties =
     changeset,
     nodeName = 'node',
     outputStatsVar = 'stats',
+    now,
   }: UpdatePropertiesOptions<TResourceStatic, TObject>) =>
   <R>(query: Query<R>) => {
     const resource = EnhancedResource.of(resourceIn);
@@ -61,7 +63,10 @@ export const updateProperties =
               labels: variable('prop.labels'),
               changeset,
               nodeName,
-              now: query.params.addParam(DateTime.local(), 'now'),
+              now:
+                now instanceof Variable
+                  ? now
+                  : query.params.addParam(now ?? DateTime.local(), 'now'),
             }),
           )
           .return<{