ExportÄnderungen

Grafische Oberfläche Änderungen
Keine txt. Dateien mehr sondern nur noch JSON Dateien
This commit is contained in:
2025-08-18 17:49:14 +02:00
parent 64b5814b23
commit e956dcb5af
7 changed files with 457 additions and 411 deletions
+1 -1
View File
@@ -3,12 +3,12 @@ from pathlib import Path
# --- Static paths/consts ---
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
DATEN_DATEI = os.path.join(SCRIPT_DIR, "daten.txt")
LOGO_PATH = os.path.join(SCRIPT_DIR, "Merz_Logo.png")
DATUM_FORMAT = "%Y-%m-%d %H:%M:%S"
# --- Settings storage ---
CONFIG_DIR = Path(SCRIPT_DIR) / "config"
DATEN_DATEI = CONFIG_DIR / "vorgaenge.txt"
CONFIG_PATH = CONFIG_DIR / "settings.json"
DEFAULTS = {
"server_excel": "" # Bearbeitungs-Excel (leer = noch nicht gesetzt)
+16
View File
@@ -0,0 +1,16 @@
[
{
"nummer": "SB18-2T-051",
"bearbeitungsnummer": "A-1078",
"start": "2025-08-18T17:18:35.298192",
"stopp": "2025-08-18T17:18:45.208586",
"kommentar": "Inbetriebnahme"
},
{
"nummer": "SB18-2T-051",
"bearbeitungsnummer": "A-1078",
"start": "2025-08-18T17:29:09.178429",
"stopp": "2025-08-18T17:29:14.318401",
"kommentar": "Test"
}
]
-1
View File
@@ -1 +0,0 @@
SBL50-354|2025-08-18 11:34:57|2025-08-18 11:35:11|A-1076: Test
+136 -1
View File
@@ -2,6 +2,141 @@ from tkinter import messagebox, filedialog
from config import DATUM_FORMAT
from openpyxl import Workbook
def exportiere_txt(vorgaenge, berechne_dauer_min):
if not vorgaenge:
messagebox.showinfo("Hinweis", "Keine Daten zum Exportieren.")
return
dateipfad = filedialog.asksaveasfilename(
defaultextension=".txt",
filetypes=[("Textdateien", "*.txt"), ("Alle Dateien", "*.*")],
title="Als TXT speichern…"
)
if not dateipfad:
return
# Sortierung: Maschine, Bearb.-Nr., Start
def sort_key(v):
return (v.get("nummer", ""), v.get("bearbeitungsnummer", ""), v.get("start"))
sortierte_vorgaenge = sorted(vorgaenge, key=sort_key)
# Summen pro (Maschine, Bearb.-Nr.)
summen = {} # {(nummer, bearb): minuten}
try:
with open(dateipfad, "w", encoding="utf-8", newline="\n") as f:
# Kopfzeile
f.write("Maschine | Bearb.-Nr. | Start | Stopp | Dauer (Min) | Kommentar\n")
for v in sortierte_vorgaenge:
nummer = v.get("nummer", "")
bearb = v.get("bearbeitungsnummer", "") or ""
start = v.get("start")
stopp = v.get("stopp")
start_s = start.strftime(DATUM_FORMAT) if start else ""
if stopp:
stopp_s = stopp.strftime(DATUM_FORMAT)
dauer = berechne_dauer_min(start, stopp)
dauer_s = f"{dauer}"
# summieren pro (Maschine, Bearb.-Nr.)
key = (nummer, bearb)
summen[key] = summen.get(key, 0) + dauer
else:
stopp_s = "Läuft..."
dauer_s = ""
kommentar = v.get("kommentar", "") or ""
f.write(f"{nummer} | {bearb} | {start_s} | {stopp_s} | {dauer_s} | {kommentar}\n")
# Zusammenfassung
f.write("\n--- Zusammenfassung ---\n")
f.write("Maschine | Bearb.-Nr. | Summe Dauer (Min)\n")
for (nummer, bearb), minuten in sorted(summen.items(), key=lambda kv: (kv[0][0], kv[0][1])):
bearb_txt = bearb if bearb else "(keine)"
f.write(f"{nummer} | {bearb_txt} | {minuten}\n")
messagebox.showinfo("Erfolg", f"Protokoll gespeichert:\n{dateipfad}")
except Exception as e:
messagebox.showerror("Fehler beim Speichern", str(e))
def exportiere_excel(vorgaenge, berechne_dauer_min):
if not vorgaenge:
messagebox.showinfo("Hinweis", "Keine Daten zum Exportieren.")
return
dateipfad = filedialog.asksaveasfilename(
defaultextension=".xlsx",
filetypes=[("Excel-Dateien", "*.xlsx"), ("Alle Dateien", "*.*")],
title="Als Excel speichern…"
)
if not dateipfad:
return
# Sortierung: Maschine, Bearb.-Nr., Start
def sort_key(v):
return (v.get("nummer", ""), v.get("bearbeitungsnummer", ""), v.get("start"))
sortierte_vorgaenge = sorted(vorgaenge, key=sort_key)
wb = Workbook()
ws = wb.active
ws.title = "Zeitprotokoll"
# Kopfzeile (inkl. Bearb.-Nr.)
ws.append(["Maschinennummer", "Bearb.-Nr.", "Startzeit", "Stoppzeit", "Dauer (Min)", "Kommentar"])
summen = {} # {(nummer, bearb): minuten}
for v in sortierte_vorgaenge:
nummer = v.get("nummer", "")
bearb = v.get("bearbeitungsnummer", "") or ""
start = v.get("start")
stopp = v.get("stopp")
start_s = start.strftime(DATUM_FORMAT) if start else ""
stopp_s = stopp.strftime(DATUM_FORMAT) if stopp else "Läuft..."
dauer = berechne_dauer_min(start, stopp) if (start and stopp) else ""
kommentar = v.get("kommentar", "") or ""
ws.append([nummer, bearb, start_s, stopp_s, dauer, kommentar])
if start and stopp:
key = (nummer, bearb)
summen[key] = summen.get(key, 0) + dauer
# Leerzeile + Zusammenfassung (mit Bearb.-Nr.)
ws.append([])
ws.append(["--- Zusammenfassung ---"])
ws.append(["Maschinennummer", "Bearb.-Nr.", "Summe Dauer (Min)"])
for (nummer, bearb), minuten in sorted(summen.items(), key=lambda kv: (kv[0][0], kv[0][1])):
ws.append([nummer, bearb if bearb else "(keine)", minuten])
# einfache Auto-Breiten
for col in ws.columns:
max_len = 0
col_letter = col[0].column_letter
for cell in col:
val = cell.value
l = len(str(val)) if val is not None else 0
if l > max_len:
max_len = l
ws.column_dimensions[col_letter].width = min(max_len + 2, 50)
try:
wb.save(dateipfad)
messagebox.showinfo("Erfolg", f"Excel-Datei gespeichert:\n{dateipfad}")
except Exception as e:
messagebox.showerror("Fehler", f"Konnte Excel-Datei nicht speichern:\n{e}")
"""from tkinter import messagebox, filedialog
from config import DATUM_FORMAT
from openpyxl import Workbook
def exportiere_txt(vorgaenge, berechne_dauer_min):
if not vorgaenge:
messagebox.showinfo("Hinweis", "Keine Daten zum Exportieren.")
@@ -67,4 +202,4 @@ def exportiere_excel(vorgaenge, berechne_dauer_min):
wb.save(dateipfad)
messagebox.showinfo("Erfolg", f"Excel-Datei gespeichert:\n{dateipfad}")
except Exception as e:
messagebox.showerror("Fehler", f"Konnte Excel-Datei nicht speichern:\n{e}")
messagebox.showerror("Fehler", f"Konnte Excel-Datei nicht speichern:\n{e}")"""
+11
View File
@@ -0,0 +1,11 @@
# Einmal-Konverter: storage.py aus cp1252/latin1 nach UTF-8 speichern
src = "storage.py"
raw = open(src, "rb").read()
for enc in ("utf-8", "utf-8-sig", "cp1252", "latin-1"):
try:
text = raw.decode(enc)
break
except UnicodeDecodeError:
continue
open(src, "w", encoding="utf-8", newline="\n").write(text)
print("storage.py nach UTF-8 konvertiert.")
+99 -408
View File
@@ -10,7 +10,6 @@ from integra_lookup import finde_integra_nummern
from config import LOGO_PATH, DATUM_FORMAT
import config
class ZeitErfassungApp:
# ---------------------- Optionen / Einstellungen ----------------------
@@ -253,7 +252,6 @@ class ZeitErfassungApp:
command=lambda: self._with_busy(lambda: exportiere_excel(self.vorgaenge, self.berechne_dauer_min), toast="Excel exportiert")
).pack()
# ------------------------------ Menü ---------------------------------
def _build_menu(self):
@@ -294,6 +292,46 @@ class ZeitErfassungApp:
self._toast = tk.Label(self.root, text="", bg="#222222", fg="white",
font=("Segoe UI", 10), padx=10, pady=6)
def _with_busy(self, func, toast: str | None = None):
#Einfache Busy-Anzeige: Cursor auf 'Warte', Funktion ausführen, optional Toast.
try:
# Cursor auf 'busy' setzen
self.root.config(cursor="watch")
self.root.update_idletasks()
func()
if toast:
# Kurze Erfolgsmeldung
try:
from tkinter import messagebox
messagebox.showinfo("Info", toast)
except Exception:
pass
except Exception as e:
# Fehler anzeigen
try:
from tkinter import messagebox
messagebox.showerror("Fehler", str(e))
except Exception:
raise
finally:
# Cursor zurücksetzen
self.root.config(cursor="")
self.root.update_idletasks()
def _append_vorgang(self, maschine: str, bearbeitungsnummer: str = ""):
#Einen Vorgang anlegen, speichern und Liste aktualisieren.
self.vorgaenge.append({
"nummer": maschine,
"bearbeitungsnummer": bearbeitungsnummer or "",
"start": datetime.now(),
"stopp": None,
"kommentar": ""
})
speichere_daten(self.vorgaenge)
self.aktualisiere_liste()
# --------------------------- Aktionen/Logik ---------------------------
def start_vorgang(self):
@@ -304,21 +342,66 @@ class ZeitErfassungApp:
# INTEGRA-Suche
bearb_num, fehler = finde_integra_nummern(nummer)
if fehler:
messagebox.showwarning("INTEGRA-Suche", fehler)
bearbeitungsnummer = "" # keine Bearbeitungsnummer gefunden
else:
bearbeitungsnummer = bearb_num
self.vorgaenge.append({
"nummer": nummer,
"bearbeitungsnummer": bearbeitungsnummer, # 👈 hier eigene Spalte
"start": datetime.now(),
"stopp": None,
"kommentar": "" # leer, wird später vom Benutzer gefüllt
})
speichere_daten(self.vorgaenge)
self.aktualisiere_liste()
# Fall A: Treffer -> Vorgang normal mit Bearbeitungsnummer anlegen
if not fehler:
self._append_vorgang(nummer, bearb_num)
return
# Fall B: Fehler mit Vorschlag: "Meintest du: XYZ?"
if "Meintest du:" in fehler:
vorschlag = fehler.split("Meintest du:")[-1].strip().rstrip("?")
dialog = tk.Toplevel(self.root)
dialog.title("INTEGRA-Suche")
dialog.transient(self.root)
dialog.grab_set()
dialog.resizable(False, False)
# Text
msg = tk.Label(dialog, text=fehler, wraplength=380, justify="left")
msg.pack(padx=16, pady=(16, 10))
# Buttons (mit schwarzer Umrandung wie in der App)
btns = tk.Frame(dialog)
btns.pack(pady=(0, 12))
def on_uebernehmen():
# Vorschlag ins Feld übernehmen und direkt nochmal starten
self.maschinennummer.set(vorschlag)
dialog.destroy()
self.start_vorgang()
def on_ok():
# Trotz Fehler mit ursprünglicher Eingabe starten (ohne Bearbeitungsnummer)
dialog.destroy()
self._append_vorgang(nummer, "")
def on_abort():
# Nichts tun, nicht starten
dialog.destroy()
# Rahmen um die Buttons (3 px) wie bei dir:
w1 = tk.Frame(btns, highlightthickness=0, highlightbackground="black", bd=0); w1.pack(side="left", padx=6)
tk.Button(w1, text="Übernehmen", command=on_uebernehmen, width=12).pack()
w2 = tk.Frame(btns, highlightthickness=0, highlightbackground="black", bd=0); w2.pack(side="left", padx=6)
tk.Button(w2, text="OK", command=on_ok, width=10).pack()
w3 = tk.Frame(btns, highlightthickness=0, highlightbackground="black", bd=0); w3.pack(side="left", padx=6)
tk.Button(w3, text="Abbrechen", command=on_abort, width=12).pack()
# Fenster halbwegs mittig über dem Hauptfenster platzieren
dialog.update_idletasks()
rw, rh = self.root.winfo_width(), self.root.winfo_height()
rx, ry = self.root.winfo_rootx(), self.root.winfo_rooty()
dw, dh = dialog.winfo_width(), dialog.winfo_height()
dialog.geometry(f"+{rx + (rw-dw)//2}+{ry + (rh-dh)//2}")
return
# Fall C: Fehler ohne Vorschlag -> optional Hinweis, kein Start
messagebox.showwarning("INTEGRA-Suche", fehler)
# -> nichts anlegen
def _get_selected_index(self) -> int | None:
@@ -362,8 +445,6 @@ class ZeitErfassungApp:
self.aktualisiere_liste()
messagebox.showinfo("Gelöscht", "Der ausgewählte Vorgang wurde gelöscht.")
def reset(self):
if messagebox.askyesno("Zurücksetzen", "Bist du sicher, dass du alle Daten löschen willst?"):
self.vorgaenge.clear()
@@ -441,393 +522,3 @@ class ZeitErfassungApp:
bg=self.bg_color, fg=self.fg_color, selectcolor="#FFFFFF"
).pack()
ttk.Button(theme_window, text="Anwenden", command=apply_theme).pack(pady=12)
"""import os
import tkinter as tk
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 export import exportiere_txt, exportiere_excel
from integra_lookup import finde_integra_nummern
from config import LOGO_PATH, DATUM_FORMAT
import config
class ZeitErfassungApp:
# ---------------------- Optionen / Einstellungen ----------------------
def _set_excel_path(self):
from tkinter import filedialog
pfad = filedialog.askopenfilename(
title="Bearbeitungs-Excel wählen",
filetypes=[
("Excel", "*.xlsx *.xlsm *.xlsb *.xls"),
("Alle Dateien", "*.*")
],
)
if pfad:
config.set_server_excel(pfad)
messagebox.showinfo("Gespeichert", f"Pfad gespeichert:\n{config.SERVER_EXCEL}")
# --------------------------- Konstruktor ------------------------------
def __init__(self, root: tk.Tk):
self.root = root
self.root.title("Zeiterfassung MERZ")
self.root.geometry("900x560")
# Fenstericon setzen (ICO bevorzugt, PNG geht auf manchen Systemen auch)
try:
icon_path = LOGO_PATH
if icon_path.lower().endswith(".ico"):
self.root.iconbitmap(icon_path)
else:
img = Image.open(icon_path)
icon_img = ImageTk.PhotoImage(img)
self.root.iconphoto(True, icon_img)
self._icon_ref = icon_img
except Exception as e:
print(f"Fenstericon konnte nicht gesetzt werden: {e}")
# Daten
self.vorgaenge = lade_daten()
# Grundfarben (helle Palette)
self.bg_color = "#F5F5F7"
self.fg_color = "#1D1D1F"
self.root.configure(bg=self.bg_color)
# UI aufbauen
self._build_gui()
self._build_menu()
self._create_busy_overlay()
self.aktualisiere_liste()
# ↵ Enter startet den Vorgang
self.root.bind("<Return>", lambda e: self.start_vorgang())
# --------------------------- Apple-Style ------------------------------
def _apply_apple_style(self):
self.bg = "#F5F5F7" # Fensterhintergrund
self.card = "#FFFFFF" # Karten/Flächen
self.border = "#E5E5EA"
self.text = "#1D1D1F"
self.subtext = "#3A3A3C"
self.blue = "#0A84FF" # Akzent
self.blue_hover = "#147CFF"
self.blue_pressed = "#0068DA"
self.neutral_hover = "#F2F2F7"
style = ttk.Style()
style.theme_use("default")
# Globale Schrift
style.configure(".", background=self.bg, foreground=self.text, font=("Segoe UI", 11))
# Karten / Toolbar
style.configure("Card.TFrame", background=self.card, borderwidth=1, relief="solid")
style.configure("Toolbar.TFrame", background=self.bg)
# Labels
style.configure("TLabel", background=self.bg, foreground=self.text, font=("Segoe UI", 11))
style.configure("Title.TLabel", background=self.bg, foreground=self.text, font=("Segoe UI", 16, "bold"))
style.configure("Secondary.TLabel", background=self.bg, foreground=self.subtext)
# Entry
style.configure("TEntry", fieldbackground=self.card, background=self.card, foreground=self.text)
# Neutraler Button
style.configure("TButton", background=self.card, foreground=self.text, padding=(12, 8),
borderwidth=1, relief="flat")
style.map("TButton",
background=[("active", self.neutral_hover)],
relief=[("pressed", "sunken")])
# Primär-Button (sichtbarere States)
style.configure("Accent.TButton", background=self.blue, foreground="#FFFFFF",
padding=(14, 9), borderwidth=0, relief="flat")
style.map("Accent.TButton",
background=[("active", self.blue_hover), ("pressed", self.blue_pressed)])
# Danger-Button (optional nutzbar)
style.configure("Danger.TButton", background="#FF3B30", foreground="white",
padding=(12, 8), borderwidth=0, relief="flat")
style.map("Danger.TButton",
background=[("active", "#FF554D"), ("pressed", "#D92A21")])
# Progressbar
style.configure("Thin.Horizontal.TProgressbar", troughcolor=self.card, background=self.blue)
# ---------------------------- GUI-Aufbau ------------------------------
def _build_gui(self):
self._apply_apple_style()
# Toolbar oben
toolbar = ttk.Frame(self.root, style="Toolbar.TFrame")
toolbar.pack(fill="x", padx=12, pady=(8, 12))
# Logo + Titel
try:
logo_img = Image.open(LOGO_PATH).resize((32, 32), Image.LANCZOS)
self.logo = ImageTk.PhotoImage(logo_img)
ttk.Label(toolbar, image=self.logo, style="TLabel").pack(side="left", padx=(0, 8))
except Exception:
pass
ttk.Label(toolbar, text="Zeiterfassung", style="Title.TLabel").pack(side="left")
ttk.Label(toolbar, text="", style="TLabel").pack(side="left", expand=True) # Spacer
# Hauptkarte
main_card = ttk.Frame(self.root, style="Card.TFrame")
main_card.pack(fill="both", expand=True, padx=12, pady=(0, 12))
# ---------------- Eingabebereich mit schwarzem Rahmen ----------------
input_wrap = tk.Frame(main_card, bg=self.card, highlightthickness=3, highlightbackground="000000")
input_wrap.pack(fill="x", padx=12, pady=(12, 8))
inner = tk.Frame(input_wrap, bg=self.card)
inner.pack(fill="x", padx=10, pady=8)
inner.grid_columnconfigure(0, weight=0)
inner.grid_columnconfigure(1, weight=1)
inner.grid_columnconfigure(2, weight=0)
# Grid: Label | Entry (dehnbar) | Start-Button
inner.grid_columnconfigure(0, weight=0)
inner.grid_columnconfigure(1, weight=1)
inner.grid_columnconfigure(2, weight=0)
self.maschinennummer = tk.StringVar()
ttk.Label(inner, text="Maschinennummer:").grid(row=0, column=0, sticky="w", padx=(0, 10))
self.entry = ttk.Entry(inner, textvariable=self.maschinennummer)
self.entry.grid(row=0, column=1, sticky="ew") # füllt bis rechts
self.entry.focus_set()
self.start_button_inline = ttk.Button(inner, text="Start", command=self.start_vorgang, style="Accent.TButton")
self.start_button_inline.grid(row=0, column=2, sticky="e", padx=(10, 0))
# ---------------- Liste + Scrollbar (auch mit schwarzem Rahmen) ----------------
list_wrap = tk.Frame(main_card, bg=self.card, highlightthickness=3, highlightbackground="000000")
list_wrap.pack(fill="both", expand=True, padx=12, pady=(0, 12))
list_frame = tk.Frame(list_wrap, bg=self.card)
list_frame.pack(fill="both", expand=True, padx=8, pady=8)
scrollbar = ttk.Scrollbar(list_frame, orient="vertical")
scrollbar.pack(side="right", fill="y")
self.listbox = tk.Listbox(
list_frame,
width=100,
font=("Segoe UI", 10),
activestyle="none",
borderwidth=0,
highlightthickness=0,
bg=self.card,
fg=self.text,
selectbackground="#D0E7FF",
selectforeground=self.text
)
self.listbox.pack(side="left", fill="both", expand=True)
self.listbox.config(yscrollcommand=scrollbar.set)
scrollbar.config(command=self.listbox.yview)
# ---------------- Aktionsleiste unten ----------------
actions = ttk.Frame(main_card, style="Toolbar.TFrame")
actions.pack(fill="x", padx=12, pady=(0, 12))
ttk.Button(actions, text="Stop mit Kommentar", command=self.stoppe_auswahl).pack(side="left")
ttk.Button(actions, text="Auswahl löschen", command=self.loesche_auswahl).pack(side="left", padx=(8, 0))
ttk.Button(actions, text="Alles zurücksetzen", command=self.reset, style="Danger.TButton").pack(side="left", padx=(8, 0))
ttk.Button(actions, text="Export TXT",
command=lambda: self._with_busy(lambda: exportiere_txt(self.vorgaenge, self.berechne_dauer_min),
toast="TXT exportiert")).pack(side="right")
ttk.Button(actions, text="Export Excel",
command=lambda: self._with_busy(lambda: exportiere_excel(self.vorgaenge, self.berechne_dauer_min),
toast="Excel exportiert")).pack(side="right", padx=(0, 8))
# ------------------------------ Menü ---------------------------------
def _build_menu(self):
menubar = tk.Menu(self.root)
# Optionen
optionen_menu = tk.Menu(menubar, tearoff=0)
darstellung_menu = tk.Menu(optionen_menu, tearoff=0)
darstellung_menu.add_command(label="Theme wechseln", command=self._open_theme_window)
optionen_menu.add_command(label="Projekt")
optionen_menu.add_command(label="Extras")
optionen_menu.add_command(label="Bearbeitungs-Excel festlegen…", command=self._set_excel_path)
optionen_menu.add_cascade(label="Darstellung", menu=darstellung_menu)
menubar.add_cascade(label="Optionen", menu=optionen_menu)
# Bearbeiten
bearbeiten_menu = tk.Menu(menubar, tearoff=0)
bearbeiten_menu.add_command(label="Bearbeitungstabelle öffnen", command=self.oeffne_excel_datei)
menubar.add_cascade(label="Bearbeiten", menu=bearbeiten_menu)
self.root.config(menu=menubar)
# --------------------------- Busy/Toast UI ----------------------------
def _create_busy_overlay(self):
# halbtransparente Überlagerung (vereinfachte Variante ohne echte Alpha)
self._overlay = tk.Frame(self.root, bg="#000000")
self._overlay.place_forget()
inner = tk.Frame(self._overlay, bg=self.card, highlightthickness=1, highlightbackground=self.border)
inner.place(relx=0.5, rely=0.5, anchor="center")
inner.configure(padx=20, pady=14)
lbl = tk.Label(inner, text="Bitte warten…", bg=self.card, fg=self.text, font=("Segoe UI", 11, "bold"))
lbl.pack(pady=(0, 8))
self._pbar = ttk.Progressbar(inner, mode="indeterminate", length=240, style="Thin.Horizontal.TProgressbar")
self._pbar.pack()
# Toast (kleine Meldung unten rechts)
self._toast = tk.Label(self.root, text="", bg="#222222", fg="white",
font=("Segoe UI", 10), padx=10, pady=6)
# --------------------------- Aktionen/Logik ---------------------------
def start_vorgang(self):
nummer = self.maschinennummer.get().strip()
if not nummer:
messagebox.showerror("Fehler", "Bitte Maschinennummer eingeben.")
return
# INTEGRA-Suche
bearb_num, fehler = finde_integra_nummern(nummer)
if fehler:
messagebox.showwarning("INTEGRA-Suche", fehler)
kommentar = "" # keine Bearbeitungsnummer gefunden
else:
kommentar = f"{bearb_num}: "
self.vorgaenge.append({
"nummer": nummer,
"start": datetime.now(),
"stopp": None,
"kommentar": kommentar
})
speichere_daten(self.vorgaenge)
self.aktualisiere_liste()
def stoppe_auswahl(self):
index = self.listbox.curselection()
if not index:
messagebox.showwarning("Hinweis", "Bitte wähle einen Vorgang aus.")
return
vorgang = self.vorgaenge[index[0]]
if vorgang["stopp"]:
messagebox.showinfo("Hinweis", "Dieser Vorgang wurde bereits gestoppt.")
return
benutzer_kommentar = simpledialog.askstring("Kommentar", "Kommentar zum Vorgang:")
vorgang["stopp"] = datetime.now()
# Kommentar an Bearbeitungsnummer anhängen (falls vorhanden)
if vorgang["kommentar"]:
if benutzer_kommentar:
vorgang["kommentar"] = f"{vorgang['kommentar']} {benutzer_kommentar}"
else:
vorgang["kommentar"] = benutzer_kommentar if benutzer_kommentar else ""
speichere_daten(self.vorgaenge)
self.aktualisiere_liste()
def loesche_auswahl(self):
index = self.listbox.curselection()
if not index:
messagebox.showwarning("Hinweis", "Bitte wähle einen Vorgang aus.")
return
if messagebox.askyesno("Löschen", "Bist du sicher, dass du den ausgewählten Vorgang löschen willst?"):
del self.vorgaenge[index[0]]
speichere_daten(self.vorgaenge)
self.aktualisiere_liste()
messagebox.showinfo("Gelöscht", "Der ausgewählte Vorgang wurde gelöscht.")
def reset(self):
if messagebox.askyesno("Zurücksetzen", "Bist du sicher, dass du alle Daten löschen willst?"):
self.vorgaenge.clear()
self.maschinennummer.set("")
reset_daten()
self.aktualisiere_liste()
messagebox.showinfo("Zurückgesetzt", "Alle Daten wurden gelöscht.")
def oeffne_excel_datei(self):
if not config.SERVER_EXCEL:
messagebox.showerror("Fehler", "Kein Pfad zur Bearbeitungs-Excel gesetzt.\nOptionen → „Bearbeitungs-Excel festlegen…“")
return
if not os.path.exists(config.SERVER_EXCEL):
messagebox.showerror("Fehler", f"Excel-Datei nicht gefunden:\n{config.SERVER_EXCEL}")
return
try:
os.startfile(config.SERVER_EXCEL) # Windows
except AttributeError:
# Fallback für andere Systeme
import subprocess, sys
if sys.platform == "darwin":
subprocess.call(["open", config.SERVER_EXCEL])
else:
subprocess.call(["xdg-open", config.SERVER_EXCEL])
# ------------------------- Anzeige / Darstellung ----------------------
def berechne_dauer_min(self, start: datetime, stopp: datetime) -> float:
return round((stopp - start).total_seconds() / 60, 2)
def aktualisiere_liste(self):
self.listbox.delete(0, tk.END)
for v in self.vorgaenge:
start_str = v["start"].strftime(DATUM_FORMAT) if v["start"] else ""
if v["stopp"]:
stopp_str = v["stopp"].strftime(DATUM_FORMAT)
dauer_str = f"{self.berechne_dauer_min(v['start'], v['stopp'])} Min"
else:
stopp_str = "Läuft..."
dauer_str = ""
bearb_nummer = v.get("bearbeitungsnummer", "")
kommentar = v["kommentar"] if v["kommentar"] else ""
# Anzeige: Nummer | Bearb.-Nr. | Start | Stopp | Dauer | Kommentar
eintrag = f"{v['nummer']} | {bearb_nummer} | {start_str} | {stopp_str} | {dauer_str} | {kommentar}"
self.listbox.insert(tk.END, eintrag)
# ------------------------------ Themes --------------------------------
def _open_theme_window(self):
# Hinweis: Das Layout ist auf hell optimiert. Umschalten möglich, aber rein optisch.
theme_window = tk.Toplevel(self.root)
theme_window.title("Darstellung")
theme_window.geometry("260x150")
theme_window.configure(bg=self.bg_color)
theme_var = tk.StringVar(value="light") # default: light
def apply_theme():
val = theme_var.get()
if val == "dark":
messagebox.showinfo("Info", "Dark Mode ist aktuell nur eingeschränkt unterstützt (UI ist für hell optimiert).")
theme_window.destroy()
tk.Radiobutton(
theme_window, text="Light (empfohlen)", variable=theme_var, value="light",
bg=self.bg_color, fg=self.fg_color, selectcolor="#FFFFFF"
).pack(pady=(12, 4))
tk.Radiobutton(
theme_window, text="Dark (experimentell)", variable=theme_var, value="dark",
bg=self.bg_color, fg=self.fg_color, selectcolor="#FFFFFF"
).pack()
ttk.Button(theme_window, text="Anwenden", command=apply_theme).pack(pady=12)
"""
+194
View File
@@ -1,3 +1,196 @@
# -*- 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
@@ -37,3 +230,4 @@ def speichere_daten(vorgaenge):
def reset_daten():
if os.path.exists(DATEN_DATEI):
os.remove(DATEN_DATEI)
"""