_

akn/manage/bots_manage.py

@@ -8,6 +8,7 @@ from datetime import datetime as dt
 from pyrogram import *
 from pyrogram import Client as ren, filters
 from pyrogram.types import *
+
 from akn.utils.database import db as db_client
 from akn.manage.settings_control import verify_bot_ownershipdl
 from akn.utils.logger import LOGS
@@ -45,7 +46,7 @@ async def show_user_bots(client: Client, callback: CallbackQuery):
         message_text += f"🚀 <b>Active Bots:</b> {sum(1 for b in bots_by_status['approved'] if b.get('is_active'))}\n"
         message_text += f"⏳ <b>Pending:</b> {len(bots_by_status['pending'])}\n"
         message_text += f"❌ <b>Rejected:</b> {len(bots_by_status['rejected'])}\n"
-        message_text += f"🏓 <b>Pong!:</b> {latency:.2f}.\n\n"
+        message_text += f"✔ <b>Pong:</b> `{latency:.2f} ms`\n\n"
 
         buttons = []
 
@@ -66,21 +67,21 @@ async def show_user_bots(client: Client, callback: CallbackQuery):
         if bots_by_status["pending"]:
             message_text += "\n🕒 <b>Pending Approval:</b>\n"
             for bot in bots_by_status["pending"]:
-                token_preview = bot.get("bot_token", "")[:10] + f":{bot.get('uuid', '')}"
+                token_preview = bot.get("bot_token", "")[:10] + "..."
                 submitted_time = bot.get("timestamp", "Unknown")
                 message_text += f"┣ {token_preview} - {submitted_time}\n"
 
                 buttons.append([
                     InlineKeyboardButton(
                         f"❌ Cancel {token_preview}",
-                        callback_data=f"cancelbotdl_{bot.get('uuid', 'unknown')}"
+                        callback_data=f"cancelbot_{bot.get('uuid', 'unknown')}"
                     )
                 ])
 
         if bots_by_status["rejected"]:
             message_text += "\n❌ <b>Rejected Bots:</b>\n"
             for bot in bots_by_status["rejected"]:
-                token_preview = bot.get("bot_token", "")[:10] + f":{bot.get('uuid', '')}"
+                token_preview = bot.get("bot_token", "")[:10] + "..."
                 reason = bot.get("admin_action", {}).get("reason", "No reason given")
                 message_text += f"┣ {token_preview} - {reason}\n"
 
@@ -121,7 +122,7 @@ async def show_user_bots(client: Client, callback: CallbackQuery):
             PRIVATE_LOGS,
             f"🚨 <b>Error in my_bots handler</b>\n\n"
             f"👤 User: {user_mention} ({user_id})\n"
-            f"🧠 Error: {type(e).__name__}: <code>{str(e)}</code>"
+            f"🧠 Error: <code>{str(e)}</code>"
         )
 
 @ren.on_callback_query(filters.regex(r"^botmgmt_(\w+)$"))
@@ -178,11 +179,11 @@ async def manage_single_bot(client: Client, callback: CallbackQuery):
             PRIVATE_LOGS,
             f"🚨 <b>Error in single manage handler</b>\n\n"
             f"👤 User: {user_mention} ({user_id})\n"
-            f"🧠 Error: {type(e).__name__}: <code>{str(e)}</code>"
+            f"🧠 Error: <code>{str(e)}</code>"
         )
 
 @ren.on_callback_query(filters.regex(r"^botsettingsdl_(\w+)$"))
-async def xbot_settingsdl(client: Client, callback: CallbackQuery):
+async def handle_bot_settingsdl(client: Client, callback: CallbackQuery):
     try:
         bots_uuid = callback.matches[0].group(1)
         user_id = callback.from_user.id
@@ -222,7 +223,7 @@ async def xbot_settingsdl(client: Client, callback: CallbackQuery):
             PRIVATE_LOGS,
             f"🚨 <b>Error in settingdl handler</b>\n\n"
             f"👤 User: {user_mention} ({user_id})\n"
-            f"🧠 Error: {type(e).__name__}: <code>{str(e)}</code>"
+            f"🧠 Error: <code>{str(e)}</code>"
         )
 
 @ren.on_callback_query(filters.regex("start_reset_tokendl"))
@@ -230,7 +231,7 @@ async def reset_tokendl_callbackx(client, callback_query):
     user_id = callback_query.from_user.id
     bot_data = await db_client.alldl_bot.find_one({"user_id": user_id})
     if not bot_data:
