Double to decimal geändert

Renovation Schlauchliner abhängig von DN und Durchmesser erstellt

Schnittstelle/Contract/ICodeBeschreibung.cs

@@ -0,0 +1,9 @@
+using Schnittstelle.Sanierung;
+
+namespace Schnittstelle.Contract
+{
+    interface ICodeBeschreibung
+    {
+        string GetBeschreibung {  get; }
+    }
+}

Schnittstelle/DWA149-2_2013/AEC.cs

@@ -0,0 +1,12 @@
+using Schnittstelle.Contract;
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    internal class AEC : CodeBeschreibung
+    {
+        public AEC(RZustand kuerzel) : base("Grundlagen änderung", kuerzel)
+        {
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/AED.cs

@@ -0,0 +1,14 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    internal class AED : CodeBeschreibung
+    {
+        public AED(RZustand kuerzel) : base("Grundlagen änderung", kuerzel)
+        {
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BAA.cs

@@ -0,0 +1,17 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using Schnittstelle.Sanierung;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAA : CodeBeschreibung
+    {
+        public BAA(RZustand kuerzel) : base("Verformung", kuerzel)
+        {
+            CH1.Add("A", "vertikal");
+            CH1.Add("B", "horizontal");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BAB.cs

@@ -0,0 +1,23 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using Schnittstelle.Sanierung;
+using System;
+using System.Collections.Generic;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAB : CodeBeschreibung
+    {
+        public BAB(RZustand kuerzel) : base("Rissbildung", kuerzel)
+        {
+            CH1.Add("A", "Oberflächenriss (Haarriss)");
+            CH1.Add("B", "Riss");
+            CH1.Add("C", "Klaffender Riss");
+
+            CH2.Add("A", "in Längsrichtung");
+            CH2.Add("B", "am Rohrumfang");
+            CH2.Add("C", "komplexe Rissbildung");
+            CH2.Add("D", "gewundene oder spiralförmige Rissbildung");
+            CH2.Add("E", "sternförmige Rissbildung");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BAC.cs

@@ -0,0 +1,17 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAC : CodeBeschreibung
+    {
+        public BAC(RZustand kuerzel) : base("Rohrbruch / Einsturz", kuerzel)
+        {
+            CH1.Add("A", "Bruch");
+            CH1.Add("B", "Fehlen von Teilen");
+            CH1.Add("C", "Einsturz");
+        }
+
+       
+    }
+}

Schnittstelle/DWA149-2_2013/BAD.cs

@@ -0,0 +1,19 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAD : CodeBeschreibung
+    {
+        public BAD(RZustand kuerzel) : base("Defektes Mauerwerk", kuerzel)
+        {
+            CH1.Add("A", "verschoben");
+            CH1.Add("B", "fehlend");
+            CH1.Add("C", "Sohle abgesackt");
+            CH1.Add("D", "Einsturz");
+
+            CH2.Add("A", "weitere Mauerwerksschicht sichtbar");
+            CH2.Add("B", "es ist nichts zu sehen");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BAE.cs

@@ -0,0 +1,14 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAE : CodeBeschreibung
+    {
+        public BAE(RZustand kuerzel) : base("Fehlender Mörtel", kuerzel)
+        {
+        }
+
+
+    }
+}

Schnittstelle/DWA149-2_2013/BAF.cs

@@ -0,0 +1,33 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAF : CodeBeschreibung
+    {
+        public BAF(RZustand kuerzel) : base("Oberflächenschaden", kuerzel)
+        {
+            CH1.Add("A", "erhöhte Rauheit");
+            CH1.Add("B", "Abplatzung");
+            CH1.Add("C", "Zuschlagstoffe sichtbar");
+            CH1.Add("D", "Zuschlagstoffe einragend");
+            CH1.Add("E", "Zuschlagstoffe fehlen");
+            CH1.Add("F", "Bewehrung sichtbar");
+            CH1.Add("G", "Bewehrung einragend");
+            CH1.Add("H", "Bewehrung korrodiert");
+            CH1.Add("I", "fehlende Wand");
+            CH1.Add("J", "Korrosionserscheinungen an der Oberfläche");
+            CH1.Add("K", "Blasen");
+            CH1.Add("Z", "andere Oberflächenschäden");
+
+            CH2.Add("A", "mechanisch");
+            CH2.Add("B", "chemisch - allgemein");
+            CH2.Add("C", "chemisch - Beschädigung im oberen Teil des Rohres");
+            CH2.Add("D", "chemisch - Beschädigung im unteren Teil des Rohres");
+            CH2.Add("E", "Ursache nicht eindeutig festellbar");
+            CH2.Add("Z", "andere Ursachen");
+        }
+
+     
+    }
+}

Schnittstelle/DWA149-2_2013/BAG.cs

@@ -0,0 +1,14 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAG : CodeBeschreibung
+    {
+        public BAG(RZustand kuerzel) : base("Einragender Anschluss", kuerzel)
+        {
+        }
+
+    
+    }
+}

Schnittstelle/DWA149-2_2013/BAH.cs

@@ -0,0 +1,18 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAH : CodeBeschreibung
+    {
+        public BAH(RZustand kuerzel) : base("Schadhafter Anschluss", kuerzel)
+        {
+            CH1.Add("A", "Lage des Anschlusses um das Rohr ist falsch");
+            CH1.Add("B", "Spalt zwischen dem Ende des Anschlusses und der Rohrleitung (Zurückliegende Anschluss)");
+            CH1.Add("C", "am Umfang des Anschlusses ist teilweise ein Spalt (Anschluss unvollständig eingebunden)");
+            CH1.Add("D", "Anschluss beschädigt");
+            CH1.Add("E", "Anschluss verstopft");
+            CH1.Add("Z", "Andere Schaden");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BAI.cs

@@ -0,0 +1,21 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAI : CodeBeschreibung
+    {
+        public BAI(RZustand kuerzel) : base("Einragendes Dichtungsmaterial", kuerzel)
+        {
+            CH1.Add("A", "Dichtring");
+            CH1.Add("Z", "andere Dichtungsart");
+
+            CH2.Add("A", "sichtbar verschoben, jedoch nicht in die Rohrleitung hineinragend");
+            CH2.Add("B", "einragend, aber nicht gebrochen - tiefster Punkt liegt oberhalb der horizontale Mittellinie");
+            CH2.Add("C", "einragend, aber nicht gebrochen - tiefster Punkt liegt unterhalb der horizontale Mittellinie");
+            CH2.Add("D", "einragend und gebrochen");
+        }
+
+ 
+    }
+}

Schnittstelle/DWA149-2_2013/BAJ.cs

@@ -0,0 +1,15 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAJ : CodeBeschreibung
+    {
+        public BAJ(RZustand kuerzel) : base("Verschobene Verbindung", kuerzel)
+        {
+            CH1.Add("A", "in längsrichtung");
+            CH1.Add("B", "radial");
+            CH1.Add("C", "im Winkel");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BAK.cs

@@ -0,0 +1,34 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAK : CodeBeschreibung
+    {
+        public BAK(RZustand kuerzel) : base("Feststellung der Innenauskleidung", kuerzel)
+        {
+            CH1.Add("A", "Innenauskleidung abgelöst");
+            CH1.Add("B", "Innenauskleidung verfärbt");
+            CH1.Add("C", "Endstelle der Auskleidung schadhaf");
+            CH1.Add("D", "Falten in der Auskleidung");
+            CH1.Add("E", "Blasen oder Beulen in der Auskleidung nach innen");
+            CH1.Add("F", "Beulen außen");
+            CH1.Add("G", "Ablösen der Innenhaut/Beschichtung");
+            CH1.Add("H", "Ablösen der Abdeckung der Verbindungsnaht");
+            CH1.Add("I", "Riss oder Spalt");
+            CH1.Add("J", "Loch in der Auskleidung");
+            CH1.Add("K", "Auskleidungsverbindung defekt");
+            CH1.Add("L", "Auskleidungswerkstoff erscheint weich");
+            CH1.Add("M", "Harz fehlt im Laminat");
+            CH1.Add("N", "Ende der Auskleidung ist nicht abgedichtet");
+            CH1.Add("Z", "anderer Auskleidungsschaden");
+
+            CH2.Add("A", "in Längsrichtung");
+            CH2.Add("B", "radial am Umfang");
+            CH2.Add("C", "komplex");
+            CH2.Add("D", "spiralförmig");
+        }
+
+ 
+    }
+}

Schnittstelle/DWA149-2_2013/BAL.cs

@@ -0,0 +1,27 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAL : CodeBeschreibung
+    {
+        public BAL(RZustand kuerzel) : base("Schadhafter Reparatur", kuerzel)
+        {
+            CH1.Add("A", "Wand fehlt teilweise");
+            CH1.Add("B", "Reparatur zur Abdichtung eines Loches ist schadhaft");
+            CH1.Add("C", "Ablösen des Reparaturwerkstoffs vom Basisrohr");
+            CH1.Add("D", "fehlender Reparaturwerkstoff an der Kontaktfläche");
+            CH1.Add("E", "überschüssiger Reparaturwerkstoff, der ein Hindernis darstellt");
+            CH1.Add("F", "Loch im Reparaturwerkstoff");
+            CH1.Add("G", "Riss im Reparaturwerkstoff");
+            CH1.Add("Z", "andere");
+
+            CH2.Add("A", "in Längsrichtung");
+            CH2.Add("B", "radial am Umfang");
+            CH2.Add("C", "komplex");
+            CH2.Add("D", "spiralförmig");
+        }
+
+    
+    }
+}

Schnittstelle/DWA149-2_2013/BAM.cs

@@ -0,0 +1,17 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAM : CodeBeschreibung
+    {
+        public BAM(RZustand kuerzel) : base("Schadhafter Schweißnaht", kuerzel)
+        {
+            CH1.Add("A", "in Längsrichtung");
+            CH1.Add("B", "am Umfang");
+            CH1.Add("C", "spiralförmiger Verlauf");
+        }
+
+   
+    }
+}

Schnittstelle/DWA149-2_2013/BAN.cs

@@ -0,0 +1,14 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAN : CodeBeschreibung
+    {
+        public BAN(RZustand kuerzel) : base("Poröses Rohr", kuerzel)
+        {
+        }
+
+ 
+    }
+}

Schnittstelle/DWA149-2_2013/BAO.cs

@@ -0,0 +1,14 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAO : CodeBeschreibung
+    {
+        public BAO(RZustand kuerzel) : base("Boden sichtbar", kuerzel)
+        {
+        }
+
+  
+    }
+}

Schnittstelle/DWA149-2_2013/BAP.cs

@@ -0,0 +1,12 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BAP : CodeBeschreibung
+    {
+        public BAP(RZustand kuerzel) : base("Hohlraum sichtbar", kuerzel)
+        {
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BBA.cs

@@ -0,0 +1,14 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BBA : CodeBeschreibung
+    {
+        public BBA(RZustand kuerzel) : base("Wurzeln", kuerzel)
+        {
+            CH1.Add("A", "Pfahlwurzel");
+            CH1.Add("B", "einzelne feine Wurzeln");
+            CH1.Add("C", "komplexes Wurzelwerk");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BBB.cs

@@ -0,0 +1,15 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BBB : CodeBeschreibung
+    {
+        public BBB(RZustand kuerzel) : base("Anhaftende Stoffe", kuerzel)
+        {
+            CH1.Add("A", "Inkrustation");
+            CH1.Add("B", "Fett");
+            CH1.Add("C", "Fäulnis");
+            CH1.Add("Z", "andere");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BBC.cs

@@ -0,0 +1,15 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BBC : CodeBeschreibung
+    {
+        public BBC(RZustand kuerzel) : base("Ablagerungen", kuerzel)
+        {
+            CH1.Add("A", "feines Material");
+            CH1.Add("B", "grobes Material");
+            CH1.Add("C", "hartes oder verdichtetes Material");
+            CH1.Add("Z", "andere");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BBD.cs

@@ -0,0 +1,16 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BBD : CodeBeschreibung
+    {
+        public BBD(RZustand kuerzel) : base("Eindringen von Bodenmaterial", kuerzel)
+        {
+            CH1.Add("A", "Sand");
+            CH1.Add("B", "Torf");
+            CH1.Add("C", "Feinmaterial");
+            CH1.Add("D", "Grobmaterial");
+            CH1.Add("Z", "andere");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BBE.cs

@@ -0,0 +1,20 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BBE : CodeBeschreibung
+    {
+        public BBE(RZustand kuerzel) : base("Andere Hindernisse", kuerzel)
+        {
+            CH1.Add("A", "Ziegel oder Mauerwerk liegen/liegt in der Rohrsohle");
+            CH1.Add("B", "Bruchstücke einer Abwasserleitung oder eines Abwasserkanals liegen in der \r\nRohrsohle");
+            CH1.Add("C", "anderer Gegenstand liegt in der Rohrsohle");
+            CH1.Add("D", "Gegenstand ragt durch die Wand ein");
+            CH1.Add("E", "Gegenstand in Rohrverbindung eingekeilt");
+            CH1.Add("F", "Gegenstand dringt durch einen Anschluss/Abzweig ein");
+            CH1.Add("G", "fremde Leitungen oder Kabel durchqueren die Rohrleitung");
+            CH1.Add("H", "Gegenstand/Objekt in den Rohrkörper eingebaut");
+            CH1.Add("Z", "andere");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BBF.cs

@@ -0,0 +1,15 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BBF : CodeBeschreibung
+    {
+        public BBF(RZustand kuerzel) : base("Infiltration", kuerzel)
+        {
+            CH1.Add("A", "Schwitzen");
+            CH1.Add("B", "Tropfen");
+            CH1.Add("C", "Fließen");
+            CH1.Add("D", "Spritzen");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BBG.cs

@@ -0,0 +1,11 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BBG : CodeBeschreibung
+    {
+        public BBG(RZustand kuerzel) : base("Exfiltration", kuerzel)
+        {
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BBH.cs

@@ -0,0 +1,19 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BBH : CodeBeschreibung
+    {
+        public BBH(RZustand kuerzel) : base("Ungeziefer", kuerzel)
+        {
+            CH1.Add("A", "Ratte");
+            CH1.Add("B", "Küchenschabe/Kakerlake");
+            CH1.Add("C", "andere");
+
+            CH2.Add("A", "in der Rohrleitung");
+            CH2.Add("B", "in einem Anschluss");
+            CH2.Add("C", "in einer offene Rohrverbindung");
+            CH2.Add("Z", "andere");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BCA.cs

@@ -0,0 +1,25 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using Schnittstelle.Sanierung;
+using System.Collections.Generic;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BCA : CodeBeschreibung
+    {
+        public BCA(RZustand kuerzel) : base("Anschluss", kuerzel)
+        {
+            CH1.Add("A", "Abzweig");
+            CH1.Add("B", "Sattelanschluss – gebohrt");
+            CH1.Add("C", "Sattelanschluss – gemeißelt");
+            CH1.Add("D", "einfacher Anschluss – gebohrt");
+            CH1.Add("E", "einfacher Anschluss – gemeißelt");
+            CH1.Add("F", "anderer Anschluss als ein Abzweig");
+            CH1.Add("G", "unbekannter Anschluss");
+            CH1.Add("Z", "andere");
+
+            CH2.Add("A", "offen");
+            CH2.Add("B", "geschlossen");
+
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BCB.cs

@@ -0,0 +1,19 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BCB : CodeBeschreibung
+    {
+        public BCB(RZustand kuerzel) : base("Punktuelle Reparatur", kuerzel)
+        {
+            CH1.Add("A", "Rohr ausgestauscht");
+            CH1.Add("B", "örtlich begrenzte Innenauskleidung des Rohrs");
+            CH1.Add("C", "Mörtelinjizierung");
+            CH1.Add("D", "Injizierung mit anderem Dichtmittel");
+            CH1.Add("E", "Loch repariert");
+            CH1.Add("F", "örtlich begrenzte Innenauskleidung des Anschlusses");
+            CH1.Add("G", "andere Reparatur des Anschlusses");
+            CH1.Add("Z", "anderes grabenloses Reparaturverfahren");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BCC.cs

@@ -0,0 +1,16 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BCC : CodeBeschreibung
+    {
+        public BCC(RZustand kuerzel) : base("Krümmung der Leitung", kuerzel)
+        {
+            CH1.Add("A", "nach links");
+            CH1.Add("B", "nach rechts");
+
+            CH2.Add("A", "nach oben");
+            CH2.Add("B", "nach unten");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BCD.cs

@@ -0,0 +1,11 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BCD : CodeBeschreibung
+    {
+        public BCD(RZustand kuerzel) : base("Anfangsknoten", kuerzel)
+        {
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BCE.cs

@@ -0,0 +1,18 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using Schnittstelle.Sanierung;
+using System.Collections.Generic;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BCE : CodeBeschreibung
+    {
+        List<SanierungMassnahme> renovation = new List<SanierungMassnahme>();
+
+        public BCE(RZustand kuerzel) : base("Endknoten", kuerzel)
+        {
+            
+        }
+
+        public List<SanierungMassnahme> Massnahmen => renovation;
+    }
+}

Schnittstelle/DWA149-2_2013/BDA.cs

@@ -0,0 +1,11 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BDA : CodeBeschreibung
+    {
+        public BDA(RZustand kuerzel) : base("Allgemeines Foto", kuerzel)
+        {
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BDB.cs

@@ -0,0 +1,11 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BDB : CodeBeschreibung
+    {
+        public BDB(RZustand kuerzel) : base("Allgemeine Anmerkung", kuerzel)
+        {
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BDC.cs

@@ -0,0 +1,22 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BDC : CodeBeschreibung
+    {
+        public BDC(RZustand kuerzel) : base("Inspektion endet vor dem Endknoten", kuerzel)
+        {
+            CH1.Add("A", "Hinderniss");
+            CH1.Add("B", "hoher Wasserstand");
+            CH1.Add("C", "Versagen der Ausrüstung");
+            CH1.Add("Z", "andere");
+
+            CH2.Add("A", "Inspektionsziel vor Erreichen des Endknotens erreicht");
+            CH2.Add("B", "Inspektion auf Anweisung des Auftraggebers abgebrochen");
+            CH2.Add("C", "ie Inspektion der Leitung/des Kanals ist bei Berücksichtigung einer früheren Teilinspektion abgeschlossen");
+            CH2.Add("D", "die Inspektion der Leitung/des Kanals ist bei Berücksichtigung einer früheren Teilinspektion nicht abgeschlossen");
+            CH2.Add("E", "es ist nicht bekannt, ob die Inspektion der gesamten Leitung bei Berücksichtigung einer früheren Teilinspektion abgeschlossen ist");
+            CH2.Add("Z", "andere");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BDD.cs

@@ -0,0 +1,16 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BDD : CodeBeschreibung
+    {
+        public BDD(RZustand kuerzel) : base("Wasserspiegel", kuerzel)
+        {
+            CH1.Add("A", "klar (Sohle sichtbar)");
+            CH1.Add("B", "Anwendung nicht fortgeführt");
+            CH1.Add("C", "trüb");
+            CH1.Add("D", "gefärbt");
+            CH1.Add("E", "trüb und gefärbt");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BDE.cs

@@ -0,0 +1,19 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BDE : CodeBeschreibung
+    {
+        public BDE(RZustand kuerzel) : base("Zufluss aus einem Anschluss", kuerzel)
+        {
+            CH1.Add("A", "klar (Sohle des Zuflusses sichtbar)");
+            CH1.Add("B", "Kode nicht fortgeführt");
+            CH1.Add("C", "trüb");
+            CH1.Add("D", "trüb und gefärbt");
+
+            CH2.Add("A", "falsch angeschlossen, da Schmutzwasser in Regenwasserleitung/-kanal abfließt");
+            CH2.Add("A", "falsch angeschlossen, da Regenwasser in Schmutzwasserleitung/-kanal abfließ");
+            CH2.Add("A", "kein Fehlanschluss erkennbar");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BDF.cs

@@ -0,0 +1,15 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BDF : CodeBeschreibung
+    {
+        public BDF(RZustand kuerzel) : base("Atmosphäre in der Leitung", kuerzel)
+        {
+            CH1.Add("A", "Sauerstoffmangel");
+            CH1.Add("B", "Schwefelwasserstoff");
+            CH1.Add("C", "Methan");
+            CH1.Add("Z", "andere");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/BDG.cs

@@ -0,0 +1,15 @@
+using Schnittstelle.Import.XML.v2013.Model;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class BDG : CodeBeschreibung
+    {
+        public BDG(RZustand kuerzel) : base("Keine Sicht", kuerzel)
+        {
+            CH1.Add("A", "Kamera unter Wasser");
+            CH1.Add("B", "Verschlammung");
+            CH1.Add("C", "Dämpfe");
+            CH1.Add("Z", "andere");
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/CodeBeschreibung.cs

@@ -0,0 +1,38 @@
+using Schnittstelle.Contract;
+using Schnittstelle.Import.XML.v2013.Model;
+using Schnittstelle.Sanierung;
+using System.Collections.Generic;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    abstract class CodeBeschreibung : ICodeBeschreibung
+    {
+        string beschreibung;
+        protected Dictionary<string, string> CH1 = new Dictionary<string, string>() {
+            { "Y", "nicht erkennbar" }
+        };
+        protected Dictionary<string, string> CH2 = new Dictionary<string, string>() {
+            { "Y", "nicht erkennbar" }
+        };
+        private readonly RZustand kuerzel;
+
+        protected CodeBeschreibung(string CodeBeschreibung, RZustand kuerzel)
+        {
+            this.beschreibung = CodeBeschreibung;
+            this.kuerzel = kuerzel;
+        }
+
+        public virtual string GetBeschreibung
+        {
+            get
+            {
+                string beschreibung = this.beschreibung;
+                string ch1 = "";
+                string ch2 = "";
+                if(kuerzel.Charakterisierung1 != null) CH1.TryGetValue(kuerzel.Charakterisierung1, out ch1);
+                if (kuerzel.Charakterisierung2 != null) CH2.TryGetValue(kuerzel.Charakterisierung2 , out ch2);
+                return string.Format("{0} {1} {2}", beschreibung, ch1,ch2);
+            }
+        }
+    }
+}

Schnittstelle/DWA149-2_2013/DWA149-2_2013Factory.cs

@@ -0,0 +1,65 @@
+using Schnittstelle.Contract;
+using Schnittstelle.Import.XML.v2013.Model;
+using System;
+using System.Collections.Generic;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Schnittstelle.DWA149_2_2013
+{
+    class DWA149_2_2013Factory
+    {
+        public ICodeBeschreibung GetCodeBeschreibung(RZustand zustand)
+        {
+            switch(zustand.Inspektionskode.ToUpper())
+            {
+                case "AED": return new AED(zustand);
+                case "AEC": return new AEC(zustand);
+
+                case "BAA": return new BAA(zustand);
+                case "BAB": return new BAB(zustand);
+                case "BAC": return new BAC(zustand);
+                case "BAD": return new BAD(zustand);
+                case "BAE": return new BAE(zustand);
+                case "BAF": return new BAF(zustand);
+                case "BAG": return new BAG(zustand);
+                case "BAH": return new BAH(zustand);
+                case "BAI": return new BAI(zustand);
+                case "BAJ": return new BAJ(zustand);
+                case "BAK": return new BAK(zustand);
+                case "BAL": return new BAL(zustand);
+                case "BAM": return new BAM(zustand);
+                case "BAN": return new BAN(zustand);
+                case "BAO": return new BAO(zustand);
+                case "BAP": return new BAP(zustand);
+
+                case "BBA": return new BBA(zustand);
+                case "BBB": return new BBB(zustand);
+                case "BBC": return new BBC(zustand);
+                case "BBD": return new BBD(zustand);
+                case "BBE": return new BBE(zustand);
+                case "BBF": return new BBF(zustand);
+                case "BBG": return new BBG(zustand);
+                case "BBH": return new BBH(zustand);
+
+                case "BCA": return new BCA(zustand);
+                case "BCB": return new BCB(zustand);
+                case "BCC": return new BCC(zustand);
+                case "BCD": return new BCD(zustand);
+                case "BCE": return new BCE(zustand);
+
+                case "BDA": return new BDA(zustand);
+                case "BDB": return new BDB(zustand);
+                case "BDC": return new BDC(zustand);
+                case "BDD": return new BDD(zustand);
+                case "BDE": return new BDE(zustand);
+                case "BDF": return new BDF(zustand);
+                case "BDG": return new BDG(zustand);
+
+                default:
+                    throw new NotImplementedException(string.Format("Code not implemented: {0}",zustand.Inspektionskode.ToUpper()));
+            }
+        }
+        
+    }
+}

Schnittstelle/Export/Excel.cs

@@ -0,0 +1,367 @@
+using Schnittstelle.Import.XML.v2013.Model;
+using Schnittstelle.Sanierung;
+using Syncfusion.Drawing;
+using Syncfusion.XlsIO;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Schnittstelle.Export
+{
+    public static class Excel
+    {
+        const string LizenceKey = "Ngo9BigBOggjHTQxAR8/V1NCaF5cXmZCf1FpRmJGdld5fUVHYVZUTXxaS00DNHVRdkdnWXdccXRQQ2NZWEBxWUM=";
+        public static void MakeWorkbook(List<KanalObjekt> KanalObjekte, List<Sanierungart> sanierungsarten)
+        {
+            Syncfusion.Licensing.SyncfusionLicenseProvider.RegisterLicense(LizenceKey);
+            ExcelEngine excelEngine = new ExcelEngine();
+            IApplication application = excelEngine.Excel;
+
+            application.DefaultVersion = ExcelVersion.Xlsx;
+            IWorkbook workbook = application.Workbooks.Create(KanalObjekte.Count);
+            IStyle CellStyle = workbook.Styles.Add("MainStyle");
+
+            CellStyle.Borders[ExcelBordersIndex.EdgeLeft].LineStyle = ExcelLineStyle.Thin;
+            CellStyle.Borders[ExcelBordersIndex.EdgeRight].LineStyle = ExcelLineStyle.Thin;
+            CellStyle.Borders[ExcelBordersIndex.EdgeTop].LineStyle = ExcelLineStyle.Thin;
+            CellStyle.Borders[ExcelBordersIndex.EdgeBottom].LineStyle = ExcelLineStyle.Thin;
+
+            IStyle HeaderStyle = workbook.Styles.Add("HeaderStyle");
+
+            HeaderStyle.Borders[ExcelBordersIndex.EdgeLeft].LineStyle = ExcelLineStyle.Thin;
+            HeaderStyle.Borders[ExcelBordersIndex.EdgeRight].LineStyle = ExcelLineStyle.Thin;
+            HeaderStyle.Borders[ExcelBordersIndex.EdgeTop].LineStyle = ExcelLineStyle.Thin;
+            HeaderStyle.Borders[ExcelBordersIndex.EdgeBottom].LineStyle = ExcelLineStyle.Thin;
+            HeaderStyle.Font.Bold = true;
+
+            IStyle KodierungEnde = workbook.Styles.Add("KodierungEndestyleStyle");
+
+            KodierungEnde.Borders[ExcelBordersIndex.EdgeLeft].LineStyle = ExcelLineStyle.Thin;
+            KodierungEnde.Borders[ExcelBordersIndex.EdgeRight].LineStyle = ExcelLineStyle.Thin;
+            KodierungEnde.Borders[ExcelBordersIndex.EdgeTop].LineStyle = ExcelLineStyle.Thin;
+            KodierungEnde.Borders[ExcelBordersIndex.EdgeBottom].LineStyle = ExcelLineStyle.Thick;
+
+            IStyle AnmerkungStyle = workbook.Styles.Add("AnmerkungStyle");
+            AnmerkungStyle.ColorIndex = ExcelKnownColors.Custom56;
+            
+            AnmerkungStyle.Borders.LineStyle = ExcelLineStyle.Medium;
+            AnmerkungStyle.Borders[ExcelBordersIndex.DiagonalUp].ShowDiagonalLine = false;
+            AnmerkungStyle.Borders[ExcelBordersIndex.DiagonalDown].ShowDiagonalLine = false;
+
+
+
+
+            for (int i = 0; i < KanalObjekte.Count; i++)
+            {
+                IWorksheet worksheet = workbook.Worksheets[i];
+                KanalObjekt k = KanalObjekte[i];
+                CalculateHaltung(k, worksheet, sanierungsarten, CellStyle, HeaderStyle, KodierungEnde,AnmerkungStyle);
+            }
+            FileStream stream = new FileStream("beurteilung.xlsx", FileMode.Create, FileAccess.ReadWrite);
+            workbook.SaveAs(stream);
+            stream.Dispose();
+        }
+
+        private static void CalculateHaltung(KanalObjekt haltung, IWorksheet worksheet, List<Sanierungart> sanierungsarten, IStyle cellStyle, IStyle headerStyle, IStyle kodierungEnde, IStyle AnmerkungStyle)
+        {
+
+            worksheet.Name = string.Format("{0}", haltung.Stammdaten.Objektbezeichnung);
+
+            int row = 1;
+
+            for (int i = 0; i < sanierungsarten.Count; i++)
+            {
+                Sanierungart sanArt = sanierungsarten[i];
+                int mainrow = row;
+                worksheet.Range[row, 1].Text = "Von - Nach";
+                worksheet.Range[row, 2].Text = "Straße"; // 5
+                worksheet.Range[row, 3].Text = "Inspizierte Länge"; // 4
+                worksheet.Range[row, 4].Text = "Länge"; // 2
+                worksheet.Range[row, 5].Text = "Tiefe"; // 3
+                worksheet.Range[row, 6].Text = "Inspektionsrichtung";
+
+
+                worksheet.Range[row, 7].Text = "Schadensbeschreibung"; //sanArt.Sanierungsbezeichnung;
+                worksheet.Range[row, 9].Text = "Durchmesser";
+                worksheet.Range[row, 10].Text = "Material";
+
+                row++;
+                string richtung = haltung.Inspektionsdaten.OptischeInspektion[0].Rohrleitung.Inspektionsrichtung_RAW;
+                string s1 = richtung == "O" ? haltung.Stammdaten.Kante.KnotenZulauf!.Objektbezeichnung : haltung.Stammdaten.Kante.KnotenAblauf!.Objektbezeichnung;
+                string s2 = richtung == "O" ? haltung.Stammdaten.Kante.KnotenAblauf!.Objektbezeichnung : haltung.Stammdaten.Kante.KnotenZulauf!.Objektbezeichnung;
+                worksheet.Range[row, 1].Text = string.Format("{0} -> {1}", s1, s2);
+                worksheet.Range[row, 2].Text = haltung.Inspektionsdaten.Lage.Strassename;
+
+                worksheet.Range[row, 4].Text = haltung.Stammdaten.Kante.Laenge.ToString(); // Länge
+                worksheet.Range[row, 5].Text = "Not Implemented yet"; // Tiefe 
+                worksheet.Range[row, 6].Text = haltung.Inspektionsdaten.OptischeInspektion[0].Rohrleitung.Inspektionsrichtung;
+
+                
+                worksheet.Range[row, 9].Text = haltung.Inspektionsdaten.OptischeInspektion[0].Rohrleitung.Grunddaten.Profilbreite.ToString();
+                worksheet.Range[row, 10].Text = haltung.Inspektionsdaten.OptischeInspektion[0].Rohrleitung.Grunddaten.Material.ToString();
+
+                worksheet.Range[mainrow, 1, mainrow, 10].CellStyle = headerStyle;
+                worksheet.Range[row,1,row,10].CellStyle = cellStyle;
+
+
+                row += 2;
+                //worksheet.Range[row, 2].Text = sanArt.Sanierungsbezeichnung;
+                //row+= 2;
+                //int temprow = row;
+                worksheet.Range[row, 1].Text = "Station";
+                worksheet.Range[row, 2].Text = "Kürzel";
+                worksheet.Range[row, 3].Text = "Charakterisi.";
+                worksheet.Range[row, 4].Text = "Quantifizierung";
+                worksheet.Range[row, 5].Text = "Lage im Kreis";
+                //worksheet.Range[row, 6].Text = "Verb.";
+                worksheet.Range[row, 7].Text = "Schadensbeschreibung / Info";
+                worksheet.Range[row, 8].Text = "Strecke";
+                worksheet.Range[row, 9].Text = "Sanierungsvorschlag";
+                worksheet.Range[row, 10].Text = "Kostenans.";
+
+                worksheet.Range[row, 1, row,10].CellStyle=headerStyle;
+
+                //08950738
+
+                row++;
+                int temprow = row;
+                int codestart_row = row;
+                //int rows = 7;
+                decimal inspizierteLaenge = 0m;
+                //if(haltung.Stammdaten.Objektbezeichnung.Equals("08950738")) Debugger.Break();
+                int anzahlInspektionen = haltung.Inspektionsdaten.OptischeInspektion.Count-1;
+                for (int j = 0; j < anzahlInspektionen+1; j++)
+                {
+                    OptischeInspektion opt = haltung.Inspektionsdaten.OptischeInspektion[j];
+                    inspizierteLaenge += opt.Rohrleitung.Zustaende.Max(x => x.Station);
+                    foreach (RZustand code in opt.Rohrleitung.Zustaende)
+                    {
+                        worksheet.Range[row + j, 1].Text = code.Station.ToString();
+                        worksheet.Range[row + j, 2].Text = code.Inspektionskode;
+                        string ch = "";
+                        if (code.Charakterisierung1 != null)
+                            ch = code.Charakterisierung1;
+                        if (code.Charakterisierung2 != null)
+                            ch = string.Format("{0} / {1}", ch, code.Charakterisierung2);
+                        worksheet.Range[row + j, 3].Text = ch;
+
+                        worksheet.Range[row + j, 4].Text = code.Quantifizierung1.ToString();
+
+                        string pos = "";
+                        if (code.PositionVon != 0)
+                            pos = code.PositionVon.ToString();
+                        if (code.PositionBis != 0)
+                            pos = string.Format("{0} - {1}", pos, code.PositionBis);
+                        worksheet.Range[row + j, 5].Text = pos;
+
+                        if (code.Verbindung)
+                            worksheet.Range[row + j, 6].Text = "JA";
+
+                        worksheet.Range[row + j, 7].Text = code.KodeDescription;
+                        worksheet.Range[row + j, 8].Text = code.Streckenschaden;
+
+                        
+                        List<SanierungMassnahme> Massnahmen;
+
+                        Console.WriteLine(code.Inspektionskode);
+                        
+
+                        if (sanArt.Massnahmen.TryGetValue(code.Inspektionskode, out Massnahmen))
+                        {
+                            List<SanierungMassnahme> imasses = Massnahmen.FindAll(x =>
+                                haltung.Inspektionsdaten.OptischeInspektion[0].Rohrleitung.Grunddaten.Profilbreite >=
+                                x.DN);
+
+                            uint counter = 0;
+                            decimal Kosten = 0;
+                            bool Schlauchliner = false;
+                            foreach (SanierungMassnahme imas in imasses)
+                            {
+                                if(CheckKuerzel(imas.Begrenzung, code))
+                                {
+                                    Kosten += imas.Kosten;
+                                    if(counter == 0)
+                                        worksheet.Range[row + j, 9].Text += imas.Beschreibung;
+                                    else
+                                        worksheet.Range[row + j, 9].Text += "," + imas.Beschreibung;
+
+                                    if (imas.Beschreibung.Equals("Schlauchliner"))
+                                    {
+                                        Schlauchliner = true;
+                                        decimal zuschlag = 1;
+                                        decimal tmpLaenge = haltung.Stammdaten.Kante.Laenge;
+                                        if (tmpLaenge < 30)
+                                            zuschlag = 1.3m;
+                                        if (tmpLaenge < 15)
+                                            zuschlag = 1.5m;
+                                        worksheet.Range[row + j, 10].Number = Convert.ToDouble((imas.Kosten * zuschlag) * tmpLaenge);
+                                        break;
+                                    }
+                                }
+                                counter++;
+                            }
+                            if(!Schlauchliner)
+                            {
+                                worksheet.Range[row + j, 10].Number = Convert.ToDouble(Kosten);
+                            }
+                            
+                            if (imasses != null)
+                            {
+                                /*
+                                worksheet.Range[row + j, 9].Text = imass.Beschreibung;
+
+                                if (imass.Beschreibung.Equals("Schlauchliner"))
+                                {
+                                    double zuschlag = 1;
+                                    double tmpLaenge = Convert.ToDouble(haltung.Stammdaten.Kante.Laenge);
+                                    if (tmpLaenge < 30)
+                                        zuschlag = 1.3;
+                                    if (tmpLaenge < 15)
+                                        zuschlag = 1.5;
+                                    worksheet.Range[row + j, 10].Number = (imass.Kosten * zuschlag) * tmpLaenge;
+
+                                }
+                                else
+                                    worksheet.Range[row + j, 10].Number = imass.Kosten;
+                                */
+                            }
+                        }
+                        
+                        row++;
+                    }
+                }
+                row += anzahlInspektionen;
+                worksheet.Range[temprow, 1, row-1, 10].CellStyle = cellStyle;
+                worksheet.Range[row-1, 1, row-1, 10].CellStyle = kodierungEnde;
+                temprow = row;
+                worksheet.Range[row, 7].Text = "netto-Zwischensumme";
+                worksheet.Range[row, 10].Formula = string.Format("=SUM(J{0}:J{1})", codestart_row, row-1);
+                row++;
+
+                //Linke seite
+                worksheet.Range[row, 1].Text =sanArt.Sanierungsbezeichnung.ToString();
+                // Auflistung
+                worksheet.Range[row, 7].Text = "Baustelleneinrichtung anteilig Haltung"; //10%
+                worksheet.Range[row, 8].Number = 10;
+                worksheet.Range[row, 10].Formula = string.Format("=(H{0}/100)*J{1}", row, temprow);
+                row++;
+                worksheet.Range[row, 7].Text = "Verkehrssicherung anteilig Haltung"; // 5%
+                worksheet.Range[row, 8].Number = 5;
+                worksheet.Range[row, 10].Formula = string.Format("=(H{0}/100)*J{1}", row, temprow);
+                row++;
+                // Linke seite
+                worksheet.Range[row, 1].CellStyle = headerStyle;
+                worksheet.Range[row, 1].Text = "Sanierungspriorität";
+                worksheet.Range[row, 3].CellStyle = headerStyle;
+                worksheet.Range[row, 3].Text = "Info";
+                // Auflistung
+                worksheet.Range[row, 7].Text = "Aufrechterhaltung der Vorflut Haltung"; // 12%
+                worksheet.Range[row, 8].Number = 12;
+                worksheet.Range[row, 10].Formula = string.Format("=(H{0}/100)*J{1}", row, temprow);
+                row++;
+                // Linke seite
+                worksheet.Range[row, 1].Text = "kurzfristing";
+                worksheet.Range[row, 2].Text = "ja oder nein";
+                worksheet.Range[row, 3].Text = "6-12 Monate";
+                worksheet.Range[row, 1, row, 3].CellStyle = cellStyle;
+                // Auflistung
+                worksheet.Range[row, 7].Text = "Kanalreinigung vor Sanierung"; // 2€ /m
+                worksheet.Range[row, 8].Number = Convert.ToDouble(inspizierteLaenge);
+                worksheet.Range[row, 9].Number = 2;
+                worksheet.Range[row, 10].Formula = string.Format("=H{0}*I{0}", row);
+                row++;
+                // Linke seite
+                worksheet.Range[row, 1].Text = "mittelfristig";
+                worksheet.Range[row, 2].Text = "ja oder nein";
+                worksheet.Range[row, 3].Text = "1 bis 5 Jahre";
+                worksheet.Range[row, 1, row, 3].CellStyle = cellStyle;
+                // Auflistung
+                worksheet.Range[row, 7].Text = "Kamerainspektion Abnahme"; // 3€ /m
+                worksheet.Range[row, 8].Number = Convert.ToDouble(inspizierteLaenge);
+                worksheet.Range[row, 9].Number = 3;
+                worksheet.Range[row, 10].Formula = string.Format("=H{0}*I{0}", row);
+                row++;
+                // Linke seite
+                worksheet.Range[row, 1].Text = "langfristig";
+                worksheet.Range[row, 2].Text = "ja oder nein";
+                worksheet.Range[row, 3].Text = "5 bis 10 Jahre";
+                worksheet.Range[row, 1, row, 3].CellStyle = cellStyle;
+                // Auflistung
+                worksheet.Range[row, 7].Text = "Summe netto Haltung";
+                worksheet.Range[row, 10].Formula = string.Format("=SUM(J{0}:J{1})",temprow,row-1);
+                row++;
+                worksheet.Range[row, 7].Text = "Mehrwertsteuer"; // 19%
+                worksheet.Range[row, 8].Number = 19;
+                worksheet.Range[row, 10].Formula = string.Format("=(H{0}/100)*J{1}",row,row-1);
+                row++;
+                // Linke seite
+                worksheet.Range[row, 1].Text = "Sanierung im Verbund";
+                worksheet.Range[row, 2].Text = "ja oder nein";
+                worksheet.Range[row, 1, row, 2].CellStyle = cellStyle;
+                // Auflistung
+                worksheet.Range[row, 7].Text = "Summe brutto Haltung";
+                worksheet.Range[row, 10].Formula = string.Format("=SUM(J{0}:J{1})", row - 1, row - 2);
+
+                worksheet.Range[temprow, 7, row, 10].CellStyle = cellStyle;
+
+                worksheet.Range[mainrow+1, 3].Text = inspizierteLaenge.ToString();
+                row += 5;
+            }
+
+            row -= 3;
+
+            worksheet.Range[row, 1].Text = "Haltungsbewertung:";
+            worksheet.Range[row + 1, 1, row + 4, 5].Merge();
+            worksheet.Range[row + 1, 1, row + 4, 5].CellStyle.Color = ColorTranslator.FromHtml("#FCE4D6");
+            row += 6;
+            worksheet.Range[row, 1].Text = "Sanierungsempfehlung:";
+
+            row += 2;
+            worksheet.Range[row, 1].Text = "Hinweis:";
+            
+            
+            row++;
+            worksheet.Range[row, 1].Text = "TV-Befahrung:";
+            worksheet.Range[row, 2].Text = "Sohle sichtbar:";
+            worksheet.Range[row, 4].Text = "% Wasser in der Sohle";
+            worksheet.UsedRange.AutofitColumns();
+            worksheet.Range[string.Format("J1:J{0}", row)].NumberFormat = "_(€* #,##0_)"; // "€ #,##0";
+
+            row += 3;
+
+            
+        }
+
+        private static bool CheckKuerzel(string begrenzung, RZustand code)
+        {
+            string[] begrenzungs = begrenzung.Split(':');
+            string ch1 = begrenzungs[1];
+            string ch2 = begrenzungs[2];
+
+            bool check1 = false;
+            bool check2 = false;
+            if(ch1 != "-")
+            {
+                check1 = ch1 == code.Charakterisierung1;
+            }
+            else
+            {
+                check1 = true;
+            }
+
+            if (ch2 != "-")
+            {
+                check2 = ch2 == code.Charakterisierung2;
+            }
+            else
+            {
+                check2 = true;
+            }
+            return check1 && check2;
+        }
+    }
+}

Schnittstelle/Import/XML/v2013/Model/Geometriedaten.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Text;
 
 namespace Schnittstelle.Import.XML.v2013.Model
 {
@@ -6,6 +7,10 @@ namespace Schnittstelle.Import.XML.v2013.Model
     {
         List<PolyKante> kanten;
 
+        private Geometriedatenknoten knoten;
+        
+        public Geometriedatenknoten Knoten { get => knoten; set => knoten = value; }
+
         public List<PolyKante> Kanten
         {
             get
@@ -18,4 +23,24 @@ namespace Schnittstelle.Import.XML.v2013.Model
             }
         }
     }
+
+    public class Geometriedatenknoten
+    {
+        private List<Punkt> punkt = new List<Punkt>();
+        
+        public List<Punkt> Punkt { get => punkt; set => punkt = value; }
+    }
+
+    public class Punkt
+    {
+        private decimal rechtswert;
+        private decimal hochwert;
+        private decimal punkthoehe;
+        private string punktattributabwasser;
+        
+        public decimal Rechtswert { get => rechtswert; set => rechtswert = value; }
+        public decimal Hochwert { get => hochwert; set => hochwert = value; }
+        public decimal Punkthoehe { get => punkthoehe; set => punkthoehe = value; }
+        public string PunktattributeAbwasser { get => punktattributabwasser; set => punktattributabwasser = value; }
+    }
 }

Schnittstelle/Import/XML/v2013/Model/InspizierteAbwassertechnischeAnlage.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 namespace Schnittstelle.Import.XML.v2013.Model
 {
     public sealed class InspizierteAbwassertechnischeAnlage
@@ -5,7 +7,7 @@ namespace Schnittstelle.Import.XML.v2013.Model
         string objektbezeichnung;
         Lage lage;
         EAnlagetyp anlagentyp;
-        OptischeInspektion optischeInspektion;
+        List<OptischeInspektion> optischeInspektion = new List<OptischeInspektion>();
 
         public string Objektbezeichnung
         {
@@ -29,7 +31,7 @@ namespace Schnittstelle.Import.XML.v2013.Model
                 anlagentyp = value;
             }
         }
-        public OptischeInspektion OptischeInspektion
+        public List<OptischeInspektion> OptischeInspektion
         {
             get
             {
@@ -53,7 +55,7 @@ namespace Schnittstelle.Import.XML.v2013.Model
         }
         public override string ToString()
         {
-            return objektbezeichnung + " " + optischeInspektion.Rohrleitung.Grunddaten.Profilbreite;
+            return objektbezeichnung + " " + optischeInspektion[0].Rohrleitung.Grunddaten.Profilbreite;
         }
     }
 }

Schnittstelle/Import/XML/v2013/Model/KanalObjekt.cs

@@ -7,7 +7,7 @@ namespace Schnittstelle.Import.XML.v2013.Model
         public InspizierteAbwassertechnischeAnlage Inspektionsdaten { get; set; }
         public override string ToString()
         {
-            return string.Format("{0} ({1})",Stammdaten.Objektbezeichnung, Inspektionsdaten.OptischeInspektion.Rohrleitung != null ? Inspektionsdaten.OptischeInspektion.Rohrleitung.Grunddaten.Profilbreite: 0);
+            return string.Format("{0} ({1})",Stammdaten.Objektbezeichnung, Inspektionsdaten.OptischeInspektion[0].Rohrleitung != null ? Inspektionsdaten.OptischeInspektion[0].Rohrleitung.Grunddaten.Profilbreite: 0);
         }
     }
 }

Schnittstelle/Import/XML/v2013/Model/Kante.cs

@@ -4,23 +4,27 @@ namespace Schnittstelle.Import.XML.v2013.Model
     {
         decimal sohlhoeheZulauf;
         decimal sohlhoeheAblauf;
-        Knoten? knotenZulauf;
+        decimal laenge;
-        Knoten? knotenAblauf;
+        AbwassertechnischeAnlage? knotenZulauf;
+        AbwassertechnischeAnlage? knotenAblauf;
         int knotenAblaufTyp;
         int knotenZulaufTyp;
         bool isFiktiveLeitung = true;
         Profil profil;
+        private string material;
 
         public string knotenZulaufTemp;
         public string knotenAblaufTemp;
 
         public decimal SohlhoeheZulauf { get => sohlhoeheZulauf; set => sohlhoeheZulauf = value; }
         public decimal SohlhoeheAblauf { get => sohlhoeheAblauf; set => sohlhoeheAblauf = value; }
-        public Knoten? KnotenZulauf { get => knotenZulauf; set => knotenZulauf = value; }
+        public AbwassertechnischeAnlage? KnotenZulauf { get => knotenZulauf; set => knotenZulauf = value; }
-        public Knoten? KnotenAblauf { get => knotenAblauf; set => knotenAblauf = value; }
+        public AbwassertechnischeAnlage? KnotenAblauf { get => knotenAblauf; set => knotenAblauf = value; }
         public int KnotenAblaufTyp { get => knotenAblaufTyp; set => knotenAblaufTyp = value; }
         public int KnotenZulaufTyp { get => knotenZulaufTyp; set => knotenZulaufTyp = value; }
         public bool IsFiktiveLeitung { get => isFiktiveLeitung; set => isFiktiveLeitung = value; }
         public Profil Profil { get => profil; set => profil = value; }
+        public decimal Laenge { get => laenge; set => laenge = value; }
+        public string Material { get => material; set => material = value; }
     }
 }

Schnittstelle/Import/XML/v2013/Model/RZustand.cs

@@ -1,3 +1,6 @@
+using Schnittstelle.Sanierung;
+using System.Collections.Generic;
+
 namespace Schnittstelle.Import.XML.v2013.Model
 {
     public struct Quantifizierung
@@ -29,7 +32,8 @@ namespace Schnittstelle.Import.XML.v2013.Model
         int positionBis;
         string kommentar;
         Klassifizierung? klassifizierung;
-
+        string kodeDescription;
+        
         public decimal Station { get => station; set => station = value; }
         public string Inspektionskode { get => inspektionskode; set => inspektionskode = value; }
         public string Charakterisierung1 { get => charakterisierung1; set => charakterisierung1 = value; }
@@ -43,5 +47,6 @@ namespace Schnittstelle.Import.XML.v2013.Model
         public int PositionBis { get => positionBis; set => positionBis = value; }
         public string Kommentar { get => kommentar; set => kommentar = value; }
         public Klassifizierung? Klassifizierung { get => klassifizierung; set => klassifizierung = value; }
+        public string KodeDescription { get => kodeDescription; set => kodeDescription = value; }
     }
 }

Schnittstelle/Import/XML/v2013/Model/Rohrleitung.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Schnittstelle.Import.XML.v2013.Model
 {
@@ -34,6 +35,12 @@ namespace Schnittstelle.Import.XML.v2013.Model
                 inspektionslaenge = value;
             }
         }
+
+        public string Inspektionsrichtung_RAW
+        {
+            get => inspektionsrichtung;
+        }
+
         public string Inspektionsrichtung
         {
             get

Schnittstelle/Import/XML/v2013/XML2013.cs

@@ -1,7 +1,10 @@
 using Schnittstelle.Contract;
+using Schnittstelle.DWA149_2_2013;
 using Schnittstelle.Import.XML.v2013.Model;
+using Schnittstelle.Sanierung;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -10,6 +13,12 @@ using System.Xml;
 
 namespace Schnittstelle.Import.XML.v2013
 {
+
+    public class NotZustandException: Exception
+    {
+
+    }
+
     public class XML2013 : ISchnittstelleImporter
     {
         private string xmlFile = "";
@@ -33,6 +42,22 @@ namespace Schnittstelle.Import.XML.v2013
             RebuildStammdaten();
         }
 
+        private static decimal ConvertXMLToDecimal(string input)
+        {
+            string str = string.Empty;
+            if(input.Contains('.'))
+            {
+                str = input.Replace('.', ',');
+            }
+            else
+            {
+                str = input;
+            }
+
+            if (decimal.TryParse(str, out decimal result)) return result;
+            else return new decimal();
+        }
+
         private void RebuildStammdaten()
         {
             // liste an knoten
@@ -41,15 +66,15 @@ namespace Schnittstelle.Import.XML.v2013
             while (QueueToRebuild.Count > 0)
             {
                 AbwassertechnischeAnlage anlage = QueueToRebuild.Dequeue();
-                anlage.Kante.KnotenZulauf = knoten.First(x => x.Objektbezeichnung.Equals(anlage.Kante.knotenZulaufTemp)).Knoten;
+                anlage.Kante.KnotenZulauf = knoten.First(x => x.Objektbezeichnung.Equals(anlage.Kante.knotenZulaufTemp));
-                var d = knoten.FirstOrDefault(x => x.Objektbezeichnung.Equals(anlage.Kante.knotenAblaufTemp));
+                AbwassertechnischeAnlage? d = knoten.FirstOrDefault(x => x.Objektbezeichnung.Equals(anlage.Kante.knotenAblaufTemp));
                 if (d == null)
                 {
                     notFoundKnoten.Add(anlage.Kante.knotenAblaufTemp);
                 }
                 else
                 {
-                    anlage.Kante.KnotenAblauf = d.Knoten;
+                    anlage.Kante.KnotenAblauf = d;
                 }     
             }
         }
@@ -59,9 +84,10 @@ namespace Schnittstelle.Import.XML.v2013
             Tuple<List<AbwassertechnischeAnlage>, List<InspizierteAbwassertechnischeAnlage>> src = LoadRawFile();
             stammdaten = src.Item1;
             inspektionsdaten = src.Item2;
+            if (inspektionsdaten.Count == 0) Console.WriteLine("Keine Inspektionsdaten gefunden in der XML");
             foreach (InspizierteAbwassertechnischeAnlage iat in inspektionsdaten)
             {
-                AbwassertechnischeAnlage stammdatens = stammdaten.Find(x => x.Objektbezeichnung.Equals(iat.Objektbezeichnung));//;
+                AbwassertechnischeAnlage stammdatens = stammdaten.Find(x => x.Objektbezeichnung.Equals(iat.Objektbezeichnung) && x.ObjektArt.Equals(EObjektArt.KANTE));//;
                 string[] filepathsplited = this.XmlFile.Split(Path.DirectorySeparatorChar);
 
                 KanalObjekte.Add(new KanalObjekt()
@@ -81,26 +107,59 @@ namespace Schnittstelle.Import.XML.v2013
             if (!File.Exists(XmlFile)) throw new FileNotFoundException(string.Format("XML Datei mit den Pfad {0} wurde nicht gefunden", XmlFile));
             XmlDocument doc = new XmlDocument();
             doc.Load(XmlFile);
+            string xmlNameSpace = doc.DocumentElement.NamespaceURI;
             rootChild = doc.LastChild;
 
             manager = new XmlNamespaceManager(doc.NameTable);
-            manager.AddNamespace("e", "http://www.ofd-hannover.la/Identifikation");
+            
+            manager.AddNamespace("e", xmlNameSpace);
             rootChild = rootChild.SelectSingleNode("//e:Datenkollektive", manager);
 
             Stammdaten = LoadStammdatenCollectiv();
-            Inspektionsdaten = LoadInspektionsdatenCollectiv();
+            try
+            {
+                Inspektionsdaten = LoadInspektionsdatenCollectiv();
+            }
+            catch (NotZustandException ex)
+            {
+                Inspektionsdaten = new List<InspizierteAbwassertechnischeAnlage>();
+            }
             return new Tuple<List<AbwassertechnischeAnlage>, List<InspizierteAbwassertechnischeAnlage>>(Stammdaten, Inspektionsdaten);
         }
 
         private List<InspizierteAbwassertechnischeAnlage> LoadInspektionsdatenCollectiv()
         {
             List<InspizierteAbwassertechnischeAnlage> result = new List<InspizierteAbwassertechnischeAnlage>();
+
+            bool found = false;
+            
+            foreach(XmlNode childNode in rootChild.ChildNodes)
+            {
+                if(childNode.Name.Equals("Zustandsdatenkollektiv"))
+                {
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found) throw new NotZustandException();
+            
             XmlNode zstdk = rootChild.SelectSingleNode("//e:Zustandsdatenkollektiv", manager);
             XmlNodeList Inspektionsdaten = zstdk.SelectNodes("//e:InspizierteAbwassertechnischeAnlage", manager);
 
             foreach (XmlNode node in Inspektionsdaten)
             {
-                result.Add(ParseInspektion(node));
+                var parsedInspektion = ParseInspektion(node);
+                var src = result.Find(x => x.Objektbezeichnung == parsedInspektion.Objektbezeichnung);
+
+                if (src != null)
+                {
+                    src.OptischeInspektion.Add(parsedInspektion.OptischeInspektion[0]);
+                }
+                else
+                {
+                    result.Add(parsedInspektion);
+                }
             }
 
             return result;
@@ -133,7 +192,8 @@ namespace Schnittstelle.Import.XML.v2013
                         }
                         result.Lage = new Lage(strassename, ortname);
                         break;
-                    case "OptischeInspektion": result.OptischeInspektion = parseOptischeInspektion(d); break;
+                    case "OptischeInspektion": result.OptischeInspektion.Add(parseOptischeInspektion(d)); break;
+                    default: throw new NotImplementedException(d.Name);
                 }
             }
             return result;
@@ -182,7 +242,7 @@ namespace Schnittstelle.Import.XML.v2013
                         result.Rohrleitungstyp = (ERohrleitungstyp)Convert.ToInt32(d.InnerText);
                         break;
                     case "Inspektionslaenge":
-                        result.Inspektionslaenge = Convert.ToDecimal(d.InnerText.Replace('.', ','));
+                        result.Inspektionslaenge = ConvertXMLToDecimal(d.InnerText);
                         break;
                     case "Inspektionsrichtung":
                         result.Inspektionsrichtung = d.InnerText;
@@ -237,11 +297,10 @@ namespace Schnittstelle.Import.XML.v2013
                 RZustand rZustand = new RZustand();
                 foreach (XmlNode d in child.ChildNodes)
                 {
-
                     switch (d.Name)
                     {
                         case "Station":
-                            rZustand.Station = Convert.ToDecimal(d.InnerText.Replace('.', ','));
+                            rZustand.Station = ConvertXMLToDecimal(d.InnerText);
                             break;
                         case "InspektionsKode":
                             rZustand.Inspektionskode = d.InnerText;
@@ -263,12 +322,12 @@ namespace Schnittstelle.Import.XML.v2013
                             break;
                         case "Quantifizierung1Numerisch":
                             Quantifizierung quantifizierung1 = new Quantifizierung();
-                            quantifizierung1.Numerisch = Convert.ToDecimal(d.InnerText.Replace('.', ','));
+                            quantifizierung1.Numerisch = ConvertXMLToDecimal(d.InnerText);
                             rZustand.Quantifizierung1 = quantifizierung1;
                             break;
                         case "Quantifizierung2Numerisch":
                             Quantifizierung quantifizierung2 = new Quantifizierung();
-                            quantifizierung2.Numerisch = Convert.ToDecimal(d.InnerText.Replace('.', ','));
+                            quantifizierung2.Numerisch = ConvertXMLToDecimal(d.InnerText);
                             rZustand.Quantifizierung1 = quantifizierung2;
                             break;
                         case "Quantifizierung1Text":
@@ -293,10 +352,18 @@ namespace Schnittstelle.Import.XML.v2013
                         case "Fotonummer": break;
                         case "Timecode": break;
                         case "GrundAbbruch": break;
+                        case "Videozaehler": break;
+                        case "BCAMaterial": break;
+                        case "BDBZustandLeitung": break;
                         default: throw new NotImplementedException(d.Name);
 
                     }
                 }
+                DWA149_2_2013Factory factory = new DWA149_2_2013Factory();
+                ICodeBeschreibung codedescription = factory.GetCodeBeschreibung(rZustand);
+
+                rZustand.KodeDescription = codedescription.GetBeschreibung;
+                
                 result.Add(rZustand);
             }
 
@@ -387,7 +454,7 @@ namespace Schnittstelle.Import.XML.v2013
                     case "Profilart": grunddaten.Profilart = Convert.ToInt32(d.InnerText); break;
                     case "HerkunftMaterial": grunddaten.HerkunftMaterial = Convert.ToInt32(d.InnerText); break;
                     case "Material": grunddaten.Material = d.InnerText; break;
-                    case "Regeleinzelrohrlaenge": grunddaten.Regeleinzelrohrlaenge = Convert.ToDecimal(d.InnerText.Replace('.', ',')); break;
+                    case "Regeleinzelrohrlaenge": grunddaten.Regeleinzelrohrlaenge = ConvertXMLToDecimal(d.InnerText); break;
                     case "ArtAuskleidung": grunddaten.ArtAuskleidung = Convert.ToInt32(d.InnerText); break;
                     case "Kanalart": grunddaten.Kanalart = d.InnerText; break;
                     case "Anschlussdaten": grunddaten.Anschlussddaten = ParseAnschlussdaten(d); break;
@@ -411,6 +478,7 @@ namespace Schnittstelle.Import.XML.v2013
             int second = Convert.ToInt32(parsedtime[2]);
             return new DateTime(year, month, day, hour, minute, second);
         }
+
         private static Anschlussdaten ParseAnschlussdaten(XmlNode anschlussdaten)
         {
             Anschlussdaten result = new Anschlussdaten();
@@ -420,8 +488,10 @@ namespace Schnittstelle.Import.XML.v2013
                 {
                     case "Objektbezeichnung": result.Objektbezeichnung = d.InnerText; break;
                     case "Kantentyp": result.Kantentyp = (EKantenTyp)Convert.ToInt32(d.InnerText); break;
-                    case "Entfernung": result.Entfernung = Convert.ToDecimal(d.InnerText.Replace('.', ',')); break;
+                    case "Entfernung": result.Entfernung = ConvertXMLToDecimal(d.InnerText); break;
                     case "Fixierung": result.Fixierung = d.InnerText; break;
+                    case "AnschlussArt": break;
+                    default: throw new NotImplementedException(d.Name);
 
                 }
             }
@@ -465,6 +535,7 @@ namespace Schnittstelle.Import.XML.v2013
                     case "Kommentar": break;
                     case "Geometrie": result.Geometrie = parseGeometrie(aktuell); break;
                     case "Sanierung": break;
+                    case "Ordnungseinheiten": break;
                     default: throw new NotImplementedException(aktuell.Name);
                 }
             }
@@ -472,44 +543,197 @@ namespace Schnittstelle.Import.XML.v2013
             return result;
         }
 
-        private Geometrie parseGeometrie(XmlNode aktuell)
+        private static Geometrie parseGeometrie(XmlNode aktuell)
         {
+            Geometrie result = new Geometrie();
+            foreach (XmlNode s in aktuell.ChildNodes)
+            {
+                switch (s.Name)
+                {
+                    case "GeoObjekttyp": break;
+                    case "Geometriedaten":
+                        result.Geometriedaten = parseGeometrieDaten(s);
+                        break;
+                    case "GeoObjektart": break;
+                    case "VorlaeufigeBezeichnung": break;
+                    case "Kommentar": break;
 
-            return new Geometrie();
+
-            //throw new NotImplementedException();
+                    default: throw new NotImplementedException(s.Name);
+                }
+            }
+            return result;
+            
         }
 
-        private Kante parseKante(XmlNode aktuell)
+        private static Geometriedaten parseGeometrieDaten(XmlNode aktuel)
+        {
+            Geometriedaten result = new Geometriedaten();
+            foreach (XmlNode s in aktuel.ChildNodes)
+            {
+                switch (s.Name)
+                {
+                    case "Knoten":
+                        result.Knoten = parseGeometrieKnoten(s);
+                        break;
+                    case "Kanten":
+                        result.Kanten = parseGeometrieKanten(s);
+                        break;
+                    case "Polygone": break;
+                    default: throw new NotImplementedException(s.Name);
+                }
+            }
+            
+            return result;
+        }
+
+        private static List<PolyKante> parseGeometrieKanten(XmlNode aktuel)
+        {
+            List<PolyKante> result = new List<PolyKante>();
+            foreach (XmlNode s in aktuel.ChildNodes)
+            {
+                switch (s.Name)
+                {
+                    case "Kante":
+                        result.Add(parseGeometrieKante(s));
+                        break;
+                    default: throw new NotImplementedException(s.Name);
+                }
+            }
+            return result;
+        }
+
+        private static PolyKante parseGeometrieKante(XmlNode aktuel)
+        {
+            PolyKante result = new PolyKante();
+            foreach (XmlNode s in aktuel.ChildNodes)
+            {
+                switch (s.Name)
+                {
+                    case "Start":
+                        result.Start = parseGeometrieKanteStartEnde(s);
+                        break;
+                    case "Ende":
+                        result.Ende = parseGeometrieKanteStartEnde(s);
+                        break;
+                    default: throw new NotImplementedException(s.Name);
+                }
+            }
+            return result;
+        }
+        private static PolyKanteAttribute parseGeometrieKanteStartEnde(XmlNode aktuel)
+        {
+            PolyKanteAttribute result = new PolyKanteAttribute();
+            foreach (XmlNode s in aktuel.ChildNodes)
+            {
+                switch (s.Name)
+                {
+                    case "Rechtswert": result.Rechtswert = ConvertXMLToDecimal(s.InnerText); break;
+                    case "Hochwert": result.Hochwert = ConvertXMLToDecimal(s.InnerText); break;
+                    case "Punkthoehe": result.Punkthoehe = ConvertXMLToDecimal(s.InnerText); break;
+                    case "PunktattributAbwasser": result.PunktattributAbwasser = s.InnerText; break;
+                    case "Lagegenauigkeitsstufe": break;
+                    case "Hoehengenauigkeitsstufe": break;
+                    default: throw new NotImplementedException(s.Name);
+                }
+            }
+            return result;
+        }
+
+        private static Geometriedatenknoten parseGeometrieKnoten(XmlNode aktuel)
+        {
+            Geometriedatenknoten result = new Geometriedatenknoten();
+            foreach (XmlNode s in aktuel.ChildNodes)
+            {
+                switch (s.Name)
+                {
+                    case "Punkt":
+                        result.Punkt.Add(parseGeometrieKnotenPunkt(s));
+                        break;
+                    default: throw new NotImplementedException(s.Name);
+                }
+            }
+
+            return result;
+        }
+
+        private static Punkt parseGeometrieKnotenPunkt(XmlNode aktuel)
+        {
+            Punkt punkt = new Punkt();
+            foreach (XmlNode s in aktuel.ChildNodes)
+            {
+                switch (s.Name)
+                {
+                    case "Rechtswert":
+                        punkt.Rechtswert = ConvertXMLToDecimal(s.InnerText);
+                        break;
+                    case "Hochwert":
+                        punkt.Hochwert = ConvertXMLToDecimal(s.InnerText);
+                        break;
+                    case "Punkthoehe":
+                        punkt.Punkthoehe = ConvertXMLToDecimal(s.InnerText);
+                        break;
+                    case "PunktattributAbwasser":
+                        punkt.PunktattributeAbwasser = s.InnerText;
+                        break;
+                    case "Lagegenauigkeitsstufe": break;
+                    case "Hoehengenauigkeitsstufe": break;
+                    default: throw new NotImplementedException(s.Name);
+                }
+            }
+            return punkt;
+        }
+
+        private static Kante parseKante(XmlNode aktuell)
         {
-            /*
-            KantenTyp
-            KnotenZulauf
-            KnotenZulaufTyp
-            KnotenAblauf
-            KnotenAblaufTyp
-            SohlhoeheZulauf
-            SohlhoeheAblauf
-            Laenge
-            Material
-            Profil
-            Haltung 
-            */
             Kante result = new Kante();
 
             foreach (XmlNode s in aktuell.ChildNodes)
             {
                 switch (s.Name)
                 {
-                    case "KnotenZulauf": result.knotenZulaufTemp = s.InnerText; break;
+                    case "KnotenZulauf": 
-                    case "KnotenAblauf": result.knotenAblaufTemp = s.InnerText; break;
+                        result.knotenZulaufTemp = s.InnerText;
-                    case "Profil": result.Profil = getProfil(s); break;
+                        break;
-
+                    case "KnotenAblauf":
+                        result.knotenAblaufTemp = s.InnerText;
+                        break;
+                    case "Profil":
+                        result.Profil = getProfil(s);
+                        break;
+                    case "KantenTyp":
+                        break;
+                    case "KnotenZulaufTyp":
+                        result.KnotenZulaufTyp = Convert.ToInt32(s.InnerText);
+                        break;
+                    case "KnotenAblaufTyp":
+                        result.KnotenAblaufTyp = Convert.ToInt32(s.InnerText);
+                        break;
+                    case "SohlhoeheZulauf":
+                        result.SohlhoeheZulauf = ConvertXMLToDecimal(s.InnerText);
+                        break;
+                    case "SohlhoeheAblauf":
+                        result.SohlhoeheAblauf = ConvertXMLToDecimal(s.InnerText);
+                        break;
+                    case "Laenge":
+                        result.Laenge = ConvertXMLToDecimal(s.InnerText);
+                        break;
+                    case "Material":
+                        result.Material = s.InnerText;
+                        break;
+                    case "Haltung":
+                        break;
+                    case "Leitung":
+                        break;
+                    case "Anschlussdaten":
+                        break;
+                    default: throw new NotImplementedException(s.Name);
                 }
             }
             return result;
         }
 
-        private Profil getProfil(XmlNode s)
+        private static Profil getProfil(XmlNode s)
         {
             int Profilart = 0, Profilbreite = 0, Profilhoehe = 0;
             foreach (XmlNode d in s.ChildNodes)
@@ -536,6 +760,8 @@ namespace Schnittstelle.Import.XML.v2013
                     case "KnotenTyp": result.KnotenTyp = (EKnotenTyp)Convert.ToInt32(s.InnerText); break;
                     case "Anschlusspunkt": result.Anschlusspunkt = new Anschlusspunkt() { Punktkennung = s.InnerText }; break;
                     case "Schacht": result.Schacht = parseSchacht(s); break;
+                    case "Abdeckungen": break;
+                    default: throw new NotImplementedException(s.Name);
                 }
             }
 
@@ -550,7 +776,20 @@ namespace Schnittstelle.Import.XML.v2013
                 switch (n.Name)
                 {
                     case "SchachtFunktion": result.SchachtFunktion = (ESchachtFunktion)Convert.ToInt32(n.InnerText); break;
-                    case "Schachttiefe": result.SchachtTiefe = Convert.ToDecimal(n.InnerText); break;
+                    case "Schachttiefe": 
+                        result.SchachtTiefe = Convert.ToDecimal(n.InnerText);
+                        //Debugger.Break();
+                        break;
+                    case "Einstieghilfe": break;
+                    case "ArtEinstieghilfe": break;
+                    case "MaterialSteighilfen": break;
+                    case "AnzahlDeckel": break;
+                    case "Abdeckung": break;
+                    case "Aufbau": break;
+                    case "UntereSchachtzone": break;
+                    case "Unterteil": break;
+                    case "AnzahlAnschluesse": break;
+                    default: throw new NotImplementedException(n.Name);
                 }
             }
             return result;

Schnittstelle/Sanierung/ISanierung.cs

@@ -0,0 +1,8 @@
+using Schnittstelle.DWA149_2_2013;
+using System.Collections.Generic;
+
+namespace Schnittstelle.Sanierung
+{
+    
+
+}

Schnittstelle/Sanierung/Sanierungart.cs

@@ -0,0 +1,140 @@
+using Syncfusion.XlsIO.Parser.Biff_Records;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Schnittstelle.Sanierung
+{
+
+    public class SanierungMassnahme
+    {
+        private string begrenzung = string.Empty;
+        string beschreibung = string.Empty;
+        decimal kosten = decimal.Zero;
+        int dn = 0;
+
+        public string Beschreibung { get => beschreibung; }
+        public string Begrenzung { get => begrenzung; }
+        public decimal Kosten { get => kosten; }
+        public int DN { get => dn; }
+
+        public SanierungMassnahme(string beschreibung, decimal kosten, int dn, string begrenzung = "-:-:-")
+        {
+            this.beschreibung = beschreibung;
+            this.kosten = kosten;
+            this.dn = dn;
+            this.begrenzung = begrenzung;
+        }
+    }
+
+    public abstract class Sanierungart
+    {
+        string sanierungsbezeichnung = string.Empty;
+        public string Sanierungsbezeichnung { get => sanierungsbezeichnung; }
+        public Dictionary<string, Tuple<string, double>> Sanierungen = new Dictionary<string, Tuple<string, double>>();
+
+        protected Dictionary<string, List<SanierungMassnahme>> massnahmen =
+            new Dictionary<string, List<SanierungMassnahme>>();
+
+        public Dictionary<string, List<SanierungMassnahme>> Massnahmen => massnahmen;
+        public Sanierungart(string art)
+        {
+            sanierungsbezeichnung = art;
+        }
+    }
+
+    public class Reparatur : Sanierungart
+    {
+
+        public Reparatur() : base("Reparatur")
+        {
+            massnahmen.Add("BAB", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Kurzliner",450,0)
+            });
+            massnahmen.Add("BAG", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+            massnahmen.Add("BAH", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0,"BAH:C:-"),
+                new SanierungMassnahme("Hut",400,0,"BAH:C:-")
+            });
+            massnahmen.Add("BAI", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+            massnahmen.Add("BAJ", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+            massnahmen.Add("BBA", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+            massnahmen.Add("BBB", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+            massnahmen.Add("BBC", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+            massnahmen.Add("BCA", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Tittensanierung",600,0,"BCA:C:-"),
+                new SanierungMassnahme("Tittensanierung",600,0,"BCA:E:-")
+            });
+        }
+    }
+
+    public class Renovation : Sanierungart
+    {
+
+        public Renovation() : base("Renovation")
+        {
+            BCA();
+            BCE();
+
+
+            massnahmen.Add("BAJ", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+            massnahmen.Add("BBA", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+            massnahmen.Add("BBB", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+            massnahmen.Add("BBC", new List<SanierungMassnahme>()
+            {
+                new SanierungMassnahme("Fräsen",50,0)
+            });
+        }
+
+        void BCA()
+        {
+            List<SanierungMassnahme> bca = new List<SanierungMassnahme>();
+            bca.Add(new SanierungMassnahme("Einmessen", 100, 0, "BCA:-:-"));
+            bca.Add(new SanierungMassnahme("Öffnen", 100, 0, "BCA:-:A"));
+            bca.Add(new SanierungMassnahme("Stsan", 600, 0, "BCA:-:A"));
+            massnahmen.Add("BCA", bca);
+        }
+        void BCE()
+        {
+            List<SanierungMassnahme> bce = new List<SanierungMassnahme>();
+            bce.Add(new SanierungMassnahme("Schlauchliner", 100, 200));
+            bce.Add(new SanierungMassnahme("Schlauchliner", 105, 250));
+            bce.Add(new SanierungMassnahme("Schlauchliner", 110, 300));
+            bce.Add(new SanierungMassnahme("Schlauchliner", 120, 400));
+            bce.Add(new SanierungMassnahme("Schlauchliner", 130, 500));
+            bce.Add(new SanierungMassnahme("Schlauchliner", 140, 600));
+
+            massnahmen.Add("BCE", bce);
+        }
+    }
+}

Schnittstelle/Schnittstelle.csproj

@@ -5,4 +5,8 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Syncfusion.XlsIO.Net.Core" Version="26.2.10" />
+  </ItemGroup>
+
 </Project>