adding clock in break and out command

Library/EmployeeState.cs

@@ -2,7 +2,7 @@
 
 public enum EmployeeState
 {
-    WORKING,
+    OUT,
+    IN,
     BREAK,
-    AWAY,
 }

Library/Server.cs

@@ -193,7 +193,7 @@ public class Server
         return Task.FromException<Employee>(new Exception("Failed to get logged in employee."));
     }
 
-    public Task<string> clockIn(Employee employee)
+    public Task<string> ClockIn(Employee? employee = null)
     {
         var commandResult = ExecuteCommandAsync("clock in").Result;
         if (commandResult == "success")
@@ -202,7 +202,7 @@ public class Server
         }
         return Task.FromException<string>(new Exception("Failed to clock in."));
     }
-    public Task<string> clockOut(Employee employee)
+    public Task<string> ClockOut(Employee? employee = null)
     {
         var commandResult = ExecuteCommandAsync("clock out").Result;
         if (commandResult == "success")
@@ -214,7 +214,7 @@ public class Server
            return Task.FromException<string>(new Exception("Failed to clock out."));
         }
     }
-    public Task<string> clockBreak(Employee employee)
+    public Task<string> ClockBreak(Employee? employee = null)
     {
         var commandResult = ExecuteCommandAsync("clock break").Result;
         if (commandResult == "success")

Server/BackendServer.cs

@@ -43,7 +43,7 @@ public class BackendServer : DX86.TcpServer
         JsonMessage? jsonMessage;
         if (message.StartsWith("{") && message.EndsWith("}"))
         {
-            this.SendMessageAsync(client, "Command received\n");
+            //this.SendMessageAsync(client, "Command received\n");
             try
             {
                 jsonMessage = JsonSerializer.Deserialize<JsonMessage>(message);

Server/Commands/CommandLibrary.cs

@@ -170,6 +170,123 @@ public class CommandLibrary
             return self.ToJson();
         }
 
+        [Command("clock")]
+        public static string ClockCommand(string[] args, TcpClient? client, TcpServer? socket)
+        {
+            // 1) Argument check
+            if (args.Length < 1)
+                throw new CommandException("Missing argument: usage is clock <in|out|break>");
+
+            string desired = args[0].ToLowerInvariant();
+            int desiredState;
+            switch (desired)
+            {
+                case "in":
+                    desiredState = 1;
+                    break;
+                case "out":
+                    desiredState = 0;
+                    break;
+                case "break":
+                    desiredState = 2;
+                    break;
+                default:
+                    throw new CommandException("Invalid argument. Use in, out, or break.");
+            }
+
+            // 2) Verify client/socket
+            if (client == null || socket == null)
+                throw new CommandException("No client connection detected.");
+
+            if (!socket.LoggedInClients.TryGetValue(client, out var employeeCode))
+                throw new CommandException("User not logged in.");
+
+            // 3) Look up the employee by Code to get Id and current state
+            var empParams = new Dictionary<string, object> { { "Code", employeeCode } };
+            string empResultJson = Program.mySql.Get("employees", empParams);
+
+            using var empDoc = JsonDocument.Parse(empResultJson);
+            bool empError = empDoc.RootElement.GetProperty("error").GetBoolean();
+            if (empError)
+            {
+                string dbMsg = empDoc.RootElement.GetProperty("data").GetString() ?? "Unknown DB error";
+                Program.messageSender.Error($"[ClockCommand] DB error when looking up employee: {dbMsg}");
+                throw new CommandException("Internal error while fetching employee data.");
+            }
+
+            var empArray = empDoc.RootElement.GetProperty("data");
+            if (empArray.GetArrayLength() == 0)
+                throw new CommandException("Logged-in user not found in database.");
+
+            var empRow = empArray[0];
+            int employeeId   = empRow.GetProperty("Id").GetInt32();
+            int currentState = empRow.GetProperty("EmployeeState").GetInt32();
+
+            // 4) Validate state transition
+            if (currentState == desiredState)
+                throw new CommandException($"Already {(desiredState == 0 ? "OUT" : desiredState == 1 ? "IN" : "on BREAK")}.");
+
+            bool valid = false;
+            switch (currentState)
+            {
+                case 0: // OUT → only IN
+                    valid = (desiredState == 1);
+                    break;
+                case 1: // IN → OUT or BREAK
+                    valid = (desiredState == 0 || desiredState == 2);
+                    break;
+                case 2: // BREAK → only IN
+                    valid = (desiredState == 1);
+                    break;
+            }
+            if (!valid)
+                throw new CommandException("Invalid transition from current status.");
+
+            // 5) Update employees.EmployeeState to desiredState
+            var updateData = new Dictionary<string, object>
+            {
+                { "EmployeeState", desiredState }
+            };
+            var whereData = new Dictionary<string, object>
+            {
+                { "Id", employeeId }
+            };
+            string updateJson = Program.mySql.Update("employees", updateData, whereData);
+
+            using (var updateDoc = JsonDocument.Parse(updateJson))
+            {
+                bool updError = updateDoc.RootElement.GetProperty("error").GetBoolean();
+                if (updError)
+                {
+                    string dbMsg = updateDoc.RootElement.GetProperty("data").GetString() ?? "Unknown DB error";
+                    Program.messageSender.Error($"[ClockCommand] DB error when updating state: {dbMsg}");
+                    throw new CommandException("Internal error while updating status.");
+                }
+            }
+
+            // 6) Insert into employee_state_history
+            var historyData = new Dictionary<string, object>
+            {
+                { "EmployeeId", employeeId },
+                { "NewState",   desiredState }
+            };
+            string historyJson = Program.mySql.Insert("employee_state_history", historyData);
+
+            using (var histDoc = JsonDocument.Parse(historyJson))
+            {
+                bool histError = histDoc.RootElement.GetProperty("error").GetBoolean();
+                if (histError)
+                {
+                    string dbMsg = histDoc.RootElement.GetProperty("data").GetString() ?? "Unknown DB error";
+                    Program.messageSender.Error($"[ClockCommand] DB error when logging history: {dbMsg}");
+                    throw new CommandException("Internal error while logging status change.");
+                }
+            }
+
+            // 7) Return success
+            return "success";
+        }
+
     #endregion
 
     #region Administration Commands

Server/Program.cs

@@ -31,6 +31,7 @@ namespace Server;
             ServerLoop();
         }
 
+        #region MySQL Initialization
                 private static MySQL LoadOrInitDatabase()
         {
             var cfg = DbConfig.Load();
@@ -54,7 +55,6 @@ namespace Server;
                 return InitializeDatabase(username, password, server, port, database);
             }
         }
