✅ UserBot Integration Complete: Fixed container startup, integrated UserBot menu to main bot

MAJOR FIXES:
✅ Fixed UserBot container startup by making TELEGRAM_BOT_TOKEN optional
✅ Broke circular import chain between app modules
✅ Made Config.validate() conditional for UserBot-only mode
✅ Removed unused celery import from userbot_service.py

INTEGRATION:
✅ UserBot menu now accessible from main bot /start command
✅ Added 🤖 UserBot button to main keyboard
✅ Integrated userbot_manager.py handlers:
   - userbot_menu: Main UserBot interface
   - userbot_settings: Configuration
   - userbot_collect_groups: Gather all user groups
   - userbot_collect_members: Parse group members
✅ UserBot handlers properly registered in ConversationHandler

CONTAINERS:
✅ tg_autoposter_bot: Running and handling /start commands
✅ tg_autoposter_userbot: Running as standalone microservice
✅ All dependent services (Redis, PostgreSQL, Celery workers) operational

STATUS: Bot is fully operational and ready for testing

app/handlers/__init__.py

@@ -1,14 +1,20 @@
-from .commands import start, help_command
+from .commands import start, help_command, sync_groups_command
 from .callbacks import (
     start_callback, manage_messages, manage_groups,
     list_messages, list_groups
 )
 from .sender import send_message
 from .group_manager import my_chat_member
+from .userbot_manager import (
+    userbot_menu, userbot_settings, userbot_init,
+    userbot_collect_groups, userbot_collect_members,
+    userbot_parse_members, cancel_userbot
+)
 
 __all__ = [
     'start',
     'help_command',
+    'sync_groups_command',
     'start_callback',
     'manage_messages',
     'manage_groups',
@@ -16,4 +22,11 @@ __all__ = [
     'list_groups',
     'send_message',
     'my_chat_member',
+    'userbot_menu',
+    'userbot_settings',
+    'userbot_init',
+    'userbot_collect_groups',
+    'userbot_collect_members',
+    'userbot_parse_members',
+    'cancel_userbot',
 ]

app/handlers/callbacks.py

@@ -1,5 +1,5 @@
 from telegram import Update, InlineKeyboardMarkup, InlineKeyboardButton
-from telegram.ext import ContextTypes, ConversationHandler
+from telegram.ext import ContextTypes
 from app.database import AsyncSessionLocal
 from app.database.repository import GroupRepository, MessageRepository, MessageGroupRepository
 from app.utils.keyboards import (
@@ -10,16 +10,11 @@ import logging
 
 logger = logging.getLogger(__name__)
 
-# Состояния для ConversationHandler
-WAITING_MESSAGE_TEXT = 1
-WAITING_MESSAGE_TITLE = 2
-WAITING_GROUP_SELECTION = 3
-WAITING_FOR_GROUP = 4
-
 
 async def start_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Главное меню"""
     query = update.callback_query
+    logger.info(f"🔘 Получена кнопка MAIN_MENU от пользователя {update.effective_user.id}")
     await query.answer()
     
     text = """🤖 <b>Автопостер - Главное меню</b>
@@ -35,50 +30,61 @@ async def start_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
 
 async def manage_messages(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Меню управления сообщениями"""
-    query = update.callback_query
-    await query.answer()
-    
-    text = """📨 <b>Управление сообщениями</b>
+    try:
+        query = update.callback_query
+        logger.info(f"🔘 Получена кнопка MANAGE_MESSAGES от пользователя {update.effective_user.id}")
+        await query.answer()
+        
+        text = """📨 <b>Управление сообщениями</b>
 
 Выберите действие:"""
 
-    keyboard = [
-        [InlineKeyboardButton("➕ Новое сообщение", callback_data=CallbackType.CREATE_MESSAGE)],
-        [InlineKeyboardButton("📜 Список сообщений", callback_data=CallbackType.LIST_MESSAGES)],
-        [InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MAIN_MENU)],
-    ]
+        keyboard = [
+            [InlineKeyboardButton("➕ Новое сообщение", callback_data=CallbackType.CREATE_MESSAGE.value)],
+            [InlineKeyboardButton("📜 Список сообщений", callback_data=CallbackType.LIST_MESSAGES.value)],
+            [InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MAIN_MENU.value)],
+        ]
 
-    await query.edit_message_text(
-        text,
-        parse_mode='HTML',
-        reply_markup=InlineKeyboardMarkup(keyboard)
-    )
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        logger.info(f"✅ Сообщение обновлено для manage_messages")
+    except Exception as e:
+        logger.error(f"❌ Ошибка в manage_messages: {e}", exc_info=True)
 
 
 async def manage_groups(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Меню управления группами"""
-    query = update.callback_query
-    await query.answer()
-    
-    text = """👥 <b>Управление группами</b>
+    try:
+        query = update.callback_query
+        logger.info(f"🔘 Получена кнопка MANAGE_GROUPS от пользователя {update.effective_user.id}")
+        await query.answer()
+        
+        text = """👥 <b>Управление группами</b>
 
 Выберите действие:"""
 
-    keyboard = [
-        [InlineKeyboardButton("📜 Список групп", callback_data=CallbackType.LIST_GROUPS)],
-        [InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MAIN_MENU)],
-    ]
+        keyboard = [
+            [InlineKeyboardButton("📜 Список групп", callback_data=CallbackType.LIST_GROUPS.value)],
+            [InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MAIN_MENU.value)],
+        ]
 
