currency/fast flow for everyone/optimization and cache/new payment system/and more

2025-09-15 21:55:31 +03:00
parent 6d9e1aba4a
commit d6b920ff4d
102 changed files with 3033 additions and 1710 deletions
@@ -20,4 +20,4 @@ async def get_hot_leads(session: AsyncSession):
    )

    result = await session.execute(stmt)
-    return [row.tg_id for row in result]
+    return [row.tg_id for row in result]
@@ -45,9 +45,9 @@ async def store_key(

        try:
            await clear_hot_lead_notifications(session, tg_id)
-        except Exception as e:
+        except Exception:
            pass
-            
+
    except SQLAlchemyError as e:
        logger.error(f"❌ Ошибка при сохранении ключа: {e}")
        await session.rollback()
@@ -3,18 +3,8 @@ import uuid

 from datetime import datetime

-from sqlalchemy import (
-    JSON,
-    BigInteger,
-    Boolean,
-    Column,
-    DateTime,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    Text,
-)
+from sqlalchemy import JSON, BigInteger, Boolean, Column, DateTime, Float, ForeignKey, Integer, Numeric, String, Text
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.orm import Mapped, declarative_base, mapped_column


@@ -43,14 +33,16 @@ class User(DictLikeMixin, Base):
    is_bot = Column(Boolean, default=False)
    balance = Column(Float, default=0.0)
    trial = Column(Integer, default=0)
+    preferred_currency = Column(String(10), nullable=False, server_default="RUB", index=True)
    source_code = Column(
        String,
        ForeignKey(
            "tracking_sources.code",
            ondelete="SET NULL",
-            onupdate="CASCADE", 
+            onupdate="CASCADE",
        ),
-        nullable=True, )
+        nullable=True,
+    )
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow)

@@ -114,6 +106,10 @@ class Payment(DictLikeMixin, Base):
    payment_system = Column(String)
    status = Column(String)
    created_at = Column(DateTime, default=datetime.utcnow)
+    original_amount = Column(Numeric(18, 8), nullable=True)
+    currency = Column(String(10), nullable=False, server_default="RUB")
+    payment_id = Column(String(128), nullable=True, index=True)
+    metadata_ = Column("metadata", JSONB, nullable=True)


 class Coupon(DictLikeMixin, Base):
@@ -131,11 +127,7 @@ class Coupon(DictLikeMixin, Base):
 class CouponUsage(DictLikeMixin, Base):
    __tablename__ = "coupon_usages"

-    coupon_id = Column(
-        Integer,
-        ForeignKey("coupons.id", ondelete="CASCADE"),
-        primary_key=True
-    )
+    coupon_id = Column(Integer, ForeignKey("coupons.id", ondelete="CASCADE"), primary_key=True)
    user_id = Column(BigInteger, primary_key=True)
    used_at = Column(DateTime, default=datetime.utcnow)

@@ -70,32 +70,27 @@ async def check_hot_lead_discount(session: AsyncSession, tg_id: int) -> dict:
        result = await session.execute(
            select(Notification.notification_type, Notification.last_notification_time)
            .where(Notification.tg_id == tg_id)
-            .where(Notification.notification_type.in_(['hot_lead_step_2', 'hot_lead_step_3']))
+            .where(Notification.notification_type.in_(["hot_lead_step_2", "hot_lead_step_3"]))
            .order_by(Notification.last_notification_time.desc())
            .limit(1)
        )
-        
+
        row = result.first()
        if not row:
            return {"available": False}
-        
+
        notification_type, last_time = row

        expires_at = last_time + timedelta(hours=DISCOUNT_ACTIVE_HOURS)
        current_time = datetime.utcnow()
-        
+
        if current_time > expires_at:
            return {"available": False}

        tariff_group = "discounts" if notification_type == "hot_lead_step_2" else "discounts_max"
-        
-        return {
-            "available": True,
-            "type": notification_type,
-            "tariff_group": tariff_group,
-            "expires_at": expires_at
-        }
-        
+
+        return {"available": True, "type": notification_type, "tariff_group": tariff_group, "expires_at": expires_at}
+
    except Exception as e:
        logger.error(f"❌ Ошибка при проверке скидки горячего лида для {tg_id}: {e}")
        return {"available": False}
