Update dependencies and Hugging Face configuration

alembic.ini

@@ -0,0 +1,100 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = app/migrations
+
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+#truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to app/migrations/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:app/migrations/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or colons.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S 

app/api/calls.py

@@ -0,0 +1,102 @@
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Header
+from typing import Optional
+from datetime import datetime
+from ..models import Customer
+from ..call_processor import CallProcessor
+from ..auth import get_current_customer
+import logging
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+@router.post("/process-call")
+async def process_call(
+    file: UploadFile = File(...),
+    caller_number: str = Header(...),
+    called_number: str = Header(...),
+    customer: Customer = Depends(get_current_customer)
+):
+    """Process a call and send results to customer's webhook"""
+    try:
+        # Create call processor for the customer
+        processor = CallProcessor(customer)
+        
+        # Process and send the call
+        result = processor.process_and_send_call(file, caller_number, called_number)
+        
+        if not result:
+            raise HTTPException(
+                status_code=500,
+                detail="Failed to send call results to webhook"
+            )
+            
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to process call: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/webhook")
+async def update_webhook(
+    webhook_url: str,
+    customer: Customer = Depends(get_current_customer)
+):
+    """Update customer's webhook URL"""
+    try:
+        # Update webhook URL
+        customer.webhook_url = webhook_url
+        customer.save()
+        
+        return {"message": "Webhook URL updated successfully"}
+        
+    except Exception as e:
+        logger.error(f"Failed to update webhook URL: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/calls/{call_id}")
+async def get_call(
+    call_id: str,
+    customer: Customer = Depends(get_current_customer)
+):
+    """Get call details from customer's database"""
+    try:
+        processor = CallProcessor(customer)
+        call_data = processor.get_call_details(call_id)
+        
+        if not call_data:
+            raise HTTPException(status_code=404, detail="Call not found")
+            
+        return call_data
+
+    except Exception as e:
+        logger.error(f"Failed to get call details: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/calls/search")
+async def search_calls(
+    start_date: Optional[datetime] = None,
+    end_date: Optional[datetime] = None,
+    caller_number: Optional[str] = None,
+    called_number: Optional[str] = None,
+    customer: Customer = Depends(get_current_customer)
+):
+    """Search calls in customer's database"""
+    try:
+        processor = CallProcessor(customer)
+        
+        filters = {
+            'start_date': start_date,
+            'end_date': end_date,
+            'caller_number': caller_number,
+            'called_number': called_number
+        }
+        
+        results = processor.search_calls(filters)
+        return {
+            'calls': results,
+            'total': len(results)
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to search calls: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e)) 

app/call_processor.py

@@ -0,0 +1,60 @@
+from .webhook_manager import WebhookManager
+import logging
+from datetime import datetime
+import uuid
+
+logger = logging.getLogger(__name__)
+
+class CallProcessor:
+    def __init__(self, customer):
+        self.customer = customer
+        self.webhook_manager = WebhookManager(customer)
+
+    def process_and_send_call(self, audio_file, caller_number, called_number):
+        """Process call and send results to customer's webhook"""
+        try:
+            # Generate a unique call ID
+            call_id = str(uuid.uuid4())
+
+            # Process the call (transcription, summary, sentiment)
+            # This is where you would integrate with your existing call processing logic
+            # For now, we'll use placeholder data
+            call_data = {
+                'id': call_id,
+                'caller_number': caller_number,
+                'called_number': called_number,
+                'transcription': "Sample transcription...",  # Replace with actual transcription
+                'summary': "Sample summary...",  # Replace with actual summary
+                'sentiment': "positive",  # Replace with actual sentiment
+                'keywords': "sample, keywords"  # Replace with actual keywords
+            }
+
+            # Send to customer's webhook
+            success = self.webhook_manager.send_call_results(call_data)
+
+            if success:
+                logger.info(f"Successfully processed and sent call {call_id} for customer {self.customer.id}")
+                return call_data
+            else:
+                logger.warning(f"Failed to send call results to webhook for customer {self.customer.id}")
+                return None
+
+        except Exception as e:
+            logger.error(f"Failed to process and send call for customer {self.customer.id}: {str(e)}")
+            raise
+
+    def get_call_details(self, call_id):
+        """Get call details from customer's database"""
+        try:
+            return self.db_manager.get_call_record(call_id)
+        except Exception as e:
+            logger.error(f"Failed to get call details for call {call_id}: {str(e)}")
+            raise
+
+    def search_calls(self, filters=None):
+        """Search calls in customer's database"""
+        try:
+            return self.db_manager.search_call_records(filters)
+        except Exception as e:
+            logger.error(f"Failed to search calls for customer {self.customer.id}: {str(e)}")
+            raise 

