devops/encoach_frontend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated the grading system to work based on entities

Browse Source
This commit is contained in:
Tiago Ribeiro
2024-11-22 15:36:21 +00:00
parent f301001ebe
commit 50bbb0dacf
14 changed files with 236 additions and 484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/components/High/Table.tsx
View File

@@ -11,10 +11,11 @@ interface Props<T> {
searchFields: string[][]
size?: number
onDownload?: (rows: T[]) => void
isDownloadLoading?: boolean
searchPlaceholder?: string
}
export default function Table<T>({ data, columns, searchFields, size = 16, onDownload, searchPlaceholder }: Props<T>) {
export default function Table<T>({ data, columns, searchFields, size = 16, onDownload, isDownloadLoading, searchPlaceholder }: Props<T>) {
const [pagination, setPagination] = useState<PaginationState>({
pageIndex: 0,
pageSize: size,
@@ -39,7 +40,7 @@ export default function Table<T>({ data, columns, searchFields, size = 16, onDow
<div className="w-full flex gap-2 items-end">
{renderSearch()}
{onDownload && (
<Button className="w-full max-w-[200px] mb-1" variant="outline" onClick={() => onDownload(rows)}>
<Button isLoading={isDownloadLoading} className="w-full max-w-[200px] mb-1" variant="outline" onClick={() => onDownload(rows)}>
Download
</Button>
)

2
src/components/Medium/StatGridItem.tsx
View File

@@ -77,7 +77,6 @@ interface StatsGridItemProps {
assignments: Assignment[];
users: User[];
training?: boolean;
gradingSystem?: Step[];
selectedTrainingExams?: string[];
maxTrainingExams?: number;
setSelectedTrainingExams?: React.Dispatch<React.SetStateAction<string[]>>;
@@ -98,7 +97,6 @@ const StatsGridItem: React.FC<StatsGridItemProps> = ({
users,
training,
selectedTrainingExams,
gradingSystem,
setSelectedTrainingExams,
setExams,
setShowSolutions,

2
src/dashboards/Student.tsx
View File

@@ -37,7 +37,6 @@ interface Props {
}
export default function StudentDashboard({ user, linkedCorporate }: Props) {
const {gradingSystem} = useGradingSystem();
const { sessions } = useSessions(user.id);
const { data: stats } = useFilterRecordsByUser<Stat[]>(user.id, !user?.id);
const { assignments, isLoading: isAssignmentsLoading, reload: reloadAssignments } = useAssignments({ assignees: user?.id });
@@ -235,7 +234,6 @@ export default function StudentDashboard({user, linkedCorporate}: Props) {
<div className="flex w-full justify-between">
<span className="text-sm font-bold md:font-extrabold">{capitalize(module)}</span>
<span className="text-mti-gray-dim text-sm font-normal">
{module === "level" && !!gradingSystem && `English Level: ${getGradingLabel(level, gradingSystem.steps)}`}
{module !== "level" && `Level ${level} / Level 9 (Desired Level: ${desiredLevel})`}
</span>
</div>

6
src/exams/Finish.tsx
View File

@@ -8,7 +8,7 @@ import { calculateBandScore, getGradingLabel } from "@/utils/score";
import clsx from "clsx";
import Link from "next/link";
import { useRouter } from "next/router";
import { Fragment, useEffect, useState } from "react";
import { Fragment, useEffect, useMemo, useState } from "react";
import {
BsArrowCounterclockwise,
BsBan,
@@ -59,7 +59,9 @@ export default function Finish({ user, scores, modules, information, solutions,
const aiUsage = Math.round(ai_usage(solutions) * 100);
const exams = useExamStore((state) => state.exams);
const { gradingSystem } = useGradingSystem();
const entity = useMemo(() => assignment?.entity || user.entities[0]?.id || "", [assignment?.entity, user.entities])
const { gradingSystem } = useGradingSystem(entity);
const router = useRouter()

6
src/hooks/useGrading.tsx
View File

@@ -3,7 +3,7 @@ import {Code, Group, User} from "@/interfaces/user";
import axios from "axios";
import { useEffect, useState } from "react";
export default function useGradingSystem() {
export default function useGradingSystem(entity: string) {
const [gradingSystem, setGradingSystem] = useState<Grading>();
const [isLoading, setIsLoading] = useState(false);
const [isError, setIsError] = useState(false);
@@ -11,12 +11,12 @@ export default function useGradingSystem() {
const getData = () => {
setIsLoading(true);
axios
.get<Grading>(`/api/grading`)
.get<Grading>(`/api/grading?entity=${entity}`)
.then((response) => setGradingSystem(response.data))
.finally(() => setIsLoading(false));
};
useEffect(getData, []);
useEffect(getData, [entity]);
return { gradingSystem, isLoading, isError, reload: getData, mutate: setGradingSystem };
}

3
src/interfaces/index.ts
View File

@@ -7,7 +7,6 @@ export interface Step {
}
export interface Grading {
user: string;
entity?: string;
entity: string;
steps: Step[];
}

36
src/pages/(admin)/CorporateGradingSystem.tsx
View File

@@ -1,9 +1,13 @@
import Button from "@/components/Low/Button";
import Input from "@/components/Low/Input";
import Select from "@/components/Low/Select";
import { Grading, Step } from "@/interfaces";
import { Entity } from "@/interfaces/entity";
import { User } from "@/interfaces/user";
import { CEFR_STEPS, GENERAL_STEPS, IELTS_STEPS, TOFEL_STEPS } from "@/resources/grading";
import { checkAccess } from "@/utils/permissions";
import axios from "axios";
import clsx from "clsx";
import { useEffect, useState } from "react";
import { BsPlusCircle, BsTrash } from "react-icons/bs";
import { toast } from "react-toastify";
@@ -21,9 +25,24 @@ const areStepsOverlapped = (steps: Step[]) => {
return false;
};
export default function CorporateGradingSystem({user, defaultSteps, mutate}: {user: User; defaultSteps: Step[]; mutate: (steps: Step[]) => void}) {
interface Props {
user: User;
entitiesGrading: Grading[];
entities: Entity[]
mutate: () => void
}
export default function CorporateGradingSystem({ user, entitiesGrading = [], entities = [], mutate }: Props) {
const [entity, setEntity] = useState(entitiesGrading[0]?.entity || undefined)
const [isLoading, setIsLoading] = useState(false);
const [steps, setSteps] = useState<Step[]>(defaultSteps || []);
const [steps, setSteps] = useState<Step[]>([]);
useEffect(() => {
if (entity) {
const entitySteps = entitiesGrading.find(e => e.entity === entity)!.steps
setSteps(entitySteps || [])
}
}, [entitiesGrading, entity])
const saveGradingSystem = () => {
if (!steps.every((x) => x.min < x.max)) return toast.error("One of your steps has a minimum threshold inferior to its superior threshold.");
@@ -37,9 +56,9 @@ export default function CorporateGradingSystem({user, defaultSteps, mutate}: {us
setIsLoading(true);
axios
.post("/api/grading", {user: user.id, steps})
.post("/api/grading", { user: user.id, entity, steps })
.then(() => toast.success("Your grading system has been saved!"))
.then(() => mutate(steps))
.then(mutate)
.catch(() => toast.error("Something went wrong, please try again later"))
.finally(() => setIsLoading(false));
};
@@ -47,6 +66,15 @@ export default function CorporateGradingSystem({user, defaultSteps, mutate}: {us
return (
<div className="flex flex-col gap-4 border p-4 border-mti-gray-platinum rounded-xl">
<label className="font-normal text-base text-mti-gray-dim">Grading System</label>
<div className={clsx("flex flex-col gap-4")}>
<label className="font-normal text-base text-mti-gray-dim">Entity</label>
<Select
defaultValue={{ value: (entities || [])[0]?.id, label: (entities || [])[0]?.label }}
options={entities.map((e) => ({ value: e.id, label: e.label }))}
onChange={(e) => setEntity(e?.value || undefined)}
isClearable={checkAccess(user, ["admin", "developer"])}
/>
</div>
<label className="font-normal text-base text-mti-gray-dim">Preset Systems</label>
<div className="grid grid-cols-4 gap-4">

255
src/pages/api/assignments/statistical/excel.ts
View File

@@ -1,255 +0,0 @@
import type {NextApiRequest, NextApiResponse} from "next";
import {storage} from "@/firebase";
import {withIronSessionApiRoute} from "iron-session/next";
import {sessionOptions} from "@/lib/session";
import {ref, uploadBytes, getDownloadURL} from "firebase/storage";
import {AssignmentWithCorporateId} from "@/interfaces/results";
import moment from "moment-timezone";
import ExcelJS from "exceljs";
import {getSpecificUsers} from "@/utils/users.be";
import {checkAccess} from "@/utils/permissions";
import {getAssignmentsForCorporates} from "@/utils/assignments.be";
import {search} from "@/utils/search";
import {getGradingSystem} from "@/utils/grading.be";
import {StudentUser, User} from "@/interfaces/user";
import {calculateBandScore, getGradingLabel} from "@/utils/score";
import {Module} from "@/interfaces";
import {uniq} from "lodash";
import {getUserName} from "@/utils/users";
import {LevelExam} from "@/interfaces/exam";
import {getSpecificExams} from "@/utils/exams.be";
export default withIronSessionApiRoute(handler, sessionOptions);
interface TableData {
user: string;
studentID: string;
passportID: string;
exams: string;
email: string;
correct: number;
corporate: string;
submitted: boolean;
date: moment.Moment;
assignment: string;
corporateId: string;
score: number;
level: string;
part1?: string;
part2?: string;
part3?: string;
part4?: string;
part5?: string;
}
async function handler(req: NextApiRequest, res: NextApiResponse) {
// if (req.method === "GET") return get(req, res);
if (req.method === "POST") return await post(req, res);
}
const searchFilters = [["email"], ["user"], ["userId"], ["assignment"], ["exams"]];
async function post(req: NextApiRequest, res: NextApiResponse) {
// verify if it's a logged user that is trying to export
if (req.session.user) {
if (!checkAccess(req.session.user, ["mastercorporate", "corporate", "developer", "admin"])) {
return res.status(403).json({error: "Unauthorized"});
}
const {
ids,
startDate,
endDate,
searchText,
displaySelection = true,
} = req.body as {
ids: string[];
startDate?: string;
endDate?: string;
searchText: string;
displaySelection?: boolean;
};
const startDateParsed = startDate ? new Date(startDate) : undefined;
const endDateParsed = endDate ? new Date(endDate) : undefined;
const assignments = await getAssignmentsForCorporates(req.session.user.type, ids, startDateParsed, endDateParsed);
const assignmentUsers = uniq([...assignments.flatMap((x) => x.assignees), ...assignments.flatMap((x) => x.assigner)]);
const assigners = [...new Set(assignments.map((a) => a.assigner))];
const users = await getSpecificUsers(assignmentUsers);
const assignerUsers = await getSpecificUsers(assigners);
const exams = await getSpecificExams(uniq(assignments.flatMap((x) => x.exams.map((x) => x.id))));
const assignerUsersGradingSystems = await Promise.all(
assignerUsers.map(async (user: User) => {
const data = await getGradingSystem(user);
// in this context I need to override as I'll have to match to the assigner
return {...data, user: user.id};
}),
);
const getGradingSystemHelper = (
exams: {id: string; module: Module; assignee: string}[],
assigner: string,
user: User,
correct: number,
total: number,
) => {
if (exams.some((e) => e.module === "level")) {
const gradingSystem = assignerUsersGradingSystems.find((gs) => gs.user === assigner);
if (gradingSystem) {
const bandScore = calculateBandScore(correct, total, "level", user?.focus || "academic");
return {
label: getGradingLabel(bandScore, gradingSystem.steps || []),
score: bandScore,
};
}
}
return {score: -1, label: "N/A"};
};
const tableResults = assignments
.reduce((accmA: TableData[], a: AssignmentWithCorporateId) => {
const userResults = a.assignees.map((assignee) => {
const userStats = a.results.find((r) => r.user === assignee)?.stats || [];
const userData = users.find((u) => u.id === assignee);
const corporateUser = users.find((u) => u.id === a.assigner);
const correct = userStats.reduce((n, e) => n + e.score.correct, 0);
const total = userStats.reduce((n, e) => n + e.score.total, 0);
const {label: level, score} = getGradingSystemHelper(a.exams, a.assigner, userData!, correct, total);
const commonData = {
user: userData?.name || "",
email: userData?.email || "",
studentID: (userData as StudentUser)?.studentID || "",
passportID: (userData as StudentUser)?.demographicInformation?.passport_id || "",
userId: assignee,
exams: a.exams.map((x) => x.id).join(", "),
corporateId: a.corporateId,
corporate: !corporateUser ? "" : getUserName(corporateUser),
assignment: a.name,
level,
score,
};
if (userStats.length === 0) {
return {
...commonData,
correct: 0,
submitted: false,
// date: moment(),
};
}
let data: {total: number; correct: number}[] = [];
if (a.exams.every((x) => x.module === "level")) {
const exam = exams.find((x) => x.id === a.exams.find((x) => x.assignee === assignee)?.id) as LevelExam;
data = exam.parts.map((x) => {
const exerciseIDs = x.exercises.map((x) => x.id);
const stats = userStats.filter((x) => exerciseIDs.includes(x.exercise));
const total = stats.reduce((acc, curr) => acc + curr.score.total, 0);
const correct = stats.reduce((acc, curr) => acc + curr.score.correct, 0);
return {total, correct};
});
}
const partsData =
data.length > 0 ? data.reduce((acc, e, index) => ({...acc, [`part${index}`]: `${e.correct}/${e.total}`}), {}) : {};
return {
...commonData,
correct,
submitted: true,
date: moment.max(userStats.map((e) => moment(e.date))),
...partsData,
};
}) as TableData[];
return [...accmA, ...userResults];
}, [])
.sort((a, b) => b.score - a.score);
// Create a new workbook and add a worksheet
const workbook = new ExcelJS.Workbook();
const worksheet = workbook.addWorksheet("Master Statistical");
const headers = [
{
label: "User",
value: (entry: TableData) => entry.user,
},
{
label: "Email",
value: (entry: TableData) => entry.email,
},
{
label: "Student ID",
value: (entry: TableData) => entry.studentID,
},
{
label: "Passport ID",
value: (entry: TableData) => entry.passportID,
},
...(displaySelection
? [
{
label: "Corporate",
value: (entry: TableData) => entry.corporate,
},
]
: []),
{
label: "Assignment",
value: (entry: TableData) => entry.assignment,
},
{
label: "Submitted",
value: (entry: TableData) => (entry.submitted ? "Yes" : "No"),
},
{
label: "Score",
value: (entry: TableData) => entry.correct,
},
{
label: "Date",
value: (entry: TableData) => entry.date?.format("YYYY/MM/DD") || "",
},
{
label: "Level",
value: (entry: TableData) => entry.level,
},
...new Array(5).fill(0).map((_, index) => ({
label: `Part ${index + 1}`,
value: (entry: TableData) => {
const key = `part${index}` as keyof TableData;
return entry[key] || "";
},
})),
];
const filteredSearch = !!searchText ? search(searchText, searchFilters, tableResults) : tableResults;
worksheet.addRow(headers.map((h) => h.label));
(filteredSearch as TableData[]).forEach((entry) => {
worksheet.addRow(headers.map((h) => h.value(entry)));
});
// Convert workbook to Buffer (Node.js) or Blob (Browser)
const buffer = await workbook.xlsx.writeBuffer();
// generate the file ref for storage
const fileName = `${Date.now().toString()}.xlsx`;
const refName = `statistical/${fileName}`;
const fileRef = ref(storage, refName);
// upload the pdf to storage
await uploadBytes(fileRef, buffer, {
contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
});
const url = await getDownloadURL(fileRef);
res.status(200).end(url);
return;
}
return res.status(401).json({error: "Unauthorized"});
}

25
src/pages/api/grading/index.ts
View File

@@ -14,8 +14,8 @@ import {Grading} from "@/interfaces";
import { getGroupsForUser } from "@/utils/groups.be";
import { uniq } from "lodash";
import { getSpecificUsers, getUser } from "@/utils/users.be";
import {getGradingSystem} from "@/utils/grading.be";
import client from "@/lib/mongodb";
import { getGradingSystemByEntity } from "@/utils/grading.be";
const db = client.db(process.env.MONGODB_DB);
@@ -32,18 +32,11 @@ async function get(req: NextApiRequest, res: NextApiResponse) {
return;
}
const gradingSystem = await getGradingSystem(req.session.user);
const entity = req.query.entity as string
const gradingSystem = await getGradingSystemByEntity(entity);
return res.status(200).json(gradingSystem);
}
async function updateGrading(id: string, body: Grading) {
if (await db.collection("grading").findOne({id})) {
await db.collection("grading").updateOne({id}, {$set: body});
} else {
await db.collection("grading").insertOne({id, ...body});
}
}
async function post(req: NextApiRequest, res: NextApiResponse) {
if (!req.session.user) {
res.status(401).json({ ok: false });
@@ -57,17 +50,7 @@ async function post(req: NextApiRequest, res: NextApiResponse) {
});
const body = req.body as Grading;
await updateGrading(req.session.user.id, body);
if (req.session.user.type === "mastercorporate") {
const groups = await getGroupsForUser(req.session.user.id);
const participants = uniq(groups.flatMap((x) => x.participants));
const participantUsers = await getSpecificUsers(participants);
const corporateUsers = participantUsers.filter((x) => x?.type === "corporate") as CorporateUser[];
await Promise.all(corporateUsers.map(async (g) => await updateGrading(g.id, body)));
}
await db.collection("grading").updateOne({ entity: body.entity }, { $set: body }, { upsert: true });
res.status(200).json({ ok: true });
}

18
src/pages/api/statistical.ts
View File

@@ -16,6 +16,8 @@ import { findBy, mapBy } from "@/utils";
import ExcelJS from "exceljs";
import moment from "moment";
import { Session } from "@/hooks/useSessions";
import { getGradingSystemByEntity } from "@/utils/grading.be";
import { getGradingLabel } from "@/utils/score";
export default withIronSessionApiRoute(handler, sessionOptions);
@@ -81,14 +83,16 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
const workbook = new ExcelJS.Workbook();
const worksheet = workbook.addWorksheet("Statistical");
entityInformations.forEach((e) => addEntityInformationToWorksheet(worksheet, e))
for (const e of entityInformations) {
await addEntityInformationToWorksheet(worksheet, e)
}
const buffer = await workbook.xlsx.writeBuffer()
res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
res.status(200).send(buffer);
}
const addEntityInformationToWorksheet = (worksheet: ExcelJS.Worksheet, entityInformation: EntityInformation) => {
const addEntityInformationToWorksheet = async (worksheet: ExcelJS.Worksheet, entityInformation: EntityInformation) => {
const data = [
['Entity', undefined, undefined, entityInformation.entity.label],
['Assignment', undefined, undefined, entityInformation.assignment.name],
@@ -108,6 +112,7 @@ const addEntityInformationToWorksheet = (worksheet: ExcelJS.Worksheet, entityInf
dataRows.forEach(row => worksheet.mergeCells(`${row.getCell(4).address}:${row.getCell(7).address}`))
worksheet.addRows([[], []]);
const gradingSystem = await getGradingSystemByEntity(entityInformation.entity.id)
for (const exam of entityInformation.exams) {
const examRow = worksheet.addRow([`${capitalize(exam.module)} Exam`, undefined, exam.id])
@@ -127,7 +132,9 @@ const addEntityInformationToWorksheet = (worksheet: ExcelJS.Worksheet, entityInf
"Student ID",
"Passport/ID",
"Gender",
"Finished at",
"Score",
...(exam.module === "level" ? ["Grade"] : []),
...parts.map((_, i) => `Part ${i + 1}`)
])
header.font = { bold: true, color: { argb: "FFFFFFFF" } }
@@ -152,6 +159,11 @@ const addEntityInformationToWorksheet = (worksheet: ExcelJS.Worksheet, entityInf
const { total, correct } = calculateScore(item.result.stats)
const score = `${correct} / ${total}`
const finishTimestamp = [...item.result.stats].sort((a, b) => b.date - a.date).shift()?.date || -1
const finishDate = finishTimestamp === -1 ? "N/A" : moment(new Date(finishTimestamp)).format("DD/MM/YYYY HH:mm")
const grade = getGradingLabel(correct, gradingSystem.steps)
return [
index + 1,
item.student.name,
@@ -159,7 +171,9 @@ const addEntityInformationToWorksheet = (worksheet: ExcelJS.Worksheet, entityInf
item.student.studentID || "N/A",
item.student.demographicInformation?.passport_id || "N/A",
item.student.demographicInformation?.gender || "N/A",
finishDate,
score,
...(exam.module === "level" ? [grade] : []),
...parts.map((part) => {
const exerciseIDs = mapBy(part.exercises, 'id')
const { total, correct } = calculateScore(item.result.stats.filter(s => exerciseIDs.includes(s.exercise)))

2
src/pages/record.tsx
View File

@@ -73,7 +73,6 @@ export default function History({ user, users, assignments, entities }: Props) {
const [filter, setFilter] = useState<Filter>();
const { data: stats, isLoading: isStatsLoading } = useFilterRecordsByUser<Stat[]>(statsUserId || user?.id);
const { gradingSystem } = useGradingSystem();
const setExams = useExamStore((state) => state.setExams);
const setShowSolutions = useExamStore((state) => state.setShowSolutions);
@@ -175,7 +174,6 @@ export default function History({ user, users, assignments, entities }: Props) {
setSelectedTrainingExams={setSelectedTrainingExams}
maxTrainingExams={MAX_TRAINING_EXAMS}
setExams={setExams}
gradingSystem={gradingSystem?.steps}
setShowSolutions={setShowSolutions}
setUserSolutions={setUserSolutions}
setSelectedModules={setSelectedModules}

22
src/pages/settings.tsx
View File

@@ -21,7 +21,6 @@ import IconCard from "@/dashboards/IconCard";
import { BsCode, BsCodeSquare, BsGearFill, BsPeopleFill, BsPersonFill } from "react-icons/bs";
import UserCreator from "./(admin)/UserCreator";
import CorporateGradingSystem from "./(admin)/CorporateGradingSystem";
import useGradingSystem from "@/hooks/useGrading";
import { CEFR_STEPS } from "@/resources/grading";
import { User } from "@/interfaces/user";
import { getUserPermissions } from "@/utils/permissions.be";
@@ -33,6 +32,9 @@ import { mapBy, serialize, redirect } from "@/utils";
import { EntityWithRoles } from "@/interfaces/entity";
import { requestUser } from "@/utils/api";
import { isAdmin } from "@/utils/users";
import { getGradingSystemByEntities, getGradingSystemByEntity } from "@/utils/grading.be";
import { Grading } from "@/interfaces";
import { useRouter } from "next/router";
export const getServerSideProps = withIronSessionSsr(async ({ req, res }) => {
const user = await requestUser(req, res)
@@ -44,9 +46,11 @@ export const getServerSideProps = withIronSessionSsr(async ({ req, res }) => {
const permissions = await getUserPermissions(user.id);
const entities = isAdmin(user) ? await getEntitiesWithRoles() : await getEntitiesWithRoles(mapBy(user.entities, 'id'))
const allUsers = await getUsers()
const gradingSystems = await getGradingSystemByEntities(mapBy(entities, 'id'))
const entitiesGrading = entities.map(e => gradingSystems.find(g => g.entity === e.id) || { entity: e.id, steps: CEFR_STEPS })
return {
props: serialize({ user, permissions, entities, allUsers }),
props: serialize({ user, permissions, entities, allUsers, entitiesGrading }),
};
}, sessionOptions);
@@ -55,12 +59,12 @@ interface Props {
permissions: PermissionType[];
entities: EntityWithRoles[];
allUsers: User[]
entitiesGrading: Grading[]
}
export default function Admin({ user, entities, permissions, allUsers }: Props) {
const { gradingSystem, mutate } = useGradingSystem();
export default function Admin({ user, entities, permissions, allUsers, entitiesGrading }: Props) {
const [modalOpen, setModalOpen] = useState<string>();
const router = useRouter()
return (
<>
@@ -90,11 +94,9 @@ export default function Admin({ user, entities, permissions, allUsers }: Props)
<Modal isOpen={modalOpen === "gradingSystem"} onClose={() => setModalOpen(undefined)}>
<CorporateGradingSystem
user={user}
defaultSteps={gradingSystem?.steps || CEFR_STEPS}
mutate={(steps) => {
mutate({ user: user.id, steps });
setModalOpen(undefined);
}}
entitiesGrading={entitiesGrading}
entities={entities}
mutate={() => router.replace(router.asPath)}
/>
</Modal>

18
src/pages/statistical.tsx
View File

@@ -78,6 +78,7 @@ export default function Statistical({ user, students, entities, assignments, ses
const [startDate, setStartDate] = useState<Date>(new Date());
const [endDate, setEndDate] = useState<Date | null>(moment().add(1, 'month').toDate());
const [selectedEntities, setSelectedEntities] = useState<string[]>([])
const [isDownloading, setIsDownloading] = useState(false)
const resetDateRange = () => {
const orderedAssignments = orderBy(assignments, ['startDate'], ['asc'])
@@ -137,6 +138,8 @@ export default function Statistical({ user, students, entities, assignments, ses
}), [data])
const downloadExcel = async () => {
setIsDownloading(true)
const request = await axios.post("/api/statistical", {
entities: entities.filter(e => selectedEntities.includes(e.id)),
items: data,
@@ -156,6 +159,8 @@ export default function Statistical({ user, students, entities, assignments, ses
document.body.removeChild(link);
URL.revokeObjectURL(href);
setIsDownloading(false)
}
const columns = [
@@ -189,17 +194,7 @@ export default function Statistical({ user, students, entities, assignments, ses
{capitalize(session.exam?.module || "")} Module, Part {session.partIndex + 1}, Exercise {session.exerciseIndex + 1}
</span>
},
}),
columnHelper.accessor("result", {
header: "Score",
cell: (info) => {
if (!info.getValue()) return null
const correct = info.getValue()!.stats.filter(x => !x.isPractice).reduce((acc, curr) => acc + curr.score.correct, 0)
const total = info.getValue()!.stats.filter(x => !x.isPractice).reduce((acc, curr) => acc + curr.score.total, 0)
return `${correct} / ${total}`
},
}),
})
]
return (
@@ -290,6 +285,7 @@ export default function Statistical({ user, students, entities, assignments, ses
searchFields={[["student", "name"], ["student", "email"], ["student", "studentID"], ["exams", "id"], ["assignment", "name"]]}
searchPlaceholder="Search by student, assignment or exam..."
onDownload={downloadExcel}
isDownloadLoading={isDownloading}
/>
)}
</Layout>

20
src/utils/grading.be.ts
View File

@@ -6,20 +6,8 @@ import client from "@/lib/mongodb";
const db = client.db(process.env.MONGODB_DB);
export const getGradingSystem = async (user: User): Promise<Grading> => {
const grading = await db.collection("grading").findOne<Grading>({id: user.id});
if (!!grading) return grading;
if (user.type !== "teacher" && user.type !== "student") return {steps: CEFR_STEPS, user: user.id};
const corporate = await getUserCorporate(user.id);
if (!corporate) return {steps: CEFR_STEPS, user: user.id};
const corporateSnapshot = await db.collection("grading").findOne<Grading>({id: corporate.id});
if (!!corporateSnapshot) return corporateSnapshot;
return {steps: CEFR_STEPS, user: user.id};
};
export const getGradingSystemByEntity = async (id: string) =>
(await db.collection("grading").findOne<Grading>({entity: id})) || {steps: CEFR_STEPS, user: ""};
(await db.collection("grading").findOne<Grading>({ entity: id })) || { steps: CEFR_STEPS, entity: "" };
export const getGradingSystemByEntities = async (ids: string[]) =>
await db.collection("grading").find<Grading>({ entity: { $in: ids } }).toArray();