old

doners/bot-market/.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

doners/bot-market/.idea/bot-market.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

doners/bot-market/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

doners/bot-market/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.10 (bot-market)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (bot-market)" project-jdk-type="Python SDK" />
+</project>

doners/bot-market/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/bot-market.iml" filepath="$PROJECT_DIR$/.idea/bot-market.iml" />
+    </modules>
+  </component>
+</project>

doners/bot-market/app/admin.py

@@ -0,0 +1,94 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.filters import CommandStart, Command, Filter
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State, StatesGroup
+
+import app.keyboards as kb
+from app.database.requests import get_users, set_item
+
+admin = Router()
+
+
+class Newsletter(StatesGroup):
+    message = State()
+
+
+class AddItem(StatesGroup):
+    name = State()
+    category = State()
+    description = State()
+    photo = State()
+    price = State()
+
+
+class AdminProtect(Filter):
+    async def __call__(self, message: Message):
+        return message.from_user.id in [1477217831]
+
+
+@admin.message(AdminProtect(), Command('apanel'))
+async def apanel(message: Message):
+    await message.answer('Возможные команды: /newsletter\n/add_item')
+
+
+@admin.message(AdminProtect(), Command('newsletter'))
+async def newsletter(message: Message, state: FSMContext):
+    await state.set_state(Newsletter.message)
+    await message.answer('Отправьте сообщение, которое вы хотите разослать всем пользователям')
+
+
+@admin.message(AdminProtect(), Newsletter.message)
+async def newsletter_message(message: Message, state: FSMContext):
+    await message.answer('Подождите... идёт рассылка.')
+    for user in await get_users():
+        try:
+            await message.send_copy(chat_id=user.tg_id)
+        except:
+            pass
+    await message.answer('Рассылка успешно завершена.')
+    await state.clear()
+
+
+@admin.message(AdminProtect(), Command('add_item'))
+async def add_item(message: Message, state: FSMContext):
+    await state.set_state(AddItem.name)
+    await message.answer('Введите название товара')
+
+
+@admin.message(AdminProtect(), AddItem.name)
+async def add_item_name(message: Message, state: FSMContext):
+    await state.update_data(name=message.text)
+    await state.set_state(AddItem.category)
+    await message.answer('Выберите категорию товара', reply_markup=await kb.categories())
+
+
+@admin.callback_query(AdminProtect(), AddItem.category)
+async def add_item_category(callback: CallbackQuery, state: FSMContext):
+    await state.update_data(category=callback.data.split('_')[1])
+    await state.set_state(AddItem.description)
+    await callback.answer('')
+    await callback.message.answer('Введите описание товара')
+
+
+@admin.message(AdminProtect(), AddItem.description)
+async def add_item_description(message: Message, state: FSMContext):
+    await state.update_data(description=message.text)
+    await state.set_state(AddItem.photo)
+    await message.answer('Отправьте фото товара')
+
+
+@admin.message(AdminProtect(), AddItem.photo, F.photo)
+async def add_item_photo(message: Message, state: FSMContext):
+    await state.update_data(photo=message.photo[-1].file_id)
+    await state.set_state(AddItem.price)
+    await message.answer('Введите цену товара')
+
+
+@admin.message(AdminProtect(), AddItem.price)
+async def add_item_price(message: Message, state: FSMContext):
+    await state.update_data(price=message.text)
+    data = await state.get_data()
+    await set_item(data)
+    await message.answer('Товар успешно добавлен')
+    await state.clear()

doners/bot-market/app/database/models.py

