feat(server): implemented evaluation of lesson attendance

Author: mostafakamar2308

packages/headless/src/lessons.ts

@@ -12,7 +12,9 @@ export function useFindLessons({
   ...query
 }: ILesson.FindLessonsApiQuery & { userOnly?: boolean }): UsePaginateResult<{
   lesson: ILesson.Self;
-  members: ILesson.PopuldatedMember[];
+  members: (ILesson.PopuldatedMember & {
+    attended: boolean;
+  })[];
 }> {
   const api = useApi();
 

packages/models/src/sessionEvents.ts

@@ -1,6 +1,6 @@
 import { column, knex, WithOptionalTx } from "@/query";
 import { first, isEmpty } from "lodash";
-import { ISessionEvent } from "@litespace/types";
+import { ISession, ISessionEvent } from "@litespace/types";
 import { Knex } from "knex";
 import dayjs from "@/lib/dayjs";
 
@@ -12,6 +12,7 @@ export class SessionEvents {
     tx?: Knex.Transaction
   ): Promise<ISessionEvent.Self> {
     const now = dayjs.utc().toDate();
+
     const rows = await this.builder(tx)
       .insert({
         type: event.type,
@@ -66,10 +67,12 @@ export class SessionEvents {
   async find({
     users,
     sessionIds,
+    events,
     tx,
   }: WithOptionalTx<{
     users?: number[];
-    sessionIds?: number[];
+    sessionIds?: ISession.Id[];
+    events?: ISessionEvent.EventType[];
   }>): Promise<ISessionEvent.Self[]> {
     const builder = this.builder(tx).select("*");
 
@@ -79,7 +82,10 @@ export class SessionEvents {
     if (sessionIds && !isEmpty(sessionIds))
       builder.whereIn(this.column("session_id"), sessionIds);
 
-    const rows = await builder.then();
+    if (events && !isEmpty(events))
+      builder.whereIn(this.column("type"), events);
+
+    const rows = await builder.orderBy("created_at", "asc").then();
     return rows.map((row) => this.from(row));
   }
 

packages/types/src/lesson.ts

@@ -145,7 +145,9 @@ export type FindLessonsApiQuery = IFilter.SkippablePagination & {
 
 export type FindUserLessonsApiResponse = Paginated<{
   lesson: Self;
-  members: PopuldatedMember[];
+  members: (PopuldatedMember & {
+    attended: boolean;
+  })[];
 }>;
 
 export enum Duration {
@@ -168,5 +170,7 @@ export type LessonDays = LessonDay[];
 
 export type FindLessonByIdApiResponse = {
   lesson: Self;
-  members: PopuldatedMember[];
+  members: (PopuldatedMember & {
+    attended: boolean;
+  })[];
 };

services/server/src/handlers/lesson.ts

@@ -16,14 +16,15 @@ import {
   forbidden,
   notfound,
 } from "@/lib/error";
-import { ILesson, IUser, Wss } from "@litespace/types";
+import { ILesson, ISession, ISessionEvent, IUser, Wss } from "@litespace/types";
 import {
   lessons,
   users,
   knex,
   rooms,
   availabilitySlots,
   interviews,
+  sessionEvents,
 } from "@litespace/models";
 import { Knex } from "knex";
 import safeRequest from "express-async-handler";
@@ -42,6 +43,7 @@ import { asSubSlots, canBook } from "@litespace/utils/availabilitySlots";
 import { isEmpty, isEqual } from "lodash";
 import { genSessionId } from "@litespace/utils";
 import { withImageUrls } from "@/lib/user";
+import { evaluateAttendance } from "@/lib/lesson";
 
 const createLessonPayload = zod.object({
   tutorId: id,
@@ -275,6 +277,50 @@ async function findLessons(req: Request, res: Response, next: NextFunction) {
     await lessons.findLessonMembers(userLesonsIds)
   );
 
+  // Extract sessionIds and create a mapping of lessons to their respective members
+  const lessonSessions = new Map<
+    ISession.Id,
+    { userIds: number[]; duration: number }
+  >();
+
+  userLessons.forEach((lesson) => {
+    const members = lessonMembers.filter(
+      (member) => member.lessonId === lesson.id
+    );
+    lessonSessions.set(lesson.sessionId, {
+      userIds: members.map((m) => m.userId),
+      duration: lesson.duration,
+    });
+  });
+
+  const sessionIds = Array.from(lessonSessions.keys());
+  const events = await sessionEvents.find({
+    sessionIds,
+    users: lessonMembers.map((member) => member.userId),
+    events: [
+      ISessionEvent.EventType.UserJoined,
+      ISessionEvent.EventType.UserLeft,
+    ],
+  });
+
+  const eventsBySession = new Map<string, ISessionEvent.Self[]>();
+  events.forEach((event) => {
+    if (!eventsBySession.has(event.sessionId)) {
+      eventsBySession.set(event.sessionId, []);
+    }
+    eventsBySession.get(event.sessionId)!.push(event);
+  });
+
+  const attendanceBySession = new Map<string, Record<number, boolean>>();
+
+  lessonSessions.forEach(({ userIds, duration }, sessionId) => {
+    const sessionEvents = eventsBySession.get(sessionId) || [];
+    attendanceBySession.set(
+      sessionId,
+      evaluateAttendance({ events: sessionEvents, userIds, duration })
+    );
+  });
+
   const result: ILesson.FindUserLessonsApiResponse = {
     list: userLessons.map((lesson) => {
       const members = lessonMembers
@@ -284,6 +330,9 @@ async function findLessons(req: Request, res: Response, next: NextFunction) {
           // mask private information
           phone: null,
           verifiedPhone: false,
+          attended: !!attendanceBySession.get(lesson.sessionId)?.[
+            member.userId
+          ],
         }));
       return { lesson, members };
     }),
@@ -308,13 +357,31 @@ async function findLessonById(req: Request, res: Response, next: NextFunction) {
   const isMember = !!members.find((member) => member.userId === user.id);
   if (!isMember) return next(forbidden());
 
+  const memberIds = members.map((member) => member.userId);
+
+  const events = await sessionEvents.find({
+    sessionIds: [lesson.sessionId],
+    users: memberIds,
+    events: [
+      ISessionEvent.EventType.UserJoined,
+      ISessionEvent.EventType.UserLeft,
+    ],
+  });
+
+  const attendance = evaluateAttendance({
+    events,
+    userIds: memberIds,
+    duration: lesson.duration,
+  });
+
   const response: ILesson.FindLessonByIdApiResponse = {
     lesson,
     members: members.map((member) => ({
       ...member,
       // mask private information
       phone: null,
       verifiedPhone: false,
+      attended: attendance[member.userId],
     })),
   };
 

services/server/src/lib/lesson.ts

@@ -0,0 +1,57 @@
+import dayjs from "@/lib/dayjs";
+import { ISessionEvent } from "@litespace/types";
+
+const MIN_ATTENDANCE_REQUIRED = 0.25;
+
+export function evaluateAttendance({
+  events,
+  userIds,
+  duration,
+}: {
+  events: ISessionEvent.Self[];
+  userIds: number[];
+  duration: number;
+}): Record<number, boolean> {
+  const attendanceStatus: Record<number, boolean> = Object.fromEntries(
+    userIds.map((id) => [id, false])
+  );
+
+  const userEventsMap = new Map<number, ISessionEvent.Self[]>();
+
+  events.forEach((event) => {
+    if (userIds.includes(event.userId)) {
+      if (!userEventsMap.has(event.userId)) userEventsMap.set(event.userId, []);
+
+      userEventsMap.get(event.userId)?.push(event);
+    }
+  });
+
+  userEventsMap.forEach((events, userId) => {
+    let totalTime = 0;
+    let lastJoinTime: number | null = null;
+
+    for (const event of events) {
+      if (event.type === ISessionEvent.EventType.UserJoined) {
+        if (lastJoinTime !== null) continue;
+
+        lastJoinTime = dayjs.utc(event.createdAt).valueOf();
+      }
+
+      if (event.type === ISessionEvent.EventType.UserLeft) {
+        if (lastJoinTime === null) continue;
+
+        const leftTime = dayjs.utc(event.createdAt).valueOf();
+        totalTime += leftTime - lastJoinTime;
+        lastJoinTime = null;
+      }
+    }
+
+    const minAttendanceMs = MIN_ATTENDANCE_REQUIRED * duration * 60 * 1000; // minimum attendance in ms
+
+    console.log({ minAttendanceMs, totalTime });
+
+    attendanceStatus[userId] = totalTime >= minAttendanceMs;
+  });
+
+  return attendanceStatus;
+}