changes to the Username displayment

Web/app.py

@@ -163,12 +163,63 @@ def _display_username(user_value):
     if user_value is None or str(user_value).strip() == '':
         return ''
 
+    raw_value = str(user_value).strip()
+    decrypted_value = decrypt_text(raw_value)
+    lookup_values = [raw_value]
+    if decrypted_value and decrypted_value not in lookup_values:
+        lookup_values.append(str(decrypted_value).strip())
+
+    for lookup_value in lookup_values:
+        user_doc = us.get_user_by_id(lookup_value)
+        if not user_doc:
+            user_doc = us.get_user_by_student_card(lookup_value)
+        if not user_doc:
+            user_doc = us.get_user_by_student_card_record_id(lookup_value)
+        if not user_doc:
+            user_doc = us.get_user(lookup_value)
+        if user_doc:
+            return str(user_doc.get('Username') or user_doc.get('username') or lookup_value)
+
+    client = None
+    try:
+        client = MongoClient(MONGODB_HOST, MONGODB_PORT)
+        cards = get_tenant_db(client)['student_cards']
+        card_queries = [{'AusweisId': lookup_value} for lookup_value in lookup_values]
+        if ObjectId.is_valid(raw_value):
+            card_queries.insert(0, {'_id': ObjectId(raw_value)})
+        card = cards.find_one({'$or': card_queries}) if card_queries else None
+        if card:
+            card = _decrypt_student_card_doc(card)
+            card_name = str(card.get('SchülerName') or '').strip()
+            if card_name:
+                return card_name
+    finally:
+        if client:
+            client.close()
+
+    return str(decrypted_value or raw_value)
+
+
+def _resolve_library_card_id(user_value):
+    """Return the card ID for a stored user reference."""
+    if user_value is None or str(user_value).strip() == '':
+        return ''
+
     raw_value = str(user_value).strip()
     user_doc = us.get_user_by_id(raw_value)
     if user_doc:
-        return str(user_doc.get('Username') or user_doc.get('username') or raw_value)
+        return str(user_doc.get('StudentCardId') or raw_value).strip().upper()
 
-    return decrypt_text(raw_value)
+    decrypted_value = decrypt_text(raw_value)
+    user_doc = us.get_user_by_id(decrypted_value)
+    if not user_doc:
+        user_doc = us.get_user_by_student_card(decrypted_value)
+    if not user_doc:
+        user_doc = us.get_user_by_student_card_record_id(decrypted_value)
+    if user_doc:
+        return str(user_doc.get('StudentCardId') or decrypted_value).strip().upper()
+
+    return str(decrypted_value or raw_value).strip().upper()
 
 
 def _decrypt_student_card_doc(card_doc):
@@ -1660,8 +1711,7 @@ def update_appointment_statuses():
                 raw_user = str(appt.get('User', '')).strip()
 
                 # Entschlüsselung der AusweisId
-                decrypted_user = _display_username(raw_user)
-                target_ausweis_id = decrypted_user if decrypted_user else raw_user
+                target_ausweis_id = _resolve_library_card_id(raw_user)
                 item_id = appt.get('Item')
 
                 if not target_ausweis_id:
@@ -3554,7 +3604,7 @@ def library_loans_admin():
             fmt_reports, fmt_repairs = format_damage_history(raw_reports, raw_repairs)
 
             raw_user = record.get('User', '')
