Neuste Version

Data/AppSettings.cs

@@ -0,0 +1,34 @@
+namespace timetracker.Data;
+
+public class AppSettings
+{
+    public int Id { get; set; }
+    public int UserId { get; set; }
+    public double DailyTargetHours { get; set; } = 7.5;
+    public int MinimumBreakMinutes { get; set; } = 30;
+    public int VacationDaysPerYear { get; set; } = 30;
+    public string? GermanState { get; set; }
+    public DateOnly? FlexTimeStartDate { get; set; }
+    public double FlexTimeStartingBalanceHours { get; set; } = 0.0;
+
+    // Arbeitstage
+    public bool WorkMonday { get; set; } = true;
+    public bool WorkTuesday { get; set; } = true;
+    public bool WorkWednesday { get; set; } = true;
+    public bool WorkThursday { get; set; } = true;
+    public bool WorkFriday { get; set; } = true;
+    public bool WorkSaturday { get; set; } = false;
+    public bool WorkSunday { get; set; } = false;
+
+    public bool IsWorkDay(DayOfWeek day) => day switch
+    {
+        DayOfWeek.Monday => WorkMonday,
+        DayOfWeek.Tuesday => WorkTuesday,
+        DayOfWeek.Wednesday => WorkWednesday,
+        DayOfWeek.Thursday => WorkThursday,
+        DayOfWeek.Friday => WorkFriday,
+        DayOfWeek.Saturday => WorkSaturday,
+        DayOfWeek.Sunday => WorkSunday,
+        _ => false
+    };
+}

Data/AuthService.cs

@@ -0,0 +1,75 @@
+using System.Security.Cryptography;
+using System.Text;
+using Microsoft.EntityFrameworkCore;
+
+namespace timetracker.Data;
+
+public class AuthService(IDbContextFactory<TimetrackerDbContext> factory)
+{
+    public async Task<User?> LoginAsync(string username, string password)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        var user = await db.Users
+            .FirstOrDefaultAsync(u => u.Username == username);
+        if (user == null) return null;
+        return VerifyPassword(password, user.PasswordHash, user.PasswordSalt) ? user : null;
+    }
+
+    public async Task<List<User>> GetAllUsersAsync()
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        return await db.Users
+            .OrderBy(u => u.Username)
+            .ToListAsync();
+    }
+
+    public async Task DeleteUserAsync(int userId)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        var user = await db.Users.FindAsync(userId);
+        if (user != null)
+        {
+            db.Users.Remove(user);
+            await db.SaveChangesAsync();
+        }
+    }
+
+    public async Task<(User? User, string? Error)> RegisterAsync(string username, string password)    {
+        if (string.IsNullOrWhiteSpace(username) || username.Length < 3)
+            return (null, "Benutzername muss mindestens 3 Zeichen lang sein.");
+        if (string.IsNullOrWhiteSpace(password) || password.Length < 6)
+            return (null, "Passwort muss mindestens 6 Zeichen lang sein.");
+
+        await using var db = await factory.CreateDbContextAsync();
+        if (await db.Users.AnyAsync(u => u.Username == username))
+            return (null, "Benutzername bereits vergeben.");
+
+        var (hash, salt) = HashPassword(password);
+        var user = new User { Username = username, PasswordHash = hash, PasswordSalt = salt };
+        db.Users.Add(user);
+        await db.SaveChangesAsync();
+        return (user, null);
+    }
+
+    private static (string hash, string salt) HashPassword(string password)
+    {
+        var saltBytes = RandomNumberGenerator.GetBytes(32);
+        var salt = Convert.ToBase64String(saltBytes);
+        var hash = ComputeHash(password, salt);
+        return (hash, salt);
+    }
+
+    private static bool VerifyPassword(string password, string hash, string salt)
+        => ComputeHash(password, salt) == hash;
+
+    private static string ComputeHash(string password, string salt)
+    {
+        var hash = Rfc2898DeriveBytes.Pbkdf2(
+            Encoding.UTF8.GetBytes(password),
+            Convert.FromBase64String(salt),
+            iterations: 200_000,
+            HashAlgorithmName.SHA256,
+            outputLength: 32);
+        return Convert.ToBase64String(hash);
+    }
+}