-
                 /// <summary>
                 /// Creates a new MySQL connection, runs the CREATE TABLE DDL,
                 /// saves credentials in config.json, and returns the MySQL instance.
@@ -139,6 +139,41 @@ private static MySQL InitializeDatabase(
             }
             messageSender.Log("[Program] 'employee_pins' table is ready.");
             
+            // 3) Neue Tabelle für Status‐Historie anlegen:
+            string createStateHistoryTable = @"
+                CREATE TABLE IF NOT EXISTS `employee_state_history` (
+                    `HistoryId`   INT       NOT NULL AUTO_INCREMENT PRIMARY KEY,
+                    `EmployeeId`  INT       NOT NULL,
+                    `NewState`    INT       NOT NULL,
+                    `ChangeTime`  DATETIME  NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                    FOREIGN KEY (`EmployeeId`) 
+                        REFERENCES `employees`(`Id`) 
+                        ON DELETE CASCADE 
+                        ON UPDATE CASCADE
+                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+            ";
+        
+            Program.messageSender.Log("[Program] Ensuring 'employee_state_history' table exists…");
+            var historyResultJson = db.ExecuteNonQuery(createStateHistoryTable);
+            try
+            {
+                using var doc = JsonDocument.Parse(historyResultJson);
+                bool histError = doc.RootElement.GetProperty("error").GetBoolean();
+                if (histError)
+                {
+                    string dbMsg = doc.RootElement.GetProperty("data").GetString() ?? "Unknown DB error";
+                    Program.messageSender.Error("[Program] Failed to create 'employee_state_history' table: " + dbMsg);
+                    Environment.Exit(1);
+                }
+            }
+            catch (Exception ex)
+            {
+                Program.messageSender.Error("[Program] Could not parse state history CREATE TABLE response: " + ex.Message);
+                Program.messageSender.Error("[Program] Raw response: " + historyResultJson);
+                Environment.Exit(1);
+            }
+            Program.messageSender.Log("[Program] 'employee_state_history' table is ready.");
+        
             // … (any further tables) …
         
             // 3) Save the new credentials (including port) into config.json:
@@ -156,6 +191,8 @@ private static MySQL InitializeDatabase(
             return db;
         }
 
+        #endregion
+
         private static void ServerLoop()
         {
             bool running = true;

TestClient/Program.cs

@@ -81,6 +81,27 @@ public class Tester
                         $"Forename: {employee.Forename}",
                     });
                 }
+                else if (command == "clock in")
+                {
+                    string response = await server.ClockIn();
+                    // split response into string[] at \n
+                    var responseLines = response.Split('\n').ToList();
+                    await messageBox.ShowAsync("Command Result: clock in", responseLines);
+                }
+                else if (command == "clock out")
+                {
+                    string response = await server.ClockOut();
+                    // split response into string[] at \n
+                    var responseLines = response.Split('\n').ToList();
+                    await messageBox.ShowAsync("Command Result: clock out", responseLines);
+                }
+                else if (command == "clock break")
+                {
+                    string response = await server.ClockBreak();
+                    // split response into string[] at \n
+                    var responseLines = response.Split('\n').ToList();
+                    await messageBox.ShowAsync("Command Result: clock break", responseLines);
+                }
             }
             catch (Exception ex)
             {