Update : Git Ignore .env

BackEnd/.gitignore

@@ -1,4 +1,22 @@
+# --- Security / Environments ---
+.env
+
+# --- Python / Flask ---
 __pycache__/
-*.pkl
-# Apple Mac's Hidden Desktop Files
+*.py[cod]
+*$py.class
+venv/
+env/
+.venv/
+
+# --- IDEs / Editors ---
+.idea/
+.vscode/
+
+# --- Machine Learning Models ---
+# (Abaikan kalau modelnya kecil dan memang mau disimpan di GitHub)
+*.pth
+*.onnx
+
+# --- OS generated files ---
 .DS_Store

BackEnd/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

BackEnd/.idea/BackEnd.iml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="Flask">
+    <option name="enabled" value="true" />
+  </component>
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.13 (BackEnd)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+  <component name="TemplatesService">
+    <option name="TEMPLATE_CONFIGURATION" value="Jinja2" />
+  </component>
+</module>

BackEnd/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

BackEnd/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.13 (BackEnd)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 (BackEnd)" project-jdk-type="Python SDK" />
+</project>

BackEnd/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/BackEnd.iml" filepath="$PROJECT_DIR$/.idea/BackEnd.iml" />
+    </modules>
+  </component>
+</project>

BackEnd/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

BackEnd/IsItFake_API.postman_collection.json

@@ -0,0 +1,277 @@
+{
+	"info": {
+		"name": "IsItFake? Deepfake Detector API",
+		"description": "Koleksi API lengkap untuk aplikasi pendeteksi deepfake IsItFake?",
+		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+	},
+	"variable": [
+		{
+			"key": "base_url",
+			"value": "http://127.0.0.1:5000",
+			"type": "string"
+		},
+		{
+			"key": "jwt_token",
+			"value": "PASTE_TOKEN_KAMU_DI_SINI_SETELAH_LOGIN",
+			"type": "string"
+		}
+	],
+	"item": [
+		{
+			"name": "1. System",
+			"item": [
+				{
+					"name": "Test Database Connection",
+					"request": {
+						"method": "GET",
+						"header": [],
+						"url": {
+							"raw": "{{base_url}}/api/test-db",
+							"host": [
+								"{{base_url}}"
+							],
+							"path": [
+								"api",
+								"test-db"
+							]
+						}
+					},
+					"response": []
+				}
+			]
+		},
+		{
+			"name": "2. Authentication",
+			"item": [
+				{
+					"name": "Register",
+					"request": {
+						"method": "POST",
+						"header": [
+							{
+								"key": "Content-Type",
+								"value": "application/json"
+							}
+						],
+						"body": {
+							"mode": "raw",
+							"raw": "{\n  \"email\": \"tester@mail.com\",\n  \"username\": \"tester_ai\",\n  \"password\": \"password123\",\n  \"display_name\": \"Si Paling Tester\"\n}"
+						},
+						"url": {
+							"raw": "{{base_url}}/api/register",
+							"host": [
+								"{{base_url}}"
+							],
+							"path": [
+								"api",
+								"register"
+							]
+						}
+					},
+					"response": []
+				},
+				{
+					"name": "Login",
+					"request": {
+						"method": "POST",
+						"header": [
+							{
+								"key": "Content-Type",
+								"value": "application/json"
+							}
+						],
+						"body": {
+							"mode": "raw",
+							"raw": "{\n  \"email\": \"tester@mail.com\",\n  \"password\": \"password123\"\n}"
+						},
+						"url": {
+							"raw": "{{base_url}}/api/login",
+							"host": [
+								"{{base_url}}"
+							],
+							"path": [
+								"api",
+								"login"
+							]
+						},
+						"description": "Setelah login berhasil, copy `access_token` dari response dan masukkan ke tab Variables di folder utama collection (jwt_token)."
+					},
+					"response": []
+				},
+				{
+					"name": "Logout",
+					"request": {
+						"auth": {
+							"type": "bearer",
+							"bearer": [
+								{
+									"key": "token",
+									"value": "{{jwt_token}}",
+									"type": "string"
+								}
+							]
+						},
+						"method": "POST",
+						"header": [],
+						"url": {
+							"raw": "{{base_url}}/api/logout",
+							"host": [
+								"{{base_url}}"
+							],
+							"path": [
+								"api",
+								"logout"
+							]
+						}
+					},
+					"response": []
+				},
+				{
+					"name": "Get Profile",
+					"request": {
+						"auth": {
+							"type": "bearer",
+							"bearer": [
+								{
+									"key": "token",
+									"value": "{{jwt_token}}",
+									"type": "string"
+								}
+							]
+						},
+						"method": "GET",
+						"header": [],
+						"url": {
+							"raw": "{{base_url}}/api/profile",
+							"host": [
+								"{{base_url}}"
+							],
+							"path": [
+								"api",
+								"profile"
+							]
+						}
+					},
+					"response": []
+				}
+			]
+		},
+		{
+			"name": "3. Analysis",
+			"item": [
+				{
+					"name": "Scan Image (Deepfake Detection)",
+					"request": {
+						"auth": {
+							"type": "bearer",
+							"bearer": [
+								{
+									"key": "token",
+									"value": "{{jwt_token}}",
+									"type": "string"
+								}
+							]
+						},
+						"method": "POST",
+						"header": [],
+						"body": {
+							"mode": "formdata",
+							"formdata": [
+								{
+									"key": "file",
+									"type": "file",
+									"src": []
+								}
+							]
+						},
+						"url": {
+							"raw": "{{base_url}}/api/scan",
+							"host": [
+								"{{base_url}}"
+							],
+							"path": [
+								"api",
+								"scan"
+							]
+						},
+						"description": "Ingat: Jika kamu tidak ingin menyimpan riwayat (mode Guest), matikan centang 'Authorization' di tab Auth."
+					},
+					"response": []
+				}
+			]
+		},
+		{
+			"name": "4. Statistics",
+			"item": [
+				{
+					"name": "Get Dashboard Summary",
+					"request": {
+						"auth": {
+							"type": "bearer",
+							"bearer": [
+								{
+									"key": "token",
+									"value": "{{jwt_token}}",
+									"type": "string"
+								}
+							]
+						},
+						"method": "GET",
+						"header": [],
+						"url": {
+							"raw": "{{base_url}}/api/statistics/summary",
+							"host": [
+								"{{base_url}}"
+							],
+							"path": [
+								"api",
+								"statistics",
+								"summary"
+							]
+						}
+					},
+					"response": []
+				},
+				{
+					"name": "Get Scan History (Pagination)",
+					"request": {
+						"auth": {
+							"type": "bearer",
+							"bearer": [
+								{
+									"key": "token",
+									"value": "{{jwt_token}}",
+									"type": "string"
+								}
+							]
+						},
+						"method": "GET",
+						"header": [],
+						"url": {
+							"raw": "{{base_url}}/api/statistics/history?page=1&limit=5",
+							"host": [
+								"{{base_url}}"
+							],
+							"path": [
+								"api",
+								"statistics",
+								"history"
+							],
+							"query": [
+								{
+									"key": "page",
+									"value": "1"
+								},
+								{
+									"key": "limit",
+									"value": "5"
+								}
+							]
+						}
+					},
+					"response": []
+				}
+			]
+		}
+	]
+}

