refactor: payload & response adjusment

app.py

@@ -72,6 +72,28 @@ async def start_detection(data: Dict):
     if not station_id or not parts or not webhook_url or not cameras:
         return {"status": "error", "message": "Missing required fields"}
 
+    # -------------------------------
+    # VALIDATION BEFORE EXECUTION
+    # -------------------------------
+    required_parts_fields = [
+        "id", 
+        "pin_api", 
+        "name", 
+        "sku"
+    ]
+    validation_errors = validate_input(required_parts_fields, station_id, cameras, parts, webhook_url)
+
+    if validation_errors:
+        logger.error("[VALIDATION FAILED] Input data is invalid.")
+        for err in validation_errors:
+            logger.error(f" - {err}")
+        return {
+            "status": "error", 
+            "station_id": station_id,
+            "camera_count": len(cameras),
+            "message": " | ".join(validation_errors)
+        }
+
     logger.info(f"[INFO] Get metadata parts")
     model_path = model_by_id_metadata(parts['id'])
 

core/defect_detection.py

@@ -7,13 +7,13 @@ from utils import *
 
 load_dotenv()
 
-WEBHOOK_URL         = os.getenv("WEBHOOK", "https://webhook.site/2f7a6096-619e-471d-8d26-9a6bb9e4ca14")
-MODEL_VERSION       = os.getenv("MODEL_VERSION", "v1.0.0")
+MODEL_VERSION   = os.getenv("MODEL_VERSION")
+WEBHOOK_URL     = os.getenv("WEBHOOK_URL")
 
-MAX_RUNTIME_SEC     = float(os.getenv("MAX_RUNTIME_SEC", "20"))
-FRAME_FAIL_SLEEP    = float(os.getenv("FRAME_FAIL_SLEEP", "0.05"))
-DEFAULT_FPS         = float(os.getenv("DEFAULT_FPS", "25"))
-WEBHOOK_TIMEOUT     = float(os.getenv("WEBHOOK_TIMEOUT", "10.0"))
+MAX_RUNTIME_SEC     = float(os.getenv("MAX_RUNTIME_SEC"))
+FRAME_FAIL_SLEEP    = float(os.getenv("FRAME_FAIL_SLEEP"))
+DEFAULT_FPS         = float(os.getenv("DEFAULT_FPS"))
+WEBHOOK_TIMEOUT     = float(os.getenv("WEBHOOK_TIMEOUT"))
 
 # ============================================================
 # DEFECT DETECTION FROM VIDEO URL
@@ -34,6 +34,9 @@ def detect_defect_from_video_url(station_id, camera_id: str, video_url: str, mod
             "station_id": station_id,
             "camera_id": camera_id,
             "status": "error",
+            "status_defect": "",
+            "image_base64": "",
+            "image_path": "",
             "detections": [],
             "message": f"Cannot open video URL: {video_url}"
         }
@@ -96,10 +99,10 @@ def detect_defect_from_video_url(station_id, camera_id: str, video_url: str, mod
                     frame_base64 = base64.b64encode(buffer).decode("utf-8")
 
                     # Save annotated image
-                    output_dir = "outputs/images"
+                    # output_dir = "outputs/images"
                     # os.makedirs(output_dir, exist_ok=True)
-                    filename = f"{station_id}_{camera_id}_NG_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
-                    filepath = os.path.join(output_dir, filename)
+                    # filename = f"{station_id}_{camera_id}_NG_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+                    # filepath = os.path.join(output_dir, filename)
                     # cv2.imwrite(filepath, frame)
                     # logger.info(f"[SAVED] NG image saved to {filepath}")
 
@@ -109,14 +112,16 @@ def detect_defect_from_video_url(station_id, camera_id: str, video_url: str, mod
                     return {
                         "station_id": station_id,
                         "camera_id": camera_id,
+                        "status": "success",
                         "status_defect": "NG",
                         "image_base64": frame_base64,
-                        "image_path": filepath,
+                        # "image_path": filepath,
                         "detections": [{
                             "class": defect_name,
                             "confidence": conf,
                             "bbox": xyxy
-                        }]
+                        }],
+                        "message": f"Detected as defect"
                     }
 
     # --- no defect detected ---
