794 lines
35 KiB
Python
794 lines
35 KiB
Python
import asyncio
|
||
import logging
|
||
from datetime import date
|
||
from decimal import Decimal
|
||
|
||
import httpx
|
||
from aiogram import Bot, Dispatcher, F
|
||
from aiogram.filters import Command, CommandObject
|
||
from aiogram.types import (
|
||
CallbackQuery,
|
||
InlineKeyboardButton,
|
||
InlineKeyboardMarkup,
|
||
KeyboardButton,
|
||
Message,
|
||
ReplyKeyboardMarkup,
|
||
WebAppInfo,
|
||
)
|
||
|
||
from app.core.config import settings
|
||
from bot.api_client import ApiClient
|
||
|
||
logging.basicConfig(level=logging.INFO)
|
||
|
||
dp = Dispatcher()
|
||
api = ApiClient()
|
||
|
||
APPROVED_SERVICE_STATUSES = {"approved", "verified"}
|
||
STO_WORKPLACE_ROLES = {"owner", "manager", "receptionist", "mechanic"}
|
||
|
||
|
||
def webapp_url(path: str = "") -> str:
|
||
base = settings.effective_webapp_url.rstrip("/")
|
||
if not path:
|
||
return base
|
||
return f"{base}/{path.lstrip('/')}"
|
||
|
||
|
||
def sto_workplace_url() -> str:
|
||
return webapp_url("sto.html")
|
||
|
||
|
||
async def sto_workplace_centers(telegram_id: int) -> list[dict]:
|
||
try:
|
||
centers = await api.my_service_centers(telegram_id)
|
||
except httpx.HTTPStatusError:
|
||
return []
|
||
return [
|
||
center
|
||
for center in centers
|
||
if center.get("verification_status") in APPROVED_SERVICE_STATUSES
|
||
and (center.get("employee_role") or "owner") in STO_WORKPLACE_ROLES
|
||
]
|
||
|
||
|
||
def main_keyboard() -> ReplyKeyboardMarkup:
|
||
return ReplyKeyboardMarkup(
|
||
keyboard=[
|
||
[KeyboardButton(text="Меню"), KeyboardButton(text="Мои авто")],
|
||
[KeyboardButton(text="Помощь")],
|
||
],
|
||
resize_keyboard=True,
|
||
)
|
||
|
||
|
||
async def main_keyboard_for(telegram_id: int) -> ReplyKeyboardMarkup:
|
||
rows = [
|
||
[KeyboardButton(text="Меню"), KeyboardButton(text="Мои авто")],
|
||
]
|
||
if await sto_workplace_centers(telegram_id):
|
||
rows.append([KeyboardButton(text="Панель СТО")])
|
||
rows.append([KeyboardButton(text="Помощь")])
|
||
return ReplyKeyboardMarkup(keyboard=rows, resize_keyboard=True)
|
||
|
||
|
||
def webapp_inline_keyboard(text: str = "Открыть CarPass", path: str = "") -> InlineKeyboardMarkup:
|
||
return InlineKeyboardMarkup(
|
||
inline_keyboard=[
|
||
[InlineKeyboardButton(text=text, web_app=WebAppInfo(url=webapp_url(path)))],
|
||
]
|
||
)
|
||
|
||
|
||
def menu_inline_keyboard(include_sto_workplace: bool = False) -> InlineKeyboardMarkup:
|
||
rows = [
|
||
[InlineKeyboardButton(text="Открыть Mini App", web_app=WebAppInfo(url=webapp_url()))],
|
||
[
|
||
InlineKeyboardButton(text="Мои авто", callback_data="menu:garage"),
|
||
InlineKeyboardButton(text="Аналитика", callback_data="menu:analytics"),
|
||
],
|
||
[
|
||
InlineKeyboardButton(text="Добавить запись", callback_data="menu:add_record"),
|
||
InlineKeyboardButton(text="СТО", callback_data="menu:sto"),
|
||
],
|
||
]
|
||
if include_sto_workplace:
|
||
rows.append([InlineKeyboardButton(text="Панель СТО", web_app=WebAppInfo(url=sto_workplace_url()))])
|
||
return InlineKeyboardMarkup(inline_keyboard=rows)
|
||
|
||
|
||
def admin_card_keyboard(center_id: int) -> InlineKeyboardMarkup:
|
||
return InlineKeyboardMarkup(
|
||
inline_keyboard=[
|
||
[
|
||
InlineKeyboardButton(text="Одобрить", callback_data=f"admin:approve:{center_id}"),
|
||
InlineKeyboardButton(text="Правки", callback_data=f"admin:changes:{center_id}"),
|
||
],
|
||
[
|
||
InlineKeyboardButton(text="Отклонить", callback_data=f"admin:reject:{center_id}"),
|
||
InlineKeyboardButton(text="Заморозить", callback_data=f"admin:suspend:{center_id}"),
|
||
],
|
||
]
|
||
)
|
||
|
||
|
||
async def safe_answer(message: Message, text: str, **kwargs) -> None:
|
||
await message.answer(text, **kwargs)
|
||
|
||
|
||
async def upsert(message: Message) -> dict:
|
||
return await api.upsert_user(message.from_user)
|
||
|
||
|
||
async def list_user_cars(message: Message) -> list[dict]:
|
||
user = await upsert(message)
|
||
return await api.list_cars(user["id"], message.from_user.id)
|
||
|
||
|
||
async def require_one_car(message: Message) -> dict | None:
|
||
cars = await list_user_cars(message)
|
||
if not cars:
|
||
await message.answer(
|
||
"В гараже пока нет автомобиля. Добавь его командой /add_car Название или через Mini App.",
|
||
reply_markup=webapp_inline_keyboard("Добавить авто"),
|
||
)
|
||
return None
|
||
if len(cars) > 1:
|
||
await message.answer(
|
||
"У тебя несколько авто. Для точной записи открой Mini App и выбери нужную машину.",
|
||
reply_markup=webapp_inline_keyboard("Выбрать авто"),
|
||
)
|
||
return None
|
||
return cars[0]
|
||
|
||
|
||
def money(value) -> str:
|
||
return f"{Decimal(str(value or 0)).quantize(Decimal('0.01'))}"
|
||
|
||
|
||
def parse_amount_arg(args: str | None) -> Decimal | None:
|
||
if not args:
|
||
return None
|
||
import re
|
||
|
||
matches = re.findall(r"\d+(?:[.,]\d+)?", args)
|
||
if not matches:
|
||
return None
|
||
return Decimal(matches[-1].replace(",", "."))
|
||
|
||
|
||
@dp.message(Command("start"))
|
||
async def start(message: Message) -> None:
|
||
user = await upsert(message)
|
||
text = (
|
||
f"Готово, {user.get('first_name') or 'водитель'}.\n\n"
|
||
"CarPass ведет цифровой паспорт автомобиля: заправки, ТО, страховку, штрафы, стоимость владения и подтвержденную историю СТО.\n\n"
|
||
"Mini App открывай кнопкой под сообщением: так Telegram передает защищенную авторизацию."
|
||
)
|
||
centers = await sto_workplace_centers(message.from_user.id)
|
||
await message.answer(text, reply_markup=menu_inline_keyboard(include_sto_workplace=bool(centers)))
|
||
await message.answer("Клавиатура ниже открывает команды бота.", reply_markup=await main_keyboard_for(message.from_user.id))
|
||
|
||
|
||
@dp.message(F.text == "Меню")
|
||
@dp.message(Command("menu"))
|
||
async def menu(message: Message) -> None:
|
||
await upsert(message)
|
||
centers = await sto_workplace_centers(message.from_user.id)
|
||
await message.answer(
|
||
"Главное меню CarPass. Быстрые команды доступны здесь, а полный интерфейс работает в Mini App.",
|
||
reply_markup=menu_inline_keyboard(include_sto_workplace=bool(centers)),
|
||
)
|
||
|
||
|
||
@dp.message(Command("garage"))
|
||
@dp.message(Command("cars"))
|
||
@dp.message(F.text == "Мои авто")
|
||
async def cars(message: Message) -> None:
|
||
items = await list_user_cars(message)
|
||
if not items:
|
||
await message.answer("Автомобилей пока нет. Добавь через Mini App или /add_car Название.", reply_markup=webapp_inline_keyboard("Добавить авто"))
|
||
return
|
||
|
||
buttons = [[InlineKeyboardButton(text=car["name"], callback_data=f"stats:{car['id']}")] for car in items]
|
||
buttons.append([InlineKeyboardButton(text="Открыть гараж", web_app=WebAppInfo(url=settings.effective_webapp_url))])
|
||
await message.answer("Твой гараж:", reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons))
|
||
|
||
|
||
@dp.message(Command("add_car"))
|
||
async def add_car(message: Message, command: CommandObject) -> None:
|
||
user = await upsert(message)
|
||
name = command.args.strip() if command.args else ""
|
||
if not name:
|
||
await message.answer(
|
||
"Напиши так: /add_car Toyota Camry\n\nVIN, госномер, кредит и параметры масла удобнее заполнить в Mini App.",
|
||
reply_markup=webapp_inline_keyboard("Заполнить карточку"),
|
||
)
|
||
return
|
||
try:
|
||
car = await api.create_car(user["id"], name, message.from_user.id)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Не удалось добавить авто: {error.response.text}")
|
||
return
|
||
await message.answer(f"Добавил авто: {car['name']}", reply_markup=webapp_inline_keyboard("Открыть карточку"))
|
||
|
||
|
||
@dp.message(Command("add_record"))
|
||
async def add_record(message: Message) -> None:
|
||
await upsert(message)
|
||
await message.answer(
|
||
"Добавить запись можно командой или через Mini App.\n\n"
|
||
"/fuel заправил полный бак 43 литра на 72000, пробег 184230\n"
|
||
"/service замена масла 70000 пробег 184900\n"
|
||
"/insurance страховка 1200000 на 12 месяцев\n"
|
||
"/tax налог 180000\n"
|
||
"/fine штраф 40000\n\n"
|
||
"При заправке бот распознает фразы «полный бак», «до полного», «full tank».",
|
||
reply_markup=webapp_inline_keyboard("Добавить запись"),
|
||
)
|
||
|
||
|
||
@dp.message(Command("fuel"))
|
||
async def fuel(message: Message, command: CommandObject) -> None:
|
||
args = command.args or ""
|
||
if not args.strip():
|
||
await message.answer(
|
||
"Напиши заправку текстом: /fuel заправил полный бак 43 литра на 72000, пробег 184230\n\n"
|
||
"Бак был заправлен до полного? Укажи «полный бак», «нет» или «не знаю».",
|
||
reply_markup=webapp_inline_keyboard("Заполнить заправку"),
|
||
)
|
||
return
|
||
await create_record_from_text(message, args, expected="fuel")
|
||
|
||
|
||
@dp.message(Command("service"))
|
||
async def service(message: Message, command: CommandObject) -> None:
|
||
args = command.args or ""
|
||
if not args.strip():
|
||
await message.answer(
|
||
"Напиши сервисную запись: /service замена масла 70000 пробег 184900\n\n"
|
||
"Для фото, следующего ТО и детальных работ удобнее Mini App.",
|
||
reply_markup=webapp_inline_keyboard("Добавить ТО"),
|
||
)
|
||
return
|
||
await create_record_from_text(message, args, expected="service")
|
||
|
||
|
||
@dp.message(Command("insurance"))
|
||
async def insurance(message: Message, command: CommandObject) -> None:
|
||
await create_expense_command(message, command, "insurance", "Страховка")
|
||
|
||
|
||
@dp.message(Command("tax"))
|
||
async def tax(message: Message, command: CommandObject) -> None:
|
||
await create_expense_command(message, command, "tax", "Налог")
|
||
|
||
|
||
@dp.message(Command("fine"))
|
||
async def fine(message: Message, command: CommandObject) -> None:
|
||
await create_expense_command(message, command, "fine", "Штраф")
|
||
|
||
|
||
async def create_expense_command(message: Message, command: CommandObject, category: str, title: str) -> None:
|
||
args = command.args or ""
|
||
if not args.strip():
|
||
await message.answer(f"Напиши сумму: /{category if category != 'fine' else 'fine'} {title.lower()} 40000", reply_markup=webapp_inline_keyboard(f"Добавить {title.lower()}"))
|
||
return
|
||
car = await require_one_car(message)
|
||
if not car:
|
||
return
|
||
parsed = await api.parse_record(message.from_user.id, f"{title} {args}")
|
||
amount = parsed.get("data", {}).get("amount") or parse_amount_arg(args)
|
||
if not amount:
|
||
await message.answer("Не нашёл сумму. Проверь запись или открой форму в Mini App.", reply_markup=webapp_inline_keyboard("Открыть форму"))
|
||
return
|
||
payload = {
|
||
"car_id": car["id"],
|
||
"entry_date": date.today().isoformat(),
|
||
"category": category,
|
||
"title": title,
|
||
"total_cost": float(amount),
|
||
"currency": parsed.get("data", {}).get("currency") or car.get("currency") or "RUB",
|
||
"is_recurring": category in {"insurance", "tax"},
|
||
}
|
||
if category == "insurance":
|
||
payload["period_months"] = 12 if "12" in args else None
|
||
payload["payment_period_months"] = payload["period_months"]
|
||
try:
|
||
await api.create_expense(message.from_user.id, payload)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Запись не сохранена: {error.response.text}")
|
||
return
|
||
await message.answer(f"{title} сохранен для {car['name']}.")
|
||
|
||
|
||
@dp.message(Command("analytics"))
|
||
async def analytics(message: Message) -> None:
|
||
await cars(message)
|
||
|
||
|
||
@dp.message(Command("sto"))
|
||
async def sto(message: Message) -> None:
|
||
await upsert(message)
|
||
try:
|
||
centers = await api.sto_catalog(message.from_user.id)
|
||
except httpx.HTTPStatusError:
|
||
centers = []
|
||
if not centers:
|
||
await message.answer(
|
||
"Проверенных СТО пока нет в каталоге. Можно зарегистрировать свое СТО через Mini App или командой /register_sto Название.",
|
||
reply_markup=webapp_inline_keyboard("Открыть СТО"),
|
||
)
|
||
return
|
||
text = "Проверенные СТО:\n" + "\n".join(
|
||
(
|
||
f"{item['id']}. {item.get('display_name') or item.get('name')} — {item.get('city') or 'город не указан'}"
|
||
f"{' · ближайшее окно ' + item['nearest_slot_at'][:16].replace('T', ' ') if item.get('nearest_slot_at') else ''}"
|
||
)
|
||
for item in centers[:10]
|
||
)
|
||
await message.answer(text, reply_markup=webapp_inline_keyboard("Каталог СТО"))
|
||
|
||
|
||
@dp.message(Command("appointments"))
|
||
async def appointments(message: Message) -> None:
|
||
await upsert(message)
|
||
try:
|
||
items = await api.my_appointments(message.from_user.id)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Записи не загрузились: {error.response.text}")
|
||
return
|
||
if not items:
|
||
await message.answer(
|
||
"Активных записей пока нет. В Mini App можно выбрать авто, СТО и свободное окно.",
|
||
reply_markup=webapp_inline_keyboard("Записаться в СТО"),
|
||
)
|
||
return
|
||
lines = ["Ваши записи:"]
|
||
for item in items[:10]:
|
||
lines.append(
|
||
f"#{item['id']} {item['service_name']} — {item['requested_start_at'][:16].replace('T', ' ')} · {item['status']}"
|
||
)
|
||
await message.answer("\n".join(lines), reply_markup=webapp_inline_keyboard("Мои записи"))
|
||
|
||
|
||
@dp.message(Command("sto_bookings"))
|
||
async def sto_bookings(message: Message) -> None:
|
||
await upsert(message)
|
||
centers = await sto_workplace_centers(message.from_user.id)
|
||
if not centers:
|
||
await message.answer("Панель СТО доступна только владельцу подтвержденного СТО и активным механикам.")
|
||
return
|
||
center = centers[0]
|
||
try:
|
||
dashboard = await api.sto_dashboard(message.from_user.id, center["id"])
|
||
pending = await api.sto_appointments(message.from_user.id, center["id"])
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Заявки СТО не загрузились: {error.response.text}")
|
||
return
|
||
lines = [
|
||
f"Кабинет СТО: {center.get('display_name') or center.get('name')}",
|
||
f"Авто: {dashboard['connected_vehicles']}",
|
||
f"Новые заявки: {dashboard['pending_appointments']}",
|
||
f"Подтверждено: {dashboard['confirmed_appointments']}",
|
||
]
|
||
for item in pending[:8]:
|
||
lines.append(f"#{item['id']} {item['service_name']} — {item['requested_start_at'][:16].replace('T', ' ')}")
|
||
await message.answer("\n".join(lines), reply_markup=webapp_inline_keyboard("Открыть панель СТО", "sto.html"))
|
||
|
||
|
||
@dp.message(Command("sto_workplace"))
|
||
@dp.message(F.text == "Панель СТО")
|
||
async def sto_workplace(message: Message) -> None:
|
||
await upsert(message)
|
||
centers = await sto_workplace_centers(message.from_user.id)
|
||
if not centers:
|
||
await message.answer("Панель СТО доступна только владельцу подтвержденного СТО и активным механикам.")
|
||
return
|
||
center = centers[0]
|
||
await message.answer(
|
||
f"Панель СТО: {center.get('display_name') or center.get('name')}",
|
||
reply_markup=webapp_inline_keyboard("Открыть панель СТО", "sto.html"),
|
||
)
|
||
|
||
|
||
@dp.message(Command("accept_sto_invite"))
|
||
async def accept_sto_invite(message: Message, command: CommandObject) -> None:
|
||
await upsert(message)
|
||
token = command.args.strip() if command.args else ""
|
||
if not token:
|
||
await message.answer("Пришлите команду вместе с токеном: /accept_sto_invite <token>")
|
||
return
|
||
try:
|
||
employee = await api.accept_sto_invite(message.from_user.id, token)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Приглашение не принято: {error.response.text}")
|
||
return
|
||
await message.answer(
|
||
f"Приглашение принято. Роль: {employee['role']}.",
|
||
reply_markup=webapp_inline_keyboard("Открыть панель СТО", "sto.html"),
|
||
)
|
||
|
||
|
||
@dp.message(Command("register_sto"))
|
||
async def register_sto(message: Message, command: CommandObject) -> None:
|
||
await upsert(message)
|
||
name = command.args.strip() if command.args else ""
|
||
if not name:
|
||
await message.answer(
|
||
"Для заявки СТО нужны название, адрес, телефон, специализация и фото документов. Открой форму в Mini App.\n\n"
|
||
"Быстрый черновик можно создать так: /register_sto Smart Service",
|
||
reply_markup=webapp_inline_keyboard("Зарегистрировать СТО"),
|
||
)
|
||
return
|
||
try:
|
||
center = await api.register_service_center(message.from_user.id, {"display_name": name})
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Не удалось отправить заявку: {error.response.text}")
|
||
return
|
||
await message.answer(
|
||
f"Заявка СТО «{center['display_name'] or center['name']}» отправлена на модерацию. Статус: {center['verification_status']}.",
|
||
reply_markup=webapp_inline_keyboard("Дополнить заявку"),
|
||
)
|
||
|
||
|
||
@dp.message(Command("admin_sto_pending"))
|
||
@dp.message(Command("admin_pending_sto"))
|
||
async def admin_sto_pending(message: Message) -> None:
|
||
await upsert(message)
|
||
try:
|
||
centers = await api.pending_service_centers(message.from_user.id)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Нет доступа к модерации: {error.response.text}")
|
||
return
|
||
if not centers:
|
||
await message.answer("Pending-заявок СТО нет.")
|
||
return
|
||
for center in centers[:20]:
|
||
text = "\n".join(
|
||
[
|
||
f"Заявка СТО #{center['id']}",
|
||
center.get("display_name") or center.get("name") or "Без названия",
|
||
f"Юр. название: {center.get('legal_name') or '-'}",
|
||
f"Рег. номер: {center.get('business_registration_number') or '-'}",
|
||
f"Адрес: {', '.join(x for x in [center.get('country'), center.get('city'), center.get('address')] if x) or '-'}",
|
||
f"Телефон: {center.get('phone') or center.get('contact_phone') or '-'}",
|
||
f"Контакт: {center.get('contact_person') or '-'}",
|
||
f"Документы: {len(center.get('document_photo_urls') or [])}",
|
||
]
|
||
)
|
||
await message.answer(text, reply_markup=admin_card_keyboard(center["id"]))
|
||
|
||
|
||
@dp.message(Command("admin"))
|
||
async def admin_home(message: Message) -> None:
|
||
await upsert(message)
|
||
try:
|
||
await api.admin_dashboard(message.from_user.id)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Админка недоступна: {error.response.text}")
|
||
return
|
||
await message.answer(
|
||
"Admin Control Center: уведомления, пользователи, СТО, заявки, Data Explorer и Audit Log.",
|
||
reply_markup=webapp_inline_keyboard("Открыть админку", "admin.html"),
|
||
)
|
||
|
||
|
||
@dp.message(Command("admin_stats"))
|
||
async def admin_stats(message: Message) -> None:
|
||
await upsert(message)
|
||
try:
|
||
dashboard = await api.admin_dashboard(message.from_user.id)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Нет доступа к admin stats: {error.response.text}")
|
||
return
|
||
await message.answer(
|
||
"\n".join(
|
||
[
|
||
"Admin stats",
|
||
f"Users today: {dashboard['users_today']}",
|
||
f"Users total: {dashboard['users_total']}",
|
||
f"STO pending: {dashboard['pending_sto_applications']}",
|
||
f"Appointments today: {dashboard['appointments_today']}",
|
||
f"Work orders active: {dashboard['active_work_orders']}",
|
||
f"Errors/security: {dashboard['system_errors']} / {dashboard['security_events']}",
|
||
]
|
||
),
|
||
reply_markup=webapp_inline_keyboard("Admin dashboard", "admin.html"),
|
||
)
|
||
|
||
|
||
@dp.message(Command("admin_users"))
|
||
async def admin_users(message: Message) -> None:
|
||
await upsert(message)
|
||
try:
|
||
data = await api.admin_users(message.from_user.id)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Нет доступа к admin users: {error.response.text}")
|
||
return
|
||
lines = ["Последние пользователи:"]
|
||
for row in data.get("rows", [])[:10]:
|
||
lines.append(f"#{row.get('id')} {row.get('username') or '-'} · {row.get('platform_role')} · {row.get('created_at')}")
|
||
await message.answer("\n".join(lines), reply_markup=webapp_inline_keyboard("Users", "admin.html?section=users"))
|
||
|
||
|
||
@dp.message(Command("admin_sto"))
|
||
async def admin_sto(message: Message) -> None:
|
||
await admin_sto_pending(message)
|
||
|
||
|
||
@dp.message(Command("admin_alerts"))
|
||
async def admin_alerts(message: Message) -> None:
|
||
await upsert(message)
|
||
try:
|
||
data = await api.admin_alerts(message.from_user.id)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Нет доступа к admin alerts: {error.response.text}")
|
||
return
|
||
lines = ["Admin alerts:"]
|
||
for row in data.get("rows", [])[:10]:
|
||
lines.append(f"#{row.get('id')} {row.get('severity')} · {row.get('title')} · {row.get('status')}")
|
||
await message.answer("\n".join(lines), reply_markup=webapp_inline_keyboard("Alerts", "admin.html?section=notifications"))
|
||
|
||
|
||
async def admin_action(message: Message, command: CommandObject, action: str) -> None:
|
||
args = (command.args or "").split(maxsplit=1)
|
||
if not args:
|
||
await message.answer("Укажи id заявки. Например: /admin_sto_approve 12")
|
||
return
|
||
try:
|
||
center_id = int(args[0])
|
||
except ValueError:
|
||
await message.answer("id заявки должен быть числом.")
|
||
return
|
||
comment = args[1] if len(args) > 1 else None
|
||
try:
|
||
center = await api.moderate_service_center(
|
||
message.from_user.id,
|
||
center_id,
|
||
action,
|
||
{"reason": comment, "comment": comment},
|
||
)
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Не удалось выполнить действие: {error.response.text}")
|
||
return
|
||
await message.answer(f"Готово. СТО #{center['id']} теперь в статусе {center['verification_status']}.")
|
||
|
||
|
||
@dp.message(Command("admin_sto_approve"))
|
||
async def admin_sto_approve(message: Message, command: CommandObject) -> None:
|
||
await admin_action(message, command, "approve")
|
||
|
||
|
||
@dp.message(Command("admin_sto_reject"))
|
||
async def admin_sto_reject(message: Message, command: CommandObject) -> None:
|
||
await admin_action(message, command, "reject")
|
||
|
||
|
||
@dp.message(Command("admin_sto_changes"))
|
||
async def admin_sto_changes(message: Message, command: CommandObject) -> None:
|
||
await admin_action(message, command, "changes")
|
||
|
||
|
||
@dp.message(Command("admin_sto_suspend"))
|
||
async def admin_sto_suspend(message: Message, command: CommandObject) -> None:
|
||
await admin_action(message, command, "suspend")
|
||
|
||
|
||
@dp.callback_query(F.data.startswith("stats:"))
|
||
async def show_stats(callback: CallbackQuery) -> None:
|
||
car_id = int(callback.data.split(":", 1)[1])
|
||
try:
|
||
stats = await api.stats(car_id, callback.from_user.id)
|
||
except httpx.HTTPStatusError as error:
|
||
await callback.message.answer(f"Не удалось получить статистику: {error.response.text}")
|
||
await callback.answer()
|
||
return
|
||
consumption = stats["avg_consumption_l_per_100km"]
|
||
cost_per_km = stats["cost_per_km"]
|
||
lines = [
|
||
"Статистика авто:",
|
||
f"Расходы всего: {money(stats['total_cost'])}",
|
||
f"Фиксированные: {money(stats.get('fixed_costs'))}",
|
||
f"Переменные: {money(stats.get('variable_costs'))}",
|
||
f"Топливо: {money(stats['fuel_cost'])}",
|
||
f"Сервис и ремонты: {money(stats['service_cost'])}",
|
||
f"Пробег по записям: {stats['distance_km']} км",
|
||
f"Средний расход: {consumption:.2f} л/100 км" if consumption else "Средний расход: нет данных",
|
||
f"Стоимость 1 км: {cost_per_km:.2f}" if cost_per_km else "Стоимость 1 км: нет данных",
|
||
]
|
||
if stats.get("cost_warning"):
|
||
lines.append(stats["cost_warning"])
|
||
await callback.message.answer("\n".join(lines))
|
||
await callback.answer()
|
||
|
||
|
||
@dp.callback_query(F.data.startswith("menu:"))
|
||
async def menu_callback(callback: CallbackQuery) -> None:
|
||
action = callback.data.split(":", 1)[1]
|
||
if action in {"garage", "analytics"}:
|
||
user = await api.upsert_user(callback.from_user)
|
||
items = await api.list_cars(user["id"], callback.from_user.id)
|
||
if not items:
|
||
await callback.message.answer("Автомобилей пока нет.", reply_markup=webapp_inline_keyboard("Добавить авто"))
|
||
else:
|
||
buttons = [[InlineKeyboardButton(text=car["name"], callback_data=f"stats:{car['id']}")] for car in items]
|
||
await callback.message.answer("Твой гараж:", reply_markup=InlineKeyboardMarkup(inline_keyboard=buttons))
|
||
elif action == "sto":
|
||
centers = await api.public_service_centers(callback.from_user.id)
|
||
if not centers:
|
||
await callback.message.answer("Проверенных СТО пока нет.", reply_markup=webapp_inline_keyboard("Каталог СТО"))
|
||
else:
|
||
await callback.message.answer(
|
||
"Проверенные СТО:\n"
|
||
+ "\n".join(f"{item['id']}. {item.get('display_name') or item.get('name')}" for item in centers[:10])
|
||
)
|
||
else:
|
||
await callback.message.answer("Открой Mini App для добавления записи.", reply_markup=webapp_inline_keyboard("Добавить запись"))
|
||
await callback.answer()
|
||
|
||
|
||
@dp.callback_query(F.data.startswith("admin:"))
|
||
async def admin_callback(callback: CallbackQuery) -> None:
|
||
_, action, center_id = callback.data.split(":", 2)
|
||
try:
|
||
center = await api.moderate_service_center(
|
||
callback.from_user.id,
|
||
int(center_id),
|
||
action,
|
||
{"reason": "Решение из Telegram-кнопки", "comment": "Решение из Telegram-кнопки"},
|
||
)
|
||
except httpx.HTTPStatusError as error:
|
||
await callback.message.answer(f"Модерация не выполнена: {error.response.text}")
|
||
await callback.answer()
|
||
return
|
||
await callback.message.answer(f"СТО #{center['id']} теперь в статусе {center['verification_status']}.")
|
||
await callback.answer()
|
||
|
||
|
||
@dp.message(F.text == "Помощь")
|
||
@dp.message(Command("help"))
|
||
async def help_message(message: Message) -> None:
|
||
user = await api.upsert_user(message.from_user)
|
||
centers = await sto_workplace_centers(message.from_user.id)
|
||
admin_help = (
|
||
"Админ: /admin — панель, /admin_stats — метрики, /admin_users — последние пользователи, "
|
||
"/admin_pending_sto — заявки СТО, /admin_alerts — события.\n"
|
||
if user.get("platform_role") in {"admin", "super_admin", "moderator", "support", "analyst"}
|
||
else ""
|
||
)
|
||
sto_workplace_help = (
|
||
"• /sto_bookings или /sto_workplace — панель подтвержденного СТО;\n"
|
||
"• /accept_sto_invite <token> — принять приглашение сотрудника;\n"
|
||
if centers
|
||
else ""
|
||
)
|
||
sto_business_help = (
|
||
"СТО: прими заявку, создай заказ-наряд, добавь работы/товары/жидкости, отправь владельцу на согласование и закрой работу после выполнения.\n"
|
||
if centers
|
||
else ""
|
||
)
|
||
await message.answer(
|
||
"CarPass помогает вести цифровой паспорт автомобиля.\n\n"
|
||
"Главное:\n"
|
||
"• /garage — список автомобилей;\n"
|
||
"• /add_car Название — быстро добавить авто;\n"
|
||
"• /fuel — заправка, включая полный бак;\n"
|
||
"• /service — ТО и ремонт;\n"
|
||
"• /insurance, /tax, /fine — регулярные и разовые расходы;\n"
|
||
"• /analytics — стоимость владения и расход;\n"
|
||
"• /sto — каталог проверенных СТО;\n"
|
||
"• /appointments — мои записи в СТО;\n"
|
||
f"{sto_workplace_help}"
|
||
f"{admin_help}"
|
||
"\n"
|
||
"Владелец: добавь авто, выбери проверенное СТО, создай запись, согласуй заказ-наряд и смотри завершенные работы в истории автомобиля.\n"
|
||
f"{sto_business_help}"
|
||
"Безопасность: СТО видит автомобиль только после подтверждения владельца, а спорные изменения VIN, номера и пробега идут через согласование.\n\n"
|
||
"Mini App открывай только кнопкой под сообщением: Telegram передает initData, и авторизация проходит корректно.",
|
||
reply_markup=menu_inline_keyboard(include_sto_workplace=bool(centers)),
|
||
)
|
||
|
||
|
||
@dp.message(F.text == "Открыть CarPass")
|
||
@dp.message(F.text == "Открыть гараж")
|
||
async def old_open_buttons(message: Message) -> None:
|
||
await message.answer(
|
||
"Эта кнопка больше не используется как ReplyButton. Открой CarPass через защищенную кнопку ниже.",
|
||
reply_markup=webapp_inline_keyboard(),
|
||
)
|
||
|
||
|
||
@dp.message(F.text)
|
||
async def parse_free_text(message: Message) -> None:
|
||
if message.text.startswith("/"):
|
||
return
|
||
parsed = await api.parse_record(message.from_user.id, message.text)
|
||
if parsed.get("event_type") == "unknown" or parsed.get("confidence", 0) < 0.55:
|
||
await message.answer("Не понял запись. Открой /menu или Mini App, там все формы под рукой.", reply_markup=menu_inline_keyboard())
|
||
return
|
||
await create_record_from_parsed(message, parsed)
|
||
|
||
|
||
async def create_record_from_text(message: Message, text: str, expected: str | None = None) -> None:
|
||
parsed = await api.parse_record(message.from_user.id, text)
|
||
if expected and parsed.get("event_type") != expected:
|
||
parsed["event_type"] = expected
|
||
await create_record_from_parsed(message, parsed)
|
||
|
||
|
||
async def create_record_from_parsed(message: Message, parsed: dict) -> None:
|
||
car = await require_one_car(message)
|
||
if not car:
|
||
return
|
||
data = parsed.get("data", {})
|
||
event_type = parsed.get("event_type")
|
||
try:
|
||
if event_type == "fuel":
|
||
missing = [field for field in ("fuel_liters", "amount", "odometer_km") if not data.get(field)]
|
||
if missing:
|
||
await message.answer("Для заправки нужны литры, сумма и пробег. Открой форму, чтобы не ошибиться.", reply_markup=webapp_inline_keyboard("Добавить заправку"))
|
||
return
|
||
await api.create_fuel(
|
||
message.from_user.id,
|
||
{
|
||
"car_id": car["id"],
|
||
"entry_date": date.today().isoformat(),
|
||
"odometer": int(data["odometer_km"]),
|
||
"liters": float(data["fuel_liters"]),
|
||
"price_per_liter": float(data["price_per_liter"] or Decimal(str(data["amount"])) / Decimal(str(data["fuel_liters"]))),
|
||
"total_cost": float(data["amount"]),
|
||
"is_full_tank": data.get("is_full_tank"),
|
||
},
|
||
)
|
||
await message.answer("Заправка сохранена.")
|
||
elif event_type == "service":
|
||
await api.create_service(
|
||
message.from_user.id,
|
||
{
|
||
"car_id": car["id"],
|
||
"entry_date": date.today().isoformat(),
|
||
"odometer": data.get("odometer_km"),
|
||
"service_type": data.get("service_type") or "maintenance",
|
||
"title": data.get("title") or "Сервисная запись",
|
||
"total_cost": float(data.get("amount") or 0),
|
||
},
|
||
)
|
||
await message.answer("Сервисная запись сохранена.")
|
||
elif event_type in {"insurance", "tax", "fine"}:
|
||
await api.create_expense(
|
||
message.from_user.id,
|
||
{
|
||
"car_id": car["id"],
|
||
"entry_date": date.today().isoformat(),
|
||
"category": event_type,
|
||
"title": {"insurance": "Страховка", "tax": "Налог", "fine": "Штраф"}[event_type],
|
||
"total_cost": float(data.get("amount") or 0),
|
||
"currency": data.get("currency") or "RUB",
|
||
"is_recurring": event_type in {"insurance", "tax"},
|
||
},
|
||
)
|
||
await message.answer("Расход сохранен.")
|
||
else:
|
||
await message.answer("Эту запись лучше проверить в Mini App перед сохранением.", reply_markup=webapp_inline_keyboard("Открыть форму"))
|
||
except httpx.HTTPStatusError as error:
|
||
await message.answer(f"Запись не сохранена: {error.response.text}")
|
||
|
||
|
||
async def main() -> None:
|
||
if not settings.bot_token:
|
||
raise RuntimeError("BOT_TOKEN is empty")
|
||
if not settings.internal_api_token:
|
||
raise RuntimeError("INTERNAL_API_TOKEN is empty")
|
||
settings.validate_webapp_url_for_telegram()
|
||
bot = Bot(settings.bot_token)
|
||
try:
|
||
await dp.start_polling(bot)
|
||
finally:
|
||
await api.close()
|
||
await bot.session.close()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
asyncio.run(main())
|