From 04e0bda14957c52a3a3a73c4b569a9fd78f59338 Mon Sep 17 00:00:00 2001 From: Henrik Rentz Date: Thu, 21 Aug 2025 11:37:21 +0200 Subject: [PATCH] =?UTF-8?q?Die=20Dateien=20werden=20nicht=20in=20der=20Exe?= =?UTF-8?q?=20gespeichert=20sondern=20in=20%Appdata=20wird=20ein=20Ordner?= =?UTF-8?q?=20daf=C3=BCr=20angelegt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- storage.py | 286 +++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 235 insertions(+), 51 deletions(-) diff --git a/storage.py b/storage.py index 6590517..8fa65a3 100644 --- a/storage.py +++ b/storage.py @@ -1,4 +1,230 @@ # -*- 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")) + elif sys.platform == "darwin": + # macOS: ~/Library/Application Support + base = Path.home() / "Library" / "Application Support" + else: + # Linux: XDG_CONFIG_HOME oder ~/.config + 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" + +# 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") # falls als Ressource mitgegeben + +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]]: + """Pipe-Format oder JSON-Zeilen in Records wandeln.""" + out: List[Dict[str, Any]] = [] + for line in text.splitlines(): + line = line.strip() + if not line: + continue + rec: Optional[Dict[str, Any]] = None + + # JSON-Zeile? + 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 + + # Pipe-Format + 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: + """Einmalige Migration in den benutzerschreibbaren Ordner.""" + if DATA_JSON.exists(): + return # schon migriert/angelegt + + # 1) Falls neben EXE/Script bereits eine config/vorgaenge.json liegt → übernehmen + if LEGACY_JSON_NEAR_APP.exists(): + try: + shutil.copyfile(LEGACY_JSON_NEAR_APP, DATA_JSON) + return + except Exception: + pass + + # 2) Falls eine alte vogaenge.txt neben EXE/Script liegt → parsen & speichern + 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 + + # 3) Optional: mitgelieferte Default-JSON aus _MEIPASS (read-only) kopieren + if BUNDLED_DEFAULT_JSON.exists(): + try: + shutil.copyfile(BUNDLED_DEFAULT_JSON, DATA_JSON) + return + except Exception: + pass + + # 4) Sonst: leere Liste anlegen + _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 ---------------- + +def lade_daten() -> List[Dict[str, Any]]: + """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.""" + _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) @@ -42,7 +268,7 @@ def _str_to_dt(s: Optional[str]) -> Optional[datetime]: # ---- 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).""" + #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: @@ -54,7 +280,7 @@ def _read_text_robust(path: Path) -> Tuple[str, str]: # ---- Migration: vogaenge.txt -> JSON ------------------------------------ def _migrate_legacy_txt() -> List[Dict[str, Any]]: - """Liest alte 'vorgaenge.txt' (Pipe-Format oder JSON-Lines) in Records um.""" + #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) @@ -168,10 +394,10 @@ def _save_json_list(path: Path, records: List[Dict[str, Any]]) -> None: # ---- Ö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. - """ + + #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) @@ -182,52 +408,10 @@ def lade_daten() -> List[Dict[str, Any]]: return [] def speichere_daten(vorgaenge: List[Dict[str, Any]]) -> None: - """Persistiert die Liste vollständig als JSON unter 'config/vorgaenge.json'.""" + #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).""" + #Leert die Daten (setzt JSON-Datei auf eine leere Liste). _save_json_list(DATA_JSON, []) - - -""" -import os -from datetime import datetime -from tkinter import messagebox -from config import DATEN_DATEI, DATUM_FORMAT - -def lade_daten(): - vorgaenge = [] - if not os.path.exists(DATEN_DATEI): - return vorgaenge - try: - with open(DATEN_DATEI, "r", encoding="utf-8") as f: - for zeile in f: - teile = zeile.strip().split("|") - if len(teile) >= 3: - nummer, start_str, stopp_str = teile[:3] - kommentar = teile[3] if len(teile) > 3 else "" - start_dt = datetime.strptime(start_str, DATUM_FORMAT) - stopp_dt = datetime.strptime(stopp_str, DATUM_FORMAT) if stopp_str else None - vorgaenge.append({ - "nummer": nummer, - "start": start_dt, - "stopp": stopp_dt, - "kommentar": kommentar - }) - except Exception as e: - messagebox.showerror("Fehler beim Laden", f"Datei konnte nicht gelesen werden:\n{e}") - return vorgaenge - -def speichere_daten(vorgaenge): - with open(DATEN_DATEI, "w", encoding="utf-8") as f: - for v in vorgaenge: - start = v["start"].strftime(DATUM_FORMAT) - stopp = v["stopp"].strftime(DATUM_FORMAT) if v["stopp"] else "" - kommentar = v["kommentar"].replace("\n", " ") - f.write(f"{v['nummer']}|{start}|{stopp}|{kommentar}\n") - -def reset_daten(): - if os.path.exists(DATEN_DATEI): - os.remove(DATEN_DATEI) - """ \ No newline at end of file + """ \ No newline at end of file