From e3e718d9102d1d54302ac2999a7877b66a0ec228 Mon Sep 17 00:00:00 2001 From: Henrik Rentz Date: Tue, 9 Dec 2025 13:53:47 +0100 Subject: [PATCH] =?UTF-8?q?Personalnummer=20kann=20unter=20Optionen=20ange?= =?UTF-8?q?passt=20werden=20und=20wird=20mit=20in=20das=20Excel=20Dokument?= =?UTF-8?q?=20=C3=BCbernommen.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- export.py | 6 +- gui.py | 49 ++++-- storage.py | 454 ++++++++++++++++++++++++++++++----------------------- 3 files changed, 299 insertions(+), 210 deletions(-) diff --git a/export.py b/export.py index d8a9555..7b154a2 100644 --- a/export.py +++ b/export.py @@ -1,6 +1,7 @@ from tkinter import messagebox, filedialog from config import DATUM_FORMAT from openpyxl import Workbook +from storage import lade_einstellungen def exportiere_excel(vorgaenge, berechne_dauer_min): if not vorgaenge: @@ -37,8 +38,9 @@ def exportiere_excel(vorgaenge, berechne_dauer_min): "Erledigt" # H ]) - #Hier wird die Personalnummer eingetragen, das ganze soll im Programm hinterlegt werden können! - PERSONALNUMMER = 56 + #Personalnummer aus dem Speicher laden + einstellungen = lade_einstellungen() + PERSONALNUMMER = einstellungen.get("personalnummer", 56) for v in sortierte_vorgaenge: bde_nr = v.get("bearbeitungsnummer", "") or "" diff --git a/gui.py b/gui.py index 92a0025..2e1d69d 100644 --- a/gui.py +++ b/gui.py @@ -4,7 +4,7 @@ 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 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 @@ -236,16 +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) @@ -266,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 @@ -677,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) + + + + diff --git a/storage.py b/storage.py index 8fa65a3..3c2a066 100644 --- a/storage.py +++ b/storage.py @@ -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, []) """ \ No newline at end of file