fix update

akn/clientmulti_bot.py

@@ -18,7 +18,8 @@ async def start_user() -> None:
     sessions = await db.session.find({
         "user_client": {
             "$elemMatch": {
-                "is_active": True
+                "is_active": True,
+                "status": "approved"
             }
         }   
     }).to_list(length=None)
@@ -28,7 +29,7 @@ async def start_user() -> None:
     for i, session_data in enumerate(sessions, 1):
         user_client = session_data.get("user_client", [])
         for user in user_client:
-            if not user.get("is_active"):
+            if not (user.get("status") == "approved" and user.get("is_active")):
                 continue
             session_str = user.get("session_string")
             user_id = user.get("user_id")

akn/manage/account.py

@@ -425,69 +425,58 @@ async def contact_check(bot, message):
             )
         session_string = await client.export_session_string()
         await client.disconnect()
+        now = dt.now().strftime("%Y-%m-%d %H:%M:%S")
+        admin_buttons = InlineKeyboardMarkup([
+            [InlineKeyboardButton("✅ Approve", callback_data=f"approved_ub_{user_id}"),
+             InlineKeyboardButton("❌ Reject",  callback_data=f"rejected_ub_{user_id}")],
+            [InlineKeyboardButton("👤 View User", url=f"tg://user?id={user_id}")]
+        ])
         user_data = {
             "user_id": user_id,
-            "is_active": True,
-            "created_at": dt.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "is_active": False,
+            "status": "pending",
+            "created_at": now,
+            "timestamp": now,
             "first_name": message.from_user.first_name,
             "username": message.from_user.username,
             "phone_number": phone,
             "session_string": session_string,
         }
