diff --git a/.eslintrc.json b/.eslintrc.json
index a5bc36c2..15b7e14a 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -19,6 +19,7 @@
     "enableMapLocate": true,
     "featureGeometry": true,
     "fetchGeoJsonFeatureCollection": true,
+    "fetchPdf": true,
     "filterApplication": true,
     "filterReset": true,
     "getFeatureCenter": true,
diff --git a/.gitignore b/.gitignore
index c16bbe76..eee61ca1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,7 +7,6 @@ db.sqlite3
 
 # Datenwerft.HRO
 datenwerft/secrets.py
-datenmanagement/migrations
 hilfe/build
 /static
 /uploads
diff --git a/datenmanagement/static/datenmanagement/js/list.js b/datenmanagement/static/datenmanagement/js/list.js
index c491d303..e92b47b6 100644
--- a/datenmanagement/static/datenmanagement/js/list.js
+++ b/datenmanagement/static/datenmanagement/js/list.js
@@ -21,6 +21,34 @@ function formatData(data, brReplacement) {
   return data.trim(); // remove any remaining whitespaces from both sides
 }
 
+/**
+ * @function
+ * @name fetchPdf
+ *
+ * fetches PDF file
+ *
+ * @param {string} url - URL
+ * @param {string} csrfToken - CSRF token
+ * @param {string} host - host
+ */
+function fetchPdf(url, csrfToken, host){
+  const response = fetch(
+    url, {
+      method: 'POST',
+      headers: {
+        contentType: 'application/json',
+        'X-CSRFToken': csrfToken
+      },
+      redirect: 'follow',
+      origin: host,
+      referrerPolicy: 'no-referrer',
+      body: JSON.stringify(window.renderParams)
+    }
+  );
+  response.then(response => response.blob())
+  .then(myblob => window.open(URL.createObjectURL(myblob)));
+}
+
 /**
  * @function
  * @name initDataTable
diff --git a/datenmanagement/templates/datenmanagement/list.html b/datenmanagement/templates/datenmanagement/list.html
index c753f727..9ffcad95 100644
--- a/datenmanagement/templates/datenmanagement/list.html
+++ b/datenmanagement/templates/datenmanagement/list.html
@@ -75,6 +75,7 @@ <h4 class="mt-3">
           window.dataUrl = '{{ url_model_tabledata }}';
         {% endif %}
         window.languageUrl = '{% static 'datatables/datatables.german.lang' %}';
+        window.checkAllTarget = true;
       </script>
       <script>
         /**
@@ -126,9 +127,46 @@ <h4 class="mt-3">
               'Bei der Übernahme der aktuellen Filtermenge auf die Karte ist ein Serverfehler aufgetreten.'
             );
           });
+
+          // fetch PDF file on clicking the "OK" button in the PDF export confirmation modal...
+          $('#confirm-export-modal-ok').on('click', () => fetchPdf(
+            '{% url "toolbox:renderpdf" %}', '{{ csrf_token }}', '{{ request.get_host }}'
+          ));
+
+          // fetch PDF file on clicking the PDF export button...
+          $('#template-button').on('click', function() {
+            let checkedBoxes = $('.action-checkbox').filter(':checked');
+            let tplSelector = $('#template-selector');
+            let desiredTplId = tplSelector.value;
+            window.renderParams= {
+              'pks': [],
+              'templateid': desiredTplId,
+              'datenthema': '{{ model_name }}',
+              'onlyactive': !$('#onlyactive').prop('checked'),
+            };
+            if (checkedBoxes.length > 0) {
+              for (let i = 0; i < checkedBoxes.length; i++)
+                window.renderParams.pks.push(checkedBoxes[i].value);
+              fetchPdf(
+                '{% url "toolbox:renderpdf" %}', '{{ csrf_token }}', '{{ request.get_host }}'
+              );
+            }
+            else {
+              $('#confirm-export-modal').modal('toggle');
+            }
+          });
+
+          // select or unselect all rows (= records)
+          $('#check-all').on('click', function() {
+            let target = window.checkAllTarget;
+            $('.action-checkbox').each(function() {
+              $(this).prop('checked', target);
+            });
+            window.checkAllTarget = !target;
+          });
         });
 
-        // as soon as a row (= record) has been selected or deselected...
+        // as soon as a row (= record) has been selected or unselected...
         $('body').on('change', '.action-checkbox', function() {
           let actionCheckboxes = $('.action-checkbox').filter(':checked');
           // adjust information texts accordingly
@@ -157,5 +195,6 @@ <h4 class="mt-3">
       </div>
     {% endif %}
     {% include "modal-error.html" %}
+    {% include "modal-confirm-export.html" with objcount=objects_count %}
   {% endif %}
 {% endblock %}
diff --git a/datenmanagement/views/views_list_map.py b/datenmanagement/views/views_list_map.py
index 5051339c..b63db8a0 100644
--- a/datenmanagement/views/views_list_map.py
+++ b/datenmanagement/views/views_list_map.py
@@ -1,6 +1,7 @@
 from datetime import date, datetime, timezone
 from decimal import Decimal
 from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
 from django.core.serializers import serialize
 from django.urls import reverse
 from django.utils.html import escape
@@ -13,6 +14,7 @@
 from zoneinfo import ZoneInfo
 
 from datenmanagement.utils import get_data, get_thumb_url, localize_number
+from toolbox.models import SuitableFor
 from toolbox.utils import optimize_datatable_filter
 from .functions import add_basic_model_context_elements, add_user_agent_context_elements, \
   get_model_objects
@@ -277,6 +279,9 @@ def get_context_data(self, **kwargs):
     else:
       context['objects_count'] = get_model_objects(self.model, None, True)
     context['url_back'] = reverse('datenmanagement:' + model_name + '_start')
+    content_type = ContentType.objects.get_for_model(self.model)
+    suitable_templates = SuitableFor.objects.filter(datenthema=content_type)
+    context['suitables'] = suitable_templates
     return context
 
 
diff --git a/datenwerft/settings.py b/datenwerft/settings.py
index a5ac8709..a53d9490 100644
--- a/datenwerft/settings.py
+++ b/datenwerft/settings.py
@@ -242,6 +242,23 @@
 }
 
 
+# Toolbox app:
+# PDF export
+
+PDF_ESCAPE = [
+  ('&', r'\&'),
+  (chr(8211), '--')
+]
+PDF_JINJASTRINGS = {
+  'block_start': r'\JINJA{',
+  'block_end': '}',
+  'variable_start': r'\VAR{',
+  'variable_end': '}',
+  'comment_start': r'\JCMNT{',
+  'comment_end': '}'
+}
+
+
 # configuration file with additional parameters
 # which must not fall under Git version control
 
diff --git a/datenwerft/templates/modal-confirm-export.html b/datenwerft/templates/modal-confirm-export.html
new file mode 100644
index 00000000..9a0a08fd
--- /dev/null
+++ b/datenwerft/templates/modal-confirm-export.html
@@ -0,0 +1,19 @@
+<div id="confirm-export-modal" class="modal" tabindex="-1"> <!-- aria-labelledby?-->
+  <div class="modal-dialog">
+    <div class="modal-content">
+      <div id="confirm-export-modal-header" class="modal-header">
+        <h5 id="confirmexport-modal-title" class="modal-title">alle Datensätze exportieren?</h5>
+      </div>
+      <div id="confirm-export-modal-body" class="modal-body">
+        <div class="text-center">
+          <p>Sie haben keinen Eintrag ausgewählt. Es werden also alle vorhandenen Datensätze dieses Datenthemas exportiert. Dies kann lange dauern und ungewollt große Dokumente erzeugen.</p>
+          <p><strong>{{ objcount }} Datensätze werden exportiert.</strong></p>
+        </div>
+      </div>
+      <div class="modal-footer">
+        <button type="button" class="btn btn-primary" id="confirm-export-modal-ok" data-bs-dismiss="modal">Export durchführen</button>
+        <button type="button" class="btn btn-warning" id="confirm-export-modal-cancel" data-bs-dismiss="modal">abbrechen</button>
+      </div>
+    </div>
+  </div>
+</div>
diff --git a/datenwerft/templates/modal-error.html b/datenwerft/templates/modal-error.html
index 3195f6a4..8056344c 100644
--- a/datenwerft/templates/modal-error.html
+++ b/datenwerft/templates/modal-error.html
@@ -2,7 +2,7 @@
   <div class="modal-dialog">
     <div class="modal-content">
       <div id="error-modal-header" class="modal-header">
-          <h5 id="error-modal-title" class="modal-title"></h5>
+        <h5 id="error-modal-title" class="modal-title"></h5>
       </div>
       <div id="error-modal-body" class="modal-body"></div>
       <div class="modal-footer">
diff --git a/datenwerft/templates/modal-loading.html b/datenwerft/templates/modal-loading.html
index b2349a99..abcf9ab5 100644
--- a/datenwerft/templates/modal-loading.html
+++ b/datenwerft/templates/modal-loading.html
@@ -2,7 +2,7 @@
   <div class="modal-dialog">
     <div class="modal-content">
       <div id="loading-modal-header" class="modal-header">
-          <h5 id="loading-modal-title" class="modal-title"></h5>
+        <h5 id="loading-modal-title" class="modal-title"></h5>
       </div>
       <div id="loading-modal-body" class="modal-body">
         <span id="loading-modal-body-text"></span>
diff --git a/requirements.txt b/requirements.txt
index b5d3202a..7a4d2f86 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,6 +5,7 @@ django-jsonview
 django-leaflet
 django-user-agents
 djangorestframework
+Jinja2
 Pillow
 psycopg2-binary
 PyYAML
diff --git a/toolbox/405.html b/toolbox/405.html
new file mode 100644
index 00000000..5e4e46b4
--- /dev/null
+++ b/toolbox/405.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<body>
+  <head>
+  </head>
+  <html>
+    <h1>405 Falsche Methode</h1>
+    Sie haben eine GET-Anfrage gesendet (vermutlich, indem sie diese URL direkt mit dem Browser angewählt haben). Vorgesehen ist, dass in der App Datenmanagement aus ihren Eingaben in den Datenthemen-Ansichten ein POST-Request zusammengestellt wird, der hierhergesandt und mit einem PDF beantwortet wird.
+  </html>
+</body>
diff --git a/toolbox/README.md b/toolbox/README.md
index 6b87b8ec..7fa7fcb9 100644
--- a/toolbox/README.md
+++ b/toolbox/README.md
@@ -31,51 +31,48 @@ Perspektivisch soll der Pfad `toolbox/mkpdf` zu einer Konfigurationsdirektive we
 
 ## Gebrauch
 
-Die Verwaltung der Templates erfolgt im Django-Admin. Es gibt zwei Datenmodelle: `PdfTemplate` und `SuitableFor`. 
+Die Verwaltung der Templates erfolgt im *Django*-Admin. Es gibt zwei Datenmodelle: `PdfTemplate` und `SuitableFor`. 
 
-### PdfTemplate
+### `PdfTemplate`
 
-* werden hochgeladen, und müssen einen sprechenden Namen bekommen. Dieser wird dem User bei geeigneten Datenthemen zur Auswahl angezeigt. 
-* Sind LaTeX-Dateien mit Jinja2-TemplateTags. 
+-  werden hochgeladen und müssen einen sprechenden Namen erhalten; dieser wird dem Benutzer bei geeigneten Datenthemen zur Auswahl angezeigt
+-  sind *LaTeX*-Dateien mit *Jinja2*-Template-Tags
 
-### SuitableFor
+### `SuitableFor`
 
-* Sind eine Verknüpfung zwischen Datenthemen (mittels `ContentTypes`) und PdfTemplates. 
-* Können direkt im Admin für die Templates erzeugt werden.
-* Pflichtfelder sind:
-	+ `Datenthema`: für welches Thema das Template als geeignet bezeichnet werden soll.
-	+ `Template`: von welchem Template das `SuitableFor` handelt. Bei Verwendung des Inline-Admin im PdfTemplate-Admin ist klar, dass es um das gerade bearbeitete Template geht.
-
-* Das Feld `ins Template zu speisende Attribute` ist kein Pflichtfeld, eventuelle Einträge müssen das Format `[[feld, breite]]` haben.
-	+ `feld` muss ein Attributname des gewählten Datenthemas sein
-	+ `breite` muss eine von LaTeX verarbeitbare Längenangabe sein (zB `12mm`, `10pt`, `2in`). Dies wird (noch) nicht geprüft. Auch noch nicht geprüft wird, ob die Summe der Einträge die Breite einer Seite überschreitet. 
-	+ Diese Angaben stehen im Templatekontext *zur Verfügung*, nur die angegebenen Spalten zu nutzen, ist Aufgabe des Templateautors.
-
-* Das Feld `Sortierung der Einträge` verlangt das Format `[Sortierschlüssel]`, wobei Sortierschlüssel ein Feld des gewählten Datenthemas sein muss. Es darf ein "minus", - , vorangestellt werden. Nach diesem Feld wird dann aufsteigend sortiert. Es können mehrere Sortierschlüssel angegeben werden, dann wird von links nach rechts geschachtelt sortiert. Also in der Art `["baujahr", "-nutzfläche"]`. 
-
-* Existiert für ein Datenthema ein `SuitableFor`-Objekt, dann wird in der Listenansicht zu diesem Thema das verknüpfte Template zur Auswahl stehen.
+-  sind Verknüpfungen zwischen Datenthemen (mittels `ContentTypes`) und `PdfTemplate`
+-  können direkt im *Django*-Admin für die Templates erzeugt werden
+-  Pflichtfelder sind:
+   - *Datenthema:* für welches Datenthema das Template als geeignet bezeichnet werden soll
+   - *Template:* von welchem Template das `SuitableFor` handelt; bei Verwendung des Inline-Admin im `PdfTemplate`-Admin ist klar, dass es um das gerade bearbeitete Template geht
+-  Das Feld *ins Template zu speisende Attribute* ist kein Pflichtfeld, eventuelle Einträge müssen das Format `[[feld, breite]]` haben:
+   - `feld` muss ein Attributname des gewählten Datenthemas sein
+   - `breite` muss eine von *LaTeX* verarbeitbare Längenangabe sein (zB `12mm`, `10pt`, `2in`). Dies wird (noch) nicht geprüft. Auch noch nicht geprüft wird, ob die Summe der Einträge die Breite einer Seite überschreitet. 
+-  Das Feld *Sortierung der Einträge* verlangt das Format `[Sortierschlüssel]`, wobei der Sortierschlüssel ein Feld des gewählten Datenthemas sein muss. Es darf ein „-“ vorangestellt werden. Nach diesem Feld wird dann aufsteigend sortiert. Es können mehrere Sortierschlüssel angegeben werden, dann wird von links nach rechts geschachtelt sortiert – also in der Art `["baujahr", "-nutzfläche"]`.
+-  Existiert für ein Datenthema ein `SuitableFor`-Objekt, dann wird in der Listenansicht zu diesem Thema das verknüpfte Template zur Auswahl stehen.
 
 ## Templates
 
-Grundsätzlich sind die Templates LaTeX-Dokumente, in welchen Jinja-Template-Tags genutzt werden können. Die jinja-Marker {% STATEMENT %} und {{ DATA }} sind ersetzt durch \JINJA{STATEMENT} und \VAR{DATA}.
+Grundsätzlich sind die Templates *LaTeX*-Dokumente, in denen *Jinja2*-Template-Tags genutzt werden können. Die *Jinja2*-Marker `{% STATEMENT %}` und `{{ DATA }}` sind ersetzt durch `\JINJA{STATEMENT}` und `\VAR{DATA}`.
 
 Im Kontext-Dictionary stehen die folgenden Daten zur Verfügung:
 
-* `jetzt` - Ein deutsch formatierter Datumsstempel (dd.mm.jjjj).
-* `datenthema` - Der Name des gerade zu verarbeitenden Datenthemas (für den Titel des Dokuments).
-* `usedkeys` - Die im Abschnitt [SuitableFor](.SuitableFor) beschriebenen zu verarbeitenden Tupel aus Schlüssel und wie breit die Tabellenspalte für diesen Schlüssel sein soll.
-* `display_names` - Ein dictionary `{attrnamen: displaynamen}`. `attrnamen` sind die internen Namen der Felder des Datenthemas, wie sie auch in `usedkeys` auftauchen, `displaynamen` sind die anzuzeigenden Kurzbeschreibungen/Darstellnamen der Felder.
-* `records` - Ein Django-Queryset, sortiert wie im `SuitableFor` eingestellt.
+-  `jetzt` – deutsch formatierter Datumsstempel (dd.mm.jjjj)
+-  `datenthema` – Name des gerade zu verarbeitenden Datenthemas (für den Titel des Dokuments)
+-  `usedkeys` – die im Abschnitt [SuitableFor](#suitablefor) beschriebenen, zu verarbeitenden Tupel aus Schlüssel und wie breit die Tabellenspalte für diesen Schlüssel sein soll
+-  `display_names` – ein Dictionary `{attrnamen: displaynamen}`: `attrnamen` sind die internen Namen der Felder des Datenthemas, wie sie auch in `usedkeys` auftauchen, `displaynamen` sind die anzuzeigenden Kurzbeschreibungen/Darstellnamen der Felder
+-  `records` – ein *Django*-Queryset, sortiert wie im `SuitableFor` eingestellt
 
-* Sollte das Erzeugen des PDFs fehlschlagen, so wird `stdout` von `pdflatex` als Antwort zurückgegeben. Es empfiehlt sich trotzdem, die Templates vorerst auf dem eigenen Rechner zu schreiben und zu testen. 
+Sollte das Erzeugen der PDF-Datei fehlschlagen, so wird `stdout` von `pdflatex` als Antwort zurückgegeben. Es empfiehlt sich trotzdem, die Templates vorerst auf dem eigenen Rechner zu schreiben und zu testen. 
 
-* es können mithilfe der Jinja-Sprache nun die verschiedenen Daten ins Template gepumpt werden. Besonders hervorgehoben seien hier 
-	+ der LaTeX-Befehl `\begin{longtable}`
-	+ jinjas for-Schleife, bei uns mit `\JINJA{for}, \JINJA{endfor}`
-	+ die Möglichkeit, im Template Variablen zu setzen, so kann über eine Liste von Schlüsseln iteriert werden, welche im Schleifenkörper nochmals als Schlüssel verwendet werden (zB für die Verarbeitung baumartiger Strukturen. Sie `pdfs.py: sortforbaudenkmale()` und das Template `Custom-Baudenkmale`
+Es können mit Hilfe der *Jinja2*-Sprache nun die verschiedenen Daten ins Template gepumpt werden. Besonders hervorgehoben seien hier:
 
-Für eine Einführung in Jinja sei auf die die Jinja-Dokumentation, [Abschnitt Template-Designer](https://jinja.palletsprojects.com/en/3.0.x/templates/), verwiesen und für LaTeX auf die große Menge an brauchbarer Literatur und Handbüchern, insbesondere [diesen Kurzeinstieg](https://www.ctan.org/pkg/lshort-german). Für gewöhnlich gibt es zu jeder erdenklichen Frage, die einem beim \LaTeX-Schreiben einfallen könnte, einen Thread in einem Forum, oder einen Artikel in den [Hilfeseiten von Overleaf](https://overleaf.com/learn/).
+-  der *LaTeX*-Befehl `\begin{longtable}`,
+-  die `for`-Schleife von *Jinja2,* bei uns mit `\JINJA{for}, \JINJA{endfor}` und
+-  die Möglichkeit, im Template Variablen zu setzen; so kann über eine Liste von Schlüsseln iteriert werden, die im Schleifenkörper nochmals als Schlüssel verwendet werden (z.B. für die Verarbeitung baumartiger Strukturen, siehe `pdfs.py: sortforbaudenkmale()` und das Template `Custom-Baudenkmale`)
 
+Für eine Einführung in *Jinja2* sei auf die die *Jinja2*-Dokumentation, [Abschnitt Template-Designer](https://jinja.palletsprojects.com/en/3.0.x/templates/), verwiesen und für *LaTeX* auf die große Menge an brauchbarer Literatur und Handbüchern, insbesondere [diesen Kurzeinstieg](https://www.ctan.org/pkg/lshort-german). Für gewöhnlich gibt es zu jeder erdenklichen Frage, die einem beim *LaTeX*-Schreiben einfallen könnte, einen Thread in einem Forum oder einen Artikel in den [Hilfeseiten von Overleaf](https://overleaf.com/learn/).
 
 ## TODO
-In der Klasse *SuitableFor* existiert ein Feld *Bemerkungen*, sodass bei mehreren Verknüpfungen desselben Datenthemas mit demselben Template jeweils im Auswahlmenü ein eigener Text angezeigt werden kann. Im Moment wird der Template-Name angezeigt. Dies gilt es noch zu ändern. Außerdem zur Diskussion stand, die Objekte auch in Karten einzutragen und diese Karten in die Exporte einzubetten.
+
+In der Klasse `SuitableFor` existiert ein Feld *Bemerkungen,* sodass bei mehreren Verknüpfungen desselben Datenthemas mit demselben Template jeweils im Auswahlmenü ein eigener Text angezeigt werden kann. Im Moment wird der Template-Name angezeigt. Dies gilt es noch zu ändern. Außerdem zur Diskussion stand die Objekte auch in Karten einzutragen und diese Karten in die Exporte einzubetten.
\ No newline at end of file
diff --git a/toolbox/admin.py b/toolbox/admin.py
new file mode 100644
index 00000000..74d2fccf
--- /dev/null
+++ b/toolbox/admin.py
@@ -0,0 +1,51 @@
+from django.contrib import admin
+from .models import PdfTemplate, SuitableFor
+from django.db import models
+from django.forms import TextInput, ModelForm
+from django.core.exceptions import ValidationError
+
+
+class SuitableForInline(admin.StackedInline):
+  model = SuitableFor
+  fieldsets = [(None, {'fields': ['id', 'datenthema', 'bemerkungen', 'usedkeys', 'sortby']})]
+
+
+@admin.register(PdfTemplate)
+class PdfTemplateAdmin(admin.ModelAdmin):
+  list_display = ('id', 'name', 'created_at', 'description')
+  inlines = [SuitableForInline]
+  formfield_overrides = {
+    models.CharField: {'widget': TextInput(attrs={'size': '20'})}
+  }
+
+
+class SuitableForm(ModelForm):
+
+  def get_f_names(self):
+    fields = self.cleaned_data['datenthema'].model_class()._meta.get_fields()
+    return [f.name for f in fields]
+
+  def clean_sortby(self):
+    keylist = self.cleaned_data['sortby']
+    fieldnames = self.get_f_names()
+    if keylist is not None:
+      for key in keylist:
+        if key not in fieldnames and not (key[0] == '-' and key[1:] in fieldnames):
+          raise ValidationError(f"{key} ist kein Feld von {self.cleaned_data['datenthema']}!")
+    return self.cleaned_data['sortby']
+
+  def clean_usedkeys(self):
+    keylist = self.cleaned_data['usedkeys']
+    fieldnames = self.get_f_names()
+    if keylist is not None:
+      for key in keylist:
+        if key[0] not in fieldnames:
+          raise ValidationError(f"{key[0]} ist kein Feld von {self.cleaned_data['datenthema']}!")
+    return keylist
+
+
+@admin.register(SuitableFor)
+class SuitableForAdmin(admin.ModelAdmin):
+  ordering = ['datenthema']
+  list_display = ('id', 'datenthema', 'template__name', 'bemerkungen')
+  form = SuitableForm
diff --git a/toolbox/management/__init__.py b/toolbox/management/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/toolbox/management/commands/__init__.py b/toolbox/management/commands/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/toolbox/management/commands/cleanpdfdir.py b/toolbox/management/commands/cleanpdfdir.py
new file mode 100644
index 00000000..613fdbc4
--- /dev/null
+++ b/toolbox/management/commands/cleanpdfdir.py
@@ -0,0 +1,28 @@
+import os
+from django.conf import settings
+from django.core.management.base import BaseCommand
+
+
+class Command(BaseCommand):
+  def handle(self, *args, **options):
+
+    verbose = False
+    if options.get('verbosity') > 1:
+      verbose = True
+
+    rmroot = os.path.join(settings.BASE_DIR, 'toolbox', 'mkpdf')
+    os.chdir(rmroot)
+    fs = os.listdir()
+    deld = 0
+    skpd = 0
+    for f in fs:
+      if f[:4] == 'tmp_':
+        os.remove(f)
+        if verbose:
+          print(f'del {f}')
+        deld += 1
+      else:
+        if verbose:
+          print(f'skip {f}')
+        skpd += 1
+    print(f'{deld} Datei(en) gelöscht, {skpd} Datei(en) übersprungen in {rmroot}')
diff --git a/toolbox/migrations/0002_pdftemplate_suitablefor_pdftemplate_suitedfor.py b/toolbox/migrations/0002_pdftemplate_suitablefor_pdftemplate_suitedfor.py
new file mode 100644
index 00000000..4c08a55a
--- /dev/null
+++ b/toolbox/migrations/0002_pdftemplate_suitablefor_pdftemplate_suitedfor.py
@@ -0,0 +1,49 @@
+# Generated by Django 4.2.5 on 2023-09-29 07:43
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+        ('toolbox', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='PdfTemplate',
+            fields=[
+                ('id', models.AutoField(primary_key=True, serialize=False)),
+                ('created_at', models.DateTimeField(auto_now=True, verbose_name='Erstellungszeitpunkt')),
+                ('templatefile', models.FileField(upload_to='', verbose_name='tatsächliche Templatedatei')),
+                ('name', models.TextField(default='noch nicht benannt', verbose_name='Name des Templates')),
+                ('description', models.TextField(verbose_name='Kurzbeschreibung des Templates')),
+            ],
+            options={
+                'verbose_name': 'Export-Vorlage',
+                'verbose_name_plural': 'Export-Vorlagen',
+            },
+        ),
+        migrations.CreateModel(
+            name='SuitableFor',
+            fields=[
+                ('id', models.AutoField(primary_key=True, serialize=False)),
+                ('usedkeys', models.JSONField(blank=True, null=True, verbose_name='ins Template zu speisende Attribute')),
+                ('sortby', models.JSONField(blank=True, null=True, verbose_name='Sortierung der Einträge')),
+                ('bemerkungen', models.TextField(blank=True, null=True)),
+                ('datenthema', models.ForeignKey(limit_choices_to={'app_label': 'datenmanagement'}, on_delete=django.db.models.deletion.CASCADE, to='contenttypes.contenttype')),
+                ('template', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='toolbox.pdftemplate')),
+            ],
+            options={
+                'verbose_name': 'Vorlage-Datenthema-Verknüpfung',
+                'verbose_name_plural': 'Vorlage-Datenthema-Verknüpfungen',
+            },
+        ),
+        migrations.AddField(
+            model_name='pdftemplate',
+            name='suitedfor',
+            field=models.ManyToManyField(through='toolbox.SuitableFor', to='contenttypes.contenttype', verbose_name='geeignet für Datenthemen'),
+        ),
+    ]
diff --git a/toolbox/models.py b/toolbox/models.py
index 6791f118..b4f1a0bb 100644
--- a/toolbox/models.py
+++ b/toolbox/models.py
@@ -1,7 +1,7 @@
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.postgres.fields import ArrayField
-from django.db.models import CASCADE, ForeignKey, Model
-from django.db.models.fields import AutoField, CharField, DateTimeField
+from django.db.models import CASCADE, FileField, ForeignKey, JSONField, ManyToManyField, Model
+from django.db.models.fields import AutoField, CharField, DateTimeField, TextField
 
 
 class Subsets(Model):
@@ -20,7 +20,7 @@ class Subsets(Model):
   )
   pk_values = ArrayField(
     CharField(
-      # data model primary keys are UUIDs (36 chars in length)
+      # usually, model primary keys are UUIDs (36 chars in length)
       max_length=36
     )
   )
@@ -31,3 +31,71 @@ class Meta:
 
   def __str__(self):
     return str(self.id)
+
+
+class PdfTemplate(Model):
+  id = AutoField(
+    primary_key=True
+  )
+  created_at = DateTimeField(
+    'Erstellungszeitpunkt',
+    auto_now=True
+  )
+  templatefile = FileField(
+    'tatsächliche Templatedatei'
+  )
+  suitedfor = ManyToManyField(
+    ContentType,
+    through='SuitableFor',
+    verbose_name='geeignet für Datenthemen'
+  )
+  name = TextField(
+    'Name des Templates',
+    default='noch nicht benannt'
+  )
+  description = TextField(
+    'Kurzbeschreibung des Templates'
+  )
+
+  class Meta:
+    verbose_name = 'Export-Vorlage'
+    verbose_name_plural = 'Export-Vorlagen'
+
+  def __str__(self):
+    return self.name
+
+
+class SuitableFor(Model):
+  id = AutoField(
+    primary_key=True
+  )
+  datenthema = ForeignKey(
+    ContentType,
+    on_delete=CASCADE,
+    limit_choices_to={'app_label': 'datenmanagement'}
+  )
+  template = ForeignKey(
+    PdfTemplate,
+    on_delete=CASCADE
+  )
+  usedkeys = JSONField(
+    'ins Template zu speisende Attribute',
+    blank=True,
+    null=True
+  )
+  sortby = JSONField(
+    'Sortierung der Einträge',
+    blank=True,
+    null=True
+  )
+  bemerkungen = TextField(
+    blank=True,
+    null=True
+  )
+
+  class Meta:
+    verbose_name = 'Vorlage-Datenthema-Verknüpfung'
+    verbose_name_plural = 'Vorlage-Datenthema-Verknüpfungen'
+
+  def template__name(self):
+    return self.template.name
diff --git a/toolbox/pdfs.py b/toolbox/pdfs.py
new file mode 100644
index 00000000..8b5c7f6e
--- /dev/null
+++ b/toolbox/pdfs.py
@@ -0,0 +1,303 @@
+import jinja2
+import json
+import subprocess
+from datetime import datetime
+from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
+from functools import cmp_to_key
+from itertools import chain
+from os.path import join as joinpath
+from uuid import uuid1
+
+from datenmanagement.models.models_simple import Baudenkmale, Denkmalbereiche
+from .models import SuitableFor
+
+
+def compare_adresses(denkmal1, denkmal2):
+  l1 = denkmal1['position'].split(' ')
+  l2 = denkmal2['position'].split(' ')
+  nr1 = ''
+  nr2 = ''
+
+  for wort1, wort2 in zip(l1, l2):
+    if wort1[0].isdigit():
+      # Wir sind bei den Hausnummern angelangt.
+      i = 0
+      j = 0
+      while i < len(wort1) and wort1[i].isdigit():
+        nr1 += (wort1[i])
+        i += 1
+      while j < len(wort2) and wort2[j].isdigit():
+        nr2 += (wort2[j])
+        j += 1
+      return int(nr1) - int(nr2)
+    elif wort1 < wort2:
+      return -1
+    elif wort1 > wort2:
+      return 1
+  return 0
+
+
+def preparecontext(request):
+  params = json.loads(request.body)
+  suitable = SuitableFor.objects.get(pk=params['templateid'])
+  params['suitable'] = suitable
+  if params.get('onlyactive') is None:
+    params['onlyactive'] = True
+  if suitable.usedkeys is None:
+    params["usedkeys"] = []
+  else:
+    params["usedkeys"] = suitable.usedkeys
+  if suitable.sortby is None:
+    params['sortby'] = []
+  else:
+    params['sortby'] = suitable.sortby
+  return params
+
+
+def render(
+    data,
+    templatefiledescriptor,
+    outfilename="tmp_",
+    pdfdir="toolbox/mkpdf/"):
+  data["jetzt"] = datetime.now().strftime("%d.%m.%Y")
+  uid = uuid1()
+  outfilename += str(uid)
+  tpl = jinja2.Template(
+    templatefiledescriptor.read().decode("utf-8"),
+    block_start_string=settings.PDF_JINJASTRINGS["block_start"],
+    block_end_string=settings.PDF_JINJASTRINGS["block_end"],
+    variable_start_string=settings.PDF_JINJASTRINGS["variable_start"],
+    variable_end_string=settings.PDF_JINJASTRINGS["variable_end"],
+    comment_start_string=r"\JCMNT",
+    comment_end_string="}"
+  )
+  f = open(joinpath(settings.BASE_DIR, pdfdir, outfilename+".latex"), "w")
+  f.write(tpl.render(data))
+  f.close()
+  log = open(f"toolbox/mkpdf/tmp_{uid}_texlog.txt", "w")
+  subprocess.run(
+      ["latexmk", outfilename+".latex", "-interaction=batchmode"],
+      cwd=joinpath(settings.BASE_DIR, pdfdir),
+      stdout=log,
+      stdin=subprocess.DEVNULL,
+      check=False)
+  log.close()
+
+  try:
+    f = open(joinpath(settings.BASE_DIR, pdfdir, outfilename+".pdf"), "rb")
+    success = True
+    return success, f
+  except FileNotFoundError:
+    success = False
+    print(" versuche texlog.txt zurückzugeben")
+    f = open(joinpath(settings.BASE_DIR, pdfdir, f"tmp_{uid}.log"), "r", encoding='latin-1')
+    ret = f.read()
+  return success, ret
+
+
+def prep4latex(string):
+  for esc in settings.PDF_REPLACES:
+    string = string.replace(esc[0], esc[1])
+  return string
+
+
+def fetchdata(datenthema, pks, onlyactive=True, order=None, usedkeys=None, **kwargs):
+  if order is None:
+    order = []
+  print(datenthema)
+  dt = ContentType.objects.get(app_label="datenmanagement", model=datenthema.lower())
+  print(dt)
+  thema = dt.model_class()
+
+  display_names = dict()
+  for field in thema._meta.fields:
+    display_names[field.name] = field.verbose_name
+    display_names[field.name+"_id"] = field.verbose_name
+
+  if usedkeys is None or usedkeys == []:
+    usedkeys = [field.name for field in thema._meta.fields]
+  else:
+    usedkeys = [key[0] for key in usedkeys]
+
+  if len(pks) > 0:
+    if onlyactive:
+      records = thema.objects.filter(pk__in=pks, aktiv=True).order_by(*order)
+    else:
+      records = thema.objects.filter(pk__in=pks).order_by(*order)
+  else:
+    if onlyactive:
+      records = thema.objects.filter(aktiv=True).order_by(*order)
+    else:
+      records = thema.objects.all().order_by(*order)
+
+  escapedrecords = list()
+  for record in records:
+    escapedrecord = dict()
+    for key in usedkeys:
+      escapedrecord[key] = prep4latex(str(getattr(record, key)))
+    escapedrecords.append(escapedrecord)
+  return escapedrecords, display_names
+
+
+def chkforwmd(record):
+  if "Warnemünde" in record.beschreibung:
+    return True
+  elif "Wmd" in record.beschreibung:
+    return True
+  elif "Wmd" in record.bezeichnung:
+    return True
+  elif "Warnemünde" in record.bezeichnung:
+    return True
+  else:
+    return False
+
+
+def cleanqueryrecord(datum):
+  ret = dict()
+  ret['lage'] = prep4latex(str(datum.bezeichnung))
+  ret['beschreibung'] = prep4latex(str(datum.beschreibung))
+  ret['landschaftsdenkmal'] = True
+  if chkforwmd(datum):
+    ret['adresse'] = "(Wmd)"
+  return ret
+
+
+def baudenkmalefull(pks=None, onlyactive=True):
+
+  if pks is None:
+    pks = []
+  if onlyactive:
+    brds = Denkmalbereiche.objects.filter(aktiv=True).order_by('bezeichnung')
+    if len(pks) > 0:
+      bdms = Baudenkmale.objects.filter(pk__in=pks, aktiv=True).order_by('adresse')
+    else:
+      bdms = Baudenkmale.objects.filter(aktiv=True).order_by('adresse')
+  else:
+    brds = Denkmalbereiche.objects.all()('bezeichnung')
+    if len(pks) > 0:
+      bdms = Baudenkmale.objects.filter(pk__in=pks).order_by('adresse')
+    else:
+      bdms = Baudenkmale.objects.all().order_by('adresse')
+
+  data = [{
+    'name': "Baudenkmale",
+    'orte': [{
+      'name': "Rostock",
+      'byletter': dict()
+    }, {
+      'name': "Warnemünde",
+      'byletter': dict()
+    }]}, {
+    'name': "Denkmalbereiche",
+    'orte': [{
+      'name': "Rostock",
+      'byletter': dict()
+    }, {
+      'name': "Warnemünde",
+      'byletter': dict()
+    }]}
+  ]
+
+  for bdm in bdms:
+    rec = dict()
+
+    adr = str(bdm.adresse)
+    if bdm.lage is not None:
+      rec['position'] = prep4latex(bdm.lage)
+    else:
+      rec['position'] = prep4latex(adr[:len(adr)-5])
+    if adr[len(adr)-5:] == "(Wmd)":
+      rec['wmd'] = True
+    else:
+      rec['wmd'] = False
+    rec['beschreibung'] = prep4latex(str(bdm.beschreibung))
+    if bdm.landschaftsdenkmal:
+      rec['beschreibung'] += '*'
+
+    if rec['wmd']:
+      insert_or_append(data[0]['orte'][1]['byletter'], rec['position'][0].upper(), rec)
+    else:
+      insert_or_append(data[0]['orte'][0]['byletter'], rec['position'][0].upper(), rec)
+
+  for brd in brds:
+    rec = dict()
+    rec['position'] = prep4latex(brd.bezeichnung)
+    rec['beschreibung'] = prep4latex(brd.beschreibung)
+    rec['wmd'] = chkforwmd(brd)
+
+    if rec['wmd']:
+      insert_or_append(data[1]['orte'][1]['byletter'], rec['position'][0].upper(), rec)
+    else:
+      insert_or_append(data[1]['orte'][0]['byletter'], rec['position'][0].upper(), rec)
+
+  for kat in data:
+    for ort in kat['orte']:
+      for anfang in ort['byletter']:
+        ort['byletter'][anfang].sort(key=cmp_to_key(compare_adresses))
+
+#  print("orte Typ: ", type(orte))
+#  for ortindex in range(len(orte)):
+#    for eintragsklassenindex in range(len(orte[ortindex]['eintragsklassen'])):
+#      for key in orte[ortindex][eintragsklassenindex]['byletter'].keys():
+#        orte[ortindex][eintragsklassenindex]['byletter'][key].sort(key=cmp_to_key(compare_adresses))
+#        print("Typ:", type(orte[ortindex][eintragsklassenindex]['byletter'][key]))
+
+  return {'kategorien': data}
+
+
+def sortforbaudenkmale(data, brdauch=False):
+
+  baud_rost_byl = {}
+  baud_wamue_byl = {}
+  bere_rost_byl = {}
+  bere_wamue_byl = {}
+  for rec in data:
+    rec.pop('geometrie')
+    print(rec)
+
+  if brdauch:
+    brds = Denkmalbereiche.objects.all()
+    preppedbrds = [cleanqueryrecord(rec) for rec in brds]
+    data = chain(data, preppedbrds)
+
+  for item in data:
+    if item.get('lage') is None:
+      if item.get('adresse') is None:
+        raise KeyError(f"{item} ({type(item)} hat weder Adresse noch lage!")
+      position = item['adresse'][:len(item.adresse.adresse)-5]
+    else:
+      position = item['lage']
+    print(f"{item['uuid']}: {position}")
+    bschrbng = item['beschreibung']
+    key = position[0].upper()
+    val = {'adresse': position, 'beschreibung': bschrbng}
+    if item.get('adresse') is not None and item['adresse'][len(item['adresse'])-5:] == "(Wmd)":
+      if item['landschaftsdenkmal']:
+        insert_or_append(bere_wamue_byl, key, val)
+      else:
+        insert_or_append(baud_wamue_byl, key, val)
+    else:
+      if item['landschaftsdenkmal']:
+        insert_or_append(bere_rost_byl, key, val)
+      else:
+        insert_or_append(baud_rost_byl, key, val)
+
+  baud_rost = {"name": "Baudenkmale", "byletter": baud_rost_byl}
+  bere_rost = {"name": "Denkmalbereiche", "byletter": bere_rost_byl}
+  baud_wamue = {"name": "Baudenkmale", "byletter": baud_wamue_byl}
+  bere_wamue = {"name": "Denkmalbereiche", "byletter": bere_wamue_byl}
+  rostock = {"name": "Rostock", "eintragsklassen": [baud_rost, bere_rost]}
+  warnemuende = {"name": "Warnemünde", "eintragsklassen": [baud_wamue, bere_wamue]}
+  orte = [rostock, warnemuende]
+
+  return {"orte": orte}
+
+
+def insert_or_append(dic, key, vals):
+  if dic.get(key) is None:
+    dic[key] = [vals]
+  else:
+    # insort(dic[key], vals, key=cmp_to_key(compare_adresses))
+    dic[key].append(vals)
+    # dic[key].sort(key=cmp_to_key(compare_adresses))
diff --git a/toolbox/urls.py b/toolbox/urls.py
index ece29888..2ea7d82b 100644
--- a/toolbox/urls.py
+++ b/toolbox/urls.py
@@ -2,7 +2,7 @@
 from django.urls import path, re_path
 from rest_framework import routers
 
-from .views import AddressSearchView, AddSubsetView, OWSProxyView, ReverseSearchView
+from .views import AddressSearchView, AddSubsetView, OWSProxyView, ReverseSearchView, renderpdf
 
 router = routers.DefaultRouter()
 
@@ -34,5 +34,11 @@
     'reversesearch',
     view=login_required(ReverseSearchView.as_view()),
     name='reversesearch'
+  ),
+  # render PDF files from templates and data
+  path(
+    'renderpdf',
+    view=login_required(renderpdf),
+    name='renderpdf'
   )
 ]
diff --git a/toolbox/views.py b/toolbox/views.py
index 737eb058..0480f008 100644
--- a/toolbox/views.py
+++ b/toolbox/views.py
@@ -4,13 +4,15 @@
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import MultipleObjectsReturned
 from django.db.utils import IntegrityError
-from django.http import HttpResponse, HttpResponseServerError, JsonResponse
+from django.http import HttpResponse, HttpResponseNotAllowed, HttpResponseServerError, \
+  FileResponse, JsonResponse
 from django.views.decorators.csrf import csrf_exempt
 from django.views.generic import View
 from json import dumps, loads
 from re import sub
 
-from .models import Subsets
+from .models import Subsets, SuitableFor
+from .pdfs import baudenkmalefull, fetchdata, preparecontext, render
 
 
 class AddSubsetView(View):
@@ -237,3 +239,40 @@ def get(self, request, *args, **kwargs):
       return HttpResponse(response, content_type='application/json')
     except Exception:
       return HttpResponseServerError()
+
+
+def renderpdf(request):
+  if request.method != 'POST':
+    ret = HttpResponseNotAllowed(['POST'], open('toolbox/405.html'))
+    ret.reason_phrase = 'Need JSON for render info in POST body!'
+    return ret
+  else:
+    params = preparecontext(request)
+    print(params)
+    d, display_names = fetchdata(**params)
+    print('Templatename: ', SuitableFor.objects.get(pk=params['templateid']).template.name)
+    print('Datenthema.lower(): ', params['datenthema'].lower())
+    if (params['datenthema'].lower() == 'baudenkmale'
+        and params['suitable'].template.name == 'Custom-Baudenkmale'):
+      print('Spezialsortierung für Baudenkmale')
+      data = baudenkmalefull(params['pks'], onlyactive=True)
+    else:
+      data = dict()
+      data['datenthema'] = params['datenthema']
+      data['records'] = d
+      data['usedkeys'] = params['usedkeys']
+      data['display_names'] = display_names
+    rendersuccess, responsefile = render(
+            data,
+            params['suitable'].template.templatefile,
+            pdfdir='toolbox/mkpdf')
+    if rendersuccess:
+      ret = FileResponse(responsefile, status=200)
+      ret['Content-Disposition'] = f'attachment, filename={params["datenthema"]}'
+      ret['Content-Type'] = 'application/pdf'
+    else:
+      ret = FileResponse(responsefile, status=409)
+      ret.reason_phrase = 'keine PDF-Datei erzeugt, wahrscheinlich ist das Template defekt'
+      ret['Content-Disposition'] = f'attachment, filename={params["datenthema"]}.errorlog'
+      ret['Content-Type'] = 'text/plain'
+    return ret