import os from flask import Flask, g, session, send_from_directory from config import config from cmbnet.extensions import sock def normalize_prefix(value): """Normalisiert einen URI-Prefix aus ``X-Forwarded-Prefix``. Akzeptiert nur absolute Pfade ohne Query/Fragment, ohne ``..``-Segmente und ohne doppelte bzw. abschließende Schrägstriche. Bei ungültigen oder gefährlichen Werten wird ein leerer Prefix zurückgegeben. """ if not value: return '' # Mehrfach-Header bzw. kommaseparierte Werte: erster Wert zählt. value = value.split(',', 1)[0].strip() if not value.startswith('/'): return '' if '://' in value or '?' in value or '#' in value or '\\' in value: return '' segments = [] for segment in value.split('/'): if not segment: continue if segment in ('.', '..'): return '' if any(ord(char) < 32 or ord(char) == 127 for char in segment): return '' if '%2f' in segment.lower() or '%5c' in segment.lower(): return '' segments.append(segment) return '/' + '/'.join(segments) if segments else '' class PrefixMiddleware: """Macht Reverse-Proxy-Prefixe über ``SCRIPT_NAME`` verfügbar. Der Proxy kann den Prefix vor dem Weiterleiten entfernen (z. B. mit Caddys ``handle_path``) oder unverändert durchreichen. Beide Varianten werden unterstützt. Flask erzeugt danach alle ``url_for``-URLs inklusive Prefix; zusätzlich wird der Prefix an die Templates weitergegeben, damit JavaScript seine AJAX- und WebSocket-URLs korrekt bilden kann. """ def __init__(self, app, prefix=''): self.app = app self.prefix = normalize_prefix(prefix) def __call__(self, environ, start_response): header_prefix = normalize_prefix(environ.get('HTTP_X_FORWARDED_PREFIX')) prefix = header_prefix or self.prefix if not prefix: return self.app(environ, start_response) script_name = environ.get('SCRIPT_NAME', '') or '' if script_name == '/': script_name = '' script_name = script_name.rstrip('/') # Nicht doppelt prefixen, wenn die Anwendung bereits unter demselben # Pfad eingebunden ist (z. B. durch den WSGI-Server). if script_name and ( script_name == prefix or script_name.endswith(prefix) ): combined_script_name = script_name else: combined_script_name = script_name + prefix path_info = environ.get('PATH_INFO', '') or '/' # Proxy hat den Prefix nicht entfernt: einmalig abschneiden. if path_info == prefix: path_info = '/' elif path_info.startswith(prefix + '/'): path_info = path_info[len(prefix):] environ['SCRIPT_NAME'] = combined_script_name environ['PATH_INFO'] = path_info or '/' return self.app(environ, start_response) def create_app(config_name=None): if config_name is None: config_name = os.environ.get('FLASK_ENV', 'development') app = Flask(__name__, template_folder='../templates', static_folder='../static') app.config.from_object(config[config_name]) # Anzeigetitel für alle Web-Views. Der interne Projektname bleibt CMBNet. app.jinja_env.globals['APP_TITLE'] = app.config.get( 'DISPLAY_TITLE', '20*C+M+B+27' ) # Middleware registrieren app.wsgi_app = PrefixMiddleware(app.wsgi_app) # Stelle sicher, dass instance Verzeichnis existiert os.makedirs(app.instance_path, exist_ok=True) os.makedirs(app.config['LOG_DIR'], exist_ok=True) # Sock initialisieren sock.init_app(app) # Datenbank-Setup from cmbnet.db import close_db, init_db_command from cmbnet.db.database import ensure_schema app.teardown_appcontext(close_db) app.cli.add_command(init_db_command) # Bestehende Installationen idempotent auf das aktuelle Schema heben. with app.app_context(): ensure_schema() # Tenant und Account für Requests laden @app.before_request def load_current_account(): if 'account_id' in session: from cmbnet.db import get_db db = get_db() account = db.execute('SELECT a.*, t.code as tenant_code FROM accounts a JOIN tenants t ON a.tenant_id = t.id WHERE a.id = ?', (session['account_id'],)).fetchone() if account: g.current_account = account g.tenant_id = account['tenant_id'] g.tenant_code = account['tenant_code'] else: session.clear() # Blueprints registrieren from cmbnet.views import auth_bp, views_bp from cmbnet.admin.accounts import admin_accounts_bp from cmbnet.admin.gruppen import admin_gruppen_bp from cmbnet.admin.strassen import admin_strassen_bp from cmbnet.admin.api import admin_api_bp from cmbnet.api.init import api_init_bp from cmbnet.api.auth import api_auth_bp from cmbnet.api.groups import api_groups_bp from cmbnet.api.positions import api_positions_bp app.register_blueprint(auth_bp, url_prefix='/') app.register_blueprint(views_bp, url_prefix='/') # Admin-Views immer unter //admin/..., damit sie nicht mit den # rollenspezifischen Views (z. B. views.gruppen unter //gruppen) # kollidieren. app.register_blueprint(admin_accounts_bp, url_prefix='//admin') app.register_blueprint(admin_gruppen_bp, url_prefix='//admin') app.register_blueprint(admin_strassen_bp, url_prefix='//admin') app.register_blueprint(admin_api_bp, url_prefix='//admin/api') app.register_blueprint(api_init_bp, url_prefix='//api') app.register_blueprint(api_auth_bp, url_prefix='//api') app.register_blueprint(api_groups_bp, url_prefix='//api') app.register_blueprint(api_positions_bp, url_prefix='//api') # WebSocket Routes laden from cmbnet.ws import routes # Optionale feste Worker-ID aus der Konfiguration übernehmen. Der Broker # liest sonst CMBNET_WS_WORKER_ID bzw. bildet :. from cmbnet.ws import broker as ws_broker if app.config.get('WS_WORKER_ID'): ws_broker.worker_id = app.config['WS_WORKER_ID'] # Heartbeat starten (Code 1 jede Minute, Aufräumen alter Nachrichten) from cmbnet.ws.heartbeat import heartbeat_manager heartbeat_manager.start( app, interval=app.config.get('WS_HEARTBEAT_INTERVAL', 60) ) # Worker-lokale Schleife für die gemeinsame Zustell-Queue. Jeder # Gunicorn-/WSGI-Worker muss eine eigene Instanz starten. Bei # ``preload_app=True`` würde sie im Master starten und in den Workern # fehlen; deshalb ist der Betrieb ohne Preload erforderlich. from cmbnet.ws.delivery import delivery_worker delivery_worker.start( app, interval=app.config.get('WS_BUS_POLL_INTERVAL', 0.5) ) # Favicon explizit bedienen, damit /favicon.ico nicht als Tenant-Pfad # interpretiert wird. @app.route('/favicon.ico') def favicon(): return send_from_directory( app.static_folder, 'favicon.ico', mimetype='image/vnd.microsoft.icon' ) # Service Worker für die PWA. Er wird bewusst an der App-Wurzel # ausgeliefert, damit er auch die statischen Assets unter /static # kontrollieren kann. Der Pfad berücksichtigt ein gesetztes SCRIPT_NAME # (Reverse-Proxy-Prefix) automatisch. @app.route('/sw.js') def service_worker(): response = send_from_directory( app.static_folder, 'js/sw.js', mimetype='application/javascript' ) response.headers['Cache-Control'] = 'no-cache' return response # Root redirect @app.route('/') def index(): from flask import redirect, url_for return redirect(url_for('auth.login_select', tenant=app.config['DEFAULT_TENANT'])) return app