Interktion im WPF erweitert

DaSaSo.DatabaseConverter/ConvertXML.cs

@@ -13,8 +13,12 @@ namespace DaSaSo.DatabaseConverter
     {
         List<Auftraggeber> auftraggeberList = new List<Auftraggeber>();
         Queue<Auftraggeber> bearbeiteteAuftraggeber = new Queue<Auftraggeber>();
+        Queue<InlinerSanierung> bearbeiteInlinerSanierung = new Queue<InlinerSanierung>();
+        Queue<Tuple<string, Imprägnierungen>> bearbeiteStammImpr = new Queue<Tuple<string, Imprägnierungen>>();
         List<Projekt> projekte = new List<Projekt>();
+        public List<Imprägnierungen> imprägnierungListe = new List<Imprägnierungen>();
         XmlReader m_reader;
+        string lastObject = "";
         public int counter = 0;
 
         public List<Projekt> GetProjekts => projekte;
@@ -46,7 +50,19 @@ namespace DaSaSo.DatabaseConverter
                         }
                         
                     }
-                    if(m_reader.IsStartElement("Projekt"))
+                    if(m_reader.IsStartElement("kc:ImprägnierBericht"))
+                    {
+                        while(m_reader.Read())
+                        {
+                            //HandleImprägnierungen();
+                            if (m_reader.Name == "kc:ImprägnierBericht" && m_reader.NodeType == XmlNodeType.EndElement)
+                            {
+                                break;
+                            }
+                        }
+                    }
+                    
+                    if (m_reader.IsStartElement("Projekt"))
                     {
                         counter++;
                         bool flag = true;
@@ -91,12 +107,65 @@ namespace DaSaSo.DatabaseConverter
                 }
             }
             RecreateAuftraggeber();
+            RecreateInlinersanierung();
+           // Debugger.Break();
+        }
+
+        
+
+        private void HandleImprägnierungen()
+        {
+            m_reader.Read();
+            m_reader.Read();
+            
             //Debugger.Break();
+            if(m_reader.HasAttributes)
+            {
+                Imprägnierungen imp = new Imprägnierungen();
+                while(m_reader.MoveToNextAttribute())
+                {
+                    switch(m_reader.Name)
+                    {
+                        
+                        case "x:Name": imp.interneID = m_reader.Value; break;              
+                        case "DN": imp.DN = Convert.ToInt32(m_reader.Value); break;
+                        case "Imprägniernummer": imp.Imprägniernummer = m_reader.Value; break;    
+                        case "LinerLänge": imp.LinerLänge = Convert.ToDecimal(m_reader.Value); break;
+                        case "NochVorhanden": imp.NochVorhanden = Convert.ToBoolean(m_reader.Value); break;
+                        case "Schlauchnummer": imp.Schlauchnummer = m_reader.Value; break;     
+                        case "Wanddicke": imp.Wanddicke = Convert.ToDecimal(m_reader.Value.Replace('.', ',')); break; 
+
+                        case "Länge":               // wird aktuell nicht gebraucht
+                        case "LagerungKorrekt":     // wird aktuell nicht gebraucht
+                        case "HarzTemperatur":      // wird aktuell nicht gebraucht
+                        case "Harzmenge":           // wird aktuell nicht gebraucht
+                        case "Vakuum":              // wird aktuell nicht gebraucht
+                        case "Walzenabstand":       // wird aktuell nicht gebraucht
+                        case "Bediener":            // wird aktuell nicht gebraucht
+                        case "HarzTyp":             // wird aktuell nicht gebraucht 
+                        case "ImprägnierungEnde":   // wird aktuell nicht gebraucht
+                        case "LängeCode": break;          // wird aktuell nicht gebraucht
+
+                        default: throw new Exception();       
+                    }
+                }
+                imprägnierungListe.Add(imp);
+                if(lastObject != "")
+                {
+                    Tuple<string, Imprägnierungen> t = new Tuple<string, Imprägnierungen>(lastObject, imp);
+                    
+                    bearbeiteStammImpr.Enqueue(t);
+                    lastObject = "";
+                }
+                //Debugger.Break();
+                
+                
+            }
         }
 
         private void RecreateAuftraggeber()
         {
-            while(bearbeiteteAuftraggeber.Count > 1)
+            while(bearbeiteteAuftraggeber.Count > 0)
             {
                 Auftraggeber _auftraggeber = bearbeiteteAuftraggeber.Dequeue();
                 if(_auftraggeber.Ansprechpartner == null && _auftraggeber.Name == null && _auftraggeber.Ort == null && _auftraggeber.Strasse == null)
@@ -118,6 +187,35 @@ namespace DaSaSo.DatabaseConverter
                 auftraggeber.Strasse = _auftraggeber.Strasse;
             }
         }
+        private void RecreateInlinersanierung()
+        {
+            while(bearbeiteInlinerSanierung.Count > 0)
+            {
+                InlinerSanierung inlinerSanierung = bearbeiteInlinerSanierung.Dequeue();
+                if (inlinerSanierung.tempImprägnierung.Equals("{x:Null}")) continue;
+                //{x:Reference __ReferenceID61}
+                string id = inlinerSanierung.tempImprägnierung.Trim('{').Trim('}').Substring(12);
+                inlinerSanierung.Impraeg = imprägnierungListe.Find(x => x.interneID.Equals(id));
+                if (inlinerSanierung.Impraeg == null) throw new Exception();
+            }
+            while(bearbeiteStammImpr.Count > 0)
+            {
+                Tuple<string, Imprägnierungen>? s = bearbeiteStammImpr.Dequeue();
+                
+                Inspektionsobjekt inspektionsobjekt = null;
+                foreach(Projekt prj in projekte)
+                {
+                    foreach(Inspektionsobjekt insp in prj.inspektionsobjekte)
+                    {
+                        if (insp.Objektbezeichnung.Equals(s.Item1))
+                            inspektionsobjekt = insp;
+                    }
+                }
+                inspektionsobjekt.InlinerSanierung.Impraeg = s.Item2;
+
+            }
+           
+        }
 
         private void HandleInspektionsobjekt(List<Inspektionsobjekt> inspektionsobjekts)
         {
@@ -189,6 +287,13 @@ namespace DaSaSo.DatabaseConverter
             if (m_reader.IsStartElement("InlinerSanierung"))
             {
                 HandleInlinerSanierung(inspektionsobjekts);
+            }
+            if (m_reader.IsStartElement("InlinerSanierung.Imprägnierungsbericht"))
+            {
+                HandleImprägnierungen();
+            }
+            if (m_reader.IsStartElement("SchachtAnbindung"))
+            {
 
             }
             //Console.WriteLine(m_reader.Name);
@@ -200,8 +305,10 @@ namespace DaSaSo.DatabaseConverter
         {
             Inspektionsobjekt objekt = null;
             InlinerSanierung san = new InlinerSanierung();
+            
             if (m_reader.HasAttributes)
             {
+                bool recreate = false;
                 while (m_reader.MoveToNextAttribute())
                 {
                     //Console.WriteLine("{0} = {1}", m_reader.Name, m_reader.Value);
@@ -211,6 +318,7 @@ namespace DaSaSo.DatabaseConverter
                         case "Inspektionsobjekt": 
                             interneObjektbezeichnung = m_reader.Value.Substring(13).Trim('}');
                             objekt = inspektionsobjekts.Find(x => x.interneID != null && x.interneID.Equals(interneObjektbezeichnung));
+                            //if (objekt.Objektbezeichnung.Equals("00450HR01")) Debugger.Break();
                             break;
                         case "Wetter": san.Wetter = m_reader.Value; break;
                         case "WasserhaltungEingerichtet": san.Wasserhaltung = Convert.ToBoolean(m_reader.Value); break;
@@ -230,12 +338,44 @@ namespace DaSaSo.DatabaseConverter
                         case "EinbauTemperatur": san.EinbauTemperatur = m_reader.Value; break;
                         case "Besatzung": san.Besatzung = m_reader.Value; break;
                         case "Datum": san.Datum = Convert.ToDateTime(m_reader.Value); break;
+                        case "Ort": san.Ort = m_reader.Value; break;
+                        case "Imprägnierungsbericht":
+                            san.tempImprägnierung = m_reader.Value;
+                            recreate = true;
+                            Trace.WriteLine(san.tempImprägnierung);
+                            break;
+                        case "Offset": break; // Use this
+
+                        
+                        case "Rueckholgeschwindigkeit":
+                        case "DatumKalibrierung":
+                        case "AnfangAushaertung":
+                        case "AnfangKalibrierung":
+                        case "EndeKalibirierung":
+                        case "HDReinigungDatum":
+                        case "HarzChargenummer":
+                        case "HarzKalibrierTemperatur":
+                        case "HarzTyp":
+                        case "Harzbedarf":
+                        case "KalibierWalzenAbstand":
+                        case "HarzBedarf":
+                        case "LinerTyp":
+                        case "KalibrierUnterdruck":
+                        case "Guid":
+                        case "LinerChargenummer":
+                        case "Bediener": break;
+                        default: throw new NotImplementedException(m_reader.Name); break;
                     }
 
                 }
+                if (recreate)
+                    bearbeiteInlinerSanierung.Enqueue(san);
+                else
+                    lastObject = objekt.Objektbezeichnung;
                 objekt.InlinerSanierung = san;
             }
             
+            
             //Debugger.Break();
         }
 
