SchachtDataService hinzugefügt

SewerStammGen.ConsoleApp/Program.cs

@@ -1,5 +1,5 @@
 using SewerStammGen.DAL.Services;
-
+using SewerStammGen.DAL.Services.PostgresqlData;
 using SewerStammGen.Shared.Contracts;
 using SewerStammGen.Shared.Domain;
 using SewerStammGen.Shared.Enum;

SewerStammGen.DAL/Services/PostgresqlData/AuftraggeberDataService.cs

@@ -7,31 +7,15 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace SewerStammGen.DAL.Services
+namespace SewerStammGen.DAL.Services.PostgresqlData
 {
     public class AuftraggeberDataService : PostgresqlDataService, IAuftraggeberDataService
     {
-        /*
+        public AuftraggeberDataService(string connectionstring) : base(connectionstring,"Auftraggebers") { }
-         * CREATE TABLE public."Auftraggebers"
-(
-    "Id" serial,
-    "Name" text,
-    "Strasse" text,
-    "Ort" text,
-    "Postleitzahl" text,
-    "Ansprechpartner" text,
-    "Telefonnummer" text,
-    PRIMARY KEY ("Id")
-);
-
-ALTER TABLE IF EXISTS public."Auftraggebers"
-    OWNER to "SewerGen";
-        */
-        public AuftraggeberDataService() : base("public.\"Auftraggebers\"") { }
 
         public async Task<Auftraggeber> Create(Auftraggeber entity)
         {
-            string command = "INSERT INTO public.\"Auftraggebers\" (\"Name\", \"Strasse\", \"Ort\", \"Postleitzahl\", \"Ansprechpartner\", \"Telefonnummer\") " +
+            string command = "INSERT INTO "+tableName+" (\"Name\", \"Strasse\", \"Ort\", \"Postleitzahl\", \"Ansprechpartner\", \"Telefonnummer\") " +
                 "VALUES(@1,@2,@3,@4,@5,@6) RETURNING \"Id\"";
 
             await using (var cmd = new NpgsqlCommand(command, conn))
@@ -53,7 +37,7 @@ ALTER TABLE IF EXISTS public."Auftraggebers"
         public async Task<Auftraggeber> Get(int id)
         {
             Auftraggeber result = new Auftraggeber();
-            using (var cmd = new NpgsqlCommand($"SELECT * FROM public.\"Auftraggebers\" WHERE \"Id\" = @1", conn))
+            using (var cmd = new NpgsqlCommand($"SELECT * FROM "+tableName+" WHERE \"Id\" = @1", conn))
             {
                 cmd.Parameters.AddWithValue("1", id);
                 using var reader = await cmd.ExecuteReaderAsync();
@@ -80,7 +64,7 @@ ALTER TABLE IF EXISTS public."Auftraggebers"
         public async Task<IEnumerable<Auftraggeber>> GetAll()
         {
             List<Auftraggeber> result = new List<Auftraggeber>();
-            using (var cmd = new NpgsqlCommand($"SELECT * FROM public.\"Auftraggebers\"", conn))
+            using (var cmd = new NpgsqlCommand($"SELECT * FROM "+tableName, conn))
             using (var reader = await cmd.ExecuteReaderAsync())
             {
                 while (reader.Read())

SewerStammGen.DAL/Services/PostgresqlData/HaltungDataService.cs

@@ -0,0 +1,85 @@
+using Npgsql;
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.DAL.Services.PostgresqlData
+{
+    public class HaltungDataService : PostgresqlDataService, IHaltungDataService
+    {
+        public HaltungDataService(string connectionstring) : base(connectionstring, "Kanaele")
+        {
+        }
+
+        public Task<Kanal> Create(Kanal entity)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<Kanal> Get(int id)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<IEnumerable<Kanal>> GetAll()
+        {
+            throw new NotImplementedException();
+        }
+
+        public async Task<IEnumerable<Kanal>> GetAllByProjekt(int projektID)
+        {
+            List<Kanal> result = new List<Kanal>();
+            ISchachtDataService schachtDataService = new SchachtDataService(connString);
+            IEnumerable<Schacht> schaechte = await schachtDataService.GetAllByProjekt(projektID);
+
+            string command = "SELECT * FROM " + tableName + " WHERE \"ProjektId\" = @1";
+            using (var cmd = new NpgsqlCommand(command, conn))
+            {
+                cmd.Parameters.AddWithValue("1", projektID);
+                using (var reader = await cmd.ExecuteReaderAsync())
+                {
+                    while(reader.Read())
+                    {
+                        Kanal adding = parseHaltung(reader);
+
+                        adding.StartSchacht = schaechte.Where(x => x.Id == reader.GetInt32(2)).Last();
+                        adding.EndSchacht = schaechte.Where(x => x.Id == reader.GetInt32(3)).Last();
+                        result.Add(adding);
+                    }
+                }
+            }
+            return result;
+
+        }
+
+        private Kanal parseHaltung(NpgsqlDataReader reader)
+        {
+            return new Kanal()
+            {
+                Id = reader.GetInt32(0),
+                Objektbezeichnung = reader.GetString(1),
+                //StartSchacht = reader.GetInt32(2),
+                //EndSchacht = reader.GetInt32(3),
+                DN = reader.GetInt32(4),
+                Material = reader.GetString(5),
+                Haltungslaenge = reader.GetDecimal(6),
+                Entwaesserung = (EEntwaeserung)reader.GetInt32(7),
+                Projekt = new Projekt() { Id = reader.GetInt32(8) }
+            };
+        }
+
+        public async Task<IEnumerable<Kanal>> GetAllByProjekt(Projekt projekt)
+        {
+            return await GetAllByProjekt(projekt.Id);
+        }
+
+        public Task<Kanal> Update(Kanal entity)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

SewerStammGen.DAL/Services/PostgresqlData/PostgresqlDataService.cs

@@ -6,22 +6,23 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace SewerStammGen.DAL.Services
+namespace SewerStammGen.DAL.Services.PostgresqlData
 {
     public class PostgresqlDataService : IDisposable
     {
-        string connString = "Host = localhost; Database = SewerGen; Username = SewerGen; Password = SewerGen";
+        protected readonly string connString; // = "Host = localhost; Database = SewerGen; Username = SewerGen; Password = SewerGen";
         NpgsqlDataSource dataSource;
         protected NpgsqlConnection? conn = null;
-        private string tableName = "";
+        protected string tableName = "";
 
-        public PostgresqlDataService(string tableName)
+        public PostgresqlDataService(string connectionstring, string tableName)
         {
+            this.connString = connectionstring;
             var dataSourceBuilder = new NpgsqlDataSourceBuilder(connString);
             dataSource = dataSourceBuilder.Build();
 
             conn = dataSource.OpenConnection();
-            this.tableName = tableName;
+            this.tableName = string.Format("public.\"{0}\"", tableName);
 
         }
 

SewerStammGen.DAL/Services/PostgresqlData/ProjektDataService.cs

@@ -10,20 +10,27 @@ using SewerStammGen.Shared.Domain;
 using SewerStammGen.Shared.Enum;
 using System.Diagnostics;
 
-namespace SewerStammGen.DAL.Services
+namespace SewerStammGen.DAL.Services.PostgresqlData
 {
     public class ProjektDataService : PostgresqlDataService, IProjektDataService
     {
-        public ProjektDataService() : base("public.\"Projekte\"")
+        public ProjektDataService(string connectionstring) : base(connectionstring,"Projekte")
         {
 
         }
 
         public async Task<Projekt> Create(Projekt entity)
         {
-            string command = "INSERT INTO public.\"Projekte\" (\"Projektname\", \"Erstelldatum\", \"Strasse\", \"Ort\", \"ExportType\", \"Kodierungssystem\",\"AuftraggeberId\") " +
+            string command = "INSERT INTO "+tableName+" (\"Projektname\", \"Erstelldatum\", \"Strasse\", \"Ort\", \"ExportType\", \"Kodierungssystem\",\"AuftraggeberId\") " +
                 "VALUES(@1,@2,@3,@4,@5,@6,@7) RETURNING \"Id\"";
 
+            if (entity.Auftraggeber.Id == 0)
+            {
+                IAuftraggeberDataService auftraggeberDataService = new AuftraggeberDataService(connString);
+                var s = await auftraggeberDataService.GetAll();
+                entity.Auftraggeber = s.ToList().Last();
+            }
+
             await using (var cmd = new NpgsqlCommand(command, conn))
             {
                 cmd.Parameters.AddWithValue("1", entity.Projektname);
@@ -44,8 +51,8 @@ namespace SewerStammGen.DAL.Services
         public async Task<Projekt> Get(int id)
         {
             Projekt result = new Projekt();
-            IAuftraggeberDataService auftraggeberDataService = new AuftraggeberDataService();
+            IAuftraggeberDataService auftraggeberDataService = new AuftraggeberDataService(connString);
-            using (var cmd = new NpgsqlCommand($"SELECT * FROM public.\"Projekte\" WHERE \"Id\" = @1", conn))
+            using (var cmd = new NpgsqlCommand($"SELECT * FROM "+tableName+" WHERE \"Id\" = @1", conn))
             {
                 cmd.Parameters.AddWithValue("1", id);
                 using var reader = await cmd.ExecuteReaderAsync();
@@ -72,12 +79,12 @@ namespace SewerStammGen.DAL.Services
 
         public async Task<IEnumerable<Projekt>> GetAll()
         {
-            IAuftraggeberDataService auftraggeberDataService = new AuftraggeberDataService();
+            IAuftraggeberDataService auftraggeberDataService = new AuftraggeberDataService(connString);
 
             IEnumerable<Auftraggeber> auftraggebers = await auftraggeberDataService.GetAll();
 
             List<Projekt> result = new List<Projekt>();
-            using (var cmd = new NpgsqlCommand($"SELECT * FROM public.\"Projekte\"", conn))
+            using (var cmd = new NpgsqlCommand($"SELECT * FROM " + tableName, conn))
             using (var reader = await cmd.ExecuteReaderAsync())
             {
                 while (reader.Read())
@@ -92,7 +99,7 @@ namespace SewerStammGen.DAL.Services
 
         public async Task<Projekt> Update(Projekt entity)
         {
-            string command = "UPDATE public.\"Projekte\" SET \"Projektname\"=@1, \"Erstelldatum\"=@2, \"Strasse\"=@3, \"Ort\"=@4, \"ExportType\"=@5, \"Kodierungssystem\"=@6 WHERE \"Id\" = @8";
+            string command = "UPDATE "+tableName+" SET \"Projektname\"=@1, \"Erstelldatum\"=@2, \"Strasse\"=@3, \"Ort\"=@4, \"ExportType\"=@5, \"Kodierungssystem\"=@6 WHERE \"Id\" = @8";
             using (var cmd = new NpgsqlCommand(command, conn))
             {
                 cmd.Parameters.AddWithValue("1", entity.Projektname);
@@ -109,26 +116,3 @@ namespace SewerStammGen.DAL.Services
         }
     }
 }
-
-/*
- * CREATE TABLE public."Projekte"
-(
-    "Id" serial,
-    "Projektname" text,
-    "Erstelldatum" text,
-    "Strasse" text,
-    "Ort" text,
-    "ExportType" bigint,
-    "Kodierungssystem" bigint,
-    "AuftraggeberId" bigint,
-    PRIMARY KEY ("Id"),
-    CONSTRAINT "Auftraggeber" FOREIGN KEY ("AuftraggeberId")
-        REFERENCES public."Auftraggebers" ("Id") MATCH SIMPLE
-        ON UPDATE NO ACTION
-        ON DELETE NO ACTION
-        NOT VALID
-);
-
-ALTER TABLE IF EXISTS public."Projekte"
-    OWNER to "SewerGen";
-*/

SewerStammGen.DAL/Services/PostgresqlData/SchachtDataService.cs

@@ -0,0 +1,109 @@
+using Npgsql;
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.DAL.Services.PostgresqlData
+{
+    public class SchachtDataService : PostgresqlDataService, ISchachtDataService
+    {
+        public SchachtDataService(string connectionstring) : base(connectionstring,"Schaechte")
+        {
+        }
+
+        public async Task<Schacht> Create(Schacht entity)
+        {
+            string command = "INSERT INTO " + tableName + " (\"Objektbezeichnung\",\"RechtsWert\",\"HochWert\",\"SohlHoehe\",\"DeckelHoehe\",\"Entwaesserung\",\"ProjektId\") VALUES " +
+                "(@1,@2,@3,@4,@5,@6,@7) RETURNING \"Id\"";
+            using(var cmd = new NpgsqlCommand(command,conn))
+            {
+                cmd.Parameters.AddWithValue("1", entity.Objektbezeichnung);
+                cmd.Parameters.AddWithValue("2", entity.RechtsWert);
+                cmd.Parameters.AddWithValue("3", entity.HochWert);
+                cmd.Parameters.AddWithValue("4", entity.SohlHoehe);
+                cmd.Parameters.AddWithValue("5", entity.DeckelHoehe);
+                cmd.Parameters.AddWithValue("6", (int)entity.Entwaesserung);
+                cmd.Parameters.AddWithValue("7", entity.Projekt.Id);
+                using var reader = await cmd.ExecuteReaderAsync();
+                reader.Read();
+                entity.Id = reader.GetInt32(0);
+            }
+            return entity;
+        }
+
+        public Task<Schacht> Get(int id)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task<IEnumerable<Schacht>> GetAll()
+        {
+            throw new NotImplementedException();
+        }
+
+        private Schacht parseSchacht(NpgsqlDataReader? reader)
+        {
+            return new Schacht()
+            {
+                Id = reader.GetInt32(0),
+                Objektbezeichnung = reader.IsDBNull(1) ? "": reader.GetString(1),
+                RechtsWert = reader.GetDecimal(2),
+                HochWert = reader.GetDecimal(3),
+                SohlHoehe = reader.GetDecimal(4),
+                DeckelHoehe = reader.GetDecimal(5),
+                Entwaesserung = (EEntwaeserung)reader.GetInt32(6),
+                Projekt = new Projekt() { Id = reader.GetInt32(7) },
+            };
+        }
+
+        public async Task<IEnumerable<Schacht>> GetAllByProjekt(int projektID)
+        {
+            List<Schacht> result = new List<Schacht>();
+            string command = @"SELECT * FROM " + tableName + " WHERE \"ProjektId\" = @1";
+            using (var cmd = new NpgsqlCommand(command, conn))
+            {
+                cmd.Parameters.AddWithValue("1", projektID);
+                using (var reader = await cmd.ExecuteReaderAsync())
+                {
+                    while(reader.Read())
+                    {
+                        result.Add(parseSchacht(reader));
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        public async Task<IEnumerable<Schacht>> GetAllByProjekt(Projekt projekt)
+        {
+            return await GetAllByProjekt(projekt.Id);
+        }
+
+        public async Task<Schacht> Update(Schacht entity)
+        {
+            string command = @"UPDATE " + tableName + "SET \"Objektbezeichnung\" =@1, \"RechtsWert\"=@2," +
+                " \"HochWert\"=@3, \"SohlHoehe\"=@4, \"DeckelHoehe\"=@5, \"Entwaesserung\"=@6," +
+                " \"ProjektId\"=@7 WHERE \"Id\"=@8";
+            using(var cmd = new NpgsqlCommand(command,conn))
+            {
+                cmd.Parameters.AddWithValue("1", entity.Objektbezeichnung);
+                cmd.Parameters.AddWithValue("2", entity.RechtsWert);
+                cmd.Parameters.AddWithValue("3", entity.HochWert);
+                cmd.Parameters.AddWithValue("4", entity.SohlHoehe);
+                cmd.Parameters.AddWithValue("5", entity.DeckelHoehe);
+                cmd.Parameters.AddWithValue("6", (int)entity.Entwaesserung);
+                cmd.Parameters.AddWithValue("7", entity.Projekt.Id);
+                cmd.Parameters.AddWithValue("8", entity.Id);
+
+                await cmd.ExecuteNonQueryAsync();
+            }
+            return entity;
+
+        }
+    }
+}

SewerStammGen.DAL/Services/SchachtDataService.cs

@@ -1,53 +0,0 @@
-using Npgsql;
-using SewerStammGen.Shared.Contracts;
-using SewerStammGen.Shared.Domain;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace SewerStammGen.DAL.Services
-{
-    public class SchachtDataService : PostgresqlDataService, ISchachtDataService
-    {
-        public SchachtDataService() : base("public.\"Schaechte\"")
-        {
-        }
-
-        public Task<Schacht> Create(Schacht entity)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<Schacht> Get(int id)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<IEnumerable<Schacht>> GetAll()
-        {
-            throw new NotImplementedException();
-        }
-
-        private Schacht parseSchacht(NpgsqlDataReader? reader)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<IEnumerable<Schacht>> GetAllByProjekt(int projektID)
-        {
-            throw new NotImplementedException();
-        }
-
-        public async Task<IEnumerable<Schacht>> GetAllByProjekt(Projekt projekt)
-        {
-            return await GetAllByProjekt(projekt.Id);
-        }
-
-        public Task<Schacht> Update(Schacht entity)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}

SewerStammGen.DAL/SewerStammGen.DAL.csproj

@@ -15,4 +15,8 @@
     <ProjectReference Include="..\Shared\SewerStammGen.Shared.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Services\SQLiteData\" />
+  </ItemGroup>
+
 </Project>

SewerStammGen.Shared/Contracts/IHaltungDataService.cs

@@ -0,0 +1,16 @@
+using SewerStammGen.Shared.Domain;
+using Shared.Contracts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.Shared.Contracts
+{
+    public interface IHaltungDataService : IDataService<Kanal>
+    {
+        Task<IEnumerable<Kanal>> GetAllByProjekt(int projektID);
+        Task<IEnumerable<Kanal>> GetAllByProjekt(Projekt projekt);
+    }
+}

SewerStammGen.Shared/Domain/Kanal.cs

@@ -9,12 +9,12 @@ namespace SewerStammGen.Shared.Domain
     public class Kanal : DBObject
     {
         public string Objektbezeichnung { get; set; } = String.Empty;
-        public Schacht? StartSchacht { get; set; }
+        public Schacht StartSchacht { get; set; } = new Schacht();
-        public Schacht? EndSchacht { get; set; }
+        public Schacht EndSchacht { get; set; } = new Schacht();
         public int DN { get; set; }
         public string Material { get; set; } = String.Empty;
         public decimal Haltungslaenge { get; set; }
-        public Projekt? Projekt { get; set; }
+        public Projekt Projekt { get; set; } = new Projekt();
         public EEntwaeserung Entwaesserung { get; set; }
 
     }

SewerStammGen.Shared/Domain/Schacht.cs

@@ -14,7 +14,7 @@ namespace SewerStammGen.Shared.Domain
         public decimal HochWert { get; set; }
         public decimal SohlHoehe { get; set; }
         public decimal DeckelHoehe { get; set; }
-        public Projekt? Projekt { get; set; }
+        public Projekt Projekt { get; set; } = new Projekt();
         public EEntwaeserung Entwaesserung { get; set; }
     }
 

SewerStammGen.WPF/App.xaml.cs

@@ -53,7 +53,7 @@ namespace SewerStammGen.WPF
             try
             {
                 Exception ex = (Exception)e.ExceptionObject;
-                string text = "An application error occured. Plrease contact the Administrator with the following information:\n\n";
+                string text = "An application error occured. Please contact the Administrator with the following information:\n\n";
                 MessageBox.Show(text + " " + ex.Message + "\n\n" + ex.StackTrace);
             }
             catch (Exception ex2)

SewerStammGen.WPF/Commands/HaltungEditCommand.cs

@@ -28,7 +28,7 @@ namespace SewerStammGen.WPF.Commands
 
         public override async Task ExecuteAsync(object? parameter)
         {
-            //actualState.SetHaltung(haltungListViewModel.SelectedHaltung);
+            actualState.SetHaltung(haltungListViewModel.SelectedHaltung);
             renavigator.Renavigate();
         }
     }

SewerStammGen.WPF/Commands/HaltungEditSaveCommand.cs

@@ -1,5 +1,6 @@
 using SewerStammGen.Shared.Contracts;
 using SewerStammGen.Shared.Domain;
+using SewerStammGen.WPF.Interface.Navigator;
 using SewerStammGen.WPF.ViewModel;
 using Shared.Contracts;
 using System;
@@ -13,26 +14,22 @@ namespace SewerStammGen.WPF.Commands
 {
     internal class HaltungEditSaveCommand : AsyncCommandBase
     {
-        private HaltungEditViewModel haltungEditViewModel;
+        private readonly HaltungEditViewModel _haltungEditViewModel;
-        private IDataService<Kanal> kanalDataService;
+        private readonly IHaltungDataService _haltungDataService;
+        private readonly IRenavigator _renavigator;
 
-
+        public HaltungEditSaveCommand(IHaltungDataService haltungDataService,IRenavigator renavigator,HaltungEditViewModel haltungEditViewModel)
-        public HaltungEditSaveCommand(HaltungEditViewModel haltungEditViewModel)
         {
-            this.haltungEditViewModel = haltungEditViewModel;
+            this._haltungEditViewModel = haltungEditViewModel;
-            //this.kanalDataService = kanalDataService;
+            this._haltungDataService = haltungDataService;
-            
+            this._renavigator = renavigator;
         }
 
         public override async Task ExecuteAsync(object? parameter)
         {
-            if(haltungEditViewModel._oberePunkt != haltungEditViewModel.Model.StartSchacht.Objektbezeichnung)
+            _haltungEditViewModel.Model = await _haltungDataService.Update(_haltungEditViewModel.Model);
-            {
+
-                //Schacht s = await schachtService.FindSchachtByNameAndProjektID(haltungEditViewModel._oberePunkt, haltungEditViewModel.Model.Projekt.Id);
+            _renavigator.Renavigate();
-                //haltungEditViewModel.Model.StartSchacht = s;
-            }
-            //haltungEditViewModel.Model = await kanalDataService.Update(haltungEditViewModel.Model.Id, haltungEditViewModel.Model);
-            Trace.WriteLine("Daten gespeichert");
         }
     }
 }

SewerStammGen.WPF/Commands/ProjektAddCommand.cs

@@ -1,4 +1,5 @@
-using SewerStammGen.Shared.Domain;
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
 using SewerStammGen.WPF.Interface.Navigator;
 using SewerStammGen.WPF.ViewModel.State;
 using Shared.Contracts;
@@ -13,10 +14,10 @@ namespace SewerStammGen.WPF.Commands
     internal class ProjektAddCommand : AsyncCommandBase
     {
         private readonly IActualState _actualState;
-        private readonly IDataService<Projekt> _generic;
+        private readonly IProjektDataService _generic;
         private readonly IRenavigator _renavigator;
 
-        public ProjektAddCommand(IDataService<Projekt> generic, IActualState actualState, IRenavigator renavigator)
+        public ProjektAddCommand(IProjektDataService generic, IActualState actualState, IRenavigator renavigator)
         {
             _renavigator = renavigator;
             _generic = generic;
@@ -35,7 +36,7 @@ namespace SewerStammGen.WPF.Commands
                 Schaechte = new List<Schacht>(),
                 Kanaele = new List<Kanal>()
             };
-            //newProjekt = await _generic.Create(newProjekt);
+            newProjekt = await _generic.Create(newProjekt);
             _actualState.SetProjekt(newProjekt);
             _renavigator.Renavigate();
             

SewerStammGen.WPF/Commands/SchachtAddCommand.cs

@@ -15,22 +15,22 @@ namespace SewerStammGen.WPF.Commands
     {
         private readonly IActualState actualState;
         private readonly IRenavigator renavigator;
-        private readonly IDataService<Projekt> projektService;
         
 
-        public SchachtAddCommand(IDataService<Projekt> projektService, IActualState actualState, IRenavigator renavigator)
+        public SchachtAddCommand(IActualState actualState, IRenavigator renavigator)
         {
             this.actualState = actualState;
             this.renavigator = renavigator;
-            this.projektService = projektService;
-            
         }
 
         public override async Task ExecuteAsync(object? parameter)
         {
-            Projekt aktuelleProjekt = await projektService.Get(actualState.ProjektID);
+            Schacht newSchacht = new Schacht()
-           // Schacht schacht = await schachtService.CreateSchacht(aktuelleProjekt);
+            {
-
+                Projekt = new Projekt() { Id = actualState.ProjektID },
+            };
+            actualState.SetSchacht(newSchacht);
+            renavigator.Renavigate();
         }
     }
 }

SewerStammGen.WPF/Commands/SchachtEditCommand.cs

@@ -12,14 +12,13 @@ namespace SewerStammGen.WPF.Commands
 {
     class SchachtEditCommand : AsyncCommandBase
     {
-        private ISchachtDataService schachtService;
+
         private IActualState actualState;
         private IRenavigator renavigator;
         private ManholeListViewModel manholeListViewModel;
 
-        public SchachtEditCommand(ISchachtDataService schachtService, IActualState actualState, IRenavigator renavigator, ManholeListViewModel manholeListViewModel)
+        public SchachtEditCommand(IActualState actualState, IRenavigator renavigator, ManholeListViewModel manholeListViewModel)
         {
-            this.schachtService = schachtService;
             this.actualState = actualState;
             this.renavigator = renavigator;
             this.manholeListViewModel = manholeListViewModel;

SewerStammGen.WPF/HostBuilders/AddServicesHostBuilderExtensions.cs

@@ -1,6 +1,6 @@
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
-using SewerStammGen.DAL.Services;
 using SewerStammGen.Shared.Contracts;
 using SewerStammGen.WPF.Interface.Navigator;
 using SewerStammGen.WPF.ViewModel;
@@ -9,6 +9,7 @@ using Shared.Contracts;
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -20,13 +21,25 @@ namespace SewerStammGen.HostBuilders
     {
         public static IHostBuilder AddServices(this IHostBuilder host)
         {
-            host.ConfigureServices(services =>
+            host.ConfigureServices((context,services) =>
             {
                 services.AddSingleton<IMainWindowNavigator, MainWindowNavigator>();
                 services.AddSingleton<ViewModelDelegateRenavigator<ProjektEditViewModel>>();
-                services.AddSingleton<IProjektDataService, ProjektDataService>();
+
-                services.AddSingleton<IAuftraggeberDataService, AuftraggeberDataService>();
+                string? databaseToUse = context.Configuration.GetConnectionString("databaseToUse");
-                services.AddSingleton<ISchachtDataService, SchachtDataService>();
+                if(databaseToUse != null)
+                {
+                    if(databaseToUse.Equals("postgresql"))
+                    {
+                        string? connectionstring = context.Configuration.GetConnectionString("postgresql");
+                        if(connectionstring == null) throw new ArgumentNullException(nameof(connectionstring));
+                        services.AddSingleton<IProjektDataService>(_=> new DAL.Services.PostgresqlData.ProjektDataService(connectionstring));
+                        services.AddSingleton<IAuftraggeberDataService>(_ => new DAL.Services.PostgresqlData.AuftraggeberDataService(connectionstring));
+                        services.AddSingleton<ISchachtDataService>(_ => new DAL.Services.PostgresqlData.SchachtDataService(connectionstring));
+                        services.AddSingleton<IHaltungDataService>(_ => new DAL.Services.PostgresqlData.HaltungDataService(connectionstring));
+                    }
+                }
+                
                
                 
             });

SewerStammGen.WPF/HostBuilders/AddViewModelsHostBuilderExtensions.cs

@@ -46,7 +46,6 @@ namespace SewerStammGen.HostBuilders
                 {
                     return () => new ManholeListViewModel(
                         services.GetRequiredService<ISchachtDataService>(),
-                        services.GetRequiredService<IDataService<Projekt>>(),
                         services.GetRequiredService<ViewModelDelegateRenavigator<ManholeEditViewModel>>(),
                         services.GetRequiredService<IActualState>()
                         
@@ -56,8 +55,9 @@ namespace SewerStammGen.HostBuilders
                 services.AddSingleton<CreateViewModel<ManholeEditViewModel>>(services =>
                 {
                     return () => new ManholeEditViewModel(
-                        services.GetRequiredService<IDataService<Schacht>>(),
+                        services.GetRequiredService<ISchachtDataService>(),
-                        services.GetRequiredService<IActualState>()
+                        services.GetRequiredService<IActualState>(),
+                        services.GetRequiredService<ViewModelDelegateRenavigator<ManholeListViewModel>>()
                         );
                 });
                 #endregion
@@ -66,7 +66,7 @@ namespace SewerStammGen.HostBuilders
                 services.AddSingleton<CreateViewModel<HaltungListViewModel>>(services =>
                 {
                     return () => new HaltungListViewModel(
-                        
+                        services.GetRequiredService<IHaltungDataService>(),
                         services.GetRequiredService<IActualState>(),
                         services.GetRequiredService<ViewModelDelegateRenavigator<HaltungEditViewModel>>()
                         );
@@ -75,9 +75,9 @@ namespace SewerStammGen.HostBuilders
                 services.AddTransient<CreateViewModel<HaltungEditViewModel>>(services =>
                 {
                     return () => new HaltungEditViewModel(
-                        
+                        services.GetRequiredService<IHaltungDataService>(),
-                        
+                        services.GetRequiredService<IActualState>(),
-                        services.GetRequiredService<IActualState>()
+                        services.GetRequiredService<ViewModelDelegateRenavigator<HaltungListViewModel>>()
                         );
                 });
                 #endregion

SewerStammGen.WPF/SewerStammGen.WPF.csproj

@@ -8,10 +8,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.4">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="7.0.1" />
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="7.0.0" />
     <PackageReference Include="Microsoft.Xaml.Behaviors.Wpf" Version="1.1.39" />

SewerStammGen.WPF/ViewModel/Haltung/HaltungEditViewModel.cs

@@ -1,6 +1,7 @@
 using SewerStammGen.Shared.Contracts;
 using SewerStammGen.Shared.Domain;
 using SewerStammGen.WPF.Commands;
+using SewerStammGen.WPF.Interface.Navigator;
 using SewerStammGen.WPF.ViewModel.State;
 using Shared.Contracts;
 using System;
@@ -17,7 +18,7 @@ namespace SewerStammGen.WPF.ViewModel
     internal class HaltungEditViewModel : BaseViewModel
     {
         private readonly IActualState _actualState;
-        //private readonly IHaltungDataService _kanalDataService;
+        private readonly IHaltungDataService _haltungDataService;
         
         private Kanal _model;
 
@@ -113,32 +114,20 @@ namespace SewerStammGen.WPF.ViewModel
         public ICommand Speichern { get; set; }
 
         public HaltungEditViewModel(
-            
+            IHaltungDataService haltungDataService,
-            IActualState actualState)
+            IActualState actualState,
+            IRenavigator renavigator)
         {
             _actualState = actualState;
-            //_kanalDataService = kanalDataService;
+            _haltungDataService = haltungDataService;
+
+            _model = _actualState.SelectedHaltung;
+            _oberePunkt = _model.StartSchacht.Objektbezeichnung;
+            _unterePunkt = _model.EndSchacht.Objektbezeichnung;
+            Speichern = new HaltungEditSaveCommand(_haltungDataService,renavigator,this);
 
-            _model = new Kanal();
-            Speichern = new HaltungEditSaveCommand(this);
             
-            LoadModel();
         
         }
-
-    
-        private async void LoadModel()
-        {
-            /*_model = await _kanalDataService.Get(_actualState.HaltungID);
-            UntereSchacht = _model.EndSchacht.Objektbezeichnung;
-            ObereSchacht = _model.StartSchacht.Objektbezeichnung;
-            OnPropertyChanged(nameof(ObereSchacht));
-            OnPropertyChanged(nameof(UntereSchacht));
-            OnPropertyChanged(nameof(Haltungslaenge));
-            OnPropertyChanged(nameof(Haltungsbezeichnung));
-            OnPropertyChanged(nameof(Material));
-            OnPropertyChanged(nameof(Durchmesser));
-            */
-        }
     }
 }

SewerStammGen.WPF/ViewModel/Haltung/HaltungListViewModel.cs

@@ -17,7 +17,7 @@ namespace SewerStammGen.WPF.ViewModel
     {
         private readonly ObservableCollection<Kanal> _haltungen;
         private readonly IActualState _actualState;
-        //private readonly IHaltungDataService _haltungDataService;
+        private readonly IHaltungDataService _haltungDataService;
         
         public Kanal? SelectedHaltung { get; set; }
         public ObservableCollection<Kanal> Haltungen { get => _haltungen; }
@@ -25,9 +25,10 @@ namespace SewerStammGen.WPF.ViewModel
         public ICommand EditCommand { get; set; }
         public ICommand AddCommand { get; set; }
 
-        public HaltungListViewModel( IActualState actualState, IRenavigator renavigator )
+        public HaltungListViewModel(IHaltungDataService haltungDataService, IActualState actualState, IRenavigator renavigator )
         {
             _haltungen = new ObservableCollection<Kanal>();
+            _haltungDataService = haltungDataService;
 
             _actualState = actualState;
             
@@ -40,9 +41,9 @@ namespace SewerStammGen.WPF.ViewModel
 
         private async void LoadHaltungen()
         {
-           /* var haltungen = await _haltungDataService.GetAll(_actualState.ProjektID);
+            var haltungen = await _haltungDataService.GetAllByProjekt(_actualState.ProjektID);
             InitCollection(_haltungen, haltungen);
-           */
+           
         }
 
         private void InitCollection(ObservableCollection<Kanal> dest, IEnumerable<Kanal> source)

SewerStammGen.WPF/ViewModel/Projekt/ProjektEditViewModel.cs

@@ -102,15 +102,9 @@ namespace SewerStammGen.WPF.ViewModel
         }
 
         private void SaveProject()
-        {
-            if (_model.Id == 0) // Handelt sich um ein neuen Eintrag
-            {
-                _dataService.Create(_model);
-            }
-            else
         {
             _dataService.Update(_model);
-            }
+
             _renavigator.Renavigate();
         }
     }

SewerStammGen.WPF/ViewModel/Schacht/ManholeEditViewModel.cs

@@ -1,4 +1,6 @@
-using SewerStammGen.Shared.Domain;
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.WPF.Interface.Navigator;
 using SewerStammGen.WPF.ViewModel.State;
 using Shared.Contracts;
 using System;
@@ -12,8 +14,8 @@ namespace SewerStammGen.WPF.ViewModel
 {
     public class ManholeEditViewModel : BaseViewModel
     {
-        private readonly IActualState _actualState;
+        private readonly ISchachtDataService _schachtDataService;
-        private readonly IDataService<Schacht> _schachtDataService;
+        private readonly IRenavigator _renavigator;
 
         private Schacht _model;
 
@@ -94,33 +96,27 @@ namespace SewerStammGen.WPF.ViewModel
             }
         }
 
-        public ManholeEditViewModel(IDataService<Schacht> schachtDataService,IActualState actualState)
+        public ManholeEditViewModel(ISchachtDataService schachtDataService,IActualState actualState, IRenavigator renavigator)
         {
-            _actualState = actualState;
             _schachtDataService = schachtDataService;
-            _model = new Schacht();
+            _model = actualState.SelectedSchacht;
+            _renavigator = renavigator;
 
             Speichern = new RelayCommand((x) => SaveSchacht());
 
-            LoadModel();
-
-            
         }
 
-        private void SaveSchacht()
+        private async void SaveSchacht()
         {
-            //_schachtDataService.Update(_model.Id, _model);
+            if (_model.Id == 0)
-        }
-
-        private async void LoadModel()
             {
-            _model = await _schachtDataService.Get(_actualState.SchachtID);
+                await _schachtDataService.Create(_model);
-            OnPropertyChanged(nameof(Entwaeserung));
+            }
-            OnPropertyChanged(nameof(Objektbezeichnung));
+            else
-            OnPropertyChanged(nameof(HochWert));
+            {
-            OnPropertyChanged(nameof(RechtsWert));
+               await _schachtDataService.Update(_model);
-            OnPropertyChanged(nameof(DeckelHoehe));
+            }
-            OnPropertyChanged(nameof(SohlHoehe));
+            _renavigator.Renavigate();
         }
     }
 }

SewerStammGen.WPF/ViewModel/Schacht/ManholeListViewModel.cs

@@ -16,7 +16,7 @@ namespace SewerStammGen.WPF.ViewModel
 {
     public class ManholeListViewModel : BaseViewModel
     {
-        private ISchachtDataService _schachtDataService;
+        private readonly ISchachtDataService _schachtDataService;
         private readonly ObservableCollection<Schacht> _schaechte;
         private readonly IActualState _actualState;
         
@@ -29,7 +29,7 @@ namespace SewerStammGen.WPF.ViewModel
         public ICommand DeleteSchachtCommand { get; set; }
 
 
-        public ManholeListViewModel(ISchachtDataService schachtDataService, IDataService<Projekt> projektService,IRenavigator renavigator ,IActualState actualState)
+        public ManholeListViewModel(ISchachtDataService schachtDataService, IRenavigator renavigator ,IActualState actualState)
         {
             _schachtDataService = schachtDataService;
             _actualState = actualState;
@@ -37,8 +37,8 @@ namespace SewerStammGen.WPF.ViewModel
             _schaechte = new ObservableCollection<Schacht>();
             
 
-            AddSchachtCommand = new SchachtAddCommand(projektService, actualState,renavigator);
+            AddSchachtCommand = new SchachtAddCommand(actualState,renavigator);
-            EditSchachtCommand = new SchachtEditCommand(schachtDataService, actualState, renavigator,this);
+            EditSchachtCommand = new SchachtEditCommand(actualState, renavigator,this);
             DeleteSchachtCommand = new SchachtDeleteCommand(schachtDataService, actualState, renavigator, this);
 
             LoadSchaechte();
@@ -46,8 +46,8 @@ namespace SewerStammGen.WPF.ViewModel
 
         private async void LoadSchaechte()
         {
-            //var schaechte = await _schachtDataService.GetAll(_actualState.ProjektID);
+            var schaechte = await _schachtDataService.GetAllByProjekt(_actualState.ProjektID);
-            //InitCollection(_schaechte, schaechte);
+            InitCollection(_schaechte, schaechte);
         }
 
         private void InitCollection(ObservableCollection<Schacht> dest, IEnumerable<Schacht> source)

SewerStammGen.WPF/ViewModel/State/ActualState.cs

@@ -14,6 +14,9 @@ namespace SewerStammGen.WPF.ViewModel.State
 
         public int SchachtID { get; private set; }
         public int HaltungID { get; private set; }
+        public Schacht SelectedSchacht { get; private set; }
+
+        public Kanal SelectedHaltung {get; private set; }
 
         public void SetProjekt(Projekt projekt, bool notification = true)
         {
@@ -25,6 +28,7 @@ namespace SewerStammGen.WPF.ViewModel.State
         }
         public void SetSchacht(Schacht schacht, bool notification = true)
         {
+            SelectedSchacht = schacht;
             SchachtID = schacht.Id;
             if(notification)
             {
@@ -33,6 +37,7 @@ namespace SewerStammGen.WPF.ViewModel.State
         }
         public void SetHaltung(Kanal haltung, bool notification = true)
         {
+            SelectedHaltung = haltung;
             HaltungID = haltung.Id;
             if(notification)
             {

SewerStammGen.WPF/ViewModel/State/IActualState.cs

@@ -14,6 +14,8 @@ namespace SewerStammGen.WPF.ViewModel.State
         int ProjektID { get; set; }
         int SchachtID { get; }
         int HaltungID { get; }
+        Schacht SelectedSchacht { get; }
+        Kanal SelectedHaltung { get; }
 
         void SetProjekt(Projekt projekt, bool notification = true);
         void SetSchacht(Schacht schacht, bool notification = true);

SewerStammGen.WPF/appsettings.json

@@ -1,7 +1,7 @@
 {
   "ConnectionStrings": {
-    "databaseToUse": "default",
+    "databaseToUse": "postgresql",
-    "default": "Host = localhost; Database = SewerGen; Username = SewerGen; Password = SewerGen",
+    "postgresql": "Host = localhost; Database = SewerGen; Username = SewerGen; Password = SewerGen",
     "sqlite": "Data Source=database.db"
   }
 }