@citolab/qti-backend-firebase 0.0.3

package/dist/helpers/logic.js

@@ -0,0 +1,759 @@
+import { getAuth, getFirestore, getStorage } from "./firebase";
+import fs from "fs/promises";
+import mime from "mime";
+import { createCode, removeDoubleSlashes } from "./utils";
+import { DATABASE } from "./database";
+import { deleteFilesRecursive } from "./storage";
+import NodeCache from "node-cache";
+export async function uploadFolderToStorage(folder, storageDestinationPath, uploadFiles, subfolder) {
+    const storage = getStorage();
+    const bucket = storage.bucket();
+    const fullFolder = subfolder ? `${folder}/${subfolder}` : folder;
+    const files = await fs.readdir(fullFolder);
+    for (const file of files) {
+        if (file === ".DS_Store") {
+            continue;
+        }
+        const filePath = `${fullFolder}/${file}`;
+        const stat = await fs.stat(filePath);
+        const fileStructure = removeDoubleSlashes(filePath.replace(folder, ""));
+        if (stat.isDirectory()) {
+            // Recursively upload files in subfolder
+            await uploadFolderToStorage(folder, `${storageDestinationPath}/${file}`, uploadFiles, fileStructure);
+        }
+        else {
+            console.log(`uploading ${filePath}`);
+            uploadFiles.push(bucket.upload(`${fullFolder}/${file}`, {
+                destination: `${storageDestinationPath}/${file}`,
+                metadata: {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    contentType: mime.getType(file),
+                },
+            }));
+        }
+    }
+}
+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) => {
+    if (!code || !db)
+        return null;
+    const application = await getApplication(db);
+    if ((application?.demoCodes || []).includes(code)) {
+        const allAssessments = await getAssessments(db);
+        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",
+            isDemo: true,
+            teacherId: "demo-teacher",
+        };
+    }
+    const firestore = getFirestore();
+    const doc = await firestore.doc(db.STUDENT.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
+        await firestore.doc(db.STUDENT_USER_ID_MAPPING.DOC(userId)).set({ code });
+    }
+    return doc.exists ? doc.data() : null;
+};
+export const getStudentGroupSessionInfo = async (groupCode, db, userId, studentIdentification) => {
+    if (!groupCode || !db || !userId)
+        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;
+};
+export const updateStudentSessionState = async (db, code, assessmentId, 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),
+        };
+        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));
+    }
+    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) {
+        const startFrom = new Date(asessment.startFrom);
+        if (startFrom > new Date()) {
+            return false;
+        }
+    }
+    if (asessment.endAt) {
+        const startUntil = new Date(asessment.endAt);
+        if (startUntil < new Date()) {
+            return false;
+        }
+    }
+    return true;
+};
+export const getCodeByUserId = async (db, userId) => {
+    const key = `${db.appId}-${userId}`;
+    const cached = userIdCode.get(key);
+    if (cached) {
+        return cached;
+    }
+    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);
+    }
+    return code;
+};
+export const getTeacherIdByCode = async (db, code) => {
+    const key = `${db.appId}-${code}`;
+    const cached = userIdCode.get(key);
+    if (cached) {
+        return cached;
+    }
+    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);
+    }
+    return teacherId;
+};
+export const getApplicationInfo = async (db) => {
+    const cached = applicationInfoCache.get(db.appId || "application");
+    if (cached) {
+        return cached;
+    }
+    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;
+    }
+};
+export const addApplicationInfo = async (db, appInfo) => {
+    const firestore = getFirestore();
+    const docRef = firestore.doc(db.APPLICATION.DOC());
+    await docRef.set(appInfo);
+};
+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,
+        };
+    if (application &&
+        (!application.assessments || !application.assessments.length)) {
+        const assessments = await getAssessments(db);
+        if (!applicationRef.exists && assessments.length === 0) {
+            return null;
+        }
+        application.assessments = assessments;
+    }
+    return application;
+};
+export const codeExists = async (code, db) => {
+    const studentSessions = await getStudentSessionInfo(code, db, undefined);
+    return studentSessions;
+};
+export const hasAccess = async (uid, appId) => {
+    const firestore = getFirestore();
+    const docRef = firestore.doc(new DATABASE().AUTH.CHECK_APP_RIGHTS(uid, appId.toLowerCase()));
+    const doc = await docRef.get();
+    return doc.exists;
+};
+// TODO: sessionState should be default on not_started. For snelkookpan specific move to specific logig
+export const createSession = async (teacherId, db, count, assessments) => {
+    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;
+        while (exists) {
+            code = createCode(5);
+            exists = !!((application?.demoCodes || []).includes(code) ||
+                (await codeExists(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);
+    }
+    await batch.commit();
+    return studentAppSessionInfos;
+};
+export const createSessionByIdentifications = async (teacherId, db, identifications, sessionState, assessments) => {
+    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 = {
+                teacherId,
+                code: identification.identifier,
+                appId: db.appId || "application",
+                sessions: assessments.map((assessment) => ({
+                    assessmentId: assessment.assessmentId,
+                    assessmentName: assessment.name,
+                    packageId: assessment.packageId,
+                    sessionState,
+                })),
+                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);
+        }
+    }
+    await batch.commit();
+    return studentAppSessionInfos;
+};
+export const getAllStudents = async (db) => {
+    const firestore = getFirestore();
+    const docs = await firestore
+        .collection(db.STUDENT.COLLECTION())
+        .listDocuments();
+    const studentInfos = [];
+    for (const doc of docs) {
+        const studentInfo = await doc.get();
+        studentInfos.push(studentInfo.data() ||
+            { code: doc.id });
+    }
+    return studentInfos;
+};
+export const getAssessments = async (db) => {
+    const firestore = getFirestore();
+    const assessmentData = await firestore
+        .collection(db.ASSESSMENT.COLLECTION())
+        .get();
+    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) => {
+    const firestore = getFirestore();
+    const assessmentDoc = await firestore
+        .doc(db.ASSESSMENT.DOC(assessmentId))
+        .get();
+    if (!assessmentDoc.exists) {
+        throw new Error(`Assessment with ID ${assessmentId} does not exist.`);
+    }
+    const assessmentData = assessmentDoc.data();
+    if (!assessmentData) {
+        throw new Error(`Assessment with ID ${assessmentId} has no package.`);
+    }
+    return assessmentData;
+};
+export const getAssessmentItemRefsFromPackage = async ($assessmentTest) => {
+    //let regularItemCount = 0;
+    let itemCount = 0;
+    const assessmentItemRefs = $assessmentTest("qti-assessment-item-ref")
+        .map((i, el) => {
+        const isInfo = $assessmentTest(el)
+            .attr("category")
+            ?.includes("dep-informational");
+        // if (!isInfo) {
+        //   regularItemCount++;
+        // }
+        itemCount++;
+        const identifier = $assessmentTest(el).attr("identifier");
+        const sequenceNumber = itemCount; // isInfo ? 0 : regularItemCount;
+        return { identifier, sequenceNumber, isInfo };
+    })
+        .toArray();
+    return assessmentItemRefs;
+};
+export const getItemsStats = async (db, teacherId, assessmentId, target) => {
+    const firestore = getFirestore();
+    const assessmentDoc = await getAssessmentTest(db, assessmentId);
+    if (!assessmentDoc) {
+        throw new Error(`Assessment with ID ${assessmentId} does not exist.`);
+    }
+    if (!assessmentDoc.items || assessmentDoc.items.length === 0) {
+        throw new Error(`Assessment with ID ${assessmentId} has no items.`);
+    }
+    const itemIdentifiers = assessmentDoc.items?.map((item) => item.identifier) || [];
+    const all = await Promise.all(itemIdentifiers.map((id) => firestore
+        .collection(target === "teacher"
+        ? db.TEACHER.ASSESSMENT_ITEM_STATS.RESPONSES.COLLECTION(teacherId, assessmentId, id)
+        : db.REVIEWER.ASSESSMENT_ITEM_STATS.RESPONSES.COLLECTION(teacherId, assessmentId, id))
+        .get()
+        .then((snapshot) => ({ itemIdentifier: id, docs: snapshot.docs }))));
+    const stats = [];
+    for (const { itemIdentifier, docs } of all) {
+        if (!docs?.length) {
+            // skip empty collections
+            continue;
+        }
+        for (const d of docs) {
+            if (!d.exists) {
+                console.warn(`Item statistics for item ${itemIdentifier} in assessment ${assessmentId} does not exist.`);
+            }
+            else {
+                const data = d.data();
+                if (data) {
+                    let itemStats = stats.find((s) => s.itemId === itemIdentifier);
+                    if (!itemStats) {
+                        itemStats = {
+                            itemId: itemIdentifier,
+                            count: 0,
+                            responses: [],
+                            numberCorrect: 0,
+                        };
+                        stats.push(itemStats);
+                    }
+                    itemStats.count += data.count;
+                    itemStats.numberCorrect +=
+                        !data.score || data.score?.toString() === "0" ? 0 : 1;
+                    itemStats.responses.push(data);
+                }
+            }
+        }
+    }
+    return stats;
+};
+export const updateItemStatResponseScore = async (db, teacherId, assessmentId, itemId, responseId, scoreExternal, target) => {
+    const firestore = getFirestore();
+    await firestore
+        .doc(target === "teacher"
+        ? db.TEACHER.ASSESSMENT_ITEM_STATS.RESPONSES.DOC(teacherId, assessmentId, itemId, responseId)
+        : db.REVIEWER.ASSESSMENT_ITEM_STATS.RESPONSES.DOC(teacherId, assessmentId, itemId, responseId))
+        .update({ scoreExternal });
+};
+export const getPlannedStudents = async (db, teacherId) => {
+    const firestore = getFirestore();
+    const studentResultCollectionRef = await firestore
+        .collection(db.TEACHER.STUDENTS.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 updatedStudent = { ...student, sessions: sessionsToReturn };
+        studentsToReturn.push(updatedStudent);
+    }
+    return studentsToReturn;
+};
+export const getPlannedStudent = async (db, teacherId, code) => {
+    const firestore = getFirestore();
+    const studentResultRef = await firestore
+        .doc(db.TEACHER.STUDENTS.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 assessments = await firestore
+        .collection(db.ASSESSMENT.COLLECTION())
+        .get();
+    for (const assessment of assessments.docs) {
+        const assessmentResultRef = await firestore.doc(db.TEACHER.ASSESSMENT_RESULTS.DOC(teacherId, assessment.id, code));
+        await assessmentResultRef.delete();
+        const assessmentReportRef = await firestore.doc(db.TEACHER.ASSESSMENT_REPORTS.DOC(teacherId, assessment.id, code));
+        await assessmentReportRef.delete();
+    }
+    await studentRef.delete();
+};
+export const getUser = async (uid) => {
+    const firestore = getFirestore();
+    const userFromDatabase = (await firestore.doc(new DATABASE().AUTH.DOC(uid)).get()).data();
+    return userFromDatabase;
+};
+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) => {
+    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);
+};
+export const getStudentInfoForTeacher = async (db, teacherId, code) => {
+    const firestore = getFirestore();
+    const studentRef = await firestore
+        .doc(db.TEACHER.STUDENTS.DOC(teacherId, code))
+        .get();
+    const student = studentRef.data();
+    return student;
+};
+export const updateStudent = 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,
+        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;
+};
+const createStrongPassword = () => {
+    const password = Math.random().toString(36).slice(-8);
+    return password;
+};
+export const createUserForApplication = async (email, applicationId) => {
+    const auth = getAuth();
+    const firestore = getFirestore();
+    let password = "";
+    let firebaseUser = undefined;
+    try {
+        firebaseUser = await auth.getUserByEmail(email);
+    }
+    catch {
+        // if the user is not found, then it raises an error.
+    }
+    if (!firebaseUser) {
+        password = createStrongPassword();
+        firebaseUser = await auth.createUser({
+            email,
+            password,
+        });
+    }
+    await firestore
+        .doc(new DATABASE().AUTH.CHECK_APP_RIGHTS(firebaseUser.uid, applicationId))
+        .set({
+        email,
+        application: applicationId.toLocaleLowerCase(),
+        userId: firebaseUser.uid,
+    });
+    if (password) {
+        return { password, id: firebaseUser.uid };
+    }
+    else {
+        return { id: firebaseUser.uid };
+    }
+};
+export const deleteUserForApplication = async (id, applicationId) => {
+    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);
+    }
+    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 async function deleteDocumentAndSubcollections(docRef) {
+    // Delete the document
+    await docRef.delete();
+    // Get all the subcollections of the document
+    const collections = await docRef.listCollections();
+    // Delete each subcollection recursively
+    for (const collection of collections) {
+        const querySnapshot = await collection.listDocuments();
+        querySnapshot.forEach(async (doc) => {
+            // Delete the subdocument and its subcollections recursively
+            await deleteDocumentAndSubcollections(doc);
+        });
+    }
+}
+export async function checkAndDeletePackages(dateTime) {
+    const firestore = getFirestore();
+    const storage = getStorage();
+    const db = new DATABASE();
+    const packageData = await firestore.collection(db.PACKAGE.COLLECTION()).get();
+    const packages = packageData.docs.map((doc) => doc.data());
+    for (const packageInfo of packages) {
+        if (packageInfo.uploaded < dateTime) {
+            for (const { assessmentId } of packageInfo.assessmentInfo) {
+                await deleteDocumentAndSubcollections(firestore.doc(db.ASSESSMENT.DOC(assessmentId)));
+            }
+            await deleteFilesRecursive(storage.bucket(), `packages/${packageInfo.packageId}`);
+            await deleteDocumentAndSubcollections(firestore.doc(db.PACKAGE.DOC(packageInfo.packageId)));
+        }
+    }
+}
+export async function fetchUsersInChunks(ids, chunkSize = 100) {
+    let results = [];
+    const auth = getAuth();
+    for (let i = 0; i < ids.length; i += chunkSize) {
+        const chunk = ids.slice(i, i + chunkSize);
+        try {
+            const chunkResults = await auth.getUsers(chunk.map((c) => ({ uid: c })));
+            results = results.concat(chunkResults.users.map((u) => {
+                return {
+                    id: u.uid || "",
+                    disabled: u.disabled,
+                    email: u.email || "",
+                };
+            }));
+        }
+        catch (error) {
+            console.error("Error fetching users:", error);
+            // Handle error appropriately - possibly rethrow, or continue to next chunk
+        }
+    }
+    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;
+};
+//# sourceMappingURL=logic.js.map