Update code to use API-based architecture

app/auth.py

@@ -1,5 +1,5 @@
-from fastapi import APIRouter, Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from fastapi import APIRouter, Depends, HTTPException, status, Security
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm, APIKeyHeader
 from sqlalchemy.orm import Session
 from datetime import datetime, timedelta
 from jose import JWTError, jwt
@@ -8,7 +8,8 @@ from typing import Optional
 import secrets
 import os
 from dotenv import load_dotenv
-from . import models
+from . import models, settings
+from .database import get_db
 
 # Load environment variables
 load_dotenv()
@@ -23,6 +24,7 @@ pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 # OAuth2 scheme
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+api_key_header = APIKeyHeader(name="api-key")
 
 router = APIRouter()
 
@@ -30,13 +32,32 @@ router = APIRouter()
 ADMIN_USERNAME = os.getenv("ADMIN_USERNAME", "admin")
 ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin")
 
-def verify_password(plain_password, hashed_password):
+def verify_api_key(api_key: str = Security(api_key_header)) -> models.Customer:
+    """Verify API key and return customer"""
+    db = next(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=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return customer
+
+def verify_password(plain_password: str, hashed_password: str):
+    """Verify password"""
     return pwd_context.verify(plain_password, hashed_password)
 
-def get_password_hash(password):
+def get_password_hash(password: str):
+    """Hash password"""
     return pwd_context.hash(password)
 
 def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    """Create JWT token for admin access"""
     to_encode = data.copy()
     if expires_delta:
         expire = datetime.utcnow() + expires_delta
@@ -46,7 +67,8 @@ def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
     encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
     return encoded_jwt
 
-async def get_current_admin(token: str = Depends(oauth2_scheme)):
+def get_current_admin(token: str = Depends(oauth2_scheme)):
+    """Get current admin user"""
     credentials_exception = HTTPException(
         status_code=status.HTTP_401_UNAUTHORIZED,
         detail="Could not validate credentials",
@@ -59,6 +81,7 @@ async def get_current_admin(token: str = Depends(oauth2_scheme)):
             raise credentials_exception
     except JWTError:
         raise credentials_exception
+    
     if username != ADMIN_USERNAME:
         raise credentials_exception
     return username

app/models.py

@@ -1,10 +1,12 @@
-from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Boolean, create_engine
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Boolean, create_engine, Text
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker, relationship
 from datetime import datetime
 import os
 from dotenv import load_dotenv
 import json
+import requests
+from typing import Optional, List, Dict
 
 # Load environment variables
 load_dotenv()
@@ -21,7 +23,7 @@ Base = declarative_base()
 class Customer(Base):
     __tablename__ = "customers"
 
-    id = Column(Integer, primary_key=True)
+    id = Column(Integer, primary_key=True, index=True)
     name = Column(String(100), nullable=False)
     company_name = Column(String(100), nullable=False)
     email = Column(String(100), unique=True, nullable=False)
@@ -56,6 +58,44 @@ class Customer(Base):
         if engine:
             CallRecord.metadata.create_all(engine)
 
+    def get_call_records(self, start_date: Optional[str] = None, end_date: Optional[str] = None) -> List[Dict]:
+        """Get call records via API"""
+        url = f"{settings.API_BASE_URL}/api/v1/calls"
+        params = {}
+        if start_date:
+            params['start_date'] = start_date
+        if end_date:
+            params['end_date'] = end_date
+            
+        response = requests.get(
+            url,
+            headers={"api-key": self.api_key},
+            params=params
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def get_call_details(self, call_id: str) -> Dict:
+        """Get specific call details via API"""
+        url = f"{settings.API_BASE_URL}/api/v1/calls/{call_id}"
+        response = requests.get(
+            url,
+            headers={"api-key": self.api_key}
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def search_calls(self, query: Dict) -> List[Dict]:
+        """Search calls via API"""
+        url = f"{settings.API_BASE_URL}/api/v1/calls/search"
+        response = requests.get(
+            url,
+            headers={"api-key": self.api_key},
+            json=query
+        )
+        response.raise_for_status()
+        return response.json()
+
     # Relationship with call records
     call_records = relationship("CallRecord", back_populates="customer")
 
@@ -63,20 +103,35 @@ class CallRecord(Base):
     __tablename__ = "call_records"
 
     id = Column(String(36), primary_key=True)
-    customer_id = Column(Integer, ForeignKey("customers.id"), nullable=False)
+    customer_id = Column(Integer, ForeignKey("customers.id"))
     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))
+    transcription = Column(Text)
+    summary = Column(Text)
     sentiment = Column(String(20))
-    keywords = Column(String(1000))
+    keywords = Column(Text)
     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")
 
+    @classmethod
+    def create_from_api(cls, customer_id: int, data: Dict) -> 'CallRecord':
+        """Create a call record from API data"""
+        return cls(
+            id=data['id'],
+            customer_id=customer_id,
+            caller_number=data['caller_number'],
+            called_number=data['called_number'],
+            file_path=data.get('file_path'),
+            transcription=data.get('transcription'),
+            summary=data.get('summary'),
+            sentiment=data.get('sentiment'),
+            keywords=data.get('keywords')
+        )
+
 # Create all tables in the main database
 Base.metadata.create_all(engine)
 

main.py

@@ -1,10 +1,10 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException, Depends, Header
+from fastapi import FastAPI, File, UploadFile, HTTPException, Depends, Header, Form
 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 Optional
+from typing import Optional, List
 import uuid
 import tempfile
 from transformers import pipeline
@@ -12,6 +12,7 @@ from sqlalchemy.orm import Session
 import asyncio
 from app import models, auth
 from sqlalchemy.orm import sessionmaker
+from fastapi.security import OAuth2PasswordRequestForm
 
 # Load environment variables
 load_dotenv()
@@ -55,9 +56,9 @@ async def get_customer_by_api_key(api_key: str = Header(...), db: Session = Depe
 @app.post("/api/v1/process-call")
 async def process_call(
     file: UploadFile = File(...),
-    caller_number: str = Header(...),
-    called_number: str = Header(...),
-    customer: models.Customer = Depends(get_customer_by_api_key),
+    caller_number: str = Form(...),
+    called_number: str = Form(...),
+    customer: models.Customer = Depends(auth.verify_api_key),
     db: Session = Depends(models.get_db)
 ):
     """
@@ -159,6 +160,66 @@ async def list_calls(
     finally:
         customer_db.close()
 
+@app.post("/api/v1/token")
+async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+    """Admin login endpoint"""
+    if form_data.username != settings.ADMIN_USERNAME or form_data.password != settings.ADMIN_PASSWORD:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token = auth.create_access_token(data={"sub": form_data.username})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@app.post("/api/v1/customers/", response_model=models.Customer)
+async def create_customer(
+    customer: models.CustomerCreate,
+    db: Session = Depends(models.get_db),
+    current_admin: str = Depends(auth.get_current_admin)
+):
+    """Create new customer"""
+    db_customer = models.Customer(
+        name=customer.name,
+        company_name=customer.company_name,
+        email=customer.email,
+        api_key=str(uuid.uuid4())
+    )
+    db.add(db_customer)
+    db.commit()
+    db.refresh(db_customer)
+    return db_customer
+
+@app.get("/api/v1/calls", response_model=List[models.CallRecord])
+async def get_calls(
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    customer: models.Customer = Depends(auth.verify_api_key)
+):
+    """Get customer's call records"""
+    return customer.get_call_records(start_date, end_date)
+
+@app.get("/api/v1/calls/{call_id}", response_model=models.CallRecord)
+async def get_call(
+    call_id: str,
+    customer: models.Customer = Depends(auth.verify_api_key)
+):
+    """Get specific call details"""
+    return customer.get_call_details(call_id)
+
+@app.get("/api/v1/calls/search")
+async def search_calls(
+    query: dict,
+    customer: models.Customer = Depends(auth.verify_api_key)
+):
+    """Search calls"""
+    return customer.search_calls(query)
+
+@app.get("/api/v1/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy"}
+
 if __name__ == "__main__":
     import uvicorn
     host = os.getenv("HOST", "0.0.0.0")