@@ -257,6 +397,18 @@ namespace DaSaSo.DatabaseConverter
         }
     }
 
+    internal class Imprägnierungen
+    {
+        
+        public string interneID { get; set; }
+        public int DN { get; set; }
+        public string Imprägniernummer { get; set; }
+        public decimal LinerLänge { get; set; }
+        public bool NochVorhanden { get; set; }
+        public string Schlauchnummer { get; set; }
+        public decimal Wanddicke { get; set; }
+    }
+
     internal class Projekt
     {
         public string ProjektNummer { get; set; }
@@ -287,9 +439,13 @@ namespace DaSaSo.DatabaseConverter
         public decimal Haltungslaenge { get; set; }
         public bool GeschlossenesEnde { get; set; }
         public InlinerSanierung InlinerSanierung {get; set;}
+        public override string ToString()
+        {
+            return Objektbezeichnung;
+        }
     }
 
-    public class InlinerSanierung
+    internal class InlinerSanierung
     {
         public string Besatzung { get; set; }
         public DateTime Datum { get; set; }
@@ -301,6 +457,7 @@ namespace DaSaSo.DatabaseConverter
         public bool HDReinigung { get; set; }
         public decimal InversionsDruck { get; set; }
         public string LagerungsTemperatur { get; set; }
+        public string Ort { get; set; }
         public bool SVTO { get; set; }
         public bool VorbereitetMechanisch { get; set; }
         public int TempAusssen { get; set; }
@@ -309,6 +466,8 @@ namespace DaSaSo.DatabaseConverter
         public bool Preliner { get; set; }
         public bool Wasserhaltung { get; set; }
         public string Wetter { get; set; }
+        public string tempImprägnierung { get; set; }
+        public Imprägnierungen Impraeg { get; set; }
     }
 
     internal class Auftraggeber

DaSaSo.DatabaseConverter/DaSaSo.DatabaseConverter.csproj

@@ -11,12 +11,6 @@
     <ProjectReference Include="..\DaSaSo.EntityFramework\DaSaSo.EntityFramework.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Reference Include="PresentationFramework">
-      <HintPath>..\..\..\..\..\..\Program Files\dotnet\packs\Microsoft.WindowsDesktop.App.Ref\6.0.0-preview.7.21378.9\ref\net6.0\PresentationFramework.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-
   <ItemGroup>
     <None Update="TeufelDB.xaml">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>

DaSaSo.DatabaseConverter/Program.cs

@@ -13,35 +13,148 @@ using DaSaSo.EntityFramework;
 Console.WriteLine("Hello, World!");
 ConvertXML convertXML = new ConvertXML();
 convertXML.parseXML();
-WriteToNewDB(convertXML.GetProjekts);
+
+    WriteToNewDB(convertXML.GetProjekts, convertXML.imprägnierungListe);
+
 Console.WriteLine("Fertig");
 
 Console.ReadLine();
 
