weitere Anpassungen

.idea/.idea.ChronoFlow/.idea/avalonia.xml

@@ -7,6 +7,7 @@
         <entry key="ChronoFlow.View/LoginView.axaml" value="ChronoFlow.View/ChronoFlow.View.csproj" />
         <entry key="ChronoFlow.View/LoginWindow.axaml" value="ChronoFlow.View/ChronoFlow.View.csproj" />
         <entry key="ChronoFlow.View/MainWindow.axaml" value="ChronoFlow.View/ChronoFlow.View.csproj" />
+        <entry key="ChronoFlow.View/MitarbeiterHinzufuegenView.axaml" value="ChronoFlow.View/ChronoFlow.View.csproj" />
         <entry key="ChronoFlow.View/ZeiterfassungView.axaml" value="ChronoFlow.View/ChronoFlow.View.csproj" />
       </map>
     </option>

ChronoFlow.Controller/LoginController.cs

@@ -1,7 +1,6 @@
 // Datei: Controller/LoginController.cs
 using ChronoFlow.Model;
-using System.Collections.Generic;
+
-using System.Linq;
 
 namespace ChronoFlow.Controller;
 

ChronoFlow.Controller/ZeiterfassungsController.cs

@@ -1,38 +1,36 @@
-using System.Collections.Generic;
+using System.Collections.Generic;         // Für die List<T>
-using ChronoFlow.Model;
+using ChronoFlow.Model;                    // Zugriff auf das Zeiteintrag-Modell
-using ChronoFlow.Persistence;
+using ChronoFlow.Persistence;              // Zugriff auf die Datenbank-Serviceklasse
 
 namespace ChronoFlow.Controller
 {
-    /// <summary>
+    // Der Controller ist dafür zuständig, die Kommunikation zwischen der View (Oberfläche)
-    /// Vermittelt zwischen der View und dem Speichersystem (SQLite)
+    // und der Datenbank (Persistence-Schicht) zu regeln.
-    /// </summary>
     public class ZeiterfassungsController
     {
-        private readonly SqliteZeiterfassungsService _dbService;
+        // Wir brauchen Zugriff auf den Sqlite-Service, um mit der Datenbank arbeiten zu können
+        private readonly SqliteZeiterfassungsService _sqliteService;
 
-        /// <summary>
+        // Konstruktor: Immer wenn ein ZeiterfassungsController erstellt wird, 
-        /// Konstruktor: Initialisiert die Verbindung zum SQLite-Dienst
+        // wird auch gleich ein SqliteService erstellt/verknüpft
-        /// </summary>
         public ZeiterfassungsController()
         {
-            _dbService = new SqliteZeiterfassungsService();
+            _sqliteService = new SqliteZeiterfassungsService();
         }
 
-        /// <summary>
+        // Diese Methode wird aufgerufen, wenn ein neuer Zeiteintrag gespeichert werden soll
-        /// Speichert einen neuen Zeiteintrag dauerhaft in der SQLite-Datenbank
-        /// </summary>
         public void SpeichereEintrag(Zeiteintrag eintrag)
         {
-            _dbService.SpeichereEintrag(eintrag);
+            // Übergibt den Eintrag direkt an den SQLite-Service,
+            // der kümmert sich um das Speichern in die Datenbank
+            _sqliteService.SpeichereEintrag(eintrag);
         }
 
-        /// <summary>
+        // Diese Methode lädt alle bisherigen Zeiteinträge aus der Datenbank
-        /// Lädt alle vorhandenen Einträge aus der Datenbank
-        /// </summary>
         public List<Zeiteintrag> LadeAlleEintraege()
         {
-            return _dbService.LadeAlleZeiteintraege();
+            // Holt die Liste der Einträge von der Datenbank und gibt sie zurück
+            return _sqliteService.LadeAlleZeiteintraege();
         }
     }
 }

ChronoFlow.Persistence/SqliteZeiterfassungsService.cs

@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Security.Cryptography;
 using Microsoft.Data.Sqlite;
 using ChronoFlow.Model;
 
@@ -9,50 +5,91 @@ namespace ChronoFlow.Persistence
 {
     public class SqliteZeiterfassungsService
     {
-        private readonly string _dbPath = "chrono_data_v2.sb";
+        private readonly string _dbPath;
+        private bool _dbInitialisiert ;
 
         public SqliteZeiterfassungsService()
         {
-            // Prüfe, ob die DB existiert, sonst erstelle sie
+            _dbPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "chrono_data.sb");
+            InitialisiereDatenbank();
+        }
+
+        private void InitialisiereDatenbank()
+        {
             if (!File.Exists(_dbPath))
+            {
+                Console.WriteLine("📂 Datenbank existiert nicht. Erstelle neue...");
                 ErstelleDatenbank();
+            }
+            else
+            {
+                Console.WriteLine("✅ Datenbankdatei gefunden: " + _dbPath);
+            }
+
+            _dbInitialisiert = true;
+            ZeigeExistierendeTabellen();
         }
 
         private void ErstelleDatenbank()
         {
-            Console.WriteLine("🛠️ ErstelleDatenbank wurde aufgerufen!");
+            using var connection = new SqliteConnection($"Data Source={_dbPath}");
+            connection.Open();
+
+            using (var cmd = connection.CreateCommand())
+            {
+                cmd.CommandText = @"
+                    CREATE TABLE IF NOT EXISTS Zeiteintraege (
+                        Id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        Mitarbeiter TEXT NOT NULL,
+                        Startzeit TEXT NOT NULL,
+                        Endzeit TEXT NOT NULL,
+                        Projekt TEXT,
+                        Kommentar TEXT,
+                        Erledigt INTEGER,
+                        MitarbeiterKommentar TEXT
+                    );
+                ";
+                cmd.ExecuteNonQuery();
+                Console.WriteLine("🛠️ Tabelle Zeiteintraege wurde erstellt/überprüft.");
+            }
+
+            using (var cmd = connection.CreateCommand())
+            {
+                cmd.CommandText = @"
+                    CREATE TABLE IF NOT EXISTS Benutzer (
+                        Id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        Username TEXT NOT NULL,
+                        Password TEXT NOT NULL,
+                        Role TEXT NOT NULL,
+                        Mitarbeiternummer TEXT,
+                        Abteilung TEXT
+                    );
+                ";
+                cmd.ExecuteNonQuery();
+                Console.WriteLine("🛠️ Tabelle Benutzer wurde erstellt/überprüft.");
+            }
+        }
+
+        public void ErstelleStandardAdmin()
+        {
+            if (!_dbInitialisiert)
+            {
+                throw new Exception("❗ Fehler: Datenbank wurde noch nicht initialisiert!");
+            }
 
             using var connection = new SqliteConnection($"Data Source={_dbPath}");
             connection.Open();
 
-            var cmd1 = connection.CreateCommand();
+            var cmd = connection.CreateCommand();
-            cmd1.CommandText = @"
+            cmd.CommandText = @"
-        CREATE TABLE IF NOT EXISTS Zeiteintraege (
+                INSERT INTO Benutzer (Username, Password, Role, Mitarbeiternummer, Abteilung)
-            Id INTEGER PRIMARY KEY AUTOINCREMENT,
+                VALUES ('admin', 'admin', 'Admin', '0001', 'IT');
-            Mitarbeiter TEXT NOT NULL,
+            ";
-            Startzeit TEXT NOT NULL,
+            cmd.ExecuteNonQuery();
-            Endzeit TEXT NOT NULL,
-            Projekt TEXT,
-            Kommentar TEXT,
-            Erledigt INTEGER,
-            MitarbeiterKommentar TEXT
-        );";
-            cmd1.ExecuteNonQuery();
 
-            var cmd2 = connection.CreateCommand();
+            Console.WriteLine("✅ Standard-Admin erfolgreich erstellt.");
-            cmd2.CommandText = @"
-        CREATE TABLE IF NOT EXISTS Benutzer (
-            Id INTEGER PRIMARY KEY AUTOINCREMENT,
-            Username TEXT NOT NULL,
-            Password TEXT NOT NULL,
-            Role TEXT NOT NULL,
-            Mitarbeiternummer TEXT,
-            Abteilung TEXT
-        );";
-            cmd2.ExecuteNonQuery();
         }
 
-
         public void SpeichereEintrag(Zeiteintrag eintrag)
         {
             using var connection = new SqliteConnection($"Data Source={_dbPath}");
@@ -103,23 +140,7 @@ namespace ChronoFlow.Persistence
 
             return eintraege;
         }
-        public List<string> LadeAlleMitarbeiterNamen()
-        {
-            var namen = new List<string>();
 
-            using var connection = new SqliteConnection($"Data Source={_dbPath}");
-            connection.Open();
-                
-            var cmd = connection.CreateCommand();
-            cmd.CommandText = "SELECT Username From Benutzer Where Role = 'Mitarbeiter';";
-                
-            using var reader = cmd.ExecuteReader();
-            while (reader.Read())
-            {
-                namen.Add(reader.GetString(0));
-            }
-            return namen;
-        }
         public List<User> LadeAlleBenutzer()
         {
             var benutzerListe = new List<User>();
@@ -146,38 +167,39 @@ namespace ChronoFlow.Persistence
             return benutzerListe;
         }
 
-        public void ErstelleStandardAdmin()
+        private void ZeigeExistierendeTabellen()
         {
             using var connection = new SqliteConnection($"Data Source={_dbPath}");
             connection.Open();
 
             var cmd = connection.CreateCommand();
-            cmd.CommandText = @"
+            cmd.CommandText = "SELECT name FROM sqlite_master WHERE type='table';";
-        INSERT INTO Benutzer (Username, Password, Role, Mitarbeiternummer, Abteilung)
-        VALUES ('admin', 'admin', 'Admin', '0001', 'IT');
-    ";
 
-            cmd.ExecuteNonQuery();
+            using var reader = cmd.ExecuteReader();
-    
+            Console.WriteLine("🗂️ Tabellen in der Datenbank:");
-            Console.WriteLine("✅ Standard-Admin erfolgreich eingefügt.");
+            while (reader.Read())
+            {
+                Console.WriteLine($"   ➔ {reader.GetString(0)}");
+            }
         }
         
-        public List<string> LadeAlleBenutzernamen()
+        /// <summary>
+        /// Prüft, ob ein Benutzername bereits existiert.
+        /// </summary>
+        /// <param name="username">Benutzername, der überprüft werden soll</param>
+        /// <returns>True, wenn Name bereits existiert, sonst False</returns>
+        public bool BenutzernameExistiert(string username)
         {
-            var benutzernamen = new List<string>();
-
             using var connection = new SqliteConnection($"Data Source={_dbPath}");
             connection.Open();
 
-            using var cmd = connection.CreateCommand();//<--- Wir erstellen cmd
+            var cmd = connection.CreateCommand();
-            cmd.CommandText = "SELECT Username From Benutzer;";
+            cmd.CommandText = "SELECT COUNT(*) FROM Benutzer WHERE Username = $username";
+            cmd.Parameters.AddWithValue("$username", username);
 
-            using var reader = cmd.ExecuteReader();
+            var result = Convert.ToInt32(cmd.ExecuteScalar());
-            while (reader.Read())
+
-            {
+            return result > 0;
-                benutzernamen.Add(reader.GetString(0));
-            }
-            return benutzernamen;
         }
 
     }

ChronoFlow.View/LoginWindow.axaml.cs

@@ -1,7 +1,6 @@
 using System.Linq;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
-using Avalonia.Metadata;
 using ChronoFlow.Controller;
 using ChronoFlow.Persistence;
 

ChronoFlow.View/MitarbeiterHinzufuegenView.axaml.cs

@@ -16,54 +16,63 @@ namespace ChronoFlow.View
         }
 
         private void SpeichernButton_Click(object? sender, RoutedEventArgs e)
+{
+    try
+    {
+        var service = new SqliteZeiterfassungsService();
+
+        string username = UsernameBox.Text?.Trim() ?? "";
+        string password = PasswordBox.Text?.Trim() ?? "";
+        string rolle = (RoleBox.SelectedItem as ComboBoxItem)?.Content?.ToString() ?? "";
+        string mitarbeiternummer = MitarbeiternummerBox.Text?.Trim() ?? "";
+        string abteilung = AbteilungBox.Text?.Trim() ?? "";
+
+        if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password) || string.IsNullOrWhiteSpace(rolle))
         {
-            try
+            FeedbackText.Text = "⚠ Bitte alle Pflichtfelder ausfüllen!";
-            {
+            FeedbackText.Foreground = Brushes.Red;
-                var service = new SqliteZeiterfassungsService();
+            FeedbackText.IsVisible = true;
+            return;
+        }
 
-                string username = UsernameBox.Text ?? "";
+        // ❗ Hier neue Prüfung, ob Benutzername existiert:
-                string password = PasswordBox.Text ?? "";
+        if (service.BenutzernameExistiert(username))
-                string rolle = (RoleBox.SelectedItem as ComboBoxItem)?.Content?.ToString() ?? "";
+        {
-                string mitarbeiternummer = MitarbeiternummerBox.Text ?? "";
+            FeedbackText.Text = "⚠ Benutzername existiert bereits!";
-                string abteilung = AbteilungBox.Text ?? "";
+            FeedbackText.Foreground = Brushes.Red;
+            FeedbackText.IsVisible = true;
+            return;
+        }
 
-                if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password) || string.IsNullOrWhiteSpace(rolle))
+        using var connection = new SqliteConnection("Data Source=chrono_data.sb");
-                {
+        connection.Open();
-                    FeedbackText.Text = "⚠ Bitte alle Pflichtfelder ausfüllen!";
-                    FeedbackText.Foreground = Brushes.Red;
-                    FeedbackText.IsVisible = true;
-                    return;
-                }
 
