Die Dateien werden nicht in der Exe gespeichert sondern in %Appdata wird ein Ordner dafür angelegt

This commit is contained in:
2025-08-21 11:37:21 +02:00
parent a0367f1a6a
commit 04e0bda149
+234 -50
View File
@@ -1,4 +1,230 @@
# -*- coding: utf-8 -*- # -*- 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 # 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) # 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 ------------------------------- # ---- robustes Lesen beliebiger Textdateien -------------------------------
def _read_text_robust(path: Path) -> Tuple[str, str]: 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() raw = path.read_bytes()
for enc in ("utf-8", "utf-8-sig", "cp1252", "latin-1"): for enc in ("utf-8", "utf-8-sig", "cp1252", "latin-1"):
try: try:
@@ -54,7 +280,7 @@ def _read_text_robust(path: Path) -> Tuple[str, str]:
# ---- Migration: vogaenge.txt -> JSON ------------------------------------ # ---- Migration: vogaenge.txt -> JSON ------------------------------------
def _migrate_legacy_txt() -> List[Dict[str, Any]]: 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(): if not LEGACY_TXT.exists():
return [] return []
text, _enc = _read_text_robust(LEGACY_TXT) 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 ----------------------------------------------------- # ---- Öffentliche API -----------------------------------------------------
def lade_daten() -> List[Dict[str, Any]]: def lade_daten() -> List[Dict[str, Any]]:
"""
Lädt alle Vorgänge aus 'config/vorgaenge.json'. #Lädt alle Vorgänge aus 'config/vorgaenge.json'.
Existiert die Datei noch nicht, wird (falls vorhanden) aus 'vorgaenge.txt' migriert. #Existiert die Datei noch nicht, wird (falls vorhanden) aus 'vorgaenge.txt' migriert.
"""
if DATA_JSON.exists(): if DATA_JSON.exists():
return _load_json_list(DATA_JSON) return _load_json_list(DATA_JSON)
@@ -182,52 +408,10 @@ def lade_daten() -> List[Dict[str, Any]]:
return [] return []
def speichere_daten(vorgaenge: List[Dict[str, Any]]) -> None: 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) _save_json_list(DATA_JSON, vorgaenge)
def reset_daten() -> None: 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, []) _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)
""" """