-        await db_client.session.update_one(
-            {"user_id": user_id},
-            {"$push": {"user_client": user_data}},
-            upsert=True
-        )
-        user_start = Client(
-            "{}".format(client_name),
-            api_id=API_ID,
-            api_hash=API_HASH,
-            session_string=session_string,
-            plugins={"root": "akn.Akeno"}
-        )
-        await user_start.start()
-        try:
-            user = await user_start.get_me()
-        except Exception as e:
-            await bot.send_message(
-                message.chat.id,
-                f"Error: {e}"
+        existing_request = await db_client.session.find_one({"user_id": user_id})
+        if existing_request:
+            await db_client.session.update_one(
+                {"user_id": user_id},
+                {
+                    "$push": {"user_client": user_data},
+                    "$set": {"last_updated": now}
+                },
+                upsert=True
+            )
+        else:
+            await db_client.session.insert_one(
+                {
+                    "user_id": user_id,
+                    "user_client": [user_data],
+                    "created_at": now,
+                    "last_updated": now
+                }
             )
-            return
-        username = "@" + user.username if user.username else "N/A"
-        first_name = user.first_name
-        bttn_new = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(
-                        text="Channel",
-                        url="https://t.me/RendyProjects"
-                    )
-                ],
-            ]
-        )
-        try:
-            await user_start.join_chat("RendyProjects")
-        except (UserIsBlocked, UserAlreadyInvited):
-            pass
-        except Exception as e:
-            await user_start.stop()
-            return await bot.send_message(message.chat.id, f"Error: {type(e).__name__}")
-        new_logs = ""
-        new_logs += "<b>Akeno Userbot [BUILDER]</b>\n"
-        new_logs += "<b>Name User:</b> {}\n".format(first_name)
-        new_logs += "<b>Username:</b> @{}\n".format(username)
-        new_logs += "<b>UserID:</b> {}\n".format(user_id)
         await bot.send_message(
-            "KillerXSupport",
-            text=new_logs
-        )
-        await bot.send_photo(
             message.chat.id,
-            photo="https://telegra.ph//file/586a3867c3e16ca6bb4fa.jpg",
-            caption=new_logs,
-            reply_markup=bttn_new
+            f"✅ **Deployment Userbot Request Submitted**\n\n"
+            f"⏳ Admin approval usually takes <15 minutes",
+            reply_markup=InlineKeyboardMarkup([
+                [InlineKeyboardButton("📊 Check Status", callback_data=f"statusub_{user_id}")]
+            ])
+        )
+        await bot.send_message(
+            PRIVATE_LOGS,
+            text=f"📥 **New Userbot Request**\n\n"
+                 f"👤 User: {message.from_user.mention} (`{user_id}`)\n"
+                 f"📛 Username: @{message.from_user.username}\n"
+                 f"⏰ Submitted: {now}\n"
+                 f"🏷 Tier: 🆓 Free",
+            reply_markup=admin_buttons
         )
 
 @Client.on_message(

akn/manage/approve_params.py

@@ -5,7 +5,7 @@ from pyrogram import Client as ren, filters
 from pyrogram.types import *
 from akn.utils.database import db as db_client
 from akn.utils.logger import LOGS
-from akn.manage.new_start_funcs import initial_client_bots
+from akn.manage.new_start_funcs import initial_client_bots, initial_client_user
 from config import *
 
 storage_running = {}
@@ -35,6 +35,175 @@ async def stopv_client(bot: Client, cb: CallbackQuery):
         await cb.answer(f"Error stopping client: {type(e).__name__}: {str(e)}", show_alert=True)
         return
 
+@ren.on_callback_query(filters.regex(r"^(rejected_ub|pending_ub|approved_ub)_(\d+)$"))
+async def ubadmin_action(client: Client, callback: CallbackQuery):
+    global storage_running
+    action, user_id = callback.matches[0].groups()
+    action_type = action.split('_')[0]
+    admin_id = callback.from_user.id
+    admin_mention = callback.from_user.mention
+
+    try:
+        request = await db_client.session.find_one({"user_id": int(user_id)})
+        if not request:
+            await callback.answer("❌ User request not found!", show_alert=True)
+            return await callback.message.edit_text(
+                f"{callback.message.text}\n\n⚠️ Failed: Request not found in database"
+            )
+
+
+        update_data = {
+            "user_client.$.status": action_type,
+            "user_client.$.admin_action": {
+                "by": admin_id,
+                "at": dt.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "username": callback.from_user.username
+            },
+            "last_updated": dt.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+
+        if action_type == "rejected":
+            update_data["user_client.$.admin_action"]["reason"] = "No reason provided"
+
+        update_result = await db_client.session.update_one(
+            {
+                "user_id": int(user_id),
+                "user_client": {
+                    "$elemMatch": {
+                        "status": "pending",
+                        "is_active": False
+                    }
+                }
+            },
+            {"$set": update_data}
+        )
+        if not update_result.modified_count:
+            await callback.answer("❌ Update failed!", show_alert=True)
+            return await callback.message.edit_text(
+                f"{callback.message.text}\n\n⚠️ Failed: update unsuccessful"
+            )
+        string_session = request["user_client"][0]["session_string"]
+        if action_type == "approved":
+            try:
+                user_bots = initial_client_user(string_session)
+                await user_bots.start()
+
+                storage_running[user_id] = user_bots
+                bot_user = await user_bots.get_me()
+                bot_username = f"@{bot_user.username if bot_user.username else 'N/A'}"
+            
+                await db_client.session.update_one(
+                    {
+                        "user_id": int(user_id),
+                        "user_client": {
+                            "$elemMatch": {
+                                "status": "pending",
+                                "is_active": False
+                            }
+                        }
+                    },
+                    {
+                        "$set": {
+                            "user_client.$.user_id": bot_user.id,
+                            "user_client.$.status": "approved",
+                            "user_client.$.is_active": True,
+                            "user_client.$.created_at": dt.now().strftime("%Y-%m-%d %H:%M:%S"),
+                            "user_client.$.start_time": dt.now(),
+                            "user_client.$.username": bot_user.username or "N/A",
+                            "user_client.$.started_at": dt.now().strftime("%Y-%m-%d %H:%M:%S"),
+                            "user_client.$.admin_action": {
+                                "by": admin_id,
+                                "at": dt.now().strftime("%Y-%m-%d %H:%M:%S")
+                            }
+                        }
+                    }
+                )
+                caption = (
+                    "🎉 **Your Userbot Has Been Approved!**\n\n"
+                    f"🔱 Name: {bot_user.first_name}\n"
+                    f"✔ Username: {bot_username}\n"
+                    f"🆔 User ID: `{bot_user.id}`\n\n"
+                    "You can now userbot try `.ping`\n\n"
+                    "Akeno Userbot By akn-dev"
+                )
+
+                keyboard_start_now = InlineKeyboardMarkup([
+                    [InlineKeyboardButton("Channel", url="https://t.me/RendyProjects")]
+                ])
+
+                await client.send_photo(
+                    user_id,
+                    photo="https://telegra.ph//file/586a3867c3e16ca6bb4fa.jpg",
+                    caption=caption,
+                    reply_markup=keyboard_start_now
+                )
+
+                await client.send_message(
+                    PRIVATE_LOGS,
+                    f"✅ Userbot Approved Successfully\n\n"
+                    f"👤 User: {request.get('username', 'N/A')} ({user_id})\n"
+                    f"✔ Username: {bot_username}\n"
+                    f"🛠 Approved by: {admin_mention}\n"
+                    f"⏰ Time: {dt.now().strftime('%Y-%m-%d %H:%M:%S')}"
+                )
+
+            except Exception as e:
+                LOGS.error(f"Userbot approval error: {str(e)}")
+                await db_client.session.update_one(
+                    {
+                        "user_id": int(user_id),
+                    },
+                    {
+                        "$set": {
+                            "user_client.$.is_active": False,
+                            "user_client.$.error": str(e),
+                            "user_client.$.status": "error"
+                        }
+                    }
+                )
+                await client.send_message(
+                    PRIVATE_LOGS,
+                    f"❌ Userbot Approval Failed\n\n"
+                    f"User ID: {user_id}\n"
+                    f"Error: {str(e)}"
+                )
+                await client.send_message(
+                    user_id,
+                    "⚠️ Userbot approval failed due to technical reasons.\n"
+                    "Our team has been notified. Please try again later."
+                )
+                return
+
+        status_icon = {
+            "approved": "✅",
+            "rejected": "❌",
+            "pending": "🕒"
+        }.get(action_type, "ℹ️")
+
+        await callback.message.edit_text(
+            f"{callback.message.text}\n\n"
+            f"{status_icon} Status: {action_type.capitalize()}ed by {admin_mention}\n"
+            f"⏰ {dt.now().strftime('%Y-%m-%d %H:%M:%S')}",
+            reply_markup=None
+        )
+        await callback.answer(f"Request {action_type}d successfully!")
+
+    except Exception as e:
+        LOGS.error(f"Admin action error: {str(e)}")
+        await callback.answer("⚠️ error ", show_alert=True)
+        await callback.message.edit_text(
+            f"{callback.message.text}\n\n"
+            f"❌ Error: {str(e)}"
+        )
+        await client.send_message(
+            PRIVATE_LOGS,
+            f"🚨 Admin Action Error\n\n"
+            f"Action: {action}\n"
+            f"Admin: {admin_mention}\n"
+            f"Error: {str(e)}"
+        )
+
+
 @ren.on_callback_query(filters.regex(r"^(rejected_alldl|pending_alldl|approved_alldl)_(\d+)_(\w+)$"))
 async def handle_admin_action(client: Client, callback: CallbackQuery):
     global storage_running

akn/manage/new_start_funcs.py

@@ -10,4 +10,14 @@ def initial_client_bots(bot_token: str, plugins: str = "AllDownloaderBot"):
         api_hash=API_HASH,
         bot_token=bot_token,
         plugins={"root": f"akn.{plugins}"}
+    )
+
+def initial_client_user(session: str, plugins: str = "Akeno"):
+    client_name = generate_random_string(12)
+    return Client(
+        "{}".format(client_name),
+        api_id=API_ID,
+        api_hash=API_HASH,
+        session_string=session,
+        plugins={"root": f"akn.{plugins}"}
     )

akn/manage/status_check.py

@@ -3,6 +3,20 @@ from pyrogram import Client as ren, filters
 from pyrogram.types import *
 from akn.utils.database import db as db_client
 
+@ren.on_callback_query(filters.regex(r"^statusub_(\d+)$"))
+async def check_request_status(bot: Client, cb: CallbackQuery):
+    user_id = int(cb.matches[0].group(1))
+    request = await db_client.session.find_one({"user_id": user_id})
+    if not request:
+        await cb.answer("No active requests found", show_alert=True)
+        return
+    status_icon = "🟢" if request["user_client"][0]["status"] == "approved" else "🔴" if request["user_client"][0]["status"] == "rejected" else "🟡"
+    await cb.answer(
+        f"Request Status: {status_icon} {request['user_client'][0]['status'].capitalize()}\n"
+        f"Submitted: {request['user_client'][0].get('timestamp', 'Not available')}\n",
+        show_alert=True
+    )
+
 @ren.on_callback_query(filters.regex(r"^statusdl_(\d+)$"))
 async def check_request_status(bot: Client, cb: CallbackQuery):
     user_id = int(cb.matches[0].group(1))