@@ -0,0 +1,62 @@
+from sqlalchemy import BigInteger, ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship, DeclarativeBase
+from sqlalchemy.ext.asyncio import AsyncAttrs, async_sessionmaker, create_async_engine
+
+from typing import List
+from config import ENGINE, ECHO
+
+engine = create_async_engine(url=ENGINE)#, echo=ECHO)
+
+async_session = async_sessionmaker(engine)
+
+
+class Base(AsyncAttrs, DeclarativeBase):
+    pass
+
+
+class User(Base):
+    __tablename__ = 'users'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    tg_id = mapped_column(BigInteger)
+
+    basket_rel: Mapped[List['Basket']] = relationship(back_populates='user_rel')
+
+
+class Category(Base):
+    __tablename__ = 'categories'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(50))
+
+    item_rel: Mapped[List['Item']] = relationship(back_populates='category_rel')
+
+
+class Item(Base):
+    __tablename__ = 'items'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(50))
+    description: Mapped[str] = mapped_column(String(200))
+    photo: Mapped[str] = mapped_column(String(200))
+    price: Mapped[int] = mapped_column()
+    category: Mapped[int] = mapped_column(ForeignKey('categories.id'))
+
+    category_rel: Mapped['Category'] = relationship(back_populates='item_rel')
+    basket_rel: Mapped[List['Basket']] = relationship(back_populates='item_rel')
+
+
+class Basket(Base):
+    __tablename__ = 'basket'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user: Mapped[int] = mapped_column(ForeignKey('users.id'))
+    item: Mapped[int] = mapped_column(ForeignKey('items.id'))
+
+    user_rel: Mapped['User'] = relationship(back_populates='basket_rel')
+    item_rel: Mapped['Item'] = relationship(back_populates='basket_rel')
+
+
+async def async_main():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)

doners/bot-market/app/database/requests.py

@@ -0,0 +1,64 @@
+from app.database.models import User, Category, Item, Basket
+from app.database.models import async_session
+
+from sqlalchemy import select, update, delete
+
+
+async def set_user(tg_id):
+    async with async_session() as session:
+        user = await session.scalar(select(User).where(User.tg_id == tg_id))
+
+        if not user:
+            session.add(User(tg_id=tg_id))
+            await session.commit()
+
+
+async def set_item(data):
+    async with async_session() as session:
+        session.add(Item(**data))
+        await session.commit()
+
+
+async def set_basket(tg_id, item_id):
+    async with async_session() as session:
+        user = await session.scalar(select(User).where(User.tg_id == tg_id))
+        session.add(Basket(user=user.id, item=item_id))
+        await session.commit()
+
+
+async def get_basket(tg_id):
+    async with async_session() as session:
+        user = await session.scalar(select(User).where(User.tg_id == tg_id))
+        basket = await session.scalars(select(Basket).where(Basket.user == user.id))
+        return basket
+
+
+async def get_users():
+    async with async_session() as session:
+        users = await session.scalars(select(User))
+        return users
+
+
+async def get_categories():
+    async with async_session() as session:
+        categories = await session.scalars(select(Category))
+        return categories
+
+
+async def get_items_by_category(category_id: int):
+    async with async_session() as session:
+        items = await session.scalars(select(Item).where(Item.category == category_id))
+        return items
+
+
+async def get_item_by_id(item_id: int):
+    async with async_session() as session:
+        item = await session.scalar(select(Item).where(Item.id == item_id))
+        return item
+
+
+async def delete_basket(tg_id, item_id):
+    async with async_session() as session:
+        user = await session.scalar(select(User).where(User.tg_id == tg_id))
+        await session.execute(delete(Basket).where(Basket.user == user.id, Basket.item == item_id))
+        await session.commit()

doners/bot-market/app/handlers.py

@@ -0,0 +1,72 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.filters import CommandStart, Command
+
+import app.keyboards as kb
+from app.database.requests import (get_item_by_id, set_user,
+                                   set_basket, get_basket, get_item_by_id, delete_basket)
+
+router = Router()
+
+
+@router.message(CommandStart())
+@router.callback_query(F.data == 'to_main')
+async def cmd_start(message: Message | CallbackQuery):
+    if isinstance(message, Message):
+        await set_user(message.from_user.id)
+        await message.answer("Добро пожаловать в интернет магазин!",
+                             reply_markup=kb.main)
+    else:
+        await message.answer('Вы вернулись на главную')
+        await message.message.answer("Добро пожаловать в интернет магазин!",
+                                     reply_markup=kb.main)
+
+
+@router.callback_query(F.data == 'catalog')
+async def catalog(callback: CallbackQuery):
+    await callback.answer('')
+    await callback.message.edit_text(text='Выберите категорию.',
+                                     reply_markup=await kb.categories())
+
+
+@router.callback_query(F.data.startswith('category_'))
+async def category(callback: CallbackQuery):
+    await callback.answer('')
+    await callback.message.edit_text('Выберите товар',
+                                     reply_markup=await kb.items(callback.data.split('_')[1]))
+
+
+@router.callback_query(F.data.startswith('item_'))
+async def category(callback: CallbackQuery):
+    item = await get_item_by_id(callback.data.split('_')[1])
+    await callback.answer('')
+    await callback.message.answer_photo(photo=item.photo,
+                                        caption=f'{item.name}\n\n{item.description}\n\nЦена: {item.price} рублей',
+                                        reply_markup=await kb.basket(item.id))
+
+
+@router.callback_query(F.data.startswith('order_'))
+async def basket(callback: CallbackQuery):
+    await set_basket(callback.from_user.id, callback.data.split('_')[1])
+    await callback.answer('Товар добавлен в корзину')
+
+
+@router.callback_query(F.data == 'mybasket')
+async def mybasket(callback: CallbackQuery):
+    await callback.answer('')
+    basket = await get_basket(callback.from_user.id)
+    counter = 0
+    for item_info in basket:
+        item = await get_item_by_id(item_info.item)
+        await callback.message.answer_photo(photo=item.photo,
+                                            caption=f'{item.name}\n\n{item.description}\n\nЦена: {item.price} рублей',
+                                            reply_markup=await kb.delete_from_basket(item.id))
+        counter += 1
+    await callback.message.answer('Ваша корзина пуста') if counter == 0 else await callback.answer('')
+
+
+@router.callback_query(F.data.startswith('delete_'))
+async def delete_from_basket(callback: CallbackQuery):
+    await delete_basket(callback.from_user.id, callback.data.split('_')[1])
+    await callback.message.delete()
+    await callback.answer('Вы удалили товар из корзины')

