Adding of the detailed module

.docker-build.env

@@ -8,5 +8,4 @@ INVENTAR_APP_MEM_SWAP_LIMIT=768m
 INVENTAR_WORKERS=4
 INVENTAR_THREADS=2
 INVENTAR_WORKER_TIMEOUT=30
-INVENTAR_WORKER_CONNECTIONS=100
-
+INVENTAR_WORKER_CONNECTIONS=100

.docker-compose.runtime.override.yml

@@ -1,5 +1,7 @@
 services:
   app:
+    working_dir: /app/Web
+    command: ["gunicorn", "app:app", "--bind", "0.0.0.0:8000", "--workers", "4", "--threads", "2", "--timeout", "30", "--graceful-timeout", "20", "--worker-connections", "100", "--max-requests", "1000", "--max-requests-jitter", "100", "--log-level", "info", "--access-logfile", "-", "--error-logfile", "-"]
     image: ghcr.io/aiirondev/legendary-octo-garbanzo:v0.7.42
     build: null
     ports:

README.md

@@ -556,6 +556,14 @@ sudo chmod 644 certs/inventarsystem.crt
 
 ## Fehlerbehebung
 
+### Logs Auslesen
+
+```bash
+docker logs inventarsystem-app-1
+docker exec inventarsystem-app-1 cat /data/logs/application.log | tail -n 100
+docker compose exec mongodb mongosh
+```
+
 ### Webserver startet nicht
 
 ```bash

Web/modules/database/ausleihung.py

@@ -1235,5 +1235,5 @@ def reset_item_completely(item_id):
     except Exception as e:
         return {
             'success': False,
-            'message': f'Fehler beim Zurücksetzen: {str(e)}'
+            'message': f'Fehler beim Zurücksetzen.'
         }

Web/modules/database/items.py

@@ -24,7 +24,7 @@ import Web.modules.database.settings as cfg
 from Web.modules.database.settings import MongoClient
 
 
-LIBRARY_ITEM_TYPES = ('book', 'cd', 'dvd', 'media')
+LIBRARY_ITEM_TYPES = ('book', 'cd', 'dvd', 'media', 'schulbuch')
 
 
 def _non_library_query(extra_query=None):

Web/modules/database/settings.py

@@ -284,7 +284,6 @@ def _match_inventory(path):
     if path == '/' or path.startswith('/home'): return True
     return path.startswith(('/scanner', '/inventory', '/upload_admin', '/manage_filters', '/manage_locations', '/admin_borrowings', '/admin_damaged_items', '/admin/borrowings', '/admin/damaged_items'))
 
-
 def _match_terminplan(path):
     if not path:
         return False
@@ -292,7 +291,7 @@ def _match_terminplan(path):
 
 def _match_library(path):
     if not path: return False
-    return path.startswith(('/library', '/library_', '/student_cards'))
+    return path.startswith(('/library', '/library_', '/student_cards', '/admin_damaged_items', '/admin_borrowings', '/admin/library'))
 
 def _match_student_cards(path):
     if not path: return False

Web/modules/database/termine.py

@@ -18,9 +18,11 @@ Collection Structure:
   - Status fields: slots_used_by
 """
 import Web.modules.database.settings as cfg
+import Web.modules.inventarsystem.data_protection as dp
 from Web.modules.database.settings import MongoClient
 from bson.objectid import ObjectId
 import datetime 
+import ast
 
 
 def _get_tenant_db(client):
@@ -37,8 +39,47 @@ def _active_record_query(extra_query=None):
         base_query.update(extra_query)
     return base_query
 
+def _decrypt_appointment(item):
+    """Helper function to safely decrypt appointment fields back to their original types."""
+    if not item:
+        return item
+    
+    try:
+        if 'user' in item and item['user']:
+            item['user'] = dp.decrypt_text(item['user'])
+        
+        if 'note' in item and item['note']:
+            item['note'] = dp.decrypt_text(item['note'])
+            
+        if 'title' in item and item['title']:
+            item['title'] = dp.decrypt_text(item['title'])
+            
+        if 'mail' in item and item['mail']:
+            decrypted_mail = dp.decrypt_text(item['mail'])
+            try:
+                item['mail'] = ast.literal_eval(decrypted_mail)
+            except Exception:
+                item['mail'] = decrypted_mail
 
-def add(date_start: str, date_end: str, time_span: list, slots: int, slot_lenght: int, user: str, mail: list=[], note:str="", calendar_enabled: bool=False):
+        if 'custom_fields' in item and item['custom_fields']:
+            item['custom_fields'] = [dp.decrypt_text(field) for field in item['custom_fields']]
+
+        if 'slots_booked' in item and item['slots_booked']:
+            # If it's a string, it was encrypted during an update execution
+            if isinstance(item['slots_booked'], str):
+                decrypted_slots = dp.decrypt_text(item['slots_booked'])
+                try:
+                    item['slots_booked'] = ast.literal_eval(decrypted_slots)
+                except Exception:
+                    item['slots_booked'] = decrypted_slots
+    except Exception as e:
+        print(f"Error during decryption: {e}")
+        
+    return item
+
+
+def add(date_start: str, date_end: str, time_span: list, slots: int, slot_lenght: int, user: str, mail: list=[], note:str="", calendar_enabled: bool=False, title: str="", custom_fields: list = (), clients_p_slot: int=1):
+    client = None
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = _get_tenant_db(client)
@@ -50,59 +91,53 @@ def add(date_start: str, date_end: str, time_span: list, slots: int, slot_lenght
             'time_span': time_span,
             'slots': slots,
             'slot_lenght': slot_lenght,
-            'user': user,
-            'mail': mail,
-            'note': note,
+            'user': dp.encrypt_text(user.strip()),
+            'mail': dp.encrypt_text(str(mail)),
+            'note': dp.encrypt_text(note),
+            'title': dp.encrypt_text(title),
+            'custom_fields': [dp.encrypt_text(str(field)) for field in custom_fields],
             'calendar_enabled': bool(calendar_enabled),
-            'slots_booked': [], # -> [(start_time, name), ...]the list gets there indexes as the slot 1-defined so is can be counted without an extra variable
+            'clients_per_slot': clients_p_slot,
+            'slots_booked': [],  # -> [(start_time, (names),(custom1, custom2,...)), ...]the list gets there indexes as the slot 1-defined so is can be counted without an extra variable
             'Created': datetime.datetime.now(),
             'LastUpdated': datetime.datetime.now()
         }
         result = items.insert_one(item)
         return result.inserted_id
     except Exception as e:
-        print(f"Exception accured: {e}")
-
+        print(f"Exception occurred in add: {e}")
+        return None
+    finally:
+        if client:
+            client.close()
 
 def get_item(id):
-    """
-    Retrieve a specific appointment by its ID.
-    
-    Args:
-        id (str): ID of the appointsment to retrieve
-        
-    Returns:
-        dict: The appointment document or None if not found
-    """
+    """Retrieve a specific appointment by its ID and decrypt it."""
+    client = None
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = _get_tenant_db(client)
         items = db['appointments']
         item = items.find_one(_active_record_query({'_id': ObjectId(id)}))
-        client.close()
-        return item
+        
+        return _decrypt_appointment(item)
     except Exception as e:
         print(f"Error retrieving item: {e}")
         return None
+    finally:
+        if client:
+            client.close()
 
-def update(id,slots_used: list):
-    """
-    Update an existing appointment.
-    
-    Args:
-        id (str): ID of the item to update
-        
-        
-    Returns:
-        bool: True if successful, False otherwise
-    """
+def update(id, slots_used: list):
+    """Update an existing appointment's booked slots securely."""
+    client = None
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = _get_tenant_db(client)
         items = db['appointments']
 
         update_data = {
-            'slots_booked': slots_used,
+            'slots_booked': dp.encrypt_text(str(slots_used)),
             'LastUpdated': datetime.datetime.now()
         }
 
@@ -111,53 +146,81 @@ def update(id,slots_used: list):
             {'$set': update_data}
         )
 
-        client.close()
         return result.modified_count > 0
     except Exception as e:
         print(f"Error updating item: {e}")
         return False
-
+    finally:
+        if client:
+            client.close()
 
 def remove_slot(id, date_start_time, name):
     """
-    Remove a booked slot from an appointment's `slots_booked`.
-
-    Args:
-        id (str): Appointment ID
-        date_start_time: The start time value used when booking
-        name (str): Name associated with the booking
-
-    Returns:
-        bool: True if a slot was removed, False otherwise
+    Remove a booked slot from an appointment's encrypted `slots_booked` list.
+    
+    Because the array is stored as an encrypted string blob, we must decrypt, 
+    modify it in Python, and re-encrypt it.
     """
+    client = None
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = _get_tenant_db(client)
         items = db['appointments']
 
-        # Attempt to pull the exact element (stored as an array/tuple)
+        item = items.find_one({'_id': ObjectId(id)})
+        if not item or 'slots_booked' not in item or not item['slots_booked']:
+            return False
+
+        try:
+            decrypted_slots = dp.decrypt_text(item['slots_booked'])
+            slots_list = ast.literal_eval(decrypted_slots)
+        except Exception as e:
+            print(f"Failed to decrypt or parse slots: {e}")
+            return False
+
+        # Structure format note: [(start_time, (names), (custom1, custom2...)), ...]
+        updated_slots = []
+        removed_any = False
+        
+        for slot in slots_list:
+            slot_start = slot[0]
+            slot_names = slot[1]
+            
+
+            if slot_start == date_start_time and (slot_names == name or name in slot_names):
+                removed_any = True
+                continue 
+            updated_slots.append(slot)
+
+        if not removed_any:
+            return False 
+
         result = items.update_one(
             {'_id': ObjectId(id)},
-            {'$pull': {'slots_booked': [date_start_time, name]}}
+            {
+                '$set': {
+                    'slots_booked': dp.encrypt_text(str(updated_slots)),
+                    'LastUpdated': datetime.datetime.now()
+                }
+            }
         )
 
-        client.close()
         return result.modified_count > 0
     except Exception as e:
         print(f"Error removing slot: {e}")
         return False
+    finally:
+        if client:
+            client.close()
 
 
 def remove(id):
     """
-    Soft-delete an appointment by setting its `Deleted` flag.
-
-    Args:
-        id (str): Appointment ID
-
-    Returns:
-        bool: True if the appointment was marked deleted, False otherwise
+    Hard-delete an appointment plan by its ID.
+    (Note: If your docstring mentions a soft-delete 'Deleted' flag, 
+    change items.delete_one to items.update_one with {'$set': {'Deleted': True}})
     """
+    client = None
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = _get_tenant_db(client)
@@ -165,70 +228,87 @@ def remove(id):
 
         result = items.delete_one({'_id': ObjectId(id)})
 
-        client.close()
         return result.deleted_count > 0
     except Exception as e:
         print(f"Error removing appointment: {e}")
         return False
+    finally:
+        if client:
+            client.close()
+
 
 def remove_done():
-    """removose already finisched appointments"""
+    """Remove all expired appointments whose end date is prior to today in a single call."""
+    client = None
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = _get_tenant_db(client)
         items = db['appointments']
 
         today = datetime.date.today().strftime('%Y-%m-%d')
-        removed_count = 0
 
-        cursor = items.find(
+        result = items.delete_many(
             _active_record_query(
                 {
                     'date_end': {'$lt': today},
                 }
             )
-        ).sort('date_start', 1)
+        )
 
-        for item in cursor:
-            item['_id'] = str(item.get('_id'))
-            result = items.delete_one({'_id': ObjectId(item['_id'])})
-            removed_count += result.deleted_count
-        
-        client.close()
-        return removed_count > 0
+        return result.deleted_count > 0
     except Exception as e:
-        print(f"Error removing appointment: {e}")
+        print(f"Error cleaning up finished appointments: {e}")
         return False
+    finally:
+        if client:
+            client.close()
+
 
 def get_upcoming_for_user(user: str, limit: int = 25):
-    """Return upcoming appointment plans for a user ordered by start date."""
-    remove_done()
+    """
+    Return upcoming appointment plans for a user, handling encrypted database records.
+    """
+    try:
+        if hasattr(globals(), 'remove_done'):
+            remove_done()
+    except Exception:
+        pass
+
+    client = None
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = _get_tenant_db(client)
         items = db['appointments']
 
         today = datetime.date.today().strftime('%Y-%m-%d')
+        target_user = str(user or '').strip()
+
         cursor = items.find(
-            _active_record_query(
-                {
-                    'user': str(user or '').strip(),
-                    'date_end': {'$gte': today},
-                }
-            )
+            _active_record_query({
+                'date_end': {'$gte': today},
+            })
         ).sort('date_start', 1)
 
         results = []
         for item in cursor:
-            item['_id'] = str(item.get('_id'))
-            results.append(item)
+            decrypted_item = _decrypt_appointment(item)
+            if not decrypted_item:
+                continue
+
+            if decrypted_item.get('user', '').strip() != target_user:
+                continue
+
+            decrypted_item['_id'] = str(decrypted_item.get('_id'))
+            results.append(decrypted_item)
+            
             if len(results) >= max(1, int(limit)):
                 break
 
-        client.close()
         return results
     except Exception as e:
         print(f"Error retrieving upcoming appointments: {e}")
         return []
+    finally:
+        if client:
+            client.close()
 
- 

Web/modules/database/user.py

@@ -20,6 +20,8 @@ import string
 from bson.objectid import ObjectId
 import Web.modules.database.settings as cfg
 from Web.modules.database.settings import MongoClient
+import hmac
+import os
 
 logger = logging.getLogger('app')
 logger.setLevel(logging.DEBUG)
@@ -430,103 +432,84 @@ def check_password_strength(password):
     return True
 
 
-def hashing(password):
+def hashing(password, salt=None):
     """
-    Hash a password using SHA-512.
+    Hasht ein Passwort mit scrypt. 
+    - Wenn kein Salt übergeben wird, wird ein sicherer, zufälliger Salt generiert (für neue Passwörter).
+    - Format für neue Hashes: v1$<salt_hex>$<hash_hex>
+    """
+    password_bytes = password.encode('utf-8') # Explizit UTF-8 für Plattformunabhängigkeit
     
-    Args:
-        password (str): Password to hash
-        
-    Returns:
-        str: Hexadecimal digest of the hashed password
+    if salt is None:
+        # Neuer Benutzer / Passwortänderung -> Dynamischer Salt
+        random_salt = os.urandom(16)
+        hashed = hashlib.scrypt(password_bytes, salt=random_salt, n=16384, r=8, p=1)
+        return f"v1${random_salt.hex()}${hashed.hex()}"
+    else:
+        # Bestehender Benutzer (wird zur Verifizierung aufgerufen)
+        hashed = hashlib.scrypt(password_bytes, salt=salt, n=16384, r=8, p=1)
+        return hashed.hex()
+
+
+def verify_password(provided_password, stored_password_string):
     """
-    return hashlib.sha512(password.encode()).hexdigest()
+    Verifiziert ein Passwort gegen einen gespeicherten Hash-String.
+    Unterstützt das alte Format (statischer Salt) und das neue Format (v1$...).
+    """
+    if not stored_password_string:
+        return False
+
+    # Überprüfung für das neue, sichere Format
+    if stored_password_string.startswith("v1$"):
+        try:
+            _, salt_hex, hash_hex = stored_password_string.split("$")
+            salt_bytes = bytes.fromhex(salt_hex)
+            # Berechne den Hash des eingegebenen Passworts mit dem extrahierten Salt
+            calculated_hash = hashing(provided_password, salt=salt_bytes)
+            # Timing-Attack-sicherer Vergleich
+            return hmac.compare_digest(calculated_hash, hash_hex)
+        except (ValueError, TypeError):
+            logger.error("Ungültiges Hash-Format in der Datenbank entdeckt.")
+            return False
+    else:
+        # Abwärtskompatibilität: Altes Format mit statischem Salt b'some_salt'
+        old_static_salt = b'some_salt'
+        calculated_hash = hashing(provided_password, salt=old_static_salt)
+        return hmac.compare_digest(calculated_hash, stored_password_string)
 
 
 def check_nm_pwd(username, password):
     """
-    Verify username and password combination.
-    
-    Args:
-        username (str): Username to check
-        password (str): Password to verify
-        
-    Returns:
-        dict: User document if credentials are valid, None otherwise
+    Überprüft die Kombination aus Benutzername und Passwort (optimiert).
     """
     db_name, tenant_id = _resolve_request_tenant_db()
-    ctx = None
-    try:
-        from tenant import get_tenant_context
-        ctx = get_tenant_context()
-    except Exception:
-        ctx = None
-
     if not db_name:
         if _has_tenant_configs():
-            logger.warning(
-                "Refusing default DB fallback for login because tenant configs exist and no tenant was resolved."
-            )
+            logger.warning("Default DB fallback verweigert, da Tenant-Konfigurationen existieren.")
             return None
         db_name = cfg.MONGODB_DB
 
-    logger.info(
-        "check_nm_pwd start: username=%r tenant=%r db=%r host=%r port=%r uri=%r",
-        username,
-        tenant_id,
-        db_name,
-        cfg.MONGODB_HOST,
-        cfg.MONGODB_PORT,
-        getattr(cfg, 'MONGODB_URI', None),
-    )
-
     client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
     try:
-        hashed_password = hashing(password)
-        logger.info("check_nm_pwd password hash for username=%r: %s", username, hashed_password)
-        available_dbs = []
-        try:
-            available_dbs = client.list_database_names()
-            logger.debug("MongoDB connected. Available databases=%s", available_dbs)
-        except Exception as exc:
-            logger.exception("Unable to list MongoDB databases: %s", exc)
-
         db = client[db_name]
-        try:
-            existing_collections = db.list_collection_names()
-        except Exception as exc:
-            logger.exception("Unable to list collections for db=%r: %s", db_name, exc)
-            existing_collections = []
-        logger.debug("Tenant db=%r collections=%s", db_name, existing_collections)
-
         users = db['users']
+        
         query = {'$or': [{'Username': username}, {'username': username}]}
-        logger.debug("Running user lookup on %r: %s", db_name, query)
         user_record = users.find_one(query)
 
         if user_record is None:
-            logger.warning("No user document found in db=%r for username=%r", db_name, username)
-            if db_name not in available_dbs:
-                logger.warning("Tenant database %r is missing from available MongoDB databases", db_name)
-            if 'users' not in existing_collections:
-                logger.warning("Tenant database %r has no users collection", db_name)
+            logger.warning("Kein Benutzer für %r in DB %r gefunden.", username, db_name)
             return None
 
-        logger.info("Found user document for username=%r in db=%r: %s", username, db_name, user_record)
         stored_password = user_record.get('Password') or user_record.get('password')
-        if stored_password is None:
-            logger.warning("User document for username=%r in db=%r has no password field", username, db_name)
+        
+        if not verify_password(password, stored_password):
+            logger.warning("Falsches Passwort für Benutzer %r in DB %r.", username, db_name)
             return None
 
-        if stored_password != hashed_password:
-            logger.warning(
-                "Password mismatch for username=%r in db=%r: provided_hash=%s stored_hash=%s",
-                username,
-                db_name,
-                hashed_password,
-                stored_password,
-            )
-            return None
+        # Automatische Migration alter Hashes auf das neue Format
+        if not stored_password.startswith("v1$"):
+            users.update_one({'_id': user_record['_id']}, {'$set': {'Password': hashing(password)}})
 
         return user_record
     finally:
@@ -556,44 +539,46 @@ def add_user(
         bool: True if user was added successfully, False if password was too weak
     """
     client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
-    db = _get_tenant_db(client)
-    users = db['users']
-    if not check_password_strength(password):
-        return False
-    permission_defaults = build_default_permission_payload(permission_preset)
-    if isinstance(action_permissions, dict):
-        for key, value in action_permissions.items():
-            permission_defaults['actions'][str(key)] = bool(value)
-    if isinstance(page_permissions, dict):
-        for key, value in page_permissions.items():
-            permission_defaults['pages'][str(key)] = bool(value)
+    try:
+        db = _get_tenant_db(client)
+        users = db['users']
+        if not check_password_strength(password):
+            return False
+        permission_defaults = build_default_permission_payload(permission_preset)
+        if isinstance(action_permissions, dict):
+            for key, value in action_permissions.items():
+                permission_defaults['actions'][str(key)] = bool(value)
+        if isinstance(page_permissions, dict):
+            for key, value in page_permissions.items():
+                permission_defaults['pages'][str(key)] = bool(value)
 
-    user_doc = {
-        'Username': username,
-        'Password': hashing(password),
-        'Admin': False,
-        'active_ausleihung': None,
-        'name': name.strip() if name else '',
-        'last_name': last_name.strip() if last_name else '',
-        'IsStudent': bool(is_student),
-        'PermissionPreset': permission_defaults['preset'],
-        'ActionPermissions': permission_defaults['actions'],
-        'PagePermissions': permission_defaults['pages'],
-    }
+        user_doc = {
+            'Username': username,
+            'Password': hashing(password),
+            'Admin': False,
+            'active_ausleihung': None,
+            'name': name.strip() if name else '',
+            'last_name': last_name.strip() if last_name else '',
+            'IsStudent': bool(is_student),
+            'PermissionPreset': permission_defaults['preset'],
+            'ActionPermissions': permission_defaults['actions'],
+            'PagePermissions': permission_defaults['pages'],
+        }
 
-    normalized_card = normalize_student_card_id(student_card_id)
-    if bool(is_student):
-        if normalized_card:
-            user_doc['StudentCardId'] = normalized_card
-        if max_borrow_days is not None:
-            try:
-                user_doc['MaxBorrowDays'] = int(max_borrow_days)
-            except (TypeError, ValueError):
-                pass
+        normalized_card = normalize_student_card_id(student_card_id)
+        if bool(is_student):
+            if normalized_card:
+                user_doc['StudentCardId'] = normalized_card
+            if max_borrow_days is not None:
+                try:
+                    user_doc['MaxBorrowDays'] = int(max_borrow_days)
+                except (TypeError, ValueError):
+                    pass
 
-    users.insert_one(user_doc)
-    client.close()
-    return True
+        users.insert_one(user_doc)
+        return True
+    finally:
+        client.close()
 
 
 def student_card_exists(student_card_id):

Web/modules/emailservice/email.py

@@ -1,5 +1,6 @@
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
+from modules.module_registry import ModuleRegistry as mr
 import smtplib
 
 import Web.modules.database.settings as cfg
@@ -27,21 +28,24 @@ def send(email: list, subject: str, note: str, sender: str) -> bool:
   Output:
   - bool: true if the sending worked and false if it didnt
   """
-  msg = MIMEMultipart()
-  msg['Subject'] = subject
-  msg['From'] = sender or cfg.EMAIL_FROM_ADDRESS or cfg.EMAIL_USERNAME
-  msg['To'] = ', '.join(email) if isinstance(email, (list, tuple)) else str(email)
-  msg.attach(MIMEText(note))
-  smtp = None
-  try:
-    smtp = _build_smtp_client()
-    smtp.sendmail(from_addr=msg['From'], to_addrs=email, msg=msg.as_string())
-    return True
-  except Exception:
+  if not mr.registry.is_enabled('mail'):
     return False
-  finally:
+  else:
+    msg = MIMEMultipart()
+    msg['Subject'] = subject
+    msg['From'] = sender or cfg.EMAIL_FROM_ADDRESS or cfg.EMAIL_USERNAME
+    msg['To'] = ', '.join(email) if isinstance(email, (list, tuple)) else str(email)
+    msg.attach(MIMEText(note))
+    smtp = None
     try:
-      if smtp:
-        smtp.quit()
+      smtp = _build_smtp_client()
+      smtp.sendmail(from_addr=msg['From'], to_addrs=email, msg=msg.as_string())
+      return True
     except Exception:
-      pass
+      return False
+    finally:
+      try:
+        if smtp:
+          smtp.quit()
+      except Exception:
+        pass

Web/modules/log/audit_log.py

@@ -10,6 +10,7 @@ import hashlib
 import json
 import random
 import time
+from Web.modules.inventarsystem.data_protection import encrypt_document_fields, decrypt_document_fields
 
 from pymongo.errors import DuplicateKeyError
 
@@ -24,21 +25,34 @@ def _entry_hash(prev_hash, payload):
     base = f"{prev_hash}|{_stable_json(payload)}"
     return hashlib.sha256(base.encode("utf-8")).hexdigest()
 
-
-def append_audit_event(db, event_type, actor, payload, request_ip=None, source="web", max_retries=5):
+def get_decrypted_audit_logs(db, query=None, decrypt_fields=None):
     """
-    Append an audit event to a tamper-evident chain.
-
+    Retrieve and decrypt audit logs for analysis.
+    
     Args:
-        db: MongoDB database handle.
-        event_type (str): Event category.
-        actor (str): User/system who performed the action.
-        payload (dict): Event details.
-        request_ip (str, optional): Request origin.
-        source (str): Source subsystem.
+        query (dict): MongoDB query filter.
+        decrypt_fields (list): Fields within the 'payload' that should be decrypted.
+    """
+    logs = db["audit_log"]
+    cursor = logs.find(query or {}).sort("chain_index", 1)
+    
+    results = []
+    for entry in cursor:
+        # Decrypt specific fields if provided
+        if decrypt_fields:
+            decrypt_document_fields(entry.get("payload", {}), decrypt_fields)
+        results.append(entry)
+        
+    return results
 
-    Returns:
-        dict: Inserted audit entry.
+
+def append_audit_event(db, event_type, actor, payload, request_ip=None, source="web", max_retries=5, encrypt_fields=None):
+    """
+    Append an audit event, optionally encrypting specific payload fields.
+    
+    Args:
+        ...
+        encrypt_fields (list, optional): List of keys in 'payload' to encrypt.
     """
     logs = db["audit_log"]
     attempts = 0
@@ -49,15 +63,24 @@ def append_audit_event(db, event_type, actor, payload, request_ip=None, source="
         chain_index = int(previous.get("chain_index", 0)) + 1 if previous else 1
 
         timestamp = datetime.datetime.utcnow()
+        
+        # 1. Create the payload dictionary
+        event_payload = payload or {}
+        
+        # 2. Encrypt sensitive fields in-place if requested
+        if encrypt_fields:
+            encrypt_document_fields(event_payload, encrypt_fields)
+
         entry_payload = {
             "event_type": event_type,
             "actor": actor or "system",
             "source": source,
             "ip": request_ip or "",
-            "payload": payload or {},
+            "payload": event_payload,
             "timestamp": timestamp.isoformat() + "Z",
         }
 
+        # 3. Hash the payload (which now contains encrypted values)
         entry_hash = _entry_hash(prev_hash, entry_payload)
 
         entry = {

Web/modules/log/ausleihung_log.py

@@ -21,7 +21,7 @@ def log_status_change(ausleihung_id, old_status, new_status, user=None):
         ausleihung_id: Die ID der Ausleihung
         old_status: Der alte Status
         new_status: Der neue Status
-        user: Der Benutzer, der die Änderung vorgenommen hat (optional)
+
     """
     try:
         # Erstelle Log-Verzeichnis, falls es nicht existiert
@@ -34,10 +34,9 @@ def log_status_change(ausleihung_id, old_status, new_status, user=None):
         
         # Protokolliere die Änderung
         timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-        user_info = f" by {user}" if user else ""
         
         with open(log_file, 'a', encoding='utf-8') as f:
-            f.write(f"{timestamp}: Ausleihung {ausleihung_id} - Status changed from '{old_status}' to '{new_status}'{user_info}\n")
+            f.write(f"{timestamp}: Ausleihung {ausleihung_id} - Status changed from '{old_status}' to '{new_status}'\n")
             
         return True
     except Exception as e:

Web/modules/terminplaner/backend_server.py

@@ -8,6 +8,7 @@ import Web.modules.emailservice.email as mail_service
 import Web.modules.database.termine as termin
 import Web.modules.database.settings as cfg
 from Web.tenant import get_tenant_context
+import Web.modules.inventarsystem.data_protection as dp
 
 
 def _resolve_public_base_url() -> str:
@@ -82,6 +83,7 @@ def build_calendar_ics(appointment_id: str) -> str | None:
     time_span = item.get('time_span', []) or []
     creator = item.get('user', 'Terminplaner')
     note = item.get('note', '') or ''
+    titel = item.get('title', '') or ''
     tenant_id = _current_tenant_id()
     try:
         link = url_for('terminplaner.client', appointment_id=str(appointment_id), tenant=tenant_id or None, _external=True)
@@ -98,8 +100,11 @@ def build_calendar_ics(appointment_id: str) -> str | None:
         return None
 
     uid = f"terminplaner-{appointment_id}@invario.eu"
-    created_at = datetime.datetime.utcnow().strftime('%Y%m%dT%H%M%SZ')
-    summary = f"Terminplan für {creator}"
+    
+    created_at = datetime.datetime.now(datetime.timezone.utc).strftime('%Y%m%dT%H%M%SZ')
+    
+    summary = titel if titel else f"Terminplan für {creator}"
+    
     description_lines = [
         f"Buchungslink: {link}",
         f"Zeitraum: {date_start} bis {date_end}",
@@ -108,6 +113,8 @@ def build_calendar_ics(appointment_id: str) -> str | None:
         description_lines.append('Zeitfenster: ' + '; '.join(str(entry) for entry in time_span))
     if note:
         description_lines.append('Notiz: ' + str(note))
+    if titel and not summary == titel: 
+        description_lines.append('Titel: ' + str(titel))
 
     ics_lines = [
         'BEGIN:VCALENDAR',
@@ -122,7 +129,7 @@ def build_calendar_ics(appointment_id: str) -> str | None:
         f'DESCRIPTION:{_escape_ics_text(chr(10).join(description_lines))}',
         f'URL:{_escape_ics_text(link)}',
         f'DTSTART;VALUE=DATE:{_format_ics_date(start_date)}',
-        f'DTEND;VALUE=DATE:{_format_ics_date(end_date + timedelta(days=1))}',
+        f'DTEND;VALUE=DATE:{_format_ics_date(end_date + datetime.timedelta(days=1))}',
         'END:VEVENT',
         'END:VCALENDAR',
         '',
@@ -142,9 +149,10 @@ def build_client_slot_ics(appointment_id: str, slot_start: str, client_name: str
         return None
 
     try:
-        slot_minutes = int(item.get('slot_lenght') or 0)
+        slot_minutes = int(item.get('slot_length') or item.get('slot_lenght') or 0)
     except Exception:
         slot_minutes = 0
+        
     if slot_minutes <= 0:
         slot_minutes = 45
 
@@ -159,7 +167,7 @@ def build_client_slot_ics(appointment_id: str, slot_start: str, client_name: str
         if tenant_id:
             link += f'?tenant={tenant_id}'
 
-    title_name = str(client_name or '').strip() or 'Termin'
+    title_name = item.get('title') or f"Terminbuchung mit {client_name}" if client_name else "Terminbuchung"
     summary = f"{title_name} - Terminbuchung"
     description_lines = [
         f"Buchungslink: {link}",
@@ -167,7 +175,7 @@ def build_client_slot_ics(appointment_id: str, slot_start: str, client_name: str
     ]
 
     uid = f"terminplaner-slot-{appointment_id}-{start_dt.strftime('%Y%m%d%H%M')}@invario.eu"
-    created_at = datetime.datetime.utcnow().strftime('%Y%m%dT%H%M%SZ')
+    created_at = datetime.datetime.now(datetime.timezone.utc).strftime('%Y%m%dT%H%M%SZ')
     dt_start = start_dt.strftime('%Y%m%dT%H%M%S')
     dt_end = end_dt.strftime('%Y%m%dT%H%M%S')
 
@@ -185,6 +193,7 @@ def build_client_slot_ics(appointment_id: str, slot_start: str, client_name: str
         f'URL:{_escape_ics_text(link)}',
         f'DTSTART:{dt_start}',
         f'DTEND:{dt_end}',
+        f'Titel:{_escape_ics_text(summary)}',
         'END:VEVENT',
         'END:VCALENDAR',
         '',
@@ -192,23 +201,29 @@ def build_client_slot_ics(appointment_id: str, slot_start: str, client_name: str
     return '\r\n'.join(ics_lines)
 
 
-def new(date_start: str, date_end: str, time_span: list, slots: int, slot_lenght: int, user: str, mail: list=[], note:str="", calendar_enabled: bool=False) -> dict:
+def new(date_start: str, date_end: str, time_span: list, slots, slot_length, user: str, mail: list=None, note:str="", calendar_enabled: bool=False, title: str="", custom_fields: list = (), clients_per_slot: int=1) -> dict:
     """
     Generates a link for the executive to send to his clients to book a time Slot
-    
-    Input:
-    - date_start: start of the time frae area
-    - date_end: end of the time frame area
-    - time_span: Time window for the days as a list [(first day Time Frame), (second day Time frame), (third etc.)]
-    - slots: amount of slots that are available
-    - slot_lenght: the lenght of a slot in minutes
-
-    Output:
-    - link: The link for the user to send to the clients
     """
+    try:
+        slots_int = int(slots)
+    except (ValueError, TypeError):
+        slots_int = 0
+        
+    try:
+        custom_fields.pop(-1)
+    except :
+        pass
+
+    try:
+        slot_length_int = int(slot_length)
+    except (ValueError, TypeError):
+        slot_length_int = 45
+
     normalized_time_span = _normalize_time_span(time_span)
-    normalized_mail = _normalize_mail_list(mail)
-    id = termin.add(date_start, date_end, normalized_time_span, slots, slot_lenght, user, normalized_mail, note, calendar_enabled=calendar_enabled)
+    normalized_mail = _normalize_mail_list(mail or [])
+    
+    id = termin.add(date_start, date_end, normalized_time_span, slots_int, slot_length_int, user, normalized_mail, note, calendar_enabled=calendar_enabled, title=title, custom_fields=custom_fields, clients_p_slot=clients_per_slot)
     id_str = str(id)
     tenant_id = _current_tenant_id()
 
@@ -219,9 +234,11 @@ def new(date_start: str, date_end: str, time_span: list, slots: int, slot_lenght
         link = host + "/terminplaner/client/" + id_str
         if tenant_id:
             link += f"?tenant={tenant_id}"
-    subject = f"Terminanfrage von {user}"
+            
+    subject = f"{title} - Bitte Termin vereinbaren" if title else f"Terminanfrage von {user} - Bitte Termin vereinbaren"
     note_link = note + f"Bitte klicken sie auf den folgenden Link um einen Termin zu vereinbaren: {link}"
     calendar_link = None
+    
     if calendar_enabled:
         try:
             calendar_link = url_for('terminplaner.calendar_export', appointment_id=id_str, tenant=tenant_id or None, _external=True)
@@ -245,20 +262,8 @@ def new(date_start: str, date_end: str, time_span: list, slots: int, slot_lenght
     }
     
         
-def book_slot(id, date_start_time, name):
-    """
-    Updates slot for the booking per a id
-
-    Input:
-    - id: the id is the id you get from the
-    - date_start_time: the date of the booking that was selected with date and time
-    - name: name that the client gave himself
-    
-    Output:
-    - bool: if worked or not
-    """
+def book_slot(id, date_start_time, name, custom: tuple = ()):
     try:
-        # Retrieve the current appointment
         item = termin.get_item(id)
         if not item:
             return False
@@ -267,40 +272,44 @@ def book_slot(id, date_start_time, name):
         if not isinstance(slots, list):
             slots = []
 
+        # 1. Check overall total booking capacity 
         capacity = int(item.get('slots', 0) or 0)
         if capacity and len(slots) >= capacity:
             return False
 
+        # 2. Prevent the exact same user from double-booking the exact same slot
         for existing in slots:
             if isinstance(existing, (list, tuple)) and len(existing) >= 2:
                 if existing[0] == date_start_time and existing[1] == name:
                     return False
 
-        # Append the new booking as a tuple (start_time, name)
-        slots.append((date_start_time, name))
+        # 3. Check concurrent capacity for this specific time slot
+        clients_per_slot = int(item.get('clients_per_slot', 1) or 1)
+        bookings_at_time = sum(
+            1 for existing in slots 
+            if isinstance(existing, (list, tuple)) and len(existing) > 0 and existing[0] == date_start_time
+        )
+        
+        if bookings_at_time >= clients_per_slot:
+            return False
 
-        # Update the appointment in the database
+        # Append the new booking successfully
+        slots.append((date_start_time, name, custom))
         success = termin.update(id, slots)
         return bool(success)
+        
     except Exception as e:
         print(f"Error booking slot: {e}")
         return False
 
 
 def remove_slot(id, date_start_time, name):
-    """
-    Remove a booked slot for an appointment.
-
-    Returns True if the removal succeeded, False otherwise.
-    """
     try:
-        # Prefer DB-level remove if available
         if hasattr(termin, 'remove_slot'):
             removed = termin.remove_slot(id, date_start_time, name)
             if removed:
                 return True
 
-        # Fallback: fetch, filter, and replace the slot list
         item = termin.get_item(id)
         if not item:
             return False
@@ -309,7 +318,6 @@ def remove_slot(id, date_start_time, name):
         new_slots = []
         for s in slots:
             try:
-                # s may be list or tuple like [start_time, name]
                 if isinstance(s, (list, tuple)) and len(s) >= 2 and s[0] == date_start_time and s[1] == name:
                     continue
             except Exception:
@@ -324,9 +332,6 @@ def remove_slot(id, date_start_time, name):
 
 
 def remove_appointment(id):
-    """
-    Remove an entire appointment by id.
-    """
     try:
         return bool(termin.remove(id))
     except Exception as e:
@@ -334,17 +339,6 @@ def remove_appointment(id):
         return False
 
 def get_available(id):
-    """
-    Gets the available time slots -> more over it returns the time frame and the allready booked slots also the lenght.
-    And checks if there are slots left.
-
-    Input:
-    - id: id of the appointment
-
-    Output:
-    - dict: all the needet information -> [Start_date, End_date, (first day Time Frame, 
-    second day Time frame, third etc.), slot lenght, (bookedslots -> list)]
-    """
     try:
         termin_range = termin.get_item(id)
         if not termin_range:
@@ -353,67 +347,68 @@ def get_available(id):
         date_start = termin_range.get('date_start')
         date_end = termin_range.get('date_end')
         time_span = termin_range.get('time_span', [])
-        slot_lenght = termin_range.get('slot_lenght')
-        total_slots = termin_range.get('slots', 0)
-        # Ensure numeric fields are cast to int when stored as strings
+        
+        # Safe integer parsing without heavy try-except blocks
         try:
             total_slots = int(termin_range.get('slots', 0) or 0)
-        except Exception:
+        except (ValueError, TypeError):
             total_slots = 0
 
+        # Support both spellings gracefully
+        raw_length = termin_range.get('slot_length') or termin_range.get('slot_lenght') or 0
         try:
-            slot_lenght = int(termin_range.get('slot_lenght') or 0)
-        except Exception:
-            slot_lenght = termin_range.get('slot_lenght')
+            slot_length = int(raw_length)
+        except (ValueError, TypeError):
+            slot_length = raw_length
 
+        clients_per_slot = int(termin_range.get('clients_per_slot', 1) or 1)
         booked = termin_range.get('slots_booked', []) or []
 
-        # Normalize booked entries to dicts for easier consumption
+        # Normalize the bookings list safely
         normalized = []
+        bookings_by_time = {}  # Tracks how many people are in each specific time slot
+        
         for s in booked:
             if isinstance(s, (list, tuple)) and len(s) >= 2:
-                normalized.append({'start': s[0], 'name': s[1]})
+                slot_time = s[0]
+                item = {'start': slot_time, 'name': s[1]}
             elif isinstance(s, dict):
-                normalized.append(s)
+                slot_time = s.get('start')
+                item = s
             else:
-                normalized.append({'value': s})
+                slot_time = str(s)
+                item = {'value': s}
+                
+            normalized.append(item)
+            
+            # Count concurrent bookings per timestamp
+            if slot_time:
+                bookings_by_time[slot_time] = bookings_by_time.get(slot_time, 0) + 1
 
+        # Calculate remaining total capacity safely
         slots_used = len(normalized)
-        try:
-            slots_left = max(0, int(total_slots) - slots_used)
-        except Exception:
-            slots_left = max(0, slots_used - slots_used)
+        slots_left = max(0, total_slots - slots_used)
 
         return {
             'date_start': date_start,
             'date_end': date_end,
             'time_span': time_span,
-            'slot_lenght': slot_lenght,
+            'slot_length': slot_length,
+            'slot_lenght': slot_length,
             'slots_total': total_slots,
+            'clients_per_slot': clients_per_slot,
             'slots_booked': normalized,
             'slots_left': slots_left,
+            'bookings_by_time': bookings_by_time
         }
     except Exception as e:
         print(f"Error getting available slots: {e}")
         return {}
 
 def get_available_user(id):
-    """
-    Gets the available time slots -> more over it returns the time frame and the allready booked slots also the lenght.
-    And checks if there are slots left.
-
-    Input:
-    - id: id of the appointment
-
-    Output:
-    - dict: all the needet information -> [Start_date, End_date, (first day Time Frame, 
-    second day Time frame, third etc.), slot lenght, (bookedslots -> list)]
-    """
     return get_available(id)
 
-
 def get_user_upcoming_events(user: str, limit: int = 25) -> list[dict]:
-    """Return upcoming appointment plans for overview display."""
     user_name = str(user or '').strip()
     if not user_name:
         return []
@@ -459,6 +454,8 @@ def get_user_upcoming_events(user: str, limit: int = 25) -> list[dict]:
                 'note': str(item.get('note') or ''),
                 'link': link,
                 'calendar_link': calendar_link if item.get('calendar_enabled') else None,
+                'title': str(item.get('title') or ''),
+                'custom_fields': list(item.get('custom_fields')),
             }
         )
 

Web/modules/terminplaner/blueprint.py

@@ -1,14 +1,57 @@
-from flask import Blueprint, render_template, request, session, url_for, redirect, flash
-from flask import Response
+from flask import Blueprint, render_template, request, session, url_for, redirect, flash, make_response, Response, send_file
 import Web.modules.terminplaner.backend_server as appointment_service
 import Web.modules.database.settings as cfg
 import Web.modules.database.termine as termin
 import Web.modules.database.user as us
+from Web.modules.terminplaner.backend_server import _resolve_public_base_url
+import csv
+import io
+import qrcode
+import os
+import tempfile
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import cm
+from reportlab.lib.colors import grey, HexColor
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image
+
 
 # Create a blueprint instance
 appoint_bp = Blueprint('terminplaner', __name__)
 
 
+def _get_school_info_for_export():
+    """
+    Get school information for PDF exports from configuration or database.
+    Returns default info if not configured.
+    """
+    try:
+        if hasattr(cfg, 'get_school_info'):
+            return cfg.get_school_info()
+
+        school_info = {
+            'name': 'Schulname',
+            'address': 'Schuladresse',
+            'postal_code': 'PLZ',
+            'city': 'Stadt',
+            'school_number': '000000',
+            'it_admin': 'IT-Beauftragter/in',
+            'logo_path': '',
+        }
+        return school_info
+    except Exception:
+        # Return defaults if anything fails
+        return {
+            'name': 'Schulname',
+            'address': 'Schuladresse', 
+            'postal_code': 'PLZ',
+            'city': 'Stadt',
+            'school_number': '000000',
+            'it_admin': 'IT-Beauftragter/in',
+            'logo_path': '',
+        }
+
+
 def _require_module_enabled():
     if not cfg.MODULES.is_enabled('terminplan'):
         flash('Der Terminplaner ist deaktiviert.', 'info')
@@ -34,10 +77,70 @@ def _current_tenant_id():
         pass
     return str(session.get('tenant_id', '') or '').strip()
 
+@appoint_bp.route('/client/<appointment_id>/export_csv')
+def export_csv(appointment_id):
+    """
+    Generiert einen CSV-Export aller Buchungen für den Ersteller.
+    """
+    # 1. Berechtigungsprüfung (analog zur Client-Route)
+    current_user = str(session.get('username', '') or '').strip()
+    appointment_item = termin.get_item(appointment_id) or {}
+    appointment_owner = str(appointment_item.get('user', '') or '').strip()
+    
+    can_view = False
+    if current_user:
+        try:
+            can_view = bool(us.check_admin(current_user) or current_user == appointment_owner)
+        except Exception:
+            can_view = bool(current_user == appointment_owner)
+            
+    if not can_view:
+        flash('Nicht autorisiert für diesen Export.', 'error')
+        return redirect(url_for('terminplaner.client', appointment_id=appointment_id))
+
+    custom_fields = appointment_item.get('custom_fields', [])
+    bookings = appointment_item.get('slots_booked', []) or []
+
+    # 2. CSV im Speicher erstellen
+    si = io.StringIO()
+    # Wir nutzen ein Semikolon als Trennzeichen – das öffnet Excel im deutschsprachigen Raum direkt fehlerfrei
+    cw = csv.writer(si, delimiter=';', quoting=csv.QUOTE_MINIMAL)
+    
+    # Tabellenkopf schreiben
+    headers = ['Zeitpunkt', 'Name'] + list(custom_fields)
+    cw.writerow(headers)
+    
+    # Datenzeilen schreiben
+    for booking in bookings:
+        if isinstance(booking, (list, tuple)):
+            row = [booking[0], booking[1]]
+            
+            # Antworten holen und sicherstellen, dass Lücken (falls vorhanden) mit Leerstrings gefüllt werden
+            answers = booking[2] if len(booking) > 2 else []
+            for i in range(len(custom_fields)):
+                if i < len(answers):
+                    row.append(answers[i])
+                else:
+                    row.append('')
+            cw.writerow(row)
+
+    # 3. Response vorbereiten und UTF-8-BOM für Excel mitsenden
+    response_content = si.getvalue()
+    output = make_response(response_content)
+    
+    output.data = b'\xef\xbb\xbf' + output.data
+    
+    # Dateiname generieren
+    title_slug = appointment_item.get('title', 'export').replace(' ', '_')
+    output.headers["Content-Disposition"] = f"attachment; filename=buchungen_{title_slug}.csv"
+    output.headers["Content-Type"] = "text/csv; charset=utf-8"
+    
+    return output
+
 @appoint_bp.route('/client/<appointment_id>', methods=['POST', 'GET'])
 def client(appointment_id):
     """
-    The Route for the terminplaner to work with the client
+    The Route for the terminplaner to work with the client and allow owners to manage it.
     """
     guard = _require_module_enabled()
     if guard:
@@ -50,6 +153,10 @@ def client(appointment_id):
     current_user = str(session.get('username', '') or '').strip()
     appointment_item = termin.get_item(appointment_id) or {}
     appointment_owner = str(appointment_item.get('user', '') or '').strip()
+    
+    custom_fields = appointment_item.get('custom_fields', [])
+
+    # Permissions check
     can_view_booking_names = False
     if current_user:
         try:
@@ -57,6 +164,7 @@ def client(appointment_id):
         except Exception:
             can_view_booking_names = bool(current_user == appointment_owner)
 
+    # Sanitize data for public/client view
     available_for_view = dict(available)
     if not can_view_booking_names:
         sanitized_bookings = []
@@ -70,31 +178,59 @@ def client(appointment_id):
         available_for_view['slots_booked'] = sanitized_bookings
 
     if request.method == 'POST':
-        start_daytime = request.form.get('start_day_time')
-        username = request.form.get('client_name')
-        if not start_daytime or not username:
-            flash('Bitte Name und gewünschte Uhrzeit angeben.', 'error')
-            return render_template(
-                'termin_client.html',
-                appointment_id=appointment_id,
-                available=available_for_view,
-                current_user=session.get('username', ''),
-                tenant_id=_current_tenant_id(),
-                can_view_booking_names=can_view_booking_names,
-            )
+        action = request.form.get('action', 'book')
 
-        if appointment_service.book_slot(appointment_id, start_daytime, username):
-            return redirect(
-                url_for(
-                    'terminplaner.client_success',
+        # Case 1: Admin/Owner cancels a booking
+        if action == 'delete' and can_view_booking_names:
+            slot_time = request.form.get('slot_time')
+            client_name = request.form.get('target_client_name')
+            
+            current_slots = appointment_item.get('slots_booked', []) or []
+            
+            # Keep everything EXCEPT the item targeted for deletion
+            updated_slots = [
+                slot for slot in current_slots 
+                if not (isinstance(slot, (list, tuple)) and slot[0] == slot_time and slot[1] == client_name)
+            ]
+            
+            if termin.update(appointment_id, updated_slots):
+                flash('Buchung wurde erfolgreich gelöscht.', 'success')
+            else:
+                flash('Fehler beim Löschen der Buchung.', 'error')
+                
+            return redirect(url_for('terminplaner.client', appointment_id=appointment_id, tenant=_current_tenant_id() or None))
+
+        # Case 2: Client books a slot
+        elif action == 'book':
+            start_daytime = request.form.get('start_day_time')
+            username = request.form.get('client_name')
+            custom_answers = tuple(request.form.getlist('custom_answers'))  # Cast to tuple for DB safety
+
+            if not start_daytime or not username:
+                flash('Bitte Name und gewünschte Uhrzeit angeben.', 'error')
+                return render_template(
+                    'termin_client.html',
                     appointment_id=appointment_id,
-                    tenant=_current_tenant_id() or None,
-                    start=start_daytime,
-                    name=username,
+                    available=available_for_view,
+                    current_user=session.get('username', ''),
+                    tenant_id=_current_tenant_id(),
+                    can_view_booking_names=can_view_booking_names,
+                    custom_fields=custom_fields,
+                    appointment_module_enabled=cfg.MODULES.is_enabled('terminplan')
                 )
-            )
 
-        flash('Der Termin konnte nicht gespeichert werden.', 'error')
+            if appointment_service.book_slot(appointment_id, start_daytime, username, custom=custom_answers):
+                return redirect(
+                    url_for(
+                        'terminplaner.client_success',
+                        appointment_id=appointment_id,
+                        tenant=_current_tenant_id() or None,
+                        start=start_daytime,
+                        name=username,
+                    )
+                )
+
+            flash('Der Termin konnte nicht gespeichert werden. Eventuell ist der Slot bereits voll.', 'error')
 
     return render_template(
         'termin_client.html',
@@ -103,6 +239,9 @@ def client(appointment_id):
         current_user=session.get('username', ''),
         tenant_id=_current_tenant_id(),
         can_view_booking_names=can_view_booking_names,
+        custom_fields=custom_fields,
+        appointment_item=appointment_item,
+        appointment_module_enabled=cfg.MODULES.is_enabled('terminplan')
     )
 
 
@@ -154,7 +293,7 @@ def delete_appointment(appointment_id):
 @appoint_bp.route('/configure', methods=['GET', 'POST'])
 def configure():
     """
-    Route for authenticated persons to configure a new appointment for them
+    Route for authenticated persons to configure a new appointment schedule
     """
     guard = _require_module_enabled()
     if guard:
@@ -169,12 +308,19 @@ def configure():
         end = request.form.get('end_date')
         time = request.form.get('time_frame')
         slots_amount = request.form.get('slots_amounts')
-        slot_lenght = request.form.get('slot_lenght')
+        slot_length = request.form.get('slot_length') 
         mail = request.form.get('mail', '')
         note = request.form.get('note', '')
         add_to_calendar = request.form.get('add_to_calendar') == 'on'
+        title = request.form.get('title', '').strip()
+        custom = request.form.getlist('custom_fields')
+        
+        try:
+            clients_p_slot = int(request.form.get('clients_per_slot', 1))
+        except (ValueError, TypeError):
+            clients_p_slot = 1
 
-        if not start or not end or not time or not slots_amount or not slot_lenght:
+        if not start or not end or not time or not slots_amount or not slot_length or not title:
             flash('Bitte alle Pflichtfelder ausfüllen.', 'error')
             return render_template(
                 'termin_configure.html',
@@ -183,25 +329,48 @@ def configure():
                 email_service_enabled=cfg.EMAIL_ENABLED,
             )
 
-        result = appointment_service.new(start, end, time, slots_amount, slot_lenght, session["username"], mail, note, calendar_enabled=add_to_calendar)
+        # Call the database service function (standardized to match your underlying code)
+        inserted_id = appointment_service.new(
+            date_start=start, 
+            date_end=end, 
+            time_span=time, 
+            slots=slots_amount, 
+            slot_length=slot_length, 
+            user=session["username"], 
+            mail=mail, 
+            note=note, 
+            calendar_enabled=add_to_calendar, 
+            title=title, 
+            custom_fields=custom,
+            clients_per_slot=clients_p_slot
+        )
+
+        if not inserted_id:
+            flash('Fehler beim Erstellen des Terminplans.', 'error')
+            return redirect(url_for('terminplaner.configure'))
+
         flash('Der Terminplan wurde angelegt.', 'success')
         return render_template(
             'termin_configure.html',
             school_periods=cfg.SCHOOL_PERIODS,
-            generated_link=result['link'],
-            calendar_link=result.get('calendar_link'),
+            generated_link=inserted_id['link'],
+            calendar_link=None, 
             add_to_calendar=add_to_calendar,
             email_service_enabled=cfg.EMAIL_ENABLED,
+            title=title,
+            appointment_module_enabled=cfg.MODULES.is_enabled('terminplan')
         )
-    elif request.method == "GET":
-        return render_template(
-            'termin_configure.html',
-            school_periods=cfg.SCHOOL_PERIODS,
-            generated_link=None,
-            calendar_link=None,
-            add_to_calendar=False,
-            email_service_enabled=cfg.EMAIL_ENABLED,
-        )
+
+    return render_template(
+        'termin_configure.html',
+        school_periods=cfg.SCHOOL_PERIODS,
+        generated_link=None,
+        calendar_link=None,
+        add_to_calendar=False,
+        email_service_enabled=cfg.EMAIL_ENABLED,
+        title=None,
+        appointment_module_enabled=cfg.MODULES.is_enabled('terminplan')
+    )
 
 
 @appoint_bp.route('/calendar/<appointment_id>.ics', methods=['GET'])
@@ -214,8 +383,10 @@ def calendar_export(appointment_id):
     if not ics_content:
         return _appointment_not_found_response()
 
+    title = str(request.args.get('title', '') or '').strip() or appointment_id
+
     response = Response(ics_content, mimetype='text/calendar; charset=utf-8')
-    response.headers['Content-Disposition'] = f'attachment; filename=terminplan-{appointment_id}.ics'
+    response.headers['Content-Disposition'] = f'attachment; filename=terminplan-{title}-{appointment_id}.ics'
     return response
 
 
@@ -231,10 +402,144 @@ def client_slot_calendar_export(appointment_id):
     if not ics_content:
         return _appointment_not_found_response()
 
+    title = str(request.args.get('title', '') or '').strip() or appointment_id
+
     response = Response(ics_content, mimetype='text/calendar; charset=utf-8')
-    response.headers['Content-Disposition'] = f'attachment; filename=termin-{appointment_id}-{slot_start.replace(" ", "_").replace(":", "")}.ics'
+    response.headers['Content-Disposition'] = f'attachment; filename=termin-{title}-{appointment_id}-{slot_start.replace(" ", "_").replace(":", "")}.ics'
     return response
 
+
+@appoint_bp.route('/export_pdf_brief/<plan_id>', methods=['GET'])
+def export_pdf_brief(plan_id):
+    # 1. Daten holen (Hier als Beispiel, passe dies auf deine Datenbank an)
+    # terminplan = Terminplan.query.get(plan_id)
+
+    school_info = _get_school_info_for_export()
+
+    school_name = school_info.get('name', 'Schulname')
+    address = school_info.get('address', 'Adresse')
+    postal_code = school_info.get('postal_code', 'PLZ')
+    city = school_info.get('city', 'Stadt')
+    school_number = school_info.get('school_number', '000000')
+    it_admin = school_info.get('it_admin', 'IT-Beauftragter/in')
+    tenant_id = _current_tenant_id()
+
+    try:
+        link = url_for('terminplaner.client', appointment_id=plan_id, tenant=tenant_id or None, _external=True)
+    except Exception:
+        host = _resolve_public_base_url()
+        link = host + "/terminplaner/client/" + plan_id
+        if tenant_id:
+            link += f"?tenant={tenant_id}"
+
+    schul_daten = {
+        "schulname": school_name,
+        "strasse": address,
+        "plz_ort": f"{postal_code} {city}",
+        "schulnummer": school_number,
+        "it_admin": it_admin
+    }
+    
+    plan_daten = {
+        "titel": termin.get_item(plan_id).get('title', 'Terminplan'), # terminplan.title
+        "link": link, # terminplan.link
+        "notizen": termin.get_item(plan_id).get('note', '') # terminplan.note
+    }
+
+    # 2. QR-Code Bild im temporären Ordner erstellen
+    qr = qrcode.QRCode(version=1, box_size=10, border=0)
+    qr.add_data(plan_daten["link"])
+    qr.make(fit=True)
+    img = qr.make_image(fill_color="black", back_color="white")
+    
+    fd, qr_path = tempfile.mkstemp(suffix=".png")
+    os.close(fd)
+    img.save(qr_path)
+
+    # 3. PDF im Speicher aufbauen (BytesIO)
+    pdf_buffer = io.BytesIO()
+    doc = SimpleDocTemplate(
+        pdf_buffer,
+        pagesize=A4,
+        rightMargin=2*cm,
+        leftMargin=2.5*cm,
+        topMargin=2.5*cm,
+        bottomMargin=2*cm
+    )
+    
+    styles = getSampleStyleSheet()
+    styles.add(ParagraphStyle(name='Sender', fontSize=8, textColor=grey))
+    styles.add(ParagraphStyle(name='Address', fontSize=10, leading=14))
+    styles.add(ParagraphStyle(name='Date', fontSize=10, alignment=2))
+    styles.add(ParagraphStyle(name='Subject', fontSize=14, fontName='Helvetica-Bold', spaceAfter=16, textColor=HexColor('#0f4c5c')))
+    styles.add(ParagraphStyle(name='Body', fontSize=11, leading=16, spaceAfter=12))
+    styles.add(ParagraphStyle(name='Notes', fontSize=10, leading=14, textColor=HexColor("#444444")))
+    
+    elements = []
+    
+    # Absenderzeile
+    sender_text = f"<u>{schul_daten['schulname']} • {schul_daten['strasse']} • {schul_daten['plz_ort']}</u>"
+    elements.append(Paragraph(sender_text, styles['Sender']))
+    elements.append(Spacer(1, 1.5*cm))
+    
+    # Sichtfenster-Adresse (Generisch)
+    elements.append(Paragraph("An die<br/>Teilnehmerinnen und Teilnehmer<br/>des Termins", styles['Address']))
+    elements.append(Spacer(1, 2*cm))
+    
+    # Datum (Hier statisch zum Test, ggf. dynamisch per datetime)
+    import datetime
+    heute = datetime.datetime.now().strftime("%d.%m.%Y")
+    elements.append(Paragraph(f"{schul_daten['plz_ort']}, den {heute}", styles['Date']))
+    elements.append(Spacer(1, 1*cm))
+    
+    # Betreff
+    elements.append(Paragraph(f"Einladung zur Terminbuchung: {plan_daten['titel']}", styles['Subject']))
+    
+    # Text
+    elements.append(Paragraph("Sehr geehrte Damen und Herren,", styles['Body']))
+    elements.append(Paragraph("hiermit möchten wir Sie herzlich einladen, einen Termin für unsere anstehende Veranstaltung zu buchen. Um den Prozess für alle Beteiligten so einfach und effizient wie möglich zu gestalten, nutzen wir unser Online-Buchungssystem.", styles['Body']))
+    elements.append(Spacer(1, 0.5*cm))
+    
+    # Link
+    elements.append(Paragraph("<b>Ihr persönlicher Buchungslink:</b>", styles['Body']))
+    link_html = f'<a href="{plan_daten["link"]}?" color="#16697a">{plan_daten["link"]}</a>'
+    elements.append(Paragraph(link_html, styles['Body']))
+    
+    # Das vorhin erstellte QR-Code Bild einfügen
+    elements.append(Spacer(1, 0.2*cm))
+    elements.append(Image(qr_path, width=3*cm, height=3*cm, hAlign='LEFT'))
+    elements.append(Spacer(1, 0.5*cm))
+    
+    # Notizen (falls vorhanden)
+    if plan_daten.get('notizen'):
+        elements.append(Paragraph("<b>Zusätzliche Informationen zum Termin:</b>", styles['Body']))
+        elements.append(Paragraph(plan_daten['notizen'], styles['Notes']))
+        
+    elements.append(Spacer(1, 1.5*cm))
+    
+    # Grußformel
+    elements.append(Paragraph("Mit freundlichen Grüßen,", styles['Body']))
+    elements.append(Spacer(1, 1.5*cm))
+    elements.append(Paragraph(f"<b>{schul_daten['schulname']}</b>", styles['Body']))
+    
+    # PDF fertigstellen
+    doc.build(elements)
+    
+    # Temporäres Bild löschen
+    if os.path.exists(qr_path):
+        os.remove(qr_path)
+    
+    # Buffer auf Anfang zurücksetzen
+    pdf_buffer.seek(0)
+    
+    # An Nutzer ausliefern
+    return send_file(
+        pdf_buffer,
+        mimetype='application/pdf',
+        as_attachment=True,
+        download_name=f"Einladung_{plan_daten['titel'].replace(' ', '_')}.pdf"
+    )
+
 @appoint_bp.route('/')
 def main():
     guard = _require_module_enabled()
@@ -245,10 +550,12 @@ def main():
     upcoming_events = appointment_service.get_user_upcoming_events(current_user) if current_user else []
     tenant_id = _current_tenant_id()
 
+
     return render_template(
         'terminplaner.html',
         school_periods=cfg.SCHOOL_PERIODS,
         current_user=current_user,
         upcoming_events=upcoming_events,
         tenant_id=tenant_id,
+        appointment_module_enabled=cfg.MODULES.is_enabled('terminplan')
     )

Web/push_notifications.py

@@ -13,6 +13,7 @@ import logging
 
 import Web.modules.database.settings as cfg
 from Web.modules.database.settings import MongoClient
+from Web.modules.inventarsystem.data_protection import encrypt_text, decrypt_text
 
 logger = logging.getLogger(__name__)
 
@@ -44,16 +45,22 @@ if not VAPID_PUBLIC_KEY or not VAPID_PRIVATE_KEY:
             serialization.PublicFormat.UncompressedPoint
         )
         
-        VAPID_PUBLIC_KEY = b64urlencode(raw_pub)
+        VAPID_PUBLIC_KEY = b64urlencode(raw_pub).decode('utf-8')
         VAPID_PRIVATE_KEY = VAPID_PRIVATE_PEM
     except Exception as e:
         logger.error(f'Could not load or generate VAPID keys: {e}')
 
 # Push service endpoint (typically Firebase or Web Push Service)
-PUSH_SERVICE_URL = 'https://fcm.googleapis.com/fcm/send'  # Firebase Cloud Messaging
 FCM_API_KEY = os.getenv('FCM_API_KEY', '')  # Firebase API key
 
 
+def _get_username_hash(username):
+    """Generates a deterministic hash for database lookups."""
+    if not username:
+        return None
+    return hashlib.sha256(username.encode('utf-8')).hexdigest()
+
+
 def get_push_subscriptions_collection(db=None):
     """Get MongoDB push subscriptions collection"""
     if db is None:
@@ -64,71 +71,68 @@ def get_push_subscriptions_collection(db=None):
 
 def get_user_subscriptions(username):
     """
-    Get all active push subscriptions for a user
-    
-    Args:
-        username (str): Username
-        
-    Returns:
-        list: List of subscription documents
+    Get all active push subscriptions for a user, decrypting data on the fly.
     """
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = client[cfg.MONGODB_DB]
         subs_col = get_push_subscriptions_collection(db)
         
-        subscriptions = list(subs_col.find({
-            'Username': username,
+        # Query using the deterministic hash, NOT the encrypted text directly
+        user_hash = _get_username_hash(username)
+        
+        encrypted_subscriptions = list(subs_col.find({
+            'UsernameHash': user_hash,
             'IsActive': True
         }))
         
         client.close()
-        return subscriptions
+        
+        # Decrypt endpoints and keys before returning
+        decrypted_subs = []
+        for sub in encrypted_subscriptions:
+            try:
+                sub['Endpoint'] = decrypt_text(sub.get('Endpoint'))
+                
+                # Keys are stored as encrypted JSON strings
+                decrypted_keys_str = decrypt_text(sub.get('Keys'))
+                sub['Keys'] = json.loads(decrypted_keys_str) if decrypted_keys_str else {}
+                
+                decrypted_subs.append(sub)
+            except Exception as e:
+                logger.error(f"Failed to decrypt subscription payload for hash {user_hash}: {e}")
+                
+        return decrypted_subs
     except Exception as e:
-        logger.error(f'Error getting push subscriptions for {username}: {e}')
+        logger.error(f'Error getting push subscriptions for user: {e}')
         return []
 
 
 def save_push_subscription(username, subscription_obj):
     """
-    Save a new push subscription for a user
-    
-    Args:
-        username (str): Username
-        subscription_obj (dict): Subscription object from Service Worker
-        {
-            'endpoint': 'https://...',
-            'keys': {
-                'p256dh': '...',
-                'auth': '...'
-            }
-        }
-        
-    Returns:
-        bool: Success status
+    Save a new push subscription for a user with field-level encryption.
     """
     try:
-        if not subscription_obj.get('endpoint'):
-            logger.warning(f'Invalid subscription object for {username}')
+        endpoint = subscription_obj.get('endpoint')
+        if not endpoint:
+            logger.warning('Invalid subscription object: missing endpoint')
             return False
         
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = client[cfg.MONGODB_DB]
         subs_col = get_push_subscriptions_collection(db)
         
-        # Create unique hash of subscription to avoid duplicates
-        sub_hash = hashlib.md5(
-            f"{username}:{subscription_obj['endpoint']}".encode()
+        # Create unique hash of subscription using plaintext data to avoid duplicates
+        sub_hash = hashlib.shake_256(
+            f"{username}:{endpoint}".encode('utf-8')
         ).hexdigest()
         
-        # Check if subscription already exists
+        # Check if subscription already exists by Hash
         existing = subs_col.find_one({
-            'Username': username,
             'SubscriptionHash': sub_hash
         })
         
         if existing:
-            # Update last used time
             subs_col.update_one(
                 {'_id': existing['_id']},
                 {'$set': {
@@ -136,15 +140,19 @@ def save_push_subscription(username, subscription_obj):
                     'IsActive': True
                 }}
             )
-            logger.info(f'Updated existing subscription for {username}')
+            logger.info('Updated existing push subscription')
             client.close()
             return True
         
-        # Save new subscription
+        # Format keys as JSON string for your encrypt_text module
+        keys_str = json.dumps(subscription_obj.get('keys', {}))
+        
+        # Save new subscription, encrypting sensitive fields
         subscription_doc = {
-            'Username': username,
-            'Endpoint': subscription_obj['endpoint'],
-            'Keys': subscription_obj.get('keys', {}),
+            'UsernameHash': _get_username_hash(username),
+            'Username': encrypt_text(username),
+            'Endpoint': encrypt_text(endpoint),
+            'Keys': encrypt_text(keys_str),
             'SubscriptionHash': sub_hash,
             'IsActive': True,
             'CreatedAt': datetime.datetime.now(),
@@ -153,36 +161,31 @@ def save_push_subscription(username, subscription_obj):
         }
         
         subs_col.insert_one(subscription_doc)
-        logger.info(f'Saved new push subscription for {username}')
+        logger.info('Saved new encrypted push subscription')
         client.close()
         return True
         
     except Exception as e:
-        logger.error(f'Error saving push subscription for {username}: {e}')
+        logger.error(f'Error saving push subscription: {e}')
         return False
 
 
 def remove_push_subscription(username, endpoint):
     """
-    Remove a push subscription
-    
-    Args:
-        username (str): Username
-        endpoint (str): Subscription endpoint URL
-        
-    Returns:
-        bool: Success status
+    Remove a push subscription by making it inactive.
     """
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = client[cfg.MONGODB_DB]
         subs_col = get_push_subscriptions_collection(db)
         
+        # Recreate the deterministic hash to find the specific subscription
+        sub_hash = hashlib.shake_256(
+            f"{username}:{endpoint}".encode('utf-8')
+        ).hexdigest()
+        
         result = subs_col.update_one(
-            {
-                'Username': username,
-                'Endpoint': endpoint
-            },
+            {'SubscriptionHash': sub_hash},
             {'$set': {'IsActive': False}}
         )
         
@@ -190,31 +193,19 @@ def remove_push_subscription(username, endpoint):
         return result.modified_count > 0
         
     except Exception as e:
-        logger.error(f'Error removing push subscription for {username}: {e}')
+        logger.error(f'Error removing push subscription: {e}')
         return False
 
 
 def send_push_notification(username, title, body, icon=None, url='/', reference=None, tag='notification'):
     """
-    Send a push notification to all user's subscriptions
-    
-    Args:
-        username (str): Target username
-        title (str): Notification title
-        body (str): Notification body
-        icon (str, optional): Icon URL
-        url (str, optional): URL to open on click
-        reference (dict, optional): Reference data (item_id, etc)
-        tag (str, optional): Notification tag for grouping
-        
-    Returns:
-        int: Number of successfully sent notifications
+    Send a push notification to all user's subscriptions.
     """
     try:
         subscriptions = get_user_subscriptions(username)
         
         if not subscriptions:
-            logger.debug(f'No active push subscriptions for {username}')
+            logger.debug('No active push subscriptions for user')
             return 0
         
         sent_count = 0
@@ -232,19 +223,18 @@ def send_push_notification(username, title, body, icon=None, url='/', reference=
             if success:
                 sent_count += 1
             else:
-                # Mark subscription as inactive if send fails
                 _mark_subscription_inactive(subscription['_id'])
         
-        logger.info(f'Sent push notification to {username}: {sent_count}/{len(subscriptions)} subscriptions')
+        logger.info(f'Sent push notification: {sent_count}/{len(subscriptions)} subscriptions')
         return sent_count
         
     except Exception as e:
-        logger.error(f'Error sending push notification to {username}: {e}')
+        logger.error(f'Error sending push notification: {e}')
         return 0
 
 
 def _send_to_subscription(subscription, title, body, icon, url, reference, tag):
-    """Send push notification to a specific subscription"""
+    """Send push notification to a specific decrypted subscription"""
     try:
         payload = {
             'title': title,
@@ -256,20 +246,17 @@ def _send_to_subscription(subscription, title, body, icon, url, reference, tag):
             'reference': reference or {},
         }
         
-        # If using Firebase Cloud Messaging
         if FCM_API_KEY and subscription.get('Endpoint', '').startswith('https://fcm.'):
             return _send_fcm_notification(subscription, payload)
         
-        # Otherwise use standard Web Push Protocol
         return _send_web_push_notification(subscription, payload)
         
     except Exception as e:
-        logger.error(f'Error sending to subscription {subscription.get("_id")}: {e}')
+        logger.error(f'Error sending to subscription: {e}')
         return False
 
 
 def _send_fcm_notification(subscription, payload):
-    """Send notification via Firebase Cloud Messaging"""
     try:
         if not FCM_API_KEY:
             logger.warning('FCM_API_KEY not configured')
@@ -311,9 +298,7 @@ def _send_fcm_notification(subscription, payload):
 
 
 def _send_web_push_notification(subscription, payload):
-    """Send notification using standard Web Push Protocol"""
     try:
-        # This requires pywebpush library
         from pywebpush import webpush
         
         webpush(
@@ -325,13 +310,13 @@ def _send_web_push_notification(subscription, payload):
             vapid_private_key=VAPID_PRIVATE_KEY,
             vapid_claims={'sub': VAPID_SUBJECT},
             timeout=10,
-            ttl=3600  # Notification expires after 1 hour if device is offline
+            ttl=3600 
         )
         
         return True
         
     except ImportError:
-        logger.warning('pywebpush not installed, install with: pip install pywebpush')
+        logger.warning('pywebpush not installed. pip install pywebpush')
         return False
     except Exception as e:
         logger.error(f'Web push error: {e}')
@@ -339,7 +324,6 @@ def _send_web_push_notification(subscription, payload):
 
 
 def _mark_subscription_inactive(subscription_id):
-    """Mark a subscription as inactive (e.g., after failed send)"""
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = client[cfg.MONGODB_DB]
@@ -349,37 +333,21 @@ def _mark_subscription_inactive(subscription_id):
             {'_id': ObjectId(subscription_id)},
             {'$set': {'IsActive': False}}
         )
-        
         client.close()
     except Exception as e:
         logger.error(f'Error marking subscription inactive: {e}')
 
 
 def send_push_to_all_admins(title, body, icon=None, url='/', reference=None):
-    """
-    Send a push notification to all admin users
-    
-    Args:
-        title (str): Notification title
-        body (str): Notification body
-        icon (str, optional): Icon URL
-        url (str, optional): URL to open on click
-        reference (dict, optional): Reference data
-        
-    Returns:
-        int: Total notifications sent
-    """
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = client[cfg.MONGODB_DB]
         users_col = db['users']
         
-        # Get all admin users
         admin_users = list(users_col.find(
             {'Admin': True},
             {'Username': 1}
         ))
-        
         client.close()
         
         total_sent = 0
@@ -404,10 +372,6 @@ def send_push_to_all_admins(title, body, icon=None, url='/', reference=None):
 
 
 def cleanup_inactive_subscriptions():
-    """
-    Remove inactive subscriptions older than 30 days
-    Run this periodically as a maintenance task
-    """
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = client[cfg.MONGODB_DB]
@@ -429,22 +393,19 @@ def cleanup_inactive_subscriptions():
         return 0
 
 
-# Database collection schema
 def ensure_push_subscriptions_collection():
-    """Ensure the push_subscriptions collection exists with proper indexes"""
     try:
         client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
         db = client[cfg.MONGODB_DB]
         subs_col = get_push_subscriptions_collection(db)
         
-        # Create indexes
-        subs_col.create_index('Username')
-        subs_col.create_index([('Username', 1), ('IsActive', 1)])
-        subs_col.create_index([('CreatedAt', 1)])  # TTL-like usage
+        subs_col.create_index('UsernameHash')
+        subs_col.create_index([('UsernameHash', 1), ('IsActive', 1)])
+        subs_col.create_index([('CreatedAt', 1)]) 
         subs_col.create_index('SubscriptionHash', unique=True)
         
         logger.info('Push subscriptions collection indexes created')
         client.close()
         
     except Exception as e:
-        logger.error(f'Error ensuring push subscriptions collection: {e}')
+        logger.error(f'Error ensuring push subscriptions collection: {e}')

Web/requirements.txt

@@ -15,3 +15,4 @@ openpyxl
 cryptography>=42.0.0
 pywebpush
 py-vapid>=1.9.0
+beautifulsoup4

Web/templates/base.html

@@ -1144,6 +1144,17 @@
                         <li class="nav-item dropdown ms-lg-auto">
                             <a class="nav-link dropdown-toggle" href="#" id="termMoreDropdown" role="button" data-bs-toggle="dropdown" aria-expanded="false" title="Weitere Optionen">Mehr Optionen</a>
                             <ul class="dropdown-menu dropdown-menu-end" aria-labelledby="termMoreDropdown">
+                                {% if 'username' in session %}
+                                {% if current_permissions.pages.get('tutorial_page', True) %}
+                                <li><a class="dropdown-item" href="{{ url_for('tutorial_page') }}">Tutorial</a></li>
+                                {% endif %}
+                                <li><a class="dropdown-item" href="{{ url_for('admin_school_settings') }}">Schulstammdaten</a></li>
+                                {% if current_permissions.actions.get('can_view_logs', True) and current_permissions.pages.get('admin_audit_dashboard', True) %}
+                                <li><a class="dropdown-item" href="{{ url_for('admin_audit_dashboard') }}">Audit Dashboard</a></li>
+                                {% endif %}
+                                <li><hr class="dropdown-divider"></li>
+                                {% endif %}
+                                
                                 {% if current_permissions.pages.get('home', True) %}
                                 <li><a class="dropdown-item" href="{{ url_for('home') }}">Inventarsystem</a></li>
                                 {% endif %}
@@ -1155,6 +1166,42 @@
                             </ul>
                         </li>
                     </ul>
+                    <div class="d-flex">
+                        {% if 'username' in session %}
+                            <div class="function-search-wrap">
+                                <form class="function-search-form" data-function-search="true">
+                                    <input
+                                        class="function-search-input"
+                                        type="search"
+                                        name="function_search"
+                                        placeholder="Funktion suchen..."
+                                        list="function-search-options"
+                                        autocomplete="off"
+                                    >
+                                    <button class="function-search-btn" type="submit">Los</button>
+                                </form>
+                            </div>
+                            {% if current_tenant_db %}
+                            <span class="navbar-text tenant-badge" title="Aktive Tenant-Datenbank">{{ current_tenant_db }}</span>
+                        {% endif %}
+                        <span class="navbar-text text-light me-3">{{ session['username'] }}</span>
+                            <div class="dropdown me-2 user-menu-wrap">
+                                <button class="btn btn-secondary dropdown-toggle user-menu-btn" type="button" id="invUserMenuDropdown" data-bs-toggle="dropdown" aria-expanded="false" data-notification-button="true">
+                                    👤
+                                    <span class="user-notification-dot {% if unread_notification_count and unread_notification_count > 0 %}visible{% endif %}" aria-hidden="true"></span>
+                                </button>
+                                <ul class="dropdown-menu dropdown-menu-end" aria-labelledby="invUserMenuDropdown">
+                                    {% if current_permissions.pages.get('notifications_view', True) %}
+                                    <li><a class="dropdown-item" href="{{ url_for('notifications_view') }}">Benachrichtigungen</a></li>
+                                    {% endif %}
+                                    <li><hr class="dropdown-divider"></li>
+                                    <li><a class="dropdown-item" href="{{ url_for('change_password') }}">Passwort ändern</a></li>
+                                    <li><hr class="dropdown-divider"></li>
+                                    <li><a class="dropdown-item" href="{{ url_for('logout') }}">Logout</a></li>
+                                </ul>
+                            </div>
+                        {% endif %}
+                    </div>
                 </div>
             </div>
         </nav>
@@ -1295,11 +1342,6 @@
                         </li>
                         {% endif %}
                         {% if 'username' in session %}
-                        {% if current_permissions.pages.get('my_borrowed_items', True) %}
-                        <li class="nav-item">
-                            <a class="nav-link quick-link-pill {% if current_path == url_for('my_borrowed_items') %}nav-active{% endif %}" href="{{ url_for('my_borrowed_items') }}" data-tutorial-tip="Hier sehen Sie Ihre bibliotheksbezogenen Ausleihen.">Meine Medien</a>
-                        </li>
-                        {% endif %}
                         {% if current_permissions.pages.get('tutorial_page', True) %}
                         <li class="nav-item">
                             <a class="nav-link quick-link-pill {% if current_path == url_for('tutorial_page') %}nav-active{% endif %}" href="{{ url_for('tutorial_page') }}" data-tutorial-tip="Nutzen Sie das Tutorial, um die Bibliotheksfunktionen kennenzulernen.">Tutorial</a>
@@ -1326,10 +1368,7 @@
                                 {% if 'username' in session and (session.get('admin', False) or is_admin) and current_permissions.actions.get('can_manage_settings', True) %}
                                 <li><h6 class="dropdown-header">Bibliotheks-Verwaltung</h6></li>
                                 {% if current_permissions.pages.get('library_loans_admin', True) %}
-                                <li><a class="dropdown-item" href="{{ url_for('library_loans_admin') }}">Ausleihen</a></li>
-                                {% endif %}
-                                {% if current_permissions.pages.get('admin_damaged_items', True) %}
-                                <li><a class="dropdown-item" href="{{ url_for('admin_damaged_items') }}">Defekte Items</a></li>
+                                <li><a class="dropdown-item" href="{{ url_for('library_loans_admin') }}">Ausleihen / Defekte Items</a></li>
                                 {% endif %}
                                 {% if student_cards_module_enabled %}
                                 <li><a class="dropdown-item" href="{{ url_for('student_cards_admin') }}">Bibliotheksausweis</a></li>

Web/templates/library_table.html

@@ -431,7 +431,7 @@
             type="text" 
             id="librarySearch" 
             class="library-search-input" 
-            placeholder="Nach Titel, Autor, ISBN suchen..."
+            placeholder="Nach Titel, ISBN suchen..."
         >
         <button 
             id="filterToggleBtn" 
@@ -466,10 +466,6 @@
     </div>
     <div id="filterPanel" class="library-filter-panel">
         <div class="filter-row">
-            <div class="filter-item">
-                <label for="filterAuthor">Autor/Künstler:</label>
-                <input type="text" id="filterAuthor" placeholder="z.B. Goethe">
-            </div>
             <div class="filter-item">
                 <label for="filterISBN">ISBN:</label>
                 <input type="text" id="filterISBN" placeholder="z.B. 978-3...">
@@ -516,7 +512,6 @@
             <thead>
                 <tr>
                     <th style="width: 24%;">Titel</th>
-                    <th style="width: 14%;">Autor/Künstler</th>
                     <th style="width: 12%;">ISBN/Code</th>
                     <th style="width: 8%;">Typ</th>
                     <th style="width: 8%;">Anzahl</th>
@@ -549,15 +544,17 @@
     </div>
 </div>
 
+<script src="https://cdn.jsdelivr.net/npm/@ericblade/quagga2/dist/quagga.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/@ericblade/quagga2/dist/quagga.js"></script>
 <script>
-    // State
+    // =========================================================================
+    // 1. GLOBAL STATE DEFINITIONS
+    // =========================================================================
     let libraryItems = [];
     let filteredItems = [];
     let visibleItems = [];
     let currentSearchTerm = '';
     let activeFilters = {
-        author: '',
         isbn: '',
         type: '',
         status: ''
@@ -573,13 +570,20 @@
     const RENDER_BATCH_COUNT = 120;
     let renderedCount = INITIAL_RENDER_COUNT;
     let filterPanelOpen = false;
+    
+    // Scanner Related State Variables
     let scannerInstance = null;
-    let scannerRunning = false;
+    let scannerRunning = false; 
+    let activeScannerCallback = null; 
     let activeStudentCardId = '';
     let lastScanValue = '';
     let lastScanAt = 0;
+    
     const canEditLibraryItems = (document.getElementById('libraryTableContainer')?.dataset.canEdit === '1');
 
+    // =========================================================================
+    // 2. DATA LOADING & FILTERING ENGINE
+    // =========================================================================
     async function fetchLibraryPage(offset, limit) {
         const response = await fetch(`/api/library_items?offset=${offset}&limit=${limit}`);
         if (!response.ok) {
@@ -588,7 +592,6 @@
         return response.json();
     }
 
-    // Load items progressively: first page immediately, rest in background
     async function loadLibraryItems() {
         if (pagingState.loading) return;
         pagingState.loading = true;
@@ -627,7 +630,6 @@
                 pagingState.total = page.total || pagingState.total;
                 pagingState.hasMore = Boolean(page.has_more);
 
-                // Keep the current view reactive while avoiding a full rerender burst.
                 applyFiltersAndSearch(false);
 
                 if ('requestIdleCallback' in window) {
@@ -643,18 +645,16 @@
     }
 
     function filterItems(items) {
-        const author = activeFilters.author;
         const isbn = activeFilters.isbn;
         const type = activeFilters.type;
         const status = activeFilters.status;
 
         return items.filter(item => {
-            const authorMatch = !author || (item.Autor || item.Author || '').toLowerCase().includes(author);
             const isbnMatch = !isbn || (item.ISBN || item.Code_4 || item.Code4 || '').toLowerCase().includes(isbn);
             const typeMatch = !type || (item.ItemType || 'book') === type;
             const statusKey = item.LibraryDisplayStatus || (item.Verfuegbar === false ? 'borrowed' : 'available');
             const statusMatch = !status || statusKey === status;
-            return authorMatch && isbnMatch && typeMatch && statusMatch;
+            return isbnMatch && typeMatch && statusMatch;
         });
     }
 
@@ -662,7 +662,6 @@
         if (!currentSearchTerm) return items;
         return items.filter(item =>
             (item.Name || '').toLowerCase().includes(currentSearchTerm) ||
-            (item.Autor || item.Author || '').toLowerCase().includes(currentSearchTerm) ||
             (item.ISBN || item.Code_4 || item.Code4 || '').toLowerCase().includes(currentSearchTerm)
         );
     }
@@ -679,7 +678,6 @@
         renderItems();
     }
 
-    // Display current view with incremental rendering
     function renderItems() {
         const tbody = document.getElementById('itemsTableBody');
         const emptyState = document.getElementById('emptyState');
@@ -697,37 +695,33 @@
         emptyState.style.display = 'none';
         const rowsToRender = visibleItems.slice(0, renderedCount);
 
-        tbody.innerHTML = rowsToRender.map(item => `
-            ${(() => {
-                const statusKey = item.LibraryDisplayStatus || (item.Verfuegbar === false ? 'borrowed' : 'available');
-                const statusClass = statusKey === 'damaged' ? 'status-damaged' : (statusKey === 'borrowed' ? 'status-borrowed' : 'status-available');
-                const statusText = statusKey === 'damaged' ? 'Defekt/Zerstört' : (statusKey === 'borrowed' ? 'Ausgeliehen' : 'Verfügbar');
-                const actionLabel = statusKey === 'available' ? 'Ausleihen' : (statusKey === 'borrowed' ? 'Reservieren' : 'Nicht ausleihbar');
-                const actionDisabled = statusKey === 'damaged' ? 'disabled' : '';
-                return `
-            <tr>
-                <td class="table-title">${escapeHtml(item.Name || 'Untitled')}</td>
-                <td>${escapeHtml(item.Autor || item.Author || '-')}</td>
-                <td>${escapeHtml(item.ISBN || item.Code_4 || item.Code4 || '-')}</td>
-                <td>${getItemTypeLabel(item.ItemType || 'book')}</td>
-                <td style="font-weight:600; text-align:center;">${item.Quantity || item.GroupedDisplayCount || 1}</td>
-                <td>
-                    <span class="table-status ${statusClass}">
-                        ${statusText}
-                    </span>
-                </td>
-                <td class="table-actions">
-                    <button class="button" onclick="showItemDetail('${item._id}')">Details</button>
-                    <button class="button" style="background: #28a745; color: white;" onclick="borrowItem('${item._id}')" ${actionDisabled}>
-                        ${actionLabel}
-                    </button>
-                    ${canEditLibraryItems ? `<button class="button" style="background:#0ea5e9;color:#fff;" onclick="openEditLibraryItem('${item._id}')">Bearbeiten</button>` : ''}
-                    ${canEditLibraryItems ? `<button class="button" style="background:#dc2626;color:#fff; margin-left:6px;" onclick="confirmDeleteLibraryItem('${item._id}')">Löschen</button>` : ''}
-                </td>
-            </tr>
-                `;
-            })()}
-        `).join('');
+        tbody.innerHTML = rowsToRender.map(item => {
+            const statusKey = item.LibraryDisplayStatus || (item.Verfuegbar === false ? 'borrowed' : 'available');
+            const statusClass = statusKey === 'damaged' ? 'status-damaged' : (statusKey === 'borrowed' ? 'status-borrowed' : 'status-available');
+            const statusText = statusKey === 'damaged' ? 'Defekt/Zerstört' : (statusKey === 'borrowed' ? 'Ausgeliehen' : 'Verfügbar');
+            const actionLabel = statusKey === 'available' ? 'Ausleihen' : (statusKey === 'borrowed' ? 'Reservieren' : 'Nicht ausleihbar');
+            const actionDisabled = statusKey === 'damaged' ? 'disabled' : '';
+            return `
+        <tr>
+            <td class="table-title">${escapeHtml(item.Name || 'Untitled')}</td>
+            <td>${escapeHtml(item.ISBN || item.Code_4 || item.Code4 || '-')}</td>
+            <td>${getItemTypeLabel(item.ItemType || 'book')}</td>
+            <td style="font-weight:600; text-align:center;">${item.Quantity || item.GroupedDisplayCount || 1}</td>
+            <td>
+                <span class="table-status ${statusClass}">
+                    ${statusText}
+                </span>
+            </td>
+            <td class="table-actions">
+                <button class="button" onclick="showItemDetail('${item._id}')">Details</button>
+                <button class="button" style="background: #28a745; color: white;" onclick="borrowItem('${item._id}')" ${actionDisabled}>
+                    ${actionLabel}
+                </button>
+                ${canEditLibraryItems ? `<button class="button" style="background:#0ea5e9;color:#fff;" onclick="openEditLibraryItem('${item._id}')">Bearbeiten</button>` : ''}
+                ${canEditLibraryItems ? `<button class="button" style="background:#dc2626;color:#fff; margin-left:6px;" onclick="confirmDeleteLibraryItem('${item._id}')">Löschen</button>` : ''}
+            </td>
+        </tr>`;
+        }).join('');
 
         const canLoadMoreRows = renderedCount < visibleItems.length;
         if (canLoadMoreRows) {
@@ -742,13 +736,6 @@
         }
     }
 
-    // Confirm and call library item delete endpoint
-    function confirmDeleteLibraryItem(itemId) {
-        if (!itemId) return;
-        if (!confirm('Dieses Bibliotheksmedium revisionssicher löschen? Diese Aktion deaktiviert alle zugehörigen Exemplare und archiviert Medien.')) return;
-        deleteLibraryItem(itemId);
-    }
-
     async function deleteLibraryItem(itemId) {
         if (!itemId) return;
         document.body.style.cursor = 'wait';
@@ -772,7 +759,6 @@
                 }
                 loadLibraryItems();
             } else {
-                // Server redirected to HTML (flash messages). Reload to show state.
                 location.reload();
             }
         } catch (e) {
@@ -783,46 +769,269 @@
         }
     }
 
-    // Filter toggle
-    document.getElementById('filterToggleBtn').addEventListener('click', () => {
-        filterPanelOpen = !filterPanelOpen;
-        const panel = document.getElementById('filterPanel');
-        const btn = document.getElementById('filterToggleBtn');
-        panel.classList.toggle('open');
-        btn.classList.toggle('active');
+    function confirmDeleteLibraryItem(itemId) {
+        if (!itemId) return;
+        if (!confirm('Dieses Bibliotheksmedium revisionssicher löschen? Diese Aktion deaktiviert alle zugehörigen Exemplare und archiviert Medien.')) return;
+        deleteLibraryItem(itemId);
+    }
+
+    // =========================================================================
+    // 3. CORE SCANNER ROUTING ENGINE (QUAGGA2)
+    // =========================================================================
+    function startScanner(targetCallback) {
+        const readerWrap = document.getElementById('scanReaderWrap');
+        const toggleBtn = document.getElementById('toggleScannerBtn');
+        
+        activeScannerCallback = targetCallback;
+
+        if (readerWrap) readerWrap.style.display = 'block';
+        setScanStatus('Initializing camera...', 'warn');
+    
+        Quagga.init({
+            inputStream: {
+                name: "Live",
+                type: "LiveStream",
+                target: document.querySelector('#library-scanner-container'), 
+                constraints: {
+                    width: 640,
+                    height: 480,
+                    facingMode: "environment" 
+                },
+            },
+            decoder: {
+                readers: [
+                    "code_128_reader", 
+                    "ean_reader", 
+                    "code_39_reader", 
+                    "upc_reader", 
+                    "codabar_reader", 
+                    "i2of5_reader"
+                ]
+            } 
+        }, function(err) {
+            if (err) {
+                console.error('Scanner start failed:', err);
+                if (readerWrap) readerWrap.style.display = 'none';
+                const detail = (err && (err.message || err.name)) ? ` (${err.message || err.name})` : '';
+                setScanStatus(`Scanner konnte nicht gestartet werden${detail}`, 'error');
+                return;
+            }
+        
+            Quagga.start();
+            scannerRunning = true;
+            
+            if (!targetCallback && toggleBtn) {
+                toggleBtn.textContent = 'Scanner stoppen';
+            }
+            setScanStatus('Scanner aktiv. Jetzt Code scannen.', 'warn');
+        });
+    }
+    
+    function stopScanner() {
+        if (!scannerRunning) return;
+        
+        const readerWrap = document.getElementById('scanReaderWrap');
+        const toggleBtn = document.getElementById('toggleScannerBtn');
+    
+        Quagga.stop();
+        scannerRunning = false;
+        activeScannerCallback = null; 
+    
+        if (readerWrap) readerWrap.style.display = 'none';
+        if (toggleBtn) toggleBtn.textContent = 'Scanner starten';
+        setScanStatus('Scanner gestoppt.', 'warn');
+    }
+    
+    Quagga.onDetected(function(data) {
+        if (!data || !data.codeResult || !data.codeResult.code) return;
+        
+        const barcode = String(data.codeResult.code || '').trim();
+        console.log("Barcode detected:", barcode);
+    
+        const currentCallback = activeScannerCallback;
+        stopScanner();
+    
+        if (typeof currentCallback === "function") {
+            currentCallback(barcode);
+        } else {
+            handleScanSuccess(barcode);
+        }
     });
 
-    // Apply filters
-    document.getElementById('applyFilterBtn').addEventListener('click', () => {
-        activeFilters.author = document.getElementById('filterAuthor').value.toLowerCase();
-        activeFilters.isbn = document.getElementById('filterISBN').value.toLowerCase();
-        activeFilters.type = document.getElementById('filterType').value;
-        activeFilters.status = document.getElementById('filterStatus').value;
-        applyFiltersAndSearch(true);
-    });
+    function handleScanSuccess(decodedText) {
+        const scannedCode = normalizeScannedCode(decodedText);
+        if (!scannedCode) return;
+    
+        const now = Date.now();
+        if (scannedCode === lastScanValue && (now - lastScanAt) < 1500) {
+            return;
+        }
+        lastScanValue = scannedCode;
+        lastScanAt = now;
+    
+        const mode = (document.getElementById('scanModeSelect') || {}).value || 'card_only';
+        if (mode === 'card_only') {
+            setActiveStudentCard(scannedCode);
+            setScanStatus(`Ausweis gesetzt: ${activeStudentCardId}`, 'ok');
+            return;
+        }
+    
+        processQuickToggleScan(scannedCode);
+    }
 
-    // Clear filters
-    document.getElementById('clearFilterBtn').addEventListener('click', () => {
-        document.getElementById('filterAuthor').value = '';
-        document.getElementById('filterISBN').value = '';
-        document.getElementById('filterType').value = '';
-        document.getElementById('filterStatus').value = '';
-        activeFilters = { author: '', isbn: '', type: '', status: '' };
-        applyFiltersAndSearch(true);
-    });
+    async function processQuickToggleScan(scannedCode) {
+        if (!activeStudentCardId) {
+            setActiveStudentCard(scannedCode);
+            setScanStatus(`Ausweis gesetzt: ${activeStudentCardId}`, 'ok');
+            return;
+        }
+    
+        try {
+            setScanStatus('Verarbeite Mediencode...', 'warn');
+            const response = await fetch('/api/library_scan_action', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({
+                    student_card_id: activeStudentCardId,
+                    item_code: scannedCode
+                })
+            });
+        
+            const result = await response.json();
+            if (!response.ok || !result.ok) {
+                setScanStatus(result.message || 'Scan-Aktion fehlgeschlagen.', 'error');
+                return;
+            }
+        
+            if (result.action === 'borrowed') {
+                setScanStatus(`Ausgeliehen: ${result.item_name}`, 'ok');
+            } else if (result.action === 'returned') {
+                setScanStatus(`Zurückgegeben: ${result.item_name}`, 'ok');
+            } else {
+                setScanStatus(result.message || 'Aktion durchgeführt.', 'ok');
+            }
+        
+            await loadLibraryItems();
+        } catch (err) {
+            console.error('Quick scan action failed:', err);
+            setScanStatus('Fehler beim Verarbeiten des Scans.', 'error');
+        }
+    }
 
-    // Search input
-    document.getElementById('librarySearch').addEventListener('input', (e) => {
-        currentSearchTerm = (e.target.value || '').toLowerCase();
-        applyFiltersAndSearch(true);
-    });
+    function scanIntoEditCode() {
+        const scanReaderWrap = document.getElementById('scanReaderWrap');
+        const editCodeInput = document.getElementById('edit-code4');
+        const scanEditBtn = document.getElementById('scan-edit-code-btn');
+        if (!scanReaderWrap || !editCodeInput || !scanEditBtn) {
+            return;
+        }
+    
+        if (scannerRunning && scanReaderWrap.style.display !== 'none') {
+            stopScanner();
+            scanEditBtn.textContent = 'Barcode scannen';
+            return;
+        }
+    
+        scanEditBtn.textContent = 'Scanner schließen';
+    
+        startScanner(function(decodedText) {
+            editCodeInput.value = decodedText;
+            if(typeof validateCodeField === "function") {
+                validateCodeField(editCodeInput, document.getElementById('edit-item-id')?.value || null);
+            }
+            scanEditBtn.textContent = 'Barcode scannen';
+        });
+    }
 
-    document.getElementById('loadMoreBtn').addEventListener('click', () => {
-        renderedCount = Math.min(renderedCount + RENDER_BATCH_COUNT, visibleItems.length);
-        renderItems();
-    });
+    // =========================================================================
+    // 4. UI INTERACTIONS & UTILITIES
+    // =========================================================================
+    function borrowItem(itemId) {
+        const selectedItem = (libraryItems || []).find(item => item._id === itemId);
+        if (selectedItem && selectedItem.LibraryDisplayStatus === 'damaged') {
+            alert('Dieses Medium ist als defekt/zerstört markiert und kann nicht ausgeliehen werden.');
+            return;
+        }
+    
+        const defaultCardId = activeStudentCardId || '';
+        const cardId = (window.prompt('Bitte Schülerausweis-ID eingeben:', defaultCardId) || '').trim().toUpperCase();
+        if (!cardId) {
+            alert('Ausleihe abgebrochen: Für Bibliotheksmedien ist eine gültige Schülerausweis-ID erforderlich.');
+            return;
+        }
+    
+        setActiveStudentCard(cardId);
+    
+        const durationInput = (window.prompt('Ausleihdauer in Tagen (optional):') || '').trim();
+        const maxAvailable = Math.max(1, parseInt(selectedItem?.AvailableGroupedCount || selectedItem?.Quantity || 1, 10) || 1);
+        const countPrompt = (window.prompt(`Anzahl ausleihen? (Standard: 1, verfügbar: ${maxAvailable})`, '1') || '').trim();
+        let borrowCount = parseInt(countPrompt || '1', 10);
+        if (!Number.isFinite(borrowCount) || borrowCount < 1) {
+            borrowCount = 1;
+        }
+        if (borrowCount > maxAvailable) {
+            alert(`Es sind nur ${maxAvailable} Exemplar(e) verfügbar.`);
+            return;
+        }
+    
+        const form = document.createElement('form');
+        form.method = 'POST';
+        form.action = `/ausleihen/${itemId}`;
+    
+        const csrfField = document.createElement('input');
+        csrfField.type = 'hidden';
+        csrfField.name = 'csrf_token';
+        csrfField.value = '{{ csrf_token }}';
+        form.appendChild(csrfField);
+    
+        const cardField = document.createElement('input');
+        cardField.type = 'hidden';
+        cardField.name = 'borrower_card_id';
+        cardField.value = cardId;
+        form.appendChild(cardField);
+    
+        const returnTargetField = document.createElement('input');
+        returnTargetField.type = 'hidden';
+        returnTargetField.name = 'return_to';
+        returnTargetField.value = 'library';
+        form.appendChild(returnTargetField);
+    
+        if (durationInput) {
+            const durationField = document.createElement('input');
+            durationField.type = 'hidden';
+            durationField.name = 'borrow_duration_days';
+            durationField.value = durationInput;
+            form.appendChild(durationField);
+        }
+    
+        const countField = document.createElement('input');
+        countField.type = 'hidden';
+        countField.name = 'exemplare_count';
+        countField.value = String(borrowCount || 1);
+        form.appendChild(countField);
+    
+        document.body.appendChild(form);
+        form.submit();
+    }
+
+    function setScanStatus(message, kind = '') {
+        const el = document.getElementById('scanStatus');
+        if (!el) return;
+        el.textContent = message;
+        el.classList.remove('ok', 'warn', 'error');
+        if (kind) el.classList.add(kind);
+    }
+    
+    function setActiveStudentCard(cardId) {
+        activeStudentCardId = (cardId || '').trim().toUpperCase();
+        const input = document.getElementById('activeStudentCard');
+        if (input) input.value = activeStudentCardId;
+    }
+    
+    function normalizeScannedCode(code) {
+        return (code || '').trim();
+    }
 
-    // Helper functions
     function getItemTypeLabel(type) {
         const labels = { 'book': 'Buch', 'cd': 'CD', 'dvd': 'DVD', 'other': 'Sonstige' };
         return labels[type] || type;
@@ -835,7 +1044,6 @@
     }
 
     function showItemDetail(itemId) {
-        // Load and show detail modal
         fetch(`/api/item_detail/${itemId}`)
             .then(r => r.text())
             .then(html => {
@@ -849,335 +1057,165 @@
         document.getElementById('detailModal').style.display = 'none';
     }
 
-        // Keep track of the scanner state globally/outer scope
-    let scannerRunning = false;
-    let lastScanValue = null;
-    let lastScanAt = 0;
-    let activeStudentCardId = ''; // Managed globally by your system
-
-    function borrowItem(itemId) {
-        const selectedItem = (libraryItems || []).find(item => item._id === itemId);
-        if (selectedItem && selectedItem.LibraryDisplayStatus === 'damaged') {
-            alert('Dieses Medium ist als defekt/zerstör markiert und kann nicht ausgeliehen werden.');
-            return;
-        }
-
-        const defaultCardId = activeStudentCardId || '';
-        const cardId = (window.prompt('Bitte Schülerausweis-ID eingeben:', defaultCardId) || '').trim().toUpperCase();
-        if (!cardId) {
-            alert('Ausleihe abgebrochen: Für Bibliotheksmedien ist eine gültige Schülerausweis-ID erforderlich.');
-            return;
-        }
-
-        setActiveStudentCard(cardId);
-
-        const durationInput = (window.prompt('Ausleihdauer in Tagen (optional):') || '').trim();
-        const maxAvailable = Math.max(1, parseInt(selectedItem?.AvailableGroupedCount || selectedItem?.Quantity || 1, 10) || 1);
-        const countPrompt = (window.prompt(`Anzahl ausleihen? (Standard: 1, verfügbar: ${maxAvailable})`, '1') || '').trim();
-        let borrowCount = parseInt(countPrompt || '1', 10);
-        if (!Number.isFinite(borrowCount) || borrowCount < 1) {
-            borrowCount = 1;
-        }
-        if (borrowCount > maxAvailable) {
-            alert(`Es sind nur ${maxAvailable} Exemplar(e) verfügbar.`);
-            return;
-        }
-
-        const form = document.createElement('form');
-        form.method = 'POST';
-        form.action = `/ausleihen/${itemId}`;
-
-        const csrfField = document.createElement('input');
-        csrfField.type = 'hidden';
-        csrfField.name = 'csrf_token';
-        csrfField.value = '{{ csrf_token }}';
-        form.appendChild(csrfField);
-
-        const cardField = document.createElement('input');
-        cardField.type = 'hidden';
-        cardField.name = 'borrower_card_id';
-        cardField.value = cardId;
-        form.appendChild(cardField);
-
-        const returnTargetField = document.createElement('input');
-        returnTargetField.type = 'hidden';
-        returnTargetField.name = 'return_to';
-        returnTargetField.value = 'library';
-        form.appendChild(returnTargetField);
-
-        if (durationInput) {
-            const durationField = document.createElement('input');
-            durationField.type = 'hidden';
-            durationField.name = 'borrow_duration_days';
-            durationField.value = durationInput;
-            form.appendChild(durationField);
-        }
-
-        const countField = document.createElement('input');
-        countField.type = 'hidden';
-        countField.name = 'exemplare_count';
-        countField.value = String(borrowCount || 1);
-        form.appendChild(countField);
-
-        document.body.appendChild(form);
-        form.submit();
-    }
-
-    function setScanStatus(message, kind = '') {
-        const el = document.getElementById('scanStatus');
-        if (!el) return;
-        el.textContent = message;
-        el.classList.remove('ok', 'warn', 'error');
-        if (kind) {
-            el.classList.add(kind);
-        }
-    }
-
-    function setActiveStudentCard(cardId) {
-        activeStudentCardId = (cardId || '').trim().toUpperCase();
-        const input = document.getElementById('activeStudentCard');
-        if (input) {
-            input.value = activeStudentCardId;
-        }
-    }
-
-    function normalizeScannedCode(code) {
-        return (code || '').trim();
-    }
-
-    async function processQuickToggleScan(scannedCode) {
-        if (!activeStudentCardId) {
-            setActiveStudentCard(scannedCode);
-            setScanStatus(`Ausweis gesetzt: ${activeStudentCardId}`, 'ok');
-            return;
-        }
-
-        try {
-            setScanStatus('Verarbeite Mediencode...', 'warn');
-            const response = await fetch('/api/library_scan_action', {
-                method: 'POST',
-                headers: {'Content-Type': 'application/json'},
-                body: JSON.stringify({
-                    student_card_id: activeStudentCardId,
-                    item_code: scannedCode
-                })
-            });
-
-            const result = await response.json();
-            if (!response.ok || !result.ok) {
-                setScanStatus(result.message || 'Scan-Aktion fehlgeschlagen.', 'error');
-                return;
-            }
-
-            if (result.action === 'borrowed') {
-                setScanStatus(`Ausgeliehen: ${result.item_name}`, 'ok');
-            } else if (result.action === 'returned') {
-                setScanStatus(`Zurückgegeben: ${result.item_name}`, 'ok');
-            } else {
-                setScanStatus(result.message || 'Aktion durchgeführt.', 'ok');
-            }
-
-            await loadLibraryItems();
-        } catch (err) {
-            console.error('Quick scan action failed:', err);
-            setScanStatus('Fehler beim Verarbeiten des Scans.', 'error');
-        }
-    }
-
-    function handleScanSuccess(decodedText) {
-        const scannedCode = normalizeScannedCode(decodedText);
-        if (!scannedCode) return;
-
-        const now = Date.now();
-        if (scannedCode === lastScanValue && (now - lastScanAt) < 1500) {
-            return;
-        }
-        lastScanValue = scannedCode;
-        lastScanAt = now;
-
-        const mode = (document.getElementById('scanModeSelect') || {}).value || 'card_only';
-        if (mode === 'card_only') {
-            setActiveStudentCard(scannedCode);
-            setScanStatus(`Ausweis gesetzt: ${activeStudentCardId}`, 'ok');
-            return;
-        }
-
-        processQuickToggleScan(scannedCode);
-    }
-
-    // Global Quagga reader hook
-    Quagga.onDetected(function(data) {
-        if (data && data.codeResult && data.codeResult.code) {
-            handleScanSuccess(data.codeResult.code);
-        }
-    });
-
-    async function startScanner() {
-        if (scannerRunning) return;
-
-        const readerWrap = document.getElementById('scanReaderWrap');
-        const toggleBtn = document.getElementById('toggleScannerBtn');
-        if (readerWrap) readerWrap.style.display = 'block';
-
-        setScanStatus('Initializing camera...', 'warn');
-
-        Quagga.init({
-            inputStream: {
-                name: "Live",
-                type: "LiveStream",
-                // Points to the interior viewport layout box
-                target: document.querySelector('#libraryQrReader'), 
-                constraints: {
-                    width: 640,
-                    height: 480,
-                    facingMode: "environment" // Force rear mobile lenses
-                },
-            },
-            decoder: {
-                // Limited down precisely to standard library/ID configurations
-                readers: [
-                    "code_128_reader", 
-                    "ean_reader", 
-                    "code_39_reader", 
-                    "upc_reader", 
-                    "codabar_reader", 
-                    "i2of5_reader" // Matches original 'ITF' format mapping
-                ]
-            } 
-        }, function(err) {
-            if (err) {
-                console.error('Scanner start failed:', err);
-                if (readerWrap) readerWrap.style.display = 'none';
-                const detail = (err && (err.message || err.name)) ? ` (${err.message || err.name})` : '';
-                setScanStatus(`Scanner konnte nicht gestartet werden${detail}`, 'error');
-                return;
-            }
-
-            Quagga.start();
-            scannerRunning = true;
-            if (toggleBtn) toggleBtn.textContent = 'Scanner stoppen';
-            setScanStatus('Scanner aktiv. Jetzt Code scannen.', 'warn');
-        });
-    }
-
-    async function stopScanner() {
-        if (!scannerRunning) return;
-        const readerWrap = document.getElementById('scanReaderWrap');
-        const toggleBtn = document.getElementById('toggleScannerBtn');
-
-        Quagga.stop();
-
-        scannerRunning = false;
-        if (readerWrap) readerWrap.style.display = 'none';
-        if (toggleBtn) toggleBtn.textContent = 'Scanner starten';
-        setScanStatus('Scanner gestoppt.', 'warn');
-    }
-
+    // =========================================================================
+    // 5. EVENT LISTENERS INITIALIZATION & ON-LOAD INITIALIZER
+    // =========================================================================
     function wireScannerUi() {
         const toggleBtn = document.getElementById('toggleScannerBtn');
         const resetBtn = document.getElementById('resetCardBtn');
         const modeSelect = document.getElementById('scanModeSelect');
-
+    
         if (toggleBtn) {
             toggleBtn.addEventListener('click', async () => {
                 if (scannerRunning) {
                     await stopScanner();
                 } else {
-                    await startScanner();
+                    await startScanner(null);
                 }
             });
         }
-
+    
         if (resetBtn) {
             resetBtn.addEventListener('click', () => {
                 setActiveStudentCard('');
                 setScanStatus('Ausweis zurückgesetzt. Bitte neu scannen.', 'warn');
             });
         }
-
+    
         if (modeSelect) {
             modeSelect.addEventListener('change', () => {
                 if (modeSelect.value === 'quick_toggle' && !activeStudentCardId) {
                     setScanStatus('Schnellmodus: zuerst Schülerausweis scannen.', 'warn');
                 } else if (modeSelect.value === 'card_only') {
-                    setScanStatus('Modus aktiv: Nur Ausweis erfassen.', 'warn');
-                } else {
-                    setScanStatus('Schnellmodus aktiv: jetzt Mediencode scannen.', 'warn');
+                    setScanStatus('Nur Ausweis-Modus aktiv.', 'warn');
                 }
             });
         }
     }
 
-    function getLibraryItemById(itemId) {
-        return libraryItems.find(i => String(i._id) === String(itemId));
-    }
+    // Run when DOM structure is entirely ready
+    document.addEventListener('DOMContentLoaded', () => {
+        wireScannerUi();       // Setup scanner control buttons 
+        loadLibraryItems();   // Fetch your database items right away!
 
+        // Safely connect standard Filters and Search inputs inside DOMContentLoaded
+        const filterToggleBtn = document.getElementById('filterToggleBtn');
+        if (filterToggleBtn) {
+            filterToggleBtn.addEventListener('click', () => {
+                filterPanelOpen = !filterPanelOpen;
+                document.getElementById('filterPanel').classList.toggle('open');
+                filterToggleBtn.classList.toggle('active');
+            });
+        }
+
+        const applyFilterBtn = document.getElementById('applyFilterBtn');
+        if (applyFilterBtn) {
+            applyFilterBtn.addEventListener('click', () => {
+                activeFilters.isbn = document.getElementById('filterISBN').value.toLowerCase();
+                activeFilters.type = document.getElementById('filterType').value;
+                activeFilters.status = document.getElementById('filterStatus').value;
+                applyFiltersAndSearch(true);
+            });
+        }
+
+        const clearFilterBtn = document.getElementById('clearFilterBtn');
+        if (clearFilterBtn) {
+            clearFilterBtn.addEventListener('click', () => {
+                document.getElementById('filterISBN').value = '';
+                document.getElementById('filterType').value = '';
+                document.getElementById('filterStatus').value = '';
+                activeFilters = { isbn: '', type: '', status: '' };
+                applyFiltersAndSearch(true);
+            });
+        }
+
+        const librarySearch = document.getElementById('librarySearch');
+        if (librarySearch) {
+            librarySearch.addEventListener('input', (e) => {
+                currentSearchTerm = (e.target.value || '').toLowerCase();
+                applyFiltersAndSearch(true);
+            });
+        }
+
+        const loadMoreBtn = document.getElementById('loadMoreBtn');
+        if (loadMoreBtn) {
+            loadMoreBtn.addEventListener('click', () => {
+                renderedCount = Math.min(renderedCount + RENDER_BATCH_COUNT, visibleItems.length);
+                renderItems();
+            });
+        }
+
+        // Edit Modal Form processing
+        const editForm = document.getElementById('editLibraryForm');
+        if (editForm) {
+            editForm.addEventListener('submit', async function(e) {
+                e.preventDefault(); 
+
+                const itemId = document.getElementById('editLibraryItemId').value;
+
+                const updatedData = {
+                    name: document.getElementById('editLibraryName').value,
+                    item_type: document.getElementById('editLibraryType').value,
+                    isbn: document.getElementById('editLibraryIsbn').value,
+                    code_4: document.getElementById('editLibraryCode4').value, 
+                    ort: document.getElementById('editLibraryLocation').value,
+                    beschreibung: document.getElementById('editLibraryDescription').value
+                };
+
+                try {
+                    const response = await fetch(`/api/library_item/${itemId}/update`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'X-CSRFToken': '{{ csrf_token }}', 
+                            'X-CSRF-Token': '{{ csrf_token }}'
+                        },
+                        body: JSON.stringify(updatedData)
+                    });
+
+                    const result = await response.json();
+
+                    if (response.ok && result.ok) {
+                        alert(result.message || 'Medium erfolgreich aktualisiert!');
+                        closeEditLibraryModal();
+
+                        pagingState.loading = false; 
+                        loadLibraryItems(); 
+                    } else {
+                        alert(result.message || 'Fehler beim Speichern der Änderungen.');
+                    }
+                } catch (error) {
+                    console.error('Update failed:', error);
+                    alert('Netzwerkfehler beim Aktualisieren des Mediums.');
+                }
+            });
+        }
+    });
+
+    // Modal Control Functions (accessible globally from table buttons)
     function openEditLibraryItem(itemId) {
-        const item = getLibraryItemById(itemId);
+        const item = libraryItems.find(i => i._id === itemId);
+        
         if (!item) {
-            alert('Element nicht gefunden.');
+            alert('Fehler: Das Medium konnte nicht gefunden werden.');
             return;
         }
 
-        const modal = document.getElementById('editLibraryModal');
+        // Populate the form fields - Using correct German properties from MongoDB fields
         document.getElementById('editLibraryItemId').value = item._id || '';
         document.getElementById('editLibraryName').value = item.Name || '';
-        document.getElementById('editLibraryAuthor').value = item.Autor || item.Author || '';
-        document.getElementById('editLibraryDescription').value = item.Beschreibung || '';
-        document.getElementById('editLibraryLocation').value = item.Ort || '';
+        document.getElementById('editLibraryType').value = item.ItemType || 'book';
         document.getElementById('editLibraryIsbn').value = item.ISBN || '';
-        document.getElementById('editLibraryCode4').value = item.Code_4 || '';
-        document.getElementById('editLibraryType').value = (item.ItemType || 'book');
-        modal.style.display = 'flex';
+        document.getElementById('editLibraryCode4').value = item.Code_4 || item.Code4 || '';
+        document.getElementById('editLibraryLocation').value = item.Ort || ''; 
+        document.getElementById('editLibraryDescription').value = item.Beschreibung || '';
+
+        document.getElementById('editLibraryModal').style.display = 'flex'; 
     }
 
     function closeEditLibraryModal() {
-        const modal = document.getElementById('editLibraryModal');
-        modal.style.display = 'none';
+        document.getElementById('editLibraryModal').style.display = 'none';
     }
-
-    async function submitEditLibraryItem(event) {
-        event.preventDefault();
-        const itemId = document.getElementById('editLibraryItemId').value;
-        const payload = {
-            name: document.getElementById('editLibraryName').value,
-            autor: document.getElementById('editLibraryAuthor').value,
-            beschreibung: document.getElementById('editLibraryDescription').value,
-            ort: document.getElementById('editLibraryLocation').value,
-            isbn: document.getElementById('editLibraryIsbn').value,
-            code_4: document.getElementById('editLibraryCode4').value,
-            item_type: document.getElementById('editLibraryType').value
-        };
-
-        try {
-            const response = await fetch(`/api/library_item/${itemId}/update`, {
-                method: 'POST',
-                headers: {'Content-Type': 'application/json'},
-                body: JSON.stringify(payload)
-            });
-            const result = await response.json();
-            if (!response.ok || !result.ok) {
-                alert(result.message || 'Bearbeiten fehlgeschlagen.');
-                return;
-            }
-            closeEditLibraryModal();
-            await loadLibraryItems();
-            setScanStatus('Bibliotheksmedium aktualisiert.', 'ok');
-        } catch (err) {
-            console.error('Library edit failed:', err);
-            alert('Fehler beim Bearbeiten des Bibliotheksmediums.');
-        }
-    }
-
-    // Load on page init
-    document.addEventListener('DOMContentLoaded', () => {
-        loadLibraryItems();
-        wireScannerUi();
-        const editForm = document.getElementById('editLibraryForm');
-        if (editForm) {
-            editForm.addEventListener('submit', submitEditLibraryItem);
-        }
-    });
 </script>
 
 <div id="editLibraryModal" class="modal" style="display:none;">
@@ -1191,10 +1229,6 @@
                     <label for="editLibraryName">Titel</label>
                     <input id="editLibraryName" required>
                 </div>
-                <div>
-                    <label for="editLibraryAuthor">Autor/Künstler</label>
-                    <input id="editLibraryAuthor">
-                </div>
                 <div>
                     <label for="editLibraryType">Medientyp</label>
                     <select id="editLibraryType">
@@ -1229,4 +1263,4 @@
         </form>
     </div>
 </div>
-{% endblock %}
+{% endblock %}

Web/templates/license.html

@@ -28,11 +28,10 @@
             <li class="nav-item" role="presentation">
                 <button class="nav-link" id="tab-legal" data-bs-toggle="tab" data-bs-target="#pane-legal"
                     type="button" role="tab">Rechtsgrundlage</button>
-            </li>
         </ul>
 
         <!-- ── NOTICE ────────────────────────────────────────────────────── -->
-        <div class="tab-pane fade" id="pane-notice" role="tabpanel">
+        <div class="tab-pane" id="pane-notice" role="tabpanel">
         <div class="license-content">
             <h2>NOTICE – Urheberrechtliche Hinweise</h2>
             <p><strong>Invario Modul Suite</strong><br>Copyright © 2026 Invario UG</p>
@@ -59,14 +58,14 @@
 
             <h4>Frontend / Laufzeit-Assets</h4>
             <ul>
-                <li>html5-qrcode (MIT) © 2020-2025 Manoj Brahmbhatt (mebjas)</li>
+                <li>quagga2 (MIT) © 2014 Christoph Oberhofer, © 2019 Eric Blade and contributors</li>
             </ul>
             <hr>
         </div>
         </div><!-- /#pane-notice -->
 
         <!-- ── DATENSCHUTZ ───────────────────────────────────────────────── -->
-        <div class="tab-pane fade" id="pane-privacy" role="tabpanel">
+        <div class="tab-pane" id="pane-privacy" role="tabpanel">
         <div class="license-content">
             <h2>Datenschutzerklärung (Privacy Policy)</h2>
 
@@ -108,7 +107,7 @@
         </div><!-- /#pane-privacy -->
 
         <!-- ── SICHERHEIT ────────────────────────────────────────────────── -->
-        <div class="tab-pane fade" id="pane-security" role="tabpanel">
+        <div class="tab-pane" id="pane-security" role="tabpanel">
         <div class="license-content">
             <h2>Sicherheitsrichtlinie (Security Policy)</h2>
 
@@ -129,7 +128,7 @@
         </div><!-- /#pane-security -->
 
         <!-- ── DATENVERARBEITUNG ─────────────────────────────────────────── -->
-        <div class="tab-pane fade" id="pane-data" role="tabpanel">
+        <div class="tab-pane" id="pane-data" role="tabpanel">
         <div class="license-content">
             <h2>Dokumentation der Datenverarbeitung (VVT)</h2>
 
@@ -157,7 +156,7 @@
         </div><!-- /#pane-data -->
 
         <!-- ── RECHTSGRUNDLAGE ───────────────────────────────────────────── -->
-        <div class="tab-pane fade" id="pane-legal" role="tabpanel">
+        <div class="tab-pane" id="pane-legal" role="tabpanel">
         <div class="license-content">
             <h2>Rechtsgrundlage der Nutzung</h2>
             <p>Um das Inventarsystem DSGVO-konform zu betreiben, muss der Betreiber eine der folgenden Grundlagen festlegen:</p>
@@ -170,9 +169,6 @@
                     Einwilligung vorliegen (Art. 6 Abs. 1 lit. a DSGVO).</li>
             </ol>
         </div>
-        </div><!-- /#pane-legal -->
-
-        </div><!-- /.tab-content -->
     </div>
 </div>
 

Web/templates/main.html

@@ -373,7 +373,7 @@
             
             <div class="filter-group">
                 <div class="filter-header">
-                    <label>Thema:</label>
+                    <label>Schlagwort:</label>
                     <button type="button" class="filter-toggle" onclick="toggleFilterDropdown('filter3-dropdown')">▼</button>
                     <button type="button" class="clear-filter" onclick="clearFilter(3)">Clear</button>
                 </div>
@@ -420,7 +420,7 @@
             <span>Ort</span>
             <span>Unterrichtsfach</span>
             <span>Jahrgangsstufe</span>
-            <span>Thema</span>
+            <span>Schlagwort</span>
             <span>Barcode</span>
         </div>
         <div id="items-container" class="items-container">
@@ -1057,7 +1057,7 @@
                                 <p class="item-col-location"><strong>Ort:</strong> ${item.Ort || '-'}</p>
                                 <p class="item-col-filter1"><strong>Unterrichtsfach:</strong> ${filter1Display}${filter1More}</p>
                                 <p class="item-col-filter2"><strong>Jahrgangsstufe:</strong> ${filter2Display}${filter2More}</p>
-                                <p class="item-col-filter3"><strong>Thema:</strong> ${filter3Display}${filter3More}</p>
+                                <p class="item-col-filter3"><strong>Schlagwort:</strong> ${filter3Display}${filter3More}</p>
                                 <p class="item-col-code"><strong>Barcode:</strong> ${item.Code_4 || '-'}</p>
                                 <p class="item-col-count"><strong>Anzahl:</strong> ${groupedCount}</p>
                                 ${isGroupedItem ? `<p class="item-col-count"><strong>Verfügbar:</strong> ${availableGroupedCount}</p>` : ''}
@@ -1682,7 +1682,7 @@
                 </div>
                 
                 <div class="detail-group">
-                    <div class="detail-label">Thema:</div>
+                    <div class="detail-label">Schlagwort:</div>
                     <div class="detail-value">${filter3Array.join(', ') || '-'}</div>
                 </div>
                 

Web/templates/main_admin.html

@@ -2395,7 +2395,7 @@ document.addEventListener('DOMContentLoaded', ()=>{
             
             <div class="filter-group">
                 <div class="filter-header">
-                    <label>Thema:</label>
+                    <label>Schlagwort:</label>
                     <button type="button" class="filter-toggle" onclick="toggleFilterDropdown('filter3-dropdown')">▼</button>
                     <button type="button" class="clear-filter" onclick="clearFilter(3)">Clear</button>
                 </div>
@@ -2446,7 +2446,7 @@ document.addEventListener('DOMContentLoaded', ()=>{
             <span>Ort</span>
             <span>Unterrichtsfach</span>
             <span>Jahrgangsstufe</span>
-            <span>Thema</span>
+            <span>Schlagwort</span>
             <span>Barcode</span>
             <span>Anzahl</span>
         </div>
@@ -2567,7 +2567,7 @@ document.addEventListener('DOMContentLoaded', ()=>{
                         </div>
                     </div>
                     
-                    <h3>Thema:</h3>
+                    <h3>Schlagwort:</h3>
                     <div class="multi-filter">
                         <div class="form-group">
                             <label for="edit-filter3-1">Wert 1:</label>
@@ -3686,7 +3686,7 @@ document.addEventListener('DOMContentLoaded', ()=>{
                                 <p class="item-col-location"><strong>Ort:</strong> ${item.Ort || '-'}</p>
                                 <p class="item-col-filter1"><strong>Unterrichtsfach:</strong> ${filter1Display}${filter1More}</p>
                                 <p class="item-col-filter2"><strong>Jahrgangsstufe:</strong> ${filter2Display}${filter2More}</p>
-                                <p class="item-col-filter3"><strong>Thema:</strong> ${filter3Display}${filter3More}</p>
+                                <p class="item-col-filter3"><strong>Schlagwort:</strong> ${filter3Display}${filter3More}</p>
                                 <p class="item-col-code"><strong>Barcode:</strong> ${item.Code_4 || '-'}</p>
                                 <p class="item-col-count"><strong>Anzahl:</strong> ${groupedCount}</p>
                                 ${hasDamage ? `<div class="damage-badge">${damageCount > 0 ? `Schäden gemeldet: ${damageCount}` : 'Schäden gemeldet'}</div>` : ''}
@@ -4229,7 +4229,7 @@ document.addEventListener('DOMContentLoaded', ()=>{
                 document.getElementById('edit-filter2-3').value = filter2Array[2] || '';
                 document.getElementById('edit-filter2-4').value = filter2Array[3] || '';
 
-                // Fill in filter 3 (Thema)
+                // Fill in filter 3 (Schlagwort)
                 const filter3Array = Array.isArray(item.Filter3) ? item.Filter3 : (item.Filter3 ? [item.Filter3] : []);
                 document.getElementById('edit-filter3-1').value = filter3Array[0] || '';
                 document.getElementById('edit-filter3-2').value = filter3Array[1] || '';
@@ -4543,7 +4543,7 @@ document.addEventListener('DOMContentLoaded', ()=>{
                 </div>
                 
                 <div class="detail-group">
-                    <div class="detail-label">Thema:</div>
+                    <div class="detail-label">Schlagwort:</div>
                     <div class="detail-value">${filter3Array.join(', ') || '-'}</div>
                 </div>
                 

Web/templates/termin_client.html

@@ -39,13 +39,19 @@
     <div class="row justify-content-center">
         <div class="col-12 col-xxl-11">
             <div class="row g-4">
+                
                 <div class="col-12 col-lg-4">
                     <div class="card border-0 shadow-lg rounded-4 h-100">
                         <div class="card-body p-4 p-md-5">
                             <p class="text-uppercase text-muted fw-semibold mb-2">Terminplaner</p>
-                            <h1 class="h3 fw-bold mb-3">Termin buchen</h1>
-                            <p class="text-muted mb-4">Wählen Sie im Kalender einen freien Slot aus. Den gewählten Termin können Sie danach direkt wie in einem Kalender-Block verschieben.</p>
-
+                            {% if can_view_booking_names %}
+                                <h1 class="h3 fw-bold mb-3">Termin Übersicht - {{ available.title }}</h1>
+                                <p class="text-muted mb-4">Hier können Sie alle Buchungen, die bereits eingegangen sind, einsehen und verwalten.</p>
+                            {% else %}
+                                <h1 class="h3 fw-bold mb-3">Termin buchen - {{ available.title }}</h1>
+                                <p class="text-muted mb-4">Wählen Sie im Kalender einen freien Slot aus. Den gewählten Termin können Sie danach direkt wie in einem Kalender-Block verschieben.</p>
+                            {% endif %}
+                            
                             <div class="p-3 rounded-3 bg-light mb-3">
                                 <div class="fw-semibold">Zeitraum</div>
                                 <div>{{ available.date_start }} bis {{ available.date_end }}</div>
@@ -58,23 +64,24 @@
                                 <div class="fw-semibold">Slot-Länge</div>
                                 <div>{{ available.slot_lenght }} Minuten</div>
                             </div>
-
+                            
+                            {% if not can_view_booking_names %}
                             <div class="p-3 rounded-3 bg-light mb-3">
                                 <div class="fw-semibold mb-2">Gewählter Termin</div>
                                 <div id="selected-slot-badge" class="text-muted small">Noch kein Slot ausgewählt.</div>
                             </div>
+                            {% endif %}
 
                             {% if available.slots_booked %}
                             <div class="p-3 rounded-3 bg-light">
                                 <div class="fw-semibold mb-2">Bereits gebucht</div>
-                                <ul class="mb-0 small">
+                                <ul class="mb-0 small text-muted">
                                     {% for booking in available.slots_booked %}
                                     <li>
-                                        {{ booking.start }}
-                                        {% if can_view_booking_names and booking.name %}
-                                        - {{ booking.name }}
+                                        {% if booking is mapping %}
+                                            {{ booking.get('start', '') }} - Belegt
                                         {% else %}
-                                        - Belegt
+                                            {{ booking[0] }} - {% if can_view_booking_names %}<span class="fw-semibold text-dark">{{ booking[1] }}</span>{% else %}Belegt{% endif %}
                                         {% endif %}
                                     </li>
                                     {% endfor %}
@@ -84,39 +91,161 @@
                         </div>
                     </div>
                 </div>
+
                 <div class="col-12 col-lg-8">
                     <div class="card border-0 shadow-lg rounded-4 h-100">
                         <div class="card-body p-4 p-md-5 bg-white">
-                            <h2 class="h4 fw-bold mb-3">Termin im Kalender auswählen</h2>
-
-                            <div class="day-slider-wrap mb-3">
-                                <div class="d-flex justify-content-between align-items-center gap-2 mb-2">
-                                    <span class="small text-muted">Tag wählen</span>
-                                    <strong id="day-slider-label" class="small"></strong>
+                            
+                            {% if can_view_booking_names %}
+                                <!-- ADMIN / AUTOREN ANSICHT -->
+                                <div class="d-flex flex-column flex-md-row justify-content-between align-items-md-center gap-3 mb-4">
+                                    <div>
+                                        <h2 class="h4 fw-bold mb-0">Eingegangene Buchungen</h2>
+                                        <div class="text-muted small">Verwalten Sie die Termine Ihrer Klienten</div>
+                                    </div>
+                                    <div class="d-flex gap-2 align-self-start align-self-md-center">
+                                        <!-- Neuer CSV Export Button -->
+                                        <a href="{{ url_for('terminplaner.export_csv', appointment_id=appointment_id) }}" class="btn btn-outline-success rounded-3 d-inline-flex align-items-center gap-2">
+                                            <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" class="bi bi-download" viewBox="0 0 16 16">
+                                                <path d="M.5 9.9a.5.5 0 0 1 .5.5v2.5a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v2.5a.5.5 0 0 1 1 0v2.5a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2v2.5a.5.5 0 0 1 .5-.5"/>
+                                                <path d="M7.646 11.854a.5.5 0 0 0 .708 0l3-3a.5.5 0 0 0-.708-.708L8.5 10.293V1.5a.5.5 0 0 0-1 0v8.793L5.354 8.146a.5.5 0 1 0-.708.708z"/>
+                                            </svg>
+                                            Excel / CSV Export
+                                        </a>
+                                        <span class="badge bg-primary rounded-pill fs-6 px-3 d-flex align-items-center">
+                                            {{ available.slots_total - available.slots_left }} von {{ available.slots_total }} belegt
+                                        </span>
+                                    </div>
                                 </div>
-                                <input id="day-slider" type="range" class="form-range m-0" min="0" max="0" value="0">
-                            </div>
-
-                            <div id="client-slot-calendar" class="mb-4"></div>
-
-                            <form id="client-booking-form" method="post" action="{{ url_for('terminplaner.client', appointment_id=appointment_id, tenant=tenant_id) }}" class="vstack gap-3">
-                                <div>
-                                    <label for="start_day_time" class="form-label fw-semibold">Gewünschter Zeitpunkt</label>
-                                    <input type="text" id="start_day_time" name="start_day_time" class="form-control form-control-lg" placeholder="Bitte im Kalender auswählen" readonly required>
-                                    <div class="form-text">Klicken Sie auf einen freien Slot oder verschieben Sie den gewählten Block.</div>
+                                <div class="bg-light p-3 rounded-3 mb-4">
+                                    <div class="row g-2 align-items-center">
+                                        <div class="col-12 col-md-8">
+                                            <label for="table-search" class="form-label small fw-semibold text-muted mb-1">Live-Filter (Name, Uhrzeit, Zusatzfelder...)</label>
+                                            <input type="text" id="table-search" class="form-control form-control-lg bg-white border" placeholder="Suchbegriff eingeben...">
+                                        </div>
+                                        <div class="col-12 col-md-4 d-flex align-items-end h-100 mt-md-4">
+                                            <button type="button" id="clear-filter-btn" class="btn btn-outline-secondary w-100 btn-lg">Filter zurücksetzen</button>
+                                        </div>
+                                    </div>
                                 </div>
-                                <div>
-                                    <label for="client_name" class="form-label fw-semibold">Ihr Name</label>
-                                    <input type="text" id="client_name" name="client_name" class="form-control form-control-lg" placeholder="Vor- und Nachname" required>
+
+                                {% if available.slots_booked %}
+                                <div class="table-responsive">
+                                    <table class="table table-hover align-middle border-top" id="admin-booking-table">
+                                        <thead class="table-light">
+                                            <tr>
+                                                <th scope="col" class="py-3">Zeitpunkt</th>
+                                                <th scope="col" class="py-3">Name</th>
+                                                <!-- Spaltenüberschriften für Custom Fields -->
+                                                {% for field_label in custom_fields %}
+                                                <th scope="col" class="py-3">{{ field_label }}</th>
+                                                {% endfor %}
+                                                <th scope="col" class="py-3 text-end">Aktion</th>
+                                            </tr>
+                                        </thead>
+                                        <tbody id="booking-table-body">
+                                            {# Wir loopen jetzt über die rohen DB-Daten statt über die beschnittene Service-Funktion #}
+                                            {% for booking in appointment_item.get('slots_booked', []) %}
+                                            <tr>
+                                                <!-- 1. ZEITPUNKT -->
+                                                <td class="fw-semibold text-primary py-3 text-nowrap">
+                                                    {{ booking[0] }}
+                                                </td>
+                                            
+                                                <!-- 2. CLIENT NAME -->
+                                                <td>
+                                                    <span class="fw-bold text-dark">{{ booking[1] }}</span>
+                                                </td>
+
+                                                <!-- 3. CUSTOM FIELDS (Präziser Index-Abgleich gegen Spaltenkopf) -->
+                                                {% for field in custom_fields %}
+                                                    <td>
+                                                        {# Prüft ob für dieses Feld eine Antwort am exakt gleichen Index existiert #}
+                                                        {% if booking|length > 2 and booking[2] and booking[2]|length > loop.index0 %}
+                                                            {% set answer = booking[2][loop.index0] %}
+                                                            {{ answer if answer else '<span class="text-muted small">-</span>'|safe }}
+                                                        {% else %}
+                                                            <span class="text-muted small">-</span>
+                                                        {% endif %}
+                                                    </td>
+                                                {% endfor %}
+                                                
+                                                <!-- 4. AKTION (LÖSCHEN) -->
+                                                <td class="text-end">
+                                                    <form method="post" action="{{ url_for('terminplaner.client', appointment_id=appointment_id, tenant=tenant_id) }}" onsubmit="return confirm('Möchten Sie diesen Termin wirklich löschen?');" class="d-inline">
+                                                        <input type="hidden" name="action" value="delete">
+                                                        <input type="hidden" name="slot_time" value="{{ booking[0] }}">
+                                                        <input type="hidden" name="target_client_name" value="{{ booking[1] }}">
+
+                                                        <button type="submit" class="btn btn-sm btn-outline-danger px-3 rounded-3">
+                                                            Löschen
+                                                        </button>
+                                                    </form>
+                                                </td>
+                                            </tr>
+                                            {% endfor %}
+                                        </tbody>
+                                    </table>
                                 </div>
-                                <div class="d-flex flex-column flex-sm-row gap-2 pt-2">
-                                    <button type="submit" class="btn btn-primary btn-lg">Termin buchen</button>
+                                
+                                <div id="no-results-msg" class="text-center py-4 text-muted d-none">
+                                    Keine Buchungen entsprechen Ihrem Filter.
+                                </div>
+                                {% else %}
+                                <div class="text-center py-5 text-muted">
+                                    <p class="mb-0">Bisher sind noch keine Buchungen für diesen Terminplaner eingegangen.</p>
+                                </div>
+                                {% endif %}
+                                
+                                <div class="pt-4 border-top mt-4">
                                     <a class="btn btn-outline-secondary btn-lg" href="{{ url_for('terminplaner.main', tenant=tenant_id) }}">Zur Übersicht</a>
                                 </div>
-                            </form>
+
+                            {% else %}
+                                <h2 class="h4 fw-bold mb-3">Termin im Kalender auswählen</h2>
+
+                                <div class="day-slider-wrap mb-3">
+                                    <div class="d-flex justify-content-between align-items-center gap-2 mb-2">
+                                        <span class="small text-muted">Tag wählen</span>
+                                        <strong id="day-slider-label" class="small"></strong>
+                                    </div>
+                                    <input id="day-slider" type="range" class="form-range m-0" min="0" max="0" value="0">
+                                </div>
+
+                                <div id="client-slot-calendar" class="mb-4"></div>
+
+                                <form id="client-booking-form" method="post" action="{{ url_for('terminplaner.client', appointment_id=appointment_id, tenant=tenant_id) }}" class="vstack gap-3">
+                                    <div>
+                                        <label for="start_day_time" class="form-label fw-semibold">Gewünschter Zeitpunkt</label>
+                                        <input type="text" id="start_day_time" name="start_day_time" class="form-control form-control-lg" placeholder="Bitte im Kalender auswählen" readonly required>
+                                        <div class="form-text">Klicken Sie auf einen freien Slot oder verschieben Sie den gewählten Block.</div>
+                                    </div>
+                                    <div>
+                                        <label for="client_name" class="form-label fw-semibold">Ihr Name</label>
+                                        <input type="text" id="client_name" name="client_name" class="form-control form-control-lg" placeholder="Vor- und Nachname" required>
+                                    </div>
+                                
+                                    {% if custom_fields %}
+                                        {% for field_label in custom_fields %}
+                                        <div>
+                                            <label class="form-label fw-semibold">{{ field_label }}</label>
+                                            <input type="text" name="custom_answers" class="form-control form-control-lg" placeholder="{{ field_label }} eingeben" required>
+                                        </div>
+                                        {% endfor %}
+                                    {% endif %}
+                                    
+                                    <div class="d-flex flex-column flex-sm-row gap-2 pt-2">
+                                        <input type="hidden" name="action" value="book">
+                                        <button type="submit" class="btn btn-primary btn-lg">Termin buchen</button>
+                                        <a class="btn btn-outline-secondary btn-lg" href="{{ url_for('terminplaner.main', tenant=tenant_id) }}">Zur Übersicht</a>
+                                    </div>
+                                </form>
+                            {% endif %}
+
                         </div>
                     </div>
                 </div>
+                
             </div>
         </div>
     </div>
@@ -142,11 +271,58 @@
     </div>
 </div>
 
+<script>
+document.addEventListener('DOMContentLoaded', function () {
+    const searchInput = document.getElementById('table-search');
+    const clearBtn = document.getElementById('clear-filter-btn');
+    const tableBody = document.getElementById('booking-table-body');
+    const noResultsMsg = document.getElementById('no-results-msg');
+
+    if (searchInput && tableBody) {
+        const rows = tableBody.querySelectorAll('tr');
+
+        searchInput.addEventListener('input', function () {
+            const query = this.value.toLowerCase().trim();
+            let visibleRowsCount = 0;
+
+            rows.forEach(row => {
+                // Liest den Textinhalt aller Spalten der Zeile aus
+                const rowText = row.textContent.toLowerCase();
+                
+                if (rowText.includes(query)) {
+                    row.classList.remove('d-none');
+                    visibleRowsCount++;
+                } else {
+                    row.classList.add('d-none');
+                }
+            });
+
+            // Falls kein Filterergebnis gefunden wurde, Nachricht einblenden
+            if (visibleRowsCount === 0 && query !== '') {
+                noResultsMsg.classList.remove('d-none');
+            } else {
+                noResultsMsg.classList.add('d-none');
+            }
+        });
+
+        // Filter zurücksetzen Button
+        if (clearBtn) {
+            clearBtn.addEventListener('click', function () {
+                searchInput.value = '';
+                rows.forEach(row => row.classList.remove('d-none'));
+                noResultsMsg.classList.add('d-none');
+                searchInput.focus();
+            });
+        }
+    }
+});
+</script>
 <script src="https://cdn.jsdelivr.net/npm/fullcalendar@6.1.15/index.global.min.js"></script>
 <script>
     (function () {
         const available = {{ available|tojson }};
         const appointmentId = {{ appointment_id|tojson }};
+        const canViewBookingNames = {{ can_view_booking_names|tojson }}; // Injected from Flask
         const slider = document.getElementById('day-slider');
         const sliderLabel = document.getElementById('day-slider-label');
         const sliderWrap = slider ? slider.closest('.day-slider-wrap') : null;
@@ -160,10 +336,10 @@
         const confirmBookingWithIcsBtn = document.getElementById('confirm-booking-with-ics');
         const modal = modalEl ? new bootstrap.Modal(modalEl) : null;
 
-        const slotLength = Number.parseInt(available.slot_lenght, 10) || 45;
-        const bookedStarts = new Set((available.slots_booked || []).map(function (entry) {
-            return String(entry.start || '').trim();
-        }).filter(Boolean));
+        // Fallback for both spellings of slot length
+        const slotLength = Number.parseInt(available.slot_length || available.slot_lenght, 10) || 45;
+        const clientsPerSlot = Number.parseInt(available.clients_per_slot, 10) || 1;
+        const bookingsByTime = available.bookings_by_time || {};
 
         function formatDateForInput(dateObj) {
             const y = dateObj.getFullYear();
@@ -227,6 +403,8 @@
             return null;
         }
 
+        const fullyBookedSlots = [];
+
         function buildCandidateSlots() {
             const slots = [];
             const allowedDates = dateRangeInclusive(String(available.date_start || ''), String(available.date_end || ''));
@@ -234,9 +412,7 @@
 
             spans.forEach(function (entry) {
                 const parsed = parseTimeSpanEntry(entry);
-                if (!parsed) {
-                    return;
-                }
+                if (!parsed) return;
 
                 const targetDates = parsed.date ? [parsed.date] : allowedDates;
                 targetDates.forEach(function (date) {
@@ -249,10 +425,19 @@
                     let cursor = new Date(from);
                     while (addMinutes(cursor, slotLength) <= to) {
                         const slotStart = formatDateForInput(cursor);
-                        if (!bookedStarts.has(slotStart)) {
+                        const currentBookingsCount = bookingsByTime[slotStart] || 0;
+                        
+                        // Check if the current individual timestamp still has capacity left
+                        if (currentBookingsCount < clientsPerSlot) {
                             slots.push({
                                 start: slotStart,
                                 end: formatDateForInput(addMinutes(cursor, slotLength)),
+                                bookingsCount: currentBookingsCount
+                            });
+                        } else {
+                            fullyBookedSlots.push({
+                                start: slotStart,
+                                end: formatDateForInput(addMinutes(cursor, slotLength))
                             });
                         }
                         cursor = addMinutes(cursor, slotLength);
@@ -267,27 +452,8 @@
         const slotStartSet = new Set(candidateSlots.map(function (slot) { return slot.start; }));
         const allDays = dateRangeInclusive(String(available.date_start || ''), String(available.date_end || ''));
 
-        // Show the requested UI time window from 08:15 to 20:00 and highlight available slots
-        let slotMinTime = '08:15:00';
+        let slotMinTime = '08:00:00';
         let slotMaxTime = '20:00:00';
-        if (candidateSlots.length > 0) {
-            const starts = candidateSlots.map(function (slot) {
-                return new Date(slot.start.replace(' ', 'T') + ':00');
-            }).filter(function (d) { return !Number.isNaN(d.getTime()); });
-            const ends = candidateSlots.map(function (slot) {
-                return new Date(slot.end.replace(' ', 'T') + ':00');
-            }).filter(function (d) { return !Number.isNaN(d.getTime()); });
-
-            // Keep the computed min/max for gap calculations below
-            var computedMinStart = null;
-            var computedMaxEnd = null;
-            if (starts.length > 0 && ends.length > 0) {
-                computedMinStart = starts[0];
-                computedMaxEnd = ends[0];
-                starts.forEach(function (d) { if (d < computedMinStart) computedMinStart = d; });
-                ends.forEach(function (d) { if (d > computedMaxEnd) computedMaxEnd = d; });
-            }
-        }
 
         const visibleStart = allDays[0] || String(available.date_start || '');
         const visibleEndExclusive = allDays.length > 0
@@ -322,14 +488,8 @@
             slotMinTime: slotMinTime,
             slotMaxTime: slotMaxTime,
             nowIndicator: true,
-            validRange: {
-                start: visibleStart,
-                end: visibleEndExclusive,
-            },
-            visibleRange: {
-                start: visibleStart,
-                end: visibleEndExclusive,
-            },
+            validRange: { start: visibleStart, end: visibleEndExclusive },
+            visibleRange: { start: visibleStart, end: visibleEndExclusive },
             headerToolbar: {
                 left: '',
                 center: 'title',
@@ -337,28 +497,22 @@
             },
             events: [],
             eventDrop: function (info) {
-                if (info.event.id !== 'selected-slot') {
-                    return;
-                }
+                if (info.event.id !== 'selected-slot') return;
                 const droppedStart = formatDateForInput(info.event.start);
                 if (!slotStartSet.has(droppedStart)) {
                     info.revert();
-                    window.alert('Dieser Zeitpunkt ist nicht als freier Slot verfügbar.');
+                    window.alert('Dieser Zeitpunkt ist ausgebucht oder nicht verfügbar.');
                     return;
                 }
                 applySelectedSlot(droppedStart);
             },
             eventClick: function (info) {
                 const slotType = info.event.extendedProps ? info.event.extendedProps.slotType : '';
-                if (slotType !== 'free') {
-                    return;
-                }
+                if (slotType !== 'free') return;
                 applySelectedSlot(info.event.extendedProps.slotStart || '');
             }
         });
 
-        // No background greying: show full calendar skeleton and only mark possible slots
-
         function updateSliderLabel() {
             const dateList = dateRangeInclusive(String(available.date_start || ''), String(available.date_end || ''));
             const idx = Number.parseInt(slider.value, 10) || 0;
@@ -377,9 +531,7 @@
                 selectedEvent = null;
             }
 
-            if (!selectedSlot) {
-                return;
-            }
+            if (!selectedSlot) return;
 
             const start = new Date(selectedSlot.replace(' ', 'T') + ':00');
             const end = addMinutes(start, slotLength);
@@ -398,13 +550,9 @@
         function getIcsDownloadUrl() {
             const base = {{ url_for('terminplaner.client_slot_calendar_export', appointment_id=appointment_id, tenant=tenant_id)|tojson }};
             const url = new URL(base, window.location.origin);
-            if (selectedSlot) {
-                url.searchParams.set('start', selectedSlot);
-            }
+            if (selectedSlot) url.searchParams.set('start', selectedSlot);
             const name = String(clientNameInput.value || '').trim();
-            if (name) {
-                url.searchParams.set('name', name);
-            }
+            if (name) url.searchParams.set('name', name);
             return url.toString();
         }
 
@@ -415,14 +563,19 @@
             }
         }
 
-        // No background gaps: keep full skeleton/grid visible
-
-        // Add candidate free slots (blue)
+        // Render Active/Available Slots with Live Seat Counts
         candidateSlots.forEach(function (slot) {
             const start = new Date(slot.start.replace(' ', 'T') + ':00');
             const end = new Date(slot.end.replace(' ', 'T') + ':00');
+            
+            let displayTitle = 'Freier Slot';
+            if (clientsPerSlot > 1) {
+                const remainingSeats = clientsPerSlot - slot.bookingsCount;
+                displayTitle += ' (' + remainingSeats + '/' + clientsPerSlot + ' frei)';
+            }
+
             calendar.addEvent({
-                title: 'Freier Slot',
+                title: displayTitle,
                 start: start,
                 end: end,
                 color: '#0d6efd',
@@ -435,46 +588,54 @@
             });
         });
 
-        (available.slots_booked || []).forEach(function (booking) {
-            const startStr = String(booking.start || '').trim();
-            if (!startStr) {
-                return;
-            }
-            const start = new Date(startStr.replace(' ', 'T') + ':00');
-            const end = addMinutes(start, slotLength);
+        // Client View Optimization: Render solid red events ONLY if a slot is 100% full
+        fullyBookedSlots.forEach(function (slot) {
+            const start = new Date(slot.start.replace(' ', 'T') + ':00');
+            const end = new Date(slot.end.replace(' ', 'T') + ':00');
             calendar.addEvent({
-                title: 'Gebucht' + (booking.name ? ' - ' + booking.name : ''),
+                title: 'Ausgebucht',
                 start: start,
                 end: end,
                 color: '#dc3545',
                 editable: false,
-                display: 'block',
+                display: 'block'
             });
         });
 
+        // Admin Management View: Render detailed name blocks exclusively for management interaction
+        if (canViewBookingNames) {
+            (available.slots_booked || []).forEach(function (booking) {
+                const startStr = String(booking.start || '').trim();
+                if (!startStr) return;
+                const start = new Date(startStr.replace(' ', 'T') + ':00');
+                const end = addMinutes(start, slotLength);
+                calendar.addEvent({
+                    title: 'Belegt: ' + (booking.name || 'Anonym'),
+                    start: start,
+                    end: end,
+                    color: '#9e9e9e',
+                    editable: false,
+                    display: 'block',
+                });
+            });
+        }
+
+        // Event Listeners and Setup
         form.addEventListener('submit', function (ev) {
             if (!selectedSlotInput.value) {
                 ev.preventDefault();
                 window.alert('Bitte zuerst im Kalender einen freien Slot auswählen.');
                 return;
             }
-
-            if (allowImmediateSubmit) {
-                return;
-            }
-
+            if (allowImmediateSubmit) return;
             ev.preventDefault();
-            if (modal) {
-                modal.show();
-            }
+            if (modal) modal.show();
         });
 
         if (confirmBookingOnlyBtn) {
             confirmBookingOnlyBtn.addEventListener('click', function () {
                 allowImmediateSubmit = true;
-                if (modal) {
-                    modal.hide();
-                }
+                if (modal) modal.hide();
                 form.submit();
             });
         }
@@ -482,13 +643,9 @@
         if (confirmBookingWithIcsBtn) {
             confirmBookingWithIcsBtn.addEventListener('click', function () {
                 const icsUrl = confirmBookingWithIcsBtn.getAttribute('data-ics-url') || getIcsDownloadUrl();
-                if (icsUrl) {
-                    window.open(icsUrl, '_blank');
-                }
+                if (icsUrl) window.open(icsUrl, '_blank');
                 allowImmediateSubmit = true;
-                if (modal) {
-                    modal.hide();
-                }
+                if (modal) modal.hide();
                 form.submit();
             });
         }
@@ -509,10 +666,8 @@
         slider.addEventListener('input', function () {
             const idx = Number.parseInt(slider.value, 10) || 0;
             updateSliderLabel();
-            if (allDays[idx]) {
-                if (calendar.view.type === 'timeGridDay') {
-                    calendar.gotoDate(allDays[idx]);
-                }
+            if (allDays[idx] && calendar.view.type === 'timeGridDay') {
+                calendar.gotoDate(allDays[idx]);
             }
         });
 

Web/templates/termin_configure.html

@@ -14,13 +14,17 @@
                 <div class="card-body p-4 p-md-5 bg-white">
                     <form method="post" action="{{ url_for('terminplaner.configure') }}" class="vstack gap-3">
                         <div class="row g-3">
+                            <div class="col-12">
+                                <label for="title" class="form-label fw-semibold">Titel des Terminplans</label>
+                                <input type="text" id="title" name="title" class="form-control form-control-lg" placeholder="z.B. Elternsprechtag Klasse 10a" value="{{ title or '' }}">
+                            </div>
                             <div class="col-12 col-md-6">
                                 <label for="start_date" class="form-label fw-semibold">Startdatum</label>
-                                <input type="date" id="start_date" name="start_date" class="form-control form-control-lg" required>
+                                <input type="date" id="start_date" name="start_date" class="form-control form-control-lg">
                             </div>
                             <div class="col-12 col-md-6">
                                 <label for="end_date" class="form-label fw-semibold">Enddatum</label>
-                                <input type="date" id="end_date" name="end_date" class="form-control form-control-lg" required>
+                                <input type="date" id="end_date" name="end_date" class="form-control form-control-lg">
                             </div>
                         </div>
 
@@ -28,52 +32,77 @@
                             <div class="d-flex flex-column flex-md-row justify-content-between align-items-md-center gap-2 mb-2">
                                 <div>
                                     <label class="form-label fw-semibold mb-0">Zeitfenster pro Tag</label>
-                                    <div class="form-text mb-0">Sobald Start- und Enddatum gesetzt sind, wird für jeden Tag automatisch ein eigener Eintrag erzeugt.</div>
+                                    <div class="form-text mb-0">Die Start-, End- und Pausenzeiten werden auf alle erzeugten Tage angewandt.</div>
                                 </div>
                                 <button type="button" class="btn btn-outline-primary btn-sm" id="build_time_frame">Tage aus Zeitraum erzeugen</button>
                             </div>
 
                             <div class="row g-3 mb-3">
-                                <div class="col-12 col-md-6 col-xl-4">
-                                    <label for="default_day_start" class="form-label fw-semibold">Standard-Startzeit</label>
+                                <div class="col-12 col-sm-6 col-lg-3">
+                                    <label for="default_day_start" class="form-label fw-semibold">Standard-Start</label>
                                     <input type="time" id="default_day_start" class="form-control" value="08:00">
                                 </div>
-                                <div class="col-12 col-md-6 col-xl-4">
-                                    <label for="default_day_end" class="form-label fw-semibold">Standard-Endzeit</label>
-                                    <input type="time" id="default_day_end" class="form-control" value="12:00">
+                                <div class="col-12 col-sm-6 col-lg-3">
+                                    <label for="default_day_end" class="form-label fw-semibold">Standard-Ende</label>
+                                    <input type="time" id="default_day_end" class="form-control" value="16:00">
+                                </div>
+                                <div class="col-12 col-sm-6 col-lg-3">
+                                    <label for="default_pause_start" class="form-label fw-semibold text-danger">Pause von</label>
+                                    <input type="time" id="default_pause_start" class="form-control border-danger-subtle" value="12:00">
+                                </div>
+                                <div class="col-12 col-sm-6 col-lg-3">
+                                    <label for="default_pause_end" class="form-label fw-semibold text-danger">Pause bis</label>
+                                    <input type="time" id="default_pause_end" class="form-control border-danger-subtle" value="12:45">
                                 </div>
                             </div>
 
                             <div id="time_frame_days" class="vstack gap-2"></div>
 
                             <div class="mt-3">
-                                <label for="time_frame" class="form-label fw-semibold">Gespeichertes Zeitfenster</label>
-                                <textarea id="time_frame" name="time_frame" class="form-control font-monospace" rows="5" placeholder="Wird automatisch aus den Tagen erzeugt" required></textarea>
-                                <div class="form-text">Das Formular überträgt die erzeugten Tageszeilen an das Backend. Sie können die Liste hier bei Bedarf noch anpassen.</div>
+                                <label for="time_frame" class="form-label fw-semibold">Gespeichertes Zeitfenster (Übertragung ans Backend)</label>
+                                <textarea id="time_frame" name="time_frame" class="form-control font-monospace" rows="5" placeholder="Wird automatisch aus den Tagen erzeugt" readonly></textarea>
+                                <div class="form-text">Pausen teilen den Tag automatisch in zwei buchbare Blöcke, sodass die Pause sicher blockiert ist.</div>
                             </div>
                         </div>
 
                         <div class="row g-3">
                             <div class="col-12 col-md-6">
-                                <label for="slots_amounts" class="form-label fw-semibold">Anzahl Slots</label>
-                                <input type="number" id="slots_amounts" name="slots_amounts" class="form-control" min="1" value="1" required>
+                                <label for="slot_length" class="form-label fw-semibold">Slot-Länge in Minuten</label>
+                                <input type="number" id="slot_length" name="slot_length" class="form-control form-control-lg" min="1" value="45">
+                            </div>
+                            <div>
+                                <label class="form-label fw-semibold text-primary">Nutzer pro Slot</label>
+                                <input type="number" id="clients_per_slot" name="clients_per_slot" value="1">
                             </div>
                             <div class="col-12 col-md-6">
-                                <label for="slot_lenght" class="form-label fw-semibold">Slot-Länge in Minuten</label>
-                                <input type="number" id="slot_lenght" name="slot_lenght" class="form-control" min="1" value="45" required>
+                                <label class="form-label fw-semibold text-primary">Automatisch berechnete Slots</label>
+                                <div id="slots_amounts_display" class="form-control form-control-lg bg-primary-subtle text-primary fw-bold d-flex align-items-center">0</div>
+                                <input type="hidden" id="slots_amounts" name="slots_amounts" value="0">
+                                <div class="form-text">Wird aus der gebuchten Zeit (abzüglich Pausen) und der Slot-Länge berechnet.</div>
+                            </div>
+                        </div>
+                        <div id="custom-fields-container" class="mt-4">
+                            <h3 class="mb-3">Benutzerdefinierte Felder</h3>
+
+                            <div class="mb-3 custom-field-row">
+                                <input type="text" 
+                                       name="custom_fields" 
+                                       class="form-control form-control-lg custom-dynamic-input" 
+                                       placeholder="Zusatzfeld hinzufügen (z.B. Firma, Kundennummer...)">
                             </div>
                         </div>
 
-                        <div>
-                            <label for="mail" class="form-label fw-semibold">Empfänger-Mails</label>
-                            <input type="text" id="mail" name="mail" class="form-control" placeholder="adresse1@schule.de, adresse2@schule.de">
-                        </div>
-
-                        <div>
-                            <label for="note" class="form-label fw-semibold">Notiz</label>
-                            <textarea id="note" name="note" class="form-control" rows="4" placeholder="Optionaler Einführungstext für die Mail"></textarea>
-                        </div>
+                        {% if mail_service_enabled %}
+                            <div>
+                                <label for="mail" class="form-label fw-semibold">Empfänger-Mails</label>
+                                <input type="text" id="mail" name="mail" class="form-control" placeholder="adresse1@schule.de, adresse2@schule.de">
+                            </div>
 
+                            <div>
+                                <label for="note" class="form-label fw-semibold">Notiz</label>
+                                <textarea id="note" name="note" class="form-control" rows="4" placeholder="Optionaler Einführungstext für die Mail"></textarea>
+                            </div>
+                        {% endif %}
                         <div class="form-check">
                             <input class="form-check-input" type="checkbox" id="add_to_calendar" name="add_to_calendar" {% if add_to_calendar %}checked{% endif %}>
                             <label class="form-check-label fw-semibold" for="add_to_calendar">Kalendereintrag für den Nutzer erzeugen</label>
@@ -92,7 +121,7 @@
             <div class="alert alert-success mt-4 shadow-sm rounded-4">
                 <div class="fw-bold mb-1">Buchungslink erstellt</div>
                 <div class="mb-2">
-                    {% if email_service_enabled %}
+                    {% if mail_service_enabled %}
                         Teilen Sie diesen Link mit den Teilnehmenden oder versenden Sie ihn direkt per E-Mail.
                     {% else %}
                         Der E-Mail-Service ist deaktiviert. Teilen Sie diesen Link manuell mit den Teilnehmenden.
@@ -117,30 +146,32 @@
     const buildButton = document.getElementById('build_time_frame');
     const daysContainer = document.getElementById('time_frame_days');
     const timeFrameTextarea = document.getElementById('time_frame');
+    
     const defaultStartInput = document.getElementById('default_day_start');
     const defaultEndInput = document.getElementById('default_day_end');
+    const defaultPauseStartInput = document.getElementById('default_pause_start');
+    const defaultPauseEndInput = document.getElementById('default_pause_end');
+    
+    const slotLengthInput = document.getElementById('slot_length');
+    const clientsperslot = document.getElementById('clients_per_slot')
+    const slotsAmountsInput = document.getElementById('slots_amounts');
+    const slotsAmountsDisplay = document.getElementById('slots_amounts_display'); 
 
-    if (!startDateInput || !endDateInput || !buildButton || !daysContainer || !timeFrameTextarea || !defaultStartInput || !defaultEndInput) {
+    if (!startDateInput || !endDateInput || !buildButton || !daysContainer || !timeFrameTextarea) {
         return;
     }
 
     const weekdayFormatter = new Intl.DateTimeFormat('de-DE', {
-        weekday: 'long',
+        weekday: 'short',
         day: '2-digit',
         month: '2-digit',
         year: 'numeric',
     });
 
     function parseDate(value) {
-        if (!value) {
-            return null;
-        }
-
+        if (!value) return null;
         const parts = value.split('-').map(Number);
-        if (parts.length !== 3 || parts.some(Number.isNaN)) {
-            return null;
-        }
-
+        if (parts.length !== 3 || parts.some(Number.isNaN)) return null;
         return new Date(parts[0], parts[1] - 1, parts[2]);
     }
 
@@ -161,16 +192,112 @@
         return copy;
     }
 
+    function timeToMinutes(timeStr) {
+        if (!timeStr) return 0;
+        const parts = timeStr.split(':').map(Number);
+        return parts[0] * 60 + parts[1];
+    }
+
+    function updateSlotsDisplay(totalSlots) {
+        if (slotsAmountsInput) slotsAmountsInput.value = totalSlots;
+        if (slotsAmountsDisplay) slotsAmountsDisplay.innerText = totalSlots + " Slots gesamt";
+    }
+
+    // Helper utility in case your timeToMinutes handler doesn't catch empty strings safely
+    function safeTimeToMinutes(timeString) {
+        if (!timeString || typeof timeString !== 'string' || !timeString.includes(':')) {
+            return 0; // Return 0 instead of NaN for empty or missing values
+        }
+        const parts = timeString.split(':');
+        const hours = parseInt(parts[0], 10);
+        const minutes = parseInt(parts[1], 10);
+        if (isNaN(hours) || isNaN(minutes)) return 0;
+        return (hours * 60) + minutes;
+    }
+
+    // Berechnet die Slots basierend auf den konfigurierten Zeiten & Pausen
+    function calculateSlots() {
+        if (!slotLengthInput || !slotsAmountsInput || !clientsperslot) return;
+
+        const slotLength = parseInt(slotLengthInput.value, 10);
+        if (isNaN(slotLength) || slotLength <= 0) {
+            updateSlotsDisplay(0);
+            return;
+        }
+
+        // FIX 1: Make sure we parse the input VALUE, defaulting to 1 if empty or invalid
+        const multiplier = parseInt(clientsperslot.value, 10) || 1;
+
+        let totalSlots = 0;
+        const rows = Array.from(daysContainer.querySelectorAll('[data-day-row]'));
+
+        rows.forEach(row => {
+            const startTime = row.querySelector('[data-time-start]')?.value;
+            const endTime = row.querySelector('[data-time-end]')?.value;
+            const pauseStart = row.querySelector('[data-time-pause-start]')?.value;
+            const pauseEnd = row.querySelector('[data-time-pause-end]')?.value;
+
+            if (!startTime || !endTime) return;
+
+            // Using safety parsing to prevent missing values from generating NaN
+            const startMins = safeTimeToMinutes(startTime);
+            const endMins = safeTimeToMinutes(endTime);
+            const pauseStartMins = safeTimeToMinutes(pauseStart);
+            const pauseEndMins = safeTimeToMinutes(pauseEnd);
+
+            if (isNaN(startMins) || isNaN(endMins) || endMins <= startMins) return;
+
+            // Wenn eine gültige Pause innerhalb der Start/Endzeit existiert
+            if (pauseStartMins > 0 && pauseEndMins > 0 && pauseStartMins < pauseEndMins && pauseStartMins > startMins && pauseStartMins < endMins) {
+                // Segment 1 (Vor der Pause)
+                const segment1 = pauseStartMins - startMins;
+                totalSlots += Math.floor(segment1 / slotLength);
+
+                // Segment 2 (Nach der Pause)
+                const effectivePauseEnd = Math.min(pauseEndMins, endMins);
+                const segment2 = endMins - effectivePauseEnd;
+                if (segment2 > 0) {
+                    totalSlots += Math.floor(segment2 / slotLength);
+                }
+            } else {
+                // Ohne Pause oder ungültige Pause -> Komplett durchrechnen
+                totalSlots += Math.floor((endMins - startMins) / slotLength);
+            }
+        });
+
+        // FIX 2: Multiply by our safely parsed input value scalar
+        const totalSlotscomplete = totalSlots * multiplier;
+
+        // Safety check: if anything went wrong anyway, fallback to 0 instead of displaying NaN
+        updateSlotsDisplay(isNaN(totalSlotscomplete) ? 0 : totalSlotscomplete);
+    }
+
+    // Synchronisiert das Textfeld und fügt den Break-Cut hinzu
     function syncTextarea() {
         const rows = Array.from(daysContainer.querySelectorAll('[data-day-row]'));
-        const lines = rows.map(function (row) {
+        const lines = [];
+        
+        rows.forEach(function (row) {
             const dayValue = row.getAttribute('data-day-value') || '';
             const startTime = row.querySelector('[data-time-start]')?.value || '';
             const endTime = row.querySelector('[data-time-end]')?.value || '';
-            return `${dayValue} ${startTime}-${endTime}`.trim();
-        }).filter(Boolean);
+            const pauseStart = row.querySelector('[data-time-pause-start]')?.value || '';
+            const pauseEnd = row.querySelector('[data-time-pause-end]')?.value || '';
+            
+            if (!dayValue || !startTime || !endTime) return;
+
+            // Hat der Nutzer eine Pause eingetragen, die innerhalb des Tagesfensters liegt?
+            if (pauseStart && pauseEnd && pauseStart < pauseEnd && pauseStart > startTime && pauseStart < endTime) {
+                // Zeile am Pausenbeginn aufsplitten -> 2 Blöcke = automatische Pause
+                lines.push(`${dayValue} ${startTime}-${pauseStart}`);
+                lines.push(`${dayValue} ${pauseEnd}-${endTime}`);
+            } else {
+                lines.push(`${dayValue} ${startTime}-${endTime}`);
+            }
+        });
 
         timeFrameTextarea.value = lines.join('\n');
+        calculateSlots(); // Nach jedem Update neu berechnen
     }
 
     function renderRows() {
@@ -193,40 +320,57 @@
 
         endDateInput.setCustomValidity('');
 
+        // Bisherige Werte sichern
         const existingValues = new Map();
         Array.from(daysContainer.querySelectorAll('[data-day-row]')).forEach(function (row) {
             const dayValue = row.getAttribute('data-day-value');
             const startTime = row.querySelector('[data-time-start]')?.value || '';
             const endTime = row.querySelector('[data-time-end]')?.value || '';
+            const pauseStart = row.querySelector('[data-time-pause-start]')?.value || '';
+            const pauseEnd = row.querySelector('[data-time-pause-end]')?.value || '';
+            
             if (dayValue) {
-                existingValues.set(dayValue, { startTime, endTime });
+                existingValues.set(dayValue, { startTime, endTime, pauseStart, pauseEnd });
             }
         });
 
         const defaultStart = defaultStartInput.value || '08:00';
-        const defaultEnd = defaultEndInput.value || '12:00';
+        const defaultEnd = defaultEndInput.value || '16:00';
+        const defaultPauseStart = defaultPauseStartInput.value || '';
+        const defaultPauseEnd = defaultPauseEndInput.value || '';
         const rows = [];
 
         for (let current = startDate; current <= endDate; current = addDays(current, 1)) {
             const dayValue = formatDateForValue(current);
             const preserved = existingValues.get(dayValue) || {};
-            const rowStart = preserved.startTime || defaultStart;
-            const rowEnd = preserved.endTime || defaultEnd;
+            
+            const rowStart = preserved.startTime !== undefined ? preserved.startTime : defaultStart;
+            const rowEnd = preserved.endTime !== undefined ? preserved.endTime : defaultEnd;
+            const rowPauseStart = preserved.pauseStart !== undefined ? preserved.pauseStart : defaultPauseStart;
+            const rowPauseEnd = preserved.pauseEnd !== undefined ? preserved.pauseEnd : defaultPauseEnd;
 
             rows.push(`
                 <div class="border rounded-3 bg-white p-3" data-day-row data-day-value="${dayValue}">
                     <div class="row g-2 align-items-end">