-        await callback.answer("❌ Bot not found!", show_alert=True)
+        await callback_query.answer("❌ Bot not found!", show_alert=True)
         return
     old_uuid = bot_data["bots"][0].get("uuid")
     await callback_query.message.edit_text(
@@ -334,134 +335,173 @@ async def tokenx_reset_flowdl(client: Client, callback: CallbackQuery):
             PRIVATE_LOGS,
             f"🚨 <b>Error in tokenx reset handler</b>\n\n"
             f"👤 User: {user_mention} ({user_id})\n"
-            f"🧠 Error: {type(e).__name__}: <code>{str(e)}</code>"
+            f"🧠 Error: <code>{str(e)}</code>"
         )
 
 @ren.on_callback_query(filters.regex("^noop$"))
 async def noopx_callback(client, callback_query):
     await callback_query.answer("🔒 This button is disabled.", show_alert=False)
 
-@ren.on_callback_query(filters.regex(r"^resubmitdl_(\w+)$"))
-async def resubmissiondl(client: Client, callback: CallbackQuery):
+@ren.on_callback_query(filters.regex(r"^deletebotdl_(\w+)$"))
+async def handle_delete_botdl(client: Client, callback: CallbackQuery):
     try:
         bots_uuid = callback.matches[0].group(1)
         user_id = callback.from_user.id
         user_mention = callback.from_user.mention
+        if not await verify_bot_ownershipdl(user_id, bots_uuid):
+            await callback.answer("❌ Unauthorized access!", show_alert=True)
+            return
 
         bot_data = await db_client.alldl_bot.find_one(
             {
                 "user_id": user_id,
                 "bots.uuid": bots_uuid,
-                "bots.status": "rejected"
             },
             {"bots.$": 1}
         )
 
         if not bot_data:
-            await callback.answer("❌ Bot not found or not eligible for resubmission", show_alert=True)
+            await callback.answer("❌ Bot not found!", show_alert=True)
             return
 
-        bot = bot_data["bots"][0]
-        rejection_reason = bot.get("admin_action", {}).get("reason", "No reason provided")
-
         await callback.message.edit_text(
-            f"🔄 **Resubmit Bot Request**\n\n"
+            f"⚠️ **Permanent Deletion**\n\n"
             f"🆔 UUID: `{bots_uuid}`\n"
-            f"❌ Previous Rejection Reason: {rejection_reason}\n\n"
-            "Please confirm you want to resubmit this bot for approval:",
+            f"🔗 Username: {bot_data['bots'][0].get('bot_username', 'N/A')}\n\n"
+            "This will immediately:\n"
+            "1. Stop the bot instance\n"
+            "2. Remove all download history\n"
+            "3. Delete configuration data",
             reply_markup=InlineKeyboardMarkup([
-                [InlineKeyboardButton("✅ Confirm Resubmit", callback_data=f"confirm_resubmitdl_{bots_uuid}")],
-                [InlineKeyboardButton("❌ Cancel", callback_data=f"cancel_resubmitdl_")]
+                [InlineKeyboardButton("☠️ Confirm Delete", callback_data=f"confirmdeletedl_{bots_uuid}")],
+                [InlineKeyboardButton("🔒 Cancel", callback_data=f"nodeletedl_{bots_uuid}")],
+                [InlineKeyboardButton("« Back", callback_data="my_bots")]
             ])
         )
         await callback.answer()
 
     except Exception as e:
-        LOGS.error(f"Resubmission init error: {str(e)}")
+        LOGS.error(f"Delete init error: {str(e)}")
         await callback.answer("⚠️ Error processing request", show_alert=True)
         await client.send_message(
             PRIVATE_LOGS,
-            f"🚨 <b>Error in resubm handler</b>\n\n"
+            f"🚨 <b>Error in delete_botdl handler</b>\n\n"
             f"👤 User: {user_mention} ({user_id})\n"
-            f"🧠 Error: {type(e).__name__}: <code>{str(e)}</code>"
+            f"🧠 Error: <code>{str(e)}</code>"
         )
 
-@ren.on_callback_query(filters.regex(r"^confirm_resubmitdl_(\w+)$"))
-async def confresubmissiondl(client: Client, callback: CallbackQuery):
+@ren.on_callback_query(filters.regex(r"^(confirmdeletedl|nodeletdl)_(\w+)$"))
+async def delete_confirmationdl(client: Client, callback: CallbackQuery):
+    action, bots_uuid = callback.matches[0].groups()
+    
+    if action == "nodelete":
+        await callback.message.edit_text(
+            "✅ Deletion cancelled",
+            reply_markup=InlineKeyboardMarkup([
+                [InlineKeyboardButton("« Back", callback_data="my_bots")]
+            ])
+        )
+        await callback.answer()
+        return
+
     try:
-        bots_uuid = callback.matches[0].group(1)
         user_id = callback.from_user.id
         user_mention = callback.from_user.mention
 
+
         result = await db_client.alldl_bot.update_one(
-            {
-                "user_id": user_id,
-                "bots.uuid": bots_uuid
-            },
-            {
-                "$set": {
-                    "bots.$.status": "pending",
-                    "bots.$.resubmitted_at": dt.now(),
-                    "bots.$.admin_action.reviewed": False
-                }
-            }
+            {"user_id": user_id},
+            {"$pull": {"bots": {"uuid": bots_uuid}}}
         )
 
         if result.modified_count == 1:
             await callback.message.edit_text(
-                f"✅ **Resubmission Successful**\n\n"
-                f"Bot `{bots_uuid}` has been queued for admin review.\n"
-                f"Average review time: 24-48 hours",
+                "🗑️ **Bot Deleted**\n\n"
+                f"All data for `{bots_uuid}` has been removed",
                 reply_markup=InlineKeyboardMarkup([
-                    [InlineKeyboardButton("📊 View Status", callback_data=f"statusdl_{user_id}")]
+                    [InlineKeyboardButton("📋 My Bots", callback_data="my_bots")],
                 ])
             )
-            await notify_adminsdl(
-                f"Bot resubmitteddl: {bots_uuid} by {callback.from_user.mention}",
+            await notify_admins(
+                f"🗑️ <b>Bot Deleted</b>\n\n"
+                f"User: {user_mention}\n"
+                f"UUID: {bots_uuid}\n",
                 user_id=user_id,
-                bots_uuid=bots_uuid
+                bot_uuid=bots_uuid
             )
         else:
             raise Exception("Database update failed")
 
     except Exception as e:
-        LOGS.error(f"Resubmission error: {str(e)}")
-        await callback.message.edit_text("❌ Failed to resubmit. Please try again later.")
+        LOGS.error(f"Deletion error: {str(e)}")
+        await callback.message.edit_text("❌ Deletion failed. Please contact support.")
         await client.send_message(
             PRIVATE_LOGS,
-            f"🚨 <b>Error in config resub handler</b>\n\n"
+            f"🚨 <b>Error indelete_confirmationdl handler</b>\n\n"
             f"👤 User: {user_mention} ({user_id})\n"
-            f"🧠 Error: {type(e).__name__}: <code>{str(e)}</code>"
+            f"🧠 Error: <code>{str(e)}</code>"
         )
 
-async def notify_adminsdl(text_str, user_id, bots_uuid):
-    admin_buttons = InlineKeyboardMarkup([
-        [InlineKeyboardButton("✅ Approve", callback_data=f"approved_alldl_{user_id}_{bots_uuid}"),
-         InlineKeyboardButton("❌ Reject", callback_data=f"rejected_alldl_{user_id}_{bots_uuid}")],
-        [InlineKeyboardButton("👤 View User", url=f"tg://user?id={user_id}")]
-    ])
-    await client.send_message(
-        PRIVATE_LOGS,
-        text_str,
-        reply_markup=admin_buttons
-    )
 
-@ren.on_callback_query(filters.regex(r"^cancel_resubmitdl_"))
-async def cancel_resubmitdl(client: Client, callback: CallbackQuery):
-    await callback.message.edit_text(
-        "🚫 Resubmission cancelled",
-        reply_markup=ikb([
-            [("« Back", "customzie_bot")]
-        ])
-    )
-    await callback.answer()
+@ren.on_callback_query(filters.regex(r"^resubmitdl_(\w+)$"))
+async def xresubmission(client: Client, callback: CallbackQuery):
+    try:
+        bots_uuid = callback.matches[0].group(1)
+        user_id = callback.from_user.id
+        user_mention = callback.from_user.mention
+        if not await verify_bot_ownershipdl(user_id, bots_uuid):
+            await callback.answer("❌ Unauthorized access!", show_alert=True)
+            return
+
+        bot_data = await db_client.alldl_bot.find_one(
+            {
+                "user_id": user_id,
+                "bots.uuid": bots_uuid,
+                "bots.status": "rejected"
+            },
+            {"bots.$": 1}
+        )
+
+        if not bot_data:
+            await callback.answer("❌ Bot not found or not eligible for resubmission", show_alert=True)
+            return
+
+        bot = bot_data["bots"][0]
+        rejection_reason = bot.get("admin_action", {}).get("reason", "No reason provided")
+
+
+        await callback.message.edit_text(
+            f"🔄 **Resubmit Bot Request**\n\n"
+            f"🆔 UUID: `{bots_uuid}`\n"
+            f"❌ Previous Rejection Reason: {rejection_reason}\n\n"
+            "Please confirm you want to resubmit this bot for approval:",
+            reply_markup=InlineKeyboardMarkup([
+                [InlineKeyboardButton("✅ Confirm Resubmit", callback_data=f"confirm_resubmitdl_{bots_uuid}")],
+                [InlineKeyboardButton("❌ Cancel", callback_data=f"cancel_resubmitdl_")],
+                [InlineKeyboardButton("« Back", callback_data="my_bots")]
+            ])
+        )
+        await callback.answer()
+
+    except Exception as e:
+        LOGS.error(f"Resubmission init error: {str(e)}")
+        await callback.answer("⚠️ Error processing request", show_alert=True)
+        await client.send_message(
+            PRIVATE_LOGS,
+            f"🚨 <b>Error in xresubmission handler</b>\n\n"
+            f"👤 User: {user_mention} ({user_id})\n"
+            f"🧠 Error: <code>{str(e)}</code>"
+        )
 
 @ren.on_callback_query(filters.regex(r"^cancelbotdl_(\w+)$"))
-async def cancelbotdl(client: Client, callback: CallbackQuery):
+async def handle_cancel_bot(client: Client, callback: CallbackQuery):
     try:
         bots_uuid = callback.matches[0].group(1)
         user_id = callback.from_user.id
         user_mention = callback.from_user.mention
+        if not await verify_bot_ownershipdl(user_id, bots_uuid):
+            await callback.answer("❌ Unauthorized access!", show_alert=True)
+            return
 
         bot_data = await db_client.alldl_bot.find_one(
             {
@@ -475,7 +515,7 @@ async def cancelbotdl(client: Client, callback: CallbackQuery):
         if not bot_data:
             await callback.answer("❌ No pending bot found with this ID", show_alert=True)
             return
-
+    
         await callback.message.edit_text(
             f"⚠️ **Confirm Cancellation**\n\n"
             f"UUID: `{bots_uuid}`\n"
@@ -483,7 +523,8 @@ async def cancelbotdl(client: Client, callback: CallbackQuery):
             "This will permanently remove the bot request:",
             reply_markup=InlineKeyboardMarkup([
                 [InlineKeyboardButton("🗑 Confirm Delete", callback_data=f"confirmcanceldl_{bots_uuid}")],
-                [InlineKeyboardButton("🔙 Keep Request", callback_data=f"keepbotdl_{user_id}")]
+                [InlineKeyboardButton("🔙 Keep Request", callback_data=f"keepbotdl_{user_id}")],
+                [InlineKeyboardButton("« Back", callback_data="my_bots")]
             ])
         )
         await callback.answer()
@@ -493,18 +534,21 @@ async def cancelbotdl(client: Client, callback: CallbackQuery):
         await callback.answer("⚠️ Error processing request", show_alert=True)
         await client.send_message(
             PRIVATE_LOGS,
-            f"🚨 <b>Error in cancelbotdl handler</b>\n\n"
+            f"🚨 <b>Error in cancel_bot handler</b>\n\n"
             f"👤 User: {user_mention} ({user_id})\n"
-            f"🧠 Error: {type(e).__name__}: <code>{str(e)}</code>"
+            f"🧠 Error: <code>{str(e)}</code>"
         )
 
 @ren.on_callback_query(filters.regex(r"^confirmcanceldl_(\w+)$"))
-async def confirm_cancel_botdl(client: Client, callback: CallbackQuery):
+async def confirm_cancel_bot(client: Client, callback: CallbackQuery):
     try:
         bots_uuid = callback.matches[0].group(1)
         user_id = callback.from_user.id
         user_mention = callback.from_user.mention
-        
+        if not await verify_bot_ownershipdl(user_id, bots_uuid):
+            await callback.answer("❌ Unauthorized access!", show_alert=True)
+            return
+
         result = await db_client.alldl_bot.update_one(
             {"user_id": user_id},
             {"$pull": {"bots": {"uuid": bots_uuid}}}
@@ -515,8 +559,7 @@ async def confirm_cancel_botdl(client: Client, callback: CallbackQuery):
                 "✅ **Request Cancelled**\n\n"
                 f"Bot `{bots_uuid}` has been permanently removed",
                 reply_markup=InlineKeyboardMarkup([
-                    [InlineKeyboardButton("📋 My Bots", callback_data="my_bots")],
-                    [InlineKeyboardButton("« Back", callback_data="customzie_bot")]
+                    [InlineKeyboardButton("📋 My Bots", callback_data="my_bots")]
                 ])
             )
         else:
@@ -527,19 +570,80 @@ async def confirm_cancel_botdl(client: Client, callback: CallbackQuery):
         await callback.message.edit_text("❌ Failed to cancel request. Please contact support.")
         await client.send_message(
             PRIVATE_LOGS,
-            f"🚨 <b>Error in confirm cancelbotdl handler</b>\n\n"
+            f"🚨 <b>Error in confirm cancel handler</b>\n\n"
+            f"👤 User: {user_mention} ({user_id})\n"
+            f"🧠 Error: <code>{str(e)}</code>"
+        )
+
+@ren.on_callback_query(filters.regex(r"^confirm_resubmitdl_(\w+)$"))
+async def confirm_resubmission(client: Client, callback: CallbackQuery):
+    try:
+        bots_uuid = callback.matches[0].group(1)
+        user_id = callback.from_user.id
+        user_mention = callback.from_user.mention
+        if not await verify_bot_ownershipdl(user_id, bots_uuid):
+            await callback.answer("❌ Unauthorized access!", show_alert=True)
+            return
+
+        result = await db_client.alldl_bot.update_one(
+            {
+                "user_id": user_id,
+                "bots.uuid": bots_uuid
+            },
+            {
+                "$set": {
+                    "bots.$.status": "pending",
+                    "bots.$.resubmitted_at": dt.now().strftime("%Y-%m-%d %H:%M:%S"),
+                    "bots.$.admin_action.reviewed": False
+                }
+            }
+        )
+
+        if result.modified_count == 1:
+            await callback.message.edit_text(
+                f"✅ **Resubmission Successful**\n\n"
+                f"Bot `{bots_uuid}` has been queued for admin review.\n"
+                f"Average review time: 24-48 hours",
+                reply_markup=InlineKeyboardMarkup([
+                    [InlineKeyboardButton("📊 View Status", callback_data=f"statusdl_{user_id}")]
+                ])
+            )
+            await notify_admins(
+                f"Bot resubmitted: {bots_uuid} by {callback.from_user.mention}",
+                user_id=user_id,
+                bots_uuid=bots_uuid
+            )
+        else:
+            raise Exception("Database update failed")
+
+    except Exception as e:
+        LOGS.error(f"Resubmission error: {str(e)}")
+        await callback.message.edit_text("❌ Failed to resubmit. Please try again later.")
+        await client.send_message(
+            PRIVATE_LOGS,
+            f"🚨 <b>Error in confirm_resubmission handler</b>\n\n"
             f"👤 User: {user_mention} ({user_id})\n"
-            f"🧠 Error: {type(e).__name__}: <code>{str(e)}</code>"
+            f"🧠 Error: <code>{str(e)}</code>"
         )
 
-@ren.on_callback_query(filters.regex(r"^keepbotdl_(\d+)$"))
-async def keep_bot_requestdl(client: Client, callback: CallbackQuery):
+async def notify_admins(message, user_id, bots_uuid):
+     admin_buttons = InlineKeyboardMarkup([
+        [InlineKeyboardButton("✅ Approve", callback_data=f"approved_alldl_{user_id}_{bots_uuid}"),
+         InlineKeyboardButton("❌ Reject",  callback_data=f"rejected_alldl_{user_id}_{bots_uuid}")],
+        [InlineKeyboardButton("👤 View User", url=f"tg://user?id={user_id}")]
+    ])
+     return await client.send_message(
+        chat_id=PRIVATE_LOGS,
+        text=message,
+        reply_markup=admin_buttons
+    )
+
+@ren.on_callback_query(filters.regex(r"^cancel_resubmitdl_"))
+async def cancel_resubmit(client: Client, callback: CallbackQuery):
     await callback.message.edit_text(
-        "🔄 Bot request kept in queue\n\n"
-        "Your submission remains pending admin review",
+        "🚫 Resubmission cancelled",
         reply_markup=InlineKeyboardMarkup([
-            [InlineKeyboardButton("🕒 Check Status", callback_data=f"statusdl_{callback.matches[0].group(1)}")],
-            [InlineKeyboardButton("« Back", callback_data="customzie_bot")]
+            [InlineKeyboardButton("« Back", callback_data="my_bots")]
         ])
     )
     await callback.answer()