Update app.py

app.py

@@ -1,501 +1,616 @@
-# app.py
-from flask import Flask, render_template, jsonify, request
+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
 from pyrogram import Client
+import logging
 import os
 import psutil
-import time
-import shutil
 import asyncio
-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
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
 
 app = Flask(__name__)
+app.secret_key = 'your_secret_key'
 
 # Initialize Pyrogram Client
 bot = Client(
     name="Professor-Bot",
-    api_id=API_ID,
-    api_hash=API_HASH,
-    bot_token=BOT_TOKEN,
-    plugins=dict(root="plugins")
+    api_id=temp.API_ID,
+    api_hash=temp.API_HASH,
+    bot_token=temp.BOT_TOKEN
 )
 
-# Initialize MongoDB Client
-mongo_client = MongoClient(DATABASE_URL)
-mongo_db = mongo_client[DATABASE_NAME]
-
 @app.route('/')
-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())
+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()
     user_list = []
-    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())
+    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()
     chat_list = []
-    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']
+    async for chat in chats:
+        chat_list.append({
+            'id': chat['id'],
+            'title': chat['title'],
+            'username': chat['username'],
+            'chat_status': chat['chat_status']
         })
-    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():
+    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.")
     user_id = request.form.get('user_id')
-    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():
+    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.")
     user_id = request.form.get('user_id')
-    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():
+    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.")
     chat_id = request.form.get('chat_id')
-    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():
+    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.")
     chat_id = request.form.get('chat_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):
+    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))
     try:
-        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
-        })
+        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.")
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/api/chat-info/<chat_id>')
-def chat_info_api(chat_id):
+        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))
     try:
-        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
-        })
+        await db.delete_user(user_id)
+        logger.info(f"User {user_id} deleted successfully.")
+        flash("User deleted successfully.")
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-@app.route('/api/restart-bot', methods=['POST'])
-def restart_bot_api():
+        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')
     admin_id = request.form.get('admin_id')
-    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():
+    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.")
     chat_id = request.args.get('chat_id')
-    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():
+    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.")
     user_id = request.args.get('user_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
+    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']
             })
-        except Exception as e:
-            print(f"Error fetching chat info: {e}")
-    return jsonify({"connections": connections})
+        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})
 
 if __name__ == '__main__':
-    bot.run()
-    app.run(host='0.0.0.0', port=7860, debug=False)
+    logger.info("Starting Flask app...")
+    app.run(host='0.0.0.0', port=8080)