BackEnd/app.py

@@ -1,152 +1,152 @@
-from flask import Flask, request, jsonify
-from flask_cors import CORS
-import numpy as np
-import cv2
-import onnxruntime as ort
-
-app = Flask(__name__)
-CORS(app)
-
-# ============================================================
-# LOAD ONNX MODEL
-# ============================================================
-MODEL_PATH = "best_model.onnx"
-session = ort.InferenceSession(MODEL_PATH, providers=['CPUExecutionProvider'])
-input_name = session.get_inputs()[0].name
-print(f"ONNX model loaded: {MODEL_PATH}")
-
-# ============================================================
-# FACE CROPPER
-# ============================================================
-face_cascade = cv2.CascadeClassifier(
-    cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
-)
-
-def crop_face(image_bgr):
-    """Finds the largest face in the image and crops it with 10% padding"""
-    gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
-    faces = face_cascade.detectMultiScale(
-        gray, scaleFactor=1.1, minNeighbors=8, minSize=(80, 80)
-    )
-    if len(faces) > 0:
-        x, y, w, h = max(faces, key=lambda f: f[2] * f[3])
-        pad = int(0.10 * min(w, h))
-        x1 = max(0, x - pad)
-        y1 = max(0, y - pad)
-        x2 = min(image_bgr.shape[1], x + w + pad)
-        y2 = min(image_bgr.shape[0], y + h + pad)
-        return image_bgr[y1:y2, x1:x2]
-    return image_bgr
-
-
-# ============================================================
-# PREPROCESSING (exact copy from training notebook Cell 27 + 37)
-# ============================================================
-def make_fft_channel(image_bgr, size=224):
-    """
-    Exact copy of training notebook's make_fft_channel.
-    Power spectrum: log1p(|F|^2), normalized to [0,1].
-    """
-    gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
-    gray = cv2.resize(gray, (size, size)).astype(np.float32)
-    f = np.fft.fft2(gray)
-    f_shift = np.fft.fftshift(f)
-    ps = np.log1p(np.abs(f_shift) ** 2)
-    ps = (ps - ps.min()) / (ps.max() - ps.min() + 1e-8)
-    return ps
-
-
-def preprocess_image(face_bgr):
-    """
-    Matches training notebook's predict_image() (Cell 37):
-    1. RGB 224x224 -> ImageNet normalize -> numpy array
-    2. FFT power spectrum channel
-    3. Concatenate to 4 channels
-    """
-    # --- RGB channels ---
-    face_rgb = cv2.cvtColor(face_bgr, cv2.COLOR_BGR2RGB)
-    img_input = cv2.resize(face_rgb, (224, 224)).astype(np.float32) / 255.0
-
-    mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
-    std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
-    img_normalized = (img_input - mean) / std
-
-    # (224,224,3) -> (3,224,224)
-    img_chw = np.transpose(img_normalized, (2, 0, 1))
-
-    # --- FFT channel ---
-    fft_ch = make_fft_channel(face_bgr, size=224)
-    fft_ch = np.expand_dims(fft_ch, axis=0)  # (1, 224, 224)
-
-    # --- Combine: (4, 224, 224) -> (1, 4, 224, 224) ---
-    combined = np.concatenate([img_chw, fft_ch], axis=0)
-    combined = np.expand_dims(combined, axis=0).astype(np.float32)
-    return combined
-
-
-# ============================================================
-# ROUTES
-# ============================================================
-@app.route('/', methods=['GET'])
-def health_check():
-    return jsonify({
-        "status": "online",
-        "message": "SynthScan Neural Engine is awake and ready!",
-        "version": "2.0 (ONNX)"
-    }), 200
-
-
-@app.route('/api/scan', methods=['POST'])
-def scan_image():
-    if 'file' not in request.files:
-        return jsonify({"status": "error", "message": "No file uploaded"}), 400
-
-    file = request.files['file']
-    file_bytes = np.frombuffer(file.read(), np.uint8)
-    face_bgr = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
-
-    if face_bgr is None:
-        return jsonify({"status": "error", "message": "Invalid image format"}), 400
-
-    try:
-        # 1. Crop the largest face
-        cropped_face = crop_face(face_bgr)
-
-        # 2. Preprocess (matching training notebook exactly)
-        input_array = preprocess_image(cropped_face)
-
-        # 3. Inference
-        logit = float(session.run(None, {input_name: input_array})[0][0])
-        prob_fake = 1.0 / (1.0 + np.exp(-max(-50, min(50, logit))))
-
-        prob_real = 1.0 - prob_fake
-        fake_percent = round(prob_fake * 100, 1)
-        real_percent = round(prob_real * 100, 1)
-
-        # Training notebook: prob >= 0.5 = FAKE, prob < 0.5 = REAL
-        if prob_fake >= 0.5:
-            final_result = "Deepfake"
-            confidence = fake_percent
-        else:
-            final_result = "Real"
-            confidence = real_percent
-
-        print(f"Logit: {logit:.4f} | P(fake): {fake_percent}% | Result: {final_result} ({confidence}%)")
-
-        return jsonify({
-            "status": "success",
-            "result": final_result,
-            "probability": confidence,
-            "probability_fake": round(prob_fake * 100, 2),
-            "probability_real": round(prob_real * 100, 2)
-        })
-
-    except Exception as e:
-        print("ERROR:", str(e))
-        import traceback
-        traceback.print_exc()
-        return jsonify({"status": "error", "message": str(e)}), 500
-
-
-if __name__ == '__main__':
-    app.run(debug=True, port=5001)
+# from flask import Flask, request, jsonify
+# from flask_cors import CORS
+# import numpy as np
+# import cv2
+# import onnxruntime as ort
+#
+# app = Flask(__name__)
+# CORS(app)
+#
+# # ============================================================
+# # LOAD ONNX MODEL
+# # ============================================================
+# MODEL_PATH = "ml_models/best_model.onnx"
+# session = ort.InferenceSession(MODEL_PATH, providers=['CPUExecutionProvider'])
+# input_name = session.get_inputs()[0].name
+# print(f"ONNX model loaded: {MODEL_PATH}")
+#
+# # ============================================================
+# # FACE CROPPER
+# # ============================================================
+# face_cascade = cv2.CascadeClassifier(
+#     cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
+# )
+#
+# def crop_face(image_bgr):
+#     """Finds the largest face in the image and crops it with 10% padding"""
+#     gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
+#     faces = face_cascade.detectMultiScale(
+#         gray, scaleFactor=1.1, minNeighbors=8, minSize=(80, 80)
+#     )
+#     if len(faces) > 0:
+#         x, y, w, h = max(faces, key=lambda f: f[2] * f[3])
+#         pad = int(0.10 * min(w, h))
+#         x1 = max(0, x - pad)
+#         y1 = max(0, y - pad)
+#         x2 = min(image_bgr.shape[1], x + w + pad)
+#         y2 = min(image_bgr.shape[0], y + h + pad)
+#         return image_bgr[y1:y2, x1:x2]
+#     return image_bgr
+#
+#
+# # ============================================================
+# # PREPROCESSING (exact copy from training notebook Cell 27 + 37)
+# # ============================================================
+# def make_fft_channel(image_bgr, size=224):
+#     """
+#     Exact copy of training notebook's make_fft_channel.
+#     Power spectrum: log1p(|F|^2), normalized to [0,1].
+#     """
+#     gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
+#     gray = cv2.resize(gray, (size, size)).astype(np.float32)
+#     f = np.fft.fft2(gray)
+#     f_shift = np.fft.fftshift(f)
+#     ps = np.log1p(np.abs(f_shift) ** 2)
+#     ps = (ps - ps.min()) / (ps.max() - ps.min() + 1e-8)
+#     return ps
+#
+#
+# def preprocess_image(face_bgr):
+#     """
+#     Matches training notebook's predict_image() (Cell 37):
+#     1. RGB 224x224 -> ImageNet normalize -> numpy array
+#     2. FFT power spectrum channel
+#     3. Concatenate to 4 channels
+#     """
+#     # --- RGB channels ---
+#     face_rgb = cv2.cvtColor(face_bgr, cv2.COLOR_BGR2RGB)
+#     img_input = cv2.resize(face_rgb, (224, 224)).astype(np.float32) / 255.0
+#
+#     mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
+#     std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+#     img_normalized = (img_input - mean) / std
+#
+#     # (224,224,3) -> (3,224,224)
+#     img_chw = np.transpose(img_normalized, (2, 0, 1))
+#
+#     # --- FFT channel ---
+#     fft_ch = make_fft_channel(face_bgr, size=224)
+#     fft_ch = np.expand_dims(fft_ch, axis=0)  # (1, 224, 224)
+#
+#     # --- Combine: (4, 224, 224) -> (1, 4, 224, 224) ---
+#     combined = np.concatenate([img_chw, fft_ch], axis=0)
+#     combined = np.expand_dims(combined, axis=0).astype(np.float32)
+#     return combined
+#
+#
+# # ============================================================
+# # ROUTES
+# # ============================================================
+# @app.route('/', methods=['GET'])
+# def health_check():
+#     return jsonify({
+#         "status": "online",
+#         "message": "SynthScan Neural Engine is awake and ready!",
+#         "version": "2.0 (ONNX)"
+#     }), 200
+#
+#
+# @app.route('/api/scan', methods=['POST'])
+# def scan_image():
+#     if 'file' not in request.files:
+#         return jsonify({"status": "error", "message": "No file uploaded"}), 400
+#
+#     file = request.files['file']
+#     file_bytes = np.frombuffer(file.read(), np.uint8)
+#     face_bgr = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+#
+#     if face_bgr is None:
+#         return jsonify({"status": "error", "message": "Invalid image format"}), 400
+#
+#     try:
+#         # 1. Crop the largest face
+#         cropped_face = crop_face(face_bgr)
+#
+#         # 2. Preprocess (matching training notebook exactly)
+#         input_array = preprocess_image(cropped_face)
+#
+#         # 3. Inference
+#         logit = float(session.run(None, {input_name: input_array})[0][0])
+#         prob_fake = 1.0 / (1.0 + np.exp(-max(-50, min(50, logit))))
+#
+#         prob_real = 1.0 - prob_fake
+#         fake_percent = round(prob_fake * 100, 1)
+#         real_percent = round(prob_real * 100, 1)
+#
+#         # Training notebook: prob >= 0.5 = FAKE, prob < 0.5 = REAL
+#         if prob_fake >= 0.5:
+#             final_result = "Deepfake"
+#             confidence = fake_percent
+#         else:
+#             final_result = "Real"
+#             confidence = real_percent
+#
+#         print(f"Logit: {logit:.4f} | P(fake): {fake_percent}% | Result: {final_result} ({confidence}%)")
+#
+#         return jsonify({
+#             "status": "success",
+#             "result": final_result,
+#             "probability": confidence,
+#             "probability_fake": round(prob_fake * 100, 2),
+#             "probability_real": round(prob_real * 100, 2)
+#         })
+#
+#     except Exception as e:
+#         print("ERROR:", str(e))
+#         import traceback
+#         traceback.print_exc()
+#         return jsonify({"status": "error", "message": str(e)}), 500
+#
+#
+# if __name__ == '__main__':
+#     app.run(debug=True, port=5001)

