BE: LangStrings /graphql + /logs endpoint, utils chores

Signed-off-by: jokob-sk <jokob.sk@gmail.com>

server/api_server/api_server_start.py

@@ -24,6 +24,8 @@ from .sessions_endpoint import get_sessions, delete_session, create_session, get
 from .nettools_endpoint import wakeonlan, traceroute, speedtest, nslookup, nmap_scan, internet_info
 from .dbquery_endpoint import read_query, write_query, update_query, delete_query
 from .sync_endpoint import handle_sync_post, handle_sync_get
+from .logs_endpoint import clean_log
+from models.user_events_queue_instance import UserEventsQueueInstance
 from messaging.in_app import write_notification, mark_all_notifications_read, delete_notifications, get_unread_notifications, delete_notification, mark_notification_as_read
 
 # Flask application
@@ -40,12 +42,25 @@ CORS(
         r"/settings/*": {"origins": "*"},
         r"/dbquery/*": {"origins": "*"},
         r"/messaging/*": {"origins": "*"},
-        r"/events/*": {"origins": "*"}
+        r"/events/*": {"origins": "*"},
+        r"/logs/*": {"origins": "*"}
     },
     supports_credentials=True,
     allow_headers=["Authorization", "Content-Type"]
 )
 
+# -------------------------------------------------------------------
+# Custom handler for 404 - Route not found
+# -------------------------------------------------------------------
+@app.errorhandler(404)
+def not_found(error):
+    response = {
+        "success": False, 
+        "error": "API route not found",
+        "message": f"The requested URL {error.description if hasattr(error, 'description') else ''} was not found on the server.",
+    }
+    return jsonify(response), 404
+
 # --------------------------
 # GraphQL Endpoints
 # --------------------------
@@ -63,7 +78,7 @@ def graphql_endpoint():
     if not is_authorized():
         msg = '[graphql_server] Unauthorized access attempt - make sure your GRAPHQL_PORT and API_TOKEN settings are correct.'
         mylog('verbose', [msg])
-        return jsonify({"error": msg}), 401
+        return jsonify({"success": False, "message": msg}), 401
 
     # Retrieve and log request data
     data = request.get_json()
@@ -89,7 +104,7 @@ def graphql_endpoint():
 @app.route("/settings/<setKey>", methods=["GET"])
 def api_get_setting(setKey):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     value = get_setting_value(setKey)
     return jsonify({"success": True, "value": value})
 
@@ -100,58 +115,58 @@ def api_get_setting(setKey):
 @app.route("/device/<mac>", methods=["GET"])
 def api_get_device(mac):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return get_device_data(mac)
 
 @app.route("/device/<mac>", methods=["POST"])
 def api_set_device(mac):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return set_device_data(mac, request.json)
 
 @app.route("/device/<mac>/delete", methods=["DELETE"])
 def api_delete_device(mac):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return delete_device(mac)
 
 @app.route("/device/<mac>/events/delete", methods=["DELETE"])
 def api_delete_device_events(mac):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return delete_device_events(mac)
 
 @app.route("/device/<mac>/reset-props", methods=["POST"])
 def api_reset_device_props(mac):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return reset_device_props(mac, request.json)
 
 @app.route("/device/copy", methods=["POST"])
 def api_copy_device():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.get_json() or {}
     mac_from = data.get("macFrom")
     mac_to = data.get("macTo")
 
     if not mac_from or not mac_to:
-        return jsonify({"success": False, "error": "macFrom and macTo are required"}), 400
+        return jsonify({"success": False, "message": "Missing parameters", "error": "macFrom and macTo are required"}), 400
 
     return copy_device(mac_from, mac_to)
 
 @app.route("/device/<mac>/update-column", methods=["POST"])
 def api_update_device_column(mac):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.get_json() or {}
     column_name = data.get("columnName")
     column_value = data.get("columnValue")
 
     if not column_name or not column_value:
-        return jsonify({"success": False, "error": "columnName and columnValue are required"}), 400
+        return jsonify({"success": False, "message": "Missing parameters", "error": "columnName and columnValue are required"}), 400
 
     return update_device_column(mac, column_name, column_value)
 
