ygfdbvghjfd

controllers/main.py

@@ -1,460 +1,18 @@
-# """
-# main.py — FastAPI + InsightFace + In-Memory RAM + File Image Storage
-# ─────────────────────────────────────────────────────────────────────
-# Thay đổi so với phiên bản cũ:
-#   • Dùng InsightFace thay face_recognition → nhanh ~15-20×
-#   • Ảnh lưu trên ổ đĩa (/uploads/) thay vì Base64 trong DB
-#   • Endpoint GET /uploads/{filename} để frontend hiển thị ảnh
-#   • match["distance"] là cosine distance (InsightFace), không phải Euclidean
-# """
-
-# import uuid
-# import json
-# import time
-# import logging
-# from contextlib import asynccontextmanager
-# from pathlib import Path
-
-# from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks
-# from fastapi.middleware.cors import CORSMiddleware
-# from fastapi.responses import JSONResponse, FileResponse
-# from fastapi.staticfiles import StaticFiles
-# from pydantic import BaseModel
-
-# from database.database import get_db_connection
-# from service.face_service import face_ai_service, face_memory_store, UPLOAD_DIR
-
-# logging.basicConfig(level=logging.INFO)
-# logger = logging.getLogger(__name__)
-
-
-# # ─── Startup ──────────────────────────────────────────────────────────────────
-# @asynccontextmanager
-# async def lifespan(app: FastAPI):
-#     logger.info("[Startup] 🚀 Đang nạp embedding vào RAM...")
-#     _load_embeddings_to_ram()
-#     logger.info(f"[Startup] ✅ Sẵn sàng — {face_memory_store.count} khuôn mặt trên RAM")
-#     yield
-#     logger.info("[Shutdown] Bye!")
-
-
-# def _load_embeddings_to_ram() -> None:
-#     try:
-#         conn   = get_db_connection()
-#         cursor = conn.cursor(dictionary=True)
-#         cursor.execute("""
-#             SELECT e.person_id, p.name, p.role, p.img_path, e.embedding_vector
-#             FROM face_embeddings e
-#             JOIN persons p ON e.person_id = p.id
-#             WHERE p.status = 'active'
-#         """)
-#         rows = cursor.fetchall()
-#         cursor.close()
-#         conn.close()
-
-#         parsed = []
-#         for row in rows:
-#             try:
-#                 parsed.append({
-#                     "person_id":        row["person_id"],
-#                     "name":             row["name"],
-#                     "role":             row.get("role", ""),
-#                     "img_path":         row.get("img_path", ""),
-#                     "embedding_vector": json.loads(row["embedding_vector"]),
-#                 })
-#             except Exception as e:
-#                 logger.warning(f"[Startup] Bỏ qua: {e}")
-
-#         face_memory_store.load_all(parsed)
-#     except Exception as e:
-#         logger.error(f"[Startup] ❌ {e}")
-
-
-# # ─── App ──────────────────────────────────────────────────────────────────────
-# app = FastAPI(lifespan=lifespan)
-
-# app.add_middleware(
-#     CORSMiddleware,
-#     allow_origins=["*"],
-#     allow_credentials=True,
-#     allow_methods=["*"],
-#     allow_headers=["*"],
-# )
-
-# # Serve ảnh tĩnh: GET /uploads/abc.jpg
-# app.mount("/uploads", StaticFiles(directory=UPLOAD_DIR), name="uploads")
-
-
-# # ─── Models ───────────────────────────────────────────────────────────────────
-# class PersonUpdate(BaseModel):
-#     name: str
-#     role: str
-#     department: str
-
-
-# # ─── Background: lưu log ──────────────────────────────────────────────────────
-# def save_log_to_db(log_queries: list) -> None:
-#     if not log_queries:
-#         return
-#     try:
-#         conn   = get_db_connection()
-#         cursor = conn.cursor()
-#         cursor.executemany(
-#             "INSERT INTO recognition_logs (id, person_id, status, confidence, camera, action) VALUES (%s,%s,%s,%s,%s,%s)",
-#             log_queries,
-#         )
-#         conn.commit()
-#         cursor.close()
-#         conn.close()
-#     except Exception as e:
-#         logger.error(f"[Log] {e}")
-
-
-# # ═════════════════════════════════════════════════════════════════════════════
-# # NHẬN DIỆN — chỉ RAM, không DB
-# # ═══════════════════════════════════════════════════════════════════════���═════
-# @app.post("/api/face/recognize")
-# async def recognize(
-#     background_tasks: BackgroundTasks,
-#     image: UploadFile = File(...),
-# ):
-#     t0         = time.time()
-#     file_bytes = await image.read()
-
-#     detections = face_ai_service.extract_faces(file_bytes)
-#     if not detections:
-#         return {"success": True, "data": {"detected": False, "faces": []}}
-
-#     results    = []
-#     log_queries = []
-
-#     for face in detections:
-#         import numpy as np
-#         query_enc = np.array(face["descriptor"], dtype=np.float32)
-#         bbox      = face["box"]
-#         det_score = face.get("det_score", 1.0)
-
-#         # So khớp trên RAM
-#         match = face_memory_store.find_best_match(query_enc)
-
-#         if match:
-#             # Chuyển cosine distance → confidence %
-#             confidence = round(max(0.0, (1.0 - match["distance"]) * 100.0), 2)
-#             logger.info(
-#                 f"[Recognize] ✅ {match['name']} | "
-#                 f"dist={match['distance']:.4f} | conf={confidence:.1f}%"
-#             )
-
-#             # URL ảnh để frontend hiển thị
-#             img_url = (
-#                 f"/uploads/{Path(match['img_path']).name}"
-#                 if match.get("img_path") else ""
-#             )
-
-#             results.append({
-#                 "id":         match["person_id"],
-#                 "name":       match["name"],
-#                 "role":       match["role"],
-#                 "img":        img_url,
-#                 "status":     "success",
-#                 "confidence": confidence,
-#                 "bbox":       bbox,
-#                 "det_score":  det_score,
-#             })
-#             log_queries.append((
-#                 str(uuid.uuid4()), match["person_id"],
-#                 "success", confidence, "Cổng Chính", "Vào",
-#             ))
-#         else:
-#             results.append({
-#                 "id":         None,
-#                 "name":       "Người Lạ",
-#                 "role":       "",
-#                 "img":        "",
-#                 "status":     "unknown",
-#                 "confidence": 0,
-#                 "bbox":       bbox,
-#             })
-#             log_queries.append((
-#                 str(uuid.uuid4()), None,
-#                 "unknown", 0, "Cổng Chính", "Từ chối",
-#             ))
-
-#     background_tasks.add_task(save_log_to_db, log_queries)
-
-#     return {
-#         "success": True,
-#         "data": {
-#             "detected":    True,
-#             "faces":       results,
-#             "processTime": int((time.time() - t0) * 1000),
-#             "model":       "InsightFace-buffalo_sc-RAM",
-#             "ramCount":    face_memory_store.count,
-#         },
-#     }
-
-
-# # ═════════════════════════════════════════════════════════════════════════════
-# # ĐĂNG KÝ — lưu ảnh file + ghi DB + cập nhật RAM
-# # ═════════════════════════════════════════════════════════════════════════════
-# @app.post("/api/face/register")
-# async def register(
-#     name:       str = Form(...),
-#     role:       str = Form(""),
-#     department: str = Form(""),
-#     images: list[UploadFile] = File(...),
-# ):
-#     conn   = get_db_connection()
-#     cursor = conn.cursor()
-
-#     person_id = str(uuid.uuid4())
-#     new_encodings: list[tuple] = []
-#     avatar_path = ""
-
-#     try:
-#         for i, img_file in enumerate(images):
-#             img_bytes = await img_file.read()
-
-#             # Lưu ảnh lên disk
-#             saved_path = face_ai_service.save_image(img_bytes, person_id, index=i)
-#             if i == 0:
-#                 avatar_path = saved_path   # ảnh đầu làm avatar
-
-#             # Trích xuất embedding
-#             detections = face_ai_service.extract_faces(img_bytes)
-
-#             if len(detections) == 0:
-#                 raise Exception(f"Không tìm thấy khuôn mặt trong ảnh thứ {i + 1}.")
-#             if len(detections) > 1:
-#                 raise Exception(f"Ảnh thứ {i + 1} có nhiều hơn 1 khuôn mặt.")
-
-#             descriptor     = detections[0]["descriptor"]
-#             embedding_json = json.dumps(descriptor)
-#             embedding_id   = str(uuid.uuid4())
-
-#             if i == 0:
-#                 # Insert person record (dùng img_path thay vì Base64)
-#                 cursor.execute(
-#                     """INSERT INTO persons (id, name, role, department, status, img_path)
-#                        VALUES (%s, %s, %s, %s, 'active', %s)""",
-#                     (person_id, name, role, department, avatar_path),
-#                 )
-
-#             cursor.execute(
-#                 "INSERT INTO face_embeddings (id, person_id, embedding_vector) VALUES (%s, %s, %s)",
-#                 (embedding_id, person_id, embedding_json),
-#             )
-#             new_encodings.append((person_id, name, role, avatar_path, descriptor))
-
-#         conn.commit()
-
-#         # ✅ Cập nhật RAM ngay — nhận diện có hiệu lực lập tức
-#         for pid, pname, prole, pimg, enc in new_encodings:
-#             face_memory_store.add(pid, pname, prole, pimg, enc)
-
-#         logger.info(f"[Register] ✅ {name} | {len(new_encodings)} mẫu | RAM: {face_memory_store.count}")
-
-#         return {
-#             "success":  True,
-#             "message":  f"Đã đăng ký {name} với {len(new_encodings)} mẫu.",
-#             "img_url":  f"/uploads/{Path(avatar_path).name}",
-#             "ramCount": face_memory_store.count,
-#         }
-
-#     except Exception as e:
-#         conn.rollback()
-#         logger.error(f"[Register] ❌ {e}")
-#         # Xóa ảnh đã lưu nếu lỗi
-#         for i in range(len(images)):
-#             p = Path(UPLOAD_DIR) / f"{person_id}_{i}.jpg"
-#             if p.exists():
-#                 p.unlink()
-#         return JSONResponse(status_code=400, content={"success": False, "error": str(e)})
-#     finally:
-#         cursor.close()
-#         conn.close()
-
-
-# # ═════════════════════════════════════════════════════════════════════════════
-# # DANH SÁCH NGƯỜI DÙNG
-# # ═════════════════════════════════════════════════════════════════════════════
-# @app.get("/api/face/persons")
-# async def get_persons():
-#     conn   = get_db_connection()
-#     cursor = conn.cursor(dictionary=True)
-#     try:
-#         cursor.execute("""
-#             SELECT p.id, p.name, p.role, p.department, p.status,
-#                    p.img_path, p.registered_at AS registered,
-#                    (SELECT COUNT(*) FROM face_embeddings e WHERE e.person_id = p.id) AS embeddings,
-#                    (SELECT COUNT(*) FROM recognition_logs l WHERE l.person_id = p.id AND l.status='success') AS recognitions
-#             FROM persons p ORDER BY p.registered_at DESC
-#         """)
-#         rows = cursor.fetchall()
-
-#         # Chuyển img_path → img_url
-#         for row in rows:
-#             raw = row.get("img_path") or ""
-#             row["img"] = f"/uploads/{Path(raw).name}" if raw else ""
-
-#         return {"success": True, "data": rows, "total": len(rows), "ramCount": face_memory_store.count}
-#     finally:
-#         cursor.close()
-#         conn.close()
-
-
-# # ═════════════════════════════════════════════════════════════════════════════
-# # CẬP NHẬT
-# # ═════════════════════════════════════════════════════════════════════════════
-# @app.put("/api/face/persons/{id}")
-# async def update_person(id: str, person_data: PersonUpdate):
-#     conn   = get_db_connection()
-#     cursor = conn.cursor()
-#     try:
-#         cursor.execute(
-#             "UPDATE persons SET name=%s, role=%s, department=%s WHERE id=%s",
-#             (person_data.name, person_data.role, person_data.department, id),
-#         )
-#         conn.commit()
-#         if cursor.rowcount == 0:
-#             return JSONResponse(status_code=404, content={"success": False, "error": "Không tìm thấy"})
-
-#         face_memory_store.update_info(id, person_data.name, person_data.role)
-#         return {"success": True, "message": "Cập nhật thành công"}
-#     finally:
-#         cursor.close()
-#         conn.close()
-
-
-# # ═════════════════════════════════════════════════════════════════════════════
-# # XÓA
-# # ═════════════════════════════════════════════════════════════════════════════
-# @app.delete("/api/face/persons/{id}")
-# async def delete_person(id: str):
-#     conn   = get_db_connection()
-#     cursor = conn.cursor(dictionary=True)
-#     try:
-#         # Lấy img_path để xóa file
-#         cursor.execute("SELECT img_path FROM persons WHERE id=%s", (id,))
-#         row = cursor.fetchone()
-
-#         cursor2 = conn.cursor()
-#         cursor2.execute("DELETE FROM persons WHERE id=%s", (id,))
-#         conn.commit()
-
-#         if cursor2.rowcount == 0:
-#             return JSONResponse(status_code=404, content={"success": False, "error": "Không tìm thấy"})
-
-#         # Xóa file ảnh trên disk
-#         if row and row.get("img_path"):
-#             p = Path(row["img_path"])
-#             if p.exists():
-#                 p.unlink()
-
-#         removed = face_memory_store.remove_by_person(id)
-#         return {"success": True, "message": "Đã xóa", "removedFromRam": removed}
-#     finally:
-#         cursor.close()
-#         conn.close()
-
-
-# # ═════════════════════════════════════════════════════════════════════════════
-# # LỊCH SỬ
-# # ═════════════════════════════════════════════════════════════════════════════
-# @app.get("/api/face/logs")
-# async def get_logs():
-#     conn   = get_db_connection()
-#     cursor = conn.cursor(dictionary=True)
-#     try:
-#         cursor.execute("""
-#             SELECT l.id, COALESCE(p.name,'Người lạ') AS name,
-#                    DATE_FORMAT(l.created_at,'%H:%i:%s') AS time,
-#                    DATE_FORMAT(l.created_at,'%d/%m/%Y') AS date,
-#                    l.status, l.confidence, l.camera, l.action,
-#                    p.img_path AS img_raw
-#             FROM recognition_logs l
-#             LEFT JOIN persons p ON l.person_id = p.id
-#             ORDER BY l.created_at DESC LIMIT 100
-#         """)
-#         rows = cursor.fetchall()
-#         for row in rows:
-#             raw = row.pop("img_raw", "") or ""
-#             row["img"] = f"/uploads/{Path(raw).name}" if raw else ""
-#         return {"success": True, "data": rows, "total": len(rows)}
-#     finally:
-#         cursor.close()
-#         conn.close()
-
-
-# # ═════════════════════════════════════════════════════════════════════════════
-# # THỐNG KÊ
-# # ═════════════════════════════════════════════════════════════════════════════
-# @app.get("/api/face/statistics")
-# async def get_statistics():
-#     conn   = get_db_connection()
-#     cursor = conn.cursor(dictionary=True)
-#     try:
-#         cursor.execute("SELECT status, created_at FROM recognition_logs ORDER BY created_at DESC LIMIT 1000")
-#         all_logs = cursor.fetchall()
-
-#         hourly = {f"{i:02d}:00": {"nhận_diện": 0, "từ_chối": 0, "lạ": 0} for i in range(24)}
-#         days   = ["T2","T3","T4","T5","T6","T7","CN"]
-#         weekly = {d: 0 for d in days}
-
-#         for log in all_logs:
-#             h = f"{log['created_at'].hour:02d}:00"
-#             d = days[log["created_at"].weekday()]
-#             if log["status"] == "success":
-#                 hourly[h]["nhận_diện"] += 1
-#                 weekly[d] += 1
-#             elif log["status"] == "unknown":
-#                 hourly[h]["lạ"] += 1
-
-#         return {
-#             "success": True,
-#             "data": {
-#                 "hourlyData": [{"time": t, **v} for t, v in hourly.items()],
-#                 "weeklyData": [{"day": d, "value": v} for d, v in weekly.items()],
-#             },
-#         }
-#     finally:
-#         cursor.close()
-#         conn.close()
-
-
-# # ═════════════════════════════════════════════════════════════════════════════
-# # DEBUG
-# # ═════════════════════════════════════════════════════════════════════════════
-# @app.get("/api/face/memory-status")
-# async def memory_status():
-#     return {
-#         "success":  True,
-#         "loaded":   face_memory_store.is_loaded,
-#         "ramCount": face_memory_store.count,
-#     }
-
-# @app.post("/api/face/reload-memory")
-# async def reload_memory():
-#     _load_embeddings_to_ram()
-#     return {"success": True, "ramCount": face_memory_store.count}
-
-
-# if __name__ == "__main__":
-#     import uvicorn
-#     uvicorn.run(app, host="0.0.0.0", port=3001)
-
-
 import os
 import sys
 from pathlib import Path
