Rafforza controlli carico barcode

barcode_client.py

@@ -48,6 +48,7 @@ def _build_bypass_session():
 class BarcodeClientApp:
     """Single-window Tk barcode client modeled after the C# legacy form."""
 
+    PALLET_BARCODE_LENGTH = 6
     NON_SCAFFALATA_BARCODE = "9001000"
     SHIPPED_BARCODE = "9000000"
     BARCODE_MAX_WIDTH = 320
@@ -65,6 +66,8 @@ class BarcodeClientApp:
         self.service = BarcodeService(self.repository, session.operator_id)
         self._pending: Future | None = None
         self._auto_advance_id: str | None = None
+        self._pallet_auto_focus_id: str | None = None
+        self._paused_queue_id: int | None = None
         self._status_colors = {
             "red": "#f4cccc",
             "green": "#d9ead3",
@@ -196,7 +199,7 @@ class BarcodeClientApp:
 
         self.btn_f1 = ttk.Button(buttons, text="[F1] H Priority", command=lambda: self._start_queue(1))
         self.btn_f1.grid(row=0, column=0, padx=(0, 4), pady=(0, button_pad_y), sticky="ew")
-        self.btn_submit = ttk.Button(buttons, text="[Ent] Carica", command=self._submit)
+        self.btn_submit = ttk.Button(buttons, text="[F3] Carica", command=self._on_f3)
         self.btn_submit.grid(row=0, column=1, padx=(4, 0), pady=(0, button_pad_y), sticky="ew")
         self.btn_f2 = ttk.Button(buttons, text="[F2] L Priority", command=lambda: self._start_queue(0))
         self.btn_f2.grid(row=1, column=0, padx=(0, 4), sticky="ew")
@@ -234,7 +237,7 @@ class BarcodeClientApp:
         parent.columnconfigure(1, weight=1)
         if scanned:
             self.pallet_entry = entry
-            self.scanned_var.trace_add("write", lambda *_: self._limit_var(self.scanned_var, 8))
+            self.scanned_var.trace_add("write", lambda *_: self._on_scanned_var_changed())
         else:
             self.destination_entry = entry
             self.destination_var.trace_add("write", lambda *_: self._limit_var(self.destination_var, 8))
@@ -244,6 +247,32 @@ class BarcodeClientApp:
         if len(value) > max_len:
             variable.set(value[:max_len])
 
+    def _on_scanned_var_changed(self) -> None:
+        self._limit_var(self.scanned_var, 8)
+        if self._pallet_auto_focus_id is not None:
+            try:
+                self.root.after_cancel(self._pallet_auto_focus_id)
+            except Exception:
+                pass
+            self._pallet_auto_focus_id = None
+        pallet = str(self.scanned_var.get() or "").strip()
+        if len(pallet) < self.PALLET_BARCODE_LENGTH:
+            return
+        self._pallet_auto_focus_id = self.root.after(80, self._auto_focus_destination_after_scan)
+
+    def _auto_focus_destination_after_scan(self) -> None:
+        self._pallet_auto_focus_id = None
+        pallet = str(self.scanned_var.get() or "").strip()
+        if not pallet:
+            return
+        if self._pending is not None and not self._pending.done():
+            return
+        if getattr(self.service.state, "mode", "") == "confirm":
+            return
+        if bool(getattr(self.service.state, "destination_readonly", False)):
+            return
+        self._focus_destination_input()
+
     def _apply_responsive_geometry(self) -> None:
         """Adapt the window size to barcode-sized or desktop-sized screens."""
 
@@ -296,7 +325,9 @@ class BarcodeClientApp:
     def _bind_keys(self) -> None:
         self.root.bind("<F1>", lambda _e: self._start_queue(1))
         self.root.bind("<F2>", lambda _e: self._start_queue(0))
+        self.root.bind("<F3>", self._on_f3_key)
         self.root.bind("<F4>", self._on_unload_key)
+        self.root.bind("<Escape>", self._on_escape_key)
         self.pallet_entry.bind("<Return>", self._on_pallet_enter)
         self.destination_entry.bind("<Return>", self._on_destination_enter)
 
@@ -324,6 +355,9 @@ class BarcodeClientApp:
             self.busy_bar.stop()
             self.busy_cover.place_forget()
 
+    def _is_priority_pause(self) -> bool:
+        return str(self.queue_var.get() or "") == "Pausa PL"
+
     def _apply_state(self, state: BarcodeViewState) -> None:
         if self._auto_advance_id is not None:
             try:
@@ -331,15 +365,35 @@ class BarcodeClientApp:
             except Exception:
                 pass
             self._auto_advance_id = None
+        if self._pallet_auto_focus_id is not None:
+            try:
+                self.root.after_cancel(self._pallet_auto_focus_id)
+            except Exception:
+                pass
+            self._pallet_auto_focus_id = None
         self.queue_var.set(state.queue_label)
         self.destination_var.set(state.destination_barcode)
         self.scanned_var.set(state.scanned_pallet)
-        self.info1_var.set(state.status_text)
+        self.info1_var.set(self._status_text_with_wait_hint(state))
         self.info2_var.set(state.document)
         self.info3_var.set(state.customer)
         self.info4_var.set(state.expected_pallet)
         self.status_band.configure(bg=state.status_color or self._status_colors["red"])
 
+        try:
+            if str(state.queue_label or "") != "Pausa PL":
+                self._paused_queue_id = None
+            resumable_queue = self._resumable_queue_from_state(state)
+            if state.mode in ("priority_high", "priority_low") or resumable_queue is not None:
+                self.btn_submit.configure(text="[F3] Pausa PL")
+            else:
+                self.btn_submit.configure(text="[F3] Carica")
+            queue_buttons_state = "disabled" if str(state.queue_label or "") == "Pausa PL" else "normal"
+            self.btn_f1.configure(state=queue_buttons_state)
+            self.btn_f2.configure(state=queue_buttons_state)
+        except Exception:
+            pass
+
         destination_readonly = bool(getattr(state, "destination_readonly", False))
         try:
             self.destination_entry.configure(state="normal")
@@ -348,20 +402,18 @@ class BarcodeClientApp:
         except Exception:
             pass
 
-        is_completed_move = (
-            str(state.status_text or "").startswith("Ok Scarico")
-            or str(state.status_text or "").startswith("Ok Carico")
-        )
-        if state.mode == "confirm" and is_completed_move:
-            next_queue = self._queue_id_from_label(state.queue_label)
-            delay_ms = int(getattr(state, "auto_advance_delay_ms", 0) or 0)
-            if next_queue is not None and delay_ms > 0:
+        if state.mode == "confirm":
+            next_queue = self._resumable_queue_from_state(state)
+            if next_queue is not None:
                 self._auto_advance_id = self.root.after(
-                    delay_ms,
+                    int(getattr(state, "auto_advance_delay_ms", 0) or 0),
                     lambda q=next_queue: self._start_queue(q),
                 )
 
-        self.root.after(20, self._focus_primary_input)
+        if bool(getattr(state, "focus_destination", False)):
+            self.root.after(20, self._focus_destination_input)
+        else:
+            self.root.after(20, self._focus_primary_input)
 
     def _focus_primary_input(self) -> None:
         try:
@@ -370,6 +422,17 @@ class BarcodeClientApp:
         except Exception:
             pass
 
+    def _status_text_with_wait_hint(self, state: BarcodeViewState) -> str:
+        text = str(getattr(state, "status_text", "") or "")
+        delay_ms = int(getattr(state, "auto_advance_delay_ms", 0) or 0)
+        if delay_ms <= 0:
+            return text
+        seconds = max(1, round(delay_ms / 1000))
+        hint = f"Attendi {seconds} secondi..."
+        if hint.lower() in text.lower():
+            return text
+        return f"{text} - {hint}" if text else hint
+
     def _focus_destination_input(self) -> None:
         try:
             self.destination_entry.configure(state="normal")
@@ -409,23 +472,53 @@ class BarcodeClientApp:
         self._begin_manual_unload()
         return "break"
 
+    def _on_escape_key(self, _event=None) -> str:
+        if self._is_priority_pause() and self._paused_queue_id is not None:
+            self._start_queue(self._paused_queue_id, allow_during_pause=True)
+        return "break"
+
+    def _on_f3_key(self, _event=None) -> str:
+        self._on_f3()
+        return "break"
+
+    def _on_f3(self) -> None:
+        mode = getattr(self.service.state, "mode", "")
+        if mode == "priority_high":
+            self._paused_queue_id = 1
+            self._apply_state(self.service.begin_priority_pause(1))
+            return
+        if mode == "priority_low":
+            self._paused_queue_id = 0
+            self._apply_state(self.service.begin_priority_pause(0))
+            return
+        resumable_queue = self._resumable_queue_from_state(self.service.state)
+        if resumable_queue is not None:
+            self._paused_queue_id = resumable_queue
+            self._apply_state(self.service.begin_priority_pause(resumable_queue))
+            return
+        self._submit()
+
     def _begin_manual_unload(self) -> None:
         pallet = str(self.scanned_var.get() or "").strip()
         destination = str(self.destination_var.get() or "").strip()
-        if pallet and destination in (self.NON_SCAFFALATA_BARCODE, self.SHIPPED_BARCODE):
+        mode = getattr(self.service.state, "mode", "")
+        if pallet and mode in ("priority_high", "priority_low") and destination == self.SHIPPED_BARCODE:
             # Legacy barcode flow: F4/Scarica confirms the prepared unload destination.
             self._submit()
             return
-        if pallet and not destination:
-            self.destination_var.set(self.NON_SCAFFALATA_BARCODE)
-            self._submit()
+        if pallet:
+            self._submit_unload_with_source_check()
+            return
+        if self._is_priority_pause():
             return
         self._apply_state(self.service.begin_manual_unload())
 
-    def _start_queue(self, id_stato: int) -> None:
+    def _start_queue(self, id_stato: int, *, allow_during_pause: bool = False) -> None:
+        if self._is_priority_pause() and not allow_during_pause:
+            return
         self._run_async(
             lambda: self.service.start_priority_queue(id_stato),
-            busy_message="Carico la coda selezionata...",
+            busy_message="In preparazione...",
         )
 
     def _submit(self) -> None:
@@ -434,7 +527,16 @@ class BarcodeClientApp:
                 scanned_pallet=self.scanned_var.get(),
                 destination_barcode=self.destination_var.get(),
             ),