-                using var connection = new SqliteConnection("Data Source=chrono_data.sb");
+        var cmd = connection.CreateCommand();
-                connection.Open();
+        cmd.CommandText = @"
-
-                var cmd = connection.CreateCommand();
-                cmd.CommandText = @"
             INSERT INTO Benutzer (Username, Password, Role, Mitarbeiternummer, Abteilung)
             VALUES ($Username, $Password, $Role, $Mitarbeiternummer, $Abteilung);";
         
-                cmd.Parameters.AddWithValue("$Username", username);
+        cmd.Parameters.AddWithValue("$Username", username);
-                cmd.Parameters.AddWithValue("$Password", password);
+        cmd.Parameters.AddWithValue("$Password", password);
-                cmd.Parameters.AddWithValue("$Role", rolle);
+        cmd.Parameters.AddWithValue("$Role", rolle);
-                cmd.Parameters.AddWithValue("$Mitarbeiternummer", mitarbeiternummer);
+        cmd.Parameters.AddWithValue("$Mitarbeiternummer", mitarbeiternummer);
-                cmd.Parameters.AddWithValue("$Abteilung", abteilung);
+        cmd.Parameters.AddWithValue("$Abteilung", abteilung);
-                cmd.ExecuteNonQuery();
+        cmd.ExecuteNonQuery();
 
-                FeedbackText.Text = "✅ Mitarbeiter erfolgreich gespeichert.";
+        FeedbackText.Text = "✅ Mitarbeiter erfolgreich gespeichert.";
-                FeedbackText.Foreground = Brushes.Green;
+        FeedbackText.Foreground = Brushes.Green;
-                FeedbackText.IsVisible = true;
+        FeedbackText.IsVisible = true;
-            }
+    }
-            catch (Exception ex)
+    catch (Exception ex)
-            {
+    {
-                FeedbackText.Text = $"❌ Fehler: {ex.Message}";
+        FeedbackText.Text = $"❌ Fehler: {ex.Message}";
-                FeedbackText.Foreground = Brushes.Red;
+        FeedbackText.Foreground = Brushes.Red;
-                FeedbackText.IsVisible = true;
+        FeedbackText.IsVisible = true;
 
-                Console.WriteLine("❌ Ausnahme beim Speichern:");
+        Console.WriteLine("❌ Ausnahme beim Speichern:");
-                Console.WriteLine(ex.ToString());
+        Console.WriteLine(ex.ToString());
-            }
+    }
-        }
+}
 
     }
 }