diff --git a/src/main/asciidoc/architectureDocumentation/architectureDocumentation.adoc b/src/main/asciidoc/architectureDocumentation/architectureDocumentation.adoc
index 57df6a8..ccd4012 100644
--- a/src/main/asciidoc/architectureDocumentation/architectureDocumentation.adoc
+++ b/src/main/asciidoc/architectureDocumentation/architectureDocumentation.adoc
@@ -986,7 +986,7 @@
 |9|stationnumber|String(255)
 |=========================================================
 
-====== Addresses for district heationg connections
+====== Addresses for district heating connections
 [options="header"]
 |=========================================================
 |Number of column|Content|Format
diff --git a/src/main/asciidoc/img/ort-adresse.png b/src/main/asciidoc/img/ort-adresse.png
index 59c81ab..5383f2e 100644
--- a/src/main/asciidoc/img/ort-adresse.png
+++ b/src/main/asciidoc/img/ort-adresse.png
Binary files differ
diff --git a/src/main/asciidoc/img/ort-karte.png b/src/main/asciidoc/img/ort-karte.png
index badab4f..e005616 100644
--- a/src/main/asciidoc/img/ort-karte.png
+++ b/src/main/asciidoc/img/ort-karte.png
Binary files differ
diff --git a/src/main/asciidoc/userDocumentation/userDocumentation.adoc b/src/main/asciidoc/userDocumentation/userDocumentation.adoc
index af63e6d..7a12001 100644
--- a/src/main/asciidoc/userDocumentation/userDocumentation.adoc
+++ b/src/main/asciidoc/userDocumentation/userDocumentation.adoc
@@ -18,8 +18,8 @@
 <<<
 
 
-* Version: 0.2
-* Datum: 03.07.2020
+* Version: 0.5
+* Datum: 04.09.2020
 * Status: In Bearbeitung
 
 <<<
@@ -27,8 +27,8 @@
 :Author: Dr. Michel Alessandrini
 :Email: michel.alessandrini@pta.de
 
-:Date: 2020-07-03
-:Revision: 0.2
+:Date: 2020-09-04
+:Revision: 0.5
 
 :icons:
 
@@ -79,8 +79,6 @@
 definiert, deren Aufgaben (Berechtigungen) in den folgenden Unterabschnitten
 aufgelistet sind:
 
-TODO: Frage: Wer darf Verteilergruppen anlegen und bearbeiten?
-
 ==== Erfasser
 * <<uebersicht-aller-stoer,Darf alle Störungsmeldungen sehen>>
 * <<stoerungsmeldung-erstellen,Darf Störungsmeldungen anlegen>>
@@ -106,9 +104,8 @@
 * <<stoerung-ansicht-bearbeitung,Darf Störungsmeldungen im internen Bearbeitungsstatus "qualifiziert" bearbeiten>>
 * <<allg-funktionen-uebersicht-aller-sm-verdichten,Darf Störungsmeldungen verdichten>>
 * <<statuswechsel-veroffentlichung,Darf Störungsmeldungen veröffentlichen (Veröffentlichungsstatus ändern)>>
-* Darf Verteilgruppen anlegen
-* Darf Email-Vorlagen bearbeiten
-
+* <<uebersicht-verteilergruppen,Darf Verteilergruppen anlegen, bearbeiten und entfernen>>
+* <<mailvorlage-bearbeiten,Darf Email-Vorlagen bearbeiten>>
 
 ==== Gast
 * <<uebersicht-aller-stoer,Darf alle Störungsmeldungen sehen>>
@@ -116,11 +113,8 @@
 
 ==== Administrator
 * Darf alles
-* Darf zusätzlich Konfigurationen vornehmen (Details sind in technischer Dokumentation beschrieben)
-** TODO prüfen: Mailvorlagen für Benachrichtigungen (bei Ziel-Status "Genehmigt", "Storniert", "Zurückgewiesen")
-** TODO prüfen: Basis eMail-Verteilerlisten
-
-TODO: ergänzen
+* Darf zusätzlich Konfigurationen vornehmen
+(Details sind in technischer Dokumentation beschrieben)
 
 === Status
 
@@ -179,6 +173,7 @@
 ===== Öffentlich
 * Die Störungsmeldung ist für die Öffentlichkeit sichtbar.
 * Die Veröffentlichung erfolgt über ausgewählte Kanäle
+* Die Störungsmeldung kann nicht mehr verdichtet werden.
 
 ===== Zurückgezogen
 * Die Störungsmeldung ist nicht mehr für die Öffentlichkeit sichtbar.
@@ -252,7 +247,16 @@
 .Übersicht aller Störungsmeldungen in der Listenansicht
 image::Listenansicht.png[]
 
+Es werden alle Störungsmeldungen angezeigt - mit Ausnahme von Störungsmeldungen,
+die sich bereits vier Wochen oder länger im internen Bearbeitungsstatus
+"abgeschlossen" oder "storniert" befinden.
+
 Die Übersicht zeigt zu jeder Störungsmeldung folgende Informationen an.
+
+TIP: Die Sichtbarkeit einzelner Spalten konfiguriert der Administrator. D.h. falls
+einzelne Spalten in Ihrer Installation nicht sichtbar sein sollten, so hat der
+Administrator diese ausgeblendet.
+
 Die Bedeutung der Felder ist im Abschnitt <<stoerung-ansicht-bearbeitung>> beschrieben.
 
 .Felder in der Listenansicht
@@ -292,13 +296,12 @@
 .Stift-Symbol zum Bearbeiten einer Störungsmeldung
 image::stift-symbol.png[]
 
-Ferner können Störungsmeldungen - ebenfalls abhängig von der Benutzerrolle
-und dem internen Bearbeitungsstatus -
+Ferner können Störungsmeldungen, ebenfalls abhängig von der Benutzerrolle
+und dem internen Bearbeitungsstatus,
 auch <<statuswechsel-stornieren,storniert>> oder <<stoerungsmeldung-loeschen,gelöscht>> werden.
 
-Mit den vordefinierten Filtern "TODO...", "TODO..." und "TODO...",
-sowie über die Filter der Liste selbst, können beliebige individuelle
-Filterkombinationen erstellt werden. Details dazu sind im Abschnitt
+Vordefinierte Filter ermöglichen das schnelle Auffinden von Störungsmeldungen
+in der Übersicht. Details dazu sind im Abschnitt
 <<allg-funktionen-uebersicht-aller-sm-filter>> beschrieben.
 
 
@@ -306,9 +309,11 @@
 über die Funktion "Verdichten" zusammengeführt werden. Details dazu sind
 im Abschnitt <<allg-funktionen-uebersicht-aller-sm-verdichten>> beschrieben.
 
-
+[[kartenansicht]]
 ==== Karten-Ansicht
-Die Karte startet i.d.R. der Anzeige des Versorgungsgebiets.
+Die Karte startet i.d.R. mit der Anzeige des Versorgungsgebiets.
+
+TIP: Die Konfiguration erfolgt durch den Administrator.
 
 .Darstellung der Störungsmeldungen im entsprechenden Kartenausschnitt
 image::kartenansicht.png[]
@@ -350,19 +355,26 @@
 
 [[stoerungsmeldung-loeschen]]
 ==== Löschen einer Störungsmeldung
-TODO: Diesen Abschnitt nach Umsetzung validieren
-
-TIP: Das Löschen einer Störungsmeldung ist nur in den internen Bearbeitungsstatus
-"neu" und "geplant" möglich.
-
-TODO: Ggf. Bild anpassen
+Ist ein Benutzer mit der Benutzerrolle "Erfasser" angemeldet,
+so besteht die Möglichkeit über die Schaltfläche "Löschen"
+eine Störungsmeldung zu löschen.
 
 .Schaltfläche zum Löschen einer Störungsmeldung
-image::loeschen.png[]
+image::stoerung-loeschen.png[]
+
+Nach dem Klick auf das Löschen erscheint eine Rückfrage, ob die Störungsmeldung
+wirklich gelöscht werden soll. Nach einem Klick auf "Ja" ist die
+Störungsmeldung entfernt.
+
+.Nachfrage beim Löschen einer Störungsmeldung
+image::loeschen-nachfrage.png[]
 
 WARNING: Beim Löschen werden alle Informationen einer Störungsmeldung
 unwiederbringlich entfernt.
 
+TIP: Das Löschen einer Störungsmeldung ist nur in den internen Bearbeitungsstatus
+"neu", "angelegt" und "geplant" möglich.
+
 Befindet sich die Störungsmeldung in einem anderen internen Bearbeitungsstatus,
 so ist die Funktion <<statuswechsel-stornieren,Stornieren>> zu verwenden.
 
@@ -375,6 +387,7 @@
 . Störungsinformation
 . Störungsdetails
 . Störungsort
+. Veröffentlichung
 
 ==== Störungsinformation
 Die allgemeinen Informationen zu einer Störungsmeldung befinden sich im oberen Teil der Detailansicht.
@@ -393,6 +406,8 @@
 * Störung
 * geplante Maßnahme
 
+Der Administrator kann dieses Feld durch Konfiguration ausblenden.
+
 |Sparte                    |ja             |Auswahlfeld
 a|
 
@@ -424,7 +439,12 @@
 [options="header"]
 |=========================================================
 |Attribut                       |Pflichtfeld(*) |Inhaltsart     |Beschreibung
-|Zuständigkeit                  |nein            |Freitext       |Zuständiger Mitarbeiter, Bereich, etc.
+|Zuständigkeit                  |nein            |Freitext
+a|
+Zuständiger Mitarbeiter, Bereich, etc.
+
+Der Administrator kann dieses Feld durch Konfiguration ausblenden.
+
 |Spannungsebene                 |ja              |Auswahlfeld
 a|
 Nur bei Sparte = Strom:
@@ -445,15 +465,37 @@
 |Störungsende (wiederversorgt)  |nein            |Datum/Uhrzeit  |Behebungszeitpunkt der Störung
 |Voraussichtlicher Grund        |ja              |Auswahlfeld
 a|
+Folgende Einträge werden immer und unabhängig von der Sparte angezeigt:
+
  * Defekt technische Anlage
  * Leitung beschädigt
- * noch nicht bekannt
+ * Noch nicht bekannt
  * Überregionale Störung
- * Kabelfehler Mittelspannung (nur bei Strom)
- * Kabelfehler Niederspannung (nur bei Strom)
+ * Sonstiges
 
-|Beschreibung                   |nein            |Freitext       |Beschreibung der Störung
-|Interne Bemerkungen            |nein            |Freitext       |Zusätzliche Hinweise der Bearbeiter
+Zusätzlich bei Sparte = Strom:
+
+ * Kabelfehler Mittelspannung
+ * Kabelfehler Niederspannung
+
+Zusätzlich bei Sparte = Wasser:
+
+ * Wasserrohrbuch
+
+Bei Sparte = ohne Sparte sind alle v.g. Einträge sichtbar.
+
+|Beschreibung                   |nein            |Freitext
+a|
+Beschreibung der Störung
+
+Der Administrator kann dieses Feld durch Konfiguration ausblenden.
+
+|Interne Bemerkungen            |nein            |Freitext
+a|
+Zusätzliche Hinweise der Bearbeiter
+
+Der Administrator kann dieses Feld durch Konfiguration ausblenden.
+
 |=========================================================
 
 (*) Pflichtfeld um einen Statuswechsel durchführen zu können.
@@ -471,7 +513,8 @@
 .Schaltfläche zur Auswahl der Ortserfassung
 image::ortserfassung.png[]
 
-WARNING: Beim Wechsel der Erfassungsart gehen alle bisherigen Eingaben zum Störungsort ohne Hinweis zurückgesetzt.
+WARNING: Beim Wechsel der Erfassungsart werden alle bisherigen Eingaben zum
+Störungsort ohne Hinweis zurückgesetzt.
 
 
 ===== Adresse
@@ -487,9 +530,9 @@
 [options="header"]
 |=========================================================
 |Attribut                   |Pflichtfeld(*) |Inhaltsart     |Beschreibung
-|Postleitzahl               |ja             |Zahl           |Postleitzahl des Störungsortes
-|Ort (betroffene Orte)      |ja             |Auswahlfeld    |Auswahllisteneinträge abhängig von der ausgewählten Postleitzahl
+|Ort (betroffene Orte)      |ja             |Auswahlfeld    |Auswahllisteneinträge abhängig von ausgewählter Sparte
 |Ortsteil                   |ja             |Auswahlfeld    |Auswahllisteneinträge abhängig vom ausgewählten Ort
+|Postleitzahl               |ja             |Auswahlfeld    |Auswahllisteneinträge abhängig vom ausgewählten Ortsteil
 |Straße (betroffene Straße) |ja             |Auswahlfeld    |Auswahllisteneinträge abhängig vom ausgewählten Ortsteil
 |Hausnummer                 |ja             |Auswahlfeld    |Auswahllisteneinträge abhängig von der ausgewählten Straße
 |Radius in Meter            |ja             |Auswahlfeld
@@ -510,7 +553,7 @@
 (*) Pflichtfeld um einen Statuswechsel durchführen zu können.
 
 Während der Erfassung des Ortes erscheint nach Eingabe des zweiten Buchstabens eine Liste von Orten.
-Es dürfen ausschließlich - in der Liste vorhandene - Orte eingetragen werden.
+Es dürfen ausschließlich in der Liste vorhandene Orte eingetragen werden.
 
 TIP: Bei der Eingabe des Ortes werden nur gültige Orte und Postleitzahlen vorgeschlagen.
 D.h. bei vorheriger Auswahl der Sparte Strom sind nur Orte und Postleitzahlen für Stromanschlüsse sichtbar.
@@ -532,14 +575,25 @@
 Die Darstellung des Störungsortes erfolgt mit dem gleichen Marker, wie in allen anderen
 Kartendarstellung auch.
 
