Merge branch 'development' into feature/list-of-incomplete-vorgaben

- Redesign incomplete Vorgaben page from card layout to unified table format
- Add visual status indicators (✓/✗) for each completeness category
- Link Vorgaben directly to admin edit pages (/autorenumgebung/ instead of /admin/)
- Enhance Vorgabe admin with Kurztext and Langtext inlines for complete editing
- Update all tests to work with new table structure and admin URLs
- Add JavaScript for dynamic summary count updates
- Maintain staff-only access control and responsive design

All 112 tests passing successfully.

argocd/deployment.yaml

@@ -25,7 +25,7 @@ spec:
               mountPath: /data
       containers:
         - name: web
-          image: git.baumann.gr/adebaumann/vui:0.941
+          image: git.baumann.gr/adebaumann/vui:0.942
           imagePullPolicy: Always
           ports:
             - containerPort: 8000

dokumente/admin.py

@@ -207,10 +207,43 @@ class ThemaAdmin(admin.ModelAdmin):
     search_fields = ['name']
     ordering = ['name']
 
+@admin.register(Vorgabe)
+class VorgabeAdmin(NestedModelAdmin):
+    form = VorgabeForm
+    list_display = ['vorgabe_nummer', 'titel', 'dokument', 'thema', 'gueltigkeit_von', 'gueltigkeit_bis']
+    list_filter = ['dokument', 'thema', 'gueltigkeit_von', 'gueltigkeit_bis']
+    search_fields = ['nummer', 'titel', 'dokument__nummer', 'dokument__name']
+    autocomplete_fields = ['stichworte', 'referenzen', 'relevanz']
+    ordering = ['dokument', 'order']
+    
+    inlines = [
+        VorgabeKurztextInline, 
+        VorgabeLangtextInline, 
+        ChecklistenfragenInline
+    ]
+    
+    fieldsets = (
+        ('Grunddaten', {
+            'fields': (('order', 'nummer'), ('dokument', 'thema'), 'titel'),
+            'classes': ('wide',),
+        }),
+        ('Gültigkeit', {
+            'fields': (('gueltigkeit_von', 'gueltigkeit_bis'),),
+            'classes': ('wide',),
+        }),
+        ('Verknüpfungen', {
+            'fields': (('referenzen', 'stichworte', 'relevanz'),),
+            'classes': ('wide',),
+        }),
+    )
+    
+    def vorgabe_nummer(self, obj):
+        return obj.Vorgabennummer()
+    vorgabe_nummer.short_description = 'Vorgabennummer'
+
 admin.site.register(Checklistenfrage)
 admin.site.register(Dokumententyp)
 #admin.site.register(Person)
 #admin.site.register(Referenz, DraggableM§PTTAdmin)
-admin.site.register(Vorgabe)
 
 #admin.site.register(Changelog)

dokumente/models.py

@@ -60,7 +60,7 @@ class Vorgabe(models.Model):
     order = models.IntegerField()
     nummer = models.IntegerField()
     dokument = models.ForeignKey(Dokument, on_delete=models.CASCADE, related_name='vorgaben')
-    thema = models.ForeignKey(Thema, on_delete=models.PROTECT)
+    thema = models.ForeignKey(Thema, on_delete=models.PROTECT, blank=False)
     titel = models.CharField(max_length=255)
     referenzen = models.ManyToManyField(Referenz, blank=True)
     gueltigkeit_von = models.DateField()
@@ -132,13 +132,13 @@ class Vorgabe(models.Model):
                     })
         
         return conflicts
-    
+
     def clean(self):
         """
         Validate the Vorgabe before saving.
         """
         from django.core.exceptions import ValidationError
-        
+
         # Check for conflicts with existing Vorgaben
         conflicts = self.find_conflicts()
         if conflicts:
@@ -172,9 +172,9 @@ class Vorgabe(models.Model):
                     'vorgabe1': self,
                     'vorgabe2': other_vorgabe,
                     'conflict_type': 'date_range_intersection',
