@studious-lms/server 1.2.53 → 1.3.0

package/coverage/sorter.js

@@ -1,210 +0,0 @@
-/* eslint-disable */
-var addSorting = (function() {
-    'use strict';
-    var cols,
-        currentSort = {
-            index: 0,
-            desc: false
-        };
-
-    // returns the summary table element
-    function getTable() {
-        return document.querySelector('.coverage-summary');
-    }
-    // returns the thead element of the summary table
-    function getTableHeader() {
-        return getTable().querySelector('thead tr');
-    }
-    // returns the tbody element of the summary table
-    function getTableBody() {
-        return getTable().querySelector('tbody');
-    }
-    // returns the th element for nth column
-    function getNthColumn(n) {
-        return getTableHeader().querySelectorAll('th')[n];
-    }
-
-    function onFilterInput() {
-        const searchValue = document.getElementById('fileSearch').value;
-        const rows = document.getElementsByTagName('tbody')[0].children;
-
-        // Try to create a RegExp from the searchValue. If it fails (invalid regex),
-        // it will be treated as a plain text search
-        let searchRegex;
-        try {
-            searchRegex = new RegExp(searchValue, 'i'); // 'i' for case-insensitive
-        } catch (error) {
-            searchRegex = null;
-        }
-
-        for (let i = 0; i < rows.length; i++) {
-            const row = rows[i];
-            let isMatch = false;
-
-            if (searchRegex) {
-                // If a valid regex was created, use it for matching
-                isMatch = searchRegex.test(row.textContent);
-            } else {
-                // Otherwise, fall back to the original plain text search
-                isMatch = row.textContent
-                    .toLowerCase()
-                    .includes(searchValue.toLowerCase());
-            }
-
-            row.style.display = isMatch ? '' : 'none';
-        }
-    }
-
-    // loads the search box
-    function addSearchBox() {
-        var template = document.getElementById('filterTemplate');
-        var templateClone = template.content.cloneNode(true);
-        templateClone.getElementById('fileSearch').oninput = onFilterInput;
-        template.parentElement.appendChild(templateClone);
-    }
-
-    // loads all columns
-    function loadColumns() {
-        var colNodes = getTableHeader().querySelectorAll('th'),
-            colNode,
-            cols = [],
-            col,
-            i;
-
-        for (i = 0; i < colNodes.length; i += 1) {
-            colNode = colNodes[i];
-            col = {
-                key: colNode.getAttribute('data-col'),
-                sortable: !colNode.getAttribute('data-nosort'),
-                type: colNode.getAttribute('data-type') || 'string'
-            };
-            cols.push(col);
-            if (col.sortable) {
-                col.defaultDescSort = col.type === 'number';
-                colNode.innerHTML =
-                    colNode.innerHTML + '<span class="sorter"></span>';
-            }
-        }
-        return cols;
-    }
-    // attaches a data attribute to every tr element with an object
-    // of data values keyed by column name
-    function loadRowData(tableRow) {
-        var tableCols = tableRow.querySelectorAll('td'),
-            colNode,
-            col,
-            data = {},
-            i,
-            val;
-        for (i = 0; i < tableCols.length; i += 1) {
-            colNode = tableCols[i];
-            col = cols[i];
-            val = colNode.getAttribute('data-value');
-            if (col.type === 'number') {
-                val = Number(val);
-            }
-            data[col.key] = val;
-        }
-        return data;
-    }
-    // loads all row data
-    function loadData() {
-        var rows = getTableBody().querySelectorAll('tr'),
-            i;
-
-        for (i = 0; i < rows.length; i += 1) {
-            rows[i].data = loadRowData(rows[i]);
-        }
-    }
-    // sorts the table using the data for the ith column
-    function sortByIndex(index, desc) {
-        var key = cols[index].key,
-            sorter = function(a, b) {
-                a = a.data[key];
-                b = b.data[key];
-                return a < b ? -1 : a > b ? 1 : 0;
-            },
-            finalSorter = sorter,
-            tableBody = document.querySelector('.coverage-summary tbody'),
-            rowNodes = tableBody.querySelectorAll('tr'),
-            rows = [],
-            i;
-
-        if (desc) {
-            finalSorter = function(a, b) {
-                return -1 * sorter(a, b);
-            };
-        }
-
-        for (i = 0; i < rowNodes.length; i += 1) {
-            rows.push(rowNodes[i]);
-            tableBody.removeChild(rowNodes[i]);
-        }
-
-        rows.sort(finalSorter);
-
-        for (i = 0; i < rows.length; i += 1) {
-            tableBody.appendChild(rows[i]);
-        }
-    }
-    // removes sort indicators for current column being sorted
-    function removeSortIndicators() {
-        var col = getNthColumn(currentSort.index),
-            cls = col.className;
-
-        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
-        col.className = cls;
-    }
-    // adds sort indicators for current column being sorted
-    function addSortIndicators() {
-        getNthColumn(currentSort.index).className += currentSort.desc
-            ? ' sorted-desc'
-            : ' sorted';
-    }
-    // adds event listeners for all sorter widgets
-    function enableUI() {
-        var i,
-            el,
-            ithSorter = function ithSorter(i) {
-                var col = cols[i];
-
-                return function() {
-                    var desc = col.defaultDescSort;
-
-                    if (currentSort.index === i) {
-                        desc = !currentSort.desc;
-                    }
-                    sortByIndex(i, desc);
-                    removeSortIndicators();
-                    currentSort.index = i;
-                    currentSort.desc = desc;
-                    addSortIndicators();
-                };
-            };
-        for (i = 0; i < cols.length; i += 1) {
-            if (cols[i].sortable) {
-                // add the click event handler on the th so users
-                // dont have to click on those tiny arrows
-                el = getNthColumn(i).querySelector('.sorter').parentElement;
-                if (el.addEventListener) {
-                    el.addEventListener('click', ithSorter(i));
-                } else {
-                    el.attachEvent('onclick', ithSorter(i));
-                }
-            }
-        }
-    }
-    // adds sorting functionality to the UI
-    return function() {
-        if (!getTable()) {
-            return;
-        }
-        cols = loadColumns();
-        loadData();
-        addSearchBox();
-        addSortIndicators();
-        enableUI();
-    };
-})();
-
-window.addEventListener('load', addSorting);