-                        <div class="col-12 col-lg-5">
+                        <div class="col-12 col-lg-4">
                             <label class="form-label fw-semibold mb-1">${formatDateForRow(current)}</label>
                             <div class="text-muted small">${dayValue}</div>
                         </div>
-                        <div class="col-6 col-lg-3">
-                            <label class="form-label mb-1">Von</label>
-                            <input type="time" class="form-control" value="${rowStart}" data-time-start>
+                        <div class="col-6 col-lg-2">
+                            <label class="form-label mb-1 text-muted small">Von</label>
+                            <input type="time" class="form-control form-control-sm" value="${rowStart}" data-time-start>
                         </div>
-                        <div class="col-6 col-lg-3">
-                            <label class="form-label mb-1">Bis</label>
-                            <input type="time" class="form-control" value="${rowEnd}" data-time-end>
+                        <div class="col-6 col-lg-2">
+                            <label class="form-label mb-1 text-muted small">Bis</label>
+                            <input type="time" class="form-control form-control-sm" value="${rowEnd}" data-time-end>
+                        </div>
+                        <div class="col-6 col-lg-2">
+                            <label class="form-label mb-1 text-danger small">Pause ab</label>
+                            <input type="time" class="form-control form-control-sm border-danger-subtle" value="${rowPauseStart}" data-time-pause-start>
+                        </div>
+                        <div class="col-6 col-lg-2">
+                            <label class="form-label mb-1 text-danger small">Pause bis</label>
+                            <input type="time" class="form-control form-control-sm border-danger-subtle" value="${rowPauseEnd}" data-time-pause-end>
                         </div>
                     </div>
                 </div>