-                    'message': f"Vorgabe {self.Vorgabennummer()} conflicts with "
-                              f"existing {other_vorgabe.Vorgabennummer()} "
-                              f"due to overlapping validity periods"
+                    'message': f"Vorgabe {self.Vorgabennummer()} in Konflikt mit "
+                              f"bestehender {other_vorgabe.Vorgabennummer()} "
+                              f" - Geltungsdauer übeschneidet sich"
                 })
         
         return conflicts

dokumente/templates/standards/incomplete_vorgaben.html

@@ -0,0 +1,151 @@
+{% extends "base.html" %}
+{% block content %}
+<h1 class="mb-4">Unvollständige Vorgaben</h1>
+
+{% if vorgaben_data %}
+    <div class="table-responsive">
+        <table class="table table-striped table-hover">
+            <thead class="table-dark">
+                <tr>
+                    <th>Vorgabe</th>
+                    <th class="text-center">Referenzen</th>
+                    <th class="text-center">Stichworte</th>
+                    <th class="text-center">Text</th>
+                    <th class="text-center">Checklistenfragen</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for item in vorgaben_data %}
+                <tr>
+                    <td>
+                        <a href="/autorenumgebung/dokumente/vorgabe/{{ item.vorgabe.id }}/change/" 
+                           class="text-decoration-none" target="_blank">
+                            <strong>{{ item.vorgabe.Vorgabennummer }}</strong><br>
+                            <small class="text-muted">{{ item.vorgabe.titel }}</small><br>
+                            <small class="text-muted">{{ item.vorgabe.dokument.nummer }} – {{ item.vorgabe.dokument.name }}</small>
+                        </a>
+                    </td>
+                    <td class="text-center align-middle">
+                        {% if item.has_references %}
+                            <span class="text-success fs-4">✓</span>
+                        {% else %}
+                            <span class="text-danger fs-4">✗</span>
+                        {% endif %}
+                    </td>
+                    <td class="text-center align-middle">
+                        {% if item.has_stichworte %}
+                            <span class="text-success fs-4">✓</span>
+                        {% else %}
+                            <span class="text-danger fs-4">✗</span>
+                        {% endif %}
+                    </td>
+                    <td class="text-center align-middle">
+                        {% if item.has_text %}
+                            <span class="text-success fs-4">✓</span>
+                        {% else %}
+                            <span class="text-danger fs-4">✗</span>
+                        {% endif %}
+                    </td>
+                    <td class="text-center align-middle">
+                        {% if item.has_checklistenfragen %}
+                            <span class="text-success fs-4">✓</span>
+                        {% else %}
+                            <span class="text-danger fs-4">✗</span>
+                        {% endif %}
+                    </td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+
+    <!-- Summary -->
+    <div class="row mt-4">
+        <div class="col-12">
+            <div class="card">
+                <div class="card-header">
+                    <h5 class="mb-0">Zusammenfassung</h5>
+                </div>
+                <div class="card-body">
+                    <div class="row text-center">
+                        <div class="col-md-3">
+                            <div class="p-3">
+                                <h4 class="text-danger" id="no-references-count">0</h4>
+                                <p class="mb-0">Ohne Referenzen</p>
+                            </div>
+                        </div>
+                        <div class="col-md-3">
+                            <div class="p-3">
+                                <h4 class="text-danger" id="no-stichworte-count">0</h4>
+                                <p class="mb-0">Ohne Stichworte</p>
+                            </div>
+                        </div>
+                        <div class="col-md-3">
+                            <div class="p-3">
+                                <h4 class="text-danger" id="no-text-count">0</h4>
+                                <p class="mb-0">Ohne Text</p>
+                            </div>
+                        </div>
+                        <div class="col-md-3">
+                            <div class="p-3">
+                                <h4 class="text-danger" id="no-checklistenfragen-count">0</h4>
+                                <p class="mb-0">Ohne Checklistenfragen</p>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="row mt-3">
+                        <div class="col-12 text-center">
+                            <h4 class="text-primary">Gesamt: {{ vorgaben_data|length }} unvollständige Vorgaben</h4>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+{% else %}
+    <div class="alert alert-success" role="alert">
+        <h4 class="alert-heading">
+            <i class="fas fa-check-circle"></i> Alle Vorgaben sind vollständig!
+        </h4>
+        <p>Alle Vorgaben haben Referenzen, Stichworte, Text und Checklistenfragen.</p>
+        <hr>
+        <p class="mb-0">
+            <a href="{% url 'standard_list' %}" class="btn btn-primary">
+                <i class="fas fa-list"></i> Zurück zur Übersicht
+            </a>
+        </p>
+    </div>
+{% endif %}
+
+<div class="mt-3">
+    <a href="{% url 'standard_list' %}" class="btn btn-secondary">
+        <i class="fas fa-arrow-left"></i> Zurück zur Übersicht
+    </a>
+</div>
+
+<script>
+// Update summary counts
+document.addEventListener('DOMContentLoaded', function() {
+    let noReferences = 0;
+    let noStichworte = 0;
+    let noText = 0;
+    let noChecklistenfragen = 0;
+    
+    const rows = document.querySelectorAll('tbody tr');
+    rows.forEach(function(row) {
+        const cells = row.querySelectorAll('td');
+        if (cells.length >= 5) {
+            if (cells[1].textContent.trim() === '✗') noReferences++;
+            if (cells[2].textContent.trim() === '✗') noStichworte++;
+            if (cells[3].textContent.trim() === '✗') noText++;
+            if (cells[4].textContent.trim() === '✗') noChecklistenfragen++;
+        }
+    });
+    
+    document.getElementById('no-references-count').textContent = noReferences;
+    document.getElementById('no-stichworte-count').textContent = noStichworte;
+    document.getElementById('no-text-count').textContent = noText;
+    document.getElementById('no-checklistenfragen-count').textContent = noChecklistenfragen;
+});
+</script>
+{% endblock %}

