@hed-hog/lms 0.0.331 → 0.0.338

package/src/enterprise/enterprise.service.ts

@@ -23,6 +23,8 @@ type PaginationParams = {
   crmPersonId?: number;
 };
 
+type LicenseEventType = 'assigned' | 'revoked' | 'status_changed';
+
 /** Maps enterprise_user.role to the global role slug that should be granted. */
 const ENTERPRISE_ROLE_TO_GLOBAL_SLUG: Partial<Record<string, string>> = {
   enterprise_admin: 'lms-enterprise-admin',
@@ -96,6 +98,7 @@ export class EnterpriseService {
             id: true,
             name: true,
             type: true,
+            avatar_id: true,
           },
         },
         _count: {
@@ -155,6 +158,175 @@ export class EnterpriseService {
     return this.prisma.enterprise.update({ where: { id }, data: dto as any });
   }
 
+  async getOverview(id: number) {
+    const enterprise = await this.getById(id);
+    if (!enterprise) return null;
+
+    const eventModel = (this.prisma as any).enterprise_student_license_event;
+    const now = new Date();
+    const timelineStart = new Date(
+      Date.UTC(now.getUTCFullYear(), now.getUTCMonth() - 11, 1),
+    );
+
+    const [
+      studentRows,
+      scheduledClasses,
+      licenseEvents,
+      recentCourses,
+      recentClasses,
+      recentStudents,
+      recentAdmins,
+    ] = await Promise.all([
+      this.prisma.enterprise_student.findMany({
+        where: { enterprise_id: id },
+        select: {
+          person_id: true,
+          status: true,
+          created_at: true,
+          person: { select: { id: true, name: true } },
+        },
+      }),
+      this.prisma.enterprise_class_group.findMany({
+        where: {
+          enterprise_id: id,
+          course_class_group: { status: { in: ['open', 'ongoing'] as any[] } },
+        },
+        select: {
+          created_at: true,
+          course_class_group: {
+            select: {
+              id: true,
+              code: true,
+              title: true,
+              status: true,
+              capacity: true,
+              course: { select: { title: true } },
+              _count: {
+                select: {
+                  course_enrollment: {
+                    where: { status: { not: 'cancelled' } },
+                  },
+                },
+              },
+            },
+          },
+        },
+      }),
+      eventModel
+        ? eventModel
+            .findMany({
+              where: { enterprise_id: id },
+              orderBy: { created_at: 'asc' },
+              select: {
+                person_id: true,
+                event_type: true,
+                previous_status: true,
+                next_status: true,
+                created_at: true,
+                person: { select: { id: true, name: true } },
+              },
+            })
+            .catch(() => [])
+        : Promise.resolve([]),
+      this.prisma.enterprise_course.findMany({
+        where: { enterprise_id: id },
+        take: 5,
+        orderBy: { created_at: 'desc' },
+        select: {
+          created_at: true,
+          course: { select: { id: true, title: true } },
+        },
+      }),
+      this.prisma.enterprise_class_group.findMany({
+        where: { enterprise_id: id },
+        take: 5,
+        orderBy: { created_at: 'desc' },
+        select: {
+          created_at: true,
+          course_class_group: {
+            select: {
+              id: true,
+              code: true,
+              title: true,
+              course: { select: { title: true } },
+            },
+          },
+        },
+      }),
+      this.prisma.enterprise_student.findMany({
+        where: { enterprise_id: id },
+        take: 5,
+        orderBy: { created_at: 'desc' },
+        select: {
+          created_at: true,
+          person: { select: { id: true, name: true } },
+        },
+      }),
+      this.prisma.enterprise_user.findMany({
+        where: { enterprise_id: id },
+        take: 5,
+        orderBy: { created_at: 'desc' },
+        select: {
+          created_at: true,
+          role: true,
+          user: { select: { id: true, name: true } },
+        },
+      }),
+    ]);
+
+    const used = studentRows.length;
+    const limit = enterprise.licenseLimit;
+    const available =
+      limit === null ? null : Math.max((limit as number) - used, 0);
+    const percent =
+      limit && limit > 0 ? Math.min(100, Math.round((used / limit) * 100)) : 0;
+
+    const capacity = scheduledClasses.reduce(
+      (sum, row) => sum + Math.max(row.course_class_group?.capacity ?? 0, 0),
+      0,
+    );
+    const seatsUsed = scheduledClasses.reduce(
+      (sum, row) =>
+        sum + (row.course_class_group?._count?.course_enrollment ?? 0),
+      0,
+    );
+
+    return {
+      account: enterprise,
+      kpis: {
+        students: enterprise.studentsCount,
+        classes: enterprise.classesCount,
+        courses: enterprise.coursesCount,
+        administrators: enterprise.adminsCount + enterprise.managersCount,
+        portalEnabled: enterprise.portalEnabled,
+      },
+      licenseUsage: {
+        used,
+        limit,
+        available,
+        percent,
+      },
+      scheduledSeats: {
+        used: seatsUsed,
+        open: Math.max(capacity - seatsUsed, 0),
+        capacity,
+      },
+      licenseTimeline: this.buildLicenseTimeline(
+        studentRows,
+        licenseEvents,
+        timelineStart,
+        now,
+      ),
+      activities: this.buildEnterpriseActivities(
+        licenseEvents,
+        recentCourses,
+        recentClasses,
+        recentStudents,
+        recentAdmins,
+      ),
+    };
+  }
+
   async delete(id: number) {
     await this.assertEnterpriseExists(id);
     return this.prisma.enterprise.delete({ where: { id } });
@@ -171,6 +343,217 @@ export class EnterpriseService {
     return exists;
   }
 
+  private async recordLicenseEvent(params: {
+    enterpriseId: number;
+    personId: number;
+    eventType: LicenseEventType;
+    previousStatus?: string | null;
+    nextStatus?: string | null;
+  }) {
+    const eventModel = (this.prisma as any).enterprise_student_license_event;
+    if (!eventModel) return;
+    try {
+      await eventModel.create({
+        data: {
+          enterprise_id: params.enterpriseId,
+          person_id: params.personId,
+          event_type: params.eventType,
+          previous_status: params.previousStatus ?? null,
+          next_status: params.nextStatus ?? null,
+        },
+      });
+    } catch {
+      // The YAML/DB apply step may not have run yet in older environments.
+    }
+  }
+
+  private monthKey(date: Date) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    return `${year}-${month}`;
+  }
+
+  private monthLabel(date: Date) {
+    return date.toLocaleDateString('pt-BR', {
+      month: 'short',
+      year: '2-digit',
+      timeZone: 'UTC',
+    });
+  }
+
+  private buildLicenseTimeline(
+    studentRows: Array<{
+      person_id: number;
+      created_at: Date;
+    }>,
+    eventRows: Array<{
+      person_id: number;
+      event_type: string;
+      previous_status?: string | null;
+      next_status?: string | null;
+      created_at: Date;
+    }>,
+    start: Date,
+    end: Date,
+  ) {
+    const eventsByPerson = new Set(
+      eventRows
+        .filter((event) => event.event_type === 'assigned')
+        .map((event) => event.person_id),
+    );
+    const syntheticEvents = studentRows
+      .filter((student) => !eventsByPerson.has(student.person_id))
+      .map((student) => ({
+        person_id: student.person_id,
+        event_type: 'assigned',
+        previous_status: null,
+        next_status: 'active',
+        created_at: student.created_at,
+      }));
+
+    const allEvents = [...eventRows, ...syntheticEvents].sort(
+      (a, b) => a.created_at.getTime() - b.created_at.getTime(),
+    );
+
+    let running = 0;
+    for (const event of allEvents) {
+      if (event.created_at >= start) break;
+      running += this.getLicenseEventDelta(event);
+      running = Math.max(running, 0);
+    }
+
+    const points: Array<{
+      period: string;
+      label: string;
+      used: number;
+      assigned: number;
+      revoked: number;
+    }> = [];
+
+    const cursor = new Date(
+      Date.UTC(start.getUTCFullYear(), start.getUTCMonth(), 1),
+    );
+    while (cursor <= end) {
+      const key = this.monthKey(cursor);
+      const monthEvents = allEvents.filter(
+        (event) => this.monthKey(event.created_at) === key,
+      );
+      const assigned = monthEvents.filter(
+        (event) => this.getLicenseEventDelta(event) > 0,
+      ).length;
+      const revoked = monthEvents.filter(
+        (event) => this.getLicenseEventDelta(event) < 0,
+      ).length;
+      for (const event of monthEvents) {
+        running += this.getLicenseEventDelta(event);
+        running = Math.max(running, 0);
+      }
+      points.push({
+        period: key,
+        label: this.monthLabel(cursor),
+        used: running,
+        assigned,
+        revoked,
+      });
+      cursor.setUTCMonth(cursor.getUTCMonth() + 1);
+    }
+
+    return points;
+  }
+
+  private getLicenseEventDelta(event: {
+    event_type: string;
+    previous_status?: string | null;
+    next_status?: string | null;
+  }) {
+    if (event.event_type === 'assigned') return 1;
+    if (event.event_type === 'revoked') return -1;
+    if (event.event_type === 'status_changed') {
+      const wasActive = event.previous_status !== 'inactive';
+      const isActive = event.next_status !== 'inactive';
+      if (!wasActive && isActive) return 1;
+      if (wasActive && !isActive) return -1;
+    }
+    return 0;
+  }
+
+  private buildEnterpriseActivities(
+    licenseEvents: Array<{
+      event_type: string;
+      created_at: Date;
+      person?: { id: number; name: string | null } | null;
+    }>,
+    courses: Array<{
+      created_at: Date;
+      course?: { id: number; title: string | null } | null;
+    }>,
+    classes: Array<{
+      created_at: Date;
+      course_class_group?: {
+        id: number;
+        code: string | null;
+        title: string | null;
+        course?: { title: string | null } | null;
+      } | null;
+    }>,
+    students: Array<{
+      created_at: Date;
+      person?: { id: number; name: string | null } | null;
+    }>,
+    admins: Array<{
+      created_at: Date;
+      role: string;
+      user?: { id: number; name: string | null } | null;
+    }>,
+  ) {
+    return [
+      ...licenseEvents.slice(-10).map((event) => ({
+        id: `license-${event.person?.id ?? 'unknown'}-${event.created_at.getTime()}`,
+        type: event.event_type,
+        title:
+          event.event_type === 'revoked'
+            ? 'Licenca removida'
+            : 'Licenca atribuida',
+        description: event.person?.name ?? 'Aluno',
+        createdAt: event.created_at,
+      })),
+      ...courses.map((row) => ({
+        id: `course-${row.course?.id ?? 'unknown'}-${row.created_at.getTime()}`,
+        type: 'course',
+        title: 'Curso vinculado',
+        description: row.course?.title ?? 'Curso',
+        createdAt: row.created_at,
+      })),
+      ...classes.map((row) => ({
+        id: `class-${row.course_class_group?.id ?? 'unknown'}-${row.created_at.getTime()}`,
+        type: 'class',
+        title: 'Turma vinculada',
+        description:
+          row.course_class_group?.code ??
+          row.course_class_group?.title ??
+          row.course_class_group?.course?.title ??
+          'Turma',
+        createdAt: row.created_at,
+      })),
+      ...students.map((row) => ({
+        id: `student-${row.person?.id ?? 'unknown'}-${row.created_at.getTime()}`,
+        type: 'student',
+        title: 'Aluno adicionado',
+        description: row.person?.name ?? 'Aluno',
+        createdAt: row.created_at,
+      })),
+      ...admins.map((row) => ({
+        id: `admin-${row.user?.id ?? 'unknown'}-${row.created_at.getTime()}`,
+        type: 'admin',
+        title: 'Administrador adicionado',
+        description: row.user?.name ? `${row.user.name} (${row.role})` : row.role,
+        createdAt: row.created_at,
+      })),
+    ]
+      .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+      .slice(0, 12);
+  }
+
   private async resolveRoleId(slug: string): Promise<number | null> {
     const role = await this.prisma.role.findUnique({
       where: { slug },
@@ -240,6 +623,7 @@ export class EnterpriseService {
               id: true,
               name: true,
               last_login_at: true,
+              photo_id: true,
               user_identifier: {
                 where: { type: 'email' },
                 select: { value: true },
@@ -263,6 +647,7 @@ export class EnterpriseService {
         personId: r.person_id,
         name: r.user?.name ?? null,
         email: r.user?.user_identifier?.[0]?.value ?? null,
+        photoId: r.user?.photo_id ?? null,
         role: r.role,
         status: r.status,
         lastAccessAt: r.user?.last_login_at ?? null,
@@ -380,6 +765,16 @@ export class EnterpriseService {
               status: true,
               level: true,
               offering_type: true,
+              course_image: {
+                where: { image_type: { slug: 'course-logo' } },
+                take: 1,
+                select: {
+                  file_id: true,
+                  file: {
+                    select: { id: true },
+                  },
+                },
+              },
             },
           },
         },
@@ -392,16 +787,21 @@ export class EnterpriseService {
       page,
       pageSize,
       lastPage: Math.max(1, Math.ceil(total / pageSize)),
-      data: rows.map((r) => ({
-        id: r.id,
-        courseId: r.course_id,
-        contractedAt: r.contracted_at,
-        title: r.course?.title ?? null,
-        slug: r.course?.slug ?? null,
-        status: r.course?.status ?? null,
-        level: r.course?.level ?? null,
-        modality: r.course?.offering_type ?? null,
-      })),
+      data: rows.map((r) => {
+        const courseLogo = r.course?.course_image?.[0] ?? null;
+
+        return {
+          id: r.id,
+          courseId: r.course_id,
+          contractedAt: r.contracted_at,
+          title: r.course?.title ?? null,
+          slug: r.course?.slug ?? null,
+          status: r.course?.status ?? null,
+          level: r.course?.level ?? null,
+          modality: r.course?.offering_type ?? null,
+          logoFileId: courseLogo?.file?.id ?? courseLogo?.file_id ?? null,
+        };
+      }),
     };
   }
 
@@ -481,7 +881,43 @@ export class EnterpriseService {
               start_date: true,
               end_date: true,
               capacity: true,
-              course: { select: { id: true, title: true, slug: true } },
+              _count: {
+                select: {
+                  course_enrollment: {
+                    where: {
+                      status: { not: 'cancelled' },
+                    },
+                  },
+                },
+              },
+              instructor: {
+                select: {
+                  id: true,
+                  person: {
+                    select: {
+                      name: true,
+                      avatar_id: true,
+                    },
+                  },
+                },
+              },
+              course: {
+                select: {
+                  id: true,
+                  title: true,
+                  slug: true,
+                  course_image: {
+                    where: { image_type: { slug: 'course-logo' } },
+                    take: 1,
+                    select: {
+                      file_id: true,
+                      file: {
+                        select: { id: true },
+                      },
+                    },
+                  },
+                },
+              },
             },
           },
         },
@@ -494,19 +930,28 @@ export class EnterpriseService {
       page,
       pageSize,
       lastPage: Math.max(1, Math.ceil(total / pageSize)),
-      data: rows.map((r) => ({
-        id: r.id,
-        courseClassGroupId: r.course_class_group_id,
-        code: r.course_class_group?.code ?? null,
-        title: r.course_class_group?.title ?? null,
-        status: r.course_class_group?.status ?? null,
-        deliveryMode: r.course_class_group?.delivery_mode ?? null,
-        startDate: r.course_class_group?.start_date ?? null,
-        endDate: r.course_class_group?.end_date ?? null,
-        capacity: r.course_class_group?.capacity ?? null,
-        courseTitle: r.course_class_group?.course?.title ?? null,
-        courseSlug: r.course_class_group?.course?.slug ?? null,
-      })),
+      data: rows.map((r) => {
+        const courseLogo = r.course_class_group?.course?.course_image?.[0] ?? null;
+
+        return {
+          id: r.id,
+          courseClassGroupId: r.course_class_group_id,
+          code: r.course_class_group?.code ?? null,
+          title: r.course_class_group?.title ?? null,
+          status: r.course_class_group?.status ?? null,
+          deliveryMode: r.course_class_group?.delivery_mode ?? null,
+          startDate: r.course_class_group?.start_date ?? null,
+          endDate: r.course_class_group?.end_date ?? null,
+          capacity: r.course_class_group?.capacity ?? null,
+          enrolledCount: r.course_class_group?._count?.course_enrollment ?? 0,
+          instructorId: r.course_class_group?.instructor?.id ?? null,
+          instructorName: r.course_class_group?.instructor?.person?.name ?? null,
+          instructorAvatarId: r.course_class_group?.instructor?.person?.avatar_id ?? null,
+          courseTitle: r.course_class_group?.course?.title ?? null,
+          courseSlug: r.course_class_group?.course?.slug ?? null,
+          logoFileId: courseLogo?.file?.id ?? courseLogo?.file_id ?? null,
+        };
+      }),
     };
   }
 
@@ -554,6 +999,12 @@ export class EnterpriseService {
         await this.prisma.enterprise_student.create({
           data: { enterprise_id: enterpriseId, person_id, status: 'active' },
         });
+        await this.recordLicenseEvent({
+          enterpriseId,
+          personId: person_id,
+          eventType: 'assigned',
+          nextStatus: 'active',
+        });
       }
     }
 
