@campxdev/campx-web-utils 2.0.13 → 2.0.14

package/src/services/crypto/CryptoService.ts

@@ -0,0 +1,112 @@
+import { syncScrypt } from 'scrypt-js'
+
+class CryptoService {
+  private static instance: CryptoService
+  private readonly algorithm = 'aes-256-cbc'
+  private secretKey: Uint8Array | null = null
+  private initialized = false
+
+  private constructor() {
+    // Lazy initialization - don't run heavy crypto operations at module load time
+  }
+
+  private ensureInitialized(): void {
+    if (this.initialized) return
+
+    try {
+      const key = '431fef99-47dc-4d2a-9175-2e8f19b20225'
+      if (key) {
+        // Same as backend: crypto.scryptSync(key, 'salt', 32)
+        // scrypt-js with N=16384, r=8, p=1 matches Node.js defaults
+        const keyBuffer = new TextEncoder().encode(key)
+        const saltBuffer = new TextEncoder().encode('salt')
+        this.secretKey = syncScrypt(keyBuffer, saltBuffer, 16384, 8, 1, 32)
+      }
+      this.initialized = true
+    } catch (error) {
+      console.error('CryptoService initialization failed:', error)
+      this.initialized = true // Prevent repeated attempts
+    }
+  }
+
+  static getInstance(): CryptoService {
+    if (!CryptoService.instance) {
+      CryptoService.instance = new CryptoService()
+    }
+    return CryptoService.instance
+  }
+
+  /**
+   * Decrypt data using AES-256-CBC (same as backend)
+   * Format: "iv_hex:encrypted_hex"
+   */
+  decryptData(encryptedData: string): string {
+    this.ensureInitialized()
+
+    if (!encryptedData || !this.secretKey) {
+      console.error('Missing encrypted data or secret key')
+      return ''
+    }
+
+    try {
+      const [ivHex, encrypted] = encryptedData.split(':')
+      if (!ivHex || !encrypted) {
+        console.error('Invalid encrypted data format')
+        return ''
+      }
+
+      // Use require for crypto to avoid bundler issues with top-level imports
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const crypto = require('crypto')
+
+      const iv = Buffer.from(ivHex, 'hex')
+      const decipher = crypto.createDecipheriv(
+        this.algorithm,
+        Buffer.from(this.secretKey),
+        iv,
+      )
+
+      let decrypted = decipher.update(encrypted, 'hex', 'utf8')
+      decrypted += decipher.final('utf8')
+
+      return decrypted
+    } catch (error) {
+      console.error('Decryption failed:', error)
+      return ''
+    }
+  }
+
+  /**
+   * Mask mobile number for display (first 2 and last 2 of actual number visible)
+   * Handles country code prefix (+91)
+   * e.g., "+919876543210" -> "+9198******10"
+   * e.g., "9876543210" -> "98******10"
+   */
+  maskMobile(mobile: string): string {
+    if (!mobile || mobile.length < 4) return '**********'
+
+    // Check for country code prefix
+    let prefix = ''
+    let number = mobile
+
+    if (mobile.startsWith('+91')) {
+      prefix = '+91'
+      number = mobile.substring(3)
+    } else if (mobile.startsWith('91') && mobile.length > 10) {
+      prefix = '91'
+      number = mobile.substring(2)
+    }
+
+    const cleaned = number.replace(/\D/g, '')
+    if (cleaned.length < 4) return prefix + '**********'
+
+    return (
+      prefix +
+      cleaned.substring(0, 2) +
+      '*'.repeat(cleaned.length - 4) +
+      cleaned.substring(cleaned.length - 2)
+    )
+  }
+}
+
+export default CryptoService.getInstance()

package/src/services/exotel/ExotelService.ts

