elevenlabs-webhook-nodejs 1.0.0

package/src/modules/calls/call.routes.ts

@@ -0,0 +1,118 @@
+import mongoose from 'mongoose';
+import { FastifyInstance } from 'fastify';
+import Call from './call.model';
+import { requireRole } from '../../plugins/rbac';
+
+export default async function callRoutes(fastify: FastifyInstance): Promise<void> {
+  fastify.addHook('preHandler', fastify.authenticate);
+
+  // GET /calls — paginated, filterable
+  fastify.get<{
+    Querystring: {
+      page?: string;
+      limit?: string;
+      direction?: string;
+      status?: string;
+      agent_id?: string;
+      from?: string;
+      to?: string;
+    };
+  }>('/', {
+    preHandler: [requireRole('admin', 'manager', 'viewer')]
+  }, async (request) => {
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = Math.min(parseInt(request.query.limit || '20', 10), 100);
+    const skip = (page - 1) * limit;
+
+    const filter: Record<string, unknown> = {
+      tenant_id: request.user.tenant_id
+    };
+
+    if (request.query.direction) {
+      filter.direction = request.query.direction;
+    }
+    if (request.query.status) {
+      filter.status = request.query.status;
+    }
+    if (request.query.agent_id) {
+      filter.agent_id = request.query.agent_id;
+    }
+    if (request.query.from || request.query.to) {
+      const dateFilter: Record<string, Date> = {};
+      if (request.query.from) dateFilter.$gte = new Date(request.query.from);
+      if (request.query.to) dateFilter.$lte = new Date(request.query.to);
+      filter.createdAt = dateFilter;
+    }
+
+    const [calls, total] = await Promise.all([
+      Call.find(filter)
+        .select('-transcript -conversation_id -elevenlabs_status -cost -analysis')
+        .sort({ createdAt: -1 })
+        .skip(skip)
+        .limit(limit)
+        .populate('agent_id', 'phone_number agent_template'),
+      Call.countDocuments(filter)
+    ]);
+
+    return {
+      calls,
+      total,
+      page,
+      totalPages: Math.ceil(total / limit)
+    };
+  });
+
+  // GET /calls/stats — aggregated statistics
+  fastify.get('/stats', {
+    preHandler: [requireRole('admin', 'manager', 'viewer')]
+  }, async (request) => {
+    const tenantId = request.user.tenant_id;
+
+    const [stats] = await Call.aggregate([
+      { $match: { tenant_id: new mongoose.Types.ObjectId(tenantId) } },
+      {
+        $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] } },
+          inbound: { $sum: { $cond: [{ $eq: ['$direction', 'inbound'] }, 1, 0] } },
+          outbound: { $sum: { $cond: [{ $eq: ['$direction', 'outbound'] }, 1, 0] } },
+          avg_duration: { $avg: '$duration_seconds' },
+          total_duration: { $sum: '$duration_seconds' }
+        }
+      }
+    ]);
+
+    return {
+      stats: stats || {
+        total: 0,
+        completed: 0,
+        failed: 0,
+        no_answer: 0,
+        inbound: 0,
+        outbound: 0,
+        avg_duration: 0,
+        total_duration: 0
+      }
+    };
+  });
+
+  // GET /calls/:id — call detail with transcript + summary + survey_responses
+  fastify.get('/:id', {
+    preHandler: [requireRole('admin', 'manager', 'viewer')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const call = await Call.findOne({ _id: id, tenant_id: request.user.tenant_id })
+      .select('-conversation_id -elevenlabs_status -cost -analysis')
+      .populate('agent_id', 'phone_number agent_template');
+
+    if (!call) {
+      return reply.status(404).send({ error: 'Call not found' });
+    }
+
+    return { call };
+  });
+}

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