+import threading
+import platform
+
+# ─── 0. FIX LỖI PYTORCH TRÊN MÔI TRƯỜNG LINUX (HUGGING FACE) ──────────────────
+if platform.system() == 'Linux':
+    import pathlib
+    pathlib.WindowsPath = pathlib.PosixPath
 
 # ─── 1. CẤU HÌNH ĐƯỜNG DẪN TUYỆT ĐỐI (TRÁNH LẠC ĐƯỜNG) ────���─────────────────
-# Lấy đường dẫn của thư mục 'controllers' hiện tại
 current_dir = os.path.dirname(os.path.abspath(__file__))
-# Lấy đường dẫn của thư mục gốc 'server'
 root_dir = os.path.dirname(current_dir)
 
-# Đưa các thư mục vào tầm ngắm của Python
 sys.path.insert(0, current_dir)
 sys.path.insert(0, os.path.join(current_dir, 'DetecInfoBoxes'))
 if root_dir not in sys.path:
@@ -471,7 +29,7 @@ from contextlib import asynccontextmanager
 from datetime import date
 from dotenv import load_dotenv
 
-# ─── 3. IMPORT CHUẨN (KHÔNG CÒN LỖI MODULE) ───────────────────────────────────
+# ─── 3. IMPORT CHUẨN ──────────────────────────────────────────────────────────
 from readInfoIdCard import ReadInfo
 from DetecInfoBoxes.GetBoxes import Detect
 from Vocr.tool.predictor import Predictor
