@hed-hog/lms 0.0.304 → 0.0.306

package/src/enterprise/enterprise.service.ts

@@ -0,0 +1,712 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  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 { UpdateEnterpriseStudentDto } from './dto/update-enterprise-student.dto';
+import { UpdateEnterpriseUserDto } from './dto/update-enterprise-user.dto';
+import { UpdateEnterpriseDto } from './dto/update-enterprise.dto';
+
+type PaginationParams = {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  status?: string;
+  role?: string;
+  crmPersonId?: number;
+};
+
+/** 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',
+  hr_manager: 'lms-enterprise-admin',
+};
+
+function paginate(params: PaginationParams) {
+  const page = Math.max(Number(params.page) || 1, 1);
+  const pageSize = Math.max(Number(params.pageSize) || 20, 1);
+  const skip = (page - 1) * pageSize;
+  return { page, pageSize, skip };
+}
+
+@Injectable()
+export class EnterpriseService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(params: PaginationParams) {
+    const { page, pageSize, skip } = paginate(params);
+
+    const where: any = {};
+    if (params.search?.trim()) {
+      const s = params.search.trim();
+      where.OR = [
+        { name: { contains: s, mode: 'insensitive' } },
+        { slug: { contains: s, mode: 'insensitive' } },
+      ];
+    }
+    if (params.status && params.status !== 'all') {
+      where.status = params.status;
+    }
+    if (params.crmPersonId) {
+      where.crm_person_id = params.crmPersonId;
+    }
+
+    const [data, total] = await Promise.all([
+      this.prisma.enterprise.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { name: 'asc' },
+        include: {
+          person: { select: { id: true, name: true } },
+          _count: {
+            select: {
+              enterprise_user: true,
+              enterprise_course: true,
+              enterprise_class_group: true,
+            },
+          },
+        },
+      }),
+      this.prisma.enterprise.count({ where }),
+    ]);
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: data.map((e) => this.mapEnterprise(e)),
+    };
+  }
+
+  async getById(id: number) {
+    const e = await this.prisma.enterprise.findUnique({
+      where: { id },
+      include: {
+        person: {
+          select: {
+            id: true,
+            name: true,
+            type: true,
+          },
+        },
+        _count: {
+          select: {
+            enterprise_user: true,
+            enterprise_course: true,
+            enterprise_class_group: true,
+          },
+        },
+      },
+    });
+    if (!e) return null;
+
+    // Compute role breakdowns and fetch person_company separately
+    // (person_company shares the same PK as person — no Prisma reverse relation)
+    const [studentsCount, managersCount, adminsCount, personCompany] = await Promise.all([
+      this.prisma.enterprise_student.count({
+        where: { enterprise_id: id },
+      }),
+      this.prisma.enterprise_user.count({
+        where: { enterprise_id: id, role: 'hr_manager' as any },
+      }),
+      this.prisma.enterprise_user.count({
+        where: { enterprise_id: id, role: 'enterprise_admin' as any },
+      }),
+      e.person?.id
+        ? this.prisma.person_company.findUnique({
+            where: { id: e.person.id },
+            select: {
+              trade_name: true,
+              industry: true,
+              website: true,
+              account_lifecycle_stage: true,
+            },
+          })
+        : Promise.resolve(null),
+    ]);
+
+    return this.mapEnterprise(e, { studentsCount, managersCount, adminsCount, personCompany });
+  }
+
+  async create(dto: CreateEnterpriseDto) {
+    try {
+      return await this.prisma.enterprise.create({ data: dto as any });
+    } catch (err: any) {
+      if (err?.code === 'P2002') {
+        throw new ConflictException(
+          `An enterprise with slug "${(dto as any).slug}" already exists.`,
+        );
+      }
+      throw err;
+    }
+  }
+
+  async update(id: number, dto: UpdateEnterpriseDto) {
+    await this.assertEnterpriseExists(id);
+    return this.prisma.enterprise.update({ where: { id }, data: dto as any });
+  }
+
+  async delete(id: number) {
+    await this.assertEnterpriseExists(id);
+    return this.prisma.enterprise.delete({ where: { id } });
+  }
+
+  // ─── Helpers ─────────────────────────────────────────────────────────────────
+
+  private async assertEnterpriseExists(id: number) {
+    const exists = await this.prisma.enterprise.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+    if (!exists) throw new NotFoundException(`Enterprise #${id} not found`);
+    return exists;
+  }
+
+  private async resolveRoleId(slug: string): Promise<number | null> {
+    const role = await this.prisma.role.findUnique({
+      where: { slug },
+      select: { id: true },
+    });
+    return role?.id ?? null;
+  }
+
+  private async upsertRoleUser(userId: number, roleSlug: string) {
+    const roleId = await this.resolveRoleId(roleSlug);
+    if (!roleId) return; // role not seeded yet — skip silently
+    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.create({
+        data: { user_id: userId, role_id: roleId },
+      });
+    }
+  }
+
+  // ─── Users ───────────────────────────────────────────────────────────────────
+
+  async listUsers(enterpriseId: number, params: PaginationParams) {
+    await this.assertEnterpriseExists(enterpriseId);
+    const { page, pageSize, skip } = paginate(params);
+
+    const where: any = { enterprise_id: enterpriseId };
+    if (params.search?.trim()) {
+      const s = params.search.trim();
+      where.user = {
+        OR: [
+          { name: { contains: s, mode: 'insensitive' } },
+          {
+            user_identifier: {
+              some: { type: 'email', value: { contains: s, mode: 'insensitive' } },
+            },
+          },
+        ],
+      };
+    }
+    if (params.status) where.status = params.status;
+    if (params.role) where.role = params.role;
+
+    const [rows, total] = await Promise.all([
+      this.prisma.enterprise_user.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { created_at: 'desc' },
+        include: {
+          user: {
+            select: {
+              id: true,
+              name: true,
+              last_login_at: true,
+              user_identifier: {
+                where: { type: 'email' },
+                select: { value: true },
+                take: 1,
+              },
+            },
+          },
+        },
+      }),
+      this.prisma.enterprise_user.count({ where }),
+    ]);
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: rows.map((r) => ({
+        id: r.id,
+        userId: r.user_id,
+        personId: r.person_id,
+        name: r.user?.name ?? null,
+        email: r.user?.user_identifier?.[0]?.value ?? null,
+        role: r.role,
+        status: r.status,
+        lastAccessAt: r.user?.last_login_at ?? null,
+      })),
+    };
+  }
+
+  async addUser(enterpriseId: number, dto: AddEnterpriseUserDto) {
+    await this.assertEnterpriseExists(enterpriseId);
+
+    const user = await this.prisma.user.findUnique({
+      where: { id: dto.user_id },
+      select: { id: true },
+    });
+    if (!user) throw new NotFoundException(`User #${dto.user_id} not found`);
+
+    const duplicate = await this.prisma.enterprise_user.findFirst({
+      where: { enterprise_id: enterpriseId, user_id: dto.user_id },
+      select: { id: true },
+    });
+    if (duplicate)
+      throw new ConflictException(
+        `User #${dto.user_id} is already linked to this enterprise`,
+      );
+
+    const record = await this.prisma.enterprise_user.create({
+      data: { enterprise_id: enterpriseId, ...(dto as any) },
+    });
+
+    // Apply the corresponding global LMS role
+    const globalSlug = ENTERPRISE_ROLE_TO_GLOBAL_SLUG[dto.role];
+    if (globalSlug) await this.upsertRoleUser(dto.user_id, globalSlug);
+
+    return record;
+  }
+
+  async updateUser(
+    enterpriseId: number,
+    userId: number,
+    dto: UpdateEnterpriseUserDto,
+  ) {
+    await this.assertEnterpriseExists(enterpriseId);
+    const existing = await this.prisma.enterprise_user.findFirst({
+      where: { enterprise_id: enterpriseId, user_id: userId },
+      select: { id: true, role: true },
+    });
+    if (!existing)
+      throw new NotFoundException(
+        `User #${userId} is not linked to enterprise #${enterpriseId}`,
+      );
+
+    const updated = await this.prisma.enterprise_user.update({
+      where: { id: existing.id },
+      data: dto as any,
+    });
+
+    // If role changed, upsert the new global role
+    if (dto.role && dto.role !== existing.role) {
+      const globalSlug = ENTERPRISE_ROLE_TO_GLOBAL_SLUG[dto.role];
+      if (globalSlug) await this.upsertRoleUser(userId, globalSlug);
+    }
+
+    return updated;
+  }
+
+  async removeUser(enterpriseId: number, userId: number) {
+    await this.assertEnterpriseExists(enterpriseId);
+    const existing = await this.prisma.enterprise_user.findFirst({
+      where: { enterprise_id: enterpriseId, user_id: userId },
+      select: { id: true },
+    });
+    if (!existing)
+      throw new NotFoundException(
+        `User #${userId} is not linked to enterprise #${enterpriseId}`,
+      );
+    return this.prisma.enterprise_user.delete({
+      where: { id: existing.id },
+    });
+  }
+
+  // ─── Courses ─────────────────────────────────────────────────────────────────
+
+  async listCourses(enterpriseId: number, params: PaginationParams) {
+    await this.assertEnterpriseExists(enterpriseId);
+    const { page, pageSize, skip } = paginate(params);
+
+    const where: any = { enterprise_id: enterpriseId };
+    if (params.search?.trim() || params.status) {
+      where.course = {
+        ...(params.search?.trim() ? { title: { contains: params.search.trim(), mode: 'insensitive' } } : {}),
+        ...(params.status ? { status: params.status } : {}),
+      };
+    }
+
+    const [rows, total] = await Promise.all([
+      this.prisma.enterprise_course.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { contracted_at: 'desc' },
+        include: {
+          course: {
+            select: {
+              id: true,
+              title: true,
+              slug: true,
+              status: true,
+              level: true,
+              offering_type: true,
+            },
+          },
+        },
+      }),
+      this.prisma.enterprise_course.count({ where }),
+    ]);
+
+    return {
+      total,
+      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,
+      })),
+    };
+  }
+
+  async addCourse(enterpriseId: number, dto: AddEnterpriseCourseDto) {
+    await this.assertEnterpriseExists(enterpriseId);
+
+    const course = await this.prisma.course.findUnique({
+      where: { id: dto.course_id },
+      select: { id: true },
+    });
+    if (!course) throw new NotFoundException(`Course #${dto.course_id} not found`);
+
+    const duplicate = await this.prisma.enterprise_course.findFirst({
+      where: { enterprise_id: enterpriseId, course_id: dto.course_id },
+      select: { id: true },
+    });
+    if (duplicate)
+      throw new ConflictException(
+        `Course #${dto.course_id} is already linked to this enterprise`,
+      );
+
+    return this.prisma.enterprise_course.create({
+      data: { enterprise_id: enterpriseId, ...(dto as any) },
+    });
+  }
+
+  async removeCourse(enterpriseId: number, courseId: number) {
+    await this.assertEnterpriseExists(enterpriseId);
+    const existing = await this.prisma.enterprise_course.findFirst({
+      where: { enterprise_id: enterpriseId, course_id: courseId },
+      select: { id: true },
+    });
+    if (!existing)
+      throw new NotFoundException(
+        `Course #${courseId} is not linked to enterprise #${enterpriseId}`,
+      );
+    return this.prisma.enterprise_course.delete({
+      where: { id: existing.id },
+    });
+  }
+
+  // ─── Class Groups ─────────────────────────────────────────────────────────────
+
+  async listClassGroups(enterpriseId: number, params: PaginationParams) {
+    await this.assertEnterpriseExists(enterpriseId);
+    const { page, pageSize, skip } = paginate(params);
+
+    const where: any = { enterprise_id: enterpriseId };
+    {
+      const s = params.search?.trim();
+      const hasSearch = Boolean(s);
+      const hasStatus = Boolean(params.status);
+      if (hasSearch || hasStatus) {
+        where.course_class_group = {
+          ...(hasSearch
+            ? { OR: [{ code: { contains: s, mode: 'insensitive' } }, { title: { contains: s, mode: 'insensitive' } }] }
+            : {}),
+          ...(hasStatus ? { status: params.status } : {}),
+        };
+      }
+    }
+
+    const [rows, total] = await Promise.all([
+      this.prisma.enterprise_class_group.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { created_at: 'desc' },
+        include: {
+          course_class_group: {
+            select: {
+              id: true,
+              code: true,
+              title: true,
+              status: true,
+              delivery_mode: true,
+              start_date: true,
+              end_date: true,
+              capacity: true,
+              course: { select: { id: true, title: true, slug: true } },
+            },
+          },
+        },
+      }),
+      this.prisma.enterprise_class_group.count({ where }),
+    ]);
+
+    return {
+      total,
+      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,
+      })),
+    };
+  }
+
+  async addClassGroup(enterpriseId: number, dto: AddEnterpriseClassGroupDto) {
+    await this.assertEnterpriseExists(enterpriseId);
+
+    const classGroup = await this.prisma.course_class_group.findUnique({
+      where: { id: dto.course_class_group_id },
+      select: { id: true },
+    });
+    if (!classGroup)
+      throw new NotFoundException(
+        `Class group #${dto.course_class_group_id} not found`,
+      );
+
+    const duplicate = await this.prisma.enterprise_class_group.findFirst({
+      where: { enterprise_id: enterpriseId, course_class_group_id: dto.course_class_group_id },
+      select: { id: true },
+    });
+    if (duplicate)
+      throw new ConflictException(
+        `Class group #${dto.course_class_group_id} is already linked to this enterprise`,
+      );
+
+    return this.prisma.enterprise_class_group.create({
+      data: { enterprise_id: enterpriseId, ...(dto as any) },
+    });
+  }
+
+  async removeClassGroup(enterpriseId: number, classGroupId: number) {
+    await this.assertEnterpriseExists(enterpriseId);
+    const existing = await this.prisma.enterprise_class_group.findFirst({
+      where: { enterprise_id: enterpriseId, course_class_group_id: classGroupId },
+      select: { id: true },
+    });
+    if (!existing)
+      throw new NotFoundException(
+        `Class group #${classGroupId} is not linked to enterprise #${enterpriseId}`,
+      );
+    return this.prisma.enterprise_class_group.delete({
+      where: { id: existing.id },
+    });
+  }
+
+  // ─── Students ─────────────────────────────────────────────────────────────────
+
+  async listStudents(enterpriseId: number, params: PaginationParams) {
+    await this.assertEnterpriseExists(enterpriseId);
+    const { page, pageSize, skip } = paginate(params);
+
+    const where: any = { enterprise_id: enterpriseId };
+    if (params.search?.trim()) {
+      const s = params.search.trim();
+      where.person = {
+        name: { contains: s, mode: 'insensitive' },
+      };
+    }
+    if (params.status) where.status = params.status;
+
+    const [rows, total] = await Promise.all([
+      this.prisma.enterprise_student.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { created_at: 'desc' },
+        include: {
+          person: {
+            select: {
+              id: true,
+              name: true,
+              contact: {
+                where: { contact_type: { code: 'EMAIL' }, is_primary: true },
+                select: { value: true },
+                take: 1,
+              },
+            },
+          },
+        },
+      }),
+      this.prisma.enterprise_student.count({ where }),
+    ]);
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: rows.map((r) => ({
+        id: r.id,
+        personId: r.person_id,
+        name: r.person?.name ?? null,
+        email: r.person?.contact?.[0]?.value ?? null,
+        status: r.status,
+        createdAt: r.created_at,
+      })),
+    };
+  }
+
+  async addStudent(enterpriseId: number, dto: AddEnterpriseStudentDto) {
+    await this.assertEnterpriseExists(enterpriseId);
+
+    const person = await this.prisma.person.findUnique({
+      where: { id: dto.person_id },
+      select: { id: true },
+    });
+    if (!person) throw new NotFoundException(`Person #${dto.person_id} not found`);
+
+    const duplicate = await this.prisma.enterprise_student.findFirst({
+      where: { enterprise_id: enterpriseId, person_id: dto.person_id },
+      select: { id: true },
+    });
+    if (duplicate)
+      throw new ConflictException(
+        `Person #${dto.person_id} is already a student of enterprise #${enterpriseId}`,
+      );
+
+    return this.prisma.enterprise_student.create({
+      data: { enterprise_id: enterpriseId, ...(dto as any) },
+    });
+  }
+
+  async updateStudent(
+    enterpriseId: number,
+    personId: number,
+    dto: UpdateEnterpriseStudentDto,
+  ) {
+    await this.assertEnterpriseExists(enterpriseId);
+    const existing = await this.prisma.enterprise_student.findFirst({
+      where: { enterprise_id: enterpriseId, person_id: personId },
+      select: { id: true },
+    });
+    if (!existing)
+      throw new NotFoundException(
+        `Person #${personId} is not a student of enterprise #${enterpriseId}`,
+      );
+    return this.prisma.enterprise_student.update({
+      where: { id: existing.id },
+      data: dto as any,
+    });
+  }
+
+  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 },
+    });
+    if (!existing)
+      throw new NotFoundException(
+        `Person #${personId} is not a student of enterprise #${enterpriseId}`,
+      );
+    return this.prisma.enterprise_student.delete({
+      where: { id: existing.id },
+    });
+  }
+
+  // ─── Stats / options ──────────────────────────────────────────────────────────
+
+  async getStats() {
+    const [total, active, trial, portalEnabled] = await Promise.all([
+      this.prisma.enterprise.count(),
+      this.prisma.enterprise.count({ where: { status: 'active' } }),
+      this.prisma.enterprise.count({ where: { status: 'trial' } }),
+      this.prisma.enterprise.count({ where: { portal_enabled: true } }),
+    ]);
+    return { total, active, trial, portalEnabled };
+  }
+
+  async getCrmOptions() {
+    const rows = await this.prisma.enterprise.findMany({
+      where: { crm_person_id: { not: null } },
+      select: { person: { select: { id: true, name: true } } },
+      distinct: ['crm_person_id'],
+    });
+    return rows
+      .filter((r) => r.person !== null)
+      .map((r) => ({ id: r.person!.id, name: r.person!.name ?? '' }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  // ─── Mapper ──────────────────────────────────────────────────────────────────
+
+  private mapEnterprise(
+    e: any,
+    extra?: {
+      studentsCount?: number;
+      managersCount?: number;
+      adminsCount?: number;
+      personCompany?: { trade_name?: string | null; industry?: string | null; website?: string | null; account_lifecycle_stage?: string | null } | null;
+    },
+  ) {
+    const { _count, person } = e;
+    const pc = extra?.personCompany ?? null;
+    return {
+      id: e.id as number,
+      name: e.name as string,
+      slug: e.slug as string,
+      status: e.status as string,
+      portalEnabled: e.portal_enabled as boolean,
+      licenseLimit: (e.license_limit as number | null) ?? null,
+      notes: (e.notes as string | null) ?? null,
+      createdAt: e.created_at as Date,
+      updatedAt: e.updated_at as Date,
+      crmAccountId: (person?.id as number | null) ?? null,
+      crmAccountName: (person?.name as string | null) ?? null,
+      crmAccount: person
+        ? {
+            id: person.id as number,
+            name: person.name as string,
+            tradeName: (pc?.trade_name as string | null) ?? null,
+            industry: (pc?.industry as string | null) ?? null,
+            website: (pc?.website as string | null) ?? null,
+            lifecycleStage: (pc?.account_lifecycle_stage as string | null) ?? null,
+          }
+        : null,
+      usersCount: (_count?.enterprise_user as number) ?? 0,
+      studentsCount: extra?.studentsCount ?? 0,
+      managersCount: extra?.managersCount ?? 0,
+      adminsCount: extra?.adminsCount ?? 0,
+      coursesCount: (_count?.enterprise_course as number) ?? 0,
+      classesCount: (_count?.enterprise_class_group as number) ?? 0,
+    };
+  }
+}