feat: add graphs to dashboard

Author: joshunrau

apps/api/src/demo/demo.service.ts

@@ -107,13 +107,16 @@ export class DemoService {
           researchId++;
         }
 
+        const date = faker.date.past({ years: 1 });
+
         const subject = await this.subjectsService.create({
+          createdAt: date,
           ...subjectIdData,
           id: subjectId
         });
 
         const session = await this.sessionsService.create({
-          date: new Date(),
+          date,
           groupId: group.id,
           subjectData: subject,
           type: 'IN_PERSON'
@@ -132,7 +135,7 @@ export class DemoService {
           }
           await this.instrumentRecordsService.create({
             data: data as Json,
-            date: faker.date.past({ years: 2 }),
+            date,
             groupId: group.id,
             instrumentId: hq.id,
             sessionId: session.id,

apps/api/src/sessions/sessions.service.ts

@@ -5,7 +5,7 @@ import { InternalServerErrorException, NotFoundException } from '@nestjs/common/
 import type { Group } from '@opendatacapture/schemas/group';
 import type { CreateSessionData } from '@opendatacapture/schemas/session';
 import type { CreateSubjectData } from '@opendatacapture/schemas/subject';
-import type { Session, Subject } from '@prisma/client';
+import type { Prisma, Session, Subject } from '@prisma/client';
 
 import type { EntityOperationOptions } from '@/core/types';
 import { GroupsService } from '@/groups/groups.service';
@@ -20,6 +20,12 @@ export class SessionsService {
     private readonly subjectsService: SubjectsService
   ) {}
 
+  async count(where: Prisma.SessionWhereInput = {}, { ability }: EntityOperationOptions = {}) {
+    return this.sessionModel.count({
+      where: { AND: [accessibleQuery(ability, 'read', 'Session'), where] }
+    });
+  }
+
   async create({ date, groupId, subjectData, type }: CreateSessionData): Promise<Session> {
     this.loggingService.debug({ message: 'Attempting to create session' });
     const subject = await this.resolveSubject(subjectData);

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

@@ -31,7 +31,13 @@ export class SubjectsService {
     });
   }
 
-  async create({ id, ...data }: CreateSubjectDto) {
+  async create({
+    id,
+    ...data
+  }: CreateSubjectDto & {
+    /** for demo purposes need to set createdAt manually */
+    createdAt?: Date;
+  }) {
     if (await this.subjectModel.exists({ id })) {
       throw new ConflictException('A subject with the provided demographic information already exists');
     }

apps/api/src/summary/summary.controller.ts

@@ -13,6 +13,7 @@ export class SummaryController {
   @RouteAccess([
     { action: 'read', subject: 'Instrument' },
     { action: 'read', subject: 'InstrumentRecord' },
+    { action: 'read', subject: 'Session' },
     { action: 'read', subject: 'Subject' },
     { action: 'read', subject: 'User' }
   ])

apps/api/src/summary/summary.module.ts

@@ -3,6 +3,7 @@ import { Module } from '@nestjs/common';
 import { GroupsModule } from '@/groups/groups.module';
 import { InstrumentRecordsModule } from '@/instrument-records/instrument-records.module';
 import { InstrumentsModule } from '@/instruments/instruments.module';
+import { SessionsModule } from '@/sessions/sessions.module';
 import { SubjectsModule } from '@/subjects/subjects.module';
 import { UsersModule } from '@/users/users.module';
 
@@ -12,7 +13,7 @@ import { SummaryService } from './summary.service';
 @Module({
   controllers: [SummaryController],
   exports: [SummaryService],
-  imports: [GroupsModule, InstrumentRecordsModule, InstrumentsModule, SubjectsModule, UsersModule],
+  imports: [GroupsModule, InstrumentRecordsModule, InstrumentsModule, SessionsModule, SubjectsModule, UsersModule],
   providers: [SummaryService]
 })
 export class SummaryModule {}

apps/api/src/summary/summary.service.ts

@@ -4,27 +4,63 @@ import type { Summary } from '@opendatacapture/schemas/summary';
 import type { EntityOperationOptions } from '@/core/types';
 import { InstrumentRecordsService } from '@/instrument-records/instrument-records.service';
 import { InstrumentsService } from '@/instruments/instruments.service';
+import { SessionsService } from '@/sessions/sessions.service';
 import { SubjectsService } from '@/subjects/subjects.service';
 import { UsersService } from '@/users/users.service';
 
+const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+
 @Injectable()
 export class SummaryService {
   constructor(
     private readonly instrumentRecordsService: InstrumentRecordsService,
     private readonly instrumentsService: InstrumentsService,
+    private readonly sessionsService: SessionsService,
     private readonly usersService: UsersService,
     private readonly subjectsService: SubjectsService
   ) {}
 
   async getSummary(groupId?: string, { ability }: EntityOperationOptions = {}): Promise<Summary> {
     const filter = groupId ? { groupIds: { has: groupId } } : ({} as { [key: string]: unknown });
+    const sessionFilter = groupId ? { groupId } : {};
+    const recordFilter = groupId ? { groupId } : {};
+
+    const counts = {
+      instruments: await this.instrumentsService.count(),
+      records: await this.instrumentRecordsService.count(recordFilter, { ability }),
+      sessions: await this.sessionsService.count(sessionFilter, { ability }),
+      subjects: await this.subjectsService.count(filter, { ability }),
+      users: await this.usersService.count(filter, { ability })
+    };
+
+    const now = Date.now();
+
+    const trends: Summary['trends'] = {
+      records: [],
+      sessions: [],
+      subjects: []
+    };
+
+    for (let i = 0; i < 5; i++) {
+      const timestamp = now - THIRTY_DAYS_MS * i;
+      const lte = new Date(timestamp);
+      trends.records.push({
+        timestamp,
+        value: await this.instrumentRecordsService.count({ date: { lte }, ...recordFilter }, { ability })
+      });
+      trends.sessions.push({
+        timestamp,
+        value: await this.sessionsService.count({ date: { lte }, ...sessionFilter }, { ability })
+      });
+      trends.subjects.push({
+        timestamp,
+        value: await this.subjectsService.count({ createdAt: { lte }, ...filter }, { ability })
+      });
+    }
+
     return {
-      counts: {
-        instruments: await this.instrumentsService.count(),
-        records: await this.instrumentRecordsService.count({ groupId }, { ability }),
-        subjects: await this.subjectsService.count(filter, { ability }),
-        users: await this.usersService.count(filter, { ability })
-      }
+      counts,
+      trends
     };
   }
 }

apps/web/package.json

@@ -48,6 +48,7 @@
     "papaparse": "workspace:papaparse__5.x@*",
     "react": "workspace:react__19.x@*",
     "react-dom": "workspace:react-dom__19.x@*",
+    "recharts": "^2.15.2",
     "ts-pattern": "workspace:ts-pattern__5.x@*",
     "type-fest": "workspace:type-fest__4.x@*",
     "xlsx": "^0.18.5",