Automated sync from GitHub

.gitattributes

@@ -1,8 +1,8 @@
-*.otf filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-*.mp4 filter=lfs diff=lfs merge=lfs -text
 *.mp3 filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.ttf filter=lfs diff=lfs merge=lfs -text
+*.otf filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text

bot/dbflow.py

@@ -13,8 +13,20 @@ All of this exists only while DB_CHANNEL and COMMUNICATION_CHAT are both set.
 
 A format without a Channel is only uploaded: no notice is written and nothing is published.
 
-Nothing about a running upload is stored: the buttons carry what is needed, and a restart in the middle just leaves the
-Processing message as it was.
+No to the offer asks "upload it and get the Share URL?": Yes copies the episode into the Database Channel, waits for the file
+store's Share URL button on the copy, and shows its link in monospace.  When this bot cannot see the button, it asks the channel
+post bot ("Get the share URL" in the communication chat) whose userbot can.  Nothing is published.
+
+Deleting what was published: the message that says "Post published successfully" has a "🗑 Delete post" button.
+5. It asks "Are you sure you want to delete this post?" in a message of its own (Yes / No).
+6. Yes: "Delete the published post" is written in the communication chat, with the channel and the id of the post (the channel
+   post bot reported both).  The channel post bot deletes the post in its channel and in My posts and answers "post deleted
+   successfully" or "deletion failed: <reason>" (the same Ref / reply conventions as above).
+7. Only when that answer is "deleted" is the episode's copy in the Database Channel deleted here.  Any other outcome leaves
+   everything as it was and offers "Try again" - asking again is harmless, a post that is already gone counts as deleted.
+
+Nothing about a running upload or deletion is stored: the buttons carry what is needed, and a restart in the middle just leaves
+the Processing message as it was.
 """
 from __future__ import annotations
 
@@ -22,6 +34,7 @@ import asyncio
 import logging
 import re
 import secrets
+from urllib.parse import unquote
 from dataclasses import dataclass, field
 from typing import Any, Dict, Optional, Set, Tuple
 
@@ -34,13 +47,19 @@ from .utils import clip, esc
 
 log = logging.getLogger(__name__)
 
-PREFIX = "dbu"  # callback data: dbu:y:<chat>:<message>:<channel or 0> (Yes), dbu:n (No)
+PREFIX = "dbu"  # callback data: dbu:y:<chat>:<message>:<channel or 0> (Yes), dbu:n (No);
+#                 dbu:d:<copy>:<channel>:<post> (🗑 Delete post), dbu:dy:<copy>:<channel>:<post>:<that message> (Yes), dbu:dn (No)
 ACK_WAIT = 60.0  # seconds the channel post bot has to say "message received" before it counts as down
 RESULT_WAIT = 900.0  # ... and then to say whether the post was published (it waits at least 10 s for the Share URL button)
+DELETE_WAIT = 300.0  # ... or whether the post was deleted (it may be busy making another post first)
 NOTICE_HEAD = "File uploaded to the Database Channel"
+DELETE_HEAD = "Delete the published post"
+LINK_WAIT = 15.0
+CALLBACK_MAX = 64  # bytes of callback data Telegram accepts
 
-_FAILED = re.compile(r"(?i)publication\s+failed\s*[:\-–]?[ \t]*(.*)")
-_PUBLISHED = re.compile(r"(?i)post\s+published\s+successfully")
+_SHARE_SHEET = re.compile(r"(?i)^https?://(?:t\.me|telegram\.me|telegram\.dog)/share(?:/url)?\?(.*)$")
+_FAILED = re.compile(r"(?i)(?:publication|deletion|share\s+url)\s+failed\s*[:\-–]?[ \t]*(.*)")
+_SUCCESS = re.compile(r"(?i)post\s+(?:published|deleted)\s+successfully|share\s+url\s+ready")
 _RECEIVED = re.compile(r"(?i)message\s+received")
 
 
@@ -61,7 +80,7 @@ def classify(text: Optional[str]) -> Tuple[str, str]:
     failed = _FAILED.search(text)
     if failed:
         return "fail", " ".join(failed.group(1).split())
-    if _PUBLISHED.search(text):
+    if _SUCCESS.search(text):
         return "ok", ""
     if _RECEIVED.search(text):
         return "ack", ""
@@ -81,6 +100,48 @@ def notice_text(*, episode: str, channel: int, file: str, post_id: Optional[int]
     return "\n".join(lines)
 
 
+def delete_notice_text(*, channel: int, message: int, ref: str) -> str:
+    """The message for the communication chat that has a published post deleted (channel and post as the channel post bot reported them)."""
+    return "\n".join([DELETE_HEAD, f"Channel: {channel}", f"Message: {message}", f"Ref: {ref}"])
+
+
+def post_message_id(reply: str) -> Optional[int]:
+    """The new post as a message of its channel, from "Post published successfully": its "Message:" line, else the last number of its
+    "Post:" link (https://t.me/name/57, https://t.me/c/123/57); None when the reply has neither."""
+    number = line_of("message", reply)
+    if re.fullmatch(r"[0-9]{1,12}", number):
+        return int(number)
+    found = re.search(r"/([0-9]{1,12})/?$", line_of("post", reply))
+    return int(found.group(1)) if found else None
+
+
+def delete_button(copy_id: int, channel: int, post: int) -> Optional[list]:
+    """The 🗑 Delete post button of a published post's message; None when its data would not fit Telegram's limit."""
+    data = f"{PREFIX}:d:{copy_id}:{channel}:{post}"
+    return [[("🗑 Delete post", data)]] if len(data.encode()) <= CALLBACK_MAX else None
+
+
+def link_notice_text(*, post_id: int, ref: str) -> str:
+    """Asks the channel post bot (which has the userbot) for the Share URL of a file in the Database Channel; nothing is published."""
+    return "\n".join(["Get the share URL", f"Post: {post_id}", f"Ref: {ref}"])
+
+
+def share_link(msg: Any) -> str:
+    """The file link of the "Share URL" button of a message ("" when it has none). A Share URL button usually opens Telegram's share
+    sheet (t.me/share/url?url=<file link>): that wrapper is taken off."""
+    for row in getattr(getattr(msg, "reply_markup", None), "rows", None) or []:
+        for button in getattr(row, "buttons", None) or []:
+            url = getattr(button, "url", None) or getattr(getattr(button, "type", None), "url", None)  # (older layers: button.url)
+            if url and re.search(r"(?i)\bshare\s*url\b", getattr(button, "text", "") or ""):
+                m = _SHARE_SHEET.match(url.strip())
+                if not m:
+                    return url.strip()
+                inner = re.search(r"(?:^|&)url=(.*?)(?=&text=|$)", m.group(1))
+                link = unquote(inner.group(1)) if inner else ""
+                return link if re.match(r"(?i)^(https?://|tg://)\S+$", link) else ""
+    return ""
+
+
 def reply_target(event: Any) -> Optional[int]:
     """The id of the message an incoming message replies to."""
     message = getattr(event, "message", None)
@@ -144,9 +205,84 @@ def silent_text(name: str, seconds: float) -> str:
     )
 
 