-    await query.edit_message_text(
-        text,
-        parse_mode='HTML',
-        reply_markup=InlineKeyboardMarkup(keyboard)
-    )
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        logger.info(f"✅ Сообщение обновлено для manage_groups")
+    except Exception as e:
+        logger.error(f"❌ Ошибка в manage_groups: {e}", exc_info=True)
 
 
 async def list_messages(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Список всех сообщений"""
     query = update.callback_query
+    logger.info(f"🔘 Получена кнопка LIST_MESSAGES от пользователя {update.effective_user.id}")
     await query.answer()
 
     async with AsyncSessionLocal() as session:
@@ -87,7 +93,7 @@ async def list_messages(update: Update, context: ContextTypes.DEFAULT_TYPE) -> N
 
     if not messages:
         text = "📭 Нет сообщений"
-        keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MANAGE_MESSAGES)]]
+        keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MANAGE_MESSAGES.value)]]
     else:
         text = "📨 <b>Ваши сообщения:</b>\n\n"
         keyboard = []
@@ -100,7 +106,7 @@ async def list_messages(update: Update, context: ContextTypes.DEFAULT_TYPE) -> N
                 InlineKeyboardButton("🗑️", callback_data=f"delete_msg_{msg.id}")
             ])
         
-        keyboard.append([InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MANAGE_MESSAGES)])
+        keyboard.append([InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MANAGE_MESSAGES.value)])
 
     await query.edit_message_text(
         text,
@@ -112,6 +118,7 @@ async def list_messages(update: Update, context: ContextTypes.DEFAULT_TYPE) -> N
 async def list_groups(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Список всех групп"""
     query = update.callback_query
+    logger.info(f"🔘 Получена кнопка LIST_GROUPS от пользователя {update.effective_user.id}")
     await query.answer()
 
     async with AsyncSessionLocal() as session:
@@ -120,7 +127,7 @@ async def list_groups(update: Update, context: ContextTypes.DEFAULT_TYPE) -> Non
 
     if not groups:
         text = "👥 Нет групп в базе данных\n\nДобавьте бота в группы - они автоматически появятся здесь."
-        keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MANAGE_GROUPS)]]
+        keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MANAGE_GROUPS.value)]]
     else:
         text = "👥 <b>Группы в базе данных:</b>\n\n"
         keyboard = []
@@ -137,7 +144,7 @@ async def list_groups(update: Update, context: ContextTypes.DEFAULT_TYPE) -> Non
                 InlineKeyboardButton("🗑️", callback_data=f"delete_group_{group.id}")
             ])
         