@@ -493,23 +51,33 @@ from service.face_service import face_ai_service, face_memory_store, UPLOAD_DIR
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# BẮT BUỘC: Tạo thư mục uploads nếu chưa có
+os.makedirs(UPLOAD_DIR, exist_ok=True)
 
-# ─── KHỞI TẠO AI: YOLOv7 + VietOCR ────────────────────────────────────────────
-logger.info("[Startup] Nạp mô hình VietOCR (VGG-seq2seq)...")
-vocr_config_path = os.path.join(current_dir, 'Vocr', 'config', 'vgg-seq2seq.yml')
-config_vietocr = Cfg_vietocr.load_config_from_file(vocr_config_path)
+# ─── KHỞI TẠO AI CHẠY NGẦM (CHỐNG TIMEOUT CLOUD) ──────────────────────────────
+ocr_predictor = None
+read_info = None
+is_ai_ready = False
 
-config_vietocr['weights'] = os.path.join(current_dir, 'Models', 'seq2seqocr.pth')
-config_vietocr['device']  = 'cpu'  # Đổi thành 'cuda:0' nếu máy có Card rời NVIDIA
-ocr_predictor = Predictor(config_vietocr)
-
-logger.info("[Startup] Nạp mô hình YOLOv7 (Phát hiện vùng thông tin)...")
-get_dictionary = Detect(opt)
-scan_weight = os.path.join(current_dir, 'Models', 'cccdYoloV7.pt')
-imgsz, stride, device, half, model, names = get_dictionary.load_model(scan_weight)
-
-read_info = ReadInfo(imgsz, stride, device, half, model, names, ocr_predictor)
-logger.info("[Startup] Hệ thống YOLO + VietOCR đã sẵn sàng!")
+def load_ai_background():
+    global ocr_predictor, read_info, is_ai_ready
+    try:
+        logger.info("[AI_LOADER] Bắt đầu nạp mô hình VietOCR và YOLO chạy ngầm...")
+        vocr_config_path = os.path.join(current_dir, 'Vocr', 'config', 'vgg-seq2seq.yml')
+        config_vietocr = Cfg_vietocr.load_config_from_file(vocr_config_path)
+        config_vietocr['weights'] = os.path.join(current_dir, 'Models', 'seq2seqocr.pth')
+        config_vietocr['device']  = 'cpu' 
+        ocr_predictor = Predictor(config_vietocr)
+
+        get_dictionary = Detect(opt)
+        scan_weight = os.path.join(current_dir, 'Models', 'cccdYoloV7.pt')
+        imgsz, stride, device, half, model, names = get_dictionary.load_model(scan_weight)
+
+        read_info = ReadInfo(imgsz, stride, device, half, model, names, ocr_predictor)
+        is_ai_ready = True
+        logger.info("[AI_LOADER] Hệ thống YOLO + VietOCR đã sẵn sàng!")
+    except Exception as e:
+        logger.error(f"[AI_LOADER] Lỗi khi nạp AI: {e}")
 
 
 # ─── Startup ──────────────────────────────────────────────────────────────────
