Compare commits

...

4 Commits

3 changed files with 355 additions and 363 deletions
+57 -155
View File
@@ -1,66 +1,7 @@
from tkinter import messagebox, filedialog
from config import DATUM_FORMAT
from openpyxl import Workbook
def exportiere_txt(vorgaenge, berechne_dauer_min):
if not vorgaenge:
messagebox.showinfo("Hinweis", "Keine Daten zum Exportieren.")
return
dateipfad = filedialog.asksaveasfilename(
defaultextension=".txt",
filetypes=[("Textdateien", "*.txt"), ("Alle Dateien", "*.*")],
title="Als TXT speichern…"
)
if not dateipfad:
return
# Sortierung: Maschine, Bearb.-Nr., Start
def sort_key(v):
return (v.get("nummer", ""), v.get("bearbeitungsnummer", ""), v.get("start"))
sortierte_vorgaenge = sorted(vorgaenge, key=sort_key)
# Summen pro (Maschine, Bearb.-Nr.)
summen = {} # {(nummer, bearb): minuten}
try:
with open(dateipfad, "w", encoding="utf-8", newline="\n") as f:
# Kopfzeile
f.write("Maschine | Bearb.-Nr. | Start | Stopp | Dauer (Min) | Kommentar\n")
for v in sortierte_vorgaenge:
nummer = v.get("nummer", "")
bearb = v.get("bearbeitungsnummer", "") or ""
start = v.get("start")
stopp = v.get("stopp")
start_s = start.strftime(DATUM_FORMAT) if start else ""
if stopp:
stopp_s = stopp.strftime(DATUM_FORMAT)
dauer = berechne_dauer_min(start, stopp)
dauer_s = f"{dauer}"
# summieren pro (Maschine, Bearb.-Nr.)
key = (nummer, bearb)
summen[key] = summen.get(key, 0) + dauer
else:
stopp_s = "Läuft..."
dauer_s = ""
kommentar = v.get("kommentar", "") or ""
f.write(f"{nummer} | {bearb} | {start_s} | {stopp_s} | {dauer_s} | {kommentar}\n")
# Zusammenfassung
f.write("\n--- Zusammenfassung ---\n")
f.write("Maschine | Bearb.-Nr. | Summe Dauer (Min)\n")
for (nummer, bearb), minuten in sorted(summen.items(), key=lambda kv: (kv[0][0], kv[0][1])):
bearb_txt = bearb if bearb else "(keine)"
f.write(f"{nummer} | {bearb_txt} | {minuten}\n")
messagebox.showinfo("Erfolg", f"Protokoll gespeichert:\n{dateipfad}")
except Exception as e:
messagebox.showerror("Fehler beim Speichern", str(e))
from storage import lade_einstellungen
def exportiere_excel(vorgaenge, berechne_dauer_min):
if not vorgaenge:
@@ -75,9 +16,9 @@ def exportiere_excel(vorgaenge, berechne_dauer_min):
if not dateipfad:
return
# Sortierung: Maschine, Bearb.-Nr., Start
# Sortierung: Bearbeitungsnummer, Startzeit
def sort_key(v):
return (v.get("nummer", ""), v.get("bearbeitungsnummer", ""), v.get("start"))
return (v.get("bearbeitungsnummer", ""), v.get("start"))
sortierte_vorgaenge = sorted(vorgaenge, key=sort_key)
@@ -85,36 +26,68 @@ def exportiere_excel(vorgaenge, berechne_dauer_min):
ws = wb.active
ws.title = "Zeitprotokoll"
# Kopfzeile (inkl. Bearb.-Nr.)
ws.append(["Maschinennummer", "Bearb.-Nr.", "Startzeit", "Stoppzeit", "Dauer (Min)", "Kommentar"])
# Kopfzeile erstellen
ws.append([
"BDE Nr.", # A
"Pers.Nr.", # B
"abw. APG", # C
"Beginn", # D
"Ende", # E
"Zeit in min", # F
"Arbeitsplatzzeit", # G
"Menge gut", # H
"Menge Ausschuss", # I
"Bemerkung", # J
"Erledigt", # K
"Rüsten", # L
])
summen = {} # {(nummer, bearb): minuten}
#Personalnummer aus dem Speicher laden
einstellungen = lade_einstellungen()
PERSONALNUMMER = einstellungen.get("personalnummer", 0)
for v in sortierte_vorgaenge:
nummer = v.get("nummer", "")
bearb = v.get("bearbeitungsnummer", "") or ""
bde_nr = v.get("bearbeitungsnummer", "") or ""
start = v.get("start")
stopp = v.get("stopp")
start_s = start.strftime(DATUM_FORMAT) if start else ""
stopp_s = stopp.strftime(DATUM_FORMAT) if stopp else "Läuft..."
dauer = berechne_dauer_min(start, stopp) if (start and stopp) else ""
kommentar = v.get("kommentar", "") or ""
ws.append([nummer, bearb, start_s, stopp_s, dauer, kommentar])
#start_s = start.strftime(DATUM_FORMAT) if start else ""
#stopp_s = stopp.strftime(DATUM_FORMAT) if stopp else ""
start_s = start if start else None
stopp_s = stopp if stopp else None
# Wenn Start und Stop vorhanden -> Dauer berechnen
if start and stopp:
key = (nummer, bearb)
summen[key] = summen.get(key, 0) + dauer
dauer = berechne_dauer_min(start, stopp)
else:
dauer = ""
# Leerzeile + Zusammenfassung (mit Bearb.-Nr.)
ws.append([])
ws.append(["--- Zusammenfassung ---"])
ws.append(["Maschinennummer", "Bearb.-Nr.", "Summe Dauer (Min)"])
for (nummer, bearb), minuten in sorted(summen.items(), key=lambda kv: (kv[0][0], kv[0][1])):
ws.append([nummer, bearb if bearb else "(keine)", minuten])
#Beliebiger Text, welcher darauf aufmerksam macht, das diese Zeit per Import nachgetragen wurde
Bemerkung = "Die Zeit wurde per Excel import eingetragen"
#Restlichen Zeilen mit Daten füllen!
ws.append([
bde_nr, # BDE Nr.
PERSONALNUMMER, # Pers.Nr.
"", # C (Arbeitsplatz Nummer)
start_s, # Beginn
stopp_s, # Ende
dauer, # Zeit in min
"", # G (leer)
"", # H
"", # I
Bemerkung, # J
"F", # Erledigt immer FALSE
"", # L
])
# einfache Auto-Breiten
#Datums Format anpassen
if start:
ws[f"D{ws.max_row}"].number_format = "DD.MM.YYYY HH:MM:SS"
if stopp:
ws[f"D{ws.max_row}"].number_format = "DD.MM.YYYY HH:MM:SS"
# Die Breiten automatisch an den Inhalt anpassen
for col in ws.columns:
max_len = 0
col_letter = col[0].column_letter
@@ -124,82 +97,11 @@ def exportiere_excel(vorgaenge, berechne_dauer_min):
if l > max_len:
max_len = l
ws.column_dimensions[col_letter].width = min(max_len + 2, 50)
#Schaut ob die Excel Tabelle erfolgreich gespeichert werden konnte oder es abbricht
try:
wb.save(dateipfad)
messagebox.showinfo("Erfolg", f"Excel-Datei gespeichert:\n{dateipfad}")
except Exception as e:
messagebox.showerror("Fehler", f"Konnte Excel-Datei nicht speichern:\n{e}")
"""from tkinter import messagebox, filedialog
from config import DATUM_FORMAT
from openpyxl import Workbook
def exportiere_txt(vorgaenge, berechne_dauer_min):
if not vorgaenge:
messagebox.showinfo("Hinweis", "Keine Daten zum Exportieren.")
return
dateipfad = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Textdateien", "*.txt")])
if not dateipfad:
return
sortierte_vorgaenge = sorted(vorgaenge, key=lambda v: v["nummer"])
maschinen_dauer = {}
try:
with open(dateipfad, "w", encoding="utf-8") as f:
for v in sortierte_vorgaenge:
start = v["start"].strftime(DATUM_FORMAT)
if v["stopp"]:
stopp = v["stopp"].strftime(DATUM_FORMAT)
dauer = berechne_dauer_min(v["start"], v["stopp"])
dauer_str = f" | Dauer: {dauer} Min"
maschinen_dauer[v["nummer"]] = maschinen_dauer.get(v["nummer"], 0) + dauer
else:
stopp = "Läuft..."
dauer_str = ""
kommentar = f" | Kommentar: {v['kommentar']}" if v["kommentar"] else ""
f.write(f"Maschine {v['nummer']} | Start: {start} | Stopp: {stopp}{dauer_str}{kommentar}\n")
f.write("\n--- Zusammenfassung ---\n")
for nummer in sorted(maschinen_dauer.keys()):
f.write(f"Maschine {nummer}: {maschinen_dauer[nummer]} Min\n")
messagebox.showinfo("Erfolg", f"Protokoll gespeichert:\n{dateipfad}")
except Exception as e:
messagebox.showerror("Fehler beim Speichern", str(e))
def exportiere_excel(vorgaenge, berechne_dauer_min):
if not vorgaenge:
messagebox.showinfo("Hinweis", "Keine Daten zum Exportieren.")
return
dateipfad = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel-Dateien", "*.xlsx")])
if not dateipfad:
return
sortierte_vorgaenge = sorted(vorgaenge, key=lambda v: v["nummer"])
wb = Workbook()
ws = wb.active
ws.title = "Zeitprotokoll"
ws.append(["Maschinennummer", "Startzeit", "Stoppzeit", "Dauer (Min)", "Kommentar"])
maschinen_dauer = {}
for v in sortierte_vorgaenge:
nummer = v["nummer"]
start = v["start"].strftime(DATUM_FORMAT)
stopp = v["stopp"].strftime(DATUM_FORMAT) if v["stopp"] else "Läuft..."
dauer = berechne_dauer_min(v["start"], v["stopp"]) if v["stopp"] else ""
kommentar = v["kommentar"]
ws.append([nummer, start, stopp, dauer, kommentar])
if v["stopp"]:
maschinen_dauer[nummer] = maschinen_dauer.get(nummer, 0) + dauer
ws.append([])
ws.append(["--- Zusammenfassung ---"])
for nummer in sorted(maschinen_dauer.keys()):
ws.append([f"Maschine {nummer}", f"{maschinen_dauer[nummer]} Min"])
try:
wb.save(dateipfad)
messagebox.showinfo("Erfolg", f"Excel-Datei gespeichert:\n{dateipfad}")
except Exception as e:
messagebox.showerror("Fehler", f"Konnte Excel-Datei nicht speichern:\n{e}")"""
+41 -11
View File
@@ -4,12 +4,14 @@ import tkinter.ttk as ttk
from tkinter import messagebox, simpledialog
from datetime import datetime
from PIL import Image, ImageTk
from storage import lade_daten, speichere_daten, reset_daten
from export import exportiere_txt, exportiere_excel
from storage import lade_daten, speichere_daten, reset_daten, lade_einstellungen, speichere_einstellungen
from export import exportiere_excel
from integra_lookup import finde_integra_nummern
from config import LOGO_PATH, DATUM_FORMAT
import config
#Before from export import exportiere_txt, exportiere_excel
class ZeitErfassungApp:
# ---------------------- Optionen / Einstellungen ----------------------
@@ -234,15 +236,6 @@ class ZeitErfassungApp:
wrap3.pack(side="left", padx=2, pady=2)
ttk.Button(wrap3, text="Alles zurücksetzen", command=self.reset, style="Danger.TButton").pack()
# Export TXT
wrap4 = tk.Frame(actions, highlightthickness=3, highlightbackground="black", bd=0)
wrap4.pack(side="right", padx=2, pady=2)
ttk.Button(
wrap4,
text="Export TXT",
command=lambda: self._with_busy(lambda: exportiere_txt(self.vorgaenge, self.berechne_dauer_min), toast="TXT exportiert")
).pack()
# Export Excel
wrap5 = tk.Frame(actions, highlightthickness=3, highlightbackground="black", bd=0)
wrap5.pack(side="right", padx=2, pady=2)
@@ -263,6 +256,7 @@ class ZeitErfassungApp:
optionen_menu.add_command(label="Bearbeitungs-Excel festlegen…", command=self._set_excel_path)
optionen_menu.add_command(label="Ausgewählten Eintrag bearbeiten…", command=self._open_edit_dialog)
optionen_menu.add_command(label="Personalnummer festlegen",command=self.optionen_dialog) #hier kommt der Befehl hin, wo man die Personalnummer eingeben kann!
menubar.add_cascade(label="Optionen", menu=optionen_menu)
# Bearbeiten
@@ -674,3 +668,39 @@ class ZeitErfassungApp:
dlg.geometry(f"+{rx + (rw - dw)//2}+{ry + (rh - dh)//2}")
#---------------------------------Personalnummer eingeben--------------------
def optionen_dialog(self):
einstellungen = lade_einstellungen()
win = tk.Toplevel(self.root)
win.title("Optionen")
win.geometry("350x220")
win.resizable(False, False)
frm = ttk.Frame(win, padding=10)
frm.pack(fill="both", expand=True)
# --- Personalnummer (NEU) ---
ttk.Label(frm, text="Personalnummer:").grid(row=0, column=0, sticky="w")
personalnummer_var = tk.StringVar(value=str(einstellungen.get("personalnummer", 56)))
ttk.Entry(frm, textvariable=personalnummer_var, width=10).grid(row=0, column=1, sticky="w")
# Weitere Optionen bleiben wie sie sind…
def speichern():
# Validate Personalnummer
try:
pn = int(personalnummer_var.get())
except:
pn = 56
einstellungen["personalnummer"] = pn
speichere_einstellungen(einstellungen)
win.destroy()
ttk.Button(frm, text="Speichern", command=speichern).grid(row=99, column=0, pady=15)
ttk.Button(frm, text="Abbrechen", command=win.destroy).grid(row=99, column=1, pady=15)
+257 -197
View File
@@ -23,6 +23,258 @@ APP_NAME = "ZeiterfassungMERZ"
def _user_config_base() -> Path:
"""Rückgabe eines benutzerschreibbaren Basisordners."""
if os.name == "nt":
base = Path(os.getenv("APPDATA", Path.home() / "AppData" / "Roaming"))
elif sys.platform == "darwin":
base = Path.home() / "Library" / "Application Support"
else:
base = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
return base
CONFIG_DIR = _user_config_base() / APP_NAME
DATA_JSON: Path = CONFIG_DIR / "vorgaenge.json"
EINSTELLUNGEN_JSON: Path = CONFIG_DIR / "einstellungen.json" # <-- NEU
# Alt-Orte (für Migration)
LEGACY_JSON_NEAR_APP = (APP_DIR / "config" / "vorgaenge.json")
LEGACY_TXT_NEAR_APP = (APP_DIR / "vorgaenge.txt")
BUNDLED_DEFAULT_JSON = (MEIPASS / "config" / "vorgaenge.json")
CONFIG_DIR.mkdir(parents=True, exist_ok=True)
# ---------------- Datum/Zeit ----------------
ISO = "%Y-%m-%dT%H:%M:%S.%f"
def _dt_to_str(dt: Optional[datetime]) -> Optional[str]:
return dt.strftime(ISO) if dt else None
def _str_to_dt(s: Optional[str]) -> Optional[datetime]:
if not s:
return None
try:
return datetime.strptime(s, ISO)
except Exception:
try:
return datetime.fromisoformat(s)
except Exception:
return None
# ---------------- robustes Lesen ----------------
def _read_text_robust(path: Path) -> Tuple[str, str]:
raw = path.read_bytes()
for enc in ("utf-8", "utf-8-sig", "cp1252", "latin-1"):
try:
return raw.decode(enc), enc
except UnicodeDecodeError:
continue
return raw.decode("latin-1", errors="replace"), "latin-1"
# ---------------- Migration ----------------
def _parse_legacy_txt_lines(text: str) -> List[Dict[str, Any]]:
out: List[Dict[str, Any]] = []
for line in text.splitlines():
line = line.strip()
if not line:
continue
rec: Optional[Dict[str, Any]] = None
if line.startswith("{") and line.endswith("}"):
try:
obj = json.loads(line)
rec = {
"nummer": obj.get("nummer", "") or "",
"bearbeitungsnummer": obj.get("bearbeitungsnummer", "") or "",
"start": _str_to_dt(obj.get("start")),
"stopp": _str_to_dt(obj.get("stopp")),
"kommentar": obj.get("kommentar", "") or "",
}
except Exception:
rec = None
if rec is None:
parts = [p.strip() for p in line.split("|")]
if len(parts) >= 1:
nummer = parts[0]
start = None
stopp = None
kommentar = ""
bearb = ""
for p in parts[1:]:
dt = _str_to_dt(p)
if dt and not start:
start = dt
continue
if dt and start and not stopp:
stopp = dt
continue
if p.lower().endswith("min"):
continue
kommentar = (kommentar + " " + p).strip()
if kommentar:
m = re.match(r"^\s*([A-Za-z0-9._\\-\\/]+)\s*:\\s*(.*)$", kommentar)
if m:
bearb = m.group(1)
kommentar = m.group(2).strip()
rec = {
"nummer": nummer or "",
"bearbeitungsnummer": bearb or "",
"start": start,
"stopp": stopp,
"kommentar": kommentar or "",
}
if rec:
rec.setdefault("nummer", "")
rec.setdefault("bearbeitungsnummer", "")
rec.setdefault("kommentar", "")
out.append(rec)
return out
def _migrate_if_needed() -> None:
if DATA_JSON.exists():
return
if LEGACY_JSON_NEAR_APP.exists():
try:
shutil.copyfile(LEGACY_JSON_NEAR_APP, DATA_JSON)
return
except Exception:
pass
if LEGACY_TXT_NEAR_APP.exists():
try:
text, _enc = _read_text_robust(LEGACY_TXT_NEAR_APP)
records = _parse_legacy_txt_lines(text)
_save_json_list(DATA_JSON, records)
return
except Exception:
pass
if BUNDLED_DEFAULT_JSON.exists():
try:
shutil.copyfile(BUNDLED_DEFAULT_JSON, DATA_JSON)
return
except Exception:
pass
_save_json_list(DATA_JSON, [])
# ---------------- JSON I/O ----------------
def _load_json_list(path: Path) -> List[Dict[str, Any]]:
if not path.exists():
return []
text, _enc = _read_text_robust(path)
try:
data = json.loads(text)
if not isinstance(data, list):
return []
except Exception:
return []
for v in data:
if isinstance(v, dict):
v["start"] = _str_to_dt(v.get("start"))
v["stopp"] = _str_to_dt(v.get("stopp"))
v.setdefault("nummer", "")
v.setdefault("bearbeitungsnummer", "")
v.setdefault("kommentar", "")
return data
def _save_json_list(path: Path, records: List[Dict[str, Any]]) -> None:
serializable: List[Dict[str, Any]] = []
for v in records:
serializable.append({
"nummer": v.get("nummer", "") or "",
"bearbeitungsnummer": v.get("bearbeitungsnummer", "") or "",
"start": _dt_to_str(v.get("start")),
"stopp": _dt_to_str(v.get("stopp")),
"kommentar": v.get("kommentar", "") or "",
})
path.parent.mkdir(parents=True, exist_ok=True)
tmp = path.with_name(path.name + ".tmp")
tmp.write_text(json.dumps(serializable, ensure_ascii=False, indent=2) + "\n",
encoding="utf-8", newline="\n")
tmp.replace(path)
# ---------------- Öffentliche API: Vorgänge ----------------
def lade_daten() -> List[Dict[str, Any]]:
_migrate_if_needed()
return _load_json_list(DATA_JSON)
def speichere_daten(vorgaenge: List[Dict[str, Any]]) -> None:
_save_json_list(DATA_JSON, vorgaenge)
def reset_daten() -> None:
_save_json_list(DATA_JSON, [])
# ---------------- Öffentliche API: Einstellungen (NEU) ----------------
DEFAULT_EINSTELLUNGEN = {
"personalnummer": 56 # <-- hier steht dein Standardwert
}
def lade_einstellungen() -> Dict[str, Any]:
"""Lädt Einstellungen wie Personalnummer aus eigener JSON-Datei."""
if not EINSTELLUNGEN_JSON.exists():
return DEFAULT_EINSTELLUNGEN.copy()
try:
text, _enc = _read_text_robust(EINSTELLUNGEN_JSON)
daten = json.loads(text)
except Exception:
return DEFAULT_EINSTELLUNGEN.copy()
# fehlende Werte ergänzen
for k, v in DEFAULT_EINSTELLUNGEN.items():
if k not in daten:
daten[k] = v
return daten
def speichere_einstellungen(einstellungen: Dict[str, Any]) -> None:
"""Persistiert Einstellungen in einstellungen.json."""
try:
EINSTELLUNGEN_JSON.write_text(
json.dumps(einstellungen, indent=2, ensure_ascii=False),
encoding="utf-8"
)
except Exception as e:
print("Fehler beim Speichern der Einstellungen:", e)
#Old Version
"""
# -*- coding: utf-8 -*-
# storage.py – persistente JSON-Ablage in einem benutzerschreibbaren Ordner
# Erkennt PyInstaller-EXE (frozen), migriert Altdateien, robust gegen Encoding-Probleme.
from __future__ import annotations
import json
import os
import re
import sys
import shutil
from datetime import datetime
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple
# ---------------- Pfade & Umgebungen ----------------
SCRIPT_DIR = Path(__file__).resolve().parent
IS_FROZEN = getattr(sys, "frozen", False)
APP_DIR = Path(sys.executable).parent if IS_FROZEN else SCRIPT_DIR
MEIPASS = Path(getattr(sys, "_MEIPASS", APP_DIR))
APP_NAME = "ZeiterfassungMERZ"
def _user_config_base() -> Path:
#Rückgabe eines benutzerschreibbaren Basisordners.
if os.name == "nt":
# Windows: %APPDATA%
base = Path(os.getenv("APPDATA", Path.home() / "AppData" / "Roaming"))
@@ -76,7 +328,7 @@ def _read_text_robust(path: Path) -> Tuple[str, str]:
# ---------------- Migration ----------------
def _parse_legacy_txt_lines(text: str) -> List[Dict[str, Any]]:
"""Pipe-Format oder JSON-Zeilen in Records wandeln."""
#Pipe-Format oder JSON-Zeilen in Records wandeln.
out: List[Dict[str, Any]] = []
for line in text.splitlines():
line = line.strip()
@@ -138,7 +390,7 @@ def _parse_legacy_txt_lines(text: str) -> List[Dict[str, Any]]:
return out
def _migrate_if_needed() -> None:
"""Einmalige Migration in den benutzerschreibbaren Ordner."""
#Einmalige Migration in den benutzerschreibbaren Ordner.
if DATA_JSON.exists():
return # schon migriert/angelegt
@@ -211,207 +463,15 @@ def _save_json_list(path: Path, records: List[Dict[str, Any]]) -> None:
# ---------------- Öffentliche API ----------------
def lade_daten() -> List[Dict[str, Any]]:
"""Lädt Vorgänge aus dem benutzerschreibbaren JSON-Pfad; migriert beim ersten Start."""
#Lädt Vorgänge aus dem benutzerschreibbaren JSON-Pfad; migriert beim ersten Start.
_migrate_if_needed()
return _load_json_list(DATA_JSON)
def speichere_daten(vorgaenge: List[Dict[str, Any]]) -> None:
"""Persistiert Vorgänge im benutzerschreibbaren JSON-Pfad."""
#Persistiert Vorgänge im benutzerschreibbaren JSON-Pfad.
_save_json_list(DATA_JSON, vorgaenge)
def reset_daten() -> None:
"""Setzt die JSON-Datei auf leere Liste."""
_save_json_list(DATA_JSON, [])
"""
# -*- coding: utf-8 -*-
# storage.py – speichert/liest alle Vorgänge in einer JSON-Datei unter ./config/vorgaenge.json
# Migriert optional aus ./vorgaenge.txt (Pipe-Format oder JSON-Lines)
from __future__ import annotations
import json
import re
from datetime import datetime
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple
# ---- Pfade ---------------------------------------------------------------
SCRIPT_DIR = Path(__file__).resolve().parent
CONFIG_DIR = SCRIPT_DIR / "config"
DATA_JSON: Path = CONFIG_DIR / "vorgaenge.json"
LEGACY_TXT: Path = SCRIPT_DIR / "vorgaenge.txt" # alte Datei ggf. neben den Skripten
# Zielordner sicherstellen (bevor wir irgendwas speichern)
CONFIG_DIR.mkdir(parents=True, exist_ok=True)
# ---- Datum/Zeiten --------------------------------------------------------
ISO = "%Y-%m-%dT%H:%M:%S.%f"
def _dt_to_str(dt: Optional[datetime]) -> Optional[str]:
if not dt:
return None
return dt.strftime(ISO)
def _str_to_dt(s: Optional[str]) -> Optional[datetime]:
if not s:
return None
try:
return datetime.strptime(s, ISO)
except Exception:
try:
return datetime.fromisoformat(s)
except Exception:
return None
# ---- robustes Lesen beliebiger Textdateien -------------------------------
def _read_text_robust(path: Path) -> Tuple[str, str]:
#Liest Datei binär und dekodiert robust. Rückgabe: (text, verwendetes_encoding).
raw = path.read_bytes()
for enc in ("utf-8", "utf-8-sig", "cp1252", "latin-1"):
try:
return raw.decode(enc), enc
except UnicodeDecodeError:
continue
return raw.decode("latin-1", errors="replace"), "latin-1"
# ---- Migration: vogaenge.txt -> JSON ------------------------------------
def _migrate_legacy_txt() -> List[Dict[str, Any]]:
#Liest alte 'vorgaenge.txt' (Pipe-Format oder JSON-Lines) in Records um.
if not LEGACY_TXT.exists():
return []
text, _enc = _read_text_robust(LEGACY_TXT)
out: List[Dict[str, Any]] = []
for line in text.splitlines():
line = line.strip()
if not line:
continue
rec: Optional[Dict[str, Any]] = None
# 1) JSON-Line?
if line.startswith("{") and line.endswith("}"):
try:
obj = json.loads(line)
rec = {
"nummer": obj.get("nummer", "") or "",
"bearbeitungsnummer": obj.get("bearbeitungsnummer", "") or "",
"start": _str_to_dt(obj.get("start")),
"stopp": _str_to_dt(obj.get("stopp")),
"kommentar": obj.get("kommentar", "") or "",
}
except Exception:
rec = None
# 2) Pipe-Format: nummer | ... | ...
if rec is None:
parts = [p.strip() for p in line.split("|")]
if len(parts) >= 1:
nummer = parts[0]
start = None
stopp = None
kommentar = ""
bearb = ""
for p in parts[1:]:
dt = _str_to_dt(p)
if dt and not start:
start = dt
continue
if dt and start and not stopp:
stopp = dt
continue
if p.lower().endswith("min"):
continue # Dauer ignorieren; wird berechnet
kommentar = (kommentar + " " + p).strip()
# Bearbeitungsnummer evtl. im Kommentar-Präfix: "A-1076: Rest"
if kommentar:
m = re.match(r"^\s*([A-Za-z0-9._\-\/]+)\s*:\s*(.*)$", kommentar)
if m:
bearb = m.group(1)
kommentar = m.group(2).strip()
rec = {
"nummer": nummer or "",
"bearbeitungsnummer": bearb or "",
"start": start,
"stopp": stopp,
"kommentar": kommentar or "",
}
if rec:
rec.setdefault("nummer", "")
rec.setdefault("bearbeitungsnummer", "")
rec.setdefault("kommentar", "")
out.append(rec)
return out
# ---- JSON I/O ------------------------------------------------------------
def _load_json_list(path: Path) -> List[Dict[str, Any]]:
if not path.exists():
return []
text, _enc = _read_text_robust(path)
try:
data = json.loads(text)
if not isinstance(data, list):
return []
except Exception:
return []
# Datumsstrings -> datetime
for v in data:
if isinstance(v, dict):
v["start"] = _str_to_dt(v.get("start"))
v["stopp"] = _str_to_dt(v.get("stopp"))
v.setdefault("nummer", "")
v.setdefault("bearbeitungsnummer", "")
v.setdefault("kommentar", "")
return data
def _save_json_list(path: Path, records: List[Dict[str, Any]]) -> None:
# Datetime -> Strings
serializable: List[Dict[str, Any]] = []
for v in records:
serializable.append({
"nummer": v.get("nummer", "") or "",
"bearbeitungsnummer": v.get("bearbeitungsnummer", "") or "",
"start": _dt_to_str(v.get("start")),
"stopp": _dt_to_str(v.get("stopp")),
"kommentar": v.get("kommentar", "") or "",
})
path.parent.mkdir(parents=True, exist_ok=True) # sicherstellen
tmp = path.with_name(path.name + ".tmp") # korrekt für Path
tmp.write_text(json.dumps(serializable, ensure_ascii=False, indent=2) + "\n",
encoding="utf-8", newline="\n")
tmp.replace(path)
# ---- Öffentliche API -----------------------------------------------------
def lade_daten() -> List[Dict[str, Any]]:
#Lädt alle Vorgänge aus 'config/vorgaenge.json'.
#Existiert die Datei noch nicht, wird (falls vorhanden) aus 'vorgaenge.txt' migriert.
if DATA_JSON.exists():
return _load_json_list(DATA_JSON)
legacy = _migrate_legacy_txt()
if legacy:
_save_json_list(DATA_JSON, legacy)
return legacy
return []
def speichere_daten(vorgaenge: List[Dict[str, Any]]) -> None:
#Persistiert die Liste vollständig als JSON unter 'config/vorgaenge.json'.
_save_json_list(DATA_JSON, vorgaenge)
def reset_daten() -> None:
#Leert die Daten (setzt JSON-Datei auf eine leere Liste).
#Setzt die JSON-Datei auf leere Liste.
_save_json_list(DATA_JSON, [])
"""