Update endpoints.py

endpoints.py

@@ -75,9 +75,22 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
                 patient = await patients_collection.find_one({"fhir_id": analysis.get("patient_id")})
                 if not patient:
                     continue  # Skip if patient no longer exists
-                analysis["full_name"] = patient.get("full_name", "Unknown")
-                analysis["_id"] = str(analysis["_id"])
-                enriched_results.append(analysis)
+                
+                # Format the response to match the expected structure
+                formatted_analysis = {
+                    "_id": str(analysis["_id"]),
+                    "patient_id": analysis.get("patient_id"),
+                    "full_name": patient.get("full_name", "Unknown"),
+                    "timestamp": analysis.get("timestamp"),
+                    "suicide_risk": {
+                        "level": analysis.get("suicide_risk", {}).get("level", "none"),
+                        "score": analysis.get("suicide_risk", {}).get("score", 0.0),
+                        "factors": analysis.get("suicide_risk", {}).get("factors", [])
+                    },
+                    "summary": analysis.get("summary", ""),
+                    "recommendations": analysis.get("recommendations", [])
+                }
+                enriched_results.append(formatted_analysis)
 
             return enriched_results
 
@@ -85,6 +98,68 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
             logger.error(f"Error fetching analysis results: {e}")
             raise HTTPException(status_code=500, detail="Failed to retrieve analysis results")
 
