Initial commit with complete vBot implementation

app/auth.py

@@ -1 +1,139 @@
- 
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from typing import Optional
+import secrets
+import os
+from dotenv import load_dotenv
+from . import models
+
+# Load environment variables
+load_dotenv()
+
+# Security configuration
+SECRET_KEY = os.getenv("JWT_SECRET", "your-secret-key")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+# Password hashing
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# OAuth2 scheme
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+router = APIRouter()
+
+# Admin user credentials (in production, use database)
+ADMIN_USERNAME = os.getenv("ADMIN_USERNAME", "admin")
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin")
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+async def get_current_admin(token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    if username != ADMIN_USERNAME:
+        raise credentials_exception
+    return username
+
+@router.post("/token")
+async def login(form_data: OAuth2PasswordRequestForm = Depends()):
+    if form_data.username != ADMIN_USERNAME or form_data.password != ADMIN_PASSWORD:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": form_data.username}, expires_delta=access_token_expires
+    )
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.post("/customers/", response_model=dict)
+async def create_customer(
+    customer_data: dict,
+    db: Session = Depends(models.get_db),
+    current_admin: str = Depends(get_current_admin)
+):
+    # Generate API key
+    api_key = secrets.token_urlsafe(32)
+    
+    # Create new customer
+    customer = models.Customer(
+        name=customer_data["name"],
+        company_name=customer_data["company_name"],
+        email=customer_data["email"],
+        api_key=api_key
+    )
+    
+    db.add(customer)
+    db.commit()
+    db.refresh(customer)
+    
+    return {
+        "id": customer.id,
+        "name": customer.name,
+        "company_name": customer.company_name,
+        "email": customer.email,
+        "api_key": customer.api_key
+    }
+
+@router.get("/customers/", response_model=list)
+async def list_customers(
+    db: Session = Depends(models.get_db),
+    current_admin: str = Depends(get_current_admin)
+):
+    customers = db.query(models.Customer).all()
+    return customers
+
+@router.get("/customers/{customer_id}", response_model=dict)
+async def get_customer(
+    customer_id: int,
+    db: Session = Depends(models.get_db),
+    current_admin: str = Depends(get_current_admin)
+):
+    customer = db.query(models.Customer).filter(models.Customer.id == customer_id).first()
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+    return customer
+
+@router.delete("/customers/{customer_id}")
+async def delete_customer(
+    customer_id: int,
+    db: Session = Depends(models.get_db),
+    current_admin: str = Depends(get_current_admin)
+):
+    customer = db.query(models.Customer).filter(models.Customer.id == customer_id).first()
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+    db.delete(customer)
+    db.commit()
+    return {"message": "Customer deleted successfully"} 

app/models.py

@@ -1,6 +1,6 @@
-from sqlalchemy import Column, Integer, String, DateTime, create_engine
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Boolean, create_engine
 from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.orm import sessionmaker, relationship
 from datetime import datetime
 import os
 from dotenv import load_dotenv
@@ -17,16 +17,38 @@ engine = create_engine(DATABASE_URL)
 # Create declarative base
 Base = declarative_base()
 
+class Customer(Base):
+    __tablename__ = "customers"
+
+    id = Column(Integer, primary_key=True)
+    name = Column(String(100), nullable=False)
+    company_name = Column(String(100), nullable=False)
+    email = Column(String(100), unique=True, nullable=False)
+    api_key = Column(String(64), unique=True, nullable=False)
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # Relationship with call records
+    call_records = relationship("CallRecord", back_populates="customer")
+
 class CallRecord(Base):
     __tablename__ = "call_records"
 
     id = Column(String(36), primary_key=True)
+    customer_id = Column(Integer, ForeignKey("customers.id"), nullable=False)
+    caller_number = Column(String(20), nullable=False)
+    called_number = Column(String(20), nullable=False)
     file_path = Column(String(255))
     transcription = Column(String(10000))
+    summary = Column(String(1000))
     sentiment = Column(String(20))
     keywords = Column(String(1000))
     created_at = Column(DateTime, default=datetime.utcnow)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # Relationship with customer
+    customer = relationship("Customer", back_populates="call_records")
 
 # Create all tables
 Base.metadata.create_all(engine)

asterisk_dialplan.conf

@@ -0,0 +1,14 @@
+[from-internal]
+; Replace YOUR_API_KEY with the API key provided by vBot
+exten => _X.,1,Answer()
+same => n,Set(CALLERID=${CALLERID(num)})
+same => n,Set(CALLED=${EXTEN})
+same => n,Record(/tmp/call-${UNIQUEID}.wav,0,30)
+same => n,System(curl -X POST "https://your-huggingface-space-url/api/v1/process-call" \
+    -H "api-key: YOUR_API_KEY" \
+    -H "caller-number: ${CALLERID}" \
+    -H "called-number: ${CALLED}" \
+    -F "file=@/tmp/call-${UNIQUEID}.wav")
+same => n,System(rm /tmp/call-${UNIQUEID}.wav)
+same => n,Dial(SIP/${EXTEN})
+same => n,Hangup() 