@@ -242,17 +386,75 @@
         syncTextarea();
     }
 
+    document.addEventListener('DOMContentLoaded', function () {
+        const container = document.getElementById('custom-fields-container');
+
+        // Monitor inputs inside the container using event delegation
+        container.addEventListener('input', function (event) {
+            // Only trigger if the user is typing inside our dynamic inputs
+            if (event.target.classList.contains('custom-dynamic-input')) {
+                const allInputs = container.querySelectorAll('.custom-dynamic-input');
+                const lastInput = allInputs[allInputs.length - 1];
+
+                // If the user typed something into the absolute last input field, spawn a new one
+                if (lastInput.value.trim() !== '') {
+                    createNewFieldRow(container);
+                }
+            }
+        });
+
+        // Helper function to generate and append a clean new input row
+        function createNewFieldRow(targetContainer) {
+            const rowDiv = document.createElement('div');
+            rowDiv.className = 'mb-3 custom-field-row';
+
+            rowDiv.innerHTML = `
+                <input type="text" 
+                       name="custom_fields" 
+                       class="form-control form-control-lg custom-dynamic-input" 
+                       placeholder="Nächstes Zusatzfeld...">
+            `;
+
+            targetContainer.appendChild(rowDiv);
+        }
+    });
+
+    // Event Listeners Registration
     buildButton.addEventListener('click', renderRows);