-        keyboard.append([InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MANAGE_GROUPS)])
+        keyboard.append([InlineKeyboardButton("⬅️ Назад", callback_data=CallbackType.MANAGE_GROUPS.value)])
 
     await query.edit_message_text(
         text,

app/handlers/commands.py

@@ -3,6 +3,8 @@ from telegram.ext import ContextTypes
 from app.database import AsyncSessionLocal
 from app.database.repository import GroupRepository, MessageRepository, MessageGroupRepository
 from app.utils.keyboards import get_main_keyboard, get_groups_keyboard, get_messages_keyboard
+from app.handlers.telethon_client import telethon_manager
+from app.userbot.parser import userbot_parser
 import logging
 
 logger = logging.getLogger(__name__)
@@ -11,6 +13,7 @@ logger = logging.getLogger(__name__)
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Обработчик команды /start"""
     user = update.effective_user
+    logger.info(f"📧 Получена команда /start от пользователя {user.id} (@{user.username})")
     
     text = f"""👋 Привет, {user.first_name}!
 
@@ -32,6 +35,8 @@ async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 
 async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Обработчик команды /help"""
+    user = update.effective_user
+    logger.info(f"📧 Получена команда /help от пользователя {user.id}")
     text = """📖 Справка по использованию:
 
 <b>Основные команды:</b>
@@ -56,3 +61,165 @@ async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
 Нажмите /start для возврата в главное меню."""
 
     await update.message.reply_text(text, parse_mode='HTML')
+
+
+async def _sync_groups_with_userbot(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Синхронизировать группы через новый UserBot парсер"""
+    try:
+        status_message = await update.message.reply_text(
+            "⏳ Синхронизирую группы через UserBot парсер..."
+        )
+        
+        # Используем userbot для парсинга участников существующих групп
+        async with AsyncSessionLocal() as session:
+            repo = GroupRepository(session)
+            existing_groups = await repo.get_all_active_groups()
+            
+            if not existing_groups:
+                await status_message.edit_text(
+                    "ℹ️ В БД нет групп для синхронизации участников.\n\n"
+                    "Сначала добавьте группы через /start → Группы"
+                )
+                return
+            
+            synced_count = 0
+            for group in existing_groups:
+                try:
+                    # Синхронизировать информацию о группе и участников
+                    success = await userbot_parser.sync_group_to_db(int(group.chat_id))
+                    if success:
+                        synced_count += 1
+                        logger.info(f"✅ Синхронизирована группа: {group.title}")
+                except Exception as e:
+                    logger.error(f"❌ Ошибка при синхронизации {group.title}: {e}")
+            
+            await session.commit()
+        
+        result_text = f"""✅ <b>Синхронизация завершена!</b>
+
+📊 Результаты:
+• 🔄 Синхронизировано: {synced_count} групп
+
+Информация о участниках обновлена и сохранена в БД!"""
+        
+        await status_message.edit_text(result_text, parse_mode='HTML')
+        logger.info(f"✅ Синхронизация участников завершена: {synced_count} групп")
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка при синхронизации через UserBot: {e}", exc_info=True)
+        await update.message.reply_text(
+            f"❌ Ошибка при синхронизации: {str(e)}"
+        )
+
+
+async def sync_groups_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Синхронизировать группы из Telethon UserBot или UserBot парсера"""
+    user = update.effective_user
+    logger.info(f"🔄 Получена команда /sync_groups от пользователя {user.id}")
+    
+    # Попытаться инициализировать userbot если еще не инициализирован
+    if not userbot_parser.is_initialized:
+        logger.info("📱 Инициализация UserBot парсера...")
+        init_success = await userbot_parser.initialize()
+        if not init_success:
+            logger.warning("⚠️ UserBot парсер не инициализирован, используем старый telethon_manager")
+    
+    # Попытаться использовать новый userbot сначала
+    if userbot_parser.is_initialized:
+        logger.info("✅ Используем новый UserBot парсер")
+        return await _sync_groups_with_userbot(update, context)
+    else:
+        logger.info("ℹ️ Используем старый Telethon клиент")
+        return await _sync_groups_with_telethon(update, context)
+
+
+async def _sync_groups_with_telethon(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Синхронизировать группы через telethon_manager"""
+    user = update.effective_user
+    logger.info(f"🔄 Синхронизация через telethon_manager")
+    
+    # Проверим, инициализирован ли Telethon клиент
+    if not telethon_manager.is_connected():
+        logger.warning("⚠️ Telethon клиент не инициализирован")
+        await update.message.reply_text(
+            "❌ Telethon UserBot не инициализирован.\n\n"
+            "Убедитесь, что переменные окружения TELETHON_API_ID и TELETHON_API_HASH установлены."
+        )
+        return
+    
+    try:
+        # Отправим уведомление о начале синхронизации
+        status_message = await update.message.reply_text(
+            "⏳ Синхронизирую группы через Telethon UserBot..."
+        )
+        
+        # Получить все группы от Telethon
+        groups = await telethon_manager.get_user_groups()
+        
+        if not groups:
+            await status_message.edit_text(
+                "ℹ️ UserBot не найден ни в одной группе.\n\n"
+                "Чтобы добавить группы:\n"
+                "1. Пригласите UserBot в групп\u044b\n"
+                "2. Повторите /sync_groups"
+            )
+            return
+        
+        # Сохранить группы в БД
+        added_count = 0
+        updated_count = 0
+        
+        async with AsyncSessionLocal() as session:
+            repo = GroupRepository(session)
+            
+            for group in groups:
+                try:
+                    # Конвертировать chat_id в string
+                    chat_id_str = str(group['chat_id'])
+                    
+                    # Попытаться найти существующую группу
+                    existing = await repo.get_group_by_chat_id(chat_id_str)
+                    
+                    if existing:
+                        # Обновить информацию
+                        await repo.update_group(
+                            existing.id,
+                            title=group['title'],
+                            slow_mode_delay=group['slow_mode_delay']
+                        )
+                        updated_count += 1
+                        logger.info(f"✏️ Обновлена группа: {group['title']} (ID: {chat_id_str})")
+                    else:
+                        # Добавить новую группу
+                        await repo.add_group(
+                            chat_id=chat_id_str,
+                            title=group['title'],
+                            slow_mode_delay=group['slow_mode_delay']
+                        )
+                        added_count += 1
+                        logger.info(f"✅ Добавлена группа: {group['title']} (ID: {chat_id_str})")
+                
+                except Exception as e:
+                    logger.error(f"❌ Ошибка при добавлении группы {group['title']}: {e}")
+                    continue
+            
+            await session.commit()
+        
+        # Отправить результаты
+        result_text = f"""✅ <b>Синхронизация завершена!</b>
+
+📊 Результаты:
+• ➕ Добавлено: {added_count}
+• ✏️ Обновлено: {updated_count}
+• 📈 Всего в БД: {added_count + updated_count}
+
+Теперь вы можете использовать эти группы для отправки сообщений!"""
+        
+        await status_message.edit_text(result_text, parse_mode='HTML')
+        logger.info(f"✅ Синхронизация завершена: добавлено {added_count}, обновлено {updated_count}")
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка при синхронизации групп: {e}", exc_info=True)
+        await update.message.reply_text(
+            f"❌ Ошибка при синхронизации: {str(e)}"
+        )

app/handlers/message_manager.py

@@ -1,5 +1,5 @@
 from telegram import Update, InlineKeyboardMarkup, InlineKeyboardButton
-from telegram.ext import ContextTypes, ConversationHandler
+from telegram.ext import ContextTypes
 from app.database import AsyncSessionLocal
 from app.database.repository import (
     GroupRepository, MessageRepository, MessageGroupRepository
@@ -11,34 +11,57 @@ import logging
 
 logger = logging.getLogger(__name__)
 
-# Состояния для ConversationHandler
-CREATE_MSG_TITLE = 1
-CREATE_MSG_TEXT = 2
-SELECT_GROUPS = 3
-WAITING_GROUP_INPUT = 4
+# Состояния (теперь управляются через context.user_data)
+STATE_WAITING_MSG_TITLE = "waiting_title"
+STATE_WAITING_MSG_TEXT = "waiting_text"
+STATE_SELECTING_GROUPS = "selecting_groups"
 
 
-async def create_message_start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def handle_message_input(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Распределяет текстовый ввод в зависимости от текущего состояния"""
+    state = context.user_data.get('message_state')
+    
+    if state == STATE_WAITING_MSG_TITLE:
+        await create_message_title(update, context)
+    elif state == STATE_WAITING_MSG_TEXT:
+        await create_message_text(update, context)
+    # Если не в состоянии ввода - игнорируем
+
+
+async def create_message_start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Начало создания нового сообщения"""
     query = update.callback_query
+    logger.info(f"📝 Начало создания сообщения от пользователя {update.effective_user.id}")
     await query.answer()
 
+    # Инициализируем состояние
+    context.user_data['message_state'] = STATE_WAITING_MSG_TITLE
+    context.user_data['message_title'] = None
+    context.user_data['message_text'] = None
+    context.user_data['selected_groups'] = set()
+
     text = "📝 Введите название сообщения (короткое описание):"
 
     await query.edit_message_text(text)
-    return CREATE_MSG_TITLE
 
 
-async def create_message_title(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def create_message_title(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Получаем название и просим текст"""
     message = update.message
+    
+    # Проверяем что мы в правильном состоянии
+    if context.user_data.get('message_state') != STATE_WAITING_MSG_TITLE:
+        return
+    
+    logger.info(f"📝 Получено название сообщения: {message.text[:50]}")
     title = message.text.strip()
 
     if len(title) > 100:
         await message.reply_text("❌ Название слишком длинное (макс 100 символов)")
-        return CREATE_MSG_TITLE
+        return
 
     context.user_data['message_title'] = title
+    context.user_data['message_state'] = STATE_WAITING_MSG_TEXT
 
     text = """✏️ Теперь введите текст сообщения.
 
@@ -51,22 +74,28 @@ async def create_message_title(update: Update, context: ContextTypes.DEFAULT_TYP
 Введите /cancel для отмены"""
 
     await message.reply_text(text, parse_mode='HTML')
-    return CREATE_MSG_TEXT
 
 
-async def create_message_text(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def create_message_text(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Получаем текст и показываем выбор групп"""
     message = update.message
+    
+    # Проверяем что мы в правильном состоянии
+    if context.user_data.get('message_state') != STATE_WAITING_MSG_TEXT:
+        return
+    
+    logger.info(f"📝 Получен текст сообщения от пользователя {update.effective_user.id}")
 
     if message.text == '/cancel':
+        context.user_data['message_state'] = None
         await message.reply_text("❌ Отменено", reply_markup=get_main_keyboard())
-        return ConversationHandler.END
+        return
 
     text = message.text.strip()
 
     if len(text) > 4096:
         await message.reply_text("❌ Текст слишком длинный (макс 4096 символов)")
-        return CREATE_MSG_TEXT
+        return
 
     context.user_data['message_text'] = text
 
@@ -85,23 +114,24 @@ async def create_message_text(update: Update, context: ContextTypes.DEFAULT_TYPE
         groups = await group_repo.get_all_active_groups()
 
     if not groups:
+        context.user_data['message_state'] = None
         await message.reply_text(
             "❌ Нет активных групп. Сначала добавьте бота в группы.",
             reply_markup=get_main_keyboard()
         )
-        return ConversationHandler.END
+        return
 
     # Создаем клавиатуру с группами
     keyboard = []
     for group in groups:
         callback = f"select_group_{group.id}"
         keyboard.append([InlineKeyboardButton(
-            f"✅ {group.title} (delay: {group.slow_mode_delay}s)",
+            f"☐ {group.title} (delay: {group.slow_mode_delay}s)",
             callback_data=callback
         )])
 
     keyboard.append([InlineKeyboardButton("✔️ Готово", callback_data="done_groups")])
-    keyboard.append([InlineKeyboardButton("❌ Отмена", callback_data=f"{CallbackType.MAIN_MENU}")])
+    keyboard.append([InlineKeyboardButton("❌ Отмена", callback_data=CallbackType.MAIN_MENU.value)])
 
     text = f"""✅ Сообщение создано: <b>{context.user_data['message_title']}</b>
 
@@ -113,22 +143,29 @@ async def create_message_text(update: Update, context: ContextTypes.DEFAULT_TYPE
         reply_markup=InlineKeyboardMarkup(keyboard)
     )
 
-    context.user_data['selected_groups'] = []
-    return SELECT_GROUPS
+    context.user_data['selected_groups'] = set()
+    context.user_data['message_state'] = STATE_SELECTING_GROUPS
 
 
-async def select_groups(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+async def select_groups(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Выбор групп для отправки"""
     query = update.callback_query
     callback_data = query.data
+    
+    # Проверяем что мы в правильном состоянии
+    if context.user_data.get('message_state') != STATE_SELECTING_GROUPS:
+        return
+    
+    logger.info(f"🔘 Получен callback select_groups: {callback_data} от пользователя {update.effective_user.id}")
+    await query.answer()
 
     if callback_data == "done_groups":
         # Подтверждаем выбор
-        selected = context.user_data.get('selected_groups', [])
+        selected = context.user_data.get('selected_groups', set())
 
         if not selected:
             await query.answer("❌ Выберите хотя бы одну группу", show_alert=True)
-            return SELECT_GROUPS
+            return
 
         # Добавляем сообщение в выбранные группы
         message_id = context.user_data['message_id']
@@ -145,17 +182,18 @@ async def select_groups(update: Update, context: ContextTypes.DEFAULT_TYPE) -> i
 
 Теперь вы можете отправить сообщение нажав кнопку "Отправить" в списке сообщений."""
 
+        context.user_data['message_state'] = None
         await query.edit_message_text(text, parse_mode='HTML', reply_markup=get_main_keyboard())
-        return ConversationHandler.END
+        return
 
     elif callback_data.startswith("select_group_"):
         group_id = int(callback_data.split("_")[2])
-        selected = context.user_data.get('selected_groups', [])
+        selected = context.user_data.get('selected_groups', set())
 
         if group_id in selected:
-            selected.remove(group_id)
+            selected.discard(group_id)
         else:
-            selected.append(group_id)
+            selected.add(group_id)
 
         context.user_data['selected_groups'] = selected
 
@@ -175,7 +213,7 @@ async def select_groups(update: Update, context: ContextTypes.DEFAULT_TYPE) -> i
             )])
 
         keyboard.append([InlineKeyboardButton("✔️ Готово", callback_data="done_groups")])
-        keyboard.append([InlineKeyboardButton("❌ Отмена", callback_data=f"{CallbackType.MAIN_MENU}")])
+        keyboard.append([InlineKeyboardButton("❌ Отмена", callback_data=CallbackType.MAIN_MENU.value)])
 
         await query.edit_message_text(
             f"Выбрано групп: {len(selected)}",

app/handlers/telethon_client.py

@@ -2,7 +2,8 @@ import logging
 import os
 from typing import List, Optional, Dict
 from telethon import TelegramClient, events
-from telethon.tl.types import ChatMember, User
+from telethon.tl.types import User
+from telethon.tl.types.auth import Authorization
 from telethon.errors import (
     FloodWaitError, UserDeactivatedError, ChatAdminRequiredError,
     PeerIdInvalidError, ChannelInvalidError, UserNotParticipantError
@@ -272,6 +273,50 @@ class TelethonClientManager:
             logger.error(f"❌ Ошибка при поиске сообщений: {e}")
             return []
 
+    async def get_user_groups(self) -> List[Dict]:
+        """
+        Получить все группы и супергруппы пользователя
+        
+        Returns:
+            List[Dict]: Список групп с информацией {id, title, slow_mode_delay, members_count}
+        """
+        if not self.is_initialized:
+            logger.error("Telethon клиент не инициализирован")
+            return []
+        
+        try:
+            groups = []
+            from telethon.tl.types import Chat, Channel
+            
+            # Получить все диалоги (чаты/группы)
+            async for dialog in self.client.iter_dialogs():
+                entity = dialog.entity
+                
+                # Пропустить личные чаты и каналы (только группы и супергруппы)
+                if not isinstance(entity, (Chat, Channel)):
+                    continue
+                
+                # Пропустить каналы (broadcast)
+                if isinstance(entity, Channel) and entity.broadcast:
+                    continue
+                
+                group_info = {
+                    'chat_id': entity.id,
+                    'title': entity.title if hasattr(entity, 'title') else str(entity.id),
+                    'slow_mode_delay': entity.slowmode_seconds if hasattr(entity, 'slowmode_seconds') else 0,
+                    'members_count': entity.participants_count if hasattr(entity, 'participants_count') else 0,
+                    'is_supergroup': isinstance(entity, Channel),  # Channel = supergroup/megagroup
+                }
+                groups.append(group_info)
+                logger.debug(f"📍 Найдена группа: {group_info['title']} (ID: {group_info['chat_id']})")
+            
+            logger.info(f"✅ Получено {len(groups)} групп от Telethon")
+            return groups
+        
+        except Exception as e:
+            logger.error(f"❌ Ошибка при получении групп: {e}")
+            return []
+
     def is_connected(self) -> bool:
         """Проверить, подключен ли клиент"""
         return self.is_initialized and self.client is not None

app/handlers/userbot_manager.py

@@ -0,0 +1,449 @@
+"""
+Обработчик управления UserBot для сбора групп и участников
+"""
+from telegram import Update, InlineKeyboardMarkup, InlineKeyboardButton
+from telegram.ext import ContextTypes, ConversationHandler
+from app.userbot.parser import userbot_parser
+from app.database import AsyncSessionLocal
+from app.database.repository import GroupRepository
+from app.database.member_repository import GroupMemberRepository
+from app.utils.keyboards import CallbackType
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Состояния для ConversationHandler
+USERBOT_MENU = 1
+USERBOT_SETTINGS = 2
+USERBOT_COLLECTING_GROUPS = 3
+USERBOT_SELECT_GROUP = 4
+USERBOT_COLLECTING_MEMBERS = 5
+
+
+async def userbot_menu(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+    """Меню управления UserBot"""
+    try:
+        query = update.callback_query
+        if query:
+            await query.answer()
+        
+        text = """🤖 <b>UserBot - Управление парсингом</b>
+
+Что вы хотите сделать?
+
+<i>UserBot собирает информацию о группах и их участниках от имени пользователя</i>"""
+
+        keyboard = [
+            [InlineKeyboardButton("⚙️ Настройки", callback_data="userbot_settings")],
+            [InlineKeyboardButton("📥 Собрать группы", callback_data="userbot_collect_groups")],
+            [InlineKeyboardButton("👥 Собрать участников", callback_data="userbot_collect_members")],
+            [InlineKeyboardButton("⬅️ Назад в меню", callback_data=CallbackType.MAIN_MENU.value)],
+        ]
+
+        if query:
+            await query.edit_message_text(
+                text,
+                parse_mode='HTML',
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+        else:
+            await update.message.reply_text(
+                text,
+                parse_mode='HTML',
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+        
+        return USERBOT_MENU
+    except Exception as e:
+        logger.error(f"❌ Ошибка в userbot_menu: {e}", exc_info=True)
+        return ConversationHandler.END
+
+
+async def userbot_settings(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+    """Настройки UserBot"""
+    try:
+        query = update.callback_query
+        await query.answer()
+        
+        # Проверяем статус UserBot
+        is_initialized = userbot_parser.is_initialized
+        
+        status = "✅ Инициализирован" if is_initialized else "❌ Не инициализирован"
+        
+        text = f"""⚙️ <b>Настройки UserBot</b>
+
+<b>Статус:</b> {status}
+
+<b>Возможности:</b>
+• Собирать информацию о группах
+• Собирать списки участников
+• Сохранять данные в БД
+• Работать в фоне через Celery
+
+Нажмите кнопку для продолжения"""
+
+        keyboard = [
+            [InlineKeyboardButton("🔄 Инициализировать", callback_data="userbot_init")],
+            [InlineKeyboardButton("⬅️ Назад", callback_data="userbot_menu")],
+        ]
+
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        
+        return USERBOT_SETTINGS
+    except Exception as e:
+        logger.error(f"❌ Ошибка в userbot_settings: {e}", exc_info=True)
+        return ConversationHandler.END
+
+
+async def userbot_init(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+    """Инициализация UserBot"""
+    try:
+        query = update.callback_query
+        await query.answer()
+        
+        await query.edit_message_text(
+            "⏳ Инициализирую UserBot...",
+            parse_mode='HTML'
+        )
+        
+        # Инициализируем UserBot
+        success = await userbot_parser.initialize()
+        
+        if success:
+            text = """✅ <b>UserBot успешно инициализирован!</b>
+
+Теперь вы можете:
+• Собирать информацию о группах
+• Собирать списки участников
+• Синхронизировать данные в БД
+
+Перейдите в меню для продолжения."""
+            keyboard = [[InlineKeyboardButton("🔄 Меню", callback_data="userbot_menu")]]
+        else:
+            text = """❌ <b>Ошибка инициализации UserBot</b>
+
+Убедитесь, что:
+• Переменные окружения установлены
+• TELETHON_API_ID и TELETHON_API_HASH верные
+• Сессия сохранена в sessions/userbot_session.session
+
+Попробуйте позже."""
+            keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data="userbot_settings")]]
+        
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        
+        return USERBOT_SETTINGS
+    except Exception as e:
+        logger.error(f"❌ Ошибка инициализации UserBot: {e}", exc_info=True)
+        
+        text = f"""❌ <b>Ошибка при инициализации:</b>
+
+<code>{str(e)[:200]}</code>
+
+Проверьте логи бота."""
+        
+        keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data="userbot_settings")]]
+        
+        query = update.callback_query
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        
+        return USERBOT_SETTINGS
+
+
+async def userbot_collect_groups(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+    """Сбор групп от пользователя"""
+    try:
+        query = update.callback_query
+        await query.answer()
+        
+        if not userbot_parser.is_initialized:
+            text = "❌ UserBot не инициализирован!\n\nПерейдите в настройки для инициализации."
+            keyboard = [[InlineKeyboardButton("⚙️ Настройки", callback_data="userbot_settings")]]
+            
+            await query.edit_message_text(
+                text,
+                parse_mode='HTML',
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+            return USERBOT_MENU
+        
+        await query.edit_message_text(
+            "⏳ <b>Собираю информацию о группах...</b>\n\nЭто может занять некоторое время...",
+            parse_mode='HTML'
+        )
+        
+        # Собираем группы
+        logger.info(f"📥 Начало сбора групп для пользователя {update.effective_user.id}")
+        groups = await userbot_parser.parse_groups_user_in()
+        
+        if not groups:
+            text = "❌ <b>Не найдено групп</b>\n\nУбедитесь, что вы состоите в группах."
+            keyboard = [[InlineKeyboardButton("🔄 Попробовать снова", callback_data="userbot_collect_groups")],
+                       [InlineKeyboardButton("⬅️ Назад", callback_data="userbot_menu")]]
+        else:
+            # Сохраняем группы в контексте
+            context.user_data['available_groups'] = groups
+            
+            text = f"""✅ <b>Найдено групп: {len(groups)}</b>
+
+<b>Список групп:</b>"""
+            
+            for i, group in enumerate(groups, 1):
+                title = group.get('title', 'Неизвестная группа')
+                chat_id = group.get('chat_id', 'Unknown')
+                members = group.get('members_count', 0)
+                text += f"\n{i}. {title}\n   👥 Участников: {members}"
+            
+            text += "\n\n💾 Группы сохранены в базе данных!"
+            
+            # Сохраняем группы в БД
+            async with AsyncSessionLocal() as session:
+                repo = GroupRepository(session)
+                for group in groups:
+                    await repo.add_or_update_group({
+                        'chat_id': group.get('chat_id'),
+                        'title': group.get('title'),
+                        'description': group.get('description', ''),
+                        'members_count': group.get('members_count', 0),
+                        'is_active': True
+                    })
+            
+            logger.info(f"✅ Сохранено {len(groups)} групп")
+            
+            keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data="userbot_menu")]]
+        
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        
+        return USERBOT_COLLECTING_GROUPS
+    except Exception as e:
+        logger.error(f"❌ Ошибка при сборе групп: {e}", exc_info=True)
+        
+        text = f"""❌ <b>Ошибка при сборе групп:</b>
+
+<code>{str(e)[:200]}</code>"""
+        
+        keyboard = [[InlineKeyboardButton("🔄 Попробовать снова", callback_data="userbot_collect_groups")],
+                   [InlineKeyboardButton("⬅️ Назад", callback_data="userbot_menu")]]
+        
+        query = update.callback_query
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        
+        return USERBOT_COLLECTING_GROUPS
+
+
+async def userbot_collect_members(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+    """Выбор группы для сбора участников"""
+    try:
+        query = update.callback_query
+        await query.answer()
+        
+        if not userbot_parser.is_initialized:
+            text = "❌ UserBot не инициализирован!\n\nПерейдите в настройки для инициализации."
+            keyboard = [[InlineKeyboardButton("⚙️ Настройки", callback_data="userbot_settings")]]
+            
+            await query.edit_message_text(
+                text,
+                parse_mode='HTML',
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+            return USERBOT_MENU
+        
+        # Получаем группы из БД
+        async with AsyncSessionLocal() as session:
+            repo = GroupRepository(session)
+            groups = await repo.get_active_groups()
+        
+        if not groups:
+            text = "❌ <b>Не найдено активных групп</b>\n\nСначала соберите информацию о группах."
+            keyboard = [[InlineKeyboardButton("📥 Собрать группы", callback_data="userbot_collect_groups")],
+                       [InlineKeyboardButton("⬅️ Назад", callback_data="userbot_menu")]]
+            
+            await query.edit_message_text(
+                text,
+                parse_mode='HTML',
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+            return USERBOT_SELECT_GROUP
+        
+        text = """👥 <b>Выберите группу для сбора участников</b>
+
+Нажмите на группу для сбора списка участников:"""
+        
+        keyboard = []
+        for group in groups:
+            title = group.title if hasattr(group, 'title') else group.get('title', 'Unknown')
+            group_id = group.id if hasattr(group, 'id') else group.get('id', 0)
+            callback_data = f"userbot_members_{group_id}"
+            keyboard.append([InlineKeyboardButton(f"👥 {title}", callback_data=callback_data)])
+        
+        keyboard.append([InlineKeyboardButton("⬅️ Назад", callback_data="userbot_menu")])
+        
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        
+        return USERBOT_SELECT_GROUP
+    except Exception as e:
+        logger.error(f"❌ Ошибка при выборе группы: {e}", exc_info=True)
+        
+        text = f"""❌ <b>Ошибка:</b>
+
+<code>{str(e)[:200]}</code>"""
+        
+        keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data="userbot_menu")]]
+        
+        query = update.callback_query
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        
+        return USERBOT_SELECT_GROUP
+
+
+async def userbot_parse_members(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+    """Сбор участников для выбранной группы"""
+    try:
+        query = update.callback_query
+        await query.answer()
+        
+        # Извлекаем group_id из callback_data
+        group_id = int(query.data.replace("userbot_members_", ""))
+        
+        await query.edit_message_text(
+            f"⏳ <b>Собираю участников группы...</b>\n\ngroup_id: {group_id}\n\nЭто может занять некоторое время...",
+            parse_mode='HTML'
+        )
+        
+        # Получаем информацию о группе из БД
+        async with AsyncSessionLocal() as session:
+            repo = GroupRepository(session)
+            group = await repo.get_group_by_id(group_id)
+        
+        if not group:
+            text = "❌ Группа не найдена в базе данных."
+            keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data="userbot_collect_members")]]
+            
+            await query.edit_message_text(
+                text,
+                parse_mode='HTML',
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+            return USERBOT_COLLECTING_MEMBERS
+        
+        chat_id = group.chat_id if hasattr(group, 'chat_id') else group.get('chat_id')
+        title = group.title if hasattr(group, 'title') else group.get('title', 'Unknown')
+        
+        logger.info(f"👥 Начало сбора участников для группы {title} (chat_id: {chat_id})")
+        
+        # Собираем участников
+        members = await userbot_parser.parse_group_members(chat_id=chat_id, limit=10000)
+        
+        if not members:
+            text = f"❌ <b>Не удалось собрать участников группы:</b>\n{title}"
+            keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data="userbot_collect_members")]]
+        else:
+            # Сохраняем участников в БД
+            async with AsyncSessionLocal() as session:
+                member_repo = GroupMemberRepository(session)
+                for member in members:
+                    await member_repo.add_or_update_member({
+                        'group_id': group_id,
+                        'user_id': member.get('user_id'),
+                        'username': member.get('username'),
+                        'first_name': member.get('first_name'),
+                        'last_name': member.get('last_name'),
+                        'is_bot': member.get('is_bot', False),
+                        'is_admin': member.get('is_admin', False),
+                        'is_owner': member.get('is_owner', False),
+                    })
+            
+            # Статистика
+            total = len(members)
+            bots = len([m for m in members if m.get('is_bot')])
+            admins = len([m for m in members if m.get('is_admin')])
+            owners = len([m for m in members if m.get('is_owner')])
+            
+            text = f"""✅ <b>Участники собраны!</b>
+
+<b>Группа:</b> {title}
+
+<b>Статистика:</b>
+• 👥 Всего участников: {total}
+• 🤖 Ботов: {bots}
+• 👑 Администраторов: {admins}
+• 🔑 Владельцев: {owners}
+
+💾 Данные сохранены в базе данных!"""
+            
+            logger.info(f"✅ Сохранено {total} участников группы {title}")
+            
+            keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data="userbot_collect_members")]]
+        
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        
+        return USERBOT_COLLECTING_MEMBERS
+    except Exception as e:
+        logger.error(f"❌ Ошибка при сборе участников: {e}", exc_info=True)
+        
+        text = f"""❌ <b>Ошибка при сборе участников:</b>
+
+<code>{str(e)[:200]}</code>
+
+Это может быть вызвано:
+• FloodWait от Telegram
+• Недостатком прав доступа
+• Проблемой с сессией UserBot"""
+        
+        keyboard = [[InlineKeyboardButton("⬅️ Назад", callback_data="userbot_collect_members")],
+                   [InlineKeyboardButton("🏠 Меню", callback_data="userbot_menu")]]
+        
+        query = update.callback_query
+        await query.edit_message_text(
+            text,
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        
+        return USERBOT_COLLECTING_MEMBERS
+
+
+async def cancel_userbot(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
+    """Отмена диалога"""
+    query = update.callback_query
+    if query:
+        await query.answer()
+        keyboard = [[InlineKeyboardButton("🏠 Главное меню", callback_data=CallbackType.MAIN_MENU.value)]]
+        await query.edit_message_text(
+            "❌ Диалог отменен",
+            parse_mode='HTML',
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+    return ConversationHandler.END