@@ -0,0 +1,238 @@
+import ExotelCRMWebSDK, {
+  CallEventData,
+  ExotelWebPhoneSDK,
+} from '@exotel-npm-dev/exotel-ip-calling-crm-websdk';
+
+export type PermissionStatus = 'granted' | 'denied' | 'prompt' | 'unknown';
+
+class ExotelService {
+  private static instance: ExotelService;
+  private exotelSDK: ExotelCRMWebSDK | null = null;
+  private webPhone: ExotelWebPhoneSDK | null = null;
+  private callListeners: Set<(event: string, data: CallEventData) => void> =
+    new Set();
+  private registerListeners: Set<(state: string) => void> = new Set();
+  private sessionListeners: Set<(state: string, data: any) => void> = new Set();
+  private permissionStatus: PermissionStatus = 'unknown';
+
+  public static getInstance(): ExotelService {
+    if (!ExotelService.instance) {
+      ExotelService.instance = new ExotelService();
+    }
+    return ExotelService.instance;
+  }
+
+  /**
+   * Initialize the Exotel SDK
+   * @param accessToken - The access token for authentication
+   * @param agentUserId - The user ID of the agent
+   * @param autoConnectVOIP - Whether to automatically connect VOIP (default: true)
+   * @returns boolean indicating success
+   */
+  public async initialize(
+    accessToken: string,
+    agentUserId: string,
+    autoConnectVOIP = true,
+  ): Promise<boolean> {
+    try {
+      await this.checkAudioPermissions();
+
+      this.exotelSDK = new ExotelCRMWebSDK(
+        accessToken,
+        agentUserId,
+        autoConnectVOIP,
+      );
+
+      const phone = await this.exotelSDK.Initialize(
+        this.handleCallEvent,
+        this.handleRegisterEvent,
+        this.handleSessionEvent,
+      );
+
+      this.webPhone = phone || null;
+
+      return !!this.webPhone;
+    } catch (error) {
+      console.error('Failed to initialize Exotel SDK:', error);
+      return false;
+    }
+  }
+
+  public async checkAudioPermissions(): Promise<boolean> {
+    try {
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      const hasAudioDevice = devices.some(
+        (device) => device.kind === 'audioinput',
+      );
+
+      if (!hasAudioDevice) {
+        console.error('No audio input devices found');
+        this.permissionStatus = 'denied';
+        return false;
+      }
+
+      if (navigator.permissions && navigator.permissions.query) {
+        try {
+          const permissionStatus = await navigator.permissions.query({
+            name: 'microphone' as PermissionName,
+          });
+          this.permissionStatus = permissionStatus.state as
+            | 'granted'
+            | 'denied'
+            | 'prompt';
+
+          permissionStatus.onchange = () => {
+            this.permissionStatus = permissionStatus.state as
+              | 'granted'
+              | 'denied'
+              | 'prompt';
+          };
+
+          return permissionStatus.state === 'granted';
+        } catch (error) {
+          console.warn('Could not query permission status:', error);
+        }
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Error checking audio permissions:', error);
+      return false;
+    }
+  }
+
+  public async requestMicrophoneAccess(): Promise<boolean> {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      stream.getTracks().forEach((track) => track.stop());
+      this.permissionStatus = 'granted';
+      return true;
+    } catch (error) {
+      console.error('Failed to get microphone access:', error);
+      this.permissionStatus = 'denied';
+      return false;
+    }
+  }
+
+  public makeCall(phoneNumber: string): Promise<any> {
+    return new Promise((resolve, reject) => {
+      if (!this.webPhone) {
+        reject(new Error('Web phone not initialized'));
+        return;
+      }
+
+      this.webPhone.MakeCall(phoneNumber, (status, data) => {
+        if (status === 'success') {
+          resolve(data);
+        } else {
+          reject(data);
+        }
+      });
+    });
+  }
+
+  public async acceptCall(): Promise<void> {
+    if (!this.webPhone) {
+      throw new Error('Web phone not initialized');
+    }
+
+    if (this.permissionStatus !== 'granted') {
+      const granted = await this.requestMicrophoneAccess();
+      if (!granted) {
+        throw new Error('Microphone access denied');
+      }
+    }
+
+    this.webPhone.AcceptCall();
+  }
+
+  public hangupCall(): void {
+    this.webPhone?.HangupCall();
+  }
+
+  /**
+   * Reject an incoming call before accepting it.
+   * Note: Exotel SDK only has HangupCall - no separate RejectCall method.
+   * HangupCall internally calls webrtcSIPPhone.rejectCall() -> phone.sipHangUp()
+   */
+  public rejectCall(): void {
+    this.webPhone?.HangupCall();
+  }
+
+  public toggleHold(): void {
+    this.webPhone?.ToggleHold();
+  }
+
+  public toggleMute(): void {
+    this.webPhone?.ToggleMute();
+  }
+
+  public sendDTMF(digit: string): void {
+    this.webPhone?.SendDTMF(digit);
+  }
+
+  public async registerDevice(): Promise<void> {
+    if (this.permissionStatus !== 'granted') {
+      const granted = await this.requestMicrophoneAccess();
+      if (!granted) {
+        throw new Error('Microphone access denied');
+      }
+    }
+
+    this.webPhone?.RegisterDevice();
+  }
+
+  public unregisterDevice(): void {
+    this.webPhone?.UnRegisterDevice();
+  }
+
+  public getPermissionStatus(): PermissionStatus {
+    return this.permissionStatus;
+  }
+
+  private handleCallEvent = (event: string, callData: CallEventData): void => {
+    this.callListeners.forEach((listener) => listener(event, callData));
+  };
+
+  private handleRegisterEvent = (state: string): void => {
+    this.registerListeners.forEach((listener) => listener(state));
+  };
+
+  private handleSessionEvent = (state: string, data: any): void => {
+    this.sessionListeners.forEach((listener) => listener(state, data));
+  };
+
+  public addCallListener(
+    listener: (event: string, data: CallEventData) => void,
+  ): void {
+    this.callListeners.add(listener);
+  }
+
+  public removeCallListener(
+    listener: (event: string, data: CallEventData) => void,
+  ): void {
+    this.callListeners.delete(listener);
+  }
+
+  public addRegisterListener(listener: (state: string) => void): void {
+    this.registerListeners.add(listener);
+  }
+
+  public removeRegisterListener(listener: (state: string) => void): void {
+    this.registerListeners.delete(listener);
+  }
+
+  public addSessionListener(
+    listener: (state: string, data: any) => void,
+  ): void {
+    this.sessionListeners.add(listener);
+  }
+
+  public removeSessionListener(
+    listener: (state: string, data: any) => void,
+  ): void {
+    this.sessionListeners.delete(listener);
+  }
+}
+
+export default ExotelService;

