Very various code revork and refactoring

.gitignore

@@ -1,6 +1,7 @@
 # Project-specific files
 external/
 log.txt
+*.db
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

README.md

@@ -88,7 +88,7 @@ logging:
 export FLASK_APP=application.py
 flask run --debug
 ```
-
+if you want to autorestart you app on Flask changes, you can do `export FLASK_DEBUG=1`. In case of `Import Error` run `pip3 install --upgrade watchdog`.
 By default, this should be run by Prismo admin process, but for debugging purpose you should run this commands by
 yourself.
 

app/api/device_api.py

@@ -0,0 +1,40 @@
+from flask import Flask, Blueprint, jsonify, request
+from flask import current_app as app
+
+from models.access_log import AccessLog
+from models.device import Device
+
+import json
+
+
+device_api = Blueprint("device_api", __name__)
+
+
+@device_api.route("/devices/<device_id>/accesses/", methods=["GET"])
+def accesses(device_id):
+    data = Device.get_authorized_users(device_id)
+    app.ee.emit('device-updated-keys', {"device_id": device_id})
+    return {"keys": data}
+
+
+@device_api.route("/devices/<device_id>/log_operation", methods=["POST"])
+def log_operation(device_id):
+
+    json_data = request.get_json()
+    if not json_data:
+        raise Exception("Invalid request, no JSON data received")
+    # logging.info("Received request: " + str(json_data))
+
+    operation = json_data["operation"]
+    if operation not in ["lock", "unlock", "deny_access"]:
+        raise Exception("Invalid operation")
+
+    user_key = json_data["key"]
+
+    if (operation == "unlock") and user_key is None:
+        raise Exception("Invalid operation")
+
+    AccessLog.add(device_id, user_key, operation)
+    app.ee.emit('access-log-entry-added', {"device_id": device_id,
+                "user_key": user_key, "operation": operation})
+    return "OK", 201

app/api/web_api.py

@@ -0,0 +1,192 @@
+# pylint: disable=consider-using-f-string
+# pylint: disable=broad-except
+import json
+
+from flask import Blueprint, jsonify, request
+from flask import current_app as app
+from models.access_log import AccessLog
+from models.device import Device
+from models.user import User
+
+web_api = Blueprint("web_api", __name__)
+
+
+# Logs API
+
+
+@web_api.route("/api/logs", methods=["GET"])
+def api_get_logs():
+    # Retrieve parameters from the query string
+    start_time = request.args.get("start_time", default=None)
+    end_time = request.args.get("end_time", default=None)
+    limit = request.args.get("limit", default=100, type=int)
+    offset = request.args.get("offset", default=0, type=int)
+
+    return jsonify(AccessLog.get_full_log(start_time, end_time, limit, offset))
+
+
+# Devices API
+
+
+@web_api.route("/api/devices/latest_key", methods=["GET"])
+def api_get_latest_key():
+    return jsonify(Device.get_latest_key())
+
+
+@web_api.route("/api/devices", methods=["GET"])
+def api_get_devices():
+    return jsonify(Device.get_all_devices())
+
+
+@web_api.route("/api/devices", methods=["POST"])
+def api_add_device():
+    device_data = request.get_json()
+
+    try:
+        device = Device(device_data["device_id"], device_data.get(
+            "device_name"), device_data["device_type"])
+        device.save()
+        app.logger.info("Device %s added successfully" % device_data["device_id"])
+        return jsonify({"message": "Device added successfully"}), 201
+    except Exception as e:
+        app.logger.error("Error adding device: %s" % e)
+        return jsonify({"message": "Error adding device"}), 303
+
+
+@web_api.route("/api/devices/<device_id>", methods=["PUT"])
+def api_update_device(device_id):
+    device_data = request.get_json()
+
+    device = Device(device_id=device_id, device_type=None, name=None)
+    device.update_device(device_data.get("device_type", None), device_data.get("name", None))
+
+    return jsonify({"message": "Device updated successfully"})
+
+
+@web_api.route("/api/devices/<device_id>", methods=["DELETE"])
+def api_remove_device(device_id):
+    try:
+        device = Device(device_id=device_id, device_type=None, name=None)
+        device.delete()
+        app.logger.info("Device %s removed successfully" % device_id)
+        return jsonify({"message": "Device removed successfully"}), 200
+    except Exception as e:
+        app.logger.error("Error removing device: %s" % e)
+        return jsonify({"message": "Error removing device"}), 303
+
+
+# Users API
+
+@web_api.route("/api/users", methods=["GET"])
+def api_get_user_permissions():
+    return jsonify(User.get_permissions())
+
+
+def api_add_user():
+    user_data = request.get_json()
+
+    user = User(user_data["name"], user_data["key"], user_data.get("slack_id"))
+
+    number_of_new_user_added = user.save()
+
+    # pylint: disable=no-else-return
+    if number_of_new_user_added == 1:
+        return jsonify({"message": "User added successfully"}), 201
+    elif number_of_new_user_added == 0:
+        return jsonify({"message": "User already exists"}), 303
+
+    # Handle other cases (e.g., database error)
+    return jsonify({"message": "An error occurred"}), 500
+
+
+@web_api.route("/api/users/<user_key>", methods=["DELETE"])
+def api_delete_user(user_key):
+    user = User(key=user_key, name=None)
+    user.delete()
+
+    return jsonify({"message": "User deleted successfully"})
+
+
+@web_api.route("/api/users/<user_key>/devices/<device_id>", methods=["POST"])
+def api_add_user_permission(user_key, device_id):
+    user = User(key=user_key, name=None)
+    user.add_permission(device_id)
+
+    return jsonify({"message": "User permission added successfully"})
+
+
+@web_api.route("/api/users/<user_key>/devices/<device_id>", methods=["DELETE"])
+def api_remove_user_permission(user_key, device_id):
+    user = User(key=user_key, name=None)
+    user.remove_permission(device_id)
+
+    return jsonify({"message": "User permission removed successfully"})
+
+
+# Settings API
+
+
+@web_api.route("/api/settings", methods=["GET"])
+def api_get_settings():
+    """
+    Returns the current settings of the system.
+
+    Returns:
+        dict: The current settings of prismo.
+
+    Example:
+        {
+            "device_type": "printer",
+            "name": "Printer 1"
+        }
+
+    Raises:
+        Exception: If the settings cannot be retrieved.
+
+    """
+    try:
+        settings = app.config["PRISMO"]
+        app.logger.info("Retrieved settings: %s", settings)
+        return jsonify(settings)
+    except Exception as e:
+        app.logger.error("Error retrieving settings: %s", e)
+        raise Exception("Error retrieving settings") from e
+
+
+@web_api.route("/api/settings", methods=["PUT"])
+def api_update_settings():
+    """
+    Updates the current settings of the system.
+
+    Returns:
+        dict: The updated settings.
+    """
+
+    try:
+        settings = app.config["PRISMO"]
+        new_settings = json.loads(request.data)
+        app.logger.info("New settings received: %s", new_settings)
+        app.config["PRISMO"] = new_settings
+
+        app.logger.info("Updated settings: %s", settings)
+        # Update "PRISMO" branch in settings file
+        try:
+            with open(app.config["PRISMO"]["CURRENT_CONFIG_FILE"], "r") as f:
+                stored_settings = json.load(f)
+            with open(app.config["PRISMO"]["CURRENT_CONFIG_FILE"], "w") as f:
+                stored_settings["PRISMO"] = new_settings
+                json.dump(stored_settings, f, indent=4)
+                app.logger.warning("Settings updated, new settings are: %s", stored_settings)
+        except Exception as e:
+            app.logger.error("Error saving settings to file: %s", e)
+
+        return jsonify(settings)
+    except Exception as e:
+        app.logger.error("Error updating settings: %s", e)
+        raise Exception("Error updating settings") from e
+
+# websocket = Sock(app)
+# @websocket.route('/updater_socket')
+# def updater(websocket):
+#    # pylint: disable=redefined-outer-name
+#    update_firmware_full(websocket)

app/application.py

@@ -0,0 +1,119 @@
+import json
+
+from flask import Flask, render_template, request, redirect, url_for
+from flask_login import (
+    LoginManager,
+    login_user,
+    logout_user,
+    login_required,
+    current_user,
+)
+from pyee.base import EventEmitter
+
+from api.device_api import device_api
+from api.web_api import web_api
+from models.admin_user import AdminUser
+from plugins.slack_notifier import SlackNotifierPlugin
+
+app = Flask(__name__)
+app.ee = EventEmitter()
+
+app.register_blueprint(web_api)
+app.register_blueprint(device_api)
+
+app.config.from_file("config_debug.json", load=json.load)
+
+login_manager = LoginManager()
+login_manager.init_app(app)
+
+# Plugins
+slack_notifier = SlackNotifierPlugin(app.app_context())
+
+
+@login_manager.user_loader
+def load_user(user_id):
+    # pylint: disable=unused-argument
+    return AdminUser("", "")
+
+
+@app.route("/init_app", methods=["GET", "POST"])
+def init_app_route():
+    if request.method == "GET":
+        return render_template("auth/init_app.html")
+
+    username = request.form["username"]
+    password = request.form["password"]
+    AdminUser(username, password).create_user()
+
+    # if "file" in request.files:
+    #    file = request.files["file"]
+    # else:
+    #    file = None
+
+    # init_app(username, password, slat, file)
+
+    return redirect(url_for("login"))
+
+
+@app.route("/login", methods=["GET", "POST"])
+def login():
+    if current_user.is_authenticated:
+        return redirect(url_for("users"))
+
+    if request.method == "GET":
+        return render_template("auth/login.html")
+
+    username = request.form["username"]
+    password = request.form["password"]
+
+    user = AdminUser(username)
+    if user is None or not user.check_password(password):
+        app.logger.error("Auth failed: Invalid username or password")
+        return render_template("auth/login.html", error="Invalid username or password")
+
+    app.logger.info("Auth success: %s", username)
+    login_user(user)
+    return redirect(url_for("users"))
+
+
+@app.route("/logout")
+def logout():
+    app.logger.info("Logout: %s", current_user.username)
+    logout_user()
+    return redirect(url_for("login"))
+
+
+# App routes
+
+
+@app.route("/", methods=["GET"])
+def index():
+    # if not database_file.is_file():
+    #    return flask.redirect(flask.url_for('admin.init_app_route'))
+    if current_user.is_authenticated:
+        return redirect(url_for("users"))
+    return redirect(url_for("login"))
+
+
+@app.route("/users", methods=["GET"])
+@login_required
+def users():
+    return render_template("prismo/users.html")
+
+
+@app.route("/devices")
+@login_required
+def devices():
+    return render_template("prismo/devices.html")
+
+
+@app.route("/logs")
+@login_required
+def logs():
+    return render_template("prismo/logs.html")
+
+
+@app.route("/settings", methods=["GET", "POST"])
+@login_required
+def settings():
+    return render_template("prismo/settings.html")