device token

api/routes/patients.py

@@ -6,7 +6,8 @@ from utils.helpers import calculate_age, standardize_language
 from models.entities import Note, PatientCreate
 from models.schemas import PatientListResponse  # Fixed import
 from api.services.fhir_integration import HAPIFHIRIntegrationService
-from datetime import datetime
+from api.services.synthea_integration import SyntheaIntegrationService
+from datetime import datetime, timedelta
 from bson import ObjectId
 from bson.errors import InvalidId
 from typing import Optional, List, Dict, Any
@@ -755,6 +756,131 @@ async def get_patients(
             detail=f"Error fetching patients: {str(e)}"
         )
 
+@router.get("/patients/ehr-systems")
+async def get_ehr_systems(current_user: dict = Depends(get_current_user)):
+    """
+    Get available EHR systems and their configurations
+    """
+    ehr_systems = [
+        {
+            "id": "epic",
+            "name": "Epic",
+            "description": "Epic EHR System",
+            "base_url": "https://fhir.epic.com/api/FHIR/R4",
+            "auth_type": "oauth2",
+            "supported_resources": ["Patient", "Condition", "Medication", "Observation"],
+            "field_mapping": {
+                "full_name": "name[0].text",
+                "date_of_birth": "birthDate",
+                "gender": "gender",
+                "address": "address[0].text",
+                "national_id": "identifier[?type.coding[0].code=='SS'].value",
+                "blood_type": "extension[?url=='http://hl7.org/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
+                "allergies": "allergyIntolerance[].substance.text",
+                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
+                "medications": "medicationRequest[].medicationCodeableConcept.text",
+                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
+                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
+                "insurance_provider": "coverage[].payor[0].display",
+                "insurance_policy_number": "coverage[].subscriberId"
+            }
+        },
+        {
+            "id": "cerner",
+            "name": "Cerner",
+            "description": "Cerner EHR System",
+            "base_url": "https://fhir.cerner.com/millennium/r4",
+            "auth_type": "oauth2",
+            "supported_resources": ["Patient", "Condition", "Medication", "Observation"],
+            "field_mapping": {
+                "full_name": "name[0].text",
+                "date_of_birth": "birthDate",
+                "gender": "gender",
+                "address": "address[0].text",
+                "national_id": "identifier[?type.coding[0].code=='SS'].value",
+                "blood_type": "extension[?url=='http://cerner.com/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
+                "allergies": "allergyIntolerance[].substance.text",
+                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
+                "medications": "medicationRequest[].medicationCodeableConcept.text",
+                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
+                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
+                "insurance_provider": "coverage[].payor[0].display",
+                "insurance_policy_number": "coverage[].subscriberId"
+            }
+        },
+        {
+            "id": "allscripts",
+            "name": "Allscripts",
+            "description": "Allscripts EHR System",
+            "base_url": "https://fhir.allscripts.com/r4",
+            "auth_type": "oauth2",
+            "supported_resources": ["Patient", "Condition", "Medication", "Observation"],
+            "field_mapping": {
+                "full_name": "name[0].text",
+                "date_of_birth": "birthDate",
+                "gender": "gender",
+                "address": "address[0].text",
+                "national_id": "identifier[?type.coding[0].code=='SS'].value",
+                "blood_type": "extension[?url=='http://allscripts.com/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
+                "allergies": "allergyIntolerance[].substance.text",
+                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
+                "medications": "medicationRequest[].medicationCodeableConcept.text",
+                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
+                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
+                "insurance_provider": "coverage[].payor[0].display",
+                "insurance_policy_number": "coverage[].subscriberId"
+            }
+        },
+        {
+            "id": "meditech",
+            "name": "Meditech",
+            "description": "Meditech EHR System",
+            "base_url": "https://fhir.meditech.com/r4",
+            "auth_type": "oauth2",
+            "supported_resources": ["Patient", "Condition", "Medication", "Observation"],
+            "field_mapping": {
+                "full_name": "name[0].text",
+                "date_of_birth": "birthDate",
+                "gender": "gender",
+                "address": "address[0].text",
+                "national_id": "identifier[?type.coding[0].code=='SS'].value",
+                "blood_type": "extension[?url=='http://meditech.com/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
+                "allergies": "allergyIntolerance[].substance.text",
+                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
+                "medications": "medicationRequest[].medicationCodeableConcept.text",
+                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
+                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
+                "insurance_provider": "coverage[].payor[0].display",
+                "insurance_policy_number": "coverage[].subscriberId"
+            }
+        },
+        {
+            "id": "hapi_fhir_test",
+            "name": "HAPI FHIR Test Server",
+            "description": "Public HAPI FHIR Test Server for development and testing",
+            "base_url": "https://hapi.fhir.org/baseR4",
+            "auth_type": "none",
+            "supported_resources": ["Patient", "Condition", "Medication", "Observation", "AllergyIntolerance"],
+            "field_mapping": {
+                "full_name": "name[0].text",
+                "date_of_birth": "birthDate",
+                "gender": "gender",
+                "address": "address[0].text",
+                "national_id": "identifier[?type.coding[0].code=='SS'].value",
+                "blood_type": "extension[?url=='http://hl7.org/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
+                "allergies": "allergyIntolerance[].substance.text",
+                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
+                "medications": "medicationRequest[].medicationCodeableConcept.text",
+                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
+                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
+                "insurance_provider": "coverage[].payor[0].display",
+                "insurance_policy_number": "coverage[].subscriberId"
+            }
+        }
+    ]
+    
+    return {"ehr_systems": ehr_systems}
+
 @router.get("/patients/{patient_id}", response_model=dict)
 async def get_patient(patient_id: str):
     logger.info(f"Retrieving patient: {patient_id}")