-            decrypted_user = safe_decrypt(raw_user)
+            decrypted_user = _display_username(raw_user)
 
             user_class = (
                     safe_decrypt(record.get('Klasse'))
@@ -3715,8 +3765,7 @@ def mahnungen_admin():
                 item_code = item_doc.get('Code_4', '')
 
                 raw_user = str(record.get('User') or '')
-                decrypted_user = decrypt_text(raw_user)
-                ausweis_id = (decrypted_user if decrypted_user else raw_user).strip().upper()
+                ausweis_id = _resolve_library_card_id(raw_user)
 
                 student_card = card_map.get(ausweis_id, {})
                 student_name = student_card.get('SchülerName', ausweis_id if ausweis_id else 'Unbekannt')
@@ -3803,8 +3852,7 @@ def mahnungen_reset(days):
 
         # 3. Schülerausweis ermitteln und entsperren
         raw_user = str(record.get('User', ''))
-        decrypted_user = decrypt_text(raw_user)
-        ausweis_id = decrypted_user if decrypted_user else raw_user
+        ausweis_id = _resolve_library_card_id(raw_user)
 
         card = student_cards_col.find_one({'AusweisId': ausweis_id})
         if not card and raw_user != ausweis_id:
@@ -3865,8 +3913,7 @@ def mahnungen_send_email():
 
         # Gegenstand und Schülerausweis ermitteln
         raw_user = str(record.get('User', ''))
-        decrypted_user = decrypt_text(raw_user)
-        ausweis_id = decrypted_user if decrypted_user else raw_user
+        ausweis_id = _resolve_library_card_id(raw_user)
 
         card = student_cards_col.find_one({'AusweisId': ausweis_id})
         student_card = _decrypt_student_card_doc(card) if card and '_decrypt_student_card_doc' in globals() else (
@@ -4218,8 +4265,7 @@ def api_library_return_by_code():
                 continue
 
             # AusweisId entschlüsseln
-            decrypted_user = decrypt_text(raw_user) if 'safe_decrypt' in globals() else raw_user
-            ausweis_id = decrypted_user if decrypted_user else raw_user
+            ausweis_id = _resolve_library_card_id(raw_user)
 
             # Prüfen, ob der Schüler noch andere eskalierte Ausleihungen hat
             # Da die aktuelle Ausleihe oben auf 'completed' gesetzt wurde, wird sie hier nicht mitgezählt!
@@ -4474,7 +4520,6 @@ def api_item_detail(item_id):
         db = client[MONGODB_DB]
         ausleihungen_col = db['ausleihungen']
         items_col = db['items']
-        student_cards_col = db['student_cards']
 
         # Determine parent/group id (if this is a child, use its ParentItemId)
         parent_id = str(item.get('ParentItemId') or str(item.get('_id')))
@@ -4515,15 +4560,7 @@ def api_item_detail(item_id):
         def get_borrower_name(user_raw):
             if not user_raw:
                 return ''
-            try:
-                user_doc = student_cards_col.find_one({'_id': ObjectId(user_raw)})
-                if user_doc:
-                    if user_doc.get('SchülerName'):
-                        return decrypt_text(str(user_doc.get('SchülerName', '')))
-                    return str(user_doc.get('AusweisId', ''))
-            except Exception:
-                pass
-            return str(user_raw)
+            return _display_username(user_raw)
 
         # Prefer the most recent active borrower across the group
         borrower_value = ''
@@ -11533,6 +11570,7 @@ def my_borrowed_items():
         username,
         str(current_user.get('_id')) if current_user.get('_id') else '',
         str(session.get('user_id') or ''),
+        str(current_user.get('StudentCardId') or '').strip().upper(),
     }
     user_ids.discard('')
 
@@ -11555,6 +11593,7 @@ def my_borrowed_items():
         try:
             if raw_user:
                 user_values.add(str(decrypt_text(raw_user)).strip())
+                user_values.add(_resolve_library_card_id(raw_user))
         except Exception:
             pass
 
@@ -11612,6 +11651,7 @@ def my_borrowed_items():
         try:
             if raw_item_user:
                 item_user_values.add(str(decrypt_text(raw_item_user)).strip())
+                item_user_values.add(_resolve_library_card_id(raw_item_user))
         except Exception:
             pass
 

Web/modules/database/user.py

@@ -695,13 +695,42 @@ def get_user_by_student_card(student_card_id):
     if not normalized:
         return None
     client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
-    db = _get_tenant_db(client)
-    users = db['student_cards']
-    found_user = users.find_one({'AusweisId': normalized})
-    client.close()
+    try:
+        db = _get_tenant_db(client)
+        users = db['users']
+        return users.find_one({
+            '$or': [
+                {'StudentCardId': normalized},
+                {'StudentCardId': student_card_id},
+            ]
+        })
+    finally:
+        client.close()
+
+
+def get_user_by_student_card_record_id(card_id):
+    """Return the user assigned to a student-card document ID."""
+    if card_id is None:
+        return None
+
+    client = MongoClient(cfg.MONGODB_HOST, cfg.MONGODB_PORT)
+    try:
+        db = _get_tenant_db(client)
+        card = None
+        if isinstance(card_id, ObjectId):
+            card = db['student_cards'].find_one({'_id': card_id})
+        elif ObjectId.is_valid(str(card_id)):
+            card = db['student_cards'].find_one({'_id': ObjectId(str(card_id))})
+        if not card:
+            return None
+
+        card_id_value = normalize_student_card_id(card.get('AusweisId'))
+        if not card_id_value:
+            return None
+        return db['users'].find_one({'StudentCardId': card_id_value})
+    finally:
+        client.close()
 
-    # Do not call dp.decrypt_text() here because found_user is a MongoDB dictionary.
-    return found_user
 
 def get_user_by_student_ident(student_ident):
     """Return user dict by student ident by decrypting all cards and matching."""