🎉 Improved cursor rules and expanded logging system across backend files. 🖥️📝

backend/app.py

@@ -10,7 +10,9 @@ import sys
 import logging
 import atexit
 import signal
-from datetime import datetime
+import pickle
+import hashlib
+from datetime import datetime, timedelta
 from flask import Flask, render_template, request, jsonify, redirect, url_for, session, abort
 from flask_login import LoginManager, current_user, logout_user, login_required
 from flask_wtf import CSRFProtect
@@ -19,6 +21,97 @@ from sqlalchemy import event
 from contextlib import contextmanager
 import threading
 
+# ===== SESSION-OPTIMIERUNG =====
+class SessionManager:
+    """Optimierter Session-Manager für große Session-Daten"""
+    
+    def __init__(self, app=None):
+        self.app = app
+        self.session_storage_path = None
+        
+    def init_app(self, app):
+        """Initialisiert den Session-Manager für die Flask-App"""
+        self.app = app
+        self.session_storage_path = os.path.join(
+            app.instance_path, 'sessions'
+        )
+        os.makedirs(self.session_storage_path, exist_ok=True)
+        
+    def store_large_session_data(self, key, data):
+        """Speichert große Session-Daten im Dateisystem"""
+        if not self.session_storage_path:
+            return False
+            
+        try:
+            session_id = session.get('session_id')
+            if not session_id:
+                session_id = hashlib.md5(
+                    f"{request.remote_addr}_{datetime.now().isoformat()}".encode()
+                ).hexdigest()
+                session['session_id'] = session_id
+            
+            file_path = os.path.join(
+                self.session_storage_path, 
+                f"{session_id}_{key}.pkl"
+            )
+            
+            with open(file_path, 'wb') as f:
+                pickle.dump(data, f)
+                
+            # Nur Referenz in Session speichern
+            session[f"{key}_ref"] = True
+            
+            return True
+        except Exception as e:
+            logging.error(f"Fehler beim Speichern der Session-Daten: {e}")
+            return False
+    
+    def load_large_session_data(self, key):
+        """Lädt große Session-Daten aus dem Dateisystem"""
+        if not self.session_storage_path:
+            return None
+            
+        try:
+            session_id = session.get('session_id')
+            if not session_id or not session.get(f"{key}_ref"):
+                return None
+                
+            file_path = os.path.join(
+                self.session_storage_path,
+                f"{session_id}_{key}.pkl"
+            )
+            
+            if not os.path.exists(file_path):
+                return None
+                
+            with open(file_path, 'rb') as f:
+                return pickle.load(f)
+                
+        except Exception as e:
+            logging.error(f"Fehler beim Laden der Session-Daten: {e}")
+            return None
+    
+    def cleanup_expired_sessions(self):
+        """Bereinigt abgelaufene Session-Dateien"""
+        if not self.session_storage_path:
+            return
+            
+        try:
+            current_time = datetime.now()
+            for filename in os.listdir(self.session_storage_path):
+                file_path = os.path.join(self.session_storage_path, filename)
+                file_time = datetime.fromtimestamp(os.path.getmtime(file_path))
+                
+                # Lösche Dateien älter als 24 Stunden
+                if current_time - file_time > timedelta(hours=24):
+                    os.remove(file_path)
+                    
+        except Exception as e:
+            logging.error(f"Fehler bei Session-Cleanup: {e}")
+
+# Globaler Session-Manager
+session_manager = SessionManager()
+
 # ===== PRODUCTION-KONFIGURATION =====
 class ProductionConfig:
     """Production-Konfiguration für Mercedes-Benz TBA Marienfelde Air-Gapped Environment
@@ -523,6 +616,9 @@ login_manager.init_app(app)
 login_manager.login_view = "auth.login"
 login_manager.login_message = "Bitte melden Sie sich an, um auf diese Seite zuzugreifen."
 
+# Session-Manager initialisieren
+session_manager.init_app(app)
+
 @login_manager.user_loader
 def load_user(user_id):
     """Lädt einen Benutzer für Flask-Login"""
@@ -595,22 +691,32 @@ def log_response_info(response):
 
 @app.before_request
 def check_session_activity():
-    """Prüft Session-Aktivität und meldet inaktive Benutzer ab"""
+    """Prüft Session-Aktivität und meldet inaktive Benutzer ab mit optimiertem Cookie-Management"""
     if current_user.is_authenticated:
         from utils.utilities_collection import SESSION_LIFETIME
-        last_activity = session.get('last_activity')
-        if last_activity:
+        now = datetime.now()
+        
+        # Reduzierte Session-Daten für Cookie-Größe
+        last_activity_str = session.get('last_activity')
+        if last_activity_str:
             try:
-                last_activity_time = datetime.fromisoformat(last_activity)
-                if (datetime.now() - last_activity_time).total_seconds() > SESSION_LIFETIME.total_seconds():
+                # Verarbeite sowohl alte ISO-Format als auch neue Zeit-Format
+                if 'T' in last_activity_str:  # ISO-Format
+                    last_activity_time = datetime.fromisoformat(last_activity_str)
+                else:  # Nur Zeit-Format
+                    today = now.date()
+                    time_part = datetime.strptime(last_activity_str, '%H:%M').time()
+                    last_activity_time = datetime.combine(today, time_part)
+                    
+                if (now - last_activity_time).total_seconds() > SESSION_LIFETIME.total_seconds():
                     app_logger.info(f"Session abgelaufen für Benutzer {current_user.id}")
                     logout_user()
                     return redirect(url_for('auth.login'))
-            except:
-                pass
+            except Exception as e:
+                app_logger.warning(f"Fehler beim Parsen der Session-Zeit: {e}")
         
-        # Aktivität aktualisieren
-        session['last_activity'] = datetime.now().isoformat()
+        # Optimierte Session-Aktivität aktualisieren - nur Zeit statt volles ISO-Format
+        session['last_activity'] = now.strftime('%H:%M')
         session.permanent = True
 
 # ===== HAUPTROUTEN =====