Files
Sternsinger/CMBNet/cmbnet/__init__.py
T

267 lines
10 KiB
Python

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-<tenant>.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.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='/<tenant>')
app.register_blueprint(views_bp, url_prefix='/<tenant>')
# Admin-Views immer unter /<tenant>/admin/..., damit sie nicht mit den
# rollenspezifischen Views (z. B. views.gruppen unter /<tenant>/gruppen)
# kollidieren.
app.register_blueprint(admin_accounts_bp, url_prefix='/<tenant>/admin')
app.register_blueprint(admin_gruppen_bp, url_prefix='/<tenant>/admin')
app.register_blueprint(admin_strassen_bp, url_prefix='/<tenant>/admin')
app.register_blueprint(admin_api_bp, url_prefix='/<tenant>/admin/api')
app.register_blueprint(api_init_bp, url_prefix='/<tenant>/api')
app.register_blueprint(api_auth_bp, url_prefix='/<tenant>/api')
app.register_blueprint(api_groups_bp, url_prefix='/<tenant>/api')
app.register_blueprint(api_positions_bp, url_prefix='/<tenant>/api')
app.register_blueprint(api_push_bp, url_prefix='/<tenant>/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 <hostname>:<pid>.
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