-            busy_message="Eseguo il movimento...",
+            busy_message="In esecuzione...",
+        )
+
+    def _submit_unload_with_source_check(self) -> None:
+        self._run_async(
+            lambda: self.service.submit_unload_with_source_check(
+                scanned_pallet=self.scanned_var.get(),
+                source_barcode=self.destination_var.get(),
+            ),
+            busy_message="In esecuzione...",
         )
 
     def _run_async(self, coro_factory: Callable[[], object], busy_message: str) -> None:
@@ -458,6 +560,12 @@ class BarcodeClientApp:
             return 0
         return None
 
+    def _resumable_queue_from_state(self, state: BarcodeViewState) -> int | None:
+        delay_ms = int(getattr(state, "auto_advance_delay_ms", 0) or 0)
+        if delay_ms <= 0:
+            return None
+        return self._queue_id_from_label(str(getattr(state, "queue_label", "") or ""))
+
     def _poll_future(self) -> None:
         if self._pending is None:
             self._set_busy(False)

barcode_repository.py

@@ -72,6 +72,29 @@ LEFT JOIN dbo.Celle AS c
 WHERE g.BarcodePallet = :pallet;
 """
 
+SQL_OPEN_LOCATIONS_BY_PALLET = """
+SELECT
+    g.BarcodePallet,
+    g.IDCella,
+    RTRIM(c.Corsia) AS Corsia,
+    RTRIM(CAST(c.Colonna AS varchar(32))) AS Colonna,
+    RTRIM(CAST(c.Fila AS varchar(32))) AS Fila
+FROM dbo.XMag_GiacenzaPallet AS g
+LEFT JOIN dbo.Celle AS c
+  ON c.ID = g.IDCella
+WHERE g.BarcodePallet = :pallet
+ORDER BY g.IDCella;
+"""
+
+SQL_OPEN_PALLETS_BY_CELL = """
+SELECT
+    g.BarcodePallet,
+    g.IDCella
+FROM dbo.XMag_GiacenzaPallet AS g
+WHERE g.IDCella = :id_cella
+ORDER BY g.BarcodePallet;
+"""
+
 SQL_RESOLVE_PHYSICAL_CELL = """
 DECLARE @raw int = TRY_CONVERT(int, :destination);
 DECLARE @cell_id int =
