Merge pull request #986 from david-roper/upload-data-session

Author: joshunrau

apps/api/src/instrument-records/dto/upload-instrument-record.dto.ts

@@ -0,0 +1,14 @@
+import { ValidationSchema } from '@douglasneuroinformatics/libnest/core';
+import type { Json } from '@opendatacapture/schemas/core';
+import { $UploadInstrumentRecordData } from '@opendatacapture/schemas/instrument-records';
+
+@ValidationSchema($UploadInstrumentRecordData)
+export class UploadInstrumentRecordDto {
+  groupId?: string;
+  instrumentId: string;
+  records: {
+    data: Json;
+    date: Date;
+    subjectId: string;
+  }[];
+}

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

@@ -12,6 +12,8 @@ import type { AppAbility } from '@/core/types';
 import { CreateInstrumentRecordDto } from './dto/create-instrument-record.dto';
 import { InstrumentRecordsService } from './instrument-records.service';
 
+import { UploadInstrumentRecordDto } from './dto/upload-instrument-record.dto';
+
 @ApiTags('Instrument Records')
 @Controller('instrument-records')
 export class InstrumentRecordsController {
@@ -24,6 +26,13 @@ export class InstrumentRecordsController {
     return this.instrumentRecordsService.create(data, { ability });
   }
 
+  @ApiOperation({ summary: 'Upload multiple instrument records' })
+  @Post('upload')
+  @RouteAccess({ action: 'create', subject: 'InstrumentRecord' })
+  upload(@Body() data: UploadInstrumentRecordDto, @CurrentUser('ability') ability: AppAbility) {
+    return this.instrumentRecordsService.upload(data, { ability });
+  }
+
   @ApiOperation({ summary: 'Get Records for Instrument ' })
   @Get()
   @RouteAccess({ action: 'read', subject: 'InstrumentRecord' })

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

@@ -1,14 +1,17 @@
 import { yearsPassed } from '@douglasneuroinformatics/libjs';
 import { linearRegression } from '@douglasneuroinformatics/libstats';
-import { Injectable, UnprocessableEntityException } from '@nestjs/common';
+import { Injectable, NotFoundException, UnprocessableEntityException } from '@nestjs/common';
 import type { ScalarInstrument } from '@opendatacapture/runtime-core';
 import type {
   CreateInstrumentRecordData,
   InstrumentRecord,
   InstrumentRecordQueryParams,
   InstrumentRecordsExport,
-  LinearRegressionResults
+  LinearRegressionResults,
+  UploadInstrumentRecordData
 } from '@opendatacapture/schemas/instrument-records';
+import type { SessionType } from '@opendatacapture/schemas/session';
+import type { CreateSubjectData } from '@opendatacapture/schemas/subject';
 import type { InstrumentRecordModel, Prisma } from '@prisma/generated-client';
 import { isNumber, pickBy } from 'lodash-es';
 
@@ -19,6 +22,7 @@ import { InstrumentsService } from '@/instruments/instruments.service';
 import { InjectModel } from '@/prisma/prisma.decorators';
 import type { Model } from '@/prisma/prisma.types';
 import { SessionsService } from '@/sessions/sessions.service';
+import type { CreateSubjectDto } from '@/subjects/dto/create-subject.dto';
 import { SubjectsService } from '@/subjects/subjects.service';
 import { VirtualizationService } from '@/virtualization/virtualization.service';
 
@@ -61,7 +65,11 @@ export class InstrumentRecordsService {
 
     await this.subjectsService.findById(subjectId);
     await this.sessionsService.findById(sessionId);
-
+    if (!instrument.validationSchema.safeParse(data).success) {
+      throw new UnprocessableEntityException(
+        `Data received does not pass validation schema of instrument '${instrument.id}'`
+      );
+    }
     return this.instrumentRecordModel.create({
       data: {
         computedMeasures: instrument.measures
@@ -243,4 +251,93 @@ export class InstrumentRecordsService {
     }
     return results;
   }
+
+  async upload(
+    { groupId, instrumentId, records }: UploadInstrumentRecordData,
+    options?: EntityOperationOptions
+  ): Promise<InstrumentRecordModel[]> {
+    if (groupId) {
+      await this.groupsService.findById(groupId, options);
+    }
+
+    const instrument = await this.instrumentsService.findById(instrumentId);
+
+    const createdModelsArray: InstrumentRecordModel[] = [];
+    if (instrument.kind === 'SERIES') {
+      throw new UnprocessableEntityException(
+        `Cannot create instrument record for series instrument '${instrument.id}'`
+      );
+    }
+
+    for (const record of records) {
+      const { data, date, subjectId } = record;
+
+      //create a new subject id in subjects service if they dont exist
+      try {
+        await this.subjectsService.findById(subjectId);
+      } catch (exception) {
+        if (exception instanceof NotFoundException) {
+          const addedSubject: CreateSubjectDto = {
+            id: subjectId
+          };
+          await this.subjectsService.create(addedSubject);
+        } else {
+          throw exception;
+        }
+      }
+
+      let subjectInfo: CreateSubjectData = {
+        dateOfBirth: null,
+        firstName: null,
+        id: subjectId,
+        lastName: null,
+        sex: null
+      };
+
+      let sessionType: SessionType = 'RETROSPECTIVE';
+
+      let sessionId = (
+        await this.sessionsService.create({
+          date: date,
+          groupId: groupId ? groupId : null,
+          subjectData: subjectInfo,
+          type: sessionType
+        })
+      ).id;
+
+      const createdModel = await this.instrumentRecordModel.create({
+        data: {
+          computedMeasures: instrument.measures
+            ? this.instrumentMeasuresService.computeMeasures(instrument.measures, data)
+            : null,
+          data,
+          date,
+          group: groupId
+            ? {
+                connect: { id: groupId }
+              }
+            : undefined,
+          instrument: {
+            connect: {
+              id: instrumentId
+            }
+          },
+          session: {
+            connect: {
+              id: sessionId
+            }
+          },
+          subject: {
+            connect: {
+              id: subjectId
+            }
+          }
+        }
+      });
+
+      createdModelsArray.push(createdModel);
+    }
+
+    return createdModelsArray;
+  }
 }

apps/web/src/Routes.tsx

@@ -13,6 +13,7 @@ import { datahubRoute } from './features/datahub';
 import { groupRoute } from './features/group';
 import { instrumentsRoute } from './features/instruments';
 import { sessionRoute } from './features/session';
+import { uploadRoute } from './features/upload';
 import { userRoute } from './features/user';
 import { DisclaimerProvider } from './providers/DisclaimerProvider';
 import { WalkthroughProvider } from './providers/WalkthroughProvider';
@@ -45,7 +46,8 @@ const protectedRoutes: RouteObject[] = [
       groupRoute,
       instrumentsRoute,
       sessionRoute,
-      userRoute
+      userRoute,
+      uploadRoute
     ]
   }
 ];

apps/web/src/features/datahub/components/MasterDataTable.tsx

@@ -15,7 +15,7 @@ export const MasterDataTable = ({ data, onSelect }: MasterDataTableProps) => {
     <ClientTable<Subject>
       columns={[
         {
-          field: (subject) => removeSubjectIdScope(subject.id).slice(0, 7),
+          field: (subject) => removeSubjectIdScope(subject.id).slice(0, 9),
           label: t('datahub.index.table.subject')
         },
         {

apps/web/src/features/datahub/components/SubjectLayout.tsx

@@ -26,7 +26,7 @@ export const SubjectLayout = () => {
               en: 'Instrument Records for Subject {}',
               fr: "Dossiers d'instruments pour le client {}"
             },
-            removeSubjectIdScope(subjectId).slice(0, 7)
+            removeSubjectIdScope(subjectId).slice(0, 9)
           )}
         </Heading>
       </PageHeader>

apps/web/src/features/upload/components/UploadSelectTable.tsx

@@ -0,0 +1,30 @@
+import { ClientTable } from '@douglasneuroinformatics/libui/components';
+import { useTranslation } from '@douglasneuroinformatics/libui/hooks';
+import type { InstrumentInfo } from '@opendatacapture/schemas/instrument';
+
+export type UploadSelectTableProps = {
+  data: InstrumentInfo[];
+  onSelect: (instrument: InstrumentInfo) => void;
+};
+
+export const UploadSelectTable = ({ data, onSelect }: UploadSelectTableProps) => {
+  const { t } = useTranslation();
+
+  // Renders a table for selecting an instrument to upload data for
+  return (
+    <ClientTable<InstrumentInfo>
+      columns={[
+        {
+          field: (instrument) => (instrument.details?.title as string) ?? 'N/A',
+          label: t({
+            en: 'Select an instrument',
+            fr: 'Selectionnez un instrument'
+          })
+        }
+      ]}
+      data={data}
+      entriesPerPage={15}
+      onEntryClick={onSelect}
+    />
+  );
+};

apps/web/src/features/upload/hooks/useProcessUploadData.ts

@@ -0,0 +1,18 @@
+import { type RouteObject } from 'react-router-dom';
+
+import { UploadPage } from './pages/UploadPage';
+import { UploadSelectPage } from './pages/UploadSelectPage';
+
+export const uploadRoute: RouteObject = {
+  children: [
+    {
+      element: <UploadSelectPage />,
+      index: true
+    },
+    {
+      element: <UploadPage />,
+      path: ':id' //instrument id
+    }
+  ],
+  path: 'upload'
+};

apps/web/src/features/upload/index.tsx

@@ -0,0 +1,101 @@
+import { useState } from 'react';
+
+import { FileDropzone } from '@douglasneuroinformatics/libui/components';
+import { Button } from '@douglasneuroinformatics/libui/components';
+import { useDownload } from '@douglasneuroinformatics/libui/hooks';
+import { useNotificationsStore } from '@douglasneuroinformatics/libui/hooks';
+import type { AnyUnilingualFormInstrument, FormTypes, Json } from '@opendatacapture/runtime-core';
+import type { UploadInstrumentRecordData } from '@opendatacapture/schemas/instrument-records';
+import { encodeScopedSubjectId } from '@opendatacapture/subject-utils';
+import axios from 'axios';
+import { DownloadIcon } from 'lucide-react';
+import { useParams } from 'react-router-dom';
+
+import { useInstrument } from '@/hooks/useInstrument';
+import { useAppStore } from '@/store';
+
+import { createUploadTemplateCSV, processInstrumentCSV } from '../utils';
+
+export const UploadPage = () => {
+  const [file, setFile] = useState<File | null>(null);
+  const download = useDownload();
+  const addNotification = useNotificationsStore((store) => store.addNotification);
+  const acceptedFiles = {
+    'text/csv': ['.csv']
+  };
+  const currentGroup = useAppStore((store) => store.currentGroup);
+
+  const params = useParams();
+  const instrument = useInstrument(params.id!) as AnyUnilingualFormInstrument;
+
+  const sendInstrumentData = async (data: FormTypes.Data[]) => {
+    const reformatForSending = reformatInstrumentData(data);
+
+    try {
+      await axios.post('/v1/instrument-records/upload', reformatForSending satisfies UploadInstrumentRecordData);
+      addNotification({ type: 'success' });
+    } catch (error) {
+      console.error(error);
+    }
+  };
+
+  const reformatInstrumentData = (data: FormTypes.Data[]): UploadInstrumentRecordData => {
+    const recordsList = [];
+
+    for (const dataInfo of data) {
+      const { date: dataDate, subjectID: dataSubjectId, ...restOfData } = dataInfo; // Destructure and extract the rest of the data
+
+      const createdRecord = {
+        data: restOfData as Json,
+        date: dataDate as Date,
+        subjectId: encodeScopedSubjectId(dataSubjectId as string, {
+          groupName: currentGroup?.name ?? 'root'
+        })
+      };
+      recordsList.push(createdRecord);
+    }
+
+    const reformatForSending: UploadInstrumentRecordData = {
+      groupId: undefined,
+      instrumentId: instrument.id!,
+      records: recordsList
+    };
+
+    return reformatForSending;
+  };
+
+  const handleTemplateDownload = () => {
+    const { content, fileName } = createUploadTemplateCSV(instrument);
+    void download(fileName, content);
+  };
+
+  const handleInstrumentCSV = async () => {
+    const input = file!;
+
+    const processedData = await processInstrumentCSV(input, instrument);
+
+    if (processedData.success) {
+      await sendInstrumentData(processedData.value);
+    } else {
+      addNotification({
+        message: processedData.message,
+        type: 'error'
+      });
+    }
+  };
+
+  return (
+    <div className="align-center items-center justify-center">
+      <FileDropzone acceptedFileTypes={acceptedFiles} file={file} setFile={setFile} />
+      <div className="mt-4 flex justify-between space-x-2">
+        <Button disabled={!(file && instrument)} variant={'primary'} onClick={handleInstrumentCSV}>
+          Submit
+        </Button>
+        <Button disabled={!instrument} variant={'primary'} onClick={handleTemplateDownload}>
+          <DownloadIcon />
+          Download Template
+        </Button>
+      </div>
+    </div>
+  );
+};