feat: remove scan cancel option, fetch deleted scan documents carefully, refactor interrupters

Fixes #56

Author: danillatency

src/bot/api.py

@@ -148,12 +148,14 @@ async def cancel_manual_scan(self, telegram_id: int, scanner: Scanner, job_id: s
 
     async def wait_and_merge_manual_scan(
         self, telegram_id: int, scanner: Scanner, job_id: str, prev_filename: str | None
-    ) -> ScanningResult:
+    ) -> ScanningResult | None:
         params = {"scanner_name": scanner.name, "job_id": job_id}
         if prev_filename:
             params["prev_filename"] = prev_filename
         async with self._create_client(telegram_id, 60 * 5) as client:
             response = await client.post("/scan/manual/wait_and_merge", params=params)
+            if response.status_code == 404:
+                return None
             response.raise_for_status()
             return ScanningResult.model_validate(response.json())
 

src/bot/routers/printing/printing.py

@@ -213,6 +213,9 @@ async def start_print_handler(callback: CallbackQuery, state: FSMContext, bot: B
 
     while time.monotonic() - start_time < max_wait_time:
         iteration += 1
+
+        # Return if the job was changed (user sent a new document or /scan)
+        await ensure_same_structural_message(callback.message, "confirmation_message_id", state)
         # Exit if state changed (user clicked cancel)
         if (await state.get_state()) == default_state:
             break

src/bot/routers/printing/printing_states.py

@@ -7,7 +7,12 @@
 
 from src.bot.api import api_client
 from src.bot.logging_ import logger
-from src.bot.routers.printing.printing_tools import discard_job_settings_message, format_printing_message
+from src.bot.routers.printing.printing_tools import (
+    discard_job_settings_message,
+    format_configure_message,
+    format_printing_message,
+)
+from src.bot.routers.tools import edit_message_text_anyway
 
 
 class PrintWork(StatesGroup):
@@ -39,14 +44,15 @@ async def gracefully_interrupt_printing_state(
     ):
         await discard_job_settings_message(data, message, state, bot)
         if "confirmation_message_id" in data:
-            try:
-                await bot.edit_message_caption(
-                    caption=f"{html.bold("You've cancelled this print work 🤷‍♀️")}",
-                    chat_id=message.chat.id,
-                    message_id=data["confirmation_message_id"],
-                )
-            except TelegramBadRequest:
-                pass
+            printer_status = await api_client.get_printer_status(message.chat.id, data["printer"])
+            text, _ = format_configure_message(data, printer_status)
+            await edit_message_text_anyway(
+                data["confirmation_message_id"],
+                f"{text}\n{html.italic('This job has expired 🕒')}",
+                None,
+                message.chat.id,
+                bot,
+            )
         if "filename" in data:
             try:
                 await api_client.cancel_not_started_job(message.chat.id, data["filename"])

src/bot/routers/scanning/scanning.py

@@ -5,6 +5,7 @@
 import httpx
 from aiogram import Bot, F, Router, flags
 from aiogram.enums import ChatAction
+from aiogram.exceptions import TelegramBadRequest
 from aiogram.filters import Command, StateFilter
 from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import default_state
@@ -27,13 +28,17 @@
 from src.bot.routers.scanning.scanning_states import ScanWork, gracefully_interrupt_scanning_state
 from src.bot.routers.scanning.scanning_tools import (
     ScanConfigureCallback,
-    ScanningCallback,
     ScanningPausedCallback,
     format_configure_message,
     format_scanning_message,
     format_scanning_paused_message,
 )
-from src.bot.routers.tools import cancel_expiring, edit_message_text_anyway, make_expiring
+from src.bot.routers.tools import (
+    cancel_expiring,
+    edit_message_text_anyway,
+    ensure_same_structural_message,
+    make_expiring,
+)
 from src.bot.shared_messages import go_to_default_state
 from src.modules.scanning.entity_models import ScanningOptions
 
@@ -96,6 +101,8 @@ async def continue_scan_handler(callback: CallbackQuery, state: FSMContext, pret
     await cancel_expiring(callback.message)
     await state.set_state(ScanWork.scanning)
     data = await state.get_data()
+    text = format_scanning_message(data, None, "starting")
+    message = await edit_message_text_anyway(message, text)
     scanner_status = await api_client.get_scanner_status(message.chat.id, data.get("scanner"))
     scanning_options = ScanningOptions(
         sides="false" if data["mode"] == "manual" else data.get("scan_sides", "false"),
@@ -107,7 +114,7 @@ async def continue_scan_handler(callback: CallbackQuery, state: FSMContext, pret
     # start scanning
     try:
         scan_job_id = await api_client.start_manual_scan(message.chat.id, scanner_status.scanner, scanning_options)
-        await state.update_data(scan_job_id=scan_job_id)
+        data = await state.update_data(scan_job_id=scan_job_id)
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 503:
             await message.answer("Scanner is busy. Try pressing Cancel button on the device and try again.")
@@ -120,8 +127,6 @@ async def continue_scan_handler(callback: CallbackQuery, state: FSMContext, pret
             await edit_message_text_anyway(message, text, markup)
             return
         raise
-    text, markup = format_scanning_message(data, scanner_status, "starting")
-    await edit_message_text_anyway(message, text, markup)
 
     scanning_result = asyncio.create_task(
         api_client.wait_and_merge_manual_scan(
@@ -138,14 +143,26 @@ async def continue_scan_handler(callback: CallbackQuery, state: FSMContext, pret
 
     while time.monotonic() - start_time < max_wait_time:
         iteration += 1
-        # Exit if state changed (user clicked cancel)
+
+        # Return if the job was changed (user sent a new document or /scan)
+        try:
+            await ensure_same_structural_message(message, "confirmation_message_id", state)
+        except TelegramBadRequest:
+            await scanning_result
+            await api_client.cancel_manual_scan(message.chat.id, scanner_status.scanner, data["scan_job_id"])
+            return
+        # Return if the job was canceled
         if (await state.get_state()) == default_state:
-            break
+            await scanning_result
+            await api_client.cancel_manual_scan(message.chat.id, scanner_status.scanner, data["scan_job_id"])
+            return
 
-        text, markup = format_scanning_message(data, scanner_status, "scanning", iteration)
-        await edit_message_text_anyway(message, text, markup)
+        text = format_scanning_message(data, scanner_status, "scanning", iteration)
+        message = await edit_message_text_anyway(message, text)
 
         if scanning_result.done():
+            if not (scanning_result := await scanning_result):
+                return
             break
 
         # Sleep for one second before next check
@@ -161,7 +178,7 @@ async def continue_scan_handler(callback: CallbackQuery, state: FSMContext, pret
         await edit_message_text_anyway(message, text, markup)
         return
 
-    scanning_result = await scanning_result
+    await api_client.cancel_manual_scan(message.chat.id, scanner_status.scanner, data["scan_job_id"])
     data = await state.update_data(
         scan_server_name=scanning_result.filename,
         scan_result_pages_count=scanning_result.page_count,
@@ -184,20 +201,12 @@ async def send_new_started_scan_confirmation_message_handler(callback: CallbackQ
     scanner_status = await api_client.get_scanner_status(callback.message.chat.id, data.get("scanner"))
     caption, markup = format_scanning_paused_message(data, scanner_status, is_finished=True)
     await edit_message_text_anyway(callback.message, caption, markup)
-    text, markup = format_scanning_message(data, scanner_status, "starting")
-    msg = await callback.message.answer(text, reply_markup=markup)
+    text = format_scanning_message(data, scanner_status, "starting")
+    msg = await callback.message.answer(text)
     await state.update_data(confirmation_message_id=msg.message_id)
     await start_new_scan_handler(callback, state, bot, msg)
 
 
-@router.callback_query(ScanWork.scanning, ScanningCallback.filter(F.menu == "cancel"))
-async def scanning_cancel_handler(callback: CallbackQuery, state: FSMContext, bot: Bot):
-    await callback.answer()
-    await cancel_expiring(callback.message)
-    await gracefully_interrupt_scanning_state(callback, state, bot)
-    await go_to_default_state(callback, state)
-
-
 @router.callback_query(CallbackFromConfirmationMessageFilter(), ScanningPausedCallback.filter(F.menu == "remove-last"))
 async def scanning_paused_remove_last_handler(
     callback: CallbackQuery, callback_data: ScanningPausedCallback, state: FSMContext, bot: Bot

src/bot/routers/scanning/scanning_states.py

@@ -1,12 +1,17 @@
-from aiogram import Bot
+from aiogram import Bot, html
 from aiogram.exceptions import TelegramBadRequest
 from aiogram.fsm.context import FSMContext
 from aiogram.fsm.state import State, StatesGroup
 from aiogram.types import CallbackQuery, Message
 
 from src.bot.api import api_client
 from src.bot.routers.printing.printing_tools import discard_job_settings_message
-from src.bot.routers.scanning.scanning_tools import format_scanning_message, format_scanning_paused_message
+from src.bot.routers.scanning.scanning_tools import (
+    format_configure_message,
+    format_scanning_message,
+    format_scanning_paused_message,
+)
+from src.bot.routers.tools import edit_message_text_anyway
 
 
 class ScanWork(StatesGroup):
@@ -39,35 +44,25 @@ async def gracefully_interrupt_scanning_state(
     ):
         await discard_job_settings_message(data, message, state, bot)
         assert "confirmation_message_id" in data
-        try:
-            await bot.edit_message_text(
-                text="Scanning cancelled", chat_id=message.chat.id, message_id=data["confirmation_message_id"]
-            )
-        except TelegramBadRequest:
-            pass
+        scanner_status = await api_client.get_scanner_status(message.chat.id, data["scanner"])
+        text, _ = format_configure_message(data, scanner_status)
+        await edit_message_text_anyway(
+            data["confirmation_message_id"],
+            f"{text}\n{html.italic('This job has expired 🕒')}",
+            None,
+            message.chat.id,
+            bot,
+        )
     elif current_state == ScanWork.scanning:
         assert "confirmation_message_id" in data
         scanner_status = await api_client.get_scanner_status(message.chat.id, data.get("scanner"))
-        if scanner_status.scanner and "scan_job_id" in data:
-            await api_client.cancel_manual_scan(message.chat.id, scanner_status.scanner, data["scan_job_id"])
-        text, markup = format_scanning_message(data, scanner_status, "cancelled")
-        try:
-            await bot.edit_message_text(
-                text=text, chat_id=message.chat.id, message_id=data["confirmation_message_id"], reply_markup=markup
-            )
-        except TelegramBadRequest:
-            try:
-                await bot.edit_message_caption(
-                    caption=text,
-                    chat_id=message.chat.id,
-                    message_id=data["confirmation_message_id"],
-                    reply_markup=markup,
-                )
-            except TelegramBadRequest:
-                pass
+        text = format_scanning_message(data, scanner_status, "cancelled")
+        await edit_message_text_anyway(data["confirmation_message_id"], text, None, message.chat.id, bot)
     elif current_state == ScanWork.pause_menu:
         assert "confirmation_message_id" in data
         scanner_status = await api_client.get_scanner_status(message.chat.id, data.get("scanner"))
+        if scanner_status.scanner and "scan_job_id" in data:
+            await api_client.cancel_manual_scan(message.chat.id, scanner_status.scanner, data["scan_job_id"])
         caption, markup = format_scanning_paused_message(data, scanner_status, is_finished=True)
         try:
             await bot.edit_message_caption(

src/bot/routers/scanning/scanning_tools.py

@@ -14,10 +14,6 @@ class ScanConfigureCallback(CallbackData, prefix="scan_menu"):
     menu: Literal["mode", "scanner", "quality", "sides", "crop", "cancel", "start"]
 
 
-class ScanningCallback(CallbackData, prefix="scanning"):
-    menu: Literal["cancel"]
-
-
 class ScanningPausedCallback(CallbackData, prefix="scanning_paused"):
     menu: Literal["remove-last", "scan-more", "scan-new", "finish", "rename"]
 
@@ -100,23 +96,17 @@ def format_scanning_message(
     scanner_status: ScannerStatus | None,
     status: Literal["starting", "scanning", "cancelled"],
     iteration: int = 0,
-) -> tuple[str, InlineKeyboardMarkup | None]:
+) -> str:
     text = scan_job_summary(data, scanner_status)
     if status == "starting":
         text += html.italic("⏳ Starting...\n")
     elif status == "scanning":
         text += html.italic(f"{'⤹⤿⤻⤺'[iteration % 4]} Scanning...\n")
     elif status == "cancelled":
         text += html.italic("❌ Cancelled\n")
-        return text, None
+        return text
 
-    return text, InlineKeyboardMarkup(
-        inline_keyboard=[
-            [
-                InlineKeyboardButton(text="Cancel", callback_data=ScanningCallback(menu="cancel").pack()),
-            ]
-        ]
-    )
+    return text
 
 
 def scan_job_summary(data: FSMData, scanner_status: ScannerStatus | None) -> str:

src/bot/routers/tools.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from aiogram import html
+from aiogram import Bot, html
 from aiogram.exceptions import TelegramBadRequest
 from aiogram.fsm.context import FSMContext
 from aiogram.types import InlineKeyboardMarkup, Message
@@ -40,15 +40,36 @@ async def cancel_expiring(message: Message):
 async def mark_as_expired(message: Message, immediately: bool = False):
     await asyncio.sleep(0 if immediately else message_expiration_time)
     await edit_message_text_anyway(
-        message=message, text=f"{message.caption or message.text}\n{html.italic('This job has expired 🕒')}"
+        message_or_id=message, text=f"{message.caption or message.text}\n{html.italic('This job has expired 🕒')}"
     )
 
 
-async def edit_message_text_anyway(message: Message, text: str, reply_markup: InlineKeyboardMarkup | None = None):
-    try:
-        await message.edit_caption(caption=text, reply_markup=reply_markup)
-    except TelegramBadRequest:
+async def edit_message_text_anyway(
+    message_or_id: Message | int,
+    text: str,
+    reply_markup: InlineKeyboardMarkup | None = None,
+    chat_id: int | None = None,
+    bot: Bot | None = None,
+):
+    after_edits = None
+    if isinstance(message_or_id, Message):
         try:
-            await message.edit_text(text=text, reply_markup=reply_markup)
+            after_edits = await message_or_id.edit_caption(caption=text, reply_markup=reply_markup)
         except TelegramBadRequest:
-            pass
+            try:
+                after_edits = await message_or_id.edit_text(text=text, reply_markup=reply_markup)
+            except TelegramBadRequest:
+                pass
+    else:
+        try:
+            after_edits = await bot.edit_message_caption(
+                chat_id=chat_id, message_id=message_or_id, caption=text, reply_markup=reply_markup
+            )
+        except TelegramBadRequest:
+            try:
+                after_edits = await bot.edit_message_text(
+                    chat_id=chat_id, message_id=message_or_id, text=text, reply_markup=reply_markup
+                )
+            except TelegramBadRequest:
+                pass
+    return after_edits

src/modules/scanning/repository.py

@@ -123,7 +123,7 @@ async def _is_scanner_offline(self, scanner: Scanner, client: httpx.AsyncClient)
             logger.warning(f"Scanner {scanner.name} is offline: {type(e)}")
             return True
 
-    async def scan_one_page(self, scanner: Scanner, options: ScanningOptions) -> bytes | None:
+    async def scan_one_page_debug(self, scanner: Scanner, options: ScanningOptions) -> bytes | None:
         """Scan using eSCL and return document as PDF bytes"""
         try:
             job_id = await self.start_scan_one(scanner, options)
@@ -158,11 +158,15 @@ async def start_scan_one(self, scanner: Scanner, options: ScanningOptions) -> st
                 logger.warning(f"Scanner {scanner.name} returned None document url")
                 return None
 
-            job_id = document_url.rsplit("/ScanJobs/", 1)[-1]
-            return job_id
+            return document_url[document_url.index("urn:uuid:") :]
 
     async def fetch_scan_one(self, scanner: Scanner, job_id: str) -> bytes | None:
-        document = await self.fetch_scanned_document(scanner, job_id)
+        try:
+            document = await self.fetch_scanned_document(scanner, job_id)
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code in (404, 410):
+                return None
+            raise
         await self.delete_printer_scan_job(scanner, job_id)
         return document
 
@@ -174,11 +178,16 @@ async def fetch_scanned_document(self, scanner: Scanner, job_id: str) -> bytes:
             return response.content  # PDF bytes
 
     async def delete_printer_scan_job(self, scanner: Scanner, job_id: str) -> None:
-        """Delete the scan job from the printer, so nobody can download the file"""
-        async with httpx.AsyncClient(verify=False) as client:
-            logger.info(f"Scanner {scanner.name} deleting document {job_id}")
-            response = await client.delete(f"{scanner.escl}/ScanJobs/{job_id}")
-            response.raise_for_status()
+        """Delete the document from the printer via its url"""
+        try:
+            async with httpx.AsyncClient(verify=False) as client:
+                logger.info(f"Scanner {scanner.name} deleting document {job_id}")
+                response = await client.delete(f"{scanner.escl}/ScanJobs/{job_id}")
+                response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 410:
+                return
+            raise
 
 
 scanning_repository = ScanningRepository()