-    startDateInput.addEventListener('input', renderRows);
     startDateInput.addEventListener('change', renderRows);
-    endDateInput.addEventListener('input', renderRows);
     endDateInput.addEventListener('change', renderRows);
-    defaultStartInput.addEventListener('change', syncTextarea);
-    defaultEndInput.addEventListener('change', syncTextarea);
+    
+    defaultStartInput.addEventListener('change', renderRows);
+    defaultEndInput.addEventListener('change', renderRows);
+    defaultPauseStartInput.addEventListener('change', renderRows);
+    defaultPauseEndInput.addEventListener('change', renderRows);
+    
+    // Slot Berechnung auf Ändeurng der Länge antriggern
+    if(slotLengthInput) {
+        slotLengthInput.addEventListener('input', calculateSlots);
+        slotLengthInput.addEventListener('change', calculateSlots);
+    }
+    if (clientsperslot) {
+        clientsperslot.addEventListener('input', calculateSlots);
+        clientsperslot.addEventListener('change', calculateSlots);
+    }
 
     if (startDateInput.value && endDateInput.value) {
         renderRows();
     }
+
+
+    const configForm = document.querySelector('form');
+    if (configForm) {
+        configForm.addEventListener('keydown', function(event) {
+            if (event.key === 'Enter') {
+                if (event.target.tagName === 'TEXTAREA') return;
+                if (event.target.tagName === 'BUTTON' && event.target.type === 'submit') return;
+                event.preventDefault();
+            }
+        });
+    }
+
 })();
 </script>
