Merge pull request #1122 from david-roper/improve-upload

Refactor creation of subject ids in upload csv code.

Author: joshunrau

apps/api/src/instrument-records/instrument-records.service.ts

@@ -20,7 +20,7 @@ import type { EntityOperationOptions } from '@/core/types';
 import { GroupsService } from '@/groups/groups.service';
 import { InstrumentsService } from '@/instruments/instruments.service';
 import { SessionsService } from '@/sessions/sessions.service';
-import type { CreateSubjectDto } from '@/subjects/dto/create-subject.dto';
+import { CreateSubjectDto } from '@/subjects/dto/create-subject.dto';
 import { SubjectsService } from '@/subjects/subjects.service';
 
 import { InstrumentMeasuresService } from './instrument-measures.service';
@@ -276,6 +276,14 @@ export class InstrumentRecordsService {
     const createdSessionsArray: Session[] = [];
 
     try {
+      const subjectIdList = records.map(({ subjectId }) => {
+        const subjectToAdd: CreateSubjectDto = { id: subjectId };
+
+        return subjectToAdd;
+      });
+
+      await this.subjectsService.createMany(subjectIdList);
+
       const preProcessedRecords = await Promise.all(
         records.map(async (record) => {
           const { data: rawData, date, subjectId } = record;
@@ -289,9 +297,6 @@ export class InstrumentRecordsService {
             );
           }
 
-          // Ensure subject exists
-          await this.createSubjectIfNotFound(subjectId);
-
           const session = await this.sessionsService.create({
             date: date,
             groupId: groupId ?? null,
@@ -316,7 +321,6 @@ export class InstrumentRecordsService {
           };
         })
       );
-
       await this.instrumentRecordModel.createMany({
         data: preProcessedRecords
       });
@@ -333,30 +337,6 @@ export class InstrumentRecordsService {
     }
   }
 
-  private async createSubjectIfNotFound(subjectId: string) {
-    try {
-      return await this.subjectsService.findById(subjectId);
-    } catch (exception) {
-      if (exception instanceof NotFoundException) {
-        const addedSubject: CreateSubjectDto = {
-          id: subjectId
-        };
-        try {
-          return await this.subjectsService.create(addedSubject);
-        } catch (prismaError) {
-          if (prismaError instanceof Prisma.PrismaClientKnownRequestError && prismaError.code === 'P2002') {
-            console.error(prismaError);
-            return await this.subjectsService.findById(subjectId);
-          } else {
-            throw prismaError;
-          }
-        }
-      } else {
-        throw exception;
-      }
-    }
-  }
-
   private parseJson(data: unknown) {
     return JSON.parse(JSON.stringify(data), reviver) as unknown;
   }

apps/api/src/subjects/subjects.service.ts

@@ -41,6 +41,47 @@ export class SubjectsService {
     });
   }
 
+  async createMany(data: CreateSubjectDto[], { ability }: EntityOperationOptions = {}) {
+    //filter out all duplicate ids that are planned to be created via a set
+    const noDuplicatesSet = new Set(
+      data.map((record) => {
+        return record.id;
+      })
+    );
+
+    const subjectIds = Array.from(noDuplicatesSet);
+
+    //find the list of subject ids that already exist
+    const existingSubjects = await this.subjectModel.findMany({
+      select: { id: true },
+      where: {
+        id: { in: subjectIds },
+        AND: [accessibleQuery(ability, 'read', 'Subject')]
+      }
+    });
+
+    //create a set of existing ids in the database to filter our to-be-created ids with
+    const existingIds = new Set(existingSubjects.map((subj) => subj.id));
+
+    //Filter out records whose IDs already exist
+    const subjectsToCreateIds = subjectIds.filter((record) => !existingIds.has(record));
+
+    const subjectsToCreate: CreateSubjectDto[] = subjectsToCreateIds.map((record) => {
+      return {
+        id: record
+      };
+    });
+
+    //if there are none left to create do not follow through with the command
+    if (subjectsToCreate.length < 1) {
+      return subjectsToCreate;
+    }
+    return this.subjectModel.createMany({
+      data: subjectsToCreate,
+      ...accessibleQuery(ability, 'create', 'Subject')
+    });
+  }
+
   async deleteById(id: string, { ability }: EntityOperationOptions = {}) {
     const subject = await this.findById(id);
     return this.subjectModel.delete({