@@ -520,8 +88,12 @@ async def lifespan(app: FastAPI):
     logger.info("[Startup] Nạp embedding vào RAM...")
     _load_embeddings_to_ram()
     logger.info(f"[Startup] {face_memory_store.count} khuôn mặt trên RAM")
+    
+    # Bật luồng chạy ngầm để nạp AI
+    threading.Thread(target=load_ai_background, daemon=True).start()
     yield
     logger.info("[Shutdown] Bye!")
+
 def _load_embeddings_to_ram():
     conn = None
     cursor = None
@@ -529,7 +101,7 @@ def _load_embeddings_to_ram():
         conn   = get_db_connection()
         cursor = conn.cursor(dictionary=True)
         cursor.execute("""
-            SELECT e.person_id, p.name, p.role, p.img_path,
+            SELECT e.person_id, p.name, p.role, p.img_path, p.img_url,
                    p.work_expiry_date, e.embedding_vector
             FROM face_embeddings e
             JOIN persons p ON e.person_id = p.id
@@ -539,20 +111,22 @@ def _load_embeddings_to_ram():
         parsed = []
         for row in rows:
             try:
+                # Ưu tiên lấy URL ảnh online truyền vào RAM, để khi nhận diện xong trả về React luôn
+                display_img = row.get("img_url") or row.get("img_path", "")
                 parsed.append({
                     "person_id":        row["person_id"],
                     "name":             row["name"],
                     "role":             row.get("role", ""),
-                    "img_path":         row.get("img_path", ""),
+                    "img_path":         display_img,
                     "work_expiry_date": str(row["work_expiry_date"]) if row.get("work_expiry_date") else None,
                     "embedding_vector": json.loads(row["embedding_vector"]),
                 })
             except Exception as e:
                 logger.warning(f"[Startup] Bỏ qua khuôn mặt lỗi: {e}")
-                face_memory_store.load_all(parsed)
+        face_memory_store.load_all(parsed)
         
     except Exception as e:
-        logger.error(f"[Startup]  Lỗi kết nối DB khi nạp dữ liệu: {e}")
+        logger.error(f"[Startup] Lỗi kết nối DB khi nạp dữ liệu: {e}")
         face_memory_store.load_all([]) 
         
     finally:
@@ -573,13 +147,11 @@ app.add_middleware(
 
 app.mount("/uploads", StaticFiles(directory=UPLOAD_DIR), name="uploads")
 
-
 class PersonUpdate(BaseModel):
     name: str
     role: str
     department: str
 
-
 def save_log_to_db(log_queries: list) -> None:
     if not log_queries:
         return
@@ -597,8 +169,15 @@ def save_log_to_db(log_queries: list) -> None:
         logger.error(f"[Log] {e}")
 
 
+# ═════════════════════════════════════════════════════════════════════════════
+# API ĐỌC CCCD (OCR)
+# ═════════════════════════════════════════════════════════════════════════════
 @app.post("/api/face/ocr")
 async def extract_ocr_local(file: UploadFile = File(...), side: str = Form(...)):
+    global is_ai_ready, read_info
+    if not is_ai_ready or not read_info:
+        return JSONResponse(status_code=503, content={"success": False, "error": "AI đang khởi động, vui lòng chờ 1 phút rồi thử lại!"})
+
     temp_path = ""
     try:
         temp_filename = f"temp_cccd_{uuid.uuid4().hex}.jpg"
@@ -607,11 +186,10 @@ async def extract_ocr_local(file: UploadFile = File(...), side: str = Form(...))
         with open(temp_path, "wb") as f:
             f.write(file_bytes)
 
-        logger.info(f"[OCR] Phân tích mặt {side} bằng YOLOv7 + VietOCR...")
+        logger.info(f"[OCR] Phân tích mặt {side}...")
 
         if side == "front":
             raw = read_info.get_all_info(temp_path)
-            logger.info(f"[OCR] Mặt trước raw: {raw}")
             mapped_data = {
                 "id_number":        raw.get("id", ""),
                 "full_name":        raw.get("full_name", ""),
@@ -622,10 +200,8 @@ async def extract_ocr_local(file: UploadFile = File(...), side: str = Form(...))
                 "address":          raw.get("place_of_residence", ""),
                 "expiry_date":      raw.get("date_of_expiry", ""),
             }
-
-        else:  # back — ĐÃ NÂNG CẤP: dùng get_back_info như mặt trước
+        else:  
             raw = read_info.get_back_info(temp_path)
-            logger.info(f"[OCR] Mặt sau raw: {raw}")
             mapped_data = {
                 "issue_date":       raw.get("issue_date", ""),
                 "issued_by":        raw.get("issued_by", ""),
@@ -635,18 +211,17 @@ async def extract_ocr_local(file: UploadFile = File(...), side: str = Form(...))
         if os.path.exists(temp_path):
             os.remove(temp_path)
 
-        logger.info(f"[OCR] Trả về React: {mapped_data}")
         return {"success": True, "data": mapped_data}
 
     except Exception as e:
-        logger.error(f"[OCR] Lỗi: {e}", exc_info=True)
+        logger.error(f"[OCR] Lỗi: {e}")
         if os.path.exists(temp_path):
             os.remove(temp_path)
         return {"success": True, "data": {}}
 
 
 # ═════════════════════════════════════════════════════════════════════════════
-# NHẬN DIỆN KHUÔN MẶT
+# API NHẬN DIỆN KHUÔN MẶT
 # ═════════════════════════════════════════════════════════════════════════════
 @app.post("/api/face/recognize")
 async def recognize(
@@ -668,11 +243,9 @@ async def recognize(
         match = face_memory_store.find_best_match(np.array(face["descriptor"], dtype=np.float32))
 
         if match:
-            # ── Kiểm tra hết hạn làm việc ────────────────────────────
             expiry_str = match.get("work_expiry_date")
             if expiry_str:
                 if date.fromisoformat(expiry_str) < today:
-                    logger.info(f"[Recognize]  {match['name']} — HẾT HẠN {expiry_str}")
                     results.append({
                         "id": match["person_id"], "name": match["name"],
                         "role": match["role"], "img": "",
@@ -683,8 +256,12 @@ async def recognize(
                     continue
 
             confidence = round(max(0.0, (1.0 - match["distance"]) * 100.0), 2)
-            img_url    = f"/uploads/{Path(match['img_path']).name}" if match.get("img_path") else ""
-            logger.info(f"[Recognize]  {match['name']} dist={match['distance']:.4f} conf={confidence:.1f}%")
+            
+            # Ưu tiên lấy Link Online (Vì RAM đang lưu URL online thay vì path)
+            img_url = match.get("img_path", "")
+            if img_url and not img_url.startswith("http"):
+                img_url = f"/uploads/{Path(img_url).name}"
+
             results.append({
                 "id": match["person_id"], "name": match["name"],
                 "role": match["role"], "img": img_url,
@@ -713,15 +290,15 @@ async def recognize(
 
 
 # ═════════════════════════════════════════════════════════════════════════════
-# ĐĂNG KÝ
+# API ĐĂNG KÝ
 # ═════════════════════════════════════════════════════════════════════════════
 @app.post("/api/face/register")
 async def register(
     name:             str = Form(...),
     role:             str = Form(""),
     department:       str = Form(""),
-    work_expiry_date: str = Form(""),    # YYYY-MM-DD hoặc ""
-    cccd_info:        str = Form("{}"),  # JSON string từ StepCCCD
+    work_expiry_date: str = Form(""),    
+    cccd_info:        str = Form("{}"),  
     images:      list[UploadFile] = File(...),
     cccd_front:  UploadFile = File(None),
     cccd_back:   UploadFile = File(None),
@@ -730,10 +307,12 @@ async def register(
     cursor    = conn.cursor()
     person_id = str(uuid.uuid4())
     new_encodings: list[tuple] = []
+    saved_files = [] 
+    
+    # URL và Path để lưu cho người dùng
     avatar_path = ""
-    saved_files = [] # Lưu danh sách file đã tạo để xóa nếu có lỗi
+    avatar_url = ""
 
-    # ĐỊNH NGHĨA NGƯỠNG SO SÁNH KHUÔN MẶT (Càng cao càng khắt khe, khuyên dùng 0.35 - 0.45)
     COSINE_THRESHOLD = 0.4 
 
     try:
@@ -741,13 +320,13 @@ async def register(
         expiry_val = work_expiry_date or None
         cccd_number = cccd.get("id_number")
 
-        # ── 1. CHECK TRÙNG CCCD ─────────────────────────────────────────────
+        # ── 1. CHECK TRÙNG CCCD ──
         if cccd_number:
             cursor.execute("SELECT id FROM citizen_ids WHERE id_number = %s", (cccd_number,))
             if cursor.fetchone():
                 raise Exception("Số CCCD này đã được đăng ký trong hệ thống!")
 
-        # ── 2. XỬ LÝ ẢNH KHUÔN MẶT WEBCAM/UPLOAD ────────────────────────────
+        # ── 2. LƯU ẢNH KHUÔN MẶT ──
         user_descriptor = None
         for i, img_file in enumerate(images):
             img_bytes  = await img_file.read()
@@ -762,41 +341,42 @@ async def register(
             emb_id     = str(uuid.uuid4())
             
             if i == 0:
-                user_descriptor = descriptor # Lưu ảnh đầu tiên để so sánh với CCCD
+                user_descriptor = descriptor 
 
-            # Lưu file cứng
-            saved_path = face_ai_service.save_image(img_bytes, person_id, index=i)
+            # NHẬN 2 KẾT QUẢ TỪ HÀM SAVE_IMAGE MỚI
+            saved_path, saved_url = face_ai_service.save_image(img_bytes, person_id, index=i)
             saved_files.append(saved_path)
             
             if i == 0:
                 avatar_path = saved_path
+                avatar_url = saved_url
                 cursor.execute(
                     """INSERT INTO persons 
-                         (id, name, role, department, status, img_path, work_expiry_date)
-                       VALUES (%s, %s, %s, %s, 'active', %s, %s)""",
-                    (person_id, name, role, department, avatar_path, expiry_val),
+                         (id, name, role, department, status, img_path, img_url, work_expiry_date)
+                       VALUES (%s, %s, %s, %s, 'active', %s, %s, %s)""",
+                    (person_id, name, role, department, avatar_path, avatar_url, expiry_val),
                 )
 
             cursor.execute(
                 "INSERT INTO face_embeddings (id, person_id, embedding_vector) VALUES (%s, %s, %s)",
                 (emb_id, person_id, json.dumps(descriptor)),
             )
