device token

api/routes/patients.py

@@ -1713,7 +1713,7 @@ async def generate_and_import_synthea_patients(
             "error_count": len(errors),
             "errors": errors,
             "config": generation_result['config'],
-            "source": "synthea"
+            "source": generation_result.get('source', 'synthea')
         }
         
     except Exception as e:

api/services/synthea_integration.py

@@ -99,6 +99,21 @@ class SyntheaIntegrationService:
         try:
             logger.info("🚀 Starting Synthea generation...")
             
+            # Check if Java is available
+            try:
+                java_check = await asyncio.create_subprocess_exec(
+                    "java", "-version",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                await java_check.communicate()
+                if java_check.returncode != 0:
+                    logger.error("❌ Java is not available in the environment")
+                    return False
+            except FileNotFoundError:
+                logger.error("❌ Java is not installed or not in PATH")
+                return False
+            
             # Clear output directory
             for file in self.output_dir.glob("*.json"):
                 file.unlink()
@@ -110,6 +125,8 @@ class SyntheaIntegrationService:
                 "-o", str(self.output_dir)
             ]
             
+            logger.info(f"Running command: {' '.join(cmd)}")
+            
             process = await asyncio.create_subprocess_exec(
                 *cmd,
                 stdout=asyncio.subprocess.PIPE,
@@ -123,7 +140,9 @@ class SyntheaIntegrationService:
                 logger.info(f"Output: {stdout.decode()}")
                 return True
             else:
-                logger.error(f"❌ Synthea generation failed: {stderr.decode()}")
+                error_output = stderr.decode()
+                logger.error(f"❌ Synthea generation failed with return code {process.returncode}")
+                logger.error(f"Error output: {error_output}")
                 return False
                 
         except Exception as e:
@@ -367,44 +386,45 @@ class SyntheaIntegrationService:
         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)
-            }
+            # Try to use real Synthea first
+            try:
+                # Download Synthea if needed
+                if not await self.download_synthea():
+                    logger.warning("⚠️ Failed to download Synthea, falling back to mock data")
+                    return await self._generate_mock_patients(population, age_min, age_max, gender, location)
+                
+                # 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):
+                    logger.warning("⚠️ Synthea generation failed, falling back to mock data")
+                    return await self._generate_mock_patients(population, age_min, age_max, gender, location)
+                
+                # 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),
+                    "source": "synthea_real"
+                }
+                
+            except Exception as e:
+                logger.warning(f"⚠️ Synthea integration failed: {str(e)}, falling back to mock data")
+                return await self._generate_mock_patients(population, age_min, age_max, gender, location)
             
-        except HTTPException:
-            raise
         except Exception as e:
             logger.error(f"❌ Error in generate_and_import_patients: {str(e)}")
             raise HTTPException(
@@ -412,6 +432,92 @@ class SyntheaIntegrationService:
                 detail=f"Synthea integration failed: {str(e)}"
             )
     
+    async def _generate_mock_patients(
+        self,
+        population: int = 10,
+        age_min: int = 18,
+        age_max: int = 80,
+        gender: str = "both",
+        location: str = "Massachusetts"
+    ) -> Dict[str, Any]:
+        """
+        Generate mock patient data when Synthea is not available
+        """
+        import random
+        from datetime import datetime, timedelta
+        
+        logger.info(f"🎭 Generating {population} mock patients")
+        
+        first_names = ["John", "Jane", "Michael", "Sarah", "David", "Emily", "Robert", "Lisa", "James", "Maria"]
+        last_names = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis", "Rodriguez", "Martinez"]
+        cities = ["Boston", "Cambridge", "Worcester", "Springfield", "Lowell", "Cambridge", "New Bedford", "Brockton", "Quincy", "Lynn"]
+        
+        patients = []
+        
+        for i in range(population):
+            # Generate random name
+            first_name = random.choice(first_names)
+            last_name = random.choice(last_names)
+            full_name = f"{first_name} {last_name}"
+            
+            # Generate random age
+            age = random.randint(age_min, age_max)
+            birth_date = datetime.now() - timedelta(days=age*365 + random.randint(0, 365))
+            
+            # Generate random gender
+            if gender == "both":
+                patient_gender = random.choice(["male", "female"])
+            else:
+                patient_gender = gender
+            
+            # Generate random address
+            street_number = random.randint(100, 9999)
+            street_name = random.choice(["Main St", "Oak Ave", "Elm St", "Maple Dr", "Cedar Ln"])
+            city = random.choice(cities)
+            state = "MA"
+            postal_code = f"{random.randint(10000, 99999)}"
+            
+            patient_data = {
+                'fhir_id': f"mock-patient-{i+1}",
+                'full_name': full_name,
+                'gender': patient_gender,
+                'date_of_birth': birth_date.strftime('%Y-%m-%d'),
+                'address': f"{street_number} {street_name}",
+                'city': city,
+                'state': state,
+                'postal_code': postal_code,
+                'country': 'US',
+                'marital_status': random.choice(['single', 'married', 'divorced', 'widowed']),
+                'language': 'English',
+                'source': 'synthea_mock',
+                'import_date': datetime.utcnow().isoformat(),
+                'last_updated': datetime.utcnow().isoformat(),
+                'conditions': [],
+                'medications': [],
+                'encounters': [],
+                'observations': [],
+                'procedures': [],
+                'immunizations': [],
+                'allergies': []
+            }
+            
+            patients.append(patient_data)
+        
+        return {
+            "status": "success",
+            "generated_patients": len(patients),
+            "patients": patients,
+            "config": {
+                "population": population,
+                "age_min": age_min,
+                "age_max": age_max,
+                "gender": gender,
+                "location": location
+            },
+            "output_directory": "mock_data",
+            "source": "synthea_mock"
+        }
+    
     async def get_synthea_statistics(self) -> Dict[str, Any]:
         """
         Get statistics about Synthea-generated data
@@ -422,9 +528,26 @@ class SyntheaIntegrationService:
                 "patient_files": 0,
                 "hospital_files": 0,
                 "practitioner_files": 0,
-                "total_size_mb": 0
+                "total_size_mb": 0,
+                "synthea_available": False,
+                "java_available": False
             }
             
+            # Check if Java is available
+            try:
+                java_check = await asyncio.create_subprocess_exec(
+                    "java", "-version",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                await java_check.communicate()
+                stats["java_available"] = (java_check.returncode == 0)
+            except FileNotFoundError:
+                stats["java_available"] = False
+            
+            # Check if Synthea JAR exists
+            stats["synthea_available"] = self.synthea_jar_path.exists()
+            
             if self.output_dir.exists():
                 for file_path in self.output_dir.glob("*.json"):
                     stats["total_files"] += 1