@@ -162,13 +177,13 @@ def api_update_device_column(mac):
 @app.route("/devices", methods=["GET"])
 def api_get_devices():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return get_all_devices()
 
 @app.route("/devices", methods=["DELETE"])
 def api_delete_devices():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     
     macs = request.json.get("macs") if request.is_json else None
 
@@ -177,13 +192,13 @@ def api_delete_devices():
 @app.route("/devices/empty-macs", methods=["DELETE"])
 def api_delete_all_empty_macs():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return delete_all_with_empty_macs()
 
 @app.route("/devices/unknown", methods=["DELETE"])
 def api_delete_unknown_devices():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return delete_unknown_devices()
 
 
@@ -191,7 +206,7 @@ def api_delete_unknown_devices():
 @app.route("/devices/export/<format>", methods=["GET"])
 def api_export_devices(format=None):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     export_format = (format or request.args.get("format", "csv")).lower()
     return export_devices(export_format)
@@ -199,19 +214,19 @@ def api_export_devices(format=None):
 @app.route("/devices/import", methods=["POST"])
 def api_import_csv():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return import_csv(request.files.get("file"))
 
 @app.route("/devices/totals", methods=["GET"])
 def api_devices_totals():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return devices_totals()
 
 @app.route("/devices/by-status", methods=["GET"])
 def api_devices_by_status():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     status = request.args.get("status", "") if request.args else None
 
@@ -223,7 +238,7 @@ def api_devices_by_status():
 @app.route("/nettools/wakeonlan", methods=["POST"])
 def api_wakeonlan():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     mac = request.json.get("devMac")
     return wakeonlan(mac)
@@ -231,14 +246,14 @@ def api_wakeonlan():
 @app.route("/nettools/traceroute", methods=["POST"])
 def api_traceroute():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     ip = request.json.get("devLastIP")
     return traceroute(ip)
 
 @app.route("/nettools/speedtest", methods=["GET"])
 def api_speedtest():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return speedtest()
 
 @app.route("/nettools/nslookup", methods=["POST"])
@@ -248,11 +263,11 @@ def api_nslookup():
     Expects JSON with 'devLastIP'.
     """
     if not is_authorized():
-        return jsonify({"success": False, "error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.get_json(silent=True)
     if not data or "devLastIP" not in data:
-        return jsonify({"success": False, "error": "Missing 'devLastIP'"}), 400
+        return jsonify({"success": False, "message": "Missing parameters", "error": "Missing 'devLastIP'"}), 400
 
     ip = data["devLastIP"]
     return nslookup(ip)
@@ -264,11 +279,11 @@ def api_nmap():
     Expects JSON with 'scan' (IP address) and 'mode' (scan mode).
     """
     if not is_authorized():
