elevenlabs-webhook-nodejs 1.0.0

package/dist/modules/appointment-validation/appointment-validation.service.js

@@ -0,0 +1,827 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePhone = normalizePhone;
+exports.recalcStats = recalcStats;
+exports.createBatch = createBatch;
+exports.submitBatch = submitBatch;
+exports.retryEntry = retryEntry;
+exports.cancelBatch = cancelBatch;
+exports.retryBatch = retryBatch;
+exports.recordValidationResult = recordValidationResult;
+exports.syncBatchConversations = syncBatchConversations;
+exports.resumeInterruptedBatches = resumeInterruptedBatches;
+exports.syncActiveBatches = syncActiveBatches;
+exports.exportCSV = exportCSV;
+const mongoose_1 = __importDefault(require("mongoose"));
+const appointment_validation_model_1 = __importDefault(require("./appointment-validation.model"));
+const agent_model_1 = __importDefault(require("../agents/agent.model"));
+const tenant_model_1 = __importDefault(require("../tenants/tenant.model"));
+const elevenlabs_service_1 = __importDefault(require("../../services/elevenlabs.service"));
+const logger_1 = __importDefault(require("../../utils/logger"));
+// ─── Phone Normalization ────────────────────────────────────
+function normalizePhone(raw) {
+    const cleaned = raw.replace(/[^+\d]/g, '');
+    if (cleaned.length < 10)
+        return '';
+    return cleaned.startsWith('+') ? cleaned : `+${cleaned}`;
+}
+// ─── Stats ──────────────────────────────────────────────────
+function recalcStats(batch) {
+    const entries = batch.entries;
+    batch.stats = {
+        total: entries.length,
+        confirmed: entries.filter(e => e.validation_result === 'confirmed').length,
+        cancelled: entries.filter(e => e.validation_result === 'cancelled').length,
+        reschedule: entries.filter(e => e.validation_result === 'reschedule').length,
+        unresolved: entries.filter(e => e.validation_result === 'unresolved' || (e.call_status === 'completed' && !e.validation_result)).length,
+        no_answer: entries.filter(e => e.call_status === 'no_answer').length,
+        voicemail: entries.filter(e => e.call_status === 'voicemail').length,
+        pending: entries.filter(e => e.call_status === 'pending' || e.call_status === 'calling').length,
+        failed: entries.filter(e => e.call_status === 'failed').length,
+    };
+}
+async function createBatch(tenantId, userId, data) {
+    const entries = data.entries.map(e => ({
+        _id: new mongoose_1.default.Types.ObjectId(),
+        row_index: e.row_index,
+        external_id: e.external_id || '',
+        patient_name: e.patient_name,
+        patient_phone: normalizePhone(e.patient_phone),
+        appointment_date: e.appointment_date,
+        appointment_time: e.appointment_time,
+        doctor_name: e.doctor_name || '',
+        department: e.department || '',
+        notes: e.notes || '',
+        raw_data: e.raw_data || {},
+        call_status: 'pending',
+        conversation_id: null,
+        validation_result: null,
+        reschedule_request: null,
+        patient_message: null,
+        call_duration_secs: 0,
+        called_at: null,
+        result_at: null,
+    }));
+    const batch = await appointment_validation_model_1.default.create({
+        tenant_id: new mongoose_1.default.Types.ObjectId(tenantId),
+        created_by: new mongoose_1.default.Types.ObjectId(userId),
+        name: data.name,
+        status: 'draft',
+        agent_id: null,
+        phone_number_id: null,
+        column_mapping: data.column_mapping,
+        call_schedule: {
+            call_date: data.call_schedule.call_date,
+            call_start_time: data.call_schedule.call_start_time || '09:00',
+            call_end_time: data.call_schedule.call_end_time || '18:00',
+            max_concurrent: data.call_schedule.max_concurrent || 3,
+            max_retries: data.call_schedule.max_retries || 2,
+            retry_delay_minutes: data.call_schedule.retry_delay_minutes || 1, // TODO: change to 30 for production
+        },
+        entries,
+        stats: {
+            total: entries.length,
+            confirmed: 0,
+            cancelled: 0,
+            reschedule: 0,
+            unresolved: 0,
+            no_answer: 0,
+            voicemail: 0,
+            pending: entries.length,
+            failed: 0,
+        },
+    });
+    return batch;
+}
+// ─── Submit ─────────────────────────────────────────────────
+async function submitBatch(batchId, tenantId, options) {
+    const batch = await appointment_validation_model_1.default.findOne({ _id: batchId, tenant_id: tenantId });
+    if (!batch)
+        throw Object.assign(new Error('Batch not found'), { statusCode: 404 });
+    if (batch.status !== 'draft') {
+        throw Object.assign(new Error('Batch must be in draft status to submit'), { statusCode: 400 });
+    }
+    if (batch.entries.length === 0) {
+        throw Object.assign(new Error('Batch has no entries'), { statusCode: 400 });
+    }
+    // Resolve agent + phone from tenant settings
+    const tenant = await tenant_model_1.default.findById(tenantId).lean();
+    if (!tenant)
+        throw Object.assign(new Error('Tenant not found'), { statusCode: 404 });
+    const agentId = tenant.settings?.whatsapp_agent?.appointment_validation_agent_id;
+    const phoneNumberId = tenant.settings?.whatsapp_agent?.appointment_validation_phone_number_id;
+    if (!agentId) {
+        throw Object.assign(new Error('Randevu onay agenti tenant ayarlarinda yapilandirilmamis'), { statusCode: 400 });
+    }
+    if (!phoneNumberId) {
+        throw Object.assign(new Error('Randevu onay telefon numarasi tenant ayarlarinda yapilandirilmamis'), { statusCode: 400 });
+    }
+    const agent = await agent_model_1.default.findById(agentId).lean();
+    if (!agent || !agent.is_active) {
+        throw Object.assign(new Error('Yapilandirilan agent bulunamadi veya aktif degil'), { statusCode: 400 });
+    }
+    // Store resolved values on the batch
+    batch.agent_id = agent._id;
+    batch.phone_number_id = phoneNumberId;
+    batch.status = 'in_progress';
+    await batch.save();
+    // Fire individual SIP trunk calls (non-blocking)
+    dispatchCalls(batch, agent.elevenlabs_agent_id, phoneNumberId, tenant.name, options?.force).catch(err => logger_1.default.error('Batch dispatch error', { batchId: batch._id, error: err.message }));
+    logger_1.default.info('Appointment validation batch submitted', {
+        batchId: batch._id,
+        entryCount: batch.entries.length,
+    });
+    return batch;
+}
+// ─── Time Window Helpers ─────────────────────────────────────
+function isWithinCallWindow(schedule) {
+    const now = new Date();
+    const today = now.toISOString().split('T')[0]; // YYYY-MM-DD
+    // Check date
+    if (schedule.call_date !== today)
+        return false;
+    // Check time window
+    const hhmm = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+    return hhmm >= schedule.call_start_time && hhmm < schedule.call_end_time;
+}
+function msUntilCallWindow(schedule) {
+    const now = new Date();
+    const today = now.toISOString().split('T')[0];
+    if (schedule.call_date > today) {
+        // Future date — calculate ms until start
+        const startDt = new Date(`${schedule.call_date}T${schedule.call_start_time}:00`);
+        return startDt.getTime() - now.getTime();
+    }
+    if (schedule.call_date === today) {
+        const hhmm = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+        if (hhmm < schedule.call_start_time) {
+            const startDt = new Date(`${today}T${schedule.call_start_time}:00`);
+            return startDt.getTime() - now.getTime();
+        }
+    }
+    return -1; // Past
+}
+function isAppointmentPassed(entry) {
+    const now = new Date();
+    const apptDate = entry.appointment_date; // YYYY-MM-DD
+    const apptTime = entry.appointment_time; // HH:MM
+    if (!apptDate)
+        return false;
+    const dt = new Date(`${apptDate}T${apptTime || '23:59'}:00`);
+    return !isNaN(dt.getTime()) && dt.getTime() <= now.getTime();
+}
+// ─── Concurrent Call Dispatcher ──────────────────────────────
+async function dispatchCalls(batch, elevenlabsAgentId, phoneNumberId, clinicName, force) {
+    const schedule = batch.call_schedule;
+    const maxConcurrent = schedule.max_concurrent || 3;
+    const maxRetries = schedule.max_retries || 2;
+    const retryDelayMs = (schedule.retry_delay_minutes || 30) * 60 * 1000;
+    if (!force) {
+        // Wait until call window opens (if not yet)
+        const waitMs = msUntilCallWindow(schedule);
+        if (waitMs > 0) {
+            logger_1.default.info('Waiting for call window to open', {
+                batchId: batch._id, waitMs, callDate: schedule.call_date, startTime: schedule.call_start_time,
+            });
+            await new Promise(resolve => setTimeout(resolve, Math.min(waitMs, 12 * 60 * 60 * 1000)));
+        }
+        else if (waitMs < 0 && schedule.call_date < new Date().toISOString().split('T')[0]) {
+            logger_1.default.warn('Call date is in the past, proceeding anyway', { batchId: batch._id, callDate: schedule.call_date });
+        }
+    }
+    else {
+        logger_1.default.info('Force mode — skipping time window checks', { batchId: batch._id });
+    }
+    let activeCount = 0;
+    async function callEntry(entry) {
+        const entryId = entry._id;
+        try {
+            // Atomic update: set calling status + increment attempts
+            await appointment_validation_model_1.default.updateOne({ _id: batch._id, 'entries._id': entryId }, { $set: { 'entries.$.call_status': 'calling' }, $inc: { 'entries.$.attempts': 1 } });
+            const result = await elevenlabs_service_1.default.sipTrunkOutboundCall({
+                agentId: elevenlabsAgentId,
+                agentPhoneNumberId: phoneNumberId,
+                toNumber: entry.patient_phone,
+                conversationInitiationClientData: {
+                    dynamicVariables: {
+                        clinic_name: clinicName,
+                        patient_name: entry.patient_name,
+                        patient_phone: entry.patient_phone,
+                        appointment_date: entry.appointment_date,
+                        appointment_time: entry.appointment_time,
+                        doctor_name: entry.doctor_name || '',
+                        department: entry.department || '',
+                        notes: entry.notes || '',
+                        current_date: new Date().toISOString().split('T')[0],
+                        row_id: entryId.toString(),
+                    },
+                },
+            });
+            // Atomic update: set conversation_id + called_at
+            await appointment_validation_model_1.default.updateOne({ _id: batch._id, 'entries._id': entryId }, { $set: {
+                    'entries.$.conversation_id': result.conversationId || null,
+                    'entries.$.called_at': new Date(),
+                } });
+            logger_1.default.info('Appointment validation call initiated', {
+                batchId: batch._id,
+                phone: entry.patient_phone,
+                conversationId: result.conversationId,
+            });
+        }
+        catch (err) {
+            await appointment_validation_model_1.default.updateOne({ _id: batch._id, 'entries._id': entryId }, { $set: { 'entries.$.call_status': 'failed' } });
+            logger_1.default.error('Failed to initiate appointment validation call', {
+                batchId: batch._id,
+                phone: entry.patient_phone,
+                error: err.message,
+            });
+        }
+    }
+    // Process pending entries with concurrency limit
+    async function processQueue() {
+        // Re-read from DB to get fresh state
+        const fresh = await appointment_validation_model_1.default.findById(batch._id);
+        if (!fresh || fresh.status === 'cancelled')
+            return;
+        batch.entries = fresh.entries;
+        const pendingEntries = batch.entries.filter(e => e.call_status === 'pending');
+        // Skip entries whose appointment has already passed (atomic)
+        for (const entry of pendingEntries) {
+            if (isAppointmentPassed(entry)) {
+                await appointment_validation_model_1.default.updateOne({ _id: batch._id, 'entries._id': entry._id }, { $set: {
+                        'entries.$.call_status': 'failed',
+                        'entries.$.validation_result': 'unresolved',
+                        'entries.$.result_at': new Date(),
+                    } });
+                logger_1.default.info('Skipped entry — appointment already passed', {
+                    batchId: batch._id, phone: entry.patient_phone,
+                    appointmentDate: entry.appointment_date, appointmentTime: entry.appointment_time,
+                });
+            }
+        }
+        // Re-read after marking passed entries
+        const updated = await appointment_validation_model_1.default.findById(batch._id);
+        if (!updated || updated.status === 'cancelled')
+            return;
+        batch.entries = updated.entries;
+        const callableEntries = batch.entries
+            .filter(e => e.call_status === 'pending')
+            .sort((a, b) => {
+            const dtA = `${a.appointment_date}T${a.appointment_time || '00:00'}`;
+            const dtB = `${b.appointment_date}T${b.appointment_time || '00:00'}`;
+            return dtA < dtB ? -1 : dtA > dtB ? 1 : 0;
+        });
+        const promises = [];
+        for (const entry of callableEntries) {
+            // Check time window before each call (skip in force mode)
+            if (!force && !isWithinCallWindow(schedule)) {
+                logger_1.default.info('Call window closed, pausing dispatch', {
+                    batchId: batch._id,
+                    endTime: schedule.call_end_time,
+                    remaining: pendingEntries.length - promises.length,
+                });
+                break;
+            }
+            // Wait for a slot to open
+            while (activeCount >= maxConcurrent) {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+            activeCount++;
+            const p = callEntry(entry).finally(() => { activeCount--; });
+            promises.push(p);
+            // Small stagger between launching calls
+            await new Promise(resolve => setTimeout(resolve, 1500));
+        }
+        await Promise.all(promises);
+    }
+    // First pass
+    await processQueue();
+    if (maxRetries <= 0) {
+        await waitAndComplete(batch._id);
+        return;
+    }
+    // Wait for all active calls to finish before checking retries
+    await waitForCallsToSettle(batch._id);
+    // Retry loop
+    for (let retry = 0; retry < maxRetries; retry++) {
+        const current = await appointment_validation_model_1.default.findById(batch._id);
+        if (!current || current.status === 'cancelled')
+            return;
+        const retriable = current.entries.filter(e => (e.call_status === 'failed' || e.call_status === 'no_answer' || e.call_status === 'voicemail' || e.validation_result === 'unresolved')
+            && (e.attempts || 0) <= retry + 1 // only retry entries from previous round
+            && !isAppointmentPassed(e));
+        if (retriable.length === 0)
+            break;
+        if (!force && !isWithinCallWindow(schedule)) {
+            logger_1.default.info('Call window closed, skipping retries', { batchId: batch._id });
+            break;
+        }
+        logger_1.default.info('Waiting for retry delay', {
+            batchId: current._id,
+            retryRound: retry + 1,
+            retriable: retriable.length,
+            retryDelayMinutes: schedule.retry_delay_minutes,
+        });
+        await new Promise(resolve => setTimeout(resolve, retryDelayMs));
+        if (!force && !isWithinCallWindow(schedule))
+            break;
+        // Reset retriable entries atomically
+        for (const entry of retriable) {
+            await appointment_validation_model_1.default.updateOne({ _id: batch._id, 'entries._id': entry._id }, { $set: {
+                    'entries.$.call_status': 'pending',
+                    'entries.$.conversation_id': null,
+                    'entries.$.validation_result': null,
+                    'entries.$.result_at': null,
+                } });
+        }
+        // Re-read batch for processQueue
+        const refreshed = await appointment_validation_model_1.default.findById(batch._id);
+        if (!refreshed || refreshed.status === 'cancelled')
+            return;
+        // Reassign batch ref for processQueue/callEntry closures
+        batch.entries = refreshed.entries;
+        await processQueue();
+        await waitForCallsToSettle(batch._id);
+    }
+    await waitAndComplete(batch._id);
+}
+async function waitForCallsToSettle(batchId) {
+    // Poll until no entries are in 'calling' status (max 10 min)
+    const maxWait = 10 * 60 * 1000;
+    const start = Date.now();
+    while (Date.now() - start < maxWait) {
+        const b = await appointment_validation_model_1.default.findById(batchId).lean();
+        if (!b)
+            return;
+        const hasCalling = b.entries.some(e => e.call_status === 'calling');
+        if (!hasCalling)
+            return;
+        await new Promise(resolve => setTimeout(resolve, 5000));
+    }
+    // Timeout — mark stuck calling entries as failed so they can be retried
+    logger_1.default.warn('waitForCallsToSettle timed out, marking stuck entries as failed', { batchId });
+    const b = await appointment_validation_model_1.default.findById(batchId);
+    if (!b)
+        return;
+    for (const entry of b.entries) {
+        if (entry.call_status === 'calling') {
+            entry.call_status = 'failed';
+        }
+    }
+    recalcStats(b);
+    await b.save();
+}
+async function waitAndComplete(batchId) {
+    await waitForCallsToSettle(batchId);
+    const final = await appointment_validation_model_1.default.findById(batchId);
+    if (final && final.status === 'in_progress') {
+        final.status = 'completed';
+        recalcStats(final);
+        await final.save();
+        logger_1.default.info('Appointment validation batch completed', { batchId: final._id });
+    }
+}
+// ─── Retry Single Entry ─────────────────────────────────────
+async function retryEntry(batchId, entryId, tenantId) {
+    const batch = await appointment_validation_model_1.default.findOne({ _id: batchId, tenant_id: tenantId });
+    if (!batch)
+        throw Object.assign(new Error('Batch not found'), { statusCode: 404 });
+    const entry = batch.entries.find(e => e._id.toString() === entryId);
+    if (!entry)
+        throw Object.assign(new Error('Entry not found'), { statusCode: 404 });
+    const tenant = await tenant_model_1.default.findById(tenantId).lean();
+    if (!tenant)
+        throw Object.assign(new Error('Tenant not found'), { statusCode: 404 });
+    const agentObjId = tenant.settings?.whatsapp_agent?.appointment_validation_agent_id;
+    const phoneNumberId = tenant.settings?.whatsapp_agent?.appointment_validation_phone_number_id;
+    if (!agentObjId || !phoneNumberId) {
+        throw Object.assign(new Error('Agent veya telefon numarasi yapilandirilmamis'), { statusCode: 400 });
+    }
+    const agent = await agent_model_1.default.findById(agentObjId).lean();
+    if (!agent || !agent.is_active) {
+        throw Object.assign(new Error('Agent bulunamadi veya aktif degil'), { statusCode: 400 });
+    }
+    if (batch.status === 'completed' || batch.status === 'cancelled') {
+        batch.status = 'in_progress';
+        await batch.save();
+    }
+    // Fire a single call directly (no dispatch loop / retries)
+    (async () => {
+        try {
+            // Reset entry atomically
+            await appointment_validation_model_1.default.updateOne({ _id: batch._id, 'entries._id': entry._id }, { $set: {
+                    'entries.$.call_status': 'calling',
+                    'entries.$.conversation_id': null,
+                    'entries.$.validation_result': null,
+                    'entries.$.reschedule_request': null,
+                    'entries.$.patient_message': null,
+                    'entries.$.call_duration_secs': 0,
+                    'entries.$.called_at': null,
+                    'entries.$.result_at': null,
+                }, $inc: { 'entries.$.attempts': 1 } });
+            const result = await elevenlabs_service_1.default.sipTrunkOutboundCall({
+                agentId: agent.elevenlabs_agent_id,
+                agentPhoneNumberId: phoneNumberId,
+                toNumber: entry.patient_phone,
+                conversationInitiationClientData: {
+                    dynamicVariables: {
+                        clinic_name: tenant.name,
+                        patient_name: entry.patient_name,
+                        patient_phone: entry.patient_phone,
+                        appointment_date: entry.appointment_date,
+                        appointment_time: entry.appointment_time,
+                        doctor_name: entry.doctor_name || '',
+                        department: entry.department || '',
+                        notes: entry.notes || '',
+                        current_date: new Date().toISOString().split('T')[0],
+                        row_id: entry._id.toString(),
+                    },
+                },
+            });
+            await appointment_validation_model_1.default.updateOne({ _id: batch._id, 'entries._id': entry._id }, { $set: {
+                    'entries.$.conversation_id': result.conversationId || null,
+                    'entries.$.called_at': new Date(),
+                } });
+            logger_1.default.info('Single entry retry call initiated', {
+                batchId: batch._id, entryId, conversationId: result.conversationId,
+            });
+        }
+        catch (err) {
+            await appointment_validation_model_1.default.updateOne({ _id: batch._id, 'entries._id': entry._id }, { $set: { 'entries.$.call_status': 'failed' } });
+            logger_1.default.error('Single entry retry call failed', {
+                batchId: batch._id, entryId, error: err.message,
+            });
+        }
+        // Recalc stats
+        const refreshed = await appointment_validation_model_1.default.findById(batch._id);
+        if (refreshed) {
+            recalcStats(refreshed);
+            await refreshed.save();
+        }
+    })().catch(err => logger_1.default.error('Single entry retry error', { batchId: batch._id, entryId, error: err.message }));
+    // Return current batch state (call fires in background)
+    recalcStats(batch);
+    return batch;
+}
+// ─── Cancel ─────────────────────────────────────────────────
+async function cancelBatch(batchId, tenantId) {
+    const batch = await appointment_validation_model_1.default.findOne({ _id: batchId, tenant_id: tenantId });
+    if (!batch)
+        throw Object.assign(new Error('Batch not found'), { statusCode: 404 });
+    if (batch.status === 'completed' || batch.status === 'cancelled') {
+        throw Object.assign(new Error('Batch is already finished'), { statusCode: 400 });
+    }
+    // Mark remaining pending/calling entries as failed
+    for (const entry of batch.entries) {
+        if (entry.call_status === 'pending' || entry.call_status === 'calling') {
+            entry.call_status = 'failed';
+        }
+    }
+    batch.status = 'cancelled';
+    recalcStats(batch);
+    await batch.save();
+    return batch;
+}
+// ─── Retry ──────────────────────────────────────────────────
+async function retryBatch(batchId, tenantId, options) {
+    const batch = await appointment_validation_model_1.default.findOne({ _id: batchId, tenant_id: tenantId });
+    if (!batch)
+        throw Object.assign(new Error('Batch not found'), { statusCode: 404 });
+    const tenant = await tenant_model_1.default.findById(tenantId).lean();
+    if (!tenant)
+        throw Object.assign(new Error('Tenant not found'), { statusCode: 404 });
+    const agentId = tenant.settings?.whatsapp_agent?.appointment_validation_agent_id;
+    const phoneNumberId = tenant.settings?.whatsapp_agent?.appointment_validation_phone_number_id;
+    if (!agentId || !phoneNumberId) {
+        throw Object.assign(new Error('Agent veya telefon numarasi yapilandirilmamis'), { statusCode: 400 });
+    }
+    const agent = await agent_model_1.default.findById(agentId).lean();
+    if (!agent || !agent.is_active) {
+        throw Object.assign(new Error('Agent bulunamadi veya aktif degil'), { statusCode: 400 });
+    }
+    // Reset failed/no_answer/voicemail/unresolved entries to pending
+    for (const entry of batch.entries) {
+        if (entry.call_status === 'failed' || entry.call_status === 'no_answer' || entry.call_status === 'voicemail'
+            || entry.validation_result === 'unresolved') {
+            entry.call_status = 'pending';
+            entry.conversation_id = null;
+            entry.validation_result = null;
+            entry.reschedule_request = null;
+            entry.patient_message = null;
+            entry.result_at = null;
+        }
+    }
+    batch.status = 'in_progress';
+    recalcStats(batch);
+    await batch.save();
+    // Fire calls for reset entries
+    dispatchCalls(batch, agent.elevenlabs_agent_id, phoneNumberId, tenant.name, options?.force).catch(err => logger_1.default.error('Batch retry dispatch error', { batchId: batch._id, error: err.message }));
+    return batch;
+}
+// ─── Record Validation Result (called by webhook tool) ──────
+async function recordValidationResult(conversationId, tenantId, result, rescheduleRequest, patientMessage) {
+    const batch = await appointment_validation_model_1.default.findOne({
+        tenant_id: tenantId,
+        'entries.conversation_id': conversationId,
+    });
+    if (!batch) {
+        return { recorded: false };
+    }
+    const entry = batch.entries.find(e => e.conversation_id === conversationId);
+    if (!entry) {
+        return { recorded: false };
+    }
+    // Atomic update to avoid race conditions with concurrent dispatchCalls
+    await appointment_validation_model_1.default.updateOne({ _id: batch._id, 'entries.conversation_id': conversationId }, { $set: {
+            'entries.$.validation_result': result,
+            'entries.$.reschedule_request': rescheduleRequest || null,
+            'entries.$.patient_message': patientMessage || null,
+            'entries.$.result_at': new Date(),
+            'entries.$.call_status': 'completed',
+        } });
+    // Recalc stats on fresh document
+    const refreshed = await appointment_validation_model_1.default.findById(batch._id);
+    if (refreshed) {
+        recalcStats(refreshed);
+        await refreshed.save();
+    }
+    logger_1.default.info('Appointment validation result recorded', {
+        batchId: batch._id,
+        conversationId,
+        result,
+    });
+    return { recorded: true, batchId: batch._id.toString() };
+}
+// ─── Sync Conversations from ElevenLabs API ─────────────────
+async function syncBatchConversations(batch) {
+    const entriesWithConvId = batch.entries.filter(e => e.conversation_id && (e.call_status === 'calling' || e.call_status === 'completed' || !e.validation_result));
+    if (entriesWithConvId.length === 0) {
+        recalcStats(batch);
+        await batch.save();
+        return batch;
+    }
+    const EL_STATUS_MAP = {
+        done: 'completed',
+        failed: 'failed',
+        'in-progress': 'calling',
+        initiated: 'calling',
+        processing: 'completed',
+    };
+    let synced = 0;
+    for (const entry of entriesWithConvId) {
+        try {
+            const conv = await elevenlabs_service_1.default.getConversation(entry.conversation_id);
+            const elStatus = (conv.status || '').toLowerCase();
+            const mappedStatus = EL_STATUS_MAP[elStatus];
+            if (mappedStatus && entry.call_status !== mappedStatus) {
+                entry.call_status = mappedStatus;
+            }
+            // Update duration from conversation metadata
+            const duration = conv.metadata?.duration;
+            if (typeof duration === 'number' && duration > 0) {
+                entry.call_duration_secs = Math.round(duration);
+            }
+            // If call is done but no validation_result, check if tool was called in transcript
+            if (elStatus === 'done' && !entry.validation_result) {
+                let foundResult = false;
+                const transcript = conv.transcript || [];
+                for (const turn of transcript) {
+                    const toolCalls = turn.tool_calls || [];
+                    for (const tc of toolCalls) {
+                        if (tc.tool_name === 'confirm_appointment_validation' && tc.params) {
+                            const result = tc.params.result;
+                            if (['confirmed', 'cancelled', 'reschedule'].includes(result)) {
+                                entry.validation_result = result;
+                                entry.reschedule_request = tc.params.reschedule_request || null;
+                                entry.patient_message = tc.params.patient_message || null;
+                                entry.result_at = new Date();
+                                foundResult = true;
+                            }
+                        }
+                    }
+                }
+                // Call done but tool never called — mark as unresolved
+                if (!foundResult) {
+                    entry.validation_result = 'unresolved';
+                    entry.result_at = new Date();
+                }
+            }
+            synced++;
+            // Small delay to avoid rate limiting
+            if (synced % 5 === 0) {
+                await new Promise(resolve => setTimeout(resolve, 500));
+            }
+        }
+        catch (err) {
+            logger_1.default.warn('Failed to sync conversation', {
+                conversationId: entry.conversation_id,
+                error: err.message,
+            });
+        }
+    }
+    // Check if batch is complete
+    const allDone = batch.entries.every(e => e.call_status !== 'pending' && e.call_status !== 'calling');
+    if (allDone && batch.status === 'in_progress') {
+        batch.status = 'completed';
+    }
+    recalcStats(batch);
+    await batch.save();
+    logger_1.default.info('Synced batch conversations from ElevenLabs', {
+        batchId: batch._id,
+        synced,
+        total: entriesWithConvId.length,
+    });
+    return batch;
+}
+// ─── Sync Active Batches ────────────────────────────────────
+// ─── Resume Interrupted Batches (on server startup) ──────────
+async function resumeInterruptedBatches() {
+    const interrupted = await appointment_validation_model_1.default.find({
+        status: 'in_progress',
+    });
+    if (interrupted.length === 0)
+        return;
+    logger_1.default.info('Found interrupted appointment validation batches', { count: interrupted.length });
+    for (const batch of interrupted) {
+        try {
+            // Fix stale "calling" entries — server died mid-call, webhook never arrived
+            let fixed = 0;
+            for (const entry of batch.entries) {
+                if (entry.call_status === 'calling') {
+                    // If we have a conversation_id, try to sync from ElevenLabs
+                    if (entry.conversation_id) {
+                        try {
+                            const conv = await elevenlabs_service_1.default.getConversation(entry.conversation_id);
+                            const elStatus = (conv.status || '').toLowerCase();
+                            const termReason = (conv.metadata?.termination_reason || '').toLowerCase();
+                            if (elStatus === 'done' || elStatus === 'failed') {
+                                entry.call_status = termReason.includes('voicemail') ? 'voicemail'
+                                    : ['failed', 'error'].includes(elStatus) ? 'failed'
+                                        : 'completed';
+                                if (entry.call_status === 'completed' && !entry.validation_result) {
+                                    entry.validation_result = 'unresolved';
+                                    entry.result_at = new Date();
+                                }
+                            }
+                            else {
+                                // Still in progress or unknown — mark failed so it can be retried
+                                entry.call_status = 'failed';
+                            }
+                        }
+                        catch {
+                            // Can't reach ElevenLabs — mark failed
+                            entry.call_status = 'failed';
+                        }
+                    }
+                    else {
+                        // No conversation_id — call was never actually placed, reset to pending
+                        entry.call_status = 'pending';
+                    }
+                    fixed++;
+                }
+            }
+            if (fixed > 0) {
+                logger_1.default.info('Fixed stale calling entries after restart', {
+                    batchId: batch._id, fixed,
+                });
+            }
+            // Check if there are still pending entries to dispatch
+            const hasPending = batch.entries.some(e => e.call_status === 'pending');
+            const hasRetriable = batch.entries.some(e => (e.call_status === 'failed' || e.call_status === 'no_answer' || e.call_status === 'voicemail')
+                && (e.attempts || 0) < (batch.call_schedule.max_retries || 2));
+            if (hasPending || hasRetriable) {
+                // Resolve tenant + agent to re-dispatch
+                const tenant = await tenant_model_1.default.findById(batch.tenant_id).lean();
+                const agentObjId = tenant?.settings?.whatsapp_agent?.appointment_validation_agent_id;
+                const phoneNumberId = tenant?.settings?.whatsapp_agent?.appointment_validation_phone_number_id;
+                if (tenant && agentObjId && phoneNumberId) {
+                    const agent = await agent_model_1.default.findById(agentObjId).lean();
+                    if (agent?.is_active) {
+                        // Reset retriable entries to pending for re-dispatch
+                        if (hasRetriable && !hasPending) {
+                            for (const entry of batch.entries) {
+                                if ((entry.call_status === 'failed' || entry.call_status === 'no_answer' || entry.call_status === 'voicemail')
+                                    && (entry.attempts || 0) < (batch.call_schedule.max_retries || 2)) {
+                                    entry.call_status = 'pending';
+                                    entry.conversation_id = null;
+                                    entry.validation_result = null;
+                                }
+                            }
+                        }
+                        recalcStats(batch);
+                        await batch.save();
+                        logger_1.default.info('Resuming interrupted batch', {
+                            batchId: batch._id,
+                            pending: batch.entries.filter(e => e.call_status === 'pending').length,
+                        });
+                        dispatchCalls(batch, agent.elevenlabs_agent_id, phoneNumberId, tenant.name).catch(err => logger_1.default.error('Failed to resume batch dispatch', { batchId: batch._id, error: err.message }));
+                        continue; // skip the save below
+                    }
+                }
+            }
+            // No pending/retriable — just complete it
+            const allDone = batch.entries.every(e => e.call_status !== 'pending' && e.call_status !== 'calling');
+            if (allDone) {
+                batch.status = 'completed';
+            }
+            recalcStats(batch);
+            await batch.save();
+        }
+        catch (err) {
+            logger_1.default.error('Failed to resume interrupted batch', {
+                batchId: batch._id,
+                error: err.message,
+            });
+        }
+    }
+}
+// ─── Sync Active Batches (periodic) ─────────────────────────
+async function syncActiveBatches() {
+    const activeBatches = await appointment_validation_model_1.default.find({
+        status: 'in_progress',
+    });
+    const staleThreshold = Date.now() - 5 * 60 * 1000; // 5 minutes
+    for (const batch of activeBatches) {
+        try {
+            let changed = false;
+            // Mark stale "calling" entries as completed (webhook probably missed)
+            for (const entry of batch.entries) {
+                if (entry.call_status === 'calling' && entry.called_at && entry.called_at.getTime() < staleThreshold) {
+                    entry.call_status = 'completed';
+                    changed = true;
+                    logger_1.default.warn('Marked stale calling entry as completed', {
+                        batchId: batch._id,
+                        entryId: entry._id,
+                        phone: entry.patient_phone,
+                    });
+                }
+            }
+            // Only auto-complete if no pending/calling entries AND batch has been
+            // in_progress for at least 5 minutes (avoids racing with dispatch retry loop)
+            const allDone = batch.entries.every(e => e.call_status !== 'pending' && e.call_status !== 'calling');
+            const batchAge = Date.now() - (batch.updatedAt?.getTime() || Date.now());
+            if (allDone && batchAge > 5 * 60 * 1000) {
+                batch.status = 'completed';
+                changed = true;
+            }
+            if (changed) {
+                recalcStats(batch);
+            }
+            await batch.save();
+        }
+        catch (err) {
+            logger_1.default.error('Failed to sync appointment validation batch', {
+                batchId: batch._id,
+                error: err.message,
+            });
+        }
+    }
+}
+// ─── CSV Export ─────────────────────────────────────────────
+function escapeCSV(value) {
+    if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+function exportCSV(batch) {
+    const header = [
+        'Harici ID',
+        'Satir No',
+        'Hasta Adi',
+        'Telefon',
+        'Randevu Tarihi',
+        'Randevu Saati',
+        'Doktor',
+        'Bolum',
+        'Arama Durumu',
+        'Deneme',
+        'Sonuc',
+        'Erteleme Talebi',
+        'Hasta Mesaji',
+        'Arama Suresi (sn)',
+        'Aranma Zamani',
+    ].join(',');
+    const rows = batch.entries.map(e => [
+        escapeCSV(e.external_id || ''),
+        String(e.row_index),
+        escapeCSV(e.patient_name),
+        e.patient_phone,
+        e.appointment_date,
+        e.appointment_time,
+        escapeCSV(e.doctor_name),
+        escapeCSV(e.department),
+        e.call_status,
+        String(e.attempts || 0),
+        e.validation_result || '',
+        escapeCSV(e.reschedule_request || ''),
+        escapeCSV(e.patient_message || ''),
+        String(e.call_duration_secs),
+        e.called_at ? e.called_at.toISOString() : '',
+    ].join(','));
+    return [header, ...rows].join('\n');
+}
+//# sourceMappingURL=appointment-validation.service.js.map