1075 lines
41 KiB
Python
1075 lines
41 KiB
Python
"""Exploration window for cells containing more than one pallet."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
import sys
|
|
import tkinter as tk
|
|
from datetime import datetime
|
|
from functools import wraps
|
|
from pathlib import Path
|
|
from tkinter import filedialog, messagebox, ttk
|
|
from typing import Any
|
|
|
|
import customtkinter as ctk
|
|
from openpyxl import Workbook
|
|
from openpyxl.styles import Alignment, Font
|
|
|
|
from busy_overlay import InlineBusyOverlay
|
|
from gestione_aree import AsyncRunner
|
|
from gestione_scarico import move_pallet_async
|
|
from tooltips import WidgetToolTip, load_tooltip_catalog, tooltip_text
|
|
from ui_theme import theme_color, theme_font, theme_section, theme_value
|
|
from window_placement import place_window_fullsize_below_parent_later
|
|
|
|
try:
|
|
from loguru import logger
|
|
except Exception: # pragma: no cover - fallback used only when Loguru is not available
|
|
class _FallbackLogger:
|
|
"""Minimal adapter used only when Loguru is not installed yet."""
|
|
|
|
def __init__(self):
|
|
self._logger = logging.getLogger(MODULE_LOG_NAME if "MODULE_LOG_NAME" in globals() else __name__)
|
|
self._logger.setLevel(logging.DEBUG)
|
|
self._logger.propagate = False
|
|
|
|
def bind(self, **_kwargs):
|
|
return self
|
|
|
|
def add(self, sink, level="INFO", format=None, encoding="utf-8", **_kwargs):
|
|
handler: logging.Handler
|
|
if hasattr(sink, "write"):
|
|
handler = logging.StreamHandler(sink)
|
|
else:
|
|
handler = logging.FileHandler(str(sink), encoding=encoding)
|
|
handler.setLevel(getattr(logging, str(level).upper(), logging.INFO))
|
|
handler.setFormatter(
|
|
logging.Formatter("%(asctime)s | %(levelname)-8s | %(name)s | %(message)s")
|
|
)
|
|
self._logger.addHandler(handler)
|
|
return 0
|
|
|
|
def log(self, level, message):
|
|
getattr(self._logger, str(level).lower(), self._logger.info)(message)
|
|
|
|
def debug(self, message):
|
|
self._logger.debug(message)
|
|
|
|
def info(self, message):
|
|
self._logger.info(message)
|
|
|
|
def exception(self, message):
|
|
self._logger.exception(message)
|
|
|
|
logger = _FallbackLogger()
|
|
|
|
|
|
MULTI_UDC_LOG_MODE = "INFO" # "OFF" | "INFO" | "DEBUG"
|
|
MODULE_LOG_NAME = Path(__file__).stem
|
|
MODULE_LOG_PATH = Path(__file__).with_suffix(".log")
|
|
_MODULE_LOG_ENABLED = MULTI_UDC_LOG_MODE.upper() != "OFF"
|
|
_MODULE_LOG_LEVEL = "DEBUG" if MULTI_UDC_LOG_MODE.upper() == "DEBUG" else "INFO"
|
|
_MODULE_LOGGER = logger.bind(warehouse_module=MODULE_LOG_NAME)
|
|
_MODULE_LOGGING_CONFIGURED = False
|
|
|
|
|
|
def _configure_module_logger():
|
|
"""Configure console and file logging for this module."""
|
|
global _MODULE_LOGGING_CONFIGURED
|
|
if _MODULE_LOGGING_CONFIGURED:
|
|
return
|
|
if not _MODULE_LOG_ENABLED:
|
|
_MODULE_LOGGING_CONFIGURED = True
|
|
return
|
|
|
|
record_filter = lambda record: record["extra"].get("warehouse_module") == MODULE_LOG_NAME
|
|
|
|
logger.add(
|
|
sys.stderr,
|
|
level=_MODULE_LOG_LEVEL,
|
|
colorize=True,
|
|
filter=record_filter,
|
|
format=(
|
|
"<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
|
|
"<level>{level: <8}</level> | "
|
|
"<cyan>" + MODULE_LOG_NAME + "</cyan> | "
|
|
"<level>{message}</level>"
|
|
),
|
|
)
|
|
logger.add(
|
|
MODULE_LOG_PATH,
|
|
level=_MODULE_LOG_LEVEL,
|
|
colorize=False,
|
|
encoding="utf-8",
|
|
filter=record_filter,
|
|
format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | " + MODULE_LOG_NAME + " | {message}",
|
|
)
|
|
_MODULE_LOGGING_CONFIGURED = True
|
|
|
|
|
|
def _format_payload(payload: Any) -> str:
|
|
"""Serialize payloads for human-readable logging."""
|
|
try:
|
|
return json.dumps(payload, ensure_ascii=False, indent=2, default=str)
|
|
except Exception:
|
|
return repr(payload)
|
|
|
|
|
|
def _log_call(level: str | None = None):
|
|
"""Trace entry, exit and failure of selected high-level functions."""
|
|
|
|
def decorator(func):
|
|
@wraps(func)
|
|
def wrapper(*args, **kwargs):
|
|
effective_level = level or _MODULE_LOG_LEVEL
|
|
_MODULE_LOGGER.log(
|
|
effective_level,
|
|
f"CALL {func.__qualname__} args={_format_payload(args[1:] if args else ())} kwargs={_format_payload(kwargs)}",
|
|
)
|
|
try:
|
|
result = func(*args, **kwargs)
|
|
except Exception:
|
|
_MODULE_LOGGER.exception(f"FAIL {func.__qualname__}")
|
|
raise
|
|
_MODULE_LOGGER.log(effective_level, f"RETURN {func.__qualname__}")
|
|
return result
|
|
|
|
return wrapper
|
|
|
|
return decorator
|
|
|
|
|
|
def _log_sql(query_name: str, sql: str, params: dict[str, Any] | None = None):
|
|
"""Log one SQL statement and its parameters."""
|
|
_MODULE_LOGGER.log(_MODULE_LOG_LEVEL, f"SQL {query_name} params={_format_payload(params or {})}")
|
|
_MODULE_LOGGER.debug(f"SQL {query_name} text:\n{sql.strip()}")
|
|
|
|
|
|
def _log_dataset(query_name: str, rows: list[Any]):
|
|
"""Log query results at summary or full-debug level depending on the flag."""
|
|
_MODULE_LOGGER.log(_MODULE_LOG_LEVEL, f"SQL {query_name} returned {len(rows)} rows")
|
|
if MULTI_UDC_LOG_MODE.upper() == "DEBUG":
|
|
_MODULE_LOGGER.debug(f"SQL {query_name} dataset:\n{_format_payload(rows)}")
|
|
|
|
|
|
_configure_module_logger()
|
|
if _MODULE_LOG_ENABLED:
|
|
_MODULE_LOGGER.info(
|
|
f"Logging inizializzato su {MODULE_LOG_PATH.name} livello={_MODULE_LOG_LEVEL} mode={MULTI_UDC_LOG_MODE.upper()}"
|
|
)
|
|
|
|
|
|
def _json_obj(res):
|
|
"""Normalize raw DB responses into a dictionary with a ``rows`` key."""
|
|
if isinstance(res, str):
|
|
try:
|
|
res = json.loads(res)
|
|
except Exception as ex:
|
|
raise RuntimeError(f"Risposta non JSON: {ex}\nRaw: {res!r}")
|
|
if isinstance(res, dict) and "error" in res:
|
|
err = res.get("error") or "Errore sconosciuto"
|
|
detail = res.get("sql") or ""
|
|
raise RuntimeError(f"{err}\n{detail}")
|
|
return res if isinstance(res, dict) else {"rows": res}
|
|
|
|
|
|
UBI_B = (
|
|
"UPPER("
|
|
" CONCAT("
|
|
" RTRIM(b.Corsia), '.', RTRIM(CAST(b.Colonna AS varchar(32))), '.', RTRIM(CAST(b.Fila AS varchar(32)))"
|
|
" )"
|
|
")"
|
|
)
|
|
|
|
BASE_CTE = """
|
|
WITH base AS (
|
|
SELECT
|
|
g.IDCella,
|
|
g.BarcodePallet,
|
|
RTRIM(c.Corsia) AS Corsia,
|
|
c.Colonna,
|
|
c.Fila
|
|
FROM dbo.XMag_GiacenzaPallet AS g
|
|
JOIN dbo.Celle AS c ON c.ID = g.IDCella
|
|
WHERE g.IDCella <> 9999 AND RTRIM(c.Corsia) <> '7G'
|
|
)
|
|
"""
|
|
|
|
SQL_CORSIE = BASE_CTE + """
|
|
, dup_celle AS (
|
|
SELECT IDCCella = b.IDCella
|
|
FROM base b
|
|
GROUP BY b.IDCella
|
|
HAVING COUNT(DISTINCT b.BarcodePallet) > 1
|
|
)
|
|
SELECT DISTINCT b.Corsia
|
|
FROM base b
|
|
WHERE EXISTS (SELECT 1 FROM dup_celle d WHERE d.IDCCella = b.IDCella)
|
|
ORDER BY b.Corsia;
|
|
"""
|
|
|
|
SQL_CELLE_DUP_PER_CORSIA = BASE_CTE + f"""
|
|
, dup_celle AS (
|
|
SELECT b.IDCella, COUNT(DISTINCT b.BarcodePallet) AS NumUDC
|
|
FROM base b
|
|
GROUP BY b.IDCella
|
|
HAVING COUNT(DISTINCT b.BarcodePallet) > 1
|
|
)
|
|
SELECT dc.IDCella,
|
|
{UBI_B} AS Ubicazione,
|
|
b.Colonna, b.Fila, b.Corsia,
|
|
dc.NumUDC
|
|
FROM dup_celle dc
|
|
JOIN base b ON b.IDCella = dc.IDCella
|
|
WHERE b.Corsia = RTRIM(:corsia)
|
|
GROUP BY dc.IDCella, {UBI_B}, b.Colonna, b.Fila, b.Corsia, dc.NumUDC
|
|
ORDER BY b.Colonna, b.Fila;
|
|
"""
|
|
|
|
SQL_PALLET_IN_CELLA = BASE_CTE + """
|
|
, cell_pallets AS (
|
|
SELECT DISTINCT b.BarcodePallet
|
|
FROM base b
|
|
WHERE b.IDCella = :idcella
|
|
),
|
|
latest_any AS (
|
|
SELECT
|
|
ranked.BarcodePallet,
|
|
ranked.IDCella
|
|
FROM (
|
|
SELECT
|
|
mp.Attributo AS BarcodePallet,
|
|
mp.IDCella,
|
|
ROW_NUMBER() OVER (
|
|
PARTITION BY mp.Attributo
|
|
ORDER BY mp.ID DESC
|
|
) AS rn
|
|
FROM dbo.MagazziniPallet mp
|
|
JOIN cell_pallets cp
|
|
ON cp.BarcodePallet COLLATE Latin1_General_CI_AS =
|
|
mp.Attributo COLLATE Latin1_General_CI_AS
|
|
WHERE mp.Tipo = 'V'
|
|
AND mp.PesoUnitario > 0
|
|
) ranked
|
|
WHERE ranked.rn = 1
|
|
),
|
|
shipped AS (
|
|
SELECT DISTINCT shipped.BarcodePallet
|
|
FROM dbo.XMag_GiacenzaPalletPlistChiuse shipped
|
|
JOIN cell_pallets cp
|
|
ON cp.BarcodePallet COLLATE Latin1_General_CI_AS =
|
|
shipped.BarcodePallet COLLATE Latin1_General_CI_AS
|
|
)
|
|
SELECT
|
|
b.BarcodePallet AS Pallet,
|
|
ta.Descrizione,
|
|
ta.Lotto,
|
|
CASE
|
|
WHEN shipped.BarcodePallet IS NOT NULL THEN CAST(1 AS int)
|
|
ELSE CAST(0 AS int)
|
|
END AS IsShippedGhost,
|
|
CASE
|
|
WHEN la.IDCella IS NOT NULL
|
|
AND la.IDCella <> :idcella
|
|
THEN CAST(1 AS int)
|
|
ELSE CAST(0 AS int)
|
|
END AS IsMovedGhost
|
|
FROM base b
|
|
OUTER APPLY (
|
|
SELECT TOP (1) t.Descrizione, t.Lotto
|
|
FROM dbo.vXTracciaProdotti AS t
|
|
WHERE t.Pallet = b.BarcodePallet COLLATE Latin1_General_CI_AS
|
|
ORDER BY t.Lotto
|
|
) AS ta
|
|
LEFT JOIN latest_any la
|
|
ON la.BarcodePallet COLLATE Latin1_General_CI_AS =
|
|
b.BarcodePallet COLLATE Latin1_General_CI_AS
|
|
LEFT JOIN shipped
|
|
ON shipped.BarcodePallet COLLATE Latin1_General_CI_AS =
|
|
b.BarcodePallet COLLATE Latin1_General_CI_AS
|
|
WHERE b.IDCella = :idcella
|
|
GROUP BY b.BarcodePallet, ta.Descrizione, ta.Lotto, shipped.BarcodePallet, la.IDCella
|
|
ORDER BY b.BarcodePallet;
|
|
"""
|
|
|
|
SQL_PALLET_IN_CORSIA = BASE_CTE + f"""
|
|
, dup_celle AS (
|
|
SELECT b.IDCella
|
|
FROM base b
|
|
WHERE b.Corsia = RTRIM(:corsia)
|
|
GROUP BY b.IDCella
|
|
HAVING COUNT(DISTINCT b.BarcodePallet) > 1
|
|
),
|
|
corsia_pallets AS (
|
|
SELECT DISTINCT b.IDCella, b.BarcodePallet
|
|
FROM base b
|
|
JOIN dup_celle dc ON dc.IDCella = b.IDCella
|
|
),
|
|
latest_any AS (
|
|
SELECT
|
|
ranked.BarcodePallet,
|
|
ranked.IDCella
|
|
FROM (
|
|
SELECT
|
|
mp.Attributo AS BarcodePallet,
|
|
mp.IDCella,
|
|
ROW_NUMBER() OVER (
|
|
PARTITION BY mp.Attributo
|
|
ORDER BY mp.ID DESC
|
|
) AS rn
|
|
FROM dbo.MagazziniPallet mp
|
|
JOIN (SELECT DISTINCT BarcodePallet FROM corsia_pallets) cp
|
|
ON cp.BarcodePallet COLLATE Latin1_General_CI_AS =
|
|
mp.Attributo COLLATE Latin1_General_CI_AS
|
|
WHERE mp.Tipo = 'V'
|
|
AND mp.PesoUnitario > 0
|
|
) ranked
|
|
WHERE ranked.rn = 1
|
|
),
|
|
shipped AS (
|
|
SELECT DISTINCT shipped.BarcodePallet
|
|
FROM dbo.XMag_GiacenzaPalletPlistChiuse shipped
|
|
JOIN (SELECT DISTINCT BarcodePallet FROM corsia_pallets) cp
|
|
ON cp.BarcodePallet COLLATE Latin1_General_CI_AS =
|
|
shipped.BarcodePallet COLLATE Latin1_General_CI_AS
|
|
)
|
|
SELECT
|
|
cp.IDCella,
|
|
{UBI_B} AS Ubicazione,
|
|
cp.BarcodePallet AS Pallet,
|
|
ta.Descrizione,
|
|
ta.Lotto,
|
|
CASE
|
|
WHEN shipped.BarcodePallet IS NOT NULL THEN CAST(1 AS int)
|
|
ELSE CAST(0 AS int)
|
|
END AS IsShippedGhost,
|
|
CASE
|
|
WHEN la.IDCella IS NOT NULL
|
|
AND la.IDCella <> cp.IDCella
|
|
THEN CAST(1 AS int)
|
|
ELSE CAST(0 AS int)
|
|
END AS IsMovedGhost
|
|
FROM corsia_pallets cp
|
|
JOIN base b
|
|
ON b.IDCella = cp.IDCella
|
|
AND b.BarcodePallet = cp.BarcodePallet
|
|
OUTER APPLY (
|
|
SELECT TOP (1) t.Descrizione, t.Lotto
|
|
FROM dbo.vXTracciaProdotti AS t
|
|
WHERE t.Pallet = cp.BarcodePallet COLLATE Latin1_General_CI_AS
|
|
ORDER BY t.Lotto
|
|
) AS ta
|
|
LEFT JOIN latest_any la
|
|
ON la.BarcodePallet COLLATE Latin1_General_CI_AS =
|
|
cp.BarcodePallet COLLATE Latin1_General_CI_AS
|
|
LEFT JOIN shipped
|
|
ON shipped.BarcodePallet COLLATE Latin1_General_CI_AS =
|
|
cp.BarcodePallet COLLATE Latin1_General_CI_AS
|
|
GROUP BY
|
|
cp.IDCella,
|
|
{UBI_B},
|
|
cp.BarcodePallet,
|
|
ta.Descrizione,
|
|
ta.Lotto,
|
|
shipped.BarcodePallet,
|
|
la.IDCella
|
|
ORDER BY cp.IDCella, cp.BarcodePallet;
|
|
"""
|
|
|
|
|
|
def _build_diagnostic_note(is_shipped: int | bool, is_moved: int | bool) -> str:
|
|
"""Translate anomaly flags into the operator-facing ghost cause."""
|
|
|
|
notes: list[str] = []
|
|
if bool(is_shipped):
|
|
notes.append("Mancato scarico: spedita")
|
|
if bool(is_moved):
|
|
notes.append("Mancato scarico: spostata")
|
|
return " | ".join(notes)
|
|
|
|
SQL_RIEPILOGO_PERCENTUALI = BASE_CTE + """
|
|
, tot AS (
|
|
SELECT b.Corsia, COUNT(DISTINCT b.IDCella) AS TotCelle
|
|
FROM base b GROUP BY b.Corsia
|
|
),
|
|
dup_celle AS (
|
|
SELECT b.Corsia, b.IDCella
|
|
FROM base b
|
|
GROUP BY b.Corsia, b.IDCella
|
|
HAVING COUNT(DISTINCT b.BarcodePallet) > 1
|
|
),
|
|
per_corsia AS (
|
|
SELECT t.Corsia, t.TotCelle, COALESCE(d.CelleMultiple, 0) AS CelleMultiple
|
|
FROM tot t
|
|
LEFT JOIN (
|
|
SELECT Corsia, COUNT(IDCella) AS CelleMultiple
|
|
FROM dup_celle GROUP BY Corsia
|
|
) d ON d.Corsia = t.Corsia
|
|
),
|
|
unione AS (
|
|
SELECT Corsia, TotCelle, CelleMultiple,
|
|
CAST(100.0 * CelleMultiple / NULLIF(TotCelle, 0) AS decimal(5,2)) AS Percentuale,
|
|
CAST(0 AS int) AS Ord
|
|
FROM per_corsia
|
|
UNION ALL
|
|
SELECT 'TOTALE' AS Corsia,
|
|
SUM(TotCelle), SUM(CelleMultiple),
|
|
CAST(100.0 * SUM(CelleMultiple) / NULLIF(SUM(TotCelle), 0) AS decimal(5,2)),
|
|
CAST(1 AS int) AS Ord
|
|
FROM per_corsia
|
|
)
|
|
SELECT Corsia, TotCelle, CelleMultiple, Percentuale
|
|
FROM unione
|
|
ORDER BY Ord, Corsia;
|
|
"""
|
|
|
|
|
|
class CelleMultipleWindow(ctk.CTkToplevel):
|
|
"""Tree-based explorer for duplicated pallet allocations."""
|
|
|
|
@_log_call()
|
|
def __init__(self, root, db_client, runner: AsyncRunner | None = None, session=None):
|
|
"""Bind the shared DB client and immediately load the tree summary."""
|
|
super().__init__(root)
|
|
self._theme = theme_section("multi_udc", {})
|
|
self._tooltip_catalog = load_tooltip_catalog()
|
|
self.title("Celle con piu' pallet")
|
|
self.session = session
|
|
self.geometry(str(theme_value(self._theme, "window_geometry", "1100x700")))
|
|
minsize = theme_value(self._theme, "window_minsize", [900, 550])
|
|
self.minsize(int(minsize[0]), int(minsize[1]))
|
|
self.resizable(True, True)
|
|
try:
|
|
self.configure(fg_color=theme_color(self._theme, "window_fg_color", ("#efefef", "#2f2f2f")))
|
|
except Exception:
|
|
pass
|
|
|
|
self.db = db_client
|
|
self.runner = runner or AsyncRunner(self)
|
|
self._busy = InlineBusyOverlay(self, self._theme)
|
|
self.selected_corsia_id: str | None = None
|
|
self.selected_udc_keys: set[str] = set()
|
|
self.udc_meta_by_key: dict[str, dict[str, Any]] = {}
|
|
|
|
self._build_layout()
|
|
self._bind_events()
|
|
self.refresh_all()
|
|
|
|
def _build_layout(self):
|
|
"""Create the toolbar, lazy-loaded tree and percentage summary table."""
|
|
self.grid_rowconfigure(0, weight=5)
|
|
self.grid_rowconfigure(1, weight=70)
|
|
self.grid_rowconfigure(2, weight=25, minsize=160)
|
|
self.grid_columnconfigure(0, weight=1)
|
|
|
|
toolbar = ctk.CTkFrame(self)
|
|
toolbar.grid(row=0, column=0, sticky="nsew")
|
|
try:
|
|
toolbar.configure(fg_color=theme_color(self._theme, "toolbar_frame_fg_color", ("#d7d7d7", "#3b3b3b")))
|
|
except Exception:
|
|
pass
|
|
btn_refresh = ctk.CTkButton(toolbar, text="Aggiorna", command=self.refresh_all, font=theme_font(self._theme, "toolbar_button_font", ("Segoe UI", 10, "bold")))
|
|
btn_refresh.pack(side="left", padx=6, pady=4)
|
|
btn_expand = ctk.CTkButton(toolbar, text="Espandi tutto", command=self.expand_all, font=theme_font(self._theme, "toolbar_button_font", ("Segoe UI", 10, "bold")))
|
|
btn_expand.pack(side="left", padx=6, pady=4)
|
|
btn_collapse = ctk.CTkButton(toolbar, text="Comprimi tutto", command=self.collapse_all, font=theme_font(self._theme, "toolbar_button_font", ("Segoe UI", 10, "bold")))
|
|
btn_collapse.pack(side="left", padx=6, pady=4)
|
|
btn_preselect = ctk.CTkButton(toolbar, text="Preselezione fantasmi corsia", command=self._preselect_selected_corsia, font=theme_font(self._theme, "toolbar_button_font", ("Segoe UI", 10, "bold")))
|
|
btn_preselect.pack(side="left", padx=6, pady=4)
|
|
btn_remove = ctk.CTkButton(toolbar, text="Rimuovi fantasmi corsia", command=self._remove_selected_ghosts_for_corsia, font=theme_font(self._theme, "toolbar_button_font", ("Segoe UI", 10, "bold")))
|
|
btn_remove.pack(side="left", padx=6, pady=4)
|
|
btn_export = ctk.CTkButton(toolbar, text="Esporta in XLSX", command=self.export_to_xlsx, font=theme_font(self._theme, "toolbar_button_font", ("Segoe UI", 10, "bold")))
|
|
btn_export.pack(side="left", padx=6, pady=4)
|
|
WidgetToolTip(btn_refresh, tooltip_text("multi_udc.refresh", catalog=self._tooltip_catalog))
|
|
WidgetToolTip(btn_expand, tooltip_text("multi_udc.expand_all", catalog=self._tooltip_catalog))
|
|
WidgetToolTip(btn_collapse, tooltip_text("multi_udc.collapse_all", catalog=self._tooltip_catalog))
|
|
WidgetToolTip(btn_preselect, tooltip_text("multi_udc.preselect", catalog=self._tooltip_catalog))
|
|
WidgetToolTip(btn_remove, tooltip_text("multi_udc.remove_ghosts", catalog=self._tooltip_catalog))
|
|
WidgetToolTip(btn_export, tooltip_text("multi_udc.export_xlsx", catalog=self._tooltip_catalog))
|
|
|
|
frame = ctk.CTkFrame(self)
|
|
frame.grid(row=1, column=0, sticky="nsew", padx=6, pady=(0, 6))
|
|
try:
|
|
frame.configure(fg_color=theme_color(self._theme, "content_frame_fg_color", ("#e5e5e5", "#383838")))
|
|
except Exception:
|
|
pass
|
|
frame.grid_rowconfigure(0, weight=1)
|
|
frame.grid_columnconfigure(0, weight=1)
|
|
self.tree = ttk.Treeview(frame, columns=("col2", "col3", "col4"), show="tree headings", selectmode="browse")
|
|
self.tree.heading("#0", text="Nodo")
|
|
self.tree.heading("col2", text="Descrizione")
|
|
self.tree.heading("col3", text="Lotto")
|
|
self.tree.heading("col4", text="Causale")
|
|
self.tree.column("#0", width=220, anchor="w")
|
|
self.tree.column("col2", width=250, anchor="w")
|
|
self.tree.column("col3", width=120, anchor="w")
|
|
self.tree.column("col4", width=260, anchor="w")
|
|
y = ttk.Scrollbar(frame, orient="vertical", command=self.tree.yview)
|
|
x = ttk.Scrollbar(frame, orient="horizontal", command=self.tree.xview)
|
|
self.tree.configure(yscrollcommand=y.set, xscrollcommand=x.set)
|
|
self.tree.grid(row=0, column=0, sticky="nsew")
|
|
y.grid(row=0, column=1, sticky="ns")
|
|
x.grid(row=1, column=0, sticky="ew")
|
|
|
|
sumf = ctk.CTkFrame(self)
|
|
sumf.grid(row=2, column=0, sticky="nsew", padx=6, pady=(0, 6))
|
|
try:
|
|
sumf.configure(fg_color=theme_color(self._theme, "summary_frame_fg_color", ("#dcdcdc", "#363636")))
|
|
except Exception:
|
|
pass
|
|
ctk.CTkLabel(
|
|
sumf,
|
|
text="Riepilogo % celle multiple per corsia",
|
|
font=theme_font(self._theme, "summary_title_font", ("Segoe UI", 12, "bold")),
|
|
).pack(anchor="w", padx=8, pady=(8, 0))
|
|
inner = ctk.CTkFrame(sumf)
|
|
inner.pack(fill="both", expand=True, padx=6, pady=6)
|
|
try:
|
|
inner.configure(fg_color=theme_color(self._theme, "inner_summary_frame_fg_color", ("#d4d4d4", "#404040")))
|
|
except Exception:
|
|
pass
|
|
inner.grid_rowconfigure(0, weight=1)
|
|
inner.grid_columnconfigure(0, weight=1)
|
|
self.sum_tbl = ttk.Treeview(inner, columns=("Corsia", "TotCelle", "CelleMultiple", "Percentuale"), show="headings")
|
|
for key, title, width, anchor in (
|
|
("Corsia", "Corsia", 100, "center"),
|
|
("TotCelle", "Totale celle", 120, "e"),
|
|
("CelleMultiple", ">1 UDC", 120, "e"),
|
|
("Percentuale", "%", 80, "e"),
|
|
):
|
|
self.sum_tbl.heading(key, text=title)
|
|
self.sum_tbl.column(key, width=width, anchor=anchor)
|
|
y2 = ttk.Scrollbar(inner, orient="vertical", command=self.sum_tbl.yview)
|
|
x2 = ttk.Scrollbar(inner, orient="horizontal", command=self.sum_tbl.xview)
|
|
self.sum_tbl.configure(yscrollcommand=y2.set, xscrollcommand=x2.set)
|
|
self.sum_tbl.grid(row=0, column=0, sticky="nsew")
|
|
y2.grid(row=0, column=1, sticky="ns")
|
|
x2.grid(row=1, column=0, sticky="ew")
|
|
|
|
def _bind_events(self):
|
|
"""Attach lazy-load behavior when nodes are expanded."""
|
|
self.tree.bind("<<TreeviewOpen>>", self._on_open_node)
|
|
self.tree.bind("<Button-1>", self._on_tree_click, add="+")
|
|
|
|
def _format_corsia_text(self, corsia: str) -> str:
|
|
"""Render one aisle root with its exclusive selection marker."""
|
|
|
|
return f"[{'x' if self.selected_corsia_id == f'corsia:{corsia}' else ' '}] Corsia {corsia}"
|
|
|
|
def _format_pallet_text(self, pallet: str, selected: bool) -> str:
|
|
"""Render one pallet leaf with its selection marker."""
|
|
|
|
return f"[{'x' if selected else ' '}] {pallet}"
|
|
|
|
def _selected_corsia_value(self) -> str | None:
|
|
"""Return the code of the currently active aisle."""
|
|
|
|
if self.selected_corsia_id and self.selected_corsia_id.startswith("corsia:"):
|
|
return self.selected_corsia_id.split(":", 1)[1]
|
|
return None
|
|
|
|
def _set_selected_corsia(self, node_id: str | None):
|
|
"""Keep exactly one selected aisle and refresh root labels."""
|
|
|
|
previous = self.selected_corsia_id
|
|
self.selected_corsia_id = node_id
|
|
for iid in self.tree.get_children(""):
|
|
if not iid.startswith("corsia:"):
|
|
continue
|
|
self.tree.item(iid, text=self._format_corsia_text(iid.split(":", 1)[1]))
|
|
if previous and previous != node_id and previous.startswith("corsia:"):
|
|
self._clear_leaf_selection_for_corsia(previous.split(":", 1)[1])
|
|
|
|
def _set_leaf_selected(self, leaf_id: str, selected: bool):
|
|
"""Toggle one selected pallet leaf and refresh its label if visible."""
|
|
|
|
meta = self.udc_meta_by_key.get(leaf_id)
|
|
if selected:
|
|
self.selected_udc_keys.add(leaf_id)
|
|
else:
|
|
self.selected_udc_keys.discard(leaf_id)
|
|
if meta and self.tree.exists(leaf_id):
|
|
self.tree.item(leaf_id, text=self._format_pallet_text(str(meta.get("pallet", "")), selected))
|
|
|
|
def _clear_leaf_selection_for_corsia(self, corsia: str):
|
|
"""Clear all selected pallet leaves for one aisle."""
|
|
|
|
for leaf_id, meta in list(self.udc_meta_by_key.items()):
|
|
if meta.get("corsia") == corsia:
|
|
self._set_leaf_selected(leaf_id, False)
|
|
|
|
def _on_tree_click(self, event):
|
|
"""Handle custom selection on aisle roots and pallet leaves."""
|
|
|
|
try:
|
|
element = self.tree.identify_element(event.x, event.y)
|
|
if "indicator" in str(element).lower():
|
|
return
|
|
item_id = self.tree.identify_row(event.y)
|
|
except Exception:
|
|
return
|
|
if not item_id:
|
|
return
|
|
tags = self.tree.item(item_id, "tags") or ()
|
|
if "corsia" in tags:
|
|
self._set_selected_corsia(item_id)
|
|
self.tree.selection_set(item_id)
|
|
return "break"
|
|
if "pallet" in tags:
|
|
corsia = next((tag.split(":", 1)[1] for tag in tags if tag.startswith("corsia:")), "")
|
|
self._set_selected_corsia(f"corsia:{corsia}")
|
|
self._set_leaf_selected(item_id, item_id not in self.selected_udc_keys)
|
|
self.tree.selection_set(item_id)
|
|
return "break"
|
|
|
|
@_log_call()
|
|
def refresh_all(self):
|
|
"""Reload both the duplication tree and the summary percentage table."""
|
|
self.selected_corsia_id = None
|
|
self.selected_udc_keys.clear()
|
|
self.udc_meta_by_key.clear()
|
|
self._load_corsie()
|
|
self._load_riepilogo()
|
|
|
|
@_log_call()
|
|
def _load_corsie(self):
|
|
"""Load root nodes representing aisles with duplicated cells."""
|
|
self.tree.delete(*self.tree.get_children())
|
|
_log_sql("multi_udc_corsie", SQL_CORSIE, {})
|
|
|
|
async def _q(db):
|
|
return await db.query_json(SQL_CORSIE, as_dict_rows=True)
|
|
|
|
def _err(ex):
|
|
_MODULE_LOGGER.exception(f"Errore caricamento corsie UDC fantasma: {ex}")
|
|
messagebox.showerror("Errore", str(ex), parent=self)
|
|
|
|
self.runner.run(_q(self.db), self._fill_corsie, _err)
|
|
|
|
@_log_call()
|
|
def _fill_corsie(self, res):
|
|
"""Populate root tree nodes after the aisle query completes."""
|
|
rows = _json_obj(res).get("rows", [])
|
|
_log_dataset("multi_udc_corsie", rows)
|
|
for row in rows:
|
|
corsia = row.get("Corsia")
|
|
if not corsia:
|
|
continue
|
|
node_id = f"corsia:{corsia}"
|
|
self.tree.insert(
|
|
"",
|
|
"end",
|
|
iid=node_id,
|
|
text=self._format_corsia_text(corsia),
|
|
values=("", "", ""),
|
|
open=False,
|
|
tags=("corsia",),
|
|
)
|
|
self.tree.insert(node_id, "end", iid=f"{node_id}::lazy", text="...", values=("", "", ""))
|
|
|
|
def _on_open_node(self, _evt):
|
|
"""Lazy-load children when a tree node is expanded."""
|
|
sel = self.tree.focus()
|
|
if not sel:
|
|
return
|
|
if sel.startswith("corsia:"):
|
|
lazy_id = f"{sel}::lazy"
|
|
if lazy_id in self.tree.get_children(sel):
|
|
self.tree.delete(lazy_id)
|
|
corsia = sel.split(":", 1)[1]
|
|
self._load_celle_for_corsia(sel, corsia)
|
|
elif sel.startswith("cella:"):
|
|
lazy_id = f"{sel}::lazy"
|
|
if lazy_id in self.tree.get_children(sel):
|
|
self.tree.delete(lazy_id)
|
|
idcella = int(sel.split(":", 1)[1])
|
|
for child in self.tree.get_children(sel):
|
|
self.tree.delete(child)
|
|
self._load_pallet_for_cella(sel, idcella)
|
|
|
|
@_log_call()
|
|
def _load_celle_for_corsia(self, parent_iid, corsia):
|
|
"""Query duplicated cells for the selected aisle."""
|
|
_log_sql("multi_udc_celle_per_corsia", SQL_CELLE_DUP_PER_CORSIA, {"corsia": corsia})
|
|
|
|
async def _q(db):
|
|
return await db.query_json(SQL_CELLE_DUP_PER_CORSIA, params={"corsia": corsia}, as_dict_rows=True)
|
|
|
|
def _err(ex):
|
|
_MODULE_LOGGER.exception(f"Errore caricamento celle duplicate corsia={corsia}: {ex}")
|
|
messagebox.showerror("Errore", str(ex), parent=self)
|
|
|
|
self.runner.run(_q(self.db), lambda res: self._fill_celle(parent_iid, res), _err)
|
|
|
|
@_log_call()
|
|
def _fill_celle(self, parent_iid, res):
|
|
"""Populate duplicated-cell nodes under an aisle node."""
|
|
rows = _json_obj(res).get("rows", [])
|
|
_log_dataset("multi_udc_celle_per_corsia", rows)
|
|
if not rows:
|
|
self.tree.insert(parent_iid, "end", text="(nessuna cella con >1 UDC)", values=("", "", ""))
|
|
return
|
|
for row in rows:
|
|
idc = row["IDCella"]
|
|
ubi = row["Ubicazione"]
|
|
corsia = row.get("Corsia")
|
|
num = row.get("NumUDC", 0)
|
|
node_id = f"cella:{idc}"
|
|
label = f"{ubi} [x{num}]"
|
|
if self.tree.exists(node_id):
|
|
self.tree.item(node_id, text=label, values=(f"IDCella {idc}", "", ""))
|
|
else:
|
|
self.tree.insert(
|
|
parent_iid,
|
|
"end",
|
|
iid=node_id,
|
|
text=label,
|
|
values=(f"IDCella {idc}", "", ""),
|
|
open=False,
|
|
tags=("cella", f"corsia:{corsia}"),
|
|
)
|
|
if not any(child.endswith("::lazy") for child in self.tree.get_children(node_id)):
|
|
self.tree.insert(node_id, "end", iid=f"{node_id}::lazy", text="...", values=("", "", ""))
|
|
|
|
@_log_call()
|
|
def _load_pallet_for_cella(self, parent_iid, idcella: int):
|
|
"""Query pallet details for a duplicated cell."""
|
|
_log_sql("multi_udc_pallet_in_cella", SQL_PALLET_IN_CELLA, {"idcella": idcella})
|
|
|
|
async def _q(db):
|
|
return await db.query_json(SQL_PALLET_IN_CELLA, params={"idcella": idcella}, as_dict_rows=True)
|
|
|
|
def _err(ex):
|
|
_MODULE_LOGGER.exception(f"Errore caricamento pallet cella idcella={idcella}: {ex}")
|
|
messagebox.showerror("Errore", str(ex), parent=self)
|
|
|
|
self.runner.run(_q(self.db), lambda res: self._fill_pallet(parent_iid, res), _err)
|
|
|
|
@_log_call()
|
|
def _fill_pallet(self, parent_iid, res):
|
|
"""Add pallet leaves under the selected cell node."""
|
|
rows = _json_obj(res).get("rows", [])
|
|
_log_dataset("multi_udc_pallet_in_cella", rows)
|
|
if not rows:
|
|
self.tree.insert(parent_iid, "end", text="(nessun pallet)", values=("", "", ""))
|
|
return
|
|
parent_tags = self.tree.item(parent_iid, "tags") or ()
|
|
corsia_tag = next((tag for tag in parent_tags if tag.startswith("corsia:")), None)
|
|
corsia_val = corsia_tag.split(":", 1)[1] if corsia_tag else ""
|
|
cella_ubi = self.tree.item(parent_iid, "text")
|
|
idcella_txt = self.tree.item(parent_iid, "values")[0]
|
|
idcella_num = int(idcella_txt.split()[-1]) if idcella_txt else None
|
|
|
|
for row in rows:
|
|
pallet = row.get("Pallet", "")
|
|
desc = row.get("Descrizione", "")
|
|
lotto = row.get("Lotto", "")
|
|
is_shipped = int(row.get("IsShippedGhost", 0) or 0)
|
|
is_moved = int(row.get("IsMovedGhost", 0) or 0)
|
|
causale = _build_diagnostic_note(is_shipped, is_moved)
|
|
leaf_id = f"pallet:{idcella_num}:{pallet}"
|
|
self.udc_meta_by_key[leaf_id] = {
|
|
"corsia": corsia_val,
|
|
"ubicazione": cella_ubi,
|
|
"idcella": idcella_num,
|
|
"pallet": str(pallet),
|
|
"descrizione": desc,
|
|
"lotto": lotto,
|
|
"causale": causale,
|
|
"is_shipped": is_shipped,
|
|
"is_moved": is_moved,
|
|
}
|
|
if self.tree.exists(leaf_id):
|
|
self.tree.item(
|
|
leaf_id,
|
|
text=self._format_pallet_text(str(pallet), leaf_id in self.selected_udc_keys),
|
|
values=(desc, lotto, causale),
|
|
)
|
|
continue
|
|
self.tree.insert(
|
|
parent_iid,
|
|
"end",
|
|
iid=leaf_id,
|
|
text=self._format_pallet_text(str(pallet), leaf_id in self.selected_udc_keys),
|
|
values=(desc, lotto, causale),
|
|
tags=("pallet", f"corsia:{corsia_val}", f"ubicazione:{cella_ubi}", f"idcella:{idcella_num}"),
|
|
)
|
|
|
|
@_log_call()
|
|
def _preselect_selected_corsia(self):
|
|
"""Expand one aisle and preselect only shipped/moved ghost pallets."""
|
|
|
|
corsia = self._selected_corsia_value()
|
|
if not corsia:
|
|
messagebox.showinfo("Preselezione", "Seleziona prima una corsia.", parent=self)
|
|
return
|
|
|
|
corsia_node = f"corsia:{corsia}"
|
|
self.tree.item(corsia_node, open=True)
|
|
self._clear_leaf_selection_for_corsia(corsia)
|
|
self._busy.show(f"Preselezione fantasmi corsia {corsia.strip()}...")
|
|
|
|
_log_sql("multi_udc_celle_per_corsia.preselect", SQL_CELLE_DUP_PER_CORSIA, {"corsia": corsia})
|
|
_log_sql("multi_udc_pallet_in_corsia.preselect", SQL_PALLET_IN_CORSIA, {"corsia": corsia})
|
|
|
|
async def _q(db):
|
|
celle_res = _json_obj(await db.query_json(SQL_CELLE_DUP_PER_CORSIA, params={"corsia": corsia}, as_dict_rows=True))
|
|
celle_rows = celle_res.get("rows", [])
|
|
pallet_res = _json_obj(await db.query_json(SQL_PALLET_IN_CORSIA, params={"corsia": corsia}, as_dict_rows=True))
|
|
return {"cells": celle_rows, "pallets": pallet_res.get("rows", [])}
|
|
|
|
def _ok(res):
|
|
self._busy.hide()
|
|
payload = _json_obj(res)
|
|
cell_rows = payload.get("cells", [])
|
|
pallet_rows = payload.get("pallets", [])
|
|
selected_count = 0
|
|
grouped_pallets: dict[int, list[dict[str, Any]]] = {}
|
|
for pallet_row in pallet_rows:
|
|
grouped_pallets.setdefault(int(pallet_row["IDCella"]), []).append(pallet_row)
|
|
|
|
if self.tree.exists(f"{corsia_node}::lazy"):
|
|
self.tree.delete(f"{corsia_node}::lazy")
|
|
|
|
for cell_row in cell_rows:
|
|
idcella = int(cell_row["IDCella"])
|
|
cell_node = f"cella:{idcella}"
|
|
if not self.tree.exists(cell_node):
|
|
self._fill_celle(corsia_node, {"rows": [cell_row]})
|
|
self.tree.item(cell_node, open=True)
|
|
for child in list(self.tree.get_children(cell_node)):
|
|
self.tree.delete(child)
|
|
self._fill_pallet(cell_node, {"rows": grouped_pallets.get(idcella, [])})
|
|
for leaf_id, meta in list(self.udc_meta_by_key.items()):
|
|
if meta.get("corsia") != corsia or meta.get("idcella") != idcella:
|
|
continue
|
|
if meta.get("is_shipped") or meta.get("is_moved"):
|
|
self._set_leaf_selected(leaf_id, True)
|
|
selected_count += 1
|
|
|
|
messagebox.showinfo(
|
|
"Preselezione completata",
|
|
f"Corsia {corsia}\nUDC candidate selezionate automaticamente: {selected_count}",
|
|
parent=self,
|
|
)
|
|
|
|
def _err(ex):
|
|
self._busy.hide()
|
|
_MODULE_LOGGER.exception(f"Errore preselezione fantasmi corsia={corsia}: {ex}")
|
|
messagebox.showerror("Errore", str(ex), parent=self)
|
|
|
|
self.runner.run(_q(self.db), _ok, _err)
|
|
|
|
@_log_call()
|
|
def _remove_selected_ghosts_for_corsia(self):
|
|
"""Remove the selected ghost pallets only for the active aisle."""
|
|
|
|
corsia = self._selected_corsia_value()
|
|
if not corsia:
|
|
messagebox.showinfo("Bonifica fantasmi", "Seleziona prima una corsia.", parent=self)
|
|
return
|
|
|
|
selected_meta = [
|
|
meta
|
|
for leaf_id, meta in self.udc_meta_by_key.items()
|
|
if leaf_id in self.selected_udc_keys and meta.get("corsia") == corsia
|
|
]
|
|
if not selected_meta:
|
|
messagebox.showinfo("Bonifica fantasmi", "Nessuna UDC selezionata nella corsia attiva.", parent=self)
|
|
return
|
|
|
|
shipped_count = sum(1 for meta in selected_meta if meta.get("is_shipped"))
|
|
moved_count = sum(1 for meta in selected_meta if meta.get("is_moved"))
|
|
cell_count = len({meta.get("idcella") for meta in selected_meta})
|
|
if not messagebox.askyesno(
|
|
"Conferma bonifica corsia",
|
|
(
|
|
f"Corsia {corsia}\n"
|
|
f"UDC selezionate: {len(selected_meta)}\n"
|
|
f"Celle coinvolte: {cell_count}\n"
|
|
f"Spedite: {shipped_count}\n"
|
|
f"Spostate: {moved_count}\n\n"
|
|
"Procedere con la rimozione delle sole UDC selezionate?"
|
|
),
|
|
parent=self,
|
|
):
|
|
return
|
|
self._busy.show(f"Rimozione fantasmi corsia {corsia.strip()}...")
|
|
|
|
async def _q(_db):
|
|
results: list[dict[str, Any]] = []
|
|
for meta in selected_meta:
|
|
result = await move_pallet_async(
|
|
self.db,
|
|
barcode_pallet=str(meta.get("pallet", "")).strip(),
|
|
target_idcella=9999,
|
|
target_barcode_cella="9000000",
|
|
utente=str(getattr(self.session, "login", "") or "warehouse_ui").strip(),
|
|
)
|
|
results.append({"meta": meta, "result": result})
|
|
return {"rows": results}
|
|
|
|
def _ok(res):
|
|
self._busy.hide()
|
|
rows = _json_obj(res).get("rows", [])
|
|
removed = sum(1 for row in rows if row.get("result"))
|
|
self.refresh_all()
|
|
messagebox.showinfo(
|
|
"Bonifica completata",
|
|
f"Corsia {corsia}\nUDC rimosse: {removed}",
|
|
parent=self,
|
|
)
|
|
|
|
def _err(ex):
|
|
self._busy.hide()
|
|
_MODULE_LOGGER.exception(f"Errore bonifica fantasmi corsia={corsia}: {ex}")
|
|
messagebox.showerror("Errore bonifica", str(ex), parent=self)
|
|
|
|
self.runner.run(_q(self.db), _ok, _err)
|
|
|
|
@_log_call()
|
|
def _load_riepilogo(self):
|
|
"""Load the percentage summary by aisle."""
|
|
_log_sql("multi_udc_riepilogo", SQL_RIEPILOGO_PERCENTUALI, {})
|
|
|
|
async def _q(db):
|
|
return await db.query_json(SQL_RIEPILOGO_PERCENTUALI, as_dict_rows=True)
|
|
|
|
def _err(ex):
|
|
_MODULE_LOGGER.exception(f"Errore caricamento riepilogo UDC fantasma: {ex}")
|
|
messagebox.showerror("Errore", str(ex), parent=self)
|
|
|
|
self.runner.run(_q(self.db), self._fill_riepilogo, _err)
|
|
|
|
@_log_call()
|
|
def _fill_riepilogo(self, res):
|
|
"""Refresh the bottom summary table."""
|
|
rows = _json_obj(res).get("rows", [])
|
|
_log_dataset("multi_udc_riepilogo", rows)
|
|
for item in self.sum_tbl.get_children():
|
|
self.sum_tbl.delete(item)
|
|
for row in rows:
|
|
self.sum_tbl.insert(
|
|
"",
|
|
"end",
|
|
values=(row.get("Corsia"), row.get("TotCelle", 0), row.get("CelleMultiple", 0), f"{row.get('Percentuale', 0):.2f}"),
|
|
)
|
|
|
|
def expand_all(self):
|
|
"""Expand all aisle roots and trigger lazy loading where needed."""
|
|
for iid in self.tree.get_children(""):
|
|
self.tree.item(iid, open=True)
|
|
if f"{iid}::lazy" in self.tree.get_children(iid):
|
|
self.tree.delete(f"{iid}::lazy")
|
|
corsia = iid.split(":", 1)[1]
|
|
self._load_celle_for_corsia(iid, corsia)
|
|
|
|
def collapse_all(self):
|
|
"""Collapse all root nodes in the duplication tree."""
|
|
for iid in self.tree.get_children(""):
|
|
self.tree.item(iid, open=False)
|
|
|
|
@_log_call()
|
|
def export_to_xlsx(self):
|
|
"""Export both the detailed tree and the summary table to Excel."""
|
|
ts = datetime.now().strftime("%d_%m_%Y_%H-%M")
|
|
default_name = f"esportazione_celle_udc_multiple_{ts}.xlsx"
|
|
fname = filedialog.asksaveasfilename(
|
|
parent=self,
|
|
title="Esporta in Excel",
|
|
defaultextension=".xlsx",
|
|
filetypes=[("Excel Workbook", "*.xlsx")],
|
|
initialfile=default_name,
|
|
)
|
|
if not fname:
|
|
return
|
|
try:
|
|
wb = Workbook()
|
|
ws_det = wb.active
|
|
ws_det.title = "Dettaglio"
|
|
ws_sum = wb.create_sheet("Riepilogo")
|
|
det_headers = ["Corsia", "Ubicazione", "IDCella", "Pallet", "Descrizione", "Lotto", "Causale"]
|
|
sum_headers = ["Corsia", "TotCelle", "CelleMultiple", "Percentuale"]
|
|
|
|
def _hdr(ws, headers):
|
|
"""Write formatted headers into the given worksheet."""
|
|
for j, header in enumerate(headers, start=1):
|
|
cell = ws.cell(row=1, column=j, value=header)
|
|
cell.font = Font(bold=True)
|
|
cell.alignment = Alignment(horizontal="center", vertical="center")
|
|
|
|
_hdr(ws_det, det_headers)
|
|
_hdr(ws_sum, sum_headers)
|
|
|
|
row_idx = 2
|
|
for corsia_node in self.tree.get_children(""):
|
|
for cella_node in self.tree.get_children(corsia_node):
|
|
for pallet_node in self.tree.get_children(cella_node):
|
|
tags = self.tree.item(pallet_node, "tags") or ()
|
|
if "pallet" not in tags:
|
|
continue
|
|
meta = self.udc_meta_by_key.get(pallet_node, {})
|
|
corsia = meta.get("corsia") or next((tag.split(":", 1)[1] for tag in tags if tag.startswith("corsia:")), "")
|
|
ubi = meta.get("ubicazione") or next((tag.split(":", 1)[1] for tag in tags if tag.startswith("ubicazione:")), "")
|
|
idcella = meta.get("idcella") or next((tag.split(":", 1)[1] for tag in tags if tag.startswith("idcella:")), "")
|
|
pallet = meta.get("pallet") or self.tree.item(pallet_node, "text")
|
|
desc, lotto, causale = self.tree.item(pallet_node, "values")
|
|
for j, value in enumerate([corsia, ubi, idcella, pallet, desc, lotto, causale], start=1):
|
|
ws_det.cell(row=row_idx, column=j, value=value)
|
|
row_idx += 1
|
|
|
|
row_idx = 2
|
|
for iid in self.sum_tbl.get_children(""):
|
|
vals = self.sum_tbl.item(iid, "values")
|
|
for j, value in enumerate(vals, start=1):
|
|
ws_sum.cell(row=row_idx, column=j, value=value)
|
|
row_idx += 1
|
|
|
|
def _autosize(ws):
|
|
"""Resize worksheet columns based on their longest value."""
|
|
widths = {}
|
|
for row in ws.iter_rows(values_only=True):
|
|
for j, value in enumerate(row, start=1):
|
|
value_s = "" if value is None else str(value)
|
|
widths[j] = max(widths.get(j, 0), len(value_s))
|
|
from openpyxl.utils import get_column_letter
|
|
|
|
for j, width in widths.items():
|
|
ws.column_dimensions[get_column_letter(j)].width = min(max(width + 2, 10), 60)
|
|
|
|
_autosize(ws_det)
|
|
_autosize(ws_sum)
|
|
wb.save(fname)
|
|
messagebox.showinfo("Esportazione completata", f"File creato:\n{fname}", parent=self)
|
|
except Exception as ex:
|
|
_MODULE_LOGGER.exception(f"Errore esportazione UDC fantasma: {ex}")
|
|
messagebox.showerror("Errore esportazione", str(ex), parent=self)
|
|
|
|
|
|
def open_celle_multiple_window(
|
|
root: tk.Tk,
|
|
db_client,
|
|
runner: AsyncRunner | None = None,
|
|
session=None,
|
|
):
|
|
"""Create, focus and return the duplicated-cells explorer."""
|
|
key = "_celle_multiple_window_singleton"
|
|
ex = getattr(root, key, None)
|
|
if ex and ex.winfo_exists():
|
|
try:
|
|
ex.lift()
|
|
ex.focus_force()
|
|
return ex
|
|
except Exception:
|
|
pass
|
|
win = CelleMultipleWindow(root, db_client, runner=runner, session=session)
|
|
setattr(root, key, win)
|
|
place_window_fullsize_below_parent_later(root, win)
|
|
try:
|
|
win.lift()
|
|
win.focus_force()
|
|
except Exception:
|
|
pass
|
|
return win
|