@studious-lms/server 1.2.29 → 1.2.31

package/dist/routers/worksheet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worksheet.d.ts","sourceRoot":"","sources":["../../src/routers/worksheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAga1B,CAAC"}
+{"version":3,"file":"worksheet.d.ts","sourceRoot":"","sources":["../../src/routers/worksheet.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2KA,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4ShC,CAAC"}

package/dist/routers/worksheet.js

@@ -119,6 +119,48 @@ export const worksheetRouter = createTRPCRouter({
         });
         return newQuestion;
     }),
+    reorderQuestions: protectedProcedure
+        .input(z.object({
+        worksheetId: z.string(),
+        movedId: z.string(),
+        position: z.enum(['before', 'after']),
+        targetId: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const { worksheetId, movedId, position, targetId } = input;
+        const worksheet = await prisma.worksheet.findUnique({
+            where: { id: worksheetId },
+        });
+        if (!worksheet) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Worksheet not found' });
+        }
+        const questions = await prisma.worksheetQuestion.findMany({
+            where: { worksheetId },
+            orderBy: { order: 'asc' },
+        });
+        const movedIdx = questions.findIndex(question => question.id === movedId);
+        if (movedIdx === -1) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Moved question not found' });
+        }
+        const targetIdx = questions.findIndex(question => question.id === targetId);
+        if (targetIdx === -1) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Target question not found' });
+        }
+        const withoutMoved = questions.filter(question => question.id !== movedId);
+        let next = [];
+        if (position === 'before') {
+            next = [...withoutMoved.slice(0, targetIdx).map(item => ({ id: item.id })), { id: movedId }, ...withoutMoved.slice(targetIdx).map(item => ({ id: item.id }))];
+        }
+        else {
+            next = [...withoutMoved.slice(0, targetIdx + 1).map(item => ({ id: item.id })), { id: movedId }, ...withoutMoved.slice(targetIdx + 1).map(item => ({ id: item.id }))];
+        }
+        // Update the order of each question
+        await prisma.$transaction(next.map((item, index) => prisma.worksheetQuestion.update({
+            where: { id: item.id },
+            data: { order: index },
+        })));
+        return next;
+    }),
     updateQuestion: protectedProcedure
         .input(z.object({
         worksheetId: z.string(),

package/dist/seedDatabase.d.ts

@@ -6,7 +6,6 @@ export declare function createUser(email: string, password: string, username: st
     password: string;
     verified: boolean;
     role: import(".prisma/client").$Enums.UserRole;
-    profileId: string | null;
     schoolId: string | null;
 }>;
 export declare function addNotification(userId: string, title: string, content: string): Promise<{

package/dist/seedDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seedDatabase.d.ts","sourceRoot":"","sources":["../src/seedDatabase.ts"],"names":[],"mappings":"AAIA,wBAAsB,aAAa,kBAuClC;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;;GAOjF;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;GAQnF;AAED,eAAO,MAAM,YAAY,qBAq+CxB,CAAC"}
+{"version":3,"file":"seedDatabase.d.ts","sourceRoot":"","sources":["../src/seedDatabase.ts"],"names":[],"mappings":"AAIA,wBAAsB,aAAa,kBAuClC;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;;;;;;;;GAOjF;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;;;;;GAQnF;AAED,eAAO,MAAM,YAAY,qBAq+CxB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.2.29",
+  "version": "1.2.31",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",

package/prisma/schema.prisma

@@ -81,8 +81,6 @@ model User {
   verified     Boolean     @default(false)
   role         UserRole    @default(NONE)
 
-  profileId    String?     @unique
-
   teacherIn   Class[] @relation("UserTeacherToClass")
   studentIn   Class[] @relation("UserStudentToClass")
 
@@ -90,6 +88,7 @@ model User {
   sessions    Session[]
   files       File[]
   assignments Assignment[]
+  specificAssignments Assignment[] @relation("SpecificAssignmentAssignedTo")
   events      Event[]
   announcements Announcement[]
   notificationsSent Notification[] @relation("SentNotifications")
@@ -143,15 +142,16 @@ model Class {
   events        Event[]
   sections      Section[]
   sessions      Session[]
-  worksheets Worksheet[]
+  worksheets    Worksheet[]
   students      User[]         @relation("UserStudentToClass")
   teachers      User[]         @relation("UserTeacherToClass")
-  markSchemes   MarkScheme[] @relation("ClassToMarkScheme")
-  gradingBoundaries GradingBoundary[] @relation("ClassToGradingBoundary")
+  // markSchemes   MarkScheme[] @relation("ClassToMarkScheme")
+  // gradingBoundaries GradingBoundary[] @relation("ClassToGradingBoundary")
   draftFiles File[] @relation("ClassDraftFiles")
   classFiles Folder? @relation("ClassFiles")
   labChats LabChat[] @relation("ClassLabChats")
-
+  markSchemes MarkScheme[]
+  gradingBoundaries GradingBoundary[]
   school    School? @relation(fields: [schoolId], references: [id])
   schoolId  String?
 }
@@ -159,7 +159,8 @@ model Class {
 model MarkScheme {
   id String @id @default(uuid())
   classId String
-  class Class[] @relation("ClassToMarkScheme")
+  // class Class[] @relation("ClassToMarkScheme")
+  class Class? @relation(fields: [classId], references: [id], onDelete: Cascade)
   structured String
   assignments Assignment[]
 }
@@ -167,7 +168,8 @@ model MarkScheme {
 model GradingBoundary {
   id String @id @default(uuid())
   classId String
-  class Class[] @relation("ClassToGradingBoundary")
+  // class Class[] @relation("ClassToGradingBoundary")
+  class Class? @relation(fields: [classId], references: [id], onDelete: Cascade)
   structured String
   assignments Assignment[]
 }
@@ -251,7 +253,13 @@ model Assignment {
   class         Class          @relation(fields: [classId], references: [id], onDelete: Cascade)
   classId       String
   attachments   File[]
+  acceptFiles Boolean @default(false)
+  acceptExtendedResponse Boolean @default(false)
+  acceptWorksheet Boolean @default(false)
+  gradeWithAI Boolean @default(false)
+
   submissions   Submission[]
+  assignedTo    User[] @relation("SpecificAssignmentAssignedTo")
   section       Section?       @relation(fields: [sectionId], references: [id], onDelete: Cascade)
   sectionId     String?
   graded        Boolean        @default(false)
@@ -333,6 +341,7 @@ model Submission {
   attachments File[]  @relation("SubmissionFile")
   annotations File[]  @relation("SubmissionAnnotations")
   worksheetResponses StudentWorksheetResponse[]
+  extendedResponse String?
   
   gradeReceived Int?
 
@@ -507,6 +516,7 @@ model WorksheetQuestion {
   answer String
   options Json?  @default("{}")
   markScheme Json?  @default("{}")
+  order Int? @default(0)
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
   studentResponses StudentQuestionProgress[]

package/src/routers/assignment.ts

@@ -25,6 +25,10 @@ const createAssignmentSchema = z.object({
   dueDate: z.string(),
   files: z.array(directFileSchema).optional(), // Use direct file schema
   existingFileIds: z.array(z.string()).optional(),
+  acceptFiles: z.boolean().optional(),
+  acceptExtendedResponse: z.boolean().optional(),
+  acceptWorksheet: z.boolean().optional(),
+  gradeWithAI: z.boolean().optional(),
   maxGrade: z.number().optional(),
   graded: z.boolean().optional(),
   weight: z.number().optional(),
@@ -42,6 +46,10 @@ const updateAssignmentSchema = z.object({
   instructions: z.string().optional(),
   dueDate: z.string().optional(),
   files: z.array(directFileSchema).optional(), // Use direct file schema
+  acceptFiles: z.boolean().optional(),
+  acceptExtendedResponse: z.boolean().optional(),
+  acceptWorksheet: z.boolean().optional(),
+  gradeWithAI: z.boolean().optional(),
   existingFileIds: z.array(z.string()).optional(),
   removedAttachments: z.array(z.string()).optional(),
   maxGrade: z.number().optional(),
@@ -307,7 +315,7 @@ export const assignmentRouter = createTRPCRouter({
   create: protectedProcedure
     .input(createAssignmentSchema)
     .mutation(async ({ ctx, input }) => {
-      const { classId, title, instructions, dueDate, files, existingFileIds, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId, inProgress } = input;
+      const { classId, title, instructions, dueDate, files, existingFileIds, acceptFiles, acceptExtendedResponse, acceptWorksheet, gradeWithAI, maxGrade, graded, weight, sectionId, type, markSchemeId, gradingBoundaryId, inProgress } = input;
 
       if (!ctx.user) {
         throw new TRPCError({
@@ -364,7 +372,11 @@ export const assignmentRouter = createTRPCRouter({
           graded,
           weight,
           type,
-            order: 1,
+          acceptFiles,
+          acceptExtendedResponse,
+          acceptWorksheet,
+          gradeWithAI,
+          order: 1,
           inProgress: inProgress || false,
           class: {
             connect: { id: classId }
@@ -499,7 +511,7 @@ export const assignmentRouter = createTRPCRouter({
   update: protectedProcedure
     .input(updateAssignmentSchema)
     .mutation(async ({ ctx, input }) => {
-      const { id, title, instructions, dueDate, files, existingFileIds, maxGrade, graded, weight, sectionId, type, inProgress } = input;
+      const { id, title, instructions, dueDate, files, existingFileIds, maxGrade, graded, weight, sectionId, type, inProgress, acceptFiles, acceptExtendedResponse, acceptWorksheet, gradeWithAI } = input;
 
       if (!ctx.user) {
         throw new TRPCError({
@@ -590,6 +602,10 @@ export const assignmentRouter = createTRPCRouter({
           ...(weight && { weight }),
           ...(type && { type }),
           ...(inProgress !== undefined && { inProgress }),
+          ...(acceptFiles !== undefined && { acceptFiles }),
+          ...(acceptExtendedResponse !== undefined && { acceptExtendedResponse }),
+          ...(acceptWorksheet !== undefined && { acceptWorksheet }),
+          ...(gradeWithAI !== undefined && { gradeWithAI }),
           ...(sectionId !== undefined && {
             section: sectionId ? {
               connect: { id: sectionId }

package/src/routers/class.ts

@@ -669,7 +669,9 @@ export const classRouter = createTRPCRouter({
 
         const markSchemes = await prisma.markScheme.findMany({
           where: {
-            classId: classId,
+            class: {
+              id: classId,
+            },
           },
         });
 
@@ -687,7 +689,11 @@ export const classRouter = createTRPCRouter({
 
         const markScheme = await prisma.markScheme.create({
           data: {
-            classId: classId,
+            class: {
+              connect: {
+                id: classId,
+              },
+            },
             structured: validatedStructure,
           },
         });
@@ -707,7 +713,14 @@ export const classRouter = createTRPCRouter({
 
         const markScheme = await prisma.markScheme.update({
           where: { id: markSchemeId },
-          data: { structured: validatedStructure },
+          data: {
+            class: {
+              connect: {
+                id: classId,
+              },
+            },
+            structured: validatedStructure,
+          },
         });
 
         return markScheme;
@@ -735,7 +748,9 @@ export const classRouter = createTRPCRouter({
 
         const gradingBoundaries = await prisma.gradingBoundary.findMany({
           where: {
-            classId: classId,
+            class: {
+              id: classId,
+            },
           },
         });
 
@@ -753,7 +768,11 @@ export const classRouter = createTRPCRouter({
 
         const gradingBoundary = await prisma.gradingBoundary.create({
           data: {
-            classId: classId,
+            class: {
+              connect: {
+                id: classId,
+              },
+            },
             structured: validatedStructure,
           },
         });
@@ -773,7 +792,14 @@ export const classRouter = createTRPCRouter({
 
         const gradingBoundary = await prisma.gradingBoundary.update({
           where: { id: gradingBoundaryId },
-          data: { structured: validatedStructure },
+          data: {
+            class: {
+              connect: {
+                id: classId,
+              },
+            },
+            structured: validatedStructure,
+          },
         });
 
         return gradingBoundary;

package/src/routers/worksheet.ts

@@ -2,6 +2,7 @@ import { TRPCError } from "@trpc/server";
 import { createTRPCRouter, protectedProcedure } from "src/trpc";
 import { z } from "zod";
 import { prisma } from "src/lib/prisma";
+import { WorksheetQuestionType } from "@prisma/client";
 
 export const worksheetRouter = createTRPCRouter({
   // Get a single worksheet with all questions
@@ -139,6 +140,61 @@ export const worksheetRouter = createTRPCRouter({
 
       return newQuestion;
     }),
+  reorderQuestions: protectedProcedure
+    .input(z.object({
+      worksheetId: z.string(),
+      movedId: z.string(),
+      position: z.enum(['before', 'after']),
+      targetId: z.string(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      const { worksheetId, movedId, position, targetId } = input;
+
+      const worksheet = await prisma.worksheet.findUnique({
+        where: { id: worksheetId },
+      });
+
+      if (!worksheet) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Worksheet not found' });
+      }
+
+      const questions = await prisma.worksheetQuestion.findMany({
+        where: { worksheetId },
+        orderBy: { order: 'asc' },
+      });
+
+      const movedIdx = questions.findIndex(question => question.id === movedId);
+      if (movedIdx === -1) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Moved question not found' });
+      }
+
+      const targetIdx = questions.findIndex(question => question.id === targetId);
+      if (targetIdx === -1) {
+        throw new TRPCError({ code: 'NOT_FOUND', message: 'Target question not found' });
+      }
+
+      const withoutMoved = questions.filter(question => question.id !== movedId);
+
+      let next: Array<{ id: string }> = [];
+
+      if (position === 'before') {
+        next = [...withoutMoved.slice(0, targetIdx).map(item => ({ id: item.id })), { id: movedId }, ...withoutMoved.slice(targetIdx).map(item => ({ id: item.id }))];
+      } else {
+        next = [...withoutMoved.slice(0, targetIdx + 1).map(item => ({ id: item.id })), { id: movedId }, ...withoutMoved.slice(targetIdx + 1).map(item => ({ id: item.id }))];
+      }
+
+      // Update the order of each question
+      await prisma.$transaction(
+        next.map((item, index) =>
+          prisma.worksheetQuestion.update({
+            where: { id: item.id },
+            data: { order: index },
+          })
+        )
+      );
+
+      return next;
+    }),
   updateQuestion: protectedProcedure
     .input(z.object({
       worksheetId: z.string(),