updated pdf form to send user to pdf generator

Reviewed-on: #66

.gitea/workflows/build.yaml

@@ -4,55 +4,13 @@ on:
   push:
     tags:
       - "*"
+    branches:
+      - main
 
 jobs:
-  testing:
-    name: Run Go Tests
-    runs-on: ubuntu-latest
-    services:
-      postgres:
-        image: postgres:16
-        env:
-          POSTGRES_USER: root
-          POSTGRES_PASSWORD: password
-          POSTGRES_DB: arbeitszeitmessung
-    env:
-      POSTGRES_HOST: postgres
-      POSTGRES_USER: root
-      POSTGRES_PASSWORD: password
-      POSTGRES_DB: arbeitszeitmessung
-      POSTGRES_PORT: 5432
-      RUNNER_TOOL_CACHE: /toolcache # Runner Tool Cache
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup go
-        uses: actions/setup-go@v5
-        with:
-          go-version-file: Backend/go.mod
-      - uses: https://gitea.com/actions/go-hashfiles@v0.0.1
-        id: hash-go
-        with:
-          patterns: |
-            go.mod
-            go.sum
-      - name: cache go
-        id: cache-go
-        uses: actions/cache@v4
-        with:
-          path: |-
-            /go_path
-            /go_cache
-          key: arbeitszeitmessung-${{ steps.hash-go.outputs.hash }}
-          restore-keys: |-
-            arbeitszeitmessung-
-      - name: Run Go Tests
-        run: cd Backend && go test ./...
-  build:
+  webserver:
     name: Build Go Image and Upload
     runs-on: ubuntu-latest
-    needs: [testing]
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -66,12 +24,49 @@ jobs:
         uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: git.letsstein.de/tom/arbeitszeitmessung-webserver
+          tags: |
+            type=raw,value=latest
+            type=pep440,pattern={{version}}
       - name: Build and push
         uses: docker/build-push-action@v6
         with:
           platforms: linux/amd64,linux/arm64
           push: true
           context: Backend
+          tags: ${{ steps.meta.outputs.tags }}
+  document-creator:
+    name: Build Go Image and Upload
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: git.letsstein.de
+          username: ${{ gitea.actor }}
+          password: ${{ secrets.REGISTRY_TOKEN }}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: git.letsstein.de/tom/arbeitszeitmessung-doc-creator
           tags: |
-            git.letsstein.de/tom/arbeitszeitmessung:latest
-            git.letsstein.de/tom/arbeitszeitmessung:${{  github.ref_name }}
+            type=raw,value=latest
+            type=pep440,pattern={{version}}
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          platforms: linux/amd64,linux/arm64
+          push: true
+          context: Backend
+          tags: ${{ steps.meta.outputs.tags }}

.gitignore

@@ -39,3 +39,4 @@ node_modules
 atlas.hcl
 .scannerwork
 Backend/logs
+.worktime.txt

Backend/endpoints/auto-kurzarbeit.go

@@ -0,0 +1,82 @@
+package endpoints
+
+import (
+	"arbeitszeitmessung/helper"
+	"arbeitszeitmessung/helper/paramParser"
+	"arbeitszeitmessung/models"
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"net/http"
+	"time"
+)
+
+func KurzarbeitFillHandler(w http.ResponseWriter, r *http.Request) {
+	helper.SetCors(w)
+	switch r.Method {
+	case "GET":
+		fillKurzarbeit(r, w)
+	default:
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func fillKurzarbeit(r *http.Request, w http.ResponseWriter) {
+	bookingTypeKurzarbeit, err := getKurzarbeitBookingType()
+	if err != nil {
+		slog.Info("Error getting BookingType Kurzarbeit %v\n", slog.Any("Error", err))
+	}
+	users, err := models.GetAllUsers()
+	if err != nil {
+		slog.Info("Error getting user list %v\n", slog.Any("Error", err))
+	}
+
+	pp := paramParser.New(r.URL.Query())
+	startDate := pp.ParseTimestampFallback("date", time.DateOnly, time.Now())
+
+	var kurzarbeitAdded int
+
+	for _, user := range users {
+		days := models.GetDays(user, startDate, startDate.AddDate(0, 0, 1), false)
+		if len(days) == 0 {
+			continue
+		}
+
+		day := days[len(days)-1]
+		if !day.IsKurzArbeit() || !day.IsWorkDay() {
+			continue
+		}
+		if day.GetWorktime(user, models.WorktimeBaseDay, false) >= day.GetWorktime(user, models.WorktimeBaseDay, true) {
+			continue
+		}
+
+		worktimeKurzarbeit := day.GetWorktime(user, models.WorktimeBaseDay, true) - day.GetWorktime(user, models.WorktimeBaseDay, false)
+
+		if wDay, ok := day.(*models.WorkDay); !ok || len(wDay.Bookings) == 0 {
+			continue
+		}
+		workday, _ := day.(*models.WorkDay)
+
+		lastBookingTime := workday.Bookings[len(workday.Bookings)-1].Timestamp
+		kurzarbeitBegin := (*models.Booking).New(nil, user.CardUID, 0, 1, bookingTypeKurzarbeit.Id)
+		kurzarbeitEnd := (*models.Booking).New(nil, user.CardUID, 0, 2, bookingTypeKurzarbeit.Id)
+		kurzarbeitBegin.Timestamp = lastBookingTime.Add(time.Minute)
+		kurzarbeitEnd.Timestamp = lastBookingTime.Add(worktimeKurzarbeit)
+
+		kurzarbeitBegin.InsertWithTimestamp()
+		kurzarbeitEnd.InsertWithTimestamp()
+		kurzarbeitAdded += 1
+	}
+
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(kurzarbeitAdded)
+}
+
+func getKurzarbeitBookingType() (models.BookingType, error) {
+	for _, bookingType := range models.GetBookingTypesCached() {
+		if bookingType.Name == "Kurzarbeit" {
+			return bookingType, nil
+		}
+	}
+	return models.BookingType{}, errors.New("No Booking Type found")
+}

Backend/endpoints/auto-logout.go

@@ -20,7 +20,7 @@ func LogoutHandler(w http.ResponseWriter, r *http.Request) {
 }
 
 func autoLogout(w http.ResponseWriter) {
-	users, err := (*models.User).GetAll(nil)
+	users, err := models.GetAllUsers()
 	var logged_out_users []models.User
 	if err != nil {
 		fmt.Printf("Error getting user list %v\n", err)

Backend/endpoints/pdf-create.go

@@ -20,13 +20,21 @@ func convertDaysToTypst(days []models.IWorkDay, u models.User) ([]typstDay, erro
 	var typstDays []typstDay
 	for _, day := range days {
 		var thisTypstDay typstDay
-		work, pause, overtime := day.GetTimesVirtual(u, models.WorktimeBaseWeek)
+		work, pause, overtime := day.GetTimes(u, models.WorktimeBaseDay, false)
+		workVirtual := day.GetWorktime(u, models.WorktimeBaseDay, true)
+		overtime = workVirtual - u.ArbeitszeitProWocheFrac(0.2)
 		thisTypstDay.Date = day.Date().Format(DE_DATE)
-		thisTypstDay.Worktime = helper.FormatDurationFill(work, true)
+		thisTypstDay.Worktime = helper.FormatDurationFill(workVirtual, true)
 		thisTypstDay.Pausetime = helper.FormatDurationFill(pause, true)
 		thisTypstDay.Overtime = helper.FormatDurationFill(overtime, true)
 		thisTypstDay.IsFriday = day.Date().Weekday() == time.Friday
 
+		if workVirtual > work {
+			thisTypstDay.Kurzarbeit = helper.FormatDurationFill(workVirtual-work, true)
+		} else {
+			thisTypstDay.Kurzarbeit = helper.FormatDurationFill(0, true)
+		}
+
 		thisTypstDay.DayParts = convertDayToTypstDayParts(day, u)
 		typstDays = append(typstDays, thisTypstDay)
 	}
@@ -45,7 +53,7 @@ func convertDayToTypstDayParts(day models.IWorkDay, user models.User) []typstDay
 			typstDayPart.IsWorkDay = true
 			typstDayParts = append(typstDayParts, typstDayPart)
 		}
-		if day.IsKurzArbeit() {
+		if day.IsKurzArbeit() && len(workDay.Bookings) > 0 {
 			tsFrom, tsTo := workDay.GenerateKurzArbeitBookings(user)
 			typstDayParts = append(typstDayParts, typstDayPart{
 				BookingFrom: tsFrom.Format("15:04"),
@@ -54,6 +62,10 @@ func convertDayToTypstDayParts(day models.IWorkDay, user models.User) []typstDay
 				IsWorkDay:   true,
 			})
 		}
+		if workdayAbsence := workDay.GetWorktimeAbsence(); (workdayAbsence != models.Absence{}) {
+			typstDayParts = append(typstDayParts, typstDayPart{IsWorkDay: false, WorkType: workdayAbsence.AbwesenheitTyp.Name})
+		}
+
 	} else {
 		absentDay, _ := day.(*models.Absence)
 		typstDayParts = append(typstDayParts, typstDayPart{IsWorkDay: false, WorkType: absentDay.AbwesenheitTyp.Name})
@@ -61,39 +73,6 @@ func convertDayToTypstDayParts(day models.IWorkDay, user models.User) []typstDay
 	return typstDayParts
 }
 
-func renderPDF(days []typstDay, metadata typstMetadata) (bytes.Buffer, error) {
-	var markup bytes.Buffer
-	var output bytes.Buffer
-
-	if err := typst.InjectValues(&markup, map[string]any{"meta": metadata, "days": days}); err != nil {
-		return output, err
-	}
-
-	// Import the template and invoke the template function with the custom data.
-	// Show is used to replace the current document with whatever content the template function in `template.typ` returns.
-	markup.WriteString(`
-		#import "templates/abrechnung.typ": abrechnung
-		#show: doc => abrechnung(meta, days)
-		`)
-
-	// Compile the prepared markup with Typst and write the result it into `output.pdf`.
-	// f, err := os.Create("output.pdf")
-	// if err != nil {
-	// 	log.Panicf("Failed to create output file: %v.", err)
-	// }
-	// defer f.Close()
-	//
-
-	// typstCLI := typst.CLI{}
-	typstCLI := typst.DockerExec{
-		ContainerName: helper.GetEnv("TYPST_CONTAINER", "arbeitszeitmessung-doc-creator"),
-	}
-	if err := typstCLI.Compile(&markup, &output, nil); err != nil {
-		return output, err
-	}
-	return output, nil
-}
-
 func PDFCreateController(w http.ResponseWriter, r *http.Request) {
 	helper.RequiresLogin(Session, w, r)
 	switch r.Method {
@@ -105,15 +84,26 @@ func PDFCreateController(w http.ResponseWriter, r *http.Request) {
 		}
 		pp := paramParser.New(r.URL.Query())
 		startDate := pp.ParseTimestampFallback("start_date", time.DateOnly, time.Now())
-		var members []models.User = make([]models.User, 0)
-		output, err := createReports(user, members, startDate)
+		personalNumbers := pp.ParseIntListFallback("employe_list", ",", make([]int, 0))
+
+		employes, err := models.GetUserByPersonalNrMulti(personalNumbers)
+		if err != nil {
+			slog.Warn("Error getting employes!", slog.Any("Error", err))
+			return
+		}
+
+		output, err := createReports(user, employes, startDate)
 		if err != nil {
 			slog.Warn("Could not create pdf report", slog.Any("Error", err))
 		}
-
+		switch pp.ParseStringFallback("output", "render") {
+		case "render":
 			w.Header().Set("Content-type", "application/pdf")
 			output.WriteTo(w)
-		w.WriteHeader(200)
+			w.WriteHeader(http.StatusOK)
+		case "download":
+			panic("Not implemented")
+		}
 
 	default:
 		http.Error(w, "Method not allowed!", http.StatusMethodNotAllowed)
@@ -121,92 +111,89 @@ func PDFCreateController(w http.ResponseWriter, r *http.Request) {
 }
 
 func createReports(user models.User, employes []models.User, startDate time.Time) (bytes.Buffer, error) {
-	if startDate.Day() > 1 {
-		startDate = startDate.AddDate(0, 0, -(startDate.Day() - 1))
-	}
+	startDate = helper.GetFirstOfMonth(startDate)
 	endDate := startDate.AddDate(0, 1, -1)
-	return createEmployeReport(user, startDate, endDate)
+
+	var employeData []typstData
+	for _, employe := range employes {
+		if data, err := createEmployeReport(employe, startDate, endDate); err != nil {
+			slog.Warn("Error when creating employeReport", slog.Any("user", employe), slog.Any("error", err))
+		} else {
+			employeData = append(employeData, data)
+		}
+	}
+	return renderPDF(employeData)
 }
 
-func createEmployeReport(employee models.User, startDate, endDate time.Time) (bytes.Buffer, error) {
-	targetHours := (employee.ArbeitszeitProWoche() / 5) * time.Duration(helper.GetWorkingDays(startDate, endDate))
-	workingDays := models.GetDays(employee, startDate, endDate, false)
+func createEmployeReport(employee models.User, startDate, endDate time.Time) (typstData, error) {
+	targetHoursThisMonth := employee.ArbeitszeitProWocheFrac(.2) * time.Duration(helper.GetWorkingDays(startDate, endDate))
+	workDaysThisMonth := models.GetDays(employee, startDate, endDate.AddDate(0, 0, 1), false)
 
-	slog.Debug("Baseline Working hours", "targetHours", targetHours.Hours())
+	slog.Debug("Baseline Working hours", "targetHours", targetHoursThisMonth.Hours())
 
-	var actualHours time.Duration
-	for _, day := range workingDays {
-		actualHours += day.TimeWorkVirtual(employee)
+	var workHours, kurzarbeitHours time.Duration
+	for _, day := range workDaysThisMonth {
+		tmpvirtualHours := day.GetWorktime(employee, models.WorktimeBaseDay, true)
+		tmpactualHours := day.GetWorktime(employee, models.WorktimeBaseDay, false)
+		if day.IsKurzArbeit() && tmpvirtualHours > tmpactualHours {
+			slog.Debug("Adding kurzarbeit to workday", "day", day.Date())
+			kurzarbeitHours += tmpvirtualHours - tmpactualHours
 		}
-	worktimeBalance := actualHours - targetHours
+		workHours += tmpvirtualHours
+	}
+	worktimeBalance := workHours - targetHoursThisMonth
 
-	typstDays, err := convertDaysToTypst(workingDays, employee)
+	typstDays, err := convertDaysToTypst(workDaysThisMonth, employee)
 	if err != nil {
-		log.Panicf("Failed to convert days!")
+		slog.Warn("Failed to convert to days", slog.Any("error", err))
+		return typstData{}, err
 	}
 
 	metadata := typstMetadata{
 		EmployeeName:     fmt.Sprintf("%s %s", employee.Vorname, employee.Name),
 		TimeRange:        fmt.Sprintf("%s - %s", startDate.Format(DE_DATE), endDate.Format(DE_DATE)),
 		Overtime:         helper.FormatDurationFill(worktimeBalance, true),
-		WorkTime:         helper.FormatDurationFill(actualHours, true),
+		WorkTime:         helper.FormatDurationFill(workHours, true),
+		Kurzarbeit:       helper.FormatDurationFill(kurzarbeitHours, true),
 		OvertimeTotal:    "",
 		CurrentTimestamp: time.Now().Format("02.01.2006 - 15:04 Uhr"),
 	}
-
-	return renderPDF(typstDays, metadata)
+	return typstData{Meta: metadata, Days: typstDays}, nil
 }
 
-func PDFHandler(w http.ResponseWriter, r *http.Request) {
-	helper.RequiresLogin(Session, w, r)
-	startDate := time.Now()
+func renderPDF(data []typstData) (bytes.Buffer, error) {
+	var markup bytes.Buffer
+	var output bytes.Buffer
 
-	if startDate.Day() > 1 {
-		startDate = startDate.AddDate(0, 0, -(startDate.Day() - 1))
-	}
-	endDate := startDate.AddDate(0, 1, -1)
-
-	user, err := models.GetUserFromSession(Session, r.Context())
-	if err != nil {
-		log.Println("Error getting user!")
+	if err := typst.InjectValues(&markup, map[string]any{"data": data}); err != nil {
+		return output, err
 	}
 
-	//TODO: only accepted weeks
-
-	weeks := models.GetDays(user, startDate, endDate, false)
-	var aggregatedOvertime, aggregatedWorkTime time.Duration
-	for _, day := range weeks {
-		aggregatedOvertime += day.TimeOvertimeReal(user)
-		aggregatedWorkTime += day.TimeWorkVirtual(user)
+	// Import the template and invoke the template function with the custom data.
+	// Show is used to replace the current document with whatever content the template function in `template.typ` returns.
+	markup.WriteString(`
+		#import "templates/abrechnung.typ": abrechnung
+		#for d in data {
+  			abrechnung(d.Meta, d.Days)
      	}
+		`)
 
-	typstDays, err := convertDaysToTypst(weeks, user)
-	if err != nil {
-		log.Panicf("Failed to convert days!")
-	}
-	metadata := typstMetadata{
-		EmployeeName:     fmt.Sprintf("%s %s", user.Vorname, user.Name),
-		TimeRange:        fmt.Sprintf("%s - %s", startDate.Format(DE_DATE), endDate.Format(DE_DATE)),
-		Overtime:         helper.FormatDurationFill(aggregatedOvertime, true),
-		WorkTime:         helper.FormatDurationFill(aggregatedWorkTime, true),
-		OvertimeTotal:    "",
-		CurrentTimestamp: time.Now().Format("02.01.2006 - 15:04 Uhr"),
-	}
+	// Compile the prepared markup with Typst and write the result it into `output.pdf`.
 
-	output, err := renderPDF(typstDays, metadata)
-	if err != nil {
-		slog.Warn("Could not create pdf report", slog.Any("Error", err))
+	typstCLI := typst.DockerExec{
+		ContainerName: helper.GetEnv("TYPST_CONTAINER", "arbeitszeitmessung-doc-creator"),
 	}
-
-	w.Header().Set("Content-type", "application/pdf")
-	output.WriteTo(w)
-	w.WriteHeader(200)
+	if err := typstCLI.Compile(&markup, &output, nil); err != nil {
+		return output, err
+	}
+	return output, nil
 }
 
 type typstMetadata struct {
 	TimeRange        string `json:"time-range"`
 	EmployeeName     string `json:"employee-name"`
 	WorkTime         string `json:"worktime"`
+	Kurzarbeit       string `json:"kurzarbeit"`
 	Overtime         string `json:"overtime"`
 	OvertimeTotal    string `json:"overtime-total"`
 	CurrentTimestamp string `json:"current-timestamp"`
@@ -225,5 +212,11 @@ type typstDay struct {
 	Worktime   string         `json:"worktime"`
 	Pausetime  string         `json:"pausetime"`
 	Overtime   string         `json:"overtime"`
+	Kurzarbeit string         `json:"kurzarbeit"`
 	IsFriday   bool           `json:"is-weekend"`
 }
+
+type typstData struct {
+	Meta typstMetadata `json:"meta"`
+	Days []typstDay    `json:"days"`
+}

Backend/endpoints/time.go

@@ -84,7 +84,7 @@ func getBookings(w http.ResponseWriter, r *http.Request) {
 		if day.Date().Before(lastSub) {
 			continue
 		}
-		aggregatedOvertime += day.TimeOvertimeReal(user)
+		aggregatedOvertime += day.GetOvertime(user, models.WorktimeBaseDay, false)
 	}
 	if reportedOvertime, err := user.GetReportedOvertime(); err == nil {
 		user.Overtime = (reportedOvertime + aggregatedOvertime).Round(time.Minute)

Backend/helper/paramParser/main.go

@@ -5,6 +5,7 @@ import (
 	"log/slog"
 	"net/url"
 	"strconv"
+	"strings"
 	"time"
 )
 
@@ -12,6 +13,30 @@ type ParamsParser struct {
 	urlParams url.Values
 }
 
+func (p ParamsParser) ParseStringListFallback(key string, delimiter string, fallback []string) []string {
+	if !p.urlParams.Has(key) {
+		return fallback
+	}
+	paramList := p.urlParams.Get(key)
+	list := strings.Split(paramList, delimiter)
+	return list
+}
+
+func (p ParamsParser) ParseIntListFallback(key string, delimiter string, fallback []int) []int {
+	if !p.urlParams.Has(key) {
+		return fallback
+	}
+	paramList := p.urlParams.Get(key)
+	list := strings.Split(paramList, delimiter)
+	parsedList := make([]int, 0)
+	for _, item := range list {
+		if parsedItem, err := strconv.Atoi(item); err == nil {
+			parsedList = append(parsedList, parsedItem)
+		}
+	}
+	return parsedList
+}
+
 type NoValueError struct {
 	Key string
 }
@@ -59,7 +84,7 @@ func (p *ParamsParser) ParseStringFallback(key string, fallback string) string {
 	return p.urlParams.Get(key)
 }
 
-func (p *ParamsParser) ParseString(key string, fallback string) (string, error) {
+func (p *ParamsParser) ParseString(key string) (string, error) {
 	if !p.urlParams.Has(key) {
 		return "", &NoValueError{Key: key}
 	}

Backend/helper/strings_test.go

@@ -0,0 +1,47 @@
+package helper
+
+import "testing"
+
+func TestGetFirst(t *testing.T) {
+	tests := []struct {
+		name string
+		a    any
+		b    any
+		want any
+	}{
+		{"ints", 10, 20, 10},
+		{"strings", "first", "second", "first"},
+		{"mixed", "abc", 123, "abc"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := GetFirst(tt.a, tt.b)
+			if got != tt.want {
+				t.Errorf("GetFirst(%v, %v) = %v, want %v", tt.a, tt.b, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestGetSecond(t *testing.T) {
+	tests := []struct {
+		name string
+		a    any
+		b    any
+		want any
+	}{
+		{"ints", 10, 20, 20},
+		{"strings", "first", "second", "second"},
+		{"mixed", "abc", 123, 123},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := GetSecond(tt.a, tt.b)
+			if got != tt.want {
+				t.Errorf("GetSecond(%v, %v) = %v, want %v", tt.a, tt.b, got, tt.want)
+			}
+		})
+	}
+}

Backend/helper/time.go

@@ -16,6 +16,13 @@ func GetMonday(ts time.Time) time.Time {
 	return ts
 }
 
+func GetFirstOfMonth(ts time.Time) time.Time {
+	if ts.Day() > 1 {
+		return ts.AddDate(0, 0, -(ts.Day() - 1))
+	}
+	return ts
+}
+
 func IsWeekend(ts time.Time) bool {
 	return ts.Weekday() == time.Saturday || ts.Weekday() == time.Sunday
 }

Backend/helper/time_test.go

@@ -8,13 +8,44 @@ import (
 
 func TestGetMonday(t *testing.T) {
 	isMonday, err := time.Parse(time.DateOnly, "2025-07-14")
+	isSunday, err := time.Parse(time.DateOnly, "2025-07-20")
 	notMonday, err := time.Parse(time.DateOnly, "2025-07-16")
 	if err != nil || isMonday.Equal(notMonday) {
 		t.Errorf("U stupid? %e", err)
 	}
-	if GetMonday(isMonday) != isMonday || GetMonday(notMonday) != isMonday {
+	if GetMonday(isMonday) != isMonday {
 		t.Error("Wrong date conversion!")
 	}
+
+	if GetMonday(notMonday) != isMonday {
+		t.Error("Wrong date conversion (notMonday)!")
+	}
+
+	if GetMonday(isSunday) != isMonday {
+		t.Error("Wrong date conversion (isSunday)!")
+	}
+}
+
+func TestFormatDurationFill(t *testing.T) {
+	testCases := []struct {
+		name     string
+		duration time.Duration
+		fill     bool
+	}{
+		{"2h", time.Duration(120 * time.Minute), true},
+		{"30min", time.Duration(30 * time.Minute), true},
+		{"1h 30min", time.Duration(90 * time.Minute), true},
+		{"-1h 30min", time.Duration(-90 * time.Minute), true},
+		{"0min", 0, true},
+		{"", 0, false},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			if FormatDurationFill(tc.duration, tc.fill) != tc.name {
+				t.Error("Format missmatch in Formatduration.")
+			}
+		})
+	}
 }
 
 func TestFormatDuration(t *testing.T) {
@@ -22,10 +53,6 @@ func TestFormatDuration(t *testing.T) {
 		name     string
 		duration time.Duration
 	}{
-		{"2h", time.Duration(120 * time.Minute)},
-		{"30min", time.Duration(30 * time.Minute)},
-		{"1h 30min", time.Duration(90 * time.Minute)},
-		{"-1h 30min", time.Duration(-90 * time.Minute)},
 		{"", 0},
 	}
 	for _, tc := range testCases {
@@ -37,6 +64,29 @@ func TestFormatDuration(t *testing.T) {
 	}
 }
 
+func TestIsSameDate(t *testing.T) {
+	testCases := []struct {
+		dateA  string
+		dateB  string
+		result bool
+	}{
+		{"2025-12-01 00:00:00", "2025-12-01 00:00:00", true},
+		{"2025-12-03 00:00:00", "2025-12-02 00:00:00", false},
+		{"2025-12-03 23:45:00", "2025-12-03 00:00:00", true},
+		{"2025-12-04 24:12:00", "2025-12-04 00:12:00", false},
+	}
+
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("IsSameDateTest: %s date", tc.dateA), func(t *testing.T) {
+			dateA, _ := time.Parse(time.DateTime, tc.dateA)
+			dateB, _ := time.Parse(time.DateTime, tc.dateB)
+			if IsSameDate(dateA, dateB) != tc.result {
+				t.Errorf("Is SameDate did not match! Result %t", IsSameDate(dateA, dateB))
+			}
+		})
+	}
+}
+
 func TestGetWorkingDays(t *testing.T) {
 	testCases := []struct {
 		start string
@@ -82,3 +132,41 @@ func TestFormatGermanDayOfWeek(t *testing.T) {
 		})
 	}
 }
+
+func TestGetKW(t *testing.T) {
+	tests := []struct {
+		name string
+		date time.Time
+		want int
+	}{
+		{
+			name: "First week of year",
+			date: time.Date(2023, 1, 2, 0, 0, 0, 0, time.UTC), // Monday
+			want: 1,
+		},
+		{
+			name: "Middle of year",
+			date: time.Date(2023, 6, 15, 0, 0, 0, 0, time.UTC),
+			want: 24,
+		},
+		{
+			name: "Last week of year",
+			date: time.Date(2023, 12, 31, 0, 0, 0, 0, time.UTC),
+			want: 52,
+		},
+		{
+			name: "ISO week crossing into next year",
+			date: time.Date(2020, 12, 31, 0, 0, 0, 0, time.UTC),
+			want: 53,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := GetKW(tt.date)
+			if got != tt.want {
+				t.Errorf("GetKW(%v) = %d, want %d", tt.date, got, tt.want)
+			}
+		})
+	}
+}

Backend/helper/types_test.go

@@ -0,0 +1,26 @@
+package helper
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestBoolToInt(t *testing.T) {
+	testCases := []struct {
+		value bool
+		res   int
+		res8  int8
+	}{
+		{true, 1, 1},
+		{false, 0, 0},
+	}
+
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("BoolToInt value: %t", tc.value), func(t *testing.T) {
+			if BoolToInt(tc.value) != tc.res || BoolToInt8(tc.value) != tc.res8 {
+				t.Error("How could you... mess up bool to int")
+			}
+		})
+	}
+
+}

Backend/helper/web_test.go

@@ -0,0 +1,112 @@
+package helper
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+
+	"github.com/alexedwards/scs/v2"
+)
+
+func TestSetCors_WhenNoCorsTrue(t *testing.T) {
+	os.Setenv("NO_CORS", "true")
+	defer os.Unsetenv("NO_CORS")
+
+	rr := httptest.NewRecorder()
+
+	SetCors(rr)
+
+	h := rr.Header()
+
+	if h.Get("Access-Control-Allow-Origin") != "*" {
+		t.Errorf("expected Access-Control-Allow-Origin to be '*', got %q", h.Get("Access-Control-Allow-Origin"))
+	}
+
+	if h.Get("Access-Control-Allow-Methods") != "*" {
+		t.Errorf("expected Access-Control-Allow-Methods to be '*', got %q", h.Get("Access-Control-Allow-Methods"))
+	}
+
+	if h.Get("Access-Control-Allow-Headers") != "*" {
+		t.Errorf("expected Access-Control-Allow-Headers to be '*', got %q", h.Get("Access-Control-Allow-Headers"))
+	}
+}
+
+func TestSetCors_WhenNoCorsFalse(t *testing.T) {
+	os.Setenv("NO_CORS", "false")
+	defer os.Unsetenv("NO_CORS")
+
+	rr := httptest.NewRecorder()
+
+	SetCors(rr)
+
+	h := rr.Header()
+	if h.Get("Access-Control-Allow-Origin") != "" ||
+		h.Get("Access-Control-Allow-Methods") != "" ||
+		h.Get("Access-Control-Allow-Headers") != "" {
+		t.Errorf("CORS headers should not be set when NO_CORS=false")
+	}
+}
+
+func TestRequiresLogin_DebugMode_NoRedirect(t *testing.T) {
+	os.Setenv("GO_ENV", "debug")
+	defer os.Unsetenv("GO_ENV")
+
+	session := scs.New()
+
+	req := httptest.NewRequest("GET", "/", nil)
+	rr := httptest.NewRecorder()
+
+	RequiresLogin(session, rr, req)
+
+	if rr.Result().StatusCode == http.StatusSeeOther {
+		t.Errorf("expected no redirect in debug mode")
+	}
+}
+
+// func TestRequiresLogin_UserExists_NoRedirect(t *testing.T) {
+// 	os.Setenv("GO_ENV", "production")
+// 	defer os.Unsetenv("GO_ENV")
+
+// 	session := scs.New()
+
+// 	req := httptest.NewRequest("GET", "/", nil)
+// 	ctx, err := session.Load(req.Context(), "")
+// 	if err != nil {
+// 		t.Fatalf("session load error: %v", err)
+// 	}
+
+// 	ctx = session.Put(ctx, "user", "123")
+// 	req = req.WithContext(context.WithValue(ctx, "session", session))
+
+// 	rr := httptest.NewRecorder()
+
+// 	yourpkg.RequiresLogin(session, rr, req)
+
+// 	if rr.Result().StatusCode == http.StatusSeeOther {
+// 		t.Errorf("expected no redirect when user exists")
+// 	}
+// }
+
+// func TestRequiresLogin_NoUser_Redirects(t *testing.T) {
+// 	os.Setenv("GO_ENV", "production")
+// 	defer os.Unsetenv("GO_ENV")
+
+// 	session := scs.New()
+
+// 	req := httptest.NewRequest("GET", "/", nil)
+// 	req = req.WithContext(context.WithValue(req.Context(), "session", session))
+
+// 	rr := httptest.NewRecorder()
+
+// 	RequiresLogin(session, rr, req)
+
+// 	if rr.Result().StatusCode != http.StatusSeeOther {
+// 		t.Errorf("expected redirect when user does not exist, got %d", rr.Result().StatusCode)
+// 	}
+
+// 	location := rr.Result().Header.Get("Location")
+// 	if location != "/user/login" {
+// 		t.Errorf("expected redirect to /user/login, got %q", location)
+// 	}
+// }

Backend/main.go

@@ -46,7 +46,8 @@ func main() {
 	server.HandleFunc("/time/new", endpoints.TimeCreateHandler)
 	server.Handle("/absence", ParamsMiddleware(endpoints.AbsencHandler))
 	server.Handle("/time", ParamsMiddleware(endpoints.TimeHandler))
-	server.HandleFunc("/logout", endpoints.LogoutHandler)
+	server.HandleFunc("/auto/logout", endpoints.LogoutHandler)
+	server.HandleFunc("/auto/kurzarbeit", endpoints.KurzarbeitFillHandler)
 	server.HandleFunc("/user/{action}", endpoints.UserHandler)
 	// server.HandleFunc("/user/login", endpoints.LoginHandler)
 	// server.HandleFunc("/user/settings", endpoints.UserSettingsHandler)

Backend/models/absence.go

@@ -49,75 +49,45 @@ func (a *Absence) IsMultiDay() bool {
 	return !a.DateFrom.Equal(a.DateTo)
 }
 
-func (a *Absence) GetWorktimeReal(u User, base WorktimeBase) time.Duration {
-	if a.AbwesenheitTyp.WorkTime <= 1 {
+func (a *Absence) GetWorktime(u User, base WorktimeBase, includeKurzarbeit bool) time.Duration {
+	switch base {
+	case WorktimeBaseDay:
+		if a.AbwesenheitTyp.WorkTime <= 0 && includeKurzarbeit {
+			return u.ArbeitszeitProTagFrac(1)
+		} else if a.AbwesenheitTyp.WorkTime <= 0 {
+			return 0
+		}
+		return u.ArbeitszeitProTagFrac(float32(a.AbwesenheitTyp.WorkTime) / 100)
+	case WorktimeBaseWeek:
+		if a.AbwesenheitTyp.WorkTime <= 0 && includeKurzarbeit {
+			return u.ArbeitszeitProTagFrac(0.2)
+		} else if a.AbwesenheitTyp.WorkTime <= 0 {
+			return 0
+		}
+		return u.ArbeitszeitProWocheFrac(0.2 * float32(a.AbwesenheitTyp.WorkTime) / 100)
+	}
+	return 0
+}
+
+func (a *Absence) GetPausetime(u User, base WorktimeBase, includeKurzarbeit bool) time.Duration {
+	return 0
+}
+
+func (a *Absence) GetOvertime(u User, base WorktimeBase, includeKurzarbeit bool) time.Duration {
+	if a.AbwesenheitTyp.WorkTime > 0 {
 		return 0
 	}
 	switch base {
 	case WorktimeBaseDay:
-		return u.ArbeitszeitProTag()
+		return -u.ArbeitszeitProTagFrac(1)
 	case WorktimeBaseWeek:
-		return u.ArbeitszeitProWoche() / 5
-	}
-	return 0
-}
-func (a *Absence) GetPausetimeReal(u User, base WorktimeBase) time.Duration {
-	return 0
-}
-
-func (a *Absence) GetOvertimeReal(u User, base WorktimeBase) time.Duration {
-	if a.AbwesenheitTyp.WorkTime > 1 {
-		return 0
-	}
-	switch base {
-	case WorktimeBaseDay:
-		return -u.ArbeitszeitProTag()
-	case WorktimeBaseWeek:
-		return -u.ArbeitszeitProWoche() / 5
+		return -u.ArbeitszeitProWocheFrac(0.2)
 	}
 	return 0
 }
 
-func (a *Absence) GetWorktimeVirtual(u User, base WorktimeBase) time.Duration {
-	return a.GetWorktimeReal(u, base)
-}
-
-func (a *Absence) GetPausetimeVirtual(u User, base WorktimeBase) time.Duration {
-	return a.GetPausetimeReal(u, base)
-}
-
-func (a *Absence) GetOvertimeVirtual(u User, base WorktimeBase) time.Duration {
-	return a.GetOvertimeReal(u, base)
-}
-
-func (a *Absence) GetTimesReal(u User, base WorktimeBase) (work, pause, overtime time.Duration) {
-	return a.GetWorktimeReal(u, base), a.GetPausetimeReal(u, base), a.GetOvertimeReal(u, base)
-}
-
-func (a *Absence) GetTimesVirtual(u User, base WorktimeBase) (work, pause, overtime time.Duration) {
-	return a.GetWorktimeVirtual(u, base), a.GetPausetimeVirtual(u, base), a.GetOvertimeVirtual(u, base)
-}
-
-func (a *Absence) TimeWorkVirtual(u User) time.Duration {
-	return a.TimeWorkReal(u)
-}
-
-func (a *Absence) TimeWorkReal(u User) time.Duration {
-	if a.AbwesenheitTyp.WorkTime > 1 {
-		return time.Duration(u.ArbeitszeitPerTag * float32(time.Hour)).Round(time.Minute)
-	}
-	return 0
-}
-
-func (a *Absence) TimePauseReal(u User) (work, pause time.Duration) {
-	return 0, 0
-}
-
-func (a *Absence) TimeOvertimeReal(u User) time.Duration {
-	if a.AbwesenheitTyp.WorkTime > 1 {
-		return 0
-	}
-	return -u.ArbeitszeitProTag()
+func (a *Absence) GetTimes(u User, base WorktimeBase, includeKurzarbeit bool) (work, pause, overtime time.Duration) {
+	return a.GetWorktime(u, base, includeKurzarbeit), a.GetPausetime(u, base, includeKurzarbeit), a.GetOvertime(u, base, includeKurzarbeit)
 }
 
 func (a *Absence) ToString() string {

Backend/models/absence_test.go

@@ -0,0 +1,92 @@
+package models_test
+
+import (
+	"arbeitszeitmessung/helper"
+	"arbeitszeitmessung/models"
+	"testing"
+	"time"
+)
+
+var testAbsence = models.Absence{
+	Day:            CatchError(time.Parse(time.DateOnly, "2025-01-01")),
+	AbwesenheitTyp: models.AbsenceType{},
+	DateFrom:       CatchError(time.Parse(time.DateOnly, "2025-01-01")),
+	DateTo:         CatchError(time.Parse(time.DateOnly, "2025-01-03")),
+}
+
+var testKurzarbeit = models.AbsenceType{
+	Name:     "Kurzarbeit",
+	WorkTime: -1,
+}
+
+var testUrlaub = models.AbsenceType{
+	Name:     "Urlaub",
+	WorkTime: 100,
+}
+
+var testUrlaubUntertags = models.AbsenceType{
+	Name:     "Urlaub untertags",
+	WorkTime: 50,
+}
+
+func TestCalcRealWorkTimeDayAbsence(t *testing.T) {
+	testCases := []struct {
+		absenceType  models.AbsenceType
+		expectedTime time.Duration
+	}{
+		{
+			absenceType:  testUrlaub,
+			expectedTime: time.Hour * 8,
+		},
+		{
+			absenceType:  testUrlaubUntertags,
+			expectedTime: time.Hour * 4,
+		},
+		{
+			absenceType:  testKurzarbeit,
+			expectedTime: 0,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run("Calc Absence Worktime: "+tc.absenceType.Name, func(t *testing.T) {
+			var testCase = testAbsence
+			testCase.AbwesenheitTyp = tc.absenceType
+			workTime := testCase.GetWorktime(testUser, models.WorktimeBaseDay, false)
+			if workTime != tc.expectedTime {
+				t.Errorf("Calc Worktime Default not working, time should be %s, but was %s", helper.FormatDurationFill(tc.expectedTime, true), helper.FormatDurationFill(workTime, true))
+			}
+		})
+	}
+}
+
+func TestCalcRealWorkTimeWeekAbsence(t *testing.T) {
+	testCases := []struct {
+		absenceType  models.AbsenceType
+		expectedTime time.Duration
+	}{
+		{
+			absenceType:  testUrlaub,
+			expectedTime: time.Hour * 7,
+		},
+		{
+			absenceType:  testUrlaubUntertags,
+			expectedTime: time.Hour*3 + time.Minute*30,
+		},
+		{
+			absenceType:  testKurzarbeit,
+			expectedTime: 0,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run("Calc Absence Worktime: "+tc.absenceType.Name, func(t *testing.T) {
+			var testCase = testAbsence
+			testCase.AbwesenheitTyp = tc.absenceType
+			workTime := testCase.GetWorktime(testUser, models.WorktimeBaseWeek, false)
+			if workTime != tc.expectedTime {
+				t.Errorf("Calc Worktime Default not working, time should be %s, but was %s", helper.FormatDurationFill(tc.expectedTime, true), helper.FormatDurationFill(workTime, true))
+			}
+		})
+	}
+}

Backend/models/booking_test.go

@@ -10,36 +10,36 @@ var testBookingType = models.BookingType{
 	Name: "Büro",
 }
 
-var testBookings8hrs = []models.Booking{models.Booking{
+var testBookings8hrs = []models.Booking{{
 	CardUID:     "aaaa-aaaa",
 	CheckInOut:  1,
 	Timestamp:   CatchError(time.Parse("2006-01-02 15:04", "2025-01-01 08:00")),
 	BookingType: testBookingType,
-}, models.Booking{
+}, {
 	CardUID:     "aaaa-aaaa",
 	CheckInOut:  2,
 	Timestamp:   CatchError(time.Parse("2006-01-02 15:04", "2025-01-01 16:00")),
 	BookingType: testBookingType,
 }}
 
-var testBookings6hrs = []models.Booking{models.Booking{
+var testBookings6hrs = []models.Booking{{
 	CardUID:     "aaaa-aaaa",
 	CheckInOut:  1,
 	Timestamp:   CatchError(time.Parse("2006-01-02 15:04", "2025-01-01 08:00")),
 	BookingType: testBookingType,
-}, models.Booking{
+}, {
 	CardUID:     "aaaa-aaaa",
 	CheckInOut:  2,
 	Timestamp:   CatchError(time.Parse("2006-01-02 15:04", "2025-01-01 14:00")),
 	BookingType: testBookingType,
 }}
 
-var testBookings10hrs = []models.Booking{models.Booking{
+var testBookings10hrs = []models.Booking{{
 	CardUID:     "aaaa-aaaa",
 	CheckInOut:  1,
 	Timestamp:   CatchError(time.Parse("2006-01-02 15:04", "2025-01-01 08:00")),
 	BookingType: testBookingType,
-}, models.Booking{
+}, {
 	CardUID:     "aaaa-aaaa",
 	CheckInOut:  2,
 	Timestamp:   CatchError(time.Parse("2006-01-02 15:04", "2025-01-01 18:00")),

Backend/models/iworkday.go

@@ -0,0 +1,55 @@
+package models
+
+import (
+	"arbeitszeitmessung/helper"
+	"log"
+	"time"
+)
+
+type IWorkDay interface {
+	Date() time.Time
+	ToString() string
+	IsWorkDay() bool
+	IsKurzArbeit() bool
+	GetDayProgress(User) int8
+	RequiresAction() bool
+	GetWorktime(User, WorktimeBase, bool) time.Duration
+	GetPausetime(User, WorktimeBase, bool) time.Duration
+	GetTimes(User, WorktimeBase, bool) (work, pause, overtime time.Duration)
+	GetOvertime(User, WorktimeBase, bool) time.Duration
+}
+
+func GetDays(user User, tsFrom, tsTo time.Time, orderedForward bool) []IWorkDay {
+	var allDays map[string]IWorkDay = make(map[string]IWorkDay)
+
+	for _, day := range GetWorkDays(user, tsFrom, tsTo) {
+		allDays[day.Date().Format(time.DateOnly)] = &day
+	}
+	absences, err := GetAbsencesByCardUID(user.CardUID, tsFrom, tsTo)
+	if err != nil {
+		log.Println("Error gettings absences for all Days!", err)
+		return nil
+	}
+	for _, day := range absences {
+		if helper.IsWeekend(day.Date()) {
+			continue
+		}
+		// Absence should be integrated in workday
+		switch {
+		case day.AbwesenheitTyp.WorkTime < 0:
+			if workDay, ok := allDays[day.Date().Format(time.DateOnly)].(*WorkDay); ok {
+				workDay.kurzArbeit = true
+				workDay.kurzArbeitAbsence = day
+			}
+		case day.AbwesenheitTyp.WorkTime < 100:
+			if workDay, ok := allDays[day.Date().Format(time.DateOnly)].(*WorkDay); ok {
+				workDay.worktimeAbsece = day
+			}
+		default:
+			allDays[day.Date().Format(time.DateOnly)] = &day
+		}
+	}
+
+	sortedDays := sortDays(allDays, orderedForward)
+	return sortedDays
+}

Backend/models/user.go

@@ -7,9 +7,11 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"log/slog"
 	"time"
 
 	"github.com/alexedwards/scs/v2"
+	"github.com/lib/pq"
 )
 
 type User struct {
@@ -57,11 +59,37 @@ func (u *User) GetReportedOvertime() (time.Duration, error) {
 	return overtime, nil
 }
 
+func GetAllUsers() ([]User, error) {
+	qStr, err := DB.Prepare((`SELECT card_uid, vorname, nachname,arbeitszeit_per_tag, arbeitszeit_per_woche FROM s_personal_daten;`))
+	var users []User
+	if err != nil {
+		return users, err
+	}
+	defer qStr.Close()
+	rows, err := qStr.Query()
+	if err != nil {
+		return users, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+
+		var user User
+		if err := rows.Scan(&user.CardUID, &user.Vorname, &user.Name, &user.ArbeitszeitPerTag, &user.ArbeitszeitPerWoche); err != nil {
+			log.Println("Error creating user!", err)
+			continue
+		}
+		users = append(users, user)
+	}
+	if err = rows.Err(); err != nil {
+		return users, nil
+	}
+	return users, nil
+}
+
 func (u *User) GetAll() ([]User, error) {
 	qStr, err := DB.Prepare((`SELECT card_uid, vorname, nachname FROM s_personal_daten;`))
 	var users []User
 	if err != nil {
-		fmt.Printf("Error preparing query statement %v\n", err)
 		return users, err
 	}
 	defer qStr.Close()
@@ -85,13 +113,21 @@ func (u *User) GetAll() ([]User, error) {
 	return users, nil
 }
 
-// Returns the worktime per day rounded to minutes
 func (u *User) ArbeitszeitProTag() time.Duration {
-	return time.Duration(u.ArbeitszeitPerTag * float32(time.Hour)).Round(time.Minute)
+	return u.ArbeitszeitProTagFrac(1)
+}
+
+// Returns the worktime per day rounded to minutes
+func (u *User) ArbeitszeitProTagFrac(fraction float32) time.Duration {
+	return time.Duration(u.ArbeitszeitPerTag * float32(time.Hour) * fraction).Round(time.Minute)
 }
 
 func (u *User) ArbeitszeitProWoche() time.Duration {
-	return time.Duration(u.ArbeitszeitPerWoche * float32(time.Hour)).Round(time.Minute)
+	return u.ArbeitszeitProWocheFrac(1)
+}
+
+func (u *User) ArbeitszeitProWocheFrac(fraction float32) time.Duration {
+	return time.Duration(u.ArbeitszeitPerWoche * float32(time.Hour) * fraction).Round(time.Minute)
 }
 
 // Returns true if there is a booking 1 for today -> meaning the user is at work
@@ -99,7 +135,7 @@ func (u *User) ArbeitszeitProWoche() time.Duration {
 func (u *User) CheckAnwesenheit() bool {
 	qStr, err := DB.Prepare((`SELECT check_in_out FROM anwesenheit WHERE card_uid = $1 AND "timestamp"::date = now()::date ORDER BY "timestamp" DESC LIMIT 1;`))
 	if err != nil {
-		fmt.Printf("Error preparing query statement %v\n", err)
+		slog.Debug("Error preparing query statement.", "error", err)
 		return false
 	}
 	defer qStr.Close()
@@ -137,11 +173,43 @@ func GetUserByPersonalNr(personalNummer int) (User, error) {
 	return user, nil
 }
 
+func GetUserByPersonalNrMulti(personalNummerMulti []int) ([]User, error) {
+	var users []User
+	if len(personalNummerMulti) == 0 {
+		return users, errors.New("No personalNumbers provided")
+	}
+
+	qStr, err := DB.Prepare((`SELECT personal_nummer, card_uid, vorname, nachname, arbeitszeit_per_tag, arbeitszeit_per_woche FROM s_personal_daten WHERE personal_nummer = ANY($1::int[]);`))
+	if err != nil {
+		return users, err
+	}
+
+	rows, err := qStr.Query(pq.Array(personalNummerMulti))
+	if err == sql.ErrNoRows {
+		return users, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var user User
+		if err := rows.Scan(&user.PersonalNummer, &user.CardUID, &user.Vorname, &user.Name, &user.ArbeitszeitPerTag, &user.ArbeitszeitPerWoche); err != nil {
+			return users, err
+		}
+		users = append(users, user)
+	}
+	if err = rows.Err(); err != nil {
+		return users, err
+	}
+	return users, nil
+}
+
 func (u *User) Login(password string) bool {
 	var loginSuccess bool
 	qStr, err := DB.Prepare((`SELECT (pass_hash = crypt($2, pass_hash)) AS pass_hash FROM user_password WHERE personal_nummer = $1;`))
 	if err != nil {
-		log.Println("Error preparing db statement", err)
+		slog.Debug("Error preparing query statement.", "error", err)
 		return false
 	}
 	defer qStr.Close()
@@ -233,7 +301,7 @@ func (u *User) GetLastWorkWeekSubmission() time.Time {
     ) AS letzte_buchung;
 `)
 	if err != nil {
-		log.Println("Error preparing statement!", err)
+		slog.Debug("Error preparing query statement.", "error", err)
 		return lastSub
 	}
 	err = qStr.QueryRow(u.PersonalNummer, u.CardUID).Scan(&lastSub)

Backend/models/user_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 )
 
-var testUser models.User = models.User{Vorname: "Kim", Name: "Mustermensch", PersonalNummer: 456, CardUID: "aaaa-aaaa", ArbeitszeitPerTag: 8, ArbeitszeitPerWoche: 40}
+var testUser models.User = models.User{Vorname: "Kim", Name: "Mustermensch", PersonalNummer: 456, CardUID: "aaaa-aaaa", ArbeitszeitPerTag: 8, ArbeitszeitPerWoche: 35}
 
 func SetupUserFixture(t *testing.T, db models.IDatabase) {
 	t.Helper()

Backend/models/workDay.go

@@ -10,39 +10,17 @@ import (
 	"time"
 )
 
-type IWorkDay interface {
-	Date() time.Time
-	TimeWorkVirtual(User) time.Duration
-	TimeWorkReal(User) time.Duration
-	TimePauseReal(User) (work, pause time.Duration)
-	TimeOvertimeReal(User) time.Duration
-	GetAllWorkTimesVirtual(User) (work, pause, overtime time.Duration)
-	ToString() string
-	IsWorkDay() bool
-	IsKurzArbeit() bool
-	GetDayProgress(User) int8
-	RequiresAction() bool
-	GetWorktimeReal(User, WorktimeBase) time.Duration
-	GetPausetimeReal(User, WorktimeBase) time.Duration
-	GetOvertimeReal(User, WorktimeBase) time.Duration
-	GetWorktimeVirtual(User, WorktimeBase) time.Duration
-	GetPausetimeVirtual(User, WorktimeBase) time.Duration
-	GetOvertimeVirtual(User, WorktimeBase) time.Duration
-	GetTimesReal(User, WorktimeBase) (work, pause, overtime time.Duration)
-	GetTimesVirtual(User, WorktimeBase) (work, pause, overtime time.Duration)
-}
-
 type WorkDay struct {
 	Day               time.Time `json:"day"`
 	Bookings          []Booking `json:"bookings"`
 	workTime          time.Duration
 	pauseTime         time.Duration
-	realWorkTime      time.Duration
-	realPauseTime     time.Duration
 	TimeFrom          time.Time
 	TimeTo            time.Time
 	kurzArbeit        bool
 	kurzArbeitAbsence Absence
+	// Urlaub untertags
+	worktimeAbsece Absence
 }
 
 type WorktimeBase string
@@ -52,101 +30,45 @@ const (
 	WorktimeBaseDay  WorktimeBase = "day"
 )
 
-func GetDays(user User, tsFrom, tsTo time.Time, orderedForward bool) []IWorkDay {
-	var allDays map[string]IWorkDay = make(map[string]IWorkDay)
-
-	for _, day := range GetWorkDays(user, tsFrom, tsTo) {
-		allDays[day.Date().Format(time.DateOnly)] = &day
-	}
-	absences, err := GetAbsencesByCardUID(user.CardUID, tsFrom, tsTo)
-	if err != nil {
-		log.Println("Error gettings absences for all Days!", err)
-		return nil
-	}
-	for _, day := range absences {
-		if helper.IsWeekend(day.Date()) {
-			continue
-		}
-		if day.AbwesenheitTyp.WorkTime == 1 {
-			if workDay, ok := allDays[day.Date().Format(time.DateOnly)].(*WorkDay); ok && len(workDay.Bookings) > 0 {
-				workDay.kurzArbeit = true
-				workDay.kurzArbeitAbsence = day
-			}
-		} else {
-			allDays[day.Date().Format(time.DateOnly)] = &day
-		}
-	}
-
-	sortedDays := sortDays(allDays, orderedForward)
-	return sortedDays
+func (d *WorkDay) GetWorktimeAbsence() Absence {
+	return d.worktimeAbsece
 }
 
 // Gets the time as is in the db (with corrected pause times)
-func (d *WorkDay) GetWorktimeReal(u User, base WorktimeBase) time.Duration {
+func (d *WorkDay) GetWorktime(u User, base WorktimeBase, includeKurzarbeit bool) time.Duration {
+	if includeKurzarbeit && d.IsKurzArbeit() && len(d.Bookings) > 0 {
+		return d.kurzArbeitAbsence.GetWorktime(u, base, true)
+	}
 	work, pause := calcWorkPause(d.Bookings)
 	work, pause = correctWorkPause(work, pause)
-	return work
+	if (d.worktimeAbsece != Absence{}) {
+		work += d.worktimeAbsece.GetWorktime(u, base, false)
+	}
+	return work.Round(time.Minute)
 }
 
 // Gets the corrected pause times based on db entries
-func (d *WorkDay) GetPausetimeReal(u User, base WorktimeBase) time.Duration {
+func (d *WorkDay) GetPausetime(u User, base WorktimeBase, includeKurzarbeit bool) time.Duration {
 	work, pause := calcWorkPause(d.Bookings)
 	work, pause = correctWorkPause(work, pause)
-	return pause
+	return pause.Round(time.Minute)
 }
 
 // Returns the overtime based on the db entries
-func (d *WorkDay) GetOvertimeReal(u User, base WorktimeBase) time.Duration {
-	work, pause := calcWorkPause(d.Bookings)
-	work, pause = correctWorkPause(work, pause)
-
+func (d *WorkDay) GetOvertime(u User, base WorktimeBase, includeKurzarbeit bool) time.Duration {
+	work := d.GetWorktime(u, base, includeKurzarbeit)
 	var targetHours time.Duration
 	switch base {
 	case WorktimeBaseDay:
 		targetHours = u.ArbeitszeitProTag()
 	case WorktimeBaseWeek:
-		targetHours = u.ArbeitszeitProWoche() / 5
+		targetHours = u.ArbeitszeitProWocheFrac(0.2)
 	}
-	return work - targetHours
+	return (work - targetHours).Round(time.Minute)
 }
 
-// Returns the worktime based on absence or kurzarbeit
-func (d *WorkDay) GetWorktimeVirtual(u User, base WorktimeBase) time.Duration {
-	if !d.IsKurzArbeit() {
-		return d.GetWorktimeReal(u, base)
-	}
-	switch base {
-	case WorktimeBaseDay:
-		return u.ArbeitszeitProTag()
-	case WorktimeBaseWeek:
-		return u.ArbeitszeitProWoche() / 5
-	}
-	return 0
-}
-
-func (d *WorkDay) GetPausetimeVirtual(u User, base WorktimeBase) time.Duration {
-	return d.GetPausetimeReal(u, base)
-}
-
-func (d *WorkDay) GetOvertimeVirtual(u User, base WorktimeBase) time.Duration {
-	work := d.GetWorktimeVirtual(u, base)
-
-	var targetHours time.Duration
-	switch base {
-	case WorktimeBaseDay:
-		targetHours = u.ArbeitszeitProTag()
-	case WorktimeBaseWeek:
-		targetHours = u.ArbeitszeitProWoche() / 5
-	}
-	return work - targetHours
-}
-
-func (d *WorkDay) GetTimesReal(u User, base WorktimeBase) (work, pause, overtime time.Duration) {
-	return d.GetWorktimeReal(u, base), d.GetPausetimeReal(u, base), d.GetOvertimeReal(u, base)
-}
-
-func (d *WorkDay) GetTimesVirtual(u User, base WorktimeBase) (work, pause, overtime time.Duration) {
-	return d.GetWorktimeVirtual(u, base), d.GetPausetimeVirtual(u, base), d.GetOvertimeVirtual(u, base)
+func (d *WorkDay) GetTimes(u User, base WorktimeBase, includeKurzarbeit bool) (work, pause, overtime time.Duration) {
+	return d.GetWorktime(u, base, includeKurzarbeit), d.GetPausetime(u, base, includeKurzarbeit), d.GetOvertime(u, base, includeKurzarbeit)
 }
 
 func calcWorkPause(bookings []Booking) (work, pause time.Duration) {
@@ -206,81 +128,21 @@ func (d *WorkDay) Date() time.Time {
 
 func (d *WorkDay) GenerateKurzArbeitBookings(u User) (time.Time, time.Time) {
 	var timeFrom, timeTo time.Time
-	if d.workTime >= u.ArbeitszeitProTag() {
+	if d.GetWorktime(u, WorktimeBaseDay, false) >= u.ArbeitszeitProTag() {
 		return timeFrom, timeTo
 	}
 
 	timeFrom = d.Bookings[len(d.Bookings)-1].Timestamp.Add(time.Minute)
-	timeTo = timeFrom.Add(u.ArbeitszeitProTag() - d.workTime)
+	timeTo = timeFrom.Add(u.ArbeitszeitProTag() - d.GetWorktime(u, WorktimeBaseDay, false))
 	slog.Debug("Added duration as Kurzarbeit", "date", d.Date().String(), "duration", timeTo.Sub(timeFrom).String())
 
 	return timeFrom, timeTo
 }
 
-func (d *WorkDay) TimeWorkVirtual(u User) time.Duration {
-	if d.IsKurzArbeit() {
-		return u.ArbeitszeitProTag()
-	}
-	return d.workTime
-}
-
 func (d *WorkDay) GetKurzArbeit() *Absence {
 	return &d.kurzArbeitAbsence
 }
 
-func (d *WorkDay) TimeWorkReal(u User) time.Duration {
-	d.realWorkTime, d.realPauseTime = 0, 0
-	var lastBooking Booking
-	for _, booking := range d.Bookings {
-		if booking.CheckInOut%2 == 1 {
-			if !lastBooking.Timestamp.IsZero() {
-				d.realPauseTime += booking.Timestamp.Sub(lastBooking.Timestamp)
-			}
-		} else {
-			d.realWorkTime += booking.Timestamp.Sub(lastBooking.Timestamp)
-		}
-		lastBooking = booking
-	}
-	if helper.IsSameDate(d.Date(), time.Now()) && len(d.Bookings)%2 == 1 {
-		d.realWorkTime += time.Since(lastBooking.Timestamp.Local())
-	}
-	// slog.Debug("Calculated RealWorkTime for user", "user", u, slog.String("worktime", d.realWorkTime.String()))
-	return d.realWorkTime
-}
-
-func (d *WorkDay) TimeOvertimeReal(u User) time.Duration {
-	workTime := d.TimeWorkVirtual(u)
-	if workTime == 0 {
-		workTime, _ = d.TimePauseReal(u)
-	}
-	if helper.IsWeekend(d.Day) && len(d.Bookings) == 0 {
-		return 0
-	}
-	var overtime time.Duration
-	overtime = workTime - u.ArbeitszeitProTag()
-	return overtime
-}
-
-func (d *WorkDay) TimePauseReal(u User) (work, pause time.Duration) {
-	if d.realWorkTime == 0 {
-		d.TimeWorkReal(u)
-	}
-	d.workTime, d.pauseTime = d.realWorkTime, d.realPauseTime
-	if d.realWorkTime <= 6*time.Hour || d.realPauseTime > 45*time.Minute {
-		return d.realWorkTime, d.realPauseTime
-	}
-	if d.realWorkTime <= (9*time.Hour) && d.realPauseTime < 30*time.Minute {
-		diff := 30*time.Minute - d.pauseTime
-		d.workTime -= diff
-		d.pauseTime += diff
-	} else if d.realPauseTime < 45*time.Minute {
-		diff := 45*time.Minute - d.pauseTime
-		d.workTime -= diff
-		d.pauseTime += diff
-	}
-	return d.workTime, d.pauseTime
-}
-
 func (d *WorkDay) ToString() string {
 	return fmt.Sprintf("WorkDay: %s with %d bookings and worktime: %s", d.Date().Format(time.DateOnly), len(d.Bookings), helper.FormatDuration(d.workTime))
 }
@@ -369,7 +231,6 @@ func GetWorkDays(user User, tsFrom, tsTo time.Time) []WorkDay {
 		return workDays
 	}
 	defer rows.Close()
-	// emptyDays, _ := strconv.ParseBool(helper.GetEnv("EMPTY_DAYS", "false"))
 	for rows.Next() {
 		var workDay WorkDay
 		var bookings []byte
@@ -388,7 +249,6 @@ func GetWorkDays(user User, tsFrom, tsTo time.Time) []WorkDay {
 		if len(workDay.Bookings) == 1 && workDay.Bookings[0].CounterId == 0 {
 			workDay.Bookings = []Booking{}
 		}
-		workDay.TimePauseReal(user)
 		if len(workDay.Bookings) > 1 || !helper.IsWeekend(workDay.Date()) {
 			workDays = append(workDays, workDay)
 		}
@@ -400,18 +260,6 @@ func GetWorkDays(user User, tsFrom, tsTo time.Time) []WorkDay {
 	return workDays
 }
 
-func (d *WorkDay) GetAllWorkTimesReal(user User) (work, pause, overtime time.Duration) {
-	if d.pauseTime == 0 || d.workTime == 0 {
-		d.TimePauseReal(user)
-	}
-	return d.workTime.Round(time.Minute), d.pauseTime.Round(time.Minute), d.TimeOvertimeReal(user)
-}
-
-func (d *WorkDay) GetAllWorkTimesVirtual(user User) (work, pause, overtime time.Duration) {
-	_, pause, overtime = d.GetAllWorkTimesReal(user)
-	return d.TimeWorkVirtual(user), pause, overtime
-}
-
 // returns bool wheter the workday was ended with an automatic logout
 func (d *WorkDay) RequiresAction() bool {
 	if len(d.Bookings) == 0 {
@@ -424,19 +272,7 @@ func (d *WorkDay) GetDayProgress(u User) int8 {
 	if d.RequiresAction() {
 		return -1
 	}
-	workTime := d.TimeWorkVirtual(u)
+	workTime := d.GetWorktime(u, WorktimeBaseDay, true)
 	progress := (workTime.Seconds() / u.ArbeitszeitProTag().Seconds()) * 100
 	return int8(progress)
 }
-
-// func (d *WorkDay) CalcOvertime(user User) time.Duration {
-// 	if d.workTime == 0 {
-// 		d.TimePauseReal(user)
-// 	}
-// 	if helper.IsWeekend(d.Day) && len(d.Bookings) == 0 {
-// 		return 0
-// 	}
-// 	var overtime time.Duration
-// 	overtime = d.workTime - user.ArbeitszeitProTag()
-// 	return overtime
-// }

Backend/models/workDay_test.go

@@ -22,59 +22,141 @@ var testWorkDay = models.WorkDay{
 	TimeTo:   CatchError(time.Parse("2006-01-02 15:04", "2025-01-01 16:30")),
 }
 
-func TestCalcRealWorkTime(t *testing.T) {
-	workTime := testWorkDay.TimeWorkReal(testUser)
-	if workTime != time.Hour*8 {
-		t.Errorf("Calc Worktime Default not working, time should be 8h, but was %s", helper.FormatDuration(workTime))
-	}
-}
-
-func TestCalcWorkPauseDiff(t *testing.T) {
-	type testCase struct {
-		Name              string
+func TestWorkdayWorktimeDay(t *testing.T) {
+	testCases := []struct {
+		testName     string
 		bookings     []models.Booking
-		expectedWorkTime  time.Duration
-		expectedPauseTime time.Duration
-		expectedOvertime  time.Duration
-	}
-
-	testCases := []testCase{testCase{
-		Name:              "6hrs no pause",
+		expectedTime time.Duration
+	}{
+		{
+			testName:     "Bookings6hrs",
 			bookings:     testBookings6hrs,
-		expectedWorkTime:  6 * time.Hour,
-		expectedPauseTime: 0,
-		expectedOvertime:  -2 * time.Hour,
+			expectedTime: time.Hour * 6,
 		},
-		testCase{
-			Name:              "8hrs - 30min pause",
+		{
+			testName:     "Bookings8hrs",
 			bookings:     testBookings8hrs,
-			expectedWorkTime:  7*time.Hour + 30*time.Minute,
-			expectedPauseTime: 30 * time.Minute,
-			expectedOvertime:  -30 * time.Minute,
+			expectedTime: time.Hour*7 + time.Minute*30,
 		},
-		testCase{
-			Name:              "10hrs - 45min pause",
+		{
+			testName:     "Bookings10hrs",
 			bookings:     testBookings10hrs,
-			expectedWorkTime:  9*time.Hour + 15*time.Minute,
-			expectedPauseTime: 45 * time.Minute,
-			expectedOvertime:  1*time.Hour + 15*time.Minute,
-		}}
+			expectedTime: time.Hour*9 + time.Minute*15,
+		},
+	}
 
-	for _, test := range testCases {
-		t.Run(test.Name, func(t *testing.T) {
-			testWorkDay.Bookings = test.bookings
-			testWorkDay.TimeWorkReal(testUser)
-			testWorkDay.TimePauseReal(testUser)
-			testWorkDay.TimeOvertimeReal(testUser)
-			workTime, pauseTime, overTime := testWorkDay.GetAllWorkTimesReal(testUser)
-			if workTime != test.expectedWorkTime {
-				t.Errorf("Calculated wrong workTime: should be %s, but was %s", helper.FormatDuration(test.expectedWorkTime), helper.FormatDuration(workTime))
-			}
-			if pauseTime != test.expectedPauseTime {
-				t.Errorf("Calculated wrong pauseTime: should be %s, but was %s", helper.FormatDuration(test.expectedPauseTime), helper.FormatDuration(pauseTime))
-			}
-			if overTime != test.expectedOvertime {
-				t.Errorf("Calculated wrong overtime: should be %s, but was %s", helper.FormatDuration(test.expectedOvertime), helper.FormatDuration(overTime))
+	for _, tc := range testCases {
+		t.Run("Calc Absence Worktime: "+tc.testName, func(t *testing.T) {
+			var testCase = testWorkDay
+			testCase.Bookings = tc.bookings
+			workTime := testCase.GetWorktime(testUser, models.WorktimeBaseDay, false)
+			if workTime != tc.expectedTime {
+				t.Errorf("GetWorktimeReal not working, time should be %s, but was %s", helper.FormatDurationFill(tc.expectedTime, true), helper.FormatDurationFill(workTime, true))
+			}
+		})
+	}
+}
+
+func TestWorkdayWorktimeWeek(t *testing.T) {
+	testCases := []struct {
+		testName     string
+		bookings     []models.Booking
+		expectedTime time.Duration
+	}{
+		{
+			testName:     "Bookings6hrs",
+			bookings:     testBookings6hrs,
+			expectedTime: time.Hour * 6,
+		},
+		{
+			testName:     "Bookings8hrs",
+			bookings:     testBookings8hrs,
+			expectedTime: time.Hour*7 + time.Minute*30,
+		},
+		{
+			testName:     "Bookings10hrs",
+			bookings:     testBookings10hrs,
+			expectedTime: time.Hour*9 + time.Minute*15,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run("Calc Absence Worktime: "+tc.testName, func(t *testing.T) {
+			var testCase = testWorkDay
+			testCase.Bookings = tc.bookings
+			workTime := testCase.GetWorktime(testUser, models.WorktimeBaseWeek, false)
+			if workTime != tc.expectedTime {
+				t.Errorf("GetWorktimeReal not working, time should be %s, but was %s", helper.FormatDurationFill(tc.expectedTime, true), helper.FormatDurationFill(workTime, true))
+			}
+		})
+	}
+}
+
+func TestWorkdayPausetimeDay(t *testing.T) {
+	testCases := []struct {
+		testName     string
+		bookings     []models.Booking
+		expectedTime time.Duration
+	}{
+		{
+			testName:     "Bookings6hrs",
+			bookings:     testBookings6hrs,
+			expectedTime: 0,
+		},
+		{
+			testName:     "Bookings8hrs",
+			bookings:     testBookings8hrs,
+			expectedTime: time.Minute * 30,
+		},
+		{
+			testName:     "Bookings10hrs",
+			bookings:     testBookings10hrs,
+			expectedTime: time.Minute * 45,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run("Calc Absence Worktime: "+tc.testName, func(t *testing.T) {
+			var testCase = testWorkDay
+			testCase.Bookings = tc.bookings
+			workTime := testCase.GetPausetime(testUser, models.WorktimeBaseDay, false)
+			if workTime != tc.expectedTime {
+				t.Errorf("GetPausetimeReal not working, time should be %s, but was %s", helper.FormatDurationFill(tc.expectedTime, true), helper.FormatDurationFill(workTime, true))
+			}
+		})
+	}
+}
+
+func TestWorkdayPausetimeWeek(t *testing.T) {
+	testCases := []struct {
+		testName     string
+		bookings     []models.Booking
+		expectedTime time.Duration
+	}{
+		{
+			testName:     "Bookings6hrs",
+			bookings:     testBookings6hrs,
+			expectedTime: 0,
+		},
+		{
+			testName:     "Bookings8hrs",
+			bookings:     testBookings8hrs,
+			expectedTime: time.Minute * 30,
+		},
+		{
+			testName:     "Bookings10hrs",
+			bookings:     testBookings10hrs,
+			expectedTime: time.Minute * 45,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run("Calc Absence Worktime: "+tc.testName, func(t *testing.T) {
+			var testCase = testWorkDay
+			testCase.Bookings = tc.bookings
+			workTime := testCase.GetPausetime(testUser, models.WorktimeBaseWeek, false)
+			if workTime != tc.expectedTime {
+				t.Errorf("GetPausetimeReal not working, time should be %s, but was %s", helper.FormatDurationFill(tc.expectedTime, true), helper.FormatDurationFill(workTime, true))
 			}
 		})
 	}

Backend/models/workWeek.go

@@ -20,7 +20,7 @@ type WorkWeek struct {
 	User            User
 	WeekStart       time.Time
 	Worktime        time.Duration
-	WorkTimeVirtual time.Duration
+	WorktimeVirtual time.Duration
 	Overtime        time.Duration
 	Status          WeekStatus
 }
@@ -47,17 +47,19 @@ func NewWorkWeek(user User, tsMonday time.Time, populate bool) WorkWeek {
 }
 
 func (w *WorkWeek) PopulateWithDays(worktime time.Duration, overtime time.Duration) {
+	slog.Debug("Populating Workweek for user", "user", w.User)
 	slog.Debug("Got Days with overtime and worktime", slog.String("worktime", worktime.String()), slog.String("overtime", overtime.String()))
 	w.Days = GetDays(w.User, w.WeekStart, w.WeekStart.Add(6*24*time.Hour), false)
 
 	for _, day := range w.Days {
-		work, _ := day.TimePauseReal(w.User)
-		w.Worktime += work
-		w.WorkTimeVirtual += day.TimeWorkVirtual(w.User)
+		w.Worktime += day.GetWorktime(w.User, WorktimeBaseDay, false)
+		w.WorktimeVirtual += day.GetWorktime(w.User, WorktimeBaseDay, true)
 	}
-	slog.Debug("Got worktime for user", "user", w.User, "worktime", w.Worktime.String(), "virtualWorkTime", w.WorkTimeVirtual.String())
+	slog.Debug("Got worktime for user", "worktime", w.Worktime.String(), "virtualWorkTime", w.WorktimeVirtual.String())
 
-	w.Overtime = w.WorkTimeVirtual - w.User.ArbeitszeitProWoche()
+	w.Overtime = w.WorktimeVirtual - w.User.ArbeitszeitProWoche()
+
+	slog.Debug("Calculated overtime", "worktime", w.Worktime.String(), "virtualWorkTime", w.WorktimeVirtual.String())
 
 	w.Worktime = w.Worktime.Round(time.Minute)
 	w.Overtime = w.Overtime.Round(time.Minute)

Backend/templates/headerComponent_templ.go

@@ -1,6 +1,6 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.3.924
+// templ: version: v0.3.943
 package templates
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.

Backend/templates/pages_templ.go

@@ -1,6 +1,6 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.3.924
+// templ: version: v0.3.943
 package templates
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.

Backend/templates/pdf.templ

@@ -10,7 +10,7 @@ import (
 templ PDFForm(teamMembers []models.User) {
 	@Base()
 	@headerComponent()
-	<div class="grid-main divide-y-1">
+	<form class="grid-main divide-y-1" action="pdf/generate" method="get">
 		<div class="grid-cell col-span-full bg-neutral-300">
 			<h1 class="text-xl uppercase font-bold">PDF Abrechnung erstellen</h1>
 		</div>
@@ -18,7 +18,7 @@ templ PDFForm(teamMembers []models.User) {
 			<div class="grid-cell">Zeitraum wählen</div>
 			<div class="grid-cell col-span-3">
 				<label class="block mb-1 text-sm text-neutral-700">Abrechnungsmonat</label>
-				<input name="start_date" type="date" value="" class="btn bg-neutral-100"/>
+				<input name="start_date" type="date" value={ helper.GetFirstOfMonth(time.Now()).Format(time.DateOnly) } class="btn bg-neutral-100"/>
 			</div>
 			<div></div>
 		</div>
@@ -30,7 +30,7 @@ templ PDFForm(teamMembers []models.User) {
 					<button class="btn" type="button" onclick={ templ.JSFuncCall("checkAll", "pdf-", templ.JSExpression("false")) }>Keine</button>
 				</div>
 				for _, member := range teamMembers {
-					@CheckboxComponent(fmt.Sprintf("pdf-%d", member.PersonalNummer), fmt.Sprintf("%s %s", member.Vorname, member.Name))
+					@CheckboxComponent(member.PersonalNummer, fmt.Sprintf("%s %s", member.Vorname, member.Name))
 				}
 			</div>
 			<div></div>
@@ -38,17 +38,20 @@ templ PDFForm(teamMembers []models.User) {
 		<div class="grid-sub divide-x-1 responsive">
 			<div class="grid-cell">PDFs Bündeln</div>
 			<div class="grid-cell col-span-3 flex gap-2 flex-col md:flex-row">
-				<button class="btn" type="button" name="action" value="download">Einzeln</button>
-				<button class="btn" type="button" name="action" value="preview" onclick="">Bündel</button>
-			</div>
+				<button class="btn" type="submit" name="output" value="download">Einzeln</button>
+				<button class="btn" type="submit" name="output" value="render" onclick="">Bündel</button>
 			</div>
 		</div>
+	</form>
 }
 
-templ CheckboxComponent(id, label string) {
+templ CheckboxComponent(pNr int, label string) {
+	{{
+		id := fmt.Sprintf("pdf-%d", pNr)
+	}}
 	<div class="inline-flex items-center">
 		<label class="flex items-center cursor-pointer relative" for={ id }>
-			<input type="checkbox" class="peer h-5 w-5 cursor-pointer transition-all appearance-none rounded border border-slate-800 checked:bg-slate-800 checked:border-slate-800" id={ id }/>
+			<input type="checkbox" name="employe_list" value={ pNr } id={ id } class="peer h-5 w-5 cursor-pointer transition-all appearance-none rounded border border-slate-800 checked:bg-slate-800 checked:border-slate-800"/>
 			<span class="absolute text-white opacity-0 peer-checked:opacity-100 top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2">
 				<svg xmlns="http://www.w3.org/2000/svg" class="h-3.5 w-3.5" viewBox="0 0 20 20" fill="currentColor" stroke="currentColor" stroke-width="1">
 					<path fill-rule="evenodd" d="M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z" clip-rule="evenodd"></path>
@@ -58,71 +61,70 @@ templ CheckboxComponent(id, label string) {
 	</div>
 }
 
-templ PDFReportEmploye(e models.User, overtime, worktime time.Duration, workDays []models.IWorkDay, tsStart time.Time, tsEnd time.Time) {
-	{{
-		_, kw := tsStart.ISOWeek()
-		noBorder := ""
-	}}
-	@Base()
-	<content class="p-8 relative flex flex-col gap-4 break-after-page">
-		<div>
-			<h1 class="text-2xl font-bold">{ e.Vorname } { e.Name }</h1>
-			<p>Zeitraum: <span>{ tsStart.Format("02.01.2006") }</span> - <span>{ tsEnd.Format("02.01.2006") }</span></p>
-			<p>Arbeitszeit: <span>{ helper.FormatDuration(worktime) }</span></p>
-			<p>Überstunden: <span>{ helper.FormatDuration(overtime) }</span></p>
-		</div>
-		<div class="grid grid-rows-6 grid-cols-[3fr_2fr_2fr_2fr_3fr_3fr_3fr] *:not-print:p-2 *:text-center auto-rows-min divide-neutral-300 divide-x-1 divide-y-1">
-			<p class="bg-neutral-300 border-neutral-600">{ kw }</p>
-			<p class="bg-neutral-300 border-neutral-600">Kommen</p>
-			<p class="bg-neutral-300 border-neutral-600">Gehen</p>
-			<p class="bg-neutral-300 border-neutral-600">Arbeitsart</p>
-			<p class="bg-neutral-300 border-neutral-600">Stunden</p>
-			<p class="bg-neutral-300 border-neutral-600">Pause</p>
-			<p class="bg-neutral-300 border-neutral-600 border-r-0">Überstunden</p>
-			for index, day := range workDays {
-				{{
-					if index == len(workDays)-1 {
-						noBorder = "border-b-0"
-					}
-				}}
-				<p class={ noBorder }>{ day.Date().Format("02.01.2006") }</p>
-				<div class={ "grid grid-cols-subgrid col-span-3 " + noBorder }>
-					if day.IsWorkDay() {
-						{{
-						workDay, _ := day.(*models.WorkDay)
-						}}
-						for bookingI := 0; bookingI < len(workDay.Bookings); bookingI+= 2 {
-							<p>{ workDay.Bookings[bookingI].Timestamp.Format("15:04") }</p>
-							<p>{ workDay.Bookings[bookingI+1].Timestamp.Format("15:04") }</p>
-							<p>{ workDay.Bookings[bookingI].BookingType.Name } </p>
-						}
-						if workDay.IsKurzArbeit() {
-							{{
-								timeFrom, timeTo := workDay.GenerateKurzArbeitBookings(e)
-							}}
-							<p>{ timeFrom.Format("15:04") }</p>
-							<p>{ timeTo.Format("15:04") }</p>
-							<p>Kurzarbeit</p>
-						}
-					} else {
-						{{
-						absentDay, _ := day.(*models.Absence)
-						}}
-						<p class="col-span-full">{ absentDay.AbwesenheitTyp.Name }</p>
-					}
-				</div>
-				{{ work, pause, overtime := day.GetAllWorkTimesVirtual(e) }}
-				@ColorDuration(work, noBorder)
-				@ColorDuration(pause, noBorder)
-				@ColorDuration(overtime, noBorder+" border-r-0")
-				if day.Date().Weekday() == time.Friday {
-					<p class="col-span-full bg-neutral-300">Wochenende</p>
-				}
-			}
-		</div>
-	</content>
-}
-
+// templ PDFReportEmploye(e models.User, overtime, worktime time.Duration, workDays []models.IWorkDay, tsStart time.Time, tsEnd time.Time) {
+// 	{{
+// 		_, kw := tsStart.ISOWeek()
+// 		noBorder := ""
+// 	}}
+// 	@Base()
+// 	<content class="p-8 relative flex flex-col gap-4 break-after-page">
+// 		<div>
+// 			<h1 class="text-2xl font-bold">{ e.Vorname } { e.Name }</h1>
+// 			<p>Zeitraum: <span>{ tsStart.Format("02.01.2006") }</span> - <span>{ tsEnd.Format("02.01.2006") }</span></p>
+// 			<p>Arbeitszeit: <span>{ helper.FormatDuration(worktime) }</span></p>
+// 			<p>Überstunden: <span>{ helper.FormatDuration(overtime) }</span></p>
+// 		</div>
+// 		<div class="grid grid-rows-6 grid-cols-[3fr_2fr_2fr_2fr_3fr_3fr_3fr] *:not-print:p-2 *:text-center auto-rows-min divide-neutral-300 divide-x-1 divide-y-1">
+// 			<p class="bg-neutral-300 border-neutral-600">{ kw }</p>
+// 			<p class="bg-neutral-300 border-neutral-600">Kommen</p>
+// 			<p class="bg-neutral-300 border-neutral-600">Gehen</p>
+// 			<p class="bg-neutral-300 border-neutral-600">Arbeitsart</p>
+// 			<p class="bg-neutral-300 border-neutral-600">Stunden</p>
+// 			<p class="bg-neutral-300 border-neutral-600">Pause</p>
+// 			<p class="bg-neutral-300 border-neutral-600 border-r-0">Überstunden</p>
+// 			for index, day := range workDays {
+// 				{{
+// 					if index == len(workDays)-1 {
+// 						noBorder = "border-b-0"
+// 					}
+// 				}}
+// 				<p class={ noBorder }>{ day.Date().Format("02.01.2006") }</p>
+// 				<div class={ "grid grid-cols-subgrid col-span-3 " + noBorder }>
+// 					if day.IsWorkDay() {
+// 						{{
+// 						workDay, _ := day.(*models.WorkDay)
+// 						}}
+// 						for bookingI := 0; bookingI < len(workDay.Bookings); bookingI+= 2 {
+// 							<p>{ workDay.Bookings[bookingI].Timestamp.Format("15:04") }</p>
+// 							<p>{ workDay.Bookings[bookingI+1].Timestamp.Format("15:04") }</p>
+// 							<p>{ workDay.Bookings[bookingI].BookingType.Name } </p>
+// 						}
+// 						if workDay.IsKurzArbeit() {
+// 							{{
+// 								timeFrom, timeTo := workDay.GenerateKurzArbeitBookings(e)
+// 							}}
+// 							<p>{ timeFrom.Format("15:04") }</p>
+// 							<p>{ timeTo.Format("15:04") }</p>
+// 							<p>Kurzarbeit</p>
+// 						}
+// 					} else {
+// 						{{
+// 						absentDay, _ := day.(*models.Absence)
+// 						}}
+// 						<p class="col-span-full">{ absentDay.AbwesenheitTyp.Name }</p>
+// 					}
+// 				</div>
+// 				{{ work, pause, overtime := day.GetTimesVirtual(e) }}
+// 				@ColorDuration(work, noBorder)
+// 				@ColorDuration(pause, noBorder)
+// 				@ColorDuration(overtime, noBorder+" border-r-0")
+// 				if day.Date().Weekday() == time.Friday {
+// 					<p class="col-span-full bg-neutral-300">Wochenende</p>
+// 				}
+// 			}
+// 		</div>
+// 	</content>
+// }
 templ ColorDuration(d time.Duration, classes string) {
 	{{
 	color := ""

Backend/templates/pdf_templ.go

@@ -1,6 +1,6 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.3.924
+// templ: version: v0.3.943
 package templates
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
@@ -44,7 +44,20 @@ func PDFForm(teamMembers []models.User) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 1, "<div class=\"grid-main divide-y-1\"><div class=\"grid-cell col-span-full bg-neutral-300\"><h1 class=\"text-xl uppercase font-bold\">PDF Abrechnung erstellen</h1></div><div class=\"grid-sub divide-x-1 responsive\"><div class=\"grid-cell\">Zeitraum wählen</div><div class=\"grid-cell col-span-3\"><label class=\"block mb-1 text-sm text-neutral-700\">Abrechnungsmonat</label> <input name=\"start_date\" type=\"date\" value=\"\" class=\"btn bg-neutral-100\"></div><div></div></div><div class=\"grid-sub divide-x-1 responsive\"><div class=\"grid-cell\">Mitarbeiter wählen</div><div class=\"grid-cell col-span-3 flex flex-col gap-2\"><div class=\"flex flex-row gap-2\">")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 1, "<form class=\"grid-main divide-y-1\" action=\"pdf/generate\" method=\"get\"><div class=\"grid-cell col-span-full bg-neutral-300\"><h1 class=\"text-xl uppercase font-bold\">PDF Abrechnung erstellen</h1></div><div class=\"grid-sub divide-x-1 responsive\"><div class=\"grid-cell\">Zeitraum wählen</div><div class=\"grid-cell col-span-3\"><label class=\"block mb-1 text-sm text-neutral-700\">Abrechnungsmonat</label> <input name=\"start_date\" type=\"date\" value=\"")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		var templ_7745c5c3_Var2 string
+		templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(helper.GetFirstOfMonth(time.Now()).Format(time.DateOnly))
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 21, Col: 105}
+		}
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2))
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 2, "\" class=\"btn bg-neutral-100\"></div><div></div></div><div class=\"grid-sub divide-x-1 responsive\"><div class=\"grid-cell\">Mitarbeiter wählen</div><div class=\"grid-cell col-span-3 flex flex-col gap-2\"><div class=\"flex flex-row gap-2\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -52,16 +65,16 @@ func PDFForm(teamMembers []models.User) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 2, "<button class=\"btn\" type=\"button\" onclick=\"")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 3, "<button class=\"btn\" type=\"button\" onclick=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var2 templ.ComponentScript = templ.JSFuncCall("checkAll", "pdf-", templ.JSExpression("true"))
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var2.Call)
+		var templ_7745c5c3_Var3 templ.ComponentScript = templ.JSFuncCall("checkAll", "pdf-", templ.JSExpression("true"))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var3.Call)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 3, "\">Alle</button> ")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 4, "\">Alle</button> ")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -69,26 +82,26 @@ func PDFForm(teamMembers []models.User) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 4, "<button class=\"btn\" type=\"button\" onclick=\"")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 5, "<button class=\"btn\" type=\"button\" onclick=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var3 templ.ComponentScript = templ.JSFuncCall("checkAll", "pdf-", templ.JSExpression("false"))
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var3.Call)
+		var templ_7745c5c3_Var4 templ.ComponentScript = templ.JSFuncCall("checkAll", "pdf-", templ.JSExpression("false"))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ_7745c5c3_Var4.Call)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 5, "\">Keine</button></div>")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 6, "\">Keine</button></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		for _, member := range teamMembers {
-			templ_7745c5c3_Err = CheckboxComponent(fmt.Sprintf("pdf-%d", member.PersonalNummer), fmt.Sprintf("%s %s", member.Vorname, member.Name)).Render(ctx, templ_7745c5c3_Buffer)
+			templ_7745c5c3_Err = CheckboxComponent(member.PersonalNummer, fmt.Sprintf("%s %s", member.Vorname, member.Name)).Render(ctx, templ_7745c5c3_Buffer)
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 6, "</div><div></div></div><div class=\"grid-sub divide-x-1 responsive\"><div class=\"grid-cell\">PDFs Bündeln</div><div class=\"grid-cell col-span-3 flex gap-2 flex-col md:flex-row\"><button class=\"btn\" type=\"button\" name=\"action\" value=\"download\">Einzeln</button> <button class=\"btn\" type=\"button\" name=\"action\" value=\"preview\" onclick=\"\">Bündel</button></div></div></div>")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 7, "</div><div></div></div><div class=\"grid-sub divide-x-1 responsive\"><div class=\"grid-cell\">PDFs Bündeln</div><div class=\"grid-cell col-span-3 flex gap-2 flex-col md:flex-row\"><button class=\"btn\" type=\"submit\" name=\"output\" value=\"download\">Einzeln</button> <button class=\"btn\" type=\"submit\" name=\"output\" value=\"render\" onclick=\"\">Bündel</button></div></div></form>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -96,7 +109,7 @@ func PDFForm(teamMembers []models.User) templ.Component {
 	})
 }
 
-func CheckboxComponent(id, label string) templ.Component {
+func CheckboxComponent(pNr int, label string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
 		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
@@ -112,400 +125,79 @@ func CheckboxComponent(id, label string) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var4 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var4 == nil {
-			templ_7745c5c3_Var4 = templ.NopComponent
+		templ_7745c5c3_Var5 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var5 == nil {
+			templ_7745c5c3_Var5 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 7, "<div class=\"inline-flex items-center\"><label class=\"flex items-center cursor-pointer relative\" for=\"")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var5 string
-		templ_7745c5c3_Var5, templ_7745c5c3_Err = templ.JoinStringErrs(id)
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 50, Col: 67}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var5))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 8, "\"><input type=\"checkbox\" class=\"peer h-5 w-5 cursor-pointer transition-all appearance-none rounded border border-slate-800 checked:bg-slate-800 checked:border-slate-800\" id=\"")
+
+		id := fmt.Sprintf("pdf-%d", pNr)
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 8, "<div class=\"inline-flex items-center\"><label class=\"flex items-center cursor-pointer relative\" for=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var6 string
 		templ_7745c5c3_Var6, templ_7745c5c3_Err = templ.JoinStringErrs(id)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 51, Col: 178}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 53, Col: 67}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var6))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 9, "\"> <span class=\"absolute text-white opacity-0 peer-checked:opacity-100 top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2\"><svg xmlns=\"http://www.w3.org/2000/svg\" class=\"h-3.5 w-3.5\" viewBox=\"0 0 20 20\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"1\"><path fill-rule=\"evenodd\" d=\"M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z\" clip-rule=\"evenodd\"></path></svg></span></label> <label class=\"cursor-pointer ml-2 text-slate-600 select-none\" for=\"")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 9, "\"><input type=\"checkbox\" name=\"employe_list\" value=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var7 string
-		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(id)
+		templ_7745c5c3_Var7, templ_7745c5c3_Err = templ.JoinStringErrs(pNr)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 57, Col: 81}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 54, Col: 57}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var7))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 10, "\">")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 10, "\" id=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var8 string
-		templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(label)
+		templ_7745c5c3_Var8, templ_7745c5c3_Err = templ.JoinStringErrs(id)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 57, Col: 91}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 54, Col: 67}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var8))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 11, "</label></div>")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 11, "\" class=\"peer h-5 w-5 cursor-pointer transition-all appearance-none rounded border border-slate-800 checked:bg-slate-800 checked:border-slate-800\"> <span class=\"absolute text-white opacity-0 peer-checked:opacity-100 top-1/2 left-1/2 transform -translate-x-1/2 -translate-y-1/2\"><svg xmlns=\"http://www.w3.org/2000/svg\" class=\"h-3.5 w-3.5\" viewBox=\"0 0 20 20\" fill=\"currentColor\" stroke=\"currentColor\" stroke-width=\"1\"><path fill-rule=\"evenodd\" d=\"M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z\" clip-rule=\"evenodd\"></path></svg></span></label> <label class=\"cursor-pointer ml-2 text-slate-600 select-none\" for=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		return nil
-	})
+		var templ_7745c5c3_Var9 string
+		templ_7745c5c3_Var9, templ_7745c5c3_Err = templ.JoinStringErrs(id)
+		if templ_7745c5c3_Err != nil {
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 60, Col: 81}
 		}
-
-func PDFReportEmploye(e models.User, overtime, worktime time.Duration, workDays []models.IWorkDay, tsStart time.Time, tsEnd time.Time) templ.Component {
-	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
-		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
-		if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil {
-			return templ_7745c5c3_CtxErr
-		}
-		templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W)
-		if !templ_7745c5c3_IsBuffer {
-			defer func() {
-				templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer)
-				if templ_7745c5c3_Err == nil {
-					templ_7745c5c3_Err = templ_7745c5c3_BufErr
-				}
-			}()
-		}
-		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var9 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var9 == nil {
-			templ_7745c5c3_Var9 = templ.NopComponent
-		}
-		ctx = templ.ClearChildren(ctx)
-
-		_, kw := tsStart.ISOWeek()
-		noBorder := ""
-		templ_7745c5c3_Err = Base().Render(ctx, templ_7745c5c3_Buffer)
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var9))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 12, "<content class=\"p-8 relative flex flex-col gap-4 break-after-page\"><div><h1 class=\"text-2xl font-bold\">")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 12, "\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
 		var templ_7745c5c3_Var10 string
-		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(e.Vorname)
+		templ_7745c5c3_Var10, templ_7745c5c3_Err = templ.JoinStringErrs(label)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 69, Col: 45}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 60, Col: 91}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var10))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 13, " ")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var11 string
-		templ_7745c5c3_Var11, templ_7745c5c3_Err = templ.JoinStringErrs(e.Name)
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 69, Col: 56}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var11))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 14, "</h1><p>Zeitraum: <span>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var12 string
-		templ_7745c5c3_Var12, templ_7745c5c3_Err = templ.JoinStringErrs(tsStart.Format("02.01.2006"))
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 70, Col: 52}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var12))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 15, "</span> - <span>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var13 string
-		templ_7745c5c3_Var13, templ_7745c5c3_Err = templ.JoinStringErrs(tsEnd.Format("02.01.2006"))
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 70, Col: 98}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var13))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 16, "</span></p><p>Arbeitszeit: <span>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var14 string
-		templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(helper.FormatDuration(worktime))
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 71, Col: 58}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 17, "</span></p><p>Überstunden: <span>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var15 string
-		templ_7745c5c3_Var15, templ_7745c5c3_Err = templ.JoinStringErrs(helper.FormatDuration(overtime))
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 72, Col: 59}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var15))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 18, "</span></p></div><div class=\"grid grid-rows-6 grid-cols-[3fr_2fr_2fr_2fr_3fr_3fr_3fr] *:not-print:p-2 *:text-center auto-rows-min divide-neutral-300 divide-x-1 divide-y-1\"><p class=\"bg-neutral-300 border-neutral-600\">")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		var templ_7745c5c3_Var16 string
-		templ_7745c5c3_Var16, templ_7745c5c3_Err = templ.JoinStringErrs(kw)
-		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 75, Col: 52}
-		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var16))
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 19, "</p><p class=\"bg-neutral-300 border-neutral-600\">Kommen</p><p class=\"bg-neutral-300 border-neutral-600\">Gehen</p><p class=\"bg-neutral-300 border-neutral-600\">Arbeitsart</p><p class=\"bg-neutral-300 border-neutral-600\">Stunden</p><p class=\"bg-neutral-300 border-neutral-600\">Pause</p><p class=\"bg-neutral-300 border-neutral-600 border-r-0\">Überstunden</p>")
-		if templ_7745c5c3_Err != nil {
-			return templ_7745c5c3_Err
-		}
-		for index, day := range workDays {
-
-			if index == len(workDays)-1 {
-				noBorder = "border-b-0"
-			}
-			var templ_7745c5c3_Var17 = []any{noBorder}
-			templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var17...)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 20, "<p class=\"")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			var templ_7745c5c3_Var18 string
-			templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var17).String())
-			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 1, Col: 0}
-			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 21, "\">")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			var templ_7745c5c3_Var19 string
-			templ_7745c5c3_Var19, templ_7745c5c3_Err = templ.JoinStringErrs(day.Date().Format("02.01.2006"))
-			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 88, Col: 59}
-			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var19))
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 22, "</p>")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			var templ_7745c5c3_Var20 = []any{"grid grid-cols-subgrid col-span-3 " + noBorder}
-			templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var20...)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 23, "<div class=\"")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			var templ_7745c5c3_Var21 string
-			templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var20).String())
-			if templ_7745c5c3_Err != nil {
-				return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 1, Col: 0}
-			}
-			_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 24, "\">")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			if day.IsWorkDay() {
-
-				workDay, _ := day.(*models.WorkDay)
-				for bookingI := 0; bookingI < len(workDay.Bookings); bookingI += 2 {
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 25, "<p>")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					var templ_7745c5c3_Var22 string
-					templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(workDay.Bookings[bookingI].Timestamp.Format("15:04"))
-					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 95, Col: 64}
-					}
-					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 26, "</p><p>")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					var templ_7745c5c3_Var23 string
-					templ_7745c5c3_Var23, templ_7745c5c3_Err = templ.JoinStringErrs(workDay.Bookings[bookingI+1].Timestamp.Format("15:04"))
-					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 96, Col: 66}
-					}
-					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var23))
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 27, "</p><p>")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					var templ_7745c5c3_Var24 string
-					templ_7745c5c3_Var24, templ_7745c5c3_Err = templ.JoinStringErrs(workDay.Bookings[bookingI].BookingType.Name)
-					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 97, Col: 55}
-					}
-					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var24))
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 28, "</p>")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-				}
-				templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 29, " ")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				if workDay.IsKurzArbeit() {
-
-					timeFrom, timeTo := workDay.GenerateKurzArbeitBookings(e)
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 30, "<p>")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					var templ_7745c5c3_Var25 string
-					templ_7745c5c3_Var25, templ_7745c5c3_Err = templ.JoinStringErrs(timeFrom.Format("15:04"))
-					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 103, Col: 36}
-					}
-					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var25))
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 31, "</p><p>")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					var templ_7745c5c3_Var26 string
-					templ_7745c5c3_Var26, templ_7745c5c3_Err = templ.JoinStringErrs(timeTo.Format("15:04"))
-					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 104, Col: 34}
-					}
-					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var26))
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-					templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 32, "</p><p>Kurzarbeit</p>")
-					if templ_7745c5c3_Err != nil {
-						return templ_7745c5c3_Err
-					}
-				}
-			} else {
-
-				absentDay, _ := day.(*models.Absence)
-				templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 33, "<p class=\"col-span-full\">")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				var templ_7745c5c3_Var27 string
-				templ_7745c5c3_Var27, templ_7745c5c3_Err = templ.JoinStringErrs(absentDay.AbwesenheitTyp.Name)
-				if templ_7745c5c3_Err != nil {
-					return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 111, Col: 62}
-				}
-				_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var27))
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-				templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 34, "</p>")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 35, "</div>")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			work, pause, overtime := day.GetAllWorkTimesVirtual(e)
-			templ_7745c5c3_Err = ColorDuration(work, noBorder).Render(ctx, templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 36, " ")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = ColorDuration(pause, noBorder).Render(ctx, templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 37, " ")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = ColorDuration(overtime, noBorder+" border-r-0").Render(ctx, templ_7745c5c3_Buffer)
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 38, " ")
-			if templ_7745c5c3_Err != nil {
-				return templ_7745c5c3_Err
-			}
-			if day.Date().Weekday() == time.Friday {
-				templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 39, "<p class=\"col-span-full bg-neutral-300\">Wochenende</p>")
-				if templ_7745c5c3_Err != nil {
-					return templ_7745c5c3_Err
-				}
-			}
-		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 40, "</div></content>")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 13, "</label></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -513,6 +205,70 @@ func PDFReportEmploye(e models.User, overtime, worktime time.Duration, workDays
 	})
 }
 
+//	templ PDFReportEmploye(e models.User, overtime, worktime time.Duration, workDays []models.IWorkDay, tsStart time.Time, tsEnd time.Time) {
+//		{{
+//			_, kw := tsStart.ISOWeek()
+//			noBorder := ""
+//		}}
+//		@Base()
+//		<content class="p-8 relative flex flex-col gap-4 break-after-page">
+//			<div>
+//				<h1 class="text-2xl font-bold">{ e.Vorname } { e.Name }</h1>
+//				<p>Zeitraum: <span>{ tsStart.Format("02.01.2006") }</span> - <span>{ tsEnd.Format("02.01.2006") }</span></p>
+//				<p>Arbeitszeit: <span>{ helper.FormatDuration(worktime) }</span></p>
+//				<p>Überstunden: <span>{ helper.FormatDuration(overtime) }</span></p>
+//			</div>
+//			<div class="grid grid-rows-6 grid-cols-[3fr_2fr_2fr_2fr_3fr_3fr_3fr] *:not-print:p-2 *:text-center auto-rows-min divide-neutral-300 divide-x-1 divide-y-1">
+//				<p class="bg-neutral-300 border-neutral-600">{ kw }</p>
+//				<p class="bg-neutral-300 border-neutral-600">Kommen</p>
+//				<p class="bg-neutral-300 border-neutral-600">Gehen</p>
+//				<p class="bg-neutral-300 border-neutral-600">Arbeitsart</p>
+//				<p class="bg-neutral-300 border-neutral-600">Stunden</p>
+//				<p class="bg-neutral-300 border-neutral-600">Pause</p>
+//				<p class="bg-neutral-300 border-neutral-600 border-r-0">Überstunden</p>
+//				for index, day := range workDays {
+//					{{
+//						if index == len(workDays)-1 {
+//							noBorder = "border-b-0"
+//						}
+//					}}
+//					<p class={ noBorder }>{ day.Date().Format("02.01.2006") }</p>
+//					<div class={ "grid grid-cols-subgrid col-span-3 " + noBorder }>
+//						if day.IsWorkDay() {
+//							{{
+//							workDay, _ := day.(*models.WorkDay)
+//							}}
+//							for bookingI := 0; bookingI < len(workDay.Bookings); bookingI+= 2 {
+//								<p>{ workDay.Bookings[bookingI].Timestamp.Format("15:04") }</p>
+//								<p>{ workDay.Bookings[bookingI+1].Timestamp.Format("15:04") }</p>
+//								<p>{ workDay.Bookings[bookingI].BookingType.Name } </p>
+//							}
+//							if workDay.IsKurzArbeit() {
+//								{{
+//									timeFrom, timeTo := workDay.GenerateKurzArbeitBookings(e)
+//								}}
+//								<p>{ timeFrom.Format("15:04") }</p>
+//								<p>{ timeTo.Format("15:04") }</p>
+//								<p>Kurzarbeit</p>
+//							}
+//						} else {
+//							{{
+//							absentDay, _ := day.(*models.Absence)
+//							}}
+//							<p class="col-span-full">{ absentDay.AbwesenheitTyp.Name }</p>
+//						}
+//					</div>
+//					{{ work, pause, overtime := day.GetTimesVirtual(e) }}
+//					@ColorDuration(work, noBorder)
+//					@ColorDuration(pause, noBorder)
+//					@ColorDuration(overtime, noBorder+" border-r-0")
+//					if day.Date().Weekday() == time.Friday {
+//						<p class="col-span-full bg-neutral-300">Wochenende</p>
+//					}
+//				}
+//			</div>
+//		</content>
+//	}
 func ColorDuration(d time.Duration, classes string) templ.Component {
 	return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) {
 		templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context
@@ -529,9 +285,9 @@ func ColorDuration(d time.Duration, classes string) templ.Component {
 			}()
 		}
 		ctx = templ.InitializeContext(ctx)
-		templ_7745c5c3_Var28 := templ.GetChildren(ctx)
-		if templ_7745c5c3_Var28 == nil {
-			templ_7745c5c3_Var28 = templ.NopComponent
+		templ_7745c5c3_Var11 := templ.GetChildren(ctx)
+		if templ_7745c5c3_Var11 == nil {
+			templ_7745c5c3_Var11 = templ.NopComponent
 		}
 		ctx = templ.ClearChildren(ctx)
 
@@ -539,38 +295,38 @@ func ColorDuration(d time.Duration, classes string) templ.Component {
 		if d.Abs() < time.Minute {
 			color = "text-neutral-300"
 		}
-		var templ_7745c5c3_Var29 = []any{color + " " + classes}
-		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var29...)
+		var templ_7745c5c3_Var12 = []any{color + " " + classes}
+		templ_7745c5c3_Err = templ.RenderCSSItems(ctx, templ_7745c5c3_Buffer, templ_7745c5c3_Var12...)
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 41, "<p class=\"")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 14, "<p class=\"")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var30 string
-		templ_7745c5c3_Var30, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var29).String())
+		var templ_7745c5c3_Var13 string
+		templ_7745c5c3_Var13, templ_7745c5c3_Err = templ.JoinStringErrs(templ.CSSClasses(templ_7745c5c3_Var12).String())
 		if templ_7745c5c3_Err != nil {
 			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 1, Col: 0}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var30))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var13))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 42, "\">")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 15, "\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		var templ_7745c5c3_Var31 string
-		templ_7745c5c3_Var31, templ_7745c5c3_Err = templ.JoinStringErrs(helper.FormatDurationFill(d, true))
+		var templ_7745c5c3_Var14 string
+		templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(helper.FormatDurationFill(d, true))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 133, Col: 72}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/pdf.templ`, Line: 135, Col: 72}
 		}
-		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var31))
+		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 43, "</p>")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 16, "</p>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

Backend/templates/presencePage_templ.go

@@ -1,6 +1,6 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.3.924
+// templ: version: v0.3.943
 package templates
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.

Backend/templates/teamComponents.templ

@@ -36,7 +36,7 @@ templ defaultWeekDayComponent(u models.User, day models.IWorkDay) {
 			if day.IsWorkDay() {
 				{{
 				workDay, _ := day.(*models.WorkDay)
-				work, pause, _ := workDay.GetAllWorkTimesReal(u)
+				work, pause, _ := workDay.GetTimes(u, models.WorktimeBaseDay, false)
 				}}
 				if !workDay.RequiresAction() {
 					<div class="flex flex-row gap-2">
@@ -81,7 +81,7 @@ templ weekDayComponent(user models.User, day models.WorkDay) {
 templ workWeekComponent(week models.WorkWeek, onlyAccept bool) {
 	{{
 		year, kw := week.WeekStart.ISOWeek()
-		progress := (float32(week.WorkTimeVirtual.Hours()) / week.User.ArbeitszeitPerWoche) * 100
+		progress := (float32(week.WorktimeVirtual.Hours()) / week.User.ArbeitszeitPerWoche) * 100
 	}}
 	<div class="employeComponent grid-sub responsive lg:divide-x-1 max-md:divide-y-1 @container">
 		<div class="grid-cell flex flex-col max-md:bg-neutral-300 gap-2">

Backend/templates/teamComponents_templ.go

@@ -1,6 +1,6 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.3.924
+// templ: version: v0.3.943
 package templates
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
@@ -179,7 +179,7 @@ func defaultWeekDayComponent(u models.User, day models.IWorkDay) templ.Component
 		if day.IsWorkDay() {
 
 			workDay, _ := day.(*models.WorkDay)
-			work, pause, _ := workDay.GetAllWorkTimesReal(u)
+			work, pause, _ := workDay.GetTimes(u, models.WorktimeBaseDay, false)
 			if !workDay.RequiresAction() {
 				templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 14, "<div class=\"flex flex-row gap-2\"><span class=\"text-accent\">")
 				if templ_7745c5c3_Err != nil {
@@ -346,7 +346,7 @@ func workWeekComponent(week models.WorkWeek, onlyAccept bool) templ.Component {
 		ctx = templ.ClearChildren(ctx)
 
 		year, kw := week.WeekStart.ISOWeek()
-		progress := (float32(week.WorkTimeVirtual.Hours()) / week.User.ArbeitszeitPerWoche) * 100
+		progress := (float32(week.WorktimeVirtual.Hours()) / week.User.ArbeitszeitPerWoche) * 100
 		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 28, "<div class=\"employeComponent grid-sub responsive lg:divide-x-1 max-md:divide-y-1 @container\"><div class=\"grid-cell flex flex-col max-md:bg-neutral-300 gap-2\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err

Backend/templates/timeComponents_templ.go

@@ -1,6 +1,6 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.3.924
+// templ: version: v0.3.943
 package templates
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.

Backend/templates/timePage.templ

@@ -103,7 +103,8 @@ templ defaultDayComponent(day models.IWorkDay) {
 				if day.IsWorkDay() {
 					{{
 						workDay, _ := day.(*models.WorkDay)
-						work, pause, overtime := workDay.GetAllWorkTimesReal(user)
+						work, pause, overtime := workDay.GetTimes(user, models.WorktimeBaseDay, true)
+						work = workDay.GetWorktime(user, models.WorktimeBaseDay, false)
 					}}
 					if day.RequiresAction() {
 						<p class="text-red-600">Bitte anpassen</p>
@@ -136,7 +137,7 @@ templ defaultDayComponent(day models.IWorkDay) {
 					if len(workDay.Bookings) < 1 {
 						<p class="text group-[.edit]:hidden">Keine Buchung gefunden. Bitte Arbeitsstunden oder Grund der Abwesenheit eingeben!</p>
 					}
-					if workDay.IsKurzArbeit() {
+					if workDay.IsKurzArbeit() && len(workDay.Bookings) > 0 {
 						@absenceComponent(workDay.GetKurzArbeit(), true)
 					}
 					for _, booking := range workDay.Bookings {

Backend/templates/timePage_templ.go

@@ -1,6 +1,6 @@
 // Code generated by templ - DO NOT EDIT.
 
-// templ: version: v0.3.924
+// templ: version: v0.3.943
 package templates
 
 //lint:file-ignore SA4006 This context is only used if a nested component is present.
@@ -297,7 +297,8 @@ func defaultDayComponent(day models.IWorkDay) templ.Component {
 		if day.IsWorkDay() {
 
 			workDay, _ := day.(*models.WorkDay)
-			work, pause, overtime := workDay.GetAllWorkTimesReal(user)
+			work, pause, overtime := workDay.GetTimes(user, models.WorktimeBaseDay, true)
+			work = workDay.GetWorktime(user, models.WorktimeBaseDay, false)
 			if day.RequiresAction() {
 				templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 20, "<p class=\"text-red-600\">Bitte anpassen</p>")
 				if templ_7745c5c3_Err != nil {
@@ -312,7 +313,7 @@ func defaultDayComponent(day models.IWorkDay) templ.Component {
 					var templ_7745c5c3_Var14 string
 					templ_7745c5c3_Var14, templ_7745c5c3_Err = templ.JoinStringErrs(helper.FormatDuration(work))
 					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 113, Col: 155}
+						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 114, Col: 155}
 					}
 					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var14))
 					if templ_7745c5c3_Err != nil {
@@ -335,7 +336,7 @@ func defaultDayComponent(day models.IWorkDay) templ.Component {
 					var templ_7745c5c3_Var15 string
 					templ_7745c5c3_Var15, templ_7745c5c3_Err = templ.JoinStringErrs(helper.FormatDuration(pause))
 					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 116, Col: 173}
+						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 117, Col: 173}
 					}
 					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var15))
 					if templ_7745c5c3_Err != nil {
@@ -358,7 +359,7 @@ func defaultDayComponent(day models.IWorkDay) templ.Component {
 					var templ_7745c5c3_Var16 string
 					templ_7745c5c3_Var16, templ_7745c5c3_Err = templ.JoinStringErrs(helper.FormatDuration(overtime))
 					if templ_7745c5c3_Err != nil {
-						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 121, Col: 41}
+						return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 122, Col: 41}
 					}
 					_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var16))
 					if templ_7745c5c3_Err != nil {
@@ -391,7 +392,7 @@ func defaultDayComponent(day models.IWorkDay) templ.Component {
 		var templ_7745c5c3_Var18 string
 		templ_7745c5c3_Var18, templ_7745c5c3_Err = templ.JoinStringErrs("time-" + day.Date().Format(time.DateOnly))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 130, Col: 56}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 131, Col: 56}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var18))
 		if templ_7745c5c3_Err != nil {
@@ -435,7 +436,7 @@ func defaultDayComponent(day models.IWorkDay) templ.Component {
 			if templ_7745c5c3_Err != nil {
 				return templ_7745c5c3_Err
 			}
-			if workDay.IsKurzArbeit() {
+			if workDay.IsKurzArbeit() && len(workDay.Bookings) > 0 {
 				templ_7745c5c3_Err = absenceComponent(workDay.GetKurzArbeit(), true).Render(ctx, templ_7745c5c3_Buffer)
 				if templ_7745c5c3_Err != nil {
 					return templ_7745c5c3_Err
@@ -507,7 +508,7 @@ func absentInput(a models.Absence) templ.Component {
 		var templ_7745c5c3_Var21 string
 		templ_7745c5c3_Var21, templ_7745c5c3_Err = templ.JoinStringErrs(a.DateFrom.Format(time.DateOnly))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 162, Col: 79}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 163, Col: 79}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var21))
 		if templ_7745c5c3_Err != nil {
@@ -520,7 +521,7 @@ func absentInput(a models.Absence) templ.Component {
 		var templ_7745c5c3_Var22 string
 		templ_7745c5c3_Var22, templ_7745c5c3_Err = templ.JoinStringErrs(a.DateTo.Format(time.DateOnly))
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 163, Col: 75}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 164, Col: 75}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var22))
 		if templ_7745c5c3_Err != nil {
@@ -533,7 +534,7 @@ func absentInput(a models.Absence) templ.Component {
 		var templ_7745c5c3_Var23 string
 		templ_7745c5c3_Var23, templ_7745c5c3_Err = templ.JoinStringErrs(a.AbwesenheitTyp.Id)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 164, Col: 64}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 165, Col: 64}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var23))
 		if templ_7745c5c3_Err != nil {
@@ -546,7 +547,7 @@ func absentInput(a models.Absence) templ.Component {
 		var templ_7745c5c3_Var24 string
 		templ_7745c5c3_Var24, templ_7745c5c3_Err = templ.JoinStringErrs(a.CounterId)
 		if templ_7745c5c3_Err != nil {
-			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 165, Col: 54}
+			return templ.Error{Err: templ_7745c5c3_Err, FileName: `templates/timePage.templ`, Line: 166, Col: 54}
 		}
 		_, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var24))
 		if templ_7745c5c3_Err != nil {

DB/initdb/01_schema.sql

@@ -104,7 +104,7 @@ CREATE TABLE "s_abwesenheit_typen" (
     "arbeitszeit_equivalent" float4 NOT NULL
 );
 
-COMMENT ON COLUMN "s_abwesenheit_typen"."arbeitszeit_equivalent" IS '0=keine Arbeitszeit; 1=Arbeitszeit auffüllen; 2=Arbeitszeit austauschen';
+COMMENT ON COLUMN "s_abwesenheit_typen"."arbeitszeit_equivalent" IS '0=keine Arbeitszeit; -1=Arbeitszeit auffüllen; <=1 - 100 => Arbeitszeit pro Tag prozentual';
 
 -- Adds crypto extension
 

DocumentCreator/templates/abrechnung.typ

@@ -11,7 +11,7 @@
       columns: (3fr,  .65fr),
       align: left + horizon,
       inset: .5em,
-      [#meta.EmployeeName -- #meta.TimeRange], grid.cell(rowspan: 2)[#image("static/logo.png")],
+      [#meta.EmployeeName -- #meta.TimeRange], grid.cell(rowspan: 2)[#image("/static/logo.png")],
       [Arbeitszeitrechnung maschinell erstellt am #meta.CurrentTimestamp],
     )
       ])
@@ -37,42 +37,47 @@
   [Zeitraum: #meta.TimeRange]
 
   table(
-  columns: (1fr, 1fr, 1fr, 1fr, 1fr, 1fr, 1.25fr),
+  columns: (1fr, 1fr, 1fr, 1fr, 1fr, 1fr, .875fr, 1.25fr),
   fill: (x, y) =>
     if y == 0 { oklch(87%, 0, 0deg) },
   table-header(
-    [Datum], [Kommen], [Gehen], [Arbeitsart], [Stunden], [Pause], [Überstunden]
+    [Datum], [Kommen], [Gehen], [Arbeitsart], [Stunden], [Kurzarbeit], [Pause], [Überstunden]
   ),
   .. for day in days {
     (
     [#day.Date],
     if day.DayParts.len() == 0{
         table.cell(colspan: 3)[Keine Buchungen]
-    }else if not day.DayParts.first().IsWorkDay{
+    }else if day.DayParts.len() == 1 and not day.DayParts.first().IsWorkDay{
       table.cell(colspan: 3)[#day.DayParts.first().WorkType]
     }
     else {
-
     table.cell(colspan: 3, inset: 0em)[
-
       #table(
         columns: (1fr, 1fr, 1fr),
         .. for Zeit in day.DayParts {
       (
-      [#Zeit.BookingFrom],
-      [#Zeit.BookingTo],
-      [#Zeit.WorkType],
+        if Zeit.IsWorkDay{
+        (
+          table.cell()[#Zeit.BookingFrom],
+          table.cell()[#Zeit.BookingTo],
+          table.cell()[#Zeit.WorkType],
+        )
+        }else{
+          (table.cell(colspan: 3)[#Zeit.WorkType],)
+        }
       )
     },
       )
     ]
     },
     [#day.Worktime],
+    [#day.Kurzarbeit],
     [#day.Pausetime],
     [#day.Overtime],
     )
     if day.IsFriday {
-      ( table.cell(colspan: 7, fill: oklch(87%, 0, 0deg))[Wochenende], )   // note the trailing comma
+      ( table.cell(colspan: 8, fill: oklch(87%, 0, 0deg))[Wochenende], )   // note the trailing comma
     }
   }
   )
@@ -84,9 +89,9 @@
     stroke: none,
     table.hline(start: 0, end: 2, stroke: stroke(dash:"dashed", thickness:.5pt)),
   [Arbeitszeit :], table.cell(align: left)[#meta.WorkTime],
+  [Kurzarbeit :], table.cell(align: left)[#meta.Kurzarbeit],
   [Überstunden :], table.cell(align: left)[#meta.Overtime],
-  [Überstunden :],table.cell(align: left)[#meta.OvertimeTotal],
+  [Überstunden lfd. :],table.cell(align: left)[#meta.OvertimeTotal],
   table.hline(start: 0, end: 2),
-
 )
 }

Readme.md

@@ -1,6 +1,6 @@
 # Arbeitszeitmessung
 
-[![Quality Gate Status](https://sonar.letsstein.de/api/project_badges/measure?project=arbeitszeitmessung&metric=alert_status&token=sqb_f8e5ad702b23aa4631a29b99c2f8030caf7d4e05)](https://sonar.letsstein.de/dashboard?id=arbeitszeitmessung)
+[![Quality Gate Status](https://sonar.letsstein.de/api/project_badges/measure?project=arbeitszeitmessung&metric=alert_status&token=sqb_253028eff30aff24f32b437cd6c484c511b5c33f)](https://sonar.letsstein.de/dashboard?id=arbeitszeitmessung)
 
 bis jetzt ein einfaches Backend mit PostgreSQL Datenbank und GO Webserver um Arbeitszeitbuchungen per HTTP PUT einzufügen
 

WIR-typst/main.typ

@@ -1,63 +0,0 @@
-#set page("a4")
-#set text(font: "Lato")
-
-= Stunden
-
-== Kim Mustermensch
-
-Zeitraum: 01.10.2025 - 31.10.2025
-
-Arbeitszeit: 136h 19min
-
-Überstunden: -39h 41min
-
-
-
-
-
-// #show table.cell: it => {
-//   if it.y == 0 {
-//     set text(white)
-//     strong(it)
-//   } else if it.body == [] {
-//     // Replace empty cells with 'N/A'
-//      pad(..it.inset)[0min]
-    
-//   } else {
-//     it
-//   }
-// }
-
-#let subgrid(body) = {
-  table.cell(colspan: 3, inset: 0em)[
-    #table(
-        columns: (1fr, 1fr, 1fr),
-        gutter: 0em,
-        stroke: black,
-        [..#body]
-    )
-  ]
-}
-
-
-  "01.09.2025",
-  "08:07",
-  "16:28",
-  "Büro",
-  "7h 51min",
-  "30min",
-  "-9min",
-    "02.09.2025",
-    	// return work, pause, overtime
-table.cell(colspan: 3, inset: 0em)[#table(
-        columns: (1fr, 1fr, 1fr),
-        gutter: 0em,
-        stroke: black,
-        [08:12], [16:24], [Büro],
-        [16:30], [17:24], [Homeoffice]
-      )],
-  "6h",
-  "0min",
-  "-1h 15min"
-
-)