243 lines
9.0 KiB
Python
243 lines
9.0 KiB
Python
"""Service d'impression — file d'attente SQLite + appel script_print.sh."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
import subprocess
|
|
import time
|
|
import uuid
|
|
from pathlib import Path
|
|
from typing import Literal
|
|
|
|
import aiosqlite
|
|
|
|
from backend.services.config_service import Config
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
PrintStatus = Literal["pending", "printing", "done", "cancelled", "error"]
|
|
|
|
CREATE_SQL = """
|
|
CREATE TABLE IF NOT EXISTS print_queue (
|
|
id TEXT PRIMARY KEY,
|
|
filename TEXT NOT NULL,
|
|
thumb_url TEXT,
|
|
copies INTEGER DEFAULT 1,
|
|
status TEXT DEFAULT 'pending',
|
|
printer TEXT,
|
|
requested_at REAL,
|
|
processed_at REAL,
|
|
error_msg TEXT
|
|
);
|
|
"""
|
|
|
|
|
|
class PrinterService:
|
|
def __init__(self, config: Config):
|
|
self._cfg = config.print
|
|
self._db_path: Path | None = None
|
|
self._db: aiosqlite.Connection | None = None
|
|
self._lock = asyncio.Lock()
|
|
|
|
async def init_db(self, db_path: Path):
|
|
db_path.parent.mkdir(parents=True, exist_ok=True)
|
|
self._db_path = db_path
|
|
self._db = await aiosqlite.connect(str(db_path))
|
|
self._db.row_factory = aiosqlite.Row
|
|
await self._db.execute(CREATE_SQL)
|
|
await self._db.commit()
|
|
logger.info("Base print_queue initialisée: %s", db_path)
|
|
|
|
async def close(self):
|
|
if self._db:
|
|
await self._db.close()
|
|
|
|
# ── File d'attente ────────────────────────────────────────────────────────
|
|
|
|
async def add_request(self, filename: str, thumb_url: str = "", copies: int = 1) -> dict:
|
|
"""Ajoute une demande d'impression dans la file. Retourne l'entrée créée."""
|
|
entry_id = str(uuid.uuid4())
|
|
now = time.time()
|
|
|
|
await self._db.execute(
|
|
"INSERT INTO print_queue (id, filename, thumb_url, copies, status, requested_at) "
|
|
"VALUES (?, ?, ?, ?, 'pending', ?)",
|
|
(entry_id, filename, thumb_url, copies, now),
|
|
)
|
|
await self._db.commit()
|
|
|
|
entry = {
|
|
"id": entry_id,
|
|
"filename": filename,
|
|
"thumb_url": thumb_url,
|
|
"copies": copies,
|
|
"status": "pending",
|
|
"requested_at": now,
|
|
}
|
|
|
|
# Mode direct : impression immédiate sans validation
|
|
if self._cfg.mode == "direct":
|
|
asyncio.create_task(self.execute_print(entry_id, copies))
|
|
|
|
logger.info("Demande d'impression ajoutée: %s (%s)", entry_id, filename)
|
|
return entry
|
|
|
|
async def get_queue(self, status: str | None = None) -> list[dict]:
|
|
"""Liste les entrées de la file d'attente."""
|
|
if status:
|
|
cursor = await self._db.execute(
|
|
"SELECT * FROM print_queue WHERE status = ? ORDER BY requested_at DESC",
|
|
(status,),
|
|
)
|
|
else:
|
|
cursor = await self._db.execute(
|
|
"SELECT * FROM print_queue ORDER BY requested_at DESC LIMIT 100"
|
|
)
|
|
rows = await cursor.fetchall()
|
|
return [dict(r) for r in rows]
|
|
|
|
async def get_pending(self) -> list[dict]:
|
|
return await self.get_queue("pending")
|
|
|
|
async def cancel(self, entry_id: str) -> bool:
|
|
async with self._lock:
|
|
cursor = await self._db.execute(
|
|
"SELECT status FROM print_queue WHERE id = ?", (entry_id,)
|
|
)
|
|
row = await cursor.fetchone()
|
|
if not row or row["status"] not in ("pending",):
|
|
return False
|
|
await self._db.execute(
|
|
"UPDATE print_queue SET status='cancelled', processed_at=? WHERE id=?",
|
|
(time.time(), entry_id),
|
|
)
|
|
await self._db.commit()
|
|
return True
|
|
|
|
# ── Impression ────────────────────────────────────────────────────────────
|
|
|
|
async def execute_print(self, entry_id: str, copies: int = 1, printer: str = "") -> dict:
|
|
"""Lance l'impression via script_print.sh."""
|
|
async with self._lock:
|
|
cursor = await self._db.execute(
|
|
"SELECT * FROM print_queue WHERE id = ?", (entry_id,)
|
|
)
|
|
entry = await cursor.fetchone()
|
|
if not entry:
|
|
return {"success": False, "error": "Entrée introuvable"}
|
|
if entry["status"] not in ("pending",):
|
|
return {"success": False, "error": f"Statut incompatible: {entry['status']}"}
|
|
|
|
await self._db.execute(
|
|
"UPDATE print_queue SET status='printing', copies=? WHERE id=?",
|
|
(copies, entry_id),
|
|
)
|
|
await self._db.commit()
|
|
|
|
filename = entry["filename"]
|
|
script = self._cfg.script_path
|
|
|
|
# Appel async du script d'impression
|
|
try:
|
|
result = await asyncio.to_thread(
|
|
self._run_print_script, script, filename, copies
|
|
)
|
|
except Exception as e:
|
|
result = {"success": False, "error": str(e), "printer": ""}
|
|
|
|
now = time.time()
|
|
if result["success"]:
|
|
await self._db.execute(
|
|
"UPDATE print_queue SET status='done', printer=?, processed_at=? WHERE id=?",
|
|
(result.get("printer", ""), now, entry_id),
|
|
)
|
|
else:
|
|
await self._db.execute(
|
|
"UPDATE print_queue SET status='error', error_msg=?, processed_at=? WHERE id=?",
|
|
(result.get("error", ""), now, entry_id),
|
|
)
|
|
await self._db.commit()
|
|
|
|
logger.info("Impression %s: %s", entry_id, "OK" if result["success"] else result.get("error"))
|
|
return result
|
|
|
|
def _run_print_script(self, script: str, filename: str, copies: int) -> dict:
|
|
"""Appelle script_print.sh de façon synchrone."""
|
|
if not Path(script).exists():
|
|
return {"success": False, "error": f"Script introuvable: {script}"}
|
|
if not Path(filename).exists():
|
|
return {"success": False, "error": f"Fichier introuvable: {filename}"}
|
|
|
|
cmd = ["/bin/bash", script, filename, "image", "default", str(copies)]
|
|
try:
|
|
proc = subprocess.run(
|
|
cmd, capture_output=True, text=True, timeout=60
|
|
)
|
|
stdout = proc.stdout.strip()
|
|
if proc.returncode == 0 and "PRINTED:" in stdout:
|
|
parts = stdout.split(":")
|
|
printer = parts[1] if len(parts) > 1 else ""
|
|
return {"success": True, "printer": printer, "output": stdout}
|
|
else:
|
|
return {"success": False, "error": proc.stderr.strip() or stdout, "printer": ""}
|
|
except subprocess.TimeoutExpired:
|
|
return {"success": False, "error": "Timeout impression (60s)"}
|
|
except Exception as e:
|
|
return {"success": False, "error": str(e)}
|
|
|
|
# ── Statut imprimantes CUPS ───────────────────────────────────────────────
|
|
|
|
async def get_printers_status(self) -> list[dict]:
|
|
"""Retourne le statut des imprimantes CUPS configurées."""
|
|
statuses = []
|
|
for p in self._cfg.printers:
|
|
status = await asyncio.to_thread(self._get_printer_status, p["name"])
|
|
statuses.append({
|
|
"name": p["name"],
|
|
"label": p["label"],
|
|
**status,
|
|
})
|
|
return statuses
|
|
|
|
def _get_printer_status(self, printer_name: str) -> dict:
|
|
try:
|
|
result = subprocess.run(
|
|
["lpstat", "-p", printer_name],
|
|
capture_output=True, text=True, timeout=5
|
|
)
|
|
output = result.stdout.lower()
|
|
if "idle" in output:
|
|
state = "idle"
|
|
elif "printing" in output or "processing" in output:
|
|
state = "printing"
|
|
elif "disabled" in output:
|
|
state = "disabled"
|
|
elif "not found" in output or result.returncode != 0:
|
|
state = "offline"
|
|
else:
|
|
state = "unknown"
|
|
|
|
# Compte les jobs en attente
|
|
jobs_result = subprocess.run(
|
|
["lpstat", "-o", printer_name],
|
|
capture_output=True, text=True, timeout=5
|
|
)
|
|
jobs = len([l for l in jobs_result.stdout.strip().splitlines() if l])
|
|
|
|
return {"state": state, "jobs": jobs}
|
|
except Exception as e:
|
|
return {"state": "error", "jobs": 0, "error": str(e)}
|
|
|
|
async def cancel_cups_jobs(self, printer_name: str) -> bool:
|
|
"""Annule tous les jobs CUPS pour une imprimante."""
|
|
try:
|
|
result = subprocess.run(
|
|
["cancel", "-a", printer_name],
|
|
capture_output=True, text=True, timeout=10
|
|
)
|
|
return result.returncode == 0
|
|
except Exception as e:
|
|
logger.error("Erreur cancel CUPS: %s", e)
|
|
return False
|