@@ -601,6 +1052,7 @@ export class EnterpriseService {
             select: {
               id: true,
               name: true,
+              avatar_id: true,
               contact: {
                 where: { contact_type: { code: 'EMAIL' }, is_primary: true },
                 select: { value: true },
@@ -623,6 +1075,7 @@ export class EnterpriseService {
         personId: r.person_id,
         name: r.person?.name ?? null,
         email: r.person?.contact?.[0]?.value ?? null,
+        avatarId: r.person?.avatar_id ?? null,
         status: r.status,
         createdAt: r.created_at,
       })),
@@ -647,9 +1100,16 @@ export class EnterpriseService {
         `Person #${dto.person_id} is already a student of enterprise #${enterpriseId}`,
       );
 
-    return this.prisma.enterprise_student.create({
+    const created = await this.prisma.enterprise_student.create({
       data: { enterprise_id: enterpriseId, ...(dto as any) },
     });
+    await this.recordLicenseEvent({
+      enterpriseId,
+      personId: dto.person_id,
+      eventType: 'assigned',
+      nextStatus: (dto as any).status ?? 'pending',
+    });
+    return created;
   }
 
   async updateStudent(
@@ -660,31 +1120,48 @@ export class EnterpriseService {
     await this.assertEnterpriseExists(enterpriseId);
     const existing = await this.prisma.enterprise_student.findFirst({
       where: { enterprise_id: enterpriseId, person_id: personId },
-      select: { id: true },
+      select: { id: true, status: true },
     });
     if (!existing)
       throw new NotFoundException(
         `Person #${personId} is not a student of enterprise #${enterpriseId}`,
       );
-    return this.prisma.enterprise_student.update({
+    const updated = await this.prisma.enterprise_student.update({
       where: { id: existing.id },
       data: dto as any,
     });
+    if (dto.status && dto.status !== existing.status) {
+      await this.recordLicenseEvent({
+        enterpriseId,
+        personId,
+        eventType: 'status_changed',
+        previousStatus: existing.status,
+        nextStatus: dto.status,
+      });
+    }
+    return updated;
   }
 
   async removeStudent(enterpriseId: number, personId: number) {
     await this.assertEnterpriseExists(enterpriseId);
     const existing = await this.prisma.enterprise_student.findFirst({
       where: { enterprise_id: enterpriseId, person_id: personId },
-      select: { id: true },
+      select: { id: true, status: true },
     });
     if (!existing)
       throw new NotFoundException(
         `Person #${personId} is not a student of enterprise #${enterpriseId}`,
       );
-    return this.prisma.enterprise_student.delete({
+    const deleted = await this.prisma.enterprise_student.delete({
       where: { id: existing.id },
     });
+    await this.recordLicenseEvent({
+      enterpriseId,
+      personId,
+      eventType: 'revoked',
+      previousStatus: existing.status,
+    });
+    return deleted;
   }
 
   // ─── Stats / options ──────────────────────────────────────────────────────────
@@ -921,6 +1398,7 @@ export class EnterpriseService {
         ? {
             id: person.id as number,
             name: person.name as string,
+            avatarId: (person.avatar_id as number | null) ?? null,
             tradeName: (pc?.trade_name as string | null) ?? null,
             industry: (pc?.industry as string | null) ?? null,
             website: (pc?.website as string | null) ?? null,

package/src/enterprise/training/training-admin.controller.ts

@@ -49,6 +49,8 @@ export class TrainingAdminController {
   getClassGroups(
     @User('id') userId: number,
     @Query('enterpriseId', new ParseIntPipe({ optional: true })) enterpriseId?: number,
+    @Query('page', new ParseIntPipe({ optional: true })) page?: number,
+    @Query('pageSize', new ParseIntPipe({ optional: true })) pageSize?: number,
     @Query('search') search?: string,
     @Query('status') status?: string,
     @Query('deliveryMode') deliveryMode?: string,
@@ -56,6 +58,8 @@ export class TrainingAdminController {
   ) {
     return this.trainingAdminService.getClassGroups(userId, {
       enterpriseId,
+      page,
+      pageSize,
       search,
       status,
       deliveryMode,