Compare commits

..

6 Commits

4 changed files with 478 additions and 365 deletions
+123 -2
View File
@@ -1,4 +1,124 @@
import os, json # -*- coding: utf-8 -*-
# config.py – zentrale Konfiguration + persistente Settings im Benutzerordner
from __future__ import annotations
import json
import os
import sys
from pathlib import Path
from typing import Any, Dict
# ----------------- App-Metadaten -----------------
APP_NAME = "ZeiterfassungMERZ"
# ----------------- Pfade / Umgebung -----------------
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)) # PyInstaller temp
def _user_config_base() -> Path:
"""Benutzer-schreibbarer Basisordner je OS."""
if os.name == "nt":
return Path(os.getenv("APPDATA", Path.home() / "AppData" / "Roaming"))
elif sys.platform == "darwin":
return Path.home() / "Library" / "Application Support"
else:
return Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
CONFIG_DIR = _user_config_base() / APP_NAME
CONFIG_DIR.mkdir(parents=True, exist_ok=True)
SETTINGS_PATH = CONFIG_DIR / "settings.json"
# ----------------- Defaults -----------------
DEFAULTS: Dict[str, Any] = {
"SERVER_EXCEL": "", # Pfad zur Bearbeitungs-Excel
"DATUM_FORMAT": "%Y-%m-%d %H:%M:%S",# Anzeige-/Eingabeformat in der GUI
"theme": "light", # evtl. zukünftig genutzt
}
# ----------------- Settings I/O -----------------
def _load_settings() -> Dict[str, Any]:
if not SETTINGS_PATH.exists():
_save_settings(DEFAULTS.copy())
return DEFAULTS.copy()
try:
text = SETTINGS_PATH.read_text(encoding="utf-8")
data = json.loads(text)
if not isinstance(data, dict):
return DEFAULTS.copy()
# fehlende Defaults ergänzen
for k, v in DEFAULTS.items():
data.setdefault(k, v)
return data
except Exception:
# Fallback: neu initialisieren
_save_settings(DEFAULTS.copy())
return DEFAULTS.copy()
def _save_settings(data: Dict[str, Any]) -> None:
SETTINGS_PATH.write_text(
json.dumps(data, ensure_ascii=False, indent=2) + "\n",
encoding="utf-8",
newline="\n",
)
def set_option(key: str, value: Any) -> None:
s = _load_settings()
s[key] = value
_save_settings(s)
def get_option(key: str, default: Any = None) -> Any:
s = _load_settings()
return s.get(key, default)
# ----------------- Öffentliche API / Variablen -----------------
# Hinweis: LOGO_PATH wird so aufgelöst, dass es sowohl im Source-Run
# als auch in der PyInstaller-EXE funktioniert.
def _resolve_logo_path() -> str:
# 1) mitgeliefertes Logo in _MEIPASS/config oder _MEIPASS
for p in (MEIPASS / "Merz_Logo.png", MEIPASS / "config" / "Merz_Logo.png"):
if p.exists():
return str(p)
# 2) neben den Skripten (Entwicklungsumgebung)
for p in (SCRIPT_DIR / "Merz_Logo.png", SCRIPT_DIR / "config" / "Merz_Logo.png"):
if p.exists():
return str(p)
# 3) Fallback: leerer String → GUI zeigt einfach kein Bild
return ""
# Load Settings zur Modul-Init
_settings = _load_settings()
# Exponierte Konstanten / Variablen
LOGO_PATH: str = _resolve_logo_path()
DATUM_FORMAT: str = _settings.get("DATUM_FORMAT", DEFAULTS["DATUM_FORMAT"])
SERVER_EXCEL: str = _settings.get("SERVER_EXCEL", DEFAULTS["SERVER_EXCEL"])
def set_server_excel(path: str) -> str:
"""
Setzt den Pfad zur Bearbeitungs-Excel (normalisiert), speichert ihn
in settings.json und aktualisiert die Modulvariable SERVER_EXCEL.
"""
global SERVER_EXCEL
norm = os.path.abspath(os.path.expanduser(path)) if path else ""
set_option("SERVER_EXCEL", norm)
SERVER_EXCEL = norm
return SERVER_EXCEL
def set_datum_format(fmt: str) -> str:
"""
Optional: DATUM_FORMAT zur Laufzeit anpassen (z. B. '%d.%m.%Y %H:%M').
"""
global DATUM_FORMAT
DATUM_FORMAT = fmt
set_option("DATUM_FORMAT", fmt)
return DATUM_FORMAT
"""import os, json
from pathlib import Path from pathlib import Path
# --- Static paths/consts --- # --- Static paths/consts ---
@@ -44,7 +164,7 @@ _SETTINGS = load_settings()
SERVER_EXCEL = _SETTINGS_SERVER_EXCEL = _SETTINGS.get("server_excel", "") # will be normalized below SERVER_EXCEL = _SETTINGS_SERVER_EXCEL = _SETTINGS.get("server_excel", "") # will be normalized below
def set_server_excel(path: str): def set_server_excel(path: str):
"""Setzt den Pfad zur Bearbeitungs-Excel, speichert ihn in settings.json und aktualisiert SERVER_EXCEL.""" #Setzt den Pfad zur Bearbeitungs-Excel, speichert ihn in settings.json und aktualisiert SERVER_EXCEL.
global SERVER_EXCEL, _SETTINGS global SERVER_EXCEL, _SETTINGS
# Normalisieren (absoluter Pfad) # Normalisieren (absoluter Pfad)
norm = os.path.abspath(os.path.expanduser(path)) if path else "" norm = os.path.abspath(os.path.expanduser(path)) if path else ""
@@ -56,3 +176,4 @@ def set_server_excel(path: str):
# Beim Import sicherstellen, dass SERVER_EXCEL normalisiert ist # Beim Import sicherstellen, dass SERVER_EXCEL normalisiert ist
if SERVER_EXCEL: if SERVER_EXCEL:
SERVER_EXCEL = set_server_excel(SERVER_EXCEL) SERVER_EXCEL = set_server_excel(SERVER_EXCEL)
"""
+57 -155
View File
@@ -1,66 +1,7 @@
from tkinter import messagebox, filedialog from tkinter import messagebox, filedialog
from config import DATUM_FORMAT from config import DATUM_FORMAT
from openpyxl import Workbook from openpyxl import Workbook
from storage import lade_einstellungen
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))
def exportiere_excel(vorgaenge, berechne_dauer_min): def exportiere_excel(vorgaenge, berechne_dauer_min):
if not vorgaenge: if not vorgaenge:
@@ -75,9 +16,9 @@ def exportiere_excel(vorgaenge, berechne_dauer_min):
if not dateipfad: if not dateipfad:
return return
# Sortierung: Maschine, Bearb.-Nr., Start # Sortierung: Bearbeitungsnummer, Startzeit
def sort_key(v): 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) sortierte_vorgaenge = sorted(vorgaenge, key=sort_key)
@@ -85,36 +26,68 @@ def exportiere_excel(vorgaenge, berechne_dauer_min):
ws = wb.active ws = wb.active
ws.title = "Zeitprotokoll" ws.title = "Zeitprotokoll"
# Kopfzeile (inkl. Bearb.-Nr.) # Kopfzeile erstellen
ws.append(["Maschinennummer", "Bearb.-Nr.", "Startzeit", "Stoppzeit", "Dauer (Min)", "Kommentar"]) 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: for v in sortierte_vorgaenge:
nummer = v.get("nummer", "") bde_nr = v.get("bearbeitungsnummer", "") or ""
bearb = v.get("bearbeitungsnummer", "") or ""
start = v.get("start") start = v.get("start")
stopp = v.get("stopp") stopp = v.get("stopp")
start_s = start.strftime(DATUM_FORMAT) if start else "" #start_s = start.strftime(DATUM_FORMAT) if start else ""
stopp_s = stopp.strftime(DATUM_FORMAT) if stopp else "Läuft..." #stopp_s = stopp.strftime(DATUM_FORMAT) if stopp else ""
dauer = berechne_dauer_min(start, stopp) if (start and stopp) else "" start_s = start if start else None
kommentar = v.get("kommentar", "") or "" stopp_s = stopp if stopp else None
ws.append([nummer, bearb, start_s, stopp_s, dauer, kommentar])
# Wenn Start und Stop vorhanden -> Dauer berechnen
if start and stopp: if start and stopp:
key = (nummer, bearb) dauer = berechne_dauer_min(start, stopp)
summen[key] = summen.get(key, 0) + dauer else:
dauer = ""
# Leerzeile + Zusammenfassung (mit Bearb.-Nr.) #Beliebiger Text, welcher darauf aufmerksam macht, das diese Zeit per Import nachgetragen wurde
ws.append([]) Bemerkung = "Die Zeit wurde per Excel import eingetragen"
ws.append(["--- Zusammenfassung ---"])
ws.append(["Maschinennummer", "Bearb.-Nr.", "Summe Dauer (Min)"]) #Restlichen Zeilen mit Daten füllen!
for (nummer, bearb), minuten in sorted(summen.items(), key=lambda kv: (kv[0][0], kv[0][1])): ws.append([
ws.append([nummer, bearb if bearb else "(keine)", minuten]) 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: for col in ws.columns:
max_len = 0 max_len = 0
col_letter = col[0].column_letter col_letter = col[0].column_letter
@@ -124,82 +97,11 @@ def exportiere_excel(vorgaenge, berechne_dauer_min):
if l > max_len: if l > max_len:
max_len = l max_len = l
ws.column_dimensions[col_letter].width = min(max_len + 2, 50) ws.column_dimensions[col_letter].width = min(max_len + 2, 50)
#Schaut ob die Excel Tabelle erfolgreich gespeichert werden konnte oder es abbricht
try: try:
wb.save(dateipfad) wb.save(dateipfad)
messagebox.showinfo("Erfolg", f"Excel-Datei gespeichert:\n{dateipfad}") messagebox.showinfo("Erfolg", f"Excel-Datei gespeichert:\n{dateipfad}")
except Exception as e: except Exception as e:
messagebox.showerror("Fehler", f"Konnte Excel-Datei nicht speichern:\n{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 tkinter import messagebox, simpledialog
from datetime import datetime from datetime import datetime
from PIL import Image, ImageTk from PIL import Image, ImageTk
from storage import lade_daten, speichere_daten, reset_daten from storage import lade_daten, speichere_daten, reset_daten, lade_einstellungen, speichere_einstellungen
from export import exportiere_txt, exportiere_excel from export import exportiere_excel
from integra_lookup import finde_integra_nummern from integra_lookup import finde_integra_nummern
from config import LOGO_PATH, DATUM_FORMAT from config import LOGO_PATH, DATUM_FORMAT
import config import config
#Before from export import exportiere_txt, exportiere_excel
class ZeitErfassungApp: class ZeitErfassungApp:
# ---------------------- Optionen / Einstellungen ---------------------- # ---------------------- Optionen / Einstellungen ----------------------
@@ -234,15 +236,6 @@ class ZeitErfassungApp:
wrap3.pack(side="left", padx=2, pady=2) wrap3.pack(side="left", padx=2, pady=2)
ttk.Button(wrap3, text="Alles zurücksetzen", command=self.reset, style="Danger.TButton").pack() 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 # Export Excel
wrap5 = tk.Frame(actions, highlightthickness=3, highlightbackground="black", bd=0) wrap5 = tk.Frame(actions, highlightthickness=3, highlightbackground="black", bd=0)
wrap5.pack(side="right", padx=2, pady=2) 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="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="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) menubar.add_cascade(label="Optionen", menu=optionen_menu)
# Bearbeiten # Bearbeiten
@@ -674,3 +668,39 @@ class ZeitErfassungApp:
dlg.geometry(f"+{rx + (rw - dw)//2}+{ry + (rh - dh)//2}") 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: def _user_config_base() -> Path:
"""Rückgabe eines benutzerschreibbaren Basisordners.""" """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": if os.name == "nt":
# Windows: %APPDATA% # Windows: %APPDATA%
base = Path(os.getenv("APPDATA", Path.home() / "AppData" / "Roaming")) base = Path(os.getenv("APPDATA", Path.home() / "AppData" / "Roaming"))
@@ -76,7 +328,7 @@ def _read_text_robust(path: Path) -> Tuple[str, str]:
# ---------------- Migration ---------------- # ---------------- Migration ----------------
def _parse_legacy_txt_lines(text: str) -> List[Dict[str, Any]]: 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]] = [] out: List[Dict[str, Any]] = []
for line in text.splitlines(): for line in text.splitlines():
line = line.strip() line = line.strip()
@@ -138,7 +390,7 @@ def _parse_legacy_txt_lines(text: str) -> List[Dict[str, Any]]:
return out return out
def _migrate_if_needed() -> None: def _migrate_if_needed() -> None:
"""Einmalige Migration in den benutzerschreibbaren Ordner.""" #Einmalige Migration in den benutzerschreibbaren Ordner.
if DATA_JSON.exists(): if DATA_JSON.exists():
return # schon migriert/angelegt return # schon migriert/angelegt
@@ -211,207 +463,15 @@ def _save_json_list(path: Path, records: List[Dict[str, Any]]) -> None:
# ---------------- Öffentliche API ---------------- # ---------------- Öffentliche API ----------------
def lade_daten() -> List[Dict[str, Any]]: 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() _migrate_if_needed()
return _load_json_list(DATA_JSON) return _load_json_list(DATA_JSON)
def speichere_daten(vorgaenge: List[Dict[str, Any]]) -> None: 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) _save_json_list(DATA_JSON, vorgaenge)
def reset_daten() -> None: def reset_daten() -> None:
"""Setzt die JSON-Datei auf leere Liste.""" #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).
_save_json_list(DATA_JSON, []) _save_json_list(DATA_JSON, [])
""" """