@@ -184,6 +207,18 @@ class BarcodeRepository:
         rows = _rows_to_dicts(res)
         return rows[0] if rows else None
 
+    async def fetch_open_locations_by_pallet(self, pallet: str) -> list[dict[str, Any]]:
+        """Return all positive stock locations currently open for a pallet."""
+
+        res = await self.db_client.query_json(SQL_OPEN_LOCATIONS_BY_PALLET, {"pallet": str(pallet or "").strip()})
+        return _rows_to_dicts(res)
+
+    async def fetch_open_pallets_by_cell(self, id_cella: int) -> list[dict[str, Any]]:
+        """Return pallets currently present in a physical cell."""
+
+        res = await self.db_client.query_json(SQL_OPEN_PALLETS_BY_CELL, {"id_cella": int(id_cella)})
+        return _rows_to_dicts(res)
+
     async def resolve_physical_cell(self, destination: str) -> DestinationCell | None:
         """Accept either an internal cell ID or the scanned legacy cell barcode."""
 

barcode_service.py

@@ -6,7 +6,7 @@ from dataclasses import dataclass
 from typing import Literal
 
 from barcode_repository import BarcodeRepository, LegacyMoveResult
-from runtime_support import log_exception
+from runtime_support import log_exception, log_runtime_event
 from version_info import module_version
 
 __version__ = module_version(__name__)
@@ -30,6 +30,7 @@ class BarcodeViewState:
     scanned_pallet: str = ""
     auto_advance_delay_ms: int = 0
     destination_readonly: bool = False
+    focus_destination: bool = False
 
 
 @dataclass
@@ -58,7 +59,7 @@ class BarcodeService:
     def __init__(self, repository: BarcodeRepository, operator_id: int):
         self.repository = repository
         self.operator_id = int(operator_id)
-        self._current_priority_state = 0
+        self._current_priority_state = -1
         self._state = BarcodeViewState()
 
     @property
@@ -70,14 +71,14 @@ class BarcodeService:
     def reset(self) -> BarcodeViewState:
         """Return the client to its neutral state."""
 
-        self._current_priority_state = 0
+        self._current_priority_state = -1
         self._state = BarcodeViewState()
         return self._state
 
     def begin_manual_load(self) -> BarcodeViewState:
         """Prepare a real versamento into a physical warehouse cell."""
 