-static void WriteToNewDB(List<Projekt> alteDB)
+static void WriteToNewDB(List<Projekt> alteDB, List<Imprägnierungen> imprägnierungListe)
 {
-    IDataService<Project> dataService = new GenericDataService<Project>(new DaSaSoDbContextFactory("Host = localhost; Database = dasaso; Username = kansan; Password = kansan"));
+    DaSaSoDbContextFactory daSaSoDbContextFactory = new DaSaSoDbContextFactory("Host = localhost; Database = dasaso; Username = kansan; Password = kansan");
+    IDataService<Project> dataService = null;
+    IDataService<Client> clientsDataService = new GenericDataService<Client>(daSaSoDbContextFactory);
+
+
+    List<Client> avaibleClients = new List<Client>();
+
+
+    /*Client dummy = new Client()
+    {
+        Firstname = "NaN"
+    };*/
+    avaibleClients.Add(dummy);
+    IEnumerable<Auftraggeber> d = alteDB.Select(s => s.Auftraggeber).Where(m => m != null);
+    var m = d.Select(f => f.Name).Distinct();
+   
+    foreach(string auftraggebername in m)
+    {
+        IEnumerable<Auftraggeber>? raw = alteDB.Select(s => s.Auftraggeber);
+        Auftraggeber rawAuftraggeber = null;
+        foreach(Auftraggeber? g in raw)
+        {
+            if (g == null) continue;
+            if (g.Name.Equals(auftraggebername))
+            {
+                rawAuftraggeber = g;
+                break;
+            }
+        }
+        if (rawAuftraggeber == null) throw new Exception("Auftraggeber nicht gefunden");
+        Client t = new Client()
+        {
+            Firstname = rawAuftraggeber.Name,
+            Street = rawAuftraggeber.Strasse,
+            Country = rawAuftraggeber.Ort
+        };
+
+        avaibleClients.Add(t);
+    }
+   
+
     foreach(Projekt projekt in alteDB)
     {
-        Client newClient = new Client();
+        dataService = new GenericDataService<Project>(daSaSoDbContextFactory);
-        /*{
+        
-            Firstname = projekt.Auftraggeber.Name,
+
-            Street = projekt.Auftraggeber.Strasse,
+        Client auftraggeber = null;
-            Country = projekt.Auftraggeber.Ort
+        if (projekt.Auftraggeber == null)
-        };*/
+            auftraggeber = avaibleClients.Find(x => x.Firstname.Equals("NaN"));
-        if(projekt.Auftraggeber == null)
+        else
+            auftraggeber = avaibleClients.Find(x => x.Firstname.Equals(projekt.Auftraggeber.Name));
+
+        if (auftraggeber == null) Debugger.Break();
+        Project project = new Project();
+        project.Client = auftraggeber;
+        project.Name = projekt.Ort;
+       
+        List<Buildingsite> buildingsites = new List<Buildingsite>();
+
+        Buildingsite buildingsite = new Buildingsite();
+        buildingsite.ContactPerson = projekt.Auftraggeber != null ? projekt.Auftraggeber.Ansprechpartner : "";
+        buildingsite.BuildingSiteNumber = projekt.ProjektNummer;
+        buildingsite.Project = project;
+
+        List<SewerObject> Sewers = new List<SewerObject>();
+        foreach (Inspektionsobjekt inspektionsobjekt in projekt.inspektionsobjekte)
         {
-            newClient.Firstname = "";
+            SewerObject sewerObject = new SewerObject();
-            newClient.Street = "";
+            sewerObject.BuildingSite = buildingsite;
-            newClient.Country ="";
+
+            sewerObject.DN = inspektionsobjekt.Kanalrohrweite;
+            sewerObject.ObjektName = inspektionsobjekt.Objektbezeichnung;
+            sewerObject.Material = inspektionsobjekt.RohrMaterial;
+            sewerObject.PunktOben = new SewerPoint()
+            {
+                Objektnummer = inspektionsobjekt.VonPunkt
+            };
+            sewerObject.PunktObenType = DaSaSo.Domain.Enums.EPointType.Schacht;
+            sewerObject.PunktUnten = new SewerPoint()
+            {
+                Objektnummer = inspektionsobjekt.BisPunkt
+            };
+            sewerObject.PunktUntenType = DaSaSo.Domain.Enums.EPointType.Anschlusspunkt;
+            sewerObject.StreetName = inspektionsobjekt.StrasseName;
+            sewerObject.SewerLength = inspektionsobjekt.Haltungslaenge;
+
+            if (inspektionsobjekt.InlinerSanierung != null)
+            {
+                sewerObject.PipeLiner = new PipeLiner();
+                sewerObject.PipeLiner.InversionPressure = inspektionsobjekt.InlinerSanierung.InversionsDruck;
+                sewerObject.PipeLiner.Operator = inspektionsobjekt.InlinerSanierung.Besatzung;
+                sewerObject.PipeLiner.PermitNeeded = inspektionsobjekt.InlinerSanierung.GenehmigungVorhanden;
+                sewerObject.PipeLiner.Preliner = inspektionsobjekt.InlinerSanierung.Preliner;
+                sewerObject.PipeLiner.STVO = inspektionsobjekt.InlinerSanierung.SVTO;
+                sewerObject.PipeLiner.TemperaturAssembly = Convert.ToDecimal(inspektionsobjekt.InlinerSanierung.EinbauTemperatur);
+                sewerObject.PipeLiner.TemperatureOutdoors = inspektionsobjekt.InlinerSanierung.TempAusssen;
+                sewerObject.PipeLiner.TemperatureSewer = inspektionsobjekt.InlinerSanierung.TempKanal;
+                sewerObject.PipeLiner.TemperaturStorage = Convert.ToDecimal(inspektionsobjekt.InlinerSanierung.LagerungsTemperatur);
+                sewerObject.PipeLiner.WaterBaried = inspektionsobjekt.InlinerSanierung.Wasserhaltung;
+                sewerObject.PipeLiner.Weather = inspektionsobjekt.InlinerSanierung.Wetter;
+                sewerObject.PipeLiner.CleanedHD = inspektionsobjekt.InlinerSanierung.HDReinigung;
+                sewerObject.PipeLiner.CleanedMechanisch = inspektionsobjekt.InlinerSanierung.VorbereitetMechanisch;
+                sewerObject.PipeLiner.CleanedRoborter = inspektionsobjekt.InlinerSanierung.VorbereitetRoborter;
+                sewerObject.PipeLiner.ClosedEnd = inspektionsobjekt.InlinerSanierung.GeschlosseneEnde;
+            }
+
+            Sewers.Add(sewerObject);
+        }
+        buildingsite.SewerObjects = Sewers;
+        buildingsites.Add(buildingsite);
+        project.BuildingSites = buildingsites;
+        auftraggeber.Projects = new List<Project>() { project };
+        clientsDataService.CreateNonAsync(auftraggeber);
+        //dataService.CreateNonAsync(project);
+    }
+
+    return;
+    
+    foreach (Projekt projekt in alteDB)
+    {
+        Client newClient = null;
+        
+        if (projekt.Auftraggeber == null)
+        {
+            newClient = avaibleClients.Find(x => x.Firstname.Equals("NaN"));
         }
         else
         {
-            newClient.Firstname = projekt.Auftraggeber.Name;
+            newClient = avaibleClients.Find(x => x.Firstname.Equals(projekt.Auftraggeber.Name));
-            newClient.Street = projekt.Auftraggeber.Strasse;
-            newClient.Country = projekt.Auftraggeber.Ort;
         }
+        if (newClient == null) Debugger.Break();
         Project project = new Project();
+        //Console.WriteLine(aktClient);
         project.Client = newClient;
         project.Name = projekt.Ort;
 
@@ -73,13 +186,52 @@ static void WriteToNewDB(List<Projekt> alteDB)
             sewerObject.PunktUntenType = DaSaSo.Domain.Enums.EPointType.Anschlusspunkt;
             sewerObject.StreetName = inspektionsobjekt.StrasseName;
             sewerObject.SewerLength = inspektionsobjekt.Haltungslaenge;
+            
+            if(inspektionsobjekt.InlinerSanierung != null)
+            {
+                sewerObject.PipeLiner = new PipeLiner();
+                sewerObject.PipeLiner.InversionPressure = inspektionsobjekt.InlinerSanierung.InversionsDruck;
+                sewerObject.PipeLiner.Operator = inspektionsobjekt.InlinerSanierung.Besatzung;
+                sewerObject.PipeLiner.PermitNeeded = inspektionsobjekt.InlinerSanierung.GenehmigungVorhanden;
+                sewerObject.PipeLiner.Preliner = inspektionsobjekt.InlinerSanierung.Preliner;
+                sewerObject.PipeLiner.STVO = inspektionsobjekt.InlinerSanierung.SVTO;
+                sewerObject.PipeLiner.TemperaturAssembly = Convert.ToDecimal(inspektionsobjekt.InlinerSanierung.EinbauTemperatur);
+                sewerObject.PipeLiner.TemperatureOutdoors = inspektionsobjekt.InlinerSanierung.TempAusssen;
+                sewerObject.PipeLiner.TemperatureSewer = inspektionsobjekt.InlinerSanierung.TempKanal;
+                sewerObject.PipeLiner.TemperaturStorage = Convert.ToDecimal(inspektionsobjekt.InlinerSanierung.LagerungsTemperatur);
+                sewerObject.PipeLiner.WaterBaried = inspektionsobjekt.InlinerSanierung.Wasserhaltung;
+                sewerObject.PipeLiner.Weather = inspektionsobjekt.InlinerSanierung.Wetter;
+                sewerObject.PipeLiner.CleanedHD = inspektionsobjekt.InlinerSanierung.HDReinigung;
+                sewerObject.PipeLiner.CleanedMechanisch = inspektionsobjekt.InlinerSanierung.VorbereitetMechanisch;
+                sewerObject.PipeLiner.CleanedRoborter = inspektionsobjekt.InlinerSanierung.VorbereitetRoborter;
+                sewerObject.PipeLiner.ClosedEnd = inspektionsobjekt.InlinerSanierung.GeschlosseneEnde;
+                Impregnation impregnation = null;
+                if (inspektionsobjekt.InlinerSanierung.Impraeg == null)
+                {
+                    impregnation = new Impregnation()
+                    {
+                        Number = Guid.NewGuid().ToString()
+                    };
+                }
+                else
+                {
+                    //impregnation = avaibleImpregnation.Find(x => x.Number.Equals(inspektionsobjekt.InlinerSanierung.Impraeg.Imprägniernummer));
+                }
+                //if (impregnation == null) Debugger.Break();
+                
+                //if (impregnation != null)
+                    //sewerObject.PipeLiner.Impregnation = impregnation;
+                
+            }
+            
             Sewers.Add(sewerObject);
         }
         buildingsite.SewerObjects = Sewers;
         buildingsites.Add(buildingsite);
         project.BuildingSites = buildingsites;
 
-        dataService.Create(project);
+        dataService.CreateNonAsync(project);
     }
     
+    
 }

DaSaSo.Domain/Model/Buildingsite.cs

@@ -12,6 +12,6 @@ namespace DaSaSo.Domain.Model
         public string BuildingSiteNumber { get; set; }
         public string Country { get; set; }
         public string ContactPerson { get; set; }
-        public IEnumerable<SewerObject> SewerObjects { get; set; }
+        public ICollection<SewerObject> SewerObjects { get; set; } = new List<SewerObject>();
     }
 }

DaSaSo.Domain/Model/Client.cs

@@ -13,7 +13,7 @@ namespace DaSaSo.Domain.Model
         public string Country { get; set; }
         public string Street { get; set; }
         public string Postcode { get; set; }
-        public IEnumerable<Project> Projects { get; set; }
+        public ICollection<Project> Projects { get; set; } = new List<Project>();
 
     }
 }

DaSaSo.Domain/Model/Impregnation.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.Domain.Model
+{
+    public class Impregnation : DomainObject
+    {
+        public int DN { get; set; }
+        public string Number { get; set; }
+        public decimal Linerlength { get; set; }
+        public bool IsAvaible { get; set; }
+        public DateTime Date { get; set; }
+        public string LinerNumber { get; set; }
+        public decimal WallThickness { get; set; }
+    }
+}

DaSaSo.Domain/Model/PipeLiner.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.Domain.Model
+{
+    public class PipeLiner : SewerRehabilation
+    {
+        public decimal InversionPressure { get; set; }
+        public Impregnation Impregnation { get; set; }
+        public bool ClosedEnd { get; set; }
+        public bool Preliner { get; set; }
+        public decimal TemperaturAssembly { get; set; }
+        public decimal TemperaturStorage { get; set; }
+        public decimal LinerLength { get; set; }
+
+    }
+}

DaSaSo.Domain/Model/Project.cs

@@ -10,6 +10,6 @@ namespace DaSaSo.Domain.Model
     {
         public string Name {  get; set; }
         public Client Client { get; set; }
-        public IEnumerable<Buildingsite> BuildingSites { get; set; }
+        public ICollection<Buildingsite> BuildingSites { get; set; } = new List<Buildingsite>();
     }
 }

DaSaSo.Domain/Model/SewerObject.cs

@@ -20,7 +20,8 @@ namespace DaSaSo.Domain.Model
         public bool WaterBarrier { get; set; }
         public bool PermitNeeded { get; set; }
         public bool BuildingsiteBarier { get; set; }
