elevenlabs-webhook-nodejs 1.0.0

package/nestjs/src/whatsapp/operator.service.ts

@@ -0,0 +1,692 @@
+import {
+  Injectable,
+  Logger,
+  OnModuleInit,
+  OnModuleDestroy,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { PrismaService } from '../database/prisma.service.js';
+import { EncryptionService } from '../integrations/encryption/encryption.service.js';
+import { MetaWhatsAppService } from '../integrations/meta-business/meta-whatsapp.service.js';
+import { MinioService } from '../integrations/minio/minio.service.js';
+
+/**
+ * Operator-in-the-loop workflow:
+ * Patient sends photo -> forwarded to doctor -> doctor replies with price + REF code -> AI delivers price
+ */
+@Injectable()
+export class OperatorService implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(OperatorService.name);
+  private expiryInterval: ReturnType<typeof setInterval> | null = null;
+
+  private readonly messageEncryptionKey: string;
+  private readonly tokenEncryptionKey: string;
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly encryption: EncryptionService,
+    private readonly eventEmitter: EventEmitter2,
+    private readonly config: ConfigService,
+    private readonly metaWhatsApp: MetaWhatsAppService,
+    private readonly minio: MinioService,
+  ) {
+    this.messageEncryptionKey = this.config.getOrThrow<string>(
+      'MESSAGE_ENCRYPTION_KEY',
+    );
+    this.tokenEncryptionKey = this.config.get<string>(
+      'META_TOKEN_ENCRYPTION_KEY',
+      '',
+    );
+  }
+
+  onModuleInit() {
+    // Sweep expired operator requests every 15 minutes
+    this.expiryInterval = setInterval(
+      () => void this.expirePendingRequests(),
+      15 * 60 * 1000,
+    );
+  }
+
+  onModuleDestroy() {
+    if (this.expiryInterval) {
+      clearInterval(this.expiryInterval);
+    }
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  FORWARD TO OPERATOR                                                */
+  /* ------------------------------------------------------------------ */
+
+  async forwardToOperator(
+    sessionId: string,
+    message?: string,
+    mediaIds?: string[],
+  ): Promise<{
+    refCode: string;
+    forwardedCount: number;
+    failedCount: number;
+  }> {
+    // 1. Load session with chat and clinic
+    const session = await this.prisma.whatsappSession.findUnique({
+      where: { session_id: sessionId },
+      include: {
+        chat: {
+          select: {
+            chat_id: true,
+            chat_contact_phone: true,
+            chat_contact_name: true,
+            chat_external_id: true,
+          },
+        },
+        clinic: {
+          select: {
+            clinic_id: true,
+            clinic_operator_phone: true,
+            clinic_operator_prefix: true,
+            clinic_operator_timeout_hours: true,
+            clinic_tenant_id: true,
+          },
+        },
+      },
+    });
+
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    // 2. Verify operator phone is configured
+    if (!session.clinic.clinic_operator_phone) {
+      throw new Error('No operator phone configured for this clinic');
+    }
+
+    // 3. Find ALL media messages from the patient in this session
+    const mediaMessages = await this.prisma.whatsappMessage.findMany({
+      where: {
+        msg_session_id: sessionId,
+        msg_sender: 'contact',
+        msg_media_key: { not: null },
+      },
+      orderBy: { msg_created_at: 'asc' },
+      select: {
+        msg_id: true,
+        msg_media_type: true,
+        msg_media_key: true,
+        msg_text: true,
+      },
+    });
+
+    // 4. Generate unique REF code
+    const refCode = await this.generateRefCode(
+      session.session_tenant_id,
+      session.clinic.clinic_operator_prefix,
+    );
+
+    const expiresAt = new Date(
+      Date.now() +
+        session.clinic.clinic_operator_timeout_hours * 60 * 60 * 1000,
+    );
+
+    // Encrypt the request message if present
+    const encryptedMessage = message
+      ? this.encryption.encrypt(message, this.messageEncryptionKey)
+      : undefined;
+
+    // 5. Create OperatorRequest record
+    const patientMessageIds =
+      mediaIds ?? mediaMessages.map((m) => m.msg_id);
+
+    await this.prisma.operatorRequest.create({
+      data: {
+        opreq_tenant_id: session.session_tenant_id,
+        opreq_clinic_id: session.session_clinic_id,
+        opreq_session_id: sessionId,
+        opreq_chat_id: session.session_chat_id,
+        opreq_ref_code: refCode,
+        opreq_request_type: 'general',
+        opreq_request_message: encryptedMessage,
+        opreq_forwarded_to_phone: session.clinic.clinic_operator_phone,
+        opreq_forwarded_media_types: [],
+        opreq_forwarded_count: 0,
+        opreq_failed_count: 0,
+        opreq_patient_message_ids: patientMessageIds,
+        opreq_expires_at: expiresAt,
+      },
+    });
+
+    // 6. Mark session as awaiting operator
+    await this.prisma.whatsappSession.update({
+      where: { session_id: sessionId },
+      data: {
+        session_awaiting_operator: true,
+        session_ref_code: refCode,
+      },
+    });
+
+    // 7. Get the clinic's active Meta WhatsApp connection
+    const metaConnection = await this.prisma.clinicMetaConnection.findFirst({
+      where: {
+        meta_clinic_id: session.clinic.clinic_id,
+        meta_type: 'whatsapp',
+        meta_is_active: true,
+      },
+    });
+
+    if (
+      !metaConnection?.meta_phone_number_id ||
+      !metaConnection?.meta_encrypted_access_token
+    ) {
+      this.logger.warn(
+        `No active Meta WhatsApp connection for clinic ${session.clinic.clinic_id}. ` +
+          `Operator request ${refCode} created but media not forwarded.`,
+      );
+      return { refCode, forwardedCount: 0, failedCount: mediaMessages.length };
+    }
+
+    // 8. Decrypt the access token
+    let accessToken: string;
+    try {
+      accessToken = this.tokenEncryptionKey
+        ? this.encryption.decrypt(
+            metaConnection.meta_encrypted_access_token,
+            this.tokenEncryptionKey,
+          )
+        : metaConnection.meta_encrypted_access_token;
+    } catch {
+      // Fallback: token might not be encrypted in dev environments
+      accessToken = metaConnection.meta_encrypted_access_token;
+    }
+
+    const operatorPhone = session.clinic.clinic_operator_phone;
+    const phoneNumberId = metaConnection.meta_phone_number_id;
+    const patientName =
+      session.chat.chat_contact_name || session.chat.chat_contact_phone;
+    const patientPhone = session.chat.chat_contact_phone;
+
+    let forwardedCount = 0;
+    let failedCount = 0;
+    const forwardedMediaTypes: string[] = [];
+
+    // 9. If we have media messages, forward each to operator
+    if (mediaMessages.length > 0) {
+      for (let i = 0; i < mediaMessages.length; i++) {
+        const msg = mediaMessages[i];
+        const mediaKey = msg.msg_media_key!;
+        const mediaType = msg.msg_media_type ?? 'image';
+
+        // Build caption: include REF code, patient info on first media, REF only on subsequent
+        const caption =
+          i === 0
+            ? `Ref: ${refCode}\nHasta: ${patientName}\nTel: ${patientPhone}${message ? `\nNot: ${message}` : ''}`
+            : `Ref: ${refCode} (${i + 1}/${mediaMessages.length})`;
+
+        try {
+          // Get a signed URL from MinIO for this media
+          const signedUrl = await this.minio.presignedGetObject(
+            mediaKey,
+            300, // 5 min TTL
+          );
+
+          // Map the stored media type to Meta API send type
+          const sendType = this.mapMediaType(mediaType);
+
+          await this.metaWhatsApp.sendMedia(
+            phoneNumberId,
+            operatorPhone,
+            sendType,
+            signedUrl,
+            caption,
+            accessToken,
+          );
+
+          forwardedCount++;
+          forwardedMediaTypes.push(mediaType);
+        } catch (err: any) {
+          failedCount++;
+          this.logger.error(
+            `Failed to forward media ${mediaKey} for ref ${refCode}: ${err.message}`,
+          );
+          // Continue with next media, don't crash on single failure
+        }
+
+        // 500ms delay between sends to avoid rate limiting
+        if (i < mediaMessages.length - 1) {
+          await this.delay(500);
+        }
+      }
+    } else {
+      // 10. No media (text-only request): send a text message to operator
+      const textMessage = [
+        `--- Operator Talebi ---`,
+        `Ref: ${refCode}`,
+        `Hasta: ${patientName}`,
+        `Tel: ${patientPhone}`,
+        ``,
+        message || '(Hasta mesaj gonderdi, medya yok)',
+        ``,
+        `Lutfen REF kodu ile yanit verin.`,
+      ].join('\n');
+
+      try {
+        await this.metaWhatsApp.sendMessage(
+          phoneNumberId,
+          operatorPhone,
+          textMessage,
+          accessToken,
+        );
+        forwardedCount = 1;
+      } catch (err: any) {
+        failedCount = 1;
+        this.logger.error(
+          `Failed to send text to operator for ref ${refCode}: ${err.message}`,
+        );
+      }
+    }
+
+    // 11. Update OperatorRequest with forwarding results
+    await this.prisma.operatorRequest.update({
+      where: {
+        opreq_tenant_id_opreq_ref_code: {
+          opreq_tenant_id: session.session_tenant_id,
+          opreq_ref_code: refCode,
+        },
+      },
+      data: {
+        opreq_forwarded_count: forwardedCount,
+        opreq_failed_count: failedCount,
+        opreq_forwarded_media_types: forwardedMediaTypes,
+      },
+    });
+
+    this.logger.log(
+      `Created operator request ${refCode} for session ${sessionId} — ` +
+        `forwarded: ${forwardedCount}, failed: ${failedCount}`,
+    );
+
+    // 12. Return result
+    return { refCode, forwardedCount, failedCount };
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  HANDLE OPERATOR REPLY                                              */
+  /* ------------------------------------------------------------------ */
+
+  async handleOperatorReply(payload: {
+    tenantId: string;
+    clinicId: string;
+    senderPhone: string;
+    messageText: string;
+    quotedText?: string;
+    messageId?: string;
+    mediaType?: string;
+  }): Promise<boolean> {
+    const {
+      tenantId,
+      senderPhone,
+      messageText,
+      quotedText,
+      messageId,
+      mediaType,
+    } = payload;
+
+    // 1. Normalize sender phone (strip non-digits, keep raw)
+    const normalizedPhone = senderPhone.replace(/\D/g, '');
+
+    // 2. Extract REF code from message text using regex
+    //    Format: {prefix}-{4 alphanumeric} e.g., R-AB2X
+    const refRegex = /\b([A-Z]+-[A-Z0-9]{4})\b/;
+    let refMatch = messageText.match(refRegex);
+
+    // Also check quotedText if present and no match in message text
+    if (!refMatch && quotedText) {
+      refMatch = quotedText.match(refRegex);
+    }
+
+    // Fallback: also try the legacy format without dash (e.g., K0001)
+    if (!refMatch) {
+      const legacyRegex = /\b([A-Z]\d{4})\b/;
+      refMatch = messageText.match(legacyRegex);
+      if (!refMatch && quotedText) {
+        refMatch = quotedText.match(legacyRegex);
+      }
+    }
+
+    // 3. If no REF code found, return false (not an operator reply)
+    if (!refMatch) {
+      this.logger.debug(
+        `No REF code found in operator message from ${normalizedPhone}`,
+      );
+      return false;
+    }
+
+    const refCode = refMatch[1];
+
+    // 4. Look up OperatorRequest by (tenant_id, ref_code)
+    const request = await this.prisma.operatorRequest.findUnique({
+      where: {
+        opreq_tenant_id_opreq_ref_code: {
+          opreq_tenant_id: tenantId,
+          opreq_ref_code: refCode,
+        },
+      },
+      include: {
+        session: {
+          select: {
+            session_id: true,
+            session_status: true,
+            session_chat_id: true,
+          },
+        },
+      },
+    });
+
+    // 5. If not found or not pending/responded, return false
+    if (!request) {
+      this.logger.debug(
+        `No operator request found for REF ${refCode} in tenant ${tenantId}`,
+      );
+      return false;
+    }
+
+    if (
+      request.opreq_status !== 'pending' &&
+      request.opreq_status !== 'responded'
+    ) {
+      this.logger.debug(
+        `Operator request ${refCode} is ${request.opreq_status}, ignoring reply`,
+      );
+      return false;
+    }
+
+    // Extract response text (remove the REF code from the message)
+    const responseText = messageText.replace(refCode, '').trim();
+
+    // 6. Encrypt the response and update the request
+    const encryptedResponse = this.encryption.encrypt(
+      responseText,
+      this.messageEncryptionKey,
+    );
+
+    await this.prisma.operatorRequest.update({
+      where: { opreq_id: request.opreq_id },
+      data: {
+        opreq_status: 'responded',
+        opreq_operator_response: encryptedResponse,
+        opreq_response_media_type: mediaType,
+        opreq_response_message_id: messageId,
+        opreq_responded_at: new Date(),
+      },
+    });
+
+    // 7. Clear session_awaiting_operator flag
+    await this.prisma.whatsappSession.update({
+      where: { session_id: request.opreq_session_id },
+      data: { session_awaiting_operator: false },
+    });
+
+    this.logger.log(
+      `Operator responded to request ${refCode} for session ${request.opreq_session_id}`,
+    );
+
+    // 8. Inject operator response — emit event for AI handling
+    await this.injectOperatorResponse(
+      request.opreq_session_id,
+      responseText,
+      refCode,
+    );
+
+    // 9. Send confirmation message to operator
+    try {
+      const metaConnection = await this.getMetaConnection(
+        request.opreq_clinic_id,
+      );
+      if (metaConnection) {
+        const accessToken = this.decryptAccessToken(
+          metaConnection.meta_encrypted_access_token!,
+        );
+        await this.metaWhatsApp.sendMessage(
+          metaConnection.meta_phone_number_id!,
+          senderPhone,
+          `✓ Yanıt alındı. Ref: ${refCode} — Hastaya iletilecek.`,
+          accessToken,
+        );
+      }
+    } catch (err: any) {
+      // Non-critical: log but don't fail the reply handling
+      this.logger.warn(
+        `Failed to send confirmation to operator for ref ${refCode}: ${err.message}`,
+      );
+    }
+
+    return true;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  INJECT OPERATOR RESPONSE                                           */
+  /* ------------------------------------------------------------------ */
+
+  async injectOperatorResponse(
+    sessionId: string,
+    operatorResponse: string,
+    refCode: string,
+  ): Promise<void> {
+    // 1. Load session and chat for context
+    const session = await this.prisma.whatsappSession.findUnique({
+      where: { session_id: sessionId },
+      select: {
+        session_id: true,
+        session_chat_id: true,
+        session_tenant_id: true,
+        session_clinic_id: true,
+        session_el_conversation_id: true,
+      },
+    });
+
+    if (!session) {
+      this.logger.warn(
+        `Cannot inject operator response: session ${sessionId} not found`,
+      );
+      return;
+    }
+
+    // 2. Emit event — the WhatsApp agent service handles reconnecting to
+    //    ElevenLabs and sending the context
+    this.eventEmitter.emit('whatsapp.operator.responded', {
+      requestId: undefined, // not always needed by listeners
+      sessionId: session.session_id,
+      chatId: session.session_chat_id,
+      tenantId: session.session_tenant_id,
+      clinicId: session.session_clinic_id,
+      refCode,
+      response: operatorResponse,
+      conversationId: session.session_el_conversation_id,
+    });
+
+    this.logger.debug(
+      `Emitted whatsapp.operator.responded for session ${sessionId}, ref ${refCode}`,
+    );
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  GENERATE UNIQUE REF CODE                                           */
+  /* ------------------------------------------------------------------ */
+
+  private async generateRefCode(
+    tenantId: string,
+    prefix: string,
+  ): Promise<string> {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    const maxAttempts = 10;
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      // 1. Generate 4 random uppercase alphanumeric chars
+      let suffix = '';
+      for (let i = 0; i < 4; i++) {
+        suffix += chars.charAt(Math.floor(Math.random() * chars.length));
+      }
+
+      // 2. Build code: {prefix}-{4chars} e.g., R-AB2X
+      const code = `${prefix}-${suffix}`;
+
+      // 3. Check if exists in tenant's OperatorRequests
+      const exists = await this.prisma.operatorRequest.findUnique({
+        where: {
+          opreq_tenant_id_opreq_ref_code: {
+            opreq_tenant_id: tenantId,
+            opreq_ref_code: code,
+          },
+        },
+        select: { opreq_id: true },
+      });
+
+      // 4. If no collision, return the unique code
+      if (!exists) {
+        return code;
+      }
+
+      this.logger.debug(
+        `REF code collision for ${code} in tenant ${tenantId}, retrying (${attempt + 1}/${maxAttempts})`,
+      );
+    }
+
+    // Exhausted attempts — extremely unlikely with 36^4 = 1,679,616 combinations
+    throw new Error(
+      `Failed to generate unique REF code after ${maxAttempts} attempts`,
+    );
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  EXPIRE PENDING REQUESTS — sweep every 15 minutes                   */
+  /* ------------------------------------------------------------------ */
+
+  async expirePendingRequests(): Promise<number> {
+    const now = new Date();
+
+    const expiredRequests = await this.prisma.operatorRequest.findMany({
+      where: {
+        opreq_status: 'pending',
+        opreq_expires_at: { lt: now },
+      },
+      include: {
+        session: {
+          select: {
+            session_id: true,
+            session_status: true,
+          },
+        },
+      },
+    });
+
+    if (expiredRequests.length === 0) return 0;
+
+    this.logger.log(
+      `Expiring ${expiredRequests.length} pending operator requests`,
+    );
+
+    let expiredCount = 0;
+
+    for (const request of expiredRequests) {
+      try {
+        // Mark request as expired
+        await this.prisma.operatorRequest.update({
+          where: { opreq_id: request.opreq_id },
+          data: { opreq_status: 'expired' },
+        });
+
+        // Clear awaiting operator flag if session still active
+        if (request.session.session_status === 'active') {
+          await this.prisma.whatsappSession.update({
+            where: { session_id: request.session.session_id },
+            data: { session_awaiting_operator: false },
+          });
+        }
+
+        // Emit event so the AI can notify the patient
+        this.eventEmitter.emit('whatsapp.operator.expired', {
+          requestId: request.opreq_id,
+          sessionId: request.opreq_session_id,
+          refCode: request.opreq_ref_code,
+        });
+
+        expiredCount++;
+      } catch (err: any) {
+        this.logger.error(
+          `Failed to expire operator request ${request.opreq_id}: ${err.message}`,
+        );
+        // Continue with next request
+      }
+    }
+
+    this.logger.log(
+      `Operator expiry sweep complete: ${expiredCount} requests expired`,
+    );
+
+    return expiredCount;
+  }
+
+  /* ------------------------------------------------------------------ */
+  /*  PRIVATE HELPERS                                                    */
+  /* ------------------------------------------------------------------ */
+
+  /**
+   * Get the first active Meta WhatsApp connection for a clinic.
+   */
+  private async getMetaConnection(clinicId: string) {
+    const conn = await this.prisma.clinicMetaConnection.findFirst({
+      where: {
+        meta_clinic_id: clinicId,
+        meta_type: 'whatsapp',
+        meta_is_active: true,
+      },
+    });
+
+    if (
+      !conn?.meta_phone_number_id ||
+      !conn?.meta_encrypted_access_token
+    ) {
+      return null;
+    }
+
+    return conn;
+  }
+
+  /**
+   * Decrypt a Meta access token. Falls back to raw value if decryption fails
+   * (e.g., dev environments where tokens may not be encrypted).
+   */
+  private decryptAccessToken(encryptedToken: string): string {
+    try {
+      return this.tokenEncryptionKey
+        ? this.encryption.decrypt(encryptedToken, this.tokenEncryptionKey)
+        : encryptedToken;
+    } catch {
+      return encryptedToken;
+    }
+  }
+
+  /**
+   * Map stored media type values to Meta WhatsApp API send types.
+   * Meta API accepts 'image', 'video', 'document'. Audio is sent as document.
+   */
+  private mapMediaType(
+    mediaType: string,
+  ): 'image' | 'video' | 'document' {
+    switch (mediaType) {
+      case 'image':
+        return 'image';
+      case 'video':
+        return 'video';
+      case 'audio':
+      case 'document':
+      default:
+        return 'document';
+    }
+  }
+
+  /**
+   * Simple delay utility.
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}