app/customer_db.py

@@ -0,0 +1,126 @@
+from sqlalchemy import create_engine, text
+from datetime import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+class CustomerDBManager:
+    def __init__(self, customer):
+        self.customer = customer
+        self.engine = None
+
+    def get_connection(self):
+        """Get database connection for the customer"""
+        if not self.engine:
+            try:
+                # Create database URL from customer's database credentials
+                db_url = f"mysql+pymysql://{self.customer.db_user}:{self.customer.db_password}@{self.customer.db_host}:{self.customer.db_port}/{self.customer.db_name}"
+                self.engine = create_engine(db_url)
+            except Exception as e:
+                logger.error(f"Failed to create database connection for customer {self.customer.id}: {str(e)}")
+                raise
+        return self.engine
+
+    def save_call_record(self, call_data):
+        """Save call record to customer's database"""
+        try:
+            engine = self.get_connection()
+            
+            # Prepare the SQL query
+            query = text("""
+                INSERT INTO call_records (
+                    id, customer_id, caller_number, called_number,
+                    transcription, summary, sentiment, keywords,
+                    created_at, updated_at
+                ) VALUES (
+                    :id, :customer_id, :caller_number, :called_number,
+                    :transcription, :summary, :sentiment, :keywords,
+                    :created_at, :updated_at
+                )
+            """)
+
+            # Prepare the data
+            now = datetime.utcnow()
+            record_data = {
+                'id': call_data.get('id'),
+                'customer_id': self.customer.id,
+                'caller_number': call_data.get('caller_number'),
+                'called_number': call_data.get('called_number'),
+                'transcription': call_data.get('transcription'),
+                'summary': call_data.get('summary'),
+                'sentiment': call_data.get('sentiment'),
+                'keywords': call_data.get('keywords'),
+                'created_at': now,
+                'updated_at': now
+            }
+
+            # Execute the query
+            with engine.connect() as connection:
+                connection.execute(query, record_data)
+                connection.commit()
+
+            logger.info(f"Successfully saved call record {call_data.get('id')} for customer {self.customer.id}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to save call record for customer {self.customer.id}: {str(e)}")
+            raise
+
+    def get_call_record(self, call_id):
+        """Retrieve a call record from customer's database"""
+        try:
+            engine = self.get_connection()
+            
+            query = text("""
+                SELECT * FROM call_records 
+                WHERE id = :call_id AND customer_id = :customer_id
+            """)
+
+            with engine.connect() as connection:
+                result = connection.execute(query, {
+                    'call_id': call_id,
+                    'customer_id': self.customer.id
+                }).fetchone()
+
+            return dict(result) if result else None
+
+        except Exception as e:
+            logger.error(f"Failed to retrieve call record {call_id} for customer {self.customer.id}: {str(e)}")
+            raise
+
+    def search_call_records(self, filters=None):
+        """Search call records in customer's database"""
+        try:
+            engine = self.get_connection()
+            
+            # Build the query based on filters
+            query = text("""
+                SELECT * FROM call_records 
+                WHERE customer_id = :customer_id
+            """)
+            params = {'customer_id': self.customer.id}
+
+            if filters:
+                if filters.get('start_date'):
+                    query = query.text + " AND created_at >= :start_date"
+                    params['start_date'] = filters['start_date']
+                if filters.get('end_date'):
+                    query = query.text + " AND created_at <= :end_date"
+                    params['end_date'] = filters['end_date']
+                if filters.get('caller_number'):
+                    query = query.text + " AND caller_number = :caller_number"
+                    params['caller_number'] = filters['caller_number']
+                if filters.get('called_number'):
+                    query = query.text + " AND called_number = :called_number"
+                    params['called_number'] = filters['called_number']
+
+            query = query.text + " ORDER BY created_at DESC"
+
+            with engine.connect() as connection:
+                results = connection.execute(query, params).fetchall()
+
+            return [dict(row) for row in results]
+
+        except Exception as e:
+            logger.error(f"Failed to search call records for customer {self.customer.id}: {str(e)}")
+            raise 

app/migrations/env.py