BackEnd/controllers/analysis_controllers.py

@@ -0,0 +1,48 @@
+
+from flask import request
+import numpy as np
+import traceback
+
+from core.response_json import error_response, success_response, server_error_response
+from middlewares.auth import token_optional
+from services.analysis_service import run_deepfake_analysis, save_scan_history
+
+
+@token_optional
+def scan_image(current_user):
+    if 'file' not in request.files:
+        return error_response(message="No file uploaded", status_code=400)
+
+    file = request.files['file']
+
+    if file.filename == '':
+        return error_response(message="No selected file", status_code=400)
+
+    try:
+        file_bytes = np.frombuffer(file.read(), np.uint8)
+
+        analysis_result = run_deepfake_analysis(file_bytes)
+
+        if current_user is not None:
+            save_scan_history(
+                user_id=current_user.get("user_id"),
+                file_name=file.filename,
+                result=analysis_result["result"],
+                confidence_score=analysis_result["probability"],
+                processing_time=analysis_result["processing_time"]
+            )
+            analysis_result["saved_to_history"] = True
+        else:
+            analysis_result["saved_to_history"] = False
+
+        return success_response(
+            message="Analysis complete",
+            data=analysis_result
+        )
+
+    except ValueError as ve:
+        return error_response(message=str(ve), status_code=400)
+    except Exception as e:
+        print("ERROR:", str(e))
+        traceback.print_exc()
+        return server_error_response(error_details=str(e))