-        return jsonify({"success": False, "error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.get_json(silent=True)
     if not data or "scan" not in data or "mode" not in data:
-        return jsonify({"success": False, "error": "Missing 'scan' or 'mode'"}), 400
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Missing 'scan' or 'mode'"}), 400
 
     ip = data["scan"]
     mode = data["mode"]
@@ -278,7 +293,7 @@ def api_nmap():
 @app.route("/nettools/internetinfo", methods=["GET"])
 def api_internet_info():
     if not is_authorized():
-        return jsonify({"success": False, "error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return internet_info()
 
 
@@ -289,13 +304,13 @@ def api_internet_info():
 @app.route("/dbquery/read", methods=["POST"])
 def dbquery_read():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.get_json() or {}
     raw_sql_b64 = data.get("rawSql")
 
     if not raw_sql_b64:
-        return jsonify({"error": "rawSql is required"}), 400
+        return jsonify({"success": False, "message": "Missing parameters", "error": "rawSql is required"}), 400
     
     return read_query(raw_sql_b64)
     
@@ -303,12 +318,12 @@ def dbquery_read():
 @app.route("/dbquery/write", methods=["POST"])
 def dbquery_write():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.get_json() or {}
     raw_sql_b64 = data.get("rawSql")
     if not raw_sql_b64:
-        return jsonify({"error": "rawSql is required"}), 400
+        return jsonify({"success": False, "message": "Missing parameters",  "error": "rawSql is required"}), 400
 
     return write_query(raw_sql_b64)
 
@@ -316,12 +331,12 @@ def dbquery_write():
 @app.route("/dbquery/update", methods=["POST"])
 def dbquery_update():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.get_json() or {}
     required = ["columnName", "id", "dbtable", "columns", "values"]
     if not all(data.get(k) for k in required):
-        return jsonify({"error": "Missing required parameters"}), 400
+        return jsonify({"success": False, "message": "Missing parameters", "error": "Missing required 'columnName', 'id', 'dbtable', 'columns', or 'values' query parameter"}), 400
 
     return update_query(
                 column_name=data["columnName"],
@@ -335,12 +350,12 @@ def dbquery_update():
 @app.route("/dbquery/delete", methods=["POST"])
 def dbquery_delete():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.get_json() or {}
     required = ["columnName", "id", "dbtable"]
     if not all(data.get(k) for k in required):
-        return jsonify({"error": "Missing required parameters"}), 400
+        return jsonify({"success": False, "message": "Missing parameters", "error": "Missing required 'columnName', 'id', or 'dbtable' query parameter"}), 400
 
     return  delete_query(
                 column_name=data["columnName"],
@@ -355,9 +370,46 @@ def dbquery_delete():
 @app.route("/history", methods=["DELETE"])
 def api_delete_online_history():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return delete_online_history()
 
+# --------------------------
+# Logs
+# --------------------------
+
+@app.route("/logs", methods=["DELETE"])
+def api_clean_log():
+    if not is_authorized():
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
+
+    file = request.args.get("file")
+    if not file:
+        return jsonify({"success": False, "message": "Missing parameters", "error": "Missing 'file' query parameter"}), 400
+
+    return clean_log(file)
+
+@app.route("/logs/add-to-execution-queue", methods=["POST"])
+def api_add_to_execution_queue():
+    queue = UserEventsQueueInstance()
+
+    # Get JSON payload safely
+    data = request.get_json(silent=True) or {}
+    action = data.get("action")
+
+    if not action:
+        return jsonify({
+            "success": False, "message": "Missing parameters", "error": "Missing required 'action' field in JSON body"}), 400
+
+    success, message = queue.add_event(action)
+    status_code = 200 if success else 400
+
+    response = {"success": success, "message": message}
+    if not success:
+        response["error"] = "ERROR"
+
+    return jsonify(response), status_code
+
+
 # --------------------------
 # Device Events
 # --------------------------
@@ -365,7 +417,7 @@ def api_delete_online_history():
 @app.route("/events/create/<mac>", methods=["POST"])
 def api_create_event(mac):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.json or {}
     ip = data.get("ip", "0.0.0.0")
@@ -384,19 +436,19 @@ def api_create_event(mac):
 @app.route("/events/<mac>", methods=["DELETE"])
 def api_events_by_mac(mac):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return delete_device_events(mac)
 
 @app.route("/events", methods=["DELETE"])
 def api_delete_all_events():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     return delete_events()
 
 @app.route("/events", methods=["GET"])
 def api_get_events():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     mac = request.args.get("mac")
     return get_events(mac)
@@ -408,14 +460,14 @@ def api_delete_old_events(days: int):
     Example: DELETE /events/30
     """
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
     
     return delete_events_older_than(days)
 
 @app.route("/sessions/totals", methods=["GET"])
 def api_get_events_totals():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     period = get_date_from_period(request.args.get("period", "7 days"))
     return get_events_totals(period)
@@ -427,7 +479,7 @@ def api_get_events_totals():
 @app.route("/sessions/create", methods=["POST"])
 def api_create_session():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.json
     mac = data.get("mac")
@@ -438,7 +490,7 @@ def api_create_session():
     event_type_disc = data.get("event_type_disc", "Disconnected")
 
     if not mac or not ip or not start_time:
-        return jsonify({"success": False, "error": "Missing required parameters"}), 400
+        return jsonify({"success": False, "message": "Missing parameters", "error": "Missing required 'mac', 'ip', or 'start_time' query parameter"}), 400
 
     return create_session(mac, ip, start_time, end_time, event_type_conn, event_type_disc)
 
@@ -446,11 +498,11 @@ def api_create_session():
 @app.route("/sessions/delete", methods=["DELETE"])
 def api_delete_session():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     mac = request.json.get("mac") if request.is_json else None
     if not mac:
-        return jsonify({"success": False, "error": "Missing MAC parameter"}), 400
+        return jsonify({"success": False, "message": "Missing parameters", "error": "Missing 'mac' query parameter"}), 400
 
     return delete_session(mac)
 
@@ -458,7 +510,7 @@ def api_delete_session():
 @app.route("/sessions/list", methods=["GET"])
 def api_get_sessions():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     mac = request.args.get("mac")
     start_date = request.args.get("start_date")
@@ -469,7 +521,7 @@ def api_get_sessions():
 @app.route("/sessions/calendar", methods=["GET"])
 def api_get_sessions_calendar():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     # Query params: /sessions/calendar?start=2025-08-01&end=2025-08-21
     start_date = request.args.get("start")
@@ -480,7 +532,7 @@ def api_get_sessions_calendar():
 @app.route("/sessions/<mac>", methods=["GET"])
 def api_device_sessions(mac):
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     period = request.args.get("period", "1 day")
     return get_device_sessions(mac, period)
@@ -488,7 +540,7 @@ def api_device_sessions(mac):
 @app.route("/sessions/session-events", methods=["GET"])
 def api_get_session_events():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     session_event_type = request.args.get("type", "all")
     period = get_date_from_period(request.args.get("period", "7 days"))
@@ -500,7 +552,7 @@ def api_get_session_events():
 @app.route("/metrics")
 def metrics():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     # Return Prometheus metrics as plain text
     return  Response(get_metric_stats(), mimetype="text/plain")
@@ -511,14 +563,14 @@ def metrics():
 @app.route("/messaging/in-app/write", methods=["POST"])
 def api_write_notification():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     data = request.json or {}
     content = data.get("content")
     level = data.get("level", "alert")
 
     if not content:
-        return jsonify({"success": False, "error": "Missing content"}), 400
+        return jsonify({"success": False, "message": "Missing parameters", "error": "Missing content"}), 400
     
     write_notification(content, level)
     return jsonify({"success": True})
@@ -526,21 +578,21 @@ def api_write_notification():
 @app.route("/messaging/in-app/unread", methods=["GET"])
 def api_get_unread_notifications():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     return get_unread_notifications()
 
 @app.route("/messaging/in-app/read/all", methods=["POST"])
 def api_mark_all_notifications_read():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     return jsonify(mark_all_notifications_read())
 
 @app.route("/messaging/in-app/delete", methods=["DELETE"])
 def api_delete_all_notifications():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     return delete_notifications()
 
@@ -548,25 +600,25 @@ def api_delete_all_notifications():
 def api_delete_notification(guid):
     """Delete a single notification by GUID."""
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     result = delete_notification(guid)
     if result.get("success"):
         return jsonify({"success": True})
     else:
-        return jsonify({"success": False, "error": result.get("error")}), 500
+        return jsonify({"success": False, "message": "ERROR", "error": result.get("error")}), 500
 
 @app.route("/messaging/in-app/read/<guid>", methods=["POST"])
 def api_mark_notification_read(guid):
     """Mark a single notification as read by GUID."""
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     result = mark_notification_as_read(guid)
     if result.get("success"):
         return jsonify({"success": True})
     else:
-        return jsonify({"success": False, "error": result.get("error")}), 500
+        return jsonify({"success": False, "message": "ERROR", "error": result.get("error")}), 500
     
 # --------------------------
 # SYNC endpoint
@@ -574,7 +626,7 @@ def api_mark_notification_read(guid):
 @app.route("/sync", methods=["GET", "POST"])
 def sync_endpoint():
     if not is_authorized():
-        return jsonify({"error": "Forbidden"}), 403
+        return jsonify({"success": False, "message": "ERROR: Not authorized", "error": "Forbidden"}), 403
 
     if request.method == "GET":
         return handle_sync_get()
@@ -584,7 +636,7 @@ def sync_endpoint():
         msg = "[sync endpoint] Method Not Allowed"
         write_notification(msg, "alert")
         mylog("verbose", [msg])
-        return jsonify({"error": "Method Not Allowed"}), 405
+        return jsonify({"success": False, "message": "ERROR: No allowed", "error": "Method Not Allowed"}), 405
 
 # --------------------------
 # Background Server Start