Commited backup

hikariatama/ftg/secret_chat.py

@@ -0,0 +1,143 @@
+#             █ █ ▀ █▄▀ ▄▀█ █▀█ ▀
+#             █▀█ █ █ █ █▀█ █▀▄ █
+#              © Copyright 2022
+#           https://t.me/hikariatama
+#
+# 🔒      Licensed under the GNU AGPLv3
+# 🌐 https://www.gnu.org/licenses/agpl-3.0.html
+
+# meta pic: https://static.dan.tatar/secret_chat_icon.png
+# meta banner: https://mods.hikariatama.ru/badges/secret_chat.jpg
+# meta developer: @hikarimods
+# requires: telethon_secret_chat
+# scope: hikka_only
+# scope: hikka_min 1.2.10
+
+import io
+import logging
+
+from telethon.events import NewMessage
+from telethon.tl.functions.channels import CreateChannelRequest
+from telethon.tl.types import Message
+from telethon.utils import get_display_name
+from telethon_secret_chat import SecretChatManager
+
+from .. import loader, utils
+
+logger = logging.getLogger(__name__)
+
+
+@loader.tds
+class SecretChatMod(loader.Module):
+    """De-secrets secret chats"""
+
+    strings = {"name": "SecretChat", "state": "👀 <b>SecretChat is now {}</b>"}
+
+    def _get_chat_id(self, chat) -> int:
+        cid = [chat.admin_id] + [chat.participant_id]
+        cid.remove(self._tg_id)
+        cid = cid[0]
+        return cid
+
+    async def _create_chat(self, chat):
+        cid = self._get_chat_id(chat)
+
+        decrypted_chat = None
+
+        async for d in self._client.iter_dialogs():
+            if d.title == f"secret-chat-with-{cid}":
+                decrypted_chat = d.entity
+
+        if not decrypted_chat:
+            decrypted_chat = (
+                await self._client(
+                    CreateChannelRequest(
+                        f"secret-chat-with-{cid}",
+                        "SecretChat conversation with {}",
+                        megagroup=True,
+                    )
+                )
+            ).chats[0]
+
+        @self._client.on(NewMessage(chats=[decrypted_chat.id]))
+        async def secret_chat_processor(event):
+            """secret_chat_processor"""
+            await self._manager.send_secret_message(chat.id, event.text)
+            await event.edit(f"<< {event.text}")
+
+        self._chats[cid] = decrypted_chat
+
+        self._manager = SecretChatManager(
+            self._client,
+            auto_accept=True,
+            new_chat_created=self._new_chat,
+        )
+        self._manager.add_secret_event_handler(func=self._replier)
+        self._chats = {}
+        self._secret_chats = {}
+
+    async def _replier(self, event):
+        if not self.get("state", False):
+            return
+
+        e = event.decrypted_event
+        user = self._secret_chats[event.message.chat_id]
+
+        if e.message:
+            await self._client.send_message(self._chats[user], f">> {e.message}")
+
+        if e.file:
+            try:
+                m = await self._manager.download_secret_media(e)
+                if m:
+                    attrs = {}
+                    f = io.BytesIO(m)
+                    if "/" in (getattr(e.media, "mime_type", "") or ""):
+                        f.name = "secret_media." + e.media.mime_type.split("/")[-1]
+
+                    if getattr(e.media, "mime_type", None) == "audio/ogg":
+                        attrs["voice_note"] = True
+
+                    if getattr(e.media, "caption", False):
+                        attrs["caption"] = e.media.caption
+
+                    if "caption" not in attrs:
+                        attrs["caption"] = ""
+
+                    attrs["caption"] = ">> " + attrs["caption"]
+
+                    await self._client.send_file(self._chats[user], f, **attrs)
+            except Exception:
+                await self._client.send_message(self._chats[user], ">>> [File]")
+
+    async def _new_chat(self, chat, _: bool):
+        if not self.get("state", False):
+            return
+
+        await self._create_chat(chat)
+        user = self._get_chat_id(chat)
+        self._secret_chats[chat.id] = user
+        u = await self._client.get_entity(user)
+        await self._client.send_message(
+            self._chats[user],
+            (
+                "㊙️ <b>New secret chat with <a"
+                f' href="tg://user?id={user}">{get_display_name(u)}</a> started</b>'
+            ),
+        )
+
+    async def on_unload(self):
+        self._client.remove_event_handler(self._manager._secret_chat_event_loop)
+        del self._manager
+        for handler in self._client.list_event_handlers():
+            if handler[0].__doc__ == "secret_chat_processor":
+                self._client.remove_event_handler(handler)
+
+    async def desecretcmd(self, message: Message):
+        """Toggle secret chat handler"""
+        current = self.get("state", False)
+        new = not current
+        self.set("state", new)
+        await utils.answer(
+            message, self.strings("state").format("on" if new else "off")
+        )