dokumente/tests.py

@@ -1,6 +1,7 @@
 from django.test import TestCase, Client
 from django.urls import reverse
 from django.core.management import call_command
+from django.contrib.auth.models import User
 from datetime import date, timedelta
 from io import StringIO
 from .models import (
@@ -628,7 +629,7 @@ class VorgabeSanityCheckTest(TestCase):
         conflict = conflicts[0]
         self.assertEqual(conflict['conflict_type'], 'date_range_intersection')
         self.assertIn('R0066.O.1', conflict['message'])
-        self.assertIn('intersecting validity periods', conflict['message'])
+        self.assertIn('überschneiden sich in der Geltungsdauer', conflict['message'])
         self.assertEqual(conflict['vorgabe1'], self.vorgabe1)
         self.assertEqual(conflict['vorgabe2'], conflicting_vorgabe)
     
@@ -711,8 +712,8 @@ class VorgabeSanityCheckTest(TestCase):
         with self.assertRaises(Exception) as context:
             conflicting_vorgabe.clean()
         
-        self.assertIn('conflicts with existing', str(context.exception))
-        self.assertIn('overlapping validity periods', str(context.exception))
+        self.assertIn('Konflikt mit bestehender', str(context.exception))
+        self.assertIn('Geltungsdauer übeschneidet sich', str(context.exception))
     
     def test_check_vorgabe_conflicts_utility(self):
         """Test check_vorgabe_conflicts utility function"""
@@ -816,4 +817,321 @@ class SanityCheckManagementCommandTest(TestCase):
         self.assertIn("Starting Vorgaben sanity check...", output)
         self.assertIn("Found 1 conflicts:", output)
         self.assertIn("R0066.O.1", output)
-        self.assertIn("intersecting validity periods", output)
+        self.assertIn("überschneiden sich in der Geltungsdauer", output)
+
+
+class IncompleteVorgabenTest(TestCase):
+    """Test cases for incomplete Vorgaben functionality"""
+    
+    def setUp(self):
+        self.client = Client()
+        
+        # Create and login a staff user
+        self.staff_user = User.objects.create_user(
+            username='teststaff',
+            password='testpass123'
+        )
+        self.staff_user.is_staff = True
+        self.staff_user.save()
+        self.client.login(username='teststaff', password='testpass123')
+        
+        # Create test data
+        self.dokumententyp = Dokumententyp.objects.create(
+            name="Test Typ",
+            verantwortliche_ve="Test VE"
+        )
+        
+        self.thema = Thema.objects.create(
+            name="Test Thema",
+            erklaerung="Test Erklärung"
+        )
+        
+        self.dokument = Dokument.objects.create(
+            nummer="TEST-001",
+            dokumententyp=self.dokumententyp,
+            name="Test Dokument",
+            gueltigkeit_von=date.today(),
+            aktiv=True
+        )
+        
+        # Create complete Vorgabe (should not appear in any list)
+        self.complete_vorgabe = Vorgabe.objects.create(
+            order=1,
+            nummer=1,
+            dokument=self.dokument,
+            thema=self.thema,
+            titel="Vollständige Vorgabe",
+            gueltigkeit_von=date.today()
+        )
+        
+        # Add all required components to make it complete
+        self.stichwort = Stichwort.objects.create(
+            stichwort="Test Stichwort"
+        )
+        self.complete_vorgabe.stichworte.add(self.stichwort)
+        
+        self.referenz = Referenz.objects.create(
+            name_nummer="Test Referenz",
+            url="/test/path"
+        )
+        self.complete_vorgabe.referenzen.add(self.referenz)
+        
+        VorgabeKurztext.objects.create(
+            abschnitt=self.complete_vorgabe,
+            inhalt="Test Kurztext"
+        )
+        
+        Checklistenfrage.objects.create(
+            vorgabe=self.complete_vorgabe,
+            frage="Test Frage"
+        )
+        
+        # Create incomplete Vorgaben
+        # 1. Vorgabe without references
+        self.no_refs_vorgabe = Vorgabe.objects.create(
+            order=2,
+            nummer=2,
+            dokument=self.dokument,
+            thema=self.thema,
+            titel="Vorgabe ohne Referenzen",
+            gueltigkeit_von=date.today()
+        )
+        self.no_refs_vorgabe.stichworte.add(self.stichwort)
+        VorgabeKurztext.objects.create(
+            abschnitt=self.no_refs_vorgabe,
+            inhalt="Test Kurztext"
+        )
+        Checklistenfrage.objects.create(
+            vorgabe=self.no_refs_vorgabe,
+            frage="Test Frage"
+        )
+        
+        # 2. Vorgabe without Stichworte
+        self.no_stichworte_vorgabe = Vorgabe.objects.create(
+            order=3,
+            nummer=3,
+            dokument=self.dokument,
+            thema=self.thema,
+            titel="Vorgabe ohne Stichworte",
+            gueltigkeit_von=date.today()
+        )
+        self.no_stichworte_vorgabe.referenzen.add(self.referenz)
+        VorgabeKurztext.objects.create(
+            abschnitt=self.no_stichworte_vorgabe,
+            inhalt="Test Kurztext"
+        )
+        Checklistenfrage.objects.create(
+            vorgabe=self.no_stichworte_vorgabe,
+            frage="Test Frage"
+        )
+        
+        # 3. Vorgabe without text
+        self.no_text_vorgabe = Vorgabe.objects.create(
+            order=4,
+            nummer=4,
+            dokument=self.dokument,
+            thema=self.thema,
+            titel="Vorgabe ohne Text",
+            gueltigkeit_von=date.today()
+        )
+        self.no_text_vorgabe.stichworte.add(self.stichwort)
+        self.no_text_vorgabe.referenzen.add(self.referenz)
+        Checklistenfrage.objects.create(
+            vorgabe=self.no_text_vorgabe,
+            frage="Test Frage"
+        )
+        
+        # 4. Vorgabe without Checklistenfragen
+        self.no_checklisten_vorgabe = Vorgabe.objects.create(
+            order=5,
+            nummer=5,
+            dokument=self.dokument,
+            thema=self.thema,
+            titel="Vorgabe ohne Checklistenfragen",
+            gueltigkeit_von=date.today()
+        )
+        self.no_checklisten_vorgabe.stichworte.add(self.stichwort)
+        self.no_checklisten_vorgabe.referenzen.add(self.referenz)
+        VorgabeKurztext.objects.create(
+            abschnitt=self.no_checklisten_vorgabe,
+            inhalt="Test Kurztext"
+        )
+    
+    def test_incomplete_vorgaben_page_status(self):
+        """Test that the incomplete Vorgaben page loads successfully"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertEqual(response.status_code, 200)
+    
+    def test_incomplete_vorgaben_page_content(self):
+        """Test that the page contains expected content"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertContains(response, 'Unvollständige Vorgaben')
+        self.assertContains(response, 'Referenzen')
+        self.assertContains(response, 'Stichworte')
+        self.assertContains(response, 'Text')
+        self.assertContains(response, 'Checklistenfragen')
+        # Check for table structure
+        self.assertContains(response, '<table class="table table-striped table-hover">')
+        self.assertContains(response, '<th class="text-center">Referenzen</th>')
+    
+    def test_no_references_list(self):
+        """Test that Vorgaben without references are listed"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertContains(response, 'Vorgabe ohne Referenzen')
+        self.assertNotContains(response, 'Vollständige Vorgabe')  # Should not appear
+    
+    def test_no_stichworte_list(self):
+        """Test that Vorgaben without Stichworte are listed"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertContains(response, 'Vorgabe ohne Stichworte')
+        self.assertNotContains(response, 'Vollständige Vorgabe')  # Should not appear
+    
+    def test_no_text_list(self):
+        """Test that Vorgaben without Kurz- or Langtext are listed"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertContains(response, 'Vorgabe ohne Text')
+        self.assertNotContains(response, 'Vollständige Vorgabe')  # Should not appear
+    
+    def test_no_checklistenfragen_list(self):
+        """Test that Vorgaben without Checklistenfragen are listed"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertContains(response, 'Vorgabe ohne Checklistenfragen')
+        self.assertNotContains(response, 'Vollständige Vorgabe')  # Should not appear
+    
+    def test_vorgabe_links(self):
+        """Test that Vorgaben link to their admin pages"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        # Should contain links to Vorgabe admin pages
+        self.assertContains(response, 'href="/autorenumgebung/dokumente/vorgabe/2/change/"')
+        self.assertContains(response, 'href="/autorenumgebung/dokumente/vorgabe/3/change/"')
+        self.assertContains(response, 'href="/autorenumgebung/dokumente/vorgabe/4/change/"')
+        self.assertContains(response, 'href="/autorenumgebung/dokumente/vorgabe/5/change/"')
+    
+    def test_badge_counts(self):
+        """Test that badge counts are correct"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        # Check that JavaScript updates the counts correctly
+        self.assertContains(response, 'id="no-references-count"')
+        self.assertContains(response, 'id="no-stichworte-count"')
+        self.assertContains(response, 'id="no-text-count"')
+        self.assertContains(response, 'id="no-checklistenfragen-count"')
+        # Check total count
+        self.assertContains(response, 'Gesamt: 4 unvollständige Vorgaben')
+    
+    def test_summary_section(self):
+        """Test that summary section shows correct counts"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertContains(response, 'Zusammenfassung')
+        self.assertContains(response, 'Ohne Referenzen')
+        self.assertContains(response, 'Ohne Stichworte')
+        self.assertContains(response, 'Ohne Text')
+        self.assertContains(response, 'Ohne Checklistenfragen')
+        self.assertContains(response, 'Gesamt: 4 unvollständige Vorgaben')
+    
+    def test_empty_lists_message(self):
+        """Test that appropriate messages are shown when lists are empty"""
+        # Delete all incomplete Vorgaben
+        Vorgabe.objects.exclude(pk=self.complete_vorgabe.pk).delete()
+        
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertContains(response, 'Alle Vorgaben sind vollständig!')
+        self.assertContains(response, 'Alle Vorgaben haben Referenzen, Stichworte, Text und Checklistenfragen.')
+    
+    def test_back_link(self):
+        """Test that back link to standard list exists"""
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertContains(response, 'href="/dokumente/"')
+        self.assertContains(response, 'Zurück zur Übersicht')
+    
+    def test_navigation_link(self):
+        """Test that navigation includes link to incomplete Vorgaben"""
+        response = self.client.get('/dokumente/')
+        self.assertContains(response, 'href="/dokumente/unvollstaendig/"')
+        self.assertContains(response, 'Unvollständig')
+    
+    def test_vorgabe_with_langtext_only(self):
+        """Test that Vorgabe with only Langtext is still considered incomplete for text"""
+        vorgabe_langtext_only = Vorgabe.objects.create(
+            order=6,
+            nummer=6,
+            dokument=self.dokument,
+            thema=self.thema,
+            titel="Vorgabe nur mit Langtext",
+            gueltigkeit_von=date.today()
+        )
+        vorgabe_langtext_only.stichworte.add(self.stichwort)
+        vorgabe_langtext_only.referenzen.add(self.referenz)
+        
+        # Add only Langtext, no Kurztext
+        VorgabeLangtext.objects.create(
+            abschnitt=vorgabe_langtext_only,
+            inhalt="Test Langtext"
+        )
+        # Add Checklistenfragen to make it complete in that aspect
+        Checklistenfrage.objects.create(
+            vorgabe=vorgabe_langtext_only,
+            frage="Test Frage"
+        )
+        
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        # Debug: print response content to see where it appears
+        print("Response content:", response.content.decode())
+        # Should NOT appear in "no text" list because it has Langtext
+        self.assertNotContains(response, 'Vorgabe nur mit Langtext')
+    
+    def test_vorgabe_with_both_text_types(self):
+        """Test that Vorgabe with both Kurztext and Langtext is complete"""
+        vorgabe_both_text = Vorgabe.objects.create(
+            order=7,
+            nummer=7,
+            dokument=self.dokument,
+            thema=self.thema,
+            titel="Vorgabe mit beiden Texten",
+            gueltigkeit_von=date.today()
+        )
+        vorgabe_both_text.stichworte.add(self.stichwort)
+        vorgabe_both_text.referenzen.add(self.referenz)
+        
+        # Add both Kurztext and Langtext
+        VorgabeKurztext.objects.create(
+            abschnitt=vorgabe_both_text,
+            inhalt="Test Kurztext"
+        )
+        VorgabeLangtext.objects.create(
+            abschnitt=vorgabe_both_text,
+            inhalt="Test Langtext"
+        )
+        # Add Checklistenfragen to make it complete in that aspect
+        Checklistenfrage.objects.create(
+            vorgabe=vorgabe_both_text,
+            frage="Test Frage"
+        )
+        
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        # Should NOT appear in "no text" list because it has both text types
+        self.assertNotContains(response, 'Vorgabe mit beiden Texten')
+    
+    def test_incomplete_vorgaben_staff_only(self):
+        """Test that non-staff users are redirected to login"""
+        # Logout the staff user
+        self.client.logout()
+        
+        # Try to access the page as anonymous user
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertEqual(response.status_code, 302)  # Redirect to login
+        
+        # Create a regular (non-staff) user
+        regular_user = User.objects.create_user(
+            username='regularuser',
+            password='testpass123'
+        )
+        self.client.login(username='regularuser', password='testpass123')
+        
+        # Try to access the page as regular user
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertEqual(response.status_code, 302)  # Redirect to login
+        
+        # Login as staff user again - should work
+        self.client.login(username='teststaff', password='testpass123')
+        response = self.client.get(reverse('incomplete_vorgaben'))
+        self.assertEqual(response.status_code, 200)  # Success

dokumente/urls.py

@@ -3,6 +3,7 @@ from . import views
 
 urlpatterns = [
     path('', views.standard_list, name='standard_list'),
+    path('unvollstaendig/', views.incomplete_vorgaben, name='incomplete_vorgaben'),
     path('<str:nummer>/', views.standard_detail, name='standard_detail'),
     path('<str:nummer>/history/<str:check_date>/', views.standard_detail),
     path('<str:nummer>/history/', views.standard_detail, {"check_date":"today"}, name='standard_history'),

dokumente/views.py

@@ -1,5 +1,6 @@
 from django.shortcuts import render, get_object_or_404
-from .models import Dokument
+from django.contrib.auth.decorators import login_required, user_passes_test
+from .models import Dokument, Vorgabe, VorgabeKurztext, VorgabeLangtext, Checklistenfrage
 from abschnitte.utils import render_textabschnitte
 
 from datetime import date
@@ -56,3 +57,48 @@ def standard_checkliste(request, nummer):
     })
 
 
+def is_staff_user(user):
+    return user.is_staff
+
+@login_required
+@user_passes_test(is_staff_user)
+def incomplete_vorgaben(request):
+    """
+    Show table of all Vorgaben with completeness status:
+    - References (✓ or ✗)
+    - Stichworte (✓ or ✗)
+    - Text (✓ or ✗)
+    - Checklistenfragen (✓ or ✗)
+    """
+    # Get all active Vorgaben
+    all_vorgaben = Vorgabe.objects.all().select_related('dokument', 'thema').prefetch_related(
+        'referenzen', 'stichworte', 'checklistenfragen', 'vorgabekurztext_set', 'vorgabelangtext_set'
+    )
+    
+    # Build table data
+    vorgaben_data = []
+    for vorgabe in all_vorgaben:
+        has_references = vorgabe.referenzen.exists()
+        has_stichworte = vorgabe.stichworte.exists()
+        has_kurztext = vorgabe.vorgabekurztext_set.exists()
+        has_langtext = vorgabe.vorgabelangtext_set.exists()
+        has_text = has_kurztext or has_langtext
+        has_checklistenfragen = vorgabe.checklistenfragen.exists()
+        
+        # Only include Vorgaben that are incomplete in at least one way
+        if not (has_references and has_stichworte and has_text and has_checklistenfragen):
+            vorgaben_data.append({
+                'vorgabe': vorgabe,
+                'has_references': has_references,
+                'has_stichworte': has_stichworte,
+                'has_text': has_text,
+                'has_checklistenfragen': has_checklistenfragen,
+                'is_complete': has_references and has_stichworte and has_text and has_checklistenfragen
+            })
+    
+    # Sort by document number and Vorgabe number
+    vorgaben_data.sort(key=lambda x: (x['vorgabe'].dokument.nummer, x['vorgabe'].Vorgabennummer()))
+    
+    return render(request, 'standards/incomplete_vorgaben.html', {
+        'vorgaben_data': vorgaben_data,
+    })

pages/templates/base.html

@@ -17,6 +17,9 @@
   <div class="collapse navbar-collapse" id="navbarNavAltMarkup">
     <div class="navbar-nav">
       <a class="nav-item nav-link active" href="/dokumente">Standards</a>
+      {% if user.is_staff %}
+      <a class="nav-item nav-link" href="/dokumente/unvollstaendig/">Unvollständig</a>
+      {% endif %}
       <a class="nav-item nav-link" href="/referenzen">Referenzen</a>
       <a class="nav-item nav-link" href="/stichworte">Stichworte</a>
       <a class="nav-item nav-link" href="/search">Suche</a>
@@ -28,6 +31,6 @@
     <div class="flex-fill">{% block content %}Main Content{% endblock %}</div>
     <div class="col-md-2">{% block sidebar_right %}{% endblock %}</div>
 </div>
-<div>VorgabenUI v0.941</div>
+<div>VorgabenUI v0.942</div>
 </body>
 </html>

pages/views.py

@@ -6,7 +6,7 @@ from abschnitte.utils import render_textabschnitte
 from dokumente.models import Dokument, VorgabeLangtext, VorgabeKurztext, Geltungsbereich, Vorgabe
 from itertools import groupby
 import datetime
-import pprint
+
 
 def startseite(request):
     standards=list(Dokument.objects.filter(aktiv=True))
@@ -66,6 +66,6 @@ def search(request):
         geltungsbereich=set(list([x.geltungsbereich for x in Geltungsbereich.objects.filter(inhalt__icontains=suchbegriff)]))
         for s in geltungsbereich:
             result["geltungsbereich"][s]=render_textabschnitte(s.geltungsbereich_set.order_by("order"))
-        pprint.pp (result)
+
         return render(request,"results.html",{"suchbegriff":safe_search_term,"resultat":result})