Update app.py

app.py

@@ -1,616 +1,501 @@
-from flask import Flask, render_template, request, redirect, url_for, flash, jsonify
-from utils import temp, admin_check, get_size, get_time
-from database.users_chats_db import db
-from database.ia_filterdb import Media
-from database.filters_mdb import get_filters, find_filter, delete_filter, del_all
-from database.gfilters_mdb import get_gfilters, find_gfilter, delete_gfilter, del_allg
-from database.connections_mdb import all_connections, delete_connection, add_connection, active_connection
-from info import ADMINS, LOG_CHANNEL, SUPPORT_CHAT, WELCOM_PIC, WELCOM_TEXT, IMDB_TEMPLATE
+# app.py
+from flask import Flask, render_template, jsonify, request
 from pyrogram import Client
-import logging
 import os
 import psutil
+import time
+import shutil
 import asyncio
-
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
+from utils import get_settings, save_group_settings, get_size, humanbytes, get_time, admin_check
+from database.users_chats_db import db
+from database.ia_filterdb import Media, get_search_results, get_file_details, save_file
+from database.filters_mdb import add_filter, get_filters, delete_filter, del_all
+from database.gfilters_mdb import add_gfilter, get_gfilters, delete_gfilter, del_allg
+from database.connections_mdb import add_connection, all_connections, if_active, delete_connection, make_active, make_inactive
+from info import ADMINS, LOG_CHANNEL, CHANNELS, DATABASE_URL, DATABASE_NAME, CACHE_TIME, API_ID, API_HASH, BOT_TOKEN, UPTIME, WEB_SUPPORT, LOG_MSG
+from pymongo import MongoClient
 
 app = Flask(__name__)
-app.secret_key = 'your_secret_key'
 
 # Initialize Pyrogram Client
 bot = Client(
     name="Professor-Bot",
-    api_id=temp.API_ID,
-    api_hash=temp.API_HASH,
-    bot_token=temp.BOT_TOKEN
+    api_id=API_ID,
+    api_hash=API_HASH,
+    bot_token=BOT_TOKEN,
+    plugins=dict(root="plugins")
 )
 
+# Initialize MongoDB Client
+mongo_client = MongoClient(DATABASE_URL)
+mongo_db = mongo_client[DATABASE_NAME]
+
 @app.route('/')
-def index():
-    """
-    Render the home page of the dashboard.
-    """
-    logger.info("Rendering home page.")
-    return render_template('index.html')
-
-@app.route('/dashboard')
-async def dashboard():
-    """
-    Render the dashboard page with statistics.
-    """
-    logger.info("Rendering dashboard page.")
-    await bot.start()
-    total_users = await db.total_users_count()
-    total_chats = await db.total_chat_count()
-    total_files = await Media.count_documents()
-    db_size = await db.get_db_size()
-    free_space = 536870912 - db_size
-    db_size = get_size(db_size)
-    free_space = get_size(free_space)
-    uptime = get_time(time.time() - bot.uptime)
-    cpu_usage = psutil.cpu_percent(interval=1)
-    ram_usage = psutil.virtual_memory().percent
-    logger.info(f"Dashboard statistics: Users: {total_users}, Chats: {total_chats}, Files: {total_files}, DB Size: {db_size}, Free Space: {free_space}, Uptime: {uptime}, CPU Usage: {cpu_usage}%, RAM Usage: {ram_usage}%.")
-    return render_template('dashboard.html', 
-                           total_users=total_users, 
-                           total_chats=total_chats, 
-                           total_files=total_files, 
-                           db_size=db_size, 
-                           free_space=free_space, 
-                           uptime=uptime, 
-                           cpu_usage=cpu_usage, 
-                           ram_usage=ram_usage)
-
-@app.route('/users')
-async def users():
-    """
-    Render the page with a list of all users.
-    """
-    logger.info("Rendering users page.")
-    users = await db.get_all_users()
+def dashboard():
+    return render_template('dashboard.html')
+
+@app.route('/api/system-info')
+def system_info():
+    uptime = time.time() - UPTIME
+    uptime_str = get_time(uptime)
+    storage = shutil.disk_usage("/")
+    return jsonify({
+        "os": {
+            "name": os.name,
+            "version": os.uname().version
+        },
+        "uptime": uptime_str,
+        "storage": {
+            "total": storage.total,
+            "free": storage.free
+        }
+    })
+
+@app.route('/api/bot-stats')
+def bot_stats():
+    loop = asyncio.get_event_loop()
+    total_files = loop.run_until_complete(Media.count_documents())
+    total_users = loop.run_until_complete(db.total_users_count())
+    total_chats = loop.run_until_complete(db.total_chat_count())
+    monsize = loop.run_until_complete(db.get_db_size())
+    free = 536870912 - monsize
+    monsize = get_size(monsize)
+    free = get_size(free)
+    return jsonify({
+        "total_files": total_files,
+        "total_users": total_users,
+        "total_chats": total_chats,
+        "storage_used": monsize,
+        "storage_free": free
+    })
+
+@app.route('/api/filters')
+def get_filters_api():
+    chat_id = request.args.get('chat_id')
+    if not chat_id:
+        return jsonify({"error": "Chat ID is required"}), 400
+    loop = asyncio.get_event_loop()
+    filters = loop.run_until_complete(get_filters(chat_id))
+    return jsonify({"filters": filters})
+
+@app.route('/api/add-filter', methods=['POST'])
+def add_filter_api():
+    chat_id = request.form.get('chat_id')
+    text = request.form.get('text')
+    reply_text = request.form.get('reply_text')
+    btn = request.form.get('btn')
+    file = request.form.get('file')
+    alert = request.form.get('alert')
+    if not chat_id or not text or not reply_text:
+        return jsonify({"error": "Chat ID, text, and reply text are required"}), 400
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(add_filter(chat_id, text, reply_text, btn, file, alert))
+    return jsonify({"message": "Filter added successfully"})
+
+@app.route('/api/delete-filter', methods=['POST'])
+def delete_filter_api():
+    chat_id = request.form.get('chat_id')
+    text = request.form.get('text')
+    if not chat_id or not text:
+        return jsonify({"error": "Chat ID and text are required"}), 400
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(delete_filter(request, text, chat_id))
+    return jsonify({"message": "Filter deleted successfully"})
+
+@app.route('/api/gfilters')
+def get_gfilters_api():
+    gfilters = 'gfilters'
+    loop = asyncio.get_event_loop()
+    filters = loop.run_until_complete(get_gfilters(gfilters))
+    return jsonify({"filters": filters})
+
+@app.route('/api/add-gfilter', methods=['POST'])
+def add_gfilter_api():
+    gfilters = 'gfilters'
+    text = request.form.get('text')
+    reply_text = request.form.get('reply_text')
+    btn = request.form.get('btn')
+    file = request.form.get('file')
+    alert = request.form.get('alert')
+    if not text or not reply_text:
+        return jsonify({"error": "Text and reply text are required"}), 400
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(add_gfilter(gfilters, text, reply_text, btn, file, alert))
+    return jsonify({"message": "Global filter added successfully"})
+
+@app.route('/api/delete-gfilter', methods=['POST'])
+def delete_gfilter_api():
+    gfilters = 'gfilters'
+    text = request.form.get('text')
+    if not text:
+        return jsonify({"error": "Text is required"}), 400
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(delete_gfilter(request, text, gfilters))
+    return jsonify({"message": "Global filter deleted successfully"})
+
+@app.route('/api/users')
+def get_users_api():
+    loop = asyncio.get_event_loop()
+    users = loop.run_until_complete(db.get_all_users())
     user_list = []