+def link_question_text() -> str:
+    return (
+        "🔗 <b>Upload it to the Database Channel and get the Share URL?</b>\n"
+        "You get the link here. Nothing is published: the channel post bot makes no post in the channel of the format."
+    )
+
+
+def link_text(name: str, url: str) -> str:
+    return "\n".join(["✅ <b>Uploaded to the Database Channel</b>", _name(name), "🔗 Share URL:", f"<code>{esc(url)}</code>"])
+
+
+def confirm_text(channel: int) -> str:
+    return (
+        "🗑 <b>Are you sure you want to delete this post?</b>\n"
+        f"It is deleted from the channel <code>{channel}</code> and from My posts of the channel post bot, "
+        "and its file from the Database Channel. This cannot be undone."
+    )
+
+
+def deleting_text(*steps: str) -> str:
+    return "\n".join(line for line in ["⏳ <b>Deleting the post…</b>", *steps] if line)
+
+
+def deleted_text(reply: str, copy: bool) -> str:
+    """The post is gone: what the channel post bot reported (its channel and notes), and the copy in the Database Channel."""
+    lines = ["🗑 <b>Post deleted</b>"]
+    where = line_of("channel", reply)
+    if where:
+        lines.append(f"📣 {esc(clip(where, 80))}")
+    lines.append("✅ Deleted from the channel and from My posts")
+    lines += [esc(clip(line.strip(), 200)) for line in (reply or "").splitlines() if line.strip().startswith("ℹ️")]
+    lines.append("✅ Deleted from the Database Channel" if copy else "ℹ️ There was no copy in the Database Channel to delete.")
+    return "\n".join(lines)
+
+
+def delete_failed_text(reason: str) -> str:
+    return "\n".join(
+        [
+            "❌ <b>The post was not deleted</b>",
+            esc(clip(reason or "No reason was given.", 600)),
+            "The file in the Database Channel was not touched.",
+        ]
+    )
+
+
+def delete_down_text(seconds: float) -> str:
+    return "\n".join(
+        [
+            "⚠️ <b>The channel post bot is down or not responding</b>",
+            f"It did not answer in the communication chat within {int(seconds)} seconds, so the post is not deleted. "
+            "The file in the Database Channel was not touched.",
+        ]
+    )
+
+
+def delete_silent_text(seconds: float) -> str:
+    return "\n".join(
+        [
+            "⚠️ <b>No word from the channel post bot</b>",
+            f"It got the message but did not say whether the post was deleted in {int(seconds // 60)} minutes. "
+            "Check the channel, then try again. The file in the Database Channel was not touched.",
+        ]
+    )
+
+
+def copy_kept_text(reason: str) -> str:
+    return "\n".join(
+        [
+            "⚠️ <b>The post is deleted, but not its file in the Database Channel</b>",
+            esc(clip(reason, 400)),
+            "Check that the bot is an admin of the Database Channel and may delete messages there, then try again.",
+        ]
+    )
+
+
 @dataclass
 class Flow:
-    """An upload that waits for the channel post bot's answers."""
+    """An upload or a deletion that waits for the channel post bot's answers."""
 
     ref: str  # in the notice and echoed in every answer: how the answers find their way back
     inbox: "asyncio.Queue[Tuple[str, str]]" = field(default_factory=asyncio.Queue)  # (ack | ok | fail, the message)
@@ -154,13 +290,18 @@ class Flow:
 
 
 class DbFlow:
-    def __init__(self, client: Any, cfg: Config, *, ack_wait: float = ACK_WAIT, result_wait: float = RESULT_WAIT):
+    def __init__(
+        self, client: Any, cfg: Config, *, ack_wait: float = ACK_WAIT, result_wait: float = RESULT_WAIT, delete_wait: float = DELETE_WAIT
+    ):
         self.client = client
         self.cfg = cfg
         self.ack_wait = ack_wait
         self.result_wait = result_wait
+        self.delete_wait = delete_wait
+        self.link_wait = LINK_WAIT  # seconds this bot looks for the Share URL button itself before it asks the channel post bot
+        self.link_poll = 3.0
         self.flows: Dict[str, Flow] = {}
-        self._busy: Set[Tuple[int, int]] = set()  # (chat, offer message) of the uploads under way: a second tap does nothing
+        self._busy: Set[Tuple[int, int]] = set()  # (chat, message) of the uploads and deletions under way: a second tap does nothing
         self._tasks: Set["asyncio.Future[Any]"] = set()
 
     # ------------------------------------------------------------------ the offer
@@ -170,7 +311,7 @@ class DbFlow:
         if not isinstance(sent_id, int):
             return  # nothing to point at
         channel = (job.fmt or {}).get("channel")
-        rows = [[("✅ Yes", f"{PREFIX}:y:{target}:{sent_id}:{channel or 0}"), ("❌ No", f"{PREFIX}:n")]]
+        rows = [[("✅ Yes", f"{PREFIX}:y:{target}:{sent_id}:{channel or 0}"), ("❌ No", f"{PREFIX}:n:{target}:{sent_id}")]]
         await self.client.send_message(
             job.chat_id, offer_text(job.new_name, episode_of(job.new_name), channel), buttons=panels.to_buttons(rows),
             parse_mode="html", link_preview=False, reply_to=sent_id if target == job.chat_id else job.msg_id,
@@ -178,6 +319,12 @@ class DbFlow:
 
     async def on_callback(self, event: Any, parts: list) -> None:
         action = parts[1] if len(parts) > 1 else ""
+        if action in ("d", "dy", "dn", "x"):
+            await self._on_delete(event, parts)
+            return
+        if action in ("l", "g", "z") or (action == "n" and len(parts) == 4):
+            await self._on_link(event, parts)
+            return
         if action == "n":
             await event.answer()
             await event.edit("👍 Okay, it is not uploaded to the Database Channel.", buttons=None, parse_mode="html")
@@ -266,16 +413,22 @@ class DbFlow:
             flow.notice_id = _id_of(note) or 0
 
             # ---- 3. what the channel post bot says
-            verdict, reply = await self._answers(flow, chat_id, msg_id, name, uploaded)
+            async def got_it() -> None:
+                await self._show(chat_id, msg_id, processing_text(name, uploaded, "📥 The channel post bot got it and is publishing…"))
+
+            rows = None
+            verdict, reply = await self._answers(flow, got_it, self.result_wait)
             if verdict == "ok":
                 text = published_text(name, reply, channel)
+                post = post_message_id(reply)
+                rows = delete_button(_id_of(copy) or 0, channel, post) if post else None  # no post id: nothing to delete later
             elif verdict == "fail":
                 text = failed_text(name, classify(reply)[1])
             elif verdict == "down":
                 text = down_text(name, self.ack_wait)
             else:
                 text = silent_text(name, self.result_wait)
-            await self._show(chat_id, msg_id, text)
+            await self._show(chat_id, msg_id, text, rows)
         except asyncio.CancelledError:
             raise
         except Exception as exc:  # noqa: BLE001
@@ -300,9 +453,10 @@ class DbFlow:
             formatting_entities=getattr(msg, "entities", None) or None, parse_mode=None,
         )
 