-        public IEnumerable<SewerDamage> SewerDamages { get; set; }
+        public PipeLiner? PipeLiner { get; set; }
+        public ICollection<SewerDamage> SewerDamages { get; set; } = new List<SewerDamage>();
 
         //Not for Databinding
         [NotMapped]

DaSaSo.Domain/Model/SewerRehabilation.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.Domain.Model
+{
+    public abstract class SewerRehabilation : DomainObject
+    {
+        public string Operator { get; set; }
+        public DateTime Date { get; set; }
+        public decimal TemperatureOutdoors { get; set; }
+        public decimal TemperatureSewer { get; set; }
+        public string Weather { get; set; }
+        public bool CleanedHD { get; set; }
+        public bool CleanedMechanisch { get; set; }
+        public bool CleanedRoborter { get; set; }
+        public bool WaterBaried { get; set; }
+        public bool PermitNeeded { get; set; }
+        public bool STVO { get; set; }
+
+    }
+}

DaSaSo.Domain/Services/BuildingsiteServices/BuildingsiteService.cs

@@ -0,0 +1,30 @@
+using DaSaSo.Domain.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.Domain.Services.BuildingsiteServices
+{
+    public class BuildingsiteService : IBuildingsiteService
+    {
+        private readonly IDataService<Project> _projectService;
+
+        public BuildingsiteService(IDataService<Project> projectService)
+        {
+            _projectService = projectService;
+        }
+
+        public async Task<Buildingsite> CreateBuildingsite(Project proj)
+        {
+            Buildingsite buildingsite = new Buildingsite()
+            {
+                Project = proj
+            };
+            proj.BuildingSites.Add(buildingsite);
+            await _projectService.Update(proj.Id, proj);
+            return buildingsite;
+        }
+    }
+}

DaSaSo.Domain/Services/BuildingsiteServices/IBuildingsiteService.cs

@@ -0,0 +1,14 @@
+using DaSaSo.Domain.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.Domain.Services.BuildingsiteServices
+{
+    public interface IBuildingsiteService
+    {
+        Task<Buildingsite> CreateBuildingsite(Project proj);
+    }
+}

DaSaSo.Domain/Services/IDataService.cs

@@ -11,6 +11,7 @@ namespace DaSaSo.Domain.Services
         Task<IEnumerable<T>> GetAll();
         Task<T> Get(int id);
         Task<T> Create(T entity);
+        T CreateNonAsync(T entity);
         Task<T> Update(int id, T entity);
         Task<bool> Delete(int id);
     }

DaSaSo.Domain/Services/ProjectServices/IProjectService.cs

@@ -0,0 +1,14 @@
+using DaSaSo.Domain.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.Domain.Services.ProjectServices
+{
+    public interface IProjectService
+    {
+        Task<Project> CreateProject(Client Auftraggeber);
+    }
+}

DaSaSo.Domain/Services/ProjectServices/ProjectService.cs

@@ -0,0 +1,31 @@
+using DaSaSo.Domain.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.Domain.Services.ProjectServices
+{
+    public class ProjectService : IProjectService
+    {
+        private readonly IDataService<Client> _clientService;
+
+        public ProjectService(IDataService<Client> clientService)
+        {
+            _clientService = clientService;
+        }
+
+        public async Task<Project> CreateProject(Client Auftraggeber)
+        {
+            Project project = new Project()
+            {
+                Client = Auftraggeber
+            };
+
+            Auftraggeber.Projects.Add(project);
+            await _clientService.Update(Auftraggeber.Id, Auftraggeber);
+            return project;
+        }
+    }
+}

DaSaSo.EntityFramework/DaSaSoDbContext.cs

@@ -25,6 +25,8 @@ namespace DaSaSo.EntityFramework
         public DbSet<Buildingsite>? Buildingsites { get; set; }
         public DbSet<SewerObject>? SewerObjects { get; set; }
         public DbSet<SewerDamage>? SewerDamages { get; set; }
+        public DbSet<PipeLiner>? PipeLiners { get; set; }
+        public DbSet<Impregnation>? Impregnations { get; set; }
 
     }
 }

DaSaSo.EntityFramework/Migrations/20210921145350_Lineradded.Designer.cs

@@ -0,0 +1,381 @@
+// <auto-generated />
+using System;
+using DaSaSo.EntityFramework;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace DaSaSo.EntityFramework.Migrations
+{
+    [DbContext(typeof(DaSaSoDbContext))]
+    [Migration("20210921145350_Lineradded")]
+    partial class Lineradded
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Relational:MaxIdentifierLength", 63)
+                .HasAnnotation("ProductVersion", "6.0.0-preview.7.21378.4")
+                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Buildingsite", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("BuildingSiteNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactPerson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProjectId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Buildingsites");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Client", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Firstname")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Postcode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Clients");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Impregnation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("DN")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("IsAvaible")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LinerNumber")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("Linerlength")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("WallThickness")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Impregnations");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.PipeLiner", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<bool>("CleanedHD")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("CleanedMechanisch")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("CleanedRoborter")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("ClosedEnd")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int?>("ImpregnationId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("InversionPressure")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LinerLength")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Operator")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PermitNeeded")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Preliner")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("STVO")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("TemperaturAssembly")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("TemperaturStorage")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("TemperatureOutdoors")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("TemperatureSewer")
+                        .HasColumnType("numeric");
+
+                    b.Property<bool>("WaterBaried")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Weather")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ImpregnationId");
+
+                    b.ToTable("PipeLiners");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Project", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int?>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.ToTable("Projects");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerDamage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("DamageType")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Distance")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("PreparationType")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SewerObjectId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SewerObjectId");
+
+                    b.ToTable("SewerDamages");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerObject", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int?>("BuildingSiteId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("BuildingsiteBarier")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("DN")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Material")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ObjektName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PermitNeeded")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("PunktObenId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PunktObenType")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("PunktUntenId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PunktUntenType")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("SewerActivated")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("SewerCleaned")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("SewerLength")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("StreetName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("WaterBarrier")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BuildingSiteId");
+
+                    b.HasIndex("PunktObenId");
+
+                    b.HasIndex("PunktUntenId");
+
+                    b.ToTable("SewerObjects");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerPoint", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Objektnummer")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SewerPoint");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Buildingsite", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.Project", "Project")
+                        .WithMany("BuildingSites")
+                        .HasForeignKey("ProjectId");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.PipeLiner", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.Impregnation", "Impregnation")
+                        .WithMany()
+                        .HasForeignKey("ImpregnationId");
+
+                    b.Navigation("Impregnation");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Project", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.Client", "Client")
+                        .WithMany("Projects")
+                        .HasForeignKey("ClientId");
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerDamage", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.SewerObject", "SewerObject")
+                        .WithMany("SewerDamages")
+                        .HasForeignKey("SewerObjectId");
+
+                    b.Navigation("SewerObject");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerObject", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.Buildingsite", "BuildingSite")
+                        .WithMany("SewerObjects")
+                        .HasForeignKey("BuildingSiteId");
+
+                    b.HasOne("DaSaSo.Domain.Model.SewerPoint", "PunktOben")
+                        .WithMany()
+                        .HasForeignKey("PunktObenId");
+
+                    b.HasOne("DaSaSo.Domain.Model.SewerPoint", "PunktUnten")
+                        .WithMany()
+                        .HasForeignKey("PunktUntenId");
+
+                    b.Navigation("BuildingSite");
+
+                    b.Navigation("PunktOben");
+
+                    b.Navigation("PunktUnten");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Buildingsite", b =>
+                {
+                    b.Navigation("SewerObjects");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Client", b =>
+                {
+                    b.Navigation("Projects");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Project", b =>
+                {
+                    b.Navigation("BuildingSites");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerObject", b =>
+                {
+                    b.Navigation("SewerDamages");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DaSaSo.EntityFramework/Migrations/20210921145350_Lineradded.cs

@@ -0,0 +1,81 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace DaSaSo.EntityFramework.Migrations
+{
+    public partial class Lineradded : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Impregnations",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    DN = table.Column<int>(type: "integer", nullable: false),
+                    Number = table.Column<string>(type: "text", nullable: true),
+                    Linerlength = table.Column<decimal>(type: "numeric", nullable: false),
+                    IsAvaible = table.Column<bool>(type: "boolean", nullable: false),
+                    Date = table.Column<DateTime>(type: "timestamp without time zone", nullable: false),
+                    LinerNumber = table.Column<string>(type: "text", nullable: true),
+                    WallThickness = table.Column<decimal>(type: "numeric", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Impregnations", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "PipeLiners",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    InversionPressure = table.Column<decimal>(type: "numeric", nullable: false),
+                    ImpregnationId = table.Column<int>(type: "integer", nullable: true),
+                    ClosedEnd = table.Column<bool>(type: "boolean", nullable: false),
+                    Preliner = table.Column<bool>(type: "boolean", nullable: false),
+                    TemperaturAssembly = table.Column<decimal>(type: "numeric", nullable: false),
+                    TemperaturStorage = table.Column<decimal>(type: "numeric", nullable: false),
+                    LinerLength = table.Column<decimal>(type: "numeric", nullable: false),
+                    Operator = table.Column<string>(type: "text", nullable: true),
+                    Date = table.Column<DateTime>(type: "timestamp without time zone", nullable: false),
+                    TemperatureOutdoors = table.Column<decimal>(type: "numeric", nullable: false),
+                    TemperatureSewer = table.Column<decimal>(type: "numeric", nullable: false),
+                    Weather = table.Column<string>(type: "text", nullable: true),
+                    CleanedHD = table.Column<bool>(type: "boolean", nullable: false),
+                    CleanedMechanisch = table.Column<bool>(type: "boolean", nullable: false),
+                    CleanedRoborter = table.Column<bool>(type: "boolean", nullable: false),
+                    WaterBaried = table.Column<bool>(type: "boolean", nullable: false),
+                    PermitNeeded = table.Column<bool>(type: "boolean", nullable: false),
+                    STVO = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PipeLiners", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_PipeLiners_Impregnations_ImpregnationId",
+                        column: x => x.ImpregnationId,
+                        principalTable: "Impregnations",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PipeLiners_ImpregnationId",
+                table: "PipeLiners",
+                column: "ImpregnationId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "PipeLiners");
+
+            migrationBuilder.DropTable(
+                name: "Impregnations");
+        }
+    }
+}

DaSaSo.EntityFramework/Migrations/20210921145447_LineraddedToSewer.Designer.cs

@@ -0,0 +1,392 @@
+// <auto-generated />
+using System;
+using DaSaSo.EntityFramework;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace DaSaSo.EntityFramework.Migrations
+{
+    [DbContext(typeof(DaSaSoDbContext))]
+    [Migration("20210921145447_LineraddedToSewer")]
+    partial class LineraddedToSewer
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Relational:MaxIdentifierLength", 63)
+                .HasAnnotation("ProductVersion", "6.0.0-preview.7.21378.4")
+                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Buildingsite", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("BuildingSiteNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactPerson")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ProjectId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Buildingsites");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Client", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Firstname")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LastName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Postcode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Clients");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Impregnation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("DN")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("IsAvaible")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LinerNumber")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("Linerlength")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("WallThickness")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Impregnations");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.PipeLiner", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<bool>("CleanedHD")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("CleanedMechanisch")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("CleanedRoborter")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("ClosedEnd")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int?>("ImpregnationId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("InversionPressure")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LinerLength")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Operator")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PermitNeeded")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Preliner")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("STVO")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("TemperaturAssembly")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("TemperaturStorage")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("TemperatureOutdoors")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("TemperatureSewer")
+                        .HasColumnType("numeric");
+
+                    b.Property<bool>("WaterBaried")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Weather")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ImpregnationId");
+
+                    b.ToTable("PipeLiners");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Project", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int?>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.ToTable("Projects");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerDamage", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("DamageType")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("Distance")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("PreparationType")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SewerObjectId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SewerObjectId");
+
+                    b.ToTable("SewerDamages");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerObject", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int?>("BuildingSiteId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("BuildingsiteBarier")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("DN")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Material")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ObjektName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PermitNeeded")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("PipeLinerId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("PunktObenId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PunktObenType")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("PunktUntenId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PunktUntenType")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("SewerActivated")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("SewerCleaned")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("SewerLength")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("StreetName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("WaterBarrier")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BuildingSiteId");
+
+                    b.HasIndex("PipeLinerId");
+
+                    b.HasIndex("PunktObenId");
+
+                    b.HasIndex("PunktUntenId");
+
+                    b.ToTable("SewerObjects");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerPoint", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Objektnummer")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SewerPoint");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Buildingsite", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.Project", "Project")
+                        .WithMany("BuildingSites")
+                        .HasForeignKey("ProjectId");
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.PipeLiner", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.Impregnation", "Impregnation")
+                        .WithMany()
+                        .HasForeignKey("ImpregnationId");
+
+                    b.Navigation("Impregnation");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Project", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.Client", "Client")
+                        .WithMany("Projects")
+                        .HasForeignKey("ClientId");
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerDamage", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.SewerObject", "SewerObject")
+                        .WithMany("SewerDamages")
+                        .HasForeignKey("SewerObjectId");
+
+                    b.Navigation("SewerObject");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerObject", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.Buildingsite", "BuildingSite")
+                        .WithMany("SewerObjects")
+                        .HasForeignKey("BuildingSiteId");
+
+                    b.HasOne("DaSaSo.Domain.Model.PipeLiner", "PipeLiner")
+                        .WithMany()
+                        .HasForeignKey("PipeLinerId");
+
+                    b.HasOne("DaSaSo.Domain.Model.SewerPoint", "PunktOben")
+                        .WithMany()
+                        .HasForeignKey("PunktObenId");
+
+                    b.HasOne("DaSaSo.Domain.Model.SewerPoint", "PunktUnten")
+                        .WithMany()
+                        .HasForeignKey("PunktUntenId");
+
+                    b.Navigation("BuildingSite");
+
+                    b.Navigation("PipeLiner");
+
+                    b.Navigation("PunktOben");
+
+                    b.Navigation("PunktUnten");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Buildingsite", b =>
+                {
+                    b.Navigation("SewerObjects");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Client", b =>
+                {
+                    b.Navigation("Projects");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Project", b =>
+                {
+                    b.Navigation("BuildingSites");
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.SewerObject", b =>
+                {
+                    b.Navigation("SewerDamages");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

DaSaSo.EntityFramework/Migrations/20210921145447_LineraddedToSewer.cs

@@ -0,0 +1,44 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace DaSaSo.EntityFramework.Migrations
+{
+    public partial class LineraddedToSewer : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "PipeLinerId",
+                table: "SewerObjects",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SewerObjects_PipeLinerId",
+                table: "SewerObjects",
+                column: "PipeLinerId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SewerObjects_PipeLiners_PipeLinerId",
+                table: "SewerObjects",
+                column: "PipeLinerId",
+                principalTable: "PipeLiners",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Restrict);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_SewerObjects_PipeLiners_PipeLinerId",
+                table: "SewerObjects");
+
+            migrationBuilder.DropIndex(
+                name: "IX_SewerObjects_PipeLinerId",
+                table: "SewerObjects");
+
+            migrationBuilder.DropColumn(
+                name: "PipeLinerId",
+                table: "SewerObjects");
+        }
+    }
+}

DaSaSo.EntityFramework/Migrations/DaSaSoDbContextModelSnapshot.cs

@@ -42,7 +42,7 @@ namespace DaSaSo.EntityFramework.Migrations
 
                     b.HasIndex("ProjectId");
 
-                    b.ToTable("Buildingsites");
+                    b.ToTable("Buildingsites", (string)null);
                 });
 
             modelBuilder.Entity("DaSaSo.Domain.Model.Client", b =>
@@ -69,7 +69,108 @@ namespace DaSaSo.EntityFramework.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("Clients");
+                    b.ToTable("Clients", (string)null);
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.Impregnation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("DN")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("IsAvaible")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("LinerNumber")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("Linerlength")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("WallThickness")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Impregnations", (string)null);
+                });
+
+            modelBuilder.Entity("DaSaSo.Domain.Model.PipeLiner", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<bool>("CleanedHD")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("CleanedMechanisch")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("CleanedRoborter")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("ClosedEnd")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int?>("ImpregnationId")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("InversionPressure")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LinerLength")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Operator")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PermitNeeded")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Preliner")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("STVO")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("TemperaturAssembly")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("TemperaturStorage")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("TemperatureOutdoors")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("TemperatureSewer")
+                        .HasColumnType("numeric");
+
+                    b.Property<bool>("WaterBaried")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Weather")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ImpregnationId");
+
+                    b.ToTable("PipeLiners", (string)null);
                 });
 
             modelBuilder.Entity("DaSaSo.Domain.Model.Project", b =>
@@ -89,7 +190,7 @@ namespace DaSaSo.EntityFramework.Migrations
 
                     b.HasIndex("ClientId");
 
-                    b.ToTable("Projects");
+                    b.ToTable("Projects", (string)null);
                 });
 
             modelBuilder.Entity("DaSaSo.Domain.Model.SewerDamage", b =>
@@ -115,7 +216,7 @@ namespace DaSaSo.EntityFramework.Migrations
 
                     b.HasIndex("SewerObjectId");
 
-                    b.ToTable("SewerDamages");
+                    b.ToTable("SewerDamages", (string)null);
                 });
 
             modelBuilder.Entity("DaSaSo.Domain.Model.SewerObject", b =>
@@ -143,6 +244,9 @@ namespace DaSaSo.EntityFramework.Migrations
                     b.Property<bool>("PermitNeeded")
                         .HasColumnType("boolean");
 
+                    b.Property<int?>("PipeLinerId")
+                        .HasColumnType("integer");
+
                     b.Property<int?>("PunktObenId")
                         .HasColumnType("integer");
 
@@ -174,11 +278,13 @@ namespace DaSaSo.EntityFramework.Migrations
 
                     b.HasIndex("BuildingSiteId");
 
+                    b.HasIndex("PipeLinerId");
+
                     b.HasIndex("PunktObenId");
 
                     b.HasIndex("PunktUntenId");
 
-                    b.ToTable("SewerObjects");
+                    b.ToTable("SewerObjects", (string)null);
                 });
 
             modelBuilder.Entity("DaSaSo.Domain.Model.SewerPoint", b =>
@@ -193,7 +299,7 @@ namespace DaSaSo.EntityFramework.Migrations
 
                     b.HasKey("Id");
 
-                    b.ToTable("SewerPoint");
+                    b.ToTable("SewerPoint", (string)null);
                 });
 
             modelBuilder.Entity("DaSaSo.Domain.Model.Buildingsite", b =>
@@ -205,6 +311,15 @@ namespace DaSaSo.EntityFramework.Migrations
                     b.Navigation("Project");
                 });
 
+            modelBuilder.Entity("DaSaSo.Domain.Model.PipeLiner", b =>
+                {
+                    b.HasOne("DaSaSo.Domain.Model.Impregnation", "Impregnation")
+                        .WithMany()
+                        .HasForeignKey("ImpregnationId");
+
+                    b.Navigation("Impregnation");
+                });
+
             modelBuilder.Entity("DaSaSo.Domain.Model.Project", b =>
                 {
                     b.HasOne("DaSaSo.Domain.Model.Client", "Client")
@@ -229,6 +344,10 @@ namespace DaSaSo.EntityFramework.Migrations
                         .WithMany("SewerObjects")
                         .HasForeignKey("BuildingSiteId");
 
+                    b.HasOne("DaSaSo.Domain.Model.PipeLiner", "PipeLiner")
+                        .WithMany()
+                        .HasForeignKey("PipeLinerId");
+
                     b.HasOne("DaSaSo.Domain.Model.SewerPoint", "PunktOben")
                         .WithMany()
                         .HasForeignKey("PunktObenId");
@@ -239,6 +358,8 @@ namespace DaSaSo.EntityFramework.Migrations
 
                     b.Navigation("BuildingSite");
 
+                    b.Navigation("PipeLiner");
+
                     b.Navigation("PunktOben");
 
                     b.Navigation("PunktUnten");

DaSaSo.EntityFramework/Services/BuildingsiteDataService.cs

@@ -25,6 +25,11 @@ namespace DaSaSo.EntityFramework.Services
             return await _nonQueryDataService.Create(entity);
         }
 
+        public Buildingsite CreateNonAsync(Buildingsite entity)
+        {
+            throw new NotImplementedException();
+        }
+
         public async Task<bool> Delete(int id)
         {
             return await _nonQueryDataService.Delete(id);

DaSaSo.EntityFramework/Services/ClientDataService.cs

@@ -27,6 +27,11 @@ namespace DaSaSo.EntityFramework.Services
             return await _nonQueryDataService.Create(entity);
         }
 
+        public Client CreateNonAsync(Client entity)
+        {
+            throw new NotImplementedException();
+        }
+
         public async Task<bool> Delete(int id)
         {
             return await _nonQueryDataService.Delete(id);

DaSaSo.EntityFramework/Services/Common/NonQueryDataService.cs

@@ -27,6 +27,16 @@ namespace DaSaSo.EntityFramework.Services.Common
             }
         }
 
+        public T CreateNonAsync(T entity)
+        {
+            using (DaSaSoDbContext context = _contextFactory.CreateDbContext())
+            {
+                EntityEntry<T> createdEntity = context.Set<T>().Add(entity);
+                context.SaveChanges();
+                return createdEntity.Entity;
+            }
+        }
+
         public async Task<bool> Delete(int id)
         {
             using (DaSaSoDbContext context = _contextFactory.CreateDbContext())

DaSaSo.EntityFramework/Services/GenericDataService.cs

@@ -27,6 +27,11 @@ namespace DaSaSo.EntityFramework.Services
             return await _nonQueryDataService.Create(entity);
         }
 
+        public T CreateNonAsync(T entity)
+        {
+            return _nonQueryDataService.CreateNonAsync(entity);
+        }
+
         public async Task<bool> Delete(int id)
         {
             return await _nonQueryDataService.Delete(id);
@@ -56,6 +61,11 @@ namespace DaSaSo.EntityFramework.Services
         {
             return await _nonQueryDataService.Update(id, entity);
         }
+
+        T IDataService<T>.CreateNonAsync(T entity)
+        {
+            return _nonQueryDataService.CreateNonAsync(entity);
+        }
     }
 }
 

DaSaSo.EntityFramework/Services/ProjectDataService.cs

@@ -56,5 +56,10 @@ namespace DaSaSo.EntityFramework.Services
         {
             return await _nonQueryDataService.Update(id, entity);
         }
+
+        public Project CreateNonAsync(Project entity)
+        {
+            return _nonQueryDataService.CreateNonAsync(entity);
+        }
     }
 }

DaSaSo.EntityFramework/Services/SewerObjectDataService.cs

@@ -26,6 +26,11 @@ namespace DaSaSo.EntityFramework.Services
             return await _nonQueryDataService.Create(entity);
         }
 
+        public SewerObject CreateNonAsync(SewerObject entity)
+        {
+            return _nonQueryDataService.CreateNonAsync(entity);
+        }
+
         public async Task<bool> Delete(int id)
         {
             return await _nonQueryDataService.Delete(id);

DaSaSo.InMemoryProvider/InMemoryDataProvider.cs

@@ -15,6 +15,11 @@ namespace DaSaSo.InMemoryProvider
             throw new NotImplementedException();
         }
 
+        public T CreateNonAsync(T entity)
+        {
+            throw new NotImplementedException();
+        }
+
         public Task<bool> Delete(int id)
         {
             throw new NotImplementedException();

DaSaSo.ReadOldDB/Class1.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xaml;
+
+namespace DaSaSo.ReadOldDB
+{
+    public class Class1
+    {
+        
+    }
+}

DaSaSo.ReadOldDB/DaSaSo.ReadOldDB.csproj

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{C2E73172-102E-44C8-93AD-1A30A27A05A3}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>DaSaSo.ReadOldDB</RootNamespace>
+    <AssemblyName>DaSaSo.ReadOldDB</AssemblyName>
+    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xaml" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Class1.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\DaSaSo.Domain\DaSaSo.Domain.csproj">
+      <Project>{9434eb7a-c6ee-46c7-8306-be806375e852}</Project>
+      <Name>DaSaSo.Domain</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

DaSaSo.ReadOldDB/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DaSaSo.ReadOldDB")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Junker & Meves Kanalsanierungstechnik GmbH")]
+[assembly: AssemblyProduct("DaSaSo.ReadOldDB")]
+[assembly: AssemblyCopyright("Copyright © Junker & Meves Kanalsanierungstechnik GmbH 2021")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("c2e73172-102e-44c8-93ad-1a30a27a05a3")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

DaSaSo.ViewModel/BuildingsiteListViewModel.cs

@@ -1,5 +1,6 @@
 using DaSaSo.Domain.Model;
 using DaSaSo.Domain.Services;
+using DaSaSo.Domain.Services.BuildingsiteServices;
 using DaSaSo.EntityFramework.Services;
 using DaSaSo.ViewModel.Commands;
 using DaSaSo.ViewModel.Interface;
@@ -37,15 +38,16 @@ namespace DaSaSo.ViewModel
         }
 
         public ICommand SelectCommand { get; set; }
+        public ICommand AddCommand { get; set; }
 
-        public BuildingsiteListViewModel(IDataService<Buildingsite> buildingSiteDataService, IActualProject actualProject, IRenavigator renavigator)
+        public BuildingsiteListViewModel(IDataService<Buildingsite> buildingSiteDataService, IActualProject actualProject, IRenavigator renavigator,IBuildingsiteService buildingsiteService)
         {
             _actualProject = actualProject;
             _renavigator = renavigator;
             _buildingSiteDataService = buildingSiteDataService as BuildingsiteDataService;
             Buildingsites = new ObservableCollection<Buildingsite>();
             SelectCommand = new SelectBuildingsiteCommand(actualProject, this);
-
+            AddCommand = new AddBuildingsiteCommand(actualProject, buildingsiteService);
             LoadBuildingsites();
         }
 

DaSaSo.ViewModel/ClientListViewModel.cs

@@ -26,7 +26,7 @@ namespace DaSaSo.ViewModel
 
         public ICommand SelectCommand { get; set; }
         public ICommand EditCommand { get; set; }
-        public IRelayCommand AddNewClientCommand { get; set; }
+        public ICommand AddNewClientCommand { get; set; }
 
         public Client SelectedClient
         {
@@ -64,48 +64,10 @@ namespace DaSaSo.ViewModel
             LoadClient();
             SelectCommand = new SelectClientCommand(actualProject, this); //= new RelayCommand(SelectClient, () => SelectedClient != null);
             EditCommand = new EditClientCommand(_dataService,actualProject,renavigator,this);
-            //EditClientCommand = new RelayCommand(EditClient, () => SelectedClient != null);
+            AddNewClientCommand = new AddClientCommand(_dataService, actualProject, renavigator, this);
-            //AddNewClientCommand = new RelayCommand(AddNewClient);
 
         }
 
