Files
mein-erstes-Projekt/Zeitmanagement_V3.pyw
Henrik_Admin f0a17dace9 Zeitmanagement Software
Zeitmanagement Software zum Zeiten auf Projekte speichern. Am Ende der Woche kann man sich die Zeiten als Excel oder .txt Datei ausgeben lassen
2025-07-20 11:37:05 +02:00

355 lines
14 KiB
Python
Raw Permalink Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import tkinter as tk
from tkinter import messagebox, simpledialog, filedialog
import tkinter.ttk as ttk
from datetime import datetime
import os
import openpyxl
from PIL import Image, ImageTk
# Dateipfad absolut bestimmen
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, "S7-1500_Logo.png")
DATUM_FORMAT = "%Y-%m-%d %H:%M:%S"
class ZeitErfassungApp:
def __init__(self, root):
self.root = root
self.root.title("Zeiterfassung MERZ")
self.root.geometry("800x600")
self.vorgaenge = []
# Standardwerte für Dark/Light-Theme setzen
self.dark_mode = True
self.bg_color = "#1e1e2f"
self.fg_color = "white"
self.button_bg = "#333543"
# Fensterfarbe setzen
self.root.configure(bg=self.bg_color)
self._build_gui()
self.lade_daten()
self._build_menu()
def _build_gui(self):
#logo_img = Image.open(logo_path).resize((60, 60), Image.LANCZOS)
#self.logo = ImageTk.PhotoImage(logo_img)
#logo_label = tk.Label(self.root, image=self.logo, bg="white") #self.bg_color
#logo_label.place(x=10, y=10)
self.root.configure(bg="#1e1e2f") # Dunkler Hintergrund
# Style konfigurieren
style = ttk.Style()
style.theme_use("default")
style.configure("TButton",
background="#333543",
foreground="white",
font=("Segoe UI", 10, "bold"),
padding=6,
borderwidth=3,
relief="raised")
style.map("TButton",
background=[("active", "#444655")],
relief=[("pressed", "sunken")])
# Oberer Frame
frame_top = tk.Frame(self.root, bg="#1e1e2f")
frame_top.pack(pady=5)
self.maschinennummer = tk.StringVar()
tk.Label(frame_top, text="Maschinennummer:", bg="#1e1e2f", fg="white", font=("Segoe UI", 10)).pack(side=tk.LEFT)
self.entry_maschine = tk.Entry(frame_top, textvariable=self.maschinennummer, font=("Segoe UI", 10))
self.entry_maschine.pack(side=tk.LEFT)
ttk.Button(self.root, text="Start", command=self.start_vorgang).pack(pady=5)
self.listbox = tk.Listbox(self.root, width=100, font=("Segoe UI", 9))
self.listbox.pack(padx=10, pady=5)
ttk.Button(self.root, text="Stop mit Kommentar", command=self.stoppe_auswahl).pack(pady=5)
# Export-Buttons nebeneinander
export_frame = tk.Frame(self.root, bg="#1e1e2f")
export_frame.pack(pady=5)
ttk.Button(self.root, text="🌗 Theme wechseln", command=self.toggle_theme).pack(pady=3)
ttk.Button(export_frame, text="Exportieren als TXT", command=self.exportiere_txt).pack(side=tk.LEFT, padx=5)
ttk.Button(export_frame, text="Exportieren als Excel", command=self.exportiere_excel).pack(side=tk.LEFT, padx=5)
ttk.Button(self.root, text="Zurücksetzen", command=self.reset).pack(pady=5)
def _build_menu(self):
menubar = tk.Menu(self.root)
# Hauptmenüpunkt "Optionen"
optionen_menu = tk.Menu(menubar, tearoff=0)
# Untermenü "Darstellung" innerhalb von "Optionen"
darstellung_menu = tk.Menu(optionen_menu, tearoff=0)
darstellung_menu.add_command(label="Theme wechseln", command=self._open_theme_window)
# Unterpunkte von "Optionen"
optionen_menu.add_command(label="Projekt") # Platzhalter
optionen_menu.add_command(label="Extras") # Platzhalter
optionen_menu.add_cascade(label="Darstellung", menu=darstellung_menu) # ← Untermenü
# "Optionen" oben in der Leiste anzeigen
menubar.add_cascade(label="Optionen", menu=optionen_menu)
self.root.config(menu=menubar)
def start_vorgang(self):
nummer = self.maschinennummer.get().strip()
if not nummer:
messagebox.showerror("Fehler", "Bitte Maschinennummer eingeben.")
return
startzeit = datetime.now()
vorgang = {
"nummer": nummer,
"start": startzeit,
"stopp": None,
"kommentar": ""
}
self.vorgaenge.append(vorgang)
self.aktualisiere_liste()
self.speichere_daten()
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"] is not None:
messagebox.showinfo("Hinweis", "Dieser Vorgang wurde bereits gestoppt.")
return
kommentar = simpledialog.askstring("Kommentar", "Kommentar zum Vorgang:")
vorgang["stopp"] = datetime.now()
vorgang["kommentar"] = kommentar if kommentar else ""
self.aktualisiere_liste()
self.speichere_daten()
def berechne_dauer_min(self, start, stopp):
dauer = (stopp - start).total_seconds() / 60
return round(dauer, 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["stopp"]:
stopp_str = v["stopp"].strftime(DATUM_FORMAT)
dauer = self.berechne_dauer_min(v["start"], v["stopp"])
dauer_str = f" | Dauer: {dauer} Min"
else:
stopp_str = "Läuft..."
dauer_str = ""
kommentar = f" | Kommentar: {v['kommentar']}" if v["kommentar"] else ""
eintrag = f"Maschine {v['nummer']} | Start: {start_str} | Stopp: {stopp_str}{dauer_str}{kommentar}"
self.listbox.insert(tk.END, eintrag)
def speichere_daten(self):
with open(DATEN_DATEI, "w", encoding="utf-8") as f:
for v in self.vorgaenge:
start = v["start"].strftime(DATUM_FORMAT)
stopp = v["stopp"].strftime(DATUM_FORMAT) if v["stopp"] else ""
kommentar = v["kommentar"].replace("\n", " ") # Kein Zeilenumbruch
zeile = f"{v['nummer']}|{start}|{stopp}|{kommentar}\n"
f.write(zeile)
def lade_daten(self):
if not os.path.exists(DATEN_DATEI):
return
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
self.vorgaenge.append({
"nummer": nummer,
"start": start_dt,
"stopp": stopp_dt,
"kommentar": kommentar
})
self.aktualisiere_liste()
except Exception as e:
messagebox.showerror("Fehler beim Laden", f"Datei konnte nicht gelesen werden:\n{e}")
def exportiere_txt(self):
if not self.vorgaenge:
messagebox.showinfo("Hinweis", "Keine Daten zum Exportieren.")
return
dateipfad = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Textdateien", "*.txt")])
if not dateipfad:
return
sortierte_vorgaenge = sorted(self.vorgaenge, key=lambda v: v["nummer"])
maschinen_dauer = {}
try:
with open(dateipfad, "w", encoding="utf-8") as f:
for v in sortierte_vorgaenge:
start = v["start"].strftime(DATUM_FORMAT)
if v["stopp"]:
stopp = v["stopp"].strftime(DATUM_FORMAT)
dauer = self.berechne_dauer_min(v["start"], v["stopp"])
dauer_str = f" | Dauer: {dauer} Min"
maschinen_dauer[v["nummer"]] = maschinen_dauer.get(v["nummer"], 0) + dauer
else:
stopp = "Läuft..."
dauer_str = ""
kommentar = f" | Kommentar: {v['kommentar']}" if v["kommentar"] else ""
zeile = f"Maschine {v['nummer']} | Start: {start} | Stopp: {stopp}{dauer_str}{kommentar}\n"
f.write(zeile)
# Zusammenfassung anhängen
f.write("\n--- Zusammenfassung ---\n")
for nummer in sorted(maschinen_dauer.keys()):
f.write(f"Maschine {nummer}: {maschinen_dauer[nummer]} Min\n")
messagebox.showinfo("Erfolg", f"Protokoll erfolgreich gespeichert:\n{dateipfad}")
except Exception as e:
messagebox.showerror("Fehler beim Speichern", str(e))
def exportiere_excel(self):
try:
from openpyxl import Workbook
except ImportError:
messagebox.showerror("Fehler", "Das Paket 'openpyxl' ist nicht installiert.\nBitte installiere es mit: pip install openpyxl")
return
if not self.vorgaenge:
messagebox.showinfo("Hinweis", "Keine Daten zum Exportieren.")
return
dateipfad = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel-Dateien", "*.xlsx")])
if not dateipfad:
return
sortierte_vorgaenge = sorted(self.vorgaenge, key=lambda v: v["nummer"])
wb = Workbook()
ws = wb.active
ws.title = "Zeitprotokoll"
# Kopfzeile
ws.append(["Maschinennummer", "Startzeit", "Stoppzeit", "Dauer (Min)", "Kommentar"])
# Maschinen-Zeitsummen sammeln
maschinen_dauer = {}
for v in sortierte_vorgaenge:
nummer = v["nummer"]
start = v["start"].strftime(DATUM_FORMAT)
stopp = v["stopp"].strftime(DATUM_FORMAT) if v["stopp"] else "Läuft..."
dauer = self.berechne_dauer_min(v["start"], v["stopp"]) if v["stopp"] else ""
kommentar = v["kommentar"]
# Zeile schreiben
ws.append([nummer, start, stopp, dauer, kommentar])
# Dauer zur Maschine addieren
if v["stopp"]:
maschinen_dauer[nummer] = maschinen_dauer.get(nummer, 0) + dauer
# Leerzeile & Zusammenfassung
ws.append([])
ws.append(["--- Zusammenfassung ---"])
for nummer in sorted(maschinen_dauer.keys()):
gesamt_dauer = maschinen_dauer[nummer]
ws.append([f"Maschine {nummer}", f"{gesamt_dauer} Min"])
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}")
def reset(self):
if messagebox.askyesno("Zurücksetzen", "Bist du sicher, dass du alle Daten löschen willst?"):
self.vorgaenge.clear()
self.maschinennummer.set("")
if os.path.exists(DATEN_DATEI):
os.remove(DATEN_DATEI)
self.aktualisiere_liste()
messagebox.showinfo("Zurückgesetzt", "Alle Daten wurden gelöscht.")
def toggle_theme(self):
self.dark_mode = not self.dark_mode
# Farben neu setzen
self.bg_color = "#1e1e2f" if self.dark_mode else "#f0f0f0"
self.fg_color = "white" if self.dark_mode else "black"
self.button_bg = "#333543" if self.dark_mode else "#dddddd"
# Hauptfenster anpassen
self.root.configure(bg=self.bg_color)
# Alle direkten Kinder des Hauptfensters durchgehen
for widget in self.root.winfo_children():
if isinstance(widget, (tk.Label, tk.Button, tk.Entry, tk.Listbox)):
widget.configure(bg=self.bg_color, fg=self.fg_color)
elif isinstance(widget, tk.Frame):
widget.configure(bg=self.bg_color)
for child in widget.winfo_children():
if isinstance(child, (tk.Label, tk.Button, tk.Entry, tk.Listbox)):
child.configure(bg=self.bg_color, fg=self.fg_color)
# TTK-Styles (z. B. Buttons) aktualisieren
style = ttk.Style()
style.configure("TButton",
background=self.button_bg,
foreground=self.fg_color,
font=("Segoe UI", 10, "bold"),
padding=6,
borderwidth=3,
relief="raised")
style.map("TButton",
background=[("active", "#444655" if self.dark_mode else "#cccccc")],
relief=[("pressed", "sunken")])
def _open_theme_window(self):
theme_window = tk.Toplevel(self.root)
theme_window.title("Darstellung ändern")
theme_window.geometry("250x150")
theme_window.configure(bg=self.bg_color)
label = tk.Label(theme_window, text="Theme auswählen:", bg=self.bg_color, fg=self.fg_color)
label.pack(pady=10)
# Radiobuttons für Auswahl
theme_var = tk.StringVar(value="dark" if self.dark_mode else "light")
def apply_theme():
selected = theme_var.get()
self.dark_mode = selected == "dark"
self.toggle_theme()
theme_window.destroy()
tk.Radiobutton(theme_window, text="Dark Mode", variable=theme_var, value="dark", bg=self.bg_color, fg=self.fg_color, selectcolor=self.bg_color).pack()
tk.Radiobutton(theme_window, text="Light Mode", variable=theme_var, value="light", bg=self.bg_color, fg=self.fg_color, selectcolor=self.bg_color).pack()
ttk.Button(theme_window, text="Anwenden", command=apply_theme).pack(pady=10)
if __name__ == "__main__":
root = tk.Tk()
app = ZeitErfassungApp(root)
root.mainloop()