490 lines
17 KiB
Go
490 lines
17 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/xuri/excelize/v2"
|
|
)
|
|
|
|
type DailySummary struct {
|
|
Date string // YYYY-MM-DD Format
|
|
Day string // Mon, Tue, etc.
|
|
WorkStart string // HH:MM:SS - Frühester Arbeitsbeginn
|
|
WorkEnd string // HH:MM:SS - Spätestes Arbeitsende
|
|
BreakDuration time.Duration // Summe aller Pausenzeiten an diesem Tag
|
|
WorkDuration time.Duration // Summe aller Arbeitszeiten an diesem Tag
|
|
Tag string // Spezielle Tags für den Tag (Urlaub, Krank, Feiertag, Uni, Free...)
|
|
}
|
|
|
|
type ExcelEntry struct {
|
|
Date string // YYYY-MM-DD
|
|
Day string // Mon, Tue, etc.
|
|
WorkStart string // HH:MM:SS
|
|
WorkEnd string // HH:MM:SS
|
|
BreakDuration string // HH:MM:SS (formatiert)
|
|
Tag string // Spezielle Tags
|
|
}
|
|
|
|
func aggregateEntriesToDailySummaries(entries []TimeEntry, yearStart, yearEnd time.Time) (map[string]*DailySummary, error) {
|
|
dailyMap := make(map[string]*DailySummary)
|
|
location := yearStart.Location() // Verwende die Zeitzone des Startdatums
|
|
now := time.Now().In(location) // Aktuelle Zeit für laufende Einträge
|
|
|
|
currentDay := yearStart
|
|
log.Println(currentDay)
|
|
for currentDay.Before(yearEnd) {
|
|
dayStr := currentDay.Format("2006-01-02")
|
|
weekday := currentDay.Weekday()
|
|
tag := ""
|
|
if weekday == time.Saturday || weekday == time.Sunday {
|
|
tag = "free"
|
|
}
|
|
|
|
dailyMap[dayStr] = &DailySummary{
|
|
Date: dayStr,
|
|
Day: weekday.String()[:3], // Mon, Tue, etc.
|
|
Tag: tag, // Initialisiere mit "free" für Wochenende, sonst leer
|
|
}
|
|
currentDay = currentDay.Add(24 * time.Hour) // Gehe zum nächsten Tag
|
|
}
|
|
|
|
fullDayTags := make(map[string]string) // Map, um ganztägige Ereignisse zu speichern (Datum -> Tag)
|
|
|
|
for _, entry := range entries {
|
|
if entry.StartTime.IsZero() {
|
|
log.Printf("WARN: Skipping entry with zero start time (ID: %d)", entry.ID)
|
|
continue
|
|
}
|
|
|
|
startTime := entry.StartTime.In(location) // Stelle sicher, dass Zeiten in der korrekten Zeitzone sind
|
|
endTime := entry.EndTime.Time.In(location)
|
|
validEndTime := entry.EndTime.Valid
|
|
if !validEndTime {
|
|
endTime = now // Nimm aktuelle Zeit für laufende Einträge
|
|
}
|
|
|
|
if endTime.Before(yearStart) || startTime.After(yearEnd) {
|
|
continue
|
|
}
|
|
|
|
lowerTag := strings.ToLower(entry.Tag)
|
|
isPotentiallyFullDaySpecialTag := false
|
|
switch lowerTag {
|
|
case "urlaub", "krank", "feiertag", "uni", "free":
|
|
isPotentiallyFullDaySpecialTag = true
|
|
}
|
|
|
|
if isPotentiallyFullDaySpecialTag {
|
|
loopTimeForTag := startTime
|
|
for loopTimeForTag.Before(endTime) || loopTimeForTag.Equal(endTime) {
|
|
dayStr := loopTimeForTag.Format("2006-01-02")
|
|
// Nur Tage innerhalb des Jahres berücksichtigen
|
|
if _, exists := dailyMap[dayStr]; exists {
|
|
existingTag := fullDayTags[dayStr]
|
|
if shouldOverwriteTag(existingTag, lowerTag) {
|
|
fullDayTags[dayStr] = lowerTag
|
|
}
|
|
}
|
|
loopTimeForTag = time.Date(loopTimeForTag.Year(), loopTimeForTag.Month(), loopTimeForTag.Day(), 0, 0, 0, 0, location).Add(24 * time.Hour)
|
|
}
|
|
}
|
|
|
|
loopTime := startTime
|
|
for loopTime.Before(endTime) {
|
|
dayStr := loopTime.Format("2006-01-02")
|
|
dayStart := time.Date(loopTime.Year(), loopTime.Month(), loopTime.Day(), 0, 0, 0, 0, location)
|
|
dayEnd := dayStart.Add(24 * time.Hour)
|
|
|
|
summary, exists := dailyMap[dayStr]
|
|
if !exists {
|
|
log.Printf("WARN: Day %s not found in initial map during entry processing (ID: %d)", dayStr, entry.ID)
|
|
loopTime = dayEnd // Gehe zum nächsten Tag
|
|
continue
|
|
}
|
|
|
|
segmentStart := loopTime
|
|
segmentEnd := endTime
|
|
if segmentEnd.After(dayEnd) {
|
|
segmentEnd = dayEnd
|
|
}
|
|
|
|
segmentDuration := segmentEnd.Sub(segmentStart)
|
|
if segmentDuration <= 0 { // Überspringe leere Segmente
|
|
loopTime = dayEnd
|
|
continue
|
|
}
|
|
|
|
timeStr := segmentStart.Format("15:04:05")
|
|
// endTimeStr := segmentEnd.Format("15:04:05") // Ende des Segments
|
|
|
|
switch lowerTag {
|
|
case TagWork: // Konstante verwenden
|
|
summary.WorkDuration += segmentDuration
|
|
if summary.WorkStart == "" || timeStr < summary.WorkStart {
|
|
summary.WorkStart = timeStr
|
|
}
|
|
entryEndTimeOnThisDay := endTime
|
|
if !endTime.Truncate(24 * time.Hour).Equal(dayStart) {
|
|
entryEndTimeOnThisDay = segmentEnd
|
|
}
|
|
entryEndTimeOnThisDayStr := entryEndTimeOnThisDay.Format("15:04:05")
|
|
if summary.WorkEnd == "" || entryEndTimeOnThisDayStr > summary.WorkEnd {
|
|
summary.WorkEnd = entryEndTimeOnThisDayStr
|
|
}
|
|
|
|
if summary.Tag == "" || summary.Tag == "free" {
|
|
summary.Tag = TagWork
|
|
}
|
|
|
|
case TagBreak: // Konstante verwenden
|
|
summary.BreakDuration += segmentDuration
|
|
default:
|
|
log.Printf("INFO: Encountered unknown tag '%s' during interval processing for entry ID %d on %s. Counting duration as 'work'.", entry.Tag, entry.ID, dayStr)
|
|
summary.WorkDuration += segmentDuration
|
|
if summary.WorkStart == "" || timeStr < summary.WorkStart {
|
|
summary.WorkStart = timeStr
|
|
}
|
|
entryEndTimeOnThisDay := endTime
|
|
if !endTime.Truncate(24 * time.Hour).Equal(dayStart) {
|
|
entryEndTimeOnThisDay = segmentEnd
|
|
}
|
|
entryEndTimeOnThisDayStr := entryEndTimeOnThisDay.Format("15:04:05")
|
|
if summary.WorkEnd == "" || entryEndTimeOnThisDayStr > summary.WorkEnd {
|
|
summary.WorkEnd = entryEndTimeOnThisDayStr
|
|
}
|
|
if summary.Tag == "" || summary.Tag == "free" {
|
|
summary.Tag = TagWork // Behandle unbekannt wie Arbeit für den Tag-Typ
|
|
}
|
|
}
|
|
|
|
loopTime = dayEnd // Gehe zum nächsten Tag
|
|
}
|
|
}
|
|
|
|
for dayStr, specialTag := range fullDayTags {
|
|
if summary, exists := dailyMap[dayStr]; exists {
|
|
// Nur überschreiben, wenn der neue Tag höhere oder gleiche Prio hat
|
|
if shouldOverwriteTag(summary.Tag, specialTag) {
|
|
summary.Tag = specialTag
|
|
summary.WorkStart = ""
|
|
summary.WorkEnd = ""
|
|
summary.WorkDuration = 0
|
|
summary.BreakDuration = 0
|
|
}
|
|
}
|
|
}
|
|
|
|
return dailyMap, nil
|
|
}
|
|
|
|
func shouldOverwriteTag(existingTag, newTag string) bool {
|
|
if newTag != "" && (existingTag == "" || strings.ToLower(existingTag) == "free") {
|
|
return true
|
|
}
|
|
if newTag == "" {
|
|
return false
|
|
}
|
|
|
|
priority := map[string]int{
|
|
"krank": 1,
|
|
"feiertag": 1,
|
|
"urlaub": 1,
|
|
"uni": 2,
|
|
"work": 3, // Arbeit hat niedrigere Priorität als spezielle Tage
|
|
"break": 99, // Pause sollte nie der Haupt-Tag sein
|
|
"free": 100, // Frei hat niedrigste Priorität
|
|
}
|
|
prioExisting, okExisting := priority[strings.ToLower(existingTag)]
|
|
if !okExisting {
|
|
prioExisting = 999
|
|
}
|
|
prioNew, okNew := priority[strings.ToLower(newTag)]
|
|
if !okNew {
|
|
prioNew = 999
|
|
}
|
|
|
|
return prioNew < prioExisting || (prioNew == prioExisting && strings.ToLower(newTag) != "work")
|
|
}
|
|
|
|
func convertDailyToExcelEntries(dailySummaries map[string]*DailySummary) []ExcelEntry {
|
|
excelEntries := make([]ExcelEntry, 0, len(dailySummaries))
|
|
|
|
dates := make([]string, 0, len(dailySummaries))
|
|
for d := range dailySummaries {
|
|
dates = append(dates, d)
|
|
}
|
|
sort.Strings(dates) // Sortiere die Datums-Strings (YYYY-MM-DD)
|
|
|
|
for _, dateStr := range dates {
|
|
summary := dailySummaries[dateStr]
|
|
entry := ExcelEntry{
|
|
Date: summary.Date,
|
|
Day: summary.Day,
|
|
WorkStart: summary.WorkStart,
|
|
WorkEnd: summary.WorkEnd,
|
|
BreakDuration: formatDuration(summary.BreakDuration), // Formatierte Dauer
|
|
Tag: summary.Tag, // Übernehme den finalen Tag
|
|
}
|
|
excelEntries = append(excelEntries, entry)
|
|
}
|
|
return excelEntries
|
|
}
|
|
|
|
func formatDuration(d time.Duration) string {
|
|
if d < 0 {
|
|
d = -d // Arbeite mit positivem Wert für die Berechnung
|
|
sign := "-"
|
|
d = d.Round(time.Second)
|
|
h := int64(d.Hours())
|
|
m := int64(d.Minutes()) % 60
|
|
s := int64(d.Seconds()) % 60
|
|
return fmt.Sprintf("%s%02d:%02d:%02d", sign, h, m, s)
|
|
}
|
|
d = d.Round(time.Second)
|
|
h := int64(d.Hours())
|
|
m := int64(d.Minutes()) % 60
|
|
s := int64(d.Seconds()) % 60
|
|
return fmt.Sprintf("%02d:%02d:%02d", h, m, s)
|
|
}
|
|
|
|
func getSollExcelTime(dayOfWeek string) any {
|
|
var sollString string
|
|
switch dayOfWeek {
|
|
case "Mon", "Tue", "Thu", "Fri": // Standard-Arbeitstage
|
|
sollString = "08:00"
|
|
case "Wed": // Kurzer Tag
|
|
sollString = "04:00"
|
|
default: // Sa, So
|
|
return nil // Kein Soll an diesen Tagen
|
|
}
|
|
|
|
sollDur, err := time.Parse("15:04", sollString)
|
|
if err != nil {
|
|
log.Printf("ERROR: Could not parse hardcoded soll string '%s': %v", sollString, err)
|
|
return nil // Fehler beim Parsen
|
|
}
|
|
return float64(sollDur.Hour())/24.0 + float64(sollDur.Minute())/(24.0*60.0)
|
|
}
|
|
|
|
func writeExcelSheet(entries []ExcelEntry, name string) error {
|
|
// Sortierung erfolgt jetzt in convertDailyToExcelEntries
|
|
|
|
f := excelize.NewFile()
|
|
defer func() {
|
|
if err := f.Close(); err != nil {
|
|
log.Printf("ERROR: Failed to close excel file handle: %v", err)
|
|
}
|
|
}()
|
|
|
|
sheetName := "Zeiten"
|
|
if len(entries) > 0 {
|
|
if t, err := time.Parse("2006-01-02", entries[0].Date); err == nil {
|
|
sheetName = fmt.Sprintf("%d", t.Year())
|
|
}
|
|
}
|
|
|
|
index, err := f.NewSheet(sheetName)
|
|
if err != nil {
|
|
existingIndex, _ := f.GetSheetIndex(sheetName)
|
|
if existingIndex == -1 {
|
|
sheetName = "Sheet1" // Fallback auf Default
|
|
index, _ = f.GetSheetIndex(sheetName)
|
|
if index == -1 {
|
|
return fmt.Errorf("could not create or find sheet '%s' or 'Sheet1': %w", sheetName, err)
|
|
}
|
|
} else {
|
|
index = existingIndex
|
|
}
|
|
}
|
|
|
|
defaultSheetName := "Sheet1"
|
|
defaultSheetIndex, _ := f.GetSheetIndex(defaultSheetName)
|
|
if sheetName != defaultSheetName && defaultSheetIndex != -1 {
|
|
f.DeleteSheet(defaultSheetName)
|
|
}
|
|
|
|
f.SetCellValue(sheetName, "B1", "Arbeitszeiten "+sheetName)
|
|
f.MergeCell(sheetName, "B1", "O1")
|
|
|
|
f.SetCellValue(sheetName, "B3", "Datum")
|
|
f.SetCellValue(sheetName, "C3", "Tag")
|
|
f.SetCellValue(sheetName, "D3", "Status / Zeit") // Titel angepasst
|
|
f.MergeCell(sheetName, "D3", "E3")
|
|
f.SetCellValue(sheetName, "G3", "Dauer") // Titel angepasst
|
|
f.MergeCell(sheetName, "G3", "H3")
|
|
f.SetCellValue(sheetName, "I3", "Pause")
|
|
f.SetCellValue(sheetName, "J3", "Netto")
|
|
f.SetCellValue(sheetName, "K3", "Soll")
|
|
f.SetCellValue(sheetName, "L3", "Saldo")
|
|
f.SetCellValue(sheetName, "N3", "Saldo Kumuliert")
|
|
f.MergeCell(sheetName, "N3", "O3")
|
|
|
|
f.SetCellValue(sheetName, "D4", "von / Status")
|
|
f.SetCellValue(sheetName, "E4", "bis")
|
|
f.SetCellValue(sheetName, "G4", "brutto")
|
|
f.SetCellValue(sheetName, "H4", "")
|
|
f.SetCellValue(sheetName, "J4", "Ist (Netto)") // Titel angepasst
|
|
f.SetCellValue(sheetName, "K4", "")
|
|
f.SetCellValue(sheetName, "L4", "Tag")
|
|
f.SetCellValue(sheetName, "N4", "Total")
|
|
f.SetCellValue(sheetName, "O4", "")
|
|
|
|
timeStyleCode := "hh:mm" // Format für Zeitpunkte und Dauer < 24h
|
|
timeStyle, _ := f.NewStyle(&excelize.Style{CustomNumFmt: &timeStyleCode})
|
|
dateStyleCode := "dd.mm.yyyy" // Format für Datum
|
|
dateStyle, _ := f.NewStyle(&excelize.Style{CustomNumFmt: &dateStyleCode})
|
|
saldoStyleCode := "[h]:mm;[RED]-[h]:mm" // Verwende [h] um Stunden > 24 zu erlauben
|
|
saldoStyle, _ := f.NewStyle(&excelize.Style{CustomNumFmt: &saldoStyleCode})
|
|
headerStyle, _ := f.NewStyle(&excelize.Style{
|
|
Font: &excelize.Font{Bold: true},
|
|
Alignment: &excelize.Alignment{Horizontal: "center"},
|
|
})
|
|
centerStyle, _ := f.NewStyle(&excelize.Style{Alignment: &excelize.Alignment{Horizontal: "center"}})
|
|
// Stil für Zellen, die leer bleiben sollen (optional, um z.B. 0 auszublenden)
|
|
// emptyStyle, _ := f.NewStyle(&excelize.Style{Fill: excelize.Fill{Type: "pattern", Color: []string{"#FFFFFF"}, Pattern: 1}}) // Weißer Hintergrund
|
|
|
|
f.SetCellStyle(sheetName, "B3", "O4", headerStyle)
|
|
f.SetCellStyle(sheetName, "B1", "O1", headerStyle) // Titel auch
|
|
|
|
startRow := 6
|
|
for i, entry := range entries {
|
|
row := startRow + i
|
|
rowStr := fmt.Sprintf("%d", row)
|
|
tagLower := strings.ToLower(entry.Tag)
|
|
|
|
dateValue, err := time.Parse("2006-01-02", entry.Date)
|
|
if err == nil {
|
|
f.SetCellValue(sheetName, "B"+rowStr, dateValue)
|
|
f.SetCellStyle(sheetName, "B"+rowStr, "B"+rowStr, dateStyle)
|
|
} else {
|
|
f.SetCellValue(sheetName, "B"+rowStr, entry.Date) // Fallback
|
|
}
|
|
f.SetCellValue(sheetName, "C"+rowStr, entry.Day)
|
|
|
|
sollExcelTime := getSollExcelTime(entry.Day)
|
|
if sollExcelTime != nil {
|
|
f.SetCellValue(sheetName, "K"+rowStr, sollExcelTime)
|
|
f.SetCellStyle(sheetName, "K"+rowStr, "K"+rowStr, timeStyle)
|
|
} else {
|
|
f.SetCellValue(sheetName, "K"+rowStr, "") // Leer für Wochenende etc.
|
|
}
|
|
|
|
switch tagLower {
|
|
case TagWork, "": // Normaler Arbeitstag oder nicht speziell getaggter Tag
|
|
if entry.WorkStart != "" && entry.WorkEnd != "" {
|
|
startTime, _ := time.Parse("15:04:05", entry.WorkStart)
|
|
endTime, _ := time.Parse("15:04:05", entry.WorkEnd)
|
|
startExcelTime := float64(startTime.Hour())/24.0 + float64(startTime.Minute())/(24.0*60.0) + float64(startTime.Second())/(24.0*60.0*60.0)
|
|
endExcelTime := float64(endTime.Hour())/24.0 + float64(endTime.Minute())/(24.0*60.0) + float64(endTime.Second())/(24.0*60.0*60.0)
|
|
if endExcelTime < startExcelTime {
|
|
endExcelTime += 1.0
|
|
}
|
|
|
|
f.SetCellValue(sheetName, "D"+rowStr, startExcelTime)
|
|
f.SetCellStyle(sheetName, "D"+rowStr, "D"+rowStr, timeStyle)
|
|
f.SetCellValue(sheetName, "E"+rowStr, endExcelTime)
|
|
f.SetCellStyle(sheetName, "E"+rowStr, "E"+rowStr, timeStyle)
|
|
|
|
f.SetCellFormula(sheetName, "G"+rowStr, fmt.Sprintf("E%d-D%d", row, row))
|
|
f.SetCellStyle(sheetName, "G"+rowStr, "H"+rowStr, saldoStyle) // Saldo-Style für Dauer
|
|
|
|
breakDur, _ := time.Parse("15:04:05", entry.BreakDuration)
|
|
breakExcelTime := float64(breakDur.Hour())/24.0 + float64(breakDur.Minute())/(24.0*60.0) + float64(breakDur.Second())/(24.0*60.0*60.0)
|
|
thirtyMinBreak := float64(30) / (24 * 60)
|
|
if breakExcelTime < thirtyMinBreak {
|
|
breakExcelTime = thirtyMinBreak
|
|
}
|
|
f.SetCellValue(sheetName, "I"+rowStr, breakExcelTime)
|
|
f.SetCellStyle(sheetName, "I"+rowStr, "I"+rowStr, timeStyle)
|
|
|
|
f.SetCellFormula(sheetName, "J"+rowStr, fmt.Sprintf("MAX(0, G%d-I%d)", row, row))
|
|
f.SetCellStyle(sheetName, "J"+rowStr, "J"+rowStr, saldoStyle) // Saldo-Style für Dauer
|
|
|
|
} else {
|
|
f.SetCellValue(sheetName, "J"+rowStr, 0.0)
|
|
f.SetCellStyle(sheetName, "J"+rowStr, "J"+rowStr, saldoStyle)
|
|
}
|
|
|
|
case "urlaub", "uni":
|
|
text := ""
|
|
if tagLower == "urlaub" {
|
|
text = "Urlaub"
|
|
} else {
|
|
text = "Hochschule"
|
|
}
|
|
f.SetCellValue(sheetName, "D"+rowStr, text)
|
|
f.MergeCell(sheetName, "D"+rowStr, "I"+rowStr) // Verbinde D bis I
|
|
f.SetCellStyle(sheetName, "D"+rowStr, "I"+rowStr, centerStyle)
|
|
|
|
if sollExcelTime != nil {
|
|
f.SetCellValue(sheetName, "J"+rowStr, sollExcelTime)
|
|
} else {
|
|
f.SetCellValue(sheetName, "J"+rowStr, 0.0) // Kein Soll (WE), Netto 0
|
|
}
|
|
f.SetCellStyle(sheetName, "J"+rowStr, "J"+rowStr, saldoStyle)
|
|
|
|
case "feiertag", "krank":
|
|
text := ""
|
|
if tagLower == "feiertag" {
|
|
text = "Feiertag"
|
|
} else {
|
|
text = "Krank"
|
|
}
|
|
f.SetCellValue(sheetName, "D"+rowStr, text)
|
|
f.MergeCell(sheetName, "D"+rowStr, "I"+rowStr) // Verbinde D bis I
|
|
f.SetCellStyle(sheetName, "D"+rowStr, "I"+rowStr, centerStyle)
|
|
|
|
if sollExcelTime != nil {
|
|
f.SetCellValue(sheetName, "J"+rowStr, sollExcelTime)
|
|
} else {
|
|
f.SetCellValue(sheetName, "J"+rowStr, 0.0) // Kein Soll (WE), Netto 0
|
|
}
|
|
f.SetCellStyle(sheetName, "J"+rowStr, "J"+rowStr, saldoStyle)
|
|
|
|
case "free": // Wochenende oder explizit "free"
|
|
f.SetCellValue(sheetName, "D"+rowStr, "")
|
|
f.MergeCell(sheetName, "D"+rowStr, "I"+rowStr) // Verbinde D bis I
|
|
f.SetCellStyle(sheetName, "D"+rowStr, "I"+rowStr, centerStyle)
|
|
// J: Netto ist 0
|
|
f.SetCellValue(sheetName, "J"+rowStr, 0.0)
|
|
f.SetCellStyle(sheetName, "J"+rowStr, "J"+rowStr, saldoStyle)
|
|
|
|
default: // Unbekannte Tags oder Tage ohne Eintrag
|
|
f.SetCellValue(sheetName, "J"+rowStr, 0.0)
|
|
f.SetCellStyle(sheetName, "J"+rowStr, "J"+rowStr, saldoStyle)
|
|
}
|
|
|
|
f.SetCellFormula(sheetName, "L"+rowStr, fmt.Sprintf("J%d-K%d", row, row))
|
|
f.SetCellStyle(sheetName, "L"+rowStr, "M"+rowStr, saldoStyle) // Style auf L und M
|
|
|
|
if i == 0 { // Erste Datenzeile
|
|
f.SetCellFormula(sheetName, "N"+rowStr, fmt.Sprintf("L%d", row))
|
|
} else {
|
|
prevSaldoTotalCell := fmt.Sprintf("N%d", row-1)
|
|
f.SetCellFormula(sheetName, "N"+rowStr, fmt.Sprintf("%s+L%d", prevSaldoTotalCell, row))
|
|
}
|
|
f.SetCellStyle(sheetName, "N"+rowStr, "O"+rowStr, saldoStyle) // Style auf N und O
|
|
}
|
|
|
|
f.SetColWidth(sheetName, "B", "B", 12) // Datum
|
|
f.SetColWidth(sheetName, "C", "C", 5) // Tag
|
|
f.SetColWidth(sheetName, "D", "E", 10) // Status/Zeit von/bis
|
|
f.SetColWidth(sheetName, "F", "F", 2) // Leer
|
|
f.SetColWidth(sheetName, "G", "H", 9) // Dauer brutto
|
|
f.SetColWidth(sheetName, "I", "I", 9) // Pause
|
|
f.SetColWidth(sheetName, "J", "J", 9) // Netto
|
|
f.SetColWidth(sheetName, "K", "K", 9) // Soll
|
|
f.SetColWidth(sheetName, "L", "M", 9) // Saldo Tag
|
|
f.SetColWidth(sheetName, "N", "O", 10) // Saldo Total
|
|
|
|
f.SetActiveSheet(index)
|
|
if err := f.SaveAs(name); err != nil {
|
|
return fmt.Errorf("failed to save excel file as '%s': %w", name, err)
|
|
}
|
|
|
|
return nil
|
|
}
|