-        private void edit()
-        {
-            
-            //_navigator.UpdateViewModelCommand.Execute(EViewType.ClientEdit);
-        }
-
-        private async Task<Client> insertNewClient()
-        {
-            Client newClient = new Client()
-            {
-                Firstname = "",
-                LastName = "",
-                Country = "",
-                Postcode = ""
-            };
-
-            await _dataService.Create(newClient);
-            return newClient;
-        }
-        private async void AddNewClient()
-        {
-
-            var d = insertNewClient();
-            await d;
-            Mediator.Notify(Enums.EMediator.EDITCLIENT, d);
-        }
-
-        private void EditClient()
-        {
-            Mediator.Notify(Enums.EMediator.EDITCLIENT, SelectedClient);
-        }
-
-        private void SelectClient()
-        {
-
-            Mediator.Notify(Enums.EMediator.SELECTEDCLIENT, SelectedClient);
-        }
 
         public async void LoadClient()
         {

DaSaSo.ViewModel/Commands/AddBuildingsiteCommand.cs

@@ -0,0 +1,28 @@
+using DaSaSo.Domain.Model;
+using DaSaSo.Domain.Services.BuildingsiteServices;
+using DaSaSo.ViewModel.Interface;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.ViewModel.Commands
+{
+    public class AddBuildingsiteCommand: AsyncCommandBase
+    {
+        private IActualProject actualProject;
+        private IBuildingsiteService buildingsiteService;
+
+        public AddBuildingsiteCommand(IActualProject actualProject, IBuildingsiteService buildingsiteService)
+        {
+            this.actualProject = actualProject;
+            this.buildingsiteService = buildingsiteService;
+        }
+
+        public override async Task ExecuteAsync(object? parameter)
+        {
+            Buildingsite buildingsite = await buildingsiteService.CreateBuildingsite(actualProject.AktuellProjekt);
+        }
+    }
+}

DaSaSo.ViewModel/Commands/AddClientCommand.cs

@@ -0,0 +1,36 @@
+using DaSaSo.Domain.Model;
+using DaSaSo.Domain.Services;
+using DaSaSo.ViewModel.Interface;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.ViewModel.Commands
+{
+    public class AddClientCommand : AsyncCommandBase
+    {
+        private readonly IDataService<Client> dataservice;
+        private readonly IActualProject actualProject;
+        private readonly IRenavigator renavigator;
+        private readonly ClientListViewModel clientListViewModel;
+
+        public AddClientCommand(IDataService<Client> dataservice, IActualProject actualProject, IRenavigator renavigator, ClientListViewModel clientListViewModel)
+        {
+            this.dataservice = dataservice;
+            this.actualProject = actualProject;
+            this.renavigator = renavigator;
+            this.clientListViewModel = clientListViewModel;
+        }
+
+        public override async Task ExecuteAsync(object? parameter)
+        {
+            
+            Client newClient = await dataservice.Create(new Client());
+            actualProject.SetClient(newClient);
+            //actualProject.SetClient(clientListViewModel.SelectedClient);
+            renavigator.Renavigate(new ClientEditViewModel(dataservice, actualProject, renavigator));
+        }
+    }
+}

DaSaSo.ViewModel/Commands/AddProjectCommand.cs

@@ -0,0 +1,30 @@
+using DaSaSo.Domain.Model;
+using DaSaSo.Domain.Services;
+using DaSaSo.Domain.Services.ProjectServices;
+using DaSaSo.ViewModel.Interface;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.ViewModel.Commands
+{
+    public class AddProjectCommand : AsyncCommandBase
+    {
+        private readonly IActualProject actualProject;
+        private readonly IProjectService _projectService;
+
+        public AddProjectCommand(IActualProject actualProject, IProjectService projectService)
+        {
+            this.actualProject = actualProject;
+            _projectService = projectService;
+        }
+
+        public override async Task ExecuteAsync(object? parameter)
+        {
+            Project pro = await _projectService.CreateProject(actualProject.AktuellClient);
+            
+        }
+    }
+}

DaSaSo.ViewModel/Commands/EditProjectCommand.cs

@@ -0,0 +1,37 @@
+using DaSaSo.Domain.Model;
+using DaSaSo.Domain.Services;
+using DaSaSo.Domain.Services.ProjectServices;
+using DaSaSo.ViewModel.Interface;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DaSaSo.ViewModel.Commands
+{
+    class EditProjectCommand : AsyncCommandBase
+    {
+        private IDataService<Project> _dataService;
+        private IActualProject _actualProject;
+        private IRenavigator _renavigator;
+        private readonly IProjectService _projectService;
+        private ProjectListViewModel _projectListViewModel;
+
+        public EditProjectCommand(IDataService<Project> dataService, IActualProject actualProject, IRenavigator renavigator, IProjectService projectService, ProjectListViewModel projectListViewModel)
+        {
+            this._dataService = dataService;
+            this._actualProject = actualProject;
+            this._renavigator = renavigator;
+            this._projectService = projectService;
+            this._projectListViewModel = projectListViewModel;
+            
+        }
+
+        public override async Task ExecuteAsync(object? parameter)
+        {
+            _actualProject.SetProject(_projectListViewModel.SelectedProject);
+            _renavigator.Renavigate(new ProjectEditViewModel(_dataService, _actualProject, _renavigator,_projectService));
+        }
+    }
+}

DaSaSo.ViewModel/Interface/IActualProject.cs

@@ -19,7 +19,7 @@ namespace DaSaSo.ViewModel.Interface
         SewerObject AktuellSewerObject { get; }
 
         void SetClient(Client client);
-        void SetProject(Project project);
+        void SetProject(Project project, bool notification = true);
         void SetBuildingSite(Buildingsite buildingsite);
         void SetSewerObject(SewerObject sewerObject);
         void ResetProject();

DaSaSo.ViewModel/ProjectEditViewModel.cs

@@ -0,0 +1,56 @@
+using DaSaSo.Domain.Model;
+using DaSaSo.Domain.Services;
+using DaSaSo.Domain.Services.ProjectServices;
+using DaSaSo.ViewModel.Commands;
+using DaSaSo.ViewModel.Interface;
+using Microsoft.Toolkit.Mvvm.Input;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace DaSaSo.ViewModel
+{
+    public class ProjectEditViewModel : BaseViewModel
+    {
+        private Project _model;
+        private readonly IDataService<Project> _dataservice;
+        private readonly IActualProject _actualProject;
+        private readonly IRenavigator _renavigator;
+        private readonly IProjectService _projectService;
+
+        public IRelayCommand SaveProjectCommand { get; set; }
+        public string ProjektName
+        {
+            get => _model.Name;
+            set
+            {
+                if (_model.Name != value)
+                {
+                    _model.Name = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+
+        public ProjectEditViewModel(IDataService<Project> dataservice, IActualProject actualProject,IRenavigator renavigator, IProjectService projectService)
+        {
+            _dataservice = dataservice;
+            _actualProject = actualProject;
+            _renavigator = renavigator;
+            _projectService = projectService;
+            _model = actualProject.AktuellProjekt;
+            SaveProjectCommand = new RelayCommand(SaveProject);
+            //SaveProjectCommand = new EditProjectCommand(_dataservice, _actualProject, _renavigator, this);
+
+        }
+
+        private void SaveProject()
+        {
+            _dataservice.Update(_model.Id, _model);
+            _renavigator.Renavigate(new ProjectListViewModel(_dataservice, _actualProject, _renavigator, _projectService));
+        }
+    }
+}

DaSaSo.ViewModel/ProjectListViewModel.cs

@@ -1,5 +1,6 @@
 using DaSaSo.Domain.Model;
 using DaSaSo.Domain.Services;
+using DaSaSo.Domain.Services.ProjectServices;
 using DaSaSo.EntityFramework.Services;
 using DaSaSo.ViewModel.Commands;
 using DaSaSo.ViewModel.Interface;
@@ -37,7 +38,9 @@ namespace DaSaSo.ViewModel
         }
 
         public ICommand SelectCommand { get; set; }
-        public ProjectListViewModel(IDataService<Project> genericDataService, IActualProject actualProject, IRenavigator renavigator)
+        public ICommand AddCommand { get; set; }
+        public ICommand EditCommand { get; set; }
+        public ProjectListViewModel(IDataService<Project> genericDataService, IActualProject actualProject, IRenavigator renavigator, IProjectService projectService)
         {
             Projekte = new ObservableCollection<Project>();
             if (genericDataService == null) throw new ArgumentNullException("genericDataService");
@@ -46,6 +49,8 @@ namespace DaSaSo.ViewModel
             this.actualProject = actualProject;
             this.renavigator = renavigator;
             SelectCommand = new SelectProjectCommand(actualProject, this);
+            AddCommand = new AddProjectCommand(actualProject, projectService);
+            EditCommand = new EditProjectCommand(genericDataService, actualProject, renavigator,projectService, this);
             LoadProjecte();
         }
 

DaSaSo.ViewModel/State/ActualState/ActualProject.cs

@@ -41,9 +41,10 @@ namespace DaSaSo.ViewModel.State.ActualState
             OnClientChanged();
         }
 
-        public void SetProject(Project project)
+        public void SetProject(Project project, bool notification = true)
         {
             AktuellProjekt = project;
+            if(notification)
                 OnProjectChanged();
         }
 

DaSaSo.Wpf/App.xaml.cs

@@ -1,5 +1,7 @@
 using DaSaSo.Domain.Model;
 using DaSaSo.Domain.Services;
+using DaSaSo.Domain.Services.BuildingsiteServices;
+using DaSaSo.Domain.Services.ProjectServices;
 using DaSaSo.EntityFramework;
 using DaSaSo.EntityFramework.Services;
 using DaSaSo.ViewModel;
@@ -46,7 +48,8 @@ namespace DaSaSo.Wpf
                     services.AddSingleton<IDataService<Buildingsite>, BuildingsiteDataService>();
                     services.AddSingleton<IDataService<SewerObject>, SewerObjectDataService>();
                     services.AddSingleton<ClientListViewModel>();
-
+                    services.AddSingleton<IProjectService, ProjectService>();
+                    services.AddSingleton<IBuildingsiteService, BuildingsiteService>();
 
 
                     services.AddSingleton<IViewModelAbstractFactory, MainWindowViewModelFactory>();
@@ -79,7 +82,10 @@ namespace DaSaSo.Wpf
                             services.GetRequiredService<IDataService<Project>>(),
                             services.GetRequiredService<IActualProject>(),
                             new ViewModelDelegateRenavigator(
-                                services.GetRequiredService<INavigator>()));
+                                services.GetRequiredService<INavigator>()),
+                            services.GetRequiredService<IProjectService>()
+                            
+                            );
                     });
 
                     services.AddSingleton<CreateViewModel<BuildingsiteListViewModel>>(services =>
@@ -88,7 +94,9 @@ namespace DaSaSo.Wpf
                             services.GetRequiredService<IDataService<Buildingsite>>(),
                             services.GetRequiredService<IActualProject>(),
                             new ViewModelDelegateRenavigator(
-                                services.GetRequiredService<INavigator>()));
+                                services.GetRequiredService<INavigator>()),
+                            services.GetRequiredService<IBuildingsiteService>()
+                            );
                     });
 
                     services.AddSingleton<CreateViewModel<SewerObjectListViewModel>>(services =>

DaSaSo.Wpf/DaSaSo.Wpf.csproj.user

@@ -25,6 +25,9 @@
     <Compile Update="View\HomeView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Update="View\Project\ProjectEditView.xaml.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Update="View\Project\ProjectListView.xaml.cs">
       <SubType>Code</SubType>
     </Compile>
@@ -60,6 +63,9 @@
     <Page Update="View\HomeView.xaml">
       <SubType>Designer</SubType>
     </Page>
+    <Page Update="View\Project\ProjectEditView.xaml">
+      <SubType>Designer</SubType>
+    </Page>
     <Page Update="View\Project\ProjectListView.xaml">
       <SubType>Designer</SubType>
     </Page>

DaSaSo.Wpf/View/Buildingsites/BuildingSiteListView.xaml

@@ -3,13 +3,14 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
-             xmlns:local="clr-namespace:DaSaSo.Wpf.View.Buildingsites"
+             xmlns:local="clr-namespace:DaSaSo.Wpf.View.Buildingsites" xmlns:viewmodel="clr-namespace:DaSaSo.ViewModel;assembly=DaSaSo.ViewModel" d:DataContext="{d:DesignInstance Type=viewmodel:BuildingsiteListViewModel}"
              mc:Ignorable="d" 
              d:DesignHeight="450" d:DesignWidth="800">
     <Grid>
         <StackPanel>
             <DataGrid ItemsSource="{Binding Buildingsites}" SelectedItem="{Binding SelectedBuildingsite}" />
             <Button Content="Selektiere" Command="{Binding SelectCommand}" />
+            <Button Content="Hinzufügen" Command="{Binding AddCommand}" />
         </StackPanel>
     </Grid>
 </UserControl>

DaSaSo.Wpf/View/Project/ProjectEditView.xaml

@@ -0,0 +1,23 @@
+<UserControl x:Class="DaSaSo.Wpf.View.Project.ProjectEditView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:DaSaSo.Wpf.View.Project" xmlns:viewmodel="clr-namespace:DaSaSo.ViewModel;assembly=DaSaSo.ViewModel" d:DataContext="{d:DesignInstance Type=viewmodel:ProjectEditViewModel}"
+             mc:Ignorable="d" 
+             d:DesignHeight="450" d:DesignWidth="800">
+    <Grid>
+        <StackPanel>
+            <Grid>
+                <Grid.ColumnDefinitions>
+                    <ColumnDefinition />
+                    <ColumnDefinition />
+                </Grid.ColumnDefinitions>
+                <Label Grid.Column="0" Content="Projektname" />
+                <TextBox Grid.Column="1" Text="{Binding ProjektName}" />
+            </Grid>
+            <Button Content="Speichern" Command="{Binding SaveProjectCommand}" />
+        </StackPanel>
+            
+    </Grid>
+</UserControl>

DaSaSo.Wpf/View/Project/ProjectEditView.xaml.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace DaSaSo.Wpf.View.Project
+{
+    /// <summary>
+    /// Interaction logic for ProjectEditView.xaml
+    /// </summary>
+    public partial class ProjectEditView : UserControl
+    {
+        public ProjectEditView()
+        {
+            InitializeComponent();
+        }
+    }
+}

DaSaSo.Wpf/View/Project/ProjectListView.xaml

@@ -12,6 +12,8 @@
 
             </DataGrid>
             <Button Content="Selektiere" Command="{Binding SelectCommand}" />
+            <Button Content="Hinzufügen" Command="{Binding AddCommand}" />
+            <Button Content="Bearbeiten" Command="{Binding EditCommand}" />
         </StackPanel>
 
     </Grid>

DaSaSo.Wpf/Window/MainWindow.xaml

@@ -22,6 +22,9 @@
         <DataTemplate DataType="{x:Type viewmodel:ProjectListViewModel}">
             <ProjektViews:ProjectListView />
         </DataTemplate>
+        <DataTemplate DataType="{x:Type viewmodel:ProjectEditViewModel}">
+            <ProjektViews:ProjectEditView />
+        </DataTemplate>
         <DataTemplate DataType="{x:Type viewmodel:HomeViewModel}">
             <View:HomeView />
         </DataTemplate>