Update app.py

app.py

@@ -1,4 +1,4 @@
-# File: C:\Users\Shakeel\Desktop\PROFESSOR-BOT\app.py
+# app.py
 from flask import Flask, render_template, jsonify, request
 from pyrogram import Client
 import os
@@ -52,11 +52,12 @@ def system_info():
     })
 
 @app.route('/api/bot-stats')
-async def bot_stats():
-    total_files = await Media.count_documents()
-    total_users = await db.total_users_count()
-    total_chats = await db.total_chat_count()
-    monsize = await db.get_db_size()
+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)
@@ -69,15 +70,16 @@ async def bot_stats():
     })
 
 @app.route('/api/filters')
-async def get_filters_api():
+def get_filters_api():
     chat_id = request.args.get('chat_id')
     if not chat_id:
         return jsonify({"error": "Chat ID is required"}), 400
-    filters = await get_filters(chat_id)
+    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'])
-async def add_filter_api():
+def add_filter_api():
     chat_id = request.form.get('chat_id')
     text = request.form.get('text')
     reply_text = request.form.get('reply_text')
@@ -86,26 +88,29 @@ async def add_filter_api():
     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
-    await add_filter(chat_id, text, reply_text, btn, file, alert)
+    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'])
-async def delete_filter_api():
+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
-    await delete_filter(request, text, chat_id)
+    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')
-async def get_gfilters_api():
+def get_gfilters_api():
     gfilters = 'gfilters'
-    filters = await get_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'])
-async def add_gfilter_api():
+def add_gfilter_api():
     gfilters = 'gfilters'
     text = request.form.get('text')
     reply_text = request.form.get('reply_text')
@@ -114,46 +119,49 @@ async def add_gfilter_api():
     alert = request.form.get('alert')
     if not text or not reply_text:
         return jsonify({"error": "Text and reply text are required"}), 400
-    await add_gfilter(gfilters, text, reply_text, btn, file, alert)
+    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'])
-async def delete_gfilter_api():
+def delete_gfilter_api():
     gfilters = 'gfilters'
     text = request.form.get('text')
     if not text:
         return jsonify({"error": "Text is required"}), 400
-    await delete_gfilter(request, text, gfilters)
+    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')
-async def get_users_api():
-    users = await db.get_all_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']
-        })
+    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')
-async def get_chats_api():
-    chats = await db.get_all_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')
-async def get_files_api():
-    files = await Media.find().to_list(None)
+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({
@@ -167,7 +175,7 @@ async def get_files_api():
     return jsonify({"files": file_list})
 
 @app.route('/api/add-file', methods=['POST'])
-async def add_file_api():
+def add_file_api():
     file_id = request.form.get('file_id')
     file_ref = request.form.get('file_ref')
     file_name = request.form.get('file_name')
@@ -187,77 +195,85 @@ async def add_file_api():
         caption=caption
     )
     try:
-        await file.commit()
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(file.commit())
     except Exception as e:
         return jsonify({"error": str(e)}), 500
     return jsonify({"message": "File added successfully"})
 
 @app.route('/api/delete-file', methods=['POST'])
-async def delete_file_api():
+def delete_file_api():
     file_id = request.form.get('file_id')
     if not file_id:
         return jsonify({"error": "File ID is required"}), 400
-    result = await Media.collection.delete_one({'_id': file_id})
+    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>')
-async def get_settings_api(chat_id):
-    settings = await get_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'])
-async def save_settings_api():
+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
-    await save_group_settings(chat_id, setting_key, setting_value)
+    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'])
-async def ban_user_api():
+def ban_user_api():
     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
-    await db.ban_user(int(user_id), ban_reason)
+    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'])
-async def unban_user_api():
+def unban_user_api():
     user_id = request.form.get('user_id')
     if not user_id:
         return jsonify({"error": "User ID is required"}), 400
-    await db.remove_ban(int(user_id))
+    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'])
-async def disable_chat_api():
+def disable_chat_api():
     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
-    await db.disable_chat(int(chat_id), reason)
+    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'])
-async def enable_chat_api():
+def enable_chat_api():
     chat_id = request.form.get('chat_id')
     if not chat_id:
         return jsonify({"error": "Chat ID is required"}), 400
-    await db.re_enable_chat(int(chat_id))
+    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'])
-async def upload_file_api():
+def upload_file_api():
     if 'fileUpload' not in request.files:
         return jsonify({"error": "No file part"}), 400
     file = request.files['fileUpload']
@@ -266,14 +282,16 @@ async def upload_file_api():
     if file:
         file_path = os.path.join("/app/uploads", file.filename)
         file.save(file_path)
-        file_id, file_ref = await save_file(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>')
-async def download_file_api(file_id):
-    file_details = await get_file_details(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]
@@ -286,12 +304,13 @@ async def download_file_api(file_id):
     })
 
 @app.route('/api/search-files', methods=['GET'])