BackEnd/controllers/auth_controllers.py

@@ -0,0 +1,62 @@
+# File: BackEnd/app/controllers/auth_controllers.py
+
+from flask import request
+
+from core.response_json import error_response, success_response, server_error_response
+from middlewares.auth import token_required
+from services.auth_service import register_new_user, authenticate_user
+
+
+def register():
+    try:
+        data = request.get_json()
+
+        if not data or not data.get("email") or not data.get("username") or not data.get("password"):
+            return error_response("Email, username, dan password wajib diisi!", status_code=400)
+
+        user_data = register_new_user(
+            email=data.get("email"),
+            username=data.get("username"),
+            password=data.get("password"),
+            display_name=data.get("display_name")
+        )
+
+        return success_response(message="Registrasi berhasil!", data=user_data, status_code=201)
+
+    except ValueError as ve:
+        return error_response(message=str(ve), status_code=409)
+    except Exception as e:
+        return server_error_response(error_details=str(e))
+
+
+def login():
+    try:
+        data = request.get_json()
+
+        if not data or not data.get("email") or not data.get("password"):
+            return error_response("Email dan password wajib diisi!", status_code=400)
+
+        auth_data = authenticate_user(
+            email=data.get("email"),
+            password=data.get("password")
+        )
+
+        return success_response(message="Login berhasil!", data=auth_data, status_code=200)
+
+    except ValueError as ve:
+        return error_response(message=str(ve), status_code=401)
+    except Exception as e:
+        return server_error_response(error_details=str(e))
+
+
+@token_required
+def logout(current_user):
+    try:
+        email_user = current_user.get('email')
+
+        return success_response(
+            message=f"Logout berhasil untuk {email_user}. Silakan hapus token di sisi Frontend.",
+            status_code=200
+        )
+    except Exception as e:
+        return server_error_response(error_details=str(e))