-{% endblock %}
+{% endblock %}

Web/templates/terminplan.html

@@ -26,12 +26,6 @@
             </div>
             <button id="new-booking" class="primary-button">Zur Termin-Konfiguration</button>
         </div>
-        <div class="calendar-legend">
-            <span class="legend-item"><span class="legend-color current"></span> Aktuelle Termine</span>
-            <span class="legend-item"><span class="legend-color planned"></span> Geplante Termine</span>
-            <span class="legend-item"><span class="legend-color completed"></span> Abgeschlossene Termine</span>
-            <span class="legend-item"><span class="legend-color your-bookings"></span> Ihre Termine</span>
-        </div>
     </div>
     
     <div class="calendar-options">

Web/templates/terminplaner.html

@@ -6,6 +6,8 @@
 <div class="container py-4">
     <div class="row justify-content-center">
         <div class="col-12 col-lg-11 col-xl-10">
+            
+            <!-- Hero Sektion -->
             <section class="p-4 p-md-5 rounded-4 shadow-lg" style="background: linear-gradient(135deg, rgba(15,76,92,0.96), rgba(22,105,122,0.92)); color: #fff;">
                 <div class="d-flex flex-column flex-lg-row justify-content-between gap-4 align-items-start align-items-lg-end">
                     <div>