@@ -106,7 +101,12 @@ async def clear_hot_lead_notifications(session: AsyncSession, tg_id: int):
        await session.execute(
            delete(Notification).where(
                Notification.tg_id == tg_id,
-                Notification.notification_type.in_(['hot_lead_step_1', 'hot_lead_step_2', 'hot_lead_step_3', 'hot_lead_step_2_expired'])
+                Notification.notification_type.in_([
+                    "hot_lead_step_1",
+                    "hot_lead_step_2",
+                    "hot_lead_step_3",
+                    "hot_lead_step_2_expired",
+                ]),
            )
        )
        await session.commit()
@@ -1,7 +1,8 @@
-from datetime import datetime
+from datetime import datetime, timedelta
+from typing import Optional

 from pytz import timezone
-from sqlalchemy import insert, select
+from sqlalchemy import and_, insert, select, update
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession

@@ -12,33 +13,153 @@ from logger import logger
 MOSCOW_TZ = timezone("Europe/Moscow")


-async def add_payment(session: AsyncSession, tg_id: int, amount: float, payment_system: str):
+async def add_payment(
+    session: AsyncSession,
+    tg_id: int,
+    amount: float,
+    payment_system: str,
+    *,
+    status: str = "success",
+    currency: str = "RUB",
+    payment_id: str | None = None,
+    metadata: dict | None = None,
+    original_amount: float | None = None,
+) -> int:
    try:
        now_moscow = datetime.now(MOSCOW_TZ).replace(tzinfo=None)
