@citolab/qti-backend-firebase 0.0.4 → 0.0.5

package/dist/helpers/logic.js

@@ -3,8 +3,10 @@ import fs from "fs/promises";
 import mime from "mime";
 import { createCode, removeDoubleSlashes } from "./utils";
 import { DATABASE } from "./database";
+import { v4 as uuidv4 } from "uuid";
 import { deleteFilesRecursive } from "./storage";
 import NodeCache from "node-cache";
+import Busboy from "busboy";
 export async function uploadFolderToStorage(folder, storageDestinationPath, uploadFiles, subfolder) {
     const storage = getStorage();
     const bucket = storage.bucket();
@@ -33,37 +35,71 @@ export async function uploadFolderToStorage(folder, storageDestinationPath, uplo
         }
     }
 }
-const applicationInfoCache = new NodeCache({
-    stdTTL: 60 * 5, // 5 minutes
-});
 const userIdCode = new NodeCache({
     stdTTL: 60 * 20, // 20 minutes
 });
-export const getStudentSessionInfo = async (code, db, userId) => {
+export const getTestsetSessions = async (testsetCode, db) => {
+    if (!testsetCode || !db)
+        return null;
+    const firestore = getFirestore();
+    const snapshot = await firestore
+        .doc(db.TESTSET_SESSIONS.DOC(testsetCode))
+        .get();
+    return snapshot.exists ? snapshot.data() : null;
+};
+export const getTestsetSessionWithSessions = async (testsetCode, db, userId) => {
+    if (!testsetCode || !db)
+        return null;
+    const firestore = getFirestore();
+    // Get the testset session from the testsetsessions collection
+    const testsetSessionDoc = await firestore
+        .doc(db.TESTSET_SESSIONS.DOC(testsetCode))
+        .get();
+    if (!testsetSessionDoc.exists) {
+        return null;
+    }
+    const testsetSession = testsetSessionDoc.data();
+    if (!testsetSession ||
+        !testsetSession.sessionIds ||
+        testsetSession.sessionIds.length === 0) {
+        return { ...testsetSession, sessions: [], userId };
+    }
+    // Retrieve all test sessions based on the sessionIds field
+    const sessionPromises = testsetSession.sessionIds.map((sessionId) => firestore.doc(db.SESSION.DOC(sessionId)).get());
+    const sessionDocs = await Promise.all(sessionPromises);
+    const sessions = sessionDocs
+        .filter((doc) => doc.exists)
+        .map((doc) => doc.data());
+    // Return the testset session with the populated sessions
+    return {
+        ...testsetSession,
+        sessions,
+        userId,
+    };
+};
+export const getSession = async (code, db, userId) => {
     if (!code || !db)
         return null;
-    const application = await getApplication(db);
-    if ((application?.demoCodes || []).includes(code)) {
-        const allAssessments = await getAssessments(db);
+    const assessments = await getAssessments(db);
+    const matchAssessmentDemoId = assessments.find((a) => a.demoCode === code);
+    if (matchAssessmentDemoId) {
         return {
-            appId: db.appId,
             code,
-            sessions: allAssessments.map((a) => {
-                return {
-                    assessmentId: a.assessmentId,
-                    assessmentName: a.name,
-                    packageId: a.packageId,
-                    sessionState: "not_started",
-                };
-            }),
-            assessment: allAssessments.length ? allAssessments[0] : null,
-            state: "not_started",
+            deliveryId: "<DEMO_DELIVERY_ID>",
+            assessmentId: matchAssessmentDemoId.id,
+            id: uuidv4(),
+            createdAt: new Date().getTime(),
+            updatedAt: new Date().getTime(),
+            createdBy: userId || null,
+            assessmentName: matchAssessmentDemoId.name,
+            packageId: matchAssessmentDemoId.packageId,
+            sessionState: "not_started",
             isDemo: true,
             teacherId: "demo-teacher",
         };
     }
     const firestore = getFirestore();
-    const doc = await firestore.doc(db.STUDENT.DOC(code)).get();
+    const doc = await firestore.doc(db.SESSION.DOC(code)).get();
     if (userId && doc.exists) {
         const firestore = getFirestore();
         // store the mapping between the user and the code so on refresh we can get the code by the user
@@ -71,116 +107,26 @@ export const getStudentSessionInfo = async (code, db, userId) => {
     }
     return doc.exists ? doc.data() : null;
 };
-export const getStudentGroupSessionInfo = async (groupCode, db, userId, studentIdentification) => {
-    if (!groupCode || !db || !userId)
+export const getDelivery = async (code, db) => {
+    if (!code)
         return null;
     const firestore = getFirestore();
-    // Check if the group code exists in the assessment codes collection
-    const groupDeliveryDoc = await firestore
-        .doc(db.GROUP_DELIVERY.DOC(groupCode))
-        .get();
-    if (!groupDeliveryDoc.exists) {
-        return null;
-    }
-    const assessment = groupDeliveryDoc.data();
-    const fullAssessment = await getAssessmentTest(db, assessment.assessmentId);
-    // Create the mapping between user and code
-    await firestore.doc(db.STUDENT_USER_ID_MAPPING.DOC(userId)).set({
-        code: groupCode,
-    });
-    // Create/update student info entry
-    const studentDocRef = firestore.doc(db.STUDENT.DOC(userId)); // Assuming nested structure
-    const studentInfo = {
-        appId: db.appId || "unknown",
-        code: groupCode,
-        currentAssessmentId: "",
-        identification: studentIdentification || "",
-        sessions: [],
-        isDemo: false,
-        teacherId: fullAssessment.teacherId || "unknown_teacher",
-        userId: userId,
-    };
-    // Get assessment details
-    const assessments = await getStartableAssessments(db);
-    if (assessments && assessments.length > 0) {
-        if (!studentInfo.currentAssessmentId) {
-            studentInfo.currentAssessmentId = assessment.assessmentId;
-        }
-        studentInfo.sessions = [
-            {
-                assessmentId: assessment.assessmentId,
-                assessmentName: assessment.name,
-                packageId: assessment.packageId,
-                sessionState: "not_started",
-            },
-        ];
-    }
-    await studentDocRef.set(studentInfo);
-    return studentInfo;
+    const doc = await firestore.doc(db.DELIVERY.DOC(code)).get();
+    return doc.exists ? doc.data() : null;
 };
-export const updateStudentSessionState = async (db, code, assessmentId, state, batch) => {
+export const updateSessionState = async (db, code, state, batch) => {
     if (!code || !db)
         return null;
     const firestore = getFirestore();
-    const studentDocRef = firestore.doc(db.STUDENT.DOC(code));
-    const student = (await studentDocRef.get())?.data();
-    if (student) {
-        const updatedStudent = {
-            ...student,
-            sessions: student.sessions.map((s) => s.assessmentId === assessmentId ? { ...s, sessionState: state } : s),
+    const sessionDocRef = firestore.doc(db.SESSION.DOC(code));
+    const session = (await sessionDocRef.get())?.data();
+    if (session) {
+        const updatedSession = {
+            ...session,
+            sessionState: state,
         };
-        batch.set(studentDocRef, updatedStudent);
-    }
-};
-export const createAssessmentCode = async (db, charCount, assessmentId, application) => {
-    let code = createCode(charCount);
-    let exists = !!(await codeExists(code, db));
-    while (exists) {
-        code = createCode(charCount);
-        exists =
-            (application?.demoCodes || []).includes(code) ||
-                !!(await codeExists(code, db));
+        batch.set(sessionDocRef, updatedSession);
     }
-    const firestore = getFirestore();
-    const assessmentData = await firestore
-        .doc(db.ASSESSMENT.DOC(assessmentId))
-        .get();
-    if (assessmentData.exists) {
-        const assessmentInfo = assessmentData.data();
-        await firestore.doc(db.GROUP_DELIVERY.DOC(code)).set(assessmentInfo);
-        return code;
-    }
-    else {
-        return null;
-    }
-};
-export const createDemoCodeForAssessment = async (db, assessmentId, code) => {
-    const exists = !!(await codeExists(code, db));
-    if (exists) {
-        return;
-    }
-    const firestore = getFirestore();
-    const assessmentData = await firestore
-        .doc(db.ASSESSMENT.DOC(assessmentId))
-        .get();
-    const assessmentInfo = assessmentData.data();
-    await firestore
-        .doc(db.GROUP_DELIVERY.DOC(code))
-        .set({ ...assessmentInfo, isDemo: true });
-    return code;
-};
-export const checkAssessmentCode = async (db, code) => {
-    const firestore = getFirestore();
-    if (!code || !db)
-        return null;
-    const application = await getApplication(db);
-    if ((application?.demoCodes || []).includes(code)) {
-        return {};
-    }
-    const assessmentInfo = await firestore.doc(db.GROUP_DELIVERY.DOC(code));
-    const doc = await assessmentInfo.get();
-    const assessment = doc.data();
-    return assessment;
 };
 export const isStartable = (asessment) => {
     if (asessment.startFrom) {
@@ -197,184 +143,307 @@ export const isStartable = (asessment) => {
     }
     return true;
 };
-export const getCodeByUserId = async (db, userId) => {
-    const key = `${db.appId}-${userId}`;
-    const cached = userIdCode.get(key);
-    if (cached) {
-        return cached;
+export const checkDeliveryCode = async (db, deliveryCode) => {
+    try {
+        const firestore = getFirestore();
+        const doc = await firestore.doc(db.DELIVERY.DOC(deliveryCode)).get();
+        return doc.exists;
     }
-    const firestore = getFirestore();
-    const doc = await firestore.doc(db.STUDENT_USER_ID_MAPPING.DOC(userId)).get();
-    const code = doc.exists ? doc.data().code : null;
-    if (code) {
-        userIdCode.set(key, code);
+    catch (error) {
+        console.error("Error checking code:", error);
+        return false;
     }
-    return code;
 };
-export const getTeacherIdByCode = async (db, code) => {
-    const key = `${db.appId}-${code}`;
-    const cached = userIdCode.get(key);
-    if (cached) {
-        return cached;
+export const checkTestsetCode = async (db, testsetCode) => {
+    try {
+        const firestore = getFirestore();
+        const doc = await firestore.doc(db.TESTSET_SESSIONS.DOC(testsetCode)).get();
+        return doc.exists;
     }
-    const firestore = getFirestore();
-    const doc = await firestore.doc(db.STUDENT.DOC(code)).get();
-    const teacherId = doc.exists
-        ? doc.data().teacherId
-        : null;
-    if (teacherId) {
-        userIdCode.set(key, teacherId);
+    catch (error) {
+        console.error("Error checking code:", error);
+        return false;
     }
-    return teacherId;
 };
-export const getApplicationInfo = async (db) => {
-    const cached = applicationInfoCache.get(db.appId || "application");
-    if (cached) {
-        return cached;
+export const checkSessionCode = async (db, studentCode) => {
+    try {
+        const firestore = getFirestore();
+        const doc = await firestore.doc(db.SESSION.DOC(studentCode)).get();
+        return doc.exists;
     }
-    const firestore = getFirestore();
-    const doc = await firestore.doc(db.APPLICATION.DOC()).get();
-    if (doc.exists) {
-        const applicationInfo = doc.data();
-        applicationInfoCache.set(db.appId || "application", applicationInfo);
-        return applicationInfo;
+    catch (error) {
+        console.error("Error checking code:", error);
+        return false;
     }
 };
-export const addApplicationInfo = async (db, appInfo) => {
-    const firestore = getFirestore();
-    const docRef = firestore.doc(db.APPLICATION.DOC());
-    await docRef.set(appInfo);
+export const deleteDelivery = async (db, deliveryId) => {
+    try {
+        const firestore = getFirestore();
+        const docRef = firestore.doc(db.DELIVERY.DOC(deliveryId));
+        await docRef.delete();
+    }
+    catch (error) {
+        console.error("Error deleting delivery:", error);
+    }
 };
-export const getApplication = async (db) => {
-    const firestore = getFirestore();
-    const docRef = firestore.doc(db.APPLICATION.DOC());
-    const applicationRef = await docRef.get();
-    const application = applicationRef.exists
-        ? applicationRef.data()
-        : {
-            name: db.appId,
+export const createDelivery = async (db, userId, assessmentId) => {
+    try {
+        await getAssessment(db, assessmentId); // Ensure assessment exists
+        const firestore = getFirestore();
+        const docRef = firestore.collection(db.DELIVERY.COLLECTION()).doc();
+        const deliveryCode = await createUniqueCodeForDelivery(db);
+        const newDelivery = {
+            id: uuidv4(),
+            code: deliveryCode,
+            createdBy: userId,
+            state: "not_started",
+            assessmentId,
+            createdAt: new Date().getTime(),
+            updatedAt: new Date().getTime(),
         };
-    if (application &&
-        (!application.assessments || !application.assessments.length)) {
-        const assessments = await getAssessments(db);
-        if (!applicationRef.exists && assessments.length === 0) {
-            return null;
-        }
-        application.assessments = assessments;
+        await docRef.set(newDelivery);
+        return docRef.id;
+    }
+    catch (error) {
+        console.error("Error creating delivery:", error);
+        return null;
     }
-    return application;
-};
-export const codeExists = async (code, db) => {
-    const studentSessions = await getStudentSessionInfo(code, db, undefined);
-    return studentSessions;
 };
-export const hasAccess = async (uid, appId) => {
+export const createSessionForDelivery = async (db, userId, delivery) => {
     const firestore = getFirestore();
-    const docRef = firestore.doc(new DATABASE().AUTH.CHECK_APP_RIGHTS(uid, appId.toLowerCase()));
-    const doc = await docRef.get();
-    return doc.exists;
+    const assessment = await getAssessment(db, delivery.assessmentId);
+    const uniqueCode = await createUniqueCodeForStudentSession(db);
+    if (!uniqueCode) {
+        console.error("Failed to create unique code for student session");
+        return;
+    }
+    const session = {
+        assessmentId: delivery.assessmentId,
+        deliveryId: delivery.id,
+        createdBy: userId,
+        createdAt: new Date().getTime(),
+        updatedAt: new Date().getTime(),
+        assessmentName: assessment.name,
+        code: uniqueCode,
+        id: uniqueCode,
+        packageId: assessment.packageId,
+        sessionState: "not_started",
+        assessmentHref: assessment.assessmentHref,
+    };
+    await firestore.doc(db.SESSION.DOC(uniqueCode)).set(session);
+    return session;
 };
-// TODO: sessionState should be default on not_started. For snelkookpan specific move to specific logig
-export const createSession = async (teacherId, db, count, assessments) => {
+export const testsetSessionCodeExists = async (code, db) => {
+    return checkTestsetCode(db, code);
+};
+export const sessionCodeExists = async (code, db) => {
+    return checkSessionCode(db, code);
+};
+export const deliveryCodeExists = async (code, db) => {
+    return checkDeliveryCode(db, code);
+};
+export const createTestsetSessionByIdentifications = async (teacherId, db, testsetCode, identifications, 
+// studentTestSessionCodes: { code: string; password?: string }[],
+testsessionState = "not_started", sessionState = "not_started", createPassword = false) => {
     const firestore = getFirestore();
-    const application = await getApplication(db);
-    const codes = new Array(count).fill(createCode(5));
-    const studentAppSessionInfos = [];
     const batch = firestore.batch();
-    for (let code of codes) {
-        // check if code does not exists twice in codes array
-        const isGeneratedTwice = codes.filter((c) => c === code).length > 1;
-        let exists = (await codeExists(code, db)) || isGeneratedTwice;
+    const allCreatedSessions = [];
+    const allCreatedTestsetSessions = [];
+    const assessments = [];
+    const testset = await getTestset(testsetCode, db);
+    for (const assessmentId of testset.assessmentIds) {
+        const assessment = await getAssessment(db, assessmentId);
+        if (assessment) {
+            assessments.push(assessment);
+        }
+    }
+    for (const identificationCode of identifications) {
+        // for (const studentCode of studentTestSessionCodes) {
+        const exists = await getTestsetSessions(identificationCode, db);
+        if (!exists) {
+            const password = createPassword ? createCode(4, "alphabetic") : undefined;
+            const testsetSession = {
+                id: identificationCode,
+                teacherId,
+                code: identificationCode,
+                createdAt: new Date().getTime(),
+                createdBy: teacherId,
+                updatedAt: new Date().getTime(),
+                state: testsessionState,
+                sessionIds: [],
+                password,
+                testsetId: testsetCode,
+                identification: "",
+            };
+            for (const assessmentId of testset.assessmentIds) {
+                const uniqueCode = await createUniqueCodeForStudentSession(db);
+                if (!uniqueCode) {
+                    console.error("Failed to create unique code for student session");
+                    return;
+                }
+                const assessment = assessments.find((a) => a.id === assessmentId);
+                const session = {
+                    id: uniqueCode,
+                    assessmentId,
+                    deliveryId: teacherId,
+                    createdBy: teacherId,
+                    createdAt: new Date().getTime(),
+                    updatedAt: new Date().getTime(),
+                    assessmentName: assessment?.name || "",
+                    packageId: assessment?.packageId || "",
+                    teacherId,
+                    assessmentHref: assessment?.assessmentHref,
+                    testsetSessionId: identificationCode,
+                    sessionState,
+                    code: uniqueCode,
+                };
+                if (!testsetSession.sessionIds) {
+                    testsetSession.sessionIds = [];
+                }
+                testsetSession.sessionIds.push(session.id);
+                batch.set(firestore.doc(db.SESSION.DOC(session.id)), session);
+                // now add them to the teacher view model
+                const teacherDocPath = db.TEACHER.SESSIONS.DOC(teacherId, session.code);
+                batch.set(firestore.doc(teacherDocPath), session);
+                allCreatedSessions.push(session);
+            }
+            batch.set(firestore.doc(db.TESTSET_SESSIONS.DOC(testsetSession.id)), testsetSession);
+            allCreatedTestsetSessions.push(testsetSession);
+        }
+    }
+    await batch.commit();
+    return {
+        session: allCreatedSessions,
+        testsetSessions: allCreatedTestsetSessions,
+    };
+};
+export const createUniqueCodeForDelivery = async (db) => {
+    // Create a unique delivery code if must be unique among students and deliveries
+    // each student session gets a unique code to be able to restart.
+    try {
+        let code = createCode(4);
+        let exists = await deliveryCodeExists(code, db);
+        while (exists) {
+            code = createCode(4);
+            exists = await deliveryCodeExists(code, db);
+        }
+        return code;
+    }
+    catch (error) {
+        console.error("Error creating activity:", error);
+        throw error;
+    }
+};
+export const createUniqueCodeForStudentSession = async (db) => {
+    // Create a unique delivery code if must be unique among students and deliveries
+    // each student session gets a unique code to be able to restart.
+    try {
+        let code = createCode(5);
+        let exists = await sessionCodeExists(code, db);
         while (exists) {
             code = createCode(5);
-            exists = !!((application?.demoCodes || []).includes(code) ||
-                (await codeExists(code, db)));
+            exists = await sessionCodeExists(code, db);
         }
-        const studentSessionInfo = {
-            teacherId,
-            code,
-            appId: db.appId || "application",
-            sessions: assessments.map((assessment) => ({
-                assessmentId: assessment.assessmentId,
-                assessmentName: assessment.name,
-                packageId: assessment.packageId,
-                sessionState: assessment.assessmentId.startsWith("practice")
-                    ? "not_generated"
-                    : "not_available",
-            })),
-            isDemo: false,
-        };
-        studentAppSessionInfos.push(studentSessionInfo);
-        const teacherResult = {
-            code,
-            sessions: studentSessionInfo.sessions.map((session) => ({
-                code,
-                assessmentId: session.assessmentId,
-                sessionState: session.sessionState,
-                testScore: 0,
-            })),
-        };
-        batch.set(firestore.doc(db.STUDENT.DOC(code)), studentSessionInfo);
-        // now add them to the teacher view model
-        const teacherDocPath = db.TEACHER.STUDENTS.DOC(teacherId, teacherResult.code);
-        batch.set(firestore.doc(teacherDocPath), teacherResult);
+        return code;
     }
-    await batch.commit();
-    return studentAppSessionInfos;
+    catch (error) {
+        console.error("Error creating activity:", error);
+        throw error;
+    }
+};
+export const createUniqueCodeForStudentTestsetSession = async (db) => {
+    // Create a unique delivery code if must be unique among students and deliveries
+    // each student session gets a unique code to be able to restart.
+    try {
+        let code = createCode(5);
+        let exists = await testsetSessionCodeExists(code, db);
+        while (exists) {
+            code = createCode(5);
+            exists = await testsetSessionCodeExists(code, db);
+        }
+        return code;
+    }
+    catch (error) {
+        console.error("Error creating activity:", error);
+        return null;
+    }
+};
+export const hasAccess = async (uid, appId) => {
+    // Always return true since we removed applicationId-based access control
+    return true;
 };
-export const createSessionByIdentifications = async (teacherId, db, identifications, sessionState, assessments) => {
+export const createSessions = async (teacherId, deliveryCode, db, count, deliveryIds) => {
     const firestore = getFirestore();
-    const studentAppSessionInfos = [];
     const batch = firestore.batch();
-    for (const identification of identifications) {
-        const exists = await codeExists(identification.identifier, db);
-        if (!exists) {
-            const studentSessionInfo = {
+    const sessionList = [];
+    const assessments = [];
+    for (const deliveryId of deliveryIds) {
+        const delivery = await getDelivery(deliveryCode, db);
+        if (!delivery) {
+            console.error(`Delivery with ID ${deliveryId} not found`);
+            continue;
+        }
+        let assessment = assessments.find((a) => a.id === delivery.assessmentId);
+        if (!assessment) {
+            assessment = await getAssessment(db, delivery.assessmentId);
+            if (assessment) {
+                assessments.push(assessment);
+            }
+            else {
+                console.error(`Assessment with ID ${delivery.assessmentId} not found`);
+                continue;
+            }
+        }
+        const codes = new Array(count).fill(createCode(5));
+        for (let code of codes) {
+            // check if code does not exists twice in codes array
+            const isGeneratedTwice = codes.filter((c) => c === code).length > 1;
+            let exists = (await deliveryCodeExists(code, db)) || isGeneratedTwice;
+            while (exists) {
+                code = createCode(5);
+                exists = !!(await deliveryCodeExists(code, db));
+                // TODO, we must check the assessment demo code as well.
+                // but for now these codes can be generated with at least one char that are not used in createCode,
+                // like AEOIU1
+            }
+            const id = uuidv4();
+            const plannedSessions = {
+                id,
+                code,
+                deliveryId,
                 teacherId,
-                code: identification.identifier,
-                appId: db.appId || "application",
-                sessions: assessments.map((assessment) => ({
-                    assessmentId: assessment.assessmentId,
-                    assessmentName: assessment.name,
-                    packageId: assessment.packageId,
-                    sessionState,
-                })),
+                createdAt: new Date().getTime(),
+                updatedAt: new Date().getTime(),
+                createdBy: teacherId || "",
+                assessmentId: assessment.id,
+                assessmentName: assessment.name,
+                packageId: assessment.packageId,
+                sessionState: assessment.id.startsWith("practice")
+                    ? "not_generated"
+                    : "not_available",
                 isDemo: false,
             };
-            if (identification.password) {
-                studentSessionInfo.password = identification.password;
-            }
-            studentAppSessionInfos.push(studentSessionInfo);
-            const teacherResult = {
-                code: identification.identifier,
-                sessions: studentSessionInfo.sessions.map((session) => ({
-                    code: identification.identifier,
-                    assessmentId: session.assessmentId,
-                    sessionState: session.sessionState,
-                    testScore: 0,
-                })),
-            };
-            batch.set(firestore.doc(db.STUDENT.DOC(identification.identifier)), studentSessionInfo);
-            // now add them to the teacher view model
-            const teacherDocPath = db.TEACHER.STUDENTS.DOC(teacherId, teacherResult.code);
-            batch.set(firestore.doc(teacherDocPath), teacherResult);
+            sessionList.push(plannedSessions);
+        }
+        for (const session of sessionList) {
+            batch.set(firestore.doc(db.SESSION.DOC(session.code)), session);
+            batch.set(firestore.doc(db.TEACHER.SESSIONS.DOC(teacherId, session.code)), session);
         }
     }
     await batch.commit();
-    return studentAppSessionInfos;
+    return sessionList;
 };
 export const getAllStudents = async (db) => {
     const firestore = getFirestore();
     const docs = await firestore
-        .collection(db.STUDENT.COLLECTION())
+        .collection(db.SESSION.COLLECTION())
         .listDocuments();
-    const studentInfos = [];
+    const studentSessions = [];
     for (const doc of docs) {
         const studentInfo = await doc.get();
-        studentInfos.push(studentInfo.data() ||
-            { code: doc.id });
+        studentSessions.push(studentInfo.data() || { code: doc.id });
     }
-    return studentInfos;
+    return studentSessions;
 };
 export const getAssessments = async (db) => {
     const firestore = getFirestore();
@@ -384,29 +453,7 @@ export const getAssessments = async (db) => {
     const assessments = assessmentData.docs.map((doc) => doc.data());
     return assessments;
 };
-export const getStartableAssessments = async (db) => {
-    const application = await getApplication(db);
-    if (!application) {
-        return [];
-    }
-    const startableAssessments = application.assessments.filter((a) => {
-        if (a.startFrom) {
-            const startFrom = new Date(a.startFrom);
-            if (startFrom > new Date()) {
-                return false;
-            }
-        }
-        if (a.endAt) {
-            const startUntil = new Date(a.endAt);
-            if (startUntil < new Date()) {
-                return false;
-            }
-        }
-        return a.canStart !== false;
-    });
-    return startableAssessments;
-};
-export const getAssessmentTest = async (db, assessmentId) => {
+export const getAssessment = async (db, assessmentId) => {
     const firestore = getFirestore();
     const assessmentDoc = await firestore
         .doc(db.ASSESSMENT.DOC(assessmentId))
@@ -420,6 +467,14 @@ export const getAssessmentTest = async (db, assessmentId) => {
     }
     return assessmentData;
 };
+export const getTestset = async (testsetId, db) => {
+    const firestore = getFirestore();
+    const testsetDoc = await firestore.doc(db.TESTSET.DOC(testsetId)).get();
+    if (!testsetDoc.exists) {
+        throw new Error(`Testset with ID ${testsetId} does not exist.`);
+    }
+    return testsetDoc.data();
+};
 export const getAssessmentItemRefsFromPackage = async ($assessmentTest) => {
     //let regularItemCount = 0;
     let itemCount = 0;
@@ -441,7 +496,7 @@ export const getAssessmentItemRefsFromPackage = async ($assessmentTest) => {
 };
 export const getItemsStats = async (db, teacherId, assessmentId, target) => {
     const firestore = getFirestore();
-    const assessmentDoc = await getAssessmentTest(db, assessmentId);
+    const assessmentDoc = await getAssessment(db, assessmentId);
     if (!assessmentDoc) {
         throw new Error(`Assessment with ID ${assessmentId} does not exist.`);
     }
@@ -500,44 +555,39 @@ export const updateItemStatResponseScore = async (db, teacherId, assessmentId, i
 export const getPlannedStudents = async (db, teacherId) => {
     const firestore = getFirestore();
     const studentResultCollectionRef = await firestore
-        .collection(db.TEACHER.STUDENTS.COLLECTION(teacherId))
+        .collection(db.TEACHER.SESSIONS.COLLECTION(teacherId))
         .get();
     // StudentResult.
     const studentSessionInfo = studentResultCollectionRef.docs.map((doc) => doc.data());
-    const studentsToReturn = [];
     let prevSessionState = "";
-    for (const student of studentSessionInfo) {
-        const sessionsToReturn = [];
-        for (const session of student.sessions) {
-            if (session.sessionState === "not_generated" &&
-                session.assessmentId === "practice" &&
-                prevSessionState === "scored") {
-                session.sessionState = "not_available";
-            }
-            else if (session.assessmentId === "practice-2" &&
-                (session.sessionState === "not_generated" ||
-                    session.sessionState === "not_available") &&
-                prevSessionState === "scored") {
-                session.sessionState = "not_started";
-            }
-            prevSessionState = session.sessionState;
-            sessionsToReturn.push(session);
+    const sessionsToReturn = [];
+    for (const session of studentSessionInfo) {
+        if (session.sessionState === "not_generated" &&
+            session.assessmentId === "practice" &&
+            prevSessionState === "scored") {
+            session.sessionState = "not_available";
+        }
+        else if (session.assessmentId === "practice-2" &&
+            (session.sessionState === "not_generated" ||
+                session.sessionState === "not_available") &&
+            prevSessionState === "scored") {
+            session.sessionState = "not_started";
         }
-        const updatedStudent = { ...student, sessions: sessionsToReturn };
-        studentsToReturn.push(updatedStudent);
+        prevSessionState = session.sessionState;
+        sessionsToReturn.push(session);
     }
-    return studentsToReturn;
+    return sessionsToReturn;
 };
 export const getPlannedStudent = async (db, teacherId, code) => {
     const firestore = getFirestore();
     const studentResultRef = await firestore
-        .doc(db.TEACHER.STUDENTS.DOC(teacherId, code))
+        .doc(db.TEACHER.SESSIONS.DOC(teacherId, code))
         .get();
     return studentResultRef.data();
 };
 export const deleteStudent = async (db, teacherId, code) => {
     const firestore = getFirestore();
-    const studentRef = await firestore.doc(db.TEACHER.STUDENTS.DOC(teacherId, code));
+    const studentRef = await firestore.doc(db.TEACHER.SESSIONS.DOC(teacherId, code));
     const assessments = await firestore
         .collection(db.ASSESSMENT.COLLECTION())
         .get();
@@ -558,61 +608,52 @@ export const setUser = async (uid, user) => {
     const firestore = getFirestore();
     await firestore.doc(new DATABASE().AUTH.DOC(uid)).set(user);
 };
-export const resetSession = async (db, teacherId, code, assessmentId) => {
+export const reopenSession = async (db, teacherId, code) => {
     const firestore = getFirestore();
-    const studentRef = await firestore
-        .doc(db.TEACHER.STUDENTS.DOC(teacherId, code))
-        .get();
-    const student = studentRef.data();
-    const updatedStudent = {
-        ...student,
-        sessions: student.sessions.map((s) => s.assessmentId === assessmentId
-            ? { ...s, sessionState: "not_started" }
-            : s),
-    };
-    await studentRef.ref.set(updatedStudent);
+    const batch = firestore.batch();
+    batch.update(firestore.doc(db.TEACHER.SESSIONS.DOC(teacherId, code)), {
+        sessionState: "not_started",
+    });
+    batch.update(firestore.doc(db.SESSION.DOC(code)), {
+        sessionState: "not_started",
+    });
+    await batch.commit();
+};
+export const resetSession = async (db, teacherId, code) => {
+    const firestore = getFirestore();
+    const batch = firestore.batch();
+    batch.update(firestore.doc(db.TEACHER.SESSIONS.DOC(teacherId, code)), {
+        sessionState: "not_started",
+    });
+    batch.update(firestore.doc(db.SESSION.DOC(code)), {
+        sessionState: "not_started",
+    });
+    batch.delete(firestore.doc(db.SESSION.DOC(code)));
+    await batch.commit();
 };
 export const getStudentInfoForTeacher = async (db, teacherId, code) => {
     const firestore = getFirestore();
     const studentRef = await firestore
-        .doc(db.TEACHER.STUDENTS.DOC(teacherId, code))
+        .doc(db.TEACHER.SESSIONS.DOC(teacherId, code))
         .get();
     const student = studentRef.data();
     return student;
 };
-export const updateStudent = async (db, teacherId, code, identification) => {
+export const updateStudentIdentification = async (db, teacherId, code, identification) => {
     const firestore = getFirestore();
-    const studentRef = await firestore
-        .doc(db.TEACHER.STUDENTS.DOC(teacherId, code))
-        .get();
-    const student = studentRef.data();
-    const updatedStudent = {
-        ...student,
+    const batch = firestore.batch();
+    batch.update(firestore.doc(db.TEACHER.SESSIONS.DOC(teacherId, code)), {
         identification,
-    };
-    await studentRef.ref.set(updatedStudent);
-};
-export const getAllApplications = async () => {
-    const firestore = getFirestore();
-    const applicationCollection = await firestore
-        .collection(new DATABASE().APPLICATION.COLLECTION)
-        .get();
-    const applications = applicationCollection.docs.map((doc) => {
-        const app = doc.data();
-        if (!app.name) {
-            app.name = doc.id;
-        }
-        return app;
     });
-    return applications;
+    batch.update(firestore.doc(db.SESSION.DOC(code)), { identification });
+    await batch.commit();
 };
 const createStrongPassword = () => {
     const password = Math.random().toString(36).slice(-8);
     return password;
 };
-export const createUserForApplication = async (email, applicationId) => {
+export const createUser = async (email) => {
     const auth = getAuth();
-    const firestore = getFirestore();
     let password = "";
     let firebaseUser = undefined;
     try {
@@ -628,13 +669,7 @@ export const createUserForApplication = async (email, applicationId) => {
             password,
         });
     }
-    await firestore
-        .doc(new DATABASE().AUTH.CHECK_APP_RIGHTS(firebaseUser.uid, applicationId))
-        .set({
-        email,
-        application: applicationId.toLocaleLowerCase(),
-        userId: firebaseUser.uid,
-    });
+    // No longer need to set application-specific permissions
     if (password) {
         return { password, id: firebaseUser.uid };
     }
@@ -642,61 +677,25 @@ export const createUserForApplication = async (email, applicationId) => {
         return { id: firebaseUser.uid };
     }
 };
-export const deleteUserForApplication = async (id, applicationId) => {
+export const deleteUser = async (id) => {
     const auth = getAuth();
-    const firestore = getFirestore();
-    // check application right. If the user has rights to just this application then the user can be deleted.
-    // otherwise we remove the user from firebase Authentication
-    const applicationDocs = await firestore
-        .collection(new DATABASE().AUTH.APP_COLLECTION(id))
-        .listDocuments();
-    const applicationIds = applicationDocs.map((a) => a.id.toLocaleLowerCase());
-    if (!applicationIds.includes(applicationId.toLocaleLowerCase())) {
-        return;
-    }
-    await firestore
-        .doc(new DATABASE().AUTH.CHECK_APP_RIGHTS(id, applicationId))
-        .delete();
-    if (applicationIds.length === 1) {
-        await auth.deleteUser(id);
-    }
+    // Simply delete the user from Firebase Auth
+    await auth.deleteUser(id);
     return;
 };
-export const getAllApplicationsWithUsers = async () => {
-    const firestore = getFirestore();
-    const applications = await getAllApplications();
-    const userDocs = await firestore
-        .collection(new DATABASE().AUTH.COLLECTION)
-        .listDocuments();
-    const usersPerApplication = new Map();
-    const allUserIds = userDocs.map((u) => u.id);
-    const users = await fetchUsersInChunks(allUserIds);
-    for (const userId of allUserIds) {
-        const applicationsForUser = await firestore
-            .collection(new DATABASE().AUTH.APP_COLLECTION(userId))
-            .listDocuments();
-        for (const applicationId of applicationsForUser.map((a) => a.id.toLowerCase())) {
-            const userData = users.find((u) => u.id === userId);
-            const user = {
-                id: userId,
-                email: userData?.email || "",
-                disabled: userData?.disabled || false,
-            };
-            if (usersPerApplication.has(applicationId)) {
-                usersPerApplication.get(applicationId)?.push(user);
-            }
-            else {
-                usersPerApplication.set(applicationId, [user]);
-            }
-        }
-    }
-    const applicationWithUsers = applications.map((a) => {
-        return {
-            ...a,
-            users: usersPerApplication.get(a.name?.toLocaleLowerCase()) || [],
-        };
-    });
-    return applicationWithUsers;
+export const getAllUsers = async () => {
+    const userDocs = await getAuth().listUsers();
+    const users = userDocs.users.map((user) => ({
+        id: user.uid,
+        email: user.email || "",
+        disabled: user.disabled || false,
+    }));
+    return [
+        {
+            name: "default",
+            users: users,
+        },
+    ];
 };
 export async function deleteDocumentAndSubcollections(docRef) {
     // Delete the document
@@ -720,7 +719,7 @@ export async function checkAndDeletePackages(dateTime) {
     const packages = packageData.docs.map((doc) => doc.data());
     for (const packageInfo of packages) {
         if (packageInfo.uploaded < dateTime) {
-            for (const { assessmentId } of packageInfo.assessmentInfo) {
+            for (const { assessmentId } of packageInfo.Assessment) {
                 await deleteDocumentAndSubcollections(firestore.doc(db.ASSESSMENT.DOC(assessmentId)));
             }
             await deleteFilesRecursive(storage.bucket(), `packages/${packageInfo.packageId}`);
@@ -750,11 +749,121 @@ export async function fetchUsersInChunks(ids, chunkSize = 100) {
     }
     return results;
 }
-export const getPackageIdByAssessment = async (db, code, assessmentId) => {
-    const fs = getFirestore();
-    const docRef = await fs.doc(db.STUDENT.DOC(code)).get();
-    const studentInfo = docRef.data();
-    const session = studentInfo.sessions.find((s) => s.assessmentId === assessmentId);
-    return session?.packageId || null;
-};
+/**
+ * Processes feedback submission with optional screenshot
+ * @param req - Express request object
+ * @param userId - User ID who is submitting feedback
+ * @param userType - Type of user ('teacher' or 'student')
+ * @returns Promise<{data: FeedbackSubmissionData, fileBuffer: Buffer | null, fileOriginalname: string | null}>
+ */
+export function processFeedbackSubmission(req) {
+    return new Promise((resolve, reject) => {
+        const busboy = Busboy({ headers: req.headers });
+        const fields = {};
+        let fileBuffer = null;
+        let fileOriginalname = null;
+        busboy.on("field", (fieldname, val) => {
+            fields[fieldname] = val;
+        });
+        busboy.on("file", (fieldname, file, filename) => {
+            if (fieldname === "screenshot") {
+                const chunks = [];
+                fileOriginalname = filename.filename || filename;
+                file.on("data", (data) => {
+                    chunks.push(data);
+                });
+                file.on("end", () => {
+                    if (chunks.length) {
+                        fileBuffer = Buffer.concat(chunks);
+                    }
+                });
+            }
+            else {
+                // Discard other files
+                file.resume();
+            }
+        });
+        busboy.on("finish", () => {
+            const { type, description, feedbackId, email, pageUrl } = fields;
+            resolve({
+                data: { type, description, feedbackId, email, pageUrl },
+                fileBuffer,
+                fileOriginalname,
+            });
+        });
+        busboy.on("error", (error) => {
+            reject(error);
+        });
+        // Handle the request
+        if (req.rawBody) {
+            // For Firebase Functions
+            busboy.end(req.rawBody);
+        }
+        else {
+            // For regular Express
+            req.pipe(busboy);
+        }
+    });
+}
+/**
+ * Validates feedback submission data
+ * @param data - Feedback data to validate
+ * @returns Validation error message or null if valid
+ */
+export function validateFeedbackData(data) {
+    const { type, description, feedbackId } = data;
+    if (!type || !description || !feedbackId) {
+        return "Missing required fields: type, description, and feedbackId are required";
+    }
+    if (type.length < 1 || type.length > 50) {
+        return "Type must be between 1 and 50 characters";
+    }
+    if (description.length < 1 || description.length > 2000) {
+        return "Description must be between 1 and 2000 characters";
+    }
+    if (feedbackId.length < 1 || feedbackId.length > 100) {
+        return "Feedback ID must be between 1 and 100 characters";
+    }
+    return null;
+}
+/**
+ * Saves feedback to Firestore and optionally uploads screenshot to Storage
+ * @param data - Feedback submission data
+ * @param userId - User ID who submitted the feedback
+ * @param userType - Type of user ('teacher' or 'student')
+ * @param fileBuffer - Screenshot file buffer (optional)
+ * @returns Promise<void>
+ */
+export async function saveFeedback(data, userId, userType, fileBuffer) {
+    const { type, description, feedbackId, email, pageUrl } = data;
+    // Create feedback document in Firestore
+    const firestore = getFirestore();
+    const db = new DATABASE();
+    const firebaseDocPath = db.FEEDBACK.DOC(`${feedbackId}_${userId}`);
+    const feedbackRef = firestore.doc(firebaseDocPath);
+    await feedbackRef.set({
+        type,
+        description,
+        userId,
+        userType,
+        email: email || null,
+        pageUrl: pageUrl || null,
+        hasScreenshot: !!fileBuffer,
+        createdAt: new Date().toISOString(),
+    });
+    // If there's a screenshot, upload it to Firebase Storage
+    if (fileBuffer) {
+        const storage = getStorage();
+        const bucket = storage.bucket();
+        // storage path = firebaseDocPath but without the first /
+        const storagePath = firebaseDocPath.replace(/^\//, "");
+        const file = bucket.file(`${storagePath}.png`);
+        // Upload the file to Firebase Storage
+        await file.save(fileBuffer, {
+            metadata: {
+                contentType: "image/png",
+            },
+        });
+    }
+}
 //# sourceMappingURL=logic.js.map