@@ -20,6 +22,39 @@
                 </div>
             </section>
 
+            <!-- NEU EINGEBAUT: Erfolgsmeldung für gerade erstellte Buchungslinks -->
+            {% if generated_link %}
+            <div class="alert alert-success mt-4 shadow-sm rounded-4">
+                <div class="fw-bold mb-1">Buchungslink erstellt</div>
+                <div class="mb-2">
+                    {% if mail_service_enabled %}
+                        Teilen Sie diesen Link mit den Teilnehmenden oder versenden Sie ihn direkt per E-Mail.
+                    {% else %}
+                        Der E-Mail-Service ist deaktiviert. Teilen Sie diesen Link manuell mit den Teilnehmenden.
+                    {% endif %}
+                </div>
+                <a href="{{ generated_link }}" class="d-inline-block text-break mb-3">{{ generated_link }}</a>
+                
+                <!-- PDF Export per ReportLab -->
+                <div class="pt-3 border-top border-success-subtle">
+                    <div class="fw-semibold mb-1">Einladungsbrief (inkl. QR-Code)</div>
+                    <p class="small text-muted mb-2">Laden Sie einen automatisch generierten Brief herunter, der den Buchungslink und einen passenden QR-Code enthält.</p>
+                    <a href="{{ url_for('terminplaner.export_pdf_brief', plan_id=plan_id) }}" class="btn btn-outline-success btn-sm">
+                        📄 Brief als PDF herunterladen
+                    </a>
+                </div>
+
+                {% if calendar_link %}
+                <div class="mt-3 pt-3 border-top border-success-subtle">
+                    <div class="fw-semibold mb-1">Kalendereintrag</div>
+                    <a href="{{ calendar_link }}" class="btn btn-outline-primary btn-sm">.ics herunterladen</a>
+                </div>
+                {% endif %}
+            </div>
+            {% endif %}
+            <!-- ENDE NEUER BLOCK -->
+
+            <!-- Info-Karten -->
             <div class="row g-4 mt-1">
                 <div class="col-12 col-md-4">
                     <div class="card h-100 shadow-sm border-0 rounded-4">
