@citolab/qti-backend-firebase 0.0.3 → 0.0.5

package/dist/api/qti-teacher.js

@@ -1,11 +1,13 @@
-import { authenticateTeacher, getAppId } from "../helpers/request-headers";
-import { createSession, createSessionByIdentifications, deleteStudent, getApplication, getItemsStats, getPlannedStudents, resetSession, updateItemStatResponseScore, updateStudent, updateStudentSessionState, } from "./../helpers/logic";
+import { Router } from "express";
+import { authenticateTeacher } from "../helpers/request-headers";
+import { createDelivery, deleteDelivery, getAssessment, getAssessments, reopenSession, resetSession, processFeedbackSubmission, validateFeedbackData, saveFeedback, } from "./../helpers/logic";
 import { getDatabase } from "../helpers/db";
 import { getFirestore } from "../helpers/firebase";
-import { body, param, query } from "express-validator";
+import { body, param } from "express-validator";
 import { generalRateLimit, handleValidationErrors, heavyOperationLimit, sendError, sendSuccess, validateAssessmentId, } from "../helpers/endpoint-helpers";
-import { dateId, createCode } from "../helpers";
 import { BaseImplementation } from "./app-specific/baseImplementation";
+import { DeliveryStateEnum } from "@citolab/qti-api";
+import { sort } from "../helpers";
 // Teacher authentication middleware
 export const requireTeacherAuth = async (req, res, next) => {
     try {
@@ -14,7 +16,6 @@ export const requireTeacherAuth = async (req, res, next) => {
             return sendError(res, 401, "Teacher authentication required");
         }
         req.user = result.user;
-        req.appId = getAppId(req);
         next();
     }
     catch (error) {
@@ -22,32 +23,6 @@ export const requireTeacherAuth = async (req, res, next) => {
         return sendError(res, 500, "Authentication failed");
     }
 };
-const checkCode = async (db, groupCode) => {
-    try {
-        const firestore = getFirestore();
-        const doc = await firestore.doc(db.GROUP_DELIVERY.DOC(groupCode)).get();
-        return doc.exists;
-    }
-    catch (error) {
-        console.error("Error checking code:", error);
-        return false;
-    }
-};
-const createDelivery = async (db) => {
-    try {
-        let groupCode = createCode(4);
-        let exists = await checkCode(db, groupCode);
-        while (exists || groupCode.toLowerCase() === "aaaa") {
-            groupCode = createCode(4);
-            exists = await checkCode(db, groupCode);
-        }
-        return groupCode;
-    }
-    catch (error) {
-        console.error("Error creating activity:", error);
-        return null;
-    }
-};
 // Validation helpers
 const validateCode = (code) => {
     return (typeof code === "string" &&
@@ -55,32 +30,11 @@ const validateCode = (code) => {
         code.length <= 50 &&
         /^[a-zA-Z0-9_-]+$/.test(code));
 };
-const validateTarget = (target) => {
-    return target === "teacher" || target === "reviewer";
-};
-const parseScore = (scoreValue) => {
-    if (scoreValue === null || scoreValue === undefined || scoreValue === "") {
-        return null;
-    }
-    if (typeof scoreValue === "number") {
-        return isFinite(scoreValue) ? scoreValue : null;
-    }
-    if (typeof scoreValue === "string") {
-        // Valid integer (positive or negative)
-        if (/^-?\d+$/.test(scoreValue)) {
-            return parseInt(scoreValue, 10);
-        }
-        // Valid float
-        if (/^-?\d*\.\d+$/.test(scoreValue)) {
-            return parseFloat(scoreValue);
-        }
-    }
-    return null;
-};
 export function addQtiTeacherEndpoints(app, specificImplementation = new BaseImplementation()) {
+    const teacherRouter = Router();
     /**
      * @openapi
-     * /teacher/startGroupDelivery:
+     * /delivery/create:
      *   post:
      *     tags:
      *       - Teacher
@@ -117,124 +71,128 @@ export function addQtiTeacherEndpoints(app, specificImplementation = new BaseImp
      *       500:
      *         description: Internal server error
      */
-    app.post("/teacher/startGroupDelivery", [
+    teacherRouter.post("/delivery/create", [
         heavyOperationLimit,
         body("assessmentId").notEmpty().withMessage("Assessment ID is required"),
         handleValidationErrors,
         requireTeacherAuth,
     ], async (req, res) => {
         try {
+            const user = await authenticateTeacher(req, res);
+            const userId = user.user?.uid || "";
             const { assessmentId } = req.body;
-            const db = getDatabase(req.appId);
-            const code = await createDelivery(db);
+            const db = getDatabase();
+            const code = await createDelivery(db, userId, assessmentId);
             if (!code) {
                 return sendError(res, 500, "Failed to create activity code");
             }
             const firestore = getFirestore();
-            // Create the activity document
-            await firestore.doc(db.GROUP_DELIVERY.DOC(code)).set({
-                groupCode: code,
+            const delivery = {
                 assessmentId,
-                created: new Date().toISOString(),
-                teacherId: req.user.uid,
-                appId: req.appId,
-            });
-            return sendSuccess(res, { groupCode: code, assessmentId }, "Group delivery created successfully");
+                createdAt: new Date().getTime(),
+                updatedAt: new Date().getTime(),
+                createdBy: userId,
+                id: code,
+                state: DeliveryStateEnum.NOT_STARTED,
+            };
+            // Create the activity document
+            await firestore.doc(db.DELIVERY.DOC(code)).set(delivery);
+            return sendSuccess(res, delivery, "Group delivery created successfully");
         }
         catch (error) {
             console.error("Error creating group delivery:", error);
             return sendError(res, 500, "Failed to create group delivery");
         }
     });
+    // delete delivery
     /**
      * @openapi
-     * /teacher/assessments:
-     *   get:
+     * /delivery/delete:
+     *   post:
      *     tags:
      *       - Teacher
-     *     summary: Get all assessments
+     *     summary: Delete a delivery
+     *     requestBody:
+     *       required: true
+     *       content:
+     *         application/json:
+     *           schema:
+     *             type: object
+     *             required:
+     *               - code
+     *             properties:
+     *               code:
+     *                 type: string
+     *                 description: The delivery code to delete
      *     responses:
      *       200:
-     *         description: Returns all assessments
+     *         description: Delivery deleted successfully
+     *       400:
+     *         description: Invalid request data
      *       401:
      *         description: Unauthorized
      *       404:
-     *         description: Application not found
+     *         description: Delivery not found
      *       500:
      *         description: Internal server error
      */
-    app.get("/teacher/assessments", [generalRateLimit, requireTeacherAuth], async (req, res) => {
-        try {
-            const db = getDatabase(req.appId);
-            const application = await getApplication(db);
-            if (!application) {
-                return sendError(res, 404, "Application not found");
+    teacherRouter.post("/delivery/delete", [
+        generalRateLimit,
+        body("code").custom((value) => {
+            if (!validateCode(value)) {
+                throw new Error("Invalid code format");
             }
-            return sendSuccess(res, { assessments: application.assessments });
+            return true;
+        }),
+        handleValidationErrors,
+        requireTeacherAuth,
+    ], async (req, res) => {
+        try {
+            const { code } = req.body;
+            const db = getDatabase();
+            await deleteDelivery(db, code);
+            return sendSuccess(res, { code }, "Delivery deleted successfully");
         }
         catch (error) {
-            console.error("Error retrieving assessments:", error);
-            return sendError(res, 500, "Failed to retrieve assessments");
+            console.error("Error deleting delivery:", error);
+            return sendError(res, 500, "Failed to delete delivery");
         }
     });
     /**
      * @openapi
-     * /teacher/students:
+     * /assessments:
      *   get:
      *     tags:
      *       - Teacher
-     *     summary: Get planned sessions
+     *     summary: Get all assessments
      *     responses:
      *       200:
-     *         description: Returns planned sessions
+     *         description: Returns all assessments
      *       401:
      *         description: Unauthorized
+     *       404:
+     *         description: Application not found
      *       500:
      *         description: Internal server error
      */
-    app.get("/teacher/students", [generalRateLimit, requireTeacherAuth], async (req, res) => {
+    teacherRouter.get("/assessments", [generalRateLimit, requireTeacherAuth], async (req, res) => {
         try {
-            const db = getDatabase(req.appId);
-            const studentSessionInfos = await getPlannedStudents(db, req.user.uid);
-            return sendSuccess(res, studentSessionInfos);
+            const db = getDatabase();
+            const assessments = await getAssessments(db);
+            return sendSuccess(res, { assessments });
         }
         catch (error) {
-            console.error("Error retrieving planned students:", error);
-            return sendError(res, 500, "Failed to retrieve planned students");
-        }
-    });
-    app.get("/teacher/assessment/:assessmentId/itemStats", [
-        generalRateLimit,
-        param("assessmentId").custom((value) => {
-            if (!validateAssessmentId(value)) {
-                throw new Error("Invalid assessment ID format");
-            }
-            return true;
-        }),
-        query("role").optional().isIn(["teacher", "reviewer"]),
-        handleValidationErrors,
-        requireTeacherAuth, // You might want to make this more generic
-    ], async (req, res) => {
-        try {
-            const { assessmentId } = req.params;
-            const role = req.query.role || "teacher"; // default to teacher
-            const db = getDatabase(req.appId);
-            const studentSessionInfos = await getItemsStats(db, req.user.uid, assessmentId, role);
-            return sendSuccess(res, studentSessionInfos);
-        }
-        catch (error) {
-            console.error("Error retrieving item stats:", error);
-            return sendError(res, 500, "Failed to retrieve item statistics");
+            console.error("Error retrieving assessments:", error);
+            return sendError(res, 500, "Failed to retrieve assessments");
         }
     });
     /**
      * @openapi
-     * /teacher/log:
+     * /delivery/stop:
      *   post:
      *     tags:
      *       - Teacher
-     *     summary: Log teacher activity
-     *     description: Logs teacher activity data for debugging and analytics purposes.
+     *     summary: Stop a delivery
      *     requestBody:
      *       required: true
      *       content:
@@ -242,109 +200,92 @@ export function addQtiTeacherEndpoints(app, specificImplementation = new BaseImp
      *           schema:
      *             type: object
      *             required:
-     *               - type
-     *               - data
+     *               - code
      *             properties:
-     *               type:
+     *               code:
      *                 type: string
-     *                 minLength: 1
-     *                 maxLength: 100
-     *                 description: The type/category of the log entry
-     *               data:
-     *                 description: Any data to be logged
+     *                 description: The delivery code to stop
      *     responses:
      *       200:
-     *         description: Successfully logged the data.
+     *         description: Delivery stopped successfully
      *       400:
      *         description: Invalid request data
      *       401:
      *         description: Unauthorized
+     *       404:
+     *         description: Delivery not found
      *       500:
      *         description: Internal server error
      */
-    app.post("/teacher/log", [
+    teacherRouter.post("/delivery/stop", [
         generalRateLimit,
-        body("type")
-            .isString()
-            .trim()
-            .isLength({ min: 1, max: 100 })
-            .withMessage("Type must be a string between 1-100 characters"),
-        body("data").exists().withMessage("Data field is required"),
+        body("code").custom((value) => {
+            if (!validateCode(value)) {
+                throw new Error("Invalid code format");
+            }
+            return true;
+        }),
         handleValidationErrors,
         requireTeacherAuth,
     ], async (req, res) => {
         try {
-            const { type, data } = req.body;
-            const db = getDatabase(req.appId);
-            // Create log entry with timestamp and teacher ID
-            const logEntry = {
-                type,
-                data,
-                timestamp: new Date().toISOString(),
-                teacherId: req.user.uid,
-                appId: req.appId,
-            };
+            const { code } = req.body;
+            const db = getDatabase();
             const firestore = getFirestore();
-            await firestore
-                .doc(db.TEACHER.LOG.DOC(req.user.uid, dateId()))
-                .set(logEntry);
-            return sendSuccess(res, undefined, "Log entry created successfully");
+            const deliveryRef = firestore.doc(db.DELIVERY.DOC(code));
+            const delivery = await deliveryRef.get();
+            if (!delivery.exists) {
+                return sendError(res, 404, "Delivery not found");
+            }
+            const finishedAt = new Date().getTime();
+            await deliveryRef.update({
+                modifiedAt: finishedAt,
+                finishedAt,
+                state: "inactive",
+            });
+            return sendSuccess(res, { code, finishedAt }, "Delivery stopped successfully");
         }
         catch (error) {
-            console.error("Error creating log entry:", error);
-            return sendError(res, 500, "Failed to create log entry");
+            console.error("Error stopping delivery:", error);
+            return sendError(res, 500, "Failed to stop delivery");
         }
     });
     /**
      * @openapi
-     * /teacher/plan:
+     * /delivery/start:
      *   post:
      *     tags:
      *       - Teacher
-     *     summary: Plan sessions
+     *     summary: Restart a delivery
      *     requestBody:
      *       required: true
      *       content:
      *         application/json:
      *           schema:
      *             type: object
+     *             required:
+     *               - code
      *             properties:
-     *               count:
-     *                 type: number
-     *                 minimum: 1
-     *                 maximum: 100
-     *               assessmentIds:
-     *                 type: array
-     *                 items:
-     *                   type: string
-     *                 maxItems: 20
+     *               code:
+     *                 type: string
+     *                 description: The delivery code to restart
      *     responses:
      *       200:
-     *         description: Returns planned sessions
+     *         description: Delivery restarted successfully
      *       400:
-     *         description: Invalid request data
+     *         description: Invalid request data or delivery cannot be restarted
      *       401:
      *         description: Unauthorized
      *       404:
-     *         description: Application not found
+     *         description: Delivery not found
      *       500:
      *         description: Internal server error
      */
-    app.post("/teacher/plan", [
-        heavyOperationLimit,
-        body("count")
-            .optional()
-            .isInt({ min: 1, max: 100 })
-            .withMessage("Count must be between 1 and 100"),
-        body("assessmentIds")
-            .optional()
-            .isArray({ max: 20 })
-            .withMessage("Assessment IDs must be an array with max 20 items"),
-        body("assessmentIds.*")
-            .optional()
-            .custom((value) => {
-            if (!validateAssessmentId(value)) {
-                throw new Error("Invalid assessment ID format");
+    teacherRouter.post("/delivery/start", [
+        generalRateLimit,
+        body("code").custom((value) => {
+            if (!validateCode(value)) {
+                throw new Error("Invalid code format");
             }
             return true;
         }),
@@ -352,82 +293,51 @@ export function addQtiTeacherEndpoints(app, specificImplementation = new BaseImp
         requireTeacherAuth,
     ], async (req, res) => {
         try {
-            const { count = 1, assessmentIds = [] } = req.body;
-            const db = getDatabase(req.appId);
-            const application = await getApplication(db);
-            if (!application) {
-                return sendError(res, 404, "Application not found");
+            const { code } = req.body;
+            const db = getDatabase();
+            const firestore = getFirestore();
+            const deliveryRef = firestore.doc(db.DELIVERY.DOC(code));
+            const delivery = await deliveryRef.get();
+            if (!delivery.exists) {
+                return sendError(res, 404, "Delivery not found");
             }
-            const assessmentsToPlan = application.assessments.filter((a) => {
-                return (assessmentIds.length === 0 || assessmentIds.includes(a.assessmentId));
+            await deliveryRef.update({
+                modifiedAt: new Date().getTime(),
+                finishedAt: null,
+                state: "active",
             });
-            if (assessmentIds.length > 0 && assessmentsToPlan.length === 0) {
-                return sendError(res, 400, "No valid assessments found for the provided IDs");
-            }
-            const studentSessionInfos = await createSession(req.user.uid, db, count, assessmentsToPlan);
-            return sendSuccess(res, studentSessionInfos, "Sessions planned successfully");
+            return sendSuccess(res, { code }, "Delivery restarted successfully");
         }
         catch (error) {
-            console.error("Error planning sessions:", error);
-            return sendError(res, 500, "Failed to plan sessions");
+            console.error("Error restarting delivery:", error);
+            return sendError(res, 500, "Failed to restart delivery");
         }
     });
     /**
      * @openapi
-     * /teacher/planByIdentification:
-     *   post:
+     * /assessment/{assessmentId}/deliveries:
+     *   get:
      *     tags:
      *       - Teacher
-     *     summary: Plan sessions by identification e.g. student number
-     *     requestBody:
-     *       required: true
-     *       content:
-     *         application/json:
-     *           schema:
-     *             type: object
-     *             required:
-     *               - identifications
-     *             properties:
-     *               identifications:
-     *                 type: array
-     *                 items:
-     *                   type: string
-     *                 minItems: 1
-     *                 maxItems: 100
-     *               assessmentIds:
-     *                 type: array
-     *                 items:
-     *                   type: string
-     *                 maxItems: 20
+     *     summary: Get all deliveries for an assessment
+     *     parameters:
+     *       - in: path
+     *         name: assessmentId
+     *         required: true
+     *         schema:
+     *           type: string
+     *         description: The assessment ID
      *     responses:
      *       200:
-     *         description: Returns planned sessions
-     *       400:
-     *         description: Invalid request data
+     *         description: Returns all deliveries for the assessment
      *       401:
      *         description: Unauthorized
-     *       404:
-     *         description: Application not found
      *       500:
      *         description: Internal server error
      */
-    app.post("/teacher/planByIdentification", [
-        heavyOperationLimit,
-        body("identifications")
-            .isArray({ min: 1, max: 100 })
-            .withMessage("Identifications must be an array with 1-100 items"),
-        body("identifications.*")
-            .isString()
-            .trim()
-            .isLength({ min: 1, max: 100 })
-            .withMessage("Each identification must be 1-100 characters"),
-        body("assessmentIds")
-            .optional()
-            .isArray({ max: 20 })
-            .withMessage("Assessment IDs must be an array with max 20 items"),
-        body("assessmentIds.*")
-            .optional()
-            .custom((value) => {
+    teacherRouter.get("/assessment/:assessmentId/deliveries", [
+        generalRateLimit,
+        param("assessmentId").custom((value) => {
             if (!validateAssessmentId(value)) {
                 throw new Error("Invalid assessment ID format");
             }
@@ -437,97 +347,126 @@ export function addQtiTeacherEndpoints(app, specificImplementation = new BaseImp
         requireTeacherAuth,
     ], async (req, res) => {
         try {
-            const { identifications, assessmentIds = [] } = req.body;
-            const db = getDatabase(req.appId);
-            const application = await getApplication(db);
-            if (!application) {
-                return sendError(res, 404, "Application not found");
-            }
-            const assessmentsToPlan = application.assessments.filter((a) => {
-                return (assessmentIds.length === 0 || assessmentIds.includes(a.assessmentId));
+            const { assessmentId } = req.params;
+            const db = getDatabase();
+            const firestore = getFirestore();
+            const deliveriesQuery = firestore
+                .collection(db.DELIVERY.COLLECTION())
+                .where("assessmentId", "==", assessmentId)
+                .where("createdBy", "==", req.user.uid);
+            const deliveriesSnapshot = await deliveriesQuery.get();
+            const deliveries = deliveriesSnapshot.docs.map((doc) => {
+                return doc.data();
             });
-            if (assessmentIds.length > 0 && assessmentsToPlan.length === 0) {
-                return sendError(res, 400, "No valid assessments found for the provided IDs");
-            }
-            const studentSessionInfos = await createSessionByIdentifications(req.user.uid, db, identifications.map((i) => ({ identifier: i })), "not_started", assessmentsToPlan);
-            return sendSuccess(res, studentSessionInfos, "Sessions planned by identification successfully");
+            const sortedDeliveries = sort(deliveries, (d) => d.createdAt, true);
+            return sendSuccess(res, sortedDeliveries);
         }
         catch (error) {
-            console.error("Error planning sessions by identification:", error);
-            return sendError(res, 500, "Failed to plan sessions by identification");
+            console.error("Error retrieving deliveries:", error);
+            return sendError(res, 500, "Failed to retrieve deliveries");
         }
     });
     /**
      * @openapi
-     * /teacher/assessment/:assessmentId/itemStats/:itemIdentifier:
-     *   post:
+     * /delivery/{assessmentId}/csv:
+     *   get:
      *     tags:
      *       - Teacher
-     *     summary: Set score for an item response
+     *     summary: Download results as CSV
      *     parameters:
      *       - in: path
-     *         name: itemIdentifier
+     *         name: assessmentId
      *         required: true
      *         schema:
      *           type: string
-     *     -   in: path
-     *         name: assessmentId
-     *         required: true
+     *         description: The assessment ID
+     *       - in: query
+     *         name: deliveryCode
+     *         required: false
      *         schema:
-     *          type: string
-     *     requestBody:
-     *       required: true
-     *       content:
-     *         application/json:
-     *           schema:
-     *             type: object
-     *             required:
-     *               - responseId
-     *             properties:
-     *               responseId:
-     *                 type: string
-     *               scoreExternal:
-     *                 oneOf:
-     *                   - type: number
-     *                   - type: string
-     *                   - type: 'null'
-     *               target:
-     *                 type: string
-     *                 enum: [teacher, reviewer]
+     *           type: string
+     *         description: Optional delivery code to filter results
      *     responses:
      *       200:
-     *         description: Score updated successfully
-     *       400:
-     *         description: Invalid request data
+     *         description: Returns CSV file with results
+     *         content:
+     *           text/csv:
+     *             schema:
+     *               type: string
+     *               format: binary
      *       401:
      *         description: Unauthorized
+     *       404:
+     *         description: Assessment not found
      *       500:
      *         description: Internal server error
      */
-    app.post("/teacher/assessment/:assessmentId/itemStats/:itemIdentifier", [
+    teacherRouter.get("/delivery/:code/csv", [
         generalRateLimit,
-        param("itemIdentifier")
-            .isString()
-            .trim()
-            .isLength({ min: 1, max: 100 })
-            .matches(/^[a-zA-Z0-9_.-]+$/)
-            .withMessage("Item identifier must be alphanumeric with dots, dashes and underscores only"),
-        param("assessmentId").custom((value) => {
-            if (!validateAssessmentId(value)) {
-                throw new Error("Invalid assessment ID format");
+        param("code").custom((value) => {
+            if (!validateCode(value)) {
+                throw new Error("Invalid code format");
             }
             return true;
         }),
-        body("responseId")
-            .isString()
-            .trim()
-            .isLength({ min: 1, max: 100 })
-            .withMessage("Response ID is required and must be 1-100 characters"),
-        body("target")
-            .optional()
-            .custom((value) => {
-            if (value && !validateTarget(value)) {
-                throw new Error('Target must be either "teacher" or "reviewer"');
+        handleValidationErrors,
+        requireTeacherAuth,
+    ], async (req, res) => {
+        try {
+            const { code } = req.params;
+            const db = getDatabase();
+            // Get assessment info
+            const assessment = await getAssessment(db, code);
+            if (!assessment) {
+                return sendError(res, 404, "Assessment not found");
+            }
+            // TODO: Implement actual results retrieval and CSV generation
+            // For now, return a placeholder CSV
+            const csvHeaders = "Assessment,DeliveryCode,StudentId,StudentName,StartTime,EndTime,Score,MaxScore,Percentage,Status\n";
+            const fileName = code
+                ? `${assessment.name}_${code}_results.csv`
+                : `${assessment.name}_all_results.csv`;
+            const csvContent = code
+                ? `${csvHeaders}${assessment.name},${code},,,,,,,No results yet\n`
+                : `${csvHeaders}${assessment.name},All,,,,,,,No results yet\n`;
+            res.setHeader("Content-Type", "text/csv");
+            res.setHeader("Content-Disposition", `attachment; filename="${fileName}"`);
+            res.send(csvContent);
+        }
+        catch (error) {
+            console.error("Error downloading results:", error);
+            return sendError(res, 500, "Failed to download results");
+        }
+    });
+    /**
+     * @openapi
+     * /session/reset:
+     *   post:
+     *     tags:
+     *       - Teacher
+     *     summary: Reset session
+     *     parameters:
+     *       - in: query
+     *         name: code
+     *         required: true
+     *         schema:
+     *           type: string
+     *         description: The session code
+     *     responses:
+     *       200:
+     *         description: Session reset successfully
+     *       401:
+     *         description: Unauthorized
+     *       404:
+     *         description: Session not found
+     *       500:
+     *         description: Internal server error
+     */
+    teacherRouter.post("/session/reset", [
+        generalRateLimit,
+        param("code").custom((value) => {
+            if (!validateCode(value)) {
+                throw new Error("Invalid code format");
             }
             return true;
         }),
@@ -535,134 +474,128 @@ export function addQtiTeacherEndpoints(app, specificImplementation = new BaseImp
         requireTeacherAuth,
     ], async (req, res) => {
         try {
-            const { assessmentId, itemIdentifier } = req.params;
-            const { responseId, scoreExternal: scoreRawValue, target = "teacher", } = req.body;
-            if (!validateTarget(target)) {
-                return sendError(res, 400, 'Invalid target. Must be "teacher" or "reviewer"');
-            }
-            const scoreExternal = parseScore(scoreRawValue);
-            const db = getDatabase(req.appId);
-            await updateItemStatResponseScore(db, req.user.uid, assessmentId, itemIdentifier, responseId, scoreExternal, target);
-            return sendSuccess(res, undefined, "Score updated successfully");
+            const code = req.params.code;
+            const userId = req.user.uid;
+            const db = getDatabase();
+            await resetSession(db, userId, code);
+            return sendSuccess(res, { message: "Session reset successfully" });
         }
         catch (error) {
-            console.error("Error updating item score:", error);
-            return sendError(res, 500, "Failed to update item score");
+            console.error("Error resetting session:", error);
+            return sendError(res, 500, "Failed to reset session");
         }
     });
     /**
-     * @openapi
-     * /teacher/access:
+     * /session/reopen:
      *   post:
      *     tags:
      *       - Teacher
-     *     summary: Check if the teacher has access
-     *     description: Authenticates the teacher and checks if they have access.
+     *     summary: Reopen session
+     *     parameters:
+     *       - in: query
+     *         name: code
+     *         required: true
+     *         schema:
+     *           type: string
+     *         description: The session code
      *     responses:
      *       200:
-     *         description: Returns if the teacher has access.
+     *         description: Session reopened successfully
      *       401:
      *         description: Unauthorized
+     *       404:
+     *         description: Session not found
+     *       500:
+     *         description: Internal server error
      */
-    app.post("/teacher/access", [generalRateLimit, requireTeacherAuth], async (req, res) => {
-        return sendSuccess(res, { hasAccess: true });
+    teacherRouter.post("/session/reopen", [
+        generalRateLimit,
+        param("code").custom((value) => {
+            if (!validateCode(value)) {
+                throw new Error("Invalid code format");
+            }
+            return true;
+        }),
+        handleValidationErrors,
+        requireTeacherAuth,
+    ], async (req, res) => {
+        try {
+            const code = req.params.code;
+            const userId = req.user.uid;
+            const db = getDatabase();
+            await reopenSession(db, userId, code);
+            return sendSuccess(res, { message: "Session reopened successfully" });
+        }
+        catch (error) {
+            console.error("Error resetting session:", error);
+            return sendError(res, 500, "Failed to reset session");
+        }
     });
     /**
      * @openapi
-     * /teacher/session/update:
+     * /log:
      *   post:
      *     tags:
      *       - Teacher
-     *     summary: Update a student session
-     *     description: Updates the session information for a student.
+     *     summary: Log teacher activity
+     *     description: Logs teacher activity data for debugging and analytics purposes.
      *     requestBody:
      *       required: true
      *       content:
      *         application/json:
      *           schema:
      *             type: object
-     *             required:
-     *               - assessmentId
-     *               - code
-     *               - session
      *             properties:
-     *               assessmentId:
-     *                 type: string
-     *               code:
+     *               type:
      *                 type: string
-     *               session:
-     *                 $ref: '#/components/schemas/SessionInfoTeacher'
+     *                 description: The type/category of the log entry
+     *               data:
+     *                 description: Any data to be logged
      *     responses:
      *       200:
-     *         description: Successfully updated the session.
-     *       400:
-     *         description: Invalid request data
-     *       401:
-     *         description: Unauthorized
+     *         description: Successfully logged the data.
      *       500:
      *         description: Internal server error
      */
-    app.post("/teacher/session/update", [
+    teacherRouter.post("/log", [
         generalRateLimit,
-        body("assessmentId").custom((value) => {
-            if (!validateAssessmentId(value)) {
-                throw new Error("Invalid assessment ID format");
-            }
-            return true;
-        }),
-        body("code").custom((value) => {
-            if (!validateCode(value)) {
-                throw new Error("Invalid code format");
-            }
-            return true;
-        }),
-        body("session").isObject().withMessage("Session must be an object"),
+        body("type").isString().withMessage("Type must be a string"),
+        body("data").exists().withMessage("Data field is required"),
         handleValidationErrors,
         requireTeacherAuth,
     ], async (req, res) => {
         try {
-            const { assessmentId, code, session } = req.body;
-            const db = getDatabase(req.appId);
-            const firestore = getFirestore();
-            const batch = firestore.batch();
-            await Promise.all([
-                specificImplementation.updatePlannedSession(req.user.uid, code, session, batch),
-                updateStudentSessionState(db, code, session.assessmentId, session.sessionState, batch),
-            ]);
-            await batch.commit();
-            return sendSuccess(res, undefined, "Session updated successfully");
+            const { type, data } = req.body;
+            // Implementation would depend on your logging requirements
+            return sendSuccess(res, undefined, "Log entry created successfully");
         }
         catch (error) {
-            console.error("Error updating session:", error);
-            return sendError(res, 500, "Failed to update session");
+            console.error("Error creating log entry:", error);
+            return sendError(res, 500, "Failed to create log entry");
         }
     });
     /**
      * @openapi
-     * /teacher/session/{code}:
+     * /session/{code}:
      *   delete:
      *     tags:
      *       - Teacher
-     *     summary: Delete a students session
-     *     description: Deletes a specific session for a student.
+     *     summary: Delete student session
+     *     description: Deletes a student session.
      *     parameters:
      *       - in: path
      *         name: code
      *         required: true
      *         schema:
      *           type: string
-     *         description: The session code.
+     *         description: The session code
      *     responses:
      *       200:
-     *         description: Successfully deleted the session.
-     *       400:
-     *         description: Invalid code format
-     *       401:
-     *         description: Unauthorized
+     *         description: Successfully deleted student session.
      *       500:
      *         description: Internal server error
      */
-    app.delete("/teacher/session/:code", [
+    teacherRouter.delete("/session/:code", [
         generalRateLimit,
         param("code").custom((value) => {
             if (!validateCode(value)) {
@@ -675,48 +608,105 @@ export function addQtiTeacherEndpoints(app, specificImplementation = new BaseImp
     ], async (req, res) => {
         try {
             const { code } = req.params;
-            const db = getDatabase(req.appId);
-            await deleteStudent(db, req.user.uid, code);
-            return sendSuccess(res, undefined, "Session deleted successfully");
+            const db = getDatabase();
+            const firestore = getFirestore();
+            // Delete the session document
+            await firestore.doc(db.SESSION.DOC(code.toUpperCase())).delete();
+            return sendSuccess(res, undefined, "Student session deleted successfully");
         }
         catch (error) {
-            console.error("Error deleting session:", error);
-            return sendError(res, 500, "Failed to delete session");
+            console.error("Error deleting student session:", error);
+            return sendError(res, 500, "Failed to delete student session");
         }
     });
     /**
      * @openapi
-     * /teacher/session/reset:
+     * /student/update:
      *   post:
      *     tags:
      *       - Teacher
-     *     summary: Reset a teacher's session
-     *     description: Resets the session information for a student.
+     *     summary: Add student identification
+     *     description: Updates student identification information.
+     *     requestBody:
+     *       required: true
+     *       content:
+     *         application/json:
+     *           schema:
+     *             type: object
+     *             properties:
+     *               code:
+     *                 type: string
+     *                 description: The session code
+     *               identification:
+     *                 type: string
+     *                 description: The student identification
+     *     responses:
+     *       200:
+     *         description: Successfully updated student identification.
+     *       500:
+     *         description: Internal server error
+     */
+    teacherRouter.post("/student/update", [
+        generalRateLimit,
+        body("code").custom((value) => {
+            if (!validateCode(value)) {
+                throw new Error("Invalid code format");
+            }
+            return true;
+        }),
+        body("identification")
+            .isString()
+            .withMessage("Identification must be a string"),
+        handleValidationErrors,
+        requireTeacherAuth,
+    ], async (req, res) => {
+        try {
+            const { code, identification } = req.body;
+            const db = getDatabase();
+            const firestore = getFirestore();
+            // Update the session with identification
+            await firestore.doc(db.SESSION.DOC(code.toUpperCase())).update({
+                identification,
+                updatedAt: new Date().getTime(),
+            });
+            return sendSuccess(res, undefined, "Student identification updated successfully");
+        }
+        catch (error) {
+            console.error("Error updating student identification:", error);
+            return sendError(res, 500, "Failed to update student identification");
+        }
+    });
+    /**
+     * @openapi
+     * /session/update:
+     *   post:
+     *     tags:
+     *       - Teacher
+     *     summary: Update session
+     *     description: Updates session information.
      *     requestBody:
      *       required: true
      *       content:
      *         application/json:
      *           schema:
      *             type: object
-     *             required:
-     *               - code
-     *               - assessmentId
      *             properties:
      *               code:
      *                 type: string
+     *                 description: The session code
      *               assessmentId:
      *                 type: string
+     *                 description: The assessment ID
+     *               session:
+     *                 type: object
+     *                 description: The session data to update
      *     responses:
      *       200:
-     *         description: Successfully reset the session.
-     *       400:
-     *         description: Invalid request data
-     *       401:
-     *         description: Unauthorized
+     *         description: Successfully updated session.
      *       500:
      *         description: Internal server error
      */
-    app.post("/teacher/session/reset", [
+    teacherRouter.post("/session/update", [
         generalRateLimit,
         body("code").custom((value) => {
             if (!validateCode(value)) {
@@ -730,78 +720,227 @@ export function addQtiTeacherEndpoints(app, specificImplementation = new BaseImp
             }
             return true;
         }),
+        body("session").isObject().withMessage("Session must be an object"),
         handleValidationErrors,
         requireTeacherAuth,
     ], async (req, res) => {
         try {
-            const { code, assessmentId } = req.body;
-            const db = getDatabase(req.appId);
-            await resetSession(db, req.user.uid, code, assessmentId);
-            return sendSuccess(res, undefined, "Session reset successfully");
+            const { code, assessmentId, session } = req.body;
+            const db = getDatabase();
+            const firestore = getFirestore();
+            // Update the session
+            await firestore.doc(db.SESSION.DOC(code.toUpperCase())).update({
+                ...session,
+                assessmentId,
+                updatedAt: new Date().getTime(),
+            });
+            return sendSuccess(res, undefined, "Session updated successfully");
         }
         catch (error) {
-            console.error("Error resetting session:", error);
-            return sendError(res, 500, "Failed to reset session");
+            console.error("Error updating session:", error);
+            return sendError(res, 500, "Failed to update session");
         }
     });
     /**
      * @openapi
-     * /teacher/student/update:
+     * /plan:
      *   post:
      *     tags:
      *       - Teacher
-     *     summary: Update student information
-     *     description: Updates student information for a specific session.
+     *     summary: Plan students
+     *     description: Plans students for delivery.
      *     requestBody:
      *       required: true
      *       content:
      *         application/json:
      *           schema:
      *             type: object
-     *             required:
-     *               - code
-     *               - studentId
      *             properties:
-     *               code:
-     *                 type: string
-     *               studentId:
-     *                 type: string
+     *               count:
+     *                 type: number
+     *                 description: Number of students to plan
+     *               deliveryCodes:
+     *                 type: array
+     *                 items:
+     *                   type: string
+     *                 description: Array of delivery codes
      *     responses:
      *       200:
-     *         description: Successfully updated student information.
-     *       400:
-     *         description: Invalid request data
-     *       401:
-     *         description: Unauthorized
+     *         description: Successfully planned students.
      *       500:
      *         description: Internal server error
      */
-    app.post("/teacher/student/update", [
+    teacherRouter.post("/plan", [
         generalRateLimit,
-        body("code").custom((value) => {
-            if (!validateCode(value)) {
-                throw new Error("Invalid code format");
+        body("count")
+            .optional()
+            .isNumeric()
+            .withMessage("Count must be a number"),
+        body("deliveryCodes")
+            .optional()
+            .isArray()
+            .withMessage("Delivery codes must be an array"),
+        handleValidationErrors,
+        requireTeacherAuth,
+    ], async (req, res) => {
+        try {
+            const { count, deliveryCodes } = req.body;
+            // This would need to implement the planning logic
+            // For now, returning a placeholder implementation
+            return sendSuccess(res, [], "Students planned successfully");
+        }
+        catch (error) {
+            console.error("Error planning students:", error);
+            return sendError(res, 500, "Failed to plan students");
+        }
+    });
+    /**
+     * @openapi
+     * /students:
+     *   get:
+     *     tags:
+     *       - Teacher
+     *     summary: Get sessions
+     *     description: Retrieves all sessions for the teacher.
+     *     responses:
+     *       200:
+     *         description: Successfully retrieved sessions.
+     *       500:
+     *         description: Internal server error
+     */
+    teacherRouter.get("/students", [generalRateLimit, requireTeacherAuth], async (req, res) => {
+        try {
+            const db = getDatabase();
+            const firestore = getFirestore();
+            // Get sessions created by this teacher
+            const sessionsQuery = firestore
+                .collection(db.SESSION.COLLECTION())
+                .where("createdBy", "==", req.user.uid);
+            const sessionsSnapshot = await sessionsQuery.get();
+            const sessions = sessionsSnapshot.docs.map((doc) => doc.data());
+            return sendSuccess(res, sessions);
+        }
+        catch (error) {
+            console.error("Error retrieving sessions:", error);
+            return sendError(res, 500, "Failed to retrieve sessions");
+        }
+    });
+    /**
+     * @openapi
+     * /assessment/{assessmentId}/csv:
+     *   get:
+     *     tags:
+     *       - Teacher
+     *     summary: Download results by assessment ID
+     *     description: Downloads results as CSV for a specific assessment.
+     *     parameters:
+     *       - in: path
+     *         name: assessmentId
+     *         required: true
+     *         schema:
+     *           type: string
+     *         description: The assessment ID
+     *     responses:
+     *       200:
+     *         description: Successfully downloaded results.
+     *         content:
+     *           text/csv:
+     *             schema:
+     *               type: string
+     *               format: binary
+     *       500:
+     *         description: Internal server error
+     */
+    teacherRouter.get("/assessment/:assessmentId/csv", [
+        generalRateLimit,
+        param("assessmentId").custom((value) => {
+            if (!validateAssessmentId(value)) {
+                throw new Error("Invalid assessment ID format");
             }
             return true;
         }),
-        body("identification")
-            .isString()
-            .trim()
-            .isLength({ min: 1, max: 100 })
-            .withMessage("identification must be 1-100 characters"),
         handleValidationErrors,
         requireTeacherAuth,
     ], async (req, res) => {
         try {
-            const { code, identification } = req.body;
-            const db = getDatabase(req.appId);
-            await updateStudent(db, req.user.uid, code, identification);
-            return sendSuccess(res, undefined, "Student updated successfully");
+            const { assessmentId } = req.params;
+            // This would need to implement the CSV export logic
+            // For now, returning a placeholder
+            res.setHeader("Content-Type", "text/csv");
+            res.setHeader("Content-Disposition", `attachment; filename="assessment-${assessmentId}.csv"`);
+            res.send("Assessment ID,Student ID,Score\n"); // Placeholder CSV
+        }
+        catch (error) {
+            console.error("Error downloading results:", error);
+            return sendError(res, 500, "Failed to download results");
+        }
+    });
+    /**
+     * @openapi
+     * /feedback:
+     *   post:
+     *     tags:
+     *       - Teacher
+     *     summary: Submit teacher feedback
+     *     description: Endpoint for teachers to submit feedback with optional screenshot
+     *     requestBody:
+     *       required: true
+     *       content:
+     *         multipart/form-data:
+     *           schema:
+     *             type: object
+     *             required:
+     *               - type
+     *               - description
+     *               - feedbackId
+     *             properties:
+     *               type:
+     *                 type: string
+     *                 description: Type of feedback
+     *               description:
+     *                 type: string
+     *                 description: Feedback description
+     *               feedbackId:
+     *                 type: string
+     *                 description: Unique feedback identifier
+     *               email:
+     *                 type: string
+     *                 description: User email (optional)
+     *               pageUrl:
+     *                 type: string
+     *                 description: URL of the page where feedback was submitted
+     *               screenshot:
+     *                 type: string
+     *                 format: binary
+     *                 description: Optional screenshot file
+     *     responses:
+     *       200:
+     *         description: Feedback submitted successfully
+     *       400:
+     *         description: Missing required fields or validation error
+     *       401:
+     *         description: Authentication required
+     *       500:
+     *         description: Server error
+     */
+    teacherRouter.post("/feedback", [generalRateLimit, requireTeacherAuth], async (req, res) => {
+        try {
+            const userId = req.user.uid;
+            const { data, fileBuffer } = await processFeedbackSubmission(req);
+            // Validate the feedback data
+            const validationError = validateFeedbackData(data);
+            if (validationError) {
+                return sendError(res, 400, validationError);
+            }
+            // Save feedback with teacher user type
+            await saveFeedback(data, userId, 'teacher', fileBuffer);
+            return sendSuccess(res, undefined, "Feedback submitted successfully");
         }
         catch (error) {
-            console.error("Error updating student:", error);
-            return sendError(res, 500, "Failed to update student");
+            console.error("Error submitting teacher feedback:", error);
+            return sendError(res, 500, "An unexpected error occurred");
         }
     });
+    app.use("/teacher", teacherRouter);
 }
 //# sourceMappingURL=qti-teacher.js.map