-async def search_files_api():
+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
-    files, next_offset, total = await get_search_results(query, file_type=file_type)
+    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({
@@ -305,28 +324,22 @@ async def search_files_api():
     return jsonify({"files": file_list, "next_offset": next_offset, "total": total})
 
 @app.route('/api/broadcast', methods=['POST'])
-async def broadcast_api():
+def broadcast_api():
     message_text = request.form.get('message_text')
     if not message_text:
         return jsonify({"error": "Message text is required"}), 400
-    users = await db.get_all_users()
-    total_users = await db.total_users_count()
+    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 for user in users:
-        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(*[
+        asyncio.create_task(handle_user(user, message_text, success, blocked, deleted, failed, done))
+        for user in users
+    ]))
     return jsonify({
         "total_users": total_users,
         "completed": done,
@@ -336,37 +349,48 @@ async def broadcast_api():
         "failed": failed
     })
 
+async def handle_user(user, message_text, 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
+
 @app.route('/api/ban-users')
-async def ban_users_api():
-    users = await db.get_all_users()
+def ban_users_api():
+    loop = asyncio.get_event_loop()
+    users = loop.run_until_complete(db.get_all_users())
     banned_users = []
-    async for user in users:
-        if user['ban_status']['is_banned']:
-            banned_users.append({
-                "id": user['id'],
-                "name": user['name'],
-                "ban_reason": user['ban_status']['ban_reason']
-            })
+    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')
-async def banned_chats_api():
-    chats = await db.get_all_chats()
+def banned_chats_api():
+    loop = asyncio.get_event_loop()
+    chats = loop.run_until_complete(db.get_all_chats())
     banned_chats = []
-    async for chat in chats:
-        if chat['chat_status']['is_disabled']:
-            banned_chats.append({
-                "id": chat['id'],
-                "title": chat['title'],
-                "username": chat['username'],
-                "reason": chat['chat_status']['reason']
-            })
+    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>')
-async def user_info_api(user_id):
+def user_info_api(user_id):
     try:
-        user = await bot.get_users(int(user_id))
+        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,
@@ -378,57 +402,62 @@ async def user_info_api(user_id):
         return jsonify({"error": str(e)}), 500
 
 @app.route('/api/chat-info/<chat_id>')
-async def chat_info_api(chat_id):
+def chat_info_api(chat_id):
     try:
-        chat = await bot.get_chat(int(chat_id))
+        loop = asyncio.get_event_loop()
+        chat = loop.run_until_complete(bot.get_chat(int(chat_id)))
         return jsonify({
             "title": chat.title,
             "username": chat.username,
             "id": chat.id,
-            "members_count": await bot.get_chat_members_count(int(chat_id))
+            "members_count": loop.run_until_complete(bot.get_chat_members_count(int(chat_id)))
         })
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 
 @app.route('/api/restart-bot', methods=['POST'])
-async def restart_bot_api():
+def restart_bot_api():
     admin_id = request.form.get('admin_id')
     if not admin_id or int(admin_id) not in ADMINS:
         return jsonify({"error": "Unauthorized access"}), 401
-    await bot.stop()
-    await bot.start()
+    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'])
-async def add_connection_api():
+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
-    result = await add_connection(group_id, user_id)
+    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'])
-async def delete_connection_api():
+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
-    result = await delete_connection(user_id, group_id)
+    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')
-async def group_stats_api():
+def group_stats_api():
     chat_id = request.args.get('chat_id')
     if not chat_id:
         return jsonify({"error": "Chat ID is required"}), 400
-    chat = await db.get_chat(chat_id)
+    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({
@@ -453,19 +482,21 @@ def bot_status():
     })
 
 @app.route('/api/connections')
-async def connections_api():
+def connections_api():
     user_id = request.args.get('user_id')
     if not user_id:
         return jsonify({"error": "User ID is required"}), 400
-    groupids = await all_connections(str(user_id))
+    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:
-            ttl = await bot.get_chat(int(groupid))
+            loop = asyncio.get_event_loop()
+            ttl = loop.run_until_complete(bot.get_chat(int(groupid)))
             title = ttl.title
-            active = await if_active(str(user_id), str(groupid))
+            active = loop.run_until_complete(if_active(str(user_id), str(groupid)))
             connections.append({
                 "group_id": groupid,
                 "title": title,
@@ -476,5 +507,4 @@ async def connections_api():
     return jsonify({"connections": connections})
 
 if __name__ == '__main__':
-    bot.run()
     app.run(host='0.0.0.0', port=7860, debug=False)