@@ -59,6 +94,7 @@
                 <p class="mb-0 text-muted">Sie können Termine anlegen, den Kalender prüfen und Buchungslinks verteilen.</p>
             </div>
 
+            <!-- "Tabelle" (Liste) der kommenden Termine -->
             <div class="mt-4 p-4 rounded-4 bg-white shadow-sm">
                 <div class="d-flex flex-column flex-md-row justify-content-between align-items-md-center gap-2 mb-3">
                     <h2 class="h5 fw-bold mb-0">Kommende Termine</h2>
@@ -71,6 +107,7 @@
                     <div class="border rounded-3 p-3">
                         <div class="d-flex flex-column flex-lg-row justify-content-between gap-3">
                             <div>
+                                <h3 class="h6 fw-bold mb-1">{{ event.title or "Terminplan" }}</h3>
                                 <div class="fw-semibold">{{ event.date_start }} bis {{ event.date_end }}</div>
                                 <div class="text-muted small">ID: {{ event.appointment_id }}</div>
                                 {% if event.time_span %}
@@ -83,10 +120,18 @@
                             <div class="text-lg-end">
                                 <div class="small mb-2">Gebucht: <strong>{{ event.slots_booked }}</strong> / {{ event.slots_total }} | Frei: <strong>{{ event.slots_left }}</strong></div>
                                 <div class="d-flex flex-wrap gap-2 justify-content-lg-end">
-                                    <a class="btn btn-sm btn-primary" href="{{ event.link }}" target="_blank" rel="noopener">Client-Link öffnen</a>
+                                    
+                                    <!-- Hinzugefügt: Direkter PDF-Export auch bei bestehenden Plänen -->
+                                    <a class="btn btn-sm btn-outline-success" href="{{ url_for('terminplaner.export_pdf_brief', plan_id=event.appointment_id) }}" title="Brief herunterladen">
+                                        📄 PDF
+                                    </a>
+
+                                    <a class="btn btn-sm btn-primary" href="{{ event.link }}" target="_blank" rel="noopener">Client-Link</a>
+                                    
                                     {% if event.calendar_link %}
                                     <a class="btn btn-sm btn-outline-primary" href="{{ event.calendar_link }}">.ics</a>
                                     {% endif %}
+                                    
                                     <form method="post" action="{{ url_for('terminplaner.delete_appointment', appointment_id=event.appointment_id, tenant=tenant_id) }}" class="d-inline" onsubmit="return confirm('Diesen Terminplan wirklich löschen?');">
                                         <button type="submit" class="btn btn-sm btn-outline-danger">Entfernen</button>
                                     </form>
@@ -104,4 +149,4 @@
         </div>
     </div>
 </div>
-{% endblock %}
+{% endblock %}

Web/templates/upload_admin.html

@@ -155,6 +155,27 @@
         background-color: #1e7e34;
     }
 
+    /* Quagga Scanner Video Styles */
+    #code4-scanner video, #code4-scanner canvas,
+    #isbn-scanner video, #isbn-scanner canvas {
+        width: 100%;
+        max-width: 640px;
+        height: auto;
+        border-radius: 5px;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    }
+    
+    #code4-scanner canvas, #isbn-scanner canvas {
+        position: absolute;
+        top: 0;
+        left: 0;
+    }
+    
+    #code4-scanner, #isbn-scanner {
+        position: relative;
+        overflow: hidden;
+    }
+
     /* ISBN input group styling */
     .isbn-input-group {
         display: flex;
@@ -767,7 +788,19 @@
             {% if show_library_features %}
             <!-- Library Mode: Single Customizable Filter -->
             <div class="filter-inputs">
-                <h3>Kategorie/Typ (customisierbar):</h3>
+                <h3>Medientyp</h3>
+                <div class="form-group">
+                    <select name="item_type_input" id="item_type_input">
+                        <option value="" disabled selected>Medientyp auswählen...</option>
+                        <option value="Buch">Buch</option>
+                        <option value="Schulbuch">Schulbuch</option>
+                        <option value="CD">CD</option>
+                        <option value="DVD">DVD</option>
+                        <option value="Sonstiges">Sonstiges</option>
+                    </select>
+                    <small style="display:block; color:#666;">Wählen Sie einen Medientyp aus zur Klassifizierung.</small>
+                </div>
+                <h3>Kategorie/Typ:</h3>
                 <div class="form-group">
                     <input type="text" name="library_category" id="library_category" placeholder="z.B. Belletristik, Sachbücher, Nachschlagewerke, etc.">
                     <small style="display:block; color:#666;">Geben Sie hier eine beliebige Kategorie ein zur freien Klassifizierung.</small>
@@ -831,7 +864,7 @@
                             <!-- Options will be loaded by JavaScript -->
                         </select>
                     </div>
-                    <div class="form-group">
+                    <div class="formupload_admin-group">
                         <label for="filter2-4">Wert 4:</label>
                         <select id="filter2-4" name="filter2" class="filter-dropdown-select">
                             <option value="">-- Optional --</option>
@@ -840,7 +873,7 @@
                     </div>
                 </div>
                 
-                <h3>Thema:</h3>
+                <h3>Schlagwort:</h3>
                 <div class="multi-filter">
                     <div class="form-group">
                         <label for="filter3-1">Wert 1:</label>
@@ -869,25 +902,41 @@
                 <label for="anschaffungskosten">Anschaffungskosten (€)</label>
                 <input id="anschaffungskosten" name="anschaffungskosten">
             </div>
-            <div class="form-group">
-                <label for="code_4">Code</label>
-                <div style="display:flex; gap:8px; flex-wrap:wrap; align-items:center;">
-                    <input id="code_4" name="code_4">
-                    <button type="button" id="scan-code4-btn" class="fetch-isbn-button">Barcode scannen</button>
+           <div class="form-group">
+                <label for="scan_mode">Erfassungs-Modus:</label>
+                <select id="scan_mode" name="scan_mode" class="form-control" onchange="toggleScanMode()">
+                    <option value="single">Einzel-Code (Scanner stoppt nach 1 Scan)</option>
+                    <option value="continuous">Fortlaufend scannen (Mehrere Codes nacheinander)</option>
+                    <option value="range">Code-Bereich generieren (z.B. ABC-001 bis ABC-010)</option>
+                </select>
+            </div>
+
+            <div id="range_generator_group" class="form-group" style="display:none; background: #f9f9f9; padding: 15px; border-radius: 5px; border: 1px solid #ddd; margin-bottom: 15px;">
+                <label style="font-weight: bold;">Code-Bereich automatisch generieren:</label>
+                <div style="display: flex; gap: 10px; margin-bottom: 10px; align-items: center;">
+                    <input type="text" id="range_prefix" placeholder="Präfix (z.B. IT-)" class="form-control" style="flex: 2;">
+                    <input type="number" id="range_start" placeholder="Start (z.B. 1)" class="form-control" style="flex: 1;">
+                    <span style="font-weight: bold;">bis</span>
+                    <input type="text" id="range_end" placeholder="Ende (z.B. 020)" class="form-control" style="flex: 1;">
                 </div>
-                <small style="display:block; color:#666;">Einzelcode manuell setzen oder per Scanner erfassen.</small>
-                <div id="code4-scanner" style="width:100%; max-width:520px; display:none; margin-top:10px;"></div>
-                <small id="code4-scan-status" style="display:block; color:#666; margin-top:6px;"></small>
+                <small style="display:block; color:#666; margin-bottom: 10px;">Tipp: Die Anzahl der Ziffern im "Ende"-Feld bestimmt die führenden Nullen (z.B. Ende "050" macht aus Start "1" einen "001").</small>
+                <button type="button" class="btn btn-secondary" onclick="generateCodeRange()">Bereich generieren & einfügen</button>
             </div>
-            <div class="form-group">
-                <label for="item_count">Anzahl dieser Sorte</label>
-                <input type="number" id="item_count" name="item_count" min="1" max="100" value="1">
-                <small style="display:block; color:#666;">Es werden eigene Items erstellt, aber in der Übersicht als ein Artikel gebündelt angezeigt.</small>
+
+            <div class="form-group" id="primary_code_group">
+                <label for="code_4">Basis-Code</label>
+                <div style="display: flex; gap: 10px;">
+                    <input type="text" id="code_4" name="code_4" class="form-control" placeholder="Haupt-Barcode" required>
+                    <button type="button" id="scan-code4-btn" class="btn btn-primary">Barcode scannen</button>
+                </div>
+                <div id="code4-scanner" style="display:none; margin-top: 10px;"></div>
+                <small id="code4-scan-status" class="form-text text-muted"></small>
             </div>
-            <div class="form-group">
-                <label for="individual_codes">Einzelcodes (optional, je Zeile ein Code)</label>
-                <textarea id="individual_codes" name="individual_codes" rows="4" placeholder="z.B.\nABC-001\nABC-002"></textarea>
-                <small style="display:block; color:#666;">Bei Anzahl > 1 können hier individuelle Codes pro Item gesetzt werden. Der Scanner setzt immer zuerst den Basis-Code im Feld oben; weitere Einzelcodes können hier bei Bedarf manuell ergänzt werden.</small>
+
+            <div class="form-group" id="individual_codes_group">
+                <label for="individual_codes">Weitere Einzelcodes (je Zeile ein Code)</label>
+                <textarea id="individual_codes" name="individual_codes" rows="6" placeholder="z.B.&#10;ABC-001&#10;ABC-002" class="form-control"></textarea>
+                <small style="display:block; color:#666; margin-top: 5px;">Bei Anzahl > 1 können hier individuelle Codes pro Item gesetzt werden. Der Scanner setzt immer zuerst den Basis-Code im Feld oben; weitere Einzelcodes werden hier angehängt.</small>
             </div>
             <!-- Image upload (hidden for library mode) -->
             <div class="form-group" {% if show_library_features %}style="display:none;"{% endif %}>
@@ -905,7 +954,7 @@
                 <div class="isbn-input-group">
                     <input type="text" id="isbn" name="isbn" placeholder="ISBN oder Barcode eingeben..." required>
                     <button type="button" id="scan-isbn-btn" class="fetch-isbn-button">Barcode scannen</button>
-                    <button type="button" class="fetch-isbn-button" onclick="fetchBookInfo('upload')">Bild abrufen</button>
+                    <button type="button" class="fetch-isbn-button" onclick="fetchBookInfo('upload')">Informationen abrufen</button>
                 </div>
                 <div id="isbn-scanner" style="width:100%; max-width:520px; display:none; margin-top:10px;"></div>
                 <small id="isbn-scan-status" style="display:block; color:#666; margin-top:6px;">Scannen oder manuell eingeben. Gültige ISBNs helfen beim Abruf von Buchdaten, andere Codes werden trotzdem akzeptiert.</small>
@@ -970,8 +1019,7 @@
         document.getElementById('csv-help-modal').style.display = 'none';
     }
 </script>
-
-<script src="https://unpkg.com/html5-qrcode@2.0.9/dist/html5-qrcode.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/@ericblade/quagga2/dist/quagga.js"></script>
 <script>
     const libraryModuleEnabled = {{ 'true' if library_module_enabled else 'false' }};
 
@@ -984,12 +1032,12 @@
 
     // Global variable to store fetched book data
     let currentBookData = null;
-    let code4ScannerInstance = null;
-    let code4ScannerRunning = false;
-    let code4LastScanned = '';
-    let code4LastScannedAt = 0;
-    let isbnScannerInstance = null;
-    let isbnScannerRunning = false;
+    
+    // Quagga2 engine state management properties
+    let scannerRunning = false;
+    let activeScannerCallback = null; // Dynamically handles routing data to the active caller field
+    var code4LastScanned = '';
+    var code4LastScannedAt = 0;
 
     function setCode4ScanStatus(message, isError = false) {
         const statusEl = document.getElementById('code4-scan-status');
@@ -1042,61 +1090,230 @@
         statusEl.style.color = '#b00020';
     }
 