@@ -1192,130 +1318,7 @@ async def get_hapi_statistics(
             detail=f"Failed to get HAPI FHIR statistics: {str(e)}"
         )
 
-@router.get("/patients/ehr-systems")
-async def get_ehr_systems(current_user: dict = Depends(get_current_user)):
-    """
-    Get available EHR systems and their configurations
-    """
-    ehr_systems = [
-        {
-            "id": "epic",
-            "name": "Epic",
-            "description": "Epic EHR System",
-            "base_url": "https://fhir.epic.com/api/FHIR/R4",
-            "auth_type": "oauth2",
-            "supported_resources": ["Patient", "Condition", "Medication", "Observation"],
-            "field_mapping": {
-                "full_name": "name[0].text",
-                "date_of_birth": "birthDate",
-                "gender": "gender",
-                "address": "address[0].text",
-                "national_id": "identifier[?type.coding[0].code=='SS'].value",
-                "blood_type": "extension[?url=='http://hl7.org/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
-                "allergies": "allergyIntolerance[].substance.text",
-                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
-                "medications": "medicationRequest[].medicationCodeableConcept.text",
-                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
-                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
-                "insurance_provider": "coverage[].payor[0].display",
-                "insurance_policy_number": "coverage[].subscriberId"
-            }
-        },
-        {
-            "id": "cerner",
-            "name": "Cerner",
-            "description": "Cerner EHR System",
-            "base_url": "https://fhir.cerner.com/millennium/r4",
-            "auth_type": "oauth2",
-            "supported_resources": ["Patient", "Condition", "Medication", "Observation"],
-            "field_mapping": {
-                "full_name": "name[0].text",
-                "date_of_birth": "birthDate",
-                "gender": "gender",
-                "address": "address[0].text",
-                "national_id": "identifier[?type.coding[0].code=='SS'].value",
-                "blood_type": "extension[?url=='http://cerner.com/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
-                "allergies": "allergyIntolerance[].substance.text",
-                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
-                "medications": "medicationRequest[].medicationCodeableConcept.text",
-                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
-                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
-                "insurance_provider": "coverage[].payor[0].display",
-                "insurance_policy_number": "coverage[].subscriberId"
-            }
-        },
-        {
-            "id": "allscripts",
-            "name": "Allscripts",
-            "description": "Allscripts EHR System",
-            "base_url": "https://fhir.allscripts.com/r4",
-            "auth_type": "oauth2",
-            "supported_resources": ["Patient", "Condition", "Medication", "Observation"],
-            "field_mapping": {
-                "full_name": "name[0].text",
-                "date_of_birth": "birthDate",
-                "gender": "gender",
-                "address": "address[0].text",
-                "national_id": "identifier[?type.coding[0].code=='SS'].value",
-                "blood_type": "extension[?url=='http://allscripts.com/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
-                "allergies": "allergyIntolerance[].substance.text",
-                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
-                "medications": "medicationRequest[].medicationCodeableConcept.text",
-                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
-                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
-                "insurance_provider": "coverage[].payor[0].display",
-                "insurance_policy_number": "coverage[].subscriberId"
-            }
-        },
-        {
-            "id": "meditech",
-            "name": "Meditech",
-            "description": "Meditech EHR System",
-            "base_url": "https://fhir.meditech.com/r4",
-            "auth_type": "oauth2",
-            "supported_resources": ["Patient", "Condition", "Medication", "Observation"],
-            "field_mapping": {
-                "full_name": "name[0].text",
-                "date_of_birth": "birthDate",
-                "gender": "gender",
-                "address": "address[0].text",
-                "national_id": "identifier[?type.coding[0].code=='SS'].value",
-                "blood_type": "extension[?url=='http://meditech.com/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
-                "allergies": "allergyIntolerance[].substance.text",
-                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
-                "medications": "medicationRequest[].medicationCodeableConcept.text",
-                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
-                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
-                "insurance_provider": "coverage[].payor[0].display",
-                "insurance_policy_number": "coverage[].subscriberId"
-            }
-        },
-        {
-            "id": "hapi_fhir_test",
-            "name": "HAPI FHIR Test Server",
-            "description": "Public HAPI FHIR Test Server for development and testing",
-            "base_url": "https://hapi.fhir.org/baseR4",
-            "auth_type": "none",
-            "supported_resources": ["Patient", "Condition", "Medication", "Observation", "AllergyIntolerance"],
-            "field_mapping": {
-                "full_name": "name[0].text",
-                "date_of_birth": "birthDate",
-                "gender": "gender",
-                "address": "address[0].text",
-                "national_id": "identifier[?type.coding[0].code=='SS'].value",
-                "blood_type": "extension[?url=='http://hl7.org/fhir/StructureDefinition/patient-bloodType'].valueCodeableConcept.text",
-                "allergies": "allergyIntolerance[].substance.text",
-                "chronic_conditions": "condition[?category.coding[0].code=='problem-list-item'].code.text",
-                "medications": "medicationRequest[].medicationCodeableConcept.text",
-                "emergency_contact_name": "contact[?relationship[0].coding[0].code=='emergency'].name.text",
-                "emergency_contact_phone": "contact[?relationship[0].coding[0].code=='emergency'].telecom[?system=='phone'].value",
-                "insurance_provider": "coverage[].payor[0].display",
-                "insurance_policy_number": "coverage[].subscriberId"
-            }
-        }
-    ]
-    
-    return {"ehr_systems": ehr_systems}
+
 
 @router.post("/patients/fetch-ehr-data")
 async def fetch_ehr_data(
@@ -1486,5 +1489,239 @@ def generate_sample_ehr_data(ehr_system: str, limit: int) -> List[dict]:
     
     return data
 
+@router.post("/patients/generate-synthea", status_code=status.HTTP_201_CREATED)
+async def generate_synthea_patients(
+    population: int = Query(10, ge=1, le=100, description="Number of patients to generate"),
+    age_min: int = Query(18, ge=0, le=120, description="Minimum age for generated patients"),
+    age_max: int = Query(80, ge=0, le=120, description="Maximum age for generated patients"),
+    gender: str = Query("both", description="Gender distribution: male, female, or both"),
+    location: str = Query("Massachusetts", description="Location for generated patients"),
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Generate synthetic patient data using Synthea FHIR
+    """
+    logger.info(f"🎯 Generating {population} Synthea patients by user {current_user.get('email')}")
+    
+    if not any(role in current_user.get('roles', []) for role in ['admin', 'doctor']):
+        logger.warning(f"Unauthorized Synthea generation attempt by {current_user.get('email')}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only administrators and doctors can generate synthetic data"
+        )
+    
+    try:
+        service = SyntheaIntegrationService()
+        result = await service.generate_and_import_patients(
+            population=population,
+            age_min=age_min,
+            age_max=age_max,
+            gender=gender,
+            location=location
+        )
+        
+        return {
+            "message": f"Successfully generated {result['generated_patients']} synthetic patients",
+            "generated_count": result['generated_patients'],
+            "config": result['config'],
+            "output_directory": result['output_directory'],
+            "patients_ready_for_import": len(result['patients'])
+        }
+        
+    except Exception as e:
+        logger.error(f"Error generating Synthea patients: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to generate Synthea patients: {str(e)}"
+        )
+
+@router.post("/patients/import-synthea", status_code=status.HTTP_201_CREATED)
+async def import_synthea_patients(
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Import previously generated Synthea patients into the database
+    """
+    logger.info(f"📥 Importing Synthea patients by user {current_user.get('email')}")
+    
+    if not any(role in current_user.get('roles', []) for role in ['admin', 'doctor']):
+        logger.warning(f"Unauthorized Synthea import attempt by {current_user.get('email')}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only administrators and doctors can import synthetic data"
+        )
+    
+    try:
+        service = SyntheaIntegrationService()
+        patients = await service.process_synthea_output()
+        
+        if not patients:
+            return {
+                "message": "No Synthea patients found to import",
+                "imported_count": 0,
+                "skipped_count": 0,
+                "errors": []
+            }
+        
+        imported_count = 0
+        skipped_count = 0
+        errors = []
+        
+        for patient_data in patients:
+            try:
+                # Check for existing patient by FHIR ID
+                existing_patient = await patients_collection.find_one({
+                    "fhir_id": patient_data['fhir_id']
+                })
+                
+                if existing_patient:
+                    skipped_count += 1
+                    continue
+                
+                # Insert patient
+                result = await patients_collection.insert_one(patient_data)
+                imported_count += 1
+                
+                logger.info(f"Imported Synthea patient {patient_data['full_name']} with FHIR ID {patient_data['fhir_id']}")
+                
+            except Exception as e:
+                error_msg = f"Error importing patient {patient_data.get('full_name', 'Unknown')}: {str(e)}"
+                errors.append(error_msg)
+                logger.error(error_msg)
+        
+        return {
+            "message": f"Import completed: {imported_count} imported, {skipped_count} skipped, {len(errors)} errors",
+            "imported_count": imported_count,
+            "skipped_count": skipped_count,
+            "error_count": len(errors),
+            "errors": errors,
+            "source": "synthea"
+        }
+        
+    except Exception as e:
+        logger.error(f"Error importing Synthea patients: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to import Synthea patients: {str(e)}"
+        )
+
+@router.get("/patients/synthea/statistics")
+async def get_synthea_statistics(
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Get statistics about Synthea-generated data
+    """
+    try:
+        service = SyntheaIntegrationService()
+        stats = await service.get_synthea_statistics()
+        
+        # Get database statistics for Synthea patients
+        db_stats = {
+            "total_synthea_patients": await patients_collection.count_documents({"source": "synthea"}),
+            "recent_synthea_patients": await patients_collection.count_documents({
+                "source": "synthea",
+                "import_date": {"$gte": (datetime.utcnow() - timedelta(days=7)).isoformat()}
+            })
+        }
+        
+        return {
+            "file_statistics": stats,
+            "database_statistics": db_stats
+        }
+        
+    except Exception as e:
+        logger.error(f"Error getting Synthea statistics: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get Synthea statistics: {str(e)}"
+        )
+
+@router.post("/patients/generate-and-import-synthea", status_code=status.HTTP_201_CREATED)
+async def generate_and_import_synthea_patients(
+    population: int = Query(10, ge=1, le=100, description="Number of patients to generate"),
+    age_min: int = Query(18, ge=0, le=120, description="Minimum age for generated patients"),
+    age_max: int = Query(80, ge=0, le=120, description="Maximum age for generated patients"),
+    gender: str = Query("both", description="Gender distribution: male, female, or both"),
+    location: str = Query("Massachusetts", description="Location for generated patients"),
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Generate and immediately import synthetic patient data using Synthea FHIR
+    """
+    logger.info(f"🎯 Generating and importing {population} Synthea patients by user {current_user.get('email')}")
+    
+    if not any(role in current_user.get('roles', []) for role in ['admin', 'doctor']):
+        logger.warning(f"Unauthorized Synthea generation/import attempt by {current_user.get('email')}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only administrators and doctors can generate and import synthetic data"
+        )
+    
+    try:
+        # Step 1: Generate Synthea data
+        service = SyntheaIntegrationService()
+        generation_result = await service.generate_and_import_patients(
+            population=population,
+            age_min=age_min,
+            age_max=age_max,
+            gender=gender,
+            location=location
+        )
+        
+        if not generation_result['patients']:
+            return {
+                "message": "No patients were generated",
+                "generated_count": 0,
+                "imported_count": 0,
+                "skipped_count": 0,
+                "errors": []
+            }
+        
+        # Step 2: Import generated patients
+        imported_count = 0
+        skipped_count = 0
+        errors = []
+        
+        for patient_data in generation_result['patients']:
+            try:
+                # Check for existing patient by FHIR ID
+                existing_patient = await patients_collection.find_one({
+                    "fhir_id": patient_data['fhir_id']
+                })
+                
+                if existing_patient:
+                    skipped_count += 1
+                    continue
+                
+                # Insert patient
+                result = await patients_collection.insert_one(patient_data)
+                imported_count += 1
+                
+                logger.info(f"Imported Synthea patient {patient_data['full_name']} with FHIR ID {patient_data['fhir_id']}")
+                
+            except Exception as e:
+                error_msg = f"Error importing patient {patient_data.get('full_name', 'Unknown')}: {str(e)}"
+                errors.append(error_msg)
+                logger.error(error_msg)
+        
+        return {
+            "message": f"Generation and import completed: {generation_result['generated_patients']} generated, {imported_count} imported, {skipped_count} skipped, {len(errors)} errors",
+            "generated_count": generation_result['generated_patients'],
+            "imported_count": imported_count,
+            "skipped_count": skipped_count,
+            "error_count": len(errors),
+            "errors": errors,
+            "config": generation_result['config'],
+            "source": "synthea"
+        }
+        
+    except Exception as e:
+        logger.error(f"Error in generate and import Synthea patients: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to generate and import Synthea patients: {str(e)}"
+        )
+
 # Export the router as 'patients' for api.__init__.py
 patients = router

api/services/synthea_integration.py

@@ -0,0 +1,444 @@
+import asyncio
+import json
+import logging
+import os
+import subprocess
+import tempfile
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import aiofiles
+import aiohttp
+from fastapi import HTTPException, status
+
+logger = logging.getLogger(__name__)
+
+class SyntheaIntegrationService:
+    """
+    Service for integrating Synthea FHIR data generation with the CPS application
+    """
+    
+    def __init__(self):
+        self.base_dir = Path(__file__).resolve().parent.parent.parent
+        self.synthea_dir = self.base_dir / "synthea"
+        self.output_dir = self.base_dir / "output" / "fhir"
+        self.synthea_jar_path = self.synthea_dir / "synthea-with-dependencies.jar"
+        
+        # Ensure directories exist
+        self.synthea_dir.mkdir(exist_ok=True)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Synthea configuration
+        self.default_config = {
+            "population": 10,
+            "seed": 42,
+            "age_min": 18,
+            "age_max": 80,
+            "gender": "both",  # male, female, both
+            "location": "Massachusetts",  # Default location
+            "modules": ["*"],  # All modules
+            "exporter": "fhir",
+            "exporter.fhir.transaction_bundle": "true",
+            "exporter.fhir.include_patient_summary": "true",
+            "exporter.fhir.include_encounters": "true",
+            "exporter.fhir.include_medications": "true",
+            "exporter.fhir.include_conditions": "true",
+            "exporter.fhir.include_observations": "true",
+            "exporter.fhir.include_procedures": "true",
+            "exporter.fhir.include_immunizations": "true",
+            "exporter.fhir.include_allergies": "true"
+        }
+    
+    async def download_synthea(self) -> bool:
+        """
+        Download Synthea JAR file if not present
+        """
+        if self.synthea_jar_path.exists():
+            logger.info("✅ Synthea JAR already exists")
+            return True
+        
+        try:
+            logger.info("📥 Downloading Synthea...")
+            synthea_url = "https://github.com/synthetichealth/synthea/releases/download/master-branch-latest/synthea-with-dependencies.jar"
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.get(synthea_url) as response:
+                    if response.status == 200:
+                        content = await response.read()
+                        async with aiofiles.open(self.synthea_jar_path, 'wb') as f:
+                            await f.write(content)
+                        logger.info("✅ Synthea downloaded successfully")
+                        return True
+                    else:
+                        logger.error(f"❌ Failed to download Synthea: {response.status}")
+                        return False
+        except Exception as e:
+            logger.error(f"❌ Error downloading Synthea: {str(e)}")
+            return False
+    
+    async def generate_synthea_config(self, config_overrides: Dict[str, Any] = None) -> str:
+        """
+        Generate Synthea configuration file
+        """
+        config = self.default_config.copy()
+        if config_overrides:
+            config.update(config_overrides)
+        
+        config_content = "\n".join([f"{k} = {v}" for k, v in config.items()])
+        config_file = self.synthea_dir / "synthea.properties"
+        
+        async with aiofiles.open(config_file, 'w') as f:
+            await f.write(config_content)
+        
+        return str(config_file)
+    
+    async def run_synthea_generation(self, config_file: str) -> bool:
+        """
+        Run Synthea to generate FHIR data
+        """
+        try:
+            logger.info("🚀 Starting Synthea generation...")
+            
+            # Clear output directory
+            for file in self.output_dir.glob("*.json"):
+                file.unlink()
+            
+            # Run Synthea
+            cmd = [
+                "java", "-jar", str(self.synthea_jar_path),
+                "-c", config_file,
+                "-o", str(self.output_dir)
+            ]
+            
+            process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+            
+            stdout, stderr = await process.communicate()
+            
+            if process.returncode == 0:
+                logger.info("✅ Synthea generation completed successfully")
+                logger.info(f"Output: {stdout.decode()}")
+                return True
+            else:
+                logger.error(f"❌ Synthea generation failed: {stderr.decode()}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ Error running Synthea: {str(e)}")
+            return False
+    
+    async def process_synthea_output(self) -> List[Dict[str, Any]]:
+        """
+        Process Synthea output files and convert to application format
+        """
+        patients = []
+        
+        try:
+            # Find all patient files (excluding hospital and practitioner files)
+            patient_files = [
+                f for f in self.output_dir.glob("*.json")
+                if not any(x in f.name for x in ["hospitalInformation", "practitionerInformation"])
+            ]
+            
+            logger.info(f"📁 Found {len(patient_files)} patient files")
+            
+            for file_path in patient_files:
+                try:
+                    async with aiofiles.open(file_path, 'r') as f:
+                        content = await f.read()
+                        bundle = json.loads(content)
+                    
+                    patient_data = await self._extract_patient_data(bundle, file_path.name)
+                    if patient_data:
+                        patients.append(patient_data)
+                        
+                except Exception as e:
+                    logger.error(f"❌ Error processing {file_path}: {str(e)}")
+                    continue
+            
+            logger.info(f"✅ Processed {len(patients)} patients from Synthea output")
+            return patients
+            
+        except Exception as e:
+            logger.error(f"❌ Error processing Synthea output: {str(e)}")
+            return []
+    
+    async def _extract_patient_data(self, bundle: Dict[str, Any], filename: str) -> Optional[Dict[str, Any]]:
+        """
+        Extract patient data from FHIR bundle
+        """
+        try:
+            patient_data = {}
+            conditions = []
+            medications = []
+            encounters = []
+            observations = []
+            procedures = []
+            immunizations = []
+            allergies = []
+            
+            if 'entry' not in bundle:
+                logger.warning(f"No entries found in bundle: {filename}")
+                return None
+            
+            for entry in bundle.get('entry', []):
+                resource = entry.get('resource', {})
+                resource_type = resource.get('resourceType')
+                
+                if resource_type == 'Patient':
+                    # Extract patient demographics
+                    name = resource.get('name', [{}])[0] if resource.get('name') else {}
+                    address = resource.get('address', [{}])[0] if resource.get('address') else {}
+                    
+                    patient_data = {
+                        'fhir_id': resource.get('id'),
+                        'full_name': f"{' '.join(name.get('given', []))} {name.get('family', '')}".strip(),
+                        'gender': resource.get('gender', 'unknown'),
+                        'date_of_birth': resource.get('birthDate'),
+                        'address': ' '.join(address.get('line', [])) if address.get('line') else '',
+                        'city': address.get('city', ''),
+                        'state': address.get('state', ''),
+                        'postal_code': address.get('postalCode', ''),
+                        'country': address.get('country', ''),
+                        'marital_status': resource.get('maritalStatus', {}).get('text', ''),
+                        'language': self._extract_language(resource),
+                        'source': 'synthea',
+                        'import_date': datetime.utcnow().isoformat(),
+                        'last_updated': datetime.utcnow().isoformat()
+                    }
+                    
+                elif resource_type == 'Condition':
+                    conditions.append({
+                        'id': resource.get('id'),
+                        'code': resource.get('code', {}).get('text', ''),
+                        'status': resource.get('clinicalStatus', {}).get('text', ''),
+                        'onset_date': resource.get('onsetDateTime'),
+                        'recorded_date': resource.get('recordedDate'),
+                        'verification_status': resource.get('verificationStatus', {}).get('text', ''),
+                        'category': resource.get('category', [{}])[0].get('text', '') if resource.get('category') else ''
+                    })
+                    
+                elif resource_type == 'MedicationRequest':
+                    medications.append({
+                        'id': resource.get('id'),
+                        'name': resource.get('medicationCodeableConcept', {}).get('text', ''),
+                        'status': resource.get('status'),
+                        'prescribed_date': resource.get('authoredOn'),
+                        'requester': resource.get('requester', {}).get('display', ''),
+                        'dosage': self._extract_dosage(resource),
+                        'intent': resource.get('intent', ''),
+                        'priority': resource.get('priority', '')
+                    })
+                    
+                elif resource_type == 'Encounter':
+                    encounters.append({
+                        'id': resource.get('id'),
+                        'type': resource.get('type', [{}])[0].get('text', '') if resource.get('type') else '',
+                        'status': resource.get('status'),
+                        'period': resource.get('period', {}),
+                        'service_provider': resource.get('serviceProvider', {}).get('display', ''),
+                        'class': resource.get('class', {}).get('code', ''),
+                        'reason': resource.get('reasonCode', [{}])[0].get('text', '') if resource.get('reasonCode') else ''
+                    })
+                    
+                elif resource_type == 'Observation':
+                    observations.append({
+                        'id': resource.get('id'),
+                        'code': resource.get('code', {}).get('text', ''),
+                        'value': self._extract_observation_value(resource),
+                        'unit': resource.get('valueQuantity', {}).get('unit', ''),
+                        'status': resource.get('status'),
+                        'effective_date': resource.get('effectiveDateTime'),
+                        'category': resource.get('category', [{}])[0].get('text', '') if resource.get('category') else ''
+                    })
+                    
+                elif resource_type == 'Procedure':
+                    procedures.append({
+                        'id': resource.get('id'),
+                        'code': resource.get('code', {}).get('text', ''),
+                        'status': resource.get('status'),
+                        'performed_date': resource.get('performedDateTime'),
+                        'performer': resource.get('performer', [{}])[0].get('actor', {}).get('display', '') if resource.get('performer') else '',
+                        'reason': resource.get('reasonCode', [{}])[0].get('text', '') if resource.get('reasonCode') else ''
+                    })
+                    
+                elif resource_type == 'Immunization':
+                    immunizations.append({
+                        'id': resource.get('id'),
+                        'vaccine': resource.get('vaccineCode', {}).get('text', ''),
+                        'status': resource.get('status'),
+                        'date': resource.get('occurrenceDateTime'),
+                        'lot_number': resource.get('lotNumber', ''),
+                        'expiration_date': resource.get('expirationDate', ''),
+                        'manufacturer': resource.get('manufacturer', {}).get('display', '')
+                    })
+                    
+                elif resource_type == 'AllergyIntolerance':
+                    allergies.append({
+                        'id': resource.get('id'),
+                        'substance': resource.get('code', {}).get('text', ''),
+                        'status': resource.get('clinicalStatus', {}).get('text', ''),
+                        'verification_status': resource.get('verificationStatus', {}).get('text', ''),
+                        'type': resource.get('type', ''),
+                        'category': resource.get('category', []),
+                        'reaction': self._extract_allergy_reactions(resource)
+                    })
+            
+            if patient_data:
+                patient_data.update({
+                    'conditions': conditions,
+                    'medications': medications,
+                    'encounters': encounters,
+                    'observations': observations,
+                    'procedures': procedures,
+                    'immunizations': immunizations,
+                    'allergies': allergies
+                })
+                
+                return patient_data
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"❌ Error extracting patient data from {filename}: {str(e)}")
+            return None
+    
+    def _extract_language(self, patient_resource: Dict[str, Any]) -> str:
+        """Extract language from patient resource"""
+        try:
+            communication = patient_resource.get('communication', [])
+            if communication and communication[0].get('language'):
+                return communication[0]['language'].get('text', 'English')
+            return 'English'
+        except:
+            return 'English'
+    
+    def _extract_dosage(self, medication_resource: Dict[str, Any]) -> str:
+        """Extract dosage information from medication resource"""
+        try:
+            dosage = medication_resource.get('dosageInstruction', [])
+            if dosage and dosage[0].get('text'):
+                return dosage[0]['text']
+            return ''
+        except:
+            return ''
+    
+    def _extract_observation_value(self, observation_resource: Dict[str, Any]) -> str:
+        """Extract observation value"""
+        try:
+            if 'valueQuantity' in observation_resource:
+                value = observation_resource['valueQuantity'].get('value', '')
+                unit = observation_resource['valueQuantity'].get('unit', '')
+                return f"{value} {unit}".strip()
+            elif 'valueCodeableConcept' in observation_resource:
+                return observation_resource['valueCodeableConcept'].get('text', '')
+            elif 'valueString' in observation_resource:
+                return observation_resource['valueString']
+            return ''
+        except:
+            return ''
+    
+    def _extract_allergy_reactions(self, allergy_resource: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Extract allergy reactions"""
+        try:
+            reactions = allergy_resource.get('reaction', [])
+            return [{
+                'manifestation': reaction.get('manifestation', [{}])[0].get('text', '') if reaction.get('manifestation') else '',
+                'severity': reaction.get('severity', ''),
+                'onset': reaction.get('onset', '')
+            } for reaction in reactions]
+        except:
+            return []
+    
+    async def generate_and_import_patients(
+        self, 
+        population: int = 10,
+        age_min: int = 18,
+        age_max: int = 80,
+        gender: str = "both",
+        location: str = "Massachusetts"
+    ) -> Dict[str, Any]:
+        """
+        Complete workflow: generate Synthea data and prepare for import
+        """
+        try:
+            logger.info(f"🎯 Starting Synthea generation for {population} patients")
+            
+            # Download Synthea if needed
+            if not await self.download_synthea():
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail="Failed to download Synthea"
+                )
+            
+            # Generate configuration
+            config_overrides = {
+                "population": population,
+                "age_min": age_min,
+                "age_max": age_max,
+                "gender": gender,
+                "location": location
+            }
+            
+            config_file = await self.generate_synthea_config(config_overrides)
+            
+            # Run generation
+            if not await self.run_synthea_generation(config_file):
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail="Synthea generation failed"
+                )
+            
+            # Process output
+            patients = await self.process_synthea_output()
+            
+            return {
+                "status": "success",
+                "generated_patients": len(patients),
+                "patients": patients,
+                "config": config_overrides,
+                "output_directory": str(self.output_dir)
+            }
+            
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"❌ Error in generate_and_import_patients: {str(e)}")
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Synthea integration failed: {str(e)}"
+            )
+    
+    async def get_synthea_statistics(self) -> Dict[str, Any]:
+        """
+        Get statistics about Synthea-generated data
+        """
+        try:
+            stats = {
+                "total_files": 0,
+                "patient_files": 0,
+                "hospital_files": 0,
+                "practitioner_files": 0,
+                "total_size_mb": 0
+            }
+            
+            if self.output_dir.exists():
+                for file_path in self.output_dir.glob("*.json"):
+                    stats["total_files"] += 1
+                    stats["total_size_mb"] += file_path.stat().st_size / (1024 * 1024)
+                    
+                    if "hospitalInformation" in file_path.name:
+                        stats["hospital_files"] += 1
+                    elif "practitionerInformation" in file_path.name:
+                        stats["practitioner_files"] += 1
+                    else:
+                        stats["patient_files"] += 1
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"❌ Error getting Synthea statistics: {str(e)}")
+            return {"error": str(e)}

requirements.txt

@@ -31,4 +31,6 @@ python-docx
 pyfcm
 httpx
 jwt
-reportlab>=3.6.0
+reportlab>=3.6.0
+aiofiles>=0.8.0
+aiohttp>=3.8.0