import json import os from flask import Flask, Response, 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' ) # Mandantenspezifisches Polyline-Skript (str2pl-.js) mit Rückfall # auf die gemeinsame str2pl.js. from cmbnet.utils.helpers import str2pl_asset, str2pl_asset_version app.jinja_env.globals['str2pl_asset'] = str2pl_asset app.jinja_env.globals['str2pl_asset_version'] = str2pl_asset_version # Öffentliche FCM-Webkonfiguration für die mobilen Templates. Der # Service-Account-Schlüssel bleibt ausschließlich auf dem Server. from cmbnet.services.fcm_service import public_fcm_config app.jinja_env.globals['fcm_public_config'] = public_fcm_config # 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.admin.backup import admin_backup_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 from cmbnet.api.push import api_push_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(admin_backup_bp, url_prefix='//admin') 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') app.register_blueprint(api_push_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) ) # FCM-Offline-Worker nur starten, wenn Firebase aktiviert ist. Er weckt # getrennte mobile Clients nach dem konfigurierten Offline-Timeout, damit # diese ein Positionsupdate senden können. if app.config.get('FCM_ENABLED'): from cmbnet.ws.push import push_wake_worker push_wake_worker.start( app, interval=app.config.get('FCM_WAKE_POLL_INTERVAL_SECONDS', 30) ) # 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 @app.route('/fcm-sw-config.js') def fcm_service_worker_config(): """Öffentliche Firebase-Konfiguration für den Service Worker. Die Datei wird per ``importScripts`` vom Service Worker geladen. Sie enthält ausschließlich öffentliche Web-API-Schlüssel, niemals den Service-Account. """ payload = public_fcm_config() body = ( '/* Automatisch erzeugt. Enthält keine Server-Geheimnisse. */\n' 'self.CMBNET_FCM_CONFIG = ' + json.dumps(payload, ensure_ascii=False) + ';\n' ) response = Response(body, mimetype='application/javascript') response.headers['Cache-Control'] = 'no-cache' return response @app.route('/wake') def wake(): """Ziel für den Klick auf ein FCM-Aufwachsignal. Der Mandant kommt aus der bestehenden Session. So landet der Nutzer nach dem Öffnen der PWA wieder in seiner mobilen View, ohne dass FCM Mandant, Rolle oder Nachrichteninhalt transportieren muss. """ from flask import redirect, url_for tenant = session.get('tenant_code') or app.config['DEFAULT_TENANT'] return redirect(url_for('views.index', tenant=tenant)) # 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