Fix: Sync missing report routes and templates for production

app/database/models.py

@@ -137,3 +137,18 @@ class UserSettings(Base):
     
     created_at = Column(DateTime, default=datetime.utcnow)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class Report(Base):
+    """Generated reports model."""
+    __tablename__ = "reports"
+    
+    id = Column(String, primary_key=True, default=generate_id)
+    user_id = Column(String, ForeignKey("users.id", ondelete="CASCADE"), nullable=True, index=True)
+    template_id = Column(String, nullable=False)
+    filename = Column(String, nullable=False)
+    file_path = Column(String, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    
+    # Relationships
+    user = relationship("User")

app/routes/reports.py

@@ -1,13 +1,15 @@
 """
 API routes for report generation.
 """
-from fastapi import APIRouter, HTTPException, Depends
+from fastapi import APIRouter, HTTPException, Depends, status
+from fastapi.responses import FileResponse
 from sqlalchemy.orm import Session
 from typing import Optional, Dict
 from pydantic import BaseModel
+import os
 
 from app.database.connection import get_db
-from app.database.models import User
+from app.database.models import User, Report
 from app.middleware.auth import get_current_user_optional
 from app.services.report_service import report_generation_service
 
@@ -21,6 +23,12 @@ class GenerateContentRequest(BaseModel):
     context: Dict[str, str] = {}
 
 
+class GenerateReportRequest(BaseModel):
+    """Request schema for full report generation."""
+    template_id: str
+    data: Dict[str, str]
+
+
 @router.post("/generate-content")
 async def generate_section_content(
     request: GenerateContentRequest,
@@ -56,3 +64,49 @@ async def generate_section_content(
             status_code=500,
             detail=f"Error generating content: {str(e)}"
         )
+
+
+@router.post("/generate")
+async def generate_report(
+    request: GenerateReportRequest,
+    current_user: Optional[User] = Depends(get_current_user_optional)
+):
+    """
+    Generate a full report and return its ID.
+    """
+    try:
+        user_id = current_user.id if current_user else None
+        report_id = report_generation_service.generate_full_pdf(
+            template_id=request.template_id,
+            data=request.data,
+            user_id=user_id
+        )
+        return {"report_id": report_id, "success": True}
+    except Exception as e:
+        print(f"Error generating report: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(e)
+        )
+
+
+@router.get("/download-pdf/{report_id}")
+async def download_report_pdf(
+    report_id: str,
+    db: Session = Depends(get_db)
+):
+    """
+    Download a generated PDF report.
+    """
+    report = db.query(Report).filter(Report.id == report_id).first()
+    if not report:
+        raise HTTPException(status_code=404, detail="Report not found")
+        
+    if not os.path.exists(report.file_path):
+        raise HTTPException(status_code=404, detail="Report file not found")
+        
+    return FileResponse(
+        path=report.file_path,
+        filename=report.filename,
+        media_type="application/pdf"
+    )

app/services/report_service.py

@@ -1,7 +1,8 @@
 """
 Service for AI-powered report content generation.
 """
-from typing import Dict
+from typing import Dict, Optional
+import uuid
 from app.llm.client import llm_client
 
 
@@ -139,5 +140,97 @@ Return ONLY the content:"""
             return f"Error generating content for {section_name}. Please try again or edit manually."
 
 
+    @staticmethod
+    def generate_full_pdf(
+        template_id: str,
+        data: Dict[str, str],
+        user_id: Optional[str] = None
+    ) -> str:
+        """
+        Generate a full PDF report from an HTML template.
+        
+        Args:
+            template_id: ID of the template to use
+            data: Data to populate the template with
+            user_id: Optional user ID
+            
+        Returns:
+            ID of the generated report record
+        """
+        import os
+        from xhtml2pdf import pisa
+        from app.database.models import Report
+        from app.database.connection import SessionLocal
+        from datetime import datetime
+        
+        template_map = {
+            'property_evaluation': 'property-evaluation.html',
+            'investor_pitch_deck': 'investor-pitch-deck.html',
+            'legal_compliance': 'legal-compliance.html'
+        }
+        
+        template_file = template_map.get(template_id)
+        if not template_file:
+            raise ValueError(f"Template {template_id} not found")
+            
+        # Get absolute path to template
+        base_dir = os.path.dirname(os.path.dirname(__file__))
+        template_path = os.path.join(base_dir, "templates", template_file)
+        
+        if not os.path.exists(template_path):
+            raise FileNotFoundError(f"Template file not found at {template_path}")
+            
+        # Load template
+        with open(template_path, "r", encoding="utf-8") as f:
+            template_html = f.read()
+            
+        # Populate template (simple replacement)
+        populated_html = template_html
+        
+        # Add date
+        today = datetime.now().strftime("%d %b %Y")
+        populated_html = populated_html.replace("{{DATE}}", today)
+        
+        # Add data placeholders
+        for key, value in data.items():
+            placeholder = f"{{{{{key.upper()}}}}}"
+            populated_html = populated_html.replace(placeholder, str(value or ""))
+            
+        # Remove AI buttons and other non-print elements
+        populated_html = populated_html.replace('<button class="ai-button"', '<div style="display:none"')
+        populated_html = populated_html.replace('</button>', '</div>')
+        
+        # Define output path
+        reports_dir = os.path.join(os.getcwd(), "data", "generated_reports")
+        os.makedirs(reports_dir, exist_ok=True)
+        
+        report_id = str(uuid.uuid4())
+        filename = f"{template_id}_{report_id}.pdf"
+        file_path = os.path.join(reports_dir, filename)
+        
+        # Generate PDF
+        with open(file_path, "wb") as pdf_file:
+            pisa_status = pisa.CreatePDF(populated_html, dest=pdf_file)
+            
+        if pisa_status.err:
+            raise RuntimeError(f"PDF generation failed: {pisa_status.err}")
+            
+        # Save to database
+        db = SessionLocal()
+        try:
+            report_record = Report(
+                id=report_id,
+                user_id=user_id,
+                template_id=template_id,
+                filename=filename,
+                file_path=file_path
+            )
+            db.add(report_record)
+            db.commit()
+            return report_id
+        finally:
+            db.close()
+
+
 # Global service instance
 report_generation_service = ReportGenerationService()