-        self._current_priority_state = 0
+        self._current_priority_state = -1
         self._state = BarcodeViewState(
             mode="manual_load",
             queue_label="Versamento",
@@ -89,7 +90,7 @@ class BarcodeService:
     def begin_manual_unload(self) -> BarcodeViewState:
         """Prepare a direct unload toward the conventional non-shelved cell."""
 
-        self._current_priority_state = 0
+        self._current_priority_state = -1
         self._state = BarcodeViewState(
             mode="manual_unload",
             queue_label="Prelievo diretto",
@@ -100,6 +101,20 @@ class BarcodeService:
         )
         return self._state
 
+    def begin_priority_pause(self, id_stato: int) -> BarcodeViewState:
+        """Pause the active picking queue locally for exactly one free movement."""
+
+        self._current_priority_state = int(id_stato)
+        self._state = BarcodeViewState(
+            mode="manual_unload",
+            queue_label="Pausa PL",
+            status_text="Premi ESC per uscire dalla pausa",
+            status_color=self.GRAY,
+            destination_barcode=self.NON_SCAFFALATA_BARCODE,
+            destination_readonly=False,
+        )
+        return self._state
+
     async def start_priority_queue(self, id_stato: int) -> BarcodeActionResult:
         """Load the next item of the selected legacy priority queue."""
 
@@ -107,6 +122,7 @@ class BarcodeService:
         self._current_priority_state = int(id_stato)
         queue_label = "Alta priorita' (F1)" if int(id_stato) == 1 else "Bassa priorita' (F2)"
         if not row:
+            self._current_priority_state = -1
             self._state = BarcodeViewState(
                 mode="manual_unload",
                 queue_label=queue_label,
@@ -161,24 +177,111 @@ class BarcodeService:
                 self._state.status_color = self.RED
                 return BarcodeActionResult(False, self._state, self._state.status_text)
 
-        current_location = await self.repository.fetch_current_location_by_pallet(pallet)
-        picking_before_move = await self.repository.fetch_picking_by_pallet(pallet)
-        if not current_location and not picking_before_move:
-            self._state.scanned_pallet = pallet
-            self._state.status_text = "UDC non presente a magazzino."
-            self._state.status_color = self.RED
-            return BarcodeActionResult(False, self._state, self._state.status_text)
-
         target_barcode = destination
         target_numero_cella = int(destination)
         target_id_cella = 9999 if destination == self.SHIPPED_BARCODE else (1000 if destination == self.NON_SCAFFALATA_BARCODE else None)
         target_display = destination
-        if destination not in (self.NON_SCAFFALATA_BARCODE, self.SHIPPED_BARCODE):
+        if is_direct_load:
+            resolved_cell = await self.repository.resolve_physical_cell(destination)
+            if not resolved_cell:
+                self._state.scanned_pallet = pallet
+                self._state.destination_barcode = destination
+                self._state.status_text = f"Cella non valida: {destination}."
+                self._state.status_color = self.RED
+                self._state.focus_destination = True
+                return BarcodeActionResult(False, self._state, self._state.status_text)
+
+            occupants = await self.repository.fetch_open_pallets_by_cell(resolved_cell.id_cella)
+            if occupants:
+                log_runtime_event(
+                    "Barcode WMS",
+                    (
+                        "MOVE BLOCKED DESTINATION_OCCUPIED "
+                        f"pallet={pallet} "
+                        f"cell={resolved_cell.id_cella} "
+                        f"occupants={','.join(str(row.get('BarcodePallet') or '') for row in occupants)}"
+                    ),
+                )
+                self._state.scanned_pallet = pallet
+                self._state.destination_barcode = destination
+                self._state.status_text = "Errore: cella scelta occupata, cambiare cella di destinazione."
+                self._state.status_color = self.RED
+                self._state.destination_readonly = False
+                self._state.focus_destination = True
+                return BarcodeActionResult(False, self._state, self._state.status_text)
+
+            target_barcode = resolved_cell.barcode_cella
+            target_numero_cella = resolved_cell.numero_cella
+            target_id_cella = resolved_cell.id_cella
+            target_display = resolved_cell.ubicazione or destination
+
+        current_location = await self.repository.fetch_current_location_by_pallet(pallet)
+        picking_before_move = await self.repository.fetch_picking_by_pallet(pallet)
+        if not current_location and not picking_before_move:
+            if is_direct_load:
+                trace_row = await self.repository.fetch_trace_by_pallet(pallet)
+                if not trace_row:
+                    self._state.scanned_pallet = pallet
+                    self._state.destination_barcode = destination
+                    self._state.status_text = "Errore: UDC non riconosciuta in ERP/SAM."
+                    self._state.status_color = self.RED
+                    return BarcodeActionResult(False, self._state, self._state.status_text)
+
+                log_runtime_event(
+                    "Barcode WMS",
+                    f"AUTO INTAKE NON_SHELVED pallet={pallet} before_cell={target_id_cella}",
+                )
+                await self.repository.execute_legacy_move(
+                    operator_id=self.operator_id,
+                    barcode_cella=self.NON_SCAFFALATA_BARCODE,
+                    barcode_pallet=pallet,
+                    numero_cella=int(self.NON_SCAFFALATA_BARCODE),
+                )
+                current_location = await self.repository.fetch_current_location_by_pallet(pallet)
+                try:
+                    current_id_cella = int((current_location or {}).get("IDCella") or 0)
+                except Exception:
+                    current_id_cella = 0
+                if current_id_cella != 1000:
+                    self._state.scanned_pallet = pallet
+                    self._state.destination_barcode = destination
+                    self._state.status_text = "Movimento non confermato: ingresso UDC non scaffalata non riuscito."
+                    self._state.status_color = self.RED
+                    return BarcodeActionResult(False, self._state, self._state.status_text)
+            else:
+                self._state.scanned_pallet = pallet
+                self._state.status_text = "UDC non presente a magazzino."
+                self._state.status_color = self.RED
+                return BarcodeActionResult(False, self._state, self._state.status_text)
+
+        open_locations = await self.repository.fetch_open_locations_by_pallet(pallet)
+        distinct_cells = sorted({
+            int(row.get("IDCella") or 0)
+            for row in open_locations
+            if row.get("IDCella") is not None
+        })
+        if len(distinct_cells) > 1:
+            log_runtime_event(
+                "Barcode WMS",
+                (
+                    "MOVE BLOCKED MULTI_LOCATION "
+                    f"pallet={pallet} "
+                    f"cells={','.join(str(cell) for cell in distinct_cells)}"
+                ),
+            )
+            self._state.scanned_pallet = pallet
+            self._state.destination_barcode = destination
+            self._state.status_text = "UDC presente in piu' celle. Movimento bloccato."
+            self._state.status_color = self.RED
+            return BarcodeActionResult(False, self._state, self._state.status_text)
+
+        if not is_direct_load and destination not in (self.NON_SCAFFALATA_BARCODE, self.SHIPPED_BARCODE):
             resolved_cell = await self.repository.resolve_physical_cell(destination)
             if not resolved_cell:
                 self._state.scanned_pallet = pallet
                 self._state.status_text = f"Cella non valida: {destination}."
                 self._state.status_color = self.RED
+                self._state.focus_destination = True
                 return BarcodeActionResult(False, self._state, self._state.status_text)
             target_barcode = resolved_cell.barcode_cella
             target_numero_cella = resolved_cell.numero_cella
@@ -210,7 +313,7 @@ class BarcodeService:
                 destination_barcode=destination,
                 destination_display=target_display,
                 last_priority_state=self._current_priority_state,
-                auto_advance_delay_ms=5000 if (is_direct_unload or is_direct_load) else 1200 if is_picking_unload else 0,
+                auto_advance_delay_ms=5000 if (is_direct_unload or is_direct_load) else 3000 if is_picking_unload else 0,
             )
         except Exception as exc:
             log_exception("Barcode WMS", exc, context=f"post move state pallet={pallet} destination={destination}")
@@ -224,6 +327,92 @@ class BarcodeService:
             )
         return BarcodeActionResult(True, self._state, self._state.status_text)
 