+    // Centered Quagga2 Engine Initialization Pattern
+    function runEngineInitialization(targetSelector, activeCallback, completionMsg, errorStatusSetter) {
+        if (scannerRunning) {
+            Quagga.stop();
+            scannerRunning = false;
+        }
+
+        activeScannerCallback = activeCallback;
+
+        Quagga.init({
+            inputStream: {
+                name: "Live",
+                type: "LiveStream",
+                target: document.querySelector(targetSelector), 
+                constraints: {
+                    width: 640,
+                    height: 480,
+                    facingMode: "environment" // Force rear camera lenses
+                },
+            },
+            decoder: {
+                readers: ["code_128_reader", "ean_reader", "code_39_reader", "upc_reader"]
+            } 
+        }, function(err) {
+            if (err) {
+                console.error("Initialization error:", err);
+                errorStatusSetter("Kamera konnte nicht gestartet werden.", true);
+                return;
+            }
+
+            Quagga.start();
+            scannerRunning = true;
+            errorStatusSetter(completionMsg, false);
+        });
+    }
+
+    function killScannerHardware() {
+        if (!scannerRunning) return;
+        Quagga.stop();
+        scannerRunning = false;
+        activeScannerCallback = null;
+    }
+
+    // Unified tracking capture listener
+    Quagga.onDetected(function(data) {
+        if (!data || !data.codeResult || !data.codeResult.code) return;
+
+        const rawBarcode = String(data.codeResult.code || '').trim();
+        const currentTargetCallback = activeScannerCallback;
+
+        if (typeof currentTargetCallback === "function") {
+            currentTargetCallback(rawBarcode);
+        }
+    });
+
+    // Globale Variablen für den Scanner-Status
+    var code4LastScanned = '';
+    var code4LastScannedAt = 0;
+
+    /**
+     * Schaltet das UI basierend auf dem ausgewählten Modus um
+     */
+    function toggleScanMode() {
+        const mode = document.getElementById('scan_mode').value;
+        const rangeGroup = document.getElementById('range_generator_group');
+        const scanButton = document.getElementById('scan-code4-btn');
+        const scannerBox = document.getElementById('code4-scanner');
+        
+        if (scannerBox && scannerBox.style.display !== 'none') {
+            if (typeof killScannerHardware === 'function') killScannerHardware();
+            scannerBox.style.display = 'none';
+            if (scanButton) scanButton.textContent = 'Barcode scannen';
+        }
+    
+        if (mode === 'range') {
+            if(rangeGroup) rangeGroup.style.display = 'block';
+            if(scanButton) scanButton.style.display = 'none'; 
+        } else {
+            if(rangeGroup) rangeGroup.style.display = 'none'; // Hier wurde der Fehler korrigiert
+            if(scanButton) scanButton.style.display = 'inline-block';
+        }
+    }
+
+    /**
+     * Generiert eine Liste von Codes basierend auf den Eingaben
+     */
+    function generateCodeRange() {
+        const prefix = document.getElementById('range_prefix').value.trim();
+        const startStr = document.getElementById('range_start').value.trim();
+        const endStr = document.getElementById('range_end').value.trim();
+
+        const start = parseInt(startStr, 10);
+        const end = parseInt(endStr, 10);
+
+        const paddingLength = endStr.length; 
+
+        if (isNaN(start) || isNaN(end) || start > end) {
+            alert("Bitte gültige Zahlen für Start und Ende eingeben. Der Startwert darf nicht größer als der Endwert sein.");
+            return;
+        }
+
+        let generatedCodes = [];
+        for (let i = start; i <= end; i++) {
+            let numStr = i.toString().padStart(paddingLength, '0');
+            generatedCodes.push(`${prefix}${numStr}`);
+        }
+
+        const codeField = document.getElementById('code_4');
+        const individualCodesArea = document.getElementById('individual_codes');
+
+        if (generatedCodes.length > 0) {
+            if (!codeField.value || confirm("Soll der aktuelle Basis-Code überschrieben werden?")) {
+                codeField.value = generatedCodes[0];
+                if (typeof validateCodeField === 'function') validateCodeField(codeField);
+                generatedCodes.shift(); 
+            }
+
+            if (generatedCodes.length > 0) {
+                let existing = individualCodesArea.value.trim();
+                individualCodesArea.value = existing ? existing + '\n' + generatedCodes.join('\n') : generatedCodes.join('\n');
+            }
+
+            alert(`Bereich erfolgreich generiert! (${end - start + 1} Codes)`);
+        }
+    }
+
+    /**
+     * Scanner-Funktion (Single & Continuous Modus)
+     */
     function startCode4Scanner() {
         const scannerBox = document.getElementById('code4-scanner');
         const scanButton = document.getElementById('scan-code4-btn');
         const codeField = document.getElementById('code_4');
+        const individualCodesArea = document.getElementById('individual_codes');
+        const scanMode = document.getElementById('scan_mode').value;
+
         if (!scannerBox || !scanButton || !codeField) return;
 
-        // Stop ISBN scanner if currently running to avoid camera conflicts.
-        if (isbnScannerRunning && isbnScannerInstance) {
-            isbnScannerInstance.clear().catch(() => {});
-            const isbnScannerBox = document.getElementById('isbn-scanner');
+        // Beende evtl. laufenden ISBN Scanner
+        const isbnScannerBox = document.getElementById('isbn-scanner');
+        if (isbnScannerBox && isbnScannerBox.style.display !== 'none') {
+            killScannerHardware();
+            isbnScannerBox.style.display = 'none';
             const isbnScanButton = document.getElementById('scan-isbn-btn');
-            if (isbnScannerBox) isbnScannerBox.style.display = 'none';
-            if (isbnScanButton) isbnScanButton.textContent = 'ISBN scannen';
-            isbnScannerRunning = false;
+            if (isbnScanButton) isbnScanButton.textContent = 'Barcode scannen';
+            if (typeof setIsbnScanStatus === 'function') setIsbnScanStatus('Scanner gestoppt.');
         }
 
-        if (code4ScannerRunning && code4ScannerInstance) {
-            code4ScannerInstance.clear().catch(() => {});
+        // Scanner ausschalten, wenn er bereits läuft
+        if (scannerBox.style.display !== 'none') {
+            killScannerHardware();
             scannerBox.style.display = 'none';
             scanButton.textContent = 'Barcode scannen';
-            code4ScannerRunning = false;
-            setCode4ScanStatus('Scanner gestoppt.');
+            if (typeof setCode4ScanStatus === 'function') setCode4ScanStatus('Scanner gestoppt.');
             return;
         }
 
+        // Scanner starten
         scannerBox.style.display = 'block';
-        scanButton.textContent = 'Scanner stoppen';
-        code4ScannerInstance = new Html5QrcodeScanner('code4-scanner', { 
-            fps: 10, 
-            qrbox: 250,
-            rememberLastUsedCamera: true
-        });
-        code4ScannerRunning = true;
-        setCode4ScanStatus('Scanner läuft. Der Scan wird im Basis-Codefeld übernommen.');
+        scanButton.textContent = scanMode === 'continuous' ? 'Fortlaufenden Scan stoppen' : 'Scanner stoppen';
+        if (typeof setCode4ScanStatus === 'function') setCode4ScanStatus('Scanner initialisiert. Richte die Kamera auf den Barcode...');
 
-        code4ScannerInstance.render((decodedText) => {
-            const scannedCode = String(decodedText || '').trim();
-            if (!scannedCode) return;
+        if (typeof runEngineInitialization === 'function') {
+            runEngineInitialization(
+                '#code4-scanner', 
+                function(decodedText) {
+                    const now = Date.now();
+                    if (decodedText === code4LastScanned && (now - code4LastScannedAt) < 1500) {
+                        return;
+                    }
+                    code4LastScanned = decodedText;
+                    code4LastScannedAt = now;
+                
+                    if (scanMode === 'single') {
+                        killScannerHardware();
+                        scannerBox.style.display = 'none';
+                        scanButton.textContent = 'Barcode scannen';
+                    
+                        codeField.value = decodedText;
+                        if (typeof validateCodeField === 'function') validateCodeField(codeField);
+                        if (typeof setCode4ScanStatus === 'function') setCode4ScanStatus(`Code gesetzt: ${decodedText}`);
 
-            const now = Date.now();
-            if (scannedCode === code4LastScanned && (now - code4LastScannedAt) < 1500) {
-                return;
-            }
-            code4LastScanned = scannedCode;
-            code4LastScannedAt = now;
+                    } else if (scanMode === 'continuous') {
+                        let currentAreaCodes = individualCodesArea.value.split('\n').map(c => c.trim()).filter(c => c !== '');
 
-            codeField.value = scannedCode;
-            validateCodeField(codeField);
-            setCode4ScanStatus(`Code_4 gesetzt: ${scannedCode}`);
-        }, () => {});
+                        if (!codeField.value) {
+                            codeField.value = decodedText;
+                            if (typeof validateCodeField === 'function') validateCodeField(codeField);
+                            if (typeof setCode4ScanStatus === 'function') setCode4ScanStatus(`Basis-Code gesetzt: ${decodedText}`);
+                        } else if (!currentAreaCodes.includes(decodedText) && codeField.value !== decodedText) {
+                            individualCodesArea.value += (individualCodesArea.value ? '\n' : '') + decodedText;
+                            if (typeof setCode4ScanStatus === 'function') setCode4ScanStatus(`Zusatz-Code erfasst: ${decodedText}`);
+
+                            try {
+                                const audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+                                const oscillator = audioCtx.createOscillator();
+                                const gainNode = audioCtx.createGain();
+                                oscillator.connect(gainNode);
+                                gainNode.connect(audioCtx.destination);
+                                oscillator.type = 'sine';
+                                oscillator.frequency.value = 800; 
+                                gainNode.gain.setValueAtTime(0.1, audioCtx.currentTime);
+                                oscillator.start();
+                                oscillator.stop(audioCtx.currentTime + 0.1);
+                            } catch (e) {
+                                console.log("Audio feedback not supported");
+                            }
+                        } else {
+                            if (typeof setCode4ScanStatus === 'function') setCode4ScanStatus(`Code ${decodedText} wurde bereits gescannt.`);
+                        }
+                    }
+                },
+                'Scanner läuft. Richte die Kamera auf den Barcode.',
+                setCode4ScanStatus
+            );
+        }
     }
 
+    /**
+     * ISBN Scanner-Funktion
+     */
     function startIsbnScanner() {
         if (!libraryModuleEnabled) {
-            setIsbnScanStatus('Bibliotheks-Modul ist deaktiviert.', true);
+            if (typeof setIsbnScanStatus === 'function') setIsbnScanStatus('Bibliotheks-Modul ist deaktiviert.', true);
             return;
         }
         const scannerBox = document.getElementById('isbn-scanner');
@@ -1104,61 +1321,75 @@
         const isbnField = document.getElementById('isbn');
         if (!scannerBox || !scanButton || !isbnField) return;
 
-        // Stop Code_4 scanner if currently running to avoid camera conflicts.
-        if (code4ScannerRunning && code4ScannerInstance) {
-            code4ScannerInstance.clear().catch(() => {});
-            const codeScannerBox = document.getElementById('code4-scanner');
-            const codeScanButton = document.getElementById('scan-code4-btn');
-            if (codeScannerBox) codeScannerBox.style.display = 'none';
-            if (codeScanButton) codeScanButton.textContent = 'Barcode scannen';
-            code4ScannerRunning = false;
-            setCode4ScanStatus('Scanner gestoppt.');
+        const codeScannerBox = document.getElementById('code4-scanner');
+        const codeScanButton = document.getElementById('scan-code4-btn');
+        if (codeScannerBox && codeScannerBox.style.display !== 'none') {
+            killScannerHardware();
+            codeScannerBox.style.display = 'none';
+            codeScanButton.textContent = 'Barcode scannen';
+            if (typeof setCode4ScanStatus === 'function') setCode4ScanStatus('Scanner gestoppt.');
         }
 
-        if (isbnScannerRunning && isbnScannerInstance) {
-            isbnScannerInstance.clear().catch(() => {});
+        if (scannerBox.style.display !== 'none') {
+            killScannerHardware();
             scannerBox.style.display = 'none';
-            scanButton.textContent = 'ISBN scannen';
-            isbnScannerRunning = false;
-            setIsbnScanStatus('Scanner gestoppt.');
+            scanButton.textContent = 'Barcode scannen';
+            if (typeof setIsbnScanStatus === 'function') setIsbnScanStatus('Scanner gestoppt.');
             return;
         }
 
         scannerBox.style.display = 'block';
         scanButton.textContent = 'Scanner stoppen';
-        isbnScannerInstance = new Html5QrcodeScanner('isbn-scanner', {
-            fps: 10,
-            qrbox: 250,
-            rememberLastUsedCamera: true
-        });
-        isbnScannerRunning = true;
-        setIsbnScanStatus('Scanner läuft. Bitte ISBN-Code erfassen.');
 
-        isbnScannerInstance.render((decodedText) => {
-            const scannedCode = String(decodedText || '').trim();
-            if (!scannedCode) return;
+        runEngineInitialization(
+            '#isbn-scanner',
+            function(decodedText) {
+                killScannerHardware();
+                scannerBox.style.display = 'none';
+                scanButton.textContent = 'Barcode scannen';
 
-            const normalizedIsbn = normalizeIsbnClient(scannedCode);
-            isbnField.value = normalizedIsbn || scannedCode;
-            updateIsbnLiveValidation();
-            if (normalizedIsbn) {
-                setIsbnScanStatus(`ISBN gesetzt: ${normalizedIsbn}`);
-            } else {
-                setIsbnScanStatus('Kein gültiges ISBN-Format erkannt, der gescannte Wert bleibt aber im Feld.', true);
-            }
+                const normalizedIsbn = typeof normalizeIsbnClient === 'function' ? normalizeIsbnClient(decodedText) : decodedText;
+                isbnField.value = normalizedIsbn || decodedText;
+                if (typeof updateIsbnLiveValidation === 'function') updateIsbnLiveValidation();
 
-            isbnScannerInstance.clear().catch(() => {});
-            scannerBox.style.display = 'none';
-            scanButton.textContent = 'ISBN scannen';
-            isbnScannerRunning = false;
-
-            if (normalizedIsbn) {
-                // Automatically load book metadata after a valid ISBN scan.
-                fetchBookInfo('upload');
-            }
-        }, () => {});
+                if (normalizedIsbn) {
+                    if (typeof setIsbnScanStatus === 'function') setIsbnScanStatus(`ISBN gesetzt: ${normalizedIsbn}`);
+                    if (typeof fetchBookInfo === 'function') fetchBookInfo('upload');
+                } else {
+                    if (typeof setIsbnScanStatus === 'function') setIsbnScanStatus('Kein gültiges ISBN-Format erkannt, der gescannte Wert bleibt aber im Feld.', true);
+                }
+            },
+            'Scanner läuft. Bitte ISBN-Code erfassen.',
+            setIsbnScanStatus
+        );
     }
 
+    // --- WICHTIG: Event Listener Binden sobald DOM geladen ist ---
+    document.addEventListener('DOMContentLoaded', function() {
+        // 1. Basis-Code Scanner Button aktivieren
+        const scanCode4Btn = document.getElementById('scan-code4-btn');
+        if (scanCode4Btn) {
+            scanCode4Btn.addEventListener('click', startCode4Scanner);
+        }
+
+        // 2. ISBN Scanner Button aktivieren
+        const scanIsbnBtn = document.getElementById('scan-isbn-btn');
+        if (scanIsbnBtn) {
+            scanIsbnBtn.addEventListener('click', startIsbnScanner);
+        }
+
+        // 3. Dropdown-Modus Wechsel überwachen
+        const scanModeSelect = document.getElementById('scan_mode');
+        if (scanModeSelect) {
+            scanModeSelect.addEventListener('change', toggleScanMode);
+        }
+
+        // 4. ISBN Live-Validierung
+        const isbnInput = document.getElementById('isbn');
+        if (isbnInput && typeof updateIsbnLiveValidation === 'function') {
+            isbnInput.addEventListener('input', updateIsbnLiveValidation);
+        }
+    });
     // Load predefined filter values for dropdowns
     function loadPredefinedFilterValues(filterNumber) {
         fetch(`/get_predefined_filter_values/${filterNumber}`)
@@ -1344,6 +1575,7 @@
         // Get form fields
         const nameField = document.getElementById('name');
         const descriptionField = document.getElementById('beschreibung');
+        const priceField = document.getElementById('anschaffungskosten'); // <-- NEU
         
         if (!nameField || !descriptionField) {
             alert('Fehler: Formularfelder nicht gefunden.');
@@ -1381,6 +1613,13 @@
         nameField.value = bookTitle;
         descriptionField.value = description;
         
+        // Preis in das Formularfeld eintragen
+        if (priceField && currentBookData.price !== null && currentBookData.price !== undefined) {
+            // Wandelt den Float (z.B. 12.25) in einen String mit Komma (12,25) um
+            let formattedPrice = currentBookData.price.toString().replace('.', ',');
+            priceField.value = formattedPrice;
+        }
+
         // Download and import book cover image if available
         if (currentBookData.thumbnail) {
             downloadBookCover(currentBookData.thumbnail);
@@ -1558,6 +1797,7 @@
         }, 10000);
     }
 
+    // Exported function for use within parent layout fields
     function validateCodeField(input, excludeId = null) {
         const code = input.value.trim();
         
@@ -1683,16 +1923,6 @@
             });
         }
 
-        const scanCodeBtn = document.getElementById('scan-code4-btn');
-        if (scanCodeBtn) {
-            scanCodeBtn.addEventListener('click', startCode4Scanner);
-        }
-
-        const scanIsbnBtn = document.getElementById('scan-isbn-btn');
-        if (scanIsbnBtn) {
-            scanIsbnBtn.addEventListener('click', startIsbnScanner);
-        }
-
         const isbnField = document.getElementById('isbn');
         if (isbnField) {
             isbnField.addEventListener('input', updateIsbnLiveValidation);
@@ -1732,188 +1962,11 @@
             if (typeof duplicateData.images === 'string') {
                 try {
                     duplicateData.images = JSON.parse(duplicateData.images);
-                    console.log("Parsed images from string:", duplicateData.images);
                 } catch (e) {
-                    console.warn("Failed to parse images string, using as single item:", duplicateData.images);
-                    duplicateData.images = [duplicateData.images];
+                    console.error("Error parsing duplicate images array:", e);
                 }
             }
-            console.log(`Final duplicateData.images (${Array.isArray(duplicateData.images) ? 'array' : typeof duplicateData.images}):`, duplicateData.images);
-        }
-    }
-    
-    // Then check for sessionStorage data (takes priority)
-    const sessionData = sessionStorage.getItem('duplicateItemData');
-    if (sessionData) {
-        try {
-            duplicateData = JSON.parse(sessionData);
-            sessionStorage.removeItem('duplicateItemData'); // Clean up
-            console.log("Session storage duplicate data:", duplicateData);
-        } catch (e) {
-            console.error('Error parsing session duplicate data:', e);
-        }
-    }
-    
-    // Function to prefill form with duplicate data
-    function prefillFormWithDuplicateData() {
-        if (!duplicateData) return;
-        
-        // Fill basic fields
-        const nameField = document.getElementById('name');
-        if (nameField && duplicateData.name) nameField.value = duplicateData.name;
-        
-        const descField = document.getElementById('beschreibung');
-        if (descField && duplicateData.description) descField.value = duplicateData.description;
-        
-        const yearField = document.getElementById('anschaffungsjahr');
-        if (yearField && duplicateData.year) yearField.value = duplicateData.year;
-        
-        const costField = document.getElementById('anschaffungskosten');
-        if (costField && duplicateData.cost) costField.value = duplicateData.cost;
-        
-        // Fill location dropdown
-        const locationField = document.getElementById('ort');
-        if (locationField && duplicateData.location) {
-            // Wait for locations to load, then set value
-            setTimeout(() => {
-                locationField.value = duplicateData.location;
-            }, 100);
-        }
-        
-        // Fill filter arrays - handle up to 4 values per filter type
-        setTimeout(() => {
-            // Filter 1 (Unterrichtsfach)
-            if (duplicateData.filter1 && Array.isArray(duplicateData.filter1)) {
-                for (let j = 1; j <= Math.min(4, duplicateData.filter1.length); j++) {
-                    const filterField = document.getElementById(`filter1-${j}`);
-                    if (filterField && duplicateData.filter1[j-1]) {
-                        filterField.value = duplicateData.filter1[j-1];
-                    }
-                }
-            }
-            
-            // Filter 2 (Jahrgangsstufe)
-            if (duplicateData.filter2 && Array.isArray(duplicateData.filter2)) {
-                for (let j = 1; j <= Math.min(4, duplicateData.filter2.length); j++) {
-                    const filterField = document.getElementById(`filter2-${j}`);
-                    if (filterField && duplicateData.filter2[j-1]) {
-                        filterField.value = duplicateData.filter2[j-1];
-                    }
-                }
-            }
-            
-            // Filter 3 (Thema) - text inputs
-            if (duplicateData.filter3 && Array.isArray(duplicateData.filter3)) {
-                for (let j = 1; j <= Math.min(4, duplicateData.filter3.length); j++) {
-                    const filterField = document.getElementById(`filter3-${j}`);
-                    if (filterField && duplicateData.filter3[j-1]) {
-                        filterField.value = duplicateData.filter3[j-1];
-                    }
-                }
-            }
-        }, 200); // Wait for filter options to load
-        
-        // Handle images - add hidden inputs for duplicate images
-        if (duplicateData.images && duplicateData.images.length > 0) {
-            console.log("Duplicate images data:", duplicateData.images);
-            const form = document.querySelector('form[action*="upload_item"]');
-            if (form) {
-                // Add hidden field to indicate duplication
-                const isDuplicatingField = document.createElement('input');
-                isDuplicatingField.type = 'hidden';
-                isDuplicatingField.name = 'is_duplicating';
-                isDuplicatingField.value = 'true';
-                form.appendChild(isDuplicatingField);
-                
-                // Add each image as a duplicate image
-                const images = duplicateData.images || [];
-                console.log(`Adding ${images.length} images as hidden fields`);
-                
-                if (Array.isArray(images)) {
-                    images.forEach((imageName, index) => {
-                        if (imageName) {
-                            console.log(`Adding duplicate image ${index}: ${imageName}`);
-                            const imageField = document.createElement('input');
-                            imageField.type = 'hidden';
-                            imageField.name = 'duplicate_images';
-                            imageField.value = imageName;
-                            form.appendChild(imageField);
-                        }
-                    });
-                } else {
-                    console.warn("Images is not an array:", images);
-                    // Try to handle as single item if it's a string
-                    if (typeof images === 'string' && images) {
-                        console.log("Adding single image:", images);
-                        const imageField = document.createElement('input');
-                        imageField.type = 'hidden';
-                        imageField.name = 'duplicate_images';
-                        imageField.value = images;
-                        form.appendChild(imageField);
-                    }
-                }
-                
-                // Show image preview
-                showDuplicateImagePreview(duplicateData.images);
-            }
-        }
-    }
-    
-    // Function to show preview of duplicate images
-    function showDuplicateImagePreview(images) {
-        const previewContainer = document.getElementById('image-preview-container');
-        if (!previewContainer) return;
-        
-        console.log("showDuplicateImagePreview called with:", images);
-        
-        // Make sure images is treated as an array
-        if (!Array.isArray(images)) {
-            if (typeof images === 'string') {
-                // Try to parse if it's a JSON string
-                try {
-                    images = JSON.parse(images);
-                } catch (e) {
-                    // If parsing fails, wrap the single string in an array
-                    images = [images];
-                }
-            } else {
-                console.error("Invalid images data:", images);
-                return;
-            }
-        }
-        
-        previewContainer.innerHTML = '';
-        console.log(`Processing ${images.length} images for preview`);
-        
-        images.forEach((imageName, index) => {
-            console.log(`Processing image ${index}:`, imageName);
-            const preview = document.createElement('div');
-            preview.className = 'image-preview-item';
-            preview.innerHTML = `
-                <img src="/uploads/${imageName}" alt="Duplicate Image ${index + 1}" class="duplicate-image-preview">
-                <div class="image-controls">
-                    <span>Von Original übernommen</span>
-                    <button type="button" onclick="removeDuplicateImage('${imageName}', this)" class="remove-duplicate-image-button">Entfernen</button>
-                </div>
-            `;
-            previewContainer.appendChild(preview);
-        });
-    }
-    
-    // Function to remove a duplicate image
-    function removeDuplicateImage(imageName, button) {
-        // Remove the hidden input
-        const hiddenInputs = document.querySelectorAll('input[name="duplicate_images"]');
-        hiddenInputs.forEach(input => {
-            if (input.value === imageName) {
-                input.remove();
-            }
-        });
-        
-        // Remove the preview
-        const previewItem = button.closest('.image-preview-item');
-        if (previewItem) {
-            previewItem.remove();
+            console.log("Parsed duplicate images successfully.");
         }
     }
 </script>

docker-compose-multitenant.yml

@@ -55,6 +55,7 @@ services:
       interval: 10s
       timeout: 5s
       retries: 10
+      start_period: 30s
     environment:
       MONGO_INITDB_DATABASE: inventar_default
 

manage-tenant.sh

@@ -23,70 +23,19 @@ ensure_runtime_config_json() {
         echo "Warning: moved unexpected directory $config_path to $backup_path"
     fi
 
-        FORCE_REMOVE=false
-        if [ "${2:-}" = "--yes" ] || [ "${2:-}" = "-y" ]; then
-            FORCE_REMOVE=true
-            TENANT_ID="${3:-}"
-        fi
-
-        if [ -z "$TENANT_ID" ]; then
+    if [ ! -f "$config_path" ]; then
         cat > "$config_path" <<'EOF'
 {
     "ver": "2.6.5",
+    "tenants": {}
+}
+EOF
+        echo "Created default config.json"
+    fi
+}
 
-        if [ "$FORCE_REMOVE" != true ]; then
-            echo -n "WARNING: Are you sure you want to permanently delete all data for tenant '$TENANT_ID'? (y/N) "
-            read confirm
-            if [ "$confirm" != "y" ] && [ "$confirm" != "Y" ]; then
-                echo "Removal canceled."
-                exit 0
-            fi
-        fi
-
-        echo "Removing tenant '$TENANT_ID'..."
-        APP_CONTAINER=$(docker ps -qf "name=app" | head -n 1)
-        port_to_remove=""
-        if [ -n "$APP_CONTAINER" ]; then
-            port_to_remove="$({ docker exec "$APP_CONTAINER" python3 - "$TENANT_ID" <<'PY'
-import sys
-sys.path.insert(0, '/app')
-sys.path.insert(0, '/app/Web')
-from tenant import delete_tenant, get_tenant_config
-
-tenant_id = sys.argv[1]
-tenant_cfg = get_tenant_config(tenant_id)
-port = tenant_cfg.get('port')
-
-if not delete_tenant(tenant_id):
-    print(f'Error: failed to delete tenant {tenant_id}', file=sys.stderr)
-    sys.exit(1)
-
-if port is not None:
-    print(port)
-PY
-            } 2>/dev/null)"
-            echo "Tenant '$TENANT_ID' database and config removed."
-        else
-            echo "Warning: Application container not running. Tenant database may still exist in MongoDB."
-            if port_to_remove="$(remove_tenant_port "$TENANT_ID" 2>/dev/null)"; then
-                :
-            else
-                echo "Warning: tenant '$TENANT_ID' was not configured in config.json or could not be removed."
-            fi
-        fi
-
-        if [ -n "$port_to_remove" ]; then
-            remove_runtime_port "$port_to_remove"
-        fi
-        sync_tenant_port_map
-        if [ -n "$(docker ps -qf 'name=app' | head -n 1)" ]; then
-            restart_app_container
-        fi
-        if [ -n "$port_to_remove" ]; then
-            echo "Removed tenant '$TENANT_ID' and cleaned runtime port $port_to_remove."
-        else
-            echo "Removed tenant '$TENANT_ID'. No port mapping was present."
-        fi
+get_tenant_aliases() {
+    local tenant_id="$1"
     local normalized alias
     normalized="$(printf '%s' "$tenant_id" | tr '[:upper:]' '[:lower:]')"
     printf '%s\n' "$tenant_id"
@@ -212,7 +161,8 @@ existing['modules'] = {
     'inventory': {'enabled': True},
     'library': {'enabled': True},
     'student_cards': {'enabled': True, 'default_borrow_days': 14, 'max_borrow_days': 365},
-        'terminplan': {'enabled': True},
+    'terminplan': {'enabled': True},
+    'mail': {'enabled': True},
 }
 existing['trial'] = trial_config
 
@@ -244,8 +194,8 @@ initialize_tenant_database() {
         return 0
     fi
 
-    docker exec "$APP_CONTAINER" python3 -c '
-import sys, re, datetime, hashlib
+    docker exec -i "$APP_CONTAINER" python3 - "$tenant_id" "$mode" <<'PY'
+import sys, os, re, datetime, hashlib
 sys.path.insert(0, "/app")
 sys.path.insert(0, "/app/Web")
 from Web.modules.database import settings
@@ -257,7 +207,11 @@ sanitized = "".join(c for c in tenant_id if c.isalnum() or c == "_")
 db_name = f"inventar_{sanitized}"
 client = MongoClient(settings.MONGODB_HOST, int(settings.MONGODB_PORT))
 db = client[db_name]
-hashed_pw = hashlib.sha512("admin123".encode()).hexdigest()
+
+pw_bytes = "admin123".encode("utf-8")
+random_salt = os.urandom(16)
+hashed = hashlib.scrypt(pw_bytes, salt=random_salt, n=16384, r=8, p=1)
+hashed_pw_string = f"v1${random_salt.hex()}${hashed.hex()}"
 
 action_permissions = {
     "can_borrow": True,
@@ -293,7 +247,7 @@ page_permissions = {
 if db.users.count_documents({"Username": "admin"}) == 0:
     db.users.insert_one({
         "Username": "admin",
-        "Password": hashed_pw,
+        "Password": hashed_pw_string,
         "Admin": True,
         "active_ausleihung": None,
         "name": "Admin",
@@ -318,7 +272,7 @@ if mode == "trial":
     )
 
 print(f"Tenant {sys.argv[1]} database initialized. Default admin: admin / admin123")
-' "$tenant_id" "$mode"
+PY
 }
 
 update_runtime_ports() {
@@ -434,7 +388,6 @@ restart_app_container() {
 
     ensure_runtime_config_json
     
-    # If HOST_WORKDIR is set (called from container), use absolute paths so docker daemon resolves them correctly
     if [ -n "${HOST_WORKDIR:-}" ]; then
         workdir="$HOST_WORKDIR"
         compose_args+=( -f "$(readlink -f "$HOST_WORKDIR/docker-compose-multitenant.yml")" )
@@ -445,7 +398,6 @@ restart_app_container() {
             compose_args+=( --env-file "$(readlink -f "$HOST_WORKDIR/.docker-build.env")" )
         fi
     else
-        # Normal case: called directly from host
         compose_args+=( -f "$workdir/docker-compose-multitenant.yml" )
         if [ -f "$workdir/.docker-compose.runtime.override.yml" ]; then
             compose_args+=( -f "$workdir/.docker-compose.runtime.override.yml" )
@@ -455,7 +407,6 @@ restart_app_container() {
         fi
     fi
     
-    # Pass along COMPOSE_PROJECT_NAME if set so the internal docker-compose sees it
     if [ -n "${COMPOSE_PROJECT_NAME:-}" ]; then
         compose_args=( -p "$COMPOSE_PROJECT_NAME" "${compose_args[@]}" )
     fi
@@ -565,24 +516,83 @@ remove_runtime_port() {
     fi
 }
 
+show_help() {
+    local HEADER='\033[95m'
+    local BLUE='\033[94m'
+    local GREEN='\033[92m'
+    local YELLOW='\033[93m'
+    local RED='\033[91m'
+    local BOLD='\033[1m'
+    local RESET='\033[0m'
+
+    cat << EOF
+
+${HEADER}${BOLD}=== MULTI-TENANT INVENTAR MANAGER ===${RESET}
+${YELLOW}Nutzung:${RESET} $0 <befehl> [tenant_id] [optionen]
+
+${BLUE}${BOLD}VERFÜGBARE BEFEHLE:${RESET}
+  ${GREEN}add${RESET} <tenant_id> [port]
+    Legt einen neuen Tenant an, registriert den Port und initialisiert 
+    die MongoDB-Datenbank mit einem Standard-Admin (${YELLOW}admin / admin123${RESET}).
+
+  ${GREEN}trial${RESET} <tenant_id> [port] [tage]
+    Erstellt einen temporären Test-Tenant. Standardlaufzeit: 7 Tage.
+    Läuft automatisch ab und löscht sich selbst.
+
+  ${GREEN}remove${RESET} [-y|--yes] <tenant_id>
+    Löscht einen Tenant, seine Konfiguration, Ports und die Datenbank.
+    Nutze ${RED}-y${RESET}, um die Bestätigungsabfrage zu überspringen.
+
+  ${GREEN}restart-tenant${RESET} <tenant_id>
+    Startet einen spezifischen Tenant neu, indem alle aktiven Sessions 
+    und der Cache in der MongoDB geleert werden (Sitzungs-Reset).
+
+  ${GREEN}restart-all${RESET}
+    Führt einen Zero-Downtime Rolling-Restart für alle App-Container durch.
+
+  ${GREEN}list${RESET}
+    Listet alle registrierten Tenants aus der 'config.json' sowie alle 
+    aktiven Tenant-Datenbanken aus der MongoDB auf.
+
+  ${GREEN}module${RESET} <tenant_id> <modulname>=<on|off> ...
+    Aktiviert oder deaktiviert bestimmte Features/Module für einen Tenant.
+    Es können mehrere Module gleichzeitig übergeben werden.
+
+${BLUE}${BOLD}GLOBALE OPTIONEN:${RESET}
+  ${GREEN}-h, --help${RESET}
+    Zeigt diese Hilfe an.
+
+${YELLOW}Beispiele:${RESET}
+  $0 add schule_muenchen 8081
+  $0 trial test_user 8082 14
+  $0 module schule_muenchen barre_code=on leih_historie=off
+  $0 remove -y test_user
+
+-----------------------------------------------------------------
+EOF
+}
+
 if [ -z "${1:-}" ]; then
     show_help
+    exit 0
 fi
 
 COMMAND="$1"
-TENANT_ID="${2:-}"
+
+# === MAIN ROUTING BLOCK ===
 
 case "$COMMAND" in
     -h|--help)
         show_help
         ;;
     add)
+        TENANT_ID="${2:-}"
         if [ -z "$TENANT_ID" ]; then
             echo "Error: Please provide a tenant_id."
             exit 1
         fi
 
-        PORT_ARG="$3"
+        PORT_ARG="${3:-}"
         if [ -n "$PORT_ARG" ]; then
             if ! printf '%s\n' "$PORT_ARG" | grep -qE '^[0-9]+$'; then
                 echo "Error: Port must be a numeric value."
@@ -597,68 +607,13 @@ case "$COMMAND" in
         fi
 
         echo "Adding new tenant '$TENANT_ID'..."
-        # Initialize tenant database via Python inside container
         echo "Initializing database for $TENANT_ID..."
-        APP_CONTAINER=$(docker ps -qf "name=app" | head -n 1)
-        if [ -n "$APP_CONTAINER" ]; then
-            docker exec $APP_CONTAINER python3 -c "
-import sys, re; sys.path.insert(0, '/app'); sys.path.insert(0, '/app/Web'); from Web.modules.database import settings; from pymongo import MongoClient; import hashlib
-tenant_id = sys.argv[1].lower()
-sanitized = ''.join(c for c in tenant_id if c.isalnum() or c == '_')
-db_name = f'inventar_{sanitized}'
-client = MongoClient(settings.MONGODB_HOST, int(settings.MONGODB_PORT))
-db = client[db_name]
-hashed_pw = hashlib.sha512('admin123'.encode()).hexdigest()
-if db.users.count_documents({'Username': 'admin'}) == 0:
-    db.users.insert_one({
-        'Username': 'admin',
-        'Password': hashed_pw,
-        'Admin': True,
-        'active_ausleihung': None,
-        'name': 'Admin',
-        'last_name': 'User',
-        'IsStudent': False,
-        'PermissionPreset': 'full_access',
-        'ActionPermissions': {
-            'can_borrow': True,
-            'can_insert': True,
-            'can_edit': True,
-            'can_delete': True,
-            'can_manage_users': True,
-            'can_manage_settings': True,
-            'can_view_logs': True,
-        },
-        'PagePermissions': {
-            'home': True,
-            'tutorial_page': True,
-            'my_borrowed_items': True,
-            'notifications_view': True,
-            'impressum': True,
-            'license': True,
-            'library_view': True,
-            'terminplan': True,
-            'home_admin': True,
-            'upload_admin': True,
-            'library_admin': True,
-            'admin_borrowings': True,
-            'library_loans_admin': True,
-            'admin_damaged_items': True,
-            'admin_audit_dashboard': True,
-            'logs': True,
-            'manage_filters': True,
-            'manage_locations': True,
-        },
-    })
-print(f'Tenant {sys.argv[1]} database initialized. Default admin: admin / admin123')
-" "$TENANT_ID"
-            echo "Tenant '$TENANT_ID' successfully added. Ready to use."
-        else
-            echo "Warning: Application container is not running. Please start the multi-tenant system first."
-            echo "Data will be initialized upon first access by the tenant."
-        fi
+        initialize_tenant_database "$TENANT_ID" "standard"
+        echo "Tenant '$TENANT_ID' successfully added. Ready to use."
         ;;
 
     trial)
+        TENANT_ID="${2:-}"
         if [ -z "$TENANT_ID" ]; then
             echo "Error: Please provide a tenant_id."
             exit 1
@@ -690,9 +645,13 @@ print(f'Tenant {sys.argv[1]} database initialized. Default admin: admin / admin1
     
     remove)
         FORCE_REMOVE=false
-        if [ "${2:-}" = "--yes" ] || [ "${2:-}" = "-y" ]; then
+        TENANT_ARG="${2:-}"
+        
+        if [ "$TENANT_ARG" = "--yes" ] || [ "$TENANT_ARG" = "-y" ]; then
             FORCE_REMOVE=true
             TENANT_ID="${3:-}"
+        else
+            TENANT_ID="$TENANT_ARG"
         fi
 
         if [ -z "$TENANT_ID" ]; then
@@ -712,17 +671,32 @@ print(f'Tenant {sys.argv[1]} database initialized. Default admin: admin / admin1
         echo "Removing tenant '$TENANT_ID'..."
         APP_CONTAINER=$(docker ps -qf "name=app" | head -n 1)
         port_to_remove=""
+        
         if [ -n "$APP_CONTAINER" ]; then
+            # Zuerst die Datenbank via PyMongo hart droppen (Erzwungenes Löschen)
             port_to_remove="$(docker exec "$APP_CONTAINER" python3 - "$TENANT_ID" <<'PY'
-import sys
+import sys, re
 sys.path.insert(0, '/app')
 sys.path.insert(0, '/app/Web')
 from tenant import delete_tenant, get_tenant_config
+from Web.modules.database import settings
+from pymongo import MongoClient
 
 tenant_id = sys.argv[1]
 tenant_cfg = get_tenant_config(tenant_id)
 port = tenant_cfg.get('port')
 
+# Datenbanknamen exakt rekonstruieren
+sanitized = "".join(c for c in tenant_id if c.isalnum() or c == "_")
+db_name = f"inventar_{sanitized}"
+
+try:
+    client = MongoClient(settings.MONGODB_HOST, int(settings.MONGODB_PORT))
+    client.drop_database(db_name)
+    print(f"MongoDB database '{db_name}' dropped successfully.", file=sys.stderr)
+except Exception as e:
+    print(f"Warning: Could not drop database '{db_name}': {e}", file=sys.stderr)
+
 if not delete_tenant(tenant_id):
     print(f'Error: failed to delete tenant {tenant_id}', file=sys.stderr)
     sys.exit(1)
@@ -756,20 +730,19 @@ PY
         ;;
 
     restart-tenant)
+        TENANT_ID="${2:-}"
         if [ -z "$TENANT_ID" ]; then
             echo "Error: Please provide a tenant_id."
             exit 1
         fi
         echo "Restarting tenant '$TENANT_ID' (clearing session/cache)..."
-        # To restart a single tenant without restarting the global python processes,
-        # we can invalidate their cache or drop their sessions collection to sign everyone out
         APP_CONTAINER=$(docker ps -qf "name=app" | head -n 1)
         if [ -n "$APP_CONTAINER" ]; then
             docker exec $APP_CONTAINER python3 -c "
 import sys; sys.path.insert(0, '/app'); sys.path.insert(0, '/app/Web'); from Web.modules.database import settings; from pymongo import MongoClient
 client = MongoClient(settings.MONGODB_HOST, int(settings.MONGODB_PORT))
 db = client[f'{settings.MONGODB_DB}_{sys.argv[1]}']
-db.sessions.drop() # Force sign-out / session clear
+db.sessions.drop()
 print(f'Tenant {sys.argv[1]} session cache cleared. Tenant restarted.')
 " "$TENANT_ID"
             echo "Tenant '$TENANT_ID' has been refreshed without impacting others."
@@ -832,12 +805,12 @@ PY
         ;;
 
     module)
+        TENANT_ID="${2:-}"
         if [ -z "$TENANT_ID" ] || [ -z "${3:-}" ]; then
             echo "Error: Usage: manage-tenant.sh module <tenant_id> <module_name>=<on|off> [...]"
             exit 1
         fi
         
-        # Pass all remaining arguments to python script
         shift 2
         
         if python3 - "$CONFIG_FILE" "$TENANT_ID" "$@" <<'PY'
@@ -913,4 +886,4 @@ PY
         ;;
 esac
 
-exit 0
+exit 0

requirements.txt

@@ -15,3 +15,4 @@ openpyxl
 cryptography>=42.0.0
 pywebpush
 py-vapid>=1.9.0
+beautifulsoup4