doners/bot-market/app/keyboards.py

@@ -0,0 +1,49 @@
+
+from aiogram.types import (ReplyKeyboardMarkup, KeyboardButton,
+                           InlineKeyboardMarkup, InlineKeyboardButton)
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+
+from app.database.requests import get_categories, get_items_by_category
+
+main = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text='Каталог', callback_data='catalog')],
+    [InlineKeyboardButton(text='Корзина', callback_data='mybasket'),
+     InlineKeyboardButton(text='Контакты', callback_data='contacts')]
+])
+
+to_main = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text='На главную', callback_data='to_main')]
+])
+
+
+async def delete_from_basket(order_id):
+    keyboard = InlineKeyboardBuilder()
+    keyboard.add(InlineKeyboardButton(text='Удалить из корзины', callback_data=f'delete_{order_id}'))
+    return keyboard.adjust(2).as_markup()
+
+
+async def basket(order_id):
+    keyboard = InlineKeyboardBuilder()
+    keyboard.add(InlineKeyboardButton(text='Оформить заказ', callback_data=f'order_{order_id}'))
+    keyboard.add(InlineKeyboardButton(text='Назад', callback_data='to_main'))
+    return keyboard.adjust(2).as_markup()
+
+
+async def categories():
+    all_categories = await get_categories()
+    keyboard = InlineKeyboardBuilder()
+    for category in all_categories:
+        keyboard.add(InlineKeyboardButton(text=category.name,
+                                          callback_data=f'category_{category.id}'))
+    keyboard.add(InlineKeyboardButton(text='Назад', callback_data='to_main'))
+    return keyboard.adjust(2).as_markup()
+
+
+async def items(category_id: int):
+    items = await get_items_by_category(category_id)
+    keyboard = InlineKeyboardBuilder()
+    for item in items:
+        keyboard.add(InlineKeyboardButton(text=item.name,
+                                          callback_data=f"item_{item.id}"))
+    keyboard.add(InlineKeyboardButton(text='Назад', callback_data='to_main'))
+    return keyboard.adjust(2).as_markup()

doners/bot-market/config.py

@@ -0,0 +1,3 @@
+TOKEN='7103505936:AAEpiQxlKNd9Uji9IziTdNzSTH38PavqXZM'
+ENGINE='sqlite+aiosqlite:///db.sqlite3'
+ECHO=''

doners/bot-market/run.py

@@ -0,0 +1,25 @@
+import asyncio
+import logging
+
+from aiogram import Bot, Dispatcher
+
+from config import TOKEN
+from app.database.models import async_main
+from app.handlers import router
+from app.admin import admin
+
+
+async def main():
+    await async_main()
+    bot = Bot(token=TOKEN)
+    dp = Dispatcher()
+    dp.include_routers(admin, router)
+    await dp.start_polling(bot)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print('Exit')

doners/old/bot(OLD).py

@@ -0,0 +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)

doners/old/bot.py

@@ -0,0 +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)

doners/old/database.py

@@ -0,0 +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()
+    conn.close()