-    async for user in users:
-        user_list.append({
-            'id': user['id'],
-            'name': user['name'],
-            'ban_status': user['ban_status']
-        })
-    logger.info(f"Users list retrieved: {len(user_list)} users.")
-    return render_template('users.html', users=user_list)
-
-@app.route('/chats')
-async def chats():
-    """
-    Render the page with a list of all chats.
-    """
-    logger.info("Rendering chats page.")
-    chats = await db.get_all_chats()
+    loop.run_until_complete(asyncio.gather(*(user_list.append({
+        "id": user['id'],
+        "name": user['name'],
+        "ban_status": user['ban_status']
+    }) for user in users)))
+    return jsonify({"users": user_list})
+
+@app.route('/api/chats')
+def get_chats_api():
+    loop = asyncio.get_event_loop()
+    chats = loop.run_until_complete(db.get_all_chats())
     chat_list = []
-    async for chat in chats:
-        chat_list.append({
-            'id': chat['id'],
-            'title': chat['title'],
-            'username': chat['username'],
-            'chat_status': chat['chat_status']
+    loop.run_until_complete(asyncio.gather(*(chat_list.append({
+        "id": chat['id'],
+        "title": chat['title'],
+        "username": chat['username'],
+        "chat_status": chat['chat_status']
+    }) for chat in chats)))
+    return jsonify({"chats": chat_list})
+
+@app.route('/api/files')
+def get_files_api():
+    loop = asyncio.get_event_loop()
+    files = loop.run_until_complete(Media.find().to_list(None))
+    file_list = []
+    for file in files:
+        file_list.append({
+            "file_id": file['file_id'],
+            "file_name": file['file_name'],
+            "file_size": file['file_size'],
+            "file_type": file['file_type'],
+            "mime_type": file['mime_type'],
+            "caption": file['caption']
         })
-    logger.info(f"Chats list retrieved: {len(chat_list)} chats.")
-    return render_template('chats.html', chats=chat_list)
-
-@app.route('/logs')
-def logs():
-    """
-    Render the page with bot logs.
-    """
-    logger.info("Rendering logs page.")
-    try:
-        with open('BotLog.txt', 'r') as file:
-            logs = file.readlines()
-        logger.info("Logs file read successfully.")
-        return render_template('logs.html', logs=logs)
-    except Exception as e:
-        logger.error(f"Error reading logs file: {e}")
-        flash("Error reading logs file.")
-        return redirect(url_for('index'))
-
-@app.route('/admin_panel')
-async def admin_panel():
-    """
-    Render the admin panel page.
-    """
-    logger.info("Rendering admin panel page.")
-    user_id = request.args.get('user_id')
-    if not user_id or not await admin_check(int(user_id)):
-        logger.info("User is not an admin, redirecting to index.")
-        flash("You are not authorized to access the admin panel.")
-        return redirect(url_for('index'))
-    logger.info("User is authorized to access the admin panel.")
-    return render_template('admin_panel.html', user_id=user_id)
-
-@app.route('/ban_user', methods=['POST'])
-async def ban_user():
-    """
-    Ban a user via the admin panel.
-    """
-    logger.info("Ban user request received.")
+    return jsonify({"files": file_list})
+
+@app.route('/api/add-file', methods=['POST'])
+def add_file_api():
+    if 'fileUpload' not in request.files:
+        return jsonify({"error": "No file part"}), 400
+    file = request.files['fileUpload']
+    if file.filename == '':
+        return jsonify({"error": "No selected file"}), 400
+    if file:
+        file_path = os.path.join("/app/uploads", file.filename)
+        file.save(file_path)
+        loop = asyncio.get_event_loop()
+        file_id, file_ref = loop.run_until_complete(save_file(file_path))
+        os.remove(file_path)
+        return jsonify({"file_id": file_id, "file_ref": file_ref, "message": "File uploaded successfully"})
+    return jsonify({"error": "Failed to upload file"}), 500
+
+@app.route('/api/delete-file', methods=['POST'])
+def delete_file_api():
+    file_id = request.form.get('file_id')
+    if not file_id:
+        return jsonify({"error": "File ID is required"}), 400
+    loop = asyncio.get_event_loop()
+    result = loop.run_until_complete(Media.collection.delete_one({'_id': file_id}))
+    if result.deleted_count:
+        return jsonify({"message": "File deleted successfully"})
+    else:
+        return jsonify({"error": "File not found"}), 404
+
+@app.route('/api/settings/<chat_id>')
+def get_settings_api(chat_id):
+    loop = asyncio.get_event_loop()
+    settings = loop.run_until_complete(get_settings(chat_id))
+    return jsonify({"settings": settings})
+
+@app.route('/api/save-settings', methods=['POST'])
+def save_settings_api():
+    chat_id = request.form.get('chat_id')
+    setting_key = request.form.get('setting_key')
+    setting_value = request.form.get('setting_value')
+    if not chat_id or not setting_key or not setting_value:
+        return jsonify({"error": "Chat ID, setting key, and setting value are required"}), 400
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(save_group_settings(chat_id, setting_key, setting_value))
+    return jsonify({"message": "Settings saved successfully"})
+
+@app.route('/api/ban-user', methods=['POST'])
+def ban_user_api():
     user_id = request.form.get('user_id')
-    ban_reason = request.form.get('ban_reason', "No Reason Provided")
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for banning user.")
-        flash("You are not authorized to ban users.")
-        return redirect(url_for('admin_panel', user_id=admin_id))
-    try:
-        await db.ban_user(user_id, ban_reason)
-        temp.BANNED_USERS.append(int(user_id))
-        logger.info(f"User {user_id} banned successfully with reason: {ban_reason}.")
-        flash("User banned successfully.")
-    except Exception as e:
-        logger.error(f"Error banning user {user_id}: {e}")
-        flash("Error banning user.")
-    return redirect(url_for('admin_panel', user_id=admin_id))
-
-@app.route('/unban_user', methods=['POST'])
-async def unban_user():
-    """
-    Unban a user via the admin panel.
-    """
-    logger.info("Unban user request received.")
+    ban_reason = request.form.get('ban_reason', "No Reason")
+    if not user_id:
+        return jsonify({"error": "User ID is required"}), 400
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(db.ban_user(int(user_id), ban_reason))
+    temp.BANNED_USERS.append(int(user_id))
+    return jsonify({"message": "User banned successfully"})
+
+@app.route('/api/unban-user', methods=['POST'])
+def unban_user_api():
     user_id = request.form.get('user_id')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for unbanning user.")
-        flash("You are not authorized to unban users.")
-        return redirect(url_for('admin_panel', user_id=admin_id))
-    try:
-        await db.remove_ban(user_id)
-        temp.BANNED_USERS.remove(int(user_id))
-        logger.info(f"User {user_id} unbanned successfully.")
-        flash("User unbanned successfully.")
-    except Exception as e:
-        logger.error(f"Error unbanning user {user_id}: {e}")
-        flash("Error unbanning user.")
-    return redirect(url_for('admin_panel', user_id=admin_id))
-
-@app.route('/disable_chat', methods=['POST'])
-async def disable_chat():
-    """
-    Disable a chat via the admin panel.
-    """
-    logger.info("Disable chat request received.")
+    if not user_id:
+        return jsonify({"error": "User ID is required"}), 400
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(db.remove_ban(int(user_id)))
+    temp.BANNED_USERS.remove(int(user_id))
+    return jsonify({"message": "User unbanned successfully"})
+
+@app.route('/api/disable-chat', methods=['POST'])
+def disable_chat_api():
     chat_id = request.form.get('chat_id')
-    reason = request.form.get('reason', "No Reason Provided")
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for disabling chat.")
-        flash("You are not authorized to disable chats.")
-        return redirect(url_for('admin_panel', user_id=admin_id))
-    try:
-        await db.disable_chat(chat_id, reason)
-        temp.BANNED_CHATS.append(int(chat_id))
-        logger.info(f"Chat {chat_id} disabled successfully with reason: {reason}.")
-        flash("Chat disabled successfully.")
-    except Exception as e:
-        logger.error(f"Error disabling chat {chat_id}: {e}")
-        flash("Error disabling chat.")
-    return redirect(url_for('admin_panel', user_id=admin_id))
-
-@app.route('/enable_chat', methods=['POST'])
-async def enable_chat():
-    """
-    Enable a chat via the admin panel.
-    """
-    logger.info("Enable chat request received.")
+    reason = request.form.get('reason', "No Reason")
+    if not chat_id:
+        return jsonify({"error": "Chat ID is required"}), 400
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(db.disable_chat(int(chat_id), reason))
+    temp.BANNED_CHATS.append(int(chat_id))
+    return jsonify({"message": "Chat disabled successfully"})
+
+@app.route('/api/enable-chat', methods=['POST'])
+def enable_chat_api():
     chat_id = request.form.get('chat_id')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for enabling chat.")
-        flash("You are not authorized to enable chats.")
-        return redirect(url_for('admin_panel', user_id=admin_id))
+    if not chat_id:
+        return jsonify({"error": "Chat ID is required"}), 400
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(db.re_enable_chat(int(chat_id)))
+    temp.BANNED_CHATS.remove(int(chat_id))
+    return jsonify({"message": "Chat enabled successfully"})
+
+@app.route('/api/upload-file', methods=['POST'])
+def upload_file_api():
+    if 'fileUpload' not in request.files:
+        return jsonify({"error": "No file part"}), 400
+    file = request.files['fileUpload']
+    if file.filename == '':
+        return jsonify({"error": "No selected file"}), 400
+    if file:
+        file_path = os.path.join("/app/uploads", file.filename)
+        file.save(file_path)
+        loop = asyncio.get_event_loop()
+        file_id, file_ref = loop.run_until_complete(save_file(file_path))
+        os.remove(file_path)
+        return jsonify({"file_id": file_id, "file_ref": file_ref, "message": "File uploaded successfully"})
+    return jsonify({"error": "Failed to upload file"}), 500
+
+@app.route('/api/download-file/<file_id>')
+def download_file_api(file_id):
+    loop = asyncio.get_event_loop()
+    file_details = loop.run_until_complete(get_file_details(file_id))
+    if not file_details:
+        return jsonify({"error": "File not found"}), 404
+    file = file_details[0]
+    return jsonify({
+        "file_name": file['file_name'],
+        "file_size": file['file_size'],
+        "file_type": file['file_type'],
+        "mime_type": file['mime_type'],
+        "caption": file['caption']
+    })
+
+@app.route('/api/search-files', methods=['GET'])
+def search_files_api():
+    query = request.args.get('query')
+    file_type = request.args.get('file_type')
+    if not query:
+        return jsonify({"error": "Query is required"}), 400
+    loop = asyncio.get_event_loop()
+    files, next_offset, total = loop.run_until_complete(get_search_results(query, file_type=file_type))
+    file_list = []
+    for file in files:
+        file_list.append({
+            "file_id": file['file_id'],
+            "file_name": file['file_name'],
+            "file_size": file['file_size'],
+            "file_type": file['file_type'],
+            "mime_type": file['mime_type'],
+            "caption": file['caption']
+        })
+    return jsonify({"files": file_list, "next_offset": next_offset, "total": total})
+
+@app.route('/api/broadcast', methods=['POST'])
+def broadcast_api():
+    message_text = request.form.get('message_text')
+    if not message_text:
+        return jsonify({"error": "Message text is required"}), 400
+    loop = asyncio.get_event_loop()
+    users = loop.run_until_complete(db.get_all_users())
+    total_users = loop.run_until_complete(db.total_users_count())
+    done = 0
+    blocked = 0
+    deleted = 0
+    failed = 0
+    success = 0
+
+    async def handle_user(user):
+        nonlocal success, blocked, deleted, failed, done
+        try:
+            await bot.send_message(user['id'], message_text)
+            success += 1
+        except UserIsBlocked:
+            blocked += 1
+        except InputUserDeactivated:
+            deleted += 1
+        except Exception as e:
+            failed += 1
+        done += 1
+
+    loop.run_until_complete(asyncio.gather(*(handle_user(user) for user in users)))
+
+    return jsonify({
+        "total_users": total_users,
+        "completed": done,
+        "success": success,
+        "blocked": blocked,
+        "deleted": deleted,
+        "failed": failed
+    })
+
+@app.route('/api/ban-users')
+def ban_users_api():
+    loop = asyncio.get_event_loop()
+    users = loop.run_until_complete(db.get_all_users())
+    banned_users = []
+    loop.run_until_complete(asyncio.gather(*(banned_users.append({
+        "id": user['id'],
+        "name": user['name'],
+        "ban_reason": user['ban_status']['ban_reason']
+    }) for user in users if user['ban_status']['is_banned'])))
+    return jsonify({"banned_users": banned_users})
+
+@app.route('/api/banned-chats')
+def banned_chats_api():
+    loop = asyncio.get_event_loop()
+    chats = loop.run_until_complete(db.get_all_chats())
+    banned_chats = []
+    loop.run_until_complete(asyncio.gather(*(banned_chats.append({
+        "id": chat['id'],
+        "title": chat['title'],
+        "username": chat['username'],
+        "reason": chat['chat_status']['reason']
+    }) for chat in chats if chat['chat_status']['is_disabled'])))
+    return jsonify({"banned_chats": banned_chats})
+
+@app.route('/api/user-info/<user_id>')
+def user_info_api(user_id):
     try:
-        await db.re_enable_chat(chat_id)
-        temp.BANNED_CHATS.remove(int(chat_id))
-        logger.info(f"Chat {chat_id} enabled successfully.")
-        flash("Chat enabled successfully.")
+        loop = asyncio.get_event_loop()
+        user = loop.run_until_complete(bot.get_users(int(user_id)))
+        return jsonify({
+            "first_name": user.first_name,
+            "last_name": user.last_name,
+            "username": user.username,
+            "id": user.id,
+            "dc_id": user.dc_id
+        })
     except Exception as e:
-        logger.error(f"Error enabling chat {chat_id}: {e}")
-        flash("Error enabling chat.")
-    return redirect(url_for('admin_panel', user_id=admin_id))
-
-@app.route('/delete_user', methods=['POST'])
-async def delete_user():
-    """
-    Delete a user from the database via the admin panel.
-    """
-    logger.info("Delete user request received.")
-    user_id = request.form.get('user_id')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for deleting user.")
-        flash("You are not authorized to delete users.")
-        return redirect(url_for('admin_panel', user_id=admin_id))
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/chat-info/<chat_id>')
+def chat_info_api(chat_id):
     try:
-        await db.delete_user(user_id)
-        logger.info(f"User {user_id} deleted successfully.")
-        flash("User deleted successfully.")
+        loop = asyncio.get_event_loop()
+        chat = loop.run_until_complete(bot.get_chat(int(chat_id)))
+        members_count = loop.run_until_complete(bot.get_chat_members_count(int(chat_id)))
+        return jsonify({
+            "title": chat.title,
+            "username": chat.username,
+            "id": chat.id,
+            "members_count": members_count
+        })
     except Exception as e:
-        logger.error(f"Error deleting user {user_id}: {e}")
-        flash("Error deleting user.")
-    return redirect(url_for('admin_panel', user_id=admin_id))
-
-@app.route('/delete_chat', methods=['POST'])
-async def delete_chat():
-    """
-    Delete a chat from the database via the admin panel.
-    """
-    logger.info("Delete chat request received.")
-    chat_id = request.form.get('chat_id')
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/api/restart-bot', methods=['POST'])
+def restart_bot_api():
     admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for deleting chat.")
-        flash("You are not authorized to delete chats.")
-        return redirect(url_for('admin_panel', user_id=admin_id))
-    try:
-        await db.delete_chat(chat_id)
-        logger.info(f"Chat {chat_id} deleted successfully.")
-        flash("Chat deleted successfully.")
-    except Exception as e:
-        logger.error(f"Error deleting chat {chat_id}: {e}")
-        flash("Error deleting chat.")
-    return redirect(url_for('admin_panel', user_id=admin_id))
-
-@app.route('/filters')
-async def filters():
-    """
-    Render the page with a list of all filters.
-    """
-    logger.info("Rendering filters page.")
+    if not admin_id or int(admin_id) not in ADMINS:
+        return jsonify({"error": "Unauthorized access"}), 401
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(bot.stop())
+    loop.run_until_complete(bot.start())
+    return jsonify({"message": "Bot restarted successfully"})
+
+@app.route('/api/add-connection', methods=['POST'])
+def add_connection_api():
+    group_id = request.form.get('group_id')
+    user_id = request.form.get('user_id')
+    if not group_id or not user_id:
+        return jsonify({"error": "Group ID and User ID are required"}), 400
+    loop = asyncio.get_event_loop()
+    result = loop.run_until_complete(add_connection(group_id, user_id))
+    if result:
+        return jsonify({"message": "Connection added successfully"})
+    else:
+        return jsonify({"error": "Connection already exists"}), 400
+
+@app.route('/api/delete-connection', methods=['POST'])
+def delete_connection_api():
+    group_id = request.form.get('group_id')
+    user_id = request.form.get('user_id')
+    if not group_id or not user_id:
+        return jsonify({"error": "Group ID and User ID are required"}), 400
+    loop = asyncio.get_event_loop()
+    result = loop.run_until_complete(delete_connection(user_id, group_id))
+    if result:
+        return jsonify({"message": "Connection deleted successfully"})
+    else:
+        return jsonify({"error": "Connection not found"}), 404
+
+@app.route('/api/group-stats')
+def group_stats_api():
     chat_id = request.args.get('chat_id')
-    if not chat_id or not await admin_check(int(request.args.get('admin_id'))):
-        logger.info("User is not an admin, redirecting to index.")
-        flash("You are not authorized to view filters.")
-        return redirect(url_for('index'))
-    filters_list = await get_filters(chat_id)
-    logger.info(f"Filters list retrieved for chat {chat_id}: {len(filters_list)} filters.")
-    return render_template('filters.html', chat_id=chat_id, filters=filters_list)
-
-@app.route('/global_filters')
-async def global_filters():
-    """
-    Render the page with a list of all global filters.
-    """
-    logger.info("Rendering global filters page.")
-    if not await admin_check(int(request.args.get('admin_id'))):
-        logger.info("User is not an admin, redirecting to index.")
-        flash("You are not authorized to view global filters.")
-        return redirect(url_for('index'))
-    gfilters_list = await get_gfilters('gfilters')
-    logger.info(f"Global filters list retrieved: {len(gfilters_list)} global filters.")
-    return render_template('global_filters.html', gfilters=gfilters_list)
-
-@app.route('/connections')
-async def connections():
-    """
-    Render the page with a list of all connections.
-    """
-    logger.info("Rendering connections page.")
+    if not chat_id:
+        return jsonify({"error": "Chat ID is required"}), 400
+    loop = asyncio.get_event_loop()
+    chat = loop.run_until_complete(db.get_chat(chat_id))
+    if not chat:
+        return jsonify({"error": "Chat not found"}), 404
+    return jsonify({
+        "chat_id": chat['id'],
+        "title": chat['title'],
+        "username": chat['username'],
+        "chat_status": chat['chat_status']
+    })
+
+@app.route('/api/bot-status')
+def bot_status():
+    cpu_usage = psutil.cpu_percent()
+    ram_usage = psutil.virtual_memory().percent
+    total_storage, used_storage, free_storage = shutil.disk_usage("/")
+    return jsonify({
+        "cpu_usage": cpu_usage,
+        "ram_usage": ram_usage,
+        "total_storage": humanbytes(total_storage),
+        "used_storage": humanbytes(used_storage),
+        "free_storage": humanbytes(free_storage),
+        "uptime": get_time(time.time() - UPTIME)
+    })
+
+@app.route('/api/connections')
+def connections_api():
     user_id = request.args.get('user_id')
-    if not user_id or not await admin_check(int(user_id)):
-        logger.info("User is not an admin, redirecting to index.")
-        flash("You are not authorized to view connections.")
-        return redirect(url_for('index'))
-    connections_list = await all_connections(user_id)
-    logger.info(f"Connections list retrieved for user {user_id}: {len(connections_list)} connections.")
-    return render_template('connections.html', user_id=user_id, connections=connections_list)
-
-@app.route('/settings')
-async def settings():
-    """
-    Render the settings page for a specific group.
-    """
-    logger.info("Rendering settings page.")
-    grp_id = request.args.get('grp_id')
-    if not grp_id or not await admin_check(int(request.args.get('admin_id'))):
-        logger.info("User is not an admin, redirecting to index.")
-        flash("You are not authorized to view settings.")
-        return redirect(url_for('index'))
-    settings = await db.get_settings(grp_id)
-    logger.info(f"Settings retrieved for group {grp_id}: {settings}.")
-    return render_template('settings.html', grp_id=grp_id, settings=settings)
-
-@app.route('/update_settings', methods=['POST'])
-async def update_settings():
-    """
-    Update settings for a specific group via the settings page.
-    """
-    logger.info("Update settings request received.")
-    grp_id = request.form.get('grp_id')
-    button = request.form.get('button', 'False') == 'True'
-    botpm = request.form.get('botpm', 'False') == 'True'
-    file_secure = request.form.get('file_secure', 'False') == 'True'
-    imdb = request.form.get('imdb', 'False') == 'True'
-    spell_check = request.form.get('spell_check', 'False') == 'True'
-    welcome = request.form.get('welcome', 'False') == 'True'
-    template = request.form.get('template', IMDB_TEMPLATE)
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for updating settings.")
-        flash("You are not authorized to update settings.")
-        return redirect(url_for('settings', grp_id=grp_id))
-    try:
-        await db.update_settings(grp_id, {
-            'button': button,
-            'botpm': botpm,
-            'file_secure': file_secure,
-            'imdb': imdb,
-            'spell_check': spell_check,
-            'welcome': welcome,
-            'template': template
-        })
-        logger.info(f"Settings updated for group {grp_id}.")
-        flash("Settings updated successfully.")
-    except Exception as e:
-        logger.error(f"Error updating settings for group {grp_id}: {e}")
-        flash("Error updating settings.")
-    return redirect(url_for('settings', grp_id=grp_id))
-
-@app.route('/logs/<path:filename>')
-def log_file(filename):
-    """
-    Serve a specific log file.
-    """
-    logger.info(f"Serving log file: {filename}.")
-    try:
-        with open(filename, 'r') as file:
-            logs = file.readlines()
-        logger.info(f"Log file {filename} read successfully.")
-        return render_template('log_file.html', logs=logs, filename=filename)
-    except Exception as e:
-        logger.error(f"Error reading log file {filename}: {e}")
-        flash("Error reading log file.")
-        return redirect(url_for('logs'))
-
-@app.route('/add_filter', methods=['POST'])
-async def add_filter():
-    """
-    Add a filter via the dashboard.
-    """
-    logger.info("Add filter request received.")
-    chat_id = request.form.get('chatId')
-    text = request.form.get('filterText')
-    reply_text = request.form.get('replyText')
-    btn = request.form.get('btn', '[]')
-    file = request.form.get('file', 'None')
-    alert = request.form.get('alert', 'None')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for adding filter.")
-        flash("You are not authorized to add filters.")
-        return redirect(url_for('filters', chat_id=chat_id, admin_id=admin_id))
-    try:
-        await db.add_filter(chat_id, text, reply_text, btn, file, alert)
-        logger.info(f"Filter added for group {chat_id} with text: {text}.")
-        flash("Filter added successfully.")
-    except Exception as e:
-        logger.error(f"Error adding filter for group {chat_id} with text: {text}: {e}")
-        flash("Error adding filter.")
-    return redirect(url_for('filters', chat_id=chat_id, admin_id=admin_id))
-
-@app.route('/delete_filter', methods=['POST'])
-async def delete_filter_route():
-    """
-    Delete a filter via the dashboard.
-    """
-    logger.info("Delete filter request received.")
-    chat_id = request.form.get('chatId')
-    text = request.form.get('filterText')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for deleting filter.")
-        flash("You are not authorized to delete filters.")
-        return redirect(url_for('filters', chat_id=chat_id, admin_id=admin_id))
-    try:
-        await delete_filter(request, text, chat_id)
-        logger.info(f"Filter deleted for group {chat_id} with text: {text}.")
-        flash("Filter deleted successfully.")
-    except Exception as e:
-        logger.error(f"Error deleting filter for group {chat_id} with text: {text}: {e}")
-        flash("Error deleting filter.")
-    return redirect(url_for('filters', chat_id=chat_id, admin_id=admin_id))
-
-@app.route('/add_gfilter', methods=['POST'])
-async def add_gfilter():
-    """
-    Add a global filter via the dashboard.
-    """
-    logger.info("Add global filter request received.")
-    text = request.form.get('gfilterText')
-    reply_text = request.form.get('greplyText')
-    btn = request.form.get('gbtn', '[]')
-    file = request.form.get('gfile', 'None')
-    alert = request.form.get('galert', 'None')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for adding global filter.")
-        flash("You are not authorized to add global filters.")
-        return redirect(url_for('global_filters', admin_id=admin_id))
-    try:
-        await db.add_gfilter('gfilters', text, reply_text, btn, file, alert)
-        logger.info(f"Global filter added with text: {text}.")
-        flash("Global filter added successfully.")
-    except Exception as e:
-        logger.error(f"Error adding global filter with text: {text}: {e}")
-        flash("Error adding global filter.")
-    return redirect(url_for('global_filters', admin_id=admin_id))
-
-@app.route('/delete_gfilter', methods=['POST'])
-async def delete_gfilter_route():
-    """
-    Delete a global filter via the dashboard.
-    """
-    logger.info("Delete global filter request received.")
-    text = request.form.get('gfilterText')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for deleting global filter.")
-        flash("You are not authorized to delete global filters.")
-        return redirect(url_for('global_filters', admin_id=admin_id))
-    try:
-        await delete_gfilter(request, text, 'gfilters')
-        logger.info(f"Global filter deleted with text: {text}.")
-        flash("Global filter deleted successfully.")
-    except Exception as e:
-        logger.error(f"Error deleting global filter with text: {text}: {e}")
-        flash("Error deleting global filter.")
-    return redirect(url_for('global_filters', admin_id=admin_id))
-
-@app.route('/add_connection', methods=['POST'])
-async def add_connection_route():
-    """
-    Add a connection between a user and a group via the dashboard.
-    """
-    logger.info("Add connection request received.")
-    group_id = request.form.get('groupId')
-    user_id = request.form.get('userId')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for adding connection.")
-        flash("You are not authorized to add connections.")
-        return redirect(url_for('connections', user_id=user_id, admin_id=admin_id))
-    try:
-        await add_connection(group_id, user_id)
-        logger.info(f"Connection added for user {user_id} to group {group_id}.")
-        flash("Connection added successfully.")
-    except Exception as e:
-        logger.error(f"Error adding connection for user {user_id} to group {group_id}: {e}")
-        flash("Error adding connection.")
-    return redirect(url_for('connections', user_id=user_id, admin_id=admin_id))
-
-@app.route('/delete_connection', methods=['POST'])
-async def delete_connection_route():
-    """
-    Delete a connection between a user and a group via the dashboard.
-    """
-    logger.info("Delete connection request received.")
-    user_id = request.form.get('userId')
-    group_id = request.form.get('groupId')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for deleting connection.")
-        flash("You are not authorized to delete connections.")
-        return redirect(url_for('connections', user_id=user_id, admin_id=admin_id))
-    try:
-        await delete_connection(user_id, group_id)
-        logger.info(f"Connection deleted for user {user_id} from group {group_id}.")
-        flash("Connection deleted successfully.")
-    except Exception as e:
-        logger.error(f"Error deleting connection for user {user_id} from group {group_id}: {e}")
-        flash("Error deleting connection.")
-    return redirect(url_for('connections', user_id=user_id, admin_id=admin_id))
-
-@app.route('/broadcast', methods=['POST'])
-async def broadcast():
-    """
-    Broadcast a message to all users or chats via the dashboard.
-    """
-    logger.info("Broadcast request received.")
-    message_text = request.form.get('broadcastText')
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for broadcasting.")
-        flash("You are not authorized to broadcast messages.")
-        return redirect(url_for('broadcast', admin_id=admin_id))
-    try:
-        users = await db.get_all_users()
-        total_users = await db.total_users_count()
-        done = 0
-        success = 0
-        failed = 0
-        async for user in users:
-            try:
-                await bot.send_message(user['id'], message_text)
-                success += 1
-            except Exception as e:
-                logger.error(f"Error broadcasting to user {user['id']}: {e}")
-                failed += 1
-            done += 1
-            if not done % 20:
-                logger.info(f"Broadcast in progress: Completed {done}/{total_users} users.")
-        logger.info(f"Broadcast completed: Success {success}, Failed {failed}.")
-        flash(f"Broadcast completed: Success {success}, Failed {failed}.")
-    except Exception as e:
-        logger.error(f"Error broadcasting message: {e}")
-        flash("Error broadcasting message.")
-    return redirect(url_for('broadcast', admin_id=admin_id))
-
-@app.route('/restart_bot', methods=['POST'])
-async def restart_bot():
-    """
-    Restart the bot via the dashboard.
-    """
-    logger.info("Restart bot request received.")
-    admin_id = request.form.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("Admin check failed for restarting bot.")
-        flash("You are not authorized to restart the bot.")
-        return redirect(url_for('extra_mods', admin_id=admin_id))
-    try:
-        await bot.stop()
-        logger.info("Bot stopped successfully.")
-        await bot.start()
-        logger.info("Bot started successfully.")
-        flash("Bot restarted successfully.")
-    except Exception as e:
-        logger.error(f"Error restarting bot: {e}")
-        flash("Error restarting bot.")
-    return redirect(url_for('extra_mods', admin_id=admin_id))
-
-@app.route('/extra_mods')
-async def extra_mods():
-    """
-    Render the extra mods page.
-    """
-    logger.info("Rendering extra mods page.")
-    admin_id = request.args.get('admin_id')
-    if not admin_id or not await admin_check(int(admin_id)):
-        logger.info("User is not an admin, redirecting to index.")
-        flash("You are not authorized to access extra mods.")
-        return redirect(url_for('index'))
-    logger.info("User is authorized to access extra mods.")
-    return render_template('extra_mods.html', admin_id=admin_id)
-
-@app.route('/get_recent_files', methods=['GET'])
-async def get_recent_files():
-    """
-    Get recent files for display in the dashboard.
-    """
-    logger.info("Request to get recent files.")
-    recent_files = []
-    try:
-        files = await Media.find().sort('_id', -1).limit(10).to_list(length=10)
-        for file in files:
-            recent_files.append({
-                'file_name': file['file_name'],
-                'file_size': get_size(file['file_size']),
-                'file_id': file['file_id']
+    if not user_id:
+        return jsonify({"error": "User ID is required"}), 400
+    loop = asyncio.get_event_loop()
+    groupids = loop.run_until_complete(all_connections(str(user_id)))
+    if groupids is None:
+        return jsonify({"connections": []})
+    connections = []
+    for groupid in groupids:
+        try:
+            loop = asyncio.get_event_loop()
+            ttl = loop.run_until_complete(bot.get_chat(int(groupid)))
+            title = ttl.title
+            active = loop.run_until_complete(if_active(str(user_id), str(groupid)))
+            connections.append({
+                "group_id": groupid,
+                "title": title,
+                "active": active
             })
-        logger.info(f"Recent files retrieved: {len(recent_files)} files.")
-        return jsonify(recent_files)
-    except Exception as e:
-        logger.error(f"Error retrieving recent files: {e}")
-        return jsonify([])
-
-@app.route('/get_os_info', methods=['GET'])
-def get_os_info():
-    """
-    Get operating system information for display in the dashboard.
-    """
-    logger.info("Request to get OS information.")
-    os_name = os.name
-    os_version = os.uname().version
-    logger.info(f"OS Information: Name: {os_name}, Version: {os_version}.")
-    return jsonify({'os_name': os_name, 'os_version': os_version})
+        except Exception as e:
+            print(f"Error fetching chat info: {e}")
+    return jsonify({"connections": connections})
 
 if __name__ == '__main__':
-    logger.info("Starting Flask app...")
-    app.run(host='0.0.0.0', port=8080)
+    bot.run()
+    app.run(host='0.0.0.0', port=7860, debug=False)