elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/patients/patients.service.ts

@@ -0,0 +1,412 @@
+import {
+  Injectable,
+  NotFoundException,
+  ConflictException,
+  Logger,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from '../database/prisma.service';
+import { EncryptionService } from '../integrations/encryption/encryption.service';
+import { CreatePatientDto, UpdatePatientDto } from './dto';
+
+@Injectable()
+export class PatientsService {
+  private readonly logger = new Logger(PatientsService.name);
+  private readonly piiKey: string;
+  private readonly summaryKey: string;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly encryption: EncryptionService,
+    private readonly config: ConfigService,
+  ) {
+    this.piiKey = this.config.getOrThrow<string>('PATIENT_PII_ENCRYPTION_KEY');
+    this.summaryKey = this.config.getOrThrow<string>('PATIENT_SUMMARY_ENCRYPTION_KEY');
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST (paginated with search)                                       */
+  /* ------------------------------------------------------------------ */
+
+  async findAll(
+    tenantId: string,
+    clinicIds?: string[],
+    query?: string,
+    page = 1,
+    limit = 25,
+  ) {
+    const where: any = {
+      patient_tenant_id: tenantId,
+      patient_is_active: true,
+    };
+
+    if (clinicIds && clinicIds.length > 0) {
+      where.patient_clinic_id = { in: clinicIds };
+    }
+
+    if (query && query.trim()) {
+      const q = query.trim();
+      where.OR = [
+        { patient_first_name: { contains: q, mode: 'insensitive' } },
+        { patient_last_name: { contains: q, mode: 'insensitive' } },
+        { patient_display_name: { contains: q, mode: 'insensitive' } },
+        { patient_phone: { contains: q } },
+      ];
+    }
+
+    const skip = (page - 1) * limit;
+
+    const [patients, total] = await Promise.all([
+      this.prisma.patient.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy: { patient_last_contact_at: 'desc' },
+        include: {
+          clinic: true,
+          _count: {
+            select: {
+              appointments: true,
+              whatsapp_chats: true,
+            },
+          },
+        },
+      }),
+      this.prisma.patient.count({ where }),
+    ]);
+
+    return {
+      data: patients.map((p) => this.formatPatient(p)),
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND BY ID                                                         */
+  /* ------------------------------------------------------------------ */
+
+  async findById(patientId: string, tenantId: string) {
+    const patient = await this.prisma.patient.findFirst({
+      where: {
+        patient_id: patientId,
+        patient_tenant_id: tenantId,
+      },
+      include: {
+        clinic: true,
+        medical_history: true,
+        _count: {
+          select: {
+            appointments: true,
+            whatsapp_chats: true,
+            documents: true,
+            notes: true,
+          },
+        },
+      },
+    });
+
+    if (!patient) {
+      throw new NotFoundException('Patient not found');
+    }
+
+    return this.formatPatientDetail(patient);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  GET DEFAULT CLINIC                                                 */
+  /* ------------------------------------------------------------------ */
+
+  async getDefaultClinic(tenantId: string) {
+    const clinic = await this.prisma.clinic.findFirst({
+      where: { clinic_tenant_id: tenantId, clinic_is_default: true },
+      select: { clinic_id: true, clinic_name: true },
+    });
+    return clinic ? { id: clinic.clinic_id, name: clinic.clinic_name } : null;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FIND OR CREATE (AI first-contact)                                  */
+  /* ------------------------------------------------------------------ */
+
+  async findOrCreate(
+    tenantId: string,
+    phone: string,
+    data?: Partial<CreatePatientDto>,
+  ) {
+    const existing = await this.prisma.patient.findUnique({
+      where: {
+        patient_tenant_id_patient_phone: {
+          patient_tenant_id: tenantId,
+          patient_phone: phone,
+        },
+      },
+    });
+
+    if (existing) {
+      // Update last contact time
+      await this.prisma.patient.update({
+        where: { patient_id: existing.patient_id },
+        data: { patient_last_contact_at: new Date() },
+      });
+      return existing;
+    }
+
+    return this.create(tenantId, { phone, ...data });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CREATE                                                              */
+  /* ------------------------------------------------------------------ */
+
+  async create(tenantId: string, dto: CreatePatientDto) {
+    // Check unique constraint
+    const existing = await this.prisma.patient.findUnique({
+      where: {
+        patient_tenant_id_patient_phone: {
+          patient_tenant_id: tenantId,
+          patient_phone: dto.phone,
+        },
+      },
+    });
+
+    if (existing) {
+      throw new ConflictException('Patient with this phone already exists');
+    }
+
+    const firstName = dto.firstName ?? '';
+    const lastName = dto.lastName ?? '';
+    const displayName = [firstName, lastName].filter(Boolean).join(' ') || dto.phone;
+
+    // Auto-assign default clinic if none provided
+    let clinicId = dto.clinicId;
+    if (!clinicId) {
+      const defaultClinic = await this.getDefaultClinic(tenantId);
+      clinicId = defaultClinic?.id ?? undefined;
+    }
+
+    const patient = await this.prisma.$transaction(async (tx) => {
+      const created = await tx.patient.create({
+        data: {
+          patient_tenant_id: tenantId,
+          patient_phone: dto.phone,
+          patient_first_name: firstName,
+          patient_last_name: lastName,
+          patient_display_name: displayName,
+          ...(dto.email !== undefined && { patient_email: dto.email }),
+          ...(dto.dateOfBirth !== undefined && {
+            patient_date_of_birth: new Date(dto.dateOfBirth),
+          }),
+          ...(dto.gender !== undefined && { patient_gender: dto.gender }),
+          ...(dto.idNumber !== undefined && {
+            patient_id_number: this.encryption.encrypt(dto.idNumber, this.piiKey),
+          }),
+          ...(dto.bloodType !== undefined && { patient_blood_type: dto.bloodType }),
+          ...(dto.preferredLanguage !== undefined && {
+            patient_preferred_language: dto.preferredLanguage,
+          }),
+          ...(dto.source !== undefined && { patient_source: dto.source }),
+          ...(dto.sourceDetail !== undefined && { patient_source_detail: dto.sourceDetail }),
+          ...(dto.tags !== undefined && { patient_tags: dto.tags }),
+          ...(clinicId !== undefined && { patient_clinic_id: clinicId }),
+        },
+      });
+
+      // Create empty medical history
+      await tx.patientMedicalHistory.create({
+        data: {
+          history_patient_id: created.patient_id,
+        },
+      });
+
+      return created;
+    });
+
+    this.logger.log(`Patient created: ${patient.patient_id} (tenant=${tenantId})`);
+
+    return patient;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE                                                              */
+  /* ------------------------------------------------------------------ */
+
+  async update(patientId: string, tenantId: string, dto: UpdatePatientDto) {
+    const patient = await this.prisma.patient.findFirst({
+      where: { patient_id: patientId, patient_tenant_id: tenantId },
+    });
+
+    if (!patient) {
+      throw new NotFoundException('Patient not found');
+    }
+
+    const data: any = {};
+
+    if (dto.phone !== undefined) data.patient_phone = dto.phone;
+    if (dto.firstName !== undefined) data.patient_first_name = dto.firstName;
+    if (dto.lastName !== undefined) data.patient_last_name = dto.lastName;
+    if (dto.email !== undefined) data.patient_email = dto.email;
+    if (dto.dateOfBirth !== undefined) {
+      data.patient_date_of_birth = new Date(dto.dateOfBirth);
+    }
+    if (dto.gender !== undefined) data.patient_gender = dto.gender;
+    if (dto.idNumber !== undefined) {
+      data.patient_id_number = dto.idNumber
+        ? this.encryption.encrypt(dto.idNumber, this.piiKey)
+        : null;
+    }
+    if (dto.bloodType !== undefined) data.patient_blood_type = dto.bloodType;
+    if (dto.preferredLanguage !== undefined) {
+      data.patient_preferred_language = dto.preferredLanguage;
+    }
+    if (dto.source !== undefined) data.patient_source = dto.source;
+    if (dto.sourceDetail !== undefined) data.patient_source_detail = dto.sourceDetail;
+    if (dto.tags !== undefined) data.patient_tags = dto.tags;
+    if (dto.clinicId !== undefined) data.patient_clinic_id = dto.clinicId;
+
+    // Recompute display name if name fields changed
+    if (dto.firstName !== undefined || dto.lastName !== undefined) {
+      const fn = dto.firstName ?? patient.patient_first_name;
+      const ln = dto.lastName ?? patient.patient_last_name;
+      data.patient_display_name =
+        [fn, ln].filter(Boolean).join(' ') || patient.patient_phone;
+    }
+
+    return this.prisma.patient.update({
+      where: { patient_id: patientId },
+      data,
+      include: {
+        clinic: true,
+        _count: {
+          select: {
+            appointments: true,
+            whatsapp_chats: true,
+          },
+        },
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  REMOVE (soft delete)                                                */
+  /* ------------------------------------------------------------------ */
+
+  async remove(patientId: string, tenantId: string) {
+    const patient = await this.prisma.patient.findFirst({
+      where: { patient_id: patientId, patient_tenant_id: tenantId },
+    });
+
+    if (!patient) {
+      throw new NotFoundException('Patient not found');
+    }
+
+    await this.prisma.patient.update({
+      where: { patient_id: patientId },
+      data: { patient_is_active: false },
+    });
+
+    return { message: 'Patient deactivated' };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  SEARCH (autocomplete)                                               */
+  /* ------------------------------------------------------------------ */
+
+  async search(tenantId: string, query: string) {
+    if (!query || !query.trim()) return [];
+
+    const q = query.trim();
+
+    return this.prisma.patient.findMany({
+      where: {
+        patient_tenant_id: tenantId,
+        patient_is_active: true,
+        OR: [
+          { patient_first_name: { contains: q, mode: 'insensitive' } },
+          { patient_last_name: { contains: q, mode: 'insensitive' } },
+          { patient_display_name: { contains: q, mode: 'insensitive' } },
+          { patient_phone: { contains: q } },
+        ],
+      },
+      take: 20,
+      orderBy: { patient_last_contact_at: 'desc' },
+      select: {
+        patient_id: true,
+        patient_phone: true,
+        patient_first_name: true,
+        patient_last_name: true,
+        patient_display_name: true,
+        patient_clinic_id: true,
+      },
+    });
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  PRIVATE HELPERS                                                     */
+  /* ------------------------------------------------------------------ */
+
+  private formatPatient(patient: any) {
+    return {
+      id: patient.patient_id,
+      phone: patient.patient_phone,
+      firstName: patient.patient_first_name,
+      lastName: patient.patient_last_name,
+      displayName: patient.patient_display_name,
+      email: patient.patient_email,
+      gender: patient.patient_gender,
+      bloodType: patient.patient_blood_type,
+      preferredLanguage: patient.patient_preferred_language,
+      source: patient.patient_source,
+      tags: patient.patient_tags,
+      isActive: patient.patient_is_active,
+      firstContactAt: patient.patient_first_contact_at,
+      lastContactAt: patient.patient_last_contact_at,
+      totalSessions: patient.patient_total_sessions,
+      totalAppointments: patient.patient_total_appointments,
+      createdAt: patient.patient_created_at,
+      clinic: patient.clinic
+        ? {
+            id: patient.clinic.clinic_id,
+            name: patient.clinic.clinic_name,
+          }
+        : null,
+      _count: patient._count,
+    };
+  }
+
+  private formatPatientDetail(patient: any) {
+    const base = this.formatPatient(patient);
+
+    // Decrypt sensitive fields
+    let idNumber: string | null = null;
+    if (patient.patient_id_number) {
+      try {
+        idNumber = this.encryption.decrypt(patient.patient_id_number, this.piiKey);
+      } catch {
+        idNumber = null;
+      }
+    }
+
+    let aiSummary = '';
+    if (patient.patient_ai_summary) {
+      try {
+        aiSummary = this.encryption.decrypt(patient.patient_ai_summary, this.summaryKey);
+      } catch {
+        aiSummary = '';
+      }
+    }
+
+    return {
+      ...base,
+      dateOfBirth: patient.patient_date_of_birth,
+      idNumber,
+      aiSummary,
+      sourceDetail: patient.patient_source_detail,
+      medicalHistory: patient.medical_history ?? null,
+    };
+  }
+}