184 lines
6.7 KiB
Python
184 lines
6.7 KiB
Python
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])
|
|
|
|
# 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
|
|
app.teardown_appcontext(close_db)
|
|
app.cli.add_command(init_db_command)
|
|
|
|
# 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
|
|
|
|
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')
|
|
|
|
# WebSocket Routes laden
|
|
from cmbnet.ws import routes
|
|
|
|
# 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)
|
|
)
|
|
|
|
# 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
|