Data/BreakEntry.cs

@@ -0,0 +1,10 @@
+namespace timetracker.Data;
+
+public class BreakEntry
+{
+    public int Id { get; set; }
+    public int WorkDayId { get; set; }
+    public WorkDay WorkDay { get; set; } = null!;
+    public TimeOnly? StartTime { get; set; }
+    public TimeOnly? EndTime { get; set; }
+}

Data/HolidayService.cs

@@ -0,0 +1,82 @@
+using Microsoft.EntityFrameworkCore;
+using System.Net.Http.Json;
+using System.Text.Json.Serialization;
+
+namespace timetracker.Data;
+
+public class HolidayService(IDbContextFactory<TimetrackerDbContext> factory, HttpClient http)
+{
+    private const string ApiUrl = "https://date.nager.at/api/v3/PublicHolidays/{0}/DE";
+
+    public async Task<List<PublicHoliday>> GetHolidaysAsync(int year, string? stateCode = null)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        var holidays = await db.PublicHolidays
+            .Where(h => h.Date.Year == year)
+            .OrderBy(h => h.Date)
+            .ToListAsync();
+
+        if (string.IsNullOrEmpty(stateCode))
+        {
+            // Default: return only global holidays (where Counties is null or empty)
+            return holidays.Where(h => string.IsNullOrEmpty(h.Counties)).ToList();
+        }
+
+        // Return global holidays OR holidays that match the user's state code
+        return holidays.Where(h => string.IsNullOrEmpty(h.Counties) || h.Counties.Split(',').Contains(stateCode)).ToList();
+    }
+
+    public async Task<(bool Success, string Message)> FetchAndStoreAsync(int year)
+    {
+        try
+        {
+            var url = string.Format(ApiUrl, year);
+            var items = await http.GetFromJsonAsync<List<NagerHoliday>>(url);
+            if (items == null) return (false, "Keine Daten erhalten.");
+
+            await using var db = await factory.CreateDbContextAsync();
+            var existing = await db.PublicHolidays.Where(h => h.Date.Year == year).ToListAsync();
+            db.PublicHolidays.RemoveRange(existing);
+
+            db.PublicHolidays.AddRange(items
+                .Where(h => DateOnly.TryParse(h.Date, out _))
+                .Select(h => new PublicHoliday
+                {
+                    Date = DateOnly.Parse(h.Date),
+                    Name = h.LocalName,
+                    Counties = h.Counties != null && h.Counties.Count > 0 ? string.Join(",", h.Counties) : null
+                }));
+
+            await db.SaveChangesAsync();
+            return (true, $"{items.Count} Feiertage für {year} erfolgreich gespeichert.");
+        }
+        catch (Exception ex)
+        {
+            return (false, $"Fehler beim Abrufen: {ex.Message}");
+        }
+    }
+
+    public async Task DeleteAsync(int id)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        var h = await db.PublicHolidays.FindAsync(id);
+        if (h != null)
+        {
+            db.PublicHolidays.Remove(h);
+            await db.SaveChangesAsync();
+        }
+    }
+
+    private sealed class NagerHoliday
+    {
+        [JsonPropertyName("date")]
+        public string Date { get; set; } = "";
+
+        [JsonPropertyName("localName")]
+        public string LocalName { get; set; } = "";
+
+        [JsonPropertyName("counties")]
+        public List<string>? Counties { get; set; }
+    }
+}
+

Data/Migrations/20260520133634_Initial.Designer.cs

