Update src/database.py

src/database.py

@@ -1,10 +1,10 @@
-# database.py (SmartHeal) — dataset ID hardcoded
+# database.py (SmartHeal) — dataset ID hardcoded, wound_images.patient_id uses INT id
 
 import os
 import json
 import logging
 from datetime import datetime
-from typing import Optional, Dict, Any, List
+from typing import Optional, Dict, Any, List, Tuple, Union
 
 import mysql.connector
 from mysql.connector import Error
@@ -52,8 +52,8 @@ def _file_url(path: str) -> str:
 class DatabaseManager:
     """
     Database operations manager for SmartHeal
-    - Keeps patient_id (INT) consistent for questionnaire_responses / ai_analyses joins
-    - Uses patients.uuid (CHAR 36) in wounds / wound_images where those tables store VARCHAR
+    - Keeps patient_id (INT) consistent for questionnaire_responses / joins
+    - Uses patients.id (INT) in wounds.patient_id and wound_images.patient_id (stored as string in VARCHAR columns)
     - Saves images locally OR to a hardcoded Hugging Face dataset and stores the URL
     """
 
@@ -171,6 +171,12 @@ class DatabaseManager:
             (patient_id,)
         )
 
+    def get_patient_by_uuid(self, patient_uuid: str) -> Optional[Dict[str, Any]]:
+        return self.execute_query_one(
+            "SELECT id, uuid, name, age, gender FROM patients WHERE uuid = %s LIMIT 1",
+            (patient_uuid,)
+        )
+
     def get_patient_by_name_age_gender(self, name: str, age: Any, gender: str) -> Optional[Dict[str, Any]]:
         age_val = self._normalize_age(age)
         if age_val is None:
@@ -185,6 +191,30 @@ class DatabaseManager:
             (name, age_val, gender),
         )
 
