Nirdoan/Tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 6 Wiki Activity

Funktionstrennung 1.0

Browse Source
This commit is contained in:
Nirodan
2025-06-17 11:28:06 +02:00
parent 97acda1d2b
commit 8ca650cf11
11 changed files with 199 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/app.py
+1 -1
View File
@@ -1,5 +1,5 @@
from flask import Flask, request, render_template, jsonify, redirect, send_from_directory
from datenbankverbindung import lade_db_config, speichere_db_config, teste_verbindung, initialisiere_admin_user
from backend.db_config import lade_db_config, speichere_db_config, teste_verbindung, initialisiere_admin_user
from datetime import datetime, timedelta
from jwt import decode, ExpiredSignatureError, InvalidTokenError
backend/auth/__init__.py
+9
View File
@@ -0,0 +1,9 @@
from flask import Blueprint
from auth.login import login_route
from auth.logout import logout_route
auth_bp = Blueprint('auth', __name__)
# Endpunkte registrieren
auth_bp.add_url_rule('/api/login', view_func=login_route, methods=['POST'])
auth_bp.add_url_rule('/api/logout', view_func=logout_route, methods=['POST'])
backend/auth/login.py
+45
View File
@@ -0,0 +1,45 @@
from flask import request, jsonify
from mysql.connector import connect
from werkzeug.security import check_password_hash
from datetime import datetime, timedelta
import jwt
from util.logger import logger
from util.db_config import load_db_config
from auth.token import SECRET_KEY
def login_route():
data = request.get_json()
username = data.get('username')
password = data.get('password')
try:
config = load_db_config()
conn = connect(**config)
cursor = conn.cursor(dictionary=True)
cursor.execute("SELECT * FROM users WHERE username = %s", (username,))
user = cursor.fetchone()
cursor.close()
conn.close()
if user and check_password_hash(user['password'], password):
logger.info(f"✅ Login successful: {username}")
payload = {
"username": user['username'],
"role": user['role'],
"exp": datetime.utcnow() + timedelta(minutes=60)
}
token = jwt.encode(payload, SECRET_KEY, algorithm="HS256")
return jsonify({
"token": token,
"role": user['role']
})
logger.warning(f"⛔ Login failed: {username}")
return jsonify({"message": "Login failed"}), 401
except Exception as e:
logger.error(f"[Login Error] {e}")
return jsonify({"message": "Server error"}), 500
backend/auth/logout.py
+6
View File
@@ -0,0 +1,6 @@
from flask import jsonify
from util.logger import logger
def logout_route():
logger.info("👋 Logout called")
return jsonify({"message": "Logout successful"})
backend/auth/token.py
+22
View File
@@ -0,0 +1,22 @@
from flask import request
from jwt import decode, ExpiredSignatureError, InvalidTokenError
from util.logger import logger
SECRET_KEY = "bitte_hier_dein_geheimes_passwort_setzen" # später .env verwenden
def verify_token():
auth_header = request.headers.get("Authorization", "")
if not auth_header.startswith("Bearer "):
logger.warning("🔐 Invalid Bearer header")
return None
token = auth_header.replace("Bearer ", "")
try:
decoded = decode(token, SECRET_KEY, algorithms=["HS256"])
return decoded
except ExpiredSignatureError:
logger.warning("🔐 Token expired")
return None
except InvalidTokenError:
logger.warning("🔐 Invalid token")
return None
backend/config/__init__.py
+1
View File
@@ -0,0 +1 @@
from .setup_routes import setup_blueprint
backend/config/db_config.py
+35
View File
@@ -0,0 +1,35 @@
import os
import json
import mysql.connector
from util.logger import logger
CONFIG_PATH = "config/db_config.json"
def is_configured():
return os.path.exists(CONFIG_PATH)
def load_config():
try:
with open(CONFIG_PATH, "r") as file:
return json.load(file)
except Exception as e:
logger.error(f"[DB-Config] Fehler beim Laden: {e}")
return None
def save_config(config):
try:
os.makedirs("config", exist_ok=True)
with open(CONFIG_PATH, "w") as file:
json.dump(config, file, indent=2)
logger.info("[DB-Config] Konfiguration gespeichert.")
except Exception as e:
logger.error(f"[DB-Config] Fehler beim Speichern: {e}")
def test_connection(config) -> bool:
try:
conn = mysql.connector.connect(**config)
conn.close()
return True
except Exception as e:
logger.warning(f"[DB-Check] Verbindung fehlgeschlagen: {e}")
return False
backend/config/setup_routes.py
+47
View File
@@ -0,0 +1,47 @@
import time
import os
from flask import Blueprint, request, render_template, redirect, jsonify
from config.db_config import load_config, save_config, test_connection, is_configured
from auth.setup_admin import initialize_admin_user
from util.logger import logger
setup_blueprint = Blueprint("setup", __name__, template_folder="../backend/templates")
MAX_WAIT = 30
WAIT_INTERVAL = 10
def wait_for_db():
elapsed = 0
config = load_config()
while not test_connection(config) and elapsed < MAX_WAIT:
logger.info(f"[SETUP] DB nicht erreichbar – warte {WAIT_INTERVAL}s...")
time.sleep(WAIT_INTERVAL)
elapsed += WAIT_INTERVAL
return elapsed < MAX_WAIT
@setup_blueprint.route('/api/status')
def status():
if not is_configured():
return jsonify({"status": "init", "db_connected": False})
elif test_connection(load_config()):
return jsonify({"status": "ready", "db_connected": True})
else:
return jsonify({"status": "error", "db_connected": False})
@setup_blueprint.route('/setup', methods=['GET', 'POST'])
def setup():
if request.method == 'POST':
db_config = {
"host": request.form['host'],
"port": int(request.form['port']),
"user": request.form['user'],
"password": request.form['password'],
"database": request.form['database']
}
save_config(db_config)
if test_connection(db_config):
initialize_admin_user(db_config)
return redirect('/')
else:
return "Verbindung fehlgeschlagen. Bitte zurück und prüfen.", 500
return render_template('setup.html')
backend/datenbankverbindung.py
-47
View File
@@ -1,47 +0,0 @@
import json
import mysql.connector
from werkzeug.security import generate_password_hash
def lade_db_config(pfad='config/db_config.json'):
with open(pfad, 'r') as f:
return json.load(f)
def speichere_db_config(daten, pfad='config/db_config.json'):
with open(pfad, 'w') as f:
json.dump(daten, f, indent=2)
def teste_verbindung(db_config):
try:
conn = mysql.connector.connect(**db_config)
conn.close()
return True
except mysql.connector.Error as e:
print(f"[Fehler] DB-Verbindung fehlgeschlagen: {e}")
return False
def initialisiere_admin_user(db_config):
conn = mysql.connector.connect(**db_config)
cursor = conn.cursor()
cursor.execute("""
CREATE TABLE IF NOT EXISTS users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(255) UNIQUE NOT NULL,
password VARCHAR(255) NOT NULL,
role ENUM('user', 'admin') NOT NULL DEFAULT 'user'
)
""")
cursor.execute("SELECT id FROM users WHERE username = 'admin'")
if not cursor.fetchone():
hashed_pw = generate_password_hash('admin')
cursor.execute("""
INSERT INTO users (username, password, role)
VALUES (%s, %s, 'admin')
""", ('admin', hashed_pw))
print("[INFO] Admin-Account wurde erstellt (gehashed): admin / admin")
conn.commit()
cursor.close()
conn.close()
backend/tools/__init__.py
+1
View File
@@ -0,0 +1 @@
from .md5 import md5_blueprint
backend/tools/md5.py
+32
View File
@@ -0,0 +1,32 @@
from flask import Blueprint, request, jsonify
import hashlib
from util.logger import logger
from auth.token import verify_token
md5_blueprint = Blueprint('md5_tool', __name__)
@md5_blueprint.route('/api/hash/md5', methods=['POST'])
def hash_md5():
logger.info("🔁 /api/hash/md5 aufgerufen")
user = verify_token()
if not user:
logger.warning("⛔ Nicht autorisiert")
return jsonify({"message": "Nicht autorisiert"}), 401
try:
data = request.get_json()
logger.debug(f"📩 Payload: {data}")
password = data.get("password", "")
result = hashlib.md5(password.encode()).hexdigest()
logger.info(f"✅ Hash erstellt von {user['username']}")
return jsonify({
"md5": result,
"by": user['username']
})
except Exception as e:
logger.error(f"❌ Fehler beim Hashen: {e}")
return jsonify({"message": "Fehler beim Hashen"}), 500