ethiele/3ddruckkalkulation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1b3ef82db45729be40f016945f250db5470761d8
3ddruckkalkulation/app.py
Erik Thiele 1b3ef82db4 Knopf "Neues Projekt" zum Leeren des Arbeitsstands 
Bisher liess sich ein neuer Auftrag nur von Hand beginnen: Namen
ueberschreiben, jede Position neu ausfuellen und auf der Rechnungsseite
Kundendaten und Rechnungsnummer leeren. Wurde der letzte Schritt
vergessen, stand der alte Kunde auf der neuen Rechnung.

- POST /projekte/neu setzt nur PROJEKT_FELDER zurueck (Name, Positionen,
  Kundendaten, Rechnungsnummer, Datum auf heute). Betriebswerte wie
  Marge, Stundenlohn, Drucker, Steuer und Firmendaten bleiben.
- GET /projekte liefert zusaetzlich 'ungespeichert'. Der Knopf fragt nur
  nach, wenn der offene Stand wirklich nicht als Projekt gesichert ist.
- Der Vergleich ignoriert 'datum' und 'geaendert', sonst waere ein
  gespeichertes Projekt am naechsten Tag faelschlich "ungespeichert".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-22 11:59:20 +02:00

1059 lines
40 KiB
Python
Raw Blame History