-            new_encodings.append((person_id, name, role, avatar_path, expiry_val, descriptor))
+            
+            # Truyền URL online vào RAM nếu có, không có thì dùng path cũ
+            display_img = avatar_url if avatar_url else avatar_path
+            new_encodings.append((person_id, name, role, display_img, descriptor))
 
-        # ── 3. XỬ LÝ CCCD VÀ SO SÁNH KHUÔN MẶT ──────────────────────────────
+        # ── 3. LƯU ẢNH CCCD ──
         front_path, back_path = "", ""
 
         if cccd_front:
             fb_bytes = await cccd_front.read()
             if fb_bytes:
-                # Trích xuất khuôn mặt từ ảnh mặt trước CCCD
                 cccd_detections = face_ai_service.extract_faces(fb_bytes)
                 if len(cccd_detections) == 0:
                     raise Exception("Không tìm thấy khuôn mặt trên ảnh mặt trước CCCD.")
                 
                 cccd_descriptor = cccd_detections[0]["descriptor"]
-
-                # So sánh độ tương đồng (Cosine Similarity)
                 q = face_memory_store._norm(np.array(user_descriptor, dtype=np.float32))
                 c = face_memory_store._norm(np.array(cccd_descriptor, dtype=np.float32))
                 score = float(np.dot(q, c))