+Zusätzlich besteht die Möglichkeit zur Erfassung weiterer Informationen zur Positionierung:
+
+.Attribute einer Störungsmeldung (Teil: Störungsort über Karte)
+[options="header"]
+|=========================================================
+|Attribut                   |Pflichtfeld(*)   |Inhaltsart  |Beschreibung
+|Ort (betroffene Orte)      |nein             |Textfeld    |Bei Bedarf: Ortsangabe
+|Ortsteil                   |nein             |Textfeld    |Bei Bedarf: Ortsteil
+|Postleitzahl               |nein             |Textfeld    |Bei Bedarf: Postleitzahl
+|=========================================================
+
+TIP: Die drei Attribute zur Ergänzung der Standortinformationen werden technisch
+nicht gegen den ausgewählten Ort in der Karte geprüft.
 
 ===== Stationsattribute
 TIP: Die Stationsattribute stehen nur zur Verfügung, wenn Sparte = Strom und
 Spannungsebene = Mittelspannung ODER Sparte = Telekommunikation ausgewählt ist.
 
-Die Erfassung über die Stationsattribute kommt dann zum Einsatz, wenn
-es sich um Mittelspannungsstörungen handelt. Hierbei sind die relevanten
-Stationen zu erfassen.
+An dieser Stelle sind die relevanten Stationen zu erfassen.
 
 .Ansicht der Ortserfassung über Stationsattribute
 image::ort-station.png[]
@@ -550,7 +604,7 @@
 
 Nach Auswahl einer Station wird diese in der Karte dargestellt. Zusätzlich wird
 das Gebiet mit den zugeordneten Hausanschlüssen in Form eines Polygons umrahmt.
-Bei der Auswahl mehrerer Stationen wird die zugrundeliegenden Bereiche miteinander
+Bei der Auswahl mehrerer Stationen werden die zugrundeliegenden Bereiche miteinander
 vereint, sofern diese geographisch nebeneinander liegen.
 
 TIP: Das Gebiet wird nur umrandet, wenn der/den ausgewählten Station(en) entsprechende
@@ -559,41 +613,293 @@
 
 [[veroeffentlichung]]
 ==== Veröffentlichung
+Die Veröffentlichung steuert wer die Informationen zu einer Störungsmeldung
+erhalten soll.
 
-TODO
+Über den Veröffentlichungskanal wird die Schnittstelle ausgewählt, über die
+die Störungsinformationen veröffentlicht werden sollen. Es ist möglich
+keinen, einen oder mehrere Kanäle auszuwählen. In der folgenden Abbildung sind
+zwei Veröffentlichungskanäle angebunden, wobei grundsätzlich vier Schnittstellen
+zur Verfügung stehen:
 
-TODO: Folgenden Hinweis einarbeiten
-Man könnte den Hinweis unterbringen, dass eine Veröffentlichung über einen Kanal
-wie E-Mail nur dann Sinn macht, wenn auch mindestens eine Verteilergruppe ausgewählt
-ist, die einen Kontakt mit einer E Mailadresse beinhaltet, sodass mindestens eine
-E Mailadresse gibt, an die eine Benachrichtigung geschickt werden kann.
+. Mail
+. Störungsauskunft.de
+. SARIS
+. SAMO
+
+IMPORTANT: Die Sichtbarkeit der verschiedenen Kanäle wird durch den
+Administrator eingestellt.
+
+.Veröffentlichungskanäle und Verteilergruppen
+image::veroeffentlichung.png[]
+
+Nachdem der oder die Veröffentlichungskanäle aktiviert wurden, müssen nun eine
+oder mehrere Verteilergruppen ausgewählt werden. Das erfolgt über das
+Auswahlfeld in der Tabelle Verteilergruppen:
+
+.Auswahl der Verteilergruppen
+image::veroeffentlichung-auswahl.png[]
+
+IMPORTANT: Die Verteilergruppen können individuell angepasst werden, siehe
+<<uebersicht-verteilergruppen,Anpassung von Verteilergruppen>>.
+
+Nachdem die Verteilgruppe im Auswahlfeld selektiert ist, muss die folgende
+Schaltfläche zur Übernahme geklickt werden.
+
+.Zuordnung einer Verteilergruppen
+image::veroeffentlichung-Zuordnung.png[]
+
+Anschließend erscheint die Verteilergruppe in der darunterliegenden Tabelle.
+Dieser Vorgang wird so oft wiederholt, bis alle Verteilergruppen hinzugefügt
+wurden.
+
+TIP: Bei Auswahl des Veröffentlichungskanals "Mail" muss darauf geachtet werden,
+die ausgewählte(n) Verteilergruppe(n) mindestens einen Kontakt mit einer
+Mail-Adressen beinhaltet. Andernfalls könnten keine Benachrichtigungen versendet
+werden.
+
+Benachrichtigungen erfolgen ausschließlich bei Statuswechseln nach:
+
+* Aktualisiert (interner Bearbeitungsstatus)
+* Beendet (interner Bearbeitungsstatus)
+* Öffentlich (Veröffentlichungsstatus)
+
+Eine Verteilergruppe bezieht sich immer genau auf einen der zuvor genannten
+Statuswechsel.
+
+Um eine Verteilgruppe aus der Liste zu entfernen, muss lediglich das Löschen-Symbol
+geklickt werden.
+
+.Schaltfläche zum Entfernen einer Verteilergruppe aus der Liste
+image::loeschen.png[]
+
+Das kann zu jedem Zeitpunkt im Bearbeitungsprozess erfolgen.
+Die entfernte Verteilgruppe erhält keine Information darüber, dass sie entfernt
+wurde.
 
 [[uebersicht-verteilergruppen]]
 === Übersicht der Verteilergruppen
+In der Hauptmenüleiste ist das folgende Icon zur Bearbeitung der
+Verteilergruppen sichtbar, sofern der angemeldete Benutzer die erforderlichen
+Rechte dafür besitzt:
 
-TODO
+.Icon zum Aufruf der Funktion zur Bearbeitung der Verteilergruppen
+image::verteilergruppen-symbol.png[]
+
+Die Übersicht der Verteilergruppen unterteilt sich in drei Bereiche:
+
+. Übersicht der Verteilergruppen (links oben)
+. Anlegen und Editieren des Veröffentlichungstextes zur ausgewählten Verteilergruppe (rechts)
+. Zugeordnete Kontakte zur ausgewählten Verteilergruppe (links unten)
+
+
+.Übersicht der Verteilergruppen
+image::verteilergruppen-uebersicht.png[]
+
+
+[[bearbeiten-verteilergruppe]]
+==== Ansicht und Bearbeitung einer Verteilergruppe
+Zur Ansicht und Bearbeitung einer Verteilergruppe ist der entsprechende Eintrag
+in der Tabelle Verteilergruppen durch einfaches Klicken auszuwählen. Anschließend
+ist die Zeile farblich markiert und die zugehörigen Ansichten stellen die Inhalte
+der Verteilergruppe dar, siehe vorherige Abbildung.
+
+Zu einer Verteilergruppe gehören folgende Attribute:
+
+.Attribute einer Verteilergruppe
+[options="header"]
+|=========================================================
+|Attribut  |Pflichtfeld(*) |Inhaltsart     |Beschreibung
+|Titel     |ja             |Text           |Bezeichnung der Verteilergruppe
+|Vorlage   |ja             |Auswahlfeld
+a|
+Auswahl der Mailvorlage, die beim entsprechenden Statuswechsel verwendet wird:
+
+* Veröffentlichen
+* Aktualisieren
+* Beenden
+
+|Betreff   |ja             |Text           |Betreff der Mail-Nachricht
+|Text      |nein           |Text           |Inhalt der Mail-Nachricht
+|Kontakte  |nein           |Kontakt        |Zugeordnete Kontakte (aus Kontaktstammdaten-Modul)
+|=========================================================
+
+[[mailvorlage-bearbeiten]]
+===== Anlegen und Editieren des Veröffentlichungstextes
+Die Bearbeitung des Veröffentlichungstextes zu einer Verteilergruppe erfolgt in folgendem
+Bereich.
+
+.Bearbeitung des Veröffentlichungstextes einer Verteilergruppe
+image::verteilergruppe-bearbeiten.png[]
+
+In den Feldern Betreff und Text können sogenannte Platzhalter verwendet
+werden. Diese werden beim Veröffentlichungsprozess durch die echten Inhalte der
+Störungsmeldung ersetzt. Zwei Beispiele:
+
+. Beispiel
+** Platzhalter im Text: $Ort$
+** Wird bei der Veröffentlichung durch den Wert "Ort" der entsprechenden Störungsmeldung
+   ersetzt, z.B. Darmstadt
+. Beispiel
+** Platzhalter: $Druckstufe$
+** Wird bei der Veröffentlichung durch den Wert "Druckstufe" der entsprechenden
+   Störungsmeldung ersetzt, z.B. Hochdruck. (Das funktioniert allerdings nur,
+   wenn bei der Störungsmeldung die Sparte "Gas" ausgewählt ist.)
+
+Folgende Platzhalter sind definiert:
+
+.Platzhalter für Feld "Text" bei Verteilergruppen
+[options="header"]
+|=========================================================
+|Platzhalter                   |Hinweis
+|$Beschreibung$                |
+|$Druckstufe$                  |Nur bei Sparte = Gas (*)
+|$Interne_Bemerkungen$         |
+|$Ort$                         |
+|$Postleitzahl$                |
+|$Spannungsebene$              |Nur bei Sparte = Strom (*)
+|$Station_Bezeichnung$         |Nur bei Sparte = Strom UND Spannungsebene = Mittelspannung (*)
+|$Status_intern$               |
+|$Störungsende_geplant$        |
+|$Straße$                      |
+|$Voraussichtlicher_Grund$     |
+|$Direkter_Link_zur_Störung$   |URL zum direkten Aufruf der Störungsmeldung in diesem Modul
+|$Hausnummer$                  |
+|$Klassifikation$              |
+|$Ortsteil$                    |
+|$Radius$                      |Nur bei Erfassung des Störungsortes über "Adresse" (*)
+|$Sparte$                      |
+|$Status_extern$               |
+|$Störungsbeginn_gemeldet$     |
+|$Störungsende_wiederversorgt$ |
+|$Veröffentlichungsstatus$     |
+|$Zuständigkeit$               |
+|=========================================================
+
+(*) Sollten die Voraussetzungen nicht erfüllt sein, so findet keine Textersetzung
+statt und der Platzhalter bleibt leer
+
+Über die Schaltfläche "Speichern" werden die Änderungen übernommen.
+
+===== Kontakte
+In der Tabelle "Kontakte zur Verteilergruppe" sind alle Kontakte aufgelistet,
+die zur ausgewählten Verteilergruppe zugeordnet sind.
+
+.Zuordnung von Kontakten zu einer Verteilergruppe
+image::verteilergruppe-kontakte.png[]
+
+Zum Hinzufügen weiterer Kontakte muss der Name in das Eingabefeld eingegeben
+werden. Nach der Eingabe von mindestens zwei Zeichen erscheint automatisch
+eine Liste mit Vorschlägen. Hieraus kann der entsprechende Eintrag durch einfachen
+Klick ausgewählt werden. Anschließend ist die Schaltfläche "Kontakt zuordnen"
+für die Übernahme des Kontakts in die Liste zu betätigen. Eine extra Speichern-Funktion
+existiert nicht.
+
+.Auswahl von Kontakten zu einer Verteilergruppe
+image::verteilergruppe-kontakte-auswahl.png[]
+
+WARNING: Sollte der gesuchte Kontakt nicht vorhanden sein, so muss dieser über das
+Modul Kontaktstammdaten erfasst werden. Ist dies erfolgt, so steht der Kontakt hier
+zur Verfügung.
+
+Das Entfernen eines Kontakts ist über das Löschen-Symbol in der entsprechenden Zeile
+möglich.
+
+.Entfernen eines Kontakts aus einer Verteilergruppe
+image::loeschen.png[]
+
+====== Einschränkung der Benachrichtigung auf Postleitzahlen-Ebene
+
+Ein Kontakt, der einer Verteilergruppe zugeordnet ist, erhält standardmäßig alle
+Benachrichtigungen, die auf dem ensprechenden Statuswechsel basieren.
+Damit aber nicht jeder Kontakt alle Mitteilungen erhalten muss, besteht die Möglichkeit
+den Versand von Nachrichten auf bestimmte Postleitzahlen zu beschränken.
+
+In der folgenden Abbildung sind dem ausgewählten Kontakt zwei Postleitzahlen
+zugeordnet:
+
+.Zuordnung von Postleitzahlen zu Kontakten einer Verteilergruppe
+image::verteilergruppe-kontakte-plz.png[]
+
+D.h. der Kontakt erhält nur Benachrichtigungen der zugrundeliegenden Verteilergruppe,
+wenn eine der zugeordneten Postleitzahlen in einer der folgenden Felder der Störungsmeldung
+enthalten ist:
+
+* Störungsort - Adresse - Postleitzahl
+* Störungsort - Karte - Postleitzahl
+* Störungsort - Stationsattribute - Station - zugeordneter Anschluss - Postleitzahl
+
+Das Hinzufügen einer Postleitzahl erfolgt über die Erfassung im
+entsprechenden Textfeld mit anschließender Übernahmne durch das "+"-Symbol.
+Das Entfernen erfolgt über die Betätigung des Löschen-Symbols des entsprechenden
+PLZ-Eintrags in der Tabelle.
+
+.Hinzufügen einer Postleitzahl
+image::plus-symbol.png[]
+
+.Entfernen einer Postleitzahl
+image::loeschen.png[]
+
+
+====== Export von Kontakten
+Das System erlaubt den Export von Kontakten einer Verteilergruppe in eine
+Textdatei. Dazu muss die folgende Schaltfläche geklickt werden:
+
+.Schaltfläche zum Export von Kontakten einer Verteilergruppe
+image::export.png[]
+
+Anschließend speichert der Browser die erzeugte Datei.
+
+TIP: Das Verhalten beim Speichern sowie der Speicherort sind von den Einstellungen
+des Browsers abhängig.
+
+Die Datei ist entsprechend der Verteilergruppe benannt:
+
+* "<Verteilergruppenname>.txt"
+
+Der Dateiinhalt sieht folgendermaßen aus:
+
+[source,csv]
+----
+  name;email;mobilenumber
+  Freudenberg, Pauline;PaulineF@gmx.net;01526677884
+  Buckley, Cornelius;sender@test.tester;
+----
+
 
 [[anlegen-verteilergruppe]]
 ==== Anlegen einer Verteilergruppe
