Dominic Gundel
db6a85a703
Senden und Abbruch laufen über den Treiber, Orca-Doppelzeilen und tote Ideen-API fallen weg, Drucker folgen der Datei, Etikettenformat liegt in den Einstellungen.
2968 lines
117 KiB
Python
2968 lines
117 KiB
Python
"""Flask hängt die API und die Seiten an den Kern."""
|
|
|
|
import json
|
|
import re
|
|
import secrets
|
|
import time
|
|
import uuid
|
|
from datetime import datetime, timedelta
|
|
from pathlib import Path
|
|
from urllib.parse import quote
|
|
|
|
import markdown
|
|
import psycopg
|
|
from flask import Flask, Response, abort, g, jsonify, redirect, render_template, request, send_file, session, stream_with_context, url_for
|
|
from markupsafe import Markup
|
|
from psycopg.rows import dict_row
|
|
from werkzeug.middleware.proxy_fix import ProxyFix
|
|
|
|
from grotti import auth as grotti_auth
|
|
from grotti import config as grotti_config
|
|
from grotti import db as grotti_db
|
|
from grotti import eject, jobs, library, logutil, moonraker, notify, store
|
|
from grotti.catalog import color_catalog
|
|
from grotti.cost import calculate, offer_from_file, order_actuals
|
|
from grotti import orders as grotti_orders
|
|
from grotti.errors import GrottiError
|
|
from grotti.printers import FAMILY_LABELS, family_from_name
|
|
from grotti.print_queue import PrintQueueDispatcher
|
|
from grotti.send_queue import SendQueue
|
|
from grotti.toolpath import TOOLPATH_VERSION, build_toolpath
|
|
from grotti.version import __version__
|
|
from grotti import verdict as grotti_verdict
|
|
from grotti.watcher import StateWatcher
|
|
|
|
log = logutil.get("grotti.web")
|
|
|
|
ROOT = Path(__file__).resolve().parent
|
|
TOOL_ROOT = ROOT.parent
|
|
DOCS_DIR = TOOL_ROOT / "docs"
|
|
PROJECT_STATUS = {"idee", "bereit", "druckt", "fertig"}
|
|
VERDICTS = {"", "gut", "ausschuss"}
|
|
VERDICT_REASONS = sorted(grotti_verdict.VERDICT_REASONS)
|
|
PRINTER_FAMILIES = set(FAMILY_LABELS) | {""}
|
|
UPLOAD_SUFFIXES = (".gcode", ".3mf", ".gcode.3mf")
|
|
HOST_RE = re.compile(r"^[A-Za-z0-9.\-]+(?::\d{1,5})?$")
|
|
SERIAL_RE = re.compile(
|
|
r"^(?:COM\d+|/dev/tty(?:USB|ACM)\d+|/dev/serial/by-id/[A-Za-z0-9._\-]+)(?:@\d{3,7})?$",
|
|
re.IGNORECASE,
|
|
)
|
|
TOKEN_QUERY_PATHS = (
|
|
"/api/v1/kamera",
|
|
"/api/v1/kamera/stream",
|
|
"/api/v1/vorschau",
|
|
"/api/v1/dateien/",
|
|
"/api/v1/projekte/",
|
|
)
|
|
STEER_ACTIONS = {
|
|
"nozzle", "bed", "speed", "flow", "fan", "emergency_stop", "clear_error",
|
|
"exclude_object", "dryer_start", "dryer_stop", "slot_setzen",
|
|
}
|
|
|
|
|
|
def validate_printer_host(host):
|
|
host = (host or "").strip()
|
|
if not host or ".." in host or not (HOST_RE.fullmatch(host) or SERIAL_RE.fullmatch(host)):
|
|
raise GrottiError(
|
|
"Host als IP, Hostname, COM-Port (COM5 oder COM5@250000) oder /dev/tty…",
|
|
"host",
|
|
)
|
|
return host
|
|
|
|
|
|
def create_app(cfg):
|
|
app = Flask(
|
|
__name__,
|
|
template_folder=str(ROOT / "templates"),
|
|
static_folder=str(ROOT / "static"),
|
|
)
|
|
app.config["GROTTI"] = cfg
|
|
app.config["SECRET_KEY"] = cfg.get("secret_key") or secrets.token_hex(32)
|
|
app.config["TEMPLATES_AUTO_RELOAD"] = True
|
|
app.config["MAX_CONTENT_LENGTH"] = 256 * 1024 * 1024
|
|
app.config["SESSION_COOKIE_HTTPONLY"] = True
|
|
app.config["SESSION_COOKIE_SAMESITE"] = "Lax"
|
|
# Orca-App-Fenster schließt oft — Session-Cookie muss überleben (30 Tage, gleitend).
|
|
app.config["PERMANENT_SESSION_LIFETIME"] = timedelta(days=30)
|
|
app.config["SESSION_REFRESH_EACH_REQUEST"] = True
|
|
if cfg.get("fqdn", "").startswith("https://"):
|
|
app.config["SESSION_COOKIE_SECURE"] = True
|
|
app.json.ensure_ascii = False
|
|
# Hinter Reverse Proxy: X-Forwarded-For für Rate-Limits.
|
|
app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1)
|
|
# Threads starten in server.main() — Tests können create_app ohne Netz/DB-Worker nutzen.
|
|
app.extensions["send_queue"] = SendQueue(cfg["database_url"], cfg)
|
|
watcher = StateWatcher(cfg["database_url"], cfg)
|
|
dispatcher = PrintQueueDispatcher(cfg["database_url"], cfg, watcher=watcher)
|
|
app.extensions["print_queue"] = dispatcher
|
|
app.extensions["watcher"] = watcher
|
|
|
|
PUBLIC_PATHS = {
|
|
"/login",
|
|
"/setup",
|
|
"/api/v1/auth/status",
|
|
"/api/v1/auth/login",
|
|
"/api/v1/auth/token",
|
|
"/api/v1/auth/setup",
|
|
"/api/v1/version",
|
|
}
|
|
ADMIN_API_PREFIXES = (
|
|
"/api/v1/users",
|
|
"/api/v1/einstellungen",
|
|
"/api/v1/backup",
|
|
)
|
|
ADMIN_API_EXACT = {
|
|
"/api/v1/telegram/test",
|
|
"/api/v1/ntfy/test",
|
|
}
|
|
ADMIN_METHODS_ON = {
|
|
# Drucker anlegen/ändern/löschen nur Admin
|
|
("POST", "/api/v1/drucker"),
|
|
}
|
|
|
|
def conn():
|
|
if "db" not in g:
|
|
try:
|
|
pool = grotti_db.get_pool()
|
|
g.db = pool.getconn()
|
|
g.db_from_pool = True
|
|
except RuntimeError:
|
|
g.db = psycopg.connect(cfg["database_url"], row_factory=dict_row)
|
|
g.db_from_pool = False
|
|
return g.db
|
|
|
|
def ensure_csrf():
|
|
if not session.get("csrf"):
|
|
session["csrf"] = grotti_auth.new_csrf()
|
|
return session["csrf"]
|
|
|
|
def auth_user():
|
|
return getattr(g, "user", None)
|
|
|
|
def require_role(need):
|
|
user = auth_user()
|
|
if not user or not grotti_auth.role_at_least(user.get("role"), need):
|
|
raise GrottiError("Keine Berechtigung.", "forbidden", 403)
|
|
return user
|
|
|
|
def resolve_bearer(presented):
|
|
if not presented.startswith(grotti_auth.TOKEN_PREFIX):
|
|
return None
|
|
row = store.get_api_token_by_hash(conn(), grotti_auth.hash_token(presented))
|
|
if not row or row.get("revoked_at") or not row.get("user_active"):
|
|
return None
|
|
if row.get("expires_at") and row["expires_at"].timestamp() < time.time():
|
|
return None
|
|
store.touch_api_token(conn(), row["id"])
|
|
return {
|
|
"id": row["user_id"],
|
|
"username": row["username"],
|
|
"role": row["role"],
|
|
"auth": "token",
|
|
"token_id": row["id"],
|
|
}
|
|
|
|
def resolve_session_user():
|
|
uid = session.get("user_id")
|
|
if not uid:
|
|
return None
|
|
row = store.get_user(conn(), uid)
|
|
if not row or not row.get("active"):
|
|
session.clear()
|
|
return None
|
|
return {
|
|
"id": row["id"],
|
|
"username": row["username"],
|
|
"role": row["role"],
|
|
"auth": "session",
|
|
}
|
|
|
|
def wants_json():
|
|
if request.path.startswith("/api/"):
|
|
return True
|
|
accept = request.accept_mimetypes
|
|
return accept.best == "application/json"
|
|
|
|
@app.before_request
|
|
def check_auth():
|
|
g.user = None
|
|
path = request.path
|
|
if path.startswith("/static/"):
|
|
return None
|
|
if path in PUBLIC_PATHS:
|
|
return None
|
|
|
|
users_exist = store.user_count(conn()) > 0
|
|
if not users_exist:
|
|
if path.startswith("/api/") and path != "/api/v1/auth/setup":
|
|
if path == "/api/v1/auth/status":
|
|
return None
|
|
return jsonify({
|
|
"error": "Zuerst Admin anlegen.",
|
|
"code": "setup",
|
|
"setup": True,
|
|
}), 503
|
|
if path != "/setup":
|
|
return redirect(url_for("setup_page"))
|
|
return None
|
|
|
|
presented = ""
|
|
header = request.headers.get("Authorization", "")
|
|
if header.startswith("Bearer "):
|
|
presented = header[7:].strip()
|
|
elif (
|
|
request.method == "GET"
|
|
and any(request.path.startswith(p) for p in TOKEN_QUERY_PATHS)
|
|
):
|
|
# Token in der URL nur für Bild-Endpunkte (img-src ohne Header).
|
|
presented = (request.args.get("token") or "").strip()
|
|
|
|
user = None
|
|
if presented:
|
|
user = resolve_bearer(presented)
|
|
if not user:
|
|
return jsonify({"error": "Token fehlt oder stimmt nicht.", "code": "token"}), 401
|
|
else:
|
|
user = resolve_session_user()
|
|
|
|
if not user:
|
|
if wants_json() or path.startswith("/api/"):
|
|
return jsonify({"error": "Anmeldung nötig.", "code": "auth"}), 401
|
|
# Query behalten (z. B. /dateien?file=12 nach Orca-Upload)
|
|
next_path = path
|
|
if request.query_string:
|
|
next_path = path + "?" + request.query_string.decode("utf-8", "replace")
|
|
return redirect(url_for("login_page", next=next_path))
|
|
|
|
g.user = user
|
|
ensure_csrf()
|
|
|
|
# CSRF für Cookie-Sessions bei mutierenden API-Calls
|
|
if (
|
|
user.get("auth") == "session"
|
|
and path.startswith("/api/")
|
|
and request.method in ("POST", "PATCH", "PUT", "DELETE")
|
|
):
|
|
sent = request.headers.get("X-CSRF-Token") or ""
|
|
expected = session.get("csrf") or ""
|
|
if not expected or not secrets.compare_digest(sent, expected):
|
|
return jsonify({"error": "CSRF-Token fehlt oder ungültig.", "code": "csrf"}), 403
|
|
|
|
need_admin = False
|
|
if path.startswith(ADMIN_API_PREFIXES) or path in ADMIN_API_EXACT:
|
|
if path == "/api/v1/einstellungen" and request.method == "GET":
|
|
need_admin = False
|
|
elif path == "/api/v1/einstellungen" and request.method == "PATCH":
|
|
# Operator darf nur Automatik-Schalter setzen
|
|
payload = request.get_json(silent=True) or {}
|
|
keys = {k for k, v in payload.items() if v is not None}
|
|
need_admin = keys - {"auto_queue", "auto_retry"} != set()
|
|
elif path.startswith("/api/v1/users"):
|
|
need_admin = True
|
|
elif request.method != "GET":
|
|
need_admin = True
|
|
if (request.method, path) in ADMIN_METHODS_ON:
|
|
need_admin = True
|
|
if path.startswith("/api/v1/drucker/id/") and request.method in ("PATCH", "DELETE"):
|
|
need_admin = True
|
|
if need_admin and not grotti_auth.role_at_least(user.get("role"), "admin"):
|
|
return jsonify({"error": "Nur für Admins.", "code": "forbidden"}), 403
|
|
return None
|
|
|
|
@app.teardown_appcontext
|
|
def close_db(exc):
|
|
db_conn = g.pop("db", None)
|
|
from_pool = g.pop("db_from_pool", False)
|
|
if not db_conn:
|
|
return
|
|
try:
|
|
if exc:
|
|
db_conn.rollback()
|
|
else:
|
|
db_conn.commit()
|
|
except Exception:
|
|
try:
|
|
db_conn.rollback()
|
|
except Exception:
|
|
pass
|
|
finally:
|
|
if from_pool:
|
|
try:
|
|
grotti_db.get_pool().putconn(db_conn)
|
|
except Exception:
|
|
try:
|
|
db_conn.close()
|
|
except Exception:
|
|
pass
|
|
else:
|
|
db_conn.close()
|
|
|
|
@app.errorhandler(GrottiError)
|
|
def grotti_error(err):
|
|
db_conn = g.get("db")
|
|
if db_conn:
|
|
try:
|
|
db_conn.rollback()
|
|
except Exception:
|
|
pass
|
|
return jsonify({"error": err.message, "code": err.code}), err.status
|
|
|
|
@app.errorhandler(psycopg.Error)
|
|
def psycopg_error(err):
|
|
db_conn = g.get("db")
|
|
if db_conn:
|
|
try:
|
|
db_conn.rollback()
|
|
except Exception:
|
|
pass
|
|
message = "Datenbankfehler."
|
|
if isinstance(err, psycopg.errors.ForeignKeyViolation):
|
|
message = "Der Eintrag hängt noch an anderen Daten."
|
|
elif isinstance(err, psycopg.errors.UniqueViolation):
|
|
message = "Diesen Eintrag gibt es schon."
|
|
elif isinstance(err, psycopg.errors.InvalidTextRepresentation):
|
|
message = "Ungültiger Wert in der Anfrage."
|
|
log.warning("DB: %s", err)
|
|
return jsonify({"error": message, "code": "db"}), 500
|
|
|
|
def body():
|
|
data = request.get_json(silent=True)
|
|
if not isinstance(data, dict):
|
|
raise GrottiError("JSON-Objekt erwartet.", "json")
|
|
return data
|
|
|
|
def optional_id(value):
|
|
if value in (None, "", 0, "0"):
|
|
return None
|
|
try:
|
|
return int(value)
|
|
except (TypeError, ValueError) as exc:
|
|
raise GrottiError("Die Nummer stimmt nicht.", "id") from exc
|
|
|
|
def require_host(host):
|
|
if not store.printer_by_host(conn(), host or ""):
|
|
raise GrottiError("Diesen Drucker kennt Grotti nicht.", "drucker", 404)
|
|
return host
|
|
|
|
def optional_host(host):
|
|
host = (host or "").strip()
|
|
if host:
|
|
require_host(host)
|
|
return host
|
|
|
|
_icons_cache = {"html": "", "mtime": None}
|
|
|
|
def icons_sprite_html():
|
|
path = ROOT / "static" / "icons.svg"
|
|
try:
|
|
mtime = path.stat().st_mtime
|
|
except OSError:
|
|
return ""
|
|
if _icons_cache["html"] and _icons_cache["mtime"] == mtime:
|
|
return _icons_cache["html"]
|
|
text = path.read_text(encoding="utf-8")
|
|
text = re.sub(r"<\?xml[^?]*\?>\s*", "", text)
|
|
text = re.sub(r"<!--.*?-->\s*", "", text, count=1, flags=re.DOTALL)
|
|
text = text.replace("<svg ", '<svg width="0" height="0" style="position:absolute" aria-hidden="true" ', 1)
|
|
_icons_cache["html"] = text
|
|
_icons_cache["mtime"] = mtime
|
|
return text
|
|
|
|
@app.context_processor
|
|
def inject_globals():
|
|
user = auth_user()
|
|
return {
|
|
"version": __version__,
|
|
"csrf": session.get("csrf") or "",
|
|
"current_user": user,
|
|
"icons_sprite": Markup(icons_sprite_html()),
|
|
}
|
|
|
|
def page(name, title):
|
|
return render_template(
|
|
name,
|
|
page=name.split(".")[0],
|
|
title=title,
|
|
token="",
|
|
)
|
|
|
|
def audit(kind, message, host=""):
|
|
user = auth_user()
|
|
who = (user or {}).get("username") or "?"
|
|
store.add_event(conn(), host, "", kind, "%s · %s" % (who, message))
|
|
|
|
@app.get("/login")
|
|
def login_page():
|
|
if store.user_count(conn()) == 0:
|
|
return redirect(url_for("setup_page"))
|
|
if resolve_session_user():
|
|
return redirect("/")
|
|
ensure_csrf()
|
|
return render_template("login.html", title="Anmelden", csrf=session.get("csrf") or "")
|
|
|
|
@app.get("/setup")
|
|
def setup_page():
|
|
if store.user_count(conn()) > 0:
|
|
return redirect(url_for("login_page"))
|
|
ensure_csrf()
|
|
return render_template("setup.html", title="Ersten Admin anlegen", csrf=session.get("csrf") or "")
|
|
|
|
@app.get("/api/v1/auth/status")
|
|
def auth_status():
|
|
count = store.user_count(conn())
|
|
user = resolve_session_user()
|
|
return jsonify({
|
|
"setup_required": count == 0,
|
|
"authenticated": bool(user or auth_user()),
|
|
"user": grotti_auth.public_user(user) if user else None,
|
|
"oauth_enabled": bool((cfg.get("oauth") or {}).get("enabled")),
|
|
"legacy_token_set": bool(cfg.get("token")),
|
|
})
|
|
|
|
@app.post("/api/v1/auth/setup")
|
|
def auth_setup():
|
|
if store.user_count(conn()) > 0:
|
|
raise GrottiError("Setup ist schon erledigt.", "setup", 409)
|
|
data = body()
|
|
username = grotti_auth.validate_username(data.get("username") or "")
|
|
password = grotti_auth.validate_password(data.get("password") or "")
|
|
row = store.create_user(conn(), username, grotti_auth.hash_password(password), "admin")
|
|
grotti_db.invalidate_user_count()
|
|
store.touch_user_login(conn(), row["id"])
|
|
session.clear()
|
|
session.permanent = True
|
|
session["user_id"] = row["id"]
|
|
session["csrf"] = grotti_auth.new_csrf()
|
|
store.add_event(conn(), "", "", "auth", "Admin %s angelegt" % username)
|
|
return jsonify({"user": grotti_auth.public_user(row), "csrf": session["csrf"]}), 201
|
|
|
|
@app.post("/api/v1/auth/login")
|
|
def auth_login():
|
|
if store.user_count(conn()) == 0:
|
|
raise GrottiError("Zuerst Admin anlegen.", "setup", 503)
|
|
key = request.remote_addr or "unknown"
|
|
if not grotti_auth.login_rate_ok(key):
|
|
raise GrottiError("Zu viele Versuche. Bitte warten.", "rate", 429)
|
|
data = body()
|
|
username = (data.get("username") or "").strip()
|
|
password = data.get("password") or ""
|
|
row = store.get_user_by_name(conn(), username)
|
|
if not row or not row.get("active") or not grotti_auth.verify_password(row["password_hash"], password):
|
|
grotti_auth.login_rate_hit(key)
|
|
raise GrottiError("Benutzer oder Passwort falsch.", "auth", 401)
|
|
store.touch_user_login(conn(), row["id"])
|
|
session.clear()
|
|
session.permanent = True
|
|
session["user_id"] = row["id"]
|
|
session["csrf"] = grotti_auth.new_csrf()
|
|
store.add_event(conn(), "", "", "auth", "Login %s" % row["username"])
|
|
return jsonify({"user": grotti_auth.public_user(row), "csrf": session["csrf"]})
|
|
|
|
@app.post("/api/v1/auth/token")
|
|
def auth_token():
|
|
"""Passwort → API-Token (für Android/App). Keine Session, Rate-Limit wie Login."""
|
|
if store.user_count(conn()) == 0:
|
|
raise GrottiError("Zuerst Admin anlegen.", "setup", 503)
|
|
key = request.remote_addr or "unknown"
|
|
if not grotti_auth.login_rate_ok(key):
|
|
raise GrottiError("Zu viele Versuche. Bitte warten.", "rate", 429)
|
|
data = body()
|
|
username = (data.get("username") or "").strip()
|
|
password = data.get("password") or ""
|
|
device = (data.get("device_name") or data.get("name") or "App").strip()[:80] or "App"
|
|
row = store.get_user_by_name(conn(), username)
|
|
if not row or not row.get("active") or not grotti_auth.verify_password(row["password_hash"], password):
|
|
grotti_auth.login_rate_hit(key)
|
|
raise GrottiError("Benutzer oder Passwort falsch.", "auth", 401)
|
|
store.touch_user_login(conn(), row["id"])
|
|
raw = grotti_auth.new_api_token()
|
|
role = grotti_auth.clamp_token_role(row["role"], data.get("role"))
|
|
token_row = store.create_api_token(
|
|
conn(),
|
|
row["id"],
|
|
device,
|
|
grotti_auth.hash_token(raw),
|
|
grotti_auth.token_prefix(raw),
|
|
role,
|
|
)
|
|
store.add_event(conn(), "", "", "auth", "Token „%s“ für %s" % (device, row["username"]))
|
|
item = grotti_auth.public_token(token_row)
|
|
item["token"] = raw
|
|
item["user"] = grotti_auth.public_user(row)
|
|
return jsonify(item), 201
|
|
|
|
@app.post("/api/v1/auth/logout")
|
|
def auth_logout():
|
|
session.clear()
|
|
return jsonify({"ok": True})
|
|
|
|
@app.get("/api/v1/me")
|
|
def me():
|
|
user = require_role("operator")
|
|
return jsonify({"user": {
|
|
"id": user["id"],
|
|
"username": user["username"],
|
|
"role": user["role"],
|
|
"auth": user.get("auth"),
|
|
}, "csrf": ensure_csrf()})
|
|
|
|
@app.get("/api/v1/users")
|
|
def users_list():
|
|
require_role("admin")
|
|
return jsonify([grotti_auth.public_user(r) for r in store.list_users(conn())])
|
|
|
|
@app.post("/api/v1/users")
|
|
def users_create():
|
|
require_role("admin")
|
|
data = body()
|
|
username = grotti_auth.validate_username(data.get("username") or "")
|
|
password = grotti_auth.validate_password(data.get("password") or "")
|
|
role = grotti_auth.normalize_role(data.get("role") or "operator")
|
|
if store.get_user_by_name(conn(), username):
|
|
raise GrottiError("Benutzer gibt es schon.", "user", 409)
|
|
row = store.create_user(conn(), username, grotti_auth.hash_password(password), role)
|
|
grotti_db.invalidate_user_count()
|
|
audit("auth", "Benutzer %s (%s) angelegt" % (username, role))
|
|
return jsonify(grotti_auth.public_user(row)), 201
|
|
|
|
@app.patch("/api/v1/users/<int:user_id>")
|
|
def users_patch(user_id):
|
|
actor = require_role("admin")
|
|
data = body()
|
|
row = store.get_user(conn(), user_id)
|
|
if not row:
|
|
raise GrottiError("Benutzer fehlt.", "user", 404)
|
|
password_hash = None
|
|
if data.get("password"):
|
|
password_hash = grotti_auth.hash_password(grotti_auth.validate_password(data["password"]))
|
|
role = grotti_auth.normalize_role(data["role"]) if "role" in data else None
|
|
active = data.get("active") if "active" in data else None
|
|
if active is False and row["id"] == actor.get("id"):
|
|
raise GrottiError("Eigenes Konto nicht deaktivieren.", "user")
|
|
if role == "operator" and row["role"] == "admin" and row["id"] == actor.get("id"):
|
|
admins = [u for u in store.list_users(conn()) if u["role"] == "admin" and u["active"]]
|
|
if len(admins) <= 1:
|
|
raise GrottiError("Letzter Admin bleibt Admin.", "user")
|
|
updated = store.update_user(conn(), user_id, password_hash=password_hash, role=role, active=active)
|
|
audit("auth", "Benutzer %s geändert" % row["username"])
|
|
return jsonify(grotti_auth.public_user(updated))
|
|
|
|
@app.delete("/api/v1/users/<int:user_id>")
|
|
def users_delete(user_id):
|
|
actor = require_role("admin")
|
|
row = store.get_user(conn(), user_id)
|
|
if not row:
|
|
raise GrottiError("Benutzer fehlt.", "user", 404)
|
|
if row["id"] == actor.get("id"):
|
|
raise GrottiError("Eigenes Konto nicht löschen.", "user")
|
|
if row["role"] == "admin":
|
|
admins = [u for u in store.list_users(conn()) if u["role"] == "admin" and u["active"]]
|
|
if len(admins) <= 1:
|
|
raise GrottiError("Letzter Admin bleibt.", "user")
|
|
store.delete_user(conn(), user_id)
|
|
audit("auth", "Benutzer %s gelöscht" % row["username"])
|
|
return "", 204
|
|
|
|
@app.get("/api/v1/tokens")
|
|
def tokens_list():
|
|
user = require_role("operator")
|
|
if user.get("role") == "admin" and request.args.get("all") == "1":
|
|
rows = store.list_api_tokens(conn(), user_id=None)
|
|
else:
|
|
if not user.get("id"):
|
|
return jsonify([])
|
|
rows = store.list_api_tokens(conn(), user_id=user["id"])
|
|
out = []
|
|
for row in rows:
|
|
item = grotti_auth.public_token(row)
|
|
item["username"] = row.get("username")
|
|
out.append(item)
|
|
return jsonify(out)
|
|
|
|
@app.post("/api/v1/tokens")
|
|
def tokens_create():
|
|
user = require_role("operator")
|
|
if not user.get("id"):
|
|
raise GrottiError("Legacy-Token: bitte Benutzer-Token anlegen.", "token")
|
|
data = body()
|
|
name = (data.get("name") or "Token").strip()[:80]
|
|
role = grotti_auth.clamp_token_role(user["role"], data.get("role"))
|
|
raw = grotti_auth.new_api_token()
|
|
row = store.create_api_token(
|
|
conn(),
|
|
user["id"],
|
|
name,
|
|
grotti_auth.hash_token(raw),
|
|
grotti_auth.token_prefix(raw),
|
|
role,
|
|
)
|
|
audit("auth", "API-Token „%s“ erzeugt" % name)
|
|
item = grotti_auth.public_token(row)
|
|
item["token"] = raw
|
|
return jsonify(item), 201
|
|
|
|
@app.delete("/api/v1/tokens/<int:token_id>")
|
|
def tokens_revoke(token_id):
|
|
user = require_role("operator")
|
|
if user.get("role") == "admin":
|
|
row = store.revoke_api_token(conn(), token_id, user_id=None)
|
|
else:
|
|
row = store.revoke_api_token(conn(), token_id, user_id=user.get("id"))
|
|
if not row:
|
|
raise GrottiError("Token fehlt.", "token", 404)
|
|
audit("auth", "API-Token #%s widerrufen" % token_id)
|
|
return jsonify(grotti_auth.public_token(row))
|
|
|
|
def doc_names():
|
|
"""Nur Anleitung-*.md — Technik liegt unter docs/internal/ (nicht in der App)."""
|
|
if not DOCS_DIR.is_dir():
|
|
return []
|
|
return sorted(p.stem for p in DOCS_DIR.glob("Anleitung-*.md"))
|
|
|
|
ANLEITUNG_ORDER = (
|
|
"Anleitung-Einrichtung",
|
|
"Anleitung-Installation-Pi",
|
|
"Anleitung-Oberflaeche",
|
|
"Anleitung-Wand",
|
|
"Anleitung-Dateien",
|
|
"Anleitung-Orca",
|
|
"Anleitung-ACE",
|
|
"Anleitung-Warteschlange",
|
|
"Anleitung-Auftraege",
|
|
"Anleitung-Material",
|
|
"Anleitung-Wartung",
|
|
"Anleitung-Einstellungen",
|
|
"Anleitung-Stoerungen",
|
|
)
|
|
|
|
def anleitung_list(names=None):
|
|
names = names if names is not None else doc_names()
|
|
anleitung_set = set(names)
|
|
ordered = [n for n in ANLEITUNG_ORDER if n in anleitung_set]
|
|
ordered += sorted(anleitung_set - set(ordered))
|
|
return ordered
|
|
|
|
def anleitung_title(name):
|
|
labels = {
|
|
"Anleitung-Einrichtung": "Einrichtung",
|
|
"Anleitung-Installation-Pi": "Raspberry Pi (.deb)",
|
|
"Anleitung-Oberflaeche": "Oberfläche",
|
|
"Anleitung-Wand": "Druckerwand",
|
|
"Anleitung-Dateien": "Dateien senden",
|
|
"Anleitung-Orca": "Orca an Grotti",
|
|
"Anleitung-ACE": "ACE und Spulen",
|
|
"Anleitung-Warteschlange": "Warteschlange",
|
|
"Anleitung-Auftraege": "Aufträge",
|
|
"Anleitung-Material": "Material und mehr",
|
|
"Anleitung-Wartung": "Wartung",
|
|
"Anleitung-Einstellungen": "Einstellungen",
|
|
"Anleitung-Stoerungen": "Störungen",
|
|
}
|
|
return labels.get(name, name.replace("Anleitung-", "").replace("-", " "))
|
|
|
|
def render_markdown(path):
|
|
"""Markdown für die App: Git-relative Bild-/Kapitelpfade → App-URLs."""
|
|
text = path.read_text(encoding="utf-8")
|
|
# docs/… → web/static/… im Repo; unter /doku als /static/…
|
|
text = text.replace("../web/static/", "/static/")
|
|
text = re.sub(
|
|
r"\]\((Anleitung-[A-Za-z0-9_-]+)(?:\.md)?\)",
|
|
r"](/doku/\1)",
|
|
text,
|
|
)
|
|
html = markdown.markdown(text, extensions=["tables", "fenced_code", "sane_lists"])
|
|
return Markup(html)
|
|
|
|
@app.get("/")
|
|
def wand():
|
|
return page("wand.html", "Drucker")
|
|
|
|
@app.get("/kameras")
|
|
def kameras():
|
|
"""Alte Links → Wand (Kameras sitzen als Snapshot-Thumbs auf den Karten)."""
|
|
return redirect("/", code=301)
|
|
|
|
@app.get("/dateien")
|
|
def dateien():
|
|
return page("dateien.html", "Dateien")
|
|
|
|
@app.get("/projekte")
|
|
def projekte():
|
|
return page("projekte.html", "Projekte")
|
|
|
|
@app.get("/auftraege")
|
|
def auftraege_page():
|
|
return page("auftraege.html", "Aufträge")
|
|
|
|
@app.get("/auftraege/<int:order_id>/lieferschein")
|
|
def auftrag_lieferschein(order_id):
|
|
row = grotti_orders.get_order(conn(), order_id)
|
|
if not row:
|
|
abort(404)
|
|
return render_template(
|
|
"lieferschein.html",
|
|
page="auftraege",
|
|
title="Lieferschein #%s" % order_id,
|
|
order=row,
|
|
)
|
|
|
|
@app.get("/einstellungen")
|
|
def einstellungen_page():
|
|
return page("einstellungen.html", "Einstellungen")
|
|
|
|
@app.get("/material")
|
|
def material():
|
|
return page("material.html", "Material")
|
|
|
|
@app.get("/etikett/<int:spool_id>")
|
|
def etikett(spool_id):
|
|
row = store.get_spool_row(conn(), spool_id)
|
|
if not row:
|
|
abort(404)
|
|
spool = store.spool_out(row)
|
|
if not spool.get("chargen_nr"):
|
|
store.ensure_spool_codes(conn())
|
|
row = store.get_spool_row(conn(), spool_id)
|
|
spool = store.spool_out(row)
|
|
base = grotti_config.public_base(cfg, request.url_root)
|
|
qr_url = "%s/material?spool=%s" % (base, spool_id)
|
|
return render_template(
|
|
"etikett.html",
|
|
page="etikett",
|
|
title="Etikett %s" % spool["chargen_nr"],
|
|
token="",
|
|
spool=spool,
|
|
qr_url=qr_url,
|
|
etikett=cfg.get("etikett") or grotti_config._etikett({}),
|
|
)
|
|
|
|
@app.get("/protokoll")
|
|
def protokoll():
|
|
return page("protokoll.html", "Protokoll")
|
|
|
|
@app.get("/protokoll/<int:run_id>")
|
|
def protokoll_detail(run_id):
|
|
row = store.get_run_row(conn(), run_id)
|
|
if not row:
|
|
abort(404)
|
|
return page("bericht.html", "Druckbericht")
|
|
|
|
@app.get("/statistik")
|
|
def statistik_page():
|
|
return page("statistik.html", "Statistik")
|
|
|
|
@app.get("/wartung")
|
|
def wartung_page():
|
|
return page("wartung.html", "Wartung")
|
|
|
|
@app.get("/etikett/lauf/<int:run_id>")
|
|
def etikett_lauf(run_id):
|
|
row = store.get_run_row(conn(), run_id)
|
|
if not row:
|
|
abort(404)
|
|
run = store.run_out(row)
|
|
if not run.get("chargen_nr"):
|
|
store.ensure_run_chargen(conn(), run_id, run.get("weight_used_g"))
|
|
row = store.get_run_row(conn(), run_id)
|
|
run = store.run_out(row)
|
|
if not run.get("chargen_nr"):
|
|
abort(404)
|
|
labels = store.list_run_labels(conn(), run_id)
|
|
mode = (request.args.get("mode") or "druck").strip()
|
|
qty = max(1, min(50, int(request.args.get("qty") or 1)))
|
|
if mode == "objekt":
|
|
labels = store.ensure_run_labels(conn(), run_id, run.get("objects") or [], qty=qty)
|
|
sheets = [lab for lab in labels if not lab.get("excluded")]
|
|
else:
|
|
sheets = [{"object_name": "", "chargen_nr": run["chargen_nr"], "excluded": False}]
|
|
if not sheets:
|
|
abort(404)
|
|
spools = store.etikett_spools_for_run(conn(), run)
|
|
base = grotti_config.public_base(cfg, request.url_root)
|
|
target_g = float(run.get("weight_planned_g") or run.get("weight_g") or 0)
|
|
for sheet in sheets:
|
|
sheet["qr_url"] = "%s/protokoll/%s" % (base, run_id)
|
|
sheet["target_g"] = target_g
|
|
if sheet.get("object_name"):
|
|
sheet["qr_url"] += "#objekt-%s" % quote(sheet["object_name"])
|
|
return render_template(
|
|
"etikett_lauf.html",
|
|
page="etikett",
|
|
title="Etikett %s" % run["chargen_nr"],
|
|
token="",
|
|
run=run,
|
|
sheets=sheets,
|
|
spools=spools,
|
|
target_g=target_g,
|
|
etikett=cfg.get("etikett") or grotti_config._etikett({}),
|
|
)
|
|
|
|
@app.get("/ideen")
|
|
def ideen():
|
|
return redirect("/auftraege", code=301)
|
|
|
|
@app.get("/jetzt")
|
|
def jetzt_page():
|
|
return page("jetzt.html", "Jetzt")
|
|
|
|
@app.get("/aktivitaet")
|
|
def aktivitaet():
|
|
return page("aktivitaet.html", "Aktivität")
|
|
|
|
@app.get("/warteschlange")
|
|
def warteschlange_page():
|
|
return page("warteschlange.html", "Warteschlange")
|
|
|
|
@app.get("/doku")
|
|
def doku():
|
|
names = doc_names()
|
|
anleitung = anleitung_list(names)
|
|
return render_template(
|
|
"doku.html",
|
|
page="doku",
|
|
title="Doku",
|
|
token="",
|
|
docs=names,
|
|
anleitung=anleitung,
|
|
anleitung_title=anleitung_title,
|
|
)
|
|
|
|
@app.get("/doku/<name>")
|
|
def doku_page(name):
|
|
names = doc_names()
|
|
if name not in names:
|
|
abort(404)
|
|
path = DOCS_DIR / ("%s.md" % name)
|
|
if not path.is_file():
|
|
abort(404)
|
|
anleitung = anleitung_list(names)
|
|
return render_template(
|
|
"doku_page.html",
|
|
page="doku",
|
|
title=anleitung_title(name),
|
|
token="",
|
|
content=render_markdown(path),
|
|
docs=names,
|
|
anleitung=anleitung,
|
|
anleitung_title=anleitung_title,
|
|
current=name,
|
|
)
|
|
|
|
@app.get("/api/v1/version")
|
|
def version_info():
|
|
return jsonify({
|
|
"name": "Grotti",
|
|
"version": __version__,
|
|
"api": 1,
|
|
"features": [
|
|
"auth_token",
|
|
"sse",
|
|
"queue",
|
|
"projects",
|
|
"orders",
|
|
"spools",
|
|
"camera",
|
|
"confirm",
|
|
"ntfy",
|
|
],
|
|
})
|
|
|
|
@app.get("/api/v1/einstellungen")
|
|
def settings():
|
|
return jsonify(grotti_config.settings_public(cfg))
|
|
|
|
@app.patch("/api/v1/einstellungen")
|
|
def settings_patch():
|
|
data = body()
|
|
energy = data.get("energy") if isinstance(data.get("energy"), dict) else None
|
|
telegram = data.get("telegram") if isinstance(data.get("telegram"), dict) else None
|
|
ntfy = data.get("ntfy") if isinstance(data.get("ntfy"), dict) else None
|
|
alerts = data.get("alerts") if isinstance(data.get("alerts"), dict) else None
|
|
auto_queue = data.get("auto_queue") if "auto_queue" in data else None
|
|
auto_retry = data.get("auto_retry") if "auto_retry" in data else None
|
|
fqdn = data.get("fqdn") if "fqdn" in data else None
|
|
watch_dir = data.get("watch_dir") if "watch_dir" in data else None
|
|
etikett = data.get("etikett") if isinstance(data.get("etikett"), dict) else None
|
|
return jsonify(grotti_config.save_settings(
|
|
cfg,
|
|
energy=energy,
|
|
telegram=telegram,
|
|
ntfy=ntfy,
|
|
alerts=alerts,
|
|
auto_queue=auto_queue,
|
|
auto_retry=auto_retry,
|
|
fqdn=fqdn,
|
|
watch_dir=watch_dir,
|
|
etikett=etikett,
|
|
))
|
|
|
|
@app.post("/api/v1/telegram/test")
|
|
def telegram_test():
|
|
ok = notify.send_telegram(cfg, "Grotti-Test: Telegram ist verbunden.")
|
|
if not ok:
|
|
raise GrottiError(
|
|
"Telegram nicht erreichbar. Token, Chat-ID und „aktiv“ prüfen.",
|
|
"telegram",
|
|
)
|
|
return jsonify({"ok": True})
|
|
|
|
@app.post("/api/v1/ntfy/test")
|
|
def ntfy_test():
|
|
ok = notify.send_ntfy(cfg, "Grotti-Test: ntfy ist verbunden.")
|
|
if not ok:
|
|
raise GrottiError(
|
|
"ntfy nicht erreichbar. Server, Topic und „aktiv“ prüfen.",
|
|
"ntfy",
|
|
)
|
|
return jsonify({"ok": True})
|
|
|
|
@app.get("/api/v1/drucker")
|
|
def printers():
|
|
rows = store.list_printers(conn())
|
|
clears = store.bed_clear_map(conn())
|
|
queues = store.queue_by_host(conn(), rows)
|
|
|
|
def attach(item):
|
|
host = item.get("host") or ""
|
|
item["needs_clear"] = bool(clears.get(host))
|
|
queue = queues.get(host) or {}
|
|
item["queue_running"] = queue.get("running")
|
|
item["queue_failed"] = queue.get("failed")
|
|
item["queue_waiting"] = queue.get("waiting", 0)
|
|
item["queue_waiting_next"] = queue.get("waiting_next", "")
|
|
live_run = store.find_live_run(conn(), host) if host else None
|
|
item["live_run_id"] = (live_run or {}).get("id")
|
|
item["live_chargen"] = (live_run or {}).get("chargen_nr") or ""
|
|
|
|
by_id = {row["host"]: row for row in rows}
|
|
if request.args.get("live", "1") == "0":
|
|
from grotti.drivers import for_printer
|
|
for row in rows:
|
|
if for_printer(row).transport == "moonraker":
|
|
row["mainsail"] = "http://%s/" % row["host"]
|
|
else:
|
|
row["mainsail"] = ""
|
|
attach(row)
|
|
return jsonify(rows)
|
|
# Eine Live-Quelle: Watcher. Frischer als 60 s, sonst einmal selbst abfragen.
|
|
watcher = app.extensions["watcher"]
|
|
cached = watcher.by_host()
|
|
age = watcher.age_s()
|
|
if not cached or age is None or age > 60:
|
|
from grotti.drivers import snapshot
|
|
lives = snapshot(rows)
|
|
else:
|
|
lives = []
|
|
for row in rows:
|
|
live = cached.get(row["host"])
|
|
if live:
|
|
item = dict(live)
|
|
item["name"] = row["name"]
|
|
item["family"] = row["family"]
|
|
item["family_label"] = row["family_label"]
|
|
lives.append(item)
|
|
else:
|
|
item = dict(row)
|
|
item["ok"] = False
|
|
item["state"] = "offline"
|
|
from grotti.drivers import for_printer as _for_printer
|
|
if _for_printer(row).transport == "moonraker":
|
|
item["mainsail"] = "http://%s/" % row["host"]
|
|
else:
|
|
item["mainsail"] = ""
|
|
lives.append(item)
|
|
for live in lives:
|
|
meta = by_id.get(live.get("host") or "") or {}
|
|
live["locked"] = bool(meta.get("locked"))
|
|
attach(live)
|
|
return jsonify(lives)
|
|
|
|
@app.get("/api/v1/marlin-dienst")
|
|
def marlin_dienst():
|
|
from grotti.marlin_supervisor import current_status, ensure_if_enabled
|
|
|
|
ensure_if_enabled()
|
|
return jsonify(current_status())
|
|
|
|
@app.post("/api/v1/meldungen")
|
|
def meldung_create():
|
|
from grotti import meldung as grotti_meldung
|
|
|
|
require_role("operator")
|
|
data = body()
|
|
try:
|
|
row = grotti_meldung.create(
|
|
conn(),
|
|
cfg,
|
|
text=data.get("text") or "",
|
|
page=data.get("page") or "",
|
|
printer_host=data.get("printer_host") or "",
|
|
error_text=data.get("error_text") or "",
|
|
user=g.user,
|
|
)
|
|
conn().commit()
|
|
except ValueError as exc:
|
|
raise GrottiError(str(exc), "meldung") from exc
|
|
return jsonify(row), 201
|
|
|
|
@app.get("/api/v1/meldungen")
|
|
def meldung_list():
|
|
from grotti import meldung as grotti_meldung
|
|
|
|
require_role("admin")
|
|
status = (request.args.get("status") or "").strip() or None
|
|
return jsonify(grotti_meldung.list_rows(conn(), status=status))
|
|
|
|
@app.post("/api/v1/meldungen/<int:meldung_id>/erledigt")
|
|
def meldung_close(meldung_id):
|
|
from grotti import meldung as grotti_meldung
|
|
|
|
require_role("admin")
|
|
row = grotti_meldung.close(conn(), meldung_id)
|
|
if not row:
|
|
raise GrottiError("Die Meldung fehlt.", "meldung", 404)
|
|
conn().commit()
|
|
return jsonify(row)
|
|
|
|
@app.post("/api/v1/drucker")
|
|
def printer_create():
|
|
data = body()
|
|
name = (data.get("name") or "").strip()
|
|
host = validate_printer_host(data.get("host") or "")
|
|
if not name:
|
|
raise GrottiError("Der Drucker braucht einen Namen.", "name")
|
|
family = (data.get("family") or "").strip() or family_from_name(name)
|
|
if family not in PRINTER_FAMILIES:
|
|
raise GrottiError("Unbekannte Druckerfamilie.", "family")
|
|
if store.printer_by_host(conn(), host):
|
|
raise GrottiError("Diesen Host gibt es schon.", "host")
|
|
return jsonify(store.create_printer(conn(), uuid.uuid4(), name, host, family)), 201
|
|
|
|
@app.patch("/api/v1/drucker/id/<printer_id>")
|
|
def printer_patch(printer_id):
|
|
data = body()
|
|
current = store.printer_by_id(conn(), printer_id)
|
|
if not current:
|
|
raise GrottiError("Diesen Drucker kennt Grotti nicht.", "drucker", 404)
|
|
name = (data.get("name") if "name" in data else current["name"]) or ""
|
|
name = str(name).strip()
|
|
host_raw = (data.get("host") if "host" in data else current["host"]) or ""
|
|
host = validate_printer_host(str(host_raw).strip())
|
|
family = data.get("family") if "family" in data else current["family"]
|
|
family = (family or "").strip() or family_from_name(name)
|
|
if not name:
|
|
raise GrottiError("Der Drucker braucht einen Namen.", "name")
|
|
if family not in PRINTER_FAMILIES:
|
|
raise GrottiError("Unbekannte Druckerfamilie.", "family")
|
|
other = store.printer_by_host(conn(), host)
|
|
if other and str(other["id"]) != str(printer_id):
|
|
raise GrottiError("Diesen Host gibt es schon.", "host")
|
|
locked = data.get("locked") if "locked" in data else current.get("locked")
|
|
start_window = data.get("start_window") if "start_window" in data else None
|
|
if start_window is not None and not isinstance(start_window, dict):
|
|
raise GrottiError("Zeitfenster muss ein Objekt sein.", "start_window")
|
|
row = store.update_printer(
|
|
conn(),
|
|
printer_id,
|
|
name,
|
|
host,
|
|
family,
|
|
locked=bool(locked),
|
|
start_window=start_window,
|
|
)
|
|
return jsonify(row)
|
|
|
|
@app.delete("/api/v1/drucker/id/<printer_id>")
|
|
def printer_delete(printer_id):
|
|
if not store.delete_printer(conn(), printer_id):
|
|
raise GrottiError("Diesen Drucker kennt Grotti nicht.", "drucker", 404)
|
|
return "", 204
|
|
|
|
@app.post("/api/v1/drucker/<host>/<action>")
|
|
def printer_action(host, action):
|
|
require_host(host)
|
|
aliases = {"resume": "fortsetzen", "cancel": "abbrechen"}
|
|
action = aliases.get(action, action)
|
|
if action not in ("pause", "fortsetzen", "abbrechen"):
|
|
raise GrottiError("Unbekannter Befehl.", "befehl")
|
|
return jsonify(jobs.control(conn(), host, action))
|
|
|
|
@app.post("/api/v1/drucker/<host>/steuern")
|
|
def printer_steer(host):
|
|
require_host(host)
|
|
data = body()
|
|
action = (data.get("action") or "").strip()
|
|
if action not in STEER_ACTIONS:
|
|
raise GrottiError("Unbekannte Steuerung.", "befehl")
|
|
if action in ("emergency_stop", "clear_error", "exclude_object") and not data.get("confirm"):
|
|
raise GrottiError("Bestätigung fehlt.", "bestaetigung")
|
|
return jsonify(jobs.steuern(conn(), host, action, data))
|
|
|
|
@app.get("/api/v1/kamera")
|
|
def camera():
|
|
host = require_host(request.args.get("host", ""))
|
|
image = moonraker.camera_image(host)
|
|
if not image:
|
|
raise GrottiError("Kein Kamerabild.", "kamera", 404)
|
|
return image[1], 200, {"Content-Type": image[0], "Cache-Control": "no-store"}
|
|
|
|
@app.get("/api/v1/kamera/stream")
|
|
def camera_stream():
|
|
"""MJPEG vom Drucker durchreichen (kein Frame-Cache)."""
|
|
host = require_host(request.args.get("host", ""))
|
|
try:
|
|
upstream = moonraker.open_camera_stream(host)
|
|
except Exception:
|
|
abort(404)
|
|
ctype = upstream.headers.get("Content-Type") or "multipart/x-mixed-replace; boundary=--"
|
|
|
|
@stream_with_context
|
|
def generate():
|
|
try:
|
|
while True:
|
|
chunk = upstream.read(16384)
|
|
if not chunk:
|
|
break
|
|
yield chunk
|
|
finally:
|
|
try:
|
|
upstream.close()
|
|
except Exception:
|
|
pass
|
|
|
|
return Response(
|
|
generate(),
|
|
status=200,
|
|
headers={
|
|
"Content-Type": ctype,
|
|
"Cache-Control": "no-store",
|
|
"X-Accel-Buffering": "no",
|
|
},
|
|
)
|
|
|
|
@app.get("/api/v1/vorschau")
|
|
def live_preview():
|
|
host = require_host(request.args.get("host", ""))
|
|
embedded_name = request.args.get("embedded", "")
|
|
if embedded_name:
|
|
png = moonraker.embedded_bytes(host, embedded_name)
|
|
if not png:
|
|
abort(404)
|
|
return png, 200, {"Content-Type": "image/png", "Cache-Control": "private, max-age=300"}
|
|
file_path = request.args.get("file", "").replace("\\", "/")
|
|
if ".." in file_path or ".thumbs/" not in file_path or not file_path.endswith(".png"):
|
|
abort(404)
|
|
try:
|
|
kind, data = moonraker.proxy_image(
|
|
host, "http://%s/server/files/gcodes/%s" % (host, quote(file_path, safe="/"))
|
|
)
|
|
except Exception:
|
|
abort(404)
|
|
return data, 200, {"Content-Type": kind, "Cache-Control": "private, max-age=300"}
|
|
|
|
@app.get("/api/v1/projekte")
|
|
def project_list():
|
|
status = (request.args.get("status") or "").strip() or None
|
|
return jsonify(store.list_projects(conn(), status=status))
|
|
|
|
@app.post("/api/v1/projekte")
|
|
def project_create():
|
|
data = body()
|
|
name = (data.get("name") or "").strip()
|
|
if not name:
|
|
raise GrottiError("Das Projekt braucht einen Namen.", "name")
|
|
status = data.get("status") or "idee"
|
|
if status not in PROJECT_STATUS:
|
|
raise GrottiError("Unbekannter Status.", "status")
|
|
folder = (data.get("folder") or "").strip()
|
|
if not folder:
|
|
folder = library.default_project_folder(name)
|
|
try:
|
|
if cfg.get("watch_dir"):
|
|
folder = library.ensure_project_folder(cfg, folder)
|
|
else:
|
|
folder = library.normalize_folder(folder)
|
|
except GrottiError as exc:
|
|
if exc.code in ("ordner", "watch"):
|
|
raise GrottiError(
|
|
"%s — Ordner relativ unter dem Slice-Pfad, z. B. Projekte/%s (kein D:\\…)."
|
|
% (exc.message.rstrip("."), library.project_slug(name)),
|
|
exc.code,
|
|
getattr(exc, "status", 400) or 400,
|
|
) from exc
|
|
raise
|
|
row = store.create_project(
|
|
conn(), name, (data.get("notes") or "").strip(), status, folder=folder
|
|
)
|
|
return jsonify(row), 201
|
|
|
|
@app.get("/api/v1/projekte/<int:project_id>")
|
|
def project_get(project_id):
|
|
row = store.get_project(conn(), project_id, watch_dir=cfg.get("watch_dir"))
|
|
if not row:
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
# Status „druckt“, wenn ein Lauf aktiv ist (nur Anzeige — kein Auto-Write ohne Wunsch)
|
|
return jsonify(row)
|
|
|
|
@app.get("/api/v1/projekte/<int:project_id>/laeufe")
|
|
def project_runs(project_id):
|
|
if not store.get_project(conn(), project_id):
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
try:
|
|
limit = max(1, min(200, int(request.args.get("limit") or 40)))
|
|
except (TypeError, ValueError):
|
|
limit = 40
|
|
try:
|
|
offset = max(0, int(request.args.get("offset") or 0))
|
|
except (TypeError, ValueError):
|
|
offset = 0
|
|
data = store.list_project_runs(conn(), project_id, limit=limit, offset=offset)
|
|
resp = jsonify(data["items"])
|
|
resp.headers["X-Total-Count"] = str(data["total"])
|
|
return resp
|
|
|
|
@app.post("/api/v1/projekte/<int:project_id>/einreihen")
|
|
def project_einreihen(project_id):
|
|
data = body()
|
|
if not bool(data.get("confirm")):
|
|
raise GrottiError("Bestätigung fehlt.", "bestaetigung")
|
|
project = store.get_project(conn(), project_id, watch_dir=cfg.get("watch_dir"))
|
|
if not project:
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
wanted = data.get("file_ids")
|
|
if isinstance(wanted, list) and wanted:
|
|
try:
|
|
wanted_ids = {int(x) for x in wanted}
|
|
except (TypeError, ValueError) as exc:
|
|
raise GrottiError("Ungültige Datei-IDs.", "datei") from exc
|
|
files = [f for f in (project.get("files") or []) if f["id"] in wanted_ids]
|
|
else:
|
|
files = list(project.get("files") or [])
|
|
if not files:
|
|
raise GrottiError("Keine Druckdateien zum Einreihen.", "datei")
|
|
try:
|
|
menge = max(1, min(50, int(data.get("menge") or 1)))
|
|
except (TypeError, ValueError):
|
|
menge = 1
|
|
try:
|
|
priority = int(data.get("priority", 100))
|
|
except (TypeError, ValueError):
|
|
priority = 100
|
|
host = optional_host(data.get("host") or "")
|
|
if host:
|
|
require_host(host)
|
|
bed = bool(data.get("bed_leveling"))
|
|
override = bool(data.get("override_machine"))
|
|
created = []
|
|
for file_row in files:
|
|
family = (data.get("family") or file_row.get("printer_family") or "").strip()
|
|
for _ in range(menge):
|
|
created.append(
|
|
store.enqueue_print(
|
|
conn(),
|
|
file_row["id"],
|
|
host,
|
|
family if not host else "",
|
|
priority,
|
|
optional_id(data.get("spool_id")),
|
|
data.get("ace_map") if isinstance(data.get("ace_map"), list) else [],
|
|
bed,
|
|
override,
|
|
)
|
|
)
|
|
# Status auf „druckt“ heben, wenn noch Idee/bereit
|
|
if project.get("status") in ("idee", "bereit"):
|
|
store.update_project(conn(), project_id, {"status": "druckt"})
|
|
return jsonify({"jobs": created, "count": len(created)}), 201
|
|
|
|
@app.patch("/api/v1/projekte/<int:project_id>")
|
|
def project_patch(project_id):
|
|
data = body()
|
|
fields = {}
|
|
if "name" in data:
|
|
name = (data.get("name") or "").strip()
|
|
if not name:
|
|
raise GrottiError("Das Projekt braucht einen Namen.", "name")
|
|
fields["name"] = name
|
|
if "notes" in data:
|
|
fields["notes"] = data.get("notes") or ""
|
|
if "status" in data:
|
|
if data["status"] not in PROJECT_STATUS:
|
|
raise GrottiError("Unbekannter Status.", "status")
|
|
fields["status"] = data["status"]
|
|
if "folder" in data:
|
|
folder = (data.get("folder") or "").strip()
|
|
if folder and cfg.get("watch_dir"):
|
|
folder = library.ensure_project_folder(cfg, folder)
|
|
elif folder:
|
|
folder = library.normalize_folder(folder)
|
|
fields["folder"] = folder
|
|
row = store.update_project(conn(), project_id, fields)
|
|
if not row:
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
return jsonify(row)
|
|
|
|
@app.delete("/api/v1/projekte/<int:project_id>")
|
|
def project_delete(project_id):
|
|
row = store.get_project(conn(), project_id)
|
|
if not row:
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
# ?force=1 löscht den Projektordner inkl. Inhalt
|
|
force = (request.args.get("force") or "").strip() in ("1", "true", "yes")
|
|
folder = (row.get("folder") or "").strip()
|
|
if folder and cfg.get("watch_dir"):
|
|
library.delete_project_disk_folder(cfg, folder, force=force)
|
|
if not store.delete_project(conn(), project_id):
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
return "", 204
|
|
|
|
@app.get("/api/v1/projekte/<int:project_id>/assets")
|
|
def project_assets_list(project_id):
|
|
row = store.get_project(conn(), project_id)
|
|
if not row:
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
folder = (row.get("folder") or "").strip()
|
|
if not folder:
|
|
return jsonify([])
|
|
if not cfg.get("watch_dir"):
|
|
return jsonify([])
|
|
return jsonify(library.list_project_assets(cfg, folder))
|
|
|
|
@app.post("/api/v1/projekte/<int:project_id>/assets")
|
|
def project_assets_upload(project_id):
|
|
row = store.get_project(conn(), project_id)
|
|
if not row:
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
folder = (row.get("folder") or "").strip()
|
|
if not folder:
|
|
raise GrottiError("Das Projekt hat keinen Ordner.", "ordner")
|
|
if not cfg.get("watch_dir"):
|
|
raise GrottiError("Kein Slice-Ordner gesetzt — unter Einstellungen festlegen.", "watch")
|
|
upload = request.files.get("file")
|
|
if not upload or not upload.filename:
|
|
raise GrottiError("Keine Datei angehängt.", "datei")
|
|
saved = library.save_project_asset(cfg, folder, upload.filename, upload.read())
|
|
return jsonify(saved), 201
|
|
|
|
@app.get("/api/v1/projekte/<int:project_id>/assets/<path:rel>")
|
|
def project_assets_download(project_id, rel):
|
|
row = store.get_project(conn(), project_id)
|
|
if not row:
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
folder = (row.get("folder") or "").strip()
|
|
if not folder:
|
|
raise GrottiError("Das Projekt hat keinen Ordner.", "ordner")
|
|
path = library.resolve_project_asset(cfg, folder, rel)
|
|
return send_file(path, as_attachment=True, download_name=path.name)
|
|
|
|
@app.delete("/api/v1/projekte/<int:project_id>/assets/<path:rel>")
|
|
def project_assets_delete(project_id, rel):
|
|
row = store.get_project(conn(), project_id)
|
|
if not row:
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
folder = (row.get("folder") or "").strip()
|
|
if not folder:
|
|
raise GrottiError("Das Projekt hat keinen Ordner.", "ordner")
|
|
library.delete_project_asset(cfg, folder, rel)
|
|
return "", 204
|
|
|
|
@app.get("/api/v1/dateien")
|
|
def file_list():
|
|
library.sync_watch(conn(), cfg, force=False)
|
|
family = (request.args.get("family") or "").strip()
|
|
material = (request.args.get("material") or "").strip()
|
|
q = (request.args.get("q") or "").strip()
|
|
host = optional_host(request.args.get("host") or "")
|
|
project_id = optional_id(request.args.get("project_id") or request.args.get("project"))
|
|
limit_raw = request.args.get("limit")
|
|
offset_raw = request.args.get("offset")
|
|
limit = None
|
|
offset = 0
|
|
if limit_raw is not None and str(limit_raw).strip() != "":
|
|
try:
|
|
limit = max(1, min(500, int(limit_raw)))
|
|
except (TypeError, ValueError):
|
|
limit = 40
|
|
if offset_raw is not None:
|
|
try:
|
|
offset = max(0, int(offset_raw))
|
|
except (TypeError, ValueError):
|
|
offset = 0
|
|
data = store.list_files(
|
|
conn(),
|
|
watch_dir=cfg.get("watch_dir"),
|
|
family=family,
|
|
material=material,
|
|
project_id=project_id,
|
|
q=q,
|
|
host=host,
|
|
limit=limit,
|
|
offset=offset,
|
|
)
|
|
resp = jsonify(data["items"])
|
|
resp.headers["X-Total-Count"] = str(data["total"])
|
|
return resp
|
|
|
|
@app.post("/api/v1/dateien/<int:file_id>/meta")
|
|
def file_meta_refresh(file_id):
|
|
"""Eine Datei neu parsen — z. B. paint_index für ACE nach Orca-Deep-Link."""
|
|
out = library.refresh_one_file(conn(), file_id, watch_dir=cfg.get("watch_dir"))
|
|
if not out:
|
|
raise GrottiError("Datei nicht gefunden.", "datei", 404)
|
|
return jsonify(out)
|
|
|
|
@app.get("/api/v1/orca-fokus")
|
|
def orca_focus():
|
|
"""Zuletzt von orca_senden gesetzte Datei — offene Tabs schalten um statt neu zu öffnen."""
|
|
path = Path(cfg["data_dir"]) / "orca-senden-focus.json"
|
|
if not path.is_file():
|
|
return jsonify({})
|
|
try:
|
|
data = json.loads(path.read_text(encoding="utf-8"))
|
|
except (OSError, json.JSONDecodeError):
|
|
return jsonify({})
|
|
if not isinstance(data, dict) or data.get("file_id") is None:
|
|
return jsonify({})
|
|
return jsonify(data)
|
|
|
|
@app.post("/api/v1/dateien/neu-lesen")
|
|
def file_rescan():
|
|
result = library.sync_watch(conn(), cfg, force=True)
|
|
result["metadaten"] = library.refresh_file_meta(conn(), force=True)
|
|
return jsonify(result)
|
|
|
|
@app.get("/api/v1/dateien/ordner")
|
|
def file_folders():
|
|
return jsonify({"folders": library.list_folders(cfg)})
|
|
|
|
@app.post("/api/v1/dateien/ordner")
|
|
def file_folder_create():
|
|
data = body()
|
|
folder = library.create_folder(cfg, data.get("folder"))
|
|
return jsonify({"folder": folder, "folders": library.list_folders(cfg)}), 201
|
|
|
|
@app.delete("/api/v1/dateien/ordner")
|
|
def file_folder_delete():
|
|
data = body()
|
|
folder = library.delete_folder(cfg, data.get("folder"))
|
|
return jsonify({"folder": folder, "folders": library.list_folders(cfg)})
|
|
|
|
@app.post("/api/v1/dateien/<int:file_id>/verschieben")
|
|
def file_move(file_id):
|
|
data = body()
|
|
folder = data.get("folder")
|
|
if folder is None:
|
|
folder = ""
|
|
moved = library.move_file(conn(), cfg, file_id, folder)
|
|
return jsonify(moved)
|
|
|
|
@app.post("/api/v1/dateien/<int:file_id>/umbenennen")
|
|
def file_rename(file_id):
|
|
data = body()
|
|
name = (data.get("name") or "").strip()
|
|
if not name:
|
|
raise GrottiError("Neuer Dateiname fehlt.", "datei")
|
|
return jsonify(library.rename_library_file(conn(), cfg, file_id, name))
|
|
|
|
@app.post("/api/v1/dateien")
|
|
def file_upload():
|
|
upload = request.files.get("file")
|
|
if not upload or not upload.filename:
|
|
raise GrottiError("Keine Datei angehängt.", "datei")
|
|
low = upload.filename.lower().replace("\\", "/")
|
|
base = low.rsplit("/", 1)[-1]
|
|
if base in (".", "..") or not base.strip("."):
|
|
raise GrottiError("Ungültiger Dateiname.", "datei")
|
|
if not any(base.endswith(suf) for suf in UPLOAD_SUFFIXES):
|
|
raise GrottiError(
|
|
"Nur .gcode, .3mf oder .gcode.3mf sind erlaubt.",
|
|
"datei",
|
|
)
|
|
project_id = optional_id(request.form.get("project_id"))
|
|
saved = library.save_upload(conn(), upload.filename, upload.read(), cfg, project_id)
|
|
return jsonify(saved), 201
|
|
|
|
@app.get("/api/v1/dateien/<int:file_id>/vorschau")
|
|
def file_preview(file_id):
|
|
row = store.get_file_row(conn(), file_id)
|
|
if not row:
|
|
raise GrottiError("Vorschau fehlt.", "vorschau", 404)
|
|
png = library.preview_png(row, conn=conn(), data_dir=cfg["data_dir"])
|
|
if not png:
|
|
raise GrottiError("Vorschau fehlt.", "vorschau", 404)
|
|
return png, 200, {"Content-Type": "image/png", "Cache-Control": "private, max-age=300"}
|
|
|
|
@app.get("/api/v1/dateien/<int:file_id>/pfad")
|
|
def file_toolpath(file_id):
|
|
row = store.get_file_row(conn(), file_id)
|
|
if not row:
|
|
raise GrottiError("Die Datei fehlt.", "datei", 404)
|
|
path = library.resolve_stored_path(conn(), row, cfg["data_dir"])
|
|
if path is None or not path.is_file():
|
|
raise GrottiError("Die Datei liegt nicht mehr auf der Platte.", "datei", 404)
|
|
cache_dir = Path(cfg["data_dir"]) / "toolpath"
|
|
cache_dir.mkdir(parents=True, exist_ok=True)
|
|
stamp = "%s-%s-%s-v%s" % (
|
|
file_id,
|
|
int(row.get("mtime") or 0),
|
|
int(row.get("size_bytes") or 0),
|
|
TOOLPATH_VERSION,
|
|
)
|
|
cache_path = cache_dir / (stamp + ".json")
|
|
if cache_path.is_file():
|
|
try:
|
|
data = json.loads(cache_path.read_text(encoding="utf-8"))
|
|
except (OSError, json.JSONDecodeError):
|
|
data = None
|
|
else:
|
|
data = None
|
|
if not isinstance(data, dict) or data.get("version") != TOOLPATH_VERSION:
|
|
data = build_toolpath(path)
|
|
try:
|
|
cache_path.write_text(json.dumps(data), encoding="utf-8")
|
|
except OSError:
|
|
pass
|
|
data["file_id"] = file_id
|
|
data["name"] = row["name"]
|
|
data["version"] = TOOLPATH_VERSION
|
|
resp = jsonify(data)
|
|
resp.headers["Cache-Control"] = "no-store"
|
|
return resp
|
|
|
|
@app.patch("/api/v1/dateien/<int:file_id>")
|
|
def file_patch(file_id):
|
|
data = body()
|
|
fields = {}
|
|
if "project_id" in data:
|
|
fields["project_id"] = optional_id(data.get("project_id"))
|
|
if "spool_id" in data:
|
|
spool_id = optional_id(data.get("spool_id"))
|
|
if spool_id and not store.get_spool_row(conn(), spool_id):
|
|
raise GrottiError("Die Spule fehlt.", "spule", 404)
|
|
fields["spool_id"] = spool_id
|
|
row = store.update_file(conn(), file_id, fields)
|
|
if not row:
|
|
raise GrottiError("Die Datei fehlt.", "datei", 404)
|
|
return jsonify(row)
|
|
|
|
@app.delete("/api/v1/dateien/<int:file_id>")
|
|
def file_delete(file_id):
|
|
library.delete_library_file(conn(), cfg, file_id)
|
|
return "", 204
|
|
|
|
@app.post("/api/v1/senden")
|
|
def send():
|
|
data = body()
|
|
try:
|
|
file_id = int(data.get("file_id"))
|
|
except (TypeError, ValueError) as exc:
|
|
raise GrottiError("Die Datei fehlt.", "datei") from exc
|
|
hosts = data.get("hosts")
|
|
if isinstance(hosts, list):
|
|
hosts = [str(item or "").strip() for item in hosts if str(item or "").strip()]
|
|
else:
|
|
host = (data.get("host") or "").strip()
|
|
hosts = [host] if host else []
|
|
ace_maps = data.get("ace_maps") if isinstance(data.get("ace_maps"), dict) else {}
|
|
if not ace_maps and isinstance(data.get("ace_map"), list) and len(hosts) == 1:
|
|
ace_maps = {hosts[0]: data.get("ace_map")}
|
|
# when_free: in Druckwarteschlange statt sofort starten
|
|
if data.get("when_free"):
|
|
if not bool(data.get("confirm")):
|
|
raise GrottiError("Start braucht eine Bestätigung.", "bestaetigung")
|
|
file_row = store.get_file_row(conn(), file_id)
|
|
if not file_row:
|
|
raise GrottiError("Die Datei fehlt.", "datei", 404)
|
|
family = (data.get("family") or file_row.get("printer_family") or "").strip()
|
|
spool_id = optional_id(data.get("spool_id"))
|
|
bed = bool(data.get("bed_leveling"))
|
|
override = bool(data.get("override_machine"))
|
|
try:
|
|
priority = int(data.get("priority", 100))
|
|
except (TypeError, ValueError):
|
|
priority = 100
|
|
created = []
|
|
targets = hosts or [""]
|
|
for host in targets:
|
|
if host:
|
|
require_host(host)
|
|
# Nur die Map dieses Hosts — nie die eines anderen Druckers
|
|
# (bei „nächster freier“ host="" bleibt die Map leer bis zum Claim).
|
|
mapping = ace_maps.get(host) if host else []
|
|
if not isinstance(mapping, list):
|
|
mapping = []
|
|
if host:
|
|
jobs.assert_filament_enough(conn(), file_row, spool_id, mapping, host)
|
|
created.append(
|
|
store.enqueue_print(
|
|
conn(),
|
|
file_id,
|
|
host,
|
|
family if not host else "",
|
|
priority,
|
|
spool_id,
|
|
mapping,
|
|
bed,
|
|
override,
|
|
)
|
|
)
|
|
return jsonify({"jobs": created, "count": len(created), "mode": "when_free"}), 202
|
|
created = app.extensions["send_queue"].enqueue_many(
|
|
conn(),
|
|
file_id,
|
|
hosts,
|
|
bool(data.get("confirm")),
|
|
bool(data.get("override_machine")),
|
|
optional_id(data.get("spool_id")),
|
|
ace_maps,
|
|
bed_leveling=bool(data.get("bed_leveling")),
|
|
marlin_mode=(data.get("marlin_mode") or "stream"),
|
|
)
|
|
return jsonify({"jobs": created, "count": len(created), "mode": "now"}), 202
|
|
|
|
@app.get("/api/v1/sende-auftraege")
|
|
def send_list():
|
|
return jsonify(app.extensions["send_queue"].list_jobs())
|
|
|
|
@app.get("/api/v1/senden-zuletzt")
|
|
def send_last():
|
|
host = optional_host(request.args.get("host") or "")
|
|
try:
|
|
file_id = int(request.args.get("file_id") or 0)
|
|
except (TypeError, ValueError):
|
|
file_id = 0
|
|
if not host:
|
|
raise GrottiError("Host nötig.", "senden")
|
|
if file_id:
|
|
row = store.latest_send_for_file(conn(), host, file_id)
|
|
else:
|
|
row = store.latest_send_for_host(conn(), host)
|
|
if not row:
|
|
return jsonify(None)
|
|
return jsonify(row)
|
|
|
|
@app.get("/api/v1/senden/<job_id>")
|
|
def send_status(job_id):
|
|
job = app.extensions["send_queue"].get(job_id)
|
|
if not job:
|
|
raise GrottiError("Der Auftrag fehlt.", "auftrag", 404)
|
|
return jsonify(job)
|
|
|
|
def enqueue_ablauf_payload(data):
|
|
"""Ablauf (Drucken/Abkühlen/Schieben) in die Druckwarteschlange."""
|
|
if not bool(data.get("confirm")):
|
|
raise GrottiError("Start braucht eine Bestätigung.", "bestaetigung")
|
|
hosts = data.get("hosts")
|
|
if isinstance(hosts, list):
|
|
hosts = [str(item or "").strip() for item in hosts if str(item or "").strip()]
|
|
else:
|
|
host = (data.get("host") or "").strip()
|
|
hosts = [host] if host else []
|
|
if not hosts:
|
|
raise GrottiError("Ablauf braucht einen Kobra-3-Drucker.", "drucker")
|
|
for host in hosts:
|
|
require_host(host)
|
|
printer = store.printer_by_host(conn(), host)
|
|
eject.require_kobra_3(printer)
|
|
fallback = {
|
|
"file_id": data.get("file_id"),
|
|
"spool_id": data.get("spool_id"),
|
|
"ace_map": data.get("ace_map") if isinstance(data.get("ace_map"), list) else [],
|
|
"bed_leveling": bool(data.get("bed_leveling")),
|
|
"override_machine": bool(data.get("override_machine")),
|
|
}
|
|
ace_maps = data.get("ace_maps") if isinstance(data.get("ace_maps"), dict) else {}
|
|
steps = eject.normalize_steps(data.get("steps"), fallback)
|
|
for step in steps:
|
|
if step["type"] != "print":
|
|
continue
|
|
if not store.get_file_row(conn(), step["file_id"]):
|
|
raise GrottiError("Die Datei fehlt.", "datei", 404)
|
|
file_id = eject.first_print_file_id(steps)
|
|
try:
|
|
priority = int(data.get("priority", 100))
|
|
except (TypeError, ValueError):
|
|
priority = 100
|
|
try:
|
|
repeat_total = int(data.get("repeat_total", 1))
|
|
except (TypeError, ValueError):
|
|
repeat_total = 1
|
|
repeat_total = max(1, min(99, repeat_total))
|
|
created = []
|
|
for host in hosts:
|
|
mapping = ace_maps.get(host) if isinstance(ace_maps.get(host), list) else None
|
|
host_steps = []
|
|
for step in steps:
|
|
if step["type"] == "print" and mapping is not None:
|
|
copy = dict(step)
|
|
copy["ace_map"] = mapping
|
|
host_steps.append(copy)
|
|
else:
|
|
host_steps.append(step)
|
|
first = next(s for s in host_steps if s["type"] == "print")
|
|
file_row = store.get_file_row(conn(), first["file_id"])
|
|
jobs.assert_filament_enough(
|
|
conn(),
|
|
file_row,
|
|
first.get("spool_id"),
|
|
first.get("ace_map") or [],
|
|
host,
|
|
)
|
|
created.append(
|
|
store.enqueue_print(
|
|
conn(),
|
|
file_id,
|
|
host,
|
|
"kobra_3",
|
|
priority,
|
|
first.get("spool_id"),
|
|
first.get("ace_map") or [],
|
|
bool(first.get("bed_leveling")),
|
|
bool(first.get("override_machine")),
|
|
steps=host_steps,
|
|
repeat_total=repeat_total,
|
|
)
|
|
)
|
|
return {"jobs": created, "count": len(created), "mode": "ablauf"}
|
|
|
|
@app.get("/api/v1/druck-queue")
|
|
def print_queue_list():
|
|
try:
|
|
limit = max(1, min(200, int(request.args.get("limit") or 40)))
|
|
except (TypeError, ValueError):
|
|
limit = 40
|
|
try:
|
|
offset = max(0, int(request.args.get("offset") or 0))
|
|
except (TypeError, ValueError):
|
|
offset = 0
|
|
host = optional_host(request.args.get("host") or "")
|
|
status = (request.args.get("status") or "").strip()
|
|
data = store.list_print_queue(
|
|
conn(), limit=limit, offset=offset, host=host, status=status
|
|
)
|
|
resp = jsonify(data["items"])
|
|
resp.headers["X-Total-Count"] = str(data["total"])
|
|
return resp
|
|
|
|
@app.get("/api/v1/laeuft")
|
|
def running_now():
|
|
"""Was gerade druckt, auch ohne Auftrag in der Queue (Stand des Watchers)."""
|
|
items = []
|
|
for live in app.extensions["watcher"].latest or []:
|
|
state = (live.get("state") or "").lower()
|
|
if state not in ("printing", "paused", "heating"):
|
|
continue
|
|
items.append({
|
|
"host": live.get("host") or "",
|
|
"name": live.get("name") or "",
|
|
"state": state,
|
|
"progress": live.get("progress") or 0,
|
|
"remain": live.get("remain") or 0,
|
|
"filename": live.get("filename") or "",
|
|
})
|
|
return jsonify(items)
|
|
|
|
@app.get("/api/v1/aufgaben")
|
|
def open_tasks():
|
|
"""Platte belegt und kein Ablauf räumt sie: Hand muss ran."""
|
|
clears = store.bed_clear_map(conn())
|
|
busy = {
|
|
row["host"]
|
|
for row in conn().execute("SELECT DISTINCT host FROM print_queue WHERE status = 'running'").fetchall()
|
|
}
|
|
items = []
|
|
for live in app.extensions["watcher"].latest or []:
|
|
host = live.get("host") or ""
|
|
state = (live.get("state") or "").lower()
|
|
if not clears.get(host) or host in busy or state in ("printing", "paused", "heating"):
|
|
continue
|
|
items.append({
|
|
"host": host,
|
|
"name": live.get("name") or "",
|
|
"state": state,
|
|
"filename": live.get("filename") or "",
|
|
})
|
|
return jsonify(items)
|
|
|
|
@app.get("/api/v1/jetzt")
|
|
def jetzt_api():
|
|
"""Priorisierte Handlungsliste, laufende Drucke und Farm-ETA."""
|
|
from grotti import jetzt as jetzt_mod
|
|
|
|
send_jobs = []
|
|
try:
|
|
send_jobs = app.extensions["send_queue"].list_jobs() or []
|
|
except Exception:
|
|
send_jobs = []
|
|
return jsonify(jetzt_mod.build(
|
|
conn(),
|
|
app.extensions["watcher"].latest or [],
|
|
printers=store.list_printers(conn()),
|
|
send_jobs=send_jobs,
|
|
))
|
|
|
|
@app.get("/api/v1/prognose")
|
|
def prognose_api():
|
|
"""Wann welcher Drucker frei ist und wann alles fertig ist."""
|
|
from grotti import jetzt as jetzt_mod
|
|
|
|
running = []
|
|
for live in app.extensions["watcher"].latest or []:
|
|
state = (live.get("state") or "").lower()
|
|
if state not in ("printing", "paused", "heating"):
|
|
continue
|
|
running.append({
|
|
"host": live.get("host") or "",
|
|
"name": live.get("name") or "",
|
|
"remain": live.get("remain") or 0,
|
|
"progress": live.get("progress") or 0,
|
|
"filename": live.get("filename") or "",
|
|
"state": state,
|
|
"free_at": None,
|
|
})
|
|
eta = jetzt_mod.farm_eta(running)
|
|
for item in running:
|
|
rem = float(item.get("remain") or 0)
|
|
item["free_at"] = jetzt_mod._iso_remain(rem) if rem > 0 else None
|
|
waiting = [
|
|
j for j in store.list_print_queue(conn(), limit=80)["items"]
|
|
if j.get("status") == "waiting"
|
|
]
|
|
return jsonify({
|
|
"running": running,
|
|
"waiting_count": len(waiting),
|
|
"eta": eta,
|
|
})
|
|
|
|
@app.get("/api/v1/suche")
|
|
def suche_api():
|
|
"""Globale Suche für Ctrl+K."""
|
|
q = (request.args.get("q") or "").strip()
|
|
if len(q) < 1:
|
|
return jsonify({"items": []})
|
|
items = store.global_search(conn(), q, limit=20)
|
|
return jsonify({"items": items})
|
|
|
|
@app.post("/api/v1/druck-queue")
|
|
def print_queue_create():
|
|
data = body()
|
|
if isinstance(data.get("steps"), list) and data.get("steps"):
|
|
return jsonify(enqueue_ablauf_payload(data)), 202
|
|
if not bool(data.get("confirm")):
|
|
raise GrottiError("Bestätigung fehlt.", "bestaetigung")
|
|
try:
|
|
file_id = int(data.get("file_id"))
|
|
except (TypeError, ValueError) as exc:
|
|
raise GrottiError("Die Datei fehlt.", "datei") from exc
|
|
if not store.get_file_row(conn(), file_id):
|
|
raise GrottiError("Die Datei fehlt.", "datei", 404)
|
|
host = optional_host(data.get("host") or "")
|
|
family = (data.get("family") or "").strip()
|
|
ace_map = data.get("ace_map") if isinstance(data.get("ace_map"), list) else []
|
|
try:
|
|
priority = int(data.get("priority", 100))
|
|
except (TypeError, ValueError):
|
|
priority = 100
|
|
row = store.enqueue_print(
|
|
conn(),
|
|
file_id,
|
|
host,
|
|
family,
|
|
priority,
|
|
optional_id(data.get("spool_id")),
|
|
ace_map,
|
|
bool(data.get("bed_leveling")),
|
|
bool(data.get("override_machine")),
|
|
)
|
|
return jsonify(row), 201
|
|
|
|
@app.post("/api/v1/ablauf")
|
|
def ablauf_create():
|
|
return jsonify(enqueue_ablauf_payload(body())), 202
|
|
|
|
@app.post("/api/v1/schieben-testen")
|
|
def schieben_testen():
|
|
"""Nur Testbahn aus dem Ablauf — nicht die Wand-Quittierung."""
|
|
data = body()
|
|
if not bool(data.get("confirm_empty")):
|
|
raise GrottiError("Bestätigung „Bett ist leer“ fehlt.", "bestaetigung")
|
|
host = require_host((data.get("host") or "").strip())
|
|
printer = store.printer_by_host(conn(), host)
|
|
eject.require_kobra_3(printer)
|
|
live = moonraker.query(host)
|
|
state = (live.get("state") or "").lower()
|
|
if live.get("ok") is False:
|
|
raise GrottiError("Drucker offline.", "offline")
|
|
if state in ("printing", "paused", "heating"):
|
|
raise GrottiError("Drucker ist beschäftigt.", "busy")
|
|
sweep = eject.normalize_sweep(data.get("sweep") if isinstance(data.get("sweep"), dict) else data)
|
|
homed = (live.get("homed_axes") or "").lower()
|
|
try:
|
|
if not all(axis in homed for axis in "xyz"):
|
|
# Bett ist laut Bestätigung leer → richtiges Homing ist sicher
|
|
moonraker.gcode_script(host, "G28", timeout=180)
|
|
moonraker.gcode_script(host, eject.sweep_script(sweep), timeout=180)
|
|
except moonraker.PrinterError as exc:
|
|
raise GrottiError(eject.explain_printer_error(exc.message), "drucker") from exc
|
|
store.set_bed_needs_clear(conn(), host, False, "Schieben-Test")
|
|
return jsonify({"ok": True, "host": host, "sweep": sweep, "message": "Bahn gefahren."})
|
|
|
|
@app.post("/api/v1/drucker/<host>/abraeumen")
|
|
def printer_abraeumen(host):
|
|
"""Quittierung: Platte ist frei. Fährt keine Bahn — nur für „wenn frei“."""
|
|
data = body()
|
|
if not bool(data.get("confirm")):
|
|
raise GrottiError("Bestätigung fehlt.", "bestaetigung")
|
|
require_host(host)
|
|
c = conn()
|
|
store.set_bed_needs_clear(c, host, False, "quittiert")
|
|
run_json = None
|
|
run_row = store.run_for_abraeumen_verdict(c, host)
|
|
if any(k in data for k in ("verdict", "verdict_reason", "pieces_ok", "pieces_bad")):
|
|
if not run_row:
|
|
raise GrottiError("Kein Lauf zum Bewerten — Protokoll prüfen.", "lauf", 404)
|
|
try:
|
|
verdict, reason, ok_n, bad_n = grotti_verdict.normalize_abraeumen_verdict(
|
|
data.get("verdict"),
|
|
data.get("verdict_reason"),
|
|
data.get("pieces_ok"),
|
|
data.get("pieces_bad"),
|
|
)
|
|
except ValueError as exc:
|
|
raise GrottiError(str(exc), "urteil") from exc
|
|
run_json = store.set_verdict(c, run_row["id"], verdict, reason, ok_n, bad_n)
|
|
# Live-Lauf schließen ohne Abzug — History bucht; Fallback nach Frist.
|
|
if run_row and (run_row.get("state") or "") in ("in_progress", "printing", "paused"):
|
|
closed = store.complete_open_run(c, run_row["id"], state="completed")
|
|
if closed:
|
|
try:
|
|
jobs.sync_history(c, cfg, host=host)
|
|
except Exception as exc:
|
|
log.warning("Abräumen Abgleich %s: %s", host, exc)
|
|
row = store.get_run_row(c, closed["id"]) or closed
|
|
run_json = store.run_out(row)
|
|
reprint = None
|
|
if bool(data.get("reprint")) and run_row and run_row.get("file_id"):
|
|
reprint = store.enqueue_print(
|
|
c,
|
|
run_row["file_id"],
|
|
host,
|
|
"",
|
|
50,
|
|
run_row.get("spool_id"),
|
|
[],
|
|
False,
|
|
False,
|
|
)
|
|
store.add_event(
|
|
c, host, "", "queue",
|
|
"Nochmal eingereiht: %s" % (run_row.get("filename") or run_row["file_id"]),
|
|
run_row.get("filename") or "",
|
|
)
|
|
return jsonify({
|
|
"ok": True,
|
|
"host": host,
|
|
"needs_clear": False,
|
|
"message": "Platte quittiert." + (" Nochmal in der Warteschlange." if reprint else ""),
|
|
"run": run_json,
|
|
"reprint": reprint,
|
|
"verdict_reasons": VERDICT_REASONS,
|
|
})
|
|
|
|
@app.get("/api/v1/abraeumen-defaults")
|
|
def abraeumen_defaults():
|
|
return jsonify({
|
|
"cool": eject.DEFAULT_COOL,
|
|
"sweep": eject.DEFAULT_SWEEP,
|
|
"check": eject.DEFAULT_CHECK,
|
|
"limits": eject.LIMITS,
|
|
})
|
|
|
|
@app.patch("/api/v1/druck-queue/<int:item_id>")
|
|
def print_queue_patch(item_id):
|
|
data = body()
|
|
fields = {}
|
|
if "priority" in data:
|
|
try:
|
|
fields["priority"] = int(data.get("priority"))
|
|
except (TypeError, ValueError) as exc:
|
|
raise GrottiError("Priorität muss eine Zahl sein.", "zahl") from exc
|
|
if "status" in data:
|
|
status = data.get("status")
|
|
if status not in ("waiting", "cancelled", "error", "done", "running", "dismissed"):
|
|
raise GrottiError("Unbekannter Status.", "status")
|
|
current_row = store.get_print_queue_row(conn(), item_id)
|
|
if not current_row:
|
|
raise GrottiError("Der Queue-Eintrag fehlt.", "queue", 404)
|
|
# Von außen nur Abbrechen, Verwerfen oder Fortsetzen — kein freies done/running.
|
|
if status == "done":
|
|
raise GrottiError("Status „fertig“ setzt nur Grotti.", "status")
|
|
if status == "running" and not data.get("resume"):
|
|
raise GrottiError("Nur ein gestoppter Ablauf lässt sich fortsetzen.", "status")
|
|
if status == "waiting" and current_row.get("status") not in ("waiting",):
|
|
# Undo: abgebrochen/entfernt wieder einreihen
|
|
if not (data.get("undo") and current_row.get("status") in ("cancelled", "dismissed")):
|
|
raise GrottiError("Status lässt sich so nicht setzen.", "status")
|
|
fields["message"] = ""
|
|
fields["phase"] = ""
|
|
fields["phase_started_at"] = None
|
|
fields["status"] = status
|
|
if status == "running" and data.get("resume"):
|
|
row = current_row
|
|
if row.get("status") != "error" or not row.get("steps"):
|
|
raise GrottiError("Nur ein gestoppter Ablauf lässt sich fortsetzen.", "status")
|
|
fields["phase"] = ""
|
|
fields["phase_started_at"] = None
|
|
fields["message"] = "Wird fortgesetzt…"
|
|
store.add_event(
|
|
conn(), row.get("host") or "", row.get("printer_name") or "", "ablauf",
|
|
"%s Ablauf von Hand fortgesetzt bei Schritt %d (%s)" % (
|
|
row.get("printer_name") or "",
|
|
int(row.get("step_index") or 0) + 1,
|
|
store.print_queue_out(row).get("step_label_current") or "",
|
|
),
|
|
row.get("filename") or "",
|
|
)
|
|
if status == "cancelled":
|
|
fields["message"] = "Abgebrochen."
|
|
fields["phase"] = ""
|
|
fields["phase_started_at"] = None
|
|
row = store.get_print_queue_row(conn(), item_id)
|
|
if row:
|
|
was_running = row.get("status") == "running"
|
|
what = "Ablauf" if row.get("steps") else "Auftrag"
|
|
stopped = ""
|
|
# laufenden Druck auf dem Host best-effort stoppen
|
|
if was_running and row.get("host"):
|
|
try:
|
|
from grotti.drivers import for_printer
|
|
printer = store.printer_by_host(conn(), row["host"])
|
|
if printer:
|
|
for_printer(printer).command(row["host"], "abbrechen")
|
|
stopped = ", Druck gestoppt"
|
|
else:
|
|
stopped = ", Druck nicht gestoppt"
|
|
except Exception:
|
|
stopped = ", Druck nicht gestoppt"
|
|
store.add_event(
|
|
conn(),
|
|
row.get("host") or "",
|
|
row.get("printer_name") or "",
|
|
"ablauf",
|
|
"%s %s von Hand %s%s: %s" % (
|
|
row.get("printer_name") or "Warteschlange",
|
|
what,
|
|
"abgebrochen" if was_running else "entfernt",
|
|
stopped,
|
|
row.get("filename") or "",
|
|
),
|
|
row.get("filename") or "",
|
|
)
|
|
if "message" in data:
|
|
fields["message"] = str(data.get("message") or "")
|
|
row = store.update_print_queue(conn(), item_id, fields)
|
|
if not row:
|
|
raise GrottiError("Der Queue-Eintrag fehlt.", "queue", 404)
|
|
return jsonify(row)
|
|
|
|
@app.get("/api/v1/ereignisse")
|
|
def events_list():
|
|
unread = request.args.get("unread") == "1"
|
|
alerts_only = request.args.get("alerts") == "1"
|
|
try:
|
|
limit = max(1, min(1000, int(request.args.get("limit") or 40)))
|
|
except (TypeError, ValueError):
|
|
limit = 40
|
|
kinds = [k for k in (request.args.get("kind") or "").split(",") if k.strip()]
|
|
if alerts_only and not kinds:
|
|
kinds = list(store.ALERT_EVENT_KINDS)
|
|
since = None
|
|
if request.args.get("since"):
|
|
try:
|
|
since = datetime.fromisoformat(request.args["since"].replace("Z", "+00:00"))
|
|
except ValueError as exc:
|
|
raise GrottiError("since muss ein ISO-Zeitpunkt sein.", "since") from exc
|
|
return jsonify({
|
|
"items": store.list_events(
|
|
conn(),
|
|
limit=limit,
|
|
unread_only=unread,
|
|
host=(request.args.get("host") or "").strip() or None,
|
|
kinds=kinds or None,
|
|
since=since,
|
|
),
|
|
"unread": store.unread_event_count(
|
|
conn(),
|
|
kinds=list(store.ALERT_EVENT_KINDS) if alerts_only or unread else None,
|
|
),
|
|
})
|
|
|
|
@app.post("/api/v1/ereignisse/gelesen")
|
|
def events_read():
|
|
data = body() if request.data else {}
|
|
ids = data.get("ids") if isinstance(data.get("ids"), list) else None
|
|
if ids is not None:
|
|
try:
|
|
ids = [int(item) for item in ids]
|
|
except (TypeError, ValueError) as exc:
|
|
raise GrottiError("IDs müssen Zahlen sein.", "id") from exc
|
|
unread = store.mark_events_read(conn(), ids, kinds=list(store.ALERT_EVENT_KINDS) if not ids else None)
|
|
return jsonify({"unread": unread})
|
|
|
|
@app.post("/api/v1/dateien/von-drucker")
|
|
def file_from_printer():
|
|
data = body()
|
|
host = require_host(data.get("host") or "")
|
|
filename = (data.get("filename") or "").strip()
|
|
saved = library.ensure_library_gcode(conn(), cfg, host, filename)
|
|
if not saved:
|
|
raise GrottiError("Datei konnte nicht vom Drucker geladen werden.", "datei")
|
|
return jsonify(saved), 201
|
|
|
|
@app.get("/api/v1/materialien")
|
|
def material_list():
|
|
return jsonify(store.list_materials(conn()))
|
|
|
|
@app.post("/api/v1/materialien")
|
|
def material_create():
|
|
data = body()
|
|
name = (data.get("name") or "").strip()
|
|
if not name:
|
|
raise GrottiError("Die Sorte braucht einen Namen.", "name")
|
|
machines = data.get("machines") or "beide"
|
|
if machines not in ("beide", "kobra_3", "kobra_s1"):
|
|
raise GrottiError("Unbekannte Maschinenwahl.", "machines")
|
|
try:
|
|
row = store.create_material(
|
|
conn(),
|
|
{
|
|
"name": name,
|
|
"brand": (data.get("brand") or "").strip(),
|
|
"material_type": (data.get("material_type") or "PLA").strip() or "PLA",
|
|
"density": float(data.get("density") or 1.24),
|
|
"volumetric": float(data.get("volumetric") or 12),
|
|
"volumetric_s1": (
|
|
float(data["volumetric_s1"])
|
|
if data.get("volumetric_s1") not in (None, "")
|
|
else None
|
|
),
|
|
"machines": machines,
|
|
"price_per_kg": float(data.get("price_per_kg") or 0),
|
|
"note": (data.get("note") or "").strip(),
|
|
},
|
|
)
|
|
except Exception as exc:
|
|
if "unique" in str(exc).lower() or "duplicate" in str(exc).lower():
|
|
raise GrottiError("Eine Sorte mit diesem Namen gibt es schon.", "name") from exc
|
|
raise
|
|
return jsonify(row), 201
|
|
|
|
@app.patch("/api/v1/materialien/<int:material_id>")
|
|
def material_patch(material_id):
|
|
data = body()
|
|
fields = {}
|
|
if "name" in data:
|
|
name = (data.get("name") or "").strip()
|
|
if not name:
|
|
raise GrottiError("Die Sorte braucht einen Namen.", "name")
|
|
fields["name"] = name
|
|
if "brand" in data:
|
|
fields["brand"] = (data.get("brand") or "").strip()
|
|
if "material_type" in data:
|
|
fields["material_type"] = (data.get("material_type") or "PLA").strip() or "PLA"
|
|
if "density" in data:
|
|
fields["density"] = float(data.get("density") or 1.24)
|
|
if "volumetric" in data:
|
|
fields["volumetric"] = float(data.get("volumetric") or 12)
|
|
if "volumetric_s1" in data:
|
|
raw = data.get("volumetric_s1")
|
|
fields["volumetric_s1"] = float(raw) if raw not in (None, "") else None
|
|
if "machines" in data:
|
|
machines = data.get("machines") or "beide"
|
|
if machines not in ("beide", "kobra_3", "kobra_s1"):
|
|
raise GrottiError("Unbekannte Maschinenwahl.", "machines")
|
|
fields["machines"] = machines
|
|
if "price_per_kg" in data:
|
|
fields["price_per_kg"] = float(data.get("price_per_kg") or 0)
|
|
if "note" in data:
|
|
fields["note"] = (data.get("note") or "").strip()
|
|
try:
|
|
row = store.update_material(conn(), material_id, fields)
|
|
except Exception as exc:
|
|
if "unique" in str(exc).lower() or "duplicate" in str(exc).lower():
|
|
raise GrottiError("Eine Sorte mit diesem Namen gibt es schon.", "name") from exc
|
|
raise
|
|
if not row:
|
|
raise GrottiError("Die Sorte fehlt.", "material", 404)
|
|
return jsonify(row)
|
|
|
|
@app.delete("/api/v1/materialien/<int:material_id>")
|
|
def material_delete(material_id):
|
|
result = store.delete_material(conn(), material_id)
|
|
if result == "in_use":
|
|
raise GrottiError("Sorte ist noch an Spulen gebunden.", "material")
|
|
if not result:
|
|
raise GrottiError("Die Sorte fehlt.", "material", 404)
|
|
return "", 204
|
|
|
|
@app.get("/api/v1/farben")
|
|
def color_list_api():
|
|
return jsonify(color_catalog())
|
|
|
|
@app.get("/api/v1/kunden")
|
|
def kunden_list():
|
|
return jsonify(grotti_orders.list_customers(conn()))
|
|
|
|
@app.post("/api/v1/kunden")
|
|
def kunden_create():
|
|
data = body()
|
|
name = (data.get("name") or "").strip()
|
|
if not name:
|
|
raise GrottiError("Der Kunde braucht einen Namen.", "name")
|
|
return jsonify(
|
|
grotti_orders.create_customer(
|
|
conn(),
|
|
name,
|
|
(data.get("email") or "").strip(),
|
|
(data.get("notes") or "").strip(),
|
|
)
|
|
), 201
|
|
|
|
@app.patch("/api/v1/kunden/<int:customer_id>")
|
|
def kunden_patch(customer_id):
|
|
data = body()
|
|
fields = {}
|
|
if "name" in data:
|
|
name = (data.get("name") or "").strip()
|
|
if not name:
|
|
raise GrottiError("Der Kunde braucht einen Namen.", "name")
|
|
fields["name"] = name
|
|
if "email" in data:
|
|
fields["email"] = (data.get("email") or "").strip()
|
|
if "notes" in data:
|
|
fields["notes"] = (data.get("notes") or "").strip()
|
|
row = grotti_orders.update_customer(conn(), customer_id, fields)
|
|
if not row:
|
|
raise GrottiError("Der Kunde fehlt.", "kunde", 404)
|
|
return jsonify(row)
|
|
|
|
@app.delete("/api/v1/kunden/<int:customer_id>")
|
|
def kunden_delete(customer_id):
|
|
if not grotti_orders.delete_customer(conn(), customer_id):
|
|
raise GrottiError("Der Kunde fehlt.", "kunde", 404)
|
|
return "", 204
|
|
|
|
@app.get("/api/v1/auftraege")
|
|
def auftraege_list():
|
|
status = (request.args.get("status") or "").strip().lower()
|
|
if status and status not in grotti_orders.ORDER_STATUSES:
|
|
raise GrottiError("Unbekannter Status.", "status")
|
|
return jsonify(grotti_orders.list_orders(conn(), status=status or None))
|
|
|
|
@app.post("/api/v1/auftraege")
|
|
def auftraege_create():
|
|
data = body()
|
|
title = (data.get("title") or "").strip()
|
|
if not title:
|
|
raise GrottiError("Der Auftrag braucht einen Titel.", "titel")
|
|
try:
|
|
status = grotti_orders.normalize_status(data.get("status") or "idee")
|
|
except ValueError as exc:
|
|
raise GrottiError(str(exc), "status") from exc
|
|
cid = optional_id(data.get("customer_id"))
|
|
return jsonify(
|
|
grotti_orders.create_order(
|
|
conn(),
|
|
title,
|
|
status,
|
|
customer_id=cid,
|
|
due_at=data.get("due_at"),
|
|
notes=(data.get("notes") or "").strip(),
|
|
quote=data.get("quote") if isinstance(data.get("quote"), dict) else {},
|
|
)
|
|
), 201
|
|
|
|
@app.get("/api/v1/auftraege/<int:order_id>")
|
|
def auftrag_get(order_id):
|
|
row = grotti_orders.get_order(conn(), order_id)
|
|
if not row:
|
|
raise GrottiError("Der Auftrag fehlt.", "auftrag", 404)
|
|
row["actuals"] = order_actuals(conn(), order_id)
|
|
return jsonify(row)
|
|
|
|
@app.patch("/api/v1/auftraege/<int:order_id>")
|
|
def auftrag_patch(order_id):
|
|
data = body()
|
|
fields = {}
|
|
if "title" in data:
|
|
title = (data.get("title") or "").strip()
|
|
if not title:
|
|
raise GrottiError("Der Auftrag braucht einen Titel.", "titel")
|
|
fields["title"] = title
|
|
if "status" in data:
|
|
try:
|
|
fields["status"] = grotti_orders.normalize_status(data.get("status"))
|
|
except ValueError as exc:
|
|
raise GrottiError(str(exc), "status") from exc
|
|
if "customer_id" in data:
|
|
fields["customer_id"] = optional_id(data.get("customer_id"))
|
|
if "due_at" in data:
|
|
fields["due_at"] = data.get("due_at")
|
|
if "notes" in data:
|
|
fields["notes"] = data.get("notes") or ""
|
|
if "quote" in data and isinstance(data.get("quote"), dict):
|
|
fields["quote"] = data["quote"]
|
|
row = grotti_orders.update_order(conn(), order_id, fields)
|
|
if not row:
|
|
raise GrottiError("Der Auftrag fehlt.", "auftrag", 404)
|
|
row["actuals"] = order_actuals(conn(), order_id)
|
|
return jsonify(row)
|
|
|
|
@app.delete("/api/v1/auftraege/<int:order_id>")
|
|
def auftrag_delete(order_id):
|
|
if not grotti_orders.delete_order(conn(), order_id):
|
|
raise GrottiError("Der Auftrag fehlt.", "auftrag", 404)
|
|
return "", 204
|
|
|
|
@app.post("/api/v1/auftraege/<int:order_id>/positionen")
|
|
def auftrag_position_create(order_id):
|
|
data = body()
|
|
file_id = optional_id(data.get("file_id"))
|
|
row = grotti_orders.create_order_item(
|
|
conn(),
|
|
order_id,
|
|
file_id=file_id,
|
|
qty=data.get("qty", 1),
|
|
unit_price=data.get("unit_price", 0),
|
|
material_type=(data.get("material_type") or "").strip(),
|
|
color=(data.get("color") or "").strip(),
|
|
note=(data.get("note") or "").strip(),
|
|
)
|
|
if not row:
|
|
raise GrottiError("Der Auftrag fehlt.", "auftrag", 404)
|
|
return jsonify(row), 201
|
|
|
|
@app.patch("/api/v1/auftraege/positionen/<int:item_id>")
|
|
def auftrag_position_patch(item_id):
|
|
data = body()
|
|
fields = {}
|
|
for key in ("file_id", "qty", "unit_price", "material_type", "color", "note"):
|
|
if key in data:
|
|
fields[key] = data[key] if key != "file_id" else optional_id(data.get("file_id"))
|
|
row = grotti_orders.update_order_item(conn(), item_id, fields)
|
|
if not row:
|
|
raise GrottiError("Die Position fehlt.", "position", 404)
|
|
return jsonify(row)
|
|
|
|
@app.delete("/api/v1/auftraege/positionen/<int:item_id>")
|
|
def auftrag_position_delete(item_id):
|
|
if not grotti_orders.delete_order_item(conn(), item_id):
|
|
raise GrottiError("Die Position fehlt.", "position", 404)
|
|
return "", 204
|
|
|
|
@app.post("/api/v1/auftraege/<int:order_id>/einreihen")
|
|
def auftrag_einreihen(order_id):
|
|
data = body()
|
|
if not bool(data.get("confirm")):
|
|
raise GrottiError("Bestätigung fehlt.", "bestaetigung")
|
|
try:
|
|
item_id = int(data.get("item_id"))
|
|
except (TypeError, ValueError) as exc:
|
|
raise GrottiError("Position fehlt.", "position") from exc
|
|
host = optional_host(data.get("host") or "")
|
|
family = (data.get("family") or "").strip()
|
|
if not host and not family:
|
|
file_row = None
|
|
item = grotti_orders.get_order_item(conn(), item_id)
|
|
if item and item.get("file_id"):
|
|
file_row = store.get_file_row(conn(), item["file_id"])
|
|
family = (file_row or {}).get("printer_family") or ""
|
|
try:
|
|
row = grotti_orders.enqueue_order_item(
|
|
conn(),
|
|
order_id,
|
|
item_id,
|
|
host=host,
|
|
family=family,
|
|
priority=int(data.get("priority", 100)),
|
|
spool_id=optional_id(data.get("spool_id")),
|
|
ace_map=data.get("ace_map") if isinstance(data.get("ace_map"), list) else [],
|
|
bed_leveling=bool(data.get("bed_leveling")),
|
|
override=bool(data.get("override_machine")),
|
|
)
|
|
except ValueError as exc:
|
|
raise GrottiError(str(exc), "auftrag") from exc
|
|
return jsonify(row), 201
|
|
|
|
@app.get("/api/v1/spulen")
|
|
def spool_list():
|
|
aktiv_raw = (request.args.get("aktiv") or "").strip().lower()
|
|
aktiv = None
|
|
if aktiv_raw in ("1", "true", "yes"):
|
|
aktiv = True
|
|
elif aktiv_raw in ("0", "false", "no"):
|
|
aktiv = False
|
|
limit_raw = request.args.get("limit")
|
|
limit = None
|
|
offset = 0
|
|
if limit_raw is not None and str(limit_raw).strip() != "":
|
|
try:
|
|
limit = max(1, min(500, int(limit_raw)))
|
|
except (TypeError, ValueError):
|
|
limit = 100
|
|
try:
|
|
offset = max(0, int(request.args.get("offset") or 0))
|
|
except (TypeError, ValueError):
|
|
offset = 0
|
|
data = store.list_spools(conn(), aktiv=aktiv, limit=limit, offset=offset)
|
|
resp = jsonify(data["items"])
|
|
resp.headers["X-Total-Count"] = str(data["total"])
|
|
return resp
|
|
|
|
@app.get("/api/v1/spulen/by-code/<path:code>")
|
|
def spool_by_code(code):
|
|
text = (code or "").strip()
|
|
if text.upper().startswith("D-"):
|
|
run = store.get_run_by_chargen(conn(), text)
|
|
if not run:
|
|
raise GrottiError("Kein Druck mit dieser Charge.", "charge", 404)
|
|
return jsonify({"kind": "lauf", "run": store.run_out(run), "redirect": "/protokoll/%s" % run["id"]})
|
|
row = store.get_spool_by_code(conn(), text)
|
|
if not row:
|
|
raise GrottiError("Keine Spule mit diesem Code.", "spule", 404)
|
|
return jsonify(row)
|
|
|
|
@app.get("/api/v1/spulen/<int:spool_id>/akte")
|
|
def spool_akte(spool_id):
|
|
spool = store.get_spool_row(conn(), spool_id)
|
|
if not spool:
|
|
raise GrottiError("Die Spule fehlt.", "spule", 404)
|
|
return jsonify({
|
|
"spool": store.spool_out(spool),
|
|
"runs": store.list_spool_runs(conn(), spool_id),
|
|
"stats": store.spool_usage_stats(conn(), spool_id),
|
|
})
|
|
|
|
@app.post("/api/v1/spulen")
|
|
def spool_create():
|
|
return jsonify(store.create_spool(conn(), spool_fields(body()))), 201
|
|
|
|
@app.patch("/api/v1/spulen/<int:spool_id>")
|
|
def spool_patch(spool_id):
|
|
data = body()
|
|
fields = spool_fields(data, partial=True, spool_id=spool_id)
|
|
if "archived" in data or "archived_at" in data:
|
|
if data.get("archived") is False or data.get("archived_at") is None:
|
|
fields["archived_at"] = None
|
|
elif data.get("archived") is True or data.get("archived_at") in (True, "now"):
|
|
fields["archived_at"] = "now"
|
|
row = store.update_spool(conn(), spool_id, fields)
|
|
if not row:
|
|
raise GrottiError("Die Spule fehlt.", "spule", 404)
|
|
return jsonify(row)
|
|
|
|
@app.post("/api/v1/spulen/<int:spool_id>/leer")
|
|
def spool_empty(spool_id):
|
|
"""Rest 0, Regal, archivieren — wenn der Rest falsch geschätzt war."""
|
|
row = store.mark_spool_empty(conn(), spool_id)
|
|
if not row:
|
|
raise GrottiError("Die Spule fehlt.", "spule", 404)
|
|
store.add_event(conn(), "", "", "spule", "Spule „%s“ als leer markiert" % row["name"])
|
|
return jsonify(row)
|
|
|
|
@app.post("/api/v1/spulen/<int:spool_id>/einlegen")
|
|
def spool_load(spool_id):
|
|
"""Spule an Drucker/Platz legen; vorherige Rolle dort geht ins Regal."""
|
|
data = body()
|
|
host = require_host((data.get("host") or "").strip())
|
|
slot = ace_slot(data.get("ace_slot"))
|
|
spool = store.get_spool_row(conn(), spool_id)
|
|
if not spool:
|
|
raise GrottiError("Die Spule fehlt.", "spule", 404)
|
|
# Auch offene History-Jobs (Pause/Resume nach Moonraker-Split), nicht nur live:
|
|
live_run = store.find_active_run(conn(), host)
|
|
mm_now = float((live_run or {}).get("filament_used_mm") or 0)
|
|
printing = bool(
|
|
live_run and (live_run.get("state") or "") in ("in_progress", "printing", "paused")
|
|
)
|
|
if printing:
|
|
try:
|
|
snap = moonraker.query(host)
|
|
if isinstance(snap.get("filament_used"), (int, float)):
|
|
mm_now = float(snap["filament_used"])
|
|
except Exception:
|
|
pass
|
|
# Alte Rolle am Platz / externe Rolle am Host freimachen
|
|
if slot:
|
|
old = conn().execute(
|
|
"SELECT * FROM spools WHERE printer_host = %s AND ace_slot = %s AND id <> %s",
|
|
(host, slot, spool_id),
|
|
).fetchall()
|
|
else:
|
|
old = conn().execute(
|
|
"SELECT * FROM spools WHERE printer_host = %s AND ace_slot IS NULL AND id <> %s",
|
|
(host, spool_id),
|
|
).fetchall()
|
|
printer = store.printer_by_host(conn(), host) or {}
|
|
if printing:
|
|
closed = store.close_open_segments(conn(), live_run["id"], slot, mm_now)
|
|
if not closed and old:
|
|
# Erster Wechsel: alter Abschnitt von 0 bis jetzt
|
|
for row in old:
|
|
store.open_segment(conn(), live_run["id"], row["id"], slot, 0)
|
|
store.close_open_segments(conn(), live_run["id"], slot, mm_now)
|
|
elif not closed and mm_now > 0:
|
|
# ACE ohne Startabschnitt oder alte Rolle schon im Regal —
|
|
# slot-genau: Platz / ACE-Map / letzter Abschnitt / Lauf-Hinweis.
|
|
prev_id = store.prev_spool_id_for_slot(
|
|
conn(), host, slot, live_run, spool_id, old_rows=old,
|
|
)
|
|
if prev_id:
|
|
store.open_segment(conn(), live_run["id"], prev_id, slot, 0)
|
|
store.close_open_segments(conn(), live_run["id"], slot, mm_now)
|
|
for row in old:
|
|
store.update_spool(conn(), row["id"], {"printer_host": "", "ace_slot": None})
|
|
store.add_event(
|
|
conn(),
|
|
host,
|
|
printer.get("name") or host,
|
|
"spule",
|
|
"%s: „%s“ ins Regal%s" % (
|
|
printer.get("name") or host,
|
|
row["name"],
|
|
(" (Platz %s)" % slot) if slot else "",
|
|
),
|
|
(live_run or {}).get("filename") or "",
|
|
run_id=(live_run or {}).get("id"),
|
|
)
|
|
updated = store.update_spool(conn(), spool_id, {"printer_host": host, "ace_slot": slot})
|
|
if printing:
|
|
store.open_segment(conn(), live_run["id"], spool_id, slot, mm_now)
|
|
store.assign_run_spool(conn(), live_run["id"], spool_id)
|
|
store.update_send_spool(conn(), host, live_run.get("filename") or "", spool_id)
|
|
store.add_event(
|
|
conn(),
|
|
host,
|
|
printer.get("name") or host,
|
|
"spule",
|
|
"%s: „%s“ eingelegt%s" % (
|
|
printer.get("name") or host,
|
|
updated["name"],
|
|
(" auf Platz %s" % slot) if slot else "",
|
|
),
|
|
(live_run or {}).get("filename") or "",
|
|
run_id=(live_run or {}).get("id"),
|
|
)
|
|
return jsonify(updated)
|
|
|
|
@app.delete("/api/v1/spulen/<int:spool_id>")
|
|
def spool_delete(spool_id):
|
|
if not store.delete_spool(conn(), spool_id):
|
|
raise GrottiError("Die Spule fehlt.", "spule", 404)
|
|
return "", 204
|
|
|
|
def spool_fields(data, partial=False, spool_id=None):
|
|
fields = {}
|
|
if not partial or "name" in data:
|
|
name = (data.get("name") or "").strip()
|
|
if not name:
|
|
raise GrottiError("Die Spule braucht einen Namen.", "name")
|
|
fields["name"] = name
|
|
text_keys = ("brand", "material_type", "hersteller_charge")
|
|
for key in text_keys:
|
|
if not partial or key in data:
|
|
fields[key] = (data.get(key) or "").strip()
|
|
if not partial or "colors" in data or "color" in data:
|
|
fields["colors"] = color_list(data.get("colors"))
|
|
label = (data.get("color") or "").strip()
|
|
if not label:
|
|
label = " / ".join(item["name"] for item in fields["colors"])
|
|
fields["color"] = label
|
|
for key, default in (("price_per_kg", 0), ("density", 1.24), ("volumetric", 12), ("remaining_g", 1000)):
|
|
if not partial or key in data:
|
|
try:
|
|
fields[key] = float(data.get(key, default) or 0)
|
|
except (TypeError, ValueError) as exc:
|
|
raise GrottiError("%s muss eine Zahl sein." % key, "zahl") from exc
|
|
if not partial or "printer_host" in data:
|
|
fields["printer_host"] = optional_host(data.get("printer_host") or "")
|
|
if not partial or "ace_slot" in data:
|
|
fields["ace_slot"] = ace_slot(data.get("ace_slot"))
|
|
if not partial or "material_id" in data:
|
|
fields["material_id"] = optional_id(data.get("material_id"))
|
|
# Doppelte Plätze verhindern
|
|
host = fields.get("printer_host")
|
|
slot = fields.get("ace_slot")
|
|
if host is None or slot is None:
|
|
current = store.get_spool_row(conn(), spool_id) if spool_id else None
|
|
if host is None and current:
|
|
host = current.get("printer_host") or ""
|
|
if slot is None and current:
|
|
slot = current.get("ace_slot")
|
|
if host and slot:
|
|
taken = conn().execute(
|
|
"""
|
|
SELECT id, name FROM spools
|
|
WHERE printer_host = %s AND ace_slot = %s
|
|
AND (%s::bigint IS NULL OR id <> %s)
|
|
LIMIT 1
|
|
""",
|
|
(host, slot, spool_id, spool_id),
|
|
).fetchone()
|
|
if taken:
|
|
raise GrottiError(
|
|
"Platz %s auf diesem Drucker ist schon von „%s“ belegt."
|
|
% (slot, taken["name"]),
|
|
"ace",
|
|
409,
|
|
)
|
|
return fields
|
|
|
|
def color_list(raw):
|
|
if raw in (None, ""):
|
|
return []
|
|
if not isinstance(raw, list):
|
|
raise GrottiError("Farben sind eine Liste.", "farbe")
|
|
if len(raw) > 8:
|
|
raise GrottiError("Eine Spule hat höchstens acht Farben.", "farbe")
|
|
colors = []
|
|
for item in raw:
|
|
if isinstance(item, dict):
|
|
name = (item.get("name") or "").strip()
|
|
hex_value = (item.get("hex") or "").strip()
|
|
else:
|
|
raise GrottiError("Eine Farbe stimmt nicht.", "farbe")
|
|
if not re.fullmatch(r"#[0-9A-Fa-f]{6}", hex_value):
|
|
raise GrottiError("Eine Farbe braucht einen Hex-Wert.", "farbe")
|
|
colors.append({"name": name or hex_value, "hex": hex_value.lower()})
|
|
return colors
|
|
|
|
def ace_slot(raw):
|
|
if raw in (None, "", 0, "0"):
|
|
return None
|
|
try:
|
|
slot = int(raw)
|
|
except (TypeError, ValueError) as exc:
|
|
raise GrottiError("Der ACE-Platz ist eine Zahl.", "ace") from exc
|
|
if slot < 1 or slot > 8:
|
|
raise GrottiError("Ein ACE hat vier Plätze, ein zweites ACE die Plätze 5 bis 8.", "ace")
|
|
return slot
|
|
|
|
@app.post("/api/v1/kalkulation")
|
|
def quote():
|
|
data = body()
|
|
spool = None
|
|
spool_id = optional_id(data.get("spool_id"))
|
|
if spool_id:
|
|
spool = store.get_spool_row(conn(), spool_id)
|
|
if not spool:
|
|
raise GrottiError("Die Spule fehlt.", "spule", 404)
|
|
material = {
|
|
"price_per_kg": spool["price_per_kg"] if spool else float(data.get("price_per_kg") or 0),
|
|
"density": spool["density"] if spool else float(data.get("density") or 1.24),
|
|
"volumetric": spool["volumetric"] if spool else float(data.get("volumetric") or 12),
|
|
}
|
|
job = {
|
|
"weight_g": float(data.get("weight_g") or 0),
|
|
"qty": float(data.get("qty") or 1),
|
|
"waste_percent": float(data.get("waste_percent", cfg["energy"]["waste_percent"]) or 0),
|
|
"utilization": float(data.get("utilization", cfg["energy"]["utilization"]) or 1),
|
|
"watts": float(data.get("watts", cfg["energy"]["watts"]) or 0),
|
|
"euro_per_kwh": float(data.get("euro_per_kwh", cfg["energy"]["euro_per_kwh"]) or 0),
|
|
"dryer_watts": float(data.get("dryer_watts", cfg["energy"]["dryer_watts"]) or 0),
|
|
"dry_hours": float(data.get("dry_hours", cfg["energy"]["dry_hours"]) or 0),
|
|
"price_mode": data.get("price_mode") or "perPart",
|
|
"price": float(data.get("price") or 0),
|
|
}
|
|
result = calculate(job, material)
|
|
payload = {"inputs": job, "material": material, "result": result}
|
|
project_id = optional_id(data.get("project_id"))
|
|
if project_id:
|
|
saved = store.update_project(conn(), project_id, {"quote": payload})
|
|
if not saved:
|
|
raise GrottiError("Das Projekt fehlt.", "projekt", 404)
|
|
return jsonify(payload)
|
|
|
|
@app.get("/api/v1/laeufe")
|
|
def run_list():
|
|
try:
|
|
limit = min(1000, max(1, int(request.args.get("limit") or 500)))
|
|
except (TypeError, ValueError):
|
|
limit = 500
|
|
return jsonify(store.list_runs(conn(), limit=limit))
|
|
|
|
@app.get("/api/v1/laeufe/aktuell")
|
|
def run_aktuell():
|
|
"""Aktueller oder letzter Temperatur-/ED-Verlauf fürs Cockpit (host=)."""
|
|
host = require_host(request.args.get("host", ""))
|
|
run = store.latest_run_for_host(conn(), host)
|
|
if not run:
|
|
return jsonify({"run": None, "samples": [], "energy": None})
|
|
run_id = run["id"]
|
|
samples = store.list_run_samples(conn(), run_id)
|
|
from grotti.cost import energy_estimate
|
|
|
|
energy = energy_estimate(run.get("duration_s"), cfg["energy"], samples)
|
|
if len(samples) > 180:
|
|
step = max(1, len(samples) // 120)
|
|
samples = samples[::step]
|
|
return jsonify({
|
|
"run": run,
|
|
"samples": samples,
|
|
"energy": energy,
|
|
"sample_count": int(run.get("_sample_count") or len(samples)),
|
|
})
|
|
|
|
@app.get("/api/v1/laeufe/<int:run_id>")
|
|
def run_get(run_id):
|
|
row = store.get_run_row(conn(), run_id)
|
|
if not row:
|
|
raise GrottiError("Der Lauf fehlt.", "lauf", 404)
|
|
run = store.run_out(row)
|
|
if not run.get("chargen_nr"):
|
|
store.ensure_run_chargen(conn(), run_id)
|
|
row = store.get_run_row(conn(), run_id) or row
|
|
run = store.run_out(row)
|
|
if run.get("chargen_nr") and run.get("objects"):
|
|
store.ensure_run_labels(conn(), run_id, run.get("objects") or [], qty=1)
|
|
if run.get("order_item_id") and not run.get("order_id"):
|
|
oi = conn().execute(
|
|
"SELECT order_id FROM order_items WHERE id = %s",
|
|
(run["order_item_id"],),
|
|
).fetchone()
|
|
if oi:
|
|
run["order_id"] = oi["order_id"]
|
|
file_row = store.get_file_row(conn(), run["file_id"]) if run.get("file_id") else None
|
|
project = (
|
|
store.get_project(conn(), run["project_id"], watch_dir=cfg.get("watch_dir"))
|
|
if run.get("project_id") else None
|
|
)
|
|
samples = store.list_run_samples(conn(), run_id)
|
|
from grotti.cost import energy_estimate
|
|
|
|
energy = energy_estimate(run.get("duration_s"), cfg["energy"], samples)
|
|
# Anzeige auf ca. 1 Punkt / Minute verdichten
|
|
if len(samples) > 180:
|
|
step = max(1, len(samples) // 120)
|
|
samples = samples[::step]
|
|
return jsonify({
|
|
"run": run,
|
|
"spools": store.list_run_spools(conn(), run_id),
|
|
"segments": store.list_run_segments(conn(), run_id),
|
|
"samples": samples,
|
|
"labels": store.list_run_labels(conn(), run_id),
|
|
"events": store.list_run_events(conn(), run_id),
|
|
"file": store.file_out(file_row, watch_dir=cfg.get("watch_dir"), conn=conn()) if file_row else None,
|
|
"project": project,
|
|
"energy": energy,
|
|
})
|
|
|
|
@app.post("/api/v1/laeufe/abgleich")
|
|
def run_sync():
|
|
library.sync_watch(conn(), cfg, force=False)
|
|
return jsonify(jobs.sync_history(conn(), cfg))
|
|
|
|
@app.post("/api/v1/laeufe/<int:run_id>/verbinden")
|
|
def run_merge(run_id):
|
|
"""Zwei Protokoll-Zeilen desselben physischen Drucks verbinden (admin)."""
|
|
require_role("admin")
|
|
data = body()
|
|
other = int(data.get("other_id") or data.get("mit") or 0)
|
|
if not other:
|
|
raise GrottiError("other_id fehlt.", "lauf")
|
|
return jsonify(jobs.manual_merge_runs(
|
|
conn(), run_id, other, confirm=bool(data.get("confirm"))
|
|
))
|
|
|
|
@app.patch("/api/v1/laeufe/<int:run_id>")
|
|
def run_patch(run_id):
|
|
data = body()
|
|
row = None
|
|
if "spool_id" in data and data.get("spool_id"):
|
|
row = jobs.assign_and_deduct(conn(), cfg, run_id, int(data["spool_id"]))
|
|
if "verdict" in data:
|
|
if data["verdict"] not in VERDICTS:
|
|
raise GrottiError("Urteil ist gut oder Ausschuss.", "urteil")
|
|
row = store.set_verdict(conn(), run_id, data["verdict"])
|
|
if row is None:
|
|
current = store.get_run_row(conn(), run_id)
|
|
if not current:
|
|
raise GrottiError("Der Lauf fehlt.", "lauf", 404)
|
|
row = store.run_out(current)
|
|
return jsonify(row)
|
|
|
|
@app.get("/api/v1/bedarf")
|
|
def bedarf_api():
|
|
from grotti import bedarf as bedarf_mod
|
|
|
|
return jsonify(bedarf_mod.compute(conn()))
|
|
|
|
@app.get("/api/v1/wartung")
|
|
def wartung_api():
|
|
from grotti import maintenance
|
|
|
|
return jsonify(maintenance.list_for_api(conn(), store.list_printers(conn())))
|
|
|
|
@app.post("/api/v1/wartung/teile")
|
|
def wartung_teil_create():
|
|
from grotti import maintenance
|
|
|
|
data = body()
|
|
host = validate_printer_host(data.get("printer_host") or data.get("host") or "")
|
|
require_host(host)
|
|
try:
|
|
part = maintenance.create_part(
|
|
conn(),
|
|
host,
|
|
data.get("part_key") or "",
|
|
label=data.get("label") or "",
|
|
life_hours=data.get("life_hours") or 0,
|
|
life_meters=data.get("life_meters") or 0,
|
|
note=data.get("note") or "",
|
|
)
|
|
except ValueError as exc:
|
|
raise GrottiError(str(exc), "wartung") from exc
|
|
conn().commit()
|
|
return jsonify(part)
|
|
|
|
@app.post("/api/v1/wartung/teile/<int:part_id>/reset")
|
|
def wartung_teil_reset(part_id):
|
|
from grotti import maintenance
|
|
|
|
part = maintenance.reset_part(conn(), part_id)
|
|
if not part:
|
|
raise GrottiError("Teil fehlt.", "wartung", 404)
|
|
conn().commit()
|
|
return jsonify(part)
|
|
|
|
@app.post("/api/v1/backup")
|
|
def backup_create():
|
|
from grotti import backup as backup_mod
|
|
|
|
try:
|
|
meta = backup_mod.create_backup(cfg)
|
|
except RuntimeError as exc:
|
|
raise GrottiError(str(exc), "backup") from exc
|
|
return jsonify(meta)
|
|
|
|
@app.get("/api/v1/backup")
|
|
def backup_list():
|
|
from grotti import backup as backup_mod
|
|
|
|
return jsonify({"items": backup_mod.list_backups(cfg)})
|
|
|
|
@app.get("/api/v1/backup/<name>")
|
|
def backup_download(name):
|
|
from grotti import backup as backup_mod
|
|
|
|
path = backup_mod.backup_path(cfg, name)
|
|
if not path:
|
|
raise GrottiError("Backup fehlt.", "backup", 404)
|
|
return send_file(path, as_attachment=True, download_name=path.name)
|
|
|
|
@app.get("/api/v1/statistik")
|
|
def statistik_api():
|
|
since = request.args.get("since") or None
|
|
until = request.args.get("until") or None
|
|
host = (request.args.get("host") or "").strip()
|
|
material = (request.args.get("material") or "").strip()
|
|
brand = (request.args.get("brand") or "").strip()
|
|
color = (request.args.get("color") or "").strip()
|
|
project_id = optional_id(request.args.get("project_id"))
|
|
return jsonify(store.statistics(
|
|
conn(),
|
|
since=since,
|
|
until=until,
|
|
host=host,
|
|
material=material or "",
|
|
brand=brand or "",
|
|
color=color or "",
|
|
project_id=project_id,
|
|
))
|
|
|
|
@app.get("/api/v1/statistik.csv")
|
|
def statistik_csv():
|
|
import csv
|
|
import io
|
|
from flask import Response
|
|
|
|
since = request.args.get("since") or None
|
|
until = request.args.get("until") or None
|
|
host = (request.args.get("host") or "").strip()
|
|
material = (request.args.get("material") or "").strip()
|
|
brand = (request.args.get("brand") or "").strip()
|
|
runs = store.list_runs(
|
|
conn(),
|
|
limit=2000,
|
|
since=since,
|
|
until=until,
|
|
host=host,
|
|
material=material,
|
|
brand=brand,
|
|
)
|
|
buf = io.StringIO()
|
|
writer = csv.writer(buf, delimiter=";")
|
|
writer.writerow([
|
|
"id", "drucker", "datei", "zustand", "start", "ende", "dauer_s",
|
|
"soll_g", "ist_g", "quelle", "filament_eur", "strom_eur", "urteil", "charge",
|
|
])
|
|
for run in runs:
|
|
writer.writerow([
|
|
run["id"],
|
|
run.get("printer_name") or "",
|
|
run.get("filename") or "",
|
|
run.get("state") or "",
|
|
run.get("started_at") or "",
|
|
run.get("ended_at") or "",
|
|
run.get("duration_s") or 0,
|
|
run.get("weight_planned_g") or 0,
|
|
run.get("weight_used_g") or 0,
|
|
run.get("weight_source") or "",
|
|
run.get("filament_cost") or 0,
|
|
run.get("energy_cost") or 0,
|
|
run.get("verdict") or "",
|
|
run.get("chargen_nr") or "",
|
|
])
|
|
return Response(
|
|
buf.getvalue(),
|
|
mimetype="text/csv; charset=utf-8",
|
|
headers={"Content-Disposition": "attachment; filename=grotti-laeufe.csv"},
|
|
)
|
|
|
|
@app.get("/api/v1/stream")
|
|
def api_event_stream():
|
|
from flask import Response, stream_with_context
|
|
|
|
from grotti import events_bus
|
|
|
|
def generate():
|
|
q = events_bus.subscribe()
|
|
try:
|
|
while True:
|
|
item = events_bus.wait_event(q, 15.0)
|
|
if item is None:
|
|
yield "event: ping\ndata: {}\n\n"
|
|
continue
|
|
kind = item.get("kind") or "message"
|
|
payload = item.get("payload") or {}
|
|
yield "event: %s\ndata: %s\n\n" % (
|
|
kind,
|
|
json.dumps(payload, ensure_ascii=False),
|
|
)
|
|
except GeneratorExit:
|
|
pass
|
|
finally:
|
|
events_bus.unsubscribe(q)
|
|
|
|
# Kein Connection-Header: waitress verbietet Hop-by-Hop-Header (PEP 3333).
|
|
return Response(
|
|
stream_with_context(generate()),
|
|
mimetype="text/event-stream; charset=utf-8",
|
|
headers={
|
|
"Cache-Control": "no-cache",
|
|
"X-Accel-Buffering": "no",
|
|
},
|
|
)
|
|
|
|
return app
|