Refactor EngagementService

Move constraints & separate reads/writes into neo4j repo.
Make `secure` sync.
Remove unnecessary logs & try/catches & comments.

Co-authored-by: Bryan Nelson <[email protected]>

Author: CarsonF

src/components/engagement/engagement.repository.ts

@@ -12,8 +12,10 @@ import { difference, pickBy, upperFirst } from 'lodash';
 import { DateTime } from 'luxon';
 import { MergeExclusive } from 'type-fest';
 import {
+  DuplicateException,
   generateId,
   ID,
+  InputException,
   labelForView,
   NotFoundException,
   ObjectView,
@@ -24,7 +26,7 @@ import {
   viewOfChangeset,
 } from '~/common';
 import { CommonRepository, OnIndex } from '~/core/database';
-import { ChangesOf, getChanges } from '~/core/database/changes';
+import { getChanges } from '~/core/database/changes';
 import {
   ACTIVE,
   coalesce,
@@ -46,11 +48,13 @@ import {
   whereNotDeletedInChangeset,
 } from '~/core/database/query';
 import { Privileges } from '../authorization';
+import { FileService } from '../file';
 import { FileId } from '../file/dto';
 import {
   languageFilters,
   languageSorters,
 } from '../language/language.repository';
+import { Location } from '../location/dto';
 import {
   matchCurrentDue,
   progressReportSorters,
@@ -59,6 +63,7 @@ import { ProjectType } from '../project/dto';
 import { projectFilters } from '../project/project-filters.query';
 import { projectSorters } from '../project/project.repository';
 import { userFilters } from '../user';
+import { User } from '../user/dto';
 import {
   CreateInternshipEngagement,
   CreateLanguageEngagement,
@@ -80,7 +85,10 @@ export type LanguageOrEngagementId = MergeExclusive<
 
 @Injectable()
 export class EngagementRepository extends CommonRepository {
-  constructor(private readonly privileges: Privileges) {
+  constructor(
+    private readonly privileges: Privileges,
+    private readonly files: FileService,
+  ) {
     super();
   }
 
@@ -192,10 +200,9 @@ export class EngagementRepository extends CommonRepository {
         );
   }
 
-  // CREATE ///////////////////////////////////////////////////////////
-
   async createLanguageEngagement(
     input: CreateLanguageEngagement,
+    session: Session,
     changeset?: ID,
   ) {
     const pnpId = await generateId<FileId>();
@@ -219,6 +226,17 @@ export class EngagementRepository extends CommonRepository {
       canDelete: true,
     };
 
+    await this.verifyRelationshipEligibility(
+      projectId,
+      languageId,
+      false,
+      changeset,
+    );
+
+    if (input.firstScripture) {
+      await this.verifyFirstScripture({ languageId });
+    }
+
     const query = this.db
       .query()
       .apply(await createNode(LanguageEngagement, { initialProps }))
@@ -238,11 +256,26 @@ export class EngagementRepository extends CommonRepository {
       throw new ServerException('Could not create Language Engagement');
     }
 
-    return { id: result.id, pnpId };
+    await this.files.createDefinedFile(
+      pnpId,
+      `PNP`,
+      session,
+      result.id,
+      'pnp',
+      input.pnp,
+      'engagement.pnp',
+    );
+
+    return (await this.readOne(
+      result.id,
+      session,
+      viewOfChangeset(changeset),
+    )) as UnsecuredDto<LanguageEngagement>;
   }
 
   async createInternshipEngagement(
     input: CreateInternshipEngagement,
+    session: Session,
     changeset?: ID,
   ) {
     const growthPlanId = await generateId<FileId>();
@@ -268,6 +301,13 @@ export class EngagementRepository extends CommonRepository {
       canDelete: true,
     };
 
+    await this.verifyRelationshipEligibility(
+      projectId,
+      internId,
+      true,
+      changeset,
+    );
+
     const query = this.db
       .query()
       .apply(await createNode(InternshipEngagement, { initialProps }))
@@ -287,67 +327,124 @@ export class EngagementRepository extends CommonRepository {
       .return<{ id: ID }>('node.id as id');
     const result = await query.first();
     if (!result) {
-      throw new NotFoundException();
+      if (mentorId && !(await this.getBaseNode(mentorId, User))) {
+        throw new NotFoundException(
+          'Could not find mentor',
+          'engagement.mentorId',
+        );
+      }
+
+      if (
+        countryOfOriginId &&
+        !(await this.getBaseNode(countryOfOriginId, Location))
+      ) {
+        throw new NotFoundException(
+          'Could not find country of origin',
+          'engagement.countryOfOriginId',
+        );
+      }
+
+      throw new ServerException('Could not create Internship Engagement');
     }
 
-    return { id: result.id, growthPlanId };
+    await this.files.createDefinedFile(
+      growthPlanId,
+      `Growth Plan`,
+      session,
+      result.id,
+      'growthPlan',
+      input.growthPlan,
+      'engagement.growthPlan',
+    );
+
+    return (await this.readOne(
+      result.id,
+      session,
+      viewOfChangeset(changeset),
+    )) as UnsecuredDto<InternshipEngagement>;
   }
 
-  // UPDATE ///////////////////////////////////////////////////////////
-
   getActualLanguageChanges = getChanges(LanguageEngagement);
 
   async updateLanguage(
-    existing: LanguageEngagement | UnsecuredDto<LanguageEngagement>,
-    changes: ChangesOf<LanguageEngagement, UpdateLanguageEngagement>,
+    changes: UpdateLanguageEngagement,
+    session: Session,
     changeset?: ID,
-  ): Promise<void> {
-    const { pnp, ...simpleChanges } = changes;
+  ) {
+    const { id, pnp, ...simpleChanges } = changes;
+
+    if (pnp) {
+      const engagement = await this.readOne(id, session);
+      if (engagement.pnp) {
+        await this.files.createFileVersion(
+          {
+            ...pnp,
+            parentId: engagement.pnp.id,
+          },
+          session,
+        );
+      }
+    }
+
+    if (changes.firstScripture) {
+      await this.verifyFirstScripture({ engagementId: id });
+    }
 
     await this.db.updateProperties({
       type: LanguageEngagement,
-      object: existing,
+      object: { id },
       changes: simpleChanges,
       changeset,
     });
+
+    return await this.readOne(id, session);
   }
 
   getActualInternshipChanges = getChanges(InternshipEngagement);
 
   async updateInternship(
-    existing: InternshipEngagement | UnsecuredDto<InternshipEngagement>,
-    changes: ChangesOf<InternshipEngagement, UpdateInternshipEngagement>,
+    changes: UpdateInternshipEngagement,
+    session: Session,
     changeset?: ID,
-  ): Promise<void> {
-    const {
-      mentorId,
-      countryOfOriginId,
-      growthPlan: _,
-      ...simpleChanges
-    } = changes;
+  ) {
+    const { id, mentorId, countryOfOriginId, growthPlan, ...simpleChanges } =
+      changes;
+
+    if (growthPlan) {
+      const engagement = await this.readOne(id, session);
+      if (engagement.growthPlan) {
+        await this.files.createFileVersion(
+          {
+            ...growthPlan,
+            parentId: engagement.growthPlan.id,
+          },
+          session,
+        );
+      }
+    }
 
     if (mentorId !== undefined) {
-      await this.updateRelation('mentor', 'User', existing.id, mentorId);
+      await this.updateRelation('mentor', 'User', id, mentorId);
     }
 
     if (countryOfOriginId !== undefined) {
       await this.updateRelation(
         'countryOfOrigin',
         'Location',
-        existing.id,
+        id,
         countryOfOriginId,
       );
     }
 
     await this.db.updateProperties({
       type: InternshipEngagement,
-      object: existing,
+      object: { id },
       changes: simpleChanges,
       changeset,
     });
-  }
 
-  // LIST ///////////////////////////////////////////////////////////
+    return await this.readOne(id, session);
+  }
 
   async list(input: EngagementListInput, session: Session, changeset?: ID) {
     const result = await this.db
@@ -425,18 +522,19 @@ export class EngagementRepository extends CommonRepository {
     return rows.map((r) => r.id);
   }
 
-  async verifyRelationshipEligibility(
+  protected async verifyRelationshipEligibility(
     projectId: ID,
     otherId: ID,
-    isTranslation: boolean,
-    property: 'language' | 'intern',
+    isInternship: boolean,
     changeset?: ID,
   ) {
-    return await this.db
+    const property = isInternship ? 'intern' : 'language';
+
+    const result = await this.db
       .query()
       .optionalMatch(node('project', 'Project', { id: projectId }))
       .optionalMatch(
-        node('other', isTranslation ? 'Language' : 'User', {
+        node('other', !isInternship ? 'Language' : 'User', {
           id: otherId,
         }),
       )
@@ -465,9 +563,48 @@ export class EngagementRepository extends CommonRepository {
         engagement?: Node;
       }>()
       .first();
+
+    if (!result?.project) {
+      throw new NotFoundException(
+        'Could not find project',
+        'engagement.projectId',
+      );
+    }
+
+    const isActuallyInternship =
+      result.project.properties.type === ProjectType.Internship;
+    if (isActuallyInternship !== isInternship) {
+      throw new InputException(
+        `Only ${
+          isInternship ? 'Internship' : 'Language'
+        } Engagements can be created on ${
+          isInternship ? 'Internship' : 'Translation'
+        } Projects`,
+        `engagement.${property}Id`,
+      );
+    }
+
+    const label = isInternship ? 'person' : 'language';
+    if (!result?.other) {
+      throw new NotFoundException(
+        `Could not find ${label}`,
+        `engagement.${property}Id`,
+      );
+    }
+
+    if (result.engagement) {
+      throw new DuplicateException(
+        `engagement.${property}Id`,
+        `Engagement for this project and ${label} already exists`,
+      );
+    }
+
+    return result;
   }
 
-  async doesLanguageHaveExternalFirstScripture(id: LanguageOrEngagementId) {
+  private async doesLanguageHaveExternalFirstScripture(
+    id: LanguageOrEngagementId,
+  ) {
     const result = await this.db
       .query()
       .apply(this.matchLanguageOrEngagement(id))
@@ -481,7 +618,9 @@ export class EngagementRepository extends CommonRepository {
     return !!result;
   }
 
-  async doOtherEngagementsHaveFirstScripture(id: LanguageOrEngagementId) {
+  private async doOtherEngagementsHaveFirstScripture(
+    id: LanguageOrEngagementId,
+  ) {
     const result = await this.db
       .query()
       .apply(this.matchLanguageOrEngagement(id))
@@ -513,6 +652,26 @@ export class EngagementRepository extends CommonRepository {
         : query.match([node('language', 'Language', { id: languageId })]);
   }
 
+  /**
+   * if firstScripture is true, validate that the engagement
+   * is the only engagement for the language that has firstScripture=true
+   * that the language doesn't have hasExternalFirstScripture=true
+   */
+  private async verifyFirstScripture(id: LanguageOrEngagementId) {
+    if (await this.doesLanguageHaveExternalFirstScripture(id)) {
+      throw new InputException(
+        'First scripture has already been marked as having been done externally',
+        'languageEngagement.firstScripture',
+      );
+    }
+    if (await this.doOtherEngagementsHaveFirstScripture(id)) {
+      throw new InputException(
+        'Another engagement has already been marked as having done the first scripture',
+        'languageEngagement.firstScripture',
+      );
+    }
+  }
+
   @OnIndex()
   private createIndexes() {
     return this.getConstraintsFor(IEngagement);