699 строки
32 KiB
Python
699 строки
32 KiB
Python
"""BotFactory — Platform Admin Bot (системный бот платформы)"""
|
|
import asyncio, logging
|
|
from datetime import datetime, timedelta
|
|
from aiogram import Bot, Dispatcher, F, Router
|
|
from aiogram.filters import Command
|
|
from aiogram.fsm.context import FSMContext
|
|
from aiogram.fsm.state import State, StatesGroup
|
|
from aiogram.fsm.storage.redis import RedisStorage
|
|
from aiogram.types import (Message, CallbackQuery,
|
|
InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton, ReplyKeyboardRemove)
|
|
from aiogram.utils.keyboard import InlineKeyboardBuilder, ReplyKeyboardBuilder
|
|
from sqlalchemy import select, func, desc
|
|
from config import settings
|
|
from database import AsyncSessionLocal
|
|
from models import Tenant, Shop, ShopToken, Product, PaymentCard, Order, BalanceTransaction, OrderStatus, PlanEnum
|
|
from billing import (current_due_date, is_postpaid, plan_title,
|
|
postpaid_previous_month_totals, tenant_can_sell)
|
|
|
|
logger = logging.getLogger("platform_bot")
|
|
router = Router()
|
|
|
|
|
|
# ── Guards ────────────────────────────────────────────────────────────────────
|
|
def is_admin(uid: int) -> bool:
|
|
return uid in settings.admin_ids
|
|
|
|
def guard(fn):
|
|
async def w(event, *a, **kw):
|
|
uid = event.from_user.id
|
|
if not is_admin(uid):
|
|
t = event.answer if isinstance(event, Message) else event.answer
|
|
await t("⛔ Доступ запрещён.", show_alert=True) if isinstance(event, CallbackQuery) else await t("⛔ Доступ запрещён.")
|
|
return
|
|
return await fn(event, *a, **kw)
|
|
return w
|
|
|
|
|
|
# ── States ────────────────────────────────────────────────────────────────────
|
|
class S(StatesGroup):
|
|
topup_amount = State()
|
|
topup_note = State()
|
|
broadcast = State()
|
|
bcast_ok = State()
|
|
plan_percent = State()
|
|
plan_due_day = State()
|
|
|
|
|
|
# ── Keyboards ─────────────────────────────────────────────────────────────────
|
|
def main_kb():
|
|
b = ReplyKeyboardBuilder()
|
|
b.row(KeyboardButton(text="📊 Статистика"), KeyboardButton(text="👥 Пользователи"))
|
|
b.row(KeyboardButton(text="💰 Балансы"), KeyboardButton(text="📦 Заказы"))
|
|
b.row(KeyboardButton(text="📢 Рассылка"), KeyboardButton(text="⚙️ Настройки"))
|
|
b.row(KeyboardButton(text="🧾 Постоплата"))
|
|
return b.as_markup(resize_keyboard=True)
|
|
|
|
def ib(*rows):
|
|
bld = InlineKeyboardBuilder()
|
|
for row in rows:
|
|
if isinstance(row, list):
|
|
bld.row(*[InlineKeyboardButton(text=t, callback_data=d) for t, d in row])
|
|
else:
|
|
bld.add(InlineKeyboardButton(text=row[0], callback_data=row[1]))
|
|
return bld.as_markup()
|
|
|
|
def fmt(v: float) -> str:
|
|
return f"{v:,.0f}".replace(",", " ") + " ₽"
|
|
|
|
def bal_em(b: float, t: float) -> str:
|
|
return "🔴" if b <= 0 else ("🟡" if b <= t else "🟢")
|
|
|
|
|
|
# ── /start ────────────────────────────────────────────────────────────────────
|
|
@router.message(Command("start"))
|
|
@guard
|
|
async def start(msg: Message, state: FSMContext):
|
|
await state.clear()
|
|
await msg.answer(
|
|
f"👋 <b>BotFactory Admin</b>\n{msg.from_user.full_name}\n"
|
|
f"ID: <code>{msg.from_user.id}</code>",
|
|
reply_markup=main_kb(), parse_mode="HTML")
|
|
|
|
|
|
# ── Статистика ────────────────────────────────────────────────────────────────
|
|
@router.message(F.text == "📊 Статистика")
|
|
@guard
|
|
async def stats(msg: Message):
|
|
async with AsyncSessionLocal() as db:
|
|
n_all = (await db.execute(select(func.count(Tenant.id)))).scalar()
|
|
n_act = (await db.execute(select(func.count(Tenant.id)).where(Tenant.is_active==True))).scalar()
|
|
n_blk = (await db.execute(select(func.count(Tenant.id)).where(Tenant.is_blocked==True))).scalar()
|
|
n_low = (await db.execute(select(func.count(Tenant.id)).where(Tenant.balance>0, Tenant.balance<=Tenant.alert_threshold))).scalar()
|
|
n_zero = (await db.execute(select(func.count(Tenant.id)).where(Tenant.balance<=0, Tenant.is_active==True))).scalar()
|
|
turn = (await db.execute(select(func.sum(Order.amount)).where(Order.status==OrderStatus.completed))).scalar() or 0
|
|
comm = (await db.execute(select(func.sum(Order.commission)).where(Order.status==OrderStatus.completed))).scalar() or 0
|
|
pending = (await db.execute(select(func.count(Order.id)).where(Order.status.in_([OrderStatus.pending,OrderStatus.confirming])))).scalar()
|
|
today = datetime.utcnow().replace(hour=0,minute=0,second=0,microsecond=0)
|
|
orders_td = (await db.execute(select(func.count(Order.id)).where(Order.status==OrderStatus.completed, Order.created_at>=today))).scalar()
|
|
|
|
txt = (
|
|
f"📊 <b>Статистика платформы</b>\n<i>{datetime.now():%d.%m.%Y %H:%M}</i>\n{'─'*28}\n\n"
|
|
f"👥 Пользователей: <b>{n_all}</b> (активных {n_act})\n"
|
|
f"🔴 Заблокировано: <b>{n_blk}</b>\n🟡 Низкий баланс: <b>{n_low}</b>\n"
|
|
f"🔴 Баланс=0: <b>{n_zero}</b>\n\n"
|
|
f"💰 Оборот: <b>{fmt(turn)}</b>\n📊 Комиссия: <b>{fmt(comm)}</b>\n\n"
|
|
f"📦 Заказов сегодня: <b>{orders_td}</b>\n⏳ На подтверждении: <b>{pending}</b>"
|
|
)
|
|
await msg.answer(txt, parse_mode="HTML", reply_markup=ib(("🔄 Обновить","stats_ref")))
|
|
|
|
@router.callback_query(F.data=="stats_ref")
|
|
@guard
|
|
async def stats_ref(cb: CallbackQuery):
|
|
await stats(cb.message); await cb.answer("Обновлено")
|
|
|
|
|
|
# ── Пользователи ──────────────────────────────────────────────────────────────
|
|
@router.message(F.text == "👥 Пользователи")
|
|
@guard
|
|
async def users(msg: Message):
|
|
async with AsyncSessionLocal() as db:
|
|
tenants = (await db.execute(
|
|
select(Tenant).order_by(desc(Tenant.created_at)).limit(20)
|
|
)).scalars().all()
|
|
if not tenants:
|
|
await msg.answer("Нет пользователей."); return
|
|
bld = InlineKeyboardBuilder()
|
|
txt = "👥 <b>Пользователи</b>\n\n"
|
|
for t in tenants:
|
|
em = "🔒" if t.is_blocked else ("🔴" if t.balance<=0 else "✅")
|
|
txt += f"{em} <b>{t.name}</b> · {t.email}\n 📦 {plan_title(t.plan)} · {bal_em(t.balance,t.alert_threshold)} {fmt(t.balance)}\n\n"
|
|
bld.add(InlineKeyboardButton(text=f"{em} {t.name[:22]}", callback_data=f"t_{t.id}"))
|
|
bld.adjust(2)
|
|
await msg.answer(txt, parse_mode="HTML", reply_markup=bld.as_markup())
|
|
|
|
@router.callback_query(F.data.startswith("t_"))
|
|
@guard
|
|
async def tenant_detail(cb: CallbackQuery, state: FSMContext):
|
|
data = cb.data or ""
|
|
if data.startswith("t_"):
|
|
tid = int(data[2:])
|
|
elif data.startswith("blk_"):
|
|
tid = int(data[4:])
|
|
elif data.startswith("setplan_"):
|
|
tid = int(data[len("setplan_"):].split("_", 1)[0])
|
|
else:
|
|
await cb.answer("Не удалось определить пользователя", show_alert=True)
|
|
return
|
|
async with AsyncSessionLocal() as db:
|
|
t = await db.get(Tenant, tid)
|
|
if not t:
|
|
await cb.answer("Не найден", show_alert=True)
|
|
return
|
|
shops_n = (await db.execute(select(func.count(Shop.id)).where(Shop.tenant_id == tid))).scalar()
|
|
trial_txt = f"\n🧪 Тест до: <b>{t.trial_ends_at:%d.%m.%Y}</b>" if t.trial_ends_at else ""
|
|
postpaid_txt = ""
|
|
if is_postpaid(t):
|
|
revenue, due = await postpaid_previous_month_totals(db, tid)
|
|
due_date = current_due_date(t)
|
|
postpaid_txt = (
|
|
f"\n🧾 Постоплата: <b>{t.postpaid_commission_percent:g}%</b> от выручки прошлого месяца"
|
|
f"\n📅 Оплата до: <b>{due_date:%d.%m.%Y}</b>"
|
|
f"\n📈 Прошлый месяц: {fmt(revenue)} · к оплате {fmt(due)}"
|
|
)
|
|
txt = (
|
|
f"👤 <b>{t.name}</b>\n{'─'*24}\n"
|
|
f"📧 {t.email}\n🆔 TG: <code>{t.telegram_id or '—'}</code>\n"
|
|
f"📦 Тариф: <b>{plan_title(t.plan)}</b>{trial_txt}{postpaid_txt}\n🏪 Магазинов: {shops_n}\n\n"
|
|
f"{bal_em(t.balance,t.alert_threshold)} Баланс: <b>{fmt(t.balance)}</b>\n"
|
|
f"⚠️ Порог: {fmt(t.alert_threshold)}\n"
|
|
f"Статус: {'🔒 Заблокирован' if t.is_blocked else '✅ Активен'}"
|
|
)
|
|
bld = InlineKeyboardBuilder()
|
|
bld.row(
|
|
InlineKeyboardButton(text="💳 Пополнить", callback_data=f"topup_{tid}"),
|
|
InlineKeyboardButton(text="🧾 Тариф", callback_data=f"plan_{tid}"),
|
|
)
|
|
bld.row(InlineKeyboardButton(
|
|
text="🔒 Блок" if not t.is_blocked else "🔓 Разблок",
|
|
callback_data=f"blk_{tid}",
|
|
))
|
|
bld.row(InlineKeyboardButton(text="← Назад", callback_data="users_back"))
|
|
await cb.message.edit_text(txt, parse_mode="HTML", reply_markup=bld.as_markup())
|
|
await cb.answer()
|
|
|
|
@router.callback_query(F.data=="users_back")
|
|
@guard
|
|
async def users_back(cb: CallbackQuery):
|
|
await users(cb.message); await cb.answer()
|
|
|
|
@router.callback_query(F.data.startswith("blk_"))
|
|
@guard
|
|
async def toggle_block(cb: CallbackQuery):
|
|
tid = int(cb.data[4:])
|
|
async with AsyncSessionLocal() as db:
|
|
t = await db.get(Tenant, tid)
|
|
if not t: await cb.answer("Не найден"); return
|
|
t.is_blocked = not t.is_blocked
|
|
await db.commit()
|
|
await cb.answer("🔒 Заблокирован" if t.is_blocked else "🔓 Разблокирован", show_alert=True)
|
|
await tenant_detail(cb, None)
|
|
|
|
|
|
|
|
|
|
# ── Тарифы пользователей ─────────────────────────────────────────────────────
|
|
def plan_keyboard(tid: int):
|
|
bld = InlineKeyboardBuilder()
|
|
bld.row(InlineKeyboardButton(text="🧪 Тест 7 дней", callback_data=f"setplan_{tid}_trial_week"))
|
|
bld.row(InlineKeyboardButton(text="Trial", callback_data=f"setplan_{tid}_trial"),
|
|
InlineKeyboardButton(text="Basic", callback_data=f"setplan_{tid}_basic"))
|
|
bld.row(InlineKeyboardButton(text="Pro", callback_data=f"setplan_{tid}_pro"),
|
|
InlineKeyboardButton(text="Enterprise", callback_data=f"setplan_{tid}_enterprise"))
|
|
bld.row(InlineKeyboardButton(text="🧾 Индивидуальный постоплатный", callback_data=f"postpaid_{tid}"))
|
|
bld.row(InlineKeyboardButton(text="← Назад", callback_data=f"t_{tid}"))
|
|
return bld.as_markup()
|
|
|
|
|
|
@router.callback_query(F.data.startswith("plan_"))
|
|
@guard
|
|
async def plan_menu(cb: CallbackQuery):
|
|
tid = int(cb.data[5:])
|
|
async with AsyncSessionLocal() as db:
|
|
t = await db.get(Tenant, tid)
|
|
if not t:
|
|
await cb.answer("Не найден", show_alert=True)
|
|
return
|
|
await cb.message.edit_text(
|
|
f"🧾 <b>Тариф пользователя</b>\n\n👤 {t.name}\nТекущий: <b>{plan_title(t.plan)}</b>\n\n"
|
|
"Постоплатный тариф применяется только вручную администратором.",
|
|
parse_mode="HTML",
|
|
reply_markup=plan_keyboard(tid),
|
|
)
|
|
await cb.answer()
|
|
|
|
|
|
@router.callback_query(F.data.startswith("setplan_"))
|
|
@guard
|
|
async def set_regular_plan(cb: CallbackQuery):
|
|
raw = cb.data[len("setplan_"):]
|
|
tid_raw, plan_raw = raw.split("_", 1)
|
|
tid = int(tid_raw)
|
|
if plan_raw not in {p.value for p in PlanEnum} or plan_raw == PlanEnum.postpaid_custom.value:
|
|
await cb.answer("Некорректный тариф", show_alert=True)
|
|
return
|
|
async with AsyncSessionLocal() as db:
|
|
t = await db.get(Tenant, tid)
|
|
if not t:
|
|
await cb.answer("Не найден", show_alert=True)
|
|
return
|
|
t.plan = PlanEnum(plan_raw)
|
|
t.trial_ends_at = datetime.utcnow() + timedelta(days=7) if plan_raw == PlanEnum.trial_week.value else None
|
|
t.postpaid_enabled_at = None
|
|
t.postpaid_note = ""
|
|
if t.is_blocked and t.balance > 0:
|
|
t.is_blocked = False
|
|
await db.commit()
|
|
await cb.answer("Тариф применён", show_alert=True)
|
|
await tenant_detail(cb, None)
|
|
|
|
|
|
@router.callback_query(F.data.startswith("postpaid_"))
|
|
@guard
|
|
async def postpaid_start(cb: CallbackQuery, state: FSMContext):
|
|
tid = int(cb.data[len("postpaid_"):])
|
|
async with AsyncSessionLocal() as db:
|
|
t = await db.get(Tenant, tid)
|
|
if not t:
|
|
await cb.answer("Не найден", show_alert=True)
|
|
return
|
|
await state.update_data(tid=tid, tname=t.name)
|
|
await state.set_state(S.plan_percent)
|
|
await cb.message.answer(
|
|
f"🧾 Индивидуальная постоплата для <b>{t.name}</b>\n\n"
|
|
"Введите процент комиссии от выручки предыдущего месяца, например: 5",
|
|
parse_mode="HTML",
|
|
reply_markup=ReplyKeyboardRemove(),
|
|
)
|
|
await cb.answer()
|
|
|
|
|
|
@router.message(S.plan_percent)
|
|
@guard
|
|
async def postpaid_percent(msg: Message, state: FSMContext):
|
|
try:
|
|
percent = float(msg.text.replace(",", ".").replace(" ", ""))
|
|
assert 0 < percent <= 100
|
|
except Exception:
|
|
await msg.answer("❌ Введите процент числом от 0.1 до 100, например: 5")
|
|
return
|
|
await state.update_data(percent=percent)
|
|
await state.set_state(S.plan_due_day)
|
|
await msg.answer("📅 Введите день месяца для оплаты комиссии: 1–28")
|
|
|
|
|
|
@router.message(S.plan_due_day)
|
|
@guard
|
|
async def postpaid_due_day(msg: Message, state: FSMContext):
|
|
try:
|
|
day = int(msg.text.strip())
|
|
assert 1 <= day <= 28
|
|
except Exception:
|
|
await msg.answer("❌ Введите день месяца числом от 1 до 28")
|
|
return
|
|
data = await state.get_data()
|
|
async with AsyncSessionLocal() as db:
|
|
t = await db.get(Tenant, data["tid"])
|
|
if not t:
|
|
await state.clear()
|
|
await msg.answer("Пользователь не найден.", reply_markup=main_kb())
|
|
return
|
|
t.plan = PlanEnum.postpaid_custom
|
|
t.trial_ends_at = None
|
|
t.postpaid_commission_percent = float(data["percent"])
|
|
t.postpaid_due_day = day
|
|
t.postpaid_enabled_at = datetime.utcnow()
|
|
t.postpaid_note = f"Назначено администратором {msg.from_user.id}"
|
|
t.is_blocked = False
|
|
await db.commit()
|
|
await state.clear()
|
|
await msg.answer(
|
|
f"✅ Постоплатный тариф применён\n\n👤 {data['tname']}\n"
|
|
f"Комиссия: <b>{data['percent']:g}%</b> от выручки прошлого месяца\n"
|
|
f"Оплата: до <b>{day}</b> числа каждого месяца",
|
|
parse_mode="HTML",
|
|
reply_markup=main_kb(),
|
|
)
|
|
|
|
|
|
@router.message(F.text == "🧾 Постоплата")
|
|
@guard
|
|
async def postpaid_report(msg: Message):
|
|
async with AsyncSessionLocal() as db:
|
|
tenants = (await db.execute(
|
|
select(Tenant).where(Tenant.plan == PlanEnum.postpaid_custom).order_by(Tenant.name.asc())
|
|
)).scalars().all()
|
|
if not tenants:
|
|
await msg.answer("🧾 Постоплатных пользователей пока нет.")
|
|
return
|
|
lines = ["🧾 <b>Индивидуальная постоплата</b>\n"]
|
|
for t in tenants:
|
|
revenue, due = await postpaid_previous_month_totals(db, t.id)
|
|
due_date = current_due_date(t)
|
|
lines.append(
|
|
f"👤 <b>{t.name}</b> · {t.postpaid_commission_percent:g}%\n"
|
|
f" Выручка прошлого месяца: {fmt(revenue)}\n"
|
|
f" К оплате: <b>{fmt(due)}</b> до {due_date:%d.%m.%Y}\n"
|
|
)
|
|
await msg.answer("\n".join(lines), parse_mode="HTML")
|
|
|
|
|
|
# ── Балансы ───────────────────────────────────────────────────────────────────
|
|
@router.message(F.text == "💰 Балансы")
|
|
@guard
|
|
async def balances(msg: Message):
|
|
async with AsyncSessionLocal() as db:
|
|
tenants = (await db.execute(
|
|
select(Tenant).where(Tenant.is_active==True).order_by(Tenant.balance.asc())
|
|
)).scalars().all()
|
|
crit, low, ok_list = [], [], []
|
|
for t in tenants:
|
|
line = f"{bal_em(t.balance,t.alert_threshold)} <b>{t.name[:20]}</b>: {fmt(t.balance)}"
|
|
if t.balance <= 0: crit.append(line + " 🔴 СТОП")
|
|
elif t.balance <= t.alert_threshold: low.append(line)
|
|
else: ok_list.append(line)
|
|
txt = "💰 <b>Балансы</b>\n\n"
|
|
if crit: txt += "🔴 <b>Критично:</b>\n" + "\n".join(crit) + "\n\n"
|
|
if low: txt += "🟡 <b>Низкий:</b>\n" + "\n".join(low) + "\n\n"
|
|
txt += f"🟢 В норме: {len(ok_list)}"
|
|
await msg.answer(txt, parse_mode="HTML",
|
|
reply_markup=ib(("🔄 Обновить","bal_ref")))
|
|
|
|
@router.callback_query(F.data=="bal_ref")
|
|
@guard
|
|
async def bal_ref(cb: CallbackQuery):
|
|
await balances(cb.message); await cb.answer("Обновлено")
|
|
|
|
|
|
# ── Пополнение баланса ────────────────────────────────────────────────────────
|
|
@router.callback_query(F.data.startswith("topup_"))
|
|
@guard
|
|
async def topup_start(cb: CallbackQuery, state: FSMContext):
|
|
tid = int(cb.data[6:])
|
|
async with AsyncSessionLocal() as db:
|
|
t = await db.get(Tenant, tid)
|
|
await state.update_data(tid=tid, tname=t.name, tbal=t.balance)
|
|
await state.set_state(S.topup_amount)
|
|
await cb.message.answer(
|
|
f"💳 Пополнение: <b>{t.name}</b>\nБаланс: {fmt(t.balance)}\n\nВведите сумму (₽):",
|
|
parse_mode="HTML", reply_markup=ReplyKeyboardRemove())
|
|
await cb.answer()
|
|
|
|
@router.message(S.topup_amount)
|
|
@guard
|
|
async def topup_amount(msg: Message, state: FSMContext):
|
|
try:
|
|
amt = float(msg.text.replace(",",".").replace(" ",""))
|
|
assert amt > 0
|
|
except:
|
|
await msg.answer("❌ Введите сумму, например: 1000"); return
|
|
await state.update_data(amt=amt)
|
|
await state.set_state(S.topup_note)
|
|
await msg.answer(f"Сумма: <b>{fmt(amt)}</b>\nКомментарий (или '-'):", parse_mode="HTML")
|
|
|
|
@router.message(S.topup_note)
|
|
@guard
|
|
async def topup_note(msg: Message, state: FSMContext):
|
|
data = await state.get_data()
|
|
note = msg.text if msg.text != "-" else "Пополнение администратором"
|
|
amt = data["amt"]
|
|
async with AsyncSessionLocal() as db:
|
|
t = await db.get(Tenant, data["tid"])
|
|
old = t.balance
|
|
t.balance += amt
|
|
if old <= 0 and t.balance > 0:
|
|
t.is_blocked = False
|
|
db.add(BalanceTransaction(
|
|
tenant_id=t.id, type="deposit", amount=amt,
|
|
balance_after=t.balance, note=f"[Admin] {note}"))
|
|
await db.commit()
|
|
await state.clear()
|
|
await msg.answer(
|
|
f"✅ <b>Пополнено</b>\n{data['tname']}\n+{fmt(amt)}\nБаланс: {fmt(t.balance)}\n{note}",
|
|
parse_mode="HTML", reply_markup=main_kb())
|
|
# Уведомить владельца
|
|
if t.telegram_id:
|
|
try:
|
|
bot = Bot(token=settings.PLATFORM_BOT_TOKEN)
|
|
await bot.send_message(t.telegram_id,
|
|
f"💰 <b>Баланс пополнен!</b>\n+{fmt(amt)}\nВаш баланс: {fmt(t.balance)}\n{note}",
|
|
parse_mode="HTML")
|
|
await bot.session.close()
|
|
except Exception: pass
|
|
|
|
|
|
|
|
|
|
async def deliver_order(shop_id: int, buyer_tg_id: int, content: str, order_id: int) -> bool:
|
|
try:
|
|
async with AsyncSessionLocal() as db:
|
|
tok = (await db.execute(select(ShopToken).where(
|
|
ShopToken.shop_id == shop_id,
|
|
ShopToken.is_active == True,
|
|
))).scalar_one_or_none()
|
|
if not tok:
|
|
logger.warning("order %s: active shop token not found", order_id)
|
|
return False
|
|
bot = Bot(token=tok.token)
|
|
try:
|
|
await bot.send_message(
|
|
buyer_tg_id,
|
|
f"✅ <b>Оплата подтверждена!</b>\n\nЗаказ #{order_id}\n\n<code>{content}</code>",
|
|
parse_mode="HTML",
|
|
)
|
|
return True
|
|
finally:
|
|
await bot.session.close()
|
|
except Exception as e:
|
|
logger.error("deliver_order #%s failed: %s", order_id, e)
|
|
return False
|
|
|
|
|
|
# ── Заказы ────────────────────────────────────────────────────────────────────
|
|
@router.message(F.text == "📦 Заказы")
|
|
@guard
|
|
async def orders_menu(msg: Message):
|
|
async with AsyncSessionLocal() as db:
|
|
pending = (await db.execute(
|
|
select(Order)
|
|
.where(Order.status.in_([OrderStatus.pending, OrderStatus.confirming]))
|
|
.order_by(Order.created_at.asc()).limit(10)
|
|
)).scalars().all()
|
|
if not pending:
|
|
await msg.answer("✅ Ожидающих заказов нет."); return
|
|
txt = f"📦 <b>На подтверждении: {len(pending)}</b>\n\n"
|
|
bld = InlineKeyboardBuilder()
|
|
for o in pending:
|
|
em = "🟡" if o.status==OrderStatus.pending else "🟠"
|
|
txt += f"{em} #{o.id} · {fmt(o.amount)} · {o.created_at:%d.%m %H:%M}\n"
|
|
bld.add(InlineKeyboardButton(text=f"{em}#{o.id}·{o.amount:.0f}₽", callback_data=f"ord_{o.id}"))
|
|
bld.adjust(3)
|
|
await msg.answer(txt, parse_mode="HTML", reply_markup=bld.as_markup())
|
|
|
|
@router.callback_query(F.data.startswith("ord_"))
|
|
@guard
|
|
async def order_detail(cb: CallbackQuery):
|
|
oid = int(cb.data[4:])
|
|
async with AsyncSessionLocal() as db:
|
|
o = await db.get(Order, oid)
|
|
if not o: await cb.answer("Не найден", show_alert=True); return
|
|
shop = await db.get(Shop, o.shop_id)
|
|
txt = (
|
|
f"📦 <b>Заказ #{o.id}</b>\n{'─'*24}\n"
|
|
f"🏪 {shop.name if shop else '—'}\n"
|
|
f"👤 {o.buyer_username or o.buyer_telegram_id}\n"
|
|
f"💰 {fmt(o.amount)} | Комиссия: {fmt(o.commission)}\n"
|
|
f"📅 {o.created_at:%d.%m.%Y %H:%M}"
|
|
)
|
|
bld = InlineKeyboardBuilder()
|
|
if o.status in [OrderStatus.pending, OrderStatus.confirming]:
|
|
bld.row(InlineKeyboardButton(text="✅ Подтвердить", callback_data=f"oc_{oid}"),
|
|
InlineKeyboardButton(text="❌ Отклонить", callback_data=f"or_{oid}"))
|
|
bld.row(InlineKeyboardButton(text="← Назад", callback_data="orders_back"))
|
|
if o.proof_file_id:
|
|
await cb.message.answer_photo(photo=o.proof_file_id, caption=txt,
|
|
parse_mode="HTML", reply_markup=bld.as_markup())
|
|
else:
|
|
await cb.message.edit_text(txt, parse_mode="HTML", reply_markup=bld.as_markup())
|
|
await cb.answer()
|
|
|
|
@router.callback_query(F.data.startswith("oc_"))
|
|
@guard
|
|
async def order_confirm(cb: CallbackQuery):
|
|
oid = int(cb.data[3:])
|
|
charged_now = False
|
|
async with AsyncSessionLocal() as db:
|
|
o = await db.get(Order, oid)
|
|
if not o or o.status not in [OrderStatus.pending, OrderStatus.confirming]:
|
|
await cb.answer("Нельзя подтвердить", show_alert=True)
|
|
return
|
|
shop = await db.get(Shop, o.shop_id)
|
|
tenant = await db.get(Tenant, shop.tenant_id) if shop else None
|
|
ok, reason = tenant_can_sell(tenant)
|
|
if not ok:
|
|
await cb.answer(f"❌ {reason}", show_alert=True)
|
|
return
|
|
|
|
product = await db.get(Product, o.product_id)
|
|
card = await db.get(PaymentCard, o.card_id) if o.card_id else None
|
|
|
|
o.status = OrderStatus.completed
|
|
o.confirmed_by = cb.from_user.id
|
|
|
|
if product:
|
|
product.sold += 1
|
|
if product.stock > 0:
|
|
product.stock -= 1
|
|
if product.stock <= 0:
|
|
product.is_active = False
|
|
|
|
if card:
|
|
card.received_total += o.amount
|
|
|
|
if tenant and not is_postpaid(tenant):
|
|
old_balance = tenant.balance
|
|
tenant.balance -= o.commission
|
|
charged_now = True
|
|
db.add(BalanceTransaction(
|
|
tenant_id=tenant.id,
|
|
type="commission",
|
|
amount=-o.commission,
|
|
balance_after=tenant.balance,
|
|
note=f"Комиссия заказ #{oid}",
|
|
order_id=oid,
|
|
))
|
|
if old_balance > 0 and tenant.balance <= 0:
|
|
tenant.is_blocked = True
|
|
elif tenant:
|
|
db.add(BalanceTransaction(
|
|
tenant_id=tenant.id,
|
|
type="postpaid_accrual",
|
|
amount=0,
|
|
balance_after=tenant.balance,
|
|
note=f"Начислена постоплатная комиссия {fmt(o.commission)} за заказ #{oid}",
|
|
order_id=oid,
|
|
))
|
|
|
|
shop_id = o.shop_id
|
|
buyer_id = o.buyer_telegram_id
|
|
content = o.product_content
|
|
await db.commit()
|
|
|
|
delivered = await deliver_order(shop_id, buyer_id, content, oid)
|
|
suffix = "комиссия списана" if charged_now else "комиссия начислена в постоплату"
|
|
delivery = "товар выдан" if delivered else "товар НЕ отправлен — нет активного токена магазина"
|
|
text = f"✅ Заказ #{oid} подтверждён: {delivery}, {suffix}."
|
|
if getattr(cb.message, "photo", None):
|
|
await cb.message.edit_caption(caption=text, parse_mode="HTML")
|
|
else:
|
|
await cb.message.edit_text(text, parse_mode="HTML")
|
|
await cb.answer("✅ Подтверждено!")
|
|
|
|
@router.callback_query(F.data.startswith("or_"))
|
|
@guard
|
|
async def order_reject(cb: CallbackQuery):
|
|
oid = int(cb.data[3:])
|
|
async with AsyncSessionLocal() as db:
|
|
o = await db.get(Order, oid)
|
|
if o: o.status = OrderStatus.rejected; await db.commit()
|
|
await cb.message.edit_text(f"❌ Заказ #{oid} отклонён.")
|
|
await cb.answer("Отклонено")
|
|
|
|
@router.callback_query(F.data=="orders_back")
|
|
@guard
|
|
async def orders_back(cb: CallbackQuery):
|
|
await orders_menu(cb.message); await cb.answer()
|
|
|
|
|
|
# ── Рассылка ──────────────────────────────────────────────────────────────────
|
|
@router.message(F.text == "📢 Рассылка")
|
|
@guard
|
|
async def broadcast_start(msg: Message, state: FSMContext):
|
|
await state.set_state(S.broadcast)
|
|
b = ReplyKeyboardBuilder(); b.add(KeyboardButton(text="❌ Отмена"))
|
|
await msg.answer("📢 Введите текст рассылки (HTML):", reply_markup=b.as_markup(resize_keyboard=True))
|
|
|
|
@router.message(S.broadcast)
|
|
@guard
|
|
async def broadcast_text(msg: Message, state: FSMContext):
|
|
if msg.text == "❌ Отмена":
|
|
await state.clear(); await msg.answer("Отменено.", reply_markup=main_kb()); return
|
|
await state.update_data(text=msg.text)
|
|
await state.set_state(S.bcast_ok)
|
|
async with AsyncSessionLocal() as db:
|
|
n = (await db.execute(select(func.count(Tenant.id))
|
|
.where(Tenant.telegram_id != None, Tenant.is_active==True))).scalar()
|
|
bld = InlineKeyboardBuilder()
|
|
bld.row(InlineKeyboardButton(text=f"✅ Отправить {n} польз.", callback_data="bcast_go"),
|
|
InlineKeyboardButton(text="❌ Отмена", callback_data="bcast_no"))
|
|
await msg.answer(f"Предпросмотр:\n\n{msg.text}\n\n👥 Получателей: {n}",
|
|
parse_mode="HTML", reply_markup=bld.as_markup())
|
|
|
|
@router.callback_query(F.data=="bcast_go", S.bcast_ok)
|
|
@guard
|
|
async def broadcast_go(cb: CallbackQuery, state: FSMContext):
|
|
data = await state.get_data(); await state.clear()
|
|
async with AsyncSessionLocal() as db:
|
|
tenants = (await db.execute(
|
|
select(Tenant).where(Tenant.telegram_id!=None, Tenant.is_active==True)
|
|
)).scalars().all()
|
|
bot = Bot(token=settings.PLATFORM_BOT_TOKEN)
|
|
sent = fail = 0
|
|
for t in tenants:
|
|
try:
|
|
await bot.send_message(t.telegram_id, data["text"], parse_mode="HTML")
|
|
sent += 1; await asyncio.sleep(0.05)
|
|
except: fail += 1
|
|
await bot.session.close()
|
|
await cb.message.edit_text(f"📢 Рассылка завершена\n✅ {sent} · ❌ {fail}")
|
|
await cb.answer()
|
|
|
|
@router.callback_query(F.data=="bcast_no")
|
|
@guard
|
|
async def broadcast_no(cb: CallbackQuery, state: FSMContext):
|
|
await state.clear(); await cb.message.edit_text("Отменено."); await cb.answer()
|
|
|
|
|
|
# ── Настройки ─────────────────────────────────────────────────────────────────
|
|
@router.message(F.text == "⚙️ Настройки")
|
|
@guard
|
|
async def platform_settings(msg: Message):
|
|
c = settings.commission
|
|
txt = (
|
|
f"⚙️ <b>Настройки платформы</b>\n\n"
|
|
f"Комиссии:\n Тест 7 дней: {c['trial_week']}% | Trial: {c['trial']}% | Basic: {c['basic']}%\n"
|
|
f" Pro: {c['pro']}% | Enterprise: {c['enterprise']}% | Постоплата default: {c['postpaid_custom']}%\n\n"
|
|
f"API: {settings.API_HOST}:{settings.API_PORT}\n"
|
|
f"Domain: {settings.DOMAIN or '—'}"
|
|
)
|
|
await msg.answer(txt, parse_mode="HTML")
|
|
|
|
|
|
# ── Уведомления (вызываются из кода) ─────────────────────────────────────────
|
|
async def notify_admins(bot: Bot, text: str):
|
|
for aid in settings.admin_ids:
|
|
try: await bot.send_message(aid, text, parse_mode="HTML")
|
|
except Exception as e: logger.warning(f"notify {aid}: {e}")
|
|
|
|
async def notify_zero_balance(bot: Bot, tenant: Tenant):
|
|
await notify_admins(bot,
|
|
f"🔴 <b>Баланс исчерпан — боты остановлены!</b>\n\n"
|
|
f"👤 {tenant.name} ({tenant.email})\n"
|
|
f"💰 Баланс: {fmt(tenant.balance)}\n\n/topup_{tenant.id}")
|
|
|
|
async def notify_low_balance(bot: Bot, tenant: Tenant):
|
|
await notify_admins(bot,
|
|
f"🟡 <b>Низкий баланс</b>\n\n"
|
|
f"👤 {tenant.name}\n"
|
|
f"💰 Баланс: {fmt(tenant.balance)} (порог {fmt(tenant.alert_threshold)})")
|
|
|
|
|
|
# ── Запуск ────────────────────────────────────────────────────────────────────
|
|
async def start_platform_bot():
|
|
if not settings.PLATFORM_BOT_TOKEN:
|
|
logger.warning("PLATFORM_BOT_TOKEN не задан — платформенный бот отключён")
|
|
return
|
|
storage = RedisStorage.from_url(settings.REDIS_URL)
|
|
bot = Bot(token=settings.PLATFORM_BOT_TOKEN)
|
|
dp = Dispatcher(storage=storage)
|
|
dp.include_router(router)
|
|
logger.info("Platform admin bot started")
|
|
try:
|
|
await dp.start_polling(bot, allowed_updates=["message","callback_query"])
|
|
finally:
|
|
await bot.session.close()
|
|
|
|
if __name__ == "__main__":
|
|
logging.basicConfig(level=logging.INFO)
|
|
asyncio.run(start_platform_bot())
|
© 2026 StackWorks