doners/old/handlers.py

@@ -0,0 +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)

doners/old/klining_order.py

@@ -0,0 +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()

doners/old/logger.py

@@ -0,0 +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()

doners/old/main(OLD).py

@@ -0,0 +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()

doners/old/main.py

@@ -0,0 +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()

doners/old/remain.py

@@ -0,0 +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)

doners/old_2/database.py

@@ -0,0 +1,53 @@
+import sqlite3
+
+def create_tables():
+    conn = sqlite3.connect('bot_data.db')
+    cursor = conn.cursor()
+
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS orders (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT,
+            phone TEXT,
+            address TEXT,
+            cleaning_time TEXT,
+            cleaning_type TEXT,
+            payment_method TEXT
+        )
+    ''')
+
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            user_id INTEGER PRIMARY KEY,
+            name TEXT,
+            phone TEXT,
+            address TEXT
+        )
+    ''')
+
+    conn.commit()
+    conn.close()
+
+def add_order(name, phone, address, cleaning_time, cleaning_type, payment_method):
+    conn = sqlite3.connect('bot_data.db')
+    cursor = conn.cursor()
+
+    cursor.execute('''
+        INSERT INTO orders (name, phone, address, cleaning_time, cleaning_type, payment_method)
+        VALUES (?, ?, ?, ?, ?, ?)
+    ''', (name, phone, address, cleaning_time, cleaning_type, payment_method))
+
+    conn.commit()
+    conn.close()
+
+def get_order_history(user_id):
+    conn = sqlite3.connect('bot_data.db')
+    cursor = conn.cursor()
+
+    cursor.execute('''
+        SELECT * FROM orders WHERE user_id = ?
+    ''', (user_id,))
+
+    orders = cursor.fetchall()
+    conn.close()
+    return orders

doners/old_2/handlers.py

@@ -0,0 +1,158 @@
+import logging
+from aiogram import types
+from aiogram.dispatcher import FSMContext
+from aiogram.dispatcher.filters.state import State, StatesGroup
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from database import add_order, get_order_history
+from logger import log_action
+
+logging.basicConfig(level=logging.INFO)
+
+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()
+
+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_confirmation_keyboard():
+    keyboard = InlineKeyboardMarkup()
+    keyboard.add(InlineKeyboardButton('Подтвердить', callback_data='confirm_order'))
+    return keyboard
+
+def register_handlers(dp, OPERATORS_GROUP_ID):
+    @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 callback_query.answer()
+        await callback_query.message.answer("Учетные данные:", 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 callback_query.answer()
+        await callback_query.message.answer("Начнем с ваших учетных данных. Введите ваше ФИО:")
+        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 callback_query.answer()
+        orders = get_order_history(callback_query.from_user.id)
+        if orders:
+            history_message = "\n\n".join([f"Заказ {order['id']}:\nФИО: {order['name']}\nАдрес: {order['address']}\nТип уборки: {order['cleaning_type']}" for order in orders])
+            await callback_query.message.answer(f"История заказов:\n{history_message}")
+        else:
+            await callback_query.message.answer("История заказов пуста.")
+        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 callback_query.answer()
+        await callback_query.message.answer("Заказ звонка оформлен. Ожидайте звонок в течение 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 callback_query.answer()
+        await callback_query.message.answer("Разговор с оператором начат.")
+        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 callback_query.answer()
+        await callback_query.message.answer("Главное меню:", 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=order_confirmation_keyboard())
+        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 callback_query.answer()
+        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)
+            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()

doners/old_2/logger.py

@@ -0,0 +1,6 @@
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+def log_action(user_id, action):
+    logging.info(f"User {user_id} performed action: {action}")

doners/old_2/main.py

@@ -0,0 +1,31 @@
+import logging
+from aiogram import Bot, Dispatcher, types
+from aiogram.contrib.middlewares.logging import LoggingMiddleware
+from aiogram.utils import executor
+from aiogram.dispatcher import FSMContext
+from aiogram.dispatcher.filters.state import State, StatesGroup
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from dotenv import load_dotenv
+import os
+
+from handlers import register_handlers
+from database import create_tables
+
+# Загрузка переменных окружения из .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())
+
+# Основное приложение
+if __name__ == '__main__':
+    create_tables()
+    register_handlers(dp, OPERATORS_GROUP_ID)
+    executor.start_polling(dp, skip_updates=True)