+    def _resolve_patient_ids(
+        self,
+        patient_ref: Union[int, str]
+    ) -> Optional[Tuple[int, str]]:
+        """
+        Accepts either a numeric ID or a UUID and returns (id_int, uuid_str).
+        """
+        try:
+            # numeric ID?
+            if isinstance(patient_ref, int) or (isinstance(patient_ref, str) and patient_ref.isdigit()):
+                rid = int(patient_ref)
+                row = self.get_patient_by_id(rid)
+                if row:
+                    return (row["id"], row["uuid"])
+                return None
+            # UUID path
+            row = self.get_patient_by_uuid(str(patient_ref))
+            if row:
+                return (row["id"], row["uuid"])
+            return None
+        except Exception as e:
+            logging.error(f"_resolve_patient_ids error: {e}")
+            return None
+
     def create_patient(self, data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         conn = None
         cur = None
@@ -195,8 +225,8 @@ class DatabaseManager:
             import uuid as _uuid
             p_uuid = str(_uuid.uuid4())
             cur.execute("""
-                INSERT INTO patients (uuid, name, age, gender, illness, allergy, notes, created_at)
-                VALUES (%s,%s,%s,%s,%s,%s,%s,%s)
+                INSERT INTO patients (uuid, name, age, gender, illness, allergy, notes, created_at, updated_at)
+                VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)
             """, (
                 p_uuid,
                 data.get("patient_name"),
@@ -205,6 +235,7 @@ class DatabaseManager:
                 data.get("medical_history", ""),
                 data.get("allergies", ""),
                 data.get("additional_notes", ""),
+                _now(),
                 _now()
             ))
             conn.commit()
@@ -333,27 +364,36 @@ class DatabaseManager:
                 pass
 
     # ------------------------------- wounds -------------------------------
-    def create_wound(self, patient_uuid: str, questionnaire_data: Dict[str, Any]) -> Optional[str]:
-        """Create wound (returns wound_uuid). Stores patient_uuid in wounds.patient_id (VARCHAR)."""
+    def create_wound(self, patient_ref: Union[int, str], questionnaire_data: Dict[str, Any]) -> Optional[str]:
+        """
+        Create wound (returns wound_uuid).
+        Stores **patients.id** (as string) in wounds.patient_id.
+        """
         conn = None
         cur = None
         try:
+            resolved = self._resolve_patient_ids(patient_ref)
+            if not resolved:
+                raise Exception("Could not resolve patient by id/uuid")
+            patient_id_int, _patient_uuid = resolved
+
             conn = self.get_connection()
             if not conn: return None
             cur = conn.cursor()
             import uuid as _uuid
             wound_uuid = str(_uuid.uuid4())
             cur.execute("""
-                INSERT INTO wounds (uuid, patient_id, position, category, moisture, infection, notes, created_at)
-                VALUES (%s,%s,%s,%s,%s,%s,%s,%s)
+                INSERT INTO wounds (uuid, patient_id, position, category, moisture, infection, notes, created_at, updated_at)
+                VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)
             """, (
                 wound_uuid,
-                patient_uuid,
+                str(patient_id_int),                      # <-- store INT id as string
                 questionnaire_data.get("wound_location") or "",
                 "Assessment",
                 questionnaire_data.get("moisture_level") or "",
                 questionnaire_data.get("infection_signs") or "",
                 questionnaire_data.get("additional_notes") or "",
+                _now(),
                 _now()
             ))
             conn.commit()
@@ -409,24 +449,28 @@ class DatabaseManager:
             logging.error(f"HF upload failed: {e}")
             return None
 
-    def _insert_wound_image_row(self, conn, cur, patient_uuid: str, wound_uuid: Optional[str], image_path_or_url: str) -> Optional[int]:
-        """Insert one row in wound_images; width/height detected for local files only."""
+    def _insert_wound_image_row(self, conn, cur, patient_id_str: str, wound_uuid: Optional[str], image_path_or_url: str) -> Optional[int]:
+        """
+        Insert one row in wound_images.
+        Stores **patients.id** as string in wound_images.patient_id.
+        """
         width, height = (None, None)
-        if not (image_path_or_url.startswith("http://") or image_path_or_url.startswith("https://")):
+        if not (str(image_path_or_url).startswith("http://") or str(image_path_or_url).startswith("https://")):
             width, height = self._read_image_size(image_path_or_url)
 
         import uuid as _uuid
         img_uuid = str(_uuid.uuid4())
         cur.execute("""
-            INSERT INTO wound_images (uuid, patient_id, wound_id, image, width, height, created_at)
-            VALUES (%s,%s,%s,%s,%s,%s,%s)
+            INSERT INTO wound_images (uuid, patient_id, wound_id, image, width, height, created_at, updated_at)
+            VALUES (%s,%s,%s,%s,%s,%s,%s,%s)
         """, (
             img_uuid,
-            patient_uuid,
+            patient_id_str,                # <-- store INT id (as string)
             wound_uuid,
             image_path_or_url,
             int(width) if width else None,
             int(height) if height else None,
+            _now(),
             _now()
         ))
         conn.commit()
@@ -434,22 +478,32 @@ class DatabaseManager:
 
     def save_wound_images_bundle(
         self,
-        patient_uuid: str,
+        patient_ref: Union[int, str],
         original_path: str,
         analysis_result: Dict[str, Any],
         wound_uuid: Optional[str] = None
     ) -> Dict[str, Any]:
         """
         Save original + detection + segmentation images to wound_images.
-        Stores **HF dataset URLs** when configured, else local paths.
+        - Accepts patient_ref as INT id or UUID
+        - Stores **patient_id (INT as string)** in wound_images.patient_id
+        - Ensures a wound row exists (wound_uuid) if not provided
         Returns display URLs for UI.
         """
         out = {
             "original_id": None, "original_url": None,
             "detection_id": None, "detection_url": None,
-            "segmentation_id": None, "segmentation_url": None
+            "segmentation_id": None, "segmentation_url": None,
+            "wound_id": None
         }
 
+        resolved = self._resolve_patient_ids(patient_ref)
+        if not resolved:
+            logging.error("save_wound_images_bundle: could not resolve patient")
+            return out
+        patient_id_int, _patient_uuid = resolved
+        patient_id_str = str(patient_id_int)
+
         conn = self.get_connection()
         if not conn: return out
         cur = conn.cursor()
@@ -460,16 +514,17 @@ class DatabaseManager:
                 import uuid as _uuid
                 wound_uuid = str(_uuid.uuid4())
                 cur.execute("""
-                    INSERT INTO wounds (uuid, patient_id, category, notes, created_at)
-                    VALUES (%s,%s,%s,%s,%s)
-                """, (wound_uuid, patient_uuid, "Assessment", "", _now()))
+                    INSERT INTO wounds (uuid, patient_id, category, notes, created_at, updated_at)
+                    VALUES (%s,%s,%s,%s,%s,%s)
+                """, (wound_uuid, patient_id_str, "Assessment", "", _now(), _now()))
                 conn.commit()
+            out["wound_id"] = wound_uuid
 
             # 1) Original
             local_orig = self._copy_to_uploads(original_path, "original")
             url_orig = self._hf_upload_and_url(local_orig, subdir="original") if self.use_dataset else None
             store_orig = url_orig or local_orig
-            img_id = self._insert_wound_image_row(conn, cur, patient_uuid, wound_uuid, store_orig)
+            img_id = self._insert_wound_image_row(conn, cur, patient_id_str, wound_uuid, store_orig)
             out["original_id"] = img_id
             out["original_url"] = _file_url(store_orig)
 
@@ -482,7 +537,7 @@ class DatabaseManager:
                 local_det = self._copy_to_uploads(det, "detect")
                 url_det = self._hf_upload_and_url(local_det, subdir="detect") if self.use_dataset else None
                 store_det = url_det or local_det
-                did = self._insert_wound_image_row(conn, cur, patient_uuid, wound_uuid, store_det)
+                did = self._insert_wound_image_row(conn, cur, patient_id_str, wound_uuid, store_det)
                 out["detection_id"] = did
                 out["detection_url"] = _file_url(store_det)
 
@@ -490,7 +545,7 @@ class DatabaseManager:
                 local_seg = self._copy_to_uploads(seg, "segment")
                 url_seg = self._hf_upload_and_url(local_seg, subdir="segment") if self.use_dataset else None
                 store_seg = url_seg or local_seg
-                sid = self._insert_wound_image_row(conn, cur, patient_uuid, wound_uuid, store_seg)
+                sid = self._insert_wound_image_row(conn, cur, patient_id_str, wound_uuid, store_seg)
                 out["segmentation_id"] = sid
                 out["segmentation_url"] = _file_url(store_seg)
 
@@ -515,7 +570,7 @@ class DatabaseManager:
         Back-compat single-image save:
         - If `image` is a PIL.Image -> we write to uploads and (optionally) the dataset.
         - If `image` is a filepath -> we copy + (optionally) upload.
-        Stores patients.uuid into wound_images.patient_id (VARCHAR).
+        Stores **patients.id** (as string) into wound_images.patient_id.
         """
         try:
             # Normalize to a temporary local path first
@@ -533,38 +588,28 @@ class DatabaseManager:
                 logging.error("Invalid image object/path")
                 return None
 
-            # Resolve patients.uuid
-            conn = self.get_connection()
-            if not conn: return None
-            cur = conn.cursor()
-
-            cur2 = conn.cursor(dictionary=True)
-            cur2.execute("SELECT uuid FROM patients WHERE id = %s LIMIT 1", (patient_id,))
-            row = cur2.fetchone()
-            cur2.close()
-            if not row:
-                logging.error("Patient id not found while saving image")
-                conn.close()
-                return None
-            patient_uuid = row["uuid"]
-
             # Push to uploads/dataset with final name
             local_path = self._copy_to_uploads(tmp_local, "original")
             url = self._hf_upload_and_url(local_path, subdir="original") if self.use_dataset else None
             path_or_url = url or local_path
 
             width, height = self._read_image_size(local_path)
+
+            conn = self.get_connection()
+            if not conn: return None
+            cur = conn.cursor()
             import uuid as _uuid
             img_uuid = str(_uuid.uuid4())
             cur.execute("""
-                INSERT INTO wound_images (uuid, patient_id, image, width, height, created_at)
-                VALUES (%s,%s,%s,%s,%s,%s)
+                INSERT INTO wound_images (uuid, patient_id, image, width, height, created_at, updated_at)
+                VALUES (%s,%s,%s,%s,%s,%s,%s)
             """, (
                 img_uuid,
-                patient_uuid,
+                str(int(patient_id)),  # <-- store INT id as string
                 path_or_url,
                 int(width) if width else None,
                 int(height) if height else None,
+                _now(),
                 _now()
             ))
             conn.commit()
@@ -647,7 +692,8 @@ class DatabaseManager:
     # ------------------------------- queries for UI -------------------------------
     def get_user_history_rows(self, user_id: int) -> List[Dict[str, Any]]:
         """
-        Latest 20 visits across patients; joins ai_analyses.image_id -> wound_images to pull display image.
+        Latest 20 visits across patients; joins ai_analyses (by questionnaire_id -> questionnaires.id)
+        and pulls image via a.image_id -> wound_images.id.
         """
         return self.execute_query("""
             SELECT
@@ -666,7 +712,7 @@ class DatabaseManager:
                 wi.image AS image_url
             FROM questionnaire_responses qr
             JOIN patients p ON p.id = qr.patient_id
-            LEFT JOIN ai_analyses a ON a.questionnaire_id = qr.id
+            LEFT JOIN ai_analyses a ON a.questionnaire_id = qr.questionnaire_id
             LEFT JOIN wound_images wi ON wi.id = a.image_id
             WHERE qr.practitioner_id = %s
             ORDER BY qr.submitted_at DESC
@@ -694,7 +740,7 @@ class DatabaseManager:
                 wi.image AS image_url
             FROM questionnaire_responses qr
             JOIN patients p ON p.id = qr.patient_id
-            LEFT JOIN ai_analyses a ON a.questionnaire_id = qr.id
+            LEFT JOIN ai_analyses a ON a.questionnaire_id = qr.questionnaire_id
             LEFT JOIN wound_images wi ON wi.id = a.image_id
             WHERE qr.practitioner_id = %s AND p.id = %s
             ORDER BY qr.submitted_at ASC