Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

запомни код: "# Импорт необходимых модулей import logging import json import os import…

  1. User

    запомни код: "# Импорт необходимых модулей import logging import json import os import re from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, InputMediaPhoto from telegram.ext import ( ApplicationBuilder, ContextTypes, CommandHandler, CallbackQueryHandler, MessageHandler, filters ) from uuid import uuid4

    Настройка логирования

    logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO )

    Пути к файлам данных

    USER_DATA_FILE = 'acclogger.txt' PRODUCTS_FILE = 'products.json' LOCALES_FILE = 'locales.json' IMAGES_DIR = 'images'

    Словари для хранения данных

    user_data = {} products = [] locales = {}

    Убедимся, что директория для изображений существует

    if not os.path.exists(IMAGES_DIR): os.makedirs(IMAGES_DIR)

    Функция для загрузки данных локализации

    def load_locales(): global locales if os.path.exists(LOCALES_FILE): try: with open(LOCALES_FILE, 'r', encoding='utf-8') as f: locales = json.load(f) except (json.JSONDecodeError, IOError) as e: logging.error(f"Ошибка при чтении файла {LOCALES_FILE}: {e}") locales = {} else: locales = {}

    Функция для получения перевода по ключу и языку пользователя

    def get_translation(user_id, key, **kwargs): user_info = user_data.get(str(user_id), {}) user_lang = user_info.get('language', 'ru') translation = locales.get(user_lang, {}).get(key, '') if kwargs: translation = translation.format(**kwargs) return translation

    Функция для загрузки данных пользователей из файла

    def load_user_data(): global user_data if os.path.exists(USER_DATA_FILE): try: with open(USER_DATA_FILE, 'r', encoding='utf-8') as f: user_data = json.load(f) except (json.JSONDecodeError, IOError) as e: logging.error(f"Ошибка при чтении файла {USER_DATA_FILE}: {e}") user_data = {} else: user_data = {}

    Функция для сохранения данных пользователей в файл

    def save_user_data(): try: with open(USER_DATA_FILE, 'w', encoding='utf-8') as f: json.dump(user_data, f, ensure_ascii=False, indent=4) except IOError as e: logging.error(f"Ошибка при сохранении файла {USER_DATA_FILE}: {e}")

    Функция для загрузки товаров из файла

    def load_products(): global products if os.path.exists(PRODUCTS_FILE): try: with open(PRODUCTS_FILE, 'r', encoding='utf-8') as f: products = json.load(f) except (json.JSONDecodeError, IOError) as e: logging.error(f"Ошибка при чтении файла {PRODUCTS_FILE}: {e}") products = [] else: products = []

    Функция для сохранения товаров в файл

    def save_products(): try: with open(PRODUCTS_FILE, 'w', encoding='utf-8') as f: json.dump(products, f, ensure_ascii=False, indent=4) except IOError as e: logging.error(f"Ошибка при сохранении файла {PRODUCTS_FILE}: {e}")

    Функция для инициализации админ-аккаунтов

    def initialize_admin_accounts(): admins = [ { 'login': 'Zumi4538dsf27358267', 'password': 'GHYIUtgy6tG^&%967', 'username': 'Admin1' }, { 'login': 'Digital8937h780', 'password': 'OH^7896&^fv796', 'username': 'Admin2' }, { 'login': 'Ivan&h%TrvGRR8', 'password': 'adOIM&R$%e34', 'username': 'Admin3' } ]

    for admin in admins:
        # Проверяем, есть ли админ с таким логином
        exists = any(user_info.get('admin') and user_info.get('login') == admin['login'] for user_info in user_data.values())
        if not exists:
            # Генерируем уникальный user_id для администратора
            user_id = str(uuid4())
            user_data[user_id] = {
                'username': admin['username'],
                'login': admin['login'],
                'password': admin['password'],
                'admin': True,
                'balance': 0,
                'cart': [],
                'reviews': {},
                'purchase_history': [],
                'language': 'ru',  # Язык по умолчанию
                'blocked': False,   # Статус блокировки
                'notes': ''         # Заметки администратора
            }
    save_user_data()
    

    Обработчик команды /start

    async def start(update: Update, context: ContextTypes.DEFAULT_TYPE): user = update.effective_user user_id = str(user.id)

    if user_id not in user_data:
        # Если пользователь впервые, предлагаем выбрать язык
        keyboard = [
            [
                InlineKeyboardButton("Русский", callback_data='set_language_ru'),
                InlineKeyboardButton("Беларуская", callback_data='set_language_be'),
            ],
            [
                InlineKeyboardButton("Қазақша", callback_data='set_language_kk'),
                InlineKeyboardButton("English", callback_data='set_language_en'),
            ]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)
        await update.effective_message.reply_text("Пожалуйста, выберите язык:", reply_markup=reply_markup)
    else:
        # Проверяем, не заблокирован ли пользователь
        if user_data[user_id].get('blocked'):
            await update.effective_message.reply_text("Вы заблокированы.")
            return
        # Если язык уже выбран, приветствуем пользователя
        await send_welcome_message(update, context)
    

    Обработчик выбора языка

    async def set_language(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query await query.answer()

    user = query.from_user
    user_id = str(user.id)
    data = query.data
    language_code = data.split('_')[-1]
    
    username = user.username or user.full_name
    
    # Обновляем или создаем данные пользователя
    user_data[user_id] = user_data.get(user_id, {})
    user_data[user_id].update({
        'username': username,
        'language': language_code,
        'balance': user_data[user_id].get('balance', 0),
        'cart': user_data[user_id].get('cart', []),
        'reviews': user_data[user_id].get('reviews', {}),
        'purchase_history': user_data[user_id].get('purchase_history', []),
        'admin': user_data[user_id].get('admin', False),
        'login': user_data[user_id].get('login', ''),
        'password': user_data[user_id].get('password', ''),
        'blocked': user_data[user_id].get('blocked', False),
        'notes': user_data[user_id].get('notes', '')
    })
    save_user_data()
    
    await send_welcome_message(update, context)
    

    Функция для отправки приветственного сообщения

    async def send_welcome_message(update: Update, context: ContextTypes.DEFAULT_TYPE): user = update.effective_user user_id = str(user.id)

    # Проверяем, не заблокирован ли пользователь
    if user_data[user_id].get('blocked'):
        await update.effective_message.reply_text("Вы заблокированы.")
        return
    
    username = user_data[user_id]['username']
    welcome_text = get_translation(user_id, 'welcome', username=username)
    
    # Кнопки "Товары" и "Личный кабинет"
    keyboard = [
        [
            InlineKeyboardButton(get_translation(user_id, 'products'), callback_data='show_products'),
            InlineKeyboardButton(get_translation(user_id, 'personal_cabinet'), callback_data='personal_cabinet')
        ]
    ]
    
    # Если пользователь является администратором, добавляем кнопку админ-панели
    if user_data[user_id].get('admin'):
        keyboard.append([InlineKeyboardButton(get_translation(user_id, 'admin_panel'), callback_data='admin_panel')])
    
    reply_markup = InlineKeyboardMarkup(keyboard)
    
    await update.effective_message.reply_text(welcome_text, reply_markup=reply_markup)
    

    Обработчик для отображения админ-панели

    async def admin_panel(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query user_id = str(query.from_user.id) await query.answer()

    if not user_data[user_id].get('admin'):
        await query.edit_message_text(get_translation(user_id, 'access_denied'))
        return
    
    # Кнопки админ-панели
    keyboard = [
        [InlineKeyboardButton(get_translation(user_id, 'manage_users'), callback_data='admin_manage_users')],
        [InlineKeyboardButton(get_translation(user_id, 'manage_products'), callback_data='admin_manage_products')],
        [InlineKeyboardButton(get_translation(user_id, 'main_menu'), callback_data='main_menu')]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    
    await query.edit_message_text(get_translation(user_id, 'admin_panel_welcome'), reply_markup=reply_markup)
    

    Обработчик для управления пользователями

    async def admin_manage_users(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query user_id = str(query.from_user.id) await query.answer()

    # Получаем список пользователей (кроме администраторов)
    users = [(uid, info) for uid, info in user_data.items() if not info.get('admin')]
    
    if not users:
        await query.edit_message_text(get_translation(user_id, 'no_users'))
        return
    
    page = 1
    data = query.data
    if '_' in data:
        parts = data.split('_')
        if len(parts) > 2:
            page = int(parts[-1])
    
    await send_user_list(query, users, page)
    

    Функция для отправки списка пользователей с пагинацией

    async def send_user_list(query, users, page): user_id = str(query.from_user.id) users_per_page = 5

    start_index = (page - 1) * users_per_page
    end_index = start_index + users_per_page
    
    page_users = users[start_index:end_index]
    
    keyboard = []
    
    for uid, info in page_users:
        button = InlineKeyboardButton(
            f"{info.get('username')} ({uid})",
            callback_data=f'admin_view_user_{uid}_{page}'
        )
        keyboard.append([button])
    
    nav_buttons = []
    if page > 1:
        nav_buttons.append(InlineKeyboardButton(get_translation(user_id, 'back'), callback_data=f'admin_manage_users_{page - 1}'))
    
    if end_index < len(users):
        nav_buttons.append(InlineKeyboardButton(get_translation(user_id, 'forward'), callback_data=f'admin_manage_users_{page + 1}'))
    
    nav_buttons.append(InlineKeyboardButton(get_translation(user_id, 'main_menu'), callback_data='admin_panel'))
    
    keyboard.append(nav_buttons)
    reply_markup = InlineKeyboardMarkup(keyboard)
    
    await query.edit_message_text(get_translation(user_id, 'user_list'), reply_markup=reply_markup)
    

    Обработчик для просмотра подробной информации о пользователе

    async def admin_view_user(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query data = query.data user_id = str(query.from_user.id) await query.answer()

    parts = data.split('_')
    target_user_id = parts[3]
    page = int(parts[-1])
    
    target_user_info = user_data.get(target_user_id)
    
    if not target_user_info:
        await query.edit_message_text(get_translation(user_id, 'user_not_found'))
        return
    
    if target_user_info.get('admin'):
        await query.edit_message_text(get_translation(user_id, 'cannot_view_admin'))
        return
    
    # Формируем информацию о пользователе
    user_info_text = f"{get_translation(user_id, 'username')}: {target_user_info.get('username')}\n"
    user_info_text += f"ID: {target_user_id}\n"
    user_info_text += f"{get_translation(user_id, 'balance')}: {target_user_info.get('balance')}\n"
    user_info_text += f"{get_translation(user_id, 'blocked')}: {'Да' if target_user_info.get('blocked') else 'Нет'}\n"
    user_info_text += f"{get_translation(user_id, 'notes')}: {target_user_info.get('notes', '')}"
    
    # Кнопки для управления пользователем
    keyboard = [
        [InlineKeyboardButton(get_translation(user_id, 'block_user'), callback_data=f'admin_block_user_{target_user_id}_{page}')],
        [InlineKeyboardButton(get_translation(user_id, 'change_balance'), callback_data=f'admin_change_balance_{target_user_id}_{page}')],
        [InlineKeyboardButton(get_translation(user_id, 'add_note'), callback_data=f'admin_add_note_{target_user_id}_{page}')],
        [InlineKeyboardButton(get_translation(user_id, 'back'), callback_data=f'admin_manage_users_{page}')]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    
    await query.edit_message_text(user_info_text, reply_markup=reply_markup)
    

    Обработчик для блокировки/разблокировки пользователя

    async def admin_block_user(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query data = query.data user_id = str(query.from_user.id) await query.answer()

    parts = data.split('_')
    target_user_id = parts[3]
    page = int(parts[-1])
    
    target_user_info = user_data.get(target_user_id)
    if not target_user_info:
        await query.edit_message_text(get_translation(user_id, 'user_not_found'))
        return
    
    target_user_info['blocked'] = not target_user_info.get('blocked', False)
    save_user_data()
    
    status = 'заблокирован' if target_user_info['blocked'] else 'разблокирован'
    await query.edit_message_text(f"Пользователь {status}.")
    
    # Возвращаемся к просмотру информации о пользователе
    await admin_view_user(update, context)
    

    Обработчик для изменения баланса пользователя

    async def admin_change_balance(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query data = query.data user_id = str(query.from_user.id)

    parts = data.split('_')
    target_user_id = parts[3]
    page = int(parts[-1])
    
    # Сохраняем информацию о том, что ожидаем ввода нового баланса
    context.user_data['awaiting_balance_change'] = {
        'target_user_id': target_user_id,
        'page': page
    }
    await query.edit_message_text(get_translation(user_id, 'enter_new_balance'))
    

    Обработчик для добавления заметки к пользователю

    async def admin_add_note(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query data = query.data user_id = str(query.from_user.id)

    parts = data.split('_')
    target_user_id = parts[3]
    page = int(parts[-1])
    
    # Сохраняем информацию о том, что ожидаем ввода заметки
    context.user_data['awaiting_note'] = {
        'target_user_id': target_user_id,
        'page': page
    }
    await query.edit_message_text(get_translation(user_id, 'enter_note'))
    

    Обработчик текстовых сообщений для изменений

    async def handle_text_message(update: Update, context: ContextTypes.DEFAULT_TYPE): user = update.effective_user user_id = str(user.id) message = update.message.text.strip()

    if message == '!admpanlog':
        # Начинаем процесс входа в админ-панель
        context.user_data['awaiting_admin_login'] = True
        await update.message.reply_text(get_translation(user_id, 'enter_login'))
    elif 'awaiting_admin_login' in context.user_data:
        # Пользователь вводит логин
        context.user_data['admin_login'] = message
        context.user_data.pop('awaiting_admin_login')
        context.user_data['awaiting_admin_password'] = True
        await update.message.reply_text(get_translation(user_id, 'enter_password'))
    elif 'awaiting_admin_password' in context.user_data:
        # Пользователь вводит пароль
        login = context.user_data.pop('admin_login')
        password = message
        context.user_data.pop('awaiting_admin_password')
    
        # Проверяем логин и пароль
        if check_admin_credentials(login, password):
            context.user_data['is_admin'] = True
            context.user_data['admin_login'] = login
            await update.message.reply_text(get_translation(user_id, 'access_granted'))
            # Здесь можно вызвать функцию, отображающую админ-панель
            await admin_panel(update, context)
        else:
            await update.message.reply_text(get_translation(user_id, 'access_denied'))
    elif 'awaiting_balance_change' in context.user_data:
        # Обработка изменения баланса пользователя
        info = context.user_data.pop('awaiting_balance_change')
        target_user_id = info['target_user_id']
        page = info['page']
    
        try:
            new_balance = float(message)
            user_data[target_user_id]['balance'] = new_balance
            save_user_data()
            await update.message.reply_text("Баланс обновлен.")
            # Возвращаемся к просмотру информации о пользователе
            await admin_view_user(update, context)
        except ValueError:
            await update.message.reply_text("Пожалуйста, введите корректное число.")
    
    elif 'awaiting_note' in context.user_data:
        # Обработка добавления заметки к пользователю
        info = context.user_data.pop('awaiting_note')
        target_user_id = info['target_user_id']
        page = info['page']
    
        note = message
        user_data[target_user_id]['notes'] = note
        save_user_data()
        await update.message.reply_text("Заметка сохранена.")
        # Возвращаемся к просмотру информации о пользователе
        await admin_view_user(update, context)
    
    elif 'awaiting_review' in context.user_data:
        # Обработка отзыва пользователя о товаре
        product_name = context.user_data.pop('awaiting_review')
        user_info = user_data.get(user_id)
    
        if user_info:
            # Сохраняем отзыв
            user_info.setdefault('reviews', {})[product_name] = message
            save_user_data()
    
            await update.message.reply_text(get_translation(user_id, 'review_saved').format(product_name=product_name))
        else:
            await update.message.reply_text("Произошла ошибка при сохранении отзыва.")
    
    elif 'awaiting_product_name' in context.user_data:
        # Администратор вводит название нового товара
        context.user_data['new_product_name'] = message
        context.user_data.pop('awaiting_product_name')
        context.user_data['awaiting_product_description'] = True
        await update.message.reply_text(get_translation(user_id, 'enter_product_description'))
    
    elif 'awaiting_product_description' in context.user_data:
        # Администратор вводит описание товара
        context.user_data['new_product_description'] = message
        context.user_data.pop('awaiting_product_description')
        context.user_data['awaiting_product_image'] = True
    
        keyboard = [
            [InlineKeyboardButton(get_translation(user_id, 'skip_image'), callback_data='skip_image')]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)
        await update.message.reply_text(get_translation(user_id, 'attach_product_image'), reply_markup=reply_markup)
    
    else:
        await update.message.reply_text(get_translation(user_id, 'unknown_command'))
    

    Обработчик для управления товарами

    async def admin_manage_products(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query user_id = str(query.from_user.id) await query.answer()

    # Кнопки для управления товарами
    keyboard = [
        [InlineKeyboardButton(get_translation(user_id, 'add_new_product'), callback_data='admin_add_product')],
        [InlineKeyboardButton(get_translation(user_id, 'edit_existing_product'), callback_data='admin_edit_product')],
        [InlineKeyboardButton(get_translation(user_id, 'main_menu'), callback_data='admin_panel')]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    
    await query.edit_message_text(get_translation(user_id, 'manage_products_menu'), reply_markup=reply_markup)
    

    Обработчик для добавления нового товара

    async def admin_add_product(update: Update, context: ContextTypes.DEFAULT_TYPE): query = update.callback_query user_id = str(query.from_user.id) await query.answer()

    context.user_data['awaiting_product_name'] = True
    await query.edit_message_text(get_translation(user_id, 'enter_product_name'))
    

    Обработчик для пропуска добавления изображения

    async def skip_image(update: Update, context: ContextTypes.DEFAULT_TYPE): message = update.message user_id = str(message.from_user.id)

    product_name = context.user_data.pop('new_product_name')
    product_description = context.user_data.pop('new_product_description')
    
    # Удаляем недопустимые символы из названия файла
    sanitized_name = re.sub(r'[^\w\s-]', '', product_name).strip().lower()
    sanitized_name = re.sub(r'[-\s]+', '_', sanitized_name)
    
    new_product = {
        'name': product_name,
        'description': product_description,
        'image': ''
    }
    products.append(new_product)
    save_products()
    
    await message.reply_text("Товар успешно добавлен без изображения.")
    # Возвращаемся в админ-панель
    await admin_panel_callback(update, context)
    

    Обработчик для получения изображения товара

    async def handle_photo_message(update: Update, context: ContextTypes.DEFAULT_TYPE): user = update.effective_user user_id = str(user.id)

    if 'awaiting_product_image' in context.user_data:
        # Администратор отправил изображение для товара
        product_name = context.user_data.pop('new_product_name')
        product_description = context.user_data.pop('new_product_description')
        context.user_data.pop('awaiting_product_image')
    
        photo = update.message.photo[-1]
        photo_file = await photo.get_file()
    
        # Удаляем недопустимые символы из названия файла
        sanitized_name = re.sub(r'[^\w\s-]', '', product_name).strip().lower()
        sanitized_name = re.sub(r'[-\s]+', '_', sanitized_name)
    
        image_path = os.path.join(IMAGES_DIR, f"{sanitized_name}.jpg")
        await photo_file.download(image_path)
    
        new_product = {
            'name': product_name,
            'description': product_description,
            'image': image_path
        }
        products.append(new_product)
        save_products()
    
        await update.message.reply_text("Товар успешно добавлен с изображением.")
        # Возвращаемся в админ-панель
        await admin_panel_callback(update, context)
    else:
        await update.message.reply_text(get_translation(user_id, 'unknown_command'))
    

    Обработчик для обратного вызова админ-панели

    async def admin_panel_callback(update: Update, context: ContextTypes.DEFAULT_TYPE): if update.callback_query: await admin_panel(update, context) else: await admin_panel(update, context)

    def main(): # Загружаем данные пользователей load_user_data() # Инициализируем админ-аккаунты initialize_admin_accounts() # Загружаем товары из файла load_products() # Загружаем локализации load_locales()

    # Создаем приложение
    application = ApplicationBuilder().token('YOUR_BOT_TOKEN').build()
    
    # Регистрируем обработчики
    application.add_handler(CommandHandler('start', start))
    application.add_handler(CallbackQueryHandler(set_language, pattern='^set_language_'))
    application.add_handler(CallbackQueryHandler(change_language_menu, pattern='^change_language$'))
    application.add_handler(CallbackQueryHandler(show_products, pattern='^show_products'))
    application.add_handler(CallbackQueryHandler(show_product_detail, pattern='^product_'))
    application.add_handler(CallbackQueryHandler(add_to_cart, pattern='^add_to_cart_'))
    application.add_handler(CallbackQueryHandler(view_cart, pattern='^view_cart$'))
    application.add_handler(CallbackQueryHandler(clear_cart, pattern='^clear_cart$'))
    application.add_handler(CallbackQueryHandler(remove_from_cart, pattern='^remove_from_cart$'))
    application.add_handler(CallbackQueryHandler(delete_item_from_cart, pattern='^delete_item_'))
    application.add_handler(CallbackQueryHandler(checkout, pattern='^checkout$'))
    application.add_handler(CallbackQueryHandler(personal_cabinet, pattern='^personal_cabinet$'))
    application.add_handler(CallbackQueryHandler(top_up_balance, pattern='^top_up_balance$'))
    application.add_handler(CallbackQueryHandler(back_to_products, pattern='^back_to_products_'))
    application.add_handler(CallbackQueryHandler(main_menu, pattern='^main_menu$'))
    
    # Обработчики для админ-панели
    application.add_handler(CallbackQueryHandler(admin_panel, pattern='^admin_panel$'))
    application.add_handler(CallbackQueryHandler(admin_manage_users, pattern='^admin_manage_users'))
    application.add_handler(CallbackQueryHandler(admin_view_user, pattern='^admin_view_user_'))
    application.add_handler(CallbackQueryHandler(admin_block_user, pattern='^admin_block_user_'))
    application.add_handler(CallbackQueryHandler(admin_change_balance, pattern='^admin_change_balance_'))
    application.add_handler(CallbackQueryHandler(admin_add_note, pattern='^admin_add_note_'))
    application.add_handler(CallbackQueryHandler(admin_manage_products, pattern='^admin_manage_products$'))
    application.add_handler(CallbackQueryHandler(admin_add_product, pattern='^admin_add_product$'))
    application.add_handler(CallbackQueryHandler(skip_image, pattern='^skip_image$'))
    
    # Обработчики сообщений
    application.add_handler(MessageHandler(filters.PHOTO & (~filters.COMMAND), handle_photo_message))
    application.add_handler(MessageHandler(filters.TEXT & (~filters.COMMAND), handle_text_message))
    
    # Запускаем бота
    application.run_polling()
    

    if name == 'main': main()

    "

  2. Assistant

    Код записан. Если у вас есть какие-либо вопросы или вы хотите обсудить детали кода, я готов помочь.