2 new modules (#96)

* now supports reply

* Added fedutils and getmsg modules

Author: ramanveerji

utils/fedutils.py

@@ -0,0 +1,169 @@
+#  Moon-Userbot - telegram userbot
+#  Copyright (C) 2020-present Moon Userbot Organization
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import asyncio
+from pyrogram import Client, filters
+from pyrogram.types import Message
+
+from utils.db import db
+from utils.scripts import format_exc
+from utils.misc import modules_help, prefix
+
+@Client.on_message(filters.command("fban", prefix) & filters.me)
+async def fban_cmd(client: Client, message: Message):
+    try:
+        msg = await message.edit("🌙 Starting Federation Ban...")
+        
+        # Get target and reason
+        args = message.text.split()
+        if len(args) < 2 and not message.reply_to_message:
+            return await msg.edit("❌ Reply to user or provide ID/username and reason")
+        
+        if message.reply_to_message:
+            target = message.reply_to_message.from_user.id
+            reason = " ".join(args[1:]) if len(args) > 1 else ""
+        else:
+            target = args[1]
+            reason = " ".join(args[2:]) if len(args) > 2 else ""
+
+        # Get configuration
+        fban_group = db.get("core.ats", "FBAN_GROUP_ID")
+        fed_ids = db.get("core.ats", "FED_IDS", [])
+        
+        if not fban_group:
+            return await msg.edit("❌ FBAN group not set! Use `.set_fban_group` first")
+        
+        if not fed_ids:
+            return await msg.edit("❌ No federations added! Use `.addfed` first")
+
+        # Execute commands in FBAN group
+        await client.send_message(fban_group, f"/fban {target} {reason}")
+        await asyncio.sleep(2)
+        
+        for fed_id in fed_ids:
+            await client.send_message(fban_group, f"/joinfed {fed_id}")
+            await asyncio.sleep(3)
+            await client.send_message(fban_group, f"/fban {target} {reason}")
+            await asyncio.sleep(3)
+
+        await msg.edit(f"✅ Successfully FBanned {target} in {len(fed_ids)} federations\n#MoonUB")
+
+    except Exception as e:
+        await msg.edit(f"⚠️ Error: {format_exc(e)}")
+
+@Client.on_message(filters.command("unfban", prefix) & filters.me)
+async def unfban_cmd(client: Client, message: Message):
+    try:
+        msg = await message.edit("🌙 Starting Federation Unban...")
+        
+        # Get target and reason
+        args = message.text.split()
+        if len(args) < 2 and not message.reply_to_message:
+            return await msg.edit("❌ Reply to user or provide ID/username and reason")
+        
+        if message.reply_to_message:
+            target = message.reply_to_message.from_user.id
+            reason = " ".join(args[1:]) if len(args) > 1 else ""
+        else:
+            target = args[1]
+            reason = " ".join(args[2:]) if len(args) > 2 else ""
+
+        # Get configuration
+        fban_group = db.get("core.ats", "FBAN_GROUP_ID")
+        fed_ids = db.get("core.ats", "FED_IDS", [])
+        
+        if not fban_group:
+            return await msg.edit("❌ FBAN group not set! Use `.set_fban_group` first")
+        
+        if not fed_ids:
+            return await msg.edit("❌ No federations added! Use `.addfed` first")
+
+        # Execute commands in FBAN group
+        await client.send_message(fban_group, f"/unfban {target} {reason}")
+        await asyncio.sleep(2)
+        
+        for fed_id in fed_ids:
+            await client.send_message(fban_group, f"/joinfed {fed_id}")
+            await asyncio.sleep(3)
+            await client.send_message(fban_group, f"/unfban {target} {reason}")
+            await asyncio.sleep(3)
+
+        await msg.edit(f"✅ Successfully UnFBanned {target} in {len(fed_ids)} federations\n#MoonUB")
+
+    except Exception as e:
+        await msg.edit(f"⚠️ Error: {format_exc(e)}")
+
+@Client.on_message(filters.command("set_fban_group", prefix) & filters.me)
+async def set_fban_group(_, message: Message):
+    if len(message.command) < 2:
+        return await message.edit(f"❌ Usage: `{prefix}set_fban_group <group_id>`")
+    
+    try:
+        group_id = int(message.command[1])
+        db.set("core.ats", "FBAN_GROUP_ID", group_id)
+        await message.edit(f"✅ FBAN group set to `{group_id}`")
+    except ValueError:
+        await message.edit("❌ Invalid group ID. Must be a valid integer.")
+    except Exception as e:
+        await message.edit(f"⚠️ Error: {format_exc(e)}")
+
+@Client.on_message(filters.command("addfed", prefix) & filters.me)
+async def add_fed(_, message: Message):
+    if len(message.command) < 2:
+        return await message.edit(f"❌ Usage: `{prefix}addfed <fed_id>`")
+    
+    fed_id = message.command[1]
+    current_feds = db.get("core.ats", "FED_IDS", [])
+    
+    if fed_id in current_feds:
+        await message.edit("❌ This federation is already in the list")
+    else:
+        current_feds.append(fed_id)
+        db.set("core.ats", "FED_IDS", current_feds)
+        await message.edit(f"✅ Added federation: `{fed_id}`")
+
+@Client.on_message(filters.command("delfed", prefix) & filters.me)
+async def del_fed(_, message: Message):
+    if len(message.command) < 2:
+        return await message.edit(f"❌ Usage: `{prefix}delfed <fed_id>`")
+    
+    fed_id = message.command[1]
+    current_feds = db.get("core.ats", "FED_IDS", [])
+    
+    if fed_id not in current_feds:
+        await message.edit("❌ Federation not found in list")
+    else:
+        current_feds.remove(fed_id)
+        db.set("core.ats", "FED_IDS", current_feds)
+        await message.edit(f"✅ Removed federation: `{fed_id}`")
+
+@Client.on_message(filters.command("listfed", prefix) & filters.me)
+async def list_fed(_, message: Message):
+    current_feds = db.get("core.ats", "FED_IDS", [])
+    if not current_feds:
+        return await message.edit("❌ No federations in list")
+    
+    fed_list = "\n".join([f"• `{fed}`" for fed in current_feds])
+    await message.edit(f"📜 Federation List:\n{fed_list}")
+
+modules_help["fedutils"] = {
+    "fban [reply]/[userid]* [reason]": "Ban user in multiple federations",
+    "unfban [reply]/[userid]* [reason]": "Unban user from multiple federations",
+    "set_fban_group [group_id]*": "Set group for FBAN operations",
+    "addfed [fed_id]*": "Add federation to ban list",
+    "delfed [fed_id]*": "Remove federation from ban list",
+    "listfed": "Show current federation list"
+}

utils/getmsg.py

@@ -0,0 +1,210 @@
+#  Moon-Userbot - telegram userbot
+#  Copyright (C) 2020-present Moon Userbot Organization
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import time
+import os
+import datetime
+from typing import Union
+
+from pyrogram import Client, filters
+from pyrogram.types import Message
+from pyrogram.errors import (
+    ChatForwardsRestricted,
+    PeerIdInvalid,
+    MessageIdInvalid,
+    MessageTooLong,
+    FloodWait
+)
+from pyrogram.enums import MessageMediaType
+
+from utils.misc import modules_help, prefix
+from utils.scripts import format_exc
+
+class ProgressTracker:
+    def __init__(self):
+        self.last_update = 0
+        self.update_interval = 1
+        
+    def should_update(self):
+        now = time.time()
+        if now - self.last_update >= self.update_interval:
+            self.last_update = now
+            return True
+        return False
+
+progress_tracker = ProgressTracker()
+
+async def safe_edit(xx: Message, text: str):
+    try:
+        if progress_tracker.should_update():
+            await xx.edit(text)
+    except FloodWait as e:
+        await asyncio.sleep(e.value)
+    except Exception:
+        pass
+
+def calculate_eta(current: int, total: int, start_time: float) -> str:
+    try:
+        elapsed = time.time() - start_time
+        if elapsed < 0.1 or total == 0:
+            return "N/A"
+        
+        speed = current / elapsed
+        remaining = total - current
+        eta = remaining / speed
+        return str(datetime.timedelta(seconds=int(eta)))
+    except:
+        return "N/A"
+
+@Client.on_message(filters.command("getmsg", prefix) & filters.me)
+async def get_restricted_msg(client: Client, message: Message):
+    if len(message.command) < 2:
+        return await message.edit("❗ Please provide a link!")
+    
+    link = message.command[1]
+    xx = await message.edit("🔄 Initializing...")
+    
+    chat, msg_id = get_chat_and_msgid(link)
+    if not (chat and msg_id):
+        return await xx.edit("❌ Invalid link format!\nExample: https://t.me/c/1524685769/40392")
+
+    try:
+        msg = await client.get_messages(chat, msg_id)
+    except Exception as e:
+        return await xx.edit(f"🚫 Error retrieving message:\n`{format_exc(e)}`")
+
+    if not msg:
+        return await xx.edit("❌ Message not found")
+
+    # Try to copy message first
+    try:
+        await msg.copy(message.chat.id)
+        return await xx.delete()
+    except ChatForwardsRestricted:
+        pass
+    except Exception as e:
+        await xx.edit(f"⚠️ Forward restricted, trying alternative method...")
+
+    # Handle media content
+    if msg.media:
+        media_path = None
+        try:
+            # Download with progress
+            dl_start = time.time()
+            
+            async def dl_progress(current, total):
+                text = (
+                    f"⬇️ Downloading...\n"
+                    f"`{current * 100 / total:.1f}%` | "
+                    f"ETA: `{calculate_eta(current, total, dl_start)}`"
+                )
+                await safe_edit(xx, text)
+
+            media_path = await msg.download(progress=dl_progress)
+
+            # Upload with original formatting
+            upload_start = time.time()
+            
+            async def up_progress(current, total):
+                text = (
+                    f"⬆️ Uploading...\n"
+                    f"`{current * 100 / total:.1f}%` | "
+                    f"ETA: `{calculate_eta(current, total, upload_start)}`"
+                )
+                await safe_edit(xx, text)
+
+            common_args = {
+                "caption": msg.caption or "",
+                "caption_entities": msg.caption_entities or [],
+                "progress": up_progress
+            }
+
+            if msg.media == MessageMediaType.VIDEO:
+                await client.send_video(
+                    message.chat.id,
+                    media_path,
+                    duration=msg.video.duration,
+                    width=msg.video.width,
+                    height=msg.video.height,
+                    supports_streaming=True,
+                    **common_args
+                )
+            elif msg.media == MessageMediaType.PHOTO:
+                await client.send_photo(
+                    message.chat.id,
+                    media_path,
+                    **common_args
+                )
+            else:
+                await client.send_document(
+                    message.chat.id,
+                    media_path,
+                    force_document=False,
+                    **common_args
+                )
+
+            await xx.delete()
+        except Exception as e:
+            await xx.edit(f"❌ Error processing media:\n`{format_exc(e)}`")
+        finally:
+            if media_path and os.path.exists(media_path):
+                try:
+                    os.remove(media_path)
+                except Exception as e:
+                    print(f"Error deleting file: {e}")
+    else:
+        # Handle text messages with formatting
+        try:
+            await xx.edit(
+                f"📝 **Message content:**\n\n{msg.text}",
+                entities=msg.entities or []
+            )
+        except MessageTooLong:
+            txt_path = os.path.abspath("message.txt")
+            try:
+                with open(txt_path, "w") as f:
+                    f.write(msg.text)
+                await client.send_document(
+                    message.chat.id,
+                    txt_path,
+                    caption="Original message formatting preserved in file"
+                )
+                await xx.delete()
+            finally:
+                if txt_path and os.path.exists(txt_path):
+                    try:
+                        os.remove(txt_path)
+                    except Exception as e:
+                        print(f"Error deleting text file: {e}")
+
+def get_chat_and_msgid(link: str) -> Union[tuple, tuple[None, None]]:
+    try:
+        parts = link.strip("/").split("/")
+        if "c" in parts:
+            c_index = parts.index("c")
+            channel_id = int(parts[c_index + 1])
+            msg_id = int(parts[c_index + 2])
+            return (-1000000000000 - channel_id), msg_id
+        else:
+            msg_id = int(parts[-1])
+            chat_part = parts[-2]
+            return int(chat_part) if chat_part.isdigit() else chat_part, msg_id
+    except (ValueError, IndexError, AttributeError):
+        return None, None
+
+modules_help["getmsg"] = {
+    "getmsg [link]": "Fetch messages with full formatting preservation and cleanup",
+}