Merge pull request #1183 from david-roper/add-user-to-session

Add user to session

Author: joshunrau

apps/api/prisma/schema.prisma

@@ -202,6 +202,7 @@ model User {
   basePermissionLevel   BasePermissionLevel?
   additionalPermissions AuthRule[]
   firstName             String
+  sessions              Session[]
   groupIds              String[]             @db.ObjectId
   groups                Group[]              @relation(fields: [groupIds], references: [id])
   lastName              String
@@ -229,6 +230,8 @@ model Session {
   instrumentRecords InstrumentRecord[]
   subject           Subject?           @relation(fields: [subjectId], references: [id])
   subjectId         String
+  user              User?              @relation(fields: [userId], references: [id])         
+  userId            String?
   type              SessionType
 
   @@map("SessionModel")

apps/api/src/sessions/dto/create-session.dto.ts

@@ -9,4 +9,5 @@ export class CreateSessionDto {
   groupId: null | string;
   subjectData: CreateSubjectData;
   type: SessionType;
+  userId?: null | string;
 }

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

@@ -1,11 +1,11 @@
-import { accessibleQuery, InjectModel, LoggingService } from '@douglasneuroinformatics/libnest';
-import type { Model } from '@douglasneuroinformatics/libnest';
+import { accessibleQuery, InjectModel, InjectPrismaClient, LoggingService } from '@douglasneuroinformatics/libnest';
+import type { ExtendedPrismaClient, Model } from '@douglasneuroinformatics/libnest';
 import { Injectable } from '@nestjs/common';
 import { InternalServerErrorException, NotFoundException } from '@nestjs/common/exceptions';
 import type { Group } from '@opendatacapture/schemas/group';
 import type { CreateSessionData } from '@opendatacapture/schemas/session';
 import type { CreateSubjectData } from '@opendatacapture/schemas/subject';
-import type { Prisma, Session, Subject } from '@prisma/client';
+import type { Prisma, Session, Subject, User } from '@prisma/client';
 
 import type { EntityOperationOptions } from '@/core/types';
 import { GroupsService } from '@/groups/groups.service';
@@ -14,6 +14,7 @@ import { SubjectsService } from '@/subjects/subjects.service';
 @Injectable()
 export class SessionsService {
   constructor(
+    @InjectPrismaClient() private readonly prismaClient: ExtendedPrismaClient,
     @InjectModel('Session') private readonly sessionModel: Model<'Session'>,
     private readonly groupsService: GroupsService,
     private readonly loggingService: LoggingService,
@@ -26,10 +27,20 @@ export class SessionsService {
     });
   }
 
-  async create({ date, groupId, subjectData, type }: CreateSessionData): Promise<Session> {
+  async create({ date, groupId, subjectData, type, username }: CreateSessionData): Promise<Session> {
     this.loggingService.debug({ message: 'Attempting to create session' });
     const subject = await this.resolveSubject(subjectData);
 
+    let user: null | Omit<User, 'hashedPassword'> = null;
+
+    if (username) {
+      user = await this.prismaClient.user.findFirst({
+        where: {
+          username: username
+        }
+      });
+    }
+
     // If the subject is not yet associated with the group, check it exists then append it
     let group: Group | null = null;
     if (groupId && !subject.groupIds.includes(groupId)) {
@@ -48,7 +59,12 @@ export class SessionsService {
         subject: {
           connect: { id: subject.id }
         },
-        type
+        type,
+        user: user
+          ? {
+              connect: { id: user.id }
+            }
+          : undefined
       }
     });
 

apps/api/src/users/users.controller.ts

@@ -12,6 +12,13 @@ import { UsersService } from './users.service';
 export class UsersController {
   constructor(private readonly usersService: UsersService) {}
 
+  @ApiOperation({ summary: 'Get User by Username' })
+  @Get('/check-username/:username')
+  @RouteAccess({ action: 'read', subject: 'User' })
+  checkUsernameExists(@Param('username') username: string, @CurrentUser('ability') ability: AppAbility) {
+    return this.usersService.checkUsernameExists(username, { ability });
+  }
+
   @ApiOperation({ summary: 'Create User' })
   @Post()
   @RouteAccess({ action: 'create', subject: 'User' })

apps/api/src/users/users.service.ts

@@ -17,6 +17,20 @@ export class UsersService {
     private readonly groupsService: GroupsService
   ) {}
 
+  async checkUsernameExists(username: string, { ability }: EntityOperationOptions = {}): Promise<{ success: boolean }> {
+    const user = await this.userModel.findFirst({
+      include: { groups: true },
+      omit: {
+        hashedPassword: true
+      },
+      where: { AND: [accessibleQuery(ability, 'read', 'User'), { username }] }
+    });
+    if (!user) {
+      return { success: false };
+    }
+    return { success: true };
+  }
+
   async count(
     filter: NonNullable<Parameters<Model<'User'>['count']>[0]>['where'] = {},
     { ability }: EntityOperationOptions = {}

apps/web/src/components/StartSessionForm/StartSessionForm.tsx

@@ -35,9 +35,16 @@ type StartSessionFormProps = {
   initialValues?: FormTypes.PartialNullableData<StartSessionFormData>;
   onSubmit: (data: CreateSessionData) => Promisable<void>;
   readOnly: boolean;
+  username?: null | string;
 };
 
-export const StartSessionForm = ({ currentGroup, initialValues, readOnly, onSubmit }: StartSessionFormProps) => {
+export const StartSessionForm = ({
+  currentGroup,
+  username,
+  initialValues,
+  readOnly,
+  onSubmit
+}: StartSessionFormProps) => {
   const { resolvedLanguage, t } = useTranslation();
   return (
     <Form
@@ -244,6 +251,7 @@ export const StartSessionForm = ({ currentGroup, initialValues, readOnly, onSubm
         await onSubmit({
           date: sessionDate,
           groupId: currentGroup?.id ?? null,
+          username: username ?? null,
           type: sessionType,
           subjectData: {
             id: subjectId,

apps/web/src/routes/_app/admin/users/create.tsx

@@ -2,10 +2,11 @@
 
 import { estimatePasswordStrength } from '@douglasneuroinformatics/libpasswd';
 import { Form, Heading } from '@douglasneuroinformatics/libui/components';
-import { useTranslation } from '@douglasneuroinformatics/libui/hooks';
+import { useNotificationsStore, useTranslation } from '@douglasneuroinformatics/libui/hooks';
 import { $BasePermissionLevel, $CreateUserData } from '@opendatacapture/schemas/user';
 import type { CreateUserData } from '@opendatacapture/schemas/user';
 import { createFileRoute, useNavigate } from '@tanstack/react-router';
+import axios from 'axios';
 import { z } from 'zod/v4';
 
 import { PageHeader } from '@/components/PageHeader';
@@ -17,10 +18,24 @@ const RouteComponent = () => {
   const navigate = useNavigate();
   const groupsQuery = useGroupsQuery();
   const createUserMutation = useCreateUserMutation();
+  const notification = useNotificationsStore();
 
-  const handleSubmit = (data: CreateUserData) => {
-    createUserMutation.mutate({ data });
-    void navigate({ to: '..' });
+  const handleSubmit = async (data: CreateUserData) => {
+    // check if username exists
+    const existingUsername = await axios.get<{ success: boolean }>(
+      `/v1/users/check-username/${encodeURIComponent(data.username)}`
+    );
+
+    if (existingUsername.data.success === true) {
+      notification.addNotification({
+        type: 'error',
+        message: t('common.usernameExists')
+      });
+    } else {
+      void createUserMutation.mutateAsync({ data });
+
+      void navigate({ to: '..' });
+    }
   };
 
   return (

apps/web/src/routes/_app/session/start-session.tsx

@@ -15,6 +15,7 @@ const RouteComponent = () => {
   const currentGroup = useAppStore((store) => store.currentGroup);
   const currentSession = useAppStore((store) => store.currentSession);
   const startSession = useAppStore((store) => store.startSession);
+  const currentUser = useAppStore((store) => store.currentUser);
   const location = useLocation();
   const defaultInitialValues = {
     sessionType: 'IN_PERSON',
@@ -44,6 +45,7 @@ const RouteComponent = () => {
         currentGroup={currentGroup}
         initialValues={initialValues}
         readOnly={currentSession !== null || createSessionMutation.isPending}
+        username={currentUser?.username}
         onSubmit={async (formData) => {
           const session = await createSessionMutation.mutateAsync(formData);
           startSession({ ...session, type: formData.type });

apps/web/src/translations/common.json

@@ -150,5 +150,9 @@
   "username": {
     "en": "Username",
     "fr": "Nom d'utilisateur"
+  },
+  "usernameExists": {
+    "en": "Username already exists",
+    "fr": "Le nom d'utilisateur existe déjà"
   }
 }

packages/schemas/src/session/session.ts

@@ -12,13 +12,15 @@ export const $Session = $BaseModel.extend({
   groupId: z.string().nullable(),
   subject: $Subject,
   subjectId: z.string(),
-  type: $SessionType
+  type: $SessionType,
+  userId: z.string().nullish()
 });
 
 export type CreateSessionData = z.infer<typeof $CreateSessionData>;
 export const $CreateSessionData = z.object({
   date: z.coerce.date(),
   groupId: z.string().nullable(),
   subjectData: $CreateSubjectData,
-  type: $SessionType
+  type: $SessionType,
+  username: z.string().nullish()
 });