paytechuz 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

paytechuz/integrations/fastapi/__init__.py

@@ -0,0 +1,21 @@
+"""
+FastAPI integration for PayTechUZ.
+"""
+# These imports are available for users of the package
+from .models import Base, PaymentTransaction  # noqa: F401
+from .schemas import (  # noqa: F401
+    PaymentTransactionBase,
+    PaymentTransactionCreate,
+    PaymentTransaction as PaymentTransactionSchema,
+    PaymentTransactionList,
+    PaymeWebhookRequest,
+    PaymeWebhookResponse,
+    PaymeWebhookErrorResponse,
+    ClickWebhookRequest,
+    ClickWebhookResponse
+)
+from .routes import (  # noqa: F401
+    router,
+    PaymeWebhookHandler,
+    ClickWebhookHandler
+)

paytechuz/integrations/fastapi/models.py

@@ -0,0 +1,151 @@
+"""
+FastAPI models for PayTechUZ.
+"""
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+from sqlalchemy import Column, Integer, String, Float, DateTime, JSON
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+class PaymentTransaction(Base):
+    """
+    Payment transaction model for storing payment information.
+    """
+    __tablename__ = "payments"
+
+    # Payment gateway choices
+    PAYME = 'payme'
+    CLICK = 'click'
+
+    # Transaction states
+    CREATED = 0
+    INITIATING = 1
+    SUCCESSFULLY = 2
+    CANCELLED = -2
+    CANCELLED_DURING_INIT = -1
+
+    id = Column(Integer, primary_key=True, index=True)
+    gateway = Column(String(10), index=True)  # 'payme' or 'click'
+    transaction_id = Column(String(255), index=True)
+    account_id = Column(String(255), index=True)
+    amount = Column(Float)
+    state = Column(Integer, default=CREATED, index=True)
+    reason = Column(Integer, nullable=True)  # Reason for cancellation
+    extra_data = Column(JSON, default={})
+    created_at = Column(DateTime, default=datetime.utcnow, index=True)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, index=True)
+    performed_at = Column(DateTime, nullable=True, index=True)
+    cancelled_at = Column(DateTime, nullable=True, index=True)
+
+    @classmethod
+    def create_transaction(
+        cls,
+        db,
+        gateway: str,
+        transaction_id: str,
+        account_id: str,
+        amount: float,
+        extra_data: Optional[Dict[str, Any]] = None
+    ) -> "PaymentTransaction":
+        """
+        Create a new transaction or get an existing one.
+
+        Args:
+            db: Database session
+            gateway: Payment gateway (payme or click)
+            transaction_id: Transaction ID from the payment system
+            account_id: Account or order ID
+            amount: Payment amount
+            extra_data: Additional data for the transaction
+
+        Returns:
+            PaymentTransaction instance
+        """
+        # Check if transaction already exists
+        transaction = db.query(cls).filter(
+            cls.gateway == gateway,
+            cls.transaction_id == transaction_id
+        ).first()
+
+        if transaction:
+            return transaction
+
+        # Create new transaction
+        transaction = cls(
+            gateway=gateway,
+            transaction_id=transaction_id,
+            account_id=str(account_id),
+            amount=amount,
+            state=cls.CREATED,
+            extra_data=extra_data or {}
+        )
+
+        db.add(transaction)
+        db.commit()
+        db.refresh(transaction)
+
+        return transaction
+
+    def mark_as_paid(self, db) -> "PaymentTransaction":
+        """
+        Mark the transaction as paid.
+
+        Args:
+            db: Database session
+
+        Returns:
+            PaymentTransaction instance
+        """
+        if self.state != self.SUCCESSFULLY:
+            self.state = self.SUCCESSFULLY
+            self.performed_at = datetime.utcnow()
+
+            db.commit()
+            db.refresh(self)
+
+        return self
+
+    def mark_as_cancelled(self, db, reason: Optional[str] = None) -> "PaymentTransaction":
+        """
+        Mark the transaction as cancelled.
+
+        Args:
+            db: Database session
+            reason: Reason for cancellation
+
+        Returns:
+            PaymentTransaction instance
+        """
+        # If reason is not provided, use default reason from PaymeCancelReason
+        if reason is None:
+            # Import here to avoid circular imports
+            from paytechuz.core.constants import PaymeCancelReason
+            reason_code = PaymeCancelReason.REASON_FUND_RETURNED  # Default reason 5
+        else:
+            # Convert reason to int if it's a string
+            if isinstance(reason, str) and reason.isdigit():
+                reason_code = int(reason)
+            else:
+                reason_code = reason
+
+        # Only update state if not already cancelled
+        if self.state not in [self.CANCELLED, self.CANCELLED_DURING_INIT]:
+            # Always set state to CANCELLED (-2) for Payme API compatibility
+            # regardless of the current state
+            self.state = self.CANCELLED
+            self.cancelled_at = datetime.utcnow()
+
+        # Store the reason directly in the reason column
+        self.reason = reason_code
+
+        # For backward compatibility, also store in extra_data
+        extra_data = self.extra_data or {}
+        extra_data['cancel_reason'] = reason_code
+        self.extra_data = extra_data
+
+        db.commit()
+        db.refresh(self)
+
+        return self