BackEnd/controllers/daily_statistic_controllers.py

@@ -0,0 +1,31 @@
+# File: BackEnd/app/controllers/daily_statistic_controllers.py
+
+from flask import request
+
+from core.response_json import success_response, server_error_response
+from middlewares.auth import token_required
+from services.statistic_service import get_dashboard_stats, get_paginated_scans
+
+
+@token_required
+def get_stats(current_user):
+    try:
+        user_id = current_user.get('user_id')
+        stats = get_dashboard_stats(user_id)
+        return success_response(message="Statistik berhasil diambil", data=stats)
+    except Exception as e:
+        return server_error_response(error_details=str(e))
+
+
+@token_required
+def show_all_data(current_user):
+    try:
+        user_id = current_user.get('user_id')
+
+        page = int(request.args.get('page', 1))
+        limit = int(request.args.get('limit', 10))
+
+        data = get_paginated_scans(user_id, page, limit)
+        return success_response(message="Riwayat scan berhasil diambil", data=data)
+    except Exception as e:
+        return server_error_response(error_details=str(e))

BackEnd/controllers/test_controllers.py

@@ -0,0 +1,19 @@
+from core.db_connector import get_db
+from core.response_json import success_response, server_error_response
+
+
+def test_connection():
+    try:
+        db = get_db()
+        response = db.table("users").select("id").limit(1).execute()
+        return success_response(
+            message="Database connection successful!",
+            data={
+                "connection": "OK",
+                "test_query_data": response.data  # Akan mengembalikan [] jika tabel masih kosong
+            },
+            status_code=200
+        )
+
+    except Exception as e:
+        return server_error_response(error_details=str(e))

BackEnd/core/db_connector.py

@@ -0,0 +1,16 @@
+import os
+from supabase import create_client, Client
+from dotenv import load_dotenv
+
+load_dotenv()
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+if not SUPABASE_URL or not SUPABASE_KEY:
+    raise ValueError("Missing Supabase URL or Key. Check your .env file.")
+
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+def get_db():
+    return supabase

BackEnd/core/response_json.py

@@ -0,0 +1,35 @@
+
+from flask import jsonify
+
+
+def success_response(message="Success", data=None, status_code=200):
+    response = {
+        "status": "success",
+        "message": message
+    }
+    if data is not None:
+        response["data"] = data
+
+    return jsonify(response), status_code
+
+
+def error_response(message="An error occurred", error_details=None, status_code=400):
+    response = {
+        "status": "error",
+        "message": message
+    }
+    if error_details is not None:
+        response["details"] = error_details
+
+    return jsonify(response), status_code
+
+
+def server_error_response(error_details=None):
+    response = {
+        "status": "fail",
+        "message": "Internal server error"
+    }
+    if error_details is not None:
+        response["details"] = str(error_details)
+
+    return jsonify(response), 500

BackEnd/middlewares/auth.py