-    async def _answers(self, flow: Flow, chat_id: int, msg_id: int, name: str, uploaded: str) -> Tuple[str, str]:
+    async def _answers(self, flow: Flow, on_ack: Any, result_wait: float) -> Tuple[str, str]:
         """Wait for the channel post bot: ``("ok" | "fail", its message)``, ``("down", "")`` when it never acknowledged the notice,
-        ``("silent", "")`` when it acknowledged it but never said how it went."""
+        ``("silent", "")`` when it acknowledged it but never said how it went in ``result_wait`` seconds.  ``on_ack()`` is awaited once,
+        when the acknowledgement comes."""
         loop = asyncio.get_running_loop()
         acked = False
         deadline = loop.time() + self.ack_wait
@@ -315,8 +469,8 @@ class DbFlow:
                 return kind, text
             if not acked:
                 acked = True
-                deadline = loop.time() + self.result_wait
-                await self._show(chat_id, msg_id, processing_text(name, uploaded, "📥 The channel post bot got it and is publishing…"))
+                deadline = loop.time() + result_wait
+                await on_ack()
 
     async def _show(self, chat_id: int, msg_id: int, text: str, rows: Optional[list] = None) -> None:
         try:
@@ -328,6 +482,283 @@ class DbFlow:
         except Exception as exc:  # noqa: BLE001
             log.warning("could not update the upload message: %s: %s", type(exc).__name__, exc)
 
+    # ------------------------------------------------------- only the Share URL
+    async def _on_link(self, event: Any, parts: list) -> None:
+        """No to the upload offer asks about the link only (``n``); Yes (``l``) uploads and returns it; ``g`` looks for it again."""
+        action = parts[1]
+        if action == "z":
+            await event.answer()
+            await event.edit("👍 Okay, it is not uploaded to the Database Channel.", buttons=None, parse_mode="html")
+            return
+        try:
+            if len(parts) != {"n": 4, "l": 4, "g": 3}[action]:
+                raise ValueError(parts)
+            numbers = [int(x) for x in parts[2:]]
+            if action != "g" and numbers[1] <= 0:
+                raise ValueError(parts)
+        except ValueError:
+            await event.answer()
+            return
+        if action == "n":
+            await event.answer()
+            yes = [[("✅ Yes", f"{PREFIX}:l:{numbers[0]}:{numbers[1]}"), ("❌ No", f"{PREFIX}:z")]]
+            await event.edit(link_question_text(), buttons=panels.to_buttons(yes), parse_mode="html", link_preview=False)
+            return
+        key = (event.chat_id, event.message_id)
+        if key in self._busy:
+            await event.answer("I'm already on it…")
+            return
+        self._busy.add(key)
+        try:
+            await event.answer()
+            try:
+                await event.edit(processing_text(""), buttons=None, parse_mode="html")
+            except errors.MessageNotModifiedError:
+                pass
+        except BaseException:
+            self._busy.discard(key)
+            raise
+        self._spawn(self._run_link(key, *numbers) if action == "l" else self._run_url(key, numbers[0]))
+
+    async def _run_link(self, key: Tuple[int, int], source_chat: int, source_id: int) -> None:
+        chat_id, msg_id = key
+        name = ""
+        try:
+            msg = await self.client.get_messages(source_chat, ids=source_id)
+            if msg is None or getattr(msg, "file", None) is None:
+                await self._show(chat_id, msg_id, "❌ <b>That episode is not there anymore</b>\nIt was deleted from the chat, so there is nothing to upload.")
+                return
+            name = getattr(msg.file, "name", None) or ""
+            try:
+                copy = await self._copy(msg, source_chat)
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:  # noqa: BLE001
+                log.warning("could not upload %s to the Database Channel: %s: %s", name, type(exc).__name__, exc)
+                retry = [[("🔁 Try again", f"{PREFIX}:l:{source_chat}:{source_id}"), ("✖ Close", "x:close")]]
+                await self._show(
+                    chat_id, msg_id,
+                    f"❌ <b>The upload to the Database Channel failed</b>\n{_name(name)}\n{_why(exc)}\n"
+                    "Check that the bot is an admin of the Database Channel and can post there.",
+                    retry,
+                )
+                return
+            await self._url(chat_id, msg_id, name, _id_of(copy) or 0)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            log.exception("getting the share url went wrong")
+            await self._show(chat_id, msg_id, f"❌ <b>Something went wrong</b>\n{_name(name)}\n{_why(exc)}")
+        finally:
+            self._busy.discard(key)
+
+    async def _run_url(self, key: Tuple[int, int], copy_id: int) -> None:
+        try:
+            await self._url(key[0], key[1], "", copy_id)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            log.exception("getting the share url went wrong")
+            await self._show(key[0], key[1], f"❌ <b>Something went wrong</b>\n{_why(exc)}")
+        finally:
+            self._busy.discard(key)
+
+    async def _url(self, chat_id: int, msg_id: int, name: str, copy_id: int) -> None:
+        """The Share URL of the copy: looked for here first, and when this bot cannot see it, the channel post bot (whose userbot can) is asked."""
+        done = "✅ Uploaded to the Database Channel" if name else ""
+        again = [[("🔁 Look for the URL again", f"{PREFIX}:g:{copy_id}"), ("✖ Close", "x:close")]]
+        if not copy_id:
+            await self._show(chat_id, msg_id, f"⚠️ <b>Uploaded, but I do not know which post it is</b>\n{_name(name)}\nLook for the Share URL in the Database Channel.")
+            return
+        await self._show(chat_id, msg_id, processing_text(name, done, "⏳ Waiting for the Share URL button…"))
+        url = await self._bot_url(copy_id)
+        if not url:
+            flow = Flow(ref=secrets.token_hex(3))
+            self.flows[flow.ref] = flow
+            try:
+                try:
+                    note = await self.client.send_message(
+                        self.cfg.comm_chat, link_notice_text(post_id=copy_id, ref=flow.ref), parse_mode=None, link_preview=False
+                    )
+                except asyncio.CancelledError:
+                    raise
+                except Exception as exc:  # noqa: BLE001
+                    await self._show(
+                        chat_id, msg_id,
+                        f"⚠️ <b>I could not see the Share URL, and could not write in the communication chat</b>\n{_name(name)}\n{_why(exc)}", again,
+                    )
+                    return
+                flow.notice_id = _id_of(note) or 0
+
+                async def got_it() -> None:
+                    await self._show(chat_id, msg_id, processing_text(name, done, "📥 The channel post bot is looking for the Share URL…"))
+
+                await self._show(chat_id, msg_id, processing_text(name, done, "⏳ Asking the channel post bot (its userbot can see it)…"))
+                verdict, reply = await self._answers(flow, got_it, self.delete_wait)
+            finally:
+                self.flows.pop(flow.ref, None)
+            if verdict == "ok":
+                url = line_of("url", reply)
+            if not url:
+                why = {
+                    "fail": classify(reply)[1], "down": f"The channel post bot did not answer within {int(self.ack_wait)} seconds (down?).",
+                    "silent": "The channel post bot did not say how it went.", "ok": "The channel post bot sent no link.",
+                }[verdict]
+                await self._show(
+                    chat_id, msg_id,
+                    f"⚠️ <b>Uploaded, but no Share URL</b>\n{_name(name)}\n{esc(clip(why or 'No reason was given.', 500))}", again,
+                )
+                return
+        await self._show(chat_id, msg_id, link_text(name, url))
+
+    async def _bot_url(self, copy_id: int) -> str:
+        """Look at the copy for its Share URL button for ``link_wait`` seconds (the file store adds it a few seconds after the post)."""
+        loop = asyncio.get_running_loop()
+        end = loop.time() + self.link_wait
+        while True:
+            try:
+                url = share_link(await self.client.get_messages(self.cfg.db_channel, ids=copy_id))
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:  # noqa: BLE001
+                log.info("could not read the copy in the Database Channel: %s: %s", type(exc).__name__, exc)
+                return ""  # this bot cannot read it: no use waiting, the channel post bot is asked
+            if url or loop.time() >= end:
+                return url
+            await asyncio.sleep(self.link_poll)
+
+    # ------------------------------------------------------- deleting what was published
+    async def _on_delete(self, event: Any, parts: list) -> None:
+        """The buttons of a published post: 🗑 Delete post (``d``), Yes (``dy``), No (``dn``), and the note it turns into (``x``)."""
+        action = parts[1]
+        if action == "x":
+            await event.answer("This post is already deleted.")
+            return
+        if action == "dn":
+            await event.answer("Okay, nothing is deleted.")
+            await self._close(event)
+            return
+        try:
+            if len(parts) != (5 if action == "d" else 6):
+                raise ValueError(parts)
+            copy_id, channel, post = int(parts[2]), int(parts[3]), int(parts[4])
+            shown = int(parts[5]) if action == "dy" else event.message_id  # the message of the post, whose button this is
+            if copy_id < 0 or post <= 0 or channel == 0:
+                raise ValueError(parts)
+        except ValueError:
+            await event.answer()
+            return
+        if action == "d":  # ask first, in a message of its own: the post's message stays as it is
+            await event.answer()
+            yes = f"{PREFIX}:dy:{copy_id}:{channel}:{post}:{shown}"
+            await self.client.send_message(
+                event.chat_id, confirm_text(channel), buttons=panels.to_buttons([[("✅ Yes, delete it", yes), ("❌ No", f"{PREFIX}:dn")]]),
+                parse_mode="html", link_preview=False, reply_to=shown,
+            )
+            return
+        key = (event.chat_id, event.message_id)
+        if key in self._busy:
+            await event.answer("I'm already on it…")
+            return
+        self._busy.add(key)
+        try:
+            await event.answer()
+            try:
+                await event.edit(deleting_text(), buttons=None, parse_mode="html")
+            except errors.MessageNotModifiedError:
+                pass
+        except BaseException:
+            self._busy.discard(key)
+            raise
+        self._spawn(self._delete(key, copy_id, channel, post, shown))
+
+    @staticmethod
+    async def _close(event: Any) -> None:
+        try:
+            await event.delete()
+        except Exception:  # noqa: BLE001 - Telegram refuses to delete messages older than 48 hours
+            try:
+                await event.edit("Closed.", buttons=None)
+            except Exception:  # noqa: BLE001
+                pass
+
+    async def _delete(self, key: Tuple[int, int], copy_id: int, channel: int, post: int, shown: int) -> None:
+        """Have the channel post bot delete the post, and when it says it is gone, delete the copy in the Database Channel."""
+        chat_id, msg_id = key
+        flow: Optional[Flow] = None
+        again = [[("🔁 Try again", f"{PREFIX}:dy:{copy_id}:{channel}:{post}:{shown}"), ("✖ Close", f"{PREFIX}:dn")]]
+        try:
+            flow = Flow(ref=secrets.token_hex(3))
+            self.flows[flow.ref] = flow  # before the notice goes out, so that no answer can come back too early
+            await self._show(chat_id, msg_id, deleting_text("⏳ Waiting for the channel post bot…"))
+            try:
+                note = await self.client.send_message(
+                    self.cfg.comm_chat, delete_notice_text(channel=channel, message=post, ref=flow.ref), parse_mode=None, link_preview=False
+                )
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:  # noqa: BLE001
+                log.warning("could not write in the communication chat: %s: %s", type(exc).__name__, exc)
+                await self._show(
+                    chat_id, msg_id,
+                    f"⚠️ <b>I could not write in the communication chat</b>\n{_why(exc)}\nNothing was deleted. Is the bot a member of that chat?",
+                    again,
+                )
+                return
+            flow.notice_id = _id_of(note) or 0
+
+            async def got_it() -> None:
+                await self._show(chat_id, msg_id, deleting_text("📥 The channel post bot got it and is deleting the post…"))
+
+            rows = again
+            verdict, reply = await self._answers(flow, got_it, self.delete_wait)
+            if verdict == "ok":
+                problem = await self._delete_copy(copy_id)
+                if problem is None:
+                    text, rows = deleted_text(reply, bool(copy_id)), None
+                    await self._mark_deleted(chat_id, shown)
+                else:
+                    text = copy_kept_text(problem)
+            elif verdict == "fail":
+                text = delete_failed_text(classify(reply)[1])
+            elif verdict == "down":
+                text = delete_down_text(self.ack_wait)
+            else:
+                text = delete_silent_text(self.delete_wait)
+            await self._show(chat_id, msg_id, text, rows)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            log.exception("deleting the published post went wrong")
+            await self._show(chat_id, msg_id, f"❌ <b>Something went wrong</b>\n{_why(exc)}", again)
+        finally:
+            self._busy.discard(key)
+            if flow is not None:
+                self.flows.pop(flow.ref, None)
+
+    async def _delete_copy(self, copy_id: int) -> Optional[str]:
+        """Delete the episode's copy in the Database Channel: ``None`` when it is gone (it also counts when it was gone already),
+        else why not, as text for the message."""
+        if not copy_id:
+            return None
+        try:
+            await self.client.delete_messages(self.cfg.db_channel, [copy_id])
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            log.warning("could not delete message %s of the Database Channel: %s: %s", copy_id, type(exc).__name__, exc)
+            return clip(f"{type(exc).__name__}: {exc}", 250)
+        return None
+
+    async def _mark_deleted(self, chat_id: int, msg_id: int) -> None:
+        """The message of the post keeps its text; its Delete button turns into a note that the post is gone."""
+        try:
+            await self.client.edit_message(chat_id, msg_id, buttons=panels.to_buttons([[("🗑 Post deleted", f"{PREFIX}:x")]]))
+        except errors.MessageNotModifiedError:
+            pass
+        except Exception as exc:  # noqa: BLE001
+            log.warning("could not change the button of the post message: %s: %s", type(exc).__name__, exc)
+
     # ------------------------------------------------- the channel post bot's answers
     async def on_chat_message(self, event: Any) -> None:
         """A message of the channel post bot in the communication chat."""

tests/test_dbflow.py

@@ -7,20 +7,20 @@ import time
 from types import SimpleNamespace
 
 import pytest
-from telethon import errors
+from telethon import errors, types
 
 from bot import panels
 from bot.app import App
 from bot.config import ConfigError, load_config
 from bot.db import Database, Format
-from bot.dbflow import classify, episode_of, line_of, notice_text, reply_target
+from bot.dbflow import link_notice_text, share_link, classify, delete_button, delete_notice_text, episode_of, line_of, notice_text, post_message_id, reply_target
 from bot.formats import default_auto_format
 from bot.pipeline import Renamer
 from bot.queue import Job
 from bot.settings_ops import parse_format_channel
 
 from .appkit import ADMIN_CFG, OWNER, STRANGER, click, data_of, env_for, say
-from .tgfakes import FakeClient, FakeEvent, dispatch, document_message, flat_buttons
+from .tgfakes import FakeCallback, FakeClient, FakeEvent, dispatch, document_message, flat_buttons
 
 DB = -1002000000001  # the Database Channel
 COMM = -1003000000002  # the communication chat
@@ -42,7 +42,7 @@ async def up(tmp_path):
     await db.init()
     client = FakeClient()
     app = App(client, cfg, db)
-    app.dbflow.ack_wait, app.dbflow.result_wait = 2.0, 4.0
+    app.dbflow.ack_wait, app.dbflow.result_wait, app.dbflow.delete_wait = 2.0, 4.0, 4.0
     app._register()
     yield SimpleNamespace(app=app, client=client, db=db, cfg=cfg, tmp=tmp_path, flow=app.dbflow)
     await app.shutdown()
@@ -338,7 +338,7 @@ async def test_the_offer_asks_yes_or_no_after_the_episode(up):
     assert entity == OWNER and kw["reply_to"] == 555 and kw["parse_mode"] == "html"
     assert "Upload this episode to the Database Channel?" in text and NAME in text
     assert "Episode: <b>05</b>" in text and f"<code>{SHOW}</code>" in text
-    assert flat_buttons(kw["buttons"]) == [("✅ Yes", f"dbu:y:{OWNER}:555:{SHOW}"), ("❌ No", "dbu:n")]
+    assert flat_buttons(kw["buttons"]) == [("✅ Yes", f"dbu:y:{OWNER}:555:{SHOW}"), ("❌ No", f"dbu:n:{OWNER}:555")]
 
 
 def test_the_buttons_fit_telegrams_limit_even_for_the_biggest_ids():
@@ -487,7 +487,9 @@ async def test_the_whole_story_from_yes_to_published(up):
     assert "Post published successfully" in texts[2] and "Black Clover English" in texts[2] and "https://t.me/c/1/2" in texts[2]
     assert NAME in texts[2]
     assert {kw["message"] for _e, _t, kw in up.client.edited} == {77} and {e for e, _t, _k in up.client.edited} == {OWNER}
-    assert all(kw["buttons"] is None for _e, _t, kw in up.client.edited)
+    buttons = [kw["buttons"] for _e, _t, kw in up.client.edited]
+    assert buttons[0] is None and buttons[1] is None  # while it works there is nothing to press ...
+    assert flat_buttons(buttons[2]) == [("🗑 Delete post", f"dbu:d:4001:{SHOW}:2")]  # ... and the published post can be deleted again
     assert up.flow.flows == {} and up.flow._busy == set()
 
 
@@ -709,3 +711,412 @@ async def test_strangers_cannot_press_the_buttons(up):
 async def test_a_broken_button_does_nothing(up, data):
     cb = await click(up, OWNER, data)
     assert cb.answers and not up.client.forwarded and up.flow._busy == set() and not up.flow._tasks
+
+
+# ---------------------------------------------------------------------------
+# 🗑 Delete post: the button, the question, the channel post bot, the copy in the Database Channel
+# ---------------------------------------------------------------------------
+
+DELETE = f"dbu:d:4001:{SHOW}:57"  # the button of the published post (copy 4001 in the Database Channel, post 57 in the channel)
+YES = f"dbu:dy:4001:{SHOW}:57:77"  # ... and the Yes of the question about it (77: the message of the published post)
+
+
+async def published(up, *, extra=""):
+    """The whole upload, answered with "Post published successfully": its message (77) now has the Delete button."""
+    await start_upload(up)
+    nid, text, _ = await the_notice(up)
+    ref = ref_of(text)
+    await post_bot_says(up, f"📥 Message received - checking the Database Channel…\nRef: {ref}", reply_to=nid)
+    done = f"✅ Post published successfully\nChannel: Black Clover English\nPost: https://t.me/c/1/57\nMessage: 57\n{extra}File: {NAME}\nRef: {ref}"
+    await post_bot_says(up, done, reply_to=nid)
+    await up.flow.idle()
+
+
+def to_owner(up):
+    return [(2000 + n, text, kw) for n, (entity, text, kw) in enumerate(up.client.sent, 1) if entity == OWNER]
+
+
+async def ask(up):
+    """Press Delete post, then Yes; the id of the question's message."""
+    await click(up, OWNER, DELETE, msg_id=77)
+    qid = to_owner(up)[-1][0]
+    await click(up, OWNER, YES, msg_id=qid)
+    return qid
+
+
+async def post_bot_deletes(up, nth, *answer):
+    """What the channel post bot says to the nth notice: each of ``answer`` (with REF in it) as a reply."""
+    nid, text, _ = await the_notice(up, nth)
+    ref = ref_of(text)
+    for line in answer:
+        await post_bot_says(up, line.replace("REF", ref), reply_to=nid)
+    return ref
+
+
+OK = "🗑 Post deleted successfully\nChannel: Black Clover English\nMessage: 57\nRef: REF"
+GOT = "📥 Message received - deleting the post…\nRef: REF"
+
+
+async def test_the_published_post_gets_a_delete_button_only_when_its_id_is_known(up):
+    await published(up)
+    assert flat_buttons(up.client.edited[-1][2]["buttons"]) == [("🗑 Delete post", DELETE)]
+    assert up.client.edited[0][2]["buttons"] is None and up.client.edited[1][2]["buttons"] is None
+
+
+async def test_without_a_post_id_there_is_no_button(up):
+    await start_upload(up)
+    nid, text, _ = await the_notice(up)
+    await post_bot_says(up, f"✅ Post published successfully\nChannel: X\nRef: {ref_of(text)}", reply_to=nid)
+    await up.flow.idle()
+    assert up.client.edited[-1][2]["buttons"] is None
+
+
+@pytest.mark.parametrize(
+    "reply, expected",
+    [
+        ("Post: https://t.me/x/58\nMessage: 57", 57),
+        ("Post: https://t.me/blackclover/58", 58),
+        ("Post: https://t.me/c/123/59", 59),
+        ("Message: abc\nPost: https://t.me/c/123/60", 60),
+        ("Channel: X", None),
+        ("Post: https://t.me/c/123/5?single", None),
+    ],
+)
+def test_the_post_id_comes_from_the_message_line_or_the_link(reply, expected):
+    assert post_message_id(reply) == expected
+
+
+def test_the_delete_notice_and_the_button_limit():
+    assert delete_notice_text(channel=SHOW, message=57, ref="ab12").splitlines() == [
+        "Delete the published post", f"Channel: {SHOW}", "Message: 57", "Ref: ab12"
+    ]
+    assert delete_button(10**40, SHOW, 57) is None
+
+
+@pytest.mark.parametrize(
+    "text, expected",
+    [
+        ("🗑 Post deleted successfully\nRef: x", ("ok", "")),
+        ("❌ Deletion failed: no right\nRef: x", ("fail", "no right")),
+        ("📥 Message received - deleting the post…", ("ack", "")),
+        ("❌ Publication failed: nope", ("fail", "nope")),
+    ],
+)
+def test_the_deletion_answers_are_understood(text, expected):
+    assert classify(text) == expected
+
+
+async def test_pressing_the_button_only_asks(up):
+    await published(up)
+    cb = await click(up, OWNER, DELETE, msg_id=77)
+    (qid, text, kw), = to_owner(up)[-1:]
+    assert cb.answers and "Are you sure you want to delete this post?" in text and str(SHOW) in text
+    assert kw["reply_to"] == 77 and kw["parse_mode"] == "html"
+    assert flat_buttons(kw["buttons"]) == [("✅ Yes, delete it", YES), ("❌ No", "dbu:dn")]
+    assert all(len(d.encode()) <= 64 for _l, d in flat_buttons(kw["buttons"]))
+    assert up.client.deleted == [] and len(notices(up)) == 1 and len(up.client.edited) == 3  # nothing happened yet
+
+
+async def test_no_closes_the_question(up):
+    await published(up)
+    cb = await click(up, OWNER, "dbu:dn", msg_id=500)
+    assert cb.deleted and cb.toasts == ["Okay, nothing is deleted."] and up.client.deleted == [] and len(notices(up)) == 1
+    stuck = FakeCallback(OWNER, "dbu:dn", msg_id=500)
+    stuck.delete_error = RuntimeError("too old")
+    await dispatch(up.client, stuck)
+    assert stuck.edits[-1][0] == "Closed."
+
+
+async def test_yes_deletes_the_copy_only_after_the_channel_post_bot_says_the_post_is_gone(up):
+    await published(up)
+    await click(up, OWNER, DELETE, msg_id=77)
+    qid = to_owner(up)[-1][0]
+    cb = await click(up, OWNER, YES, msg_id=qid)
+    assert cb.edits[-1][0].startswith("⏳ <b>Deleting the post…</b>") and cb.edits[-1][1] is None
+    nid, text, kw = await the_notice(up, 2)
+    ref = ref_of(text)
+    assert text.splitlines() == ["Delete the published post", f"Channel: {SHOW}", "Message: 57", f"Ref: {ref}"] and kw["parse_mode"] is None
+    await post_bot_says(up, GOT.replace("REF", ref), reply_to=nid)
+    await wait_for(lambda: "got it" in str(up.client.edited[-1][1]))
+    assert up.client.deleted == []  # not before the channel post bot has said so
+    await post_bot_says(up, OK.replace("REF", ref) + "\nℹ️ The post was already gone from the channel and from My posts.", reply_to=nid)
+    await up.flow.idle()
+    assert up.client.deleted == [(DB, [4001])]
+    chat, final, kw = up.client.edited[-1]
+    assert kw["message"] == qid and kw["buttons"] is None
+    assert "Post deleted" in final and "Black Clover English" in final and "already gone" in final and "Deleted from the Database Channel" in final
+    mark = up.client.edited[-2]
+    assert mark[1] is None and mark[2]["message"] == 77 and flat_buttons(mark[2]["buttons"]) == [("🗑 Post deleted", "dbu:x")]
+    assert up.flow.flows == {} and up.flow._busy == set()
+    left = await click(up, OWNER, "dbu:x", msg_id=77)
+    assert left.toasts == ["This post is already deleted."]
+
+
+async def test_a_failure_leaves_everything_and_can_be_tried_again(up):
+    await published(up)
+    qid = await ask(up)
+    await post_bot_deletes(up, 2, GOT, "❌ Deletion failed: Telegram did not delete it & more\nRef: REF")
+    await up.flow.idle()
+    final = up.client.edited[-1]
+    assert "The post was not deleted" in final[1] and "did not delete it &amp; more" in final[1] and "was not touched" in final[1]
+    assert flat_buttons(final[2]["buttons"]) == [("🔁 Try again", YES), ("✖ Close", "dbu:dn")]
+    assert up.client.deleted == [] and up.flow._busy == set()
+    await click(up, OWNER, YES, msg_id=qid)
+    ref2 = await post_bot_deletes(up, 3, GOT, OK)
+    await up.flow.idle()
+    assert ref2 != ref_of(notices(up)[1][1]) and up.client.deleted == [(DB, [4001])]
+
+
+async def test_a_channel_post_bot_that_does_not_answer_is_reported(up):
+    await published(up)
+    up.flow.ack_wait = 0.1
+    await ask(up)
+    await up.flow.idle()
+    final = up.client.edited[-1]
+    assert "down or not responding" in final[1] and "post is not deleted" in final[1] and up.client.deleted == []
+    assert flat_buttons(final[2]["buttons"])[0][0] == "🔁 Try again"
+
+
+async def test_an_acknowledged_deletion_that_is_never_answered_is_not_called_down(up):
+    await published(up)
+    up.flow.delete_wait = 0.15
+    await ask(up)
+    await post_bot_deletes(up, 2, GOT)
+    await up.flow.idle()
+    final = up.client.edited[-1][1]
+    assert "No word from the channel post bot" in final and "down" not in final and up.client.deleted == []
+
+
+async def test_a_copy_that_cannot_be_deleted_is_reported_and_retried(up):
+    await published(up)
+    up.client.delete_errors.append(RuntimeError("no right"))
+    qid = await ask(up)
+    await post_bot_deletes(up, 2, GOT, OK)
+    await up.flow.idle()
+    chat, final, kw = up.client.edited[-1]
+    assert "deleted, but not its file in the Database Channel" in final and "RuntimeError: no right" in final
+    assert flat_buttons(kw["buttons"])[0] == ("🔁 Try again", YES) and up.client.deleted == []
+    assert [e for e in up.client.edited if e[1] is None] == []  # the post's own button is left alone until everything is done
+    await click(up, OWNER, YES, msg_id=qid)
+    await post_bot_deletes(up, 3, GOT, OK)
+    await up.flow.idle()
+    assert up.client.deleted == [(DB, [4001])] and "Post deleted" in up.client.edited[-1][1]
+
+
+async def test_a_second_tap_on_yes_does_nothing_while_it_works(up):
+    await published(up)
+    await click(up, OWNER, DELETE, msg_id=77)
+    qid = to_owner(up)[-1][0]
+    await click(up, OWNER, YES, msg_id=qid)
+    again = await click(up, OWNER, YES, msg_id=qid)
+    assert again.toasts == ["I'm already on it…"] and again.edits == []
+    await the_notice(up, 2)
+    await asyncio.sleep(0.05)
+    assert len(notices(up)) == 2
+
+
+async def test_a_notice_that_cannot_be_written_is_reported(up):
+    await published(up)
+    up.client.message_errors[COMM] = RuntimeError("chat not found")
+    await ask(up)
+    await up.flow.idle()
+    final = up.client.edited[-1][1]
+    assert "could not write in the communication chat" in final and "chat not found" in final and "Nothing was deleted" in final
+    assert up.client.deleted == [] and up.flow.flows == {} and up.flow._busy == set()
+
+
+async def test_an_unexpected_error_is_shown(up):
+    await published(up)
+
+    async def broken(*args, **kw):
+        raise RuntimeError("boom")
+
+    up.flow._answers = broken
+    await ask(up)
+    await up.flow.idle()
+    assert "Something went wrong" in up.client.edited[-1][1] and "RuntimeError: boom" in up.client.edited[-1][1]
+    assert up.flow._busy == set() and up.flow.flows == {} and up.client.deleted == []
+
+
+async def test_deleting_needs_nothing_but_the_buttons_so_it_survives_a_restart(up):
+    await click(up, OWNER, DELETE, msg_id=77)  # no upload in this run of the bot
+    qid = to_owner(up)[-1][0]
+    await click(up, OWNER, YES, msg_id=qid)
+    await post_bot_deletes(up, 1, GOT, OK)
+    await up.flow.idle()
+    assert up.client.deleted == [(DB, [4001])]
+
+
+async def test_a_post_without_a_known_copy_is_deleted_without_touching_the_database_channel(up):
+    await click(up, OWNER, f"dbu:d:0:{SHOW}:57", msg_id=77)
+    await click(up, OWNER, f"dbu:dy:0:{SHOW}:57:77", msg_id=to_owner(up)[-1][0])
+    await post_bot_deletes(up, 1, OK)
+    await up.flow.idle()
+    assert up.client.deleted == [] and "no copy in the Database Channel" in up.client.edited[-1][1]
+
+
+async def test_the_question_message_deleted_meanwhile_does_not_stop_the_deletion(up):
+    await published(up)
+    await ask(up)
+
+    async def gone(*args, **kw):
+        raise errors.MessageIdInvalidError(None)
+
+    up.client.edit_message = gone
+    await post_bot_deletes(up, 2, GOT, OK)
+    await up.flow.idle()
+    assert up.client.deleted == [(DB, [4001])] and up.flow._busy == set()
+
+
+async def test_shutdown_stops_a_deletion_that_is_waiting(up):
+    await published(up)
+    await ask(up)
+    await the_notice(up, 2)
+    await up.app.shutdown()
+    assert up.flow._tasks == set() and up.flow.flows == {} and up.flow._busy == set()
+
+
+async def test_strangers_cannot_press_the_delete_buttons(up):
+    await click(up, STRANGER, DELETE)
+    await click(up, STRANGER, f"dbu:dy:4001:{SHOW}:57:77")
+    assert not [t for _e, t, _k in up.client.sent if "Are you sure" in t] and not notices(up) and not up.flow._tasks
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        "dbu:d", "dbu:d:1:2", "dbu:d:a:b:c", f"dbu:d:-1:{SHOW}:5", f"dbu:d:1:{SHOW}:0", "dbu:d:1:0:5",
+        f"dbu:dy:1:{SHOW}:5", f"dbu:d:1:{SHOW}:5:9", f"dbu:dy:1:{SHOW}:5:x",
+    ],
+)
+async def test_a_broken_delete_button_does_nothing(up, data):
+    cb = await click(up, OWNER, data)
+    assert cb.answers and not up.client.sent and not up.client.deleted and up.flow._busy == set() and not up.flow._tasks
+
+
+async def test_without_the_chats_the_delete_button_says_it_is_switched_off(ctx):
+    cb = await click(ctx, OWNER, DELETE)
+    assert cb.alerts and "switched off" in cb.alerts[0] and not ctx.client.sent
+
+
+# ---------------------------------------------------------------------------
+# No -> "upload it and get the Share URL?" (nothing is published)
+# ---------------------------------------------------------------------------
+
+FILE_LINK = "https://t.me/filestore_bot?start=Zm9v"
+SHEET = "https://t.me/share/url?url=https%3A%2F%2Ft.me%2Ffilestore_bot%3Fstart%3DZm9v"
+ASK = f"dbu:n:{OWNER}:555"
+LINK_YES = f"dbu:l:{OWNER}:555"
+
+
+def with_button(link=SHEET, text="🔁 Share URL"):
+    row = types.KeyboardInlineButtonRow([types.KeyboardInlineButton(text, types.InlineButtonTypeUrl(link))])
+    return SimpleNamespace(id=4001, reply_markup=types.ReplyInlineMarkup([row]))
+
+
+def test_the_share_button_is_found_and_the_share_sheet_taken_off():
+    assert share_link(with_button()) == FILE_LINK and share_link(with_button(FILE_LINK)) == FILE_LINK
+    assert share_link(with_button(text="Other")) == "" and share_link(SimpleNamespace(reply_markup=None)) == "" and share_link(None) == ""
+    assert share_link(with_button("https://t.me/share/url?text=hi")) == ""
+
+
+async def test_no_asks_about_the_link_and_uploads_nothing(up):
+    cb = await click(up, OWNER, ASK, msg_id=77)
+    text, buttons = cb.edits[-1]
+    assert "Share URL" in text and "Nothing is published" in text
+    assert flat_buttons(buttons) == [("✅ Yes", LINK_YES), ("❌ No", "dbu:z")]
+    assert not up.client.forwarded and not notices(up)
+    cb = await click(up, OWNER, "dbu:z", msg_id=77)
+    assert "not uploaded" in cb.edits[-1][0] and not up.client.forwarded
+
+
+async def test_yes_uploads_and_shows_the_link_in_monospace(up):
+    up.client.messages[555] = document_message(NAME, 10, mid=555)
+    up.client.messages[4001] = with_button()
+    up.flow.link_poll = 0.01
+    await click(up, OWNER, LINK_YES, msg_id=77)
+    await up.flow.idle()
+    assert up.client.forwarded == [(DB, 555, OWNER, {"drop_author": True})] and not notices(up)  # nothing for the channel post bot
+    final = last_edit(up)
+    assert "Uploaded to the Database Channel" in final and f"<code>{FILE_LINK}</code>" in final and up.flow._busy == set()
+
+
+async def test_the_button_that_shows_up_later_is_waited_for(up):
+    up.client.messages[555] = document_message(NAME, 10, mid=555)
+    up.flow.link_poll, up.flow.link_wait = 0.01, 3.0
+    await click(up, OWNER, LINK_YES, msg_id=77)
+    await asyncio.sleep(0.1)
+    up.client.messages[4001] = with_button()
+    await up.flow.idle()
+    assert f"<code>{FILE_LINK}</code>" in last_edit(up) and not notices(up)
+
+
+async def test_when_this_bot_cannot_see_it_the_channel_post_bot_is_asked(up):
+    up.client.messages[555] = document_message(NAME, 10, mid=555)
+    up.flow.link_poll, up.flow.link_wait = 0.01, 0.05
+    await click(up, OWNER, LINK_YES, msg_id=77)
+    nid, text, kw = await the_notice(up)
+    ref = ref_of(text)
+    assert text.splitlines() == ["Get the share URL", "Post: 4001", f"Ref: {ref}"] and kw["parse_mode"] is None
+    await post_bot_says(up, f"📥 Message received - looking for the Share URL…\nRef: {ref}", reply_to=nid)
+    await post_bot_says(up, f"🔗 Share URL ready\nURL: {FILE_LINK}\nRef: {ref}", reply_to=nid)
+    await up.flow.idle()
+    assert f"<code>{FILE_LINK}</code>" in last_edit(up) and up.flow.flows == {} and up.flow._busy == set()
+
+
+async def test_a_failure_of_the_channel_post_bot_offers_to_look_again(up):
+    up.client.messages[555] = document_message(NAME, 10, mid=555)
+    up.flow.link_poll, up.flow.link_wait = 0.01, 0.05
+    await click(up, OWNER, LINK_YES, msg_id=77)
+    nid, text, _ = await the_notice(up)
+    await post_bot_says(up, f"❌ Share URL failed: No button after 45 seconds\nRef: {ref_of(text)}", reply_to=nid)
+    await up.flow.idle()
+    chat, final, kw = up.client.edited[-1]
+    assert "no Share URL" in final and "No button after 45 seconds" in final
+    assert flat_buttons(kw["buttons"]) == [("🔁 Look for the URL again", "dbu:g:4001"), ("✖ Close", "x:close")]
+    assert len(up.client.forwarded) == 1  # looking again does not upload again
+    up.client.messages[4001] = with_button()
+    await click(up, OWNER, "dbu:g:4001", msg_id=77)
+    await up.flow.idle()
+    assert f"<code>{FILE_LINK}</code>" in last_edit(up) and len(up.client.forwarded) == 1
+
+
+async def test_a_channel_post_bot_that_is_down_is_reported(up):
+    up.client.messages[555] = document_message(NAME, 10, mid=555)
+    up.flow.link_poll, up.flow.link_wait, up.flow.ack_wait = 0.01, 0.03, 0.1
+    await click(up, OWNER, LINK_YES, msg_id=77)
+    await up.flow.idle()
+    assert "no Share URL" in last_edit(up) and "did not answer" in last_edit(up)
+
+
+async def test_an_episode_that_was_deleted_or_cannot_be_uploaded_is_reported(up):
+    await click(up, OWNER, f"dbu:l:{OWNER}:999", msg_id=77)
+    await up.flow.idle()
+    assert "not there anymore" in last_edit(up)
+    up.client.messages[555] = document_message(NAME, 10, mid=555)
+    up.client.forward_errors.append(RuntimeError("no rights"))
+    up.client.fail_send_file = True
+    await click(up, OWNER, LINK_YES, msg_id=77)
+    await up.flow.idle()
+    chat, text, kw = up.client.edited[-1]
+    assert "upload to the Database Channel failed" in text and flat_buttons(kw["buttons"])[0] == ("🔁 Try again", LINK_YES)
+    assert up.flow._busy == set()
+
+
+async def test_a_second_tap_does_nothing_and_broken_buttons_are_ignored(up):
+    up.client.messages[555] = document_message(NAME, 10, mid=555)
+    up.flow.link_poll, up.flow.link_wait = 0.01, 1.0
+    await click(up, OWNER, LINK_YES, msg_id=77)
+    again = await click(up, OWNER, LINK_YES, msg_id=77)
+    assert again.toasts == ["I'm already on it…"]
+    up.client.messages[4001] = with_button()
+    await up.flow.idle()
+    assert len(up.client.forwarded) == 1
+    for data in ("dbu:l", "dbu:l:1", "dbu:l:a:b", f"dbu:l:{OWNER}:0", "dbu:g", "dbu:g:x", "dbu:n:1"):
+        cb = await click(up, OWNER, data)
+        assert cb.answers and up.flow._busy == set() and len(up.client.forwarded) == 1
+
+
+def test_the_new_answers_are_understood():
+    assert classify("🔗 Share URL ready\nURL: x") == ("ok", "") and classify("❌ Share URL failed: why") == ("fail", "why")
+    assert link_notice_text(post_id=5, ref="r").splitlines() == ["Get the share URL", "Post: 5", "Ref: r"]

tests/tgfakes.py

@@ -235,6 +235,7 @@ class FakeClient:
         self.forwarded: List[tuple] = []  # forward_messages(entity, messages, from_peer, **kw)
         self.forward_errors: List[Exception] = []  # raised by forward_messages(), one per call
         self.message_errors: dict = {}  # entity -> exception that send_message() raises for it
+        self.delete_errors: List[Exception] = []  # raised by delete_messages(), one per call
 
     async def get_me(self) -> SimpleNamespace:
         self.me_calls += 1
@@ -277,6 +278,8 @@ class FakeClient:
         return source.get(getattr(message, "id", None))
 
     async def delete_messages(self, entity: Any, ids: Any, **kw: Any) -> None:
+        if self.delete_errors:
+            raise self.delete_errors.pop(0)
         self.deleted.append((entity, list(ids) if isinstance(ids, (list, tuple)) else [ids]))
 
     async def send_file(self, entity: Any, file: Any, **kw: Any) -> SimpleNamespace: