Update system to use customer-specific databases

app/auth.py

@@ -91,9 +91,27 @@ async def create_customer(
         name=customer_data["name"],
         company_name=customer_data["company_name"],
         email=customer_data["email"],
-        api_key=api_key
+        api_key=api_key,
+        # Database credentials
+        db_host=customer_data.get("db_host"),
+        db_port=customer_data.get("db_port"),
+        db_name=customer_data.get("db_name"),
+        db_user=customer_data.get("db_user"),
+        db_password=customer_data.get("db_password")
     )
     
+    # Validate database connection if credentials are provided
+    if all([customer.db_host, customer.db_port, customer.db_name, customer.db_user, customer.db_password]):
+        try:
+            engine = customer.get_db_engine()
+            with engine.connect() as conn:
+                conn.execute("SELECT 1")
+        except Exception as e:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid database credentials: {str(e)}"
+            )
+    
     db.add(customer)
     db.commit()
     db.refresh(customer)
@@ -103,7 +121,8 @@ async def create_customer(
         "name": customer.name,
         "company_name": customer.company_name,
         "email": customer.email,
-        "api_key": customer.api_key
+        "api_key": customer.api_key,
+        "db_configured": bool(customer.get_db_url())
     }
 
 @router.get("/customers/", response_model=list)

app/models.py

@@ -4,6 +4,7 @@ from sqlalchemy.orm import sessionmaker, relationship
 from datetime import datetime
 import os
 from dotenv import load_dotenv
+import json
 
 # Load environment variables
 load_dotenv()
@@ -29,6 +30,32 @@ class Customer(Base):
     created_at = Column(DateTime, default=datetime.utcnow)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
     
+    # Database credentials for customer's own database
+    db_host = Column(String(255))
+    db_port = Column(Integer)
+    db_name = Column(String(100))
+    db_user = Column(String(100))
+    db_password = Column(String(255))
+    
+    def get_db_url(self):
+        """Get the database URL for this customer"""
+        if all([self.db_host, self.db_port, self.db_name, self.db_user, self.db_password]):
+            return f"mysql+pymysql://{self.db_user}:{self.db_password}@{self.db_host}:{self.db_port}/{self.db_name}"
+        return None
+
+    def get_db_engine(self):
+        """Get a SQLAlchemy engine for this customer's database"""
+        db_url = self.get_db_url()
+        if db_url:
+            return create_engine(db_url)
+        return None
+
+    def create_tables(self):
+        """Create necessary tables in customer's database"""
+        engine = self.get_db_engine()
+        if engine:
+            CallRecord.metadata.create_all(engine)
+
     # Relationship with call records
     call_records = relationship("CallRecord", back_populates="customer")
 
@@ -50,7 +77,7 @@ class CallRecord(Base):
     # Relationship with customer
     customer = relationship("Customer", back_populates="call_records")
 
-# Create all tables
+# Create all tables in the main database
 Base.metadata.create_all(engine)
 
 # Create session factory

main.py

@@ -11,6 +11,7 @@ from transformers import pipeline
 from sqlalchemy.orm import Session
 import asyncio
 from app import models, auth
+from sqlalchemy.orm import sessionmaker
 
 # Load environment variables
 load_dotenv()
@@ -78,31 +79,50 @@ async def process_call(
         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
-        )
+        # Create call record in customer's database
+        customer_engine = customer.get_db_engine()
+        if not customer_engine:
+            raise HTTPException(
+                status_code=400,
+                detail="Customer database not configured"
+            )
         
-        db.add(call_record)
-        db.commit()
+        # Create tables if they don't exist
+        customer.create_tables()
         
-        # Clean up temporary file
-        os.unlink(temp_file_path)
+        # Create a session for the customer's database
+        CustomerSession = sessionmaker(autocommit=False, autoflush=False, bind=customer_engine)
+        customer_db = CustomerSession()
         
-        return {
-            "id": process_id,
-            "transcription": transcription,
-            "summary": summary,
-            "sentiment": sentiment,
-            "timestamp": datetime.utcnow().isoformat() + "Z"
-        }
+        try:
+            # 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
+            )
+            
+            customer_db.add(call_record)
+            customer_db.commit()
+            
+            # Clean up temporary file
+            os.unlink(temp_file_path)
+            
+            return {
+                "id": process_id,
+                "transcription": transcription,
+                "summary": summary,
+                "sentiment": sentiment,
+                "timestamp": datetime.utcnow().isoformat() + "Z"
+            }
+            
+        finally:
+            customer_db.close()
         
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
@@ -116,10 +136,28 @@ async def list_calls(
     """
     List all calls for a specific customer.
     """
-    calls = db.query(models.CallRecord).filter(
-        models.CallRecord.customer_id == customer_id
-    ).all()
-    return calls
+    customer = db.query(models.Customer).filter(models.Customer.id == customer_id).first()
+    if not customer:
+        raise HTTPException(status_code=404, detail="Customer not found")
+    
+    customer_engine = customer.get_db_engine()
+    if not customer_engine:
+        raise HTTPException(
+            status_code=400,
+            detail="Customer database not configured"
+        )
+    
+    # Create a session for the customer's database
+    CustomerSession = sessionmaker(autocommit=False, autoflush=False, bind=customer_engine)
+    customer_db = CustomerSession()
+    
+    try:
+        calls = customer_db.query(models.CallRecord).filter(
+            models.CallRecord.customer_id == customer_id
+        ).all()
+        return calls
+    finally:
+        customer_db.close()
 
 if __name__ == "__main__":
     import uvicorn