"""
3D-Druck Kostenkalkulation — Flask Web-App.
Ersetzt die alte Tkinter-Version (3dDruckKalkulator.py).
Bietet eine Weboberflaeche zur Eingabe von Druckparametern,
Live-Berechnung der Kosten, PDF-Rechnung und TXT-Export.
"""
import os
import yaml
import io
import tempfile
import threading
from datetime import datetime
from flask import Flask, render_template, request, jsonify, redirect, url_for, send_file
from fpdf import FPDF
from fpdf.enums import XPos, YPos
def image_dimensions(filepath):
"""Liest Pixelmasse aus PNG/JPEG/WebP ohne externe Libs.""" # noqa: E501
with open(filepath, 'rb') as f:
head = f.read(24)
if head[:8] == b'\x89PNG\r\n\x1a\n':
import struct
return struct.unpack('>II', head[16:24])
if head[:2] == b'\xff\xd8':
import struct
with open(filepath, 'rb') as f:
data = f.read(8192)
i = 2
while i < len(data) - 1:
if data[i] != 0xFF:
i += 1
continue
marker = data[i+1]
if marker in (0xC0, 0xC1, 0xC2):
h, w = struct.unpack('>HH', data[i+5:i+9])
return w, h
length = struct.unpack('>H', data[i+2:i+4])[0]
i += 2 + length
if head[:4] == b'RIFF' and head[8:12] == b'WEBP':
import struct
with open(filepath, 'rb') as f:
data = f.read(64)
if data[12:16] == b'VP8 ' and len(data) >= 30:
w, h = struct.unpack('<HH', data[26:30])
return (w & 0x3FFF) * 2, (h & 0x3FFF) * 2
if data[12:16] == b'VP8L' and len(data) >= 25:
bits = struct.unpack('<I', data[21:25])[0]
return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1
return None, None
# Zeichen, die die PDF-Kernfonts (latin-1) nicht darstellen koennen,
# aber regelmaessig aus Copy-Paste in Kunden- und Projektnamen landen.
_LATIN1_ERSATZ = {
'\u2013': '-', '\u2014': '-', '\u2012': '-', '\u2212': '-',
'\u2018': "'", '\u2019': "'", '\u201a': ',', '\u2032': "'",
'\u201c': '"', '\u201d': '"', '\u201e': '"', '\u2033': '"',
'\u2026': '...', '\u2022': '-', '\u00a0': ' ', '\u202f': ' ',
'\u20ac': 'EUR', '\u2044': '/', '\u00ad': '',
}
# Die drei Faelle unterscheiden sich rechtlich grundlegend:
# 'regel' -> Unternehmer, weist MwSt. aus
# 'kleinunternehmer' -> Unternehmer nach §19 UStG, keine MwSt., Pflichthinweis
# 'privat' -> gar kein Unternehmer (§2 UStG); weder MwSt. noch
# §19-Hinweis noch Steuernummer gehoeren auf den Beleg
STEUERREGIME = ('regel', 'kleinunternehmer', 'privat')
KLEINUNTERNEHMER_HINWEIS = (
"Gemäß § 19 UStG wird keine Umsatzsteuer berechnet."
)
PRIVAT_HINWEIS = (
"Privatverkauf. Kein Ausweis von Umsatzsteuer."
)
# Ein Zahlungsziel ist eine Geschaeftsbedingung. Beim Privatverkauf
# entfaellt es -- dort wird der Betrag ueblicherweise direkt beglichen.
ZAHLUNGSZIEL = "Zahlbar innerhalb von 14 Tagen ohne Abzug."
DANK = "Vielen Dank für Ihren Auftrag!"
def mwst_satz_label(satz):
"""Formatiert den Steuersatz ohne unnoetige Nachkommastellen (19 statt 19.0)."""
return f"{satz:g}"
def as_stueckzahl(value):
"""Stueckzahl robust nach int, mindestens 1.
Leere Felder oder Kommazahlen (z.B. '' oder '1.5') haben frueher
einen ValueError und damit HTTP 500 ausgeloest.
"""
try:
zahl = int(float(value))
except (TypeError, ValueError):
return 1
return max(1, zahl)
def pdf_text(value):
"""Macht beliebigen Text fuer die latin-1-Kernfonts von fpdf sicher.
Ohne diese Umwandlung wirft fpdf beim Schreiben einen
UnicodeEncodeError und die PDF-Route antwortet mit HTTP 500.
"""
text = '' if value is None else str(value)
for zeichen, ersatz in _LATIN1_ERSATZ.items():
text = text.replace(zeichen, ersatz)
# Alles weiterhin Unkodierbare faellt auf '?' zurueck, statt zu crashen.
return text.encode('latin-1', 'replace').decode('latin-1')
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 5 * 1024 * 1024
CONFIG_FILE = 'druckkalkulation_config.yaml'
PROJEKTE_FILE = 'druckkalkulation_projekte.yaml'
# Felder, die zu einem Projekt gehoeren. Alles andere (Drucker, Strom,
# Stundenlohn, Marge, Steuer, Firmendaten) ist werkstattweit und wird
# bewusst NICHT mitgespeichert -- sonst wuerde das Laden eines alten
# Projekts die aktuellen Betriebswerte ueberschreiben.
PROJEKT_FELDER = ('projektName', 'positionen', 'kundenName', 'kundenAdresse',
'rechnungsnummer', 'datum', 'leistungsdatum')
MAX_PROJEKTE = 500
LOGO_EXTS = ('png', 'jpg', 'webp')
# Obergrenze, damit ein fehlerhafter Client die Config nicht aufblaeht.
MAX_POSITIONEN = 50
# Eine einzelne Kalkulationsposition. Material, Arbeitszeit und Stueckzahl
# gehoeren hierher: verschiedene Teile eines Objekts nutzen oft
# unterschiedliche Filamente und brauchen unterschiedlich viel Nacharbeit.
DEFAULT_POSITION = {
'name': '',
'materialGewicht': 0,
'materialPreisProKg': 25,
'druckzeit': 0,
'arbeitszeit': 0,
'stueckzahl': 1,
}
# Felder, die frueher direkt in der Config lagen und jetzt zu einer
# Position gehoeren. Wird fuer die Migration alter Staende gebraucht.
LEGACY_POSITIONSFELDER = ('materialGewicht', 'materialPreisProKg',
'druckzeit', 'arbeitszeit', 'stueckzahl')
DEFAULT_VALUES = {
'projektName': '',
'kundenName': '',
'kundenAdresse': '',
'positionen': [dict(DEFAULT_POSITION)],
'stromverbrauch': 0.15,
'strompreis': 0.35,
'druckerAnschaffung': 500,
'druckerNutzungsdauer': 3,
'druckerBetriebsstunden': 2000,
'stundenlohn': 25,
'gewinnmarge': 20,
# 'regel' = regelbesteuert (MwSt. wird ausgewiesen),
# 'kleinunternehmer' = §19 UStG (keine MwSt., dafuer Pflichthinweis).
'steuerregime': 'regel',
'mwst_satz': 19,
'steuernummer': '',
'ust_id': '',
'mwst_ausweisen': False,
'rechnungsnummer': '',
'datum': datetime.now().strftime('%Y-%m-%d'),
'leistungsdatum': '',
'dark_mode': False,
'firmenName': '',
'firmenAdresse': '',
'telefon': '',
'email': '',
'paypal': '',
'iban': '',
'bankName': '',
'logo': '',
}
# Serialisiert Read-modify-write auf der Config-Datei. Ohne Lock koennen
# zwei parallele Autosaves (Tippen in zwei Tabs) sich gegenseitig
# ueberschreiben.
_config_lock = threading.Lock()
class ConfigError(RuntimeError):
"""Die Config-Datei existiert, ist aber nicht lesbar."""
def load_config():
"""Liest die YAML-Konfiguration von Disk. Fehlt die Datei,
werden DEFAULT_VALUES verwendet.
Ist die Datei vorhanden aber beschaedigt, wird ConfigError geworfen,
statt stillschweigend auf Defaults zurueckzufallen -- sonst wuerde
der naechste Autosave die kaputte Datei mit Defaults ueberschreiben
und alle gespeicherten Werte waeren endgueltig weg.
"""
if not os.path.exists(CONFIG_FILE):
return dict(DEFAULT_VALUES)
try:
with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
data = yaml.safe_load(f)
except (OSError, yaml.YAMLError) as e:
raise ConfigError(f"{CONFIG_FILE} ist nicht lesbar: {e}") from e
if not isinstance(data, dict):
if data is None:
return dict(DEFAULT_VALUES)
raise ConfigError(f"{CONFIG_FILE} enthaelt kein YAML-Mapping")
# Migration VOR dem Auffuellen mit Defaults: sonst hat setdefault
# 'steuerregime' bereits gesetzt und die Ableitung liefe ins Leere.
data = _migriere(data)
for k, v in DEFAULT_VALUES.items():
data.setdefault(k, v)
return data
def _migriere(data):
"""Bringt aeltere Config-Staende auf das aktuelle Schema.
Frueher gab es nur den Schalter 'mwst_ausweisen'. Daraus laesst sich
das Steuerregime ableiten: wer keine MwSt. auswies, rechnete faktisch
als Kleinunternehmer ab. Nur greifen, wenn 'steuerregime' wirklich
fehlt -- ein leerer Wert im Feld ist etwas anderes als ein alter Stand.
"""
if 'steuerregime' not in data:
if 'mwst_ausweisen' in data:
data['steuerregime'] = ('regel' if data['mwst_ausweisen']
else 'kleinunternehmer')
else:
data['steuerregime'] = DEFAULT_VALUES['steuerregime']
if data['steuerregime'] not in STEUERREGIME:
data['steuerregime'] = DEFAULT_VALUES['steuerregime']
# 'mwst_ausweisen' bleibt als abgeleitetes Feld erhalten, damit
# Templates und Export nicht an zwei Stellen entscheiden muessen.
data['mwst_ausweisen'] = data['steuerregime'] == 'regel'
# Positionen: frueher lag genau ein Teil flach in der Config.
if 'positionen' not in data:
alt = {k: data[k] for k in LEGACY_POSITIONSFELDER if k in data}
if alt:
alt.setdefault('name', data.get('projektName', ''))
data['positionen'] = [alt]
else:
data['positionen'] = [dict(DEFAULT_POSITION)]
data['positionen'] = saubere_positionen(data['positionen'])
# Die alten Flachfelder nicht mitschleppen -- sonst driften zwei
# Quellen fuer dieselbe Angabe auseinander.
for k in LEGACY_POSITIONSFELDER:
data.pop(k, None)
return data
def saubere_positionen(rohliste):
"""Normalisiert eine Positionsliste aus Config oder Client-JSON.
Nimmt nur bekannte Felder an, erzwingt Zahlentypen und liefert immer
mindestens eine Position -- eine leere Kalkulation waere sinnlos und
wuerde die Oberflaeche in einen Zustand ohne Eingabefelder bringen.
"""
if not isinstance(rohliste, list):
rohliste = []
sauber = []
for eintrag in rohliste:
if not isinstance(eintrag, dict):
continue
pos = dict(DEFAULT_POSITION)
pos['name'] = str(eintrag.get('name', '') or '')[:200]
for feld in ('materialGewicht', 'materialPreisProKg',
'druckzeit', 'arbeitszeit'):
try:
wert = float(eintrag.get(feld, DEFAULT_POSITION[feld]))
except (TypeError, ValueError):
wert = float(DEFAULT_POSITION[feld])
pos[feld] = max(0.0, wert)
pos['stueckzahl'] = as_stueckzahl(eintrag.get('stueckzahl', 1))
sauber.append(pos)
if len(sauber) >= MAX_POSITIONEN:
break
return sauber or [dict(DEFAULT_POSITION)]
def save_config(data):
"""Schreibt das uebergebene Dict atomar als YAML-Datei.
Erst in eine temporaere Datei im selben Verzeichnis schreiben, dann
os.replace() -- so bleibt bei einem Absturz mitten im Schreiben die
alte Config intakt statt abgeschnitten zurueckzubleiben.
"""
verzeichnis = os.path.dirname(os.path.abspath(CONFIG_FILE))
fd, tmp_pfad = tempfile.mkstemp(
prefix='.druckkalkulation_', suffix='.tmp', dir=verzeichnis)
try:
with os.fdopen(fd, 'w', encoding='utf-8') as f:
yaml.dump(data, f, default_flow_style=False, allow_unicode=True)
f.flush()
os.fsync(f.fileno())
os.replace(tmp_pfad, CONFIG_FILE)
except Exception:
if os.path.exists(tmp_pfad):
os.remove(tmp_pfad)
raise
_projekte_lock = threading.Lock()
def lade_projekte():
"""Liest die Projektdatei. Fehlt sie, gibt es eben noch keine Projekte."""
if not os.path.exists(PROJEKTE_FILE):
return {}
try:
with open(PROJEKTE_FILE, 'r', encoding='utf-8') as f:
data = yaml.safe_load(f)
except (OSError, yaml.YAMLError) as e:
raise ConfigError(f"{PROJEKTE_FILE} ist nicht lesbar: {e}") from e
if data is None:
return {}
if not isinstance(data, dict):
raise ConfigError(f"{PROJEKTE_FILE} enthaelt kein YAML-Mapping")
return data
def speichere_projekte(projekte):
"""Schreibt die Projektdatei atomar (gleiche Technik wie save_config)."""
verzeichnis = os.path.dirname(os.path.abspath(PROJEKTE_FILE))
fd, tmp_pfad = tempfile.mkstemp(
prefix='.druckkalkulation_projekte_', suffix='.tmp', dir=verzeichnis)
try:
with os.fdopen(fd, 'w', encoding='utf-8') as f:
yaml.dump(projekte, f, default_flow_style=False, allow_unicode=True)
f.flush()
os.fsync(f.fileno())
os.replace(tmp_pfad, PROJEKTE_FILE)
except Exception:
if os.path.exists(tmp_pfad):
os.remove(tmp_pfad)
raise
def projekt_name(roh):
"""Normalisiert einen Projektnamen zum Schluessel.
Der Name ist der Schluessel -- er landet aber nie in einem Dateipfad,
daher reicht Trimmen und Laengenbegrenzung.
"""
return str(roh or '').strip()[:200]
def projekt_aus_config(config):
"""Schneidet die Projektfelder aus dem aktuellen Arbeitsstand heraus."""
return {feld: config.get(feld, DEFAULT_VALUES.get(feld))
for feld in PROJEKT_FELDER}
def leerer_projektstand():
"""Projektfelder im Ausgangszustand. Datum auf heute."""
stand = {feld: DEFAULT_VALUES.get(feld) for feld in PROJEKT_FELDER}
stand['projektName'] = ''
stand['kundenName'] = ''
stand['kundenAdresse'] = ''
stand['rechnungsnummer'] = ''
stand['leistungsdatum'] = ''
stand['datum'] = datetime.now().strftime('%Y-%m-%d')
stand['positionen'] = [dict(DEFAULT_POSITION)]
return stand
def _vergleichbar(stand):
"""Projektfelder in eine vergleichbare Form bringen.
'geaendert' und das Datum bleiben aussen vor -- ein neuer Tag macht
aus einem gespeicherten Projekt keinen ungespeicherten Stand.
"""
return {
'projektName': projekt_name(stand.get('projektName')),
'kundenName': str(stand.get('kundenName') or ''),
'kundenAdresse': str(stand.get('kundenAdresse') or ''),
'rechnungsnummer': str(stand.get('rechnungsnummer') or ''),
'leistungsdatum': str(stand.get('leistungsdatum') or ''),
'positionen': saubere_positionen(stand.get('positionen')),
}
def ungespeicherte_aenderungen(config, projekte):
"""True, wenn der Arbeitsstand nicht so in den Projekten liegt.
Ein voellig leerer Stand zaehlt nicht als ungespeichert -- da ist
nichts zu verlieren.
"""
aktuell = _vergleichbar(config)
if aktuell == _vergleichbar(leerer_projektstand()):
return False
gespeichert = projekte.get(aktuell['projektName'])
if not isinstance(gespeichert, dict):
return True
return aktuell != _vergleichbar(gespeichert)
def steuer_kontext(data):
"""Liest Regime und MwSt.-Satz robust aus den Formularwerten."""
regime = str(data.get('steuerregime', 'regel')).lower()
if regime not in STEUERREGIME:
regime = 'regel'
mwst_ausweisen = regime == 'regel'
try:
mwst_satz = float(data.get('mwst_satz', 19))
except (TypeError, ValueError):
mwst_satz = 19.0
mwst_satz = max(0.0, mwst_satz)
return regime, mwst_ausweisen, mwst_satz, (mwst_satz / 100 if mwst_ausweisen else 0)
def positions_label(pos, nummer, projekt, anzahl):
"""Beschriftung einer Rechnungszeile.
Bei einer einzelnen namenlosen Position bleibt es beim bisherigen
"3D-Druck: <Projekt>". Sobald mehrere Positionen im Spiel sind,
braucht jede Zeile eine eigene, unterscheidbare Bezeichnung.
"""
name = (pos.get('name') or '').strip()
if name:
return f"3D-Druck: {name}"
if anzahl == 1:
return f"3D-Druck: {projekt}" if projekt else "3D-Druck"
return f"3D-Druck: Position {nummer}"
def berechne_position(pos, data, abschreibung_pro_stunde):
"""Berechnet eine einzelne Position.
'data' liefert die auftragsweiten Werte (Strom, Stundenlohn, Marge),
'pos' die positionsspezifischen (Material, Zeiten, Stueckzahl).
"""
druckzeit_stunden = float(pos.get('druckzeit', 0)) / 60
arbeitszeit_stunden = float(pos.get('arbeitszeit', 0)) / 60
material_kg = float(pos.get('materialGewicht', 0)) / 1000
material_preis_pro_kg = float(pos.get('materialPreisProKg', 0))
materialkosten = material_kg * material_preis_pro_kg
stromkosten = (druckzeit_stunden * float(data.get('stromverbrauch', 0))
* float(data.get('strompreis', 0)))
abschreibung = abschreibung_pro_stunde * druckzeit_stunden
arbeitskosten = arbeitszeit_stunden * float(data.get('stundenlohn', 0))
kosten = materialkosten + stromkosten + abschreibung + arbeitskosten
gewinn = kosten * (float(data.get('gewinnmarge', 0)) / 100)
verkaufspreis = kosten + gewinn
# Auf Cent gerundeter Stueckpreis ist die Basis der Zeilensumme,
# damit die Rechnungszeile nachrechenbar bleibt.
stueckzahl = as_stueckzahl(pos.get('stueckzahl', 1))
stueckpreis = round(verkaufspreis, 2)
zeilensumme = round(stueckpreis * stueckzahl, 2)
return {
'name': str(pos.get('name', '') or ''),
'stueckzahl': stueckzahl,
'materialkosten': round(materialkosten, 2),
'stromkosten': round(stromkosten, 2),
'abschreibung': round(abschreibung, 2),
'arbeitskosten': round(arbeitskosten, 2),
'kosten': round(kosten, 2),
'gewinn': round(gewinn, 2),
'stueckpreis': stueckpreis,
'zeilensumme': zeilensumme,
'druckzeit_stunden': round(druckzeit_stunden, 2),
'arbeitszeit_stunden': round(arbeitszeit_stunden, 2),
'material_kg': round(material_kg, 3),
'kosten_pro_gramm': round(material_preis_pro_kg / 1000, 3),
}
def calculate(data):
"""Berechnet alle Positionen und die Auftragssummen.
Rueckgabe: Dict mit der Positionsliste, den Summen und den
auftragsweiten Detailwerten.
"""
anschaffung = float(data.get('druckerAnschaffung', 0))
nutzung = float(data.get('druckerNutzungsdauer', 1))
betrieb = float(data.get('druckerBetriebsstunden', 1))
abschreibung_pro_stunde = (anschaffung / (nutzung * betrieb)
if (nutzung * betrieb) > 0 else 0)
positionen = saubere_positionen(data.get('positionen'))
berechnet = [berechne_position(p, data, abschreibung_pro_stunde)
for p in positionen]
regime, mwst_ausweisen, mwst_satz, mwst_faktor = steuer_kontext(data)
# Summe der bereits gerundeten Zeilen -- so stimmt die Rechnung
# auch dann, wenn der Kunde sie Zeile fuer Zeile nachrechnet.
netto = round(sum(p['zeilensumme'] for p in berechnet), 2)
mwst = round(netto * mwst_faktor, 2)
brutto = round(netto + mwst, 2)
return {
'positionen': berechnet,
'anzahl_positionen': len(berechnet),
'teile_gesamt': sum(p['stueckzahl'] for p in berechnet),
'gesamt_netto': netto,
'gesamt_mwst': mwst,
'gesamt_endpreis': brutto,
# Auftragsweite Kostensummen (fuer die Aufstellung im Frontend)
'summe_materialkosten': round(sum(p['materialkosten'] * p['stueckzahl'] for p in berechnet), 2),
'summe_stromkosten': round(sum(p['stromkosten'] * p['stueckzahl'] for p in berechnet), 2),
'summe_abschreibung': round(sum(p['abschreibung'] * p['stueckzahl'] for p in berechnet), 2),
'summe_arbeitskosten': round(sum(p['arbeitskosten'] * p['stueckzahl'] for p in berechnet), 2),
'summe_kosten': round(sum(p['kosten'] * p['stueckzahl'] for p in berechnet), 2),
'summe_gewinn': round(sum(p['gewinn'] * p['stueckzahl'] for p in berechnet), 2),
'gewinnmarge': float(data.get('gewinnmarge', 0)),
'steuerregime': regime,
'mwst_satz': mwst_satz,
'mwst_ausweisen': mwst_ausweisen,
'kleinunternehmer': regime == 'kleinunternehmer',
'privat': regime == 'privat',
# Steuernummer/USt-IdNr. gehoeren nur auf einen Unternehmer-Beleg.
'ist_unternehmer': regime != 'privat',
'druckzeit_stunden': round(sum(p['druckzeit_stunden'] * p['stueckzahl'] for p in berechnet), 2),
'material_kg': round(sum(p['material_kg'] * p['stueckzahl'] for p in berechnet), 3),
'abschreibung_pro_stunde': round(abschreibung_pro_stunde, 4),
'strom_pro_stunde': round(float(data.get('stromverbrauch', 0))
* float(data.get('strompreis', 0)), 3),
}
# ---------------------------------------------------------------------------
# Routes
# ---------------------------------------------------------------------------
@app.context_processor
def inject_konstanten():
"""Stellt den §19-Hinweis allen Templates zur Verfuegung."""
return {'kleinunternehmer_hinweis': KLEINUNTERNEHMER_HINWEIS,
'privat_hinweis': PRIVAT_HINWEIS,
'zahlungsziel': ZAHLUNGSZIEL,
'dank': DANK}
@app.errorhandler(ConfigError)
def handle_config_error(e):
"""Kaputte Config-Datei: klar melden statt Daten zu ueberschreiben."""
hinweis = (f"Konfigurationsdatei beschaedigt: {e}. "
f"Bitte {CONFIG_FILE} reparieren oder loeschen "
f"(dann startet die App mit Standardwerten).")
if request.path in ('/calculate', '/save_config'):
return jsonify({'error': hinweis}), 500
return hinweis, 500
@app.route('/')
def index():
"""Hauptseite mit Eingabeformular und Ergebnissen."""
config = load_config()
calc = calculate(config)
return render_template('index.html', config=config, calc=calc)
@app.route('/settings')
def settings():
"""Einstellungsseite fuer Druckerabschreibung, Arbeitskosten und Marge."""
config = load_config()
return render_template('settings.html', config=config)
@app.route('/calculate', methods=['POST'])
def calc_json():
"""AJAX-Endpunkt: Nimmt Formular-JSON entgegen, gibt Berechnung zurueck.
Fehlende Werte werden aus der gespeicherten Config ergaenzt."""
data = request.get_json()
config = load_config()
merged = {**config, **data}
calc = calculate(merged)
return jsonify(calc)
@app.route('/save_config', methods=['POST'])
def save_config_route():
"""AJAX-Endpunkt: Speichert aktuelle Formularwerte in YAML.
Vorhandene Werte (z.B. aus Einstellungen) werden nicht ueberschrieben."""
data = request.get_json(silent=True) or {}
# Nur bekannte Schluessel uebernehmen -- sonst kann ein beliebiger
# Client die Config mit fremden Feldern vollschreiben.
gefiltert = {k: v for k, v in data.items() if k in DEFAULT_VALUES}
# Positionen sind eine Liste von Dicts -- vor dem Speichern
# normalisieren, damit kein Client-Muell in der Config landet.
if 'positionen' in gefiltert:
gefiltert['positionen'] = saubere_positionen(gefiltert['positionen'])
with _config_lock:
existing = load_config()
existing.update(gefiltert)
# Abgeleitete Felder neu berechnen, damit auf der Platte nie
# 'kleinunternehmer' neben 'mwst_ausweisen: true' steht.
existing = _migriere(existing)
save_config(existing)
return jsonify({'status': 'ok', 'gespeichert': len(gefiltert)})
@app.route('/projekte')
def projekte_liste():
"""Liefert die gespeicherten Projekte als JSON, neueste zuerst."""
projekte = lade_projekte()
config = load_config()
eintraege = []
for name, daten in projekte.items():
if not isinstance(daten, dict):
continue
positionen = saubere_positionen(daten.get('positionen'))
# Preis mit den AKTUELLEN Betriebswerten rechnen, nicht mit den
# Werten von damals -- die Marge liegt bewusst nicht im Projekt.
calc = calculate({**config, 'positionen': positionen})
eintraege.append({
'name': name,
'geaendert': daten.get('geaendert', ''),
'kundenName': daten.get('kundenName', ''),
'anzahl_positionen': calc['anzahl_positionen'],
'teile_gesamt': calc['teile_gesamt'],
'gesamt_endpreis': calc['gesamt_endpreis'],
})
eintraege.sort(key=lambda e: e['geaendert'], reverse=True)
return jsonify({
'projekte': eintraege,
'aktuell': config.get('projektName', ''),
'ungespeichert': ungespeicherte_aenderungen(config, projekte),
})
@app.route('/projekte/speichern', methods=['POST'])
def projekt_speichern():
"""Sichert den aktuellen Arbeitsstand unter seinem Projektnamen."""
daten = request.get_json(silent=True) or {}
with _config_lock:
config = load_config()
name = projekt_name(daten.get('name') or config.get('projektName'))
if not name:
return jsonify({'error': 'Bitte zuerst einen Projektnamen vergeben'}), 400
with _projekte_lock:
projekte = lade_projekte()
neu_angelegt = name not in projekte
if neu_angelegt and len(projekte) >= MAX_PROJEKTE:
return jsonify({'error': f'Maximal {MAX_PROJEKTE} Projekte'}), 400
eintrag = projekt_aus_config(config)
eintrag['projektName'] = name
eintrag['geaendert'] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
projekte[name] = eintrag
speichere_projekte(projekte)
# Der Arbeitsstand traegt danach denselben Namen wie das Projekt.
with _config_lock:
config = load_config()
config['projektName'] = name
save_config(_migriere(config))
return jsonify({'status': 'ok', 'name': name, 'neu': neu_angelegt})
@app.route('/projekte/laden', methods=['POST'])
def projekt_laden():
"""Laedt ein gespeichertes Projekt in den Arbeitsstand."""
daten = request.get_json(silent=True) or {}
name = projekt_name(daten.get('name'))
with _projekte_lock:
projekte = lade_projekte()
eintrag = projekte.get(name)
if not isinstance(eintrag, dict):
return jsonify({'error': f'Projekt "{name}" nicht gefunden'}), 404
with _config_lock:
config = load_config()
for feld in PROJEKT_FELDER:
if feld in eintrag:
config[feld] = eintrag[feld]
config['projektName'] = name
save_config(_migriere(config))
return jsonify({'status': 'ok', 'name': name})
@app.route('/projekte/neu', methods=['POST'])
def projekt_neu():
"""Setzt den Arbeitsstand auf einen leeren Auftrag zurueck.
Betriebswerte (Drucker, Strom, Stundenlohn, Marge, Steuer,
Firmendaten) bleiben unangetastet -- zurueckgesetzt wird nur, was
zu einem einzelnen Auftrag gehoert.
"""
with _config_lock:
config = load_config()
config.update(leerer_projektstand())
save_config(_migriere(config))
return jsonify({'status': 'ok'})
@app.route('/projekte/loeschen', methods=['POST'])
def projekt_loeschen():
"""Entfernt ein gespeichertes Projekt. Der Arbeitsstand bleibt."""
daten = request.get_json(silent=True) or {}
name = projekt_name(daten.get('name'))
with _projekte_lock:
projekte = lade_projekte()
if name not in projekte:
return jsonify({'error': f'Projekt "{name}" nicht gefunden'}), 404
del projekte[name]
speichere_projekte(projekte)
return jsonify({'status': 'ok', 'name': name})
@app.route('/upload_logo', methods=['POST'])
def upload_logo():
"""Logo-Datei hochladen, auf gueltiges Bild pruefen und speichern."""
if 'logo' not in request.files:
return jsonify({'error': 'Keine Datei'}), 400
file = request.files['logo']
if file.filename == '':
return jsonify({'error': 'Keine Datei ausgewaehlt'}), 400
raw = file.read()
# Magic-Bytes-Pruefung
if raw[:8] == b'\x89PNG\r\n\x1a\n':
ext = 'png'
elif raw[:2] in (b'\xff\xd8',):
ext = 'jpg'
elif raw[:4] == b'RIFF' and raw[8:12] == b'WEBP':
ext = 'webp'
else:
return jsonify({'error': 'Nur PNG, JPEG oder WebP erlaubt'}), 400
filename = f'logo.{ext}'
filepath = os.path.join('static', filename)
with open(filepath, 'wb') as f:
f.write(raw)
# Logos in anderen Formaten entfernen, sonst bleibt z.B. logo.png
# liegen, wenn jetzt logo.jpg aktiv ist.
for alt_ext in LOGO_EXTS:
if alt_ext == ext:
continue
alt_pfad = os.path.join('static', f'logo.{alt_ext}')
if os.path.exists(alt_pfad):
os.remove(alt_pfad)
with _config_lock:
config = load_config()
config['logo'] = filename
save_config(config)
return jsonify({'status': 'ok', 'filename': filename})
@app.route('/delete_logo', methods=['POST'])
def delete_logo():
"""Logo loeschen."""
with _config_lock:
config = load_config()
# Alle bekannten Logo-Varianten entfernen, nicht nur die
# gerade in der Config eingetragene.
for ext in LOGO_EXTS:
logo_path = os.path.join('static', f'logo.{ext}')
if os.path.exists(logo_path):
os.remove(logo_path)
config['logo'] = ''
save_config(config)
return jsonify({'status': 'ok'})
@app.route('/invoice')
def invoice():
"""Rechnungsseite mit Kundendaten und Vorschau."""
config = load_config()
calc = calculate(config)
return render_template('invoice.html', config=config, calc=calc)
@app.route('/invoice/pdf', methods=['POST'])
def invoice_pdf():
"""Generiert eine PDF-Rechnung via fpdf2 und sendet sie zum Download."""
data = request.form
config = load_config()
calc = calculate(config)
gesamt_netto = calc['gesamt_netto']
gesamt_mwst = calc['gesamt_mwst']
gesamt_brutto = calc['gesamt_endpreis']
firmen_name = pdf_text(config.get('firmenName', ''))
firmen_adresse = pdf_text(config.get('firmenAdresse', ''))
telefon = pdf_text(config.get('telefon', ''))
email = pdf_text(config.get('email', ''))
paypal = pdf_text(config.get('paypal', ''))
iban = pdf_text(config.get('iban', ''))
bank_name = pdf_text(config.get('bankName', ''))
steuernummer = pdf_text(config.get('steuernummer', ''))
ust_id = pdf_text(config.get('ust_id', ''))
kunde = pdf_text(data.get('kundenName', config.get('kundenName', '')))
adresse = pdf_text(data.get('kundenAdresse', config.get('kundenAdresse', '')))
rechnungsnummer = pdf_text(data.get('rechnungsnummer', config.get('rechnungsnummer', '')))
datum = pdf_text(data.get('datum', config.get('datum', '')))
# §14 UStG verlangt den Leistungszeitpunkt. Fehlt er, gilt das
# Rechnungsdatum -- dann ist der uebliche Zusatz noetig.
leistungsdatum = pdf_text(data.get('leistungsdatum',
config.get('leistungsdatum', '')))
projekt = pdf_text(config.get('projektName', ''))
pdf = FPDF()
pdf.set_margins(15, 10, 15)
pdf.add_page()
left = 15
col_w = 45
# Logo rechts oben
logo_name = config.get('logo', '')
logo_path = os.path.join('static', logo_name) if logo_name else ''
if logo_name and os.path.exists(logo_path):
pdf.image(logo_path, x=175, y=12, w=20)
img_w, img_h = image_dimensions(logo_path)
if img_w and img_h:
logo_bottom = 12 + 20 * (img_h / img_w) + 3
else:
logo_bottom = 12 + 12 + 3
else:
pdf.set_font("Helvetica", "B", 18)
pdf.set_xy(150, 12)
pdf.set_text_color(6, 111, 209)
pdf.cell(col_w, 7, "JET", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
pdf.set_x(150)
pdf.cell(col_w, 7, "Design", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
pdf.set_text_color(0, 0, 0)
logo_bottom = pdf.get_y()
# Firmendaten rechts unter Logo (fester Abstand)
right_x = 150
pdf.set_font("Helvetica", "B", 9)
pdf.set_xy(right_x, logo_bottom)
pdf.cell(col_w, 4, firmen_name, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
pdf.set_font("Helvetica", "", 8)
if firmen_adresse:
pdf.set_x(right_x)
pdf.cell(col_w, 3.5, firmen_adresse, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
if telefon:
pdf.set_x(right_x)
pdf.cell(col_w, 3.5, f"Tel: {telefon}", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
if email:
pdf.set_x(right_x)
pdf.cell(col_w, 3.5, email, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
if paypal:
pdf.set_x(right_x)
pdf.cell(col_w, 3.5, f"PayPal: {paypal}", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
if iban:
pdf.set_x(right_x)
pdf.cell(col_w, 3.5, iban, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
if bank_name:
pdf.set_x(right_x)
pdf.cell(col_w, 3.5, bank_name, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
# Bei Privatverkauf gehoeren Steuernummer/USt-IdNr. nicht auf den Beleg --
# sie wuerden eine Unternehmereigenschaft behaupten, die nicht besteht.
if calc.get('ist_unternehmer'):
if steuernummer:
pdf.set_x(right_x)
pdf.cell(col_w, 3.5, f"St.-Nr.: {steuernummer}",
new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
if ust_id:
pdf.set_x(right_x)
pdf.cell(col_w, 3.5, f"USt-IdNr.: {ust_id}",
new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
right_bottom = pdf.get_y()
# --- Rechnungsdaten & Empfaenger (links, unterhalb der rechten Spalte) ---
content_y = max(right_bottom + 15, 80)
pdf.set_xy(left, content_y)
pdf.set_font("Helvetica", "", 10)
if rechnungsnummer:
pdf.cell(80, 5, f"Rechnungsnr.: {rechnungsnummer}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
pdf.set_x(left)
pdf.cell(80, 5, f"Rechnungsdatum: {datum}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
pdf.set_x(left)
if leistungsdatum:
pdf.cell(80, 5, f"Leistungsdatum: {leistungsdatum}",
new_x=XPos.LMARGIN, new_y=YPos.NEXT)
elif calc.get('ist_unternehmer'):
# Nur Unternehmer brauchen den Leistungszeitpunkt (§14 UStG).
pdf.cell(80, 5, pdf_text("Leistungsdatum entspricht dem Rechnungsdatum."),
new_x=XPos.LMARGIN, new_y=YPos.NEXT)
pdf.set_xy(left, pdf.get_y() + 8)
pdf.set_font("Helvetica", "B", 10)
pdf.cell(80, 5, pdf_text("Rechnungsempfänger:"), new_x=XPos.LMARGIN, new_y=YPos.NEXT)
pdf.set_font("Helvetica", "", 10)
pdf.set_x(left)
pdf.cell(80, 5, kunde, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
if adresse:
pdf.set_x(left)
pdf.set_font("Helvetica", "", 9)
for line in adresse.split('\n'):
pdf.set_x(left)
pdf.cell(80, 4, line.strip(), new_x=XPos.LMARGIN, new_y=YPos.NEXT)
# --- Trennlinie ---
pdf.set_draw_color(220, 220, 220)
pdf.line(left, pdf.get_y() + 6, 195, pdf.get_y() + 6)
pdf.set_draw_color(0, 0, 0)
# --- Positionstabelle ---
table_y = pdf.get_y() + 10
pdf.set_xy(left, table_y)
pdf.set_font("Helvetica", "B", 10)
pdf.cell(85, 6, "Leistungsbeschreibung")
pdf.cell(20, 6, "Menge", align='R')
pdf.cell(30, 6, "Einzelpreis", align='R')
pdf.cell(30, 6, "Gesamt", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
pdf.set_draw_color(200, 200, 200)
pdf.line(left, pdf.get_y() + 0.5, 195, pdf.get_y() + 0.5)
pdf.set_draw_color(0, 0, 0)
pdf.set_font("Helvetica", "", 10)
for nummer, pos in enumerate(calc['positionen'], start=1):
# Seitenumbruch, bevor die Zeile in den Fussbereich laufen wuerde.
if pdf.get_y() > 250:
pdf.add_page()
pdf.set_y(20)
pdf.set_x(left)
pdf.cell(85, 7, pdf_text(positions_label(pos, nummer, projekt,
len(calc['positionen']))))
pdf.cell(20, 7, str(pos['stueckzahl']), align='R')
pdf.cell(30, 7, f"{pos['stueckpreis']:.2f} EUR", align='R')
pdf.cell(30, 7, f"{pos['zeilensumme']:.2f} EUR",
new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
pdf.line(left, pdf.get_y() + 0.5, 195, pdf.get_y() + 0.5)
# --- Summen (linksbundig) ---
pdf.set_x(left)
pdf.ln(8)
pdf.set_font("Helvetica", "", 10)
pdf.cell(180, 6, f"Nettobetrag: {gesamt_netto:.2f} EUR", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
if calc.get('mwst_ausweisen'):
satz = mwst_satz_label(calc['mwst_satz'])
pdf.cell(180, 6, f"MwSt. ({satz}%): {gesamt_mwst:.2f} EUR",
new_x=XPos.LMARGIN, new_y=YPos.NEXT)
pdf.set_font("Helvetica", "B", 12)
label_total = "GESAMTBETRAG (brutto):" if calc.get('mwst_ausweisen') else "GESAMTBETRAG:"
pdf.cell(180, 8, f"{label_total} {gesamt_brutto:.2f} EUR", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
# --- Steuerhinweis je nach Regime ---
steuer_hinweis = ''
if calc.get('kleinunternehmer'):
steuer_hinweis = KLEINUNTERNEHMER_HINWEIS
elif calc.get('privat'):
steuer_hinweis = PRIVAT_HINWEIS
if steuer_hinweis:
pdf.set_font("Helvetica", "", 9)
pdf.ln(4)
pdf.multi_cell(180, 4, pdf_text(steuer_hinweis))
# --- Zahlungsbedingungen ---
pdf.set_font("Helvetica", "", 9)
pdf.ln(6)
schluss = f"{ZAHLUNGSZIEL} {DANK}" if calc.get('ist_unternehmer') else DANK
pdf.cell(180, 4, pdf_text(schluss))
return send_file(
io.BytesIO(bytes(pdf.output())),
mimetype='application/pdf',
as_attachment=True,
download_name='rechnung.pdf'
)
@app.route('/export', methods=['POST'])
def export():
"""Exportiert die Kalkulation als TXT-Datei."""
data = request.get_json(silent=True) or {}
config = load_config()
merged = {**config, **data}
calc = calculate(merged)
lines = [
"3D-DRUCK KOSTENKALKULATION",
"=" * 58 + "",
"",
f"Projekt: {merged.get('projektName', '')}",
f"Datum: {merged.get('datum', '')}",
"",
]
for nummer, pos in enumerate(calc['positionen'], start=1):
label = positions_label(pos, nummer, merged.get('projektName', ''),
calc['anzahl_positionen'])
lines.append(f"POSITION {nummer}: {label}")
lines.append("-" * 58)
lines.append(f" Materialkosten: {pos['materialkosten']:>10.2f} EUR")
lines.append(f" Stromkosten: {pos['stromkosten']:>10.2f} EUR")
lines.append(f" Abschreibung: {pos['abschreibung']:>10.2f} EUR")
lines.append(f" Arbeitskosten: {pos['arbeitskosten']:>10.2f} EUR")
lines.append(f" Kosten je Stuck: {pos['kosten']:>10.2f} EUR")
lines.append(f" Gewinn je Stuck: {pos['gewinn']:>10.2f} EUR")
lines.append(f" Stueckpreis (netto): {pos['stueckpreis']:>10.2f} EUR")
lines.append(f" Stueckzahl: {pos['stueckzahl']:>10}")
lines.append(f" Zeilensumme: {pos['zeilensumme']:>10.2f} EUR")
lines.append("")
satz = mwst_satz_label(calc['mwst_satz'])
lines.append("=" * 58)
lines.append(f"AUFTRAG ({calc['anzahl_positionen']} Positionen, "
f"{calc['teile_gesamt']} Teile)")
lines.append(f" Materialkosten gesamt: {calc['summe_materialkosten']:>10.2f} EUR")
lines.append(f" Stromkosten gesamt: {calc['summe_stromkosten']:>10.2f} EUR")
lines.append(f" Abschreibung gesamt: {calc['summe_abschreibung']:>10.2f} EUR")
lines.append(f" Arbeitskosten gesamt: {calc['summe_arbeitskosten']:>10.2f} EUR")
lines.append(f" Kosten gesamt: {calc['summe_kosten']:>10.2f} EUR")
lines.append(f" Gewinn gesamt: {calc['summe_gewinn']:>10.2f} EUR")
lines.append("-" * 58)
lines.append(f" Auftrag netto: {calc['gesamt_netto']:>10.2f} EUR")
if calc.get('mwst_ausweisen'):
lines.append(f" MwSt. ({satz}%):{'':<{max(1, 16 - len(satz))}}{calc['gesamt_mwst']:>10.2f} EUR")
lines.append(f" GESAMTPREIS: {calc['gesamt_endpreis']:>10.2f} EUR")
if calc.get('kleinunternehmer'):
lines.append("")
lines.append(KLEINUNTERNEHMER_HINWEIS)
elif calc.get('privat'):
lines.append("")
lines.append(PRIVAT_HINWEIS)
text = '\n'.join(lines)
return send_file(
io.BytesIO(text.encode('utf-8')),
mimetype='text/plain',
as_attachment=True,
download_name='kalkulation.txt'
)
def _env_flag(name, default=False):
"""Liest ein Boolean aus einer Umgebungsvariable."""
raw = os.environ.get(name)
if raw is None:
return default
return raw.strip().lower() in ('1', 'true', 'yes', 'on')
if __name__ == '__main__':
# Debug-Modus NIE als Default: der Werkzeug-Debugger erlaubt
# Codeausfuehrung ueber das Netz. Lokal per FLASK_DEBUG=1 einschalten.
debug = _env_flag('FLASK_DEBUG', False)
host = os.environ.get('HOST', '0.0.0.0')
port = int(os.environ.get('PORT', '5001'))
if debug and host == '0.0.0.0':
# Im Debug-Modus nur lokal lauschen.
host = '127.0.0.1'
app.run(host=host, port=port, debug=debug)
Reference in New Issue View Git Blame Copy Permalink