@@ -0,0 +1,84 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+import os
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from app.models import Base
+from app.database import get_db_url
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = get_db_url()
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    configuration = config.get_section(config.config_ini_section)
+    configuration["sqlalchemy.url"] = get_db_url()
+    connectable = engine_from_config(
+        configuration,
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online() 

app/migrations/versions/add_webhook_url.py

@@ -0,0 +1,23 @@
+"""Add webhook_url column to customers table
+
+Revision ID: add_webhook_url
+Revises: 
+Create Date: 2024-03-14 12:00:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = 'add_webhook_url'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+def upgrade():
+    # Add webhook_url column to customers table
+    op.add_column('customers', sa.Column('webhook_url', sa.String(255), nullable=True))
+
+def downgrade():
+    # Remove webhook_url column from customers table
+    op.drop_column('customers', 'webhook_url') 

app/models.py

@@ -20,7 +20,7 @@ class Customer(Base):
     company_name = Column(String(100), nullable=False)
     email = Column(String(100), unique=True, nullable=False)
     api_key = Column(String(64), unique=True, nullable=False)
-    webhook_url = Column(String(255), nullable=True)  # URL where call results will be sent
+    webhook_url = Column(String(255), nullable=True, default=None)  # URL where call results will be sent
     is_active = Column(Boolean, default=True)
     created_at = Column(DateTime(timezone=True), server_default=func.now())
     updated_at = Column(DateTime(timezone=True), onupdate=func.now())
@@ -66,6 +66,24 @@ class Customer(Base):
         response.raise_for_status()
         return response.json()
 
+    def send_webhook(self, data: Dict) -> bool:
+        """Send call results to webhook URL if configured"""
+        if not self.webhook_url:
+            return False
+            
+        try:
+            response = requests.post(
+                self.webhook_url,
+                json=data,
+                headers={"Content-Type": "application/json"},
+                timeout=5
+            )
+            response.raise_for_status()
+            return True
+        except Exception as e:
+            print(f"Webhook delivery failed: {str(e)}")
+            return False
+
 class CallRecord(Base):
     __tablename__ = "call_records"
 

app/webhook_manager.py

@@ -0,0 +1,54 @@
+import requests
+import logging
+from datetime import datetime
+import json
+
+logger = logging.getLogger(__name__)
+
+class WebhookManager:
+    def __init__(self, customer):
+        self.customer = customer
+        self.webhook_url = customer.webhook_url
+
+    def send_call_results(self, call_data):
+        """Send call analysis results to customer's webhook URL"""
+        if not self.webhook_url:
+            logger.warning(f"No webhook URL configured for customer {self.customer.id}")
+            return False
+
+        try:
+            # Prepare the payload
+            payload = {
+                'call_id': call_data.get('id'),
+                'caller_number': call_data.get('caller_number'),
+                'called_number': call_data.get('called_number'),
+                'transcription': call_data.get('transcription'),
+                'summary': call_data.get('summary'),
+                'sentiment': call_data.get('sentiment'),
+                'keywords': call_data.get('keywords'),
+                'timestamp': datetime.utcnow().isoformat(),
+                'customer_id': self.customer.id
+            }
+
+            # Send POST request to webhook URL
+            response = requests.post(
+                self.webhook_url,
+                json=payload,
+                headers={'Content-Type': 'application/json'},
+                timeout=10  # 10 seconds timeout
+            )
+
+            # Check if request was successful
+            if response.status_code in [200, 201, 202]:
+                logger.info(f"Successfully sent call results to webhook for customer {self.customer.id}")
+                return True
+            else:
+                logger.error(f"Failed to send call results to webhook. Status code: {response.status_code}")
+                return False
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error sending webhook for customer {self.customer.id}: {str(e)}")
+            return False
+        except Exception as e:
+            logger.error(f"Unexpected error sending webhook for customer {self.customer.id}: {str(e)}")
+            return False 

customer_webhook/README.md

@@ -0,0 +1,101 @@
+# vBot Customer Webhook Handler
+
+This package provides a simple webhook handler for vBot customers to receive and process call analysis results on their own servers.
+
+## Features
+
+- Secure webhook endpoint with API key validation
+- Automatic call record storage in MySQL database
+- Configurable webhook secret for additional security
+- Easy integration with LAMP stack
+- Example implementation included
+
+## Requirements
+
+- PHP 7.4 or higher
+- MySQL 5.7 or higher
+- Apache/Nginx web server
+- mod_rewrite enabled (for Apache)
+
+## Installation
+
+1. Copy the contents of this package to your web server directory:
+   ```bash
+   cp -r customer_webhook/* /var/www/html/vbot-webhook/
+   ```
+
+2. Create the MySQL database and table:
+   ```sql
+   CREATE DATABASE vbot_calls;
+   USE vbot_calls;
+   
+   CREATE TABLE call_records (
+       id VARCHAR(36) PRIMARY KEY,
+       customer_id INT NOT NULL,
+       caller_number VARCHAR(20) NOT NULL,
+       called_number VARCHAR(20) NOT NULL,
+       transcription TEXT,
+       summary TEXT,
+       sentiment VARCHAR(50),
+       keywords TEXT,
+       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+       updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+   );
+   ```
+
+3. Configure the webhook handler:
+   - Copy `config/config.example.php` to `config/config.php`
+   - Update the database credentials and webhook secret
+
+4. Set up Apache/Nginx:
+   - Ensure the webhook directory is accessible
+   - Configure URL rewriting (see examples)
+
+## Configuration
+
+Edit `config/config.php` to set your:
+- Database credentials
+- Webhook secret (for additional security)
+- API key (provided by vBot)
+
+## Usage
+
+1. Your webhook URL will be: `https://your-domain.com/vbot-webhook/webhook.php`
+
+2. The webhook will receive POST requests with call analysis data in JSON format:
+   ```json
+   {
+       "call_id": "uuid",
+       "caller_number": "+1234567890",
+       "called_number": "+0987654321",
+       "transcription": "Call transcript...",
+       "summary": "Call summary...",
+       "sentiment": "positive",
+       "keywords": "keyword1, keyword2",
+       "timestamp": "2024-03-14T12:00:00Z",
+       "customer_id": 123
+   }
+   ```
+
+3. The handler will:
+   - Validate the API key
+   - Store the call record in your database
+   - Return a success response
+
+## Security
+
+- All requests must include the API key in the `X-API-Key` header
+- Optional webhook secret for additional security
+- Input validation and sanitization
+- SQL injection prevention
+
+## Examples
+
+See the `examples` directory for:
+- Apache configuration
+- Nginx configuration
+- Custom processing example
+
+## Support
+
+For support, contact vBot support team or refer to the documentation. 

customer_webhook/config/config.example.php

@@ -0,0 +1,25 @@
+<?php
+// Database configuration
+define('DB_HOST', 'localhost');
+define('DB_NAME', 'vbot_calls');
+define('DB_USER', 'your_db_user');
+define('DB_PASS', 'your_db_password');
+
+// vBot API configuration
+define('VBOT_API_KEY', 'your_api_key_here');  // API key provided by vBot
+define('WEBHOOK_SECRET', 'your_webhook_secret_here');  // Optional secret for additional security
+
+// Error reporting
+error_reporting(E_ALL);
+ini_set('display_errors', 0);  // Set to 1 for development
+ini_set('log_errors', 1);
+ini_set('error_log', __DIR__ . '/../logs/error.log');
+
+// Response settings
+define('ALLOW_ORIGIN', '*');  // Set to your domain in production
+define('MAX_RETRIES', 3);     // Maximum number of retry attempts
+define('RETRY_DELAY', 5);     // Delay between retries in seconds
+
+// Custom processing
+define('ENABLE_CUSTOM_PROCESSING', false);  // Set to true to enable custom processing
+define('CUSTOM_PROCESSOR_FILE', __DIR__ . '/../src/custom_processor.php'); 

customer_webhook/examples/apache.conf

@@ -0,0 +1 @@
+ 

customer_webhook/examples/nginx.conf

@@ -0,0 +1 @@
+ 

customer_webhook/src/Database.php

@@ -0,0 +1,115 @@
+<?php
+class Database {
+    private static $instance = null;
+    private $connection = null;
+
+    private function __construct() {
+        try {
+            $this->connection = new PDO(
+                "mysql:host=" . DB_HOST . ";dbname=" . DB_NAME,
+                DB_USER,
+                DB_PASS,
+                [
+                    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
+                    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
+                    PDO::ATTR_EMULATE_PREPARES => false
+                ]
+            );
+        } catch (PDOException $e) {
+            error_log("Database Connection Error: " . $e->getMessage());
+            throw new Exception("Database connection failed");
+        }
+    }
+
+    public static function getInstance() {
+        if (self::$instance === null) {
+            self::$instance = new self();
+        }
+        return self::$instance;
+    }
+
+    public function getConnection() {
+        return $this->connection;
+    }
+
+    public function saveCallRecord($data) {
+        try {
+            $sql = "INSERT INTO call_records (
+                id, customer_id, caller_number, called_number,
+                transcription, summary, sentiment, keywords,
+                created_at, updated_at
+            ) VALUES (
+                :id, :customer_id, :caller_number, :called_number,
+                :transcription, :summary, :sentiment, :keywords,
+                NOW(), NOW()
+            )";
+
+            $stmt = $this->connection->prepare($sql);
+            
+            return $stmt->execute([
+                'id' => $data['call_id'],
+                'customer_id' => $data['customer_id'],
+                'caller_number' => $data['caller_number'],
+                'called_number' => $data['called_number'],
+                'transcription' => $data['transcription'],
+                'summary' => $data['summary'],
+                'sentiment' => $data['sentiment'],
+                'keywords' => $data['keywords']
+            ]);
+
+        } catch (PDOException $e) {
+            error_log("Database Error: " . $e->getMessage());
+            throw new Exception("Failed to save call record");
+        }
+    }
+
+    public function getCallRecord($callId) {
+        try {
+            $sql = "SELECT * FROM call_records WHERE id = :id";
+            $stmt = $this->connection->prepare($sql);
+            $stmt->execute(['id' => $callId]);
+            return $stmt->fetch();
+
+        } catch (PDOException $e) {
+            error_log("Database Error: " . $e->getMessage());
+            throw new Exception("Failed to retrieve call record");
+        }
+    }
+
+    public function searchCallRecords($filters = []) {
+        try {
+            $sql = "SELECT * FROM call_records WHERE 1=1";
+            $params = [];
+
+            if (!empty($filters['start_date'])) {
+                $sql .= " AND created_at >= :start_date";
+                $params['start_date'] = $filters['start_date'];
+            }
+
+            if (!empty($filters['end_date'])) {
+                $sql .= " AND created_at <= :end_date";
+                $params['end_date'] = $filters['end_date'];
+            }
+
+            if (!empty($filters['caller_number'])) {
+                $sql .= " AND caller_number = :caller_number";
+                $params['caller_number'] = $filters['caller_number'];
+            }
+
+            if (!empty($filters['called_number'])) {
+                $sql .= " AND called_number = :called_number";
+                $params['called_number'] = $filters['called_number'];
+            }
+
+            $sql .= " ORDER BY created_at DESC";
+
+            $stmt = $this->connection->prepare($sql);
+            $stmt->execute($params);
+            return $stmt->fetchAll();
+
+        } catch (PDOException $e) {
+            error_log("Database Error: " . $e->getMessage());
+            throw new Exception("Failed to search call records");
+        }
+    }
+} 

