elevenlabs-webhook-nodejs 1.0.0

package/src/modules/campaigns/campaign.service.ts

@@ -0,0 +1,99 @@
+import mongoose from 'mongoose';
+import Campaign, { ICampaign, CampaignStatus } from './campaign.model';
+import Call from '../calls/call.model';
+
+/**
+ * Campaign state machine.
+ * Valid transitions:
+ *   draft → scheduled
+ *   scheduled → running
+ *   running → paused
+ *   running → completed
+ *   paused → running
+ *   paused → completed
+ *   any non-completed → completed (stop)
+ */
+
+const VALID_TRANSITIONS: Record<CampaignStatus, CampaignStatus[]> = {
+  draft: ['scheduled'],
+  scheduled: ['running'],
+  running: ['paused', 'completed'],
+  paused: ['running', 'completed'],
+  completed: []
+};
+
+export function canTransition(from: CampaignStatus, to: CampaignStatus): boolean {
+  return VALID_TRANSITIONS[from].includes(to);
+}
+
+export async function transitionStatus(
+  campaign: ICampaign,
+  targetStatus: CampaignStatus
+): Promise<ICampaign> {
+  if (!canTransition(campaign.status, targetStatus)) {
+    throw Object.assign(
+      new Error(`Cannot transition from "${campaign.status}" to "${targetStatus}"`),
+      { statusCode: 400 }
+    );
+  }
+
+  campaign.status = targetStatus;
+  await campaign.save();
+  return campaign;
+}
+
+export function recalcStats(campaign: ICampaign): void {
+  const list = campaign.phone_list;
+  campaign.stats = {
+    total: list.length,
+    pending: list.filter(p => p.status === 'pending').length,
+    completed: list.filter(p => p.status === 'completed').length,
+    failed: list.filter(p => p.status === 'failed').length,
+    no_answer: list.filter(p => p.status === 'no_answer').length,
+    voicemail: list.filter(p => p.status === 'voicemail').length
+  };
+}
+
+export async function aggregateStatsFromCalls(campaignId: string): Promise<{
+  total: number;
+  completed: number;
+  failed: number;
+  no_answer: number;
+}> {
+  const [stats] = await Call.aggregate([
+    { $match: { campaign_id: new mongoose.Types.ObjectId(campaignId) } },
+    {
+      $group: {
+        _id: null,
+        total: { $sum: 1 },
+        completed: { $sum: { $cond: [{ $eq: ['$status', 'completed'] }, 1, 0] } },
+        failed: { $sum: { $cond: [{ $eq: ['$status', 'failed'] }, 1, 0] } },
+        no_answer: { $sum: { $cond: [{ $eq: ['$status', 'no_answer'] }, 1, 0] } }
+      }
+    }
+  ]);
+
+  return stats || { total: 0, completed: 0, failed: 0, no_answer: 0 };
+}
+
+export function parsePhoneListCSV(csvContent: string): string[] {
+  const lines = csvContent.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+  const numbers: string[] = [];
+
+  for (const line of lines) {
+    // Take first column (in case of multi-column CSV)
+    const value = line.split(',')[0].trim().replace(/["\s]/g, '');
+
+    // Skip header-like rows
+    if (/^(phone|number|tel|numara)/i.test(value)) continue;
+
+    // Must start with + or digits, be at least 10 chars
+    const cleaned = value.replace(/[^+\d]/g, '');
+    if (cleaned.length >= 10) {
+      numbers.push(cleaned.startsWith('+') ? cleaned : `+${cleaned}`);
+    }
+  }
+
+  // Deduplicate
+  return [...new Set(numbers)];
+}

package/src/modules/google-calendar/google-calendar.routes.ts

@@ -0,0 +1,31 @@
+import type { FastifyInstance } from 'fastify';
+import googleCalendarService from '../../services/google-calendar.service';
+import config from '../../config';
+import logger from '../../utils/logger';
+
+export default async function googleCalendarCallbackRoutes(fastify: FastifyInstance): Promise<void> {
+  // GET /google-calendar/callback — OAuth2 callback (browser redirect from Google, no auth)
+  fastify.get<{
+    Querystring: { code?: string; state?: string; error?: string };
+  }>('/callback', async (request, reply) => {
+    const { code, state, error } = request.query;
+    const frontendUrl = config.google.frontendUrl || 'http://localhost:5173';
+
+    if (error) {
+      logger.warn('Google Calendar OAuth denied', { error });
+      return reply.redirect(`${frontendUrl}/whatsapp/settings?gcal_error=access_denied`);
+    }
+
+    if (!code || !state) {
+      return reply.redirect(`${frontendUrl}/whatsapp/settings?gcal_error=invalid_params`);
+    }
+
+    try {
+      await googleCalendarService.handleCallback(code, state);
+      return reply.redirect(`${frontendUrl}/whatsapp/settings?gcal_connected=true`);
+    } catch (err) {
+      logger.error('Google Calendar OAuth callback failed', { error: (err as Error).message });
+      return reply.redirect(`${frontendUrl}/whatsapp/settings?gcal_error=callback_failed`);
+    }
+  });
+}

package/src/modules/inbound-call/inbound-call-config.model.ts

@@ -0,0 +1,49 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import type { IAiShiftEntry } from '../tenants/tenant.model';
+
+export interface IInboundCallConfig extends Document {
+  tenant_id: mongoose.Types.ObjectId;
+  elevenlabs_phone_number_id: string;
+  elevenlabs_agent_id: string;
+  phone_number: string;
+  label: string;
+  schedule_enabled: boolean;
+  schedule: IAiShiftEntry[];
+  agent_assigned: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const inboundCallConfigSchema = new Schema<IInboundCallConfig>({
+  tenant_id: {
+    type: Schema.Types.ObjectId,
+    ref: 'Tenant',
+    required: true,
+    index: true,
+  },
+  elevenlabs_phone_number_id: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  elevenlabs_agent_id: {
+    type: String,
+    default: '',
+  },
+  phone_number: { type: String, required: true },
+  label: { type: String, default: '' },
+  schedule_enabled: { type: Boolean, default: false },
+  schedule: [{
+    _id: false,
+    day: { type: Number, min: 0, max: 6, required: true },
+    start: { type: String, default: '09:00' },
+    end: { type: String, default: '18:00' },
+  }],
+  agent_assigned: { type: Boolean, default: false },
+}, {
+  timestamps: true,
+});
+
+inboundCallConfigSchema.index({ schedule_enabled: 1, elevenlabs_phone_number_id: 1 });
+
+export default mongoose.model<IInboundCallConfig>('InboundCallConfig', inboundCallConfigSchema);

package/src/modules/inbound-call/inbound-call.routes.ts

@@ -0,0 +1,289 @@
+import { FastifyInstance } from 'fastify';
+import InboundCallConfig from './inbound-call-config.model';
+import Tenant from '../tenants/tenant.model';
+import { requireRole, requireFeature } from '../../plugins/rbac';
+import elevenlabsService from '../../services/elevenlabs.service';
+import inboundCallScheduleService from '../../services/inbound-call-schedule.service';
+
+export default async function inboundCallRoutes(fastify: FastifyInstance): Promise<void> {
+  fastify.addHook('preHandler', fastify.authenticate);
+
+  // ─── Superadmin endpoints ──────────────────────────────────
+
+  // GET /inbound-call/phone-numbers — List all ElevenLabs phone numbers with local assignment info
+  fastify.get('/phone-numbers', {
+    preHandler: [requireRole('superadmin')],
+  }, async () => {
+    const [elPhoneNumbers, configs] = await Promise.all([
+      elevenlabsService.listPhoneNumbers(),
+      InboundCallConfig.find().populate('tenant_id', 'name'),
+    ]);
+
+    const configMap = new Map(
+      configs.map(c => [c.elevenlabs_phone_number_id, c]),
+    );
+
+    const phoneNumbers = elPhoneNumbers.map(pn => {
+      const config = configMap.get(pn.phoneNumberId);
+      return {
+        phoneNumberId: pn.phoneNumberId,
+        phoneNumber: pn.phoneNumber,
+        label: pn.label,
+        provider: pn.provider,
+        assignedAgent: pn.assignedAgent || null,
+        localConfig: config
+          ? {
+              _id: config._id,
+              tenant_id: config.tenant_id,
+              elevenlabs_agent_id: config.elevenlabs_agent_id,
+              schedule_enabled: config.schedule_enabled,
+              schedule: config.schedule,
+              agent_assigned: config.agent_assigned,
+            }
+          : null,
+      };
+    });
+
+    return { phoneNumbers };
+  });
+
+  // POST /inbound-call/configs — Assign a phone number to a tenant (superadmin)
+  fastify.post('/configs', {
+    preHandler: [requireRole('superadmin')],
+  }, async (request, reply) => {
+    const { tenant_id, elevenlabs_phone_number_id, elevenlabs_agent_id } = request.body as {
+      tenant_id: string;
+      elevenlabs_phone_number_id: string;
+      elevenlabs_agent_id?: string;
+    };
+
+    if (!tenant_id || !elevenlabs_phone_number_id) {
+      return reply.status(400).send({ error: 'tenant_id and elevenlabs_phone_number_id required' });
+    }
+
+    // Validate tenant exists
+    const tenant = await Tenant.findById(tenant_id);
+    if (!tenant) {
+      return reply.status(404).send({ error: 'Tenant not found' });
+    }
+
+    // Check uniqueness
+    const existing = await InboundCallConfig.findOne({ elevenlabs_phone_number_id });
+    if (existing) {
+      return reply.status(409).send({ error: 'Phone number already assigned to a tenant' });
+    }
+
+    // Fetch phone number details from ElevenLabs
+    const elPhone = await elevenlabsService.getPhoneNumber(elevenlabs_phone_number_id);
+
+    const config = await InboundCallConfig.create({
+      tenant_id,
+      elevenlabs_phone_number_id,
+      elevenlabs_agent_id: elevenlabs_agent_id || elPhone.assignedAgent?.agentId || '',
+      phone_number: elPhone.phoneNumber,
+      label: elPhone.label || '',
+      schedule_enabled: false,
+      schedule: [],
+      agent_assigned: !!elPhone.assignedAgent,
+    });
+
+    return reply.status(201).send({ config });
+  });
+
+  // DELETE /inbound-call/configs/:id — Remove phone number assignment (superadmin)
+  fastify.delete<{ Params: { id: string } }>('/configs/:id', {
+    preHandler: [requireRole('superadmin')],
+  }, async (request, reply) => {
+    const config = await InboundCallConfig.findById(request.params.id);
+    if (!config) {
+      return reply.status(404).send({ error: 'Config not found' });
+    }
+
+    // If agent is currently assigned, unassign it first
+    if (config.agent_assigned) {
+      try {
+        await elevenlabsService.updatePhoneNumber(config.elevenlabs_phone_number_id, { agentId: '' });
+      } catch {
+        // Log but proceed with deletion
+      }
+    }
+
+    await config.deleteOne();
+    return { success: true };
+  });
+
+  // PUT /inbound-call/configs/:id/admin-agent — Change agent (superadmin)
+  fastify.put<{ Params: { id: string } }>('/configs/:id/admin-agent', {
+    preHandler: [requireRole('superadmin')],
+  }, async (request, reply) => {
+    const config = await InboundCallConfig.findById(request.params.id);
+    if (!config) {
+      return reply.status(404).send({ error: 'Config not found' });
+    }
+
+    const { elevenlabs_agent_id } = request.body as { elevenlabs_agent_id: string };
+    if (!elevenlabs_agent_id) {
+      return reply.status(400).send({ error: 'elevenlabs_agent_id required' });
+    }
+
+    config.elevenlabs_agent_id = elevenlabs_agent_id;
+    await config.save();
+
+    // If agent is currently assigned, update on ElevenLabs immediately
+    if (config.agent_assigned) {
+      await elevenlabsService.updatePhoneNumber(config.elevenlabs_phone_number_id, {
+        agentId: elevenlabs_agent_id,
+      });
+    }
+
+    return { config };
+  });
+
+  // PUT /inbound-call/configs/:id/admin-schedule — Update schedule (superadmin, no feature/ownership check)
+  fastify.put<{ Params: { id: string } }>('/configs/:id/admin-schedule', {
+    preHandler: [requireRole('superadmin')],
+  }, async (request, reply) => {
+    const config = await InboundCallConfig.findById(request.params.id);
+    if (!config) {
+      return reply.status(404).send({ error: 'Config not found' });
+    }
+
+    const { schedule_enabled, schedule } = request.body as {
+      schedule_enabled?: boolean;
+      schedule?: Array<{ day: number; start: string; end: string }>;
+    };
+
+    if (schedule_enabled !== undefined) {
+      config.schedule_enabled = !!schedule_enabled;
+    }
+
+    if (schedule !== undefined) {
+      if (!Array.isArray(schedule)) {
+        return reply.status(400).send({ error: 'schedule must be an array' });
+      }
+      for (const entry of schedule) {
+        if (typeof entry.day !== 'number' || entry.day < 0 || entry.day > 6) {
+          return reply.status(400).send({ error: 'Each schedule entry day must be 0-6' });
+        }
+        if (!/^\d{2}:\d{2}$/.test(entry.start) || !/^\d{2}:\d{2}$/.test(entry.end)) {
+          return reply.status(400).send({ error: 'start and end must be HH:MM format' });
+        }
+      }
+      config.schedule = schedule;
+    }
+
+    await config.save();
+    await inboundCallScheduleService.syncConfig(config._id.toString());
+    const updated = await InboundCallConfig.findById(config._id);
+    return { config: updated };
+  });
+
+  // POST /inbound-call/configs/:id/admin-toggle — Manual assign/unassign (superadmin)
+  fastify.post<{ Params: { id: string } }>('/configs/:id/admin-toggle', {
+    preHandler: [requireRole('superadmin')],
+  }, async (request, reply) => {
+    const config = await InboundCallConfig.findById(request.params.id);
+    if (!config) {
+      return reply.status(404).send({ error: 'Config not found' });
+    }
+
+    const { assign } = request.body as { assign: boolean };
+
+    if (assign) {
+      await elevenlabsService.updatePhoneNumber(config.elevenlabs_phone_number_id, {
+        agentId: config.elevenlabs_agent_id,
+      });
+      config.agent_assigned = true;
+    } else {
+      await elevenlabsService.updatePhoneNumber(config.elevenlabs_phone_number_id, { agentId: '' });
+      config.agent_assigned = false;
+    }
+
+    await config.save();
+    return { config };
+  });
+
+  // ─── Tenant endpoints ─────────────────────────────────────
+
+  // GET /inbound-call/configs — List configs for current tenant
+  fastify.get('/configs', {
+    preHandler: [requireFeature('inbound_call_schedule'), requireRole('admin', 'manager', 'viewer')],
+  }, async (request) => {
+    const configs = await InboundCallConfig.find({ tenant_id: request.user.tenant_id });
+    return { configs };
+  });
+
+  // PUT /inbound-call/configs/:id/schedule — Update schedule for a config
+  fastify.put<{ Params: { id: string } }>('/configs/:id/schedule', {
+    preHandler: [requireFeature('inbound_call_schedule'), requireRole('admin')],
+  }, async (request, reply) => {
+    const config = await InboundCallConfig.findById(request.params.id);
+    if (!config) {
+      return reply.status(404).send({ error: 'Config not found' });
+    }
+
+    // Verify ownership
+    if (config.tenant_id.toString() !== request.user.tenant_id.toString()) {
+      return reply.status(403).send({ error: 'Not your config' });
+    }
+
+    const { schedule_enabled, schedule } = request.body as {
+      schedule_enabled?: boolean;
+      schedule?: Array<{ day: number; start: string; end: string }>;
+    };
+
+    if (schedule_enabled !== undefined) {
+      config.schedule_enabled = !!schedule_enabled;
+    }
+
+    if (schedule !== undefined) {
+      // Validate schedule entries
+      if (!Array.isArray(schedule)) {
+        return reply.status(400).send({ error: 'schedule must be an array' });
+      }
+      for (const entry of schedule) {
+        if (typeof entry.day !== 'number' || entry.day < 0 || entry.day > 6) {
+          return reply.status(400).send({ error: 'Each schedule entry day must be 0-6' });
+        }
+        if (!/^\d{2}:\d{2}$/.test(entry.start) || !/^\d{2}:\d{2}$/.test(entry.end)) {
+          return reply.status(400).send({ error: 'start and end must be HH:MM format' });
+        }
+      }
+      config.schedule = schedule;
+    }
+
+    await config.save();
+    await inboundCallScheduleService.syncConfig(config._id.toString());
+    const updated = await InboundCallConfig.findById(config._id);
+    return { config: updated };
+  });
+
+  // POST /inbound-call/configs/:id/toggle-now — Manual assign/unassign
+  fastify.post<{ Params: { id: string } }>('/configs/:id/toggle-now', {
+    preHandler: [requireFeature('inbound_call_schedule'), requireRole('admin')],
+  }, async (request, reply) => {
+    const config = await InboundCallConfig.findById(request.params.id);
+    if (!config) {
+      return reply.status(404).send({ error: 'Config not found' });
+    }
+
+    if (config.tenant_id.toString() !== request.user.tenant_id.toString()) {
+      return reply.status(403).send({ error: 'Not your config' });
+    }
+
+    const { assign } = request.body as { assign: boolean };
+
+    if (assign) {
+      await elevenlabsService.updatePhoneNumber(config.elevenlabs_phone_number_id, {
+        agentId: config.elevenlabs_agent_id,
+      });
+      config.agent_assigned = true;
+    } else {
+      await elevenlabsService.updatePhoneNumber(config.elevenlabs_phone_number_id, { agentId: '' });
+      config.agent_assigned = false;
+    }
+
+    await config.save();
+    return { config };
+  });
+}

package/src/modules/leads/lead.model.ts

@@ -0,0 +1,40 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export type LeadSourceType = 'call' | 'whatsapp';
+export type LeadStatus = 'new' | 'contacted' | 'appointment_scheduled' | 'completed' | 'lost' | 'expired';
+
+export interface ILead extends Document {
+  tenant_id: mongoose.Types.ObjectId;
+  source_type: LeadSourceType;
+  source_id: mongoose.Types.ObjectId;
+  chat_id: mongoose.Types.ObjectId | null;
+  name: string | null;
+  phone: string;
+  service_of_interest: string | null;
+  channel: 'phone' | 'whatsapp';
+  lead_status: LeadStatus;
+  categories: string[];
+  summary: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const leadSchema = new Schema<ILead>({
+  tenant_id: { type: Schema.Types.ObjectId, ref: 'Tenant', required: true },
+  source_type: { type: String, enum: ['call', 'whatsapp'], required: true },
+  source_id: { type: Schema.Types.ObjectId, required: true },
+  chat_id: { type: Schema.Types.ObjectId, ref: 'WhatsAppChat', default: null },
+  name: { type: String, default: null },
+  phone: { type: String, required: true },
+  service_of_interest: { type: String, default: null },
+  channel: { type: String, enum: ['phone', 'whatsapp'], required: true },
+  lead_status: { type: String, enum: ['new', 'contacted', 'appointment_scheduled', 'completed', 'lost', 'expired'], default: 'new' },
+  categories: { type: [String], default: [] },
+  summary: { type: String, default: null },
+}, { timestamps: true });
+
+leadSchema.index({ tenant_id: 1, createdAt: -1 });
+leadSchema.index({ tenant_id: 1, lead_status: 1 });
+leadSchema.index({ source_type: 1, source_id: 1 }, { unique: true });
+
+export default mongoose.model<ILead>('Lead', leadSchema);