1638 lines
84 KiB
Python
1638 lines
84 KiB
Python
import asyncio
|
||
from os import getenv
|
||
import logging
|
||
from datetime import datetime
|
||
import platform
|
||
import os
|
||
from logging.handlers import TimedRotatingFileHandler
|
||
|
||
from aiogram import Bot, Dispatcher
|
||
from aiogram.filters import Command
|
||
from aiogram.types import Message, InlineKeyboardButton, InlineKeyboardMarkup, CallbackQuery, LabeledPrice, PreCheckoutQuery, InputMediaPhoto, FSInputFile
|
||
from aiogram.utils.keyboard import InlineKeyboardBuilder
|
||
from aiogram.fsm.state import State, StatesGroup
|
||
from aiogram.fsm.context import FSMContext
|
||
from db import OracleDatabase
|
||
from middlewares.db import DbSessionMiddleware
|
||
|
||
|
||
def setup_logging():
|
||
"""
|
||
Настройка системы логирования с ротацией файлов и выводом в консоль
|
||
"""
|
||
# Создаем каталог logs если он не существует
|
||
if is_windows():
|
||
logs_dir = "logs"
|
||
else:
|
||
logs_dir = "/logs/"
|
||
if not os.path.exists(logs_dir):
|
||
os.makedirs(logs_dir)
|
||
print(f"Created logs directory: {logs_dir}")
|
||
|
||
# Определяем уровень логирования
|
||
if getenv("DEBUG", '0') == '1':
|
||
log_level = logging.INFO
|
||
else:
|
||
log_level = logging.WARNING
|
||
|
||
# Временно включаем детальное логирование для отладки
|
||
log_level = logging.INFO
|
||
|
||
# Создаем основной логгер
|
||
logger = logging.getLogger()
|
||
logger.setLevel(log_level)
|
||
|
||
# Очищаем существующие обработчики
|
||
logger.handlers.clear()
|
||
|
||
# Формат логов
|
||
formatter = logging.Formatter(
|
||
'%(asctime)s - %(name)s - %(levelname)s - %(message)s',
|
||
datefmt='%Y-%m-%d %H:%M:%S'
|
||
)
|
||
|
||
# Настройка файлового логирования с ротацией
|
||
file_handler = TimedRotatingFileHandler(
|
||
filename=os.path.join(logs_dir, "salvagedb_bot.log"),
|
||
when='midnight', # Ротация в полночь
|
||
interval=1, # Каждый день
|
||
backupCount=30, # Храним 30 дней
|
||
encoding='utf-8',
|
||
utc=False # Используем локальное время
|
||
)
|
||
file_handler.setLevel(log_level)
|
||
file_handler.setFormatter(formatter)
|
||
file_handler.suffix = "%Y-%m-%d" # Формат суффикса для файлов
|
||
|
||
# Настройка консольного логирования
|
||
console_handler = logging.StreamHandler()
|
||
console_handler.setLevel(log_level)
|
||
console_handler.setFormatter(formatter)
|
||
|
||
# Добавляем обработчики к логгеру
|
||
logger.addHandler(file_handler)
|
||
logger.addHandler(console_handler)
|
||
|
||
# Логируем успешную настройку
|
||
logging.info("=== LOGGING SYSTEM INITIALIZED ===")
|
||
logging.info(f"Log level: {logging.getLevelName(log_level)}")
|
||
logging.info(f"Logs directory: {os.path.abspath(logs_dir)}")
|
||
logging.info(f"Log rotation: daily, keeping 30 days")
|
||
|
||
# Проверяем запуск в Docker
|
||
if os.path.exists('/.dockerenv'):
|
||
logging.info("Running inside Docker container")
|
||
logging.info(f"Container timezone: {getenv('TZ', 'UTC')}")
|
||
logging.info(f"Container user: {getenv('USER', 'unknown')}")
|
||
else:
|
||
logging.info("Running on host system")
|
||
|
||
logging.info("=== LOGGING SETUP COMPLETE ===")
|
||
|
||
|
||
def get_us_state_name(state_code: str) -> str:
|
||
"""
|
||
Конвертирует двухбуквенный код штата США в полное название
|
||
"""
|
||
states = {
|
||
'AL': 'Alabama', 'AK': 'Alaska', 'AZ': 'Arizona', 'AR': 'Arkansas', 'CA': 'California',
|
||
'CO': 'Colorado', 'CT': 'Connecticut', 'DE': 'Delaware', 'FL': 'Florida', 'GA': 'Georgia',
|
||
'HI': 'Hawaii', 'ID': 'Idaho', 'IL': 'Illinois', 'IN': 'Indiana', 'IA': 'Iowa',
|
||
'KS': 'Kansas', 'KY': 'Kentucky', 'LA': 'Louisiana', 'ME': 'Maine', 'MD': 'Maryland',
|
||
'MA': 'Massachusetts', 'MI': 'Michigan', 'MN': 'Minnesota', 'MS': 'Mississippi', 'MO': 'Missouri',
|
||
'MT': 'Montana', 'NE': 'Nebraska', 'NV': 'Nevada', 'NH': 'New Hampshire', 'NJ': 'New Jersey',
|
||
'NM': 'New Mexico', 'NY': 'New York', 'NC': 'North Carolina', 'ND': 'North Dakota', 'OH': 'Ohio',
|
||
'OK': 'Oklahoma', 'OR': 'Oregon', 'PA': 'Pennsylvania', 'RI': 'Rhode Island', 'SC': 'South Carolina',
|
||
'SD': 'South Dakota', 'TN': 'Tennessee', 'TX': 'Texas', 'UT': 'Utah', 'VT': 'Vermont',
|
||
'VA': 'Virginia', 'WA': 'Washington', 'WV': 'West Virginia', 'WI': 'Wisconsin', 'WY': 'Wyoming',
|
||
'DC': 'District of Columbia'
|
||
}
|
||
return states.get(state_code.upper(), state_code)
|
||
|
||
|
||
def format_sale_date(date_str: str) -> str:
|
||
"""
|
||
Форматирует дату продажи из MM/YYYY в красивый формат
|
||
"""
|
||
if not date_str or date_str == 'None' or '/' not in date_str:
|
||
return "Unknown"
|
||
|
||
try:
|
||
month, year = date_str.split('/')
|
||
months = {
|
||
'1': 'January', '2': 'February', '3': 'March', '4': 'April',
|
||
'5': 'May', '6': 'June', '7': 'July', '8': 'August',
|
||
'9': 'September', '10': 'October', '11': 'November', '12': 'December'
|
||
}
|
||
month_name = months.get(month.lstrip('0'), month)
|
||
return f"{month_name} {year}"
|
||
except:
|
||
return date_str
|
||
|
||
|
||
def parse_location(location_str: str) -> str:
|
||
r"""
|
||
Парсит и форматирует локацию из формата ST/TOWN или ST\TOWN
|
||
"""
|
||
if not location_str or location_str == 'None':
|
||
return "Unknown Location"
|
||
|
||
try:
|
||
# Проверяем оба варианта разделителей: / и \
|
||
if '/' in location_str:
|
||
state_code, city = location_str.split('/', 1)
|
||
state_name = get_us_state_name(state_code.strip())
|
||
city_formatted = city.strip().title()
|
||
return f"{city_formatted}, {state_name}"
|
||
elif '\\' in location_str:
|
||
state_code, city = location_str.split('\\', 1)
|
||
state_name = get_us_state_name(state_code.strip())
|
||
city_formatted = city.strip().title()
|
||
return f"{city_formatted}, {state_name}"
|
||
else:
|
||
return location_str
|
||
except:
|
||
return location_str
|
||
|
||
|
||
def escape_markdown(text: str) -> str:
|
||
"""
|
||
Экранирует специальные символы Markdown для безопасной отправки в Telegram
|
||
"""
|
||
if not text:
|
||
return ""
|
||
|
||
# Символы которые нужно экранировать для Markdown
|
||
escape_chars = ['*', '_', '[', ']', '(', ')', '~', '`', '>', '#', '+', '-', '=', '|', '{', '}', '.', '!']
|
||
|
||
escaped_text = str(text)
|
||
for char in escape_chars:
|
||
escaped_text = escaped_text.replace(char, f'\\{char}')
|
||
|
||
return escaped_text
|
||
|
||
|
||
def get_operating_system() -> str:
|
||
"""
|
||
Определяет операционную систему на которой запущен код
|
||
Returns:
|
||
str: 'Windows', 'Linux', 'macOS' или 'Unknown'
|
||
"""
|
||
system = platform.system().lower()
|
||
|
||
if system == 'windows':
|
||
return 'Windows'
|
||
elif system == 'linux':
|
||
return 'Linux'
|
||
elif system == 'darwin':
|
||
return 'macOS'
|
||
else:
|
||
return f'Unknown ({system})'
|
||
|
||
|
||
def log_system_info():
|
||
"""
|
||
Логирует информацию о системе при запуске
|
||
"""
|
||
os_name = get_operating_system()
|
||
python_version = platform.python_version()
|
||
architecture = platform.machine()
|
||
|
||
logging.info(f"=== SYSTEM INFORMATION ===")
|
||
logging.info(f"Operating System: {os_name}")
|
||
logging.info(f"Platform: {platform.platform()}")
|
||
logging.info(f"Python Version: {python_version}")
|
||
logging.info(f"Architecture: {architecture}")
|
||
logging.info(f"Node Name: {platform.node()}")
|
||
logging.info(f"os.name: {os.name}")
|
||
logging.info(f"=== END SYSTEM INFO ===")
|
||
|
||
|
||
def is_windows() -> bool:
|
||
"""Проверяет, запущен ли код на Windows"""
|
||
return get_operating_system() == 'Windows'
|
||
|
||
|
||
def is_linux() -> bool:
|
||
"""Проверяет, запущен ли код на Linux"""
|
||
return get_operating_system() == 'Linux'
|
||
|
||
|
||
def is_macos() -> bool:
|
||
"""Проверяет, запущен ли код на macOS"""
|
||
return get_operating_system() == 'macOS'
|
||
|
||
|
||
def convert_photo_path(db_path: str) -> str:
|
||
"""
|
||
Конвертирует путь к фотографии в зависимости от операционной системы
|
||
Args:
|
||
db_path: путь из базы данных в Linux формате (с /)
|
||
Returns:
|
||
str: полный путь к файлу с учетом OS и базового пути
|
||
"""
|
||
if not db_path:
|
||
return ""
|
||
|
||
# Базовый путь из константы
|
||
base_path = image_path
|
||
|
||
if is_windows():
|
||
# Конвертируем Linux пути в Windows формат
|
||
windows_path = db_path.replace('/', '\\')
|
||
full_path = f"{base_path}\\{windows_path}"
|
||
logging.info(f"Converted path for Windows: {db_path} -> {full_path}")
|
||
return full_path
|
||
else:
|
||
# Для Linux/macOS оставляем как есть
|
||
full_path = f"{base_path}/{db_path}"
|
||
logging.info(f"Path for Linux/macOS: {db_path} -> {full_path}")
|
||
return full_path
|
||
|
||
|
||
def prepare_photo_paths(db_paths: list) -> list:
|
||
"""
|
||
Подготавливает список полных путей к фотографиям
|
||
Args:
|
||
db_paths: список путей из базы данных
|
||
Returns:
|
||
list: список полных путей к файлам
|
||
"""
|
||
if not db_paths:
|
||
return []
|
||
|
||
full_paths = []
|
||
for db_path in db_paths:
|
||
full_path = convert_photo_path(db_path)
|
||
if full_path:
|
||
full_paths.append(full_path)
|
||
|
||
logging.info(f"Prepared {len(full_paths)} photo paths from {len(db_paths)} database paths")
|
||
return full_paths
|
||
|
||
|
||
async def send_vehicle_photos(message: Message, vin: str, photo_paths: list, make: str, model: str, year: str):
|
||
"""
|
||
Отправляет фотографии автомобиля пользователю
|
||
Args:
|
||
message: сообщение пользователя
|
||
vin: VIN автомобиля
|
||
photo_paths: список полных путей к фотографиям
|
||
make, model, year: информация об автомобиле
|
||
"""
|
||
if not photo_paths:
|
||
await message.answer("❌ No photos found to send.")
|
||
return
|
||
|
||
try:
|
||
# Telegram позволяет максимум 10 фотографий в media group
|
||
photos_per_group = 10
|
||
total_photos = len(photo_paths)
|
||
|
||
logging.info(f"Attempting to send {total_photos} photos for VIN: {vin}")
|
||
|
||
# Разбиваем фотографии на группы по 10
|
||
photo_groups = [photo_paths[i:i + photos_per_group] for i in range(0, len(photo_paths), photos_per_group)]
|
||
total_groups = len(photo_groups)
|
||
|
||
logging.info(f"Split {total_photos} photos into {total_groups} groups")
|
||
|
||
sent_count = 0
|
||
|
||
for group_num, photo_group in enumerate(photo_groups, 1):
|
||
try:
|
||
logging.info(f"Processing group {group_num}/{total_groups} with {len(photo_group)} photos")
|
||
|
||
# Создаем media group для текущей группы
|
||
media_group = []
|
||
|
||
for i, photo_path in enumerate(photo_group):
|
||
try:
|
||
# Проверяем существование файла
|
||
if os.path.exists(photo_path):
|
||
# Создаем InputMediaPhoto
|
||
if i == 0 and group_num == 1:
|
||
# Первая фотография первой группы с полным описанием
|
||
if make == "UNKNOWN" and model == "UNKNOWN" and year == "UNKNOWN":
|
||
caption = f"📸 Vehicle damage photos\n📋 VIN: {vin}\n📊 Total photos: {total_photos}\n🗂️ Group {group_num}/{total_groups}"
|
||
else:
|
||
caption = f"📸 {year} {make} {model}\n📋 VIN: {vin}\n📊 Total photos: {total_photos}\n🗂️ Group {group_num}/{total_groups}"
|
||
elif i == 0:
|
||
# Первая фотография других групп с номером группы
|
||
caption = f"🗂️ Group {group_num}/{total_groups}"
|
||
else:
|
||
# Остальные фотографии без описания
|
||
caption = None
|
||
|
||
if caption:
|
||
media_group.append(InputMediaPhoto(
|
||
media=FSInputFile(photo_path),
|
||
caption=caption
|
||
))
|
||
else:
|
||
media_group.append(InputMediaPhoto(
|
||
media=FSInputFile(photo_path)
|
||
))
|
||
|
||
sent_count += 1
|
||
logging.info(f"Added photo {sent_count}/{total_photos}: {photo_path}")
|
||
else:
|
||
logging.warning(f"Photo file not found: {photo_path}")
|
||
except Exception as photo_error:
|
||
logging.error(f"Error processing photo {sent_count + 1} ({photo_path}): {photo_error}")
|
||
continue
|
||
|
||
if media_group:
|
||
# Отправляем media group
|
||
await message.answer_media_group(media_group)
|
||
logging.info(f"Successfully sent group {group_num}/{total_groups} with {len(media_group)} photos")
|
||
|
||
# Небольшая пауза между группами для избежания rate limiting
|
||
if group_num < total_groups:
|
||
await asyncio.sleep(0.5)
|
||
else:
|
||
logging.warning(f"No valid photos in group {group_num}")
|
||
|
||
except Exception as group_error:
|
||
logging.error(f"Error sending photo group {group_num}: {group_error}")
|
||
await message.answer(f"❌ Error sending photo group {group_num}. Continuing with remaining photos...")
|
||
continue
|
||
|
||
if sent_count > 0:
|
||
# Отправляем итоговое сообщение
|
||
await message.answer(
|
||
f"✅ **Photos sent successfully!**\n"
|
||
f"📊 **{sent_count} of {total_photos} photos** delivered\n"
|
||
f"🗂️ **{total_groups} photo groups** sent"
|
||
)
|
||
logging.info(f"Successfully sent {sent_count}/{total_photos} photos for VIN: {vin}")
|
||
else:
|
||
# Если ни одна фотография не найдена
|
||
await message.answer(
|
||
"❌ **Error:** Photo files not found on server.\n"
|
||
"Please contact support with your transaction details."
|
||
)
|
||
logging.error(f"No valid photo files found for VIN: {vin}")
|
||
|
||
except Exception as e:
|
||
logging.error(f"Error sending photos for VIN {vin}: {e}")
|
||
await message.answer(
|
||
"❌ **Error sending photos.** Please contact support with your transaction details.\n"
|
||
f"Error details: {str(e)}"
|
||
)
|
||
|
||
|
||
# Настройка системы логирования
|
||
setup_logging()
|
||
|
||
# Логируем информацию о системе
|
||
log_system_info()
|
||
|
||
|
||
TOKEN = getenv("BOT_TOKEN")
|
||
BOTNAME = getenv("BOT_NAME")
|
||
DECODE_PRICE = getenv("DECODE_PRICE",1)
|
||
CHECK_PRICE = getenv("CHECK_PRICE",10)
|
||
IMG_PRICE = getenv("IMG_PRICE",100)
|
||
|
||
|
||
if is_windows():
|
||
image_path = "D:\\SALVAGEDB\\salvagedb_bot\\images"
|
||
else:
|
||
image_path = "/images"
|
||
|
||
|
||
oracle_db = OracleDatabase(
|
||
user= getenv("DB_USER"),
|
||
password= getenv("DB_PASSWORD"),
|
||
dsn= getenv("DB_DSN")
|
||
)
|
||
|
||
|
||
dp = Dispatcher()
|
||
|
||
class VinStates(StatesGroup):
|
||
waiting_for_vin = State()
|
||
waiting_for_check_vin = State()
|
||
waiting_for_photo_vin = State()
|
||
|
||
|
||
# Command handler
|
||
@dp.message(Command("start"))
|
||
async def command_start_handler(message: Message, db: OracleDatabase = None) -> None:
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при каждом взаимодействии
|
||
await database.save_user(message.from_user, "start_command")
|
||
|
||
welcome_text = (
|
||
"Welcome to SalvagedbBot — your trusted assistant for vehicle history checks via VIN!\n\n"
|
||
"🔍 What You Can Discover:\n\n"
|
||
"• Salvage or junk status\n"
|
||
"• Damage from hail, flood, or fire\n"
|
||
"• Mileage discrepancies or odometer rollback\n"
|
||
"• Gray market vehicle status\n\n"
|
||
"We don't claim that a vehicle has a salvage title, but we provide information indicating possible past damages, helping you make informed decisions."
|
||
)
|
||
builder = InlineKeyboardBuilder()
|
||
builder.button(text="Decode VIN", callback_data="decode_vin")
|
||
builder.button(text="Check VIN", callback_data="check_vin")
|
||
builder.button(text="Search car Photo", callback_data="search_car_photo")
|
||
builder.adjust(3)
|
||
builder.button(text="Help", callback_data="help")
|
||
builder.button(text="Prices", callback_data="prices")
|
||
builder.button(text="Go Salvagedb.com", url="https://salvagedb.com")
|
||
builder.adjust(3, 2)
|
||
await message.answer(welcome_text, reply_markup=builder.as_markup())
|
||
|
||
|
||
@dp.callback_query(lambda c: c.data == "decode_vin")
|
||
async def decode_vin_callback(callback: CallbackQuery, state: FSMContext, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при нажатии кнопки
|
||
await database.save_user(callback.from_user, "decode_vin_button")
|
||
|
||
await callback.message.answer("Please enter the vehicle VIN.")
|
||
await state.set_state(VinStates.waiting_for_vin)
|
||
await callback.answer()
|
||
|
||
|
||
@dp.callback_query(lambda c: c.data == "check_vin")
|
||
async def check_vin_callback(callback: CallbackQuery, state: FSMContext, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при нажатии кнопки
|
||
await database.save_user(callback.from_user, "check_vin_button")
|
||
|
||
await callback.message.answer("Please enter the vehicle VIN to check salvage records.")
|
||
await state.set_state(VinStates.waiting_for_check_vin)
|
||
await callback.answer()
|
||
|
||
|
||
@dp.callback_query(lambda c: c.data == "search_car_photo")
|
||
async def search_car_photo_callback(callback: CallbackQuery, state: FSMContext, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при нажатии кнопки
|
||
await database.save_user(callback.from_user, "search_car_photo_button")
|
||
|
||
await callback.message.answer("Please enter the vehicle VIN to search for damage photos.")
|
||
await state.set_state(VinStates.waiting_for_photo_vin)
|
||
await callback.answer()
|
||
|
||
|
||
@dp.callback_query(lambda c: c.data == "main_menu")
|
||
async def main_menu_callback(callback: CallbackQuery, state: FSMContext, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при возврате в главное меню
|
||
await database.save_user(callback.from_user, "main_menu_button")
|
||
|
||
await state.clear()
|
||
await command_start_handler(callback.message, database)
|
||
await callback.answer()
|
||
|
||
|
||
@dp.callback_query(lambda c: c.data == "help")
|
||
async def help_callback(callback: CallbackQuery, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при просмотре справки
|
||
await database.save_user(callback.from_user, "help_button")
|
||
|
||
help_text = (
|
||
"ℹ️ **Help - Our Services**\n\n"
|
||
|
||
"🔍 **1. Decode VIN**\n"
|
||
f"• Free basic vehicle information (make, model, year)\n"
|
||
f"• Detailed specifications for {DECODE_PRICE} ⭐ (engine, transmission, safety features, etc.)\n"
|
||
f"• Comprehensive technical data from NHTSA database\n\n"
|
||
|
||
"🚨 **2. Check VIN**\n"
|
||
f"• Free salvage records count\n"
|
||
f"• Detailed damage history for {CHECK_PRICE} ⭐ (auction data, damage types, repair costs)\n"
|
||
f"• Sale dates and locations from insurance auctions\n\n"
|
||
|
||
"📸 **3. Search Car Photos**\n"
|
||
f"• Check availability of damage photos\n"
|
||
f"• Access to actual auction photos for {IMG_PRICE} ⭐\n"
|
||
f"• High-quality images showing vehicle condition and damage\n\n"
|
||
|
||
"💡 **How to use:**\n"
|
||
"• Enter any 17-character VIN number\n"
|
||
"• VIN must contain only letters and numbers (no I, O, Q)\n"
|
||
"• All payments are made with Telegram Stars ⭐\n\n"
|
||
|
||
"⚠️ **Important:** Our reports show historical data for informed decision-making. "
|
||
"Always consult automotive experts for professional vehicle evaluation."
|
||
)
|
||
|
||
builder = InlineKeyboardBuilder()
|
||
builder.button(text="🔍 Try Decode VIN", callback_data="decode_vin")
|
||
builder.button(text="🚨 Try Check VIN", callback_data="check_vin")
|
||
builder.button(text="📸 Try Search Photos", callback_data="search_car_photo")
|
||
builder.adjust(3)
|
||
builder.button(text="🏠 Back to Main Menu", callback_data="main_menu")
|
||
builder.adjust(3, 1)
|
||
|
||
await callback.message.answer(help_text, reply_markup=builder.as_markup(), parse_mode="Markdown")
|
||
await callback.answer()
|
||
|
||
|
||
@dp.callback_query(lambda c: c.data == "prices")
|
||
async def prices_callback(callback: CallbackQuery, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при просмотре цен
|
||
await database.save_user(callback.from_user, "prices_button")
|
||
|
||
prices_text = (
|
||
"💰 **Our Service Prices**\n\n"
|
||
|
||
"🔍 **VIN Decoding Service:**\n"
|
||
f"• Basic info (make, model, year): **FREE** 🆓\n"
|
||
f"• Detailed specifications: **{DECODE_PRICE} ⭐**\n"
|
||
f" └ Engine details, transmission, safety features\n"
|
||
f" └ Dimensions, construction, brake system\n"
|
||
f" └ Lighting, additional features, NCSA data\n\n"
|
||
|
||
"🚨 **Salvage Check Service:**\n"
|
||
f"• Records count check: **FREE** 🆓\n"
|
||
f"• Detailed damage history: **{CHECK_PRICE} ⭐**\n"
|
||
f" └ Primary and secondary damage types\n"
|
||
f" └ Sale dates and auction locations\n"
|
||
f" └ Odometer readings and repair costs\n"
|
||
f" └ Engine/drive status information\n\n"
|
||
|
||
"📸 **Vehicle Photos Service:**\n"
|
||
f"• Photo availability check: **FREE** 🆓\n"
|
||
f"• Access to damage photos: **{IMG_PRICE} ⭐**\n"
|
||
f" └ High-quality auction images\n"
|
||
f" └ Multiple angles of vehicle damage\n"
|
||
f" └ Before and after condition photos\n\n"
|
||
|
||
"⭐ **Payment Information:**\n"
|
||
"• All payments made with **Telegram Stars**\n"
|
||
"• Instant delivery after successful payment\n"
|
||
"• Automatic refund if no data found\n"
|
||
"• Admin users get automatic refunds\n\n"
|
||
|
||
"💡 **Money-back guarantee:** If we can't provide the requested data, "
|
||
"your payment will be automatically refunded!"
|
||
)
|
||
|
||
builder = InlineKeyboardBuilder()
|
||
builder.button(text=f"🔍 Decode for {DECODE_PRICE} ⭐", callback_data="decode_vin")
|
||
builder.button(text=f"🚨 Check for {CHECK_PRICE} ⭐", callback_data="check_vin")
|
||
builder.button(text=f"📸 Photos for {IMG_PRICE} ⭐", callback_data="search_car_photo")
|
||
builder.adjust(3)
|
||
builder.button(text="ℹ️ Help", callback_data="help")
|
||
builder.button(text="🏠 Back to Main Menu", callback_data="main_menu")
|
||
builder.adjust(2, 1)
|
||
|
||
await callback.message.answer(prices_text, reply_markup=builder.as_markup(), parse_mode="Markdown")
|
||
await callback.answer()
|
||
|
||
|
||
@dp.callback_query(lambda c: c.data and c.data.startswith("pay_detailed_info:"))
|
||
async def pay_detailed_info_callback(callback: CallbackQuery, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при инициации платежа
|
||
await database.save_user(callback.from_user, "payment_initiation")
|
||
|
||
# Extract VIN from callback data
|
||
vin = callback.data.split(":")[1]
|
||
prices = [LabeledPrice(label="Detailed VIN Report", amount=DECODE_PRICE)]
|
||
logging.info(f"Sending invoice for VIN: {vin}")
|
||
await callback.bot.send_invoice(
|
||
chat_id=callback.message.chat.id,
|
||
title="Detailed VIN Information",
|
||
description=f"Get comprehensive vehicle detailed information for {DECODE_PRICE} Telegram Star",
|
||
payload=f"detailed_vin_info:{vin}", # Include VIN in payload
|
||
provider_token="", # Empty for Telegram Stars
|
||
currency="XTR", # Telegram Stars currency
|
||
prices=prices
|
||
)
|
||
await callback.answer()
|
||
|
||
|
||
@dp.message(VinStates.waiting_for_vin)
|
||
async def process_vin(message: Message, state: FSMContext, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при обработке VIN
|
||
await database.save_user(message.from_user, "vin_processing")
|
||
|
||
vin = message.text.strip().upper()
|
||
if len(vin) == 17 and vin.isalnum() and all(c not in vin for c in ["I", "O", "Q"]):
|
||
try:
|
||
make, model, year, cnt = await database.fetch_vin_info(vin)
|
||
logging.info(f"Decode VIN 1st step: make: {make}, model: {model}, year: {year}, cnt: {cnt}")
|
||
logging.info(f"VIN decode check: make==UNKNOWN: {make == 'UNKNOWN'}, model==UNKNOWN: {model == 'UNKNOWN'}, year==UNKNOWN: {year == 'UNKNOWN'}")
|
||
logging.info(f"All UNKNOWN check: {make == 'UNKNOWN' and model == 'UNKNOWN' and year == 'UNKNOWN'}")
|
||
logging.info(f"cnt == 0 check: {cnt == 0}")
|
||
|
||
# Формируем текст ответа
|
||
if make == "UNKNOWN" and model == "UNKNOWN" and year == "UNKNOWN":
|
||
logging.info("Setting response_text to 'Unable to decode VIN' because all fields are UNKNOWN")
|
||
response_text = "❌ **Unable to decode VIN, possibly incorrect**"
|
||
else:
|
||
logging.info(f"VIN successfully decoded! Setting response_text to car info: {year} {make} {model}")
|
||
response_text = f"🚗 **{year} {make} {model}**\n\n"
|
||
|
||
# Create keyboard based on cnt value
|
||
builder = InlineKeyboardBuilder()
|
||
builder.button(text="Try another VIN", callback_data="decode_vin")
|
||
builder.button(text="Back to Main Menu", callback_data="main_menu")
|
||
|
||
if cnt > 9 and not (make == "UNKNOWN" and model == "UNKNOWN" and year == "UNKNOWN"):
|
||
logging.info("Adding detailed info button because cnt > 9 and VIN is decoded")
|
||
builder.button(text=f"Get detailed info. Pay {DECODE_PRICE} ⭐️", callback_data=f"pay_detailed_info:{vin}", pay=True)
|
||
builder.adjust(1, 1, 1) # Each button on separate row
|
||
else:
|
||
logging.info(f"Not adding detailed info button because cnt <= 9 (cnt={cnt}) or VIN not decoded")
|
||
builder.adjust(1, 1) # Each button on separate row
|
||
|
||
logging.info(f"Final response_text before sending in decode VIN: '{response_text}'")
|
||
logging.info(f"Response text length: {len(response_text)}")
|
||
await message.answer(response_text, reply_markup=builder.as_markup(), parse_mode="Markdown")
|
||
|
||
except Exception as e:
|
||
logging.error(f"Database error for VIN {vin}: {e}")
|
||
await message.answer("Error retrieving data from database. Please try again later.")
|
||
await state.clear()
|
||
else:
|
||
await message.answer("Invalid VIN. Please enter a valid 17-character VIN (letters and numbers, no I, O, Q).")
|
||
|
||
|
||
@dp.message(VinStates.waiting_for_check_vin)
|
||
async def process_check_vin(message: Message, state: FSMContext, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при обработке VIN
|
||
await database.save_user(message.from_user, "check_vin_processing")
|
||
|
||
vin = message.text.strip().upper()
|
||
if len(vin) == 17 and vin.isalnum() and all(c not in vin for c in ["I", "O", "Q"]):
|
||
try:
|
||
# Получаем базовую информацию о VIN
|
||
make, model, year, cnt = await database.fetch_vin_info(vin)
|
||
|
||
# Получаем количество записей в salvagedb.salvagedb
|
||
salvage_count = await database.count_salvage_records(vin)
|
||
|
||
logging.info(f"Check VIN: make: {make}, model: {model}, year: {year}, cnt: {cnt}, salvage_count: {salvage_count}")
|
||
logging.info(f"VIN decode check: make==UNKNOWN: {make == 'UNKNOWN'}, model==UNKNOWN: {model == 'UNKNOWN'}, year==UNKNOWN: {year == 'UNKNOWN'}")
|
||
logging.info(f"All UNKNOWN check: {make == 'UNKNOWN' and model == 'UNKNOWN' and year == 'UNKNOWN'}")
|
||
logging.info(f"cnt == 0 check: {cnt == 0}")
|
||
|
||
# Формируем текст ответа
|
||
if make == "UNKNOWN" and model == "UNKNOWN" and year == "UNKNOWN":
|
||
logging.info("Setting response_text to 'Unable to decode VIN' because all fields are UNKNOWN")
|
||
response_text = "❌ **Unable to decode VIN, possibly incorrect**\n\n"
|
||
else:
|
||
logging.info(f"VIN successfully decoded! Setting response_text to car info: {year} {make} {model}")
|
||
response_text = f"🚗 **{year} {make} {model}**\n\n"
|
||
|
||
response_text += f"📊 **Records found in database:** {salvage_count}\n\n"
|
||
|
||
# Создаем клавиатуру в зависимости от наличия записей
|
||
builder = InlineKeyboardBuilder()
|
||
|
||
if salvage_count > 0:
|
||
# Есть записи - показываем кнопки: Pay 10⭐️ for detailed info, Try another VIN, Back to main menu
|
||
builder.button(text=f"Pay {CHECK_PRICE} ⭐️ for detailed info", callback_data=f"pay_check_detailed:{vin}", pay=True)
|
||
builder.button(text="Try another VIN", callback_data="check_vin")
|
||
builder.button(text="Back to Main Menu", callback_data="main_menu")
|
||
builder.adjust(1, 1, 1) # Each button on separate row
|
||
else:
|
||
# Нет записей - показываем кнопки: Try another VIN, Back to main menu
|
||
response_text += "ℹ️ **No salvage records found for this VIN**"
|
||
builder.button(text="Try another VIN", callback_data="check_vin")
|
||
builder.button(text="Back to Main Menu", callback_data="main_menu")
|
||
builder.adjust(1, 1) # Each button on separate row
|
||
|
||
logging.info(f"Final response_text before sending: '{response_text}'")
|
||
logging.info(f"Response text length: {len(response_text)}")
|
||
await message.answer(response_text, reply_markup=builder.as_markup(), parse_mode="Markdown")
|
||
|
||
except Exception as e:
|
||
logging.error(f"Database error for check VIN {vin}: {e}")
|
||
await message.answer("Error retrieving data from database. Please try again later.")
|
||
await state.clear()
|
||
else:
|
||
await message.answer("Invalid VIN. Please enter a valid 17-character VIN (letters and numbers, no I, O, Q).")
|
||
|
||
|
||
@dp.callback_query(lambda c: c.data and c.data.startswith("pay_check_detailed:"))
|
||
async def pay_check_detailed_callback(callback: CallbackQuery, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при инициации платежа
|
||
await database.save_user(callback.from_user, "check_payment_initiation")
|
||
|
||
# Извлекаем VIN из callback data
|
||
vin = callback.data.split(":")[1]
|
||
prices = [LabeledPrice(label="Detailed Salvage Report", amount=CHECK_PRICE)]
|
||
logging.info(f"Sending invoice for salvage check VIN: {vin}")
|
||
|
||
await callback.bot.send_invoice(
|
||
chat_id=callback.message.chat.id,
|
||
title="Detailed Salvage Report",
|
||
description=f"Get comprehensive salvage history and damage information for {CHECK_PRICE} Telegram Stars",
|
||
payload=f"detailed_salvage_check:{vin}", # Уникальный payload для этого типа платежа
|
||
provider_token="", # Empty for Telegram Stars
|
||
currency="XTR", # Telegram Stars currency
|
||
prices=prices
|
||
)
|
||
await callback.answer()
|
||
|
||
|
||
@dp.callback_query(lambda c: c.data and c.data.startswith("pay_photos:"))
|
||
async def pay_photos_callback(callback: CallbackQuery, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при инициации платежа
|
||
await database.save_user(callback.from_user, "photos_payment_initiation")
|
||
|
||
# Извлекаем VIN из callback data
|
||
vin = callback.data.split(":")[1]
|
||
prices = [LabeledPrice(label="Vehicle Damage Photos", amount=IMG_PRICE)]
|
||
logging.info(f"Sending invoice for photos VIN: {vin}")
|
||
|
||
await callback.bot.send_invoice(
|
||
chat_id=callback.message.chat.id,
|
||
title="Vehicle Damage Photos",
|
||
description=f"Get access to all damage photos for this vehicle for {IMG_PRICE} Telegram Stars",
|
||
payload=f"vehicle_photos:{vin}", # Уникальный payload для фотографий
|
||
provider_token="", # Empty for Telegram Stars
|
||
currency="XTR", # Telegram Stars currency
|
||
prices=prices
|
||
)
|
||
await callback.answer()
|
||
|
||
|
||
@dp.pre_checkout_query()
|
||
async def pre_checkout_handler(pre_checkout_query: PreCheckoutQuery, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при pre-checkout
|
||
await database.save_user(pre_checkout_query.from_user, "pre_checkout")
|
||
await pre_checkout_query.answer(ok=True)
|
||
|
||
|
||
ADMIN_USER_ID = int(getenv("ADMIN_USER_ID", "0")) # ID администратора из переменных окружения
|
||
|
||
@dp.message(Command("admin_stats"))
|
||
async def admin_stats_handler(message: Message, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Проверяем, является ли пользователь администратором
|
||
if message.from_user.id != ADMIN_USER_ID:
|
||
await message.answer("❌ Access denied. This command is for administrators only.")
|
||
return
|
||
|
||
try:
|
||
# Получаем общую статистику
|
||
stats = await database.get_users_summary()
|
||
|
||
# Формируем отчет
|
||
report = f"""
|
||
📊 **Bot Users Statistics**
|
||
|
||
👥 **Users Overview:**
|
||
• Total users: {stats.get('total_users', 0)}
|
||
• Premium users: {stats.get('premium_users', 0)}
|
||
|
||
💰 **Revenue:**
|
||
• Total revenue: {stats.get('total_revenue', 0)} ⭐️
|
||
• Total transactions: {stats.get('total_transactions', 0)}
|
||
|
||
📈 **Activity:**
|
||
• Active last 24h: {stats.get('active_last_24h', 0)}
|
||
• Active last week: {stats.get('active_last_week', 0)}
|
||
|
||
📅 **Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
|
||
"""
|
||
|
||
await message.answer(report, parse_mode="Markdown")
|
||
|
||
except Exception as e:
|
||
logging.error(f"Error generating admin stats: {e}")
|
||
await message.answer("❌ Error generating statistics. Please try again later.")
|
||
|
||
|
||
@dp.message(lambda message: message.successful_payment)
|
||
async def successful_payment_handler(message: Message, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные о платеже пользователя
|
||
await database.save_user(message.from_user, "successful_payment")
|
||
|
||
payload = message.successful_payment.invoice_payload
|
||
|
||
# Определяем сумму платежа в зависимости от типа
|
||
if payload.startswith("detailed_salvage_check:"):
|
||
payment_amount = float(CHECK_PRICE)
|
||
elif payload.startswith("vehicle_photos:"):
|
||
payment_amount = float(IMG_PRICE)
|
||
else:
|
||
payment_amount = float(DECODE_PRICE)
|
||
|
||
await database.update_user_payment(message.from_user.id, payment_amount)
|
||
|
||
# Подготавливаем базовые данные платежа для логирования
|
||
payment_data = {
|
||
'amount': payment_amount,
|
||
'transaction_id': message.successful_payment.telegram_payment_charge_id,
|
||
'status': 'completed',
|
||
'currency': 'XTR',
|
||
'refund_status': 'no_refund'
|
||
}
|
||
|
||
if payload.startswith("detailed_vin_info:"):
|
||
vin = payload.split(":")[1]
|
||
|
||
try:
|
||
# Get detailed information from database
|
||
detailed_info = await database.fetch_detailed_vin_info(vin)
|
||
|
||
if detailed_info and detailed_info['all_params']:
|
||
params = detailed_info['all_params']
|
||
|
||
# Format the detailed report with all categories
|
||
report = f"🚗 **{params.get('model_year', 'N/A')} {params.get('make', 'N/A')} {params.get('model', 'N/A')}**\n"
|
||
if params.get('trim'):
|
||
report += f"{params.get('trim')}\n"
|
||
report += "\n"
|
||
|
||
# BASIC CHARACTERISTICS
|
||
if detailed_info['basic_characteristics']:
|
||
report += "📋 **BASIC CHARACTERISTICS**\n"
|
||
for key, data in detailed_info['basic_characteristics'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# ENGINE AND POWERTRAIN
|
||
if detailed_info['engine_and_powertrain']:
|
||
report += "🔧 **ENGINE AND POWERTRAIN**\n"
|
||
for key, data in detailed_info['engine_and_powertrain'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# TRANSMISSION
|
||
if detailed_info['transmission']:
|
||
report += "⚙️ **TRANSMISSION**\n"
|
||
for key, data in detailed_info['transmission'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# ACTIVE SAFETY
|
||
if detailed_info['active_safety']:
|
||
report += "🛡️ **ACTIVE SAFETY**\n"
|
||
for key, data in detailed_info['active_safety'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# PASSIVE SAFETY
|
||
if detailed_info['passive_safety']:
|
||
report += "🚗 **PASSIVE SAFETY**\n"
|
||
for key, data in detailed_info['passive_safety'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# DIMENSIONS AND CONSTRUCTION
|
||
if detailed_info['dimensions_and_construction']:
|
||
report += "📏 **DIMENSIONS AND CONSTRUCTION**\n"
|
||
for key, data in detailed_info['dimensions_and_construction'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# BRAKE SYSTEM
|
||
if detailed_info['brake_system']:
|
||
report += "🔧 **BRAKE SYSTEM**\n"
|
||
for key, data in detailed_info['brake_system'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# LIGHTING
|
||
if detailed_info['lighting']:
|
||
report += "💡 **LIGHTING**\n"
|
||
for key, data in detailed_info['lighting'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# ADDITIONAL FEATURES
|
||
if detailed_info['additional_features']:
|
||
report += "✨ **ADDITIONAL FEATURES**\n"
|
||
for key, data in detailed_info['additional_features'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# MANUFACTURING AND LOCALIZATION
|
||
if detailed_info['manufacturing_and_localization']:
|
||
report += "🏭 **MANUFACTURING AND LOCALIZATION**\n"
|
||
for key, data in detailed_info['manufacturing_and_localization'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# NCSA DATA
|
||
if detailed_info['ncsa_data']:
|
||
report += "📊 **NCSA DATA**\n"
|
||
for key, data in detailed_info['ncsa_data'].items():
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
# TECHNICAL INFORMATION AND ERRORS
|
||
if detailed_info['technical_information_and_errors']:
|
||
report += "⚠️ **TECHNICAL INFORMATION AND ERRORS**\n"
|
||
for key, data in detailed_info['technical_information_and_errors'].items():
|
||
if data['value'] == "0":
|
||
report += "✅ **No errors found**\n"
|
||
else:
|
||
report += f"• **{data['param_name']}:** {data['value']}\n"
|
||
report += "\n"
|
||
|
||
report += "---\n"
|
||
report += f"📋 **VIN:** {vin}\n"
|
||
report += f"💰 **Transaction ID:** {escape_markdown(message.successful_payment.telegram_payment_charge_id)}\n"
|
||
report += "⚠️ **This report shows salvage/damage history. Please consult with automotive experts for vehicle evaluation.**"
|
||
|
||
# Create keyboard with action buttons
|
||
builder = InlineKeyboardBuilder()
|
||
builder.button(text="Try another VIN", callback_data="decode_vin")
|
||
builder.button(text="Back to Main Menu", callback_data="main_menu")
|
||
builder.adjust(2) # Two buttons on one row
|
||
|
||
logging.info("Attempting to send message with Markdown...")
|
||
try:
|
||
await message.answer(report, reply_markup=builder.as_markup(), parse_mode="Markdown")
|
||
logging.info("Message sent successfully!")
|
||
except Exception as markdown_error:
|
||
logging.error(f"Markdown parsing failed: {markdown_error}")
|
||
logging.info("Attempting to send without Markdown...")
|
||
# Удаляем markdown символы и отправляем как обычный текст
|
||
plain_report = report.replace("**", "").replace("*", "")
|
||
await message.answer(plain_report, reply_markup=builder.as_markup())
|
||
logging.info("Plain text message sent successfully!")
|
||
|
||
# Логируем успешную операцию DecodeVin
|
||
service_result = {
|
||
'status': 'success',
|
||
'data_count': len(detailed_info['all_params']),
|
||
'vehicle_make': params.get('make', 'N/A'),
|
||
'vehicle_model': params.get('model', 'N/A'),
|
||
'vehicle_year': params.get('model_year', 'N/A')
|
||
}
|
||
await database.save_payment_log(message.from_user, "decode_vin", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged successfully for DecodeVin service - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
# Проверяем, является ли пользователь администратором и возвращаем звезды
|
||
if message.from_user.id == ADMIN_USER_ID:
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
payment_data['refund_status'] = 'admin_refund'
|
||
await message.answer(
|
||
"🔧 **Admin Refund**\n\n"
|
||
f"💰 Payment automatically refunded for admin user.\n"
|
||
f"🆔 Transaction ID: {escape_markdown(message.successful_payment.telegram_payment_charge_id)}\n"
|
||
"ℹ️ Admin access - no charges applied.",
|
||
parse_mode="Markdown"
|
||
)
|
||
logging.info(f"Admin refund successful for user {message.from_user.id}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund admin payment: {refund_error}")
|
||
await message.answer(
|
||
"⚠️ **Admin Refund Failed**\n\n"
|
||
"Could not automatically refund admin payment. Please contact technical support.\n"
|
||
f"🆔 Transaction ID: {escape_markdown(message.successful_payment.telegram_payment_charge_id)}",
|
||
parse_mode="Markdown"
|
||
)
|
||
else:
|
||
# No detailed information found - refund the payment
|
||
service_result = {
|
||
'status': 'no_data',
|
||
'data_count': 0,
|
||
'error': 'No detailed information found for VIN'
|
||
}
|
||
payment_data['refund_status'] = 'auto_refund'
|
||
payment_data['refund_reason'] = 'No detailed information found'
|
||
await database.save_payment_log(message.from_user, "decode_vin", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged for DecodeVin no data case - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
await message.answer(
|
||
"❌ No detailed information found for this VIN in our database.\n"
|
||
"💰 Your payment has been automatically refunded.\n"
|
||
"Please verify the VIN and try again."
|
||
)
|
||
logging.info(f"Refund successful for user {message.from_user.id} - no data found for VIN {vin}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund payment for user {message.from_user.id}: {refund_error}")
|
||
await message.answer(
|
||
"❌ No detailed information found for this VIN.\n"
|
||
"⚠️ Please contact support with this transaction ID for a refund:\n"
|
||
f"🆔 {message.successful_payment.telegram_payment_charge_id}"
|
||
)
|
||
except Exception as e:
|
||
logging.error(f"Error getting detailed VIN info for {vin}: {e}")
|
||
|
||
# Логируем ошибку
|
||
service_result = {
|
||
'status': 'error',
|
||
'data_count': 0,
|
||
'error': str(e)
|
||
}
|
||
payment_data['refund_status'] = 'auto_refund'
|
||
payment_data['refund_reason'] = 'Service error'
|
||
await database.save_payment_log(message.from_user, "decode_vin", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged for DecodeVin error case - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
# Attempt to refund the payment due to service error
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
await message.answer(
|
||
"❌ Error retrieving detailed information from our database.\n"
|
||
"💰 Your payment has been automatically refunded.\n"
|
||
"Please try again later or contact support if the issue persists."
|
||
)
|
||
logging.info(f"Refund successful for user {message.from_user.id}, charge_id: {message.successful_payment.telegram_payment_charge_id}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund payment for user {message.from_user.id}: {refund_error}")
|
||
await message.answer(
|
||
"❌ Error retrieving detailed information from our database.\n"
|
||
"⚠️ Please contact support immediately with this transaction ID for a manual refund:\n"
|
||
f"🆔 {message.successful_payment.telegram_payment_charge_id}"
|
||
)
|
||
elif payload.startswith("detailed_salvage_check:"):
|
||
vin = payload.split(":")[1]
|
||
|
||
try:
|
||
logging.info(f"=== DETAILED SALVAGE CHECK DEBUG START for VIN: {vin} ===")
|
||
|
||
# Получаем детальную информацию о salvage записях
|
||
salvage_records = await database.fetch_salvage_detailed_info(vin)
|
||
logging.info(f"Salvage records count: {len(salvage_records) if salvage_records else 0}")
|
||
|
||
if salvage_records:
|
||
# Логируем первую запись для отладки
|
||
if len(salvage_records) > 0:
|
||
logging.info(f"First record data: {salvage_records[0]}")
|
||
|
||
# Получаем базовую информацию о VIN для заголовка
|
||
make, model, year, cnt = await database.fetch_vin_info(vin)
|
||
logging.info(f"VIN info: make={make}, model={model}, year={year}, cnt={cnt}")
|
||
|
||
report = f"🚗 **{year} {make} {model}**\n"
|
||
report += f"📋 **VIN:** {escape_markdown(vin)}\n\n"
|
||
report += f"🔍 **DETAILED SALVAGE HISTORY REPORT**\n"
|
||
report += f"📊 **Total Records Found:** {len(salvage_records)}\n\n"
|
||
|
||
logging.info(f"Report header created, length: {len(report)}")
|
||
|
||
# Добавляем информацию по каждой записи
|
||
for idx, record in enumerate(salvage_records[:5], 1): # Показываем максимум 5 записей
|
||
logging.info(f"Processing record #{idx}: {record}")
|
||
|
||
record_text = f"📋 **Record #{idx}**\n"
|
||
|
||
# Дата продажи с красивым форматированием
|
||
if record['sale_date']:
|
||
formatted_date = format_sale_date(record['sale_date'])
|
||
logging.info(f"Formatted date: {formatted_date}")
|
||
record_text += f"📅 **Sale Date:** {formatted_date}\n"
|
||
|
||
# Основное повреждение
|
||
if record['dem1']:
|
||
logging.info(f"Primary damage: {record['dem1']}")
|
||
record_text += f"⚠️ **Primary Damage:** {escape_markdown(record['dem1'])}\n"
|
||
|
||
# Вторичное повреждение
|
||
if record['dem2']:
|
||
logging.info(f"Secondary damage: {record['dem2']}")
|
||
record_text += f"⚠️ **Secondary Damage:** {escape_markdown(record['dem2'])}\n"
|
||
|
||
# Одометр
|
||
if record['odo']:
|
||
try:
|
||
odo_value = int(record['odo']) if record['odo'] else 0
|
||
odo_status = f" ({record['odos']})" if record['odos'] else ""
|
||
logging.info(f"Odometer: {odo_value}, status: {record['odos']}")
|
||
record_text += f"🛣️ **Odometer:** {odo_value:,} miles{odo_status}\n"
|
||
except (ValueError, TypeError):
|
||
logging.info(f"Odometer parsing error for: {record['odo']}")
|
||
record_text += f"🛣️ **Odometer:** {record['odo']}\n"
|
||
|
||
# Стоимость ремонта
|
||
if record['j_rep_cost']:
|
||
try:
|
||
repair_cost = float(record['j_rep_cost']) if record['j_rep_cost'] else 0
|
||
if repair_cost > 0:
|
||
logging.info(f"Repair cost: {repair_cost}")
|
||
record_text += f"💰 **Repair Cost:** ${repair_cost:,.2f}\n"
|
||
except (ValueError, TypeError):
|
||
logging.info(f"Repair cost parsing error for: {record['j_rep_cost']}")
|
||
record_text += f"💰 **Repair Cost:** {record['j_rep_cost']}\n"
|
||
|
||
# Состояние двигателя/движения
|
||
if record['j_runs_drive']:
|
||
logging.info(f"Engine status: {record['j_runs_drive']}")
|
||
record_text += f"🔧 **Engine Status:** {escape_markdown(record['j_runs_drive'])}\n"
|
||
|
||
# Локация с конвертированными штатами
|
||
if record['j_locate']:
|
||
formatted_location = parse_location(record['j_locate'])
|
||
logging.info(f"Location: {record['j_locate']} -> {formatted_location}")
|
||
record_text += f"📍 **Sale Location:** {formatted_location}\n"
|
||
|
||
record_text += "\n"
|
||
report += record_text
|
||
logging.info(f"Record #{idx} text length: {len(record_text)}")
|
||
|
||
if len(salvage_records) > 5:
|
||
report += f"📋 **... and {len(salvage_records) - 5} more records**\n\n"
|
||
|
||
report += "---\n"
|
||
report += f"💰 **Transaction ID:** {escape_markdown(message.successful_payment.telegram_payment_charge_id)}\n"
|
||
report += "⚠️ **This report shows salvage/damage history. Please consult with automotive experts for vehicle evaluation.**"
|
||
|
||
logging.info(f"Final report length: {len(report)}")
|
||
logging.info("=== REPORT CONTENT START ===")
|
||
logging.info(report)
|
||
logging.info("=== REPORT CONTENT END ===")
|
||
|
||
# Создаем клавиатуру
|
||
builder = InlineKeyboardBuilder()
|
||
builder.button(text="Try another VIN", callback_data="check_vin")
|
||
builder.button(text="Back to Main Menu", callback_data="main_menu")
|
||
builder.adjust(2)
|
||
|
||
logging.info("Attempting to send message with Markdown...")
|
||
try:
|
||
await message.answer(report, reply_markup=builder.as_markup(), parse_mode="Markdown")
|
||
logging.info("Message sent successfully!")
|
||
except Exception as markdown_error:
|
||
logging.error(f"Markdown parsing failed: {markdown_error}")
|
||
logging.info("Attempting to send without Markdown...")
|
||
# Удаляем markdown символы и отправляем как обычный текст
|
||
plain_report = report.replace("**", "").replace("*", "")
|
||
await message.answer(plain_report, reply_markup=builder.as_markup())
|
||
logging.info("Plain text message sent successfully!")
|
||
|
||
# Логируем успешную операцию CheckSalvage
|
||
service_result = {
|
||
'status': 'success',
|
||
'data_count': len(salvage_records),
|
||
'vehicle_make': make,
|
||
'vehicle_model': model,
|
||
'vehicle_year': year
|
||
}
|
||
await database.save_payment_log(message.from_user, "check_salvage", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged successfully for CheckSalvage service - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
# Отправляем отдельное сообщение о фотографиях
|
||
if salvage_records and salvage_records[0]['img_count'] > 0:
|
||
img_count = salvage_records[0]['img_count']
|
||
photo_message = f"📸 **Photo Information**\n\n"
|
||
photo_message += f"🖼️ **{img_count} damage photos** found in our database for this vehicle.\n"
|
||
photo_message += f"These photos show the actual condition and damage of the vehicle during auction."
|
||
logging.info("Sending photo information message...")
|
||
await message.answer(photo_message, parse_mode="Markdown")
|
||
logging.info("Photo message sent successfully!")
|
||
|
||
# Проверяем, является ли пользователь администратором и возвращаем звезды
|
||
if message.from_user.id == ADMIN_USER_ID:
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
payment_data['refund_status'] = 'admin_refund'
|
||
await message.answer(
|
||
"🔧 **Admin Refund**\n\n"
|
||
f"💰 Payment automatically refunded for admin user.\n"
|
||
f"🆔 Transaction ID: {escape_markdown(message.successful_payment.telegram_payment_charge_id)}\n"
|
||
"ℹ️ Admin access - no charges applied.",
|
||
parse_mode="Markdown"
|
||
)
|
||
logging.info(f"Admin refund successful for user {message.from_user.id}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund admin payment: {refund_error}")
|
||
await message.answer(
|
||
"⚠️ **Admin Refund Failed**\n\n"
|
||
"Could not automatically refund admin payment. Please contact technical support.\n"
|
||
f"🆔 Transaction ID: {escape_markdown(message.successful_payment.telegram_payment_charge_id)}",
|
||
parse_mode="Markdown"
|
||
)
|
||
else:
|
||
# Нет записей - возвращаем деньги
|
||
service_result = {
|
||
'status': 'no_data',
|
||
'data_count': 0,
|
||
'error': 'No salvage records found for VIN'
|
||
}
|
||
payment_data['refund_status'] = 'auto_refund'
|
||
payment_data['refund_reason'] = 'No salvage records found'
|
||
await database.save_payment_log(message.from_user, "check_salvage", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged for CheckSalvage no data case - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
await message.answer(
|
||
"❌ No salvage records found for this VIN in our database.\n"
|
||
"💰 Your payment has been automatically refunded.\n"
|
||
"This is actually good news - no salvage history found!"
|
||
)
|
||
logging.info(f"Refund successful for user {message.from_user.id} - no salvage data found for VIN {vin}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund payment for user {message.from_user.id}: {refund_error}")
|
||
await message.answer(
|
||
"❌ No salvage records found for this VIN.\n"
|
||
"⚠️ Please contact support with this transaction ID for a refund:\n"
|
||
f"🆔 {message.successful_payment.telegram_payment_charge_id}"
|
||
)
|
||
|
||
except Exception as e:
|
||
logging.error(f"Error getting salvage info for {vin}: {e}")
|
||
|
||
# Логируем ошибку
|
||
service_result = {
|
||
'status': 'error',
|
||
'data_count': 0,
|
||
'error': str(e)
|
||
}
|
||
payment_data['refund_status'] = 'auto_refund'
|
||
payment_data['refund_reason'] = 'Service error'
|
||
await database.save_payment_log(message.from_user, "check_salvage", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged for CheckSalvage error case - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
# Возвращаем деньги при ошибке
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
await message.answer(
|
||
"❌ Error retrieving salvage information from our database.\n"
|
||
"💰 Your payment has been automatically refunded.\n"
|
||
"Please try again later or contact support if the issue persists."
|
||
)
|
||
logging.info(f"Refund successful for user {message.from_user.id}, charge_id: {message.successful_payment.telegram_payment_charge_id}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund payment for user {message.from_user.id}: {refund_error}")
|
||
await message.answer(
|
||
"❌ Error retrieving salvage information from our database.\n"
|
||
"⚠️ Please contact support immediately with this transaction ID for a manual refund:\n"
|
||
f"🆔 {message.successful_payment.telegram_payment_charge_id}"
|
||
)
|
||
elif payload.startswith("vehicle_photos:"):
|
||
vin = payload.split(":")[1]
|
||
|
||
try:
|
||
# Получаем информацию о VIN и количество фотографий
|
||
make, model, year, cnt = await database.fetch_vin_info(vin)
|
||
photo_count = await database.count_photo_records(vin)
|
||
|
||
logging.info(f"Photos payment for VIN: {vin}, make: {make}, model: {model}, year: {year}, photo_count: {photo_count}")
|
||
|
||
if photo_count > 0:
|
||
# Есть фотографии - предоставляем доступ (пока заглушка)
|
||
if make == "UNKNOWN" and model == "UNKNOWN" and year == "UNKNOWN":
|
||
response_text = f"📸 **Vehicle Damage Photos**\n\n"
|
||
else:
|
||
response_text = f"🚗 **{year} {make} {model}**\n\n"
|
||
response_text += f"📸 **Vehicle Damage Photos**\n\n"
|
||
|
||
response_text += f"✅ **Payment successful!** You now have access to **{photo_count} damage photos** for this vehicle.\n\n"
|
||
response_text += f"📁 **Photos will be sent separately** - please wait while we prepare your images.\n\n"
|
||
response_text += f"---\n"
|
||
response_text += f"💰 **Transaction ID:** {escape_markdown(message.successful_payment.telegram_payment_charge_id)}\n"
|
||
response_text += f"📋 **VIN:** {escape_markdown(vin)}"
|
||
|
||
# Создаем клавиатуру с дополнительными действиями
|
||
builder = InlineKeyboardBuilder()
|
||
builder.button(text="Search another VIN", callback_data="search_car_photo")
|
||
builder.button(text="Back to Main Menu", callback_data="main_menu")
|
||
builder.adjust(2)
|
||
|
||
logging.info("Attempting to send photos payment success message...")
|
||
try:
|
||
await message.answer(response_text, reply_markup=builder.as_markup(), parse_mode="Markdown")
|
||
logging.info("Photos payment message sent successfully!")
|
||
|
||
# Получаем пути к фотографиям из базы данных
|
||
logging.info(f"Fetching photo paths for VIN: {vin}")
|
||
db_photo_paths = await database.fetch_photo_paths(vin)
|
||
logging.info(f"Found {len(db_photo_paths)} photo paths in database")
|
||
|
||
if db_photo_paths:
|
||
# Подготавливаем полные пути к файлам
|
||
full_photo_paths = prepare_photo_paths(db_photo_paths)
|
||
logging.info(f"Prepared {len(full_photo_paths)} full photo paths")
|
||
|
||
# Отправляем фотографии
|
||
await send_vehicle_photos(message, vin, full_photo_paths, make, model, year)
|
||
|
||
# Логируем успешную операцию GetPhotos
|
||
service_result = {
|
||
'status': 'success',
|
||
'data_count': len(full_photo_paths),
|
||
'vehicle_make': make,
|
||
'vehicle_model': model,
|
||
'vehicle_year': year
|
||
}
|
||
await database.save_payment_log(message.from_user, "get_photos", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged successfully for GetPhotos service - User: {message.from_user.id}, VIN: {vin}")
|
||
else:
|
||
await message.answer(
|
||
"⚠️ **Warning:** No photo paths found in database despite photo count > 0.\n"
|
||
"Please contact support with your transaction details."
|
||
)
|
||
logging.warning(f"No photo paths found for VIN {vin} despite photo_count = {photo_count}")
|
||
|
||
# Логируем проблему с путями к фотографиям
|
||
service_result = {
|
||
'status': 'error',
|
||
'data_count': 0,
|
||
'error': 'Photo paths not found despite photo count > 0'
|
||
}
|
||
await database.save_payment_log(message.from_user, "get_photos", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged for GetPhotos path error case - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
except Exception as markdown_error:
|
||
logging.error(f"Markdown parsing failed for photos payment: {markdown_error}")
|
||
plain_response = response_text.replace("**", "").replace("*", "")
|
||
await message.answer(plain_response, reply_markup=builder.as_markup())
|
||
logging.info("Plain text photos payment message sent successfully!")
|
||
|
||
# Получаем пути к фотографиям из базы данных (fallback)
|
||
logging.info(f"Fetching photo paths for VIN: {vin} (fallback)")
|
||
db_photo_paths = await database.fetch_photo_paths(vin)
|
||
logging.info(f"Found {len(db_photo_paths)} photo paths in database (fallback)")
|
||
|
||
if db_photo_paths:
|
||
# Подготавливаем полные пути к файлам
|
||
full_photo_paths = prepare_photo_paths(db_photo_paths)
|
||
logging.info(f"Prepared {len(full_photo_paths)} full photo paths (fallback)")
|
||
|
||
# Отправляем фотографии
|
||
await send_vehicle_photos(message, vin, full_photo_paths, make, model, year)
|
||
|
||
# Логируем успешную операцию GetPhotos (fallback)
|
||
service_result = {
|
||
'status': 'success',
|
||
'data_count': len(full_photo_paths),
|
||
'vehicle_make': make,
|
||
'vehicle_model': model,
|
||
'vehicle_year': year
|
||
}
|
||
await database.save_payment_log(message.from_user, "get_photos", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged successfully for GetPhotos service (fallback) - User: {message.from_user.id}, VIN: {vin}")
|
||
else:
|
||
await message.answer(
|
||
"Warning: No photo paths found in database despite photo count > 0. "
|
||
"Please contact support with your transaction details."
|
||
)
|
||
logging.warning(f"No photo paths found for VIN {vin} despite photo_count = {photo_count} (fallback)")
|
||
|
||
# Логируем проблему с путями к фотографиям (fallback)
|
||
service_result = {
|
||
'status': 'error',
|
||
'data_count': 0,
|
||
'error': 'Photo paths not found despite photo count > 0 (fallback)'
|
||
}
|
||
await database.save_payment_log(message.from_user, "get_photos", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged for GetPhotos fallback path error case - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
# Проверяем, является ли пользователь администратором и возвращаем звезды
|
||
if message.from_user.id == ADMIN_USER_ID:
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
payment_data['refund_status'] = 'admin_refund'
|
||
await message.answer(
|
||
"🔧 **Admin Refund**\n\n"
|
||
f"💰 Payment automatically refunded for admin user.\n"
|
||
f"🆔 Transaction ID: {escape_markdown(message.successful_payment.telegram_payment_charge_id)}\n"
|
||
"ℹ️ Admin access - no charges applied.",
|
||
parse_mode="Markdown"
|
||
)
|
||
logging.info(f"Admin refund successful for user {message.from_user.id}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund admin payment: {refund_error}")
|
||
await message.answer(
|
||
"⚠️ **Admin Refund Failed**\n\n"
|
||
"Could not automatically refund admin payment. Please contact technical support.\n"
|
||
f"🆔 Transaction ID: {escape_markdown(message.successful_payment.telegram_payment_charge_id)}",
|
||
parse_mode="Markdown"
|
||
)
|
||
else:
|
||
# Нет фотографий - возвращаем деньги
|
||
service_result = {
|
||
'status': 'no_data',
|
||
'data_count': 0,
|
||
'error': 'No photos found for VIN'
|
||
}
|
||
payment_data['refund_status'] = 'auto_refund'
|
||
payment_data['refund_reason'] = 'No photos found'
|
||
await database.save_payment_log(message.from_user, "get_photos", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged for GetPhotos no data case - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
await message.answer(
|
||
"❌ No photos found for this VIN in our database.\n"
|
||
"💰 Your payment has been automatically refunded.\n"
|
||
"Please try another VIN or contact support if you believe this is an error."
|
||
)
|
||
logging.info(f"Refund successful for user {message.from_user.id} - no photos found for VIN {vin}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund payment for user {message.from_user.id}: {refund_error}")
|
||
await message.answer(
|
||
"❌ No photos found for this VIN.\n"
|
||
"⚠️ Please contact support with this transaction ID for a refund:\n"
|
||
f"🆔 {message.successful_payment.telegram_payment_charge_id}"
|
||
)
|
||
|
||
except Exception as e:
|
||
logging.error(f"Error getting photos info for {vin}: {e}")
|
||
|
||
# Логируем ошибку
|
||
service_result = {
|
||
'status': 'error',
|
||
'data_count': 0,
|
||
'error': str(e)
|
||
}
|
||
payment_data['refund_status'] = 'auto_refund'
|
||
payment_data['refund_reason'] = 'Service error'
|
||
await database.save_payment_log(message.from_user, "get_photos", vin, payment_data, service_result)
|
||
logging.info(f"Payment logged for GetPhotos error case - User: {message.from_user.id}, VIN: {vin}")
|
||
|
||
# Возвращаем деньги при ошибке
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
await message.answer(
|
||
"❌ Error retrieving photos information from our database.\n"
|
||
"💰 Your payment has been automatically refunded.\n"
|
||
"Please try again later or contact support if the issue persists."
|
||
)
|
||
logging.info(f"Refund successful for user {message.from_user.id}, charge_id: {message.successful_payment.telegram_payment_charge_id}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund payment for user {message.from_user.id}: {refund_error}")
|
||
await message.answer(
|
||
"❌ Error retrieving photos information from our database.\n"
|
||
"⚠️ Please contact support immediately with this transaction ID for a manual refund:\n"
|
||
f"🆔 {message.successful_payment.telegram_payment_charge_id}"
|
||
)
|
||
else:
|
||
await message.answer(
|
||
f"✅ Payment successful! Thank you for your purchase.\n"
|
||
f"Transaction ID: {message.successful_payment.telegram_payment_charge_id}"
|
||
)
|
||
|
||
# Проверяем, является ли пользователь администратором и возвращаем звезды
|
||
if message.from_user.id == ADMIN_USER_ID:
|
||
try:
|
||
await message.bot.refund_star_payment(
|
||
user_id=message.from_user.id,
|
||
telegram_payment_charge_id=message.successful_payment.telegram_payment_charge_id
|
||
)
|
||
await message.answer(
|
||
"🔧 **Admin Refund**\n\n"
|
||
f"💰 Payment automatically refunded for admin user.\n"
|
||
f"🆔 Transaction ID: {escape_markdown(message.successful_payment.telegram_payment_charge_id)}\n"
|
||
"ℹ️ Admin access - no charges applied.",
|
||
parse_mode="Markdown"
|
||
)
|
||
logging.info(f"Admin refund successful for user {message.from_user.id}")
|
||
except Exception as refund_error:
|
||
logging.error(f"Failed to refund admin payment: {refund_error}")
|
||
await message.answer(
|
||
"⚠️ **Admin Refund Failed**\n\n"
|
||
"Could not automatically refund admin payment. Please contact technical support.\n"
|
||
f"🆔 Transaction ID: {escape_markdown(message.successful_payment.telegram_payment_charge_id)}",
|
||
parse_mode="Markdown"
|
||
)
|
||
|
||
|
||
@dp.message(VinStates.waiting_for_photo_vin)
|
||
async def process_photo_vin(message: Message, state: FSMContext, db: OracleDatabase = None):
|
||
# Используем переданный db или глобальный oracle_db
|
||
database = db or oracle_db
|
||
|
||
# Сохраняем данные пользователя при обработке VIN
|
||
await database.save_user(message.from_user, "photo_vin_processing")
|
||
|
||
vin = message.text.strip().upper()
|
||
if len(vin) == 17 and vin.isalnum() and all(c not in vin for c in ["I", "O", "Q"]):
|
||
try:
|
||
# Получаем базовую информацию о VIN для заголовка
|
||
make, model, year, cnt = await database.fetch_vin_info(vin)
|
||
|
||
# Получаем количество фотографий
|
||
photo_count = await database.count_photo_records(vin)
|
||
|
||
logging.info(f"Photo search VIN: make: {make}, model: {model}, year: {year}, photo_count: {photo_count}")
|
||
|
||
# Формируем ответ в зависимости от наличия фотографий
|
||
builder = InlineKeyboardBuilder()
|
||
|
||
if photo_count > 0:
|
||
# Есть фотографии - показываем информацию и кнопку оплаты
|
||
if make == "UNKNOWN" and model == "UNKNOWN" and year == "UNKNOWN":
|
||
response_text = f"📸 **Photo Information**\n\n"
|
||
else:
|
||
response_text = f"🚗 **{year} {make} {model}**\n\n"
|
||
response_text += f"📸 **Photo Information**\n\n"
|
||
|
||
response_text += f"🖼️ **{photo_count} damage photos** found in our database for this vehicle.\n"
|
||
response_text += f"These photos show the actual condition and damage of the vehicle during auction."
|
||
|
||
builder.button(text=f"Pay {IMG_PRICE} ⭐️ for photos", callback_data=f"pay_photos:{vin}", pay=True)
|
||
builder.button(text="Try another VIN", callback_data="search_car_photo")
|
||
builder.button(text="Back to Main Menu", callback_data="main_menu")
|
||
builder.adjust(1, 1, 1) # Each button on separate row
|
||
else:
|
||
# Нет фотографий
|
||
if make == "UNKNOWN" and model == "UNKNOWN" and year == "UNKNOWN":
|
||
response_text = f"❌ **Unable to decode VIN or no photos found**\n\n"
|
||
else:
|
||
response_text = f"🚗 **{year} {make} {model}**\n\n"
|
||
|
||
response_text += f"📸 **No damage photos found** for this VIN in our database."
|
||
|
||
builder.button(text="Try another VIN", callback_data="search_car_photo")
|
||
builder.button(text="Back to Main Menu", callback_data="main_menu")
|
||
builder.adjust(1, 1) # Each button on separate row
|
||
|
||
await message.answer(response_text, reply_markup=builder.as_markup(), parse_mode="Markdown")
|
||
|
||
except Exception as e:
|
||
logging.error(f"Database error for photo search VIN {vin}: {e}")
|
||
await message.answer("Error retrieving data from database. Please try again later.")
|
||
await state.clear()
|
||
else:
|
||
await message.answer("Invalid VIN. Please enter a valid 17-character VIN (letters and numbers, no I, O, Q).")
|
||
|
||
|
||
async def on_startup():
|
||
await oracle_db.connect()
|
||
# Регистрируем middleware для всех типов событий
|
||
dp.message.middleware(DbSessionMiddleware(oracle_db))
|
||
dp.callback_query.middleware(DbSessionMiddleware(oracle_db))
|
||
dp.pre_checkout_query.middleware(DbSessionMiddleware(oracle_db))
|
||
|
||
|
||
async def on_shutdown():
|
||
await oracle_db.close()
|
||
|
||
|
||
# Run the bot
|
||
async def main() -> None:
|
||
bot = Bot(token=TOKEN)
|
||
dp.startup.register(on_startup)
|
||
dp.shutdown.register(on_shutdown)
|
||
await dp.start_polling(bot)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
asyncio.run(main())
|
||
|