Assign directors as members if needed when the project's region is assigned

Author: CarsonF

src/components/project/project-member/handlers/project-region-defaults-director-membership.handler.ts

@@ -0,0 +1,42 @@
+import { ResourceLoader } from '~/core';
+import { EventsHandler } from '~/core/events';
+import { ProjectUpdatedEvent } from '../../events';
+import { ProjectMemberRepository } from '../project-member.repository';
+
+@EventsHandler(ProjectUpdatedEvent)
+export class ProjectRegionDefaultsDirectorMembershipHandler {
+  constructor(
+    private readonly repo: ProjectMemberRepository,
+    private readonly resources: ResourceLoader,
+  ) {}
+
+  async handle(event: ProjectUpdatedEvent) {
+    const { fieldRegionId } = event.changes;
+    if (!fieldRegionId) {
+      return;
+    }
+
+    const fieldRegion = await this.resources.load('FieldRegion', fieldRegionId);
+    if (fieldRegion.director.value) {
+      await this.repo.addDefaultForRole(
+        'RegionalDirector',
+        event.updated.id,
+        fieldRegion.director.value.id,
+      );
+    }
+
+    if (fieldRegion.fieldZone.value) {
+      const fieldZone = await this.resources.load(
+        'FieldZone',
+        fieldRegion.fieldZone.value.id,
+      );
+      if (fieldZone.director.value) {
+        await this.repo.addDefaultForRole(
+          'FieldOperationsDirector',
+          event.updated.id,
+          fieldZone.director.value.id,
+        );
+      }
+    }
+  }
+}

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

@@ -73,6 +73,54 @@ export class ProjectMemberGelRepository
     ];
   }
 
+  async addDefaultForRole(
+    role: Role,
+    project: ID<'Project'>,
+    user: ID<'User'>,
+  ) {
+    await this.db.run(this.addDefaultForRoleQuery, {
+      role,
+      project,
+      user,
+    });
+  }
+  private readonly addDefaultForRoleQuery = e.params(
+    {
+      role: e.Role,
+      project: e.uuid,
+      user: e.uuid,
+    },
+    ($) => {
+      const project = e.cast(e.Project, $.project);
+      const user = e.cast(e.User, $.user);
+
+      const membersWithRole = e.select(project.members, (member) => ({
+        filter: e.all(
+          e.set(
+            e.op(member.active, '=', true),
+            e.op($.role, 'in', member.roles),
+          ),
+        ),
+      }));
+      const hasMemberWithRole = e.op('exists', membersWithRole);
+      const createNew = e.insert(e.Project.Member, {
+        project,
+        projectContext: project.projectContext,
+        user,
+        roles: $.role,
+      });
+      const exp = e.op(
+        'if',
+        hasMemberWithRole,
+        'then',
+        membersWithRole,
+        'else',
+        createNew,
+      );
+      return e.select(exp);
+    },
+  );
+
   async replaceMembershipsOnOpenProjects(
     oldDirector: ID<'User'>,
     newDirector: ID<'User'>,

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

@@ -5,6 +5,7 @@ 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 { ProjectRegionDefaultsDirectorMembershipHandler } from './handlers/project-region-defaults-director-membership.handler';
 import { RegionsZoneChangesAppliesDirectorChangeToProjectMembersHandler } from './handlers/regions-zone-changes-applies-director-change-to-project-members.handler';
 import { AddInactiveAtMigration } from './migrations/add-inactive-at.migration';
 import { ProjectMemberGelRepository } from './project-member.gel.repository';
@@ -28,6 +29,7 @@ import { ProjectMemberService } from './project-member.service';
     AddInactiveAtMigration,
     DirectorChangeApplyToProjectMembersHandler,
     RegionsZoneChangesAppliesDirectorChangeToProjectMembersHandler,
+    ProjectRegionDefaultsDirectorMembershipHandler,
   ],
   exports: [ProjectMemberService],
 })

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

@@ -32,6 +32,7 @@ import {
   sorting,
   updateProperty,
   variable,
+  Variable,
 } from '~/core/database/query';
 import { type FilterFn } from '~/core/database/query/filters';
 import { conditionalOn } from '~/core/database/query/properties/update-property';
@@ -202,6 +203,41 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
       .run();
   }
 
+  async addDefaultForRole(
+    role: Role,
+    project: ID<'Project'>,
+    user: ID<'User'>,
+  ) {
+    const now = DateTime.now();
+    await this.db
+      .query()
+      .apply((q) => {
+        q.params.addParam(now, 'now');
+      })
+      .match(node('project', 'Project', { id: project }))
+      .subQuery('project', (sub) =>
+        sub
+          .match([
+            node('project'),
+            relation('out', '', 'member', ACTIVE),
+            node('node', 'ProjectMember'),
+          ])
+          .apply(
+            projectMemberFilters({
+              active: true,
+              roles: [role],
+            }),
+          )
+          .with('count(node) as members')
+          .raw('WHERE members = 0')
+          .return('true as filtered'),
+      )
+      .with('*')
+      .apply(await this.upsertMember(user, role))
+      .return<{ id: ID<'ProjectMember'> }>('project.id as id')
+      .executeAndLogStats();
+  }
+
   async replaceMembershipsOnOpenProjects(
     oldDirector: ID<'User'>,
     newDirector: ID<'User'>,
@@ -211,20 +247,11 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
   ) {
     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 })
+      .apply((q) => {
+        q.params.addParam(nowVal, 'now');
+      })
       .match([
         node('project', 'Project'),
         relation('out', '', 'member', ACTIVE),
@@ -282,15 +309,39 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
           )
           .return('stats as oldMemberStats'),
       )
-      .subQuery('project', (sub) =>
+      .with('project')
+      .apply(await this.upsertMember(newDirector, role))
+      .return<{ id: ID }>('project.id as id')
+      .run();
+    return {
+      projects: result.map(({ id }) => id) as readonly ID[],
+      timestampId: nowVal,
+    };
+  }
+
+  protected async upsertMember(user: ID<'User'> | Variable, role: Role) {
+    const now = variable('$now');
+    const createMember = await createNode(ProjectMember, {
+      baseNodeProps: {
+        id: variable(randomUUID()),
+        createdAt: now,
+      },
+      initialProps: {
+        roles: [role],
+        inactiveAt: null,
+        modifiedAt: now,
+      },
+    });
+    return (query: Query) =>
+      query.subQuery('project', (sub) =>
         sub
           .match([
             [
               node('project'),
               relation('out', '', 'member', ACTIVE),
               node('node', 'ProjectMember'),
               relation('out', '', 'user', ACTIVE),
-              node('', 'User', { id: newDirector }),
+              node('', 'User', { id: user }),
             ],
             [
               node('node', 'ProjectMember'),
@@ -339,25 +390,19 @@ export class ProjectMemberRepository extends DtoRepository(ProjectMember) {
                 relation('out', '', 'member', ACTIVE),
                 node('', 'ProjectMember'),
                 relation('out', '', 'user', ACTIVE),
-                node('', 'User', { id: newDirector }),
+                node('', 'User', { id: user }),
               ]),
             ),
           )
           .apply(createMember)
           .apply(
             createRelationships(ProjectMember, {
               in: { member: variable('project') },
-              out: { user: ['User', newDirector] },
+              out: { user: user instanceof Variable ? user : ['User', user] },
             }),
           )
           .return('node as member'),
-      )
-      .return<{ id: ID }>('project.id as id')
-      .run();
-    return {
-      projects: result.map(({ id }) => id) as readonly ID[],
-      timestampId: nowVal,
-    };
+      );
   }
 }