@studious-lms/server 1.11.0 → 1.13.0

package/src/services/adminInstitution.ts

@@ -0,0 +1,140 @@
+import type { Prisma } from '@prisma/client';
+import { prisma } from '../lib/prisma.js';
+
+export async function listSchoolsForAdmin(input: {
+  page: number;
+  pageSize: number;
+  query?: string;
+}) {
+  const skip = input.page * input.pageSize;
+  const where: Prisma.SchoolWhereInput = {};
+  const q = input.query?.trim();
+  if (q) {
+    where.OR = [
+      { name: { contains: q, mode: 'insensitive' } },
+      { subdomain: { contains: q, mode: 'insensitive' } },
+      { description: { contains: q, mode: 'insensitive' } },
+    ];
+  }
+
+  const [items, total] = await Promise.all([
+    prisma.school.findMany({
+      where,
+      orderBy: { createdAt: 'desc' },
+      skip,
+      take: input.pageSize,
+      include: {
+        _count: {
+          select: {
+            memberships: true,
+            classes: true,
+            departments: true,
+          },
+        },
+      },
+    }),
+    prisma.school.count({ where }),
+  ]);
+
+  return {
+    items,
+    total,
+    page: input.page,
+    pageSize: input.pageSize,
+    pageCount: Math.max(1, Math.ceil(total / input.pageSize)),
+  };
+}
+
+export async function listDepartmentsForAdmin(input: {
+  page: number;
+  pageSize: number;
+  schoolId?: string;
+}) {
+  const skip = input.page * input.pageSize;
+  const where: Prisma.DepartmentWhereInput = {};
+  if (input.schoolId) where.schoolId = input.schoolId;
+
+  const [items, total] = await Promise.all([
+    prisma.department.findMany({
+      where,
+      orderBy: [{ schoolId: 'asc' }, { name: 'asc' }],
+      skip,
+      take: input.pageSize,
+      include: {
+        school: { select: { id: true, name: true, subdomain: true } },
+        _count: { select: { classes: true, members: true } },
+      },
+    }),
+    prisma.department.count({ where }),
+  ]);
+
+  return {
+    items,
+    total,
+    page: input.page,
+    pageSize: input.pageSize,
+    pageCount: Math.max(1, Math.ceil(total / input.pageSize)),
+  };
+}
+
+export async function listSchoolDevelopmentProgramsForAdmin(input: {
+  page: number;
+  pageSize: number;
+  status?: string;
+  query?: string;
+}) {
+  const skip = input.page * input.pageSize;
+  const where: Prisma.SchoolDevelopementProgramWhereInput = {};
+  if (input.status?.trim()) where.status = input.status.trim();
+  const q = input.query?.trim();
+  if (q) {
+    where.OR = [
+      { name: { contains: q, mode: 'insensitive' } },
+      { city: { contains: q, mode: 'insensitive' } },
+      { country: { contains: q, mode: 'insensitive' } },
+      { contactEmail: { contains: q, mode: 'insensitive' } },
+    ];
+  }
+
+  const [items, total] = await Promise.all([
+    prisma.schoolDevelopementProgram.findMany({
+      where,
+      orderBy: { submittedAt: 'desc' },
+      skip,
+      take: input.pageSize,
+    }),
+    prisma.schoolDevelopementProgram.count({ where }),
+  ]);
+
+  return {
+    items,
+    total,
+    page: input.page,
+    pageSize: input.pageSize,
+    pageCount: Math.max(1, Math.ceil(total / input.pageSize)),
+  };
+}
+
+export async function listEarlyAccessRequestsForAdmin(input: {
+  page: number;
+  pageSize: number;
+}) {
+  const skip = input.page * input.pageSize;
+
+  const [items, total] = await Promise.all([
+    prisma.earlyAccessRequest.findMany({
+      orderBy: { createdAt: 'desc' },
+      skip,
+      take: input.pageSize,
+    }),
+    prisma.earlyAccessRequest.count(),
+  ]);
+
+  return {
+    items,
+    total,
+    page: input.page,
+    pageSize: input.pageSize,
+    pageCount: Math.max(1, Math.ceil(total / input.pageSize)),
+  };
+}