@@ -0,0 +1,60 @@
+# File: BackEnd/app/middlewares/auth.py
+
+from functools import wraps
+from flask import request
+import jwt
+import os
+
+from core.response_json import error_response
+
+
+def token_required(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        token = None
+
+        if "Authorization" in request.headers:
+            auth_header = request.headers["Authorization"]
+            if auth_header.startswith("Bearer "):
+                token = auth_header.split(" ")[1]
+
+        if not token:
+            return error_response("Token akses tidak ditemukan! Silakan login.", status_code=401)
+
+        try:
+            secret_key = os.getenv("JWT_SECRET")
+            decoded_data = jwt.decode(token, secret_key, algorithms=["HS256"])
+
+            current_user = decoded_data
+
+        except jwt.ExpiredSignatureError:
+            return error_response("Token sudah kedaluwarsa! Silakan login ulang.", status_code=401)
+        except jwt.InvalidTokenError:
+            return error_response("Token tidak valid!", status_code=401)
+
+        return f(current_user, *args, **kwargs)
+
+    return decorated
+
+
+
+def token_optional(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        current_user = None
+
+        if "Authorization" in request.headers:
+            auth_header = request.headers["Authorization"]
+            if auth_header.startswith("Bearer "):
+                token = auth_header.split(" ")[1]
+                try:
+                    secret_key = os.getenv("JWT_SECRET")
+                    # Jika berhasil decode, masukkan ke current_user
+                    current_user = jwt.decode(token, secret_key, algorithms=["HS256"])
+                except Exception:
+                    # Abaikan error (expired/invalid), tetap izinkan masuk sebagai Guest
+                    pass
+
+        return f(current_user, *args, **kwargs)
+
+    return decorated

BackEnd/models/scan_history.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ScanHistory:
+    user_id: str
+    file_name: str
+    url_file: str
+    result: str
+    confidence_score: float
+    processing_time: float
+    id: Optional[str] = None
+    created_at: Optional[str] = None
+
+    @staticmethod
+    def from_dict(data: dict) -> 'ScanHistory':
+        if not data:
+            return None
+
+        return ScanHistory(
+            id=data.get("id"),
+            user_id=data.get("user_id"),
+            file_name=data.get("file_name"),
+            url_file=data.get("url_file"),
+            result=data.get("result"),
+            confidence_score=float(data.get("confidence_score", 0.0)),
+            processing_time=float(data.get("processing_time", 0.0)),
+            created_at=data.get("created_at")
+        )

BackEnd/models/user.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import Optional
+from datetime import datetime
+
+
+@dataclass
+class User:
+    email: str
+    username: str
+    password_hash: str
+    display_name: Optional[str] = None
+    role: str = "user"
+    id: Optional[str] = None
+    created_at: Optional[str] = None
+
+    @staticmethod
+    def from_dict(data: dict) -> 'User':
+        if not data:
+            return None
+
+        return User(
+            id=data.get("id"),
+            email=data.get("email"),
+            username=data.get("username"),
+            password_hash=data.get("password_hash"),
+            display_name=data.get("display_name"),
+            role=data.get("role", "user"),
+            created_at=data.get("created_at")
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "username": self.username,
+            "email": self.email,
+            "display_name": self.display_name,
+            "role": self.role,
+            "created_at": self.created_at
+        }

BackEnd/noted.txt

@@ -0,0 +1,2 @@
+
+main file nya aku rubah sebelumnya app.py sekarang run.py

BackEnd/requirements.txt

@@ -2,5 +2,70 @@ Flask==3.0.0
 Flask-Cors==4.0.0
 numpy==1.26.4
 opencv-python-headless==4.9.0.80
-onnxruntime==1.18.0
-Werkzeug==3.0.1
+onnxruntime~=1.24.4
+Werkzeug~=3.1.8
+supabase~=2.28.3
+dotenv~=0.9.9
+python-dotenv~=1.2.2
+hpack~=4.1.0
+hyperframe~=6.1.0
+h11~=0.16.0
+cryptography~=46.0.7
+pip~=25.0.1
+typing_extensions~=4.15.0
+cffi~=2.0.0
+rich~=14.3.3
+Pygments~=2.20.0
+markdown-it-py~=4.0.0
+idna~=3.11
+multidict~=6.7.1
+propcache~=0.4.1
+pydantic~=2.12.5
+pydantic_core~=2.41.5
+click~=8.3.2
+httpcore~=1.0.9
+httpx~=0.28.1
+zstandard~=0.25.0
+mdurl~=0.1.2
+charset-normalizer~=3.4.7
+fsspec~=2026.3.0
+requests~=2.33.1
+yarl~=1.23.0
+certifi~=2026.2.25
+h2~=4.3.0
+urllib3~=2.6.3
+six~=1.17.0
+python-dateutil~=2.9.0.post0
+anyio~=4.13.0
+annotated-types~=0.7.0
+realtime~=2.28.3
+websockets~=15.0.1
+storage3~=2.28.3
+pyiceberg~=0.11.1
+deprecation~=2.1.0
+postgrest~=2.28.3
+tenacity~=9.1.4
+pyroaring~=1.0.4
+mmh3~=5.2.1
+strictyaml~=1.7.3
+pyparsing~=3.3.2
+cachetools~=6.2.6
+Jinja2~=3.1.6
+packaging~=26.0
+PyJWT~=2.12.1
+typing_extensions~=4.15.0
+protobuf~=7.34.1
+pydantic_core~=2.41.5
+Cython~=3.2.4
+sympy~=1.14.0
+mpmath~=1.3.0
+pyglet~=2.1.14
+decorator~=5.2.1
+pillow~=12.2.0
+flatbuffers~=25.12.19
+scipy~=1.17.1
+tqdm~=4.67.3
+manim~=0.20.1
+typing_extensions~=4.15.0
+pydantic_core~=2.41.5
+gTTS~=2.5.4

BackEnd/run.py

@@ -0,0 +1,35 @@
+# File: BackEnd/run.py
+
+from flask import Flask
+from flask_cors import CORS
+
+from controllers.analysis_controllers import scan_image
+from controllers.auth_controllers import register, login, logout
+from controllers.daily_statistic_controllers import get_stats, show_all_data
+from controllers.test_controllers import test_connection
+from core.response_json import success_response
+from middlewares.auth import token_required
+
+app = Flask(__name__)
+CORS(app)
+
+# --- PUBLIC ROUTES ---
+app.add_url_rule('/api/test-db', view_func=test_connection, methods=['GET'])
+app.add_url_rule('/api/register', view_func=register, methods=['POST'])
+app.add_url_rule('/api/login', view_func=login, methods=['POST'])
+app.add_url_rule('/api/logout', view_func=logout, methods=['POST'])
+
+app.add_url_rule('/api/statistics/summary', view_func=get_stats, methods=['GET'])
+app.add_url_rule('/api/statistics/history', view_func=show_all_data, methods=['GET'])
+app.add_url_rule('/api/scan', view_func=scan_image, methods=['POST'])
+
+@app.route('/api/profile', methods=['GET'])
+@token_required
+def get_profile(current_user):
+    return success_response(
+        message="Selamat datang di area privat!",
+        data={"user_aktif": current_user}
+    )
+
+if __name__ == '__main__':
+    app.run(debug=True, port=5000)

BackEnd/services/analysis_service.py

@@ -0,0 +1,157 @@
+# File: BackEnd/app/services/analysis_service.py
+import os
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+import time
+
+from core.db_connector import get_db
+
+# ============================================================
+# LOAD ONNX MODEL
+# ============================================================
+
+# Gunakan base directory agar path selalu benar dimanapun server dijalankan
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MODEL_PATH = os.path.join(BASE_DIR, "ml_models", "best_model.onnx")
+
+# Inisialisasi session sebagai None dulu agar tidak NameError
+session = None
+input_name = None
+try:
+    if not os.path.exists(MODEL_PATH):
+        print(f"❌ File model tidak ditemukan di: {MODEL_PATH}")
+    else:
+        session = ort.InferenceSession(MODEL_PATH, providers=['CPUExecutionProvider'])
+        input_name = session.get_inputs()[0].name
+        print(f"✅ ONNX model loaded successfully from: {MODEL_PATH}")
+except Exception as e:
+    print(f"❌ Gagal memuat ONNX model: {e}")
+
+
+# ============================================================
+# FACE CROPPER
+# ============================================================
+face_cascade = cv2.CascadeClassifier(
+    cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
+)
+
+def crop_face(image_bgr):
+    """Finds the largest face in the image and crops it with 10% padding"""
+    gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
+    faces = face_cascade.detectMultiScale(
+        gray, scaleFactor=1.1, minNeighbors=8, minSize=(80, 80)
+    )
+    if len(faces) > 0:
+        x, y, w, h = max(faces, key=lambda f: f[2] * f[3])
+        pad = int(0.10 * min(w, h))
+        x1 = max(0, x - pad)
+        y1 = max(0, y - pad)
+        x2 = min(image_bgr.shape[1], x + w + pad)
+        y2 = min(image_bgr.shape[0], y + h + pad)
+        return image_bgr[y1:y2, x1:x2]
+    return image_bgr
+
+# ============================================================
+# PREPROCESSING (exact copy from training notebook Cell 27 + 37)
+# ============================================================
+def make_fft_channel(image_bgr, size=224):
+    """
+    Exact copy of training notebook's make_fft_channel.
+    Power spectrum: log1p(|F|^2), normalized to [0,1].
+    """
+    gray = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2GRAY)
+    gray = cv2.resize(gray, (size, size)).astype(np.float32)
+    f = np.fft.fft2(gray)
+    f_shift = np.fft.fftshift(f)
+    ps = np.log1p(np.abs(f_shift) ** 2)
+    ps = (ps - ps.min()) / (ps.max() - ps.min() + 1e-8)
+    return ps
+
+def preprocess_image(face_bgr):
+    """
+    Matches training notebook's predict_image() (Cell 37):
+    1. RGB 224x224 -> ImageNet normalize -> numpy array
+    2. FFT power spectrum channel
+    3. Concatenate to 4 channels
+    """
+    # --- RGB channels ---
+    face_rgb = cv2.cvtColor(face_bgr, cv2.COLOR_BGR2RGB)
+    img_input = cv2.resize(face_rgb, (224, 224)).astype(np.float32) / 255.0
+
+    mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
+    std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+    img_normalized = (img_input - mean) / std
+
+    # (224,224,3) -> (3,224,224)
+    img_chw = np.transpose(img_normalized, (2, 0, 1))
+
+    # --- FFT channel ---
+    fft_ch = make_fft_channel(face_bgr, size=224)
+    fft_ch = np.expand_dims(fft_ch, axis=0)  # (1, 224, 224)
+
+    # --- Combine: (4, 224, 224) -> (1, 4, 224, 224) ---
+    combined = np.concatenate([img_chw, fft_ch], axis=0)
+    combined = np.expand_dims(combined, axis=0).astype(np.float32)
+    return combined
+
+# ============================================================
+# MAIN INFERENCE SERVICE
+# ============================================================
+def run_deepfake_analysis(file_bytes):
+    start_time = time.time()
+
+    face_bgr = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+    if face_bgr is None:
+        raise ValueError("Invalid image format")
+
+    # 1. Crop the largest face
+    cropped_face = crop_face(face_bgr)
+
+    # 2. Preprocess (matching training notebook exactly)
+    input_array = preprocess_image(cropped_face)
+
+    # 3. Inference
+    logit = float(session.run(None, {input_name: input_array})[0][0])
+    prob_fake = 1.0 / (1.0 + np.exp(-max(-50, min(50, logit))))
+
+    prob_real = 1.0 - prob_fake
+    fake_percent = round(prob_fake * 100, 1)
+    real_percent = round(prob_real * 100, 1)
+
+    # Training notebook: prob >= 0.5 = FAKE, prob < 0.5 = REAL
+    if prob_fake >= 0.5:
+        final_result = "Deepfake"
+        confidence = fake_percent
+    else:
+        final_result = "Real"
+        confidence = real_percent
+
+    # Print logit persis seperti kode lamamu untuk debugging di terminal
+    print(f"Logit: {logit:.4f} | P(fake): {fake_percent}% | Result: {final_result} ({confidence}%)")
+
+    processing_time = round(time.time() - start_time, 2)
+
+    return {
+        "result": final_result,
+        "probability": confidence,
+        "probability_fake": round(prob_fake * 100, 2),
+        "probability_real": round(prob_real * 100, 2),
+        "processing_time": processing_time
+    }
+
+# ============================================================
+# DATABASE INSERTION SERVICE
+# ============================================================
+def save_scan_history(user_id, file_name, result, confidence_score, processing_time):
+    db = get_db()
+    data = {
+        "user_id": user_id,
+        "file_name": file_name,
+        "url_file": f"/uploads/{file_name}",
+        "result": result,
+        "confidence_score": confidence_score,
+        "processing_time": processing_time
+    }
+    db.table("scan_histories").insert(data).execute()

BackEnd/services/auth_service.py

@@ -0,0 +1,61 @@
+from werkzeug.security import generate_password_hash, check_password_hash
+import jwt
+import os
+import datetime
+
+from core.db_connector import get_db
+from models.user import User
+
+
+def register_new_user(email, username, password, display_name):
+    db = get_db()
+
+    cek_email = db.table("users").select("id").eq("email", email).execute()
+    if len(cek_email.data) > 0:
+        raise ValueError("Email sudah digunakan!")
+
+    cek_username = db.table("users").select("id").eq("username", username).execute()
+    if len(cek_username.data) > 0:
+        raise ValueError("Username sudah digunakan!")
+
+    hashed_password = generate_password_hash(password)
+    new_user_data = {
+        "email": email,
+        "username": username,
+        "password_hash": hashed_password,
+        "display_name": display_name
+    }
+
+    response = db.table("users").insert(new_user_data).execute()
+
+    user_obj = User.from_dict(response.data[0])
+    return user_obj.to_dict()
+
+
+def authenticate_user(email, password):
+    db = get_db()
+
+    response = db.table("users").select("*").eq("email", email).execute()
+    if len(response.data) == 0:
+        raise ValueError("Email atau password salah!")
+
+    user_data = response.data[0]
+
+    if not check_password_hash(user_data["password_hash"], password):
+        raise ValueError("Email atau password salah!")
+
+    secret_key = os.getenv("JWT_SECRET")
+    token_payload = {
+        "user_id": user_data["id"],
+        "email": user_data["email"],
+        "role": user_data["role"],
+        "exp": datetime.datetime.utcnow() + datetime.timedelta(hours=24)
+    }
+
+    token = jwt.encode(token_payload, secret_key, algorithm="HS256")
+
+    user_obj = User.from_dict(user_data)
+    return {
+        "access_token": token,
+        "user": user_obj.to_dict()
+    }

BackEnd/services/statistic_service.py

@@ -0,0 +1,70 @@
+from datetime import date
+from core.db_connector import get_db
+from models.scan_history import ScanHistory
+
+
+def get_dashboard_stats(user_id):
+    db = get_db()
+    today = date.today().isoformat()
+
+    today_res = db.table("scan_histories").select("id", count="exact") \
+        .eq("user_id", user_id) \
+        .gte("created_at", f"{today}T00:00:00") \
+        .execute()
+    today_scans = today_res.count if today_res.count is not None else 0
+
+    fakes_res = db.table("scan_histories").select("id", count="exact") \
+        .eq("user_id", user_id) \
+        .eq("result", "Deepfake") \
+        .execute()
+    detected_fakes = fakes_res.count if fakes_res.count is not None else 0
+
+    all_data_res = db.table("scan_histories").select("confidence_score, processing_time").eq("user_id",
+                                                                                             user_id).execute()
+
+    avg_confidence = 0.0
+    avg_time = 0.0
+
+    if all_data_res.data:
+        scores = [float(d['confidence_score']) for d in all_data_res.data if d.get('confidence_score') is not None]
+        times = [float(d['processing_time']) for d in all_data_res.data if d.get('processing_time') is not None]
+
+        avg_confidence = sum(scores) / len(scores) if scores else 0.0
+        avg_time = sum(times) / len(times) if times else 0.0
+
+    return {
+        "today_scans": today_scans,
+        "detected_fakes": detected_fakes,
+        "avg_confidence": round(avg_confidence, 1),  # Dibulatkan 1 desimal (misal 95.2)
+        "avg_processing_time": round(avg_time, 1)  # Dibulatkan 1 desimal (misal 3.0)
+    }
+
+
+def get_paginated_scans(user_id, page=1, limit=10):
+    # ... (Kode get_paginated_scans tetap sama persis seperti punyamu sebelumnya) ...
+    db = get_db()
+
+    start = (page - 1) * limit
+    end = start + limit - 1
+
+    response = db.table("scan_histories") \
+        .select("*", count="exact") \
+        .eq("user_id", user_id) \
+        .order("created_at", desc=True) \
+        .range(start, end) \
+        .execute()
+
+    scans = [ScanHistory.from_dict(d) for d in response.data]
+
+    total_items = response.count
+    total_pages = (total_items + limit - 1) // limit
+
+    return {
+        "items": [s.__dict__ for s in scans],
+        "pagination": {
+            "current_page": page,
+            "limit": limit,
+            "total_items": total_items,
+            "total_pages": total_pages
+        }
+    }

FrontEnd/.gitignore

@@ -7,6 +7,10 @@ yarn-error.log*
 pnpm-debug.log*
 lerna-debug.log*
 
+env/
+.venv/
+
+
 node_modules
 dist
 dist-ssr