+Zur Anlage einer neuen Verteilergruppe ist die Schaltfläche "Neue Verteilergruppe anlegen"
+zu betätigen.
 
-TODO
+.Schaltfläche zur Anlage einer neuen Verteilergruppe
+image::verteilergruppe-anlegen.png[]
+
+Anschließend erscheint eine leere Eingabemaske für die entsprechenden Felder:
+
+.Erfassung Informationen zu einer neuen Verteilergruppe
+image::verteilergruppe-anlegen-2.png[]
+
+Es müssen zumindest die Pflichtfelder gefüllt werden, damit die neue Verteilergruppe
+gespeichert werden kann.
+
+Die weitere Erfassung erfolgt analog zur
+<<bearbeiten-verteilergruppe,Bearbeitung von Verteilergruppen>>.
 
 
 [[löschen-verteilergruppe]]
 ==== Löschen einer Verteilergruppe
+Das Entfernen einer Verteilergruppe ist über das Löschen-Symbol in der
+entsprechenden Zeile der Tabelle mit den Verteilergruppen möglich.
 
-TODO
+.Löschen einer Verteilergruppe
+image::loeschen.png[]
 
-TODO: Hinweis von Frau Salbeck einarbeiten
-Es können einzelne Verteiler aus dem Veröffentlichungsprozess herausgenommen werden,
-ohne dass diese eine Nachricht darüber erhalten.
+Nach dem Klick auf das Löschen-Symbol erscheint eine Rückfrage, ob die Verteilergruppe wirklich gelöscht
+werden soll. Nach einem Klick auf "Ja" ist die Verteilergruppe entfernt.
 
-
-[[bearbeitung-verteilergruppen]]
-=== Ansicht und Bearbeiten einer Verteilergruppe
-
-TODO
-
+.Nachfrage beim Löschen einer Verteilergruppe
+image::loeschen-nachfrage.png[]
 
 <<<
 
@@ -604,9 +910,34 @@
 === Zur: Übersicht der Störungsmeldungen
 
 [[allg-funktionen-uebersicht-aller-sm-filter]]
-==== Vordefinierte Filter (Kennzahlen)
+==== Vordefinierte Filter
+Die Listen-Ansicht stellt zwei vordefinierte Filter zur Verfügung:
 
-TODO
+===== Filter: qualifiziert/veröffentlicht
+Mit Aktivierung des folgenden Schalters wird dieser Filter aktiviert.
+
+.Schalter zur Aktivierung des Filters qualifiziert/veröffentlicht
+image::filter-1.png[]
+
+Anschließend erscheinen in der Haupttabelle ausschließlich
+Störungsmeldungen, die mindestens eine der folgenden Bedingungen erfüllt:
+
+* Interner Bearbeitungsstatus = qualifiziert
+* Veröffentlichungsstatus = öffentlich
+
+===== Filter: qualifiziert/veröffentlicht
+Mit Aktivierung des folgenden Schalters wird dieser Filter aktiviert.
+
+.Schalter zur Aktivierung des Filters angelegt/geplant/aktualisiert
+image::filter-2.png[]
+
+Anschließend erscheinen in der Haupttabelle ausschließlich
+Störungsmeldungen, die mindestens eine der folgenden Bedingungen erfüllt:
+
+* Interner Bearbeitungsstatus = angelegt
+* Interner Bearbeitungsstatus = geplant
+* Interner Bearbeitungsstatus = aktualisiert
+
 
 [[allg-funktionen-uebersicht-aller-sm-verdichten]]
 ==== Verdichten von Störungsmeldungen
@@ -615,6 +946,9 @@
 
 TIP: Es können nur Störungsmeldungen der gleichen Sparte verdichtet werden.
 
+TIP: Störungsmeldungen mit dem Veröffentlichungsstatus "öffentlich" können nicht
+mehr verdichtet werden.
+
 Dazu ist in der Übersicht der Störungsmeldungen die Schaltfläche "Verdichtung"
 zu betätigen.
 
@@ -653,13 +987,14 @@
 * Spannungsebene bzw. Druckstufe: Wenn bei allen verdichten Meldungen gleich, sonst leer
 * Störungsbeginn (gemeldet): Das frühste Datum der verdichteten Meldungen
 * Störungsende (geplant): Das späteste Datum der verdichteten Meldungen
+* Stationen: Alle Stationen aus den verdichteten Meldungen, sofern vorhanden
 
 Zudem wird der interne Bearbeitungsstatus auf "neu" gesetzt.
 
 Alle Anpassungen und Aktualisierungen bzgl. dieser Störung sind fortan nur
 noch an dieser neuen Störungsmeldung vorzunehmen.
 
-INFO: Die verdichteten Meldungen werden nach Aktualisierung der übergeordneten
+TIP: Die verdichteten Meldungen werden nach Aktualisierung der übergeordneten
 Störungsmeldung nicht synchronisiert. Die einzige Ausnahme ist, wenn der
 interne Bearbeitungsstatus auf "beendet" wird. Dann werden auch die untergeordneten
 Störungsmeldungen auf "beendet" gesetzt.
@@ -705,11 +1040,26 @@
 .Meldung bei geänderten Daten nach Klick auf Abbrechen
 image::meldung-nach-abbrechen.png[]
 
-Im Bearbeitungsmodus steht zusätzlich die Schaltfläche Speichern zur Verfügung.
+Im Bearbeitungsmodus steht zusätzlich die Schaltfläche Speichern zur Verfügung,
+sofern der Status nicht "qualifiziert", "storniert" oder "beendet" ist.
 
 .Schaltfläche Speichern
 image::speichern.png[]
 
+Befindet sich die Störungsmeldung im Status "qualifiziert", dann ist die
+Schaltfläche "Aktualisieren" sichtbar, die gleichzeitig einen entsprechenden
+Statuswechsel durchführt.
+
+.Schaltfläche zum Aktualisieren einer Störungsmeldung (im Status "qualifiziert")
+image::aktualisieren.png[]
+
+Um die Detailansicht einer Störungsmeldung zu verlassen, muss die folgende
+Schaltfläche betätigt werden:
+
+.Schaltfläche zum Schließen der Detail-Ansicht einer Störungsmeldung
+image::schliessen.png[]
+
+
 Des Weiteren existieren zusätzlich Schaltflächen, um den internen
 Bearbeitungsstatus zu ändern. Details dazu befinden sich im
 Abschnitt <<statuswechsel>>.
@@ -733,12 +1083,10 @@
 Das Stornieren eines Störungsmeldung erfolgt ebenfalls in der Detailansicht
 über die Schaltfläche "Stornieren".
 
-TODO: Bild einfügen
-
 .Schaltfläche zum Stornieren einer Störungsmeldung
-image::stornieren.png[]
+image::stoerung-stornieren.png[]
 
-Durch das Stornieren erhält die Störungsmeldung den internen Bearbeitungstatus
+Durch das Stornieren erhält die Störungsmeldung den internen Bearbeitungsstatus
 "storniert". Gleichzeitig wird der Veröffentlichungsstatus auf "zurückgezogen"
 gesetzt.
 
@@ -751,8 +1099,27 @@
 
 [[statuswechsel-veroffentlichung]]
 ===== Statuswechsel des Veröffentlichungsstatus
+Der Statuswechsel des Veröffentlichungsstatus erfolgt durch den Veröffentlicher.
+Befindet sich die zugrundeliegende Störungsmeldung im Status "qualifiziert",
+so kann die Veröffentlichung über die folgende Schaltfläche vollzogen werden.
 
-TODO
+.Schaltfläche zum Veröffentlichen einer Störungsmeldung
+image::veroeffentlichen-2.png[]
+
+Wenn kein Veröffentlichungskanal ausgewählt ist, dann ist die Schaltfläche
+nicht aktiv. In diesem Fall muss zunächst eine Veröffentlichungskanal aktiviert
+werden.
+
+.Inaktive Schaltfläche zum Veröffentlichen einer Störungsmeldung
+image::veroeffentlichen.png[]
+
+Für das Beenden der Veröffentlichung gibt es drei Möglichkeiten:
+
+. <<veroeffentlichung,Deaktivierung der Veröffentlichungskanäle>>
+. <<statuswechsel-allgemein,Störungsmeldung beenden>>
+. <<statuswechsel-stornieren,Störungsmeldung stornieren>>
+
+
 
 [[versionierung]]
 ==== Versionierung
@@ -779,31 +1146,150 @@
 
 == Schnittstellen
 
-=== Import von Störungsmeldungen
+=== Internet-Applikation
+Die Bereitstellung der Informationen zu einer Störungsmeldung für die
+Öffentlichkeit erfolgt in der separaten Internet-Applikation. D.h. sobald
+eine Störungsmeldung den Veröffentlichungsstatus "Öffentlich" besitzt,
+ist diese Meldung in der Internet-Applikation sichtbar.
 
-TODO
+Die Internet-Applikation besteht aus drei Komponenten, die i.d.R. in bestehende
+Webseiten der Netzbetreiber integriert sind:
+
+. Karte
+. Liste
+. PLZ-Suche
+
+==== Karte
+Die Kartendarstellung entspricht der <<kartenansicht>> der
+Übersichtsseite. In dieser Ansicht sind allerdings nur Störungsmeldungen
+mit dem Veröffentlichungsstatus "Öffentlich" sichtbar.
+
+.Internet-Applikation Karte
+image::internet-karte.png[]
+
+TIP: Die initiale Darstellung, ob alle veröffentlichten oder
+keine Störungsmeldung angezeigt wird, konfiguriert der Administrator.
+
+==== Liste
+In der Listenansicht sind ausschließlich Störungsmeldungen
+mit dem Veröffentlichungsstatus "Öffentlich" dargestellt. Die Meldungen enthalten
+lediglich solche Informationen, die für die Öffentlichkeit relevant sind.
+
+.Internet-Applikation Liste
+image::internet-liste.png[]
+
+Die Listenansicht enthält folgende Attribute.
+
+.Felder in der Internet-Applikation Liste
+[options="header"]
+|=========================================================
+|Sparte
+|Beginn der Maßnahme
+|Voraussichtliches Ende
+|Voraussichtlicher Grund
+|Beschreibung
+|Postleitzahl
+|Ort
+|Ortsteil
+|Straße
+|Meldungsart
+|=========================================================
+
+Die Bedeutung der Felder ist im Abschnitt <<stoerung-ansicht-bearbeitung>> beschrieben.
+
+TIP: Die initiale Darstellung, ob alle veröffentlichten oder
+keine Störungsmeldung angezeigt wird, konfiguriert der Administrator.
+
+==== PLZ-Suche
+Über die PLZ-Suche können die beiden Ansichten - Karte und Liste - gefiltert werden.
+Dazu muss lediglich die Postleitzahl in das Eingabefeld eingetragen und
+anschließend mit Enter bestätigt werden.
+
+.Internet-Applikation PLZ-Suche
+image::internet-suche.png[]
+
+Anschließend werden autonatisch die beiden Komponenten auf diese PLZ gefiltert.
+
+.Internet-Applikation PLZ-Suche (Beispiel)
+image::internet-suche-beispiel.png[]
+
+
 
 === Export von Störungsmeldungen
+Die Veröffentlichung von Störungsmeldung erfolgt über verschiedene Kanäle,
+die - technisch - auch als Export-Schnittstellen bezeichnet werden.
+
+Die Zeitpunkte, wann die Informationen über die definierten Kanäle veröffentlicht
+werden, ist bei allen Schnittstellen gleich und lassen sich in drei Phasen
+einteilen:
+
+. Initiale Veröffentlichung
+. Aktualisierung
+. Veröffentlichung beenden
+
+Details dazu sind in den folgenden Abschnitten erläutert.
+
+==== Initiale Veröffentlichung
+Die erstmalige Veröffentlichung einer Störungsmeldung erfolgt, wenn der Benutzer
+durch Klick auf die Schaltfläche "Veröffentlichen" den Veröffentlichungsstatus
+auf "öffentlich" setzt. Hierbei werden die, dem Kanal zugeordneten Inhalte,
+übertragen.
+
+==== Aktualisierung
+Weitere Veröffentlichungsmeldungen folgen jeweils, wenn sich der interne Bearbeitungsstatus
+wieder auf "qualifiziert" ändert. Das kommt vor, wenn eine Störungsmeldung nach
+der letzten Veröffentlichungsmeldung aktualisiert wurde.
+
+==== Veröffentlichung beenden
+Die letzte Veröffentlichungsmeldung, die das Beenden der Veröffentlichung mitteilt,
+erfolgt dann, wenn der Benutzer den Veröffentlichungsstatus auf "zurückgezogen"
+ändert. Das kann durch den Benutzer manuell erfolgen oder wenn eine Störungsmeldung
+in den internen Bearbeitungsstatus "storniert" oder "beendet" wechselt.
+
+==== Ergänzende Hinweise
+Weitere Informationen zu den einzelnen Schnittstellen sind im Folgenden aufgelistet:
 
 [[Mail]]
-==== Mail
+===== Mail
+Die Absender-Adresse der Mails wird durch den Administrator definiert.
 
-TODO
 
 [[stoerungsauskunft]]
-==== Störungsauskunft.de
+===== Störungsauskunft.de
+Die aktuell veröffentlichten Störungsmeldungen sind im Portal von
+Störungsauskunft.de ersichtlich:
 
-TODO
+* https://störungsauskunft.de/
 
 
+[[SARIS]]
+===== SARIS
+TODO: Gibt es hier relevante Infos?
+
+
+[[SAMO]]
+===== SAMO
+TODO: Gibt es hier relevante Infos?
+
 <<<
 
 == Benachrichtigungen und Erinnerungen
 
-[[email-benachrichtigung-statuswechsel]]
-=== eMail-Benachrichtigung bei Statuswechsel
+[[erinnerung]]
+=== Erinnerungen
+Über die Erinnerungsfunktion wird der Benutzer informiert, dass mindestens
+eine nicht abgeschlossene Störungsmeldung das Datum für "Störungsende (geplant)"
+erreicht hat. In diesem Fall wird das Glockensymbol in der Hauptmenüleiste rot
+angezeigt.
 