@@ -805,13 +385,15 @@ async def register(
                     logger.warning(f"Cảnh báo giả mạo: Score {score} < {COSINE_THRESHOLD}")
                     raise Exception("Cảnh báo: Khuôn mặt trên thẻ CCCD KHÔNG KHỚP với ảnh chụp trực tiếp!")
 
-                front_path = face_ai_service.save_image(fb_bytes, f"cccd_front_{person_id}", index=0)
+                f_path, f_url = face_ai_service.save_image(fb_bytes, f"cccd_front_{person_id}", index=0)
+                front_path = f_path
                 saved_files.append(front_path)
 
         if cccd_back:
             bb_bytes = await cccd_back.read()
             if bb_bytes:
-                back_path = face_ai_service.save_image(bb_bytes, f"cccd_back_{person_id}", index=0)
+                b_path, b_url = face_ai_service.save_image(bb_bytes, f"cccd_back_{person_id}", index=0)
+                back_path = b_path
                 saved_files.append(back_path)
 
         cursor.execute("""
@@ -833,22 +415,20 @@ async def register(
 
         conn.commit()
 
-        # ── 4. CẬP NHẬT RAM NGAY LẬP TỨC ─────────────────────────────────
-        for pid, pname, prole, pimg, pexpiry, enc in new_encodings:
-            face_memory_store.add(pid, pname, prole, pimg, enc) # Đã bỏ work_expiry_date
+        # ── 4. CẬP NHẬT RAM NGAY LẬP TỨC ──
+        for pid, pname, prole, pimg, enc in new_encodings:
+            face_memory_store.add(pid, pname, prole, pimg, enc) 
 
-        logger.info(f"[Register]  {name} | {len(new_encodings)} mẫu | RAM: {face_memory_store.count}")
         return {
             "success":  True,
-            "message":  f"Đã đăng ký {name} với {len(new_encodings)} mẫu.",
-            "img_url":  f"/uploads/{Path(avatar_path).name}" if avatar_path else "",
+            "message":  f"Đã đăng ký {name} thành công.",
+            "img_url":  avatar_url if avatar_url else (f"/uploads/{Path(avatar_path).name}" if avatar_path else ""),
             "ramCount": face_memory_store.count,
         }
 
     except Exception as e:
         conn.rollback()
         logger.error(f"[Register Lỗi]  {e}")
-        # Rollback: Xóa các file ảnh vừa tạo nếu có lỗi xảy ra
         for path in saved_files:
             p = Path(path)
             if p.exists():
@@ -857,8 +437,10 @@ async def register(
     finally:
         cursor.close()
         conn.close()
+
+
 # ═════════════════════════════════════════════════════════════════════════════
-# DANH SÁCH NGƯỜI DÙNG
+# API LẤY DANH SÁCH (SỬA ĐỂ TRẢ VỀ LINK IMGBB)
 # ═════════════════════════════════════════════════════════════════════════════
 @app.get("/api/face/persons")
 async def get_persons():
@@ -867,7 +449,7 @@ async def get_persons():
     try:
         cursor.execute("""
             SELECT p.id, p.name, p.role, p.department, p.status,
-                   p.img_path, p.work_expiry_date,
+                   p.img_path, p.img_url, p.work_expiry_date,
                    p.registered_at AS registered,
                    (SELECT COUNT(*) FROM face_embeddings e WHERE e.person_id = p.id) AS embeddings,
                    (SELECT COUNT(*) FROM recognition_logs l WHERE l.person_id = p.id AND l.status = 'success') AS recognitions,
@@ -881,8 +463,11 @@ async def get_persons():
         rows  = cursor.fetchall()
         today = str(date.today())
         for row in rows:
-            raw = row.get("img_path") or ""
-            row["img"]        = f"/uploads/{Path(raw).name}" if raw else ""
+            # Lấy URL online trước, nếu không có mới chế link Local
+            online_link = row.get("img_url")
+            local_path = row.get("img_path") or ""
+            row["img"] = online_link if online_link else (f"/uploads/{Path(local_path).name}" if local_path else "")
+            
             exp               = row.get("work_expiry_date")
             row["is_expired"] = bool(exp and str(exp) < today)
         return {"success": True, "data": rows, "total": len(rows), "ramCount": face_memory_store.count}
@@ -892,7 +477,7 @@ async def get_persons():
 
 
 # ═════════════════════════════════════════════════════════════════════════════
-# CẬP NHẬT & XÓA & LOGS & THỐNG KÊ (Giữ nguyên)
+# CẬP NHẬT, XÓA VÀ LOGS (FIX MÚI GIỜ + URL)
 # ═════════════════════════════════════════════════════════════════════════════
 @app.put("/api/face/persons/{id}")
 async def update_person(id: str, person_data: PersonUpdate):
@@ -941,18 +526,20 @@ async def get_logs():
     try:
         cursor.execute("""
             SELECT l.id, COALESCE(p.name, 'Người lạ') AS name,
-                   DATE_FORMAT(l.created_at, '%H:%i:%s') AS time,
-                   DATE_FORMAT(l.created_at, '%d/%m/%Y') AS date,
+                   DATE_FORMAT(DATE_ADD(l.created_at, INTERVAL 7 HOUR), '%H:%i:%s') AS time,
+                   DATE_FORMAT(DATE_ADD(l.created_at, INTERVAL 7 HOUR), '%d/%m/%Y') AS date,
                    l.status, l.confidence, l.camera, l.action,
-                   p.img_path AS img_raw
+                   p.img_path AS img_raw,
+                   p.img_url
             FROM recognition_logs l
             LEFT JOIN persons p ON l.person_id = p.id
             ORDER BY l.created_at DESC LIMIT 100
         """)
         rows = cursor.fetchall()
         for row in rows:
+            online_link = row.pop("img_url", None)
             raw = row.pop("img_raw", "") or ""
-            row["img"] = f"/uploads/{Path(raw).name}" if raw else ""
+            row["img"] = online_link if online_link else (f"/uploads/{Path(raw).name}" if raw else "")
         return {"success": True, "data": rows, "total": len(rows)}
     finally:
         cursor.close()
@@ -963,7 +550,8 @@ async def get_statistics():
     conn   = get_db_connection()
     cursor = conn.cursor(dictionary=True)
     try:
-        cursor.execute("SELECT status, created_at FROM recognition_logs ORDER BY created_at DESC LIMIT 1000")
+        # CỘNG 7 TIẾNG ĐỂ BIỂU ĐỒ HIỂN THỊ ĐÚNG GIỜ VIỆT NAM
+        cursor.execute("SELECT status, DATE_ADD(created_at, INTERVAL 7 HOUR) AS created_at FROM recognition_logs ORDER BY created_at DESC LIMIT 1000")
         all_logs = cursor.fetchall()
         hourly = {f"{i:02d}:00": {"nhận_diện": 0, "từ_chối": 0, "lạ": 0} for i in range(24)}
         days   = ["T2", "T3", "T4", "T5", "T6", "T7", "CN"]