633 lines
26 KiB
Plaintext
633 lines
26 KiB
Plaintext
from __future__ import annotations
|
|
import tkinter as tk
|
|
from tkinter import Menu, messagebox, filedialog
|
|
import customtkinter as ctk
|
|
from datetime import datetime
|
|
|
|
from gestione_aree_frame_async import BusyOverlay, AsyncRunner
|
|
|
|
# ---- Color palette ----
|
|
COLOR_EMPTY = "#B0B0B0" # grigio (vuota)
|
|
COLOR_FULL = "#FFA500" # arancione (una UDC)
|
|
COLOR_DOUBLE = "#D62728" # rosso (>=2 UDC)
|
|
FG_DARK = "#111111"
|
|
FG_LIGHT = "#FFFFFF"
|
|
|
|
|
|
def pct_text(p_full: float, p_double: float | None = None) -> str:
|
|
p_full = max(0.0, min(1.0, p_full))
|
|
pf = round(p_full * 100, 1)
|
|
pe = round(100 - pf, 1)
|
|
if p_double and p_double > 0:
|
|
pd = round(p_double * 100, 1)
|
|
return f"Pieno {pf}% · Vuoto {pe}% (di cui doppie {pd}%)"
|
|
return f"Pieno {pf}% · Vuoto {pe}%"
|
|
|
|
|
|
class LayoutWindow(ctk.CTkToplevel):
|
|
"""
|
|
Visualizzazione layout corsie con matrice di celle.
|
|
- Ogni cella è un pulsante colorato (vuota/piena/doppia)
|
|
- Etichetta su DUE righe:
|
|
1) "Corsia.Colonna.Fila" (una sola riga, senza andare a capo)
|
|
2) barcode UDC (primo, se presente)
|
|
- Ricerca per barcode UDC con cambio automatico corsia + highlight cella
|
|
- Statistiche: globale e corsia selezionata
|
|
- Export XLSX
|
|
"""
|
|
def __init__(self, parent: tk.Widget, db_app):
|
|
super().__init__(parent)
|
|
self.title("Warehouse · Layout corsie")
|
|
self.geometry("1200x740")
|
|
self.minsize(980, 560)
|
|
self.resizable(True, True)
|
|
|
|
self.db = db_app
|
|
self._busy = BusyOverlay(self)
|
|
self._async = AsyncRunner(self)
|
|
|
|
# layout principale 5% / 80% / 15%
|
|
self.grid_rowconfigure(0, weight=5)
|
|
self.grid_rowconfigure(1, weight=80)
|
|
self.grid_rowconfigure(2, weight=15)
|
|
self.grid_columnconfigure(0, weight=1)
|
|
|
|
# stato runtime
|
|
self.corsia_selezionata = tk.StringVar()
|
|
self.buttons: list[list[ctk.CTkButton]] = []
|
|
self.btn_frames: list[list[ctk.CTkFrame]] = []
|
|
self.matrix_state: list[list[int]] = [] # <— rinominata: prima era self.state
|
|
self.fila_txt: list[list[str]] = []
|
|
self.col_txt: list[list[str]] = []
|
|
self.desc: list[list[str]] = []
|
|
self.udc1: list[list[str]] = [] # primo barcode UDC trovato (o "")
|
|
|
|
# ricerca → focus differito (corsia, col, fila, barcode)
|
|
self._pending_focus: tuple[str, str, str, str] | None = None
|
|
self._highlighted: tuple[int, int] | None = None
|
|
|
|
# anti-race: token per ignorare risposte vecchie
|
|
self._req_counter = 0
|
|
self._last_req = 0
|
|
|
|
self._build_top()
|
|
self._build_matrix_host()
|
|
self._build_stats()
|
|
|
|
self._load_corsie()
|
|
self.bind("<Configure>", lambda e: self.after_idle(self._refresh_stats))
|
|
|
|
# ---------------- TOP BAR ----------------
|
|
def _build_top(self):
|
|
top = ctk.CTkFrame(self)
|
|
top.grid(row=0, column=0, sticky="nsew", padx=8, pady=6)
|
|
for i in range(4):
|
|
top.grid_columnconfigure(i, weight=0)
|
|
top.grid_columnconfigure(1, weight=1)
|
|
|
|
# lista corsie
|
|
lf = ctk.CTkFrame(top)
|
|
lf.grid(row=0, column=0, sticky="nsw")
|
|
lf.grid_columnconfigure(0, weight=1)
|
|
ctk.CTkLabel(lf, text="Corsie", font=("", 12, "bold")).grid(row=0, column=0, sticky="w", padx=6, pady=(6, 2))
|
|
self.lb = tk.Listbox(lf, height=6, exportselection=False)
|
|
self.lb.grid(row=1, column=0, sticky="nsw", padx=6, pady=(0, 6))
|
|
self.lb.bind("<<ListboxSelect>>", self._on_select)
|
|
|
|
# search by barcode
|
|
srch = ctk.CTkFrame(top)
|
|
srch.grid(row=0, column=1, sticky="nsew", padx=(10, 10))
|
|
self.search_var = tk.StringVar()
|
|
self.search_entry = ctk.CTkEntry(srch, textvariable=self.search_var, width=260)
|
|
self.search_entry.grid(row=0, column=0, sticky="w")
|
|
ctk.CTkButton(srch, text="Cerca per barcode UDC", command=self._search_udc).grid(row=0, column=1, padx=(8, 0))
|
|
srch.grid_columnconfigure(0, weight=1)
|
|
|
|
# toolbar
|
|
tb = ctk.CTkFrame(top)
|
|
tb.grid(row=0, column=3, sticky="ne")
|
|
ctk.CTkButton(tb, text="Aggiorna", command=self._refresh_current).grid(row=0, column=0, padx=4)
|
|
ctk.CTkButton(tb, text="Export XLSX", command=self._export_xlsx).grid(row=0, column=1, padx=4)
|
|
|
|
# ---------------- MATRIX HOST ----------------
|
|
def _build_matrix_host(self):
|
|
center = ctk.CTkFrame(self)
|
|
center.grid(row=1, column=0, sticky="nsew", padx=8, pady=(0, 6))
|
|
center.grid_rowconfigure(0, weight=1)
|
|
center.grid_columnconfigure(0, weight=1)
|
|
self.host = ctk.CTkFrame(center)
|
|
self.host.grid(row=0, column=0, sticky="nsew", padx=4, pady=4)
|
|
|
|
def _apply_cell_style(self, btn: ctk.CTkButton, state: int):
|
|
if state == 0:
|
|
btn.configure(
|
|
fg_color=COLOR_EMPTY, hover_color="#9A9A9A",
|
|
text_color=FG_DARK, border_width=0
|
|
)
|
|
elif state == 1:
|
|
btn.configure(
|
|
fg_color=COLOR_FULL, hover_color="#E69500",
|
|
text_color=FG_DARK, border_width=0
|
|
)
|
|
else:
|
|
btn.configure(
|
|
fg_color=COLOR_DOUBLE, hover_color="#B22222",
|
|
text_color=FG_LIGHT, border_width=0
|
|
)
|
|
|
|
def _clear_highlight(self):
|
|
if self._highlighted and self.buttons:
|
|
r, c = self._highlighted
|
|
try:
|
|
if 0 <= r < len(self.buttons) and 0 <= c < len(self.buttons[r]):
|
|
btn = self.buttons[r][c]
|
|
if getattr(btn, "winfo_exists", None) and btn.winfo_exists():
|
|
try:
|
|
btn.configure(border_width=0)
|
|
except Exception:
|
|
pass
|
|
# clear blue frame border
|
|
try:
|
|
fr = self.btn_frames[r][c]
|
|
if fr and getattr(fr, "winfo_exists", None) and fr.winfo_exists():
|
|
fr.configure(border_width=0)
|
|
# in CTkFrame non esiste highlightthickness come in tk; border_* è corretto
|
|
except Exception:
|
|
pass
|
|
except Exception:
|
|
pass
|
|
self._highlighted = None
|
|
|
|
def _rebuild_matrix(self, rows: int, cols: int, state, fila_txt, col_txt, desc, udc1, corsia):
|
|
# prima rimuovi highlight su vecchi bottoni
|
|
self._clear_highlight()
|
|
# ripulisci host
|
|
for w in self.host.winfo_children():
|
|
w.destroy()
|
|
self.buttons.clear()
|
|
self.btn_frames.clear()
|
|
|
|
# salva matrici
|
|
self.matrix_state, self.fila_txt, self.col_txt, self.desc, self.udc1 = state, fila_txt, col_txt, desc, udc1
|
|
|
|
# ridistribuisci pesi griglia
|
|
for r in range(rows):
|
|
self.host.grid_rowconfigure(r, weight=1)
|
|
for c in range(cols):
|
|
self.host.grid_columnconfigure(c, weight=1)
|
|
|
|
# crea Frame+Button per cella (righe invertite: fila "a" in basso)
|
|
for r in range(rows):
|
|
row_btns = []
|
|
row_frames = []
|
|
for c in range(cols):
|
|
st = state[r][c]
|
|
code = f"{corsia}.{col_txt[r][c]}.{fila_txt[r][c]}" # PRIMA RIGA (in linea)
|
|
udc = udc1[r][c] or "" # SECONDA RIGA: barcode UDC
|
|
text = f"{code}\n{udc}"
|
|
cell = ctk.CTkFrame(self.host, corner_radius=6, border_width=0)
|
|
btn = ctk.CTkButton(
|
|
cell,
|
|
text=text,
|
|
corner_radius=6)
|
|
self._apply_cell_style(btn, st)
|
|
|
|
rr = (rows - 1) - r # capovolgi
|
|
cell.grid(row=rr, column=c, padx=1, pady=1, sticky="nsew")
|
|
btn.pack(fill="both", expand=True)
|
|
btn.configure(command=lambda rr=r, cc=c: self._open_menu(None, rr, cc))
|
|
btn.bind("<Button-3>", lambda e, rr=r, cc=c: self._open_menu(e, rr, cc))
|
|
row_btns.append(btn)
|
|
row_frames.append(cell)
|
|
self.buttons.append(row_btns)
|
|
self.btn_frames.append(row_frames)
|
|
|
|
# focus differito post-ricarica
|
|
if self._pending_focus and self._pending_focus[0] == corsia:
|
|
_, col, fila, _barcode = self._pending_focus
|
|
self._pending_focus = None
|
|
self._highlight_cell_by_labels(col, fila)
|
|
|
|
# ---------------- CONTEXT MENU ----------------
|
|
def _open_menu(self, event, r, c):
|
|
st = self.matrix_state[r][c]
|
|
corsia = self.corsia_selezionata.get()
|
|
label = f"{corsia}.{self.col_txt[r][c]}.{self.fila_txt[r][c]}"
|
|
m = Menu(self, tearoff=0)
|
|
m.add_command(label="Apri dettaglio", command=lambda: self._toast(f"Dettaglio {label}"))
|
|
if st == 0:
|
|
m.add_command(label="Segna pieno", command=lambda: self._set_cell(r, c, 1))
|
|
m.add_command(label="Segna doppia", command=lambda: self._set_cell(r, c, 2))
|
|
elif st == 1:
|
|
m.add_command(label="Segna vuoto", command=lambda: self._set_cell(r, c, 0))
|
|
m.add_command(label="Segna doppia", command=lambda: self._set_cell(r, c, 2))
|
|
else:
|
|
m.add_command(label="Segna vuoto", command=lambda: self._set_cell(r, c, 0))
|
|
m.add_command(label="Segna pieno", command=lambda: self._set_cell(r, c, 1))
|
|
m.add_separator()
|
|
m.add_command(label="Copia ubicazione", command=lambda: self._copy(label))
|
|
x = self.winfo_pointerx() if event is None else event.x_root
|
|
y = self.winfo_pointery() if event is None else event.y_root
|
|
m.tk_popup(x, y)
|
|
|
|
def _set_cell(self, r, c, val):
|
|
self.matrix_state[r][c] = val
|
|
btn = self.buttons[r][c]
|
|
self._apply_cell_style(btn, val)
|
|
self._refresh_stats()
|
|
|
|
# ---------------- STATS ----------------
|
|
def _build_stats(self):
|
|
bottom = ctk.CTkFrame(self)
|
|
bottom.grid(row=2, column=0, sticky="nsew", padx=8, pady=6)
|
|
bottom.grid_columnconfigure(0, weight=1)
|
|
|
|
ctk.CTkLabel(bottom, text="Riempimento globale", font=("", 10, "bold")).grid(row=0, column=0, sticky="w", pady=(0, 2))
|
|
self.tot_canvas = tk.Canvas(bottom, height=22, highlightthickness=0)
|
|
self.tot_canvas.grid(row=1, column=0, sticky="ew", padx=(0, 260))
|
|
self.tot_text = ctk.CTkLabel(bottom, text=pct_text(0.0, 0.0))
|
|
self.tot_text.grid(row=1, column=0, sticky="e")
|
|
|
|
ctk.CTkLabel(bottom, text="Riempimento corsia selezionata", font=("", 10, "bold")).grid(row=2, column=0, sticky="w", pady=(10, 2))
|
|
self.sel_canvas = tk.Canvas(bottom, height=22, highlightthickness=0)
|
|
self.sel_canvas.grid(row=3, column=0, sticky="ew", padx=(0, 260))
|
|
self.sel_text = ctk.CTkLabel(bottom, text=pct_text(0.0, 0.0))
|
|
self.sel_text.grid(row=3, column=0, sticky="e")
|
|
|
|
leg = ctk.CTkFrame(bottom)
|
|
leg.grid(row=4, column=0, sticky="w", pady=(10, 0))
|
|
ctk.CTkLabel(leg, text="Legenda celle:").grid(row=0, column=0, padx=(0, 8))
|
|
self._legend(leg, 1, "Vuota", COLOR_EMPTY)
|
|
self._legend(leg, 3, "Piena", COLOR_FULL)
|
|
self._legend(leg, 5, "Doppia UDC", COLOR_DOUBLE)
|
|
|
|
def _legend(self, parent, col, text, color):
|
|
box = tk.Canvas(parent, width=18, height=12, highlightthickness=0)
|
|
box.create_rectangle(0, 0, 18, 12, fill=color, width=1, outline="#444")
|
|
box.grid(row=0, column=col)
|
|
ctk.CTkLabel(parent, text=text).grid(row=0, column=col + 1, padx=(4, 12))
|
|
|
|
# ---------------- DATA LOADING ----------------
|
|
def _load_corsie(self):
|
|
sql = """
|
|
WITH C AS (
|
|
SELECT DISTINCT LTRIM(RTRIM(Corsia)) AS Corsia
|
|
FROM dbo.Celle
|
|
WHERE ID <> 9999 AND (DelDataOra IS NULL) AND LTRIM(RTRIM(Corsia)) <> '7G'
|
|
)
|
|
SELECT Corsia
|
|
FROM C
|
|
ORDER BY
|
|
CASE
|
|
WHEN LEFT(Corsia,3)='MAG' AND TRY_CONVERT(int, SUBSTRING(Corsia,4,50)) IS NOT NULL THEN 0
|
|
WHEN TRY_CONVERT(int, Corsia) IS NOT NULL THEN 1
|
|
ELSE 2
|
|
END,
|
|
CASE WHEN LEFT(Corsia,3)='MAG' THEN TRY_CONVERT(int, SUBSTRING(Corsia,4,50)) END,
|
|
CASE WHEN TRY_CONVERT(int, Corsia) IS NOT NULL THEN TRY_CONVERT(int, Corsia) END,
|
|
CASE WHEN TRY_CONVERT(int, Corsia) IS NOT NULL THEN SUBSTRING(Corsia, LEN(CAST(TRY_CONVERT(int, Corsia) AS varchar(20)))+1, 50) END,
|
|
Corsia;
|
|
"""
|
|
def _ok(res):
|
|
rows = res.get("rows", []) if isinstance(res, dict) else []
|
|
self.lb.delete(0, tk.END)
|
|
corsie = [r[0] for r in rows]
|
|
for c in corsie:
|
|
self.lb.insert(tk.END, c)
|
|
idx = corsie.index("1A") if "1A" in corsie else (0 if corsie else -1)
|
|
if idx >= 0:
|
|
self.lb.selection_clear(0, tk.END)
|
|
self.lb.selection_set(idx)
|
|
self.lb.see(idx)
|
|
self._on_select(None)
|
|
else:
|
|
self._toast("Nessuna corsia trovata.")
|
|
self._busy.hide()
|
|
def _err(ex):
|
|
self._busy.hide()
|
|
messagebox.showerror("Errore", f"Caricamento corsie fallito:\n{ex}")
|
|
self._async.run(self.db.query_json(sql, {}), _ok, _err, busy=self._busy, message="Carico corsie…")
|
|
|
|
def _on_select(self, _):
|
|
sel = self.lb.curselection()
|
|
if not sel:
|
|
return
|
|
corsia = self.lb.get(sel[0])
|
|
self.corsia_selezionata.set(corsia)
|
|
self._load_matrix(corsia)
|
|
|
|
def _select_corsia_in_listbox(self, corsia: str):
|
|
for i in range(self.lb.size()):
|
|
if self.lb.get(i) == corsia:
|
|
self.lb.selection_clear(0, tk.END)
|
|
self.lb.selection_set(i)
|
|
self.lb.see(i)
|
|
break
|
|
|
|
def _load_matrix(self, corsia: str):
|
|
# nuovo token richiesta → evita che risposte vecchie spazzino la UI
|
|
self._req_counter += 1
|
|
req_id = self._req_counter
|
|
self._last_req = req_id
|
|
|
|
sql = """
|
|
WITH C AS (
|
|
SELECT
|
|
ID,
|
|
LTRIM(RTRIM(Corsia)) AS Corsia,
|
|
LTRIM(RTRIM(Fila)) AS Fila,
|
|
LTRIM(RTRIM(Colonna)) AS Colonna,
|
|
Descrizione
|
|
FROM dbo.Celle
|
|
WHERE ID <> 9999 AND (DelDataOra IS NULL)
|
|
AND LTRIM(RTRIM(Corsia)) <> '7G' AND LTRIM(RTRIM(Corsia)) = :corsia
|
|
),
|
|
R AS (
|
|
SELECT Fila,
|
|
DENSE_RANK() OVER (
|
|
ORDER BY CASE WHEN TRY_CONVERT(int, Fila) IS NULL THEN 1 ELSE 0 END,
|
|
TRY_CONVERT(int, Fila), Fila
|
|
) AS RowN
|
|
FROM C GROUP BY Fila
|
|
),
|
|
K AS (
|
|
SELECT Colonna,
|
|
DENSE_RANK() OVER (
|
|
ORDER BY CASE WHEN TRY_CONVERT(int, Colonna) IS NULL THEN 1 ELSE 0 END,
|
|
TRY_CONVERT(int, Colonna), Colonna
|
|
) AS ColN
|
|
FROM C GROUP BY Colonna
|
|
),
|
|
S AS (
|
|
SELECT c.ID, COUNT(DISTINCT g.BarcodePallet) AS n
|
|
FROM C AS c
|
|
LEFT JOIN dbo.XMag_GiacenzaPallet AS g ON g.IDCella = c.ID
|
|
GROUP BY c.ID
|
|
),
|
|
U AS (
|
|
SELECT c.ID, MIN(g.BarcodePallet) AS FirstUDC
|
|
FROM C c
|
|
LEFT JOIN dbo.XMag_GiacenzaPallet g ON g.IDCella = c.ID
|
|
GROUP BY c.ID
|
|
)
|
|
SELECT
|
|
r.RowN, k.ColN,
|
|
CASE WHEN s.n IS NULL OR s.n = 0 THEN 0
|
|
WHEN s.n = 1 THEN 1
|
|
ELSE 2 END AS Stato,
|
|
c.Descrizione,
|
|
LTRIM(RTRIM(c.Fila)) AS FilaTxt,
|
|
LTRIM(RTRIM(c.Colonna)) AS ColTxt,
|
|
U.FirstUDC
|
|
FROM C c
|
|
JOIN R r ON r.Fila = c.Fila
|
|
JOIN K k ON k.Colonna = c.Colonna
|
|
LEFT JOIN S s ON s.ID = c.ID
|
|
LEFT JOIN U ON U.ID = c.ID
|
|
ORDER BY r.RowN, k.ColN;
|
|
"""
|
|
def _ok(res):
|
|
# ignora risposte superate
|
|
if req_id < self._last_req:
|
|
return
|
|
rows = res.get("rows", []) if isinstance(res, dict) else []
|
|
if not rows:
|
|
# mostra matrice vuota senza rimuovere il frame (evita "schermo bianco")
|
|
self._rebuild_matrix(0, 0, [], [], [], [], [], corsia)
|
|
self._refresh_stats()
|
|
self._busy.hide()
|
|
return
|
|
max_r = max_c = 0
|
|
for row in rows:
|
|
rown, coln = row[0], row[1]
|
|
if rown and coln:
|
|
max_r = max(max_r, int(rown))
|
|
max_c = max(max_c, int(coln))
|
|
mat = [[0] * max_c for _ in range(max_r)]
|
|
fila = [[""] * max_c for _ in range(max_r)]
|
|
col = [[""] * max_c for _ in range(max_r)]
|
|
desc = [[""] * max_c for _ in range(max_r)]
|
|
udc = [[""] * max_c for _ in range(max_r)]
|
|
for row in rows:
|
|
rown, coln, stato, descr, fila_txt, col_txt, first_udc = row
|
|
r = int(rown) - 1
|
|
c = int(coln) - 1
|
|
mat[r][c] = int(stato)
|
|
fila[r][c] = str(fila_txt or "")
|
|
col[r][c] = str(col_txt or "")
|
|
desc[r][c] = str(descr or f"{corsia}.{col_txt}.{fila_txt}")
|
|
udc[r][c] = str(first_udc or "")
|
|
self._rebuild_matrix(max_r, max_c, mat, fila, col, desc, udc, corsia)
|
|
self._refresh_stats()
|
|
self._busy.hide()
|
|
def _err(ex):
|
|
if req_id < self._last_req:
|
|
return
|
|
self._busy.hide()
|
|
messagebox.showerror("Errore", f"Caricamento matrice {corsia} fallito:\n{ex}")
|
|
self._async.run(self.db.query_json(sql, {"corsia": corsia}), _ok, _err, busy=self._busy, message=f"Carico corsia {corsia}…")
|
|
|
|
# ---------------- SEARCH ----------------
|
|
def _search_udc(self):
|
|
barcode = (self.search_var.get() or "").strip()
|
|
if not barcode:
|
|
self._toast("Inserisci un barcode UDC da cercare.")
|
|
return
|
|
|
|
# bump token per impedire che una vecchia _load_matrix cancelli UI
|
|
self._req_counter += 1
|
|
search_req_id = self._req_counter
|
|
self._last_req = search_req_id
|
|
|
|
sql = """
|
|
SELECT TOP (1)
|
|
RTRIM(c.Corsia) AS Corsia,
|
|
RTRIM(c.Colonna) AS Colonna,
|
|
RTRIM(c.Fila) AS Fila,
|
|
c.ID AS IDCella
|
|
FROM dbo.XMag_GiacenzaPallet g
|
|
JOIN dbo.Celle c ON c.ID = g.IDCella
|
|
WHERE g.BarcodePallet = :barcode
|
|
AND c.ID <> 9999 AND RTRIM(c.Corsia) <> '7G'
|
|
"""
|
|
def _ok(res):
|
|
if search_req_id < self._last_req:
|
|
return
|
|
rows = res.get("rows", []) if isinstance(res, dict) else []
|
|
if not rows:
|
|
messagebox.showinfo("Ricerca", f"UDC {barcode} non trovata.", parent=self)
|
|
return
|
|
corsia, col, fila, _idc = rows[0]
|
|
corsia = str(corsia).strip(); col = str(col).strip(); fila = str(fila).strip()
|
|
self._pending_focus = (corsia, col, fila, barcode)
|
|
|
|
# sincronizza listbox e carica SEMPRE la corsia della UDC
|
|
self._select_corsia_in_listbox(corsia)
|
|
self.corsia_selezionata.set(corsia)
|
|
self._load_matrix(corsia) # highlight avverrà in _rebuild_matrix
|
|
def _err(ex):
|
|
if search_req_id < self._last_req:
|
|
return
|
|
messagebox.showerror("Ricerca", f"Errore ricerca UDC:\n{ex}", parent=self)
|
|
|
|
self._async.run(self.db.query_json(sql, {"barcode": barcode}), _ok, _err, busy=self._busy, message="Cerco UDC…")
|
|
|
|
def _try_highlight(self, col_txt: str, fila_txt: str) -> bool:
|
|
for r in range(len(self.col_txt)):
|
|
for c in range(len(self.col_txt[r])):
|
|
if self.col_txt[r][c] == col_txt and self.fila_txt[r][c] == fila_txt:
|
|
self._clear_highlight()
|
|
btn = self.buttons[r][c]
|
|
btn.configure(border_width=3, border_color="blue")
|
|
try:
|
|
fr = self.btn_frames[r][c]
|
|
fr.configure(border_color="blue", border_width=2)
|
|
except Exception:
|
|
pass
|
|
self._highlighted = (r, c)
|
|
return True
|
|
return False
|
|
|
|
def _highlight_cell_by_labels(self, col_txt: str, fila_txt: str):
|
|
if not self._try_highlight(col_txt, fila_txt):
|
|
self._toast("Cella trovata ma non mappabile a pulsante.")
|
|
|
|
# ---------------- COMMANDS ----------------
|
|
def _refresh_current(self):
|
|
if self.corsia_selezionata.get():
|
|
self._load_matrix(self.corsia_selezionata.get())
|
|
|
|
def _export_xlsx(self):
|
|
if not self.matrix_state:
|
|
messagebox.showinfo("Export", "Nessuna matrice da esportare.")
|
|
return
|
|
corsia = self.corsia_selezionata.get() or "NA"
|
|
ts = datetime.now().strftime("%d_%m_%Y_%H-%M")
|
|
default = f"layout_matrice_{corsia}_{ts}.xlsx"
|
|
path = filedialog.asksaveasfilename(
|
|
title="Esporta matrice",
|
|
defaultextension=".xlsx",
|
|
initialfile=default,
|
|
filetypes=[("Excel", "*.xlsx")]
|
|
)
|
|
if not path:
|
|
return
|
|
try:
|
|
from openpyxl import Workbook
|
|
from openpyxl.styles import PatternFill, Alignment, Font
|
|
except Exception as ex:
|
|
messagebox.showerror("Export", f"Manca openpyxl: {ex}\nInstalla con: pip install openpyxl")
|
|
return
|
|
rows = len(self.matrix_state)
|
|
cols = len(self.matrix_state[0]) if self.matrix_state else 0
|
|
wb = Workbook()
|
|
ws1 = wb.active
|
|
ws1.title = f"Dettaglio {corsia}"
|
|
ws1.append(["Corsia", "FilaIdx", "ColIdx", "Stato", "Descrizione", "FilaTxt", "ColTxt", "UDC1"])
|
|
for r in range(rows):
|
|
for c in range(cols):
|
|
st = self.matrix_state[r][c]
|
|
stato_lbl = "Vuota" if st == 0 else ("Piena" if st == 1 else "Doppia")
|
|
ws1.append([corsia, r + 1, c + 1, stato_lbl,
|
|
self.desc[r][c], self.fila_txt[r][c], self.col_txt[r][c], self.udc1[r][c]])
|
|
for cell in ws1[1]:
|
|
cell.font = Font(bold=True)
|
|
|
|
ws2 = wb.create_sheet(f"Matrice {corsia}")
|
|
fills = {
|
|
0: PatternFill("solid", fgColor="B0B0B0"),
|
|
1: PatternFill("solid", fgColor="FFA500"),
|
|
2: PatternFill("solid", fgColor="D62728"),
|
|
}
|
|
center = Alignment(horizontal="center", vertical="center", wrap_text=True)
|
|
for r in range(rows):
|
|
for c in range(cols):
|
|
value = f"{corsia}.{self.col_txt[r][c]}.{self.fila_txt[r][c]}\n{self.udc1[r][c]}"
|
|
cell = ws2.cell(row=(rows - r), column=c + 1, value=value) # capovolto per avere 'a' in basso
|
|
cell.fill = fills.get(self.matrix_state[r][c], fills[0])
|
|
cell.alignment = center
|
|
try:
|
|
wb.save(path)
|
|
self._toast(f"Esportato: {path}")
|
|
except Exception as ex:
|
|
messagebox.showerror("Export", f"Salvataggio fallito:\n{ex}")
|
|
|
|
# ---------------- STATS ----------------
|
|
def _refresh_stats(self):
|
|
# globale dal DB
|
|
sql_tot = """
|
|
WITH C AS (
|
|
SELECT ID
|
|
FROM dbo.Celle
|
|
WHERE ID <> 9999 AND (DelDataOra IS NULL)
|
|
AND LTRIM(RTRIM(Corsia)) <> '7G'
|
|
AND LTRIM(RTRIM(Fila)) IS NOT NULL
|
|
AND LTRIM(RTRIM(Colonna)) IS NOT NULL
|
|
),
|
|
S AS (
|
|
SELECT c.ID, COUNT(DISTINCT g.BarcodePallet) AS n
|
|
FROM C AS c LEFT JOIN dbo.XMag_GiacenzaPallet AS g ON g.IDCella = c.ID
|
|
GROUP BY c.ID
|
|
)
|
|
SELECT
|
|
CAST(SUM(CASE WHEN s.n>0 THEN 1 ELSE 0 END) AS float)/NULLIF(COUNT(*),0) AS PercPieno,
|
|
CAST(SUM(CASE WHEN s.n>1 THEN 1 ELSE 0 END) AS float)/NULLIF(COUNT(*),0) AS PercDoppie
|
|
FROM C LEFT JOIN S s ON s.ID = C.ID;
|
|
"""
|
|
def _ok(res):
|
|
rows = res.get("rows", []) if isinstance(res, dict) else []
|
|
p_full = float(rows[0][0] or 0.0) if rows else 0.0
|
|
p_dbl = float(rows[0][1] or 0.0) if rows else 0.0
|
|
self._draw_bar(self.tot_canvas, p_full)
|
|
self.tot_text.configure(text=pct_text(p_full, p_dbl))
|
|
self._async.run(self.db.query_json(sql_tot, {}), _ok, lambda e: None, busy=None, message=None)
|
|
|
|
# selezionata dalla matrice in memoria
|
|
if self.matrix_state:
|
|
tot = sum(len(r) for r in self.matrix_state)
|
|
full = sum(1 for row in self.matrix_state for v in row if v in (1, 2))
|
|
doubles = sum(1 for row in self.matrix_state for v in row if v == 2)
|
|
p_full = (full / tot) if tot else 0.0
|
|
p_dbl = (doubles / tot) if tot else 0.0
|
|
else:
|
|
p_full = p_dbl = 0.0
|
|
self._draw_bar(self.sel_canvas, p_full)
|
|
self.sel_text.configure(text=pct_text(p_full, p_dbl))
|
|
|
|
def _draw_bar(self, cv: tk.Canvas, p_full: float):
|
|
cv.delete("all")
|
|
w = max(300, cv.winfo_width() or 600)
|
|
h = 18
|
|
fw = int(w * max(0.0, min(1.0, p_full)))
|
|
cv.create_rectangle(2, 2, 2 + fw, 2 + h, fill="#D62728", width=0)
|
|
cv.create_rectangle(2 + fw, 2, 2 + w, 2 + h, fill="#2CA02C", width=0)
|
|
cv.create_rectangle(2, 2, 2 + w, 2 + h, outline="#555", width=1)
|
|
|
|
# ---------------- UTIL ----------------
|
|
def _toast(self, msg, ms=1400):
|
|
if not hasattr(self, "_status"):
|
|
self._status = ctk.CTkLabel(self, anchor="w")
|
|
self._status.grid(row=3, column=0, sticky="ew")
|
|
self._status.configure(text=msg)
|
|
self.after(ms, lambda: self._status.configure(text=""))
|
|
|
|
def _copy(self, txt: str):
|
|
self.clipboard_clear()
|
|
self.clipboard_append(txt)
|
|
self._toast(f"Copiato: {txt}")
|
|
|
|
|
|
def open_layout_window(parent, db_app):
|
|
key = "_layout_window_singleton"
|
|
ex = getattr(parent, key, None)
|
|
if ex and ex.winfo_exists():
|
|
try:
|
|
ex.lift()
|
|
ex.focus_force()
|
|
return ex
|
|
except Exception:
|
|
pass
|
|
w = LayoutWindow(parent, db_app)
|
|
setattr(parent, key, w)
|
|
return w
|