@@ -0,0 +1,141 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using timetracker.Data;
+
+#nullable disable
+
+namespace timetracker.Data.Migrations
+{
+    [DbContext(typeof(TimetrackerDbContext))]
+    [Migration("20260520133634_Initial")]
+    partial class Initial
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.8");
+
+            modelBuilder.Entity("timetracker.Data.AppSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double>("DailyTargetHours")
+                        .HasColumnType("REAL");
+
+                    b.Property<int>("MinimumBreakMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VacationDaysPerYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkFriday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkMonday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSaturday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSunday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkThursday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkTuesday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkWednesday")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AppSettings");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkDayId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkDayId");
+
+                    b.ToTable("BreakEntries");
+                });
+
+            modelBuilder.Entity("timetracker.Data.VacationDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("VacationDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorkDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.HasOne("timetracker.Data.WorkDay", "WorkDay")
+                        .WithMany("Breaks")
+                        .HasForeignKey("WorkDayId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkDay");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Navigation("Breaks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Data/Migrations/20260520133634_Initial.cs

@@ -0,0 +1,108 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace timetracker.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class Initial : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "AppSettings",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    DailyTargetHours = table.Column<double>(type: "REAL", nullable: false),
+                    MinimumBreakMinutes = table.Column<int>(type: "INTEGER", nullable: false),
+                    VacationDaysPerYear = table.Column<int>(type: "INTEGER", nullable: false),
+                    WorkMonday = table.Column<bool>(type: "INTEGER", nullable: false),
+                    WorkTuesday = table.Column<bool>(type: "INTEGER", nullable: false),
+                    WorkWednesday = table.Column<bool>(type: "INTEGER", nullable: false),
+                    WorkThursday = table.Column<bool>(type: "INTEGER", nullable: false),
+                    WorkFriday = table.Column<bool>(type: "INTEGER", nullable: false),
+                    WorkSaturday = table.Column<bool>(type: "INTEGER", nullable: false),
+                    WorkSunday = table.Column<bool>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AppSettings", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "VacationDays",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Date = table.Column<DateOnly>(type: "TEXT", nullable: false),
+                    Note = table.Column<string>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_VacationDays", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "WorkDays",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Date = table.Column<DateOnly>(type: "TEXT", nullable: false),
+                    StartTime = table.Column<TimeOnly>(type: "TEXT", nullable: true),
+                    EndTime = table.Column<TimeOnly>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_WorkDays", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "BreakEntries",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    WorkDayId = table.Column<int>(type: "INTEGER", nullable: false),
+                    StartTime = table.Column<TimeOnly>(type: "TEXT", nullable: true),
+                    EndTime = table.Column<TimeOnly>(type: "TEXT", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_BreakEntries", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_BreakEntries_WorkDays_WorkDayId",
+                        column: x => x.WorkDayId,
+                        principalTable: "WorkDays",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_BreakEntries_WorkDayId",
+                table: "BreakEntries",
+                column: "WorkDayId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "AppSettings");
+
+            migrationBuilder.DropTable(
+                name: "BreakEntries");
+
+            migrationBuilder.DropTable(
+                name: "VacationDays");
+
+            migrationBuilder.DropTable(
+                name: "WorkDays");
+        }
+    }
+}

Data/Migrations/20260520200000_AddPublicHolidays.Designer.cs

@@ -0,0 +1,159 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using timetracker.Data;
+
+#nullable disable
+
+namespace timetracker.Data.Migrations
+{
+    [DbContext(typeof(TimetrackerDbContext))]
+    [Migration("20260520200000_AddPublicHolidays")]
+    partial class AddPublicHolidays
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.8");
+
+            modelBuilder.Entity("timetracker.Data.AppSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double>("DailyTargetHours")
+                        .HasColumnType("REAL");
+
+                    b.Property<int>("MinimumBreakMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VacationDaysPerYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkFriday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkMonday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSaturday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSunday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkThursday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkTuesday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkWednesday")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AppSettings");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkDayId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkDayId");
+
+                    b.ToTable("BreakEntries");
+                });
+
+            modelBuilder.Entity("timetracker.Data.PublicHoliday", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PublicHolidays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.VacationDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("VacationDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorkDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.HasOne("timetracker.Data.WorkDay", "WorkDay")
+                        .WithMany("Breaks")
+                        .HasForeignKey("WorkDayId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkDay");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Navigation("Breaks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Data/Migrations/20260520200000_AddPublicHolidays.cs

@@ -0,0 +1,35 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace timetracker.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPublicHolidays : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "PublicHolidays",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Date = table.Column<DateOnly>(type: "TEXT", nullable: false),
+                    Name = table.Column<string>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PublicHolidays", x => x.Id);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(name: "PublicHolidays");
+        }
+    }
+}

Data/Migrations/20260522081459_AddMultiUser.Designer.cs

@@ -0,0 +1,191 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using timetracker.Data;
+
+#nullable disable
+
+namespace timetracker.Data.Migrations
+{
+    [DbContext(typeof(TimetrackerDbContext))]
+    [Migration("20260522081459_AddMultiUser")]
+    partial class AddMultiUser
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.8");
+
+            modelBuilder.Entity("timetracker.Data.AppSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double>("DailyTargetHours")
+                        .HasColumnType("REAL");
+
+                    b.Property<int>("MinimumBreakMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VacationDaysPerYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkFriday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkMonday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSaturday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSunday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkThursday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkTuesday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkWednesday")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AppSettings");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkDayId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkDayId");
+
+                    b.ToTable("BreakEntries");
+                });
+
+            modelBuilder.Entity("timetracker.Data.PublicHoliday", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PublicHolidays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("timetracker.Data.VacationDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("VacationDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorkDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.HasOne("timetracker.Data.WorkDay", "WorkDay")
+                        .WithMany("Breaks")
+                        .HasForeignKey("WorkDayId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkDay");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Navigation("Breaks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Data/Migrations/20260522081459_AddMultiUser.cs

@@ -0,0 +1,69 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace timetracker.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddMultiUser : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "UserId",
+                table: "WorkDays",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "UserId",
+                table: "VacationDays",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "UserId",
+                table: "AppSettings",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.CreateTable(
+                name: "Users",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    Username = table.Column<string>(type: "TEXT", nullable: false),
+                    PasswordHash = table.Column<string>(type: "TEXT", nullable: false),
+                    PasswordSalt = table.Column<string>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Users", x => x.Id);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "UserId",
+                table: "WorkDays");
+
+            migrationBuilder.DropColumn(
+                name: "UserId",
+                table: "VacationDays");
+
+            migrationBuilder.DropColumn(
+                name: "UserId",
+                table: "AppSettings");
+        }
+    }
+}

Data/Migrations/20260607213215_AddFlexTimeAndHolidayState.Designer.cs

