elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/treatments/dto/update-treatment.dto.ts

@@ -0,0 +1,70 @@
+import {
+  IsString,
+  IsOptional,
+  IsInt,
+  IsNumber,
+  IsBoolean,
+  MaxLength,
+  Min,
+} from 'class-validator';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+
+export class UpdateTreatmentDto {
+  @ApiPropertyOptional({ example: 'Diş Beyazlatma' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  name?: string;
+
+  @ApiPropertyOptional({ example: 'Estetik' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  category?: string;
+
+  @ApiPropertyOptional({ example: 'Profesyonel diş beyazlatma işlemi' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(2000)
+  description?: string;
+
+  @ApiPropertyOptional({ example: 30 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  durationMinutes?: number;
+
+  @ApiPropertyOptional({ example: 1500.0 })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  price?: number | null;
+
+  @ApiPropertyOptional({ example: 'TRY' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(10)
+  currency?: string;
+
+  @ApiPropertyOptional({ example: 180 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  recallDays?: number | null;
+
+  @ApiPropertyOptional({ example: 'uuid' })
+  @IsOptional()
+  @IsString()
+  clinicId?: string | null;
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+
+  @ApiPropertyOptional({ example: 0 })
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  sortOrder?: number;
+}

package/nestjs/src/treatments/treatment-plans.service.ts

@@ -0,0 +1,362 @@
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PrismaService } from '../database/prisma.service';
+import { EncryptionService } from '../integrations/encryption/encryption.service';
+import {
+  CreateTreatmentPlanDto,
+  UpdateTreatmentPlanDto,
+  CreatePlanItemDto,
+  UpdatePlanItemDto,
+} from './dto';
+
+@Injectable()
+export class TreatmentPlansService {
+  private readonly encryptionKey: string;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly encryption: EncryptionService,
+    private readonly config: ConfigService,
+  ) {
+    this.encryptionKey = this.config.get<string>('PATIENT_PII_ENCRYPTION_KEY', '');
+  }
+
+  /* ================================================================== */
+  /*  PLAN CRUD                                                          */
+  /* ================================================================== */
+
+  /* ------------------------------------------------------------------ */
+  /*  LIST BY PATIENT                                                    */
+  /* ------------------------------------------------------------------ */
+
+  async findByPatient(patientId: string, tenantId: string) {
+    const plans = await this.prisma.treatmentPlan.findMany({
+      where: {
+        tplan_patient_id: patientId,
+        tplan_tenant_id: tenantId,
+      },
+      include: {
+        items: {
+          orderBy: { tpitem_sort_order: 'asc' },
+        },
+        doctor: {
+          select: { user_id: true, user_first_name: true, user_last_name: true },
+        },
+      },
+      orderBy: { tplan_created_at: 'desc' },
+    });
+
+    return plans.map((plan) => this.decryptPlan(plan));
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  SINGLE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async findById(planId: string, tenantId: string) {
+    const plan = await this.prisma.treatmentPlan.findFirst({
+      where: {
+        tplan_id: planId,
+        tplan_tenant_id: tenantId,
+      },
+      include: {
+        items: {
+          orderBy: { tpitem_sort_order: 'asc' },
+        },
+        doctor: {
+          select: { user_id: true, user_first_name: true, user_last_name: true },
+        },
+        patient: {
+          select: { patient_id: true, patient_first_name: true, patient_last_name: true },
+        },
+      },
+    });
+
+    if (!plan) {
+      throw new NotFoundException('Treatment plan not found');
+    }
+
+    return this.decryptPlan(plan);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  CREATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async create(tenantId: string, dto: CreateTreatmentPlanDto) {
+    const encryptedNotes = dto.notes
+      ? this.encryptField(dto.notes)
+      : '';
+
+    const plan = await this.prisma.treatmentPlan.create({
+      data: {
+        tplan_tenant_id: tenantId,
+        tplan_patient_id: dto.patientId,
+        tplan_clinic_id: dto.clinicId,
+        tplan_name: dto.name,
+        ...(dto.doctorId && { tplan_doctor_id: dto.doctorId }),
+        tplan_notes: encryptedNotes,
+      },
+    });
+
+    if (dto.items && dto.items.length > 0) {
+      await this.prisma.treatmentPlanItem.createMany({
+        data: dto.items.map((item, index) => ({
+          tpitem_plan_id: plan.tplan_id,
+          tpitem_name: item.name,
+          ...(item.treatmentId && { tpitem_treatment_id: item.treatmentId }),
+          ...(item.toothNumber && { tpitem_tooth_number: item.toothNumber }),
+          tpitem_notes: item.notes ? this.encryptField(item.notes) : '',
+          tpitem_sort_order: index,
+        })),
+      });
+    }
+
+    return this.findById(plan.tplan_id, tenantId);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async update(planId: string, tenantId: string, dto: UpdateTreatmentPlanDto) {
+    await this.findById(planId, tenantId);
+
+    const data: Record<string, any> = {};
+
+    if (dto.name !== undefined) data.tplan_name = dto.name;
+    if (dto.notes !== undefined) {
+      data.tplan_notes = dto.notes ? this.encryptField(dto.notes) : '';
+    }
+    if (dto.status !== undefined) data.tplan_status = dto.status;
+
+    if (Object.keys(data).length === 0) {
+      throw new BadRequestException('No fields to update');
+    }
+
+    await this.prisma.treatmentPlan.update({
+      where: { tplan_id: planId },
+      data,
+    });
+
+    // Auto-complete check (if not explicitly setting status)
+    if (dto.status === undefined) {
+      await this.checkAutoComplete(planId);
+    }
+
+    return this.findById(planId, tenantId);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  REMOVE                                                             */
+  /* ------------------------------------------------------------------ */
+
+  async remove(planId: string, tenantId: string) {
+    const plan = await this.prisma.treatmentPlan.findFirst({
+      where: { tplan_id: planId, tplan_tenant_id: tenantId },
+      include: { items: true },
+    });
+
+    if (!plan) {
+      throw new NotFoundException('Treatment plan not found');
+    }
+
+    const hasCompleted = plan.items.some(
+      (item) => item.tpitem_status === 'completed',
+    );
+
+    if (hasCompleted) {
+      throw new BadRequestException(
+        'Cannot delete a plan that has completed items',
+      );
+    }
+
+    await this.prisma.treatmentPlan.delete({
+      where: { tplan_id: planId },
+    });
+
+    return { deleted: true };
+  }
+
+  /* ================================================================== */
+  /*  PLAN ITEM OPERATIONS                                               */
+  /* ================================================================== */
+
+  /* ------------------------------------------------------------------ */
+  /*  ADD ITEM                                                           */
+  /* ------------------------------------------------------------------ */
+
+  async addItem(planId: string, tenantId: string, dto: CreatePlanItemDto) {
+    const plan = await this.prisma.treatmentPlan.findFirst({
+      where: { tplan_id: planId, tplan_tenant_id: tenantId },
+      include: { items: true },
+    });
+
+    if (!plan) {
+      throw new NotFoundException('Treatment plan not found');
+    }
+
+    const maxSort = plan.items.reduce(
+      (max, item) => Math.max(max, item.tpitem_sort_order),
+      -1,
+    );
+
+    const item = await this.prisma.treatmentPlanItem.create({
+      data: {
+        tpitem_plan_id: planId,
+        tpitem_name: dto.name,
+        ...(dto.treatmentId && { tpitem_treatment_id: dto.treatmentId }),
+        ...(dto.toothNumber && { tpitem_tooth_number: dto.toothNumber }),
+        tpitem_notes: dto.notes ? this.encryptField(dto.notes) : '',
+        tpitem_sort_order: maxSort + 1,
+      },
+    });
+
+    return this.decryptItem(item);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  UPDATE ITEM                                                        */
+  /* ------------------------------------------------------------------ */
+
+  async updateItem(itemId: string, tenantId: string, dto: UpdatePlanItemDto) {
+    const item = await this.prisma.treatmentPlanItem.findFirst({
+      where: { tpitem_id: itemId },
+      include: {
+        plan: { select: { tplan_id: true, tplan_tenant_id: true } },
+      },
+    });
+
+    if (!item || item.plan.tplan_tenant_id !== tenantId) {
+      throw new NotFoundException('Treatment plan item not found');
+    }
+
+    const data: Record<string, any> = {};
+
+    if (dto.status !== undefined) {
+      data.tpitem_status = dto.status;
+      if (dto.status === 'completed') {
+        data.tpitem_completed_at = new Date();
+      }
+      // Clear completed_at if reverting from completed
+      if (dto.status !== 'completed' && item.tpitem_completed_at) {
+        data.tpitem_completed_at = null;
+      }
+    }
+
+    if (dto.notes !== undefined) {
+      data.tpitem_notes = dto.notes ? this.encryptField(dto.notes) : '';
+    }
+
+    if (dto.appointmentId !== undefined) {
+      data.tpitem_appointment_id = dto.appointmentId;
+    }
+
+    if (Object.keys(data).length === 0) {
+      throw new BadRequestException('No fields to update');
+    }
+
+    const updated = await this.prisma.treatmentPlanItem.update({
+      where: { tpitem_id: itemId },
+      data,
+    });
+
+    // Check auto-complete on the parent plan
+    await this.checkAutoComplete(item.plan.tplan_id);
+
+    return this.decryptItem(updated);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  REMOVE ITEM                                                        */
+  /* ------------------------------------------------------------------ */
+
+  async removeItem(itemId: string, tenantId: string) {
+    const item = await this.prisma.treatmentPlanItem.findFirst({
+      where: { tpitem_id: itemId },
+      include: {
+        plan: { select: { tplan_id: true, tplan_tenant_id: true } },
+      },
+    });
+
+    if (!item || item.plan.tplan_tenant_id !== tenantId) {
+      throw new NotFoundException('Treatment plan item not found');
+    }
+
+    if (item.tpitem_status === 'completed') {
+      throw new BadRequestException('Cannot remove a completed item');
+    }
+
+    await this.prisma.treatmentPlanItem.delete({
+      where: { tpitem_id: itemId },
+    });
+
+    return { deleted: true };
+  }
+
+  /* ================================================================== */
+  /*  HELPERS                                                            */
+  /* ================================================================== */
+
+  private async checkAutoComplete(planId: string) {
+    const plan = await this.prisma.treatmentPlan.findUnique({
+      where: { tplan_id: planId },
+      include: { items: true },
+    });
+
+    if (!plan || plan.items.length === 0) return;
+    if (plan.tplan_status !== 'active') return;
+
+    const allCompleted = plan.items.every(
+      (item) => item.tpitem_status === 'completed',
+    );
+
+    if (allCompleted) {
+      await this.prisma.treatmentPlan.update({
+        where: { tplan_id: planId },
+        data: { tplan_status: 'completed' },
+      });
+    }
+  }
+
+  private encryptField(value: string): string {
+    if (!this.encryptionKey) return value;
+    return this.encryption.encrypt(value, this.encryptionKey);
+  }
+
+  private decryptField(value: string): string {
+    if (!this.encryptionKey || !value) return value;
+    try {
+      return this.encryption.decrypt(value, this.encryptionKey);
+    } catch {
+      // Return as-is if decryption fails (e.g. unencrypted legacy data)
+      return value;
+    }
+  }
+
+  private decryptPlan<T extends { tplan_notes: string; items?: any[] }>(
+    plan: T,
+  ): T {
+    const result = {
+      ...plan,
+      tplan_notes: this.decryptField(plan.tplan_notes),
+    };
+
+    if (result.items) {
+      result.items = result.items.map((item: any) => this.decryptItem(item));
+    }
+
+    return result;
+  }
+
+  private decryptItem<T extends { tpitem_notes: string }>(item: T): T {
+    return {
+      ...item,
+      tpitem_notes: this.decryptField(item.tpitem_notes),
+    };
+  }
+}

package/nestjs/src/treatments/treatments.controller.ts

@@ -0,0 +1,265 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Param,
+  Query,
+  Body,
+  UseGuards,
+  BadRequestException,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { TreatmentsService } from './treatments.service';
+import { TreatmentPlansService } from './treatment-plans.service';
+import {
+  CreateTreatmentDto,
+  UpdateTreatmentDto,
+  CreateTreatmentPlanDto,
+  UpdateTreatmentPlanDto,
+  CreatePlanItemDto,
+  UpdatePlanItemDto,
+} from './dto';
+import {
+  JwtAuthGuard,
+  PermissionsGuard,
+  ClinicAccessGuard,
+} from '../common/guards';
+import { CurrentUser, Permissions } from '../common/decorators';
+import type { JwtPayload } from '../common/interfaces/jwt-payload.interface';
+
+/* ====================================================================== */
+/*  TREATMENT CATALOG CONTROLLER                                          */
+/* ====================================================================== */
+
+@ApiTags('Treatments')
+@Controller('treatments')
+@UseGuards(JwtAuthGuard, PermissionsGuard, ClinicAccessGuard)
+@ApiBearerAuth()
+export class TreatmentsCatalogController {
+  constructor(private readonly treatmentsService: TreatmentsService) {}
+
+  @Get()
+  @Permissions('treatments:read')
+  @ApiOperation({ summary: 'List treatments (optionally filtered by clinic)' })
+  async findAll(
+    @CurrentUser() user: JwtPayload,
+    @Query('clinicId') clinicId?: string,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.treatmentsService.findAll(user.tenantId, clinicId);
+  }
+
+  @Get('categories')
+  @Permissions('treatments:read')
+  @ApiOperation({ summary: 'Get distinct treatment categories' })
+  async getCategories(@CurrentUser() user: JwtPayload) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.treatmentsService.getCategories(user.tenantId);
+  }
+
+  @Post()
+  @Permissions('treatments:manage')
+  @ApiOperation({ summary: 'Create a treatment' })
+  async create(
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: CreateTreatmentDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.treatmentsService.create(user.tenantId, dto);
+  }
+
+  @Get(':id')
+  @Permissions('treatments:read')
+  @ApiOperation({ summary: 'Get a single treatment by ID' })
+  async findById(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.treatmentsService.findById(id, user.tenantId);
+  }
+
+  @Put(':id')
+  @Permissions('treatments:manage')
+  @ApiOperation({ summary: 'Update a treatment' })
+  async update(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: UpdateTreatmentDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.treatmentsService.update(id, user.tenantId, dto);
+  }
+
+  @Delete(':id')
+  @Permissions('treatments:manage')
+  @ApiOperation({ summary: 'Soft-delete a treatment (set inactive)' })
+  async remove(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.treatmentsService.remove(id, user.tenantId);
+  }
+}
+
+/* ====================================================================== */
+/*  TREATMENT PLANS CONTROLLER                                            */
+/* ====================================================================== */
+
+@ApiTags('Treatment Plans')
+@UseGuards(JwtAuthGuard, PermissionsGuard, ClinicAccessGuard)
+@ApiBearerAuth()
+@Controller('treatment-plans')
+export class TreatmentPlansController {
+  constructor(private readonly plansService: TreatmentPlansService) {}
+
+  /* ------------------------------------------------------------------ */
+  /*  PLANS (nested under patients)                                      */
+  /* ------------------------------------------------------------------ */
+
+  @Get('patient/:patientId')
+  @Permissions('patients:read')
+  @ApiOperation({ summary: 'List treatment plans for a patient' })
+  async findByPatient(
+    @Param('patientId') patientId: string,
+    @CurrentUser() user: JwtPayload,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.plansService.findByPatient(patientId, user.tenantId);
+  }
+
+  @Post('patient/:patientId')
+  @Permissions('treatment_plans:manage')
+  @ApiOperation({ summary: 'Create a treatment plan for a patient' })
+  async create(
+    @Param('patientId') patientId: string,
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: CreateTreatmentPlanDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    // Ensure the patientId from URL matches the DTO
+    dto.patientId = patientId;
+
+    return this.plansService.create(user.tenantId, dto);
+  }
+
+  @Get(':id')
+  @Permissions('patients:read')
+  @ApiOperation({ summary: 'Get a single treatment plan' })
+  async findById(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.plansService.findById(id, user.tenantId);
+  }
+
+  @Put(':id')
+  @Permissions('treatment_plans:manage')
+  @ApiOperation({ summary: 'Update a treatment plan' })
+  async update(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: UpdateTreatmentPlanDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.plansService.update(id, user.tenantId, dto);
+  }
+
+  @Delete(':id')
+  @Permissions('treatment_plans:manage')
+  @ApiOperation({ summary: 'Delete a treatment plan (only if no completed items)' })
+  async remove(
+    @Param('id') id: string,
+    @CurrentUser() user: JwtPayload,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.plansService.remove(id, user.tenantId);
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  PLAN ITEMS                                                         */
+  /* ------------------------------------------------------------------ */
+
+  @Post(':id/items')
+  @Permissions('treatment_plans:manage')
+  @ApiOperation({ summary: 'Add an item to a treatment plan' })
+  async addItem(
+    @Param('id') planId: string,
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: CreatePlanItemDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.plansService.addItem(planId, user.tenantId, dto);
+  }
+
+  @Put(':id/items/:itemId')
+  @Permissions('treatment_plans:manage')
+  @ApiOperation({ summary: 'Update a treatment plan item' })
+  async updateItem(
+    @Param('id') _planId: string,
+    @Param('itemId') itemId: string,
+    @CurrentUser() user: JwtPayload,
+    @Body() dto: UpdatePlanItemDto,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.plansService.updateItem(itemId, user.tenantId, dto);
+  }
+
+  @Delete(':id/items/:itemId')
+  @Permissions('treatment_plans:manage')
+  @ApiOperation({ summary: 'Remove a treatment plan item (only if not completed)' })
+  async removeItem(
+    @Param('id') _planId: string,
+    @Param('itemId') itemId: string,
+    @CurrentUser() user: JwtPayload,
+  ) {
+    if (!user.tenantId) {
+      throw new BadRequestException('No tenant associated with this user');
+    }
+
+    return this.plansService.removeItem(itemId, user.tenantId);
+  }
+}

package/nestjs/src/treatments/treatments.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TreatmentsService } from './treatments.service';
+import { TreatmentPlansService } from './treatment-plans.service';
+import {
+  TreatmentsCatalogController,
+  TreatmentPlansController,
+} from './treatments.controller';
+
+@Module({
+  controllers: [TreatmentsCatalogController, TreatmentPlansController],
+  providers: [TreatmentsService, TreatmentPlansService],
+  exports: [TreatmentsService, TreatmentPlansService],
+})
+export class TreatmentsModule {}