+    @router.post("/patients/analyze")
+    async def analyze_patients(
+        current_user: dict = Depends(get_current_user)
+    ):
+        """Trigger analysis for all patients"""
+        logger.info(f"Triggering analysis for all patients by {current_user['email']}")
+        try:
+            # Get all patients
+            patients = await patients_collection.find({}).to_list(length=None)
+            
+            if not patients:
+                return {"message": "No patients found to analyze", "analyzed_count": 0}
+            
+            analyzed_count = 0
+            for patient in patients:
+                try:
+                    from analysis import analyze_patient
+                    await analyze_patient(patient)
+                    analyzed_count += 1
+                    logger.info(f"✅ Analyzed patient: {patient.get('full_name', 'Unknown')}")
+                except Exception as e:
+                    logger.error(f"❌ Failed to analyze patient {patient.get('full_name', 'Unknown')}: {e}")
+                    continue
+            
+            return {
+                "message": f"Analysis completed for {analyzed_count} patients",
+                "analyzed_count": analyzed_count,
+                "total_patients": len(patients)
+            }
+            
+        except Exception as e:
+            logger.error(f"Error triggering analysis: {e}")
+            raise HTTPException(status_code=500, detail="Failed to trigger analysis")
+
+    @router.post("/patients/{patient_id}/analyze")
+    async def analyze_specific_patient(
+        patient_id: str = Path(..., description="The ID of the patient to analyze"),
+        current_user: dict = Depends(get_current_user)
+    ):
+        """Trigger analysis for a specific patient"""
+        logger.info(f"Triggering analysis for patient {patient_id} by {current_user['email']}")
+        try:
+            # Get the patient
+            patient = await patients_collection.find_one({"fhir_id": patient_id})
+            
+            if not patient:
+                raise HTTPException(status_code=404, detail="Patient not found")
+            
+            # Analyze the patient
+            from analysis import analyze_patient
+            await analyze_patient(patient)
+            
+            return {
+                "message": f"Analysis completed for patient {patient.get('full_name', 'Unknown')}",
+                "patient_id": patient_id,
+                "patient_name": patient.get("full_name", "Unknown")
+            }
+            
+        except Exception as e:
+            logger.error(f"Error analyzing patient {patient_id}: {e}")
+            raise HTTPException(status_code=500, detail="Failed to analyze patient")
+
     @router.get("/patients/{patient_id}/analysis-reports/pdf")
     async def get_patient_analysis_reports_pdf(
         patient_id: str = Path(..., description="The ID of the patient"),
@@ -102,97 +177,109 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
             if not analyses:
                 raise HTTPException(status_code=404, detail="No analysis reports found for this patient")
 
-            # Creating LaTeX document
-            latex_content = r"""
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{lmodern}
-\usepackage{geometry}
-\geometry{margin=1in}
-\usepackage{enumitem}
-\usepackage{fancyhdr}
-\usepackage{lastpage}
-\usepackage{datetime}
-\pagestyle{fancy}
-\fancyhf{}
-\rhead{Patient Analysis Report}
-\lhead{\today}
-\cfoot{Page \thepage\ of \pageref{LastPage}}
-\begin{document}
-"""
-
-            # Adding patient information
+            # Generate PDF using ReportLab
+            try:
+                from reportlab.lib.pagesizes import A4
+                from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+                from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+                from reportlab.lib.units import inch
+                from reportlab.lib import colors
+                from io import BytesIO
+            except ImportError:
+                logger.error("ReportLab not available, falling back to text report")
+                raise HTTPException(status_code=500, detail="PDF generation not available")
+
+            logger.info("📄 Generating PDF report using ReportLab")
+            buffer = BytesIO()
+            doc = SimpleDocTemplate(buffer, pagesize=A4, rightMargin=72, leftMargin=72, topMargin=72, bottomMargin=18)
+            story = []
+            styles = getSampleStyleSheet()
+
+            # Custom styles
+            title_style = ParagraphStyle(
+                'CustomTitle', 
+                parent=styles['Heading1'], 
+                fontSize=18, 
+                spaceAfter=30, 
+                alignment=1,
+                textColor=colors.darkblue
+            )
+            
+            heading_style = ParagraphStyle(
+                'CustomHeading', 
+                parent=styles['Heading2'], 
+                fontSize=14, 
+                spaceAfter=12, 
+                spaceBefore=20,
+                textColor=colors.darkblue
+            )
+            
+            normal_style = styles['Normal']
+
+            # Title
             patient_name = patient.get("full_name", "Unknown")
-            latex_content += f"""
-\\section*{{Analysis Reports for {patient_name} (ID: {patient_id})}}
-\\textbf{{Patient Name:}} {patient_name}\\\\
-\\textbf{{Patient ID:}} {patient_id}\\\\
-\\textbf{{Generated on:}} \\today\\\\
-"""
-
-            # Adding analysis reports
+            story.append(Paragraph(f"PATIENT ANALYSIS REPORT", title_style))
+            story.append(Paragraph(f"Patient: {patient_name}", normal_style))
+            story.append(Paragraph(f"Generated on {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')}", normal_style))
+            story.append(Spacer(1, 20))
+
+            # Analysis Reports
             for idx, analysis in enumerate(analyses, 1):
                 timestamp = analysis.get("timestamp", datetime.utcnow()).strftime("%Y-%m-%d %H:%M:%S")
                 suicide_risk = analysis.get("suicide_risk", {})
                 risk_level = suicide_risk.get("level", "none").capitalize()
                 risk_score = suicide_risk.get("score", 0.0)
-                risk_factors = ", ".join(suicide_risk.get("factors", [])) or "None"
+                risk_factors = suicide_risk.get("factors", [])
+                
+                story.append(Paragraph(f"Report {idx} - {timestamp}", heading_style))
+                
+                # Risk Assessment Table
+                risk_data = [
+                    ["Risk Level", risk_level],
+                    ["Risk Score", f"{risk_score:.2f}"],
+                    ["Risk Factors", ", ".join(risk_factors) if risk_factors else "None"]
+                ]
+                
+                risk_table = Table(risk_data, colWidths=[2*inch, 4*inch])
+                risk_table.setStyle(TableStyle([
+                    ('BACKGROUND', (0, 0), (0, -1), colors.lightblue),
+                    ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+                    ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                    ('FONTNAME', (0, 0), (-1, -1), 'Helvetica'),
+                    ('FONTSIZE', (0, 0), (-1, -1), 10),
+                    ('BOTTOMPADDING', (0, 0), (-1, -1), 12),
+                    ('BACKGROUND', (1, 0), (1, -1), colors.beige),
+                    ('GRID', (0, 0), (-1, -1), 1, colors.black)
+                ]))
                 
-                latex_content += f"""
-\\subsection*{{Report {idx} - {timestamp}}}
-\\begin{{description}}
-    \\item[Risk Level:] {risk_level}
-    \\item[Risk Score:] {risk_score:.2f}
-    \\item[Risk Factors:] {risk_factors}
-"""
-
-                # Adding additional analysis details if available
+                story.append(risk_table)
+                story.append(Spacer(1, 12))
+
+                # Summary and Recommendations
                 if analysis.get("summary"):
-                    latex_content += f"    \\item[Summary:] {analysis['summary']}\n"
+                    story.append(Paragraph("Summary:", heading_style))
+                    story.append(Paragraph(str(analysis["summary"]), normal_style))
+                    story.append(Spacer(1, 12))
+                
                 if analysis.get("recommendations"):
-                    recommendations = ", ".join(analysis["recommendations"]) if isinstance(analysis["recommendations"], list) else analysis["recommendations"]
-                    latex_content += f"    \\item[Recommendations:] {recommendations}\n"
-
-                latex_content += r"\end{description}\vspace{0.5cm}"
-
-            latex_content += r"\end{document}"
-
-            # Creating temporary directory for LaTeX compilation
-            with tempfile.TemporaryDirectory() as tmpdirname:
-                latex_file = PathLib(tmpdirname) / "report.tex"
-                pdf_file = PathLib(tmpdirname) / "report.pdf"
-
-                # Writing LaTeX content to file
-                with open(latex_file, "w", encoding="utf-8") as f:
-                    f.write(latex_content)
-
-                # Compiling LaTeX to PDF using pdflatex
-                try:
-                    subprocess.run(
-                        ["pdflatex", "-output-directory", tmpdirname, str(latex_file)],
-                        check=True,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
-                        text=True
-                    )
-                except subprocess.CalledProcessError as e:
-                    logger.error(f"LaTeX compilation failed: {e.stderr}")
-                    raise HTTPException(status_code=500, detail="Failed to generate PDF report")
-
-                if not pdf_file.exists():
-                    raise HTTPException(status_code=500, detail="PDF generation failed")
-
-                # Reading the generated PDF
-                with open(pdf_file, "rb") as f:
-                    pdf_content = f.read()
-
-                # Returning the PDF as a response
-                return FileResponse(
-                    pdf_file,
-                    media_type="application/pdf",
-                    headers={"Content-Disposition": f"attachment; filename={patient_name.replace(' ', '_')}_{patient_id}_analysis_reports.pdf"}
-                )
+                    recommendations = analysis["recommendations"]
+                    if isinstance(recommendations, list):
+                        recommendations = ", ".join(recommendations)
+                    story.append(Paragraph("Recommendations:", heading_style))
+                    story.append(Paragraph(str(recommendations), normal_style))
+                    story.append(Spacer(1, 20))
+
+            # Build PDF
+            doc.build(story)
+            pdf_content = buffer.getvalue()
+            buffer.close()
+
+            # Return PDF as response
+            return StreamingResponse(
+                io.BytesIO(pdf_content),
+                media_type="application/pdf",
+                headers={"Content-Disposition": f"attachment; filename={patient_name.replace(' ', '_')}_{patient_id}_analysis_reports.pdf"}
+            )
 
         except HTTPException:
             raise
@@ -211,27 +298,58 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
             if not patients:
                 raise HTTPException(status_code=404, detail="No patients found")
 
-            # Creating LaTeX document
-            latex_content = r"""
-\documentclass[a4paper,12pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
-\usepackage{lmodern}
-\usepackage{geometry}
-\geometry{margin=1in}
-\usepackage{enumitem}
-\usepackage{fancyhdr}
-\usepackage{lastpage}
-\usepackage{datetime}
-\pagestyle{fancy}
-\fancyhf{}
-\rhead{All Patients Analysis Reports}
-\lhead{\today}
-\cfoot{Page \thepage\ of \pageref{LastPage}}
-\begin{document}
-\section*{Analysis Reports for All Patients}
-\textbf{Generated on:} \today\\\\
-"""
+            # Generate PDF using ReportLab
+            try:
+                from reportlab.lib.pagesizes import A4
+                from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
+                from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+                from reportlab.lib.units import inch
+                from reportlab.lib import colors
+                from io import BytesIO
+            except ImportError:
+                logger.error("ReportLab not available, falling back to text report")
+                raise HTTPException(status_code=500, detail="PDF generation not available")
+
+            logger.info("📄 Generating PDF report for all patients using ReportLab")
+            buffer = BytesIO()
+            doc = SimpleDocTemplate(buffer, pagesize=A4, rightMargin=72, leftMargin=72, topMargin=72, bottomMargin=18)
+            story = []
+            styles = getSampleStyleSheet()
+
+            # Custom styles
+            title_style = ParagraphStyle(
+                'CustomTitle', 
+                parent=styles['Heading1'], 
+                fontSize=20, 
+                spaceAfter=30, 
+                alignment=1,
+                textColor=colors.darkblue
+            )
+            
+            patient_heading_style = ParagraphStyle(
+                'PatientHeading', 
+                parent=styles['Heading2'], 
+                fontSize=16, 
+                spaceAfter=15, 
+                spaceBefore=25,
+                textColor=colors.darkgreen
+            )
+            
+            report_heading_style = ParagraphStyle(
+                'ReportHeading', 
+                parent=styles['Heading3'], 
+                fontSize=12, 
+                spaceAfter=10, 
+                spaceBefore=15,
+                textColor=colors.darkblue
+            )
+            
+            normal_style = styles['Normal']
+
+            # Title
+            story.append(Paragraph("ALL PATIENTS ANALYSIS REPORTS", title_style))
+            story.append(Paragraph(f"Generated on {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')}", normal_style))
+            story.append(Spacer(1, 30))
 
             # Flag to track if any analyses exist
             has_analyses = False
@@ -248,78 +366,73 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
 
                 has_analyses = True
 
-                # Adding patient section
-                latex_content += f"""
-\\section*{{Patient: {patient_name} (ID: {patient_id})}}
-\\textbf{{Patient Name:}} {patient_name}\\\\
-\\textbf{{Patient ID:}} {patient_id}\\\\
-"""
+                # Patient section
+                story.append(Paragraph(f"Patient: {patient_name}", patient_heading_style))
+                story.append(Spacer(1, 10))
 
-                # Adding analysis reports for the patient
+                # Analysis Reports for this patient
                 for idx, analysis in enumerate(analyses, 1):
                     timestamp = analysis.get("timestamp", datetime.utcnow()).strftime("%Y-%m-%d %H:%M:%S")
                     suicide_risk = analysis.get("suicide_risk", {})
                     risk_level = suicide_risk.get("level", "none").capitalize()
                     risk_score = suicide_risk.get("score", 0.0)
-                    risk_factors = ", ".join(suicide_risk.get("factors", [])) or "None"
-
-                    latex_content += f"""
-\\subsection*{{Report {idx} - {timestamp}}}
-\\begin{{description}}
-    \\item[Risk Level:] {risk_level}
-    \\item[Risk Score:] {risk_score:.2f}
-    \\item[Risk Factors:] {risk_factors}
-"""
-
-                    # Adding additional analysis details if available
+                    risk_factors = suicide_risk.get("factors", [])
+                    
+                    story.append(Paragraph(f"Report {idx} - {timestamp}", report_heading_style))
+                    
+                    # Risk Assessment Table
+                    risk_data = [
+                        ["Risk Level", risk_level],
+                        ["Risk Score", f"{risk_score:.2f}"],
+                        ["Risk Factors", ", ".join(risk_factors) if risk_factors else "None"]
+                    ]
+                    
+                    risk_table = Table(risk_data, colWidths=[2*inch, 4*inch])
+                    risk_table.setStyle(TableStyle([
+                        ('BACKGROUND', (0, 0), (0, -1), colors.lightblue),
+                        ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+                        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                        ('FONTNAME', (0, 0), (-1, -1), 'Helvetica'),
+                        ('FONTSIZE', (0, 0), (-1, -1), 9),
+                        ('BOTTOMPADDING', (0, 0), (-1, -1), 8),
+                        ('BACKGROUND', (1, 0), (1, -1), colors.beige),
+                        ('GRID', (0, 0), (-1, -1), 1, colors.black)
+                    ]))
+                    
+                    story.append(risk_table)
+                    story.append(Spacer(1, 10))
+
+                    # Summary and Recommendations
                     if analysis.get("summary"):
-                        latex_content += f"    \\item[Summary:] {analysis['summary']}\n"
+                        story.append(Paragraph("Summary:", report_heading_style))
+                        story.append(Paragraph(str(analysis["summary"]), normal_style))
+                        story.append(Spacer(1, 10))
+                    
                     if analysis.get("recommendations"):
-                        recommendations = ", ".join(analysis["recommendations"]) if isinstance(analysis["recommendations"], list) else analysis["recommendations"]
-                        latex_content += f"    \\item[Recommendations:] {recommendations}\n"
-
-                    latex_content += r"\end{description}\vspace{0.5cm}"
+                        recommendations = analysis["recommendations"]
+                        if isinstance(recommendations, list):
+                            recommendations = ", ".join(recommendations)
+                        story.append(Paragraph("Recommendations:", report_heading_style))
+                        story.append(Paragraph(str(recommendations), normal_style))
+                        story.append(Spacer(1, 15))
 
-            latex_content += r"\end{document}"
+                # Add page break between patients
+                story.append(PageBreak())
 
             if not has_analyses:
                 raise HTTPException(status_code=404, detail="No analysis reports found for any patients")
 
-            # Creating temporary directory for LaTeX compilation
-            with tempfile.TemporaryDirectory() as tmpdirname:
-                latex_file = PathLib(tmpdirname) / "all_reports.tex"
-                pdf_file = PathLib(tmpdirname) / "all_reports.pdf"
+            # Build PDF
+            doc.build(story)
+            pdf_content = buffer.getvalue()
+            buffer.close()
 
-                # Writing LaTeX content to file
-                with open(latex_file, "w", encoding="utf-8") as f:
-                    f.write(latex_content)
-
-                # Compiling LaTeX to PDF using pdflatex
-                try:
-                    subprocess.run(
-                        ["pdflatex", "-output-directory", tmpdirname, str(latex_file)],
-                        check=True,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
-                        text=True
-                    )
-                except subprocess.CalledProcessError as e:
-                    logger.error(f"LaTeX compilation failed: {e.stderr}")
-                    raise HTTPException(status_code=500, detail="Failed to generate PDF report")
-
-                if not pdf_file.exists():
-                    raise HTTPException(status_code=500, detail="PDF generation failed")
-
-                # Reading the generated PDF
-                with open(pdf_file, "rb") as f:
-                    pdf_content = f.read()
-
-                # Returning the PDF as a response
-                return FileResponse(
-                    pdf_file,
-                    media_type="application/pdf",
-                    headers={"Content-Disposition": f"attachment; filename=all_patients_analysis_reports_{datetime.utcnow().strftime('%Y%m%d')}.pdf"}
-                )
+            # Return PDF as response
+            return StreamingResponse(
+                io.BytesIO(pdf_content),
+                media_type="application/pdf",
+                headers={"Content-Disposition": f"attachment; filename=all_patients_analysis_reports_{datetime.utcnow().strftime('%Y%m%d')}.pdf"}
+            )
 
         except HTTPException:
             raise