package/src/lib/notificationHandler.ts

@@ -1,36 +0,0 @@
-import { prisma } from "./prisma.js";
-
-interface notificationData {
-    title: string,
-    content: string
-}
-
-export async function sendNotification(receiver: string, data: notificationData) {
-    const notification = await prisma.notification.create({
-        data: {
-            receiverId: receiver,
-            title: data.title,
-            content: data.content,
-        },
-    });
-    return notification;
-}
-
-export async function sendNotifications(receiverIds: Array<string>, data: notificationData) {
-    const notifications = await prisma.notification.createMany({
-        data: receiverIds.map(receiverId => ({
-            receiverId: receiverId,
-            title: data.title,
-            content: data.content,
-        })),
-    });
-    return notifications;
-}
-
-export async function markRead(id: string, read: boolean = true) {
-    const notification = await prisma.notification.update({
-        where: {id},
-        data: {read: read},
-    });
-    return notification;
-}

package/tests/announcement.test.ts

@@ -1,164 +0,0 @@
-import { test, expect, describe, beforeEach } from 'vitest';
-import { user1Caller, user2Caller } from './setup';
-import { createTRPCContext } from '../src/trpc';
-import { appRouter } from '../src/routers/_app';
-
-describe('Announcement Router', () => {
-  let testClass: any;
-  let testAnnouncement: any;
-
-  beforeEach(async () => {
-    // Create a test class
-    testClass = await user1Caller.class.create({
-      name: 'Test Class for Announcements',
-      subject: 'Mathematics',
-      section: '10th Grade',
-    });
-
-    // Create a test announcement
-    testAnnouncement = await user1Caller.announcement.create({
-      classId: testClass.id,
-      remarks: 'This is a test announcement',
-    });
-  });
-
-  describe('create', () => {
-    test('should create announcement successfully', async () => {
-      expect(testAnnouncement).toBeDefined();
-      expect(testAnnouncement.announcement).toBeDefined();
-      expect(testAnnouncement.announcement.remarks).toBe('This is a test announcement');
-      expect(testAnnouncement.announcement.teacher.id).toBeDefined();
-    });
-
-    test('should create announcement with attachments', async () => {
-      const announcement = await user1Caller.announcement.create({
-        classId: testClass.id,
-        remarks: 'Announcement with attachments',
-        files: [
-          {
-            name: 'test.pdf',
-            type: 'application/pdf',
-            size: 1024,
-          },
-        ],
-      });
-
-      expect(announcement.announcement).toBeDefined();
-      expect(announcement.announcement.attachments).toBeDefined();
-    });
-
-    test('should fail to create announcement for class user is not teacher of', async () => {
-      await expect(user2Caller.announcement.create({
-        classId: testClass.id,
-        remarks: 'Unauthorized announcement',
-      })).rejects.toThrow();
-    });
-
-    test('should fail without authentication', async () => {
-      const invalidCaller = await createTRPCContext({
-        req: { headers: {} } as any,
-        res: {} as any,
-      });
-      const router = appRouter.createCaller(invalidCaller);
-
-      await expect(router.announcement.create({
-        classId: testClass.id,
-        remarks: 'Test',
-      })).rejects.toThrow();
-    });
-  });
-
-  describe('getAll', () => {
-    test('should get all announcements for class', async () => {
-      const result = await user1Caller.announcement.getAll({
-        classId: testClass.id,
-      });
-
-      expect(result.announcements).toBeDefined();
-      expect(Array.isArray(result.announcements)).toBe(true);
-      expect(result.announcements.length).toBeGreaterThanOrEqual(1);
-      expect(result.announcements.some((a: any) => a.id === testAnnouncement.announcement.id)).toBe(true);
-    });
-
-    test('should fail to get announcements for class user is not member of', async () => {
-      await expect(user2Caller.announcement.getAll({
-        classId: testClass.id,
-      })).rejects.toThrow();
-    });
-  });
-
-  describe('get', () => {
-    test('should get single announcement successfully', async () => {
-      const announcement = await user1Caller.announcement.get({
-        id: testAnnouncement.announcement.id,
-        classId: testClass.id,
-      });
-
-      expect(announcement.announcement).toBeDefined();
-      expect(announcement.announcement.id).toBe(testAnnouncement.announcement.id);
-      expect(announcement.announcement.remarks).toBe('This is a test announcement');
-    });
-
-    test('should fail to get announcement for class user is not member of', async () => {
-      await expect(user2Caller.announcement.get({
-        id: testAnnouncement.announcement.id,
-        classId: testClass.id,
-      })).rejects.toThrow();
-    });
-  });
-
-  describe('update', () => {
-    test('should update announcement successfully', async () => {
-      const updated = await user1Caller.announcement.update({
-        id: testAnnouncement.announcement.id,
-        classId: testClass.id,
-        data: {
-          remarks: 'Updated announcement remarks',
-        },
-      });
-
-      expect(updated.announcement.remarks).toBe('Updated announcement remarks');
-    });
-
-    test('should fail to update announcement user is not teacher of', async () => {
-      await expect(user2Caller.announcement.update({
-        id: testAnnouncement.announcement.id,
-        classId: testClass.id,
-        data: {
-          remarks: 'Unauthorized update',
-        },
-      })).rejects.toThrow();
-    });
-  });
-
-  describe('delete', () => {
-    test('should delete announcement successfully', async () => {
-      // Create a new announcement to delete
-      const newAnnouncement = await user1Caller.announcement.create({
-        classId: testClass.id,
-        remarks: 'To be deleted',
-      });
-
-      const result = await user1Caller.announcement.delete({
-        id: newAnnouncement.announcement.id,
-        classId: testClass.id,
-      });
-
-      expect(result.success).toBe(true);
-
-      // Verify announcement is deleted
-      await expect(user1Caller.announcement.get({
-        id: newAnnouncement.announcement.id,
-        classId: testClass.id,
-      })).rejects.toThrow();
-    });
-
-    test('should fail to delete announcement user is not teacher of', async () => {
-      await expect(user2Caller.announcement.delete({
-        id: testAnnouncement.announcement.id,
-        classId: testClass.id,
-      })).rejects.toThrow();
-    });
-  });
-});
-