package/src/services/adminRunJob.ts

@@ -0,0 +1,46 @@
+import type { Prisma, RunJobStatus, RunJobType } from '@prisma/client';
+import { TRPCError } from '@trpc/server';
+import { prisma } from '../lib/prisma.js';
+
+export async function listRunJobsForAdmin(input: {
+  page: number;
+  pageSize: number;
+  status?: RunJobStatus;
+  type?: RunJobType;
+}) {
+  const { page, pageSize, status, type } = input;
+  const skip = page * pageSize;
+
+  const where: Prisma.RunJobWhereInput = {};
+  if (status) where.status = status;
+  if (type) where.type = type;
+
+  const [items, total] = await Promise.all([
+    prisma.runJob.findMany({
+      where,
+      orderBy: { createdAt: 'desc' },
+      skip,
+      take: pageSize,
+    }),
+    prisma.runJob.count({ where }),
+  ]);
+
+  return {
+    items,
+    total,
+    page,
+    pageSize,
+    pageCount: Math.max(1, Math.ceil(total / pageSize)),
+  };
+}
+
+export async function getRunJobForAdmin(id: string) {
+  const job = await prisma.runJob.findUnique({ where: { id } });
+  if (!job) {
+    throw new TRPCError({
+      code: 'NOT_FOUND',
+      message: 'Run job not found',
+    });
+  }
+  return job;
+}

package/src/services/assignment.ts

@@ -26,6 +26,7 @@ import { deleteFile } from "../lib/googleCloudStorage.js";
 import { sendToMultiple } from "./notification.js";
 import { enqueueRunJob } from "../workers/queues.js";
 import { logger } from "../utils/logger.js";
+import { invalidateStudentProgressInferenceCache } from "./studentProgressInferenceCache.js";
 
 export async function assignmentExists(id: string) {
   const assignment = await findAssignmentById(id);
@@ -424,12 +425,13 @@ export async function updateAssignmentRecord(
     });
   }
 
-  const submissionData =
-    input.studentIds?.length
-      ? input.studentIds.map((studentId) => ({ student: { connect: { id: studentId } } }))
-      : classData?.students.map((student) => ({
-          student: { connect: { id: student.id } },
-        }));
+  const submissionData = input.studentIds
+    ? (input.studentIds.length > 0
+        ? input.studentIds.map((studentId) => ({ student: { connect: { id: studentId } } }))
+        : classData?.students.map((student) => ({
+            student: { connect: { id: student.id } },
+          })))
+    : undefined;
 
   if (input.removedAttachments?.length) {
     const filesToDelete = assignment.attachments.filter((f) =>
@@ -480,7 +482,7 @@ export async function updateAssignmentRecord(
         connect: input.studentIds.map((id) => ({ id })),
       },
     }),
