@studious-lms/server 1.22.0 → 1.24.0

package/src/models/class.ts

@@ -190,6 +190,7 @@ const classIncludeForGet = {
   discussionsEnabled: true,
   studentsCanCreateDiscussions: true,
   studentsCanReply: true,
+  sidebarFeatures: true,
 } as const;
 
 const assignmentSelect = {

package/src/models/fees.ts

@@ -0,0 +1,349 @@
+/**
+ * Fee ledger model — FeePlan, FeeInvoice, FeePayment queries.
+ */
+import {
+  FeeInvoiceStatus,
+  FeePaymentMethod,
+  Prisma,
+} from "@prisma/client";
+import { prisma } from "../lib/prisma.js";
+
+const studentSelect = {
+  id: true,
+  username: true,
+  email: true,
+  profile: {
+    select: {
+      displayName: true,
+      profilePicture: true,
+      profilePictureThumbnail: true,
+    },
+  },
+} as const;
+
+const planSelect = {
+  id: true,
+  schoolId: true,
+  name: true,
+  description: true,
+  amountNpr: true,
+  currency: true,
+  isActive: true,
+  createdAt: true,
+  updatedAt: true,
+  _count: { select: { enrollments: true, invoices: true } },
+} as const;
+
+const invoiceSelect = {
+  id: true,
+  schoolId: true,
+  feePlanId: true,
+  studentId: true,
+  year: true,
+  month: true,
+  amountNpr: true,
+  currency: true,
+  status: true,
+  dueDate: true,
+  issuedAt: true,
+  notes: true,
+  createdAt: true,
+  updatedAt: true,
+  feePlan: { select: { id: true, name: true } },
+  student: { select: studentSelect },
+  payments: {
+    orderBy: { paidAt: "desc" as const },
+    select: {
+      id: true,
+      amountNpr: true,
+      method: true,
+      reference: true,
+      paidAt: true,
+      notes: true,
+      recordedById: true,
+    },
+  },
+} as const;
+
+export function listFeePlans(schoolId: string) {
+  return prisma.feePlan.findMany({
+    where: { schoolId },
+    orderBy: [{ isActive: "desc" }, { name: "asc" }],
+    select: planSelect,
+  });
+}
+
+export function getFeePlan(planId: string) {
+  return prisma.feePlan.findUnique({
+    where: { id: planId },
+    select: {
+      ...planSelect,
+      enrollments: {
+        select: {
+          id: true,
+          studentId: true,
+          student: { select: studentSelect },
+        },
+      },
+    },
+  });
+}
+
+export function createFeePlan(data: {
+  schoolId: string;
+  name: string;
+  description?: string | null;
+  amountNpr: number;
+  currency?: string;
+  isActive?: boolean;
+}) {
+  return prisma.feePlan.create({
+    data: {
+      schoolId: data.schoolId,
+      name: data.name,
+      description: data.description,
+      amountNpr: data.amountNpr,
+      currency: data.currency ?? "NPR",
+      isActive: data.isActive ?? true,
+    },
+    select: planSelect,
+  });
+}
+
+export function updateFeePlan(
+  planId: string,
+  data: {
+    name?: string;
+    description?: string | null;
+    amountNpr?: number;
+    isActive?: boolean;
+  }
+) {
+  return prisma.feePlan.update({
+    where: { id: planId },
+    data,
+    select: planSelect,
+  });
+}
+
+export function setFeePlanEnrollments(planId: string, studentIds: string[]) {
+  return prisma.$transaction(async (tx) => {
+    await tx.feePlanEnrollment.deleteMany({ where: { feePlanId: planId } });
+    if (studentIds.length) {
+      await tx.feePlanEnrollment.createMany({
+        data: studentIds.map((studentId) => ({ feePlanId: planId, studentId })),
+        skipDuplicates: true,
+      });
+    }
+    return tx.feePlan.findUnique({
+      where: { id: planId },
+      select: {
+        ...planSelect,
+        enrollments: {
+          select: {
+            id: true,
+            studentId: true,
+            student: { select: studentSelect },
+          },
+        },
+      },
+    });
+  });
+}
+
+export function listActiveStudentIds(schoolId: string) {
+  return prisma.schoolMembership
+    .findMany({
+      where: { schoolId, role: "STUDENT", status: "ACTIVE" },
+      select: { userId: true },
+    })
+    .then((rows) => rows.map((r) => r.userId));
+}
+
+export function listPlanEnrollmentIds(planId: string) {
+  return prisma.feePlanEnrollment
+    .findMany({
+      where: { feePlanId: planId },
+      select: { studentId: true },
+    })
+    .then((rows) => rows.map((r) => r.studentId));
+}
+
+export function createFeeInvoices(
+  rows: {
+    schoolId: string;
+    feePlanId: string;
+    studentId: string;
+    year: number;
+    month: number;
+    amountNpr: number;
+    currency: string;
+    dueDate?: Date | null;
+  }[]
+) {
+  return prisma.feeInvoice.createMany({
+    data: rows,
+    skipDuplicates: true,
+  });
+}
+
+export function listFeeInvoices(filters: {
+  schoolId: string;
+  year?: number;
+  month?: number;
+  studentId?: string;
+  feePlanId?: string;
+  status?: FeeInvoiceStatus;
+}) {
+  const where: Prisma.FeeInvoiceWhereInput = {
+    schoolId: filters.schoolId,
+  };
+  if (filters.year != null) where.year = filters.year;
+  if (filters.month != null) where.month = filters.month;
+  if (filters.studentId) where.studentId = filters.studentId;
+  if (filters.feePlanId) where.feePlanId = filters.feePlanId;
+  if (filters.status) where.status = filters.status;
+
+  return prisma.feeInvoice.findMany({
+    where,
+    orderBy: [{ year: "desc" }, { month: "desc" }, { issuedAt: "desc" }],
+    select: invoiceSelect,
+  });
+}
+
+export function getFeeInvoice(invoiceId: string) {
+  return prisma.feeInvoice.findUnique({
+    where: { id: invoiceId },
+    select: {
+      ...invoiceSelect,
+      school: {
+        select: {
+          id: true,
+          name: true,
+          letterheadFileId: true,
+          letterhead: {
+            select: { id: true, path: true, type: true, name: true },
+          },
+        },
+      },
+    },
+  });
+}
+
+export function createFeePayment(data: {
+  schoolId: string;
+  invoiceId: string;
+  amountNpr: number;
+  method: FeePaymentMethod;
+  reference?: string | null;
+  paidAt?: Date;
+  recordedById: string;
+  notes?: string | null;
+}) {
+  return prisma.feePayment.create({
+    data: {
+      schoolId: data.schoolId,
+      invoiceId: data.invoiceId,
+      amountNpr: data.amountNpr,
+      method: data.method,
+      reference: data.reference,
+      paidAt: data.paidAt,
+      recordedById: data.recordedById,
+      notes: data.notes,
+    },
+  });
+}
+
+export function sumPaymentsForInvoice(invoiceId: string) {
+  return prisma.feePayment.aggregate({
+    where: { invoiceId },
+    _sum: { amountNpr: true },
+  });
+}
+
+export function updateInvoiceStatus(invoiceId: string, status: FeeInvoiceStatus) {
+  return prisma.feeInvoice.update({
+    where: { id: invoiceId },
+    data: { status },
+  });
+}
+
+export function getFeePayment(paymentId: string) {
+  return prisma.feePayment.findUnique({
+    where: { id: paymentId },
+    include: {
+      invoice: {
+        select: {
+          ...invoiceSelect,
+          school: {
+            select: {
+              id: true,
+              name: true,
+              letterheadFileId: true,
+              letterhead: {
+                select: { id: true, path: true, type: true, name: true },
+              },
+            },
+          },
+        },
+      },
+      recordedBy: {
+        select: {
+          id: true,
+          username: true,
+          profile: { select: { displayName: true } },
+        },
+      },
+    },
+  });
+}
+
+export async function listStudentBalances(schoolId: string) {
+  const invoices = await prisma.feeInvoice.findMany({
+    where: {
+      schoolId,
+      status: { in: ["UNPAID", "PARTIAL"] },
+    },
+    select: {
+      studentId: true,
+      amountNpr: true,
+      student: { select: studentSelect },
+      payments: { select: { amountNpr: true } },
+    },
+  });
+
+  const byStudent = new Map<
+    string,
+    {
+      student: (typeof invoices)[number]["student"];
+      invoicedNpr: number;
+      paidNpr: number;
+      balanceNpr: number;
+      openInvoiceCount: number;
+    }
+  >();
+
+  for (const inv of invoices) {
+    const paid = inv.payments.reduce((s, p) => s + p.amountNpr, 0);
+    const balance = Math.max(0, inv.amountNpr - paid);
+    const existing = byStudent.get(inv.studentId);
+    if (existing) {
+      existing.invoicedNpr += inv.amountNpr;
+      existing.paidNpr += paid;
+      existing.balanceNpr += balance;
+      existing.openInvoiceCount += 1;
+    } else {
+      byStudent.set(inv.studentId, {
+        student: inv.student,
+        invoicedNpr: inv.amountNpr,
+        paidNpr: paid,
+        balanceNpr: balance,
+        openInvoiceCount: 1,
+      });
+    }
+  }
+
+  return Array.from(byStudent.entries())
+    .map(([studentId, row]) => ({ studentId, ...row }))
+    .sort((a, b) => b.balanceNpr - a.balanceNpr);
+}

package/src/models/marketplace.ts

@@ -0,0 +1,158 @@
+/**
+ * MarketplaceListing data access — B1 v1 (markschemes, worksheets, files).
+ * Isolated Marketplace* tables only; no Attendance/Fee coupling.
+ */
+import type {
+  MarketplaceListingType,
+  MarketplaceVisibility,
+  Prisma,
+} from "@prisma/client";
+import { prisma } from "../lib/prisma.js";
+
+export const marketplaceListingInclude = {
+  author: {
+    select: {
+      id: true,
+      username: true,
+      profile: { select: { displayName: true } },
+    },
+  },
+  school: { select: { id: true, name: true } },
+} as const;
+
+export type MarketplaceListingWithRelations = Prisma.MarketplaceListingGetPayload<{
+  include: typeof marketplaceListingInclude;
+}>;
+
+export async function createMarketplaceListing(data: {
+  type: MarketplaceListingType;
+  title: string;
+  description?: string | null;
+  authorId: string;
+  schoolId?: string | null;
+  visibility: MarketplaceVisibility;
+  markSchemeId?: string | null;
+  worksheetId?: string | null;
+  fileId?: string | null;
+  payload: Prisma.InputJsonValue;
+  tags?: string[];
+}) {
+  return prisma.marketplaceListing.create({
+    data: {
+      type: data.type,
+      title: data.title,
+      description: data.description ?? null,
+      authorId: data.authorId,
+      schoolId: data.schoolId ?? null,
+      visibility: data.visibility,
+      markSchemeId: data.markSchemeId ?? null,
+      worksheetId: data.worksheetId ?? null,
+      fileId: data.fileId ?? null,
+      payload: data.payload,
+      tags: data.tags ?? [],
+    },
+    include: marketplaceListingInclude,
+  });
+}
+
+export async function findMarketplaceListingById(id: string) {
+  return prisma.marketplaceListing.findUnique({
+    where: { id },
+    include: marketplaceListingInclude,
+  });
+}
+
+export async function searchMarketplaceListings(input: {
+  schoolIds: string[];
+  type?: MarketplaceListingType;
+  search?: string;
+  tags?: string[];
+  cursor?: string;
+  limit: number;
+  /** When true, include the caller's own hidden listings (for authors). */
+  authorId?: string;
+}) {
+  const search = input.search?.trim();
+  const where: Prisma.MarketplaceListingWhereInput = {
+    AND: [
+      {
+        OR: [
+          { visibility: "PUBLIC", isHidden: false },
+          {
+            visibility: "SCHOOL",
+            isHidden: false,
+            schoolId: { in: input.schoolIds },
+          },
+          // Authors can always see their own listings (including hidden).
+          ...(input.authorId ? [{ authorId: input.authorId }] : []),
+        ],
+      },
+      ...(input.type ? [{ type: input.type }] : []),
+      ...(input.tags?.length
+        ? [{ tags: { hasSome: input.tags } }]
+        : []),
+      ...(search
+        ? [
+            {
+              OR: [
+                { title: { contains: search, mode: "insensitive" as const } },
+                {
+                  description: {
+                    contains: search,
+                    mode: "insensitive" as const,
+                  },
+                },
+                { tags: { has: search } },
+              ],
+            },
+          ]
+        : []),
+    ],
+  };
+
+  const rows = await prisma.marketplaceListing.findMany({
+    where,
+    include: marketplaceListingInclude,
+    orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+    take: input.limit + 1,
+    ...(input.cursor
+      ? {
+          cursor: { id: input.cursor },
+          skip: 1,
+        }
+      : {}),
+  });
+
+  let nextCursor: string | undefined;
+  if (rows.length > input.limit) {
+    const next = rows.pop();
+    nextCursor = next?.id;
+  }
+
+  return { items: rows, nextCursor };
+}
+
+export async function incrementMarketplaceReportCount(id: string) {
+  return prisma.marketplaceListing.update({
+    where: { id },
+    data: { reportCount: { increment: 1 } },
+    select: { id: true, reportCount: true, isHidden: true },
+  });
+}
+
+export async function setMarketplaceListingHidden(
+  id: string,
+  isHidden: boolean
+) {
+  return prisma.marketplaceListing.update({
+    where: { id },
+    data: { isHidden },
+    include: marketplaceListingInclude,
+  });
+}
+
+export async function deleteMarketplaceListing(id: string, authorId: string) {
+  return prisma.marketplaceListing.deleteMany({
+    where: { id, authorId },
+  });
+}

package/src/models/moduleItem.ts

@@ -0,0 +1,107 @@
+/**
+ * ModuleItem model – Canvas-style pages / file collections / videos in a section.
+ */
+import { prisma } from "../lib/prisma.js";
+import type { ModuleItemType } from "@prisma/client";
+import {
+  classMemberOrSchoolAdminWhere,
+  classTeacherOrSchoolAdminWhere,
+} from "./access.js";
+
+const moduleItemInclude = {
+  files: {
+    select: {
+      id: true,
+      name: true,
+      type: true,
+      size: true,
+      path: true,
+      uploadStatus: true,
+    },
+  },
+  section: {
+    select: { id: true, name: true, classId: true, color: true },
+  },
+} as const;
+
+export function findModuleItemsByClassId(classId: string) {
+  return prisma.moduleItem.findMany({
+    where: { section: { classId } },
+    include: moduleItemInclude,
+    orderBy: [{ section: { order: "asc" } }, { order: "asc" }],
+  });
+}
+
+export function findModuleItemsBySectionId(sectionId: string) {
+  return prisma.moduleItem.findMany({
+    where: { sectionId },
+    include: moduleItemInclude,
+    orderBy: { order: "asc" },
+  });
+}
+
+export function findModuleItemByIdForMember(id: string, userId: string) {
+  return prisma.moduleItem.findFirst({
+    where: {
+      id,
+      section: { class: classMemberOrSchoolAdminWhere(userId) },
+    },
+    include: moduleItemInclude,
+  });
+}
+
+export function findModuleItemByIdForTeacher(id: string, userId: string) {
+  return prisma.moduleItem.findFirst({
+    where: {
+      id,
+      section: { class: classTeacherOrSchoolAdminWhere(userId) },
+    },
+    include: moduleItemInclude,
+  });
+}
+
+export function createModuleItem(data: {
+  sectionId: string;
+  title: string;
+  type: ModuleItemType;
+  body?: string | null;
+  order?: number | null;
+  published?: boolean;
+}) {
+  return prisma.moduleItem.create({
+    data,
+    include: moduleItemInclude,
+  });
+}
+
+export function updateModuleItem(
+  id: string,
+  data: {
+    title?: string;
+    body?: string | null;
+    order?: number | null;
+    published?: boolean;
+    type?: ModuleItemType;
+    sectionId?: string;
+  }
+) {
+  return prisma.moduleItem.update({
+    where: { id },
+    data,
+    include: moduleItemInclude,
+  });
+}
+
+export function deleteModuleItem(id: string) {
+  return prisma.moduleItem.delete({ where: { id } });
+}
+
+export function attachFilesToModuleItem(
+  moduleItemId: string,
+  fileIds: string[]
+) {
+  return prisma.file.updateMany({
+    where: { id: { in: fileIds } },
+    data: { moduleItemId },
+  });
+}