+    async def submit_unload_with_source_check(self, *, scanned_pallet: str, source_barcode: str) -> BarcodeActionResult:
+        """Unload to the non-shelved cell only if the scanned source cell matches DB."""
+
+        pallet = str(scanned_pallet or "").strip()
+        source = str(source_barcode or "").strip()
+        if not pallet:
+            return BarcodeActionResult(False, self._state, "Inserisci o leggi il pallet.")
+        if not source:
+            return BarcodeActionResult(False, self._state, "Leggi il codice della cella da scaricare.")
+        if not source.isdigit():
+            return BarcodeActionResult(False, self._state, "La cella da scaricare deve essere numerica.")
+
+        current_location = await self.repository.fetch_current_location_by_pallet(pallet)
+        if not current_location:
+            self._state.scanned_pallet = pallet
+            self._state.status_text = "UDC non presente a magazzino."
+            self._state.status_color = self.RED
+            return BarcodeActionResult(False, self._state, self._state.status_text)
+
+        open_locations = await self.repository.fetch_open_locations_by_pallet(pallet)
+        distinct_cells = sorted({
+            int(row.get("IDCella") or 0)
+            for row in open_locations
+            if row.get("IDCella") is not None
+        })
+        if len(distinct_cells) > 1:
+            log_runtime_event(
+                "Barcode WMS",
+                (
+                    "MOVE BLOCKED MULTI_LOCATION "
+                    f"pallet={pallet} "
+                    f"cells={','.join(str(cell) for cell in distinct_cells)}"
+                ),
+            )
+            self._state.scanned_pallet = pallet
+            self._state.destination_barcode = source
+            self._state.status_text = "UDC presente in piu' celle. Movimento bloccato."
+            self._state.status_color = self.RED
+            return BarcodeActionResult(False, self._state, self._state.status_text)
+
+        if source == self.NON_SCAFFALATA_BARCODE:
+            source_id_cella = 1000
+        else:
+            resolved_source = await self.repository.resolve_physical_cell(source)
+            if not resolved_source:
+                self._state.scanned_pallet = pallet
+                self._state.destination_barcode = source
+                self._state.status_text = f"Cella non valida: {source}."
+                self._state.status_color = self.RED
+                return BarcodeActionResult(False, self._state, self._state.status_text)
+            source_id_cella = int(resolved_source.id_cella)
+
+        current_id_cella = int((current_location or {}).get("IDCella") or 0)
+        if current_id_cella != source_id_cella:
+            if source == self.NON_SCAFFALATA_BARCODE and current_id_cella != 1000:
+                log_runtime_event(
+                    "Barcode WMS",
+                    (
+                        "MOVE BLOCKED SOURCE_REQUIRED "
+                        f"pallet={pallet} "
+                        f"db_cell={current_id_cella} "
+                        f"default_cell={source_id_cella}"
+                    ),
+                )
+                self._state.scanned_pallet = pallet
+                self._state.destination_barcode = source
+                self._state.status_text = "Errore: leggi la cella da scaricare."
+                self._state.status_color = self.RED
+                return BarcodeActionResult(False, self._state, self._state.status_text)
+            log_runtime_event(
+                "Barcode WMS",
+                (
+                    "MOVE BLOCKED SOURCE_MISMATCH "
+                    f"pallet={pallet} "
+                    f"db_cell={current_id_cella} "
+                    f"scanned_cell={source_id_cella}"
+                ),
+            )
+            self._state.scanned_pallet = pallet
+            self._state.destination_barcode = source
+            self._state.status_text = "Errore: UDC in cella diversa, rileggi il codice della cella da scaricare."
+            self._state.status_color = self.RED
+            return BarcodeActionResult(False, self._state, self._state.status_text)
+
+        return await self.submit(scanned_pallet=pallet, destination_barcode=self.NON_SCAFFALATA_BARCODE)
+
     async def _build_post_move_state(
         self,
         *,

comandi_git_per_installare.txt

@@ -0,0 +1,256 @@
+# Prontuario Git per installare/aggiornare Warehouse da remoto
+
+Repository Gitea:
+
+    https://gitea.alessandrobonvicini.it/administrator/ware_house.git
+
+Cartella consigliata sul PC di produzione:
+
+    C:\flywms
+
+Ramo principale da usare in produzione:
+
+    main
+
+Ultimo tag stabile al momento della stesura:
+
+    alpha7-stabilizzazione-non-scaffalate
+
+
+1. Prima installazione su PC nuovo
+----------------------------------
+
+Aprire PowerShell nella macchina di produzione ed eseguire:
+
+    cd C:\
+    git clone https://gitea.alessandrobonvicini.it/administrator/ware_house.git C:\flywms
+    cd C:\flywms
+    git switch main
+    git pull origin main
+
+Installare le dipendenze Python:
+
+    python -m pip install --upgrade pip
+    python -m pip install -r requirements.txt
+
+Avvio applicazione desktop:
+
+    python main.py
+
+Oppure senza finestra console:
+
+    pythonw warehouse.pyw
+
+Avvio applicazione barcode:
+
+    python barcode_client.py
+
+Oppure senza finestra console:
+
+    pythonw barcode.pyw
+
+
+2. Aggiornare un'installazione gia' esistente
+--------------------------------------------
+
+Sul PC di produzione:
+
+    cd C:\flywms
+    git fetch --all --tags
+    git switch main
+    git pull origin main
+    python -m pip install -r requirements.txt
+
+Poi rilanciare l'applicazione.
+
+
+2.bis Aggiornare produzione dopo merge su main gia' fatto
+---------------------------------------------------------
+
+Questo e' il caso piu' normale:
+
+    - sul PC di sviluppo hai gia' fatto merge del ramo di lavoro dentro main;
+    - hai gia' fatto push su Gitea;
+    - sul PC di produzione devi solo scaricare l'ultima versione ufficiale.
+
+Sul PC di produzione eseguire:
+
+    cd C:\flywms
+    git fetch --all --tags
+    git switch main
+    git pull origin main
+    python -m pip install -r requirements.txt
+
+Poi chiudere e riaprire l'applicazione.
+
+Controllo consigliato dopo l'aggiornamento:
+
+    git log --oneline --decorate -3
+    git describe --tags --abbrev=0 main
+
+
+3. Controllare che versione/tag si sta usando
+---------------------------------------------
+
+Dentro C:\flywms:
+
+    git status
+    git log --oneline --decorate -5
+
+Vedere l'ultimo tag raggiungibile da main:
+
+    git describe --tags --abbrev=0 main
+
+Vedere tutti i tag, dal piu' recente:
+
+    git tag --sort=-creatordate
+
+Vedere graficamente branch, commit e tag:
+
+    git log --oneline --decorate --graph --all -20
+
+
+4. Installare esattamente una versione taggata
+---------------------------------------------
+
+Usare questa modalita' quando si vuole installare una fotografia precisa e non
+necessariamente l'ultima versione di main.
+
+Esempio:
+
+    cd C:\
+    git clone --branch alpha7-stabilizzazione-non-scaffalate https://gitea.alessandrobonvicini.it/administrator/ware_house.git C:\flywms_alpha7
+
+Nota:
+
+    Un tag e' una fotografia ferma. Non avanza con git pull come un branch.
+    Per produzione ordinaria e' piu' comodo usare main.
+
+
+5. Portare l'ultimo sviluppo dentro main
+---------------------------------------
+
+Da fare sulla macchina di sviluppo, non sul PC di produzione.
+
+Se l'ultima versione buona e' su sviluppo3 e vuoi renderla ufficiale su main:
+
+    cd C:\devel\python\ware_house
+    git fetch --all --tags
+    git status
+    git switch main
+    git pull origin main
+    git merge sviluppo3
+    git push origin main
+
+Se vuoi anche creare un tag stabile:
+
+    git tag nome-del-tag
+    git push origin nome-del-tag
+
+Esempio:
+
+    git tag alpha8-nome-breve-della-modifica
+    git push origin alpha8-nome-breve-della-modifica
+
+
+6. Se il PC di produzione ha modifiche locali
+---------------------------------------------
+
+Prima di aggiornare controllare:
+
+    cd C:\flywms
+    git status
+
+Se compaiono file modificati che non devono essere conservati, NON fare comandi
+distruttivi senza sapere cosa sono. Prima copiare o rinominare i file modificati.
+
+File che normalmente NON devono essere messi nel repository:
+
+    db_connection.json
+    *.log
+    __pycache__
+    *.pyc
+    *.zip
+
+
+7. Script SQL
+-------------
+
+Gli script SQL sono nel repository e vanno lanciati in SSMS solo quando serve
+preparare o aggiornare il database per le funzioni Python.
+
+Patch principali:
+
+    apply_python_parallel_pickinglist_patch.sql
+    apply_python_pickinglist_history_views.sql
+    apply_online_history_forms_patch.sql
+
+Rollback principali:
+
+    rollback_python_parallel_pickinglist_patch.sql
+    rollback_python_pickinglist_history_views.sql
+    rollback_online_history_forms_patch.sql
+
+Nota:
+
+    Prima di lanciare patch SQL in produzione, fare sempre backup o snapshot del
+    database, oppure verificare di avere una procedura di rollback sicura.
+
+
+8. Comando rapido piu' usato
+----------------------------
+
+Aggiornamento standard del PC di produzione:
+
+    cd C:\flywms
+    git fetch --all --tags
+    git switch main
+    git pull origin main
+    python -m pip install -r requirements.txt
+	
+
+9. Per vedere cosa ho installato
+------------------------------------------------------
+	git log --oneline --decorate -3
+	git describe --tags --abbrev=0 main
+
+
+10. Salvare questo prontuario su Gitea
+-------------------------------------
+
+Da fare sul PC di sviluppo, dentro la cartella del repository:
+
+    cd C:\devel\python\ware_house
+    git status
+    git add comandi_git_per_installare.txt
+    git commit -m "Aggiungi prontuario Git per installazione remota"
+    git push origin main
+
+Dopo il push, il file sara' disponibile anche sui PC di produzione al prossimo:
+
+    cd C:\flywms
+    git pull origin main
+
+
+11. Aggiornare il prontuario se lo modifico in locale
+----------------------------------------------------
+
+Se modifichi questo file sul PC di sviluppo e vuoi sincronizzarlo su Gitea:
+
+    cd C:\devel\python\ware_house
+    git status
+    git diff -- comandi_git_per_installare.txt
+    git add comandi_git_per_installare.txt
+    git commit -m "Aggiorna prontuario Git installazione"
+    git push origin main
+
+Se invece lo hai modificato su un PC di produzione e vuoi prima recuperare
+eventuali aggiornamenti online:
+
+    cd C:\flywms
+    git status
+    git pull origin main
+
+Se Git segnala conflitti, fermarsi e risolverli prima di rilanciare
+l'applicazione. Per evitare confusione, e' meglio modificare questo prontuario
+solo sul PC di sviluppo e poi fare push su Gitea.

gestione_aree.py

@@ -19,6 +19,7 @@ from typing import Any, Callable, Optional
 import customtkinter as ctk
 
 from async_loop_singleton import get_global_loop
+from runtime_support import log_exception
 from version_info import module_version
 
 __version__ = module_version(__name__)
@@ -128,21 +129,53 @@ class AsyncRunner:
             busy.show(message)
         fut = asyncio.run_coroutine_threadsafe(awaitable, self.loop)
 
+        def _widget_alive() -> bool:
+            try:
+                return bool(self.widget.winfo_exists())
+            except tk.TclError:
+                return False
+
+        def _dispatch_success(res: Any) -> None:
+            try:
+                on_success(res)
+            except BaseException as ex:
+                log_exception(__name__, ex, context="AsyncRunner on_success")
+
+        def _dispatch_error(ex: BaseException) -> None:
+            if on_error:
+                try:
+                    on_error(ex)
+                except BaseException as callback_ex:
+                    log_exception(__name__, callback_ex, context="AsyncRunner on_error")
+            else:
+                log_exception(__name__, ex, context="AsyncRunner unhandled error")
+
         def _poll():
+            if not _widget_alive():
+                return
             if fut.done():
                 if busy:
-                    busy.hide()
+                    try:
+                        busy.hide()
+                    except Exception as ex:
+                        log_exception(__name__, ex, context="AsyncRunner hide busy")
                 try:
                     res = fut.result()
                 except BaseException as ex:
-                    if on_error:
-                        self.widget.after(0, lambda e=ex: on_error(e))
-                    else:
-                        print("[AsyncRunner] Unhandled error:", repr(ex))
+                    try:
+                        self.widget.after(0, lambda e=ex: _dispatch_error(e))
+                    except tk.TclError:
+                        log_exception(__name__, ex, context="AsyncRunner error after destroyed")
                 else:
-                    self.widget.after(0, lambda r=res: on_success(r))
+                    try:
+                        self.widget.after(0, lambda r=res: _dispatch_success(r))
+                    except tk.TclError as ex:
+                        log_exception(__name__, ex, context="AsyncRunner success after destroyed")
             else:
-                self.widget.after(60, _poll)
+                try:
+                    self.widget.after(60, _poll)
+                except tk.TclError:
+                    return
 
         _poll()
 

udc_non_scaffalate.py

@@ -11,6 +11,7 @@ import customtkinter as ctk
 from busy_overlay import InlineBusyOverlay
 from gestione_aree import AsyncRunner
 from locale_text import load_locale_catalog, text as loc_text
+from runtime_support import log_exception
 from ui_tables import style_treeview, zebra_tag
 from ui_theme import theme_color, theme_font, theme_section, theme_value
 from version_info import module_version, versioned_title
@@ -20,7 +21,7 @@ __version__ = module_version(__name__)
 
 
 SQL_NON_SCAFFALATE = """
-WITH trace AS (
+WITH trace_rows AS (
     SELECT
         Pallet,
         MIN(Lotto) AS Lotto,
@@ -39,7 +40,7 @@ SELECT
 FROM dbo.XMag_GiacenzaPallet AS g
 LEFT JOIN dbo.Celle AS c
   ON c.ID = g.IDCella
-LEFT JOIN trace AS t
+LEFT JOIN trace_rows AS t
   ON t.Pallet COLLATE Latin1_General_CI_AS =
      g.BarcodePallet COLLATE Latin1_General_CI_AS
 WHERE g.IDCella = 1000
@@ -72,6 +73,7 @@ class UDCNonScaffalateWindow(ctk.CTkToplevel):
         self._locale_catalog = load_locale_catalog()
         self._async = AsyncRunner(self)
         self._busy = InlineBusyOverlay(self, self._theme)
+        self._load_in_progress = False
 
         self.title(versioned_title(loc_text("non_shelved.title", catalog=self._locale_catalog, default="UDC non scaffalate"), __name__))
         self.geometry(str(theme_value(self._theme, "window_geometry", "1000x650")))
@@ -85,6 +87,18 @@ class UDCNonScaffalateWindow(ctk.CTkToplevel):
         self._build_ui()
         self.after(250, self._load)
 
+    def _is_alive(self) -> bool:
+        try:
+            return bool(self.winfo_exists())
+        except tk.TclError:
+            return False
+
+    def _hide_busy_safe(self) -> None:
+        try:
+            self._busy.hide()
+        except Exception as exc:
+            log_exception(__name__, exc, context="hide busy UDC non scaffalate")
+
     def _build_ui(self) -> None:
         self.grid_rowconfigure(1, weight=1)
         self.grid_columnconfigure(0, weight=1)
@@ -145,33 +159,62 @@ class UDCNonScaffalateWindow(ctk.CTkToplevel):
         sx.grid(row=1, column=0, sticky="ew")
 
     def _load(self) -> None:
+        if self._load_in_progress or not self._is_alive():
+            return
+
         async def job():
             return await self.db_client.query_json(SQL_NON_SCAFFALATE, as_dict_rows=True)
 
-        self._busy.show(loc_text("non_shelved.busy", catalog=self._locale_catalog, default="Carico UDC non scaffalate..."))
-        self._async.run(job(), self._on_loaded, self._on_error)
+        self._load_in_progress = True
+        try:
+            self._busy.show(loc_text("non_shelved.busy", catalog=self._locale_catalog, default="Carico UDC non scaffalate..."))
+            self._async.run(job(), self._on_loaded, self._on_error)
+        except Exception as exc:
+            self._load_in_progress = False
+            self._hide_busy_safe()
+            log_exception(__name__, exc, context="avvio caricamento UDC non scaffalate")
+            messagebox.showerror(
+                loc_text("non_shelved.title", catalog=self._locale_catalog, default="UDC non scaffalate"),
+                str(exc),
+                parent=self if self._is_alive() else None,
+            )
 
     def _on_loaded(self, res: dict[str, Any] | None) -> None:
-        self._busy.hide()
-        rows = _rows_to_dicts(res)
-        self.tree.delete(*self.tree.get_children(""))
-        for index, row in enumerate(rows):
-            self.tree.insert(
-                "",
-                "end",
-                values=(
-                    row.get("UDC") or "",
-                    row.get("IDCella") or "",
-                    row.get("Ubicazione") or "",
-                    row.get("Lotto") or "",
-                    row.get("Prodotto") or "",
-                    row.get("Descrizione") or "",
-                ),
-                tags=(zebra_tag(index),),
+        self._load_in_progress = False
+        self._hide_busy_safe()
+        if not self._is_alive():
+            return
+        try:
+            rows = _rows_to_dicts(res)
+            self.tree.delete(*self.tree.get_children(""))
+            for index, row in enumerate(rows):
+                self.tree.insert(
+                    "",
+                    "end",
+                    values=(
+                        row.get("UDC") or "",
+                        row.get("IDCella") or "",
+                        row.get("Ubicazione") or "",
+                        row.get("Lotto") or "",
+                        row.get("Prodotto") or "",
+                        row.get("Descrizione") or "",
+                    ),
+                    tags=(zebra_tag(index),),
+                )
+        except Exception as exc:
+            log_exception(__name__, exc, context="render UDC non scaffalate")
+            messagebox.showerror(
+                loc_text("non_shelved.title", catalog=self._locale_catalog, default="UDC non scaffalate"),
+                str(exc),
+                parent=self,
             )
 
     def _on_error(self, exc: BaseException) -> None:
-        self._busy.hide()
+        self._load_in_progress = False
+        self._hide_busy_safe()
+        log_exception(__name__, exc, context="query UDC non scaffalate")
+        if not self._is_alive():
+            return
         messagebox.showerror(
             loc_text("non_shelved.title", catalog=self._locale_catalog, default="UDC non scaffalate"),
             str(exc),
@@ -183,5 +226,5 @@ def open_udc_non_scaffalate_window(parent: tk.Misc, db_client, session=None) ->
     """Open the non-shelved UDC window."""
 
     win = UDCNonScaffalateWindow(parent, db_client, session=session)
-    place_window_fullsize_below_parent_later(win, parent)
+    place_window_fullsize_below_parent_later(parent, win)
     return win

version_info.py

@@ -13,12 +13,12 @@ MODULE_VERSIONS: dict[str, str] = {
     "async_msssql_query": "1.0.0",
     "audit_log": "1.0.0",
     "main": "1.0.1",
-    "barcode_client": "1.0.10",
-    "barcode_repository": "1.0.3",
-    "barcode_service": "1.0.7",
+    "barcode_client": "1.0.18",
+    "barcode_repository": "1.0.5",
+    "barcode_service": "1.0.14",
     "busy_overlay": "1.0.0",
     "db_config": "1.0.0",
-    "gestione_aree": "1.0.0",
+    "gestione_aree": "1.0.1",
     "gestione_layout": "1.0.0",
     "gestione_pickinglist": "1.0.2",
     "gestione_scarico": "1.0.0",
@@ -31,7 +31,7 @@ MODULE_VERSIONS: dict[str, str] = {
     "storico_pickinglist": "1.0.3",
     "storico_udc": "1.0.0",
     "tooltips": "1.0.0",
-    "udc_non_scaffalate": "1.0.0",
+    "udc_non_scaffalate": "1.0.1",
     "ui_theme": "1.0.0",
     "user_session": "1.0.0",
     "view_celle_multi_udc": "1.0.0",