@hed-hog/lms 0.0.312 → 0.0.315

package/hedhog/table/enterprise_user.yaml

@@ -21,7 +21,7 @@ columns:
       onDelete: SET NULL
   - name: role
     type: enum
-    values: [hr_manager, enterprise_admin, viewer]
+    values: [hr_manager, enterprise_admin, viewer, instructor]
     default: viewer
   - name: status
     type: enum

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/lms",
-  "version": "0.0.312",
+  "version": "0.0.315",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
@@ -9,15 +9,15 @@
     "@nestjs/core": "^11",
     "@nestjs/jwt": "^11",
     "@nestjs/mapped-types": "*",
-    "@hed-hog/api-prisma": "0.0.6",
-    "@hed-hog/api-pagination": "0.0.7",
-    "@hed-hog/contact": "0.0.312",
-    "@hed-hog/core": "0.0.312",
+    "@hed-hog/api": "0.0.6",
+    "@hed-hog/contact": "0.0.315",
     "@hed-hog/api-locale": "0.0.14",
+    "@hed-hog/api-pagination": "0.0.7",
     "@hed-hog/api-types": "0.0.1",
-    "@hed-hog/finance": "0.0.312",
-    "@hed-hog/api": "0.0.6",
-    "@hed-hog/category": "0.0.312"
+    "@hed-hog/api-prisma": "0.0.6",
+    "@hed-hog/finance": "0.0.315",
+    "@hed-hog/category": "0.0.315",
+    "@hed-hog/core": "0.0.315"
   },
   "exports": {
     ".": {

package/src/enterprise/dto/enterprise-profile.dto.ts

@@ -0,0 +1,17 @@
+export type EnterpriseAccessSlug =
+  | 'lms-enterprise-admin'
+  | 'lms-enterprise-viewer'
+  | 'lms-instructor'
+  | 'lms-student';
+
+export interface EnterpriseProfile {
+  enterpriseId: number;
+  enterpriseName: string;
+  /** Raw value from enterprise_user.role or 'student' for enterprise_student entries */
+  role: string;
+  /** Normalized access slug used by the training app to determine the home dashboard */
+  accessSlug: EnterpriseAccessSlug;
+  status: string;
+  /** file.id of the enterprise's CRM person avatar, null when not set */
+  enterpriseLogoId: number | null;
+}

package/src/enterprise/enterprise.controller.ts

@@ -1,4 +1,4 @@
-import { Role } from '@hed-hog/api';
+import { Public, Role, UserOptional } from '@hed-hog/api';
 import {
     Body,
     Controller,
@@ -57,6 +57,14 @@ export class EnterpriseController {
     return this.enterpriseService.getCrmOptions();
   }
 
+  @Public()
+  @Get('auth/profiles')
+  async getAuthProfiles(@UserOptional() user: any) {
+    if (!user?.id) return { profiles: [] };
+    const profiles = await this.enterpriseService.getProfilesForUser(user.id);
+    return { profiles };
+  }
+
   @Get(':id')
   getById(@Param('id', ParseIntPipe) id: number) {
     return this.enterpriseService.getById(id);

package/src/enterprise/enterprise.service.ts

@@ -1,14 +1,15 @@
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-  ConflictException,
-  Injectable,
-  NotFoundException,
+    ConflictException,
+    Injectable,
+    NotFoundException,
 } from '@nestjs/common';
 import { AddEnterpriseClassGroupDto } from './dto/add-enterprise-class-group.dto';
 import { AddEnterpriseCourseDto } from './dto/add-enterprise-course.dto';
 import { AddEnterpriseStudentDto } from './dto/add-enterprise-student.dto';
 import { AddEnterpriseUserDto } from './dto/add-enterprise-user.dto';
 import { CreateEnterpriseDto } from './dto/create-enterprise.dto';
+import { EnterpriseProfile } from './dto/enterprise-profile.dto';
 import { UpdateEnterpriseStudentDto } from './dto/update-enterprise-student.dto';
 import { UpdateEnterpriseUserDto } from './dto/update-enterprise-user.dto';
 import { UpdateEnterpriseDto } from './dto/update-enterprise.dto';
@@ -192,6 +193,18 @@ export class EnterpriseService {
     }
   }
 
+  private async removeRoleUser(userId: number, roleSlug: string) {
+    const roleId = await this.resolveRoleId(roleSlug);
+    if (!roleId) return;
+    const existing = await this.prisma.role_user.findFirst({
+      where: { user_id: userId, role_id: roleId },
+      select: { id: true },
+    });
+    if (existing) {
+      await this.prisma.role_user.delete({ where: { id: existing.id } });
+    }
+  }
+
   // ─── Users ───────────────────────────────────────────────────────────────────
 
   async listUsers(enterpriseId: number, params: PaginationParams) {
@@ -282,6 +295,7 @@ export class EnterpriseService {
     // Apply the corresponding global LMS role
     const globalSlug = ENTERPRISE_ROLE_TO_GLOBAL_SLUG[dto.role];
     if (globalSlug) await this.upsertRoleUser(dto.user_id, globalSlug);
+    await this.upsertRoleUser(dto.user_id, 'lms-training-access');
 
     return record;
   }
@@ -325,9 +339,16 @@ export class EnterpriseService {
       throw new NotFoundException(
         `User #${userId} is not linked to enterprise #${enterpriseId}`,
       );
-    return this.prisma.enterprise_user.delete({
+    const deleted = await this.prisma.enterprise_user.delete({
       where: { id: existing.id },
     });
+    const remainingLinks = await this.prisma.enterprise_user.count({
+      where: { user_id: userId },
+    });
+    if (remainingLinks === 0) {
+      await this.removeRoleUser(userId, 'lms-training-access');
+    }
+    return deleted;
   }
 
   // ─── Courses ─────────────────────────────────────────────────────────────────
@@ -668,6 +689,128 @@ export class EnterpriseService {
 
   // ─── Mapper ──────────────────────────────────────────────────────────────────
 
+  // ─── Training Auth Profiles ──────────────────────────────────────────────────
+
+  async getProfilesForUser(userId: number): Promise<EnterpriseProfile[]> {
+    const ROLE_TO_SLUG: Record<string, string> = {
+      hr_manager: 'lms-enterprise-admin',
+      enterprise_admin: 'lms-enterprise-admin',
+      viewer: 'lms-enterprise-viewer',
+      instructor: 'lms-instructor',
+    };
+
+    const [enterpriseUsers, personLinks] = await Promise.all([
+      this.prisma.enterprise_user.findMany({
+        where: {
+          user_id: userId,
+          status: { in: ['active', 'pending'] as any[] },
+        },
+        select: {
+          enterprise_id: true,
+          role: true,
+          status: true,
+          enterprise: { select: { name: true, person: { select: { avatar_id: true } } } },
+        },
+      }),
+      this.prisma.person_user.findMany({
+        where: { user_id: userId },
+        select: { person_id: true },
+      }),
+    ]);
+
+    const personIds = personLinks.map((p) => p.person_id);
+    const studentEntries =
+      personIds.length > 0
+        ? await this.prisma.enterprise_student.findMany({
+            where: {
+              person_id: { in: personIds },
+              status: { in: ['active', 'pending'] as any[] },
+            },
+            select: {
+              enterprise_id: true,
+              status: true,
+              enterprise: { select: { name: true, person: { select: { avatar_id: true } } } },
+            },
+          })
+        : [];
+
+    // Activate pending records on first access
+    const pendingEnterpriseIds = enterpriseUsers
+      .filter((eu) => (eu.status as string) === 'pending')
+      .map((eu) => eu.enterprise_id);
+
+    const pendingStudentEnterpriseIds = studentEntries
+      .filter((es) => (es.status as string) === 'pending')
+      .map((es) => es.enterprise_id);
+
+    const activations: Promise<any>[] = [];
+
+    if (pendingEnterpriseIds.length > 0) {
+      activations.push(
+        this.prisma.enterprise_user.updateMany({
+          where: {
+            user_id: userId,
+            enterprise_id: { in: pendingEnterpriseIds },
+            status: 'pending' as any,
+          },
+          data: { status: 'active' as any },
+        }),
+      );
+    }
+
+    if (pendingStudentEnterpriseIds.length > 0) {
+      activations.push(
+        this.prisma.enterprise_student.updateMany({
+          where: {
+            person_id: { in: personIds },
+            enterprise_id: { in: pendingStudentEnterpriseIds },
+            status: 'pending' as any,
+          },
+          data: { status: 'active' as any },
+        }),
+      );
+    }
+
+    if (activations.length > 0) {
+      await Promise.all(activations);
+    }
+
+    const profiles: EnterpriseProfile[] = [];
+    const seen = new Set<string>();
+
+    for (const eu of enterpriseUsers) {
+      const accessSlug = ROLE_TO_SLUG[eu.role as string];
+      if (!accessSlug) continue;
+      const key = `${eu.enterprise_id}:${accessSlug}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      profiles.push({
+        enterpriseId: eu.enterprise_id,
+        enterpriseName: eu.enterprise.name,
+        role: eu.role as string,
+        accessSlug: accessSlug as EnterpriseProfile['accessSlug'],
+        status: 'active',
+        enterpriseLogoId: (eu.enterprise as any).person?.avatar_id ?? null,
+      });
+    }
+
+    for (const es of studentEntries) {
+      const key = `${es.enterprise_id}:lms-student`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      profiles.push({
+        enterpriseId: es.enterprise_id,
+        enterpriseName: es.enterprise.name,
+        role: 'student',
+        accessSlug: 'lms-student',
+        status: 'active',
+        enterpriseLogoId: (es.enterprise as any).person?.avatar_id ?? null,
+      });
+    }
+
+    return profiles;
+  }
+
   private mapEnterprise(
     e: any,
     extra?: {

package/src/instructor/instructor.controller.ts

@@ -1,13 +1,16 @@
-import { Role } from '@hed-hog/api';
+import { Role, User } from '@hed-hog/api';
 import {
-  Body,
-  Controller,
-  Get,
-  Param,
-  ParseIntPipe,
-  Patch,
-  Post,
-  Query,
+    Body,
+    Controller,
+    Delete,
+    Get,
+    HttpCode,
+    HttpStatus,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
 } from '@nestjs/common';
 import { CreateInstructorDto } from './dto/create-instructor.dto';
 import { UpdateInstructorDto } from './dto/update-instructor.dto';
@@ -35,6 +38,16 @@ export class InstructorController {
     });
   }
 
+  @Get('stats')
+  getStats() {
+    return this.instructorService.getStats();
+  }
+
+  @Get('me')
+  getMe(@User('id') userId: number) {
+    return this.instructorService.getMe(userId);
+  }
+
   @Post()
   create(@Body() dto: CreateInstructorDto) {
     return this.instructorService.create(dto);
@@ -45,6 +58,14 @@ export class InstructorController {
     return this.instructorService.getById(id);
   }
 
+  @Patch(':id/training-access')
+  setTrainingAccess(
+    @Param('id', ParseIntPipe) id: number,
+    @Body('enabled') enabled: boolean,
+  ) {
+    return this.instructorService.setTrainingAccess(id, enabled);
+  }
+
   @Patch(':id')
   update(
     @Param('id', ParseIntPipe) id: number,
@@ -53,6 +74,12 @@ export class InstructorController {
     return this.instructorService.update(id, dto);
   }
 
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.instructorService.delete(id);
+  }
+
   private toArray(value?: string | string[]) {
     if (Array.isArray(value)) {
       return value

package/src/instructor/instructor.service.ts

@@ -85,6 +85,20 @@ export class InstructorService {
               id: true,
               name: true,
               avatar_id: true,
+              person_user: {
+                take: 1,
+                select: {
+                  user_id: true,
+                  user: {
+                    select: {
+                      role_user: {
+                        where: { role: { slug: 'lms-instructor' } },
+                        select: { id: true },
+                      },
+                    },
+                  },
+                },
+              },
             },
           },
           instructor_qualification_assignment: {
@@ -106,16 +120,21 @@ export class InstructorService {
 
     return {
       data: rows
-        .map((row) => ({
-          id: row.id,
-          personId: row.person_id,
-          name: row.person?.name?.trim() || `Instructor #${row.id}`,
-          avatarId: row.person?.avatar_id ?? null,
-          status: row.status,
-          qualificationSlugs: row.instructor_qualification_assignment
-            .map((assignment) => assignment.instructor_qualification.slug)
-            .sort(),
-        }))
+        .map((row) => {
+          const personUser = row.person?.person_user?.[0] ?? null;
+          return {
+            id: row.id,
+            personId: row.person_id,
+            name: row.person?.name?.trim() || `Instructor #${row.id}`,
+            avatarId: row.person?.avatar_id ?? null,
+            userId: personUser?.user_id ?? null,
+            hasTrainingAccess: (personUser?.user?.role_user?.length ?? 0) > 0,
+            status: row.status,
+            qualificationSlugs: row.instructor_qualification_assignment
+              .map((assignment) => assignment.instructor_qualification.slug)
+              .sort(),
+          };
+        })
         .sort((left, right) => left.name.localeCompare(right.name)),
       total,
       page,
@@ -269,6 +288,37 @@ export class InstructorService {
     });
   }
 
+  async getMe(userId: number) {
+    const instructor = await this.prisma.instructor.findFirst({
+      where: {
+        person: {
+          person_user: {
+            some: { user_id: userId },
+          },
+        },
+      },
+      select: {
+        id: true,
+        person: {
+          select: {
+            name: true,
+            avatar_id: true,
+          },
+        },
+      },
+    });
+
+    if (!instructor) {
+      return { isInstructor: false, avatarId: null, name: null };
+    }
+
+    return {
+      isInstructor: true,
+      avatarId: instructor.person?.avatar_id ?? null,
+      name: instructor.person?.name?.trim() || null,
+    };
+  }
+
   async getById(id: number, db: DbClient = this.prisma) {
     await this.ensureQualificationCatalog(db);
     await this.backfillLegacyCourseLessonQualifications(db);
@@ -295,6 +345,20 @@ export class InstructorService {
               },
               orderBy: [{ is_primary: 'desc' }, { id: 'asc' }],
             },
+            person_user: {
+              take: 1,
+              select: {
+                user_id: true,
+                user: {
+                  select: {
+                    role_user: {
+                      where: { role: { slug: 'lms-instructor' } },
+                      select: { id: true },
+                    },
+                  },
+                },
+              },
+            },
           },
         },
         instructor_qualification_assignment: {
@@ -313,11 +377,15 @@ export class InstructorService {
       throw new NotFoundException('Instructor not found');
     }
 
+    const personUser = instructor.person.person_user?.[0] ?? null;
+
     return {
       id: instructor.id,
       personId: instructor.person.id,
       name: instructor.person.name?.trim() || `Instructor #${instructor.id}`,
       avatarId: instructor.person.avatar_id ?? null,
+      userId: personUser?.user_id ?? null,
+      hasTrainingAccess: (personUser?.user?.role_user?.length ?? 0) > 0,
       email: this.getPrimaryContactValue(instructor.person.contact, ['EMAIL']),
       phone: this.getPrimaryContactValue(instructor.person.contact, [
         'PHONE',
@@ -331,6 +399,68 @@ export class InstructorService {
     };
   }
 
+  async setTrainingAccess(instructorId: number, enabled: boolean) {
+    const instructor = await this.prisma.instructor.findUnique({
+      where: { id: instructorId },
+      select: {
+        person: {
+          select: {
+            person_user: { take: 1, select: { user_id: true } },
+          },
+        },
+      },
+    });
+
+    const userId = instructor?.person?.person_user?.[0]?.user_id;
+    if (!userId) {
+      throw new BadRequestException('Instrutor não possui usuário vinculado.');
+    }
+
+    const role = await this.prisma.role.findFirst({
+      where: { slug: 'lms-instructor' },
+      select: { id: true },
+    });
+    if (!role) {
+      throw new BadRequestException('Role lms-instructor não encontrada.');
+    }
+
+    if (enabled) {
+      await this.prisma.role_user.upsert({
+        where: { role_id_user_id: { role_id: role.id, user_id: userId } },
+        create: { role_id: role.id, user_id: userId },
+        update: {},
+      });
+    } else {
+      await this.prisma.role_user.deleteMany({
+        where: { role_id: role.id, user_id: userId },
+      });
+    }
+
+    return { userId, enabled };
+  }
+
+  async getStats() {
+    const [total, active, inactive] = await Promise.all([
+      this.prisma.instructor.count(),
+      this.prisma.instructor.count({ where: { status: 'active' } }),
+      this.prisma.instructor.count({ where: { status: 'inactive' } }),
+    ]);
+    return { total, active, inactive };
+  }
+
+  async delete(id: number) {
+    const instructor = await this.prisma.instructor.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!instructor) {
+      throw new NotFoundException('Instructor not found');
+    }
+
+    await this.prisma.instructor.delete({ where: { id } });
+  }
+
   async listQualifiedInstructorOptions(qualificationSlugs: string[]) {
     const result = await this.list({
       page: 1,