477 lines
16 KiB
Python
477 lines
16 KiB
Python
# -*- 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":
|
||
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"))
|
||
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, [])
|
||
""" |