-    ...(submissionData && {
+    ...(input.studentIds && submissionData && {
       submissions: {
         deleteMany: {},
         create: submissionData,
@@ -892,7 +894,7 @@ export async function updateSubmissionAsTeacherRecord(
     );
   }
 
-  return prisma.submission.update({
+  const updated = await prisma.submission.update({
     where: { id: submissionId },
     data: {
       ...(gradeReceived !== undefined && { gradeReceived }),
@@ -906,6 +908,15 @@ export async function updateSubmissionAsTeacherRecord(
     },
     include: submissionTeacherInclude,
   });
+
+  if (gradeReceived !== undefined) {
+    invalidateStudentProgressInferenceCache(
+      submission.assignment.classId,
+      submission.studentId,
+    );
+  }
+
+  return updated;
 }
 
 export async function attachAssignmentToEventRecord(

package/src/services/class.ts

@@ -26,6 +26,7 @@ import {
   createClassByImport,
 } from "../models/class.js";
 import { Class, Folder } from "@prisma/client";
+import { invalidateStudentProgressInferenceCache } from "./studentProgressInferenceCache.js";
 
 async function requireActiveSchoolMembers(schoolId: string, userIds: string[]) {
   const uniqueUserIds = [...new Set(userIds)];
@@ -74,6 +75,9 @@ export async function getAllClasses(userId: string) {
       schoolId: cls.schoolId ?? null,
       school: cls.school ?? null,
       department: cls.department ?? null,
+      discussionsEnabled: cls.discussionsEnabled,
+      studentsCanCreateDiscussions: cls.studentsCanCreateDiscussions,
+      studentsCanReply: cls.studentsCanReply,
     })).filter((cls) => cls.members.some((member) => member.id === userId)),
     studentInClass: studentClasses.map((cls) => ({
       id: cls.id,
@@ -81,12 +85,24 @@ export async function getAllClasses(userId: string) {
       section: cls.section,
       subject: cls.subject,
       dueToday: cls.assignments,
-      assignments: cls.assignments,
+      assignments: cls.assignments.map((assignment) => ({
+        ...assignment,
+        late: new Date(assignment.dueDate) < new Date(),
+        submitted: assignment.submissions.find(
+          (s) => s.studentId === userId,
+        )?.submitted ?? false,
+        returned: assignment.submissions.find(
+          (s) => s.studentId === userId,
+        )?.returned ?? false,
+      })),
       members: [...cls.students, ...cls.teachers],
       color: cls.color,
       schoolId: cls.schoolId ?? null,
       school: cls.school ?? null,
       department: cls.department ?? null,
+      discussionsEnabled: cls.discussionsEnabled,
+      studentsCanCreateDiscussions: cls.studentsCanCreateDiscussions,
+      studentsCanReply: cls.studentsCanReply,
     })),
   };
 }
@@ -171,6 +187,9 @@ export async function updateClass(
     subject?: string;
     color?: string;
     departmentId?: string | null;
+    discussionsEnabled?: boolean;
+    studentsCanCreateDiscussions?: boolean;
+    studentsCanReply?: boolean;
   }
 ) {
   if (data.departmentId !== undefined) {
@@ -209,6 +228,9 @@ export async function updateClass(
       subject: true,
       color: true,
       departmentId: true,
+      discussionsEnabled: true,
+      studentsCanCreateDiscussions: true,
+      studentsCanReply: true,
     },
   });
   return { updatedClass };
@@ -498,10 +520,15 @@ export async function updateGrade(
           title: true,
           maxGrade: true,
           weight: true,
+          classId: true,
         },
       },
     },
   });
+  invalidateStudentProgressInferenceCache(
+    updatedSubmission.assignment.classId,
+    updatedSubmission.studentId,
+  );
   return updatedSubmission;
 }
 

package/src/services/comment.ts

@@ -158,6 +158,28 @@ export async function deleteComment(userId: string, id: string) {
   return { success: true };
 }
 
+/** Pin or unpin a comment. Only teachers can pin comments. */
+export async function pinComment(userId: string, commentId: string, isPinned: boolean) {
+  const comment = await requireCommentAccess(commentId, userId);
+  if (comment.parentCommentId) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Only top-level comments can be pinned",
+    });
+  }
+  if (!isClassTeacher(comment, userId)) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only teachers can pin comments",
+    });
+  }
+  const updated = await prisma.comment.update({
+    where: { id: commentId },
+    data: { isPinned },
+  });
+  return updated;
+}
+
 /** Add or update a reaction (emoji) on a comment. */
 export async function addReaction(
   userId: string,

package/src/services/conversation.ts

@@ -15,6 +15,7 @@ import {
   findConversationByIdAndMember,
   createConversationMember,
   hideConversationMember,
+  unhideConversationMember,
   deleteConversationMember,
 } from "../models/conversation.js";
 
@@ -160,10 +161,14 @@ export async function createConversationRecord(
     });
 
     if (existingDM) {
-      throw new TRPCError({
-        code: "BAD_REQUEST",
-        message: `A conversation with ${targetUser.username} already exists`,
-      });
+      const userMembership = existingDM.members.find(
+        (m) => m.userId === userId
+      );
+      if (userMembership) {
+        await unhideConversationMember(userId, existingDM.id);
+      }
+      const conversation = await findConversationByIdAndMember(existingDM.id, userId);
+      return conversation!;
     }
   }