device token

api/routes/patients.py

@@ -1678,42 +1678,16 @@ async def generate_and_import_synthea_patients(
                 "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)
-        
+        # The patients are already saved to database by the service
+        # Just return the results
         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": generation_result.get('source', 'synthea')
+            "message": "Synthea patients generated and saved to database successfully",
+            "generated_count": generation_result.get('generated_patients', 0),
+            "saved_to_database": generation_result.get('saved_to_database', 0),
+            "failed_to_save": generation_result.get('failed_to_save', 0),
+            "database_errors": generation_result.get('database_errors', []),
+            "source": generation_result.get('source', 'unknown'),
+            "config": generation_result.get('config', {})
         }
         
     except Exception as e:

api/services/synthea_integration.py

@@ -10,6 +10,8 @@ from typing import Dict, List, Optional, Any
 import aiofiles
 import aiohttp
 from fastapi import HTTPException, status
+from bson import ObjectId
+from db.mongo import patients_collection
 
 logger = logging.getLogger(__name__)
 
@@ -208,6 +210,28 @@ class SyntheaIntegrationService:
                 ]
                 patient_files.extend(subdir_files)
             
+            # If no files found, try alternative locations
+            if not patient_files:
+                logger.warning("⚠️ No patient files found in output directory, trying alternative locations...")
+                
+                # Try parent directory
+                parent_dir = self.output_dir.parent
+                logger.info(f"🔍 Checking parent directory: {parent_dir}")
+                parent_files = [
+                    f for f in parent_dir.glob("*.json")
+                    if not any(x in f.name for x in ["hospitalInformation", "practitionerInformation"])
+                ]
+                patient_files.extend(parent_files)
+                
+                # Try current working directory
+                cwd = Path.cwd()
+                logger.info(f"🔍 Checking current working directory: {cwd}")
+                cwd_files = [
+                    f for f in cwd.glob("*.json")
+                    if not any(x in f.name for x in ["hospitalInformation", "practitionerInformation"])
+                ]
+                patient_files.extend(cwd_files)
+            
             logger.info(f"📁 Found {len(patient_files)} patient files")
             logger.info(f"📁 Patient file names: {[f.name for f in patient_files]}")
             
@@ -419,6 +443,72 @@ class SyntheaIntegrationService:
         except:
             return []
     
+    async def save_patients_to_database(self, patients: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Save generated patients directly to the database
+        """
+        try:
+            saved_count = 0
+            failed_count = 0
+            errors = []
+            
+            for patient in patients:
+                try:
+                    # Prepare patient document for database
+                    patient_doc = {
+                        '_id': ObjectId(),
+                        'fhir_id': patient.get('fhir_id', f"synthea-{ObjectId()}"),
+                        'full_name': patient.get('full_name', ''),
+                        'gender': patient.get('gender', 'unknown'),
+                        'date_of_birth': patient.get('date_of_birth'),
+                        'address': patient.get('address', ''),
+                        'city': patient.get('city', ''),
+                        'state': patient.get('state', ''),
+                        'postal_code': patient.get('postal_code', ''),
+                        'country': patient.get('country', 'US'),
+                        'marital_status': patient.get('marital_status', ''),
+                        'language': patient.get('language', 'English'),
+                        'source': patient.get('source', 'synthea'),
+                        'import_date': datetime.utcnow(),
+                        'last_updated': datetime.utcnow(),
+                        'conditions': patient.get('conditions', []),
+                        'medications': patient.get('medications', []),
+                        'encounters': patient.get('encounters', []),
+                        'observations': patient.get('observations', []),
+                        'procedures': patient.get('procedures', []),
+                        'immunizations': patient.get('immunizations', []),
+                        'allergies': patient.get('allergies', []),
+                        'notes': []
+                    }
+                    
+                    # Insert into database
+                    result = await patients_collection.insert_one(patient_doc)
+                    saved_count += 1
+                    logger.info(f"✅ Saved patient {patient.get('full_name', 'Unknown')} with ID: {result.inserted_id}")
+                    
+                except Exception as e:
+                    failed_count += 1
+                    error_msg = f"Failed to save patient {patient.get('full_name', 'Unknown')}: {str(e)}"
+                    errors.append(error_msg)
+                    logger.error(f"❌ {error_msg}")
+                    continue
+            
+            return {
+                "saved_count": saved_count,
+                "failed_count": failed_count,
+                "errors": errors,
+                "success": saved_count > 0
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Error saving patients to database: {str(e)}")
+            return {
+                "saved_count": 0,
+                "failed_count": len(patients),
+                "errors": [f"Database error: {str(e)}"],
+                "success": False
+            }
+    
     async def generate_and_import_patients(
         self, 
         population: int = 10,
@@ -468,9 +558,19 @@ class SyntheaIntegrationService:
                 # Process output
                 patients = await self.process_synthea_output()
                 
+                # Save patients to database
+                if patients:
+                    db_result = await self.save_patients_to_database(patients)
+                    logger.info(f"💾 Database save result: {db_result}")
+                else:
+                    db_result = {"saved_count": 0, "failed_count": 0, "errors": ["No patients to save"], "success": False}
+                
                 return {
                     "status": "success",
                     "generated_patients": len(patients),
+                    "saved_to_database": db_result["saved_count"],
+                    "failed_to_save": db_result["failed_count"],
+                    "database_errors": db_result["errors"],
                     "patients": patients,
                     "config": config_overrides,
                     "output_directory": str(self.output_dir),
@@ -559,9 +659,19 @@ class SyntheaIntegrationService:
             
             patients.append(patient_data)
         
+        # Save mock patients to database
+        if patients:
+            db_result = await self.save_patients_to_database(patients)
+            logger.info(f"💾 Mock patients database save result: {db_result}")
+        else:
+            db_result = {"saved_count": 0, "failed_count": 0, "errors": ["No mock patients to save"], "success": False}
+        
         return {
             "status": "success",
             "generated_patients": len(patients),
+            "saved_to_database": db_result["saved_count"],
+            "failed_to_save": db_result["failed_count"],
+            "database_errors": db_result["errors"],
             "patients": patients,
             "config": {
                 "population": population,