migrazione verso gitea
This commit is contained in:
712
trash/gestione_pickinglist_lento.py
Normal file
712
trash/gestione_pickinglist_lento.py
Normal file
@@ -0,0 +1,712 @@
|
||||
"""Picking list management window.
|
||||
|
||||
The module presents a master/detail UI for packing lists, supports reservation
|
||||
and unreservation through an async stored-procedure port and keeps rendering
|
||||
smooth by relying on deferred updates and lightweight progress indicators.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
import tkinter as tk
|
||||
import customtkinter as ctk
|
||||
from tkinter import messagebox
|
||||
from typing import Optional, Any, Dict, List, Callable
|
||||
from dataclasses import dataclass
|
||||
|
||||
# Usa overlay e runner "collaudati"
|
||||
from gestione_aree_frame_async import BusyOverlay, AsyncRunner
|
||||
|
||||
# === IMPORT procedura async prenota/s-prenota (no pyodbc qui) ===
|
||||
import asyncio
|
||||
try:
|
||||
from prenota_sprenota_sql import sp_xExePackingListPallet_async, SPResult
|
||||
except Exception:
|
||||
async def sp_xExePackingListPallet_async(*args, **kwargs):
|
||||
raise RuntimeError("sp_xExePackingListPallet_async non importabile: verifica prenota_sprenota_sql.py")
|
||||
class SPResult:
|
||||
def __init__(self, rc=-1, message="Procedura non disponibile", id_result=None):
|
||||
self.rc = rc; self.message = message; self.id_result = id_result
|
||||
|
||||
|
||||
# -------------------- SQL --------------------
|
||||
SQL_PL = """
|
||||
SELECT
|
||||
COUNT(DISTINCT Pallet) AS Pallet,
|
||||
COUNT(DISTINCT Lotto) AS Lotto,
|
||||
COUNT(DISTINCT Articolo) AS Articolo,
|
||||
COUNT(DISTINCT Descrizione) AS Descrizione,
|
||||
SUM(Qta) AS Qta,
|
||||
Documento,
|
||||
CodNazione,
|
||||
NAZIONE,
|
||||
Stato,
|
||||
MAX(PalletCella) AS PalletCella,
|
||||
MAX(Magazzino) AS Magazzino,
|
||||
MAX(Area) AS Area,
|
||||
MAX(Cella) AS Cella,
|
||||
MIN(Ordinamento) AS Ordinamento,
|
||||
MAX(IDStato) AS IDStato
|
||||
FROM dbo.XMag_ViewPackingList
|
||||
GROUP BY Documento, CodNazione, NAZIONE, Stato
|
||||
ORDER BY MIN(Ordinamento), Documento, NAZIONE, Stato;
|
||||
"""
|
||||
|
||||
SQL_PL_DETAILS = """
|
||||
SELECT *
|
||||
FROM ViewPackingListRestante
|
||||
WHERE Documento = :Documento
|
||||
ORDER BY Ordinamento;
|
||||
"""
|
||||
|
||||
# -------------------- helpers --------------------
|
||||
def _rows_to_dicts(res: Dict[str, Any]) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Converte il payload ritornato da query_json in lista di dict.
|
||||
Supporta:
|
||||
- res = [ {..}, {..} ]
|
||||
- res = { "rows": [..], "columns": [...] }
|
||||
- res = { "data": [..], "columns": [...] }
|
||||
- res = { "rows": [tuple,..], "columns": [...] }
|
||||
"""
|
||||
if res is None:
|
||||
return []
|
||||
|
||||
if isinstance(res, list):
|
||||
if not res:
|
||||
return []
|
||||
if isinstance(res[0], dict):
|
||||
return res
|
||||
return []
|
||||
|
||||
if isinstance(res, dict):
|
||||
for rows_key in ("rows", "data", "result", "records"):
|
||||
if rows_key in res and isinstance(res[rows_key], list):
|
||||
rows = res[rows_key]
|
||||
if not rows:
|
||||
return []
|
||||
if isinstance(rows[0], dict):
|
||||
return rows
|
||||
cols = res.get("columns") or res.get("cols") or []
|
||||
out = []
|
||||
for r in rows:
|
||||
if cols and isinstance(r, (list, tuple)):
|
||||
out.append({ (cols[i] if i < len(cols) else f"c{i}") : r[i]
|
||||
for i in range(min(len(cols), len(r))) })
|
||||
else:
|
||||
if isinstance(r, (list, tuple)):
|
||||
out.append({ f"c{i}": r[i] for i in range(len(r)) })
|
||||
return out
|
||||
if res and all(not isinstance(v, (list, tuple, dict)) for v in res.values()):
|
||||
return [res]
|
||||
|
||||
return []
|
||||
|
||||
def _s(v) -> str:
|
||||
"""Return a string representation, converting ``None`` to an empty string."""
|
||||
return "" if v is None else str(v)
|
||||
|
||||
def _first(d: Dict[str, Any], keys: List[str], default: str = ""):
|
||||
"""Return the first non-empty value found among the provided keys."""
|
||||
for k in keys:
|
||||
if k in d and d[k] not in (None, ""):
|
||||
return d[k]
|
||||
return default
|
||||
|
||||
# -------------------- column specs --------------------
|
||||
@dataclass
|
||||
class ColSpec:
|
||||
"""Describe one logical column rendered in a ``ScrollTable``."""
|
||||
|
||||
title: str
|
||||
key: str
|
||||
width: int
|
||||
anchor: str # 'w' | 'e' | 'center'
|
||||
|
||||
# Colonne PL (in alto) — include IDStato per la colorazione
|
||||
PL_COLS: List[ColSpec] = [
|
||||
ColSpec("", "__check__", 36, "w"),
|
||||
ColSpec("Documento", "Documento", 120, "w"),
|
||||
ColSpec("NAZIONE", "NAZIONE", 240, "w"),
|
||||
ColSpec("Stato", "Stato", 110, "w"),
|
||||
ColSpec("IDStato", "IDStato", 80, "e"), # nuova colonna
|
||||
ColSpec("#Pallet", "Pallet", 100, "e"),
|
||||
ColSpec("#Lotti", "Lotto", 100, "e"),
|
||||
ColSpec("#Articoli", "Articolo", 110, "e"),
|
||||
ColSpec("Qta", "Qta", 120, "e"),
|
||||
]
|
||||
|
||||
DET_COLS: List[ColSpec] = [
|
||||
ColSpec("UDC/Pallet", "Pallet", 150, "w"),
|
||||
ColSpec("Lotto", "Lotto", 130, "w"),
|
||||
ColSpec("Articolo", "Articolo", 150, "w"),
|
||||
ColSpec("Descrizione","Descrizione", 320, "w"),
|
||||
ColSpec("Qta", "Qta", 110, "e"),
|
||||
ColSpec("Ubicazione", "Ubicazione", 320, "w"),
|
||||
]
|
||||
|
||||
ROW_H = 28
|
||||
|
||||
|
||||
# -------------------- Micro spinner (toolbar) --------------------
|
||||
class ToolbarSpinner:
|
||||
"""
|
||||
Micro-animazione leggerissima per indicare attività:
|
||||
mostra una label con frame: ◐ ◓ ◑ ◒ ... finché è attivo.
|
||||
"""
|
||||
FRAMES = ("◐", "◓", "◑", "◒")
|
||||
def __init__(self, parent: tk.Widget):
|
||||
"""Create the spinner label attached to the given parent widget."""
|
||||
self.parent = parent
|
||||
self.lbl = ctk.CTkLabel(parent, text="", width=28)
|
||||
self._i = 0
|
||||
self._active = False
|
||||
self._job = None
|
||||
|
||||
def widget(self) -> ctk.CTkLabel:
|
||||
"""Return the label widget hosting the spinner animation."""
|
||||
return self.lbl
|
||||
|
||||
def start(self, text: str = ""):
|
||||
"""Start the animation and optionally show a short status message."""
|
||||
if self._active:
|
||||
return
|
||||
self._active = True
|
||||
self.lbl.configure(text=f"{self.FRAMES[self._i]} {text}".strip())
|
||||
self._tick()
|
||||
|
||||
def stop(self):
|
||||
"""Stop the animation and clear the label text."""
|
||||
self._active = False
|
||||
if self._job is not None:
|
||||
try:
|
||||
self.parent.after_cancel(self._job)
|
||||
except Exception:
|
||||
pass
|
||||
self._job = None
|
||||
self.lbl.configure(text="")
|
||||
|
||||
def _tick(self):
|
||||
"""Advance the spinner animation frame."""
|
||||
if not self._active:
|
||||
return
|
||||
self._i = (self._i + 1) % len(self.FRAMES)
|
||||
current = self.lbl.cget("text")
|
||||
# Mantieni l'eventuale testo dopo il simbolo
|
||||
txt_suffix = ""
|
||||
if isinstance(current, str) and len(current) > 2:
|
||||
txt_suffix = current[2:]
|
||||
self.lbl.configure(text=f"{self.FRAMES[self._i]}{txt_suffix}")
|
||||
self._job = self.parent.after(120, self._tick) # 8 fps soft
|
||||
|
||||
|
||||
# -------------------- Scrollable table --------------------
|
||||
class ScrollTable(ctk.CTkFrame):
|
||||
GRID_COLOR = "#D0D5DD"
|
||||
PADX_L = 8
|
||||
PADX_R = 8
|
||||
PADY = 2
|
||||
|
||||
def __init__(self, master, columns: List[ColSpec]):
|
||||
"""Create a fixed-header scrollable table rendered with Tk/CTk widgets."""
|
||||
super().__init__(master)
|
||||
self.columns = columns
|
||||
self.total_w = sum(c.width for c in self.columns)
|
||||
|
||||
self.grid_rowconfigure(1, weight=1)
|
||||
self.grid_columnconfigure(0, weight=1)
|
||||
|
||||
# header
|
||||
self.h_canvas = tk.Canvas(self, height=ROW_H, highlightthickness=0, bd=0)
|
||||
self.h_inner = ctk.CTkFrame(self.h_canvas, fg_color="#f3f3f3",
|
||||
height=ROW_H, width=self.total_w)
|
||||
self.h_canvas.create_window((0,0), window=self.h_inner, anchor="nw",
|
||||
width=self.total_w, height=ROW_H)
|
||||
self.h_canvas.grid(row=0, column=0, sticky="ew")
|
||||
|
||||
# body
|
||||
self.b_canvas = tk.Canvas(self, highlightthickness=0, bd=0)
|
||||
self.b_inner = ctk.CTkFrame(self.b_canvas, fg_color="transparent",
|
||||
width=self.total_w)
|
||||
self.body_window = self.b_canvas.create_window((0,0), window=self.b_inner,
|
||||
anchor="nw", width=self.total_w)
|
||||
self.b_canvas.grid(row=1, column=0, sticky="nsew")
|
||||
|
||||
# scrollbars
|
||||
self.vbar = tk.Scrollbar(self, orient="vertical", command=self.b_canvas.yview)
|
||||
self.xbar = tk.Scrollbar(self, orient="horizontal", command=self._xscroll_both)
|
||||
self.vbar.grid(row=1, column=1, sticky="ns")
|
||||
self.xbar.grid(row=2, column=0, sticky="ew")
|
||||
|
||||
# link scroll
|
||||
self.b_canvas.configure(yscrollcommand=self.vbar.set, xscrollcommand=self._xscroll_set_both)
|
||||
self.h_canvas.configure(xscrollcommand=self.xbar.set)
|
||||
|
||||
# bind
|
||||
self.h_inner.bind("<Configure>", lambda e: self._sync_header_width())
|
||||
self.b_inner.bind("<Configure>", lambda e: self._on_body_configure())
|
||||
|
||||
self._build_header()
|
||||
|
||||
def _build_header(self):
|
||||
"""Build the static header row using the configured columns."""
|
||||
for w in self.h_inner.winfo_children():
|
||||
w.destroy()
|
||||
|
||||
row = ctk.CTkFrame(self.h_inner, fg_color="#f3f3f3",
|
||||
height=ROW_H, width=self.total_w)
|
||||
row.pack(fill="x", expand=False)
|
||||
row.pack_propagate(False)
|
||||
|
||||
for col in self.columns:
|
||||
holder = ctk.CTkFrame(
|
||||
row, fg_color="#f3f3f3",
|
||||
width=col.width, height=ROW_H,
|
||||
border_width=1, border_color=self.GRID_COLOR
|
||||
)
|
||||
holder.pack(side="left", fill="y")
|
||||
holder.pack_propagate(False)
|
||||
|
||||
lbl = ctk.CTkLabel(holder, text=col.title, anchor="w")
|
||||
lbl.pack(fill="both", padx=(self.PADX_L, self.PADX_R), pady=self.PADY)
|
||||
|
||||
self.h_inner.configure(width=self.total_w, height=ROW_H)
|
||||
self.h_canvas.configure(scrollregion=(0,0,self.total_w,ROW_H))
|
||||
|
||||
def _update_body_width(self):
|
||||
"""Keep the scroll region aligned with the current body content width."""
|
||||
self.b_canvas.itemconfigure(self.body_window, width=self.total_w)
|
||||
sr = self.b_canvas.bbox("all")
|
||||
if sr:
|
||||
self.b_canvas.configure(scrollregion=(0,0,max(self.total_w, sr[2]), sr[3]))
|
||||
else:
|
||||
self.b_canvas.configure(scrollregion=(0,0,self.total_w,0))
|
||||
|
||||
def _on_body_configure(self):
|
||||
"""React to body resize events by syncing dimensions and header scroll."""
|
||||
self._update_body_width()
|
||||
self._sync_header_width()
|
||||
|
||||
def _sync_header_width(self):
|
||||
"""Mirror the body horizontal scroll position on the header canvas."""
|
||||
first, _ = self.b_canvas.xview()
|
||||
self.h_canvas.xview_moveto(first)
|
||||
|
||||
def _xscroll_both(self, *args):
|
||||
"""Scroll header and body together when the horizontal bar moves."""
|
||||
self.h_canvas.xview(*args)
|
||||
self.b_canvas.xview(*args)
|
||||
|
||||
def _xscroll_set_both(self, first, last):
|
||||
"""Update the header viewport and scrollbar thumb in one place."""
|
||||
self.h_canvas.xview_moveto(first)
|
||||
self.xbar.set(first, last)
|
||||
|
||||
def clear_rows(self):
|
||||
"""Remove all rendered body rows."""
|
||||
for w in self.b_inner.winfo_children():
|
||||
w.destroy()
|
||||
self._update_body_width()
|
||||
|
||||
def add_row(
|
||||
self,
|
||||
values: List[str],
|
||||
row_index: int,
|
||||
anchors: Optional[List[str]] = None,
|
||||
checkbox_builder: Optional[Callable[[tk.Widget], ctk.CTkCheckBox]] = None,
|
||||
):
|
||||
"""Append one row to the table body."""
|
||||
row = ctk.CTkFrame(self.b_inner, fg_color="transparent",
|
||||
height=ROW_H, width=self.total_w)
|
||||
row.pack(fill="x", expand=False)
|
||||
row.pack_propagate(False)
|
||||
|
||||
for i, col in enumerate(self.columns):
|
||||
holder = ctk.CTkFrame(
|
||||
row, fg_color="transparent",
|
||||
width=col.width, height=ROW_H,
|
||||
border_width=1, border_color=self.GRID_COLOR
|
||||
)
|
||||
holder.pack(side="left", fill="y")
|
||||
holder.pack_propagate(False)
|
||||
|
||||
if col.key == "__check__":
|
||||
if checkbox_builder:
|
||||
cb = checkbox_builder(holder)
|
||||
cb.pack(padx=(self.PADX_L, self.PADX_R), pady=self.PADY, anchor="w")
|
||||
else:
|
||||
ctk.CTkLabel(holder, text="").pack(fill="both")
|
||||
else:
|
||||
anchor = (anchors[i] if anchors else col.anchor)
|
||||
ctk.CTkLabel(holder, text=values[i], anchor=anchor).pack(
|
||||
fill="both", padx=(self.PADX_L, self.PADX_R), pady=self.PADY
|
||||
)
|
||||
|
||||
self._update_body_width()
|
||||
|
||||
|
||||
# -------------------- PL row model --------------------
|
||||
class PLRow:
|
||||
"""State holder for one picking list row and its selection checkbox."""
|
||||
|
||||
def __init__(self, pl: Dict[str, Any], on_check):
|
||||
"""Bind a picking list payload to a ``BooleanVar`` and callback."""
|
||||
self.pl = pl
|
||||
self.var = ctk.BooleanVar(value=False)
|
||||
self._callback = on_check
|
||||
|
||||
def is_checked(self) -> bool:
|
||||
"""Return whether the row is currently selected."""
|
||||
return self.var.get()
|
||||
|
||||
def set_checked(self, val: bool):
|
||||
"""Programmatically update the checkbox state."""
|
||||
self.var.set(val)
|
||||
|
||||
def build_checkbox(self, parent) -> ctk.CTkCheckBox:
|
||||
"""Create the checkbox widget bound to this row model."""
|
||||
return ctk.CTkCheckBox(parent, text="", variable=self.var,
|
||||
command=lambda: self._callback(self, self.var.get()))
|
||||
|
||||
|
||||
# -------------------- main frame (no-flicker + UX tuning + spinner) --------------------
|
||||
class GestionePickingListFrame(ctk.CTkFrame):
|
||||
def __init__(self, master, *, db_client=None, conn_str=None):
|
||||
"""Create the master/detail picking list frame."""
|
||||
super().__init__(master)
|
||||
if db_client is None:
|
||||
raise ValueError("GestionePickingListFrame richiede un db_client condiviso.")
|
||||
self.db_client = db_client
|
||||
self.runner = AsyncRunner(self) # runner condiviso (usa loop globale)
|
||||
self.busy = BusyOverlay(self) # overlay collaudato
|
||||
|
||||
self.rows_models: list[PLRow] = []
|
||||
self._detail_cache: Dict[Any, list] = {}
|
||||
self.detail_doc = None
|
||||
|
||||
self._first_loading: bool = False # flag per cursore d'attesa solo al primo load
|
||||
|
||||
self._build_layout()
|
||||
# 🔇 Niente reload immediato: carichiamo quando la finestra è idle (= già resa)
|
||||
self.after_idle(self._first_show)
|
||||
|
||||
def _first_show(self):
|
||||
"""Chiamato a finestra già resa → evitiamo sfarfallio del primo paint e mostriamo wait-cursor."""
|
||||
self._first_loading = True
|
||||
try:
|
||||
self.winfo_toplevel().configure(cursor="watch")
|
||||
except Exception:
|
||||
pass
|
||||
# spinner inizia
|
||||
self.spinner.start(" Carico…")
|
||||
self.reload_from_db(first=True)
|
||||
|
||||
# ---------- UI ----------
|
||||
def _build_layout(self):
|
||||
"""Build toolbar, master table and detail table."""
|
||||
for r in (1, 3): self.grid_rowconfigure(r, weight=1)
|
||||
self.grid_columnconfigure(0, weight=1)
|
||||
|
||||
top = ctk.CTkFrame(self)
|
||||
top.grid(row=0, column=0, sticky="ew", padx=10, pady=(8,4))
|
||||
for i, (text, cmd) in enumerate([
|
||||
("Ricarica", self.reload_from_db),
|
||||
("Prenota", self.on_prenota),
|
||||
("S-prenota", self.on_sprenota),
|
||||
("Esporta XLSX", self.on_export)
|
||||
]):
|
||||
ctk.CTkButton(top, text=text, command=cmd).grid(row=0, column=i, padx=6)
|
||||
|
||||
# --- micro spinner a destra della toolbar ---
|
||||
self.spinner = ToolbarSpinner(top)
|
||||
self.spinner.widget().grid(row=0, column=10, padx=(8,0)) # largo spazio a destra
|
||||
|
||||
self.pl_table = ScrollTable(self, PL_COLS)
|
||||
self.pl_table.grid(row=1, column=0, sticky="nsew", padx=10, pady=(4,8))
|
||||
|
||||
self.det_table = ScrollTable(self, DET_COLS)
|
||||
self.det_table.grid(row=3, column=0, sticky="nsew", padx=10, pady=(4,10))
|
||||
|
||||
self._draw_details_hint()
|
||||
|
||||
def _draw_details_hint(self):
|
||||
"""Render the placeholder row shown when no document is selected."""
|
||||
self.det_table.clear_rows()
|
||||
self.det_table.add_row(
|
||||
values=["", "", "", "Seleziona una Picking List per vedere le UDC…", "", ""],
|
||||
row_index=0,
|
||||
anchors=["w"]*6
|
||||
)
|
||||
|
||||
def _apply_row_colors(self, rows: List[Dict[str, Any]]):
|
||||
"""Colorazione differita (after_idle) per evitare micro-jank durante l'inserimento righe."""
|
||||
try:
|
||||
for idx, d in enumerate(rows):
|
||||
row_widget = self.pl_table.b_inner.winfo_children()[idx]
|
||||
if int(d.get("IDStato") or 0) == 1:
|
||||
row_widget.configure(fg_color="#ffe6f2") # rosa tenue
|
||||
else:
|
||||
row_widget.configure(fg_color="transparent")
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def _refresh_mid_rows(self, rows: List[Dict[str, Any]]):
|
||||
"""Rebuild the master table using the latest query results."""
|
||||
self.pl_table.clear_rows()
|
||||
self.rows_models.clear()
|
||||
|
||||
for r, d in enumerate(rows):
|
||||
model = PLRow(d, self.on_row_checked)
|
||||
self.rows_models.append(model)
|
||||
values = [
|
||||
"", # checkbox
|
||||
_s(d.get("Documento")),
|
||||
_s(d.get("NAZIONE")),
|
||||
_s(d.get("Stato")),
|
||||
_s(d.get("IDStato")), # nuova colonna visibile
|
||||
_s(d.get("Pallet")),
|
||||
_s(d.get("Lotto")),
|
||||
_s(d.get("Articolo")),
|
||||
_s(d.get("Qta")),
|
||||
]
|
||||
self.pl_table.add_row(
|
||||
values=values,
|
||||
row_index=r,
|
||||
anchors=[c.anchor for c in PL_COLS],
|
||||
checkbox_builder=model.build_checkbox
|
||||
)
|
||||
|
||||
# 🎯 Colora dopo che la UI è resa → no balzi visivi
|
||||
self.after_idle(lambda: self._apply_row_colors(rows))
|
||||
|
||||
# ----- helpers -----
|
||||
def _get_selected_model(self) -> Optional[PLRow]:
|
||||
"""Return the currently checked picking list row, if any."""
|
||||
for m in self.rows_models:
|
||||
if m.is_checked():
|
||||
return m
|
||||
return None
|
||||
|
||||
def _recolor_row_by_documento(self, documento: str, idstato: int):
|
||||
"""Aggiorna colore riga e cella IDStato per il Documento indicato."""
|
||||
for idx, m in enumerate(self.rows_models):
|
||||
if _s(m.pl.get("Documento")) == _s(documento):
|
||||
m.pl["IDStato"] = idstato
|
||||
def _paint():
|
||||
try:
|
||||
row_widget = self.pl_table.b_inner.winfo_children()[idx]
|
||||
row_widget.configure(fg_color="#ffe6f2" if idstato == 1 else "transparent")
|
||||
row_children = row_widget.winfo_children()
|
||||
if len(row_children) >= 5:
|
||||
holder = row_children[4]
|
||||
if holder.winfo_children():
|
||||
lbl = holder.winfo_children()[0]
|
||||
if hasattr(lbl, "configure"):
|
||||
lbl.configure(text=str(idstato))
|
||||
except Exception:
|
||||
pass
|
||||
# differisci la colorazione (smooth)
|
||||
self.after_idle(_paint)
|
||||
break
|
||||
|
||||
def _reselect_documento_after_reload(self, documento: str):
|
||||
"""(Opzionale) Dopo un reload DB, riseleziona la PL con lo stesso Documento."""
|
||||
for m in self.rows_models:
|
||||
if _s(m.pl.get("Documento")) == _s(documento):
|
||||
m.set_checked(True)
|
||||
self.on_row_checked(m, True)
|
||||
break
|
||||
|
||||
# ----- eventi -----
|
||||
def on_row_checked(self, model: PLRow, is_checked: bool):
|
||||
"""Handle row selection changes and refresh the detail section."""
|
||||
# selezione esclusiva
|
||||
if is_checked:
|
||||
for m in self.rows_models:
|
||||
if m is not model and m.is_checked():
|
||||
m.set_checked(False)
|
||||
|
||||
self.detail_doc = model.pl.get("Documento")
|
||||
self.spinner.start(" Carico dettagli…") # spinner ON
|
||||
|
||||
async def _job():
|
||||
return await self.db_client.query_json(SQL_PL_DETAILS, {"Documento": self.detail_doc})
|
||||
|
||||
def _ok(res):
|
||||
self.spinner.stop() # spinner OFF
|
||||
self._detail_cache[self.detail_doc] = _rows_to_dicts(res)
|
||||
# differisci il render dei dettagli (più fluido)
|
||||
self.after_idle(self._refresh_details)
|
||||
|
||||
def _err(ex):
|
||||
self.spinner.stop()
|
||||
messagebox.showerror("DB", f"Errore nel caricamento dettagli:\n{ex}")
|
||||
|
||||
self.runner.run(
|
||||
_job(),
|
||||
on_success=_ok,
|
||||
on_error=_err,
|
||||
busy=self.busy,
|
||||
message=f"Carico UDC per Documento {self.detail_doc}…"
|
||||
)
|
||||
|
||||
else:
|
||||
if not any(m.is_checked() for m in self.rows_models):
|
||||
self.detail_doc = None
|
||||
self._refresh_details()
|
||||
|
||||
# ----- load PL -----
|
||||
def reload_from_db(self, first: bool = False):
|
||||
"""Load or reload the picking list summary table from the database."""
|
||||
self.spinner.start(" Carico…") # spinner ON
|
||||
async def _job():
|
||||
return await self.db_client.query_json(SQL_PL, {})
|
||||
def _on_success(res):
|
||||
rows = _rows_to_dicts(res)
|
||||
self._refresh_mid_rows(rows)
|
||||
self.spinner.stop() # spinner OFF
|
||||
# se era il primo load, ripristina il cursore standard
|
||||
if self._first_loading:
|
||||
try:
|
||||
self.winfo_toplevel().configure(cursor="")
|
||||
except Exception:
|
||||
pass
|
||||
self._first_loading = False
|
||||
def _on_error(ex):
|
||||
self.spinner.stop()
|
||||
if self._first_loading:
|
||||
try:
|
||||
self.winfo_toplevel().configure(cursor="")
|
||||
except Exception:
|
||||
pass
|
||||
self._first_loading = False
|
||||
messagebox.showerror("DB", f"Errore nel caricamento:\n{ex}")
|
||||
|
||||
self.runner.run(
|
||||
_job(),
|
||||
on_success=_on_success,
|
||||
on_error=_on_error,
|
||||
busy=self.busy,
|
||||
message="Caricamento Picking List…" if first else "Aggiornamento…"
|
||||
)
|
||||
|
||||
def _refresh_details(self):
|
||||
"""Render the detail table for the currently selected document."""
|
||||
self.det_table.clear_rows()
|
||||
if not self.detail_doc:
|
||||
self._draw_details_hint()
|
||||
return
|
||||
|
||||
rows = self._detail_cache.get(self.detail_doc, [])
|
||||
if not rows:
|
||||
self.det_table.add_row(values=["", "", "", "Nessuna UDC trovata.", "", ""],
|
||||
row_index=0, anchors=["w"]*6)
|
||||
return
|
||||
|
||||
for r, d in enumerate(rows):
|
||||
pallet = _s(_first(d, ["Pallet", "UDC", "PalletID"]))
|
||||
lotto = _s(_first(d, ["Lotto"]))
|
||||
articolo = _s(_first(d, ["Articolo", "CodArticolo", "CodiceArticolo", "Art", "Codice"]))
|
||||
descr = _s(_first(d, ["Descrizione", "Descr", "DescrArticolo", "DescArticolo", "DesArticolo"]))
|
||||
qta = _s(_first(d, ["Qta", "Quantita", "Qty", "QTY"]))
|
||||
ubi_raw = _first(d, ["Ubicazione", "Cella", "PalletCella"])
|
||||
loc = "Non scaffalata" if (ubi_raw is None or str(ubi_raw).strip()=="") else str(ubi_raw).strip()
|
||||
|
||||
self.det_table.add_row(
|
||||
values=[pallet, lotto, articolo, descr, qta, loc],
|
||||
row_index=r,
|
||||
anchors=[c.anchor for c in DET_COLS]
|
||||
)
|
||||
|
||||
# ----- azioni -----
|
||||
def on_prenota(self):
|
||||
"""Reserve the selected picking list."""
|
||||
model = self._get_selected_model()
|
||||
if not model:
|
||||
messagebox.showinfo("Prenota", "Seleziona una Picking List (checkbox) prima di prenotare.")
|
||||
return
|
||||
|
||||
documento = _s(model.pl.get("Documento"))
|
||||
current = int(model.pl.get("IDStato") or 0)
|
||||
desired = 1
|
||||
if current == desired:
|
||||
messagebox.showinfo("Prenota", f"La Picking List {documento} è già prenotata.")
|
||||
return
|
||||
|
||||
id_operatore = 1 # TODO: recupera dal contesto reale
|
||||
self.spinner.start(" Prenoto…")
|
||||
|
||||
async def _job():
|
||||
return await sp_xExePackingListPallet_async(self.db_client, id_operatore, documento)
|
||||
|
||||
def _ok(res: SPResult):
|
||||
self.spinner.stop()
|
||||
if res and res.rc == 0:
|
||||
self._recolor_row_by_documento(documento, desired)
|
||||
else:
|
||||
msg = (res.message if res else "Errore sconosciuto")
|
||||
messagebox.showerror("Prenota", f"Operazione non riuscita:\n{msg}")
|
||||
|
||||
def _err(ex):
|
||||
self.spinner.stop()
|
||||
messagebox.showerror("Prenota", f"Errore:\n{ex}")
|
||||
|
||||
self.runner.run(
|
||||
_job(),
|
||||
on_success=_ok,
|
||||
on_error=_err,
|
||||
busy=self.busy,
|
||||
message=f"Prenoto la Picking List {documento}…"
|
||||
)
|
||||
|
||||
def on_sprenota(self):
|
||||
"""Unreserve the selected picking list."""
|
||||
model = self._get_selected_model()
|
||||
if not model:
|
||||
messagebox.showinfo("S-prenota", "Seleziona una Picking List (checkbox) prima di s-prenotare.")
|
||||
return
|
||||
|
||||
documento = _s(model.pl.get("Documento"))
|
||||
current = int(model.pl.get("IDStato") or 0)
|
||||
desired = 0
|
||||
if current == desired:
|
||||
messagebox.showinfo("S-prenota", f"La Picking List {documento} è già NON prenotata.")
|
||||
return
|
||||
|
||||
id_operatore = 1 # TODO: recupera dal contesto reale
|
||||
self.spinner.start(" S-prenoto…")
|
||||
|
||||
async def _job():
|
||||
return await sp_xExePackingListPallet_async(self.db_client, id_operatore, documento)
|
||||
|
||||
def _ok(res: SPResult):
|
||||
self.spinner.stop()
|
||||
if res and res.rc == 0:
|
||||
self._recolor_row_by_documento(documento, desired)
|
||||
else:
|
||||
msg = (res.message if res else "Errore sconosciuto")
|
||||
messagebox.showerror("S-prenota", f"Operazione non riuscita:\n{msg}")
|
||||
|
||||
def _err(ex):
|
||||
self.spinner.stop()
|
||||
messagebox.showerror("S-prenota", f"Errore:\n{ex}")
|
||||
|
||||
self.runner.run(
|
||||
_job(),
|
||||
on_success=_ok,
|
||||
on_error=_err,
|
||||
busy=self.busy,
|
||||
message=f"S-prenoto la Picking List {documento}…"
|
||||
)
|
||||
|
||||
def on_export(self):
|
||||
"""Placeholder for a future export implementation."""
|
||||
messagebox.showinfo("Esporta", "Stub esportazione.")
|
||||
|
||||
|
||||
# factory per main
|
||||
def create_frame(parent, *, db_client=None, conn_str=None) -> 'GestionePickingListFrame':
|
||||
"""Factory used by the launcher to build the picking list frame."""
|
||||
ctk.set_appearance_mode("light")
|
||||
ctk.set_default_color_theme("green")
|
||||
return GestionePickingListFrame(parent, db_client=db_client)
|
||||
|
||||
# =================== /gestione_pickinglist.py ===================
|
||||
Reference in New Issue
Block a user