main.py

@@ -1,11 +1,16 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException, Depends
-from fastapi.security import OAuth2PasswordBearer
+from fastapi import FastAPI, File, UploadFile, HTTPException, Depends, Header
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
 from datetime import datetime
 import os
 from dotenv import load_dotenv
-from typing import List
+from typing import Optional
 import uuid
+import tempfile
+from transformers import pipeline
+from sqlalchemy.orm import Session
+import asyncio
+from app import models, auth
 
 # Load environment variables
 load_dotenv()
@@ -26,24 +31,33 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# OAuth2 scheme for token authentication
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+# Initialize Hugging Face models
+transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base")
+summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+sentiment_analyzer = pipeline("sentiment-analysis", model="nlptown/bert-base-multilingual-uncased-sentiment")
 
-# Dependency for authentication
-async def get_current_user(token: str = Depends(oauth2_scheme)):
-    # TODO: Implement proper JWT token validation
-    if not token:
+# Include auth router
+app.include_router(auth.router, prefix="/api/v1", tags=["auth"])
+
+async def get_customer_by_api_key(api_key: str = Header(...), db: Session = Depends(models.get_db)):
+    customer = db.query(models.Customer).filter(
+        models.Customer.api_key == api_key,
+        models.Customer.is_active == True
+    ).first()
+    if not customer:
         raise HTTPException(
             status_code=401,
-            detail="Could not validate credentials",
-            headers={"WWW-Authenticate": "Bearer"},
+            detail="Invalid or inactive API key"
         )
-    return token
+    return customer
 
 @app.post("/api/v1/process-call")
 async def process_call(
     file: UploadFile = File(...),
-    current_user: str = Depends(get_current_user)
+    caller_number: str = Header(...),
+    called_number: str = Header(...),
+    customer: models.Customer = Depends(get_customer_by_api_key),
+    db: Session = Depends(models.get_db)
 ):
     """
     Process a voice call recording file.
@@ -52,23 +66,61 @@ async def process_call(
         # Generate unique ID for this processing request
         process_id = str(uuid.uuid4())
         
-        # TODO: Implement actual file processing logic
-        # 1. Save the file temporarily
-        # 2. Process audio using ML models
-        # 3. Clean up temporary files
+        # Save the uploaded file temporarily
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
+            content = await file.read()
+            temp_file.write(content)
+            temp_file_path = temp_file.name
+        
+        # Process audio using Hugging Face models
+        # Note: In production, these should be processed asynchronously
+        transcription = transcriber(temp_file_path)["text"]
+        summary = summarizer(transcription, max_length=130, min_length=30, do_sample=False)[0]["summary_text"]
+        sentiment = sentiment_analyzer(transcription)[0]["label"]
+        
+        # Create call record
+        call_record = models.CallRecord(
+            id=process_id,
+            customer_id=customer.id,
+            caller_number=caller_number,
+            called_number=called_number,
+            file_path=temp_file_path,
+            transcription=transcription,
+            summary=summary,
+            sentiment=sentiment
+        )
+        
+        db.add(call_record)
+        db.commit()
+        
+        # Clean up temporary file
+        os.unlink(temp_file_path)
         
-        # Mock response for now
         return {
             "id": process_id,
-            "text": "Sample transcribed text",
-            "sentiment": "neutral",
-            "keywords": ["sample", "keywords"],
+            "transcription": transcription,
+            "summary": summary,
+            "sentiment": sentiment,
             "timestamp": datetime.utcnow().isoformat() + "Z"
         }
         
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/api/v1/calls/{customer_id}")
+async def list_calls(
+    customer_id: int,
+    db: Session = Depends(models.get_db),
+    current_admin: str = Depends(auth.get_current_admin)
+):
+    """
+    List all calls for a specific customer.
+    """
+    calls = db.query(models.CallRecord).filter(
+        models.CallRecord.customer_id == customer_id
+    ).all()
+    return calls
+
 if __name__ == "__main__":
     import uvicorn
     host = os.getenv("HOST", "0.0.0.0")

requirements.txt

@@ -7,4 +7,9 @@ pymysql==1.1.0
 cryptography==42.0.2
 python-dotenv==1.0.0
 passlib[bcrypt]==1.7.4
-PyJWT==2.8.0 
+PyJWT==2.8.0
+transformers==4.37.2
+torch==2.2.0
+soundfile==0.12.1
+librosa==0.10.1
+numpy==1.26.3