@@ -0,0 +1,203 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using timetracker.Data;
+
+#nullable disable
+
+namespace timetracker.Data.Migrations
+{
+    [DbContext(typeof(TimetrackerDbContext))]
+    [Migration("20260607213215_AddFlexTimeAndHolidayState")]
+    partial class AddFlexTimeAndHolidayState
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.8");
+
+            modelBuilder.Entity("timetracker.Data.AppSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double>("DailyTargetHours")
+                        .HasColumnType("REAL");
+
+                    b.Property<DateOnly?>("FlexTimeStartDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<double>("FlexTimeStartingBalanceHours")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("GermanState")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MinimumBreakMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VacationDaysPerYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkFriday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkMonday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSaturday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSunday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkThursday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkTuesday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkWednesday")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AppSettings");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkDayId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkDayId");
+
+                    b.ToTable("BreakEntries");
+                });
+
+            modelBuilder.Entity("timetracker.Data.PublicHoliday", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Counties")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PublicHolidays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("timetracker.Data.VacationDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("VacationDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorkDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.HasOne("timetracker.Data.WorkDay", "WorkDay")
+                        .WithMany("Breaks")
+                        .HasForeignKey("WorkDayId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkDay");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Navigation("Breaks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Data/Migrations/20260607213215_AddFlexTimeAndHolidayState.cs

@@ -0,0 +1,60 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace timetracker.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddFlexTimeAndHolidayState : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "Counties",
+                table: "PublicHolidays",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateOnly>(
+                name: "FlexTimeStartDate",
+                table: "AppSettings",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<double>(
+                name: "FlexTimeStartingBalanceHours",
+                table: "AppSettings",
+                type: "REAL",
+                nullable: false,
+                defaultValue: 0.0);
+
+            migrationBuilder.AddColumn<string>(
+                name: "GermanState",
+                table: "AppSettings",
+                type: "TEXT",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Counties",
+                table: "PublicHolidays");
+
+            migrationBuilder.DropColumn(
+                name: "FlexTimeStartDate",
+                table: "AppSettings");
+
+            migrationBuilder.DropColumn(
+                name: "FlexTimeStartingBalanceHours",
+                table: "AppSettings");
+
+            migrationBuilder.DropColumn(
+                name: "GermanState",
+                table: "AppSettings");
+        }
+    }
+}

Data/Migrations/TimetrackerDbContextModelSnapshot.cs

@@ -0,0 +1,200 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using timetracker.Data;
+
+#nullable disable
+
+namespace timetracker.Data.Migrations
+{
+    [DbContext(typeof(TimetrackerDbContext))]
+    partial class TimetrackerDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.8");
+
+            modelBuilder.Entity("timetracker.Data.AppSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double>("DailyTargetHours")
+                        .HasColumnType("REAL");
+
+                    b.Property<DateOnly?>("FlexTimeStartDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<double>("FlexTimeStartingBalanceHours")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("GermanState")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MinimumBreakMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VacationDaysPerYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkFriday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkMonday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSaturday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkSunday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkThursday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkTuesday")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("WorkWednesday")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AppSettings");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("WorkDayId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkDayId");
+
+                    b.ToTable("BreakEntries");
+                });
+
+            modelBuilder.Entity("timetracker.Data.PublicHoliday", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Counties")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PublicHolidays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("timetracker.Data.VacationDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("VacationDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateOnly>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeOnly?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorkDays");
+                });
+
+            modelBuilder.Entity("timetracker.Data.BreakEntry", b =>
+                {
+                    b.HasOne("timetracker.Data.WorkDay", "WorkDay")
+                        .WithMany("Breaks")
+                        .HasForeignKey("WorkDayId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WorkDay");
+                });
+
+            modelBuilder.Entity("timetracker.Data.WorkDay", b =>
+                {
+                    b.Navigation("Breaks");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Data/PublicHoliday.cs

@@ -0,0 +1,9 @@
+namespace timetracker.Data;
+
+public class PublicHoliday
+{
+    public int Id { get; set; }
+    public DateOnly Date { get; set; }
+    public string Name { get; set; } = "";
+    public string? Counties { get; set; }
+}

Data/TimetrackerDbContext.cs

@@ -0,0 +1,13 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace timetracker.Data;
+
+public class TimetrackerDbContext(DbContextOptions<TimetrackerDbContext> options) : DbContext(options)
+{
+    public DbSet<User> Users => Set<User>();
+    public DbSet<WorkDay> WorkDays => Set<WorkDay>();
+    public DbSet<BreakEntry> BreakEntries => Set<BreakEntry>();
+    public DbSet<AppSettings> AppSettings => Set<AppSettings>();
+    public DbSet<VacationDay> VacationDays => Set<VacationDay>();
+    public DbSet<PublicHoliday> PublicHolidays => Set<PublicHoliday>();
+}

Data/TimetrackerService.cs

@@ -0,0 +1,198 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace timetracker.Data;
+
+public class TimetrackerService(IDbContextFactory<TimetrackerDbContext> factory)
+{
+    public async Task<List<WorkDay>> GetWeekAsync(int userId, DateOnly monday)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        return await db.WorkDays
+            .Include(w => w.Breaks)
+            .Where(w => w.UserId == userId && w.Date >= monday && w.Date < monday.AddDays(7))
+            .OrderBy(w => w.Date)
+            .ToListAsync();
+    }
+
+    public async Task UpsertWorkDayAsync(WorkDay workDay)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        var existing = await db.WorkDays
+            .Include(w => w.Breaks)
+            .FirstOrDefaultAsync(w => w.UserId == workDay.UserId && w.Date == workDay.Date);
+
+        if (existing == null)
+        {
+            workDay.Id = 0;
+            foreach (var b in workDay.Breaks) b.Id = 0;
+            db.WorkDays.Add(workDay);
+        }
+        else
+        {
+            existing.StartTime = workDay.StartTime;
+            existing.EndTime = workDay.EndTime;
+            db.BreakEntries.RemoveRange(existing.Breaks);
+            existing.Breaks.Clear();
+            foreach (var b in workDay.Breaks)
+                existing.Breaks.Add(new BreakEntry
+                {
+                    WorkDayId = existing.Id,
+                    StartTime = b.StartTime,
+                    EndTime = b.EndTime
+                });
+        }
+
+        await db.SaveChangesAsync();
+    }
+
+    public async Task<AppSettings> GetSettingsAsync(int userId)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        return await db.AppSettings.FirstOrDefaultAsync(s => s.UserId == userId)
+            ?? new AppSettings { UserId = userId };
+    }
+
+    public async Task SaveSettingsAsync(AppSettings settings)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        var existing = await db.AppSettings.FirstOrDefaultAsync(s => s.UserId == settings.UserId);
+        if (existing == null)
+            db.AppSettings.Add(settings);
+        else
+        {
+            existing.DailyTargetHours = settings.DailyTargetHours;
+            existing.MinimumBreakMinutes = settings.MinimumBreakMinutes;
+            existing.VacationDaysPerYear = settings.VacationDaysPerYear;
+            existing.WorkMonday = settings.WorkMonday;
+            existing.WorkTuesday = settings.WorkTuesday;
+            existing.WorkWednesday = settings.WorkWednesday;
+            existing.WorkThursday = settings.WorkThursday;
+            existing.WorkFriday = settings.WorkFriday;
+            existing.WorkSaturday = settings.WorkSaturday;
+            existing.WorkSunday = settings.WorkSunday;
+        }
+        await db.SaveChangesAsync();
+    }
+
+    // ── Urlaub ────────────────────────────────────────────────────────────
+    public async Task<List<VacationDay>> GetVacationDaysAsync(int userId, int year)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        return await db.VacationDays
+            .Where(v => v.UserId == userId && v.Date.Year == year)
+            .OrderBy(v => v.Date)
+            .ToListAsync();
+    }
+
+    public async Task AddVacationDayAsync(VacationDay vacationDay)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        var exists = await db.VacationDays.AnyAsync(v => v.UserId == vacationDay.UserId && v.Date == vacationDay.Date);
+        if (!exists)
+        {
+            vacationDay.Id = 0;
+            db.VacationDays.Add(vacationDay);
+            await db.SaveChangesAsync();
+        }
+    }
+
+    public async Task RemoveVacationDayAsync(int userId, int id)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        var v = await db.VacationDays.FirstOrDefaultAsync(v => v.Id == id && v.UserId == userId);
+        if (v != null)
+        {
+            db.VacationDays.Remove(v);
+            await db.SaveChangesAsync();
+        }
+    }
+
+    // ── Gleitzeitkonto ───────────────────────────────────────────────────
+    public async Task<TimeSpan> GetTotalOvertimeAsync(int userId, AppSettings settings)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+
+        // 1. Finde das Startdatum für die Berechnung
+        var firstDay = await db.WorkDays
+            .Where(w => w.UserId == userId)
+            .OrderBy(w => w.Date)
+            .Select(w => (DateOnly?)w.Date)
+            .FirstOrDefaultAsync();
+
+        if (firstDay == null && !settings.FlexTimeStartDate.HasValue)
+            return TimeSpan.FromHours(settings.FlexTimeStartingBalanceHours);
+
+        var startDate = settings.FlexTimeStartDate ?? firstDay!.Value;
+        var endDate = DateOnly.FromDateTime(DateTime.Today);
+
+        if (startDate > endDate)
+            return TimeSpan.FromHours(settings.FlexTimeStartingBalanceHours);
+
+        // 2. Lade alle erfassten Arbeitstage in diesem Zeitraum
+        var workDays = await db.WorkDays
+            .Include(w => w.Breaks)
+            .Where(w => w.UserId == userId && w.Date >= startDate && w.Date <= endDate)
+            .ToDictionaryAsync(w => w.Date);
+
+        // 3. Lade alle Feiertage in diesem Zeitraum
+        var holidaysList = await db.PublicHolidays
+            .Where(h => h.Date >= startDate && h.Date <= endDate)
+            .ToListAsync();
+
+        var state = settings.GermanState;
+        var holidaySet = holidaysList
+            .Where(h => string.IsNullOrEmpty(h.Counties) || (!string.IsNullOrEmpty(state) && h.Counties.Split(',').Contains(state)))
+            .Select(h => h.Date)
+            .ToHashSet();
+
+        // 4. Lade alle Urlaubstage in diesem Zeitraum
+        var vacationSet = await db.VacationDays
+            .Where(v => v.UserId == userId && v.Date >= startDate && v.Date <= endDate)
+            .Select(v => v.Date)
+            .ToHashSetAsync();
+
+        double totalOvertimeHours = settings.FlexTimeStartingBalanceHours;
+
+        for (var date = startDate; date <= endDate; date = date.AddDays(1))
+        {
+            bool isWorkDay = settings.IsWorkDay(date.DayOfWeek);
+            bool isHoliday = holidaySet.Contains(date);
+            bool isVacation = vacationSet.Contains(date);
+
+            // Sollzeit gilt nur an regulären Arbeitstagen, die weder Feiertag noch Urlaub sind
+            double target = (isWorkDay && !isHoliday && !isVacation) ? settings.DailyTargetHours : 0.0;
+            double actual = 0.0;
+
+            if (workDays.TryGetValue(date, out var wd) && wd.StartTime != null && wd.EndTime != null)
+            {
+                var gross = wd.EndTime.Value.ToTimeSpan() - wd.StartTime.Value.ToTimeSpan();
+                if (gross > TimeSpan.Zero)
+                {
+                    var breakTotal = wd.Breaks
+                        .Where(b => b.StartTime.HasValue && b.EndTime.HasValue && b.EndTime > b.StartTime)
+                        .Aggregate(TimeSpan.Zero, (s, b) =>
+                            s + (b.EndTime!.Value.ToTimeSpan() - b.StartTime!.Value.ToTimeSpan()));
+                    actual = (gross - breakTotal).TotalHours;
+                    if (actual < 0) actual = 0.0;
+                }
+            }
+
+            totalOvertimeHours += (actual - target);
+        }
+
+        return TimeSpan.FromHours(totalOvertimeHours);
+    }
+
+    // ── Monatsübersicht ───────────────────────────────────────────────────
+    public async Task<List<WorkDay>> GetMonthAsync(int userId, int year, int month)
+    {
+        await using var db = await factory.CreateDbContextAsync();
+        var from = new DateOnly(year, month, 1);
+        var to = from.AddMonths(1);
+        return await db.WorkDays
+            .Include(w => w.Breaks)
+            .Where(w => w.UserId == userId && w.Date >= from && w.Date < to)
+            .OrderBy(w => w.Date)
+            .ToListAsync();
+    }
+}

Data/User.cs

@@ -0,0 +1,9 @@
+namespace timetracker.Data;
+
+public class User
+{
+    public int Id { get; set; }
+    public string Username { get; set; } = "";
+    public string PasswordHash { get; set; } = "";
+    public string PasswordSalt { get; set; } = "";
+}

Data/VacationDay.cs

@@ -0,0 +1,9 @@
+namespace timetracker.Data;
+
+public class VacationDay
+{
+    public int Id { get; set; }
+    public int UserId { get; set; }
+    public DateOnly Date { get; set; }
+    public string? Note { get; set; }
+}

Data/WorkDay.cs

@@ -0,0 +1,11 @@
+namespace timetracker.Data;
+
+public class WorkDay
+{
+    public int Id { get; set; }
+    public int UserId { get; set; }
+    public DateOnly Date { get; set; }
+    public TimeOnly? StartTime { get; set; }
+    public TimeOnly? EndTime { get; set; }
+    public List<BreakEntry> Breaks { get; set; } = [];
+}