krasi/BOTKlining
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

old_01

Browse Source
This commit is contained in:
krasi
2025-06-08 20:55:08 +09:00
parent f7e0d17829
commit 7a75f79413
139 changed files with 10619 additions and 2340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
doners/old/__init__.py Normal file
View File

206
doners/old/bot(OLD).py
View File

@@ -1,103 +1,103 @@
import os
import logging
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.utils import executor
from aiogram.dispatcher.filters import Text
from database import create_tables
from logger import log_action
from dotenv import load_dotenv
# Загрузка переменных окружения из .env файла
load_dotenv()
API_TOKEN = os.getenv('BOT_API_TOKEN')
OPERATORS_GROUP_ID = os.getenv('OPERATORS_GROUP_ID')
ADMIN_GROUP_ID = os.getenv('ADMIN_GROUP_ID')
logging.basicConfig(level=logging.INFO)
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Inline клавиатуры
def main_menu_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Учетные данные', callback_data='account_data'))
keyboard.add(InlineKeyboardButton('Сделать заказ', callback_data='make_order'))
keyboard.add(InlineKeyboardButton('История заказов', callback_data='order_history'))
keyboard.add(InlineKeyboardButton('Заказать звонок', callback_data='request_call'))
keyboard.add(InlineKeyboardButton('Начать разговор с оператором', callback_data='talk_operator'))
return keyboard
def account_data_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Изменить ФИО', callback_data='change_name'))
keyboard.add(InlineKeyboardButton('Изменить номер телефона', callback_data='change_phone'))
keyboard.add(InlineKeyboardButton('Добавить адрес', callback_data='add_address'))
keyboard.add(InlineKeyboardButton('Удалить адрес', callback_data='delete_address'))
keyboard.add(InlineKeyboardButton('Поделиться контактом', callback_data='share_contact'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
def order_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Добавить учетные данные', callback_data='add_account_data'))
keyboard.add(InlineKeyboardButton('Выбрать адрес', callback_data='select_address'))
keyboard.add(InlineKeyboardButton('Выбрать время для уборки', callback_data='select_time'))
keyboard.add(InlineKeyboardButton('Выбрать тип уборки', callback_data='select_cleaning_type'))
keyboard.add(InlineKeyboardButton('Выбрать способ оплаты', callback_data='select_payment_method'))
keyboard.add(InlineKeyboardButton('Подтвердить заказ', callback_data='confirm_order'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
# Обработчики команд
@dp.message_handler(commands=['start'])
async def send_welcome(message: types.Message):
await message.answer("Добро пожаловать в BOTKlining!", reply_markup=main_menu_keyboard())
log_action(message.from_user.id, 'start')
@dp.callback_query_handler(lambda c: c.data == 'account_data')
async def process_account_data(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Учетные данные:", reply_markup=account_data_keyboard())
log_action(callback_query.from_user.id, 'account_data')
@dp.callback_query_handler(lambda c: c.data == 'make_order')
async def process_make_order(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Сделать заказ:", reply_markup=order_keyboard())
log_action(callback_query.from_user.id, 'make_order')
@dp.callback_query_handler(lambda c: c.data == 'order_history')
async def process_order_history(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для просмотра истории заказов
await bot.send_message(callback_query.from_user.id, "История заказов:")
log_action(callback_query.from_user.id, 'order_history')
@dp.callback_query_handler(lambda c: c.data == 'request_call')
async def process_request_call(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для заказа звонка
await bot.send_message(callback_query.from_user.id, "Заказ звонка оформлен. Ожидайте звонок в течение 30 минут.")
log_action(callback_query.from_user.id, 'request_call')
@dp.callback_query_handler(lambda c: c.data == 'talk_operator')
async def process_talk_operator(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для начала разговора с оператором
await bot.send_message(callback_query.from_user.id, "Разговор с оператором начат.")
log_action(callback_query.from_user.id, 'talk_operator')
@dp.callback_query_handler(lambda c: c.data == 'back_to_main')
async def process_back_to_main(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Главное меню:", reply_markup=main_menu_keyboard())
log_action(callback_query.from_user.id, 'back_to_main')
if __name__ == '__main__':
create_tables()
executor.start_polling(dp, skip_updates=True)
import os
import logging
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.utils import executor
from aiogram.dispatcher.filters import Text
from database import create_tables
from logger import log_action
from dotenv import load_dotenv
# Загрузка переменных окружения из .env файла
load_dotenv()
API_TOKEN = os.getenv('BOT_API_TOKEN')
OPERATORS_GROUP_ID = os.getenv('OPERATORS_GROUP_ID')
ADMIN_GROUP_ID = os.getenv('ADMIN_GROUP_ID')
logging.basicConfig(level=logging.INFO)
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Inline клавиатуры
def main_menu_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Учетные данные', callback_data='account_data'))
keyboard.add(InlineKeyboardButton('Сделать заказ', callback_data='make_order'))
keyboard.add(InlineKeyboardButton('История заказов', callback_data='order_history'))
keyboard.add(InlineKeyboardButton('Заказать звонок', callback_data='request_call'))
keyboard.add(InlineKeyboardButton('Начать разговор с оператором', callback_data='talk_operator'))
return keyboard
def account_data_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Изменить ФИО', callback_data='change_name'))
keyboard.add(InlineKeyboardButton('Изменить номер телефона', callback_data='change_phone'))
keyboard.add(InlineKeyboardButton('Добавить адрес', callback_data='add_address'))
keyboard.add(InlineKeyboardButton('Удалить адрес', callback_data='delete_address'))
keyboard.add(InlineKeyboardButton('Поделиться контактом', callback_data='share_contact'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
def order_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Добавить учетные данные', callback_data='add_account_data'))
keyboard.add(InlineKeyboardButton('Выбрать адрес', callback_data='select_address'))
keyboard.add(InlineKeyboardButton('Выбрать время для уборки', callback_data='select_time'))
keyboard.add(InlineKeyboardButton('Выбрать тип уборки', callback_data='select_cleaning_type'))
keyboard.add(InlineKeyboardButton('Выбрать способ оплаты', callback_data='select_payment_method'))
keyboard.add(InlineKeyboardButton('Подтвердить заказ', callback_data='confirm_order'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
# Обработчики команд
@dp.message_handler(commands=['start'])
async def send_welcome(message: types.Message):
await message.answer("Добро пожаловать в BOTKlining!", reply_markup=main_menu_keyboard())
log_action(message.from_user.id, 'start')
@dp.callback_query_handler(lambda c: c.data == 'account_data')
async def process_account_data(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Учетные данные:", reply_markup=account_data_keyboard())
log_action(callback_query.from_user.id, 'account_data')
@dp.callback_query_handler(lambda c: c.data == 'make_order')
async def process_make_order(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Сделать заказ:", reply_markup=order_keyboard())
log_action(callback_query.from_user.id, 'make_order')
@dp.callback_query_handler(lambda c: c.data == 'order_history')
async def process_order_history(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для просмотра истории заказов
await bot.send_message(callback_query.from_user.id, "История заказов:")
log_action(callback_query.from_user.id, 'order_history')
@dp.callback_query_handler(lambda c: c.data == 'request_call')
async def process_request_call(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для заказа звонка
await bot.send_message(callback_query.from_user.id, "Заказ звонка оформлен. Ожидайте звонок в течение 30 минут.")
log_action(callback_query.from_user.id, 'request_call')
@dp.callback_query_handler(lambda c: c.data == 'talk_operator')
async def process_talk_operator(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для начала разговора с оператором
await bot.send_message(callback_query.from_user.id, "Разговор с оператором начат.")
log_action(callback_query.from_user.id, 'talk_operator')
@dp.callback_query_handler(lambda c: c.data == 'back_to_main')
async def process_back_to_main(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Главное меню:", reply_markup=main_menu_keyboard())
log_action(callback_query.from_user.id, 'back_to_main')
if __name__ == '__main__':
create_tables()
executor.start_polling(dp, skip_updates=True)

508
doners/old/bot.py
View File

@@ -1,254 +1,254 @@
import logging
import sqlite3
from aiogram import types
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.utils import executor
from aiogram import Bot, Dispatcher
from aiogram.dispatcher.filters import Text
from database import create_tables, add_user, update_user_name, update_user_phone, add_address, delete_address
from logger import log_action
from dotenv import load_dotenv
import os
# Загрузка переменных окружения из .env файла
load_dotenv()
API_TOKEN = os.getenv('BOT_API_TOKEN')
OPERATORS_GROUP_ID = int(os.getenv('OPERATORS_GROUP_ID'))
ADMIN_GROUP_ID = int(os.getenv('ADMIN_GROUP_ID'))
logging.basicConfig(level=logging.INFO)
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Состояния
class OrderForm(StatesGroup):
waiting_for_name = State()
waiting_for_phone = State()
waiting_for_address = State()
waiting_for_cleaning_time = State()
waiting_for_cleaning_type = State()
waiting_for_payment_method = State()
confirmation = State()
class CallRequest(StatesGroup):
waiting_for_name = State()
waiting_for_phone = State()
class OperatorChat(StatesGroup):
in_chat = State()
# Inline клавиатуры
def main_menu_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Учетные данные', callback_data='account_data'))
keyboard.add(InlineKeyboardButton('Сделать заказ', callback_data='make_order'))
keyboard.add(InlineKeyboardButton('История заказов', callback_data='order_history'))
keyboard.add(InlineKeyboardButton('Заказать звонок', callback_data='request_call'))
keyboard.add(InlineKeyboardButton('Начать разговор с оператором', callback_data='talk_operator'))
return keyboard
def account_data_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Изменить ФИО', callback_data='change_name'))
keyboard.add(InlineKeyboardButton('Изменить номер телефона', callback_data='change_phone'))
keyboard.add(InlineKeyboardButton('Добавить адрес', callback_data='add_address'))
keyboard.add(InlineKeyboardButton('Удалить адрес', callback_data='delete_address'))
keyboard.add(InlineKeyboardButton('Поделиться контактом', callback_data='share_contact'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
def order_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Добавить учетные данные', callback_data='add_account_data'))
keyboard.add(InlineKeyboardButton('Выбрать адрес', callback_data='select_address'))
keyboard.add(InlineKeyboardButton('Выбрать время для уборки', callback_data='select_time'))
keyboard.add(InlineKeyboardButton('Выбрать тип уборки', callback_data='select_cleaning_type'))
keyboard.add(InlineKeyboardButton('Выбрать способ оплаты', callback_data='select_payment_method'))
keyboard.add(InlineKeyboardButton('Подтвердить заказ', callback_data='confirm_order'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
# Основные команды
@dp.message_handler(commands=['start'])
async def send_welcome(message: types.Message):
await message.answer("Добро пожаловать в BOTKlining!", reply_markup=main_menu_keyboard())
log_action(message.from_user.id, 'start')
@dp.callback_query_handler(lambda c: c.data == 'account_data')
async def process_account_data(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Учетные данные:", reply_markup=account_data_keyboard())
log_action(callback_query.from_user.id, 'account_data')
@dp.callback_query_handler(lambda c: c.data == 'make_order')
async def process_make_order(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Сделать заказ:", reply_markup=order_keyboard())
log_action(callback_query.from_user.id, 'make_order')
@dp.callback_query_handler(lambda c: c.data == 'order_history')
async def process_order_history(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для просмотра истории заказов
await bot.send_message(callback_query.from_user.id, "История заказов:")
log_action(callback_query.from_user.id, 'order_history')
@dp.callback_query_handler(lambda c: c.data == 'request_call')
async def process_request_call(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для заказа звонка
await bot.send_message(callback_query.from_user.id, "Заказ звонка оформлен. Ожидайте звонок в течение 30 минут.")
log_action(callback_query.from_user.id, 'request_call')
@dp.callback_query_handler(lambda c: c.data == 'talk_operator')
async def process_talk_operator(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для начала разговора с оператором
await bot.send_message(callback_query.from_user.id, "Разговор с оператором начат.")
log_action(callback_query.from_user.id, 'talk_operator')
@dp.callback_query_handler(lambda c: c.data == 'back_to_main')
async def process_back_to_main(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Главное меню:", reply_markup=main_menu_keyboard())
log_action(callback_query.from_user.id, 'back_to_main')
# Добавление учетных данных
@dp.callback_query_handler(lambda c: c.data == 'add_account_data')
async def process_add_account_data(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите ваше ФИО:")
await OrderForm.waiting_for_name.set()
@dp.message_handler(state=OrderForm.waiting_for_name, content_types=types.ContentTypes.TEXT)
async def process_name(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['name'] = message.text
await message.answer("Введите ваш номер телефона:")
await OrderForm.waiting_for_phone.set()
@dp.message_handler(state=OrderForm.waiting_for_phone, content_types=types.ContentTypes.TEXT)
async def process_phone(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['phone'] = message.text
user_id = message.from_user.id
name = data['name']
phone = data['phone']
add_user(user_id, name, phone)
await message.answer("Ваши данные успешно сохранены!")
await state.finish()
# Изменение учетных данных
@dp.callback_query_handler(lambda c: c.data == 'change_name')
async def process_change_name(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите новое ФИО:")
await OrderForm.waiting_for_name.set()
@dp.callback_query_handler(lambda c: c.data == 'change_phone')
async def process_change_phone(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите новый номер телефона:")
await OrderForm.waiting_for_phone.set()
# Добавление адреса
@dp.callback_query_handler(lambda c: c.data == 'add_address')
async def process_add_address(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите адрес для добавления:")
await OrderForm.waiting_for_address.set()
@dp.message_handler(state=OrderForm.waiting_for_address, content_types=types.ContentTypes.TEXT)
async def process_add_address_step(message: types.Message, state: FSMContext):
user_id = message.from_user.id
address = message.text
add_address(user_id, address)
await message.answer("Адрес успешно добавлен!")
await state.finish()
# Удаление адреса
@dp.callback_query_handler(lambda c: c.data == 'delete_address')
async def process_delete_address(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите адрес для удаления:")
await OrderForm.waiting_for_address.set()
@dp.message_handler(state=OrderForm.waiting_for_address, content_types=types.ContentTypes.TEXT)
async def process_delete_address_step(message: types.Message, state: FSMContext):
user_id = message.from_user.id
address = message.text
delete_address(user_id, address)
await message.answer("Адрес успешно удален!")
await state.finish()
# Обработка заказа
@dp.callback_query_handler(lambda c: c.data == 'select_address')
async def process_select_address(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите адрес для уборки:")
await OrderForm.waiting_for_address.set()
@dp.message_handler(state=OrderForm.waiting_for_address, content_types=types.ContentTypes.TEXT)
async def process_order_address(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['address'] = message.text
await message.answer("Выберите время для уборки (утро/день/вечер):")
await OrderForm.waiting_for_cleaning_time.set()
@dp.message_handler(state=OrderForm.waiting_for_cleaning_time, content_types=types.ContentTypes.TEXT)
async def process_cleaning_time(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['cleaning_time'] = message.text
await message.answer("Выберите тип уборки (влажная/сухая/генеральная):")
await OrderForm.waiting_for_cleaning_type.set()
@dp.message_handler(state=OrderForm.waiting_for_cleaning_type, content_types=types.ContentTypes.TEXT)
async def process_cleaning_type(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['cleaning_type'] = message.text
await message.answer("Выберите способ оплаты (картой/наличными):")
await OrderForm.waiting_for_payment_method.set()
@dp.message_handler(state=OrderForm.waiting_for_payment_method, content_types=types.ContentTypes.TEXT)
async def process_payment_method(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['payment_method'] = message.text
# Отправка подтверждения заказа
await message.answer("Подтвердите заказ:\n"
f"Адрес: {data['address']}\n"
f"Время уборки: {data['cleaning_time']}\n"
f"Тип уборки: {data['cleaning_type']}\n"
f"Способ оплаты: {data['payment_method']}\n"
"Если все верно, нажмите 'Подтвердить'. В противном случае, измените нужные данные.",
reply_markup=InlineKeyboardMarkup().add(InlineKeyboardButton('Подтвердить', callback_data='confirm_order')))
await OrderForm.confirmation.set()
@dp.callback_query_handler(lambda c: c.data == 'confirm_order', state=OrderForm.confirmation)
async def process_confirm_order(callback_query: types.CallbackQuery, state: FSMContext):
await bot.answer_callback_query(callback_query.id)
async with state.proxy() as data:
order_details = (f"Новый заказ:\n"
f"ФИО: {data['name']}\n"
f"Номер телефона: {data['phone']}\n"
f"Адрес: {data['address']}\n"
f"Время уборки: {data['cleaning_time']}\n"
f"Тип уборки: {data['cleaning_type']}\n"
f"Способ оплаты: {data['payment_method']}")
await bot.send_message(OPERATORS_GROUP_ID, order_details)
log_action(callback_query.from_user.id, 'confirm_order')
await bot.send_message(callback_query.from_user.id, "Ваш заказ был подтвержден и отправлен операторам.")
await state.finish()
# Основное приложение
if __name__ == '__main__':
create_tables()
executor.start_polling(dp, skip_updates=True)
import logging
import sqlite3
from aiogram import types
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.utils import executor
from aiogram import Bot, Dispatcher
from aiogram.dispatcher.filters import Text
from database import create_tables, add_user, update_user_name, update_user_phone, add_address, delete_address
from logger import log_action
from dotenv import load_dotenv
import os
# Загрузка переменных окружения из .env файла
load_dotenv()
API_TOKEN = os.getenv('BOT_API_TOKEN')
OPERATORS_GROUP_ID = int(os.getenv('OPERATORS_GROUP_ID'))
ADMIN_GROUP_ID = int(os.getenv('ADMIN_GROUP_ID'))
logging.basicConfig(level=logging.INFO)
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Состояния
class OrderForm(StatesGroup):
waiting_for_name = State()
waiting_for_phone = State()
waiting_for_address = State()
waiting_for_cleaning_time = State()
waiting_for_cleaning_type = State()
waiting_for_payment_method = State()
confirmation = State()
class CallRequest(StatesGroup):
waiting_for_name = State()
waiting_for_phone = State()
class OperatorChat(StatesGroup):
in_chat = State()
# Inline клавиатуры
def main_menu_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Учетные данные', callback_data='account_data'))
keyboard.add(InlineKeyboardButton('Сделать заказ', callback_data='make_order'))
keyboard.add(InlineKeyboardButton('История заказов', callback_data='order_history'))
keyboard.add(InlineKeyboardButton('Заказать звонок', callback_data='request_call'))
keyboard.add(InlineKeyboardButton('Начать разговор с оператором', callback_data='talk_operator'))
return keyboard
def account_data_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Изменить ФИО', callback_data='change_name'))
keyboard.add(InlineKeyboardButton('Изменить номер телефона', callback_data='change_phone'))
keyboard.add(InlineKeyboardButton('Добавить адрес', callback_data='add_address'))
keyboard.add(InlineKeyboardButton('Удалить адрес', callback_data='delete_address'))
keyboard.add(InlineKeyboardButton('Поделиться контактом', callback_data='share_contact'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
def order_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Добавить учетные данные', callback_data='add_account_data'))
keyboard.add(InlineKeyboardButton('Выбрать адрес', callback_data='select_address'))
keyboard.add(InlineKeyboardButton('Выбрать время для уборки', callback_data='select_time'))
keyboard.add(InlineKeyboardButton('Выбрать тип уборки', callback_data='select_cleaning_type'))
keyboard.add(InlineKeyboardButton('Выбрать способ оплаты', callback_data='select_payment_method'))
keyboard.add(InlineKeyboardButton('Подтвердить заказ', callback_data='confirm_order'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
# Основные команды
@dp.message_handler(commands=['start'])
async def send_welcome(message: types.Message):
await message.answer("Добро пожаловать в BOTKlining!", reply_markup=main_menu_keyboard())
log_action(message.from_user.id, 'start')
@dp.callback_query_handler(lambda c: c.data == 'account_data')
async def process_account_data(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Учетные данные:", reply_markup=account_data_keyboard())
log_action(callback_query.from_user.id, 'account_data')
@dp.callback_query_handler(lambda c: c.data == 'make_order')
async def process_make_order(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Сделать заказ:", reply_markup=order_keyboard())
log_action(callback_query.from_user.id, 'make_order')
@dp.callback_query_handler(lambda c: c.data == 'order_history')
async def process_order_history(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для просмотра истории заказов
await bot.send_message(callback_query.from_user.id, "История заказов:")
log_action(callback_query.from_user.id, 'order_history')
@dp.callback_query_handler(lambda c: c.data == 'request_call')
async def process_request_call(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для заказа звонка
await bot.send_message(callback_query.from_user.id, "Заказ звонка оформлен. Ожидайте звонок в течение 30 минут.")
log_action(callback_query.from_user.id, 'request_call')
@dp.callback_query_handler(lambda c: c.data == 'talk_operator')
async def process_talk_operator(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для начала разговора с оператором
await bot.send_message(callback_query.from_user.id, "Разговор с оператором начат.")
log_action(callback_query.from_user.id, 'talk_operator')
@dp.callback_query_handler(lambda c: c.data == 'back_to_main')
async def process_back_to_main(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Главное меню:", reply_markup=main_menu_keyboard())
log_action(callback_query.from_user.id, 'back_to_main')
# Добавление учетных данных
@dp.callback_query_handler(lambda c: c.data == 'add_account_data')
async def process_add_account_data(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите ваше ФИО:")
await OrderForm.waiting_for_name.set()
@dp.message_handler(state=OrderForm.waiting_for_name, content_types=types.ContentTypes.TEXT)
async def process_name(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['name'] = message.text
await message.answer("Введите ваш номер телефона:")
await OrderForm.waiting_for_phone.set()
@dp.message_handler(state=OrderForm.waiting_for_phone, content_types=types.ContentTypes.TEXT)
async def process_phone(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['phone'] = message.text
user_id = message.from_user.id
name = data['name']
phone = data['phone']
add_user(user_id, name, phone)
await message.answer("Ваши данные успешно сохранены!")
await state.finish()
# Изменение учетных данных
@dp.callback_query_handler(lambda c: c.data == 'change_name')
async def process_change_name(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите новое ФИО:")
await OrderForm.waiting_for_name.set()
@dp.callback_query_handler(lambda c: c.data == 'change_phone')
async def process_change_phone(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите новый номер телефона:")
await OrderForm.waiting_for_phone.set()
# Добавление адреса
@dp.callback_query_handler(lambda c: c.data == 'add_address')
async def process_add_address(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите адрес для добавления:")
await OrderForm.waiting_for_address.set()
@dp.message_handler(state=OrderForm.waiting_for_address, content_types=types.ContentTypes.TEXT)
async def process_add_address_step(message: types.Message, state: FSMContext):
user_id = message.from_user.id
address = message.text
add_address(user_id, address)
await message.answer("Адрес успешно добавлен!")
await state.finish()
# Удаление адреса
@dp.callback_query_handler(lambda c: c.data == 'delete_address')
async def process_delete_address(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите адрес для удаления:")
await OrderForm.waiting_for_address.set()
@dp.message_handler(state=OrderForm.waiting_for_address, content_types=types.ContentTypes.TEXT)
async def process_delete_address_step(message: types.Message, state: FSMContext):
user_id = message.from_user.id
address = message.text
delete_address(user_id, address)
await message.answer("Адрес успешно удален!")
await state.finish()
# Обработка заказа
@dp.callback_query_handler(lambda c: c.data == 'select_address')
async def process_select_address(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Введите адрес для уборки:")
await OrderForm.waiting_for_address.set()
@dp.message_handler(state=OrderForm.waiting_for_address, content_types=types.ContentTypes.TEXT)
async def process_order_address(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['address'] = message.text
await message.answer("Выберите время для уборки (утро/день/вечер):")
await OrderForm.waiting_for_cleaning_time.set()
@dp.message_handler(state=OrderForm.waiting_for_cleaning_time, content_types=types.ContentTypes.TEXT)
async def process_cleaning_time(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['cleaning_time'] = message.text
await message.answer("Выберите тип уборки (влажная/сухая/генеральная):")
await OrderForm.waiting_for_cleaning_type.set()
@dp.message_handler(state=OrderForm.waiting_for_cleaning_type, content_types=types.ContentTypes.TEXT)
async def process_cleaning_type(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['cleaning_type'] = message.text
await message.answer("Выберите способ оплаты (картой/наличными):")
await OrderForm.waiting_for_payment_method.set()
@dp.message_handler(state=OrderForm.waiting_for_payment_method, content_types=types.ContentTypes.TEXT)
async def process_payment_method(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['payment_method'] = message.text
# Отправка подтверждения заказа
await message.answer("Подтвердите заказ:\n"
f"Адрес: {data['address']}\n"
f"Время уборки: {data['cleaning_time']}\n"
f"Тип уборки: {data['cleaning_type']}\n"
f"Способ оплаты: {data['payment_method']}\n"
"Если все верно, нажмите 'Подтвердить'. В противном случае, измените нужные данные.",
reply_markup=InlineKeyboardMarkup().add(InlineKeyboardButton('Подтвердить', callback_data='confirm_order')))
await OrderForm.confirmation.set()
@dp.callback_query_handler(lambda c: c.data == 'confirm_order', state=OrderForm.confirmation)
async def process_confirm_order(callback_query: types.CallbackQuery, state: FSMContext):
await bot.answer_callback_query(callback_query.id)
async with state.proxy() as data:
order_details = (f"Новый заказ:\n"
f"ФИО: {data['name']}\n"
f"Номер телефона: {data['phone']}\n"
f"Адрес: {data['address']}\n"
f"Время уборки: {data['cleaning_time']}\n"
f"Тип уборки: {data['cleaning_type']}\n"
f"Способ оплаты: {data['payment_method']}")
await bot.send_message(OPERATORS_GROUP_ID, order_details)
log_action(callback_query.from_user.id, 'confirm_order')
await bot.send_message(callback_query.from_user.id, "Ваш заказ был подтвержден и отправлен операторам.")
await state.finish()
# Основное приложение
if __name__ == '__main__':
create_tables()
executor.start_polling(dp, skip_updates=True)

176
doners/old/database.py
View File

@@ -1,89 +1,89 @@
import sqlite3
def create_tables():
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
telegram_id INTEGER UNIQUE,
name TEXT,
phone TEXT
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS addresses (
id INTEGER PRIMARY KEY,
user_id INTEGER,
address TEXT,
FOREIGN KEY(user_id) REFERENCES users(id)
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS orders (
id INTEGER PRIMARY KEY,
user_id INTEGER,
address TEXT,
cleaning_time TEXT,
cleaning_type TEXT,
payment_method TEXT,
order_id TEXT UNIQUE,
FOREIGN KEY(user_id) REFERENCES users(id)
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS logs (
id INTEGER PRIMARY KEY,
user_id INTEGER,
action TEXT,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY(user_id) REFERENCES users(id)
)
''')
conn.commit()
conn.close()
def add_user(telegram_id, name, phone):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('INSERT OR IGNORE INTO users (telegram_id, name, phone) VALUES (?, ?, ?)', (telegram_id, name, phone))
conn.commit()
conn.close()
def update_user_name(telegram_id, name):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('UPDATE users SET name = ? WHERE telegram_id = ?', (name, telegram_id))
conn.commit()
conn.close()
def update_user_phone(telegram_id, phone):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('UPDATE users SET phone = ? WHERE telegram_id = ?', (phone, telegram_id))
conn.commit()
conn.close()
def add_address(telegram_id, address):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('SELECT id FROM users WHERE telegram_id = ?', (telegram_id,))
user_id = cursor.fetchone()[0]
cursor.execute('INSERT INTO addresses (user_id, address) VALUES (?, ?)', (user_id, address))
conn.commit()
conn.close()
def delete_address(telegram_id, address):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('SELECT id FROM users WHERE telegram_id = ?', (telegram_id,))
user_id = cursor.fetchone()[0]
cursor.execute('DELETE FROM addresses WHERE user_id = ? AND address = ?', (user_id, address))
conn.commit()
import sqlite3
def create_tables():
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
telegram_id INTEGER UNIQUE,
name TEXT,
phone TEXT
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS addresses (
id INTEGER PRIMARY KEY,
user_id INTEGER,
address TEXT,
FOREIGN KEY(user_id) REFERENCES users(id)
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS orders (
id INTEGER PRIMARY KEY,
user_id INTEGER,
address TEXT,
cleaning_time TEXT,
cleaning_type TEXT,
payment_method TEXT,
order_id TEXT UNIQUE,
FOREIGN KEY(user_id) REFERENCES users(id)
)
''')
cursor.execute('''
CREATE TABLE IF NOT EXISTS logs (
id INTEGER PRIMARY KEY,
user_id INTEGER,
action TEXT,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY(user_id) REFERENCES users(id)
)
''')
conn.commit()
conn.close()
def add_user(telegram_id, name, phone):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('INSERT OR IGNORE INTO users (telegram_id, name, phone) VALUES (?, ?, ?)', (telegram_id, name, phone))
conn.commit()
conn.close()
def update_user_name(telegram_id, name):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('UPDATE users SET name = ? WHERE telegram_id = ?', (name, telegram_id))
conn.commit()
conn.close()
def update_user_phone(telegram_id, phone):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('UPDATE users SET phone = ? WHERE telegram_id = ?', (phone, telegram_id))
conn.commit()
conn.close()
def add_address(telegram_id, address):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('SELECT id FROM users WHERE telegram_id = ?', (telegram_id,))
user_id = cursor.fetchone()[0]
cursor.execute('INSERT INTO addresses (user_id, address) VALUES (?, ?)', (user_id, address))
conn.commit()
conn.close()
def delete_address(telegram_id, address):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('SELECT id FROM users WHERE telegram_id = ?', (telegram_id,))
user_id = cursor.fetchone()[0]
cursor.execute('DELETE FROM addresses WHERE user_id = ? AND address = ?', (user_id, address))
conn.commit()
conn.close()

366
doners/old/handlers.py
View File

@@ -1,183 +1,183 @@
import logging
import sqlite3
from aiogram import types
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.utils import executor
from aiogram import Bot, Dispatcher
from aiogram.dispatcher.filters import Text
from database import create_tables, add_user, update_user_name, update_user_phone, add_address, delete_address, add_order
from logger import log_action
from dotenv import load_dotenv
import os
# Загрузка переменных окружения из .env файла
load_dotenv()
API_TOKEN = os.getenv('BOT_API_TOKEN')
OPERATORS_GROUP_ID = int(os.getenv('OPERATORS_GROUP_ID'))
ADMIN_GROUP_ID = int(os.getenv('ADMIN_GROUP_ID'))
logging.basicConfig(level=logging.INFO)
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Состояния для заказа
class OrderForm(StatesGroup):
waiting_for_name = State()
waiting_for_phone = State()
waiting_for_address = State()
waiting_for_cleaning_time = State()
waiting_for_cleaning_type = State()
waiting_for_payment_method = State()
confirmation = State()
# Inline клавиатуры
def main_menu_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Учетные данные', callback_data='account_data'))
keyboard.add(InlineKeyboardButton('Сделать заказ', callback_data='make_order'))
keyboard.add(InlineKeyboardButton('История заказов', callback_data='order_history'))
keyboard.add(InlineKeyboardButton('Заказать звонок', callback_data='request_call'))
keyboard.add(InlineKeyboardButton('Начать разговор с оператором', callback_data='talk_operator'))
return keyboard
def account_data_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Изменить ФИО', callback_data='change_name'))
keyboard.add(InlineKeyboardButton('Изменить номер телефона', callback_data='change_phone'))
keyboard.add(InlineKeyboardButton('Добавить адрес', callback_data='add_address'))
keyboard.add(InlineKeyboardButton('Удалить адрес', callback_data='delete_address'))
keyboard.add(InlineKeyboardButton('Поделиться контактом', callback_data='share_contact'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
# Основные команды
@dp.message_handler(commands=['start'])
async def send_welcome(message: types.Message):
await message.answer("Добро пожаловать в BOTKlining!", reply_markup=main_menu_keyboard())
log_action(message.from_user.id, 'start')
@dp.callback_query_handler(lambda c: c.data == 'account_data')
async def process_account_data(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Учетные данные:", reply_markup=account_data_keyboard())
log_action(callback_query.from_user.id, 'account_data')
@dp.callback_query_handler(lambda c: c.data == 'make_order')
async def process_make_order(callback_query: types.CallbackQuery, state: FSMContext):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Начнем с ваших учетных данных. Введите ваше ФИО:")
await OrderForm.waiting_for_name.set()
log_action(callback_query.from_user.id, 'make_order')
@dp.callback_query_handler(lambda c: c.data == 'order_history')
async def process_order_history(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для просмотра истории заказов
await bot.send_message(callback_query.from_user.id, "История заказов:")
log_action(callback_query.from_user.id, 'order_history')
@dp.callback_query_handler(lambda c: c.data == 'request_call')
async def process_request_call(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для заказа звонка
await bot.send_message(callback_query.from_user.id, "Заказ звонка оформлен. Ожидайте звонок в течение 30 минут.")
log_action(callback_query.from_user.id, 'request_call')
@dp.callback_query_handler(lambda c: c.data == 'talk_operator')
async def process_talk_operator(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для начала разговора с оператором
await bot.send_message(callback_query.from_user.id, "Разговор с оператором начат.")
log_action(callback_query.from_user.id, 'talk_operator')
@dp.callback_query_handler(lambda c: c.data == 'back_to_main')
async def process_back_to_main(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Главное меню:", reply_markup=main_menu_keyboard())
log_action(callback_query.from_user.id, 'back_to_main')
# Обработка шагов заказа
@dp.message_handler(state=OrderForm.waiting_for_name, content_types=types.ContentTypes.TEXT)
async def process_name(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['name'] = message.text
await message.answer("Введите ваш номер телефона:")
await OrderForm.waiting_for_phone.set()
@dp.message_handler(state=OrderForm.waiting_for_phone, content_types=types.ContentTypes.TEXT)
async def process_phone(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['phone'] = message.text
await message.answer("Введите адрес для уборки:")
await OrderForm.waiting_for_address.set()
@dp.message_handler(state=OrderForm.waiting_for_address, content_types=types.ContentTypes.TEXT)
async def process_order_address(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['address'] = message.text
await message.answer("Выберите время для уборки (утро/день/вечер):")
await OrderForm.waiting_for_cleaning_time.set()
@dp.message_handler(state=OrderForm.waiting_for_cleaning_time, content_types=types.ContentTypes.TEXT)
async def process_cleaning_time(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['cleaning_time'] = message.text
await message.answer("Выберите тип уборки (влажная/сухая/генеральная):")
await OrderForm.waiting_for_cleaning_type.set()
@dp.message_handler(state=OrderForm.waiting_for_cleaning_type, content_types=types.ContentTypes.TEXT)
async def process_cleaning_type(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['cleaning_type'] = message.text
await message.answer("Выберите способ оплаты (картой/наличными):")
await OrderForm.waiting_for_payment_method.set()
@dp.message_handler(state=OrderForm.waiting_for_payment_method, content_types=types.ContentTypes.TEXT)
async def process_payment_method(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['payment_method'] = message.text
# Отправка подтверждения заказа
await message.answer("Подтвердите заказ:\n"
f"ФИО: {data['name']}\n"
f"Номер телефона: {data['phone']}\n"
f"Адрес: {data['address']}\n"
f"Время уборки: {data['cleaning_time']}\n"
f"Тип уборки: {data['cleaning_type']}\n"
f"Способ оплаты: {data['payment_method']}\n"
"Если все верно, нажмите 'Подтвердить'. В противном случае, измените нужные данные.",
reply_markup=InlineKeyboardMarkup().add(InlineKeyboardButton('Подтвердить', callback_data='confirm_order')))
await OrderForm.confirmation.set()
@dp.callback_query_handler(lambda c: c.data == 'confirm_order', state=OrderForm.confirmation)
async def process_confirm_order(callback_query: types.CallbackQuery, state: FSMContext):
await bot.answer_callback_query(callback_query.id)
async with state.proxy() as data:
order_details = (f"Новый заказ:\n"
f"ФИО: {data['name']}\n"
f"Номер телефона: {data['phone']}\n"
f"Адрес: {data['address']}\n"
f"Время уборки: {data['cleaning_time']}\n"
f"Тип уборки: {data['cleaning_type']}\n"
f"Способ оплаты: {data['payment_method']}")
# Отправка заказа операторам
await bot.send_message(OPERATORS_GROUP_ID, order_details)
log_action(callback_query.from_user.id, 'confirm_order')
# Сохранение заказа в базе данных
add_order(data['name'], data['phone'], data['address'], data['cleaning_time'], data['cleaning_type'], data['payment_method'])
await bot.send_message(callback_query.from_user.id, "Ваш заказ был подтвержден и отправлен операторам.")
await state.finish()
# Основное приложение
if __name__ == '__main__':
create_tables()
executor.start_polling(dp, skip_updates=True)
import logging
import sqlite3
from aiogram import types
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.utils import executor
from aiogram import Bot, Dispatcher
from aiogram.dispatcher.filters import Text
from database import create_tables, add_user, update_user_name, update_user_phone, add_address, delete_address, add_order
from logger import log_action
from dotenv import load_dotenv
import os
# Загрузка переменных окружения из .env файла
load_dotenv()
API_TOKEN = os.getenv('BOT_API_TOKEN')
OPERATORS_GROUP_ID = int(os.getenv('OPERATORS_GROUP_ID'))
ADMIN_GROUP_ID = int(os.getenv('ADMIN_GROUP_ID'))
logging.basicConfig(level=logging.INFO)
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Состояния для заказа
class OrderForm(StatesGroup):
waiting_for_name = State()
waiting_for_phone = State()
waiting_for_address = State()
waiting_for_cleaning_time = State()
waiting_for_cleaning_type = State()
waiting_for_payment_method = State()
confirmation = State()
# Inline клавиатуры
def main_menu_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Учетные данные', callback_data='account_data'))
keyboard.add(InlineKeyboardButton('Сделать заказ', callback_data='make_order'))
keyboard.add(InlineKeyboardButton('История заказов', callback_data='order_history'))
keyboard.add(InlineKeyboardButton('Заказать звонок', callback_data='request_call'))
keyboard.add(InlineKeyboardButton('Начать разговор с оператором', callback_data='talk_operator'))
return keyboard
def account_data_keyboard():
keyboard = InlineKeyboardMarkup()
keyboard.add(InlineKeyboardButton('Изменить ФИО', callback_data='change_name'))
keyboard.add(InlineKeyboardButton('Изменить номер телефона', callback_data='change_phone'))
keyboard.add(InlineKeyboardButton('Добавить адрес', callback_data='add_address'))
keyboard.add(InlineKeyboardButton('Удалить адрес', callback_data='delete_address'))
keyboard.add(InlineKeyboardButton('Поделиться контактом', callback_data='share_contact'))
keyboard.add(InlineKeyboardButton('Назад', callback_data='back_to_main'))
return keyboard
# Основные команды
@dp.message_handler(commands=['start'])
async def send_welcome(message: types.Message):
await message.answer("Добро пожаловать в BOTKlining!", reply_markup=main_menu_keyboard())
log_action(message.from_user.id, 'start')
@dp.callback_query_handler(lambda c: c.data == 'account_data')
async def process_account_data(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Учетные данные:", reply_markup=account_data_keyboard())
log_action(callback_query.from_user.id, 'account_data')
@dp.callback_query_handler(lambda c: c.data == 'make_order')
async def process_make_order(callback_query: types.CallbackQuery, state: FSMContext):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Начнем с ваших учетных данных. Введите ваше ФИО:")
await OrderForm.waiting_for_name.set()
log_action(callback_query.from_user.id, 'make_order')
@dp.callback_query_handler(lambda c: c.data == 'order_history')
async def process_order_history(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для просмотра истории заказов
await bot.send_message(callback_query.from_user.id, "История заказов:")
log_action(callback_query.from_user.id, 'order_history')
@dp.callback_query_handler(lambda c: c.data == 'request_call')
async def process_request_call(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для заказа звонка
await bot.send_message(callback_query.from_user.id, "Заказ звонка оформлен. Ожидайте звонок в течение 30 минут.")
log_action(callback_query.from_user.id, 'request_call')
@dp.callback_query_handler(lambda c: c.data == 'talk_operator')
async def process_talk_operator(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
# Добавьте логику для начала разговора с оператором
await bot.send_message(callback_query.from_user.id, "Разговор с оператором начат.")
log_action(callback_query.from_user.id, 'talk_operator')
@dp.callback_query_handler(lambda c: c.data == 'back_to_main')
async def process_back_to_main(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
await bot.send_message(callback_query.from_user.id, "Главное меню:", reply_markup=main_menu_keyboard())
log_action(callback_query.from_user.id, 'back_to_main')
# Обработка шагов заказа
@dp.message_handler(state=OrderForm.waiting_for_name, content_types=types.ContentTypes.TEXT)
async def process_name(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['name'] = message.text
await message.answer("Введите ваш номер телефона:")
await OrderForm.waiting_for_phone.set()
@dp.message_handler(state=OrderForm.waiting_for_phone, content_types=types.ContentTypes.TEXT)
async def process_phone(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['phone'] = message.text
await message.answer("Введите адрес для уборки:")
await OrderForm.waiting_for_address.set()
@dp.message_handler(state=OrderForm.waiting_for_address, content_types=types.ContentTypes.TEXT)
async def process_order_address(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['address'] = message.text
await message.answer("Выберите время для уборки (утро/день/вечер):")
await OrderForm.waiting_for_cleaning_time.set()
@dp.message_handler(state=OrderForm.waiting_for_cleaning_time, content_types=types.ContentTypes.TEXT)
async def process_cleaning_time(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['cleaning_time'] = message.text
await message.answer("Выберите тип уборки (влажная/сухая/генеральная):")
await OrderForm.waiting_for_cleaning_type.set()
@dp.message_handler(state=OrderForm.waiting_for_cleaning_type, content_types=types.ContentTypes.TEXT)
async def process_cleaning_type(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['cleaning_type'] = message.text
await message.answer("Выберите способ оплаты (картой/наличными):")
await OrderForm.waiting_for_payment_method.set()
@dp.message_handler(state=OrderForm.waiting_for_payment_method, content_types=types.ContentTypes.TEXT)
async def process_payment_method(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['payment_method'] = message.text
# Отправка подтверждения заказа
await message.answer("Подтвердите заказ:\n"
f"ФИО: {data['name']}\n"
f"Номер телефона: {data['phone']}\n"
f"Адрес: {data['address']}\n"
f"Время уборки: {data['cleaning_time']}\n"
f"Тип уборки: {data['cleaning_type']}\n"
f"Способ оплаты: {data['payment_method']}\n"
"Если все верно, нажмите 'Подтвердить'. В противном случае, измените нужные данные.",
reply_markup=InlineKeyboardMarkup().add(InlineKeyboardButton('Подтвердить', callback_data='confirm_order')))
await OrderForm.confirmation.set()
@dp.callback_query_handler(lambda c: c.data == 'confirm_order', state=OrderForm.confirmation)
async def process_confirm_order(callback_query: types.CallbackQuery, state: FSMContext):
await bot.answer_callback_query(callback_query.id)
async with state.proxy() as data:
order_details = (f"Новый заказ:\n"
f"ФИО: {data['name']}\n"
f"Номер телефона: {data['phone']}\n"
f"Адрес: {data['address']}\n"
f"Время уборки: {data['cleaning_time']}\n"
f"Тип уборки: {data['cleaning_type']}\n"
f"Способ оплаты: {data['payment_method']}")
# Отправка заказа операторам
await bot.send_message(OPERATORS_GROUP_ID, order_details)
log_action(callback_query.from_user.id, 'confirm_order')
# Сохранение заказа в базе данных
add_order(data['name'], data['phone'], data['address'], data['cleaning_time'], data['cleaning_type'], data['payment_method'])
await bot.send_message(callback_query.from_user.id, "Ваш заказ был подтвержден и отправлен операторам.")
await state.finish()
# Основное приложение
if __name__ == '__main__':
create_tables()
executor.start_polling(dp, skip_updates=True)

370
doners/old/klining_order.py
View File

@@ -1,185 +1,185 @@
import logging
import sqlite3
import asyncio
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
# Устанавливаем уровень логов
logging.basicConfig(level=logging.INFO)
# Подключаемся к базе данных SQLite
conn = sqlite3.connect("answers.db")
cursor = conn.cursor()
# Создание таблицы для хранения ответов
cursor.execute("""
CREATE TABLE IF NOT EXISTS answers (
user_id INTEGER,
question_id INTEGER,
answer TEXT
)
""")
conn.commit()
# Заменить на свой токен
API_TOKEN = '7472030348:AAGI53nX-ON-WBmEhd_qBC6EnZsHOqp_2kE'
GROUP_ID = '-1001961537659'
# Инициализация бота и диспетчера
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Словарь для хранения вопросов и ответов
questions = {
1: "Как вас зовут?",
2: "Укажите номер телефона для связи",
3: "Укажите район, улицу, дом",
4: "Какая уборка нужна, влажная или сухая?",
5: "На какое время?",
6: "Оплата наличными или картой?"
}
answer_map = {
'wet_cleaning': 'Влажная уборка',
'dry_cleaning': 'Сухая уборка',
'morning_time': 'Утро',
'day_time': 'День',
'evening_time': 'Вечер',
'cash_payment': 'Наличные',
'card_payment': 'Карта'
}
# Обработчик команды /start
@dp.message_handler(commands=['start'])
async def start(message: types.Message):
await message.answer("Привет! Я задам тебе 6 вопросов. Давай начнем.")
await ask_question(message.chat.id, 1)
# Функция для задания вопроса
async def ask_question(user_id, question_id):
if question_id in [4, 5, 6]:
if question_id == 4:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Влажная", callback_data="wet_cleaning")],
[InlineKeyboardButton(text="Сухая", callback_data="dry_cleaning")]
])
elif question_id == 5:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Утро", callback_data="morning_time")],
[InlineKeyboardButton(text="День", callback_data="day_time")],
[InlineKeyboardButton(text="Вечер", callback_data="evening_time")]
])
elif question_id == 6:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Наличные", callback_data="cash_payment")],
[InlineKeyboardButton(text="Карта", callback_data="card_payment")]
])
await bot.send_message(user_id, text=questions[question_id], reply_markup=keyboard)
else:
await bot.send_message(user_id, text=questions[question_id])
# Обработчик текстовых ответов на первые три вопроса
@dp.message_handler(lambda message: message.text not in ["Переписать", "Отправить"])
async def handle_text_answer(message: types.Message):
user_id = message.chat.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
answer = message.text
await save_answer(user_id, question_id, answer)
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Обработчик inline-кнопок
@dp.callback_query_handler(lambda query: query.data in answer_map.keys())
async def handle_callback_answer(query: types.CallbackQuery):
user_id = query.from_user.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
await save_answer(user_id, question_id, answer_map[query.data])
await query.answer()
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Функция для сохранения ответа в базе данных
async def save_answer(user_id, question_id, answer):
cursor.execute("INSERT INTO answers (user_id, question_id, answer) VALUES (?, ?, ?)", (user_id, question_id, answer))
conn.commit()
# Функция для отображения опций подтверждения
async def show_confirmation_options(user_id):
cursor.execute("SELECT answer FROM answers WHERE user_id=? ORDER BY question_id", (user_id,))
answers = cursor.fetchall()
answer_text = "\n".join([f"{questions[i+1]}: {answers[i][0]}" for i in range(6)])
await bot.send_message(user_id, text=f"Ваши ответы:\n\n{answer_text}")
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Отправить", callback_data="send_answers")],
[InlineKeyboardButton(text="Переписать", callback_data="rewrite_answers")]
])
await bot.send_message(user_id, "Проверьте свои ответы. Выберите действие:", reply_markup=keyboard)
# Обработчик выбора действия подтверждения
@dp.callback_query_handler(lambda query: query.data in ['send_answers', 'rewrite_answers'])
async def handle_confirmation(query: types.CallbackQuery):
user_id = query.from_user.id
if query.data == "send_answers":
await send_answers_to_group(user_id)
elif query.data == "rewrite_answers":
await rewrite_answers(user_id)
# Функция для отправки ответов в группу
async def send_answers_to_group(user_id):
cursor.execute("SELECT * FROM answers WHERE user_id=?", (user_id,))
answers = cursor.fetchall()
if answers:
answer_text = '\n'.join([f"{questions[ans[1]]}: {ans[2]}" for ans in answers])
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
# Отправляем ответы в группу
await bot.send_message(GROUP_ID, answer_text)
await bot.send_message(user_id, "Ваши ответы отправлены.")
else:
await bot.send_message(user_id, "Ответов нет")
# Функция для переписывания ответов
async def rewrite_answers(user_id):
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
await bot.send_message(user_id, "Ваши ответы удалены. Начнем сначала.")
await ask_question(user_id, 1)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
try:
loop.create_task(dp.start_polling())
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
conn.close()
import logging
import sqlite3
import asyncio
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
# Устанавливаем уровень логов
logging.basicConfig(level=logging.INFO)
# Подключаемся к базе данных SQLite
conn = sqlite3.connect("answers.db")
cursor = conn.cursor()
# Создание таблицы для хранения ответов
cursor.execute("""
CREATE TABLE IF NOT EXISTS answers (
user_id INTEGER,
question_id INTEGER,
answer TEXT
)
""")
conn.commit()
# Заменить на свой токен
API_TOKEN = '7472030348:AAGI53nX-ON-WBmEhd_qBC6EnZsHOqp_2kE'
GROUP_ID = '-1001961537659'
# Инициализация бота и диспетчера
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Словарь для хранения вопросов и ответов
questions = {
1: "Как вас зовут?",
2: "Укажите номер телефона для связи",
3: "Укажите район, улицу, дом",
4: "Какая уборка нужна, влажная или сухая?",
5: "На какое время?",
6: "Оплата наличными или картой?"
}
answer_map = {
'wet_cleaning': 'Влажная уборка',
'dry_cleaning': 'Сухая уборка',
'morning_time': 'Утро',
'day_time': 'День',
'evening_time': 'Вечер',
'cash_payment': 'Наличные',
'card_payment': 'Карта'
}
# Обработчик команды /start
@dp.message_handler(commands=['start'])
async def start(message: types.Message):
await message.answer("Привет! Я задам тебе 6 вопросов. Давай начнем.")
await ask_question(message.chat.id, 1)
# Функция для задания вопроса
async def ask_question(user_id, question_id):
if question_id in [4, 5, 6]:
if question_id == 4:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Влажная", callback_data="wet_cleaning")],
[InlineKeyboardButton(text="Сухая", callback_data="dry_cleaning")]
])
elif question_id == 5:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Утро", callback_data="morning_time")],
[InlineKeyboardButton(text="День", callback_data="day_time")],
[InlineKeyboardButton(text="Вечер", callback_data="evening_time")]
])
elif question_id == 6:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Наличные", callback_data="cash_payment")],
[InlineKeyboardButton(text="Карта", callback_data="card_payment")]
])
await bot.send_message(user_id, text=questions[question_id], reply_markup=keyboard)
else:
await bot.send_message(user_id, text=questions[question_id])
# Обработчик текстовых ответов на первые три вопроса
@dp.message_handler(lambda message: message.text not in ["Переписать", "Отправить"])
async def handle_text_answer(message: types.Message):
user_id = message.chat.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
answer = message.text
await save_answer(user_id, question_id, answer)
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Обработчик inline-кнопок
@dp.callback_query_handler(lambda query: query.data in answer_map.keys())
async def handle_callback_answer(query: types.CallbackQuery):
user_id = query.from_user.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
await save_answer(user_id, question_id, answer_map[query.data])
await query.answer()
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Функция для сохранения ответа в базе данных
async def save_answer(user_id, question_id, answer):
cursor.execute("INSERT INTO answers (user_id, question_id, answer) VALUES (?, ?, ?)", (user_id, question_id, answer))
conn.commit()
# Функция для отображения опций подтверждения
async def show_confirmation_options(user_id):
cursor.execute("SELECT answer FROM answers WHERE user_id=? ORDER BY question_id", (user_id,))
answers = cursor.fetchall()
answer_text = "\n".join([f"{questions[i+1]}: {answers[i][0]}" for i in range(6)])
await bot.send_message(user_id, text=f"Ваши ответы:\n\n{answer_text}")
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Отправить", callback_data="send_answers")],
[InlineKeyboardButton(text="Переписать", callback_data="rewrite_answers")]
])
await bot.send_message(user_id, "Проверьте свои ответы. Выберите действие:", reply_markup=keyboard)
# Обработчик выбора действия подтверждения
@dp.callback_query_handler(lambda query: query.data in ['send_answers', 'rewrite_answers'])
async def handle_confirmation(query: types.CallbackQuery):
user_id = query.from_user.id
if query.data == "send_answers":
await send_answers_to_group(user_id)
elif query.data == "rewrite_answers":
await rewrite_answers(user_id)
# Функция для отправки ответов в группу
async def send_answers_to_group(user_id):
cursor.execute("SELECT * FROM answers WHERE user_id=?", (user_id,))
answers = cursor.fetchall()
if answers:
answer_text = '\n'.join([f"{questions[ans[1]]}: {ans[2]}" for ans in answers])
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
# Отправляем ответы в группу
await bot.send_message(GROUP_ID, answer_text)
await bot.send_message(user_id, "Ваши ответы отправлены.")
else:
await bot.send_message(user_id, "Ответов нет")
# Функция для переписывания ответов
async def rewrite_answers(user_id):
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
await bot.send_message(user_id, "Ваши ответы удалены. Начнем сначала.")
await ask_question(user_id, 1)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
try:
loop.create_task(dp.start_polling())
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
conn.close()

34
doners/old/logger.py
View File

@@ -1,17 +1,17 @@
import logging
import sqlite3
# Настройка логирования
logging.basicConfig(filename='bot.log', level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
def log_action(user_id, action, details=""):
logging.info(f"User ID: {user_id} - Action: {action} - Details: {details}")
def log_action(user_id, action):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('INSERT INTO logs (user_id, action) VALUES ((SELECT id FROM users WHERE telegram_id = ?), ?)', (user_id, action))
conn.commit()
conn.close()
import logging
import sqlite3
# Настройка логирования
logging.basicConfig(filename='bot.log', level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
def log_action(user_id, action, details=""):
logging.info(f"User ID: {user_id} - Action: {action} - Details: {details}")
def log_action(user_id, action):
conn = sqlite3.connect('bot_klining.db')
cursor = conn.cursor()
cursor.execute('INSERT INTO logs (user_id, action) VALUES ((SELECT id FROM users WHERE telegram_id = ?), ?)', (user_id, action))
conn.commit()
conn.close()

426
doners/old/main(OLD).py
View File

@@ -1,213 +1,213 @@
import logging
import sqlite3
import asyncio
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
# Устанавливаем уровень логов
logging.basicConfig(level=logging.INFO)
# Подключаемся к базе данных SQLite
conn = sqlite3.connect("answers.db")
cursor = conn.cursor()
# Создание таблицы для хранения ответов
cursor.execute("""
CREATE TABLE IF NOT EXISTS answers (
user_id INTEGER,
question_id INTEGER,
answer TEXT
)
""")
conn.commit()
# Заменить на свой токен
API_TOKEN = '7472030348:AAGI53nX-ON-WBmEhd_qBC6EnZsHOqp_2kE'
GROUP_ID = '-1001961537659'
# Инициализация бота и диспетчера
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Словарь для хранения вопросов и ответов
questions = {
1: "Как вас зовут?",
2: "Укажите номер телефона для связи",
3: "Укажите район, улицу, дом",
4: "Какая уборка нужна, влажная или сухая?",
5: "На какое время?",
6: "Оплата наличными или картой?"
}
answer_map = {
'wet_cleaning': 'Влажная уборка',
'dry_cleaning': 'Сухая уборка',
'morning_time': 'Утро',
'day_time': 'День',
'evening_time': 'Вечер',
'cash_payment': 'Наличные',
'card_payment': 'Карта'
}
# Обработчик команды /start
@dp.message_handler(commands=['start'])
async def start(message: types.Message):
if message.chat.id != int(GROUP_ID):
await message.answer("Привет! Я задам тебе 6 вопросов. Давай начнем.")
await ask_question(message.chat.id, 1)
# Функция для задания вопроса
async def ask_question(user_id, question_id):
if question_id in [4, 5, 6]:
if question_id == 4:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Влажная", callback_data="wet_cleaning")],
[InlineKeyboardButton(text="Сухая", callback_data="dry_cleaning")]
])
elif question_id == 5:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Утро", callback_data="morning_time")],
[InlineKeyboardButton(text="День", callback_data="day_time")],
[InlineKeyboardButton(text="Вечер", callback_data="evening_time")]
])
elif question_id == 6:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Наличные", callback_data="cash_payment")],
[InlineKeyboardButton(text="Карта", callback_data="card_payment")]
])
await bot.send_message(user_id, text=questions[question_id], reply_markup=keyboard)
else:
await bot.send_message(user_id, text=questions[question_id])
# Обработчик текстовых ответов на первые три вопроса
@dp.message_handler(lambda message: message.text not in ["Переписать", "Отправить"])
async def handle_text_answer(message: types.Message):
if message.chat.id != int(GROUP_ID):
user_id = message.chat.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
answer = message.text
await save_answer(user_id, question_id, answer)
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Обработчик inline-кнопок
@dp.callback_query_handler(lambda query: query.data in answer_map.keys())
async def handle_callback_answer(query: types.CallbackQuery):
user_id = query.from_user.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
await save_answer(user_id, question_id, answer_map[query.data])
await query.answer()
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Функция для сохранения ответа в базе данных
async def save_answer(user_id, question_id, answer):
cursor.execute("INSERT INTO answers (user_id, question_id, answer) VALUES (?, ?, ?)", (user_id, question_id, answer))
conn.commit()
# Функция для отображения опций подтверждения
async def show_confirmation_options(user_id):
cursor.execute("SELECT answer FROM answers WHERE user_id=? ORDER BY question_id", (user_id,))
answers = cursor.fetchall()
answer_text = "\n".join([f"{questions[i+1]}: {answers[i][0]}" for i in range(6)])
await bot.send_message(user_id, text=f"Ваши ответы:\n\n{answer_text}")
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Отправить", callback_data="send_answers")],
[InlineKeyboardButton(text="Переписать", callback_data="rewrite_answers")]
])
await bot.send_message(user_id, "Проверьте свои ответы. Выберите действие:", reply_markup=keyboard)
# Обработчик выбора действия подтверждения
@dp.callback_query_handler(lambda query: query.data in ['send_answers', 'rewrite_answers'])
async def handle_confirmation(query: types.CallbackQuery):
user_id = query.from_user.id
if query.data == "send_answers":
await send_answers_to_group(user_id)
elif query.data == "rewrite_answers":
await rewrite_answers(user_id)
# Функция для отправки ответов в группу
async def send_answers_to_group(user_id):
cursor.execute("SELECT * FROM answers WHERE user_id=?", (user_id,))
answers = cursor.fetchall()
if answers:
answer_text = '\n'.join([f"{questions[ans[1]]}: {ans[2]}" for ans in answers])
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
# Отправляем ответы в группу и добавляем ID пользователя
sent_message = await bot.send_message(GROUP_ID, f"Ответы от пользователя {user_id}:\n\n{answer_text}")
await bot.send_message(user_id, f"Ваши ответы отправлены. Можете посмотреть их [здесь](https://t.me/{sent_message.chat.username}/{sent_message.message_id})",
parse_mode='Markdown')
else:
await bot.send_message(user_id, "Ответов нет")
# Функция для переписывания ответов
async def rewrite_answers(user_id):
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
await bot.send_message(user_id, "Ваши ответы удалены. Начнем сначала.")
await ask_question(user_id, 1)
# Функция для обработки сообщений из группы и пересылки их пользователю
@dp.message_handler(lambda message: message.chat.id == int(GROUP_ID) and message.reply_to_message)
async def handle_group_reply(message: types.Message):
# Проверяем, что сообщение является ответом на сообщение бота
if message.reply_to_message.from_user.id == bot.id:
# Извлекаем ID пользователя из текста сообщения
try:
user_id = int(message.reply_to_message.text.split()[2].strip(':'))
await bot.send_message(user_id, f"Сообщение от администратора:\n\n{message.text}")
# Сохраняем ответ пользователя для пересылки обратно в группу
cursor.execute("INSERT INTO admin_user_conversation (user_id, admin_message_id) VALUES (?, ?)",
(user_id, message.message_id))
conn.commit()
except (IndexError, ValueError):
await message.reply("Не удалось определить ID пользователя для ответа.")
# Обработчик сообщений от пользователя в ответ на администратора
@dp.message_handler(lambda message: message.chat.id != int(GROUP_ID))
async def handle_user_reply(message: types.Message):
user_id = message.chat.id
cursor.execute("SELECT admin_message_id FROM admin_user_conversation WHERE user_id=? ORDER BY admin_message_id DESC LIMIT 1", (user_id,))
admin_message_id = cursor.fetchone()
if admin_message_id:
await bot.send_message(GROUP_ID, f"Сообщение от пользователя {user_id}:\n\n{message.text}", reply_to_message_id=admin_message_id[0])
if __name__ == '__main__':
loop = asyncio.get_event_loop()
try:
loop.create_task(dp.start_polling())
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
conn.close()
import logging
import sqlite3
import asyncio
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
# Устанавливаем уровень логов
logging.basicConfig(level=logging.INFO)
# Подключаемся к базе данных SQLite
conn = sqlite3.connect("answers.db")
cursor = conn.cursor()
# Создание таблицы для хранения ответов
cursor.execute("""
CREATE TABLE IF NOT EXISTS answers (
user_id INTEGER,
question_id INTEGER,
answer TEXT
)
""")
conn.commit()
# Заменить на свой токен
API_TOKEN = '7472030348:AAGI53nX-ON-WBmEhd_qBC6EnZsHOqp_2kE'
GROUP_ID = '-1001961537659'
# Инициализация бота и диспетчера
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Словарь для хранения вопросов и ответов
questions = {
1: "Как вас зовут?",
2: "Укажите номер телефона для связи",
3: "Укажите район, улицу, дом",
4: "Какая уборка нужна, влажная или сухая?",
5: "На какое время?",
6: "Оплата наличными или картой?"
}
answer_map = {
'wet_cleaning': 'Влажная уборка',
'dry_cleaning': 'Сухая уборка',
'morning_time': 'Утро',
'day_time': 'День',
'evening_time': 'Вечер',
'cash_payment': 'Наличные',
'card_payment': 'Карта'
}
# Обработчик команды /start
@dp.message_handler(commands=['start'])
async def start(message: types.Message):
if message.chat.id != int(GROUP_ID):
await message.answer("Привет! Я задам тебе 6 вопросов. Давай начнем.")
await ask_question(message.chat.id, 1)
# Функция для задания вопроса
async def ask_question(user_id, question_id):
if question_id in [4, 5, 6]:
if question_id == 4:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Влажная", callback_data="wet_cleaning")],
[InlineKeyboardButton(text="Сухая", callback_data="dry_cleaning")]
])
elif question_id == 5:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Утро", callback_data="morning_time")],
[InlineKeyboardButton(text="День", callback_data="day_time")],
[InlineKeyboardButton(text="Вечер", callback_data="evening_time")]
])
elif question_id == 6:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Наличные", callback_data="cash_payment")],
[InlineKeyboardButton(text="Карта", callback_data="card_payment")]
])
await bot.send_message(user_id, text=questions[question_id], reply_markup=keyboard)
else:
await bot.send_message(user_id, text=questions[question_id])
# Обработчик текстовых ответов на первые три вопроса
@dp.message_handler(lambda message: message.text not in ["Переписать", "Отправить"])
async def handle_text_answer(message: types.Message):
if message.chat.id != int(GROUP_ID):
user_id = message.chat.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
answer = message.text
await save_answer(user_id, question_id, answer)
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Обработчик inline-кнопок
@dp.callback_query_handler(lambda query: query.data in answer_map.keys())
async def handle_callback_answer(query: types.CallbackQuery):
user_id = query.from_user.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
await save_answer(user_id, question_id, answer_map[query.data])
await query.answer()
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Функция для сохранения ответа в базе данных
async def save_answer(user_id, question_id, answer):
cursor.execute("INSERT INTO answers (user_id, question_id, answer) VALUES (?, ?, ?)", (user_id, question_id, answer))
conn.commit()
# Функция для отображения опций подтверждения
async def show_confirmation_options(user_id):
cursor.execute("SELECT answer FROM answers WHERE user_id=? ORDER BY question_id", (user_id,))
answers = cursor.fetchall()
answer_text = "\n".join([f"{questions[i+1]}: {answers[i][0]}" for i in range(6)])
await bot.send_message(user_id, text=f"Ваши ответы:\n\n{answer_text}")
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Отправить", callback_data="send_answers")],
[InlineKeyboardButton(text="Переписать", callback_data="rewrite_answers")]
])
await bot.send_message(user_id, "Проверьте свои ответы. Выберите действие:", reply_markup=keyboard)
# Обработчик выбора действия подтверждения
@dp.callback_query_handler(lambda query: query.data in ['send_answers', 'rewrite_answers'])
async def handle_confirmation(query: types.CallbackQuery):
user_id = query.from_user.id
if query.data == "send_answers":
await send_answers_to_group(user_id)
elif query.data == "rewrite_answers":
await rewrite_answers(user_id)
# Функция для отправки ответов в группу
async def send_answers_to_group(user_id):
cursor.execute("SELECT * FROM answers WHERE user_id=?", (user_id,))
answers = cursor.fetchall()
if answers:
answer_text = '\n'.join([f"{questions[ans[1]]}: {ans[2]}" for ans in answers])
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
# Отправляем ответы в группу и добавляем ID пользователя
sent_message = await bot.send_message(GROUP_ID, f"Ответы от пользователя {user_id}:\n\n{answer_text}")
await bot.send_message(user_id, f"Ваши ответы отправлены. Можете посмотреть их [здесь](https://t.me/{sent_message.chat.username}/{sent_message.message_id})",
parse_mode='Markdown')
else:
await bot.send_message(user_id, "Ответов нет")
# Функция для переписывания ответов
async def rewrite_answers(user_id):
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
await bot.send_message(user_id, "Ваши ответы удалены. Начнем сначала.")
await ask_question(user_id, 1)
# Функция для обработки сообщений из группы и пересылки их пользователю
@dp.message_handler(lambda message: message.chat.id == int(GROUP_ID) and message.reply_to_message)
async def handle_group_reply(message: types.Message):
# Проверяем, что сообщение является ответом на сообщение бота
if message.reply_to_message.from_user.id == bot.id:
# Извлекаем ID пользователя из текста сообщения
try:
user_id = int(message.reply_to_message.text.split()[2].strip(':'))
await bot.send_message(user_id, f"Сообщение от администратора:\n\n{message.text}")
# Сохраняем ответ пользователя для пересылки обратно в группу
cursor.execute("INSERT INTO admin_user_conversation (user_id, admin_message_id) VALUES (?, ?)",
(user_id, message.message_id))
conn.commit()
except (IndexError, ValueError):
await message.reply("Не удалось определить ID пользователя для ответа.")
# Обработчик сообщений от пользователя в ответ на администратора
@dp.message_handler(lambda message: message.chat.id != int(GROUP_ID))
async def handle_user_reply(message: types.Message):
user_id = message.chat.id
cursor.execute("SELECT admin_message_id FROM admin_user_conversation WHERE user_id=? ORDER BY admin_message_id DESC LIMIT 1", (user_id,))
admin_message_id = cursor.fetchone()
if admin_message_id:
await bot.send_message(GROUP_ID, f"Сообщение от пользователя {user_id}:\n\n{message.text}", reply_to_message_id=admin_message_id[0])
if __name__ == '__main__':
loop = asyncio.get_event_loop()
try:
loop.create_task(dp.start_polling())
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
conn.close()

442
doners/old/main.py
View File

@@ -1,221 +1,221 @@
import logging
import sqlite3
import asyncio
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher.filters import Command
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton
# Устанавливаем уровень логов
logging.basicConfig(level=logging.INFO)
# Подключаемся к базе данных SQLite
conn = sqlite3.connect("answers.db")
cursor = conn.cursor()
# Создание таблицы для хранения ответов
cursor.execute("""
CREATE TABLE IF NOT EXISTS answers (
user_id INTEGER,
question_id INTEGER,
answer TEXT
)
""")
conn.commit()
# Заменить на свой токен
API_TOKEN = '7472030348:AAGI53nX-ON-WBmEhd_qBC6EnZsHOqp_2kE'
GROUP_ID = '-1001961537659'
# Инициализация бота и диспетчера
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Словарь для хранения вопросов и ответов
questions = {
1: "Как вас зовут?",
2: "Укажите номер телефона для связи",
3: "Укажите район, улицу, дом",
4: "Какая уборка нужна, влажная или сухая?",
5: "На какое время?",
6: "Оплата наличными или картой?"
}
answer_map = {
'wet_cleaning': 'Влажная уборка',
'dry_cleaning': 'Сухая уборка',
'morning_time': 'Утро',
'day_time': 'День',
'evening_time': 'Вечер',
'cash_payment': 'Наличные',
'card_payment': 'Карта'
}
# Обработчик команды /start
@dp.message_handler(commands=['start'])
async def start(message: types.Message):
if message.chat.id != int(GROUP_ID):
await message.answer("Привет! Я задам тебе 6 вопросов Чтобы создать заказ. Давай начнем.")
await ask_question(message.chat.id, 1)
@dp.message_handler(Command("start"))
async def show_menu(message: types.Message):
await message.reply("Выбери действие:", reply_markup=ReplyKeyboardMarkup(
resize_keyboard=True).add(KeyboardButton("Создать заказ")))
# Функция для задания вопроса
async def ask_question(user_id, question_id):
if question_id in [4, 5, 6]:
if question_id == 4:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Влажная", callback_data="wet_cleaning")],
[InlineKeyboardButton(text="Сухая", callback_data="dry_cleaning")]
])
elif question_id == 5:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Утро", callback_data="morning_time")],
[InlineKeyboardButton(text="День", callback_data="day_time")],
[InlineKeyboardButton(text="Вечер", callback_data="evening_time")]
])
elif question_id == 6:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Наличные", callback_data="cash_payment")],
[InlineKeyboardButton(text="Карта", callback_data="card_payment")]
])
await bot.send_message(user_id, text=questions[question_id], reply_markup=keyboard)
else:
await bot.send_message(user_id, text=questions[question_id])
# Обработчик текстовых ответов на первые три вопроса
@dp.message_handler(lambda message: message.text not in ["Переписать", "Отправить"])
async def handle_text_answer(message: types.Message):
if message.chat.id != int(GROUP_ID):
user_id = message.chat.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
answer = message.text
await save_answer(user_id, question_id, answer)
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Обработчик inline-кнопок
@dp.callback_query_handler(lambda query: query.data in answer_map.keys())
async def handle_callback_answer(query: types.CallbackQuery):
user_id = query.from_user.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
await save_answer(user_id, question_id, answer_map[query.data])
await query.answer()
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Функция для сохранения ответа в базе данных
async def save_answer(user_id, question_id, answer):
cursor.execute("INSERT INTO answers (user_id, question_id, answer) VALUES (?, ?, ?)", (user_id, question_id, answer))
conn.commit()
# Функция для отображения опций подтверждения
async def show_confirmation_options(user_id):
cursor.execute("SELECT answer FROM answers WHERE user_id=? ORDER BY question_id", (user_id,))
answers = cursor.fetchall()
answer_text = "\n".join([f"{questions[i+1]}: {answers[i][0]}" for i in range(6)])
await bot.send_message(user_id, text=f"Ваши ответы:\n\n{answer_text}")
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Отправить", callback_data="send_answers")],
[InlineKeyboardButton(text="Переписать", callback_data="rewrite_answers")]
])
await bot.send_message(user_id, "Проверьте свои ответы. Выберите действие:", reply_markup=keyboard)
# Обработчик выбора действия подтверждения
@dp.callback_query_handler(lambda query: query.data in ['send_answers', 'rewrite_answers'])
async def handle_confirmation(query: types.CallbackQuery):
user_id = query.from_user.id
if query.data == "send_answers":
await send_answers_to_group(user_id)
elif query.data == "rewrite_answers":
await rewrite_answers(user_id)
# Функция для отправки ответов в группу
async def send_answers_to_group(user_id):
cursor.execute("SELECT * FROM answers WHERE user_id=?", (user_id,))
answers = cursor.fetchall()
if answers:
answer_text = '\n'.join([f"{questions[ans[1]]}: {ans[2]}" for ans in answers])
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
# Отправляем ответы в группу и добавляем ID пользователя
sent_message = await bot.send_message(GROUP_ID, f"Ответы от пользователя {user_id}:\n\n{answer_text}")
await bot.send_message(user_id, f"Ваши ответы отправлены. Оператор с вами свяжится)",
parse_mode='Markdown')
else:
await bot.send_message(user_id, "Ответов нет")
# Функция для переписывания ответов
async def rewrite_answers(user_id):
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
await bot.send_message(user_id, "Ваши ответы удалены. Начнем сначала.")
await ask_question(user_id, 1)
# Функция для обработки сообщений из группы и пересылки их пользователю
@dp.message_handler(lambda message: message.chat.id == int(GROUP_ID) and message.reply_to_message)
async def handle_group_reply(message: types.Message):
# Проверяем, что сообщение является ответом на сообщение бота
if message.reply_to_message.from_user.id == bot.id:
# Извлекаем ID пользователя из текста сообщения
try:
user_id = int(message.reply_to_message.text.split()[2].strip(':'))
await bot.send_message(user_id, f"Сообщение от администратора:\n\n{message.text}")
# Сохраняем ответ пользователя для пересылки обратно в группу
cursor.execute("INSERT INTO admin_user_conversation (user_id, admin_message_id) VALUES (?, ?)",
(user_id, message.message_id))
conn.commit()
except (IndexError, ValueError):
await message.reply("Не удалось определить ID пользователя для ответа.")
# Обработчик сообщений от пользователя в ответ на администратора
@dp.message_handler(lambda message: message.chat.id != int(GROUP_ID))
async def handle_user_reply(message: types.Message):
user_id = message.chat.id
cursor.execute("SELECT admin_message_id FROM admin_user_conversation WHERE user_id=? ORDER BY admin_message_id DESC LIMIT 1", (user_id,))
admin_message_id = cursor.fetchone()
if admin_message_id:
await bot.send_message(GROUP_ID, f"Сообщение от пользователя {user_id}:\n\n{message.text}", reply_to_message_id=admin_message_id[0])
if __name__ == '__main__':
loop = asyncio.get_event_loop()
try:
loop.create_task(dp.start_polling())
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
conn.close()
import logging
import sqlite3
import asyncio
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher.filters import Command
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton
# Устанавливаем уровень логов
logging.basicConfig(level=logging.INFO)
# Подключаемся к базе данных SQLite
conn = sqlite3.connect("answers.db")
cursor = conn.cursor()
# Создание таблицы для хранения ответов
cursor.execute("""
CREATE TABLE IF NOT EXISTS answers (
user_id INTEGER,
question_id INTEGER,
answer TEXT
)
""")
conn.commit()
# Заменить на свой токен
API_TOKEN = '7472030348:AAGI53nX-ON-WBmEhd_qBC6EnZsHOqp_2kE'
GROUP_ID = '-1001961537659'
# Инициализация бота и диспетчера
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Словарь для хранения вопросов и ответов
questions = {
1: "Как вас зовут?",
2: "Укажите номер телефона для связи",
3: "Укажите район, улицу, дом",
4: "Какая уборка нужна, влажная или сухая?",
5: "На какое время?",
6: "Оплата наличными или картой?"
}
answer_map = {
'wet_cleaning': 'Влажная уборка',
'dry_cleaning': 'Сухая уборка',
'morning_time': 'Утро',
'day_time': 'День',
'evening_time': 'Вечер',
'cash_payment': 'Наличные',
'card_payment': 'Карта'
}
# Обработчик команды /start
@dp.message_handler(commands=['start'])
async def start(message: types.Message):
if message.chat.id != int(GROUP_ID):
await message.answer("Привет! Я задам тебе 6 вопросов Чтобы создать заказ. Давай начнем.")
await ask_question(message.chat.id, 1)
@dp.message_handler(Command("start"))
async def show_menu(message: types.Message):
await message.reply("Выбери действие:", reply_markup=ReplyKeyboardMarkup(
resize_keyboard=True).add(KeyboardButton("Создать заказ")))
# Функция для задания вопроса
async def ask_question(user_id, question_id):
if question_id in [4, 5, 6]:
if question_id == 4:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Влажная", callback_data="wet_cleaning")],
[InlineKeyboardButton(text="Сухая", callback_data="dry_cleaning")]
])
elif question_id == 5:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Утро", callback_data="morning_time")],
[InlineKeyboardButton(text="День", callback_data="day_time")],
[InlineKeyboardButton(text="Вечер", callback_data="evening_time")]
])
elif question_id == 6:
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Наличные", callback_data="cash_payment")],
[InlineKeyboardButton(text="Карта", callback_data="card_payment")]
])
await bot.send_message(user_id, text=questions[question_id], reply_markup=keyboard)
else:
await bot.send_message(user_id, text=questions[question_id])
# Обработчик текстовых ответов на первые три вопроса
@dp.message_handler(lambda message: message.text not in ["Переписать", "Отправить"])
async def handle_text_answer(message: types.Message):
if message.chat.id != int(GROUP_ID):
user_id = message.chat.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
answer = message.text
await save_answer(user_id, question_id, answer)
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Обработчик inline-кнопок
@dp.callback_query_handler(lambda query: query.data in answer_map.keys())
async def handle_callback_answer(query: types.CallbackQuery):
user_id = query.from_user.id
cursor.execute("SELECT MAX(question_id) FROM answers WHERE user_id=?", (user_id,))
prev_question_id = cursor.fetchone()[0]
if prev_question_id is None:
question_id = 1
else:
question_id = prev_question_id + 1
await save_answer(user_id, question_id, answer_map[query.data])
await query.answer()
if question_id < 6:
await ask_question(user_id, question_id + 1)
else:
await show_confirmation_options(user_id)
# Функция для сохранения ответа в базе данных
async def save_answer(user_id, question_id, answer):
cursor.execute("INSERT INTO answers (user_id, question_id, answer) VALUES (?, ?, ?)", (user_id, question_id, answer))
conn.commit()
# Функция для отображения опций подтверждения
async def show_confirmation_options(user_id):
cursor.execute("SELECT answer FROM answers WHERE user_id=? ORDER BY question_id", (user_id,))
answers = cursor.fetchall()
answer_text = "\n".join([f"{questions[i+1]}: {answers[i][0]}" for i in range(6)])
await bot.send_message(user_id, text=f"Ваши ответы:\n\n{answer_text}")
keyboard = InlineKeyboardMarkup(inline_keyboard=[
[InlineKeyboardButton(text="Отправить", callback_data="send_answers")],
[InlineKeyboardButton(text="Переписать", callback_data="rewrite_answers")]
])
await bot.send_message(user_id, "Проверьте свои ответы. Выберите действие:", reply_markup=keyboard)
# Обработчик выбора действия подтверждения
@dp.callback_query_handler(lambda query: query.data in ['send_answers', 'rewrite_answers'])
async def handle_confirmation(query: types.CallbackQuery):
user_id = query.from_user.id
if query.data == "send_answers":
await send_answers_to_group(user_id)
elif query.data == "rewrite_answers":
await rewrite_answers(user_id)
# Функция для отправки ответов в группу
async def send_answers_to_group(user_id):
cursor.execute("SELECT * FROM answers WHERE user_id=?", (user_id,))
answers = cursor.fetchall()
if answers:
answer_text = '\n'.join([f"{questions[ans[1]]}: {ans[2]}" for ans in answers])
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
# Отправляем ответы в группу и добавляем ID пользователя
sent_message = await bot.send_message(GROUP_ID, f"Ответы от пользователя {user_id}:\n\n{answer_text}")
await bot.send_message(user_id, f"Ваши ответы отправлены. Оператор с вами свяжится)",
parse_mode='Markdown')
else:
await bot.send_message(user_id, "Ответов нет")
# Функция для переписывания ответов
async def rewrite_answers(user_id):
# Очищаем таблицу с ответами
cursor.execute("DELETE FROM answers WHERE user_id=?", (user_id,))
conn.commit()
await bot.send_message(user_id, "Ваши ответы удалены. Начнем сначала.")
await ask_question(user_id, 1)
# Функция для обработки сообщений из группы и пересылки их пользователю
@dp.message_handler(lambda message: message.chat.id == int(GROUP_ID) and message.reply_to_message)
async def handle_group_reply(message: types.Message):
# Проверяем, что сообщение является ответом на сообщение бота
if message.reply_to_message.from_user.id == bot.id:
# Извлекаем ID пользователя из текста сообщения
try:
user_id = int(message.reply_to_message.text.split()[2].strip(':'))
await bot.send_message(user_id, f"Сообщение от администратора:\n\n{message.text}")
# Сохраняем ответ пользователя для пересылки обратно в группу
cursor.execute("INSERT INTO admin_user_conversation (user_id, admin_message_id) VALUES (?, ?)",
(user_id, message.message_id))
conn.commit()
except (IndexError, ValueError):
await message.reply("Не удалось определить ID пользователя для ответа.")
# Обработчик сообщений от пользователя в ответ на администратора
@dp.message_handler(lambda message: message.chat.id != int(GROUP_ID))
async def handle_user_reply(message: types.Message):
user_id = message.chat.id
cursor.execute("SELECT admin_message_id FROM admin_user_conversation WHERE user_id=? ORDER BY admin_message_id DESC LIMIT 1", (user_id,))
admin_message_id = cursor.fetchone()
if admin_message_id:
await bot.send_message(GROUP_ID, f"Сообщение от пользователя {user_id}:\n\n{message.text}", reply_to_message_id=admin_message_id[0])
if __name__ == '__main__':
loop = asyncio.get_event_loop()
try:
loop.create_task(dp.start_polling())
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
conn.close()

152
doners/old/remain.py
View File

@@ -1,76 +1,76 @@
import logging
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters import Command
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton
API_TOKEN = '7472030348:AAGI53nX-ON-WBmEhd_qBC6EnZsHOqp_2kE'
GROUP_ID = '-1001961537659'
logging.basicConfig(level=logging.INFO)
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Define states
class OrderForm(StatesGroup):
question_1 = State()
question_2 = State()
question_3 = State()
question_4 = State()
question_5 = State()
question_6 = State()
@dp.message_handler(Command("start"))
async def cmd_start(message: types.Message):
await message.reply("Привет! Чтобы создать заказ, нажми на кнопку 'Создать заказ' внизу.", reply_markup=ReplyKeyboardMarkup(
resize_keyboard=True).add(KeyboardButton("Создать заказ")))
@dp.message_handler(Command("menu"))
async def show_menu(message: types.Message):
await message.reply("Выбери действие:", reply_markup=ReplyKeyboardMarkup(
resize_keyboard=True).add(KeyboardButton("Создать заказ")))
@dp.message_handler(Command("create_order"))
async def cmd_create_order(message: types.Message):
await OrderForm.question_1.set()
await message.reply("Ответьте на первый вопрос:")
@dp.message_handler(state=OrderForm.question_1)
async def process_question_1(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['question_1'] = message.text
await OrderForm.next()
await message.reply("Ответьте на второй вопрос:")
# Аналогично для остальных вопросов
@dp.message_handler(state=OrderForm.question_6)
async def process_question_6(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['question_6'] = message.text
await message.reply("Отлично! Ваши ответы:")
async with state.proxy() as data:
for key, value in data.items():
await message.reply(f"{key}: {value}")
# Предложить отправить или переписать ответы
keyboard = InlineKeyboardMarkup().add(InlineKeyboardButton("Отправить", callback_data="send_order")).add(InlineKeyboardButton("Переписать", callback_data="rewrite_order"))
await message.reply("Хотите отправить эти ответы или переписать?", reply_markup=keyboard)
@dp.callback_query_handler(text="send_order", state="*")
async def send_order(callback_query: types.CallbackQuery, state: FSMContext):
async with state.proxy() as data:
for key, value in data.items():
await bot.send_message(callback_query.from_user.id, f"{key}: {value}")
@dp.callback_query_handler(text="rewrite_order", state="*")
async def rewrite_order(callback_query: types.CallbackQuery):
await cmd_create_order(callback_query.message)
if __name__ == '__main__':
from aiogram import executor
executor.start_polling(dp, skip_updates=True)
import logging
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters import Command
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton
API_TOKEN = '7472030348:AAGI53nX-ON-WBmEhd_qBC6EnZsHOqp_2kE'
GROUP_ID = '-1001961537659'
logging.basicConfig(level=logging.INFO)
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
# Define states
class OrderForm(StatesGroup):
question_1 = State()
question_2 = State()
question_3 = State()
question_4 = State()
question_5 = State()
question_6 = State()
@dp.message_handler(Command("start"))
async def cmd_start(message: types.Message):
await message.reply("Привет! Чтобы создать заказ, нажми на кнопку 'Создать заказ' внизу.", reply_markup=ReplyKeyboardMarkup(
resize_keyboard=True).add(KeyboardButton("Создать заказ")))
@dp.message_handler(Command("menu"))
async def show_menu(message: types.Message):
await message.reply("Выбери действие:", reply_markup=ReplyKeyboardMarkup(
resize_keyboard=True).add(KeyboardButton("Создать заказ")))
@dp.message_handler(Command("create_order"))
async def cmd_create_order(message: types.Message):
await OrderForm.question_1.set()
await message.reply("Ответьте на первый вопрос:")
@dp.message_handler(state=OrderForm.question_1)
async def process_question_1(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['question_1'] = message.text
await OrderForm.next()
await message.reply("Ответьте на второй вопрос:")
# Аналогично для остальных вопросов
@dp.message_handler(state=OrderForm.question_6)
async def process_question_6(message: types.Message, state: FSMContext):
async with state.proxy() as data:
data['question_6'] = message.text
await message.reply("Отлично! Ваши ответы:")
async with state.proxy() as data:
for key, value in data.items():
await message.reply(f"{key}: {value}")
# Предложить отправить или переписать ответы
keyboard = InlineKeyboardMarkup().add(InlineKeyboardButton("Отправить", callback_data="send_order")).add(InlineKeyboardButton("Переписать", callback_data="rewrite_order"))
await message.reply("Хотите отправить эти ответы или переписать?", reply_markup=keyboard)
@dp.callback_query_handler(text="send_order", state="*")
async def send_order(callback_query: types.CallbackQuery, state: FSMContext):
async with state.proxy() as data:
for key, value in data.items():
await bot.send_message(callback_query.from_user.id, f"{key}: {value}")
@dp.callback_query_handler(text="rewrite_order", state="*")
async def rewrite_order(callback_query: types.CallbackQuery):
await cmd_create_order(callback_query.message)
if __name__ == '__main__':
from aiogram import executor
executor.start_polling(dp, skip_updates=True)