elevenlabs-webhook-nodejs 1.0.0

package/src/services/google-calendar.service.ts

@@ -0,0 +1,656 @@
+import crypto from 'crypto';
+import Tenant from '../modules/tenants/tenant.model';
+import config from '../config';
+import logger from '../utils/logger';
+
+// --- Types ---
+
+interface CachedToken {
+  token: string;
+  expiry: number;
+}
+
+interface CalendarListEntry {
+  id: string;
+  summary: string;
+  primary: boolean;
+}
+
+interface AvailableSlot {
+  start: string;       // "HH:MM"
+  end: string;         // "HH:MM"
+  iso_start: string;   // full ISO 8601
+  iso_end: string;
+}
+
+interface Reservation {
+  event_id: string;
+  summary: string;
+  start: string;
+  end: string;
+  all_day: boolean;
+}
+
+interface FreeBusySlot {
+  start: string;
+  end: string;
+}
+
+// --- Service ---
+
+class GoogleCalendarService {
+  private tokenCache = new Map<string, CachedToken>();
+  private refreshPromises = new Map<string, Promise<string>>();
+
+  // ─── Encryption ──────────────────────────────────────────
+
+  private encryptToken(plaintext: string): string {
+    const key = Buffer.from(config.google.tokenEncryptionKey, 'hex');
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    return Buffer.concat([iv, encrypted, authTag]).toString('base64');
+  }
+
+  private decryptToken(ciphertext: string): string {
+    const key = Buffer.from(config.google.tokenEncryptionKey, 'hex');
+    const buf = Buffer.from(ciphertext, 'base64');
+    const iv = buf.subarray(0, 12);
+    const authTag = buf.subarray(buf.length - 16);
+    const encrypted = buf.subarray(12, buf.length - 16);
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(authTag);
+    return decipher.update(encrypted) + decipher.final('utf8');
+  }
+
+  // ─── OAuth ───────────────────────────────────────────────
+
+  getAuthUrl(tenantId: string): string {
+    const hmac = crypto.createHmac('sha256', config.google.oauthStateSecret)
+      .update(tenantId).digest('hex');
+    const state = `${hmac}:${tenantId}`;
+
+    const params = new URLSearchParams({
+      client_id: config.google.clientId,
+      redirect_uri: config.google.callbackUrl,
+      response_type: 'code',
+      scope: 'https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/userinfo.email',
+      access_type: 'offline',
+      prompt: 'consent',
+      state,
+    });
+
+    return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+  }
+
+  validateState(state: string): string {
+    const colonIdx = state.indexOf(':');
+    if (colonIdx === -1) throw new Error('Invalid OAuth state');
+    const hmac = state.substring(0, colonIdx);
+    const tenantId = state.substring(colonIdx + 1);
+    const expected = crypto.createHmac('sha256', config.google.oauthStateSecret)
+      .update(tenantId).digest('hex');
+    if (!crypto.timingSafeEqual(Buffer.from(hmac, 'hex'), Buffer.from(expected, 'hex'))) {
+      throw new Error('Invalid OAuth state signature');
+    }
+    return tenantId;
+  }
+
+  async handleCallback(code: string, state: string): Promise<{ tenantId: string }> {
+    const tenantId = this.validateState(state);
+
+    // Exchange code for tokens
+    const tokenRes = await fetch('https://oauth2.googleapis.com/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        code,
+        client_id: config.google.clientId,
+        client_secret: config.google.clientSecret,
+        redirect_uri: config.google.callbackUrl,
+        grant_type: 'authorization_code',
+      }),
+    });
+
+    if (!tokenRes.ok) {
+      const errBody = await tokenRes.text();
+      throw new Error(`Token exchange failed: ${errBody}`);
+    }
+
+    const tokens = await tokenRes.json() as {
+      access_token: string;
+      refresh_token: string;
+      expires_in: number;
+      id_token?: string;
+    };
+
+    if (!tokens.refresh_token) {
+      throw new Error('No refresh token received. User may need to revoke access and try again.');
+    }
+
+    // Get user email
+    const userInfoRes = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
+      headers: { Authorization: `Bearer ${tokens.access_token}` },
+    });
+    const userInfo = await userInfoRes.json() as { email?: string };
+    const email = userInfo.email || null;
+
+    // Encrypt and store
+    const encryptedRefresh = this.encryptToken(tokens.refresh_token);
+    const expiryDate = Date.now() + tokens.expires_in * 1000;
+
+    await Tenant.findByIdAndUpdate(tenantId, {
+      $set: {
+        'settings.whatsapp_agent.google_calendar.connected': true,
+        'settings.whatsapp_agent.google_calendar.google_email': email,
+        'settings.whatsapp_agent.google_calendar.encrypted_refresh_token': encryptedRefresh,
+        'settings.whatsapp_agent.google_calendar.connected_at': new Date(),
+      },
+    });
+
+    // Cache access token
+    this.tokenCache.set(tenantId, { token: tokens.access_token, expiry: expiryDate });
+
+    logger.info('Google Calendar connected', { tenantId, email });
+    return { tenantId };
+  }
+
+  async disconnect(tenantId: string): Promise<void> {
+    const tenant = await Tenant.findById(tenantId);
+    const encryptedToken = tenant?.settings?.whatsapp_agent?.google_calendar?.encrypted_refresh_token;
+
+    // Revoke token with Google
+    if (encryptedToken) {
+      try {
+        const refreshToken = this.decryptToken(encryptedToken);
+        await fetch(`https://oauth2.googleapis.com/revoke?token=${refreshToken}`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+      } catch (err) {
+        logger.warn('Token revocation failed (may already be invalid)', { error: (err as Error).message });
+      }
+    }
+
+    // Clear all google_calendar fields
+    await Tenant.findByIdAndUpdate(tenantId, {
+      $set: {
+        'settings.whatsapp_agent.google_calendar.connected': false,
+        'settings.whatsapp_agent.google_calendar.google_email': null,
+        'settings.whatsapp_agent.google_calendar.encrypted_refresh_token': null,
+        'settings.whatsapp_agent.google_calendar.calendar_id': null,
+        'settings.whatsapp_agent.google_calendar.calendar_name': null,
+        'settings.whatsapp_agent.google_calendar.connected_at': null,
+      },
+    });
+
+    this.tokenCache.delete(tenantId);
+    this.refreshPromises.delete(tenantId);
+    logger.info('Google Calendar disconnected', { tenantId });
+  }
+
+  // ─── Token Management ───────────────────────────────────
+
+  private async getValidAccessToken(tenantId: string): Promise<string> {
+    // Check cache
+    const cached = this.tokenCache.get(tenantId);
+    if (cached && cached.expiry > Date.now() + 60_000) {
+      return cached.token;
+    }
+
+    // Dedupe concurrent refresh requests
+    const existingPromise = this.refreshPromises.get(tenantId);
+    if (existingPromise) return existingPromise;
+
+    const refreshPromise = this.refreshAccessToken(tenantId);
+    this.refreshPromises.set(tenantId, refreshPromise);
+    try {
+      return await refreshPromise;
+    } finally {
+      this.refreshPromises.delete(tenantId);
+    }
+  }
+
+  private async refreshAccessToken(tenantId: string): Promise<string> {
+    const tenant = await Tenant.findById(tenantId);
+    const encryptedToken = tenant?.settings?.whatsapp_agent?.google_calendar?.encrypted_refresh_token;
+    if (!encryptedToken) throw new Error('No Google Calendar refresh token found');
+
+    const refreshToken = this.decryptToken(encryptedToken);
+
+    const res = await fetch('https://oauth2.googleapis.com/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        client_id: config.google.clientId,
+        client_secret: config.google.clientSecret,
+        refresh_token: refreshToken,
+        grant_type: 'refresh_token',
+      }),
+    });
+
+    if (!res.ok) {
+      const errBody = await res.text();
+      // If refresh fails due to revoked token, mark as disconnected
+      if (res.status === 400 || res.status === 401) {
+        await Tenant.findByIdAndUpdate(tenantId, {
+          $set: { 'settings.whatsapp_agent.google_calendar.connected': false },
+        });
+        this.tokenCache.delete(tenantId);
+      }
+      throw new Error(`Token refresh failed: ${errBody}`);
+    }
+
+    const data = await res.json() as { access_token: string; expires_in: number };
+    const expiry = Date.now() + data.expires_in * 1000;
+    this.tokenCache.set(tenantId, { token: data.access_token, expiry });
+    return data.access_token;
+  }
+
+  // ─── Calendar Operations ─────────────────────────────────
+
+  async listCalendars(tenantId: string): Promise<CalendarListEntry[]> {
+    const token = await this.getValidAccessToken(tenantId);
+    const res = await fetch('https://www.googleapis.com/calendar/v3/users/me/calendarList', {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) throw new Error(`Failed to list calendars: ${await res.text()}`);
+    const data = await res.json() as { items: Array<{ id: string; summary: string; primary?: boolean }> };
+    return (data.items || []).map(c => ({
+      id: c.id,
+      summary: c.summary,
+      primary: !!c.primary,
+    }));
+  }
+
+  async selectCalendar(tenantId: string, calendarId: string): Promise<void> {
+    // Validate calendar exists
+    const calendars = await this.listCalendars(tenantId);
+    const cal = calendars.find(c => c.id === calendarId);
+    if (!cal) throw new Error('Calendar not found in account');
+
+    await Tenant.findByIdAndUpdate(tenantId, {
+      $set: {
+        'settings.whatsapp_agent.google_calendar.calendar_id': calendarId,
+        'settings.whatsapp_agent.google_calendar.calendar_name': cal.summary,
+      },
+    });
+  }
+
+  async checkAvailability(tenantId: string, date: string): Promise<{ slots: AvailableSlot[]; message?: string }> {
+    const tenant = await Tenant.findById(tenantId).lean();
+    if (!tenant) throw new Error('Tenant not found');
+
+    const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+    if (!gcal?.connected || !gcal?.calendar_id) {
+      throw new Error('Google Calendar not configured');
+    }
+
+    const tz = gcal.timezone || 'Europe/Istanbul';
+    const durationMin = gcal.appointment_duration_minutes || 30;
+
+    // Check blocked dates
+    const isBlocked = (gcal.blocked_dates || []).some(bd => bd.date === date);
+    if (isBlocked) {
+      const blockedEntry = gcal.blocked_dates.find(bd => bd.date === date);
+      return {
+        slots: [],
+        message: blockedEntry?.reason
+          ? `Doktor bu tarihte müsait değil: ${blockedEntry.reason}`
+          : 'Doktor bu tarihte müsait değil',
+      };
+    }
+
+    // Get day-of-week for the date
+    const dateObj = new Date(date + 'T00:00:00');
+    const dayOfWeek = dateObj.getDay(); // 0=Sun
+
+    // Find working hours for this day
+    const workingHour = (gcal.working_hours || []).find(wh => wh.day === dayOfWeek);
+    if (!workingHour) {
+      return { slots: [], message: 'Bu gün klinik kapalı' };
+    }
+
+    // Build time range in the tenant's timezone
+    const dayStart = this.toISOWithTimezone(date, workingHour.start, tz);
+    const dayEnd = this.toISOWithTimezone(date, workingHour.end, tz);
+
+    // Query FreeBusy
+    const busySlots = await this.getFreeBusy(tenantId, gcal.calendar_id, dayStart, dayEnd);
+
+    // Generate available slots
+    const slots = this.generateAvailableSlots(
+      date, workingHour.start, workingHour.end, durationMin, busySlots, tz
+    );
+
+    return { slots };
+  }
+
+  async reserveSlot(tenantId: string, params: {
+    iso_start: string;
+    iso_end: string;
+    patient_name: string;
+    patient_phone: string;
+    notes?: string;
+    appointment_id?: string;
+  }): Promise<{ event_id: string; start: string; end: string }> {
+    const tenant = await Tenant.findById(tenantId).lean();
+    if (!tenant) throw new Error('Tenant not found');
+
+    const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+    if (!gcal?.connected || !gcal?.calendar_id) {
+      throw new Error('Google Calendar not configured');
+    }
+
+    // Re-check that the slot is still free
+    const busySlots = await this.getFreeBusy(tenantId, gcal.calendar_id, params.iso_start, params.iso_end);
+    if (busySlots.length > 0) {
+      throw new Error('Bu saat dilimi artık müsait değil. Lütfen başka bir saat seçin.');
+    }
+
+    // Create event
+    const token = await this.getValidAccessToken(tenantId);
+    const tz = gcal.timezone || 'Europe/Istanbul';
+
+    const detailUrl = params.appointment_id
+      ? `${config.google.frontendUrl}/appointments/${params.appointment_id}`
+      : null;
+
+    const descLines = [
+      `📋 Randevu Talebi — Asistan 7/24`,
+      ``,
+      `👤 Hasta: ${params.patient_name}`,
+      `📞 Telefon: ${params.patient_phone}`,
+      ...(params.notes ? [`📝 Not: ${params.notes}`] : []),
+      ``,
+      `⏱ Süre: ${gcal.appointment_duration_minutes || 30} dakika`,
+      `📅 Oluşturulma: ${new Date().toLocaleString('tr-TR', { timeZone: tz })}`,
+      ...(detailUrl ? [``, `🔗 Detay: ${detailUrl}`] : []),
+      ``,
+      `— Bu randevu Asistan 7/24 tarafından otomatik oluşturulmuştur.`,
+    ];
+
+    const event = {
+      summary: `Randevu Talebi - Asistan 7/24 | ${params.patient_name}`,
+      description: descLines.join('\n'),
+      colorId: '6',
+      start: { dateTime: params.iso_start, timeZone: tz },
+      end: { dateTime: params.iso_end, timeZone: tz },
+      extendedProperties: {
+        private: {
+          source: 'portal-asistan',
+          patient_phone: params.patient_phone,
+        },
+      },
+    };
+
+    const res = await fetch(
+      `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(gcal.calendar_id)}/events`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(event),
+      },
+    );
+
+    if (!res.ok) throw new Error(`Failed to create event: ${await res.text()}`);
+
+    const created = await res.json() as { id: string; start: { dateTime: string }; end: { dateTime: string } };
+
+    logger.info('Calendar slot reserved', {
+      tenantId,
+      eventId: created.id,
+      patientPhone: params.patient_phone,
+    });
+
+    return {
+      event_id: created.id,
+      start: created.start.dateTime,
+      end: created.end.dateTime,
+    };
+  }
+
+  async listReservations(tenantId: string, patientPhone: string): Promise<Reservation[]> {
+    const tenant = await Tenant.findById(tenantId).lean();
+    if (!tenant) throw new Error('Tenant not found');
+
+    const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+    if (!gcal?.connected || !gcal?.calendar_id) {
+      throw new Error('Google Calendar not configured');
+    }
+
+    const token = await this.getValidAccessToken(tenantId);
+    const now = new Date().toISOString();
+
+    const params = new URLSearchParams({
+      timeMin: now,
+      singleEvents: 'true',
+      orderBy: 'startTime',
+      maxResults: '20',
+      privateExtendedProperty: `source=portal-asistan`,
+    });
+
+    const res = await fetch(
+      `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(gcal.calendar_id)}/events?${params}`,
+      { headers: { Authorization: `Bearer ${token}` } },
+    );
+
+    if (!res.ok) throw new Error(`Failed to list events: ${await res.text()}`);
+
+    const data = await res.json() as {
+      items: Array<{
+        id: string;
+        summary: string;
+        start: { dateTime?: string; date?: string };
+        end: { dateTime?: string; date?: string };
+        extendedProperties?: { private?: Record<string, string> };
+      }>;
+    };
+
+    // Filter by patient phone
+    return (data.items || [])
+      .filter(ev => ev.extendedProperties?.private?.patient_phone === patientPhone)
+      .map(ev => ({
+        event_id: ev.id,
+        summary: ev.summary,
+        start: ev.start.dateTime || ev.start.date!,
+        end: ev.end.dateTime || ev.end.date!,
+        all_day: !ev.start.dateTime,
+      }));
+  }
+
+  async cancelReservation(tenantId: string, eventId: string, patientPhone: string): Promise<boolean> {
+    const tenant = await Tenant.findById(tenantId).lean();
+    if (!tenant) throw new Error('Tenant not found');
+
+    const gcal = tenant.settings?.whatsapp_agent?.google_calendar;
+    if (!gcal?.connected || !gcal?.calendar_id) {
+      throw new Error('Google Calendar not configured');
+    }
+
+    const token = await this.getValidAccessToken(tenantId);
+    const calId = encodeURIComponent(gcal.calendar_id);
+
+    // Get event to verify ownership
+    const getRes = await fetch(
+      `https://www.googleapis.com/calendar/v3/calendars/${calId}/events/${encodeURIComponent(eventId)}`,
+      { headers: { Authorization: `Bearer ${token}` } },
+    );
+
+    if (!getRes.ok) {
+      if (getRes.status === 404) throw new Error('Randevu bulunamadı');
+      throw new Error(`Failed to get event: ${await getRes.text()}`);
+    }
+
+    const event = await getRes.json() as {
+      extendedProperties?: { private?: Record<string, string> };
+      start?: { dateTime?: string; date?: string };
+    };
+
+    // Verify ownership
+    if (event.extendedProperties?.private?.patient_phone !== patientPhone) {
+      throw new Error('Bu randevuyu iptal etme yetkiniz yok');
+    }
+
+    // Check event is in the future
+    const eventStart = event.start?.dateTime || event.start?.date;
+    if (eventStart && new Date(eventStart) < new Date()) {
+      throw new Error('Geçmiş randevular iptal edilemez');
+    }
+
+    // Delete
+    const delRes = await fetch(
+      `https://www.googleapis.com/calendar/v3/calendars/${calId}/events/${encodeURIComponent(eventId)}`,
+      { method: 'DELETE', headers: { Authorization: `Bearer ${token}` } },
+    );
+
+    if (!delRes.ok && delRes.status !== 204) {
+      throw new Error(`Failed to delete event: ${await delRes.text()}`);
+    }
+
+    logger.info('Calendar reservation cancelled', { tenantId, eventId, patientPhone });
+    return true;
+  }
+
+  // ─── Helpers ─────────────────────────────────────────────
+
+  private async getFreeBusy(
+    tenantId: string,
+    calendarId: string,
+    timeMin: string,
+    timeMax: string,
+  ): Promise<FreeBusySlot[]> {
+    const token = await this.getValidAccessToken(tenantId);
+
+    const res = await fetch('https://www.googleapis.com/calendar/v3/freeBusy', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        timeMin,
+        timeMax,
+        items: [{ id: calendarId }],
+      }),
+    });
+
+    if (!res.ok) throw new Error(`FreeBusy query failed: ${await res.text()}`);
+
+    const data = await res.json() as {
+      calendars: Record<string, { busy: Array<{ start: string; end: string }> }>;
+    };
+
+    return data.calendars?.[calendarId]?.busy || [];
+  }
+
+  private toISOWithTimezone(date: string, time: string, tz: string): string {
+    // Get UTC offset for the timezone on the given date
+    const dt = new Date(`${date}T${time}:00`);
+    const formatter = new Intl.DateTimeFormat('en-US', {
+      timeZone: tz,
+      timeZoneName: 'shortOffset',
+    });
+    const parts = formatter.formatToParts(dt);
+    const offsetPart = parts.find(p => p.type === 'timeZoneName');
+    const offsetStr = offsetPart?.value || '+03';
+
+    // Parse offset like "GMT+3" or "GMT+5:30" to "+03:00" format
+    const match = offsetStr.match(/GMT([+-])(\d{1,2})(?::(\d{2}))?/);
+    if (match) {
+      const sign = match[1];
+      const hours = match[2].padStart(2, '0');
+      const minutes = match[3] || '00';
+      return `${date}T${time}:00${sign}${hours}:${minutes}`;
+    }
+
+    // Fallback: Turkey is always UTC+3
+    return `${date}T${time}:00+03:00`;
+  }
+
+  private generateAvailableSlots(
+    date: string,
+    workStart: string,
+    workEnd: string,
+    durationMin: number,
+    busySlots: FreeBusySlot[],
+    tz: string,
+  ): AvailableSlot[] {
+    const slots: AvailableSlot[] = [];
+
+    // Parse working hours to minutes since midnight
+    const [startH, startM] = workStart.split(':').map(Number);
+    const [endH, endM] = workEnd.split(':').map(Number);
+    const workStartMin = startH * 60 + startM;
+    const workEndMin = endH * 60 + endM;
+
+    // Convert busy slots to minute ranges
+    const busyRanges = busySlots.map(b => {
+      const bStart = new Date(b.start);
+      const bEnd = new Date(b.end);
+      // Get time in tenant's timezone
+      const bStartLocal = this.getLocalMinutes(bStart, tz);
+      const bEndLocal = this.getLocalMinutes(bEnd, tz);
+      return { start: bStartLocal, end: bEndLocal };
+    });
+
+    // Filter out past slots if checking today
+    const now = new Date();
+    const nowLocal = this.getLocalMinutes(now, tz);
+    const todayStr = this.getLocalDateString(now, tz);
+    const isToday = date === todayStr;
+
+    // Generate slots
+    for (let slotStart = workStartMin; slotStart + durationMin <= workEndMin; slotStart += durationMin) {
+      const slotEnd = slotStart + durationMin;
+
+      // Skip past slots
+      if (isToday && slotStart < nowLocal) continue;
+
+      // Check overlap with busy periods
+      const overlaps = busyRanges.some(b => slotStart < b.end && slotEnd > b.start);
+      if (overlaps) continue;
+
+      const startTime = this.minutesToTime(slotStart);
+      const endTime = this.minutesToTime(slotEnd);
+
+      slots.push({
+        start: startTime,
+        end: endTime,
+        iso_start: this.toISOWithTimezone(date, startTime, tz),
+        iso_end: this.toISOWithTimezone(date, endTime, tz),
+      });
+    }
+
+    return slots;
+  }
+
+  private getLocalMinutes(date: Date, tz: string): number {
+    const parts = new Intl.DateTimeFormat('en-US', {
+      timeZone: tz,
+      hour: 'numeric',
+      minute: 'numeric',
+      hour12: false,
+    }).formatToParts(date);
+    const hour = parseInt(parts.find(p => p.type === 'hour')?.value || '0', 10);
+    const minute = parseInt(parts.find(p => p.type === 'minute')?.value || '0', 10);
+    return hour * 60 + minute;
+  }
+
+  private getLocalDateString(date: Date, tz: string): string {
+    const parts = new Intl.DateTimeFormat('en-CA', { timeZone: tz }).format(date);
+    return parts; // "YYYY-MM-DD" format from en-CA locale
+  }
+
+  private minutesToTime(minutes: number): string {
+    const h = Math.floor(minutes / 60).toString().padStart(2, '0');
+    const m = (minutes % 60).toString().padStart(2, '0');
+    return `${h}:${m}`;
+  }
+}
+
+export default new GoogleCalendarService();