@@ -127,12 +132,12 @@ def detect_defect_from_video_url(station_id, camera_id: str, video_url: str, mod
         frame_base64 = base64.b64encode(buffer).decode("utf-8")
 
         # Save OK image (no bbox)
-        output_dir = "outputs/images"
-        os.makedirs(output_dir, exist_ok=True)
-        filename = f"{station_id}_{camera_id}_OK_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
-        filepath = os.path.join(output_dir, filename)
-        cv2.imwrite(filepath, last_frame)
-        logger.info(f"[SAVED] OK image saved to {filepath}")
+        # output_dir = "outputs/images"
+        # os.makedirs(output_dir, exist_ok=True)
+        # filename = f"{station_id}_{camera_id}_OK_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+        # filepath = os.path.join(output_dir, filename)
+        # cv2.imwrite(filepath, last_frame)
+        # logger.info(f"[SAVED] OK image saved to {filepath}")
     else:
         frame_base64 = ""
         filepath = None
@@ -140,10 +145,12 @@ def detect_defect_from_video_url(station_id, camera_id: str, video_url: str, mod
     return {
         "station_id": station_id,
         "camera_id": camera_id,
+        "status": "success",
         "status_defect": "OK",
         "image_base64": frame_base64,
-        "image_path": filepath,
-        "detections": []
+        # "image_path": filepath,
+        "detections": [],
+        "message": f"Detected as normal (no defect)"
     }
 
 
@@ -158,25 +165,47 @@ async def _detect_camera_video(station_id: str, camera: Dict, stop_flag: Dict, m
 async def run_detection_group(station_id: str, cameras: List[Dict], webhook_url: str, model=None, parts=str):
     """
     Run detection for all cameras in parallel.
+    Validate input before detection.
     Send webhook with NG/OK status.
     """
+    
     stop_flag = {"stop": False}
     logger.info(f"[START] Station {station_id} → {len(cameras)} camera(s)")
-
-    results = await asyncio.gather(*[
-        _detect_camera_video(station_id, cam, stop_flag, model)
-        for cam in cameras
-    ])
+    
+    results = await asyncio.gather(
+        *[_detect_camera_video(station_id, cam, stop_flag, model) for cam in cameras],
+        return_exceptions=True
+    )
+
+    # misalnya results sudah berisi hasil dari tiap kamera
+    has_error = any(
+        isinstance(r, Exception) or (isinstance(r, dict) and r.get("status") == "error")
+        for r in results
+    )
+    all_error = all(
+        isinstance(r, Exception) or (isinstance(r, dict) and r.get("status") == "error")
+        for r in results
+    )
+
+    if all_error:
+        status = "error"
+        message = "All cameras failed during detection"
+    elif has_error:
+        status = "partial_error"
+        message = "Some cameras failed during detection"
+    else:
+        status = "success"
+        message = "Success detecting defects"
 
     payload = {
-        "status": "success",
-        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "status": status,
+        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime()),
         "model_version": MODEL_VERSION,
-        "parts" : parts,
+        "message": message,
+        "parts": parts,
         "data": results,
     }
 
-    # Send webhook
     try:
         async with httpx.AsyncClient(timeout=WEBHOOK_TIMEOUT) as client:
             await client.post(webhook_url, json=payload)
@@ -184,4 +213,5 @@ async def run_detection_group(station_id: str, cameras: List[Dict], webhook_url:
     except Exception as e:
         logger.error(f"[ERROR] Webhook failed: {e}")
 
+    return "DONE"
     # return payload

utils.py

@@ -1,5 +1,6 @@
-import logging, sys, asyncio, random, json
+import logging, sys, asyncio, random, json, requests, os
 from pathlib import Path
+from dotenv import load_dotenv
 
 # ============================================================
 # LOGGER SETUP
@@ -22,6 +23,37 @@ async def async_sleep_random(min_s=0.2, max_s=0.8):
     """
     durasi = random.uniform(min_s, max_s)
     await asyncio.sleep(durasi)
+    
+# ==============================================================
+# VALIDATION FUNCTION
+# ==============================================================
+def validate_input(required_parts_fields, station_id, cameras, parts, webhook_url):
+    errors = []
+
+    # Validate station_id
+    if not station_id or not str(station_id).strip():
+        errors.append("station_id is missing or empty")
+
+    # Validate parts
+    for field in required_parts_fields:
+        if field not in parts or not str(parts[field]).strip():
+            errors.append(f"parts.{field} is missing or empty")
+
+    # Validate cameras list
+    if not isinstance(cameras, list) or len(cameras) == 0:
+        errors.append("cameras must be a non-empty list")
+    else:
+        for index, cam in enumerate(cameras):
+            if "camera_id" not in cam or not str(cam["camera_id"]).strip():
+                errors.append(f"camera[{index}].camera_id missing or empty")
+            if "rtsp_url" not in cam or not str(cam["rtsp_url"]).strip():
+                errors.append(f"camera[{index}].rtsp_url missing or empty")
+
+    # Validate webhook
+    if not webhook_url or not webhook_url.startswith("http"):
+        errors.append("webhook_url is invalid or missing")
+
+    return errors
 
 # ============================================================
 # HELPER
@@ -83,4 +115,15 @@ def color_defect(defect_name):
     r = int(hex_color[0:2], 16)
     g = int(hex_color[2:4], 16)
     b = int(hex_color[4:6], 16)
-    return (b, g, r)  # Convert to BGR
+    return (b, g, r)  # Convert to BGR
+
+def load_json(path):
+    with open(path, "r") as f:
+        return json.load(f)
+
+def start_detection(base_url, payload):
+    return requests.post(f"{base_url}/start-detection", json=payload)
+
+def load_config():
+    load_dotenv()
+    return os.getenv("BASE_URL"), os.getenv("WEBHOOK")