Files
Zeitmanagement-Software/storage.py
T
Henrik_Admin e956dcb5af ExportÄnderungen
Grafische Oberfläche Änderungen
Keine txt. Dateien mehr sondern nur noch JSON Dateien
2025-08-18 17:49:14 +02:00

233 lines
8.2 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# -*- 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, [])
"""
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)
"""