package/tests/assignment.test.ts

@@ -1,296 +0,0 @@
-import { test, expect, describe, beforeEach } from 'vitest';
-import { user1Caller, user2Caller } from './setup';
-import { createTRPCContext } from '../src/trpc';
-import { appRouter } from '../src/routers/_app';
-
-describe('Assignment Router', () => {
-  let testClass: any;
-  let testAssignment: any;
-  let studentId: string;
-
-  beforeEach(async () => {
-    // Create a test class
-    testClass = await user1Caller.class.create({
-      name: 'Test Class for Assignments',
-      subject: 'Mathematics',
-      section: '10th Grade',
-    });
-
-    // Add user2 as a student
-    const studentProfile = await user2Caller.user.getProfile();
-    studentId = studentProfile.id;
-    await user1Caller.class.addStudent({
-      classId: testClass.id,
-      studentId: studentId,
-    });
-
-    // Create a test assignment
-    const dueDate = new Date();
-    dueDate.setDate(dueDate.getDate() + 7); // Due in 7 days
-
-    testAssignment = await user1Caller.assignment.create({
-      classId: testClass.id,
-      title: 'Test Assignment',
-      instructions: 'Complete this test assignment',
-      dueDate: dueDate.toISOString(),
-      maxGrade: 100,
-      type: 'HOMEWORK',
-    });
-  });
-
-  describe('create', () => {
-    test('should create assignment successfully', async () => {
-      expect(testAssignment).toBeDefined();
-      expect(testAssignment).toBeDefined();
-      expect(testAssignment.title).toBe('Test Assignment');
-      expect(testAssignment.instructions).toBe('Complete this test assignment');
-      expect(testAssignment.maxGrade).toBe(100);
-      expect(testAssignment.type).toBe('HOMEWORK');
-    });
-
-    test('should create assignment with different types', async () => {
-      const dueDate = new Date();
-      dueDate.setDate(dueDate.getDate() + 7);
-
-      const quiz = await user1Caller.assignment.create({
-        classId: testClass.id,
-        title: 'Test Quiz',
-        instructions: 'Complete this quiz',
-        dueDate: dueDate.toISOString(),
-        type: 'QUIZ',
-        maxGrade: 50,
-      });
-
-      expect(quiz.type).toBe('QUIZ');
-      expect(quiz.maxGrade).toBe(50);
-    });
-
-    test('should create assignment with files', async () => {
-      const dueDate = new Date();
-      dueDate.setDate(dueDate.getDate() + 7);
-
-      const assignment = await user1Caller.assignment.create({
-        classId: testClass.id,
-        title: 'Assignment with Files',
-        instructions: 'Submit with files',
-        dueDate: dueDate.toISOString(),
-        acceptFiles: true,
-        files: [
-          {
-            name: 'test.pdf',
-            type: 'application/pdf',
-            size: 1024,
-          },
-        ],
-      });
-
-      expect(assignment).toBeDefined();
-    });
-
-    test('should fail to create assignment for class user is not teacher of', async () => {
-      const dueDate = new Date();
-      dueDate.setDate(dueDate.getDate() + 7);
-
-      await expect(user2Caller.assignment.create({
-        classId: testClass.id,
-        title: 'Unauthorized Assignment',
-        instructions: 'Test',
-        dueDate: dueDate.toISOString(),
-      })).rejects.toThrow();
-    });
-
-    test('should fail without authentication', async () => {
-      const invalidCaller = await createTRPCContext({
-        req: { headers: {} } as any,
-        res: {} as any,
-      });
-      const router = appRouter.createCaller(invalidCaller);
-
-      const dueDate = new Date();
-      await expect(router.assignment.create({
-        classId: testClass.id,
-        title: 'Test',
-        instructions: 'Test',
-        dueDate: dueDate.toISOString(),
-      })).rejects.toThrow();
-    });
-  });
-
-  describe('get', () => {
-    test('should get assignment successfully', async () => {
-      const assignment = await user1Caller.assignment.get({
-        id: testAssignment.id,
-        classId: testClass.id,
-      });
-
-      expect(assignment).toBeDefined();
-      expect(assignment.id).toBe(testAssignment.id);
-      expect(assignment.title).toBe('Test Assignment');
-    });
-
-    test('should allow students to get assignment', async () => {
-      const assignment = await user2Caller.assignment.get({
-        id: testAssignment.id,
-        classId: testClass.id,
-      });
-
-      expect(assignment).toBeDefined();
-    });
-
-    test('should fail to get assignment for non-class members', async () => {
-      const newClass = await user1Caller.class.create({
-        name: 'Other Class',
-        subject: 'Science',
-        section: '11th Grade',
-      });
-
-      await expect(user2Caller.assignment.get({
-        id: testAssignment.id,
-        classId: newClass.id,
-      })).rejects.toThrow();
-    });
-  });
-
-  // describe('getAll', () => {
-  //   test('should get all assignments for class', async () => {
-  //     const result = await user1Caller.assignment.get({
-  //       classId: testClass.id,
-  //     });
-
-  //     expect(result).toBeDefined();
-  //     expect(Array.isArray(result)).toBe(true);
-  //     expect(result.length).toBeGreaterThanOrEqual(1);
-  //     expect(result.some((a: any) => a.id === testAssignment.id)).toBe(true);
-  //   });
-
-  //   test('should allow students to get all assignments', async () => {
-  //     const result = await user2Caller.assignment.({
-  //       classId: testClass.id,
-  //     });
-
-  //     expect(result.assignments).toBeDefined();
-  //   });
-  // });
-
-  describe('update', () => {
-    test('should update assignment successfully', async () => {
-      const updated = await user1Caller.assignment.update({
-        classId: testClass.id,
-        id: testAssignment.id,
-        title: 'Updated Assignment Title',
-        instructions: 'Updated instructions',
-      });
-
-      expect(updated.title).toBe('Updated Assignment Title');
-      expect(updated.instructions).toBe('Updated instructions');
-    });
-
-    test('should update assignment with partial data', async () => {
-      const updated = await user1Caller.assignment.update({
-        classId: testClass.id,
-        id: testAssignment.id,
-        title: 'Partially Updated Title',
-      });
-
-      expect(updated.title).toBe('Partially Updated Title');
-      expect(updated.instructions).toBe('Complete this test assignment'); // Should remain unchanged
-    });
-
-    test('should fail to update assignment user is not teacher of', async () => {
-      await expect(user2Caller.assignment.update({
-        classId: testClass.id,
-        id: testAssignment.id,
-        title: 'Unauthorized Update',
-      })).rejects.toThrow();
-    });
-  });
-
-  describe('delete', () => {
-    test('should delete assignment successfully', async () => {
-      // Create a new assignment to delete
-      const dueDate = new Date();
-      dueDate.setDate(dueDate.getDate() + 7);
-
-      const newAssignment = await user1Caller.assignment.create({
-        classId: testClass.id,
-        title: 'To Be Deleted',
-        instructions: 'This will be deleted',
-        dueDate: dueDate.toISOString(),
-      });
-
-      const result = await user1Caller.assignment.delete({
-        id: newAssignment.id,
-        classId: testClass.id,
-      });
-
-      expect(result.id).toBe(newAssignment.id);
-
-      // Verify assignment is deleted
-      await expect(user1Caller.assignment.get({
-        id: newAssignment.id,
-        classId: testClass.id,
-      })).rejects.toThrow();
-    });
-
-    test('should fail to delete assignment user is not teacher of', async () => {
-      await expect(user2Caller.assignment.delete({
-        id: testAssignment.id,
-        classId: testClass.id,
-      })).rejects.toThrow();
-    });
-  });
-
-  describe('submit', () => {
-    test('should automatically create submission successfully', async () => {
-      // First create a submission
-      const submission = await user2Caller.assignment.getSubmission({
-        classId: testClass.id,
-        assignmentId: testAssignment.id,
-      });
-
-      expect(submission).toBeDefined();
-    });
-
-    test('should submit assignment with extended response', async () => {
-
-      const submission = await user2Caller.assignment.getSubmission({
-        classId: testClass.id,
-        assignmentId: testAssignment.id,
-      });
-
-      const updatedSubmission = await user2Caller.assignment.updateSubmission({
-        classId: testClass.id,
-        assignmentId: testAssignment.id,
-        submissionId: submission.id,
-        extendedResponse: 'This is my answer to the assignment',
-      });
-
-      expect(updatedSubmission.extendedResponse).toBe('This is my answer to the assignment');
-    });
-
-    test('should fail to submit assignment for non-class members', async () => {
-      const newClass = await user1Caller.class.create({
-        name: 'Other Class',
-        subject: 'Science',
-        section: '11th Grade',
-      });
-
-      const dueDate = new Date();
-      dueDate.setDate(dueDate.getDate() + 7);
-
-      const newAssignment = await user1Caller.assignment.create({
-        classId: newClass.id,
-        title: 'Other Assignment',
-        instructions: 'Test',
-        dueDate: dueDate.toISOString(),
-      });
-
-      await expect(user2Caller.assignment.getSubmission({
-        assignmentId: newAssignment.id,
-        classId: newClass.id,
-        submit: true,
-      })).rejects.toThrow();
-    });
-  });
-});
-