-        stmt = insert(Payment).values(
-            tg_id=tg_id,
-            amount=amount,
-            payment_system=payment_system,
-            status="success",
-            created_at=now_moscow,
+        stmt = (
+            insert(Payment)
+            .values(
+                tg_id=tg_id,
+                amount=amount,
+                payment_system=payment_system,
+                status=status,
+                created_at=now_moscow,
+                currency=currency,
+                payment_id=payment_id,
+                metadata_=metadata,
+                original_amount=original_amount,
+            )
+            .returning(Payment.id)
        )
-        await session.execute(stmt)
+        result = await session.execute(stmt)
+        internal_id = result.scalar_one()
        await session.commit()
-        logger.info(f"✅ Успешно добавлен платёж: {tg_id}, {amount}₽ через {payment_system}")
+        logger.info(
+            f"Добавлен платёж id={internal_id}: tg_id={tg_id}, amount={amount}, system={payment_system}, status={status}"
+        )
+        return internal_id
    except SQLAlchemyError as e:
-        logger.error(f"❌ Ошибка при добавлении платежа: {e}")
        await session.rollback()
+        logger.error(f"Ошибка при добавлении платежа: {e}")
        raise


-async def get_last_payments(session: AsyncSession, tg_id: int, limit: int = 3):
+async def get_last_payments(
+    session: AsyncSession,
+    tg_id: int,
+    limit: int = 3,
+    statuses: list[str] | None = None,
+):
+    query = select(Payment).where(Payment.tg_id == tg_id)
+
+    if statuses:
+        query = query.where(Payment.status.in_(statuses))
+
+    query = query.order_by(Payment.created_at.desc()).limit(limit)
+
+    result = await session.execute(query)
+    payments = result.scalars().all()
+    return [
+        {
+            "id": p.id,
+            "tg_id": p.tg_id,
+            "amount": p.amount,
+            "currency": p.currency,
+            "status": p.status,
+            "payment_system": p.payment_system,
+            "payment_id": p.payment_id,
+            "created_at": p.created_at,
+            "metadata": p.metadata_,
+            "original_amount": p.original_amount,
+        }
+        for p in payments
+    ]
+
+
+async def get_payment_by_id(session: AsyncSession, internal_id: int) -> dict | None:
    try:
-        result = await session.execute(
-            select(Payment).where(Payment.tg_id == tg_id).order_by(Payment.created_at.desc()).limit(limit)
-        )
-        payments = result.scalars().all()
-        logger.info(f"✅ Получены последние платежи пользователя {tg_id}, всего: {len(payments)}")
-        return [dict(p.__dict__) for p in payments]
+        result = await session.execute(select(Payment).where(Payment.id == internal_id).limit(1))
+        payment = result.scalar_one_or_none()
+        if payment:
+            logger.info(f"Найден платёж id={internal_id}")
+            return dict(payment.__dict__)
+        logger.info(f"Платёж id={internal_id} не найден")
+        return None
    except SQLAlchemyError as e:
-        logger.error(f"❌ Ошибка при получении платежей пользователя {tg_id}: {e}")
-        return []
+        logger.error(f"Ошибка при поиске платежа id={internal_id}: {e}")
+        return None
+
+
+async def update_payment_status(
+    session: AsyncSession,
+    internal_id: int,
+    new_status: str,
+    *,
+    payment_id: str | None = None,
+    metadata_patch: dict | None = None,
+) -> bool:
+    try:
+        result = await session.execute(select(Payment).where(Payment.id == internal_id).limit(1))
+        payment = result.scalar_one_or_none()
+        if not payment:
+            logger.info(f"Не удалось сменить статус: платёж id={internal_id} не найден")
+            return False
+
+        payment.status = new_status
+        if payment_id is not None:
+            payment.payment_id = payment_id
+        if metadata_patch:
+            base = payment.metadata_ or {}
+            base.update(metadata_patch)
+            payment.metadata_ = base
+
+        await session.commit()
+        logger.info(f"Статус платежа id={internal_id} изменён на {new_status}")
+        return True
+    except SQLAlchemyError as e:
+        await session.rollback()
+        logger.error(f"Ошибка при смене статуса платежа id={internal_id}: {e}")
+        return False
+
+
+async def get_payment_by_payment_id(session: AsyncSession, pid: str) -> dict | None:
+    try:
+        result = await session.execute(select(Payment).where(Payment.payment_id == pid).limit(1))
+        payment = result.scalar_one_or_none()
+        if payment:
+            logger.info(f"Найден платёж payment_id={pid}")
+            return dict(payment.__dict__)
+        logger.info(f"Платёж payment_id={pid} не найден")
+        return None
+    except SQLAlchemyError as e:
+        logger.error(f"Ошибка при поиске платежа payment_id={pid}: {e}")
+        return None
+
+
+async def cancel_expired_pending_payments(session: AsyncSession) -> int:
+    cutoff = datetime.now(MOSCOW_TZ).replace(tzinfo=None) - timedelta(minutes=60)
+    stmt = (
+        update(Payment)
+        .where(
+            and_(
+                Payment.status.in_(("pending", "issued", "processing", "awaiting_choice")),
+                Payment.created_at < cutoff,
+            )
+        )
+        .values(status="cancelled")
+        .returning(Payment.id)
+    )
+    res = await session.execute(stmt)
+    await session.commit()
+    return len(res.fetchall())
@@ -34,15 +34,9 @@ async def count_active_keys(session: AsyncSession) -> int:


 async def count_trial_keys(session: AsyncSession) -> int:
-    trial_tariffs_subquery = (
-        select(Tariff.id).where(Tariff.group_code == "trial")
-    )
-    
-    return await session.scalar(
-        select(func.count())
-        .select_from(Key)
-        .where(Key.tariff_id.in_(trial_tariffs_subquery))
-    )
+    trial_tariffs_subquery = select(Tariff.id).where(Tariff.group_code == "trial")
+
+    return await session.scalar(select(func.count()).select_from(Key).where(Key.tariff_id.in_(trial_tariffs_subquery)))


 async def get_tariff_distribution(
@@ -93,7 +87,11 @@ async def count_total_referrals(session: AsyncSession) -> int:
 async def sum_payments_since(session: AsyncSession, since: date) -> float:
    result = await session.scalar(
        select(func.coalesce(func.sum(Payment.amount), 0)).where(
-            and_(Payment.created_at >= since, Payment.payment_system.notin_(["referral", "coupon", "cashback"]))
+            and_(
+                Payment.created_at >= since,
+                Payment.status == "success",
+                Payment.payment_system.notin_(["referral", "coupon", "cashback"]),
+            )
        )
    )
    return round(float(result), 2)
@@ -105,6 +103,7 @@ async def sum_payments_between(session: AsyncSession, start: date, end: date) ->
            and_(
                Payment.created_at >= start,
                Payment.created_at < end,
+                Payment.status == "success",
                Payment.payment_system.notin_(["referral", "coupon", "cashback"]),
            )
        )
@@ -115,7 +114,10 @@ async def sum_payments_between(session: AsyncSession, start: date, end: date) ->
 async def sum_total_payments(session: AsyncSession) -> float:
    result = await session.scalar(
        select(func.coalesce(func.sum(Payment.amount), 0)).where(
-            Payment.payment_system.notin_(["referral", "coupon", "cashback"])
+            and_(
+                Payment.status == "success",
+                Payment.payment_system.notin_(["referral", "coupon", "cashback"]),
+            )
        )
    )
    return round(float(result), 2)
@@ -1,6 +1,6 @@
 import hashlib
-from collections import defaultdict

+from collections import defaultdict
 from datetime import datetime

 from sqlalchemy import delete, func, insert, select, update
@@ -35,15 +35,15 @@ async def find_subgroup_by_hash(session: AsyncSession, subgroup_hash: str, group
    return None


-async def get_tariffs(session: AsyncSession, tariff_id: int = None, group_code: str = None, with_subgroup_weights: bool = False):
+async def get_tariffs(
+    session: AsyncSession, tariff_id: int = None, group_code: str = None, with_subgroup_weights: bool = False
+):
    try:
        if tariff_id:
            result = await session.execute(select(Tariff).where(Tariff.id == tariff_id))
        elif group_code:
            result = await session.execute(
-                select(Tariff)
-                .where(Tariff.group_code == group_code)
-                .order_by(Tariff.sort_order, Tariff.id)
+                select(Tariff).where(Tariff.group_code == group_code).order_by(Tariff.sort_order, Tariff.id)
            )
        else:
            result = await session.execute(select(Tariff).order_by(Tariff.sort_order, Tariff.id))
@@ -55,26 +55,21 @@ async def get_tariffs(session: AsyncSession, tariff_id: int = None, group_code:
            if tariffs_without_order:
                for tariff in tariffs_without_order:
                    tariff["sort_order"] = 1
-                    await session.execute(
-                        update(Tariff).where(Tariff.id == tariff["id"]).values(sort_order=1)
-                    )
+                    await session.execute(update(Tariff).where(Tariff.id == tariff["id"]).values(sort_order=1))
                await session.commit()
-            
+
            grouped = defaultdict(list)
            for t in tariffs:
                grouped[t.get("subgroup_title")].append(t)
-            
+
            subgroup_weights = {}
            for subgroup, tariffs_list in grouped.items():
                if subgroup:
                    total_weight = sum(t.get("sort_order", 1) for t in tariffs_list)
                    subgroup_weights[subgroup] = total_weight
-            
-            return {
-                'tariffs': tariffs,
-                'subgroup_weights': subgroup_weights
-            }
-        
+
+            return {"tariffs": tariffs, "subgroup_weights": subgroup_weights}
+
        return tariffs
    except SQLAlchemyError as e:
        logger.error(f"[TARIFF] Ошибка при получении тарифов: {e}")
@@ -128,15 +123,13 @@ async def create_tariff(session: AsyncSession, data: dict):
            group_code = data.get("group_code")
            if group_code:
                result = await session.execute(
-                    select(func.max(Tariff.sort_order))
-                    .where(Tariff.group_code == group_code, Tariff.sort_order.isnot(None))
+                    select(func.max(Tariff.sort_order)).where(
+                        Tariff.group_code == group_code, Tariff.sort_order.isnot(None)
+                    )
                )
                max_order = result.scalar() or 0
            else:
-                result = await session.execute(
-                    select(func.max(Tariff.sort_order))
-                    .where(Tariff.sort_order.isnot(None))
-                )
+                result = await session.execute(select(func.max(Tariff.sort_order)).where(Tariff.sort_order.isnot(None)))
                max_order = result.scalar() or 0

            data["sort_order"] = max_order + 1
@@ -191,18 +184,14 @@ async def check_tariff_exists(session: AsyncSession, tariff_id: int):

 async def get_tariff_sort_order(session: AsyncSession, tariff_id: int) -> int:
    try:
-        result = await session.execute(
-            select(Tariff.sort_order).where(Tariff.id == tariff_id)
-        )
+        result = await session.execute(select(Tariff.sort_order).where(Tariff.id == tariff_id))
        sort_order = result.scalar_one_or_none()
-        
+
        if sort_order is None:
-            await session.execute(
-                update(Tariff).where(Tariff.id == tariff_id).values(sort_order=1)
-            )
+            await session.execute(update(Tariff).where(Tariff.id == tariff_id).values(sort_order=1))
            await session.commit()
            return 1
-        
+
        return sort_order
    except SQLAlchemyError as e:
        logger.error(f"[TARIFF] Ошибка при получении sort_order для тарифа {tariff_id}: {e}")
@@ -213,10 +202,8 @@ async def move_tariff_up(session: AsyncSession, tariff_id: int) -> bool:
    try:
        current_order = await get_tariff_sort_order(session, tariff_id)
        new_order = max(1, current_order - 1)
-        
-        await session.execute(
-            update(Tariff).where(Tariff.id == tariff_id).values(sort_order=new_order)
-        )
+
+        await session.execute(update(Tariff).where(Tariff.id == tariff_id).values(sort_order=new_order))
        await session.commit()
        return True
    except SQLAlchemyError as e:
@@ -229,10 +216,8 @@ async def move_tariff_down(session: AsyncSession, tariff_id: int) -> bool:
    try:
        current_order = await get_tariff_sort_order(session, tariff_id)
        new_order = current_order + 1
-        
-        await session.execute(
-            update(Tariff).where(Tariff.id == tariff_id).values(sort_order=new_order)
-        )
+
+        await session.execute(update(Tariff).where(Tariff.id == tariff_id).values(sort_order=new_order))
        await session.commit()
        return True
    except SQLAlchemyError as e:
@@ -243,20 +228,16 @@ async def move_tariff_down(session: AsyncSession, tariff_id: int) -> bool:

 async def initialize_tariff_sort_orders(session: AsyncSession, group_code: str) -> bool:
    try:
-        result = await session.execute(
-            select(Tariff).where(Tariff.group_code == group_code).order_by(Tariff.id)
-        )
+        result = await session.execute(select(Tariff).where(Tariff.group_code == group_code).order_by(Tariff.id))
        tariffs = result.scalars().all()
-        
+
        if not tariffs:
            return True

        for i, tariff in enumerate(tariffs):
            new_sort_order = 1 + i
-            await session.execute(
-                update(Tariff).where(Tariff.id == tariff.id).values(sort_order=new_sort_order)
-            )
-        
+            await session.execute(update(Tariff).where(Tariff.id == tariff.id).values(sort_order=new_sort_order))
+
        await session.commit()
        return True
    except SQLAlchemyError as e:
@@ -267,23 +248,19 @@ async def initialize_tariff_sort_orders(session: AsyncSession, group_code: str)

 async def initialize_all_tariff_weights(session: AsyncSession) -> bool:
    try:
-        result = await session.execute(
-            select(Tariff).where(Tariff.sort_order.is_(None))
-        )
+        result = await session.execute(select(Tariff).where(Tariff.sort_order.is_(None)))
        tariffs_without_weight = result.scalars().all()
-        
+
        if not tariffs_without_weight:
            return True

        for tariff in tariffs_without_weight:
-            await session.execute(
-                update(Tariff).where(Tariff.id == tariff.id).values(sort_order=1)
-            )
-        
+            await session.execute(update(Tariff).where(Tariff.id == tariff.id).values(sort_order=1))
+
        await session.commit()
        return True
-        
+
    except SQLAlchemyError as e:
        logger.error(f"[TARIFF] Ошибка при инициализации весов тарифов: {e}")
        await session.rollback()
-        return False
+        return False
@@ -1,4 +1,4 @@
-from sqlalchemy import func, insert, not_, select, and_
+from sqlalchemy import and_, func, insert, not_, select
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.ext.asyncio import AsyncSession

@@ -8,6 +8,7 @@ from logger import logger

 EXCLUDED_PAYMENT_MARKERS = ["coupon", "referral", "cashback"]

+
 async def create_tracking_source(session: AsyncSession, name: str, code: str, type_: str, created_by: int):
    try:
        stmt = insert(TrackingSource).values(
@@ -76,14 +77,13 @@ async def get_tracking_source_stats(session: AsyncSession, code: str) -> dict |
        return dt.strftime("%Y-%m")

    src_row = await session.execute(
-        select(TrackingSource.name, TrackingSource.code, TrackingSource.created_at)
-        .where(TrackingSource.code == code)
+        select(TrackingSource.name, TrackingSource.code, TrackingSource.created_at).where(TrackingSource.code == code)
    )
    src = src_row.first()
    if not src:
        return None

-    src_name, src_code, created_at = src
+    _src_name, _src_code, created_at = src

    reg_subq = (
        select(func.count(func.distinct(User.tg_id)))
@@ -212,11 +212,7 @@ async def get_tracking_source_stats(session: AsyncSession, code: str) -> dict |
            month_expr_trials,
            func.count(func.distinct(User.tg_id)).label("cnt"),
        )
-        .where(
-            (User.source_code == code)
-            & (User.trial == 1)
-            & (User.created_at >= created_at)
-        )
+        .where((User.source_code == code) & (User.trial == 1) & (User.created_at >= created_at))
        .group_by(month_expr_trials)
        .order_by(month_expr_trials)
    )