device token

api/routes/patients.py

@@ -491,83 +491,137 @@ async def import_patients(
 async def import_ehr_patients(
     ehr_data: List[dict],
     ehr_system: str = Query(..., description="Name of the EHR system"),
-    current_user: dict = Depends(get_current_user),
-    db_client: AsyncIOMotorClient = Depends(lambda: db)
+    current_user: dict = Depends(get_current_user)
 ):
-    """Import patients from external EHR system"""
+    """
+    Import patients from external EHR system
+    """
     logger.info(f"Importing {len(ehr_data)} patients from EHR system: {ehr_system}")
     
     if not any(role in current_user.get('roles', []) for role in ['admin', 'doctor']):
         logger.warning(f"Unauthorized EHR import attempt by {current_user.get('email')}")
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
-            detail="Only administrators and doctors can import EHR patients"
+            detail="Only administrators and doctors can import patients"
         )
     
     try:
+        imported_count = 0
+        skipped_count = 0
         imported_patients = []
         skipped_patients = []
+        errors = []
         
         for patient_data in ehr_data:
-            # Check if patient already exists by multiple criteria
-            existing_patient = await patients_collection.find_one({
-                "$or": [
-                    {"ehr_id": patient_data.get("ehr_id"), "ehr_system": ehr_system},
-                    {"full_name": patient_data.get("full_name"), "date_of_birth": patient_data.get("date_of_birth")},
-                    {"national_id": patient_data.get("national_id")} if patient_data.get("national_id") else {}
-                ]
-            })
-            
-            if existing_patient:
-                skipped_patients.append(patient_data.get("full_name", "Unknown"))
-                logger.info(f"Patient {patient_data.get('full_name', 'Unknown')} already exists, skipping...")
-                continue
-            
-            # Prepare patient document for EHR import
-            patient_doc = {
-                "full_name": patient_data.get("full_name"),
-                "date_of_birth": patient_data.get("date_of_birth"),
-                "gender": patient_data.get("gender"),
-                "address": patient_data.get("address"),
-                "national_id": patient_data.get("national_id"),
-                "blood_type": patient_data.get("blood_type"),
-                "allergies": patient_data.get("allergies", []),
-                "chronic_conditions": patient_data.get("chronic_conditions", []),
-                "medications": patient_data.get("medications", []),
-                "emergency_contact_name": patient_data.get("emergency_contact_name"),
-                "emergency_contact_phone": patient_data.get("emergency_contact_phone"),
-                "insurance_provider": patient_data.get("insurance_provider"),
-                "insurance_policy_number": patient_data.get("insurance_policy_number"),
-                "contact": patient_data.get("contact"),
-                "source": "ehr",
-                "ehr_id": patient_data.get("ehr_id"),
-                "ehr_system": ehr_system,
-                "status": "active",
-                "registration_date": datetime.now(),
-                "created_by": current_user.get('email'),
-                "created_at": datetime.now(),
-                "updated_at": datetime.now()
-            }
-            
-            # Insert patient
-            result = await patients_collection.insert_one(patient_doc)
-            imported_patients.append(patient_data.get("full_name", "Unknown"))
-        
-        logger.info(f"Successfully imported {len(imported_patients)} patients, skipped {len(skipped_patients)}")
+            try:
+                # Validate required fields
+                if not patient_data.get('ehr_id') or not patient_data.get('full_name'):
+                    errors.append(f"Patient missing required fields (ehr_id, full_name): {patient_data.get('full_name', 'Unknown')}")
+                    continue
+                
+                # Check for existing patient by EHR ID and system
+                existing_patient = await patients_collection.find_one({
+                    "ehr_id": patient_data['ehr_id'],
+                    "ehr_system": ehr_system
+                })
+                
+                if existing_patient:
+                    skipped_count += 1
+                    skipped_patients.append(patient_data['full_name'])
+                    continue
+                
+                # Prepare patient document
+                patient_doc = {
+                    "fhir_id": str(uuid.uuid4()),
+                    "full_name": patient_data['full_name'],
+                    "date_of_birth": patient_data.get('date_of_birth', ''),
+                    "gender": patient_data.get('gender', 'unknown'),
+                    "address": patient_data.get('address', ''),
+                    "national_id": patient_data.get('national_id', ''),
+                    "blood_type": patient_data.get('blood_type', ''),
+                    "allergies": patient_data.get('allergies', []),
+                    "chronic_conditions": patient_data.get('chronic_conditions', []),
+                    "medications": patient_data.get('medications', []),
+                    "emergency_contact_name": patient_data.get('emergency_contact_name', ''),
+                    "emergency_contact_phone": patient_data.get('emergency_contact_phone', ''),
+                    "insurance_provider": patient_data.get('insurance_provider', ''),
+                    "insurance_policy_number": patient_data.get('insurance_policy_number', ''),
+                    "source": "ehr_import",
+                    "ehr_id": patient_data['ehr_id'],
+                    "ehr_system": ehr_system,
+                    "status": "active",
+                    "created_by": current_user.get('email'),
+                    "created_at": datetime.utcnow().isoformat(),
+                    "updated_at": datetime.utcnow().isoformat()
+                }
+                
+                # Insert patient
+                result = await patients_collection.insert_one(patient_doc)
+                imported_count += 1
+                imported_patients.append(patient_data['full_name'])
+                
+                logger.info(f"Imported patient {patient_data['full_name']} with EHR ID {patient_data['ehr_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"Successfully imported {len(imported_patients)} patients from {ehr_system}",
-            "imported_count": len(imported_patients),
-            "skipped_count": len(skipped_patients),
+            "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),
             "imported_patients": imported_patients,
-            "skipped_patients": skipped_patients
+            "skipped_patients": skipped_patients,
+            "errors": errors,
+            "ehr_system": ehr_system
         }
         
     except Exception as e:
-        logger.error(f"Error importing EHR patients: {str(e)}")
+        logger.error(f"Failed to import EHR patients: {str(e)}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Error importing EHR patients: {str(e)}"
+            detail=f"Failed to import EHR patients: {str(e)}"
+        )
+
+@router.post("/patients/import-hapi-fhir", status_code=status.HTTP_201_CREATED)
+async def import_hapi_fhir_patients(
+    limit: int = Query(20, ge=1, le=100, description="Number of patients to import"),
+    current_user: dict = Depends(get_current_user)
+):
+    """
+    Import patients from HAPI FHIR Test Server
+    """
+    logger.info(f"Importing {limit} patients from HAPI FHIR by user {current_user.get('email')}")
+    
+    if not any(role in current_user.get('roles', []) for role in ['admin', 'doctor']):
+        logger.warning(f"Unauthorized HAPI FHIR import attempt by {current_user.get('email')}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only administrators and doctors can import patients"
+        )
+    
+    try:
+        service = HAPIFHIRIntegrationService()
+        result = await service.import_patients_from_hapi(limit=limit)
+        
+        return {
+            "message": f"Successfully imported {result.get('imported_count', 0)} patients from HAPI FHIR",
+            "imported_count": result.get('imported_count', 0),
+            "skipped_count": result.get('skipped_count', 0),
+            "error_count": result.get('error_count', 0),
+            "imported_patients": result.get('imported_patients', []),
+            "skipped_patients": result.get('skipped_patients', []),
+            "errors": result.get('errors', []),
+            "source": "hapi_fhir"
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to import HAPI FHIR patients: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to import HAPI FHIR patients: {str(e)}"
         )
 
 @router.get("/patients/sources", response_model=List[dict])
@@ -704,18 +758,32 @@ async def get_patients(
             # Add assigned doctor name
             patient["assigned_doctor_name"] = assigned_doctor_name
             
+            # Clean date_of_birth field - convert empty strings to None
+            if patient.get("date_of_birth") == "":
+                patient["date_of_birth"] = None
+            
             processed_patients.append(patient)
         
         logger.info(f"✅ Returning {len(processed_patients)} processed patients")
         
-        return PatientListResponse(
-            patients=processed_patients,
-            total=total,
-            page=page,
-            limit=limit,
-            source_filter=source,
-            status_filter=patient_status
-        )
+        try:
+            return PatientListResponse(
+                patients=processed_patients,
+                total=total,
+                page=page,
+                limit=limit,
+                source_filter=source,
+                status_filter=patient_status
+            )
+        except Exception as validation_error:
+            logger.error(f"❌ Validation error for PatientListResponse: {str(validation_error)}")
+            # Log the problematic data for debugging
+            for i, patient in enumerate(processed_patients):
+                logger.error(f"Patient {i}: {patient.get('full_name', 'Unknown')} - date_of_birth: '{patient.get('date_of_birth')}'")
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Data validation error: {str(validation_error)}"
+            )
         
     except Exception as e:
         logger.error(f"❌ Error fetching patients: {str(e)}")

models/schemas.py

@@ -140,7 +140,7 @@ class PatientUpdate(BaseModel):
 class PatientResponse(BaseModel):
     id: str
     full_name: str
-    date_of_birth: date
+    date_of_birth: Optional[date] = None
     gender: str
     notes: Optional[Union[str, List[dict]]] = []  # Can be string or list of dicts
     address: Optional[str] = None