@@ -0,0 +1,111 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+export type CampaignStatus = 'draft' | 'scheduled' | 'running' | 'paused' | 'completed';
+export type PhoneEntryStatus = 'pending' | 'completed' | 'failed' | 'no_answer' | 'voicemail';
+
+export interface IPhoneEntry {
+  number: string;
+  status: PhoneEntryStatus;
+  attempts: number;
+  last_attempt_at: Date | null;
+}
+
+export interface ICampaignSchedule {
+  start_date: Date;
+  end_date: Date;
+  daily_start_time: string;
+  daily_end_time: string;
+  days_of_week: number[];
+  max_concurrent_calls: number;
+  max_retries: number;
+  retry_delay_minutes: number;
+}
+
+export interface ICampaignStats {
+  total: number;
+  completed: number;
+  failed: number;
+  no_answer: number;
+  voicemail: number;
+  pending: number;
+}
+
+export interface ICampaign extends Document {
+  tenant_id: mongoose.Types.ObjectId;
+  survey_id: mongoose.Types.ObjectId;
+  agent_id: mongoose.Types.ObjectId;
+  name: string;
+  status: CampaignStatus;
+  phone_list: IPhoneEntry[];
+  schedule: ICampaignSchedule;
+  stats: ICampaignStats;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const phoneEntrySchema = new Schema<IPhoneEntry>({
+  number: { type: String, required: true },
+  status: {
+    type: String,
+    enum: ['pending', 'completed', 'failed', 'no_answer', 'voicemail'],
+    default: 'pending'
+  },
+  attempts: { type: Number, default: 0 },
+  last_attempt_at: { type: Date, default: null }
+}, { _id: false });
+
+const campaignScheduleSchema = new Schema<ICampaignSchedule>({
+  start_date: { type: Date, required: true },
+  end_date: { type: Date, required: true },
+  daily_start_time: { type: String, default: '09:00' },
+  daily_end_time: { type: String, default: '18:00' },
+  days_of_week: { type: [Number], default: [1, 2, 3, 4, 5] },
+  max_concurrent_calls: { type: Number, default: 1 },
+  max_retries: { type: Number, default: 3 },
+  retry_delay_minutes: { type: Number, default: 60 }
+}, { _id: false });
+
+const campaignStatsSchema = new Schema<ICampaignStats>({
+  total: { type: Number, default: 0 },
+  completed: { type: Number, default: 0 },
+  failed: { type: Number, default: 0 },
+  no_answer: { type: Number, default: 0 },
+  voicemail: { type: Number, default: 0 },
+  pending: { type: Number, default: 0 }
+}, { _id: false });
+
+const campaignSchema = new Schema<ICampaign>({
+  tenant_id: {
+    type: Schema.Types.ObjectId,
+    ref: 'Tenant',
+    required: true
+  },
+  survey_id: {
+    type: Schema.Types.ObjectId,
+    ref: 'Survey',
+    required: true
+  },
+  agent_id: {
+    type: Schema.Types.ObjectId,
+    ref: 'Agent',
+    required: true
+  },
+  name: { type: String, required: true },
+  status: {
+    type: String,
+    enum: ['draft', 'scheduled', 'running', 'paused', 'completed'],
+    default: 'draft'
+  },
+  phone_list: [phoneEntrySchema],
+  schedule: { type: campaignScheduleSchema, required: true },
+  stats: {
+    type: campaignStatsSchema,
+    default: () => ({ total: 0, completed: 0, failed: 0, no_answer: 0, voicemail: 0, pending: 0 })
+  }
+}, {
+  timestamps: true
+});
+
+campaignSchema.index({ tenant_id: 1, status: 1 });
+
+export default mongoose.model<ICampaign>('Campaign', campaignSchema);

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

@@ -0,0 +1,402 @@
+import { FastifyInstance } from 'fastify';
+import Campaign from './campaign.model';
+import Call from '../calls/call.model';
+import Survey from '../surveys/survey.model';
+import Agent from '../agents/agent.model';
+import { requireRole, requireFeature } from '../../plugins/rbac';
+import {
+  transitionStatus,
+  recalcStats,
+  aggregateStatsFromCalls,
+  parsePhoneListCSV
+} from './campaign.service';
+
+export default async function campaignRoutes(fastify: FastifyInstance): Promise<void> {
+  fastify.addHook('preHandler', fastify.authenticate);
+  fastify.addHook('preHandler', requireFeature('outbound_campaigns'));
+
+  // GET /campaigns
+  fastify.get<{
+    Querystring: { page?: string; status?: string };
+  }>('/', {
+    preHandler: [requireRole('admin', 'manager', 'viewer')]
+  }, async (request) => {
+    const page = parseInt(request.query.page || '1', 10);
+    const limit = 20;
+    const skip = (page - 1) * limit;
+
+    const filter: Record<string, unknown> = { tenant_id: request.user.tenant_id };
+    if (request.query.status) filter.status = request.query.status;
+
+    const [campaigns, total] = await Promise.all([
+      Campaign.find(filter)
+        .select('-phone_list')
+        .sort({ createdAt: -1 })
+        .skip(skip)
+        .limit(limit)
+        .populate('survey_id', 'name status')
+        .populate('agent_id', 'phone_number agent_template'),
+      Campaign.countDocuments(filter)
+    ]);
+
+    return { campaigns, total, page, totalPages: Math.ceil(total / limit) };
+  });
+
+  // POST /campaigns
+  fastify.post('/', {
+    preHandler: [requireRole('admin', 'manager')]
+  }, async (request, reply) => {
+    const { name, survey_id, agent_id, schedule } = request.body as {
+      name: string;
+      survey_id: string;
+      agent_id: string;
+      schedule: {
+        start_date: string;
+        end_date: string;
+        daily_start_time?: string;
+        daily_end_time?: string;
+        days_of_week?: number[];
+        max_concurrent_calls?: number;
+        max_retries?: number;
+        retry_delay_minutes?: number;
+      };
+    };
+
+    if (!name || !survey_id || !agent_id || !schedule) {
+      return reply.status(400).send({ error: 'name, survey_id, agent_id, and schedule are required' });
+    }
+
+    // Verify survey belongs to tenant
+    const survey = await Survey.findOne({ _id: survey_id, tenant_id: request.user.tenant_id });
+    if (!survey) {
+      return reply.status(404).send({ error: 'Survey not found' });
+    }
+
+    // Verify agent belongs to tenant
+    const agent = await Agent.findOne({ _id: agent_id, tenant_id: request.user.tenant_id });
+    if (!agent) {
+      return reply.status(404).send({ error: 'Agent not found' });
+    }
+
+    const campaign = await Campaign.create({
+      tenant_id: request.user.tenant_id,
+      survey_id,
+      agent_id,
+      name,
+      status: 'draft',
+      phone_list: [],
+      schedule: {
+        start_date: new Date(schedule.start_date),
+        end_date: new Date(schedule.end_date),
+        daily_start_time: schedule.daily_start_time || '09:00',
+        daily_end_time: schedule.daily_end_time || '18:00',
+        days_of_week: schedule.days_of_week || [1, 2, 3, 4, 5],
+        max_concurrent_calls: schedule.max_concurrent_calls || 1,
+        max_retries: schedule.max_retries || 3,
+        retry_delay_minutes: schedule.retry_delay_minutes || 60
+      },
+      stats: { total: 0, completed: 0, failed: 0, no_answer: 0, voicemail: 0, pending: 0 }
+    });
+
+    return reply.status(201).send({ campaign });
+  });
+
+  // GET /campaigns/:id
+  fastify.get('/:id', {
+    preHandler: [requireRole('admin', 'manager', 'viewer')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const campaign = await Campaign.findOne({ _id: id, tenant_id: request.user.tenant_id })
+      .populate('survey_id', 'name status questions')
+      .populate('agent_id', 'phone_number agent_template');
+
+    if (!campaign) {
+      return reply.status(404).send({ error: 'Campaign not found' });
+    }
+
+    return { campaign };
+  });
+
+  // PUT /campaigns/:id — update config (only in draft/scheduled)
+  fastify.put('/:id', {
+    preHandler: [requireRole('admin', 'manager')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const body = request.body as {
+      name?: string;
+      schedule?: Record<string, unknown>;
+    };
+
+    const campaign = await Campaign.findOne({ _id: id, tenant_id: request.user.tenant_id });
+    if (!campaign) {
+      return reply.status(404).send({ error: 'Campaign not found' });
+    }
+
+    if (!['draft', 'scheduled'].includes(campaign.status)) {
+      return reply.status(400).send({ error: 'Can only edit campaigns in draft or scheduled status' });
+    }
+
+    if (body.name) campaign.name = body.name;
+    if (body.schedule) {
+      Object.assign(campaign.schedule, body.schedule);
+    }
+
+    await campaign.save();
+    return { campaign };
+  });
+
+  // --- State Machine Actions ---
+
+  // POST /campaigns/:id/start — draft→scheduled→running or scheduled→running
+  fastify.post('/:id/start', {
+    preHandler: [requireRole('admin', 'manager')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const campaign = await Campaign.findOne({ _id: id, tenant_id: request.user.tenant_id });
+    if (!campaign) {
+      return reply.status(404).send({ error: 'Campaign not found' });
+    }
+
+    if (campaign.phone_list.length === 0) {
+      return reply.status(400).send({ error: 'Cannot start campaign with empty phone list' });
+    }
+
+    try {
+      // draft → scheduled → running (shortcut)
+      if (campaign.status === 'draft') {
+        await transitionStatus(campaign, 'scheduled');
+      }
+      await transitionStatus(campaign, 'running');
+    } catch (error) {
+      const err = error as { message: string; statusCode?: number };
+      return reply.status(err.statusCode || 400).send({ error: err.message });
+    }
+
+    return { campaign };
+  });
+
+  // POST /campaigns/:id/pause
+  fastify.post('/:id/pause', {
+    preHandler: [requireRole('admin', 'manager')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const campaign = await Campaign.findOne({ _id: id, tenant_id: request.user.tenant_id });
+    if (!campaign) {
+      return reply.status(404).send({ error: 'Campaign not found' });
+    }
+
+    try {
+      await transitionStatus(campaign, 'paused');
+    } catch (error) {
+      const err = error as { message: string; statusCode?: number };
+      return reply.status(err.statusCode || 400).send({ error: err.message });
+    }
+
+    return { campaign };
+  });
+
+  // POST /campaigns/:id/resume
+  fastify.post('/:id/resume', {
+    preHandler: [requireRole('admin', 'manager')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const campaign = await Campaign.findOne({ _id: id, tenant_id: request.user.tenant_id });
+    if (!campaign) {
+      return reply.status(404).send({ error: 'Campaign not found' });
+    }
+
+    try {
+      await transitionStatus(campaign, 'running');
+    } catch (error) {
+      const err = error as { message: string; statusCode?: number };
+      return reply.status(err.statusCode || 400).send({ error: err.message });
+    }
+
+    return { campaign };
+  });
+
+  // POST /campaigns/:id/stop — permanently complete
+  fastify.post('/:id/stop', {
+    preHandler: [requireRole('admin', 'manager')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const campaign = await Campaign.findOne({ _id: id, tenant_id: request.user.tenant_id });
+    if (!campaign) {
+      return reply.status(404).send({ error: 'Campaign not found' });
+    }
+
+    if (campaign.status === 'completed') {
+      return reply.status(400).send({ error: 'Campaign is already completed' });
+    }
+
+    campaign.status = 'completed';
+    await campaign.save();
+
+    return { campaign };
+  });
+
+  // --- Phone List ---
+
+  // POST /campaigns/:id/phone-list — upload CSV or JSON array
+  fastify.post('/:id/phone-list', {
+    preHandler: [requireRole('admin', 'manager')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const campaign = await Campaign.findOne({ _id: id, tenant_id: request.user.tenant_id });
+    if (!campaign) {
+      return reply.status(404).send({ error: 'Campaign not found' });
+    }
+
+    if (!['draft', 'scheduled'].includes(campaign.status)) {
+      return reply.status(400).send({ error: 'Can only modify phone list in draft or scheduled status' });
+    }
+
+    const body = request.body as { numbers?: string[]; csv?: string };
+    let numbers: string[] = [];
+
+    if (body.csv) {
+      numbers = parsePhoneListCSV(body.csv);
+    } else if (body.numbers && Array.isArray(body.numbers)) {
+      numbers = body.numbers.map(n => n.trim()).filter(n => n.length >= 10);
+    } else {
+      return reply.status(400).send({ error: 'Provide either "numbers" array or "csv" string' });
+    }
+
+    if (numbers.length === 0) {
+      return reply.status(400).send({ error: 'No valid phone numbers found' });
+    }
+
+    campaign.phone_list = numbers.map(number => ({
+      number,
+      status: 'pending' as const,
+      attempts: 0,
+      last_attempt_at: null
+    }));
+
+    recalcStats(campaign);
+    await campaign.save();
+
+    return {
+      campaign: {
+        id: campaign._id,
+        phone_count: campaign.phone_list.length,
+        stats: campaign.stats
+      }
+    };
+  });
+
+  // --- Results ---
+
+  // GET /campaigns/:id/results — structured survey responses
+  fastify.get('/:id/results', {
+    preHandler: [requireRole('admin', 'manager', 'viewer')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const campaign = await Campaign.findOne({ _id: id, tenant_id: request.user.tenant_id });
+    if (!campaign) {
+      return reply.status(404).send({ error: 'Campaign not found' });
+    }
+
+    // Refresh stats from actual calls
+    const callStats = await aggregateStatsFromCalls(id);
+
+    const calls = await Call.find({ campaign_id: id })
+      .select('caller_number status duration_seconds survey_responses llm_summary createdAt')
+      .sort({ createdAt: -1 });
+
+    return {
+      campaign: {
+        id: campaign._id,
+        name: campaign.name,
+        status: campaign.status,
+        stats: campaign.stats,
+        call_stats: callStats
+      },
+      results: calls.map(c => ({
+        call_id: c._id,
+        caller_number: c.caller_number,
+        status: c.status,
+        duration_seconds: c.duration_seconds,
+        survey_responses: c.survey_responses,
+        llm_summary: c.llm_summary,
+        createdAt: c.createdAt
+      }))
+    };
+  });
+
+  // GET /campaigns/:id/results/export — CSV export
+  fastify.get('/:id/results/export', {
+    preHandler: [requireRole('admin', 'manager', 'viewer')]
+  }, async (request, reply) => {
+    const { id } = request.params as { id: string };
+
+    const campaign = await Campaign.findOne({ _id: id, tenant_id: request.user.tenant_id })
+      .populate('survey_id', 'questions');
+    if (!campaign) {
+      return reply.status(404).send({ error: 'Campaign not found' });
+    }
+
+    const calls = await Call.find({ campaign_id: id })
+      .select('caller_number status duration_seconds survey_responses llm_summary createdAt')
+      .sort({ createdAt: 1 });
+
+    // Build CSV header
+    const survey = campaign.survey_id as unknown as { questions: { id: string; text: string }[] };
+    const questionIds = survey?.questions?.map(q => q.id) || [];
+    const questionTexts = survey?.questions?.map(q => q.text) || [];
+
+    const headerCols = [
+      'phone_number',
+      'status',
+      'duration_seconds',
+      'date',
+      ...questionIds,
+      'summary'
+    ];
+
+    const headerDisplay = [
+      'Telefon',
+      'Durum',
+      'Sure (sn)',
+      'Tarih',
+      ...questionTexts,
+      'Ozet'
+    ];
+
+    const rows = calls.map(call => {
+      const responseMap = new Map(
+        (call.survey_responses || []).map(r => [r.question_id, r.answer])
+      );
+
+      return [
+        call.caller_number,
+        call.status,
+        String(call.duration_seconds),
+        call.createdAt.toISOString(),
+        ...questionIds.map(qid => escapeCSV(responseMap.get(qid) || '')),
+        escapeCSV(call.llm_summary || '')
+      ].join(',');
+    });
+
+    const csv = [headerDisplay.join(','), ...rows].join('\n');
+
+    reply
+      .header('Content-Type', 'text/csv; charset=utf-8')
+      .header('Content-Disposition', `attachment; filename="campaign-${id}-results.csv"`)
+      .send(csv);
+  });
+}
+
+function escapeCSV(value: string): string {
+  if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}