customer_webhook/src/WebhookHandler.php

@@ -0,0 +1 @@
+ 

customer_webhook/src/custom_processor.php

@@ -0,0 +1 @@
+ 

customer_webhook/src/webhook.php

@@ -0,0 +1,50 @@
+<?php
+require_once __DIR__ . '/../config/config.php';
+require_once __DIR__ . '/Database.php';
+require_once __DIR__ . '/WebhookHandler.php';
+
+// Set headers
+header('Content-Type: application/json');
+header('Access-Control-Allow-Origin: ' . ALLOW_ORIGIN);
+header('Access-Control-Allow-Methods: POST');
+header('Access-Control-Allow-Headers: Content-Type, X-API-Key');
+
+// Handle preflight requests
+if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
+    http_response_code(200);
+    exit();
+}
+
+// Only allow POST requests
+if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
+    http_response_code(405);
+    echo json_encode(['error' => 'Method not allowed']);
+    exit();
+}
+
+try {
+    // Initialize webhook handler
+    $handler = new WebhookHandler();
+    
+    // Process the webhook
+    $result = $handler->process();
+    
+    // Return success response
+    http_response_code(200);
+    echo json_encode([
+        'success' => true,
+        'message' => 'Call record processed successfully',
+        'call_id' => $result['call_id'] ?? null
+    ]);
+
+} catch (Exception $e) {
+    // Log error
+    error_log("Webhook Error: " . $e->getMessage());
+    
+    // Return error response
+    http_response_code(500);
+    echo json_encode([
+        'success' => false,
+        'error' => 'Internal server error'
+    ]);
+} 

huggingface.yml

@@ -1 +1,3 @@
- 
+image: python:3.9
+pip:
+  - requirements.txt 

requirements.txt

@@ -12,4 +12,6 @@ transformers==4.37.2
 torch==2.2.0
 soundfile==0.12.1
 librosa==0.10.1
-numpy==1.26.3 
+numpy==1.26.3
+alembic==1.13.1
+requests==2.31.0