package/src/services/exotel/api.ts

@@ -0,0 +1,319 @@
+import { axios } from '../../config/axios'
+import { workspace } from '../../utils/constants'
+
+/**
+ * Voice config from notification-configs API
+ */
+export interface VoiceConfig {
+  id: string
+  isEnabled: boolean
+  name: string
+  channelType: string
+  EXOTEL?: {
+    appId: string
+    appSecret: string
+    token?: string
+    tokenExpiresAt?: string
+  }
+}
+
+/**
+ * Notification config response structure
+ */
+export interface NotificationConfigResponse {
+  config: {
+    id: string
+    tenantId: string
+    institutionUniqueId: number
+    enableVoice?: boolean
+    voiceConfigs?: VoiceConfig[]
+    // ... other fields not relevant to VoIP
+  }
+  options: {
+    voiceChannels?: string[]
+    // ... other fields
+  }
+}
+
+/**
+ * Check if VoIP is enabled for the current tenant by fetching notification config.
+ * Returns true only if:
+ * - enableVoice is true
+ * - voiceConfigs has at least one enabled config
+ */
+export const checkVoIPEnabled = async (): Promise<{
+  enabled: boolean
+  hasValidToken: boolean
+}> => {
+  try {
+    const { data } = await axios.get<NotificationConfigResponse>(
+      '/notifications/notification-configs',
+    )
+
+    const config = data?.config
+
+    // Check if voice is enabled at tenant level
+    if (!config?.enableVoice) {
+      return { enabled: false, hasValidToken: false }
+    }
+
+    // Check if there's at least one enabled voice config
+    const enabledVoiceConfig = config.voiceConfigs?.find(
+      (vc) => vc.isEnabled === true,
+    )
+
+    if (!enabledVoiceConfig) {
+      return { enabled: false, hasValidToken: false }
+    }
+
+    // Check if token exists and is not expired
+    const hasValidToken = !!(
+      enabledVoiceConfig.EXOTEL?.token &&
+      enabledVoiceConfig.EXOTEL?.tokenExpiresAt &&
+      new Date(enabledVoiceConfig.EXOTEL.tokenExpiresAt) > new Date()
+    )
+
+    return { enabled: true, hasValidToken }
+  } catch (error) {
+    console.error('Failed to check VoIP config:', error)
+    return { enabled: false, hasValidToken: false }
+  }
+}
+
+/**
+ * Get the active Exotel voice token from the backend.
+ * The backend manages credentials securely and auto-refreshes tokens.
+ */
+export const getActiveVoiceToken = async (): Promise<{
+  token: string
+  expiresAt: string
+} | null> => {
+  try {
+    const { data } = await axios.get(
+      '/notifications/notification-configs/voice-config/active-token',
+    )
+    return data
+  } catch (error) {
+    console.error('Failed to fetch Exotel token:', error)
+    return null
+  }
+}
+
+/**
+ * @deprecated Use getActiveVoiceToken instead.
+ * This function is kept for backwards compatibility but will be removed.
+ */
+export const createExotelAppToken = async () => {
+  const tokenData = await getActiveVoiceToken()
+  if (!tokenData) {
+    throw new Error('No active voice configuration found')
+  }
+  return { Data: tokenData.token }
+}
+
+// ============ Call Activity APIs ============
+
+export interface CallActivity {
+  id: string
+  callSid: string
+  prospectId: string
+  direction: 'inbound' | 'outbound'
+  status: string
+  durationSeconds?: number
+  createdAt: string
+  startTime?: string
+  endTime?: string
+  fromNumber?: string
+  toNumber?: string
+  userId?: number
+  dispositionCategory?: string
+  dispositionReason?: string
+  dispositionNotes?: string
+  callStatusDisposition?: 'connected' | 'not_connected'
+  recordingUrl?: string
+}
+
+export interface InitiateCallInput {
+  prospectId: string
+  toNumber: string
+  fromNumber?: string
+  userId?: number
+  callSid?: string // Exotel CallSid from SDK response
+}
+
+export interface SaveDispositionInput {
+  callId: string
+  prospectId?: string
+  callStatusDisposition?: 'connected' | 'not_connected'
+  dispositionCategory: string
+  dispositionReason?: string
+  dispositionNotes?: string
+  callbackScheduledAt?: string
+}
+
+export interface CancelCallInput {
+  callSid: string
+  reason?: string // 'declined' | 'cancelled' | 'missed' | 'timeout'
+}
+
+export interface CallActivityResponse {
+  success: boolean
+  message: string
+  data: CallActivity
+}
+
+export interface RegisterIncomingCallInput {
+  callSid: string
+  fromNumber: string
+  toNumber?: string
+  prospectId?: string
+  userId?: number
+}
+
+export interface RegisterIncomingCallResponse {
+  success: boolean
+  message: string
+  data: CallActivity
+  prospect?: {
+    id: string
+    uniqueId?: number
+    prospectId?: string // Formatted ID like PRSP-000001
+    name: string
+    mobile: string
+  }
+}
+
+/**
+ * Initiate an outbound call - creates call activity record
+ */
+export const initiateCallActivity = async (
+  input: InitiateCallInput,
+): Promise<{ success: boolean; message: string; data: CallActivity }> => {
+  const endpoint =
+    workspace === 'common-workspace'
+      ? `/paymentx/call-activities`
+      : `/call-activities`
+
+  const { data } = await axios.post(`${endpoint}/initiate`, input)
+  return data
+}
+
+/**
+ * Register an incoming call - creates call activity record
+ */
+export const registerIncomingCall = async (
+  input: RegisterIncomingCallInput,
+): Promise<RegisterIncomingCallResponse> => {
+  const endpoint =
+    workspace === 'common-workspace'
+      ? `/paymentx/call-activities`
+      : `/call-activities`
+
+  const { data } = await axios.post(`${endpoint}/register-incoming`, input)
+  return data
+}
+
+/**
+ * Fetch call history for a prospect
+ */
+export const fetchCallHistory = async (
+  prospectId: string,
+): Promise<CallActivity[]> => {
+  const endpoint =
+    workspace === 'common-workspace'
+      ? `/paymentx/call-activities`
+      : `/call-activities`
+
+  const { data } = await axios.get(`${endpoint}/by-prospect`, {
+    params: { prospectId },
+  })
+  return data
+}
+
+/**
+ * Get call activity by ID
+ */
+export const getCallActivityById = async (
+  id: string,
+): Promise<CallActivity> => {
+  const endpoint =
+    workspace === 'common-workspace'
+      ? `/paymentx/call-activities`
+      : `/call-activities`
+
+  const { data } = await axios.get(`${endpoint}/${id}`)
+  return data
+}
+
+/**
+ * Get call activity by CallSid
+ */
+export const getCallActivityByCallSid = async (
+  callSid: string,
+): Promise<CallActivity> => {
+  const endpoint =
+    workspace === 'common-workspace'
+      ? `/paymentx/call-activities`
+      : `/call-activities`
+
+  const { data } = await axios.get(`${endpoint}/by-call-sid`, {
+    params: { callSid },
+  })
+  return data
+}
+
+/**
+ * Get call count for a prospect
+ */
+export const getCallCountByProspect = async (
+  prospectId: string,
+): Promise<number> => {
+  const endpoint =
+    workspace === 'common-workspace'
+      ? `/paymentx/call-activities`
+      : `/call-activities`
+
+  const { data } = await axios.get(`${endpoint}/count-by-prospect`, {
+    params: { prospectId },
+  })
+  return data?.count || 0
+}
+
+/**
+ * Save call disposition
+ */
+export const saveCallDisposition = async (
+  input: SaveDispositionInput,
+): Promise<CallActivity> => {
+  const endpoint =
+    workspace === 'common-workspace'
+      ? `/paymentx/call-activities`
+      : `/call-activities`
+
+  const requestBody = {
+    callStatusDisposition: input.callStatusDisposition,
+    dispositionCategory: input.dispositionCategory,
+    dispositionNotes: input.dispositionNotes,
+    callbackScheduledAt: input.callbackScheduledAt,
+  };
+
+  const { data } = await axios.post(`${endpoint}/${input.callId}/disposition`, requestBody)
+  return data
+}
+
+/**
+ * Cancel/decline a call before it was connected
+ * Updates the call activity status to CANCELED
+ */
+export const cancelCall = async (
+  input: CancelCallInput,
+): Promise<{ success: boolean; message: string }> => {
+  const endpoint =
+    workspace === 'common-workspace'
+      ? `/paymentx/call-activities`
+      : `/call-activities`
+
+  const { data } = await axios.post(`${endpoint}/cancel`, input)
+  return data
+}
+

package/src/services/exotel/index.ts

@@ -0,0 +1,2 @@
+export * from './ExotelService'
+export * from './api'

package/src/utils/exotel/formatters.ts

@@ -0,0 +1,17 @@
+/**
+ * Format duration in MM:SS format (e.g., "02:30")
+ */
+export const formatDurationTimer = (seconds: number): string => {
+  const mins = Math.floor(seconds / 60)
+  const secs = seconds % 60
+  return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
+}
+
+/**
+ * Format duration in verbose format (e.g., "2m 30s")
+ */
+export const formatDurationVerbose = (seconds: number): string => {
+  const mins = Math.floor(seconds / 60)
+  const secs = seconds % 60
+  return `${mins}m ${secs}s`
+}

package/src/utils/exotel/index.ts

@@ -0,0 +1 @@
+export * from './formatters'