-TODO
+.Erinnerung(en) vorhanden
+image::glocke-rot.png[]
+
+In allen anderen Fällen bleibt das Glockensymbol schwarz.
+
+.Keine Erinnerung vorhanden
+image::glocke-schwarz.png[]
+
 
 [[meldungen-hinweise]]
 === Hinweise und Meldungen nach Benutzeraktionen
@@ -851,7 +1337,7 @@
 Nach erfolgreicher Anmeldung am openKONSEQUENZ-Portal und mit entsprechender
 Berechtigung für das Modul "Störungsinformationstool" ist die Kachel für das Modul
 sichtbar. Mit einem Klick auf die Kachel startet das Modul "Störungsinformationstool"
-in einem neuen Fenster bzw. in einem neuen Tab des selben Browserfensters (je nach
+in einem neuen Fenster bzw. in einem neuen Tab desselben Browserfensters (je nach
 Browsereinstellung).
 
 .Kachel zum Starten des Moduls "Störungsinformationstool"
diff --git a/src/main/asciidoc/userDocumentation/userDocumentation.adoc.html b/src/main/asciidoc/userDocumentation/userDocumentation.adoc.html
index 33d40d2..905443f 100644
--- a/src/main/asciidoc/userDocumentation/userDocumentation.adoc.html
+++ b/src/main/asciidoc/userDocumentation/userDocumentation.adoc.html
@@ -463,10 +463,10 @@
 <div class="ulist">
 <ul>
 <li>
-<p>Version: 0.2</p>
+<p>Version: 0.5</p>
 </li>
 <li>
-<p>Datum: 03.07.2020</p>
+<p>Datum: 04.09.2020</p>
 </li>
 <li>
 <p>Status: In Bearbeitung</p>
@@ -493,7 +493,6 @@
 <li><a href="#uebersicht-aller-stoer">3.1. Übersicht der Störungsmeldungen</a></li>
 <li><a href="#stoerung-ansicht-bearbeitung">3.2. Ansicht und Bearbeitung einer Störungsmeldung</a></li>
 <li><a href="#uebersicht-verteilergruppen">3.3. Übersicht der Verteilergruppen</a></li>
-<li><a href="#bearbeitung-verteilergruppen">3.4. Ansicht und Bearbeiten einer Verteilergruppe</a></li>
 </ul>
 </li>
 <li><a href="#_weitere_funktionen">4. Weitere Funktionen</a>
@@ -504,13 +503,13 @@
 </li>
 <li><a href="#_schnittstellen">5. Schnittstellen</a>
 <ul class="sectlevel2">
-<li><a href="#_import_von_störungsmeldungen">5.1. Import von Störungsmeldungen</a></li>
+<li><a href="#_internet_applikation">5.1. Internet-Applikation</a></li>
 <li><a href="#_export_von_störungsmeldungen">5.2. Export von Störungsmeldungen</a></li>
 </ul>
 </li>
 <li><a href="#_benachrichtigungen_und_erinnerungen">6. Benachrichtigungen und Erinnerungen</a>
 <ul class="sectlevel2">
-<li><a href="#email-benachrichtigung-statuswechsel">6.1. eMail-Benachrichtigung bei Statuswechsel</a></li>
+<li><a href="#erinnerung">6.1. Erinnerungen</a></li>
 <li><a href="#meldungen-hinweise">6.2. Hinweise und Meldungen nach Benutzeraktionen</a></li>
 </ul>
 </li>
@@ -553,9 +552,6 @@
 definiert, deren Aufgaben (Berechtigungen) in den folgenden Unterabschnitten
 aufgelistet sind:</p>
 </div>
-<div class="paragraph">
-<p>TODO: Frage: Wer darf Verteilergruppen anlegen und bearbeiten?</p>
-</div>
 <div class="sect3">
 <h4 id="_erfasser"><a class="anchor" href="#_erfasser"></a>2.1.1. Erfasser</h4>
 <div class="ulist">
@@ -635,10 +631,10 @@
 <p><a href="#statuswechsel-veroffentlichung">Darf Störungsmeldungen veröffentlichen (Veröffentlichungsstatus ändern)</a></p>
 </li>
 <li>
-<p>Darf Verteilgruppen anlegen</p>
+<p><a href="#uebersicht-verteilergruppen">Darf Verteilergruppen anlegen, bearbeiten und entfernen</a></p>
 </li>
 <li>
-<p>Darf Email-Vorlagen bearbeiten</p>
+<p><a href="#mailvorlage-bearbeiten">Darf Email-Vorlagen bearbeiten</a></p>
 </li>
 </ul>
 </div>
@@ -661,23 +657,11 @@
 <p>Darf alles</p>
 </li>
 <li>
-<p>Darf zusätzlich Konfigurationen vornehmen (Details sind in technischer Dokumentation beschrieben)</p>
-<div class="ulist">
-<ul>
-<li>
-<p>TODO prüfen: Mailvorlagen für Benachrichtigungen (bei Ziel-Status "Genehmigt", "Storniert", "Zurückgewiesen")</p>
-</li>
-<li>
-<p>TODO prüfen: Basis eMail-Verteilerlisten</p>
+<p>Darf zusätzlich Konfigurationen vornehmen
+(Details sind in technischer Dokumentation beschrieben)</p>
 </li>
 </ul>
 </div>
-</li>
-</ul>
-</div>
-<div class="paragraph">
-<p>TODO: ergänzen</p>
-</div>
 </div>
 </div>
 <div class="sect2">
@@ -835,6 +819,9 @@
 <li>
 <p>Die Veröffentlichung erfolgt über ausgewählte Kanäle</p>
 </li>
+<li>
+<p>Die Störungsmeldung kann nicht mehr verdichtet werden.</p>
+</li>
 </ul>
 </div>
 </div>
@@ -995,8 +982,29 @@
 <div class="title">Figure 3. Übersicht aller Störungsmeldungen in der Listenansicht</div>
 </div>
 <div class="paragraph">
-<p>Die Übersicht zeigt zu jeder Störungsmeldung folgende Informationen an.
-Die Bedeutung der Felder ist im Abschnitt <a href="#stoerung-ansicht-bearbeitung">Ansicht und Bearbeitung einer Störungsmeldung</a> beschrieben.</p>
+<p>Es werden alle Störungsmeldungen angezeigt - mit Ausnahme von Störungsmeldungen,
+die sich bereits vier Wochen oder länger im internen Bearbeitungsstatus
+"abgeschlossen" oder "storniert" befinden.</p>
+</div>
+<div class="paragraph">
+<p>Die Übersicht zeigt zu jeder Störungsmeldung folgende Informationen an.</p>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Die Sichtbarkeit einzelner Spalten konfiguriert der Administrator. D.h. falls
+einzelne Spalten in Ihrer Installation nicht sichtbar sein sollten, so hat der
+Administrator diese ausgeblendet.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>Die Bedeutung der Felder ist im Abschnitt <a href="#stoerung-ansicht-bearbeitung">Ansicht und Bearbeitung einer Störungsmeldung</a> beschrieben.</p>
 </div>
 <table class="tableblock frame-all grid-all stretch">
 <caption class="title">Table 1. Felder in der Listenansicht</caption>
@@ -1092,15 +1100,14 @@
 <div class="title">Figure 5. Stift-Symbol zum Bearbeiten einer Störungsmeldung</div>
 </div>
 <div class="paragraph">
-<p>Ferner können Störungsmeldungen - ebenfalls abhängig von der Benutzerrolle
-und dem internen Bearbeitungsstatus -
+<p>Ferner können Störungsmeldungen, ebenfalls abhängig von der Benutzerrolle
+und dem internen Bearbeitungsstatus,
 auch <a href="#statuswechsel-stornieren">storniert</a> oder <a href="#stoerungsmeldung-loeschen">gelöscht</a> werden.</p>
 </div>
 <div class="paragraph">
-<p>Mit den vordefinierten Filtern "TODO&#8230;&#8203;", "TODO&#8230;&#8203;" und "TODO&#8230;&#8203;",
-sowie über die Filter der Liste selbst, können beliebige individuelle
-Filterkombinationen erstellt werden. Details dazu sind im Abschnitt
-<a href="#allg-funktionen-uebersicht-aller-sm-filter">Vordefinierte Filter (Kennzahlen)</a> beschrieben.</p>
+<p>Vordefinierte Filter ermöglichen das schnelle Auffinden von Störungsmeldungen
+in der Übersicht. Details dazu sind im Abschnitt
+<a href="#allg-funktionen-uebersicht-aller-sm-filter">Vordefinierte Filter</a> beschrieben.</p>
 </div>
 <div class="paragraph">
 <p>Sollten mehrere Störungsmeldungen zu einer Störung gehören, so können diese
@@ -1109,9 +1116,21 @@
 </div>
 </div>
 <div class="sect3">
-<h4 id="_karten_ansicht"><a class="anchor" href="#_karten_ansicht"></a>3.1.2. Karten-Ansicht</h4>
+<h4 id="kartenansicht"><a class="anchor" href="#kartenansicht"></a>3.1.2. Karten-Ansicht</h4>
 <div class="paragraph">
-<p>Die Karte startet i.d.R. der Anzeige des Versorgungsgebiets.</p>
+<p>Die Karte startet i.d.R. mit der Anzeige des Versorgungsgebiets.</p>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Die Konfiguration erfolgt durch den Administrator.
+</td>
+</tr>
+</table>
 </div>
 <div class="imageblock">
 <div class="content">
@@ -1181,30 +1200,27 @@
 <div class="sect3">
 <h4 id="stoerungsmeldung-loeschen"><a class="anchor" href="#stoerungsmeldung-loeschen"></a>3.1.4. Löschen einer Störungsmeldung</h4>
 <div class="paragraph">
-<p>TODO: Diesen Abschnitt nach Umsetzung validieren</p>
-</div>
-<div class="admonitionblock tip">
-<table>
-<tr>
-<td class="icon">
-<img src="../img/icons/tip.png" alt="Tip">
-</td>
-<td class="content">
-Das Löschen einer Störungsmeldung ist nur in den internen Bearbeitungsstatus
-"neu" und "geplant" möglich.
-</td>
-</tr>
-</table>
-</div>
-<div class="paragraph">
-<p>TODO: Ggf. Bild anpassen</p>
+<p>Ist ein Benutzer mit der Benutzerrolle "Erfasser" angemeldet,
+so besteht die Möglichkeit über die Schaltfläche "Löschen"
+eine Störungsmeldung zu löschen.</p>
 </div>
 <div class="imageblock">
 <div class="content">
-<img src="../img/loeschen.png" alt="loeschen">
+<img src="../img/stoerung-loeschen.png" alt="stoerung loeschen">
 </div>
 <div class="title">Figure 10. Schaltfläche zum Löschen einer Störungsmeldung</div>
 </div>
+<div class="paragraph">
+<p>Nach dem Klick auf das Löschen erscheint eine Rückfrage, ob die Störungsmeldung
+wirklich gelöscht werden soll. Nach einem Klick auf "Ja" ist die
+Störungsmeldung entfernt.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/loeschen-nachfrage.png" alt="loeschen nachfrage">
+</div>
+<div class="title">Figure 11. Nachfrage beim Löschen einer Störungsmeldung</div>
+</div>
 <div class="admonitionblock warning">
 <table>
 <tr>
@@ -1218,6 +1234,19 @@
 </tr>
 </table>
 </div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Das Löschen einer Störungsmeldung ist nur in den internen Bearbeitungsstatus
+"neu", "angelegt" und "geplant" möglich.
+</td>
+</tr>
+</table>
+</div>
 <div class="paragraph">
 <p>Befindet sich die Störungsmeldung in einem anderen internen Bearbeitungsstatus,
 so ist die Funktion <a href="#statuswechsel-stornieren">Stornieren</a> zu verwenden.</p>
@@ -1240,6 +1269,9 @@
 <li>
 <p>Störungsort</p>
 </li>
+<li>
+<p>Veröffentlichung</p>
+</li>
 </ol>
 </div>
 <div class="sect3">
@@ -1251,7 +1283,7 @@
 <div class="content">
 <img src="../img/stoerung-uebersicht.png" alt="stoerung uebersicht">
 </div>
-<div class="title">Figure 11. Ansicht der Informationen zu einer Störungsmeldung</div>
+<div class="title">Figure 12. Ansicht der Informationen zu einer Störungsmeldung</div>
 </div>
 <div class="paragraph">
 <p>Die Störungsinformation enthält folgende Attribute:</p>
@@ -1286,6 +1318,9 @@
 <p>geplante Maßnahme</p>
 </li>
 </ul>
+</div>
+<div class="paragraph">
+<p>Der Administrator kann dieses Feld durch Konfiguration ausblenden.</p>
 </div></div></td>
 </tr>
 <tr>
@@ -1351,7 +1386,7 @@
 <div class="content">
 <img src="../img/stoerung-detail.png" alt="stoerung detail">
 </div>
-<div class="title">Figure 12. Ansicht der Details zu einer Störungsmeldung</div>
+<div class="title">Figure 13. Ansicht der Details zu einer Störungsmeldung</div>
 </div>
 <div class="paragraph">
 <p>Die Störungsdetails enthalten folgende Attribute:</p>
@@ -1377,7 +1412,12 @@
 <td class="tableblock halign-left valign-top"><p class="tableblock">Zuständigkeit</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">nein</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Freitext</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Zuständiger Mitarbeiter, Bereich, etc.</p></td>
+<td class="tableblock halign-left valign-top"><div class="content"><div class="paragraph">
+<p>Zuständiger Mitarbeiter, Bereich, etc.</p>
+</div>
+<div class="paragraph">
+<p>Der Administrator kann dieses Feld durch Konfiguration ausblenden.</p>
+</div></div></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Spannungsebene</p></td>
@@ -1437,7 +1477,10 @@
 <td class="tableblock halign-left valign-top"><p class="tableblock">Voraussichtlicher Grund</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">ja</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Auswahlfeld</p></td>
-<td class="tableblock halign-left valign-top"><div class="content"><div class="ulist">
+<td class="tableblock halign-left valign-top"><div class="content"><div class="paragraph">
+<p>Folgende Einträge werden immer und unabhängig von der Sparte angezeigt:</p>
+</div>
+<div class="ulist">
 <ul>
 <li>
 <p>Defekt technische Anlage</p>
@@ -1446,31 +1489,64 @@
 <p>Leitung beschädigt</p>
 </li>
 <li>
-<p>noch nicht bekannt</p>
+<p>Noch nicht bekannt</p>
 </li>
 <li>
 <p>Überregionale Störung</p>
 </li>
 <li>
-<p>Kabelfehler Mittelspannung (nur bei Strom)</p>
-</li>
-<li>
-<p>Kabelfehler Niederspannung (nur bei Strom)</p>
+<p>Sonstiges</p>
 </li>
 </ul>
+</div>
+<div class="paragraph">
+<p>Zusätzlich bei Sparte = Strom:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Kabelfehler Mittelspannung</p>
+</li>
+<li>
+<p>Kabelfehler Niederspannung</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>Zusätzlich bei Sparte = Wasser:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Wasserrohrbuch</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>Bei Sparte = ohne Sparte sind alle v.g. Einträge sichtbar.</p>
 </div></div></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Beschreibung</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">nein</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Freitext</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Beschreibung der Störung</p></td>
+<td class="tableblock halign-left valign-top"><div class="content"><div class="paragraph">
+<p>Beschreibung der Störung</p>
+</div>
+<div class="paragraph">
+<p>Der Administrator kann dieses Feld durch Konfiguration ausblenden.</p>
+</div></div></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Interne Bemerkungen</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">nein</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Freitext</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Zusätzliche Hinweise der Bearbeiter</p></td>
+<td class="tableblock halign-left valign-top"><div class="content"><div class="paragraph">
+<p>Zusätzliche Hinweise der Bearbeiter</p>
+</div>
+<div class="paragraph">
+<p>Der Administrator kann dieses Feld durch Konfiguration ausblenden.</p>
+</div></div></td>
 </tr>
 </tbody>
 </table>
@@ -1504,7 +1580,7 @@
 <div class="content">
 <img src="../img/ortserfassung.png" alt="ortserfassung">
 </div>
-<div class="title">Figure 13. Schaltfläche zur Auswahl der Ortserfassung</div>
+<div class="title">Figure 14. Schaltfläche zur Auswahl der Ortserfassung</div>
 </div>
 <div class="admonitionblock warning">
 <table>
@@ -1513,7 +1589,8 @@
 <img src="../img/icons/warning.png" alt="Warning">
 </td>
 <td class="content">
-Beim Wechsel der Erfassungsart gehen alle bisherigen Eingaben zum Störungsort ohne Hinweis zurückgesetzt.
+Beim Wechsel der Erfassungsart werden alle bisherigen Eingaben zum
+Störungsort ohne Hinweis zurückgesetzt.
 </td>
 </tr>
 </table>
@@ -1528,7 +1605,7 @@
 <div class="content">
 <img src="../img/ort-adresse.png" alt="ort adresse">
 </div>
-<div class="title">Figure 14. Ansicht der Ortserfassung über Adresse</div>
+<div class="title">Figure 15. Ansicht der Ortserfassung über Adresse</div>
 </div>
 <div class="paragraph">
 <p>Zur Adresse gehören folgende Attribute:</p>
@@ -1551,16 +1628,10 @@
 </thead>
 <tbody>
 <tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Postleitzahl</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">ja</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Zahl</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Postleitzahl des Störungsortes</p></td>
-</tr>
-<tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Ort (betroffene Orte)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">ja</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Auswahlfeld</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Auswahllisteneinträge abhängig von der ausgewählten Postleitzahl</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Auswahllisteneinträge abhängig von ausgewählter Sparte</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Ortsteil</p></td>
@@ -1569,6 +1640,12 @@
 <td class="tableblock halign-left valign-top"><p class="tableblock">Auswahllisteneinträge abhängig vom ausgewählten Ort</p></td>
 </tr>
 <tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Postleitzahl</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">ja</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Auswahlfeld</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Auswahllisteneinträge abhängig vom ausgewählten Ortsteil</p></td>
+</tr>
+<tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Straße (betroffene Straße)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">ja</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Auswahlfeld</p></td>
@@ -1623,7 +1700,7 @@
 </div>
 <div class="paragraph">
 <p>Während der Erfassung des Ortes erscheint nach Eingabe des zweiten Buchstabens eine Liste von Orten.
-Es dürfen ausschließlich - in der Liste vorhandene - Orte eingetragen werden.</p>
+Es dürfen ausschließlich in der Liste vorhandene Orte eingetragen werden.</p>
 </div>
 <div class="admonitionblock tip">
 <table>
@@ -1651,7 +1728,7 @@
 <div class="content">
 <img src="../img/ort-karte.png" alt="ort karte">
 </div>
-<div class="title">Figure 15. Ansicht der Ortserfassung über Karte</div>
+<div class="title">Figure 16. Ansicht der Ortserfassung über Karte</div>
 </div>
 <div class="paragraph">
 <p>Mit einem Mausklick auf die entsprechende Stelle auf der Karte wird eine Markierung
@@ -1662,6 +1739,59 @@
 <p>Die Darstellung des Störungsortes erfolgt mit dem gleichen Marker, wie in allen anderen
 Kartendarstellung auch.</p>
 </div>
+<div class="paragraph">
+<p>Zusätzlich besteht die Möglichkeit zur Erfassung weiterer Informationen zur Positionierung:</p>
+</div>
+<table class="tableblock frame-all grid-all stretch">
+<caption class="title">Table 5. Attribute einer Störungsmeldung (Teil: Störungsort über Karte)</caption>
+<colgroup>
+<col style="width: 25%;">
+<col style="width: 25%;">
+<col style="width: 25%;">
+<col style="width: 25%;">
+</colgroup>
+<thead>
+<tr>
+<th class="tableblock halign-left valign-top">Attribut</th>
+<th class="tableblock halign-left valign-top">Pflichtfeld(*)</th>
+<th class="tableblock halign-left valign-top">Inhaltsart</th>
+<th class="tableblock halign-left valign-top">Beschreibung</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Ort (betroffene Orte)</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">nein</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Textfeld</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Bei Bedarf: Ortsangabe</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Ortsteil</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">nein</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Textfeld</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Bei Bedarf: Ortsteil</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Postleitzahl</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">nein</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Textfeld</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Bei Bedarf: Postleitzahl</p></td>
+</tr>
+</tbody>
+</table>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Die drei Attribute zur Ergänzung der Standortinformationen werden technisch
+nicht gegen den ausgewählten Ort in der Karte geprüft.
+</td>
+</tr>
+</table>
+</div>
 </div>
 <div class="sect4">
 <h5 id="_stationsattribute"><a class="anchor" href="#_stationsattribute"></a>3.2.3.3. Stationsattribute</h5>
@@ -1679,15 +1809,13 @@
 </table>
 </div>
 <div class="paragraph">
-<p>Die Erfassung über die Stationsattribute kommt dann zum Einsatz, wenn
-es sich um Mittelspannungsstörungen handelt. Hierbei sind die relevanten
-Stationen zu erfassen.</p>
+<p>An dieser Stelle sind die relevanten Stationen zu erfassen.</p>
 </div>
 <div class="imageblock">
 <div class="content">
 <img src="../img/ort-station.png" alt="ort station">
 </div>
-<div class="title">Figure 16. Ansicht der Ortserfassung über Stationsattribute</div>
+<div class="title">Figure 17. Ansicht der Ortserfassung über Stationsattribute</div>
 </div>
 <div class="paragraph">
 <p>Während der Erfassung der Station (Straßenname oder Stationsnummer) erscheint
@@ -1697,7 +1825,7 @@
 <div class="paragraph">
 <p>Nach Auswahl einer Station wird diese in der Karte dargestellt. Zusätzlich wird
 das Gebiet mit den zugeordneten Hausanschlüssen in Form eines Polygons umrahmt.
-Bei der Auswahl mehrerer Stationen wird die zugrundeliegenden Bereiche miteinander
+Bei der Auswahl mehrerer Stationen werden die zugrundeliegenden Bereiche miteinander
 vereint, sofern diese geographisch nebeneinander liegen.</p>
 </div>
 <div class="admonitionblock tip">
@@ -1718,58 +1846,693 @@
 <div class="sect3">
 <h4 id="veroeffentlichung"><a class="anchor" href="#veroeffentlichung"></a>3.2.4. Veröffentlichung</h4>
 <div class="paragraph">
-<p>TODO</p>
+<p>Die Veröffentlichung steuert wer die Informationen zu einer Störungsmeldung
+erhalten soll.</p>
 </div>
 <div class="paragraph">
-<p>TODO: Folgenden Hinweis einarbeiten
-Man könnte den Hinweis unterbringen, dass eine Veröffentlichung über einen Kanal
-wie E-Mail nur dann Sinn macht, wenn auch mindestens eine Verteilergruppe ausgewählt
-ist, die einen Kontakt mit einer E Mailadresse beinhaltet, sodass mindestens eine
-E Mailadresse gibt, an die eine Benachrichtigung geschickt werden kann.</p>
+<p>Über den Veröffentlichungskanal wird die Schnittstelle ausgewählt, über die
+die Störungsinformationen veröffentlicht werden sollen. Es ist möglich
+keinen, einen oder mehrere Kanäle auszuwählen. In der folgenden Abbildung sind
+zwei Veröffentlichungskanäle angebunden, wobei grundsätzlich vier Schnittstellen
+zur Verfügung stehen:</p>
+</div>
+<div class="olist arabic">
+<ol class="arabic">
+<li>
+<p>Mail</p>
+</li>
+<li>
+<p>Störungsauskunft.de</p>
+</li>
+<li>
+<p>SARIS</p>
+</li>
+<li>
+<p>SAMO</p>
+</li>
+</ol>
+</div>
+<div class="admonitionblock important">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/important.png" alt="Important">
+</td>
+<td class="content">
+Die Sichtbarkeit der verschiedenen Kanäle wird durch den
+Administrator eingestellt.
+</td>
+</tr>
+</table>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/veroeffentlichung.png" alt="veroeffentlichung">
+</div>
+<div class="title">Figure 18. Veröffentlichungskanäle und Verteilergruppen</div>
+</div>
+<div class="paragraph">
+<p>Nachdem der oder die Veröffentlichungskanäle aktiviert wurden, müssen nun eine
+oder mehrere Verteilergruppen ausgewählt werden. Das erfolgt über das
+Auswahlfeld in der Tabelle Verteilergruppen:</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/veroeffentlichung-auswahl.png" alt="veroeffentlichung auswahl">
+</div>
+<div class="title">Figure 19. Auswahl der Verteilergruppen</div>
+</div>
+<div class="admonitionblock important">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/important.png" alt="Important">
+</td>
+<td class="content">
+Die Verteilergruppen können individuell angepasst werden, siehe
+<a href="#uebersicht-verteilergruppen">Anpassung von Verteilergruppen</a>.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>Nachdem die Verteilgruppe im Auswahlfeld selektiert ist, muss die folgende
+Schaltfläche zur Übernahme geklickt werden.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/veroeffentlichung-Zuordnung.png" alt="veroeffentlichung Zuordnung">
+</div>
+<div class="title">Figure 20. Zuordnung einer Verteilergruppen</div>
+</div>
+<div class="paragraph">
+<p>Anschließend erscheint die Verteilergruppe in der darunterliegenden Tabelle.
+Dieser Vorgang wird so oft wiederholt, bis alle Verteilergruppen hinzugefügt
+wurden.</p>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Bei Auswahl des Veröffentlichungskanals "Mail" muss darauf geachtet werden,
+die ausgewählte(n) Verteilergruppe(n) mindestens einen Kontakt mit einer
+Mail-Adressen beinhaltet. Andernfalls könnten keine Benachrichtigungen versendet
+werden.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>Benachrichtigungen erfolgen ausschließlich bei Statuswechseln nach:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Aktualisiert (interner Bearbeitungsstatus)</p>
+</li>
+<li>
+<p>Beendet (interner Bearbeitungsstatus)</p>
+</li>
+<li>
+<p>Öffentlich (Veröffentlichungsstatus)</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>Eine Verteilergruppe bezieht sich immer genau auf einen der zuvor genannten
+Statuswechsel.</p>
+</div>
+<div class="paragraph">
+<p>Um eine Verteilgruppe aus der Liste zu entfernen, muss lediglich das Löschen-Symbol
+geklickt werden.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/loeschen.png" alt="loeschen">
+</div>
+<div class="title">Figure 21. Schaltfläche zum Entfernen einer Verteilergruppe aus der Liste</div>
+</div>
+<div class="paragraph">
+<p>Das kann zu jedem Zeitpunkt im Bearbeitungsprozess erfolgen.
+Die entfernte Verteilgruppe erhält keine Information darüber, dass sie entfernt
+wurde.</p>
 </div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="uebersicht-verteilergruppen"><a class="anchor" href="#uebersicht-verteilergruppen"></a>3.3. Übersicht der Verteilergruppen</h3>
 <div class="paragraph">
-<p>TODO</p>
+<p>In der Hauptmenüleiste ist das folgende Icon zur Bearbeitung der
+Verteilergruppen sichtbar, sofern der angemeldete Benutzer die erforderlichen
+Rechte dafür besitzt:</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/verteilergruppen-symbol.png" alt="verteilergruppen symbol">
+</div>
+<div class="title">Figure 22. Icon zum Aufruf der Funktion zur Bearbeitung der Verteilergruppen</div>
+</div>
+<div class="paragraph">
+<p>Die Übersicht der Verteilergruppen unterteilt sich in drei Bereiche:</p>
+</div>
+<div class="olist arabic">
+<ol class="arabic">
+<li>
+<p>Übersicht der Verteilergruppen (links oben)</p>
+</li>
+<li>
+<p>Anlegen und Editieren des Veröffentlichungstextes zur ausgewählten Verteilergruppe (rechts)</p>
+</li>
+<li>
+<p>Zugeordnete Kontakte zur ausgewählten Verteilergruppe (links unten)</p>
+</li>
+</ol>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/verteilergruppen-uebersicht.png" alt="verteilergruppen uebersicht">
+</div>
+<div class="title">Figure 23. Übersicht der Verteilergruppen</div>
 </div>
 <div class="sect3">
-<h4 id="anlegen-verteilergruppe"><a class="anchor" href="#anlegen-verteilergruppe"></a>3.3.1. Anlegen einer Verteilergruppe</h4>
+<h4 id="bearbeiten-verteilergruppe"><a class="anchor" href="#bearbeiten-verteilergruppe"></a>3.3.1. Ansicht und Bearbeitung einer Verteilergruppe</h4>
 <div class="paragraph">
-<p>TODO</p>
+<p>Zur Ansicht und Bearbeitung einer Verteilergruppe ist der entsprechende Eintrag
+in der Tabelle Verteilergruppen durch einfaches Klicken auszuwählen. Anschließend
+ist die Zeile farblich markiert und die zugehörigen Ansichten stellen die Inhalte
+der Verteilergruppe dar, siehe vorherige Abbildung.</p>
+</div>
+<div class="paragraph">
+<p>Zu einer Verteilergruppe gehören folgende Attribute:</p>
+</div>
+<table class="tableblock frame-all grid-all stretch">
+<caption class="title">Table 6. Attribute einer Verteilergruppe</caption>
+<colgroup>
+<col style="width: 25%;">
+<col style="width: 25%;">
+<col style="width: 25%;">
+<col style="width: 25%;">
+</colgroup>
+<thead>
+<tr>
+<th class="tableblock halign-left valign-top">Attribut</th>
+<th class="tableblock halign-left valign-top">Pflichtfeld(*)</th>
+<th class="tableblock halign-left valign-top">Inhaltsart</th>
+<th class="tableblock halign-left valign-top">Beschreibung</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Titel</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">ja</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Text</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Bezeichnung der Verteilergruppe</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Vorlage</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">ja</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Auswahlfeld</p></td>
+<td class="tableblock halign-left valign-top"><div class="content"><div class="paragraph">
+<p>Auswahl der Mailvorlage, die beim entsprechenden Statuswechsel verwendet wird:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Veröffentlichen</p>
+</li>
+<li>
+<p>Aktualisieren</p>
+</li>
+<li>
+<p>Beenden</p>
+</li>
+</ul>
+</div></div></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Betreff</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">ja</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Text</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Betreff der Mail-Nachricht</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Text</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">nein</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Text</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Inhalt der Mail-Nachricht</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Kontakte</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">nein</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Kontakt</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Zugeordnete Kontakte (aus Kontaktstammdaten-Modul)</p></td>
+</tr>
+</tbody>
+</table>
+<div class="sect4">
+<h5 id="mailvorlage-bearbeiten"><a class="anchor" href="#mailvorlage-bearbeiten"></a>3.3.1.1. Anlegen und Editieren des Veröffentlichungstextes</h5>
+<div class="paragraph">
+<p>Die Bearbeitung des Veröffentlichungstextes zu einer Verteilergruppe erfolgt in folgendem
+Bereich.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/verteilergruppe-bearbeiten.png" alt="verteilergruppe bearbeiten">
+</div>
+<div class="title">Figure 24. Bearbeitung des Veröffentlichungstextes einer Verteilergruppe</div>
+</div>
+<div class="paragraph">
+<p>In den Feldern Betreff und Text können sogenannte Platzhalter verwendet
+werden. Diese werden beim Veröffentlichungsprozess durch die echten Inhalte der
+Störungsmeldung ersetzt. Zwei Beispiele:</p>
+</div>
+<div class="olist arabic">
+<ol class="arabic">
+<li>
+<p>Beispiel</p>
+<div class="ulist">
+<ul>
+<li>
+<p>Platzhalter im Text: $Ort$</p>
+</li>
+<li>
+<p>Wird bei der Veröffentlichung durch den Wert "Ort" der entsprechenden Störungsmeldung
+ersetzt, z.B. Darmstadt</p>
+</li>
+</ul>
+</div>
+</li>
+<li>
+<p>Beispiel</p>
+<div class="ulist">
+<ul>
+<li>
+<p>Platzhalter: $Druckstufe$</p>
+</li>
+<li>
+<p>Wird bei der Veröffentlichung durch den Wert "Druckstufe" der entsprechenden
+Störungsmeldung ersetzt, z.B. Hochdruck. (Das funktioniert allerdings nur,
+wenn bei der Störungsmeldung die Sparte "Gas" ausgewählt ist.)</p>
+</li>
+</ul>
+</div>
+</li>
+</ol>
+</div>
+<div class="paragraph">
+<p>Folgende Platzhalter sind definiert:</p>
+</div>
+<table class="tableblock frame-all grid-all stretch">
+<caption class="title">Table 7. Platzhalter für Feld "Text" bei Verteilergruppen</caption>
+<colgroup>
+<col style="width: 50%;">
+<col style="width: 50%;">
+</colgroup>
+<thead>
+<tr>
+<th class="tableblock halign-left valign-top">Platzhalter</th>
+<th class="tableblock halign-left valign-top">Hinweis</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Beschreibung$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Druckstufe$</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Nur bei Sparte = Gas (*)</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Interne_Bemerkungen$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Ort$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Postleitzahl$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Spannungsebene$</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Nur bei Sparte = Strom (*)</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Station_Bezeichnung$</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Nur bei Sparte = Strom UND Spannungsebene = Mittelspannung (*)</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Status_intern$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Störungsende_geplant$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Straße$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Voraussichtlicher_Grund$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Direkter_Link_zur_Störung$</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">URL zum direkten Aufruf der Störungsmeldung in diesem Modul</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Hausnummer$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Klassifikation$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Ortsteil$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Radius$</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Nur bei Erfassung des Störungsortes über "Adresse" (*)</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Sparte$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Status_extern$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Störungsbeginn_gemeldet$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Störungsende_wiederversorgt$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Veröffentlichungsstatus$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">$Zuständigkeit$</p></td>
+<td class="tableblock halign-left valign-top"></td>
+</tr>
+</tbody>
+</table>
+<div class="paragraph">
+<p>(*) Sollten die Voraussetzungen nicht erfüllt sein, so findet keine Textersetzung
+statt und der Platzhalter bleibt leer</p>
+</div>
+<div class="paragraph">
+<p>Über die Schaltfläche "Speichern" werden die Änderungen übernommen.</p>
+</div>
+</div>
+<div class="sect4">
+<h5 id="_kontakte"><a class="anchor" href="#_kontakte"></a>3.3.1.2. Kontakte</h5>
+<div class="paragraph">
+<p>In der Tabelle "Kontakte zur Verteilergruppe" sind alle Kontakte aufgelistet,
+die zur ausgewählten Verteilergruppe zugeordnet sind.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/verteilergruppe-kontakte.png" alt="verteilergruppe kontakte">
+</div>
+<div class="title">Figure 25. Zuordnung von Kontakten zu einer Verteilergruppe</div>
+</div>
+<div class="paragraph">
+<p>Zum Hinzufügen weiterer Kontakte muss der Name in das Eingabefeld eingegeben
+werden. Nach der Eingabe von mindestens zwei Zeichen erscheint automatisch
+eine Liste mit Vorschlägen. Hieraus kann der entsprechende Eintrag durch einfachen
+Klick ausgewählt werden. Anschließend ist die Schaltfläche "Kontakt zuordnen"
+für die Übernahme des Kontakts in die Liste zu betätigen. Eine extra Speichern-Funktion
+existiert nicht.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/verteilergruppe-kontakte-auswahl.png" alt="verteilergruppe kontakte auswahl">
+</div>
+<div class="title">Figure 26. Auswahl von Kontakten zu einer Verteilergruppe</div>
+</div>
+<div class="admonitionblock warning">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/warning.png" alt="Warning">
+</td>
+<td class="content">
+Sollte der gesuchte Kontakt nicht vorhanden sein, so muss dieser über das
+Modul Kontaktstammdaten erfasst werden. Ist dies erfolgt, so steht der Kontakt hier
+zur Verfügung.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>Das Entfernen eines Kontakts ist über das Löschen-Symbol in der entsprechenden Zeile
+möglich.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/loeschen.png" alt="loeschen">
+</div>
+<div class="title">Figure 27. Entfernen eines Kontakts aus einer Verteilergruppe</div>
+</div>
+<div class="sect5">
+<h6 id="_einschränkung_der_benachrichtigung_auf_postleitzahlen_ebene"><a class="anchor" href="#_einschränkung_der_benachrichtigung_auf_postleitzahlen_ebene"></a>3.3.1.2.1. Einschränkung der Benachrichtigung auf Postleitzahlen-Ebene</h6>
+<div class="paragraph">
+<p>Ein Kontakt, der einer Verteilergruppe zugeordnet ist, erhält standardmäßig alle
+Benachrichtigungen, die auf dem ensprechenden Statuswechsel basieren.
+Damit aber nicht jeder Kontakt alle Mitteilungen erhalten muss, besteht die Möglichkeit
+den Versand von Nachrichten auf bestimmte Postleitzahlen zu beschränken.</p>
+</div>
+<div class="paragraph">
+<p>In der folgenden Abbildung sind dem ausgewählten Kontakt zwei Postleitzahlen
+zugeordnet:</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/verteilergruppe-kontakte-plz.png" alt="verteilergruppe kontakte plz">
+</div>
+<div class="title">Figure 28. Zuordnung von Postleitzahlen zu Kontakten einer Verteilergruppe</div>
+</div>
+<div class="paragraph">
+<p>D.h. der Kontakt erhält nur Benachrichtigungen der zugrundeliegenden Verteilergruppe,
+wenn eine der zugeordneten Postleitzahlen in einer der folgenden Felder der Störungsmeldung
+enthalten ist:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Störungsort - Adresse - Postleitzahl</p>
+</li>
+<li>
+<p>Störungsort - Karte - Postleitzahl</p>
+</li>
+<li>
+<p>Störungsort - Stationsattribute - Station - zugeordneter Anschluss - Postleitzahl</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>Das Hinzufügen einer Postleitzahl erfolgt über die Erfassung im
+entsprechenden Textfeld mit anschließender Übernahmne durch das "+"-Symbol.
+Das Entfernen erfolgt über die Betätigung des Löschen-Symbols des entsprechenden
+PLZ-Eintrags in der Tabelle.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/plus-symbol.png" alt="plus symbol">
+</div>
+<div class="title">Figure 29. Hinzufügen einer Postleitzahl</div>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/loeschen.png" alt="loeschen">
+</div>
+<div class="title">Figure 30. Entfernen einer Postleitzahl</div>
+</div>
+</div>
+<div class="sect5">
+<h6 id="_export_von_kontakten"><a class="anchor" href="#_export_von_kontakten"></a>3.3.1.2.2. Export von Kontakten</h6>
+<div class="paragraph">
+<p>Das System erlaubt den Export von Kontakten einer Verteilergruppe in eine
+Textdatei. Dazu muss die folgende Schaltfläche geklickt werden:</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/export.png" alt="export">
+</div>
+<div class="title">Figure 31. Schaltfläche zum Export von Kontakten einer Verteilergruppe</div>
+</div>
+<div class="paragraph">
+<p>Anschließend speichert der Browser die erzeugte Datei.</p>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Das Verhalten beim Speichern sowie der Speicherort sind von den Einstellungen
+des Browsers abhängig.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>Die Datei ist entsprechend der Verteilergruppe benannt:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>"&lt;Verteilergruppenname&gt;.txt"</p>
+</li>
+</ul>
+</div>
+<div class="paragraph">
+<p>Der Dateiinhalt sieht folgendermaßen aus:</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="highlightjs highlight"><code data-lang="json" class="language-json hljs">  name;email;mobilenumber
+  Freudenberg, Pauline;PaulineF@gmx.net;01526677884
+  Buckley, Cornelius;sender@test.tester;</code></pre>
+</div>
+</div>
+</div>
 </div>
 </div>
 <div class="sect3">
-<h4 id="löschen-verteilergruppe"><a class="anchor" href="#löschen-verteilergruppe"></a>3.3.2. Löschen einer Verteilergruppe</h4>
+<h4 id="anlegen-verteilergruppe"><a class="anchor" href="#anlegen-verteilergruppe"></a>3.3.2. Anlegen einer Verteilergruppe</h4>
 <div class="paragraph">
-<p>TODO</p>
+<p>Zur Anlage einer neuen Verteilergruppe ist die Schaltfläche "Neue Verteilergruppe anlegen"
+zu betätigen.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/verteilergruppe-anlegen.png" alt="verteilergruppe anlegen">
+</div>
+<div class="title">Figure 32. Schaltfläche zur Anlage einer neuen Verteilergruppe</div>
 </div>
 <div class="paragraph">
-<p>TODO: Hinweis von Frau Salbeck einarbeiten
-Es können einzelne Verteiler aus dem Veröffentlichungsprozess herausgenommen werden,
-ohne dass diese eine Nachricht darüber erhalten.</p>
+<p>Anschließend erscheint eine leere Eingabemaske für die entsprechenden Felder:</p>
 </div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/verteilergruppe-anlegen-2.png" alt="verteilergruppe anlegen 2">
 </div>
+<div class="title">Figure 33. Erfassung Informationen zu einer neuen Verteilergruppe</div>
 </div>
-<div class="sect2">
-<h3 id="bearbeitung-verteilergruppen"><a class="anchor" href="#bearbeitung-verteilergruppen"></a>3.4. Ansicht und Bearbeiten einer Verteilergruppe</h3>
 <div class="paragraph">
-<p>TODO</p>
+<p>Es müssen zumindest die Pflichtfelder gefüllt werden, damit die neue Verteilergruppe
+gespeichert werden kann.</p>
+</div>
+<div class="paragraph">
+<p>Die weitere Erfassung erfolgt analog zur
+<a href="#bearbeiten-verteilergruppe">Bearbeitung von Verteilergruppen</a>.</p>
+</div>
+</div>
+<div class="sect3">
+<h4 id="löschen-verteilergruppe"><a class="anchor" href="#löschen-verteilergruppe"></a>3.3.3. Löschen einer Verteilergruppe</h4>
+<div class="paragraph">
+<p>Das Entfernen einer Verteilergruppe ist über das Löschen-Symbol in der
+entsprechenden Zeile der Tabelle mit den Verteilergruppen möglich.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/loeschen.png" alt="loeschen">
+</div>
+<div class="title">Figure 34. Löschen einer Verteilergruppe</div>
+</div>
+<div class="paragraph">
+<p>Nach dem Klick auf das Löschen-Symbol erscheint eine Rückfrage, ob die Verteilergruppe wirklich gelöscht
+werden soll. Nach einem Klick auf "Ja" ist die Verteilergruppe entfernt.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/loeschen-nachfrage.png" alt="loeschen nachfrage">
+</div>
+<div class="title">Figure 35. Nachfrage beim Löschen einer Verteilergruppe</div>
 </div>
 <div style="page-break-after: always;"></div>
 </div>
 </div>
 </div>
+</div>
 <div class="sect1">
 <h2 id="_weitere_funktionen"><a class="anchor" href="#_weitere_funktionen"></a>4. Weitere Funktionen</h2>
 <div class="sectionbody">
 <div class="sect2">
 <h3 id="allg-funktionen-uebersicht-aller-sm"><a class="anchor" href="#allg-funktionen-uebersicht-aller-sm"></a>4.1. Zur: Übersicht der Störungsmeldungen</h3>
 <div class="sect3">
-<h4 id="allg-funktionen-uebersicht-aller-sm-filter"><a class="anchor" href="#allg-funktionen-uebersicht-aller-sm-filter"></a>4.1.1. Vordefinierte Filter (Kennzahlen)</h4>
+<h4 id="allg-funktionen-uebersicht-aller-sm-filter"><a class="anchor" href="#allg-funktionen-uebersicht-aller-sm-filter"></a>4.1.1. Vordefinierte Filter</h4>
 <div class="paragraph">
-<p>TODO</p>
+<p>Die Listen-Ansicht stellt zwei vordefinierte Filter zur Verfügung:</p>
+</div>
+<div class="sect4">
+<h5 id="_filter_qualifiziertveröffentlicht"><a class="anchor" href="#_filter_qualifiziertveröffentlicht"></a>4.1.1.1. Filter: qualifiziert/veröffentlicht</h5>
+<div class="paragraph">
+<p>Mit Aktivierung des folgenden Schalters wird dieser Filter aktiviert.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/filter-1.png" alt="filter 1">
+</div>
+<div class="title">Figure 36. Schalter zur Aktivierung des Filters qualifiziert/veröffentlicht</div>
+</div>
+<div class="paragraph">
+<p>Anschließend erscheinen in der Haupttabelle ausschließlich
+Störungsmeldungen, die mindestens eine der folgenden Bedingungen erfüllt:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Interner Bearbeitungsstatus = qualifiziert</p>
+</li>
+<li>
+<p>Veröffentlichungsstatus = öffentlich</p>
+</li>
+</ul>
+</div>
+</div>
+<div class="sect4">
+<h5 id="_filter_qualifiziertveröffentlicht_2"><a class="anchor" href="#_filter_qualifiziertveröffentlicht_2"></a>4.1.1.2. Filter: qualifiziert/veröffentlicht</h5>
+<div class="paragraph">
+<p>Mit Aktivierung des folgenden Schalters wird dieser Filter aktiviert.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/filter-2.png" alt="filter 2">
+</div>
+<div class="title">Figure 37. Schalter zur Aktivierung des Filters angelegt/geplant/aktualisiert</div>
+</div>
+<div class="paragraph">
+<p>Anschließend erscheinen in der Haupttabelle ausschließlich
+Störungsmeldungen, die mindestens eine der folgenden Bedingungen erfüllt:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Interner Bearbeitungsstatus = angelegt</p>
+</li>
+<li>
+<p>Interner Bearbeitungsstatus = geplant</p>
+</li>
+<li>
+<p>Interner Bearbeitungsstatus = aktualisiert</p>
+</li>
+</ul>
+</div>
 </div>
 </div>
 <div class="sect3">
@@ -1790,6 +2553,19 @@
 </tr>
 </table>
 </div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Störungsmeldungen mit dem Veröffentlichungsstatus "öffentlich" können nicht
+mehr verdichtet werden.
+</td>
+</tr>
+</table>
+</div>
 <div class="paragraph">
 <p>Dazu ist in der Übersicht der Störungsmeldungen die Schaltfläche "Verdichtung"
 zu betätigen.</p>
@@ -1798,7 +2574,7 @@
 <div class="content">
 <img src="../img/verdichten-1.png" alt="verdichten 1">
 </div>
-<div class="title">Figure 17. Übersicht der Störungsmeldungen</div>
+<div class="title">Figure 38. Übersicht der Störungsmeldungen</div>
 </div>
 <div class="paragraph">
 <p>Anschließend öffnet sich unter der Schaltfläche "Verdichtung" der Bereich
@@ -1810,7 +2586,7 @@
 <div class="content">
 <img src="../img/verdichten-2.png" alt="verdichten 2">
 </div>
-<div class="title">Figure 18. Auswahl von Störungsmeldungen zum Verdichten</div>
+<div class="title">Figure 39. Auswahl von Störungsmeldungen zum Verdichten</div>
 </div>
 <div class="paragraph">
 <p>Nun sind die entsprechenden Störungsmeldungen über das "+"-Symbol auszuwählen.
@@ -1822,7 +2598,7 @@
 <div class="content">
 <img src="../img/verdichten-3.png" alt="verdichten 3">
 </div>
-<div class="title">Figure 19. Selektierte Störungsmeldungen zum Verdichten</div>
+<div class="title">Figure 40. Selektierte Störungsmeldungen zum Verdichten</div>
 </div>
 <div class="paragraph">
 <p>Mit einem Klick auf die Schaltfläche "Ausgewählte Meldungen verdichten" wird
@@ -1833,7 +2609,7 @@
 <div class="content">
 <img src="../img/verdichten-4.png" alt="verdichten 4">
 </div>
-<div class="title">Figure 20. Neue erstellte Störungsmeldung (nach Verdichtung)</div>
+<div class="title">Figure 41. Neue erstellte Störungsmeldung (nach Verdichtung)</div>
 </div>
 <div class="paragraph">
 <p>Bei der Erstellung der neuen Störungsmeldungen werden initial die Grunddaten der
@@ -1853,6 +2629,9 @@
 <li>
 <p>Störungsende (geplant): Das späteste Datum der verdichteten Meldungen</p>
 </li>
+<li>
+<p>Stationen: Alle Stationen aus den verdichteten Meldungen, sofern vorhanden</p>
+</li>
 </ul>
 </div>
 <div class="paragraph">
@@ -1862,11 +2641,20 @@
 <p>Alle Anpassungen und Aktualisierungen bzgl. dieser Störung sind fortan nur
 noch an dieser neuen Störungsmeldung vorzunehmen.</p>
 </div>
-<div class="paragraph">
-<p>INFO: Die verdichteten Meldungen werden nach Aktualisierung der übergeordneten
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Die verdichteten Meldungen werden nach Aktualisierung der übergeordneten
 Störungsmeldung nicht synchronisiert. Die einzige Ausnahme ist, wenn der
 interne Bearbeitungsstatus auf "beendet" wird. Dann werden auch die untergeordneten
-Störungsmeldungen auf "beendet" gesetzt.</p>
+Störungsmeldungen auf "beendet" gesetzt.
+</td>
+</tr>
+</table>
 </div>
 <div class="paragraph">
 <p>Nach der Verdichtung und Erzeugung der übergeordneten Störungsmeldung müssen die
@@ -1896,7 +2684,7 @@
 <div class="content">
 <img src="../img/verdichten-5.png" alt="verdichten 5">
 </div>
-<div class="title">Figure 21. Verdichtete Störungsmeldungen bearbeiten</div>
+<div class="title">Figure 42. Verdichtete Störungsmeldungen bearbeiten</div>
 </div>
 <div class="paragraph">
 <p>Nach einem Klick auf "Verdichtung bearbeiten" erscheint wieder die Ansicht
@@ -1922,7 +2710,7 @@
 <div class="content">
 <img src="../img/abbrechen.png" alt="abbrechen">
 </div>
-<div class="title">Figure 22. Schaltfläche Abbrechen</div>
+<div class="title">Figure 43. Schaltfläche Abbrechen</div>
 </div>
 </div>
 <div class="sect4">
@@ -1935,16 +2723,38 @@
 <div class="content">
 <img src="../img/meldung-nach-abbrechen.png" alt="meldung nach abbrechen">
 </div>
-<div class="title">Figure 23. Meldung bei geänderten Daten nach Klick auf Abbrechen</div>
+<div class="title">Figure 44. Meldung bei geänderten Daten nach Klick auf Abbrechen</div>
 </div>
 <div class="paragraph">
-<p>Im Bearbeitungsmodus steht zusätzlich die Schaltfläche Speichern zur Verfügung.</p>
+<p>Im Bearbeitungsmodus steht zusätzlich die Schaltfläche Speichern zur Verfügung,
+sofern der Status nicht "qualifiziert", "storniert" oder "beendet" ist.</p>
 </div>
 <div class="imageblock">
 <div class="content">
 <img src="../img/speichern.png" alt="speichern">
 </div>
-<div class="title">Figure 24. Schaltfläche Speichern</div>
+<div class="title">Figure 45. Schaltfläche Speichern</div>
+</div>
+<div class="paragraph">
+<p>Befindet sich die Störungsmeldung im Status "qualifiziert", dann ist die
+Schaltfläche "Aktualisieren" sichtbar, die gleichzeitig einen entsprechenden
+Statuswechsel durchführt.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/aktualisieren.png" alt="aktualisieren">
+</div>
+<div class="title">Figure 46. Schaltfläche zum Aktualisieren einer Störungsmeldung (im Status "qualifiziert")</div>
+</div>
+<div class="paragraph">
+<p>Um die Detailansicht einer Störungsmeldung zu verlassen, muss die folgende
+Schaltfläche betätigt werden:</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/schliessen.png" alt="schliessen">
+</div>
+<div class="title">Figure 47. Schaltfläche zum Schließen der Detail-Ansicht einer Störungsmeldung</div>
 </div>
 <div class="paragraph">
 <p>Des Weiteren existieren zusätzlich Schaltflächen, um den internen
@@ -1967,7 +2777,7 @@
 <div class="content">
 <img src="../img/anlegen.png" alt="anlegen">
 </div>
-<div class="title">Figure 25. Schaltfläche zum Wechsel des internen Bearbeitungsstatus auf "anlegen"</div>
+<div class="title">Figure 48. Schaltfläche zum Wechsel des internen Bearbeitungsstatus auf "anlegen"</div>
 </div>
 </div>
 <div class="sect4">
@@ -1976,17 +2786,14 @@
 <p>Das Stornieren eines Störungsmeldung erfolgt ebenfalls in der Detailansicht
 über die Schaltfläche "Stornieren".</p>
 </div>
-<div class="paragraph">
-<p>TODO: Bild einfügen</p>
-</div>
 <div class="imageblock">
 <div class="content">
-<img src="../img/stornieren.png" alt="stornieren">
+<img src="../img/stoerung-stornieren.png" alt="stoerung stornieren">
 </div>
-<div class="title">Figure 26. Schaltfläche zum Stornieren einer Störungsmeldung</div>
+<div class="title">Figure 49. Schaltfläche zum Stornieren einer Störungsmeldung</div>
 </div>
 <div class="paragraph">
-<p>Durch das Stornieren erhält die Störungsmeldung den internen Bearbeitungstatus
+<p>Durch das Stornieren erhält die Störungsmeldung den internen Bearbeitungsstatus
 "storniert". Gleichzeitig wird der Veröffentlichungsstatus auf "zurückgezogen"
 gesetzt.</p>
 </div>
@@ -2001,7 +2808,42 @@
 <div class="sect4">
 <h5 id="statuswechsel-veroffentlichung"><a class="anchor" href="#statuswechsel-veroffentlichung"></a>4.2.2.4. Statuswechsel des Veröffentlichungsstatus</h5>
 <div class="paragraph">
-<p>TODO</p>
+<p>Der Statuswechsel des Veröffentlichungsstatus erfolgt durch den Veröffentlicher.
+Befindet sich die zugrundeliegende Störungsmeldung im Status "qualifiziert",
+so kann die Veröffentlichung über die folgende Schaltfläche vollzogen werden.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/veroeffentlichen-2.png" alt="veroeffentlichen 2">
+</div>
+<div class="title">Figure 50. Schaltfläche zum Veröffentlichen einer Störungsmeldung</div>
+</div>
+<div class="paragraph">
+<p>Wenn kein Veröffentlichungskanal ausgewählt ist, dann ist die Schaltfläche
+nicht aktiv. In diesem Fall muss zunächst eine Veröffentlichungskanal aktiviert
+werden.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/veroeffentlichen.png" alt="veroeffentlichen">
+</div>
+<div class="title">Figure 51. Inaktive Schaltfläche zum Veröffentlichen einer Störungsmeldung</div>
+</div>
+<div class="paragraph">
+<p>Für das Beenden der Veröffentlichung gibt es drei Möglichkeiten:</p>
+</div>
+<div class="olist arabic">
+<ol class="arabic">
+<li>
+<p><a href="#veroeffentlichung">Deaktivierung der Veröffentlichungskanäle</a></p>
+</li>
+<li>
+<p><a href="#statuswechsel-allgemein">Störungsmeldung beenden</a></p>
+</li>
+<li>
+<p><a href="#statuswechsel-stornieren">Störungsmeldung stornieren</a></p>
+</li>
+</ol>
 </div>
 </div>
 </div>
@@ -2016,7 +2858,7 @@
 <div class="content">
 <img src="../img/versionierung-1.png" alt="versionierung 1">
 </div>
-<div class="title">Figure 27. Anzeige der Version einer Störungsmeldung</div>
+<div class="title">Figure 52. Anzeige der Version einer Störungsmeldung</div>
 </div>
 <div class="paragraph">
 <p>Standardmäßig ist die aktuellste Version ausgewählt. Je nach
@@ -2032,7 +2874,7 @@
 <div class="content">
 <img src="../img/versionierung-2.png" alt="versionierung 2">
 </div>
-<div class="title">Figure 28. Anzeige einer älteren Version einer Störungsmeldung (schreibgeschützt)</div>
+<div class="title">Figure 53. Anzeige einer älteren Version einer Störungsmeldung (schreibgeschützt)</div>
 </div>
 <div style="page-break-after: always;"></div>
 </div>
@@ -2043,36 +2885,274 @@
 <h2 id="_schnittstellen"><a class="anchor" href="#_schnittstellen"></a>5. Schnittstellen</h2>
 <div class="sectionbody">
 <div class="sect2">
-<h3 id="_import_von_störungsmeldungen"><a class="anchor" href="#_import_von_störungsmeldungen"></a>5.1. Import von Störungsmeldungen</h3>
+<h3 id="_internet_applikation"><a class="anchor" href="#_internet_applikation"></a>5.1. Internet-Applikation</h3>
 <div class="paragraph">
-<p>TODO</p>
+<p>Die Bereitstellung der Informationen zu einer Störungsmeldung für die
+Öffentlichkeit erfolgt in der separaten Internet-Applikation. D.h. sobald
+eine Störungsmeldung den Veröffentlichungsstatus "Öffentlich" besitzt,
+ist diese Meldung in der Internet-Applikation sichtbar.</p>
+</div>
+<div class="paragraph">
+<p>Die Internet-Applikation besteht aus drei Komponenten, die i.d.R. in bestehende
+Webseiten der Netzbetreiber integriert sind:</p>
+</div>
+<div class="olist arabic">
+<ol class="arabic">
+<li>
+<p>Karte</p>
+</li>
+<li>
+<p>Liste</p>
+</li>
+<li>
+<p>PLZ-Suche</p>
+</li>
+</ol>
+</div>
+<div class="sect3">
+<h4 id="_karte_2"><a class="anchor" href="#_karte_2"></a>5.1.1. Karte</h4>
+<div class="paragraph">
+<p>Die Kartendarstellung entspricht der <a href="#kartenansicht">Karten-Ansicht</a> der
+Übersichtsseite. In dieser Ansicht sind allerdings nur Störungsmeldungen
+mit dem Veröffentlichungsstatus "Öffentlich" sichtbar.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/internet-karte.png" alt="internet karte">
+</div>
+<div class="title">Figure 54. Internet-Applikation Karte</div>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Die initiale Darstellung, ob alle veröffentlichten oder
+keine Störungsmeldung angezeigt wird, konfiguriert der Administrator.
+</td>
+</tr>
+</table>
+</div>
+</div>
+<div class="sect3">
+<h4 id="_liste"><a class="anchor" href="#_liste"></a>5.1.2. Liste</h4>
+<div class="paragraph">
+<p>In der Listenansicht sind ausschließlich Störungsmeldungen
+mit dem Veröffentlichungsstatus "Öffentlich" dargestellt. Die Meldungen enthalten
+lediglich solche Informationen, die für die Öffentlichkeit relevant sind.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/internet-liste.png" alt="internet liste">
+</div>
+<div class="title">Figure 55. Internet-Applikation Liste</div>
+</div>
+<div class="paragraph">
+<p>Die Listenansicht enthält folgende Attribute.</p>
+</div>
+<table class="tableblock frame-all grid-all stretch">
+<caption class="title">Table 8. Felder in der Internet-Applikation Liste</caption>
+<colgroup>
+<col style="width: 100%;">
+</colgroup>
+<thead>
+<tr>
+<th class="tableblock halign-left valign-top">Sparte</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Beginn der Maßnahme</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Voraussichtliches Ende</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Voraussichtlicher Grund</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Beschreibung</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Postleitzahl</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Ort</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Ortsteil</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Straße</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Meldungsart</p></td>
+</tr>
+</tbody>
+</table>
+<div class="paragraph">
+<p>Die Bedeutung der Felder ist im Abschnitt <a href="#stoerung-ansicht-bearbeitung">Ansicht und Bearbeitung einer Störungsmeldung</a> beschrieben.</p>
+</div>
+<div class="admonitionblock tip">
+<table>
+<tr>
+<td class="icon">
+<img src="../img/icons/tip.png" alt="Tip">
+</td>
+<td class="content">
+Die initiale Darstellung, ob alle veröffentlichten oder
+keine Störungsmeldung angezeigt wird, konfiguriert der Administrator.
+</td>
+</tr>
+</table>
+</div>
+</div>
+<div class="sect3">
+<h4 id="_plz_suche"><a class="anchor" href="#_plz_suche"></a>5.1.3. PLZ-Suche</h4>
+<div class="paragraph">
+<p>Über die PLZ-Suche können die beiden Ansichten - Karte und Liste - gefiltert werden.
+Dazu muss lediglich die Postleitzahl in das Eingabefeld eingetragen und
+anschließend mit Enter bestätigt werden.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/internet-suche.png" alt="internet suche">
+</div>
+<div class="title">Figure 56. Internet-Applikation PLZ-Suche</div>
+</div>
+<div class="paragraph">
+<p>Anschließend werden autonatisch die beiden Komponenten auf diese PLZ gefiltert.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/internet-suche-beispiel.png" alt="internet suche beispiel">
+</div>
+<div class="title">Figure 57. Internet-Applikation PLZ-Suche (Beispiel)</div>
+</div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="_export_von_störungsmeldungen"><a class="anchor" href="#_export_von_störungsmeldungen"></a>5.2. Export von Störungsmeldungen</h3>
-<div class="sect3">
-<h4 id="Mail"><a class="anchor" href="#Mail"></a>5.2.1. Mail</h4>
 <div class="paragraph">
-<p>TODO</p>
+<p>Die Veröffentlichung von Störungsmeldung erfolgt über verschiedene Kanäle,
+die - technisch - auch als Export-Schnittstellen bezeichnet werden.</p>
+</div>
+<div class="paragraph">
+<p>Die Zeitpunkte, wann die Informationen über die definierten Kanäle veröffentlicht
+werden, ist bei allen Schnittstellen gleich und lassen sich in drei Phasen
+einteilen:</p>
+</div>
+<div class="olist arabic">
+<ol class="arabic">
+<li>
+<p>Initiale Veröffentlichung</p>
+</li>
+<li>
+<p>Aktualisierung</p>
+</li>
+<li>
+<p>Veröffentlichung beenden</p>
+</li>
+</ol>
+</div>
+<div class="paragraph">
+<p>Details dazu sind in den folgenden Abschnitten erläutert.</p>
+</div>
+<div class="sect3">
+<h4 id="_initiale_veröffentlichung"><a class="anchor" href="#_initiale_veröffentlichung"></a>5.2.1. Initiale Veröffentlichung</h4>
+<div class="paragraph">
+<p>Die erstmalige Veröffentlichung einer Störungsmeldung erfolgt, wenn der Benutzer
+durch Klick auf die Schaltfläche "Veröffentlichen" den Veröffentlichungsstatus
+auf "öffentlich" setzt. Hierbei werden die, dem Kanal zugeordneten Inhalte,
+übertragen.</p>
 </div>
 </div>
 <div class="sect3">
-<h4 id="stoerungsauskunft"><a class="anchor" href="#stoerungsauskunft"></a>5.2.2. Störungsauskunft.de</h4>
+<h4 id="_aktualisierung"><a class="anchor" href="#_aktualisierung"></a>5.2.2. Aktualisierung</h4>
 <div class="paragraph">
-<p>TODO</p>
+<p>Weitere Veröffentlichungsmeldungen folgen jeweils, wenn sich der interne Bearbeitungsstatus
+wieder auf "qualifiziert" ändert. Das kommt vor, wenn eine Störungsmeldung nach
+der letzten Veröffentlichungsmeldung aktualisiert wurde.</p>
+</div>
+</div>
+<div class="sect3">
+<h4 id="_veröffentlichung_beenden"><a class="anchor" href="#_veröffentlichung_beenden"></a>5.2.3. Veröffentlichung beenden</h4>
+<div class="paragraph">
+<p>Die letzte Veröffentlichungsmeldung, die das Beenden der Veröffentlichung mitteilt,
+erfolgt dann, wenn der Benutzer den Veröffentlichungsstatus auf "zurückgezogen"
+ändert. Das kann durch den Benutzer manuell erfolgen oder wenn eine Störungsmeldung
+in den internen Bearbeitungsstatus "storniert" oder "beendet" wechselt.</p>
+</div>
+</div>
+<div class="sect3">
+<h4 id="_ergänzende_hinweise"><a class="anchor" href="#_ergänzende_hinweise"></a>5.2.4. Ergänzende Hinweise</h4>
+<div class="paragraph">
+<p>Weitere Informationen zu den einzelnen Schnittstellen sind im Folgenden aufgelistet:</p>
+</div>
+<div class="sect4">
+<h5 id="Mail"><a class="anchor" href="#Mail"></a>5.2.4.1. Mail</h5>
+<div class="paragraph">
+<p>Die Absender-Adresse der Mails wird durch den Administrator definiert.</p>
+</div>
+</div>
+<div class="sect4">
+<h5 id="stoerungsauskunft"><a class="anchor" href="#stoerungsauskunft"></a>5.2.4.2. Störungsauskunft.de</h5>
+<div class="paragraph">
+<p>Die aktuell veröffentlichten Störungsmeldungen sind im Portal von
+Störungsauskunft.de ersichtlich:</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p><a href="https://störungsauskunft.de/" class="bare">https://störungsauskunft.de/</a></p>
+</li>
+</ul>
+</div>
+</div>
+<div class="sect4">
+<h5 id="SARIS"><a class="anchor" href="#SARIS"></a>5.2.4.3. SARIS</h5>
+<div class="paragraph">
+<p>TODO: Gibt es hier relevante Infos?</p>
+</div>
+</div>
+<div class="sect4">
+<h5 id="SAMO"><a class="anchor" href="#SAMO"></a>5.2.4.4. SAMO</h5>
+<div class="paragraph">
+<p>TODO: Gibt es hier relevante Infos?</p>
 </div>
 <div style="page-break-after: always;"></div>
 </div>
 </div>
 </div>
 </div>
+</div>
 <div class="sect1">
 <h2 id="_benachrichtigungen_und_erinnerungen"><a class="anchor" href="#_benachrichtigungen_und_erinnerungen"></a>6. Benachrichtigungen und Erinnerungen</h2>
 <div class="sectionbody">
 <div class="sect2">
-<h3 id="email-benachrichtigung-statuswechsel"><a class="anchor" href="#email-benachrichtigung-statuswechsel"></a>6.1. eMail-Benachrichtigung bei Statuswechsel</h3>
+<h3 id="erinnerung"><a class="anchor" href="#erinnerung"></a>6.1. Erinnerungen</h3>
 <div class="paragraph">
-<p>TODO</p>
+<p>Über die Erinnerungsfunktion wird der Benutzer informiert, dass mindestens
+eine nicht abgeschlossene Störungsmeldung das Datum für "Störungsende (geplant)"
+erreicht hat. In diesem Fall wird das Glockensymbol in der Hauptmenüleiste rot
+angezeigt.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/glocke-rot.png" alt="glocke rot">
+</div>
+<div class="title">Figure 58. Erinnerung(en) vorhanden</div>
+</div>
+<div class="paragraph">
+<p>In allen anderen Fällen bleibt das Glockensymbol schwarz.</p>
+</div>
+<div class="imageblock">
+<div class="content">
+<img src="../img/glocke-schwarz.png" alt="glocke schwarz">
+</div>
+<div class="title">Figure 59. Keine Erinnerung vorhanden</div>
 </div>
 </div>
 <div class="sect2">
@@ -2115,7 +3195,7 @@
 <div class="content">
 <img src="../img/meldung-hinweis.png" alt="meldung hinweis">
 </div>
-<div class="title">Figure 29. Hinweis Pflichtfelder</div>
+<div class="title">Figure 60. Hinweis Pflichtfelder</div>
 </div>
 <div class="paragraph">
 <p>Diese Meldungen bleiben für einige Sekunden sichtbar und verschwinden dann wieder
@@ -2143,7 +3223,7 @@
 <div class="content">
 <img src="../img/meldung-fehler.png" alt="meldung fehler">
 </div>
-<div class="title">Figure 30. Fehlermeldung</div>
+<div class="title">Figure 61. Fehlermeldung</div>
 </div>
 <div class="paragraph">
 <p>Diese Meldungen bleiben solange sichtbar bis sie durch den Benutzer durch einfaches
@@ -2163,14 +3243,14 @@
 <p>Nach erfolgreicher Anmeldung am openKONSEQUENZ-Portal und mit entsprechender
 Berechtigung für das Modul "Störungsinformationstool" ist die Kachel für das Modul
 sichtbar. Mit einem Klick auf die Kachel startet das Modul "Störungsinformationstool"
-in einem neuen Fenster bzw. in einem neuen Tab des selben Browserfensters (je nach
+in einem neuen Fenster bzw. in einem neuen Tab desselben Browserfensters (je nach
 Browsereinstellung).</p>
 </div>
 <div class="imageblock">
 <div class="content">
 <img src="../img/oeffnen-modul.png" alt="oeffnen modul">
 </div>
-<div class="title">Figure 31. Kachel zum Starten des Moduls "Störungsinformationstool"</div>
+<div class="title">Figure 62. Kachel zum Starten des Moduls "Störungsinformationstool"</div>
 </div>
 </div>
 <div class="sect2">
@@ -2182,7 +3262,7 @@
 <div class="content">
 <img src="../img/abmelden.png" alt="abmelden">
 </div>
-<div class="title">Figure 32. Abmelden vom openKONSEQUENZ-System</div>
+<div class="title">Figure 63. Abmelden vom openKONSEQUENZ-System</div>
 </div>
 <div class="admonitionblock caution">
 <table>
