paytechuz 0.2.7__py3-none-any.whl → 0.2.8__py3-none-any.whl

paytechuz/integrations/fastapi/models.py

@@ -9,6 +9,7 @@ from sqlalchemy.ext.declarative import declarative_base
 
 Base = declarative_base()
 
+
 class PaymentTransaction(Base):
     """
     Payment transaction model for storing payment information.
@@ -35,7 +36,11 @@ class PaymentTransaction(Base):
     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)
+    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)
 
@@ -107,7 +112,9 @@ class PaymentTransaction(Base):
 
         return self
 
-    def mark_as_cancelled(self, db, reason: Optional[str] = None) -> "PaymentTransaction":
+    def mark_as_cancelled(
+        self, db, reason: Optional[str] = None
+    ) -> "PaymentTransaction":
         """
         Mark the transaction as cancelled.
 
@@ -118,23 +125,21 @@ class PaymentTransaction(Base):
         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
+            reason_code = 5  # REASON_FUND_RETURNED
         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
+            if self.state == self.INITIATING or reason_code == 3:
+                self.state = self.CANCELLED_DURING_INIT
+            else:
+                # Otherwise, set state to CANCELLED (-2)
+                self.state = self.CANCELLED
+
             self.cancelled_at = datetime.utcnow()
 
         # Store the reason directly in the reason column

paytechuz/integrations/fastapi/routes.py

@@ -7,11 +7,10 @@ import json
 import logging
 from datetime import datetime
 from decimal import Decimal
-from typing import Dict, Any, Optional, Callable
+from typing import Dict, Any, Optional
 
 from fastapi import (
     APIRouter,
-    Depends,
     HTTPException,
     Request,
     Response,
@@ -19,6 +18,7 @@ from fastapi import (
 )
 from sqlalchemy.orm import Session
 
+# pylint: disable=E0401,E0611
 from paytechuz.core.exceptions import (
     PermissionDenied,
     InvalidAmount,
@@ -185,13 +185,12 @@ class PaymeWebhookHandler:
                     'jsonrpc': '2.0',
                     'id': request_id if 'request_id' in locals() else 0,
                     'error': {
-                        # Code for account not found, in the range -31099 to -31050
                         'code': -31050,
                         'message': str(e)
                     }
                 }),
                 media_type="application/json",
-                status_code=200  # Return 200 status code for all errors
+                status_code=200
             )
 
         except InvalidAmount as e:
@@ -200,12 +199,12 @@ class PaymeWebhookHandler:
                     'jsonrpc': '2.0',
                     'id': request_id if 'request_id' in locals() else 0,
                     'error': {
-                        'code': -31001,  # Code for invalid amount
+                        'code': -31001,
                         'message': str(e)
                     }
                 }),
                 media_type="application/json",
-                status_code=200  # Return 200 status code for all errors
+                status_code=200
             )
 
         except InvalidAccount as e:
@@ -214,13 +213,12 @@ class PaymeWebhookHandler:
                     'jsonrpc': '2.0',
                     'id': request_id if 'request_id' in locals() else 0,
                     'error': {
-                        # Code for invalid account, in the range -31099 to -31050
                         'code': -31050,
                         'message': str(e)
                     }
                 }),
                 media_type="application/json",
-                status_code=200  # Return 200 status code for all errors
+                status_code=200
             )
 
         except TransactionNotFound as e:
@@ -234,7 +232,7 @@ class PaymeWebhookHandler:
                     }
                 }),
                 media_type="application/json",
-                status_code=200  # Return 200 status code for all errors
+                status_code=200
             )
 
         except Exception as e:
@@ -249,7 +247,7 @@ class PaymeWebhookHandler:
                     }
                 }),
                 media_type="application/json",
-                status_code=200  # Return 200 status code for all errors
+                status_code=200
             )
 
     def _check_auth(self, auth_header: Optional[str]) -> None:
@@ -270,7 +268,6 @@ class PaymeWebhookHandler:
             if password != self.payme_key:
                 raise PermissionDenied("Invalid merchant key")
         except PermissionDenied:
-            # Re-raise permission denied exceptions
             raise
         except Exception as e:
             logger.error(f"Authentication error: {e}")
@@ -284,13 +281,12 @@ class PaymeWebhookHandler:
         if not account_value:
             raise AccountNotFound("Account not found in parameters")
 
-        # Handle special case for 'order_id' field
         lookup_field = 'id' if self.account_field == 'order_id' else (
             self.account_field
         )
 
-        # Try to convert account_value to int if it's a string and lookup_field is 'id'
-        if (lookup_field == 'id' and isinstance(account_value, str) and
+        if (lookup_field == 'id' and
+                isinstance(account_value, str) and
                 account_value.isdigit()):
             account_value = int(account_value)
 
@@ -324,12 +320,15 @@ class PaymeWebhookHandler:
         # If one_time_payment is disabled, amount must be positive
         if not self.one_time_payment and received_amount <= 0:
             raise InvalidAmount(
-                f"Invalid amount. Amount must be positive, received: {received_amount}"
+                (f"Invalid amount. Amount must be positive, "
+                 f"received: {received_amount}")
             )
 
         return True
 
-    def _check_perform_transaction(self, params: Dict[str, Any]) -> Dict[str, Any]:
+    def _check_perform_transaction(
+        self, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """
         Handle CheckPerformTransaction method.
         """
@@ -351,8 +350,8 @@ class PaymeWebhookHandler:
 
         self._validate_amount(account, amount)
 
-        # Check if there's already a transaction for this account with a different transaction_id
-        # Only check if one_time_payment is enabled
+        # Check if there's already a transaction for this account with a
+        # different transaction_id. Only check if one_time_payment is enabled
         if self.one_time_payment:
             # Check for existing transactions in non-final states
             existing_transactions = self.db.query(PaymentTransaction).filter(
@@ -362,16 +361,23 @@ class PaymeWebhookHandler:
                 PaymentTransaction.transaction_id != transaction_id
             ).all()
 
-            # Filter out transactions in final states (SUCCESSFULLY, CANCELLED)
+            # Filter out transactions in final states
+            # (SUCCESSFULLY, CANCELLED, CANCELLED_DURING_INIT)
             non_final_transactions = [
                 t for t in existing_transactions
-                if t.state not in [PaymentTransaction.SUCCESSFULLY, PaymentTransaction.CANCELLED]
+                if t.state not in [
+                    PaymentTransaction.SUCCESSFULLY,
+                    PaymentTransaction.CANCELLED,
+                    PaymentTransaction.CANCELLED_DURING_INIT
+                ]
             ]
 
             if non_final_transactions:
-                # If there's already a transaction for this account with a different transaction_id in a non-final state, raise an error
+                # If there's already a transaction for this account with a
+                # different transaction_id in a non-final state, raise an error
                 raise InvalidAccount(
-                    f"Account with {self.account_field}={account.id} already has a pending transaction"
+                    (f"Account with {self.account_field}={account.id} "
+                     f"already has a pending transaction")
                 )
 
         # Check for existing transaction with the same transaction_id
@@ -386,7 +392,9 @@ class PaymeWebhookHandler:
 
             # For existing transactions, use the original time from extra_data
             # This ensures the same response is returned for repeated calls
-            create_time = transaction.extra_data.get('create_time', params.get('time'))
+            create_time = transaction.extra_data.get(
+                'create_time', params.get('time')
+            )
 
             return {
                 'transaction': transaction.transaction_id,
@@ -403,7 +411,9 @@ class PaymeWebhookHandler:
             state=PaymentTransaction.INITIATING,
             extra_data={
                 'account_field': self.account_field,
-                'account_value': params.get('account', {}).get(self.account_field),
+                'account_value': (
+                    params.get('account', {}).get(self.account_field)
+                ),
                 'create_time': params.get('time'),
                 'raw_params': params
             }
@@ -416,7 +426,8 @@ class PaymeWebhookHandler:
         # Call the event method
         self.transaction_created(params, transaction, account)
 
-        # Use the time from the request params instead of transaction.created_at
+        # Use the time from the request params
+        # instead of transaction.created_at
         create_time = params.get('time')
 
         return {
@@ -451,7 +462,9 @@ class PaymeWebhookHandler:
         return {
             'transaction': transaction.transaction_id,
             'state': transaction.state,
-            'perform_time': int(transaction.performed_at.timestamp() * 1000) if transaction.performed_at else 0,
+            'perform_time': int(
+                transaction.performed_at.timestamp() * 1000
+            ) if transaction.performed_at else 0,
         }
 
     def _check_transaction(self, params: Dict[str, Any]) -> Dict[str, Any]:
@@ -475,18 +488,28 @@ class PaymeWebhookHandler:
         self.check_transaction(params, transaction)
 
         # Use the original time from extra_data for consistency
-        create_time = transaction.extra_data.get('create_time', int(transaction.created_at.timestamp() * 1000))
+        create_time = transaction.extra_data.get(
+            'create_time', int(transaction.created_at.timestamp() * 1000)
+        )
 
         return {
             'transaction': transaction.transaction_id,
             'state': transaction.state,
             'create_time': create_time,
-            'perform_time': int(transaction.performed_at.timestamp() * 1000) if transaction.performed_at else 0,
-            'cancel_time': int(transaction.cancelled_at.timestamp() * 1000) if transaction.cancelled_at else 0,
+            'perform_time': (
+                int(transaction.performed_at.timestamp() * 1000)
+                if transaction.performed_at else 0
+            ),
+            'cancel_time': (
+                int(transaction.cancelled_at.timestamp() * 1000)
+                if transaction.cancelled_at else 0
+            ),
             'reason': transaction.reason,
         }
 
-    def _cancel_response(self, transaction: PaymentTransaction) -> Dict[str, Any]:
+    def _cancel_response(
+        self, transaction: PaymentTransaction
+    ) -> Dict[str, Any]:
         """
         Helper method to generate cancel transaction response.
 
@@ -511,7 +534,8 @@ class PaymeWebhookHandler:
         return {
             'transaction': transaction.transaction_id,
             'state': transaction.state,
-            'cancel_time': int(transaction.cancelled_at.timestamp() * 1000) if transaction.cancelled_at else 0,
+            'cancel_time': (int(transaction.cancelled_at.timestamp() * 1000)
+                            if transaction.cancelled_at else 0),
             'reason': reason,
         }
 
@@ -534,15 +558,22 @@ class PaymeWebhookHandler:
             )
 
         # Check if transaction is already cancelled
-        if transaction.state == PaymentTransaction.CANCELLED:
-            # If transaction is already cancelled, update the reason if provided
+        cancelled_states = [
+            PaymentTransaction.CANCELLED,
+            PaymentTransaction.CANCELLED_DURING_INIT
+        ]
+        if transaction.state in cancelled_states:
+            # If transaction is already cancelled, update the reason
+            # if provided
             if 'reason' in params:
                 reason = params.get('reason')
 
-                # If reason is not provided, use default reason from PaymeCancelReason
+                # If reason is not provided, use default reason
+                # from PaymeCancelReason
                 if reason is None:
                     from paytechuz.core.constants import PaymeCancelReason
-                    reason = PaymeCancelReason.REASON_FUND_RETURNED  # Default reason 5
+                    # Default reason 5
+                    reason = PaymeCancelReason.REASON_FUND_RETURNED
 
                 # Convert reason to int if it's a string
                 if isinstance(reason, str) and reason.isdigit():
@@ -569,7 +600,8 @@ class PaymeWebhookHandler:
         # Ensure the reason is stored in extra_data
         extra_data = transaction.extra_data or {}
         if 'cancel_reason' not in extra_data:
-            extra_data['cancel_reason'] = reason if reason is not None else 5  # Default reason 5
+            # Default reason 5 if none provided
+            extra_data['cancel_reason'] = reason if reason is not None else 5
             transaction.extra_data = extra_data
             self.db.commit()
             self.db.refresh(transaction)
@@ -616,9 +648,18 @@ class PaymeWebhookHandler:
                     self.account_field: transaction.account_id
                 },
                 'state': transaction.state,
-                'create_time': transaction.extra_data.get('create_time', int(transaction.created_at.timestamp() * 1000)),
-                'perform_time': int(transaction.performed_at.timestamp() * 1000) if transaction.performed_at else 0,
-                'cancel_time': int(transaction.cancelled_at.timestamp() * 1000) if transaction.cancelled_at else 0,
+                'create_time': transaction.extra_data.get(
+                    'create_time',
+                    int(transaction.created_at.timestamp() * 1000)
+                ),
+                'perform_time': (
+                    int(transaction.performed_at.timestamp() * 1000)
+                    if transaction.performed_at else 0
+                ),
+                'cancel_time': (
+                    int(transaction.cancelled_at.timestamp() * 1000)
+                    if transaction.cancelled_at else 0
+                ),
                 'reason': transaction.reason,
             })
 
@@ -629,7 +670,9 @@ class PaymeWebhookHandler:
 
     # Event methods that can be overridden by subclasses
 
-    def before_check_perform_transaction(self, params: Dict[str, Any], account: Any) -> None:
+    def before_check_perform_transaction(
+        self, params: Dict[str, Any], account: Any
+    ) -> None:
         """
         Called before checking if a transaction can be performed.
 
@@ -639,7 +682,9 @@ class PaymeWebhookHandler:
         """
         pass
 
-    def transaction_already_exists(self, params: Dict[str, Any], transaction: PaymentTransaction) -> None:
+    def transaction_already_exists(
+        self, params: Dict[str, Any], transaction: PaymentTransaction
+    ) -> None:
         """
         Called when a transaction already exists.
 
@@ -649,7 +694,12 @@ class PaymeWebhookHandler:
         """
         pass
 
-    def transaction_created(self, params: Dict[str, Any], transaction: PaymentTransaction, account: Any) -> None:
+    def transaction_created(
+        self,
+        params: Dict[str, Any],
+        transaction: PaymentTransaction,
+        account: Any
+    ) -> None:
         """
         Called when a transaction is created.
 
@@ -660,7 +710,11 @@ class PaymeWebhookHandler:
         """
         pass
 
-    def successfully_payment(self, params: Dict[str, Any], transaction: PaymentTransaction) -> None:
+    def successfully_payment(
+        self,
+        params: Dict[str, Any],
+        transaction: PaymentTransaction
+    ) -> None:
         """
         Called when a payment is successful.
 
@@ -670,7 +724,11 @@ class PaymeWebhookHandler:
         """
         pass
 
-    def check_transaction(self, params: Dict[str, Any], transaction: PaymentTransaction) -> None:
+    def check_transaction(
+        self,
+        params: Dict[str, Any],
+        transaction: PaymentTransaction
+    ) -> None:
         """
         Called when checking a transaction.
 
@@ -680,7 +738,11 @@ class PaymeWebhookHandler:
         """
         pass
 
-    def cancelled_payment(self, params: Dict[str, Any], transaction: PaymentTransaction) -> None:
+    def cancelled_payment(
+        self,
+        params: Dict[str, Any],
+        transaction: PaymentTransaction
+    ) -> None:
         """
         Called when a payment is cancelled.
 
@@ -690,7 +752,11 @@ class PaymeWebhookHandler:
         """
         pass
 
-    def get_statement(self, params: Dict[str, Any], transactions: list) -> None:
+    def get_statement(
+        self,
+        params: Dict[str, Any],
+        transactions: list
+    ) -> None:
         """
         Called when getting a statement.
 
@@ -719,7 +785,9 @@ class ClickWebhookHandler:
             print(f"Payment successful: {transaction.transaction_id}")
 
             # Update your order status
-            order = db.query(Order).filter(Order.id == transaction.account_id).first()
+            order = (db.query(Order)
+                     .filter(Order.id == transaction.account_id)
+                     .first())
             order.status = 'paid'
             db.commit()
     ```
@@ -788,7 +856,8 @@ class ClickWebhookHandler:
 
             # Validate amount
             try:
-                self._validate_amount(amount, float(getattr(account, 'amount', 0)))
+                expected = float(getattr(account, 'amount', 0))
+                self._validate_amount(amount, expected)
             except Exception as e:
                 logger.error(f"Invalid amount: {e}")
                 return {
@@ -886,7 +955,8 @@ class ClickWebhookHandler:
                     self.successfully_payment(params, transaction)
                 else:
                     # Mark transaction as cancelled
-                    transaction.mark_as_cancelled(self.db, reason=f"Error code: {error}")
+                    error_reason = f"Error code: {error}"
+                    transaction.mark_as_cancelled(self.db, reason=error_reason)
 
                     # Call the event method
                     self.cancelled_payment(params, transaction)
@@ -937,10 +1007,15 @@ class ClickWebhookHandler:
                 )
 
             # Create string to sign
-            to_sign = f"{params.get('click_trans_id')}{params.get('service_id')}"
-            to_sign += f"{self.secret_key}{params.get('merchant_trans_id')}"
-            to_sign += f"{params.get('amount')}{params.get('action')}"
-            to_sign += f"{sign_time}"
+            to_sign = (
+                f"{params.get('click_trans_id')}"
+                f"{params.get('service_id')}"
+                f"{self.secret_key}"
+                f"{params.get('merchant_trans_id')}"
+                f"{params.get('amount')}"
+                f"{params.get('action')}"
+                f"{sign_time}"
+            )
 
             # Generate signature
             signature = hashlib.md5(to_sign.encode('utf-8')).hexdigest()
@@ -959,7 +1034,11 @@ class ClickWebhookHandler:
         if isinstance(merchant_trans_id, str) and merchant_trans_id.isdigit():
             merchant_trans_id = int(merchant_trans_id)
 
-        account = self.db.query(self.account_model).filter_by(id=merchant_trans_id).first()
+        account = (
+            self.db.query(self.account_model)
+            .filter_by(id=merchant_trans_id)
+            .first()
+        )
         if not account:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
@@ -968,25 +1047,35 @@ class ClickWebhookHandler:
 
         return account
 
-    def _validate_amount(self, received_amount: float, expected_amount: float) -> None:
+    def _validate_amount(
+        self, received_amount: float, expected_amount: float
+    ) -> None:
         """
         Validate payment amount.
         """
         # Add commission if needed
         if self.commission_percent > 0:
-            expected_amount = expected_amount * (1 + self.commission_percent / 100)
+            commission_factor = 1 + (self.commission_percent / 100)
+            expected_amount = expected_amount * commission_factor
             expected_amount = round(expected_amount, 2)
 
         # Allow small difference due to floating point precision
         if abs(received_amount - expected_amount) > 0.01:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Incorrect amount. Expected: {expected_amount}, received: {received_amount}"
+                detail=(
+                    f"Incorrect amount. Expected: {expected_amount}, "
+                    f"received: {received_amount}"
+                )
             )
 
     # Event methods that can be overridden by subclasses
 
-    def transaction_already_exists(self, params: Dict[str, Any], transaction: PaymentTransaction) -> None:
+    def transaction_already_exists(
+        self,
+        params: Dict[str, Any],
+        transaction: PaymentTransaction
+    ) -> None:
         """
         Called when a transaction already exists.
 
@@ -996,7 +1085,12 @@ class ClickWebhookHandler:
         """
         pass
 
-    def transaction_created(self, params: Dict[str, Any], transaction: PaymentTransaction, account: Any) -> None:
+    def transaction_created(
+        self,
+        params: Dict[str, Any],
+        transaction: PaymentTransaction,
+        account: Any
+    ) -> None:
         """
         Called when a transaction is created.
 
@@ -1007,7 +1101,11 @@ class ClickWebhookHandler:
         """
         pass
 
-    def successfully_payment(self, params: Dict[str, Any], transaction: PaymentTransaction) -> None:
+    def successfully_payment(
+        self,
+        params: Dict[str, Any],
+        transaction: PaymentTransaction
+    ) -> None:
         """
         Called when a payment is successful.
 
@@ -1017,7 +1115,11 @@ class ClickWebhookHandler:
         """
         pass
 
-    def cancelled_payment(self, params: Dict[str, Any], transaction: PaymentTransaction) -> None:
+    def cancelled_payment(
+        self,
+        params: Dict[str, Any],
+        transaction: PaymentTransaction
+    ) -> None:
         """
         Called when a payment is cancelled.
 

paytechuz/integrations/fastapi/schemas.py

@@ -6,12 +6,15 @@ from typing import Dict, Any, Optional, List
 
 from pydantic import BaseModel, Field
 
+
 class PaymentTransactionBase(BaseModel):
     """
     Base schema for payment transaction.
     """
     gateway: str = Field(..., description="Payment gateway (payme or click)")
-    transaction_id: str = Field(..., description="Transaction ID from the payment system")
+    transaction_id: str = Field(
+        ..., description="Transaction ID from the payment system"
+    )
     account_id: str = Field(..., description="Account or order ID")
     amount: float = Field(..., description="Payment amount")
     state: int = Field(0, description="Transaction state")
@@ -21,18 +24,27 @@ class PaymentTransactionCreate(PaymentTransactionBase):
     """
     Schema for creating a payment transaction.
     """
-    extra_data: Optional[Dict[str, Any]] = Field(None, description="Additional data for the transaction")
+    extra_data: Optional[Dict[str, Any]] = Field(
+        None, description="Additional data for the transaction"
+    )
+
 
 class PaymentTransaction(PaymentTransactionBase):
     """
     Schema for payment transaction.
     """
     id: int = Field(..., description="Transaction ID")
-    extra_data: Dict[str, Any] = Field({}, description="Additional data for the transaction")
+    extra_data: Dict[str, Any] = Field(
+        {}, description="Additional data for the transaction"
+    )
     created_at: datetime = Field(..., description="Creation timestamp")
     updated_at: datetime = Field(..., description="Last update timestamp")
-    performed_at: Optional[datetime] = Field(None, description="Payment timestamp")
-    cancelled_at: Optional[datetime] = Field(None, description="Cancellation timestamp")
+    performed_at: Optional[datetime] = Field(
+        None, description="Payment timestamp"
+    )
+    cancelled_at: Optional[datetime] = Field(
+        None, description="Cancellation timestamp"
+    )
 
     class Config:
         """
@@ -45,9 +57,12 @@ class PaymentTransactionList(BaseModel):
     """
     Schema for a list of payment transactions.
     """
-    transactions: List[PaymentTransaction] = Field(..., description="List of transactions")
+    transactions: List[PaymentTransaction] = Field(
+        ..., description="List of transactions"
+    )
     total: int = Field(..., description="Total number of transactions")
 
+
 class PaymeWebhookRequest(BaseModel):
     """
     Schema for Payme webhook request.
@@ -65,6 +80,7 @@ class PaymeWebhookResponse(BaseModel):
     id: int = Field(..., description="Request ID")
     result: Dict[str, Any] = Field(..., description="Response result")
 
+
 class PaymeWebhookErrorResponse(BaseModel):
     """
     Schema for Payme webhook error response.
@@ -88,12 +104,15 @@ class ClickWebhookRequest(BaseModel):
     error: Optional[str] = Field(None, description="Error code")
     error_note: Optional[str] = Field(None, description="Error note")
 
+
 class ClickWebhookResponse(BaseModel):
     """
     Schema for Click webhook response.
     """
     click_trans_id: str = Field(..., description="Click transaction ID")
     merchant_trans_id: str = Field(..., description="Merchant transaction ID")
-    merchant_prepare_id: Optional[int] = Field(None, description="Merchant prepare ID")
+    merchant_prepare_id: Optional[int] = Field(
+        None, description="Merchant prepare ID"
+    )
     error: int = Field(0, description="Error code")
     error_note: str = Field("Success", description="Error note")

paytechuz-0.2.8.dist-info/METADATA

@@ -0,0 +1,312 @@
+Metadata-Version: 2.4
+Name: paytechuz
+Version: 0.2.8
+Summary: Unified Python package for Uzbekistan payment gateways
+Home-page: https://github.com/Muhammadali-Akbarov/paytechuz
+Author: Muhammadali Akbarov
+Author-email: muhammadali17abc@gmail.com
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-python
+
+# PayTechUZ
+
+[![PyPI version](https://badge.fury.io/py/paytechuz.svg)](https://badge.fury.io/py/paytechuz)
+[![Python Versions](https://img.shields.io/pypi/pyversions/paytechuz.svg)](https://pypi.org/project/paytechuz/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+PayTechUZ is a unified payment library for integrating with popular payment systems in Uzbekistan. It provides a simple and consistent interface for working with Payme and Click payment gateways.
+
+## Features
+
+- 🔄 **API**: Consistent interface for multiple payment providers
+- 🛡️ **Secure**: Built-in security features for payment processing
+- 🔌 **Framework Integration**: Native support for Django and FastAPI
+- 🌐 **Webhook Handling**: Easy-to-use webhook handlers for payment notifications
+- 📊 **Transaction Management**: Automatic transaction tracking and management
+- 🧩 **Extensible**: Easy to add new payment providers
+## Installation
+
+### Basic Installation
+
+```bash
+pip install paytechuz
+```
+
+### Framework-Specific Installation
+
+```bash
+# For Django
+pip install paytechuz[django]
+
+# For FastAPI
+pip install paytechuz[fastapi]
+```
+
+## Quick Start
+
+### Generate Payment Links
+
+```python
+from paytechuz.gateways.payme import PaymeGateway
+from paytechuz.gateways.click import ClickGateway
+
+# Initialize Payme gateway
+payme = PaymeGateway(
+    payme_id="your_payme_id",
+    payme_key="your_payme_key",
+    is_test_mode=True  # Set to False in production environment
+)
+
+# Initialize Click gateway
+click = ClickGateway(
+    service_id="your_service_id",
+    merchant_id="your_merchant_id",
+    merchant_user_id="your_merchant_user_id",
+    secret_key="your_secret_key",
+    is_test_mode=True  # Set to False in production environment
+)
+
+# Generate payment links
+payme_link = payme.create_payment(
+    id="order_123",
+    amount=150000,  # amount in UZS
+    return_url="https://example.com/return"
+)
+
+click_link = click.create_payment(
+    id="order_123",
+    amount=150000,  # amount in UZS
+    description="Test payment",
+    return_url="https://example.com/return"
+)
+```
+
+### Django Integration
+
+1. Create Order model:
+
+```python
+# models.py
+from django.db import models
+from django.utils import timezone
+
+class Order(models.Model):
+    STATUS_CHOICES = (
+        ('pending', 'Pending'),
+        ('paid', 'Paid'),
+        ('cancelled', 'Cancelled'),
+        ('delivered', 'Delivered'),
+    )
+
+    product_name = models.CharField(max_length=255)
+    amount = models.DecimalField(max_digits=12, decimal_places=2)
+    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='pending')
+    created_at = models.DateTimeField(default=timezone.now)
+
+    def __str__(self):
+        return f"{self.id} - {self.product_name} ({self.amount})"
+```
+
+2. Add to `INSTALLED_APPS` and configure settings:
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    # ...
+    'paytechuz.integrations.django',
+]
+
+PAYME_ID = 'your_payme_merchant_id'
+PAYME_KEY = 'your_payme_merchant_key'
+PAYME_ACCOUNT_MODEL = 'your_app.models.Order'  # For example: 'orders.models.Order'
+PAYME_ACCOUNT_FIELD = 'id'
+PAYME_AMOUNT_FIELD = 'amount'  # Field for storing payment amount
+PAYME_ONE_TIME_PAYMENT = True  # Allow only one payment per account
+
+CLICK_SERVICE_ID = 'your_click_service_id'
+CLICK_MERCHANT_ID = 'your_click_merchant_id'
+CLICK_SECRET_KEY = 'your_click_secret_key'
+CLICK_ACCOUNT_MODEL = 'your_app.models.Order'
+CLICK_COMMISSION_PERCENT = 0.0
+```
+
+3. Create webhook handlers:
+
+```python
+# views.py
+from paytechuz.integrations.django.views import BasePaymeWebhookView, BaseClickWebhookView
+from .models import Order
+
+class PaymeWebhookView(BasePaymeWebhookView):
+    def successfully_payment(self, params, transaction):
+        order = Order.objects.get(id=transaction.account_id)
+        order.status = 'paid'
+        order.save()
+
+    def cancelled_payment(self, params, transaction):
+        order = Order.objects.get(id=transaction.account_id)
+        order.status = 'cancelled'
+        order.save()
+
+class ClickWebhookView(BaseClickWebhookView):
+    def successfully_payment(self, params, transaction):
+        order = Order.objects.get(id=transaction.account_id)
+        order.status = 'paid'
+        order.save()
+
+    def cancelled_payment(self, params, transaction):
+        order = Order.objects.get(id=transaction.account_id)
+        order.status = 'cancelled'
+        order.save()
+```
+
+4. Add webhook URLs to `urls.py`:
+
+```python
+# urls.py
+from django.urls import path
+from django.views.decorators.csrf import csrf_exempt
+from .views import PaymeWebhookView, ClickWebhookView
+
+urlpatterns = [
+    # ...
+    path('payments/webhook/payme/', csrf_exempt(PaymeWebhookView.as_view()), name='payme_webhook'),
+    path('payments/webhook/click/', csrf_exempt(ClickWebhookView.as_view()), name='click_webhook'),
+]
+```
+
+### FastAPI Integration
+
+1. Set up database models:
+
+```python
+from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from paytechuz.integrations.fastapi import Base as PaymentsBase
+from paytechuz.integrations.fastapi.models import run_migrations
+from datetime import datetime, timezone
+
+# Create database engine
+SQLALCHEMY_DATABASE_URL = "sqlite:///./payments.db"
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+
+# Create base declarative class
+Base = declarative_base()
+
+# Create Order model
+class Order(Base):
+    __tablename__ = "orders"
+
+    id = Column(Integer, primary_key=True, index=True)
+    product_name = Column(String, index=True)
+    amount = Column(Float)
+    status = Column(String, default="pending")
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+
+# Create payment tables using run_migrations
+run_migrations(engine)
+
+# Create Order table
+Base.metadata.create_all(bind=engine)
+
+# Create session
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+```
+
+2. Create webhook handlers:
+
+```python
+from fastapi import FastAPI, Request, Depends
+from sqlalchemy.orm import Session
+from paytechuz.integrations.fastapi import PaymeWebhookHandler, ClickWebhookHandler
+
+app = FastAPI()
+
+# Dependency to get the database session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+class CustomPaymeWebhookHandler(PaymeWebhookHandler):
+    def successfully_payment(self, params, transaction):
+        # Handle successful payment
+        order = self.db.query(Order).filter(Order.id == transaction.account_id).first()
+        order.status = "paid"
+        self.db.commit()
+
+    def cancelled_payment(self, params, transaction):
+        # Handle cancelled payment
+        order = self.db.query(Order).filter(Order.id == transaction.account_id).first()
+        order.status = "cancelled"
+        self.db.commit()
+
+class CustomClickWebhookHandler(ClickWebhookHandler):
+    def successfully_payment(self, params, transaction):
+        # Handle successful payment
+        order = self.db.query(Order).filter(Order.id == transaction.account_id).first()
+        order.status = "paid"
+        self.db.commit()
+
+    def cancelled_payment(self, params, transaction):
+        # Handle cancelled payment
+        order = self.db.query(Order).filter(Order.id == transaction.account_id).first()
+        order.status = "cancelled"
+        self.db.commit()
+
+@app.post("/payments/payme/webhook")
+async def payme_webhook(request: Request, db: Session = Depends(get_db)):
+    handler = CustomPaymeWebhookHandler(
+        db=db,
+        payme_id="your_merchant_id",
+        payme_key="your_merchant_key",
+        account_model=Order,
+        account_field='id',
+        amount_field='amount'
+    )
+    return await handler.handle_webhook(request)
+
+@app.post("/payments/click/webhook")
+async def click_webhook(request: Request, db: Session = Depends(get_db)):
+    handler = CustomClickWebhookHandler(
+        db=db,
+        service_id="your_service_id",
+        merchant_id="your_merchant_id",
+        secret_key="your_secret_key",
+        account_model=Order
+    )
+    return await handler.handle_webhook(request)
+```
+
+## Documentation
+
+Detailed documentation is available in multiple languages:
+
+- 📖 [English Documentation](src/docs/en/index.md)
+- 📖 [O'zbek tilidagi hujjatlar](src/docs/index.md)
+
+### Framework-Specific Documentation
+
+- [Django Integration Guide](src/docs/en/django_integration.md) | [Django integratsiyasi bo'yicha qo'llanma](src/docs/django_integration.md)
+- [FastAPI Integration Guide](src/docs/en/fastapi_integration.md) | [FastAPI integratsiyasi bo'yicha qo'llanma](src/docs/fastapi_integration.md)
+
+## Supported Payment Systems
+
+- **Payme** - [Official Website](https://payme.uz)
+- **Click** - [Official Website](https://click.uz)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

{paytechuz-0.2.7.dist-info → paytechuz-0.2.8.dist-info}/RECORD

@@ -27,10 +27,10 @@ paytechuz/integrations/django/webhooks.py,sha256=cP_Jc3VlyyvyzDbBd2yEVHikw60th1_
 paytechuz/integrations/django/migrations/0001_initial.py,sha256=SWHIUuwq91crzaxa9v1UK0kay8CxsjUo6t4bqg7j0Gw,1896
 paytechuz/integrations/django/migrations/__init__.py,sha256=KLQ5NdjOMLDS21-u3b_g08G1MjPMMhG95XI_N8m4FSo,41
 paytechuz/integrations/fastapi/__init__.py,sha256=DLnhAZQZf2ghu8BuFFfE7FzbNKWQQ2SLG8qxldRuwR4,565
-paytechuz/integrations/fastapi/models.py,sha256=eWGUpiKufj47AK8Hld4A91jRDj0ZKQzAf95CyUozmvo,4638
-paytechuz/integrations/fastapi/routes.py,sha256=D17QeyY4-aX6tCNmk5h3UiavukvVrE5e6JOFCy4t_n8,36629
-paytechuz/integrations/fastapi/schemas.py,sha256=CkNohj22mQQje8Pu_IkTQwUPAoYHNOKXlGjqaRX_SGQ,3784
-paytechuz-0.2.7.dist-info/METADATA,sha256=gwH2lLsL2ikMoLcZjJARIh2uHGDk7xFFc31yYYhubo4,4390
-paytechuz-0.2.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-paytechuz-0.2.7.dist-info/top_level.txt,sha256=oloyKGNVj9Z2h3wpKG5yPyTlpdpWW0-CWr-j-asCWBc,10
-paytechuz-0.2.7.dist-info/RECORD,,
+paytechuz/integrations/fastapi/models.py,sha256=uayHUDt0nN6hIkhbGrM1NZRXzpCPvaPMPEjowJFUQPI,4425
+paytechuz/integrations/fastapi/routes.py,sha256=X7ejcICe4lFtpsKMXxvyrklqHWQJMhR-AdhcitSiXlE,37647
+paytechuz/integrations/fastapi/schemas.py,sha256=PgRqviJiD4-u3_CIkUOX8R7L8Yqn8L44WLte7968G0E,3887
+paytechuz-0.2.8.dist-info/METADATA,sha256=YKr2kp5NH_VapJ1DCn7H6zVQ_cerzHvXwnYAHqBtIfM,9407
+paytechuz-0.2.8.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+paytechuz-0.2.8.dist-info/top_level.txt,sha256=oloyKGNVj9Z2h3wpKG5yPyTlpdpWW0-CWr-j-asCWBc,10
+paytechuz-0.2.8.dist-info/RECORD,,

paytechuz-0.2.7.dist-info/METADATA

@@ -1,170 +0,0 @@
-Metadata-Version: 2.4
-Name: paytechuz
-Version: 0.2.7
-Summary: Unified Python package for Uzbekistan payment gateways
-Home-page: https://github.com/Muhammadali-Akbarov/paytechuz
-Author: Muhammadali Akbarov
-Author-email: muhammadali17abc@gmail.com
-License: MIT
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Dynamic: author
-Dynamic: author-email
-Dynamic: home-page
-Dynamic: requires-python
-
-# PayTechUZ
-
-[![PyPI version](https://badge.fury.io/py/paytechuz.svg)](https://badge.fury.io/py/paytechuz)
-[![Python Versions](https://img.shields.io/pypi/pyversions/paytechuz.svg)](https://pypi.org/project/paytechuz/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-## Installation
-
-### Basic Installation
-
-```bash
-pip install paytechuz
-```
-
-### Framework-Specific Installation
-
-```bash
-# For Django
-pip install paytechuz[django]
-
-# For FastAPI
-pip install paytechuz[fastapi]
-```
-
-## Quick Start
-
-### Generate Payment Links
-
-```python
-from paytechuz import create_gateway, PaymentGateway
-
-# Initialize gateways
-payme = create_gateway(PaymentGateway.PAYME.value,
-    payme_id="your_payme_id",
-    payme_key="your_payme_key",
-    is_test_mode=True
-)
-
-click = create_gateway(PaymentGateway.CLICK.value,
-    service_id="your_service_id",
-    merchant_id="your_merchant_id",
-    merchant_user_id="your_merchant_user_id",
-    secret_key="your_secret_key",
-    is_test_mode=True
-)
-
-# Generate payment links
-payme_link = payme.create_payment(
-    id="order_123",
-    amount=150000,  # amount in UZS
-    return_url="https://example.com/return"
-)
-
-click_link = click.create_payment(
-    id="order_123",
-    amount=150000,  # amount in UZS
-    description="Test payment",
-    return_url="https://example.com/return"
-)
-```
-
-### Django Integration
-
-1. Add to `INSTALLED_APPS`:
-
-```python
-# settings.py
-INSTALLED_APPS = [
-    # ...
-    'paytechuz.integrations.django',
-]
-
-PAYME_ID = 'your_payme_merchant_id'
-PAYME_KEY = 'your_payme_merchant_key'
-PAYME_ACCOUNT_MODEL = 'your_app.models.YourModel'  # For example: 'orders.models.Order'
-PAYME_ACCOUNT_FIELD = 'id'
-PAYME_AMOUNT_FIELD = 'amount'  # Field for storing payment amount
-PAYME_ONE_TIME_PAYMENT = True  # Allow only one payment per account
-
-CLICK_SERVICE_ID = 'your_click_service_id'
-CLICK_MERCHANT_ID = 'your_click_merchant_id'
-CLICK_SECRET_KEY = 'your_click_secret_key'
-CLICK_ACCOUNT_MODEL = 'your_app.models.YourModel'
-CLICK_COMMISSION_PERCENT = 0.0
-```
-
-2. Create webhook handlers:
-
-```python
-# views.py
-from paytechuz.integrations.django.views import BasePaymeWebhookView
-from .models import Order
-
-class PaymeWebhookView(BasePaymeWebhookView):
-    def successfully_payment(self, params, transaction):
-        order = Order.objects.get(id=transaction.account_id)
-        order.status = 'paid'
-        order.save()
-
-    def cancelled_payment(self, params, transaction):
-        order = Order.objects.get(id=transaction.account_id)
-        order.status = 'cancelled'
-        order.save()
-```
-
-3. Add webhook URLs to `urls.py`:
-
-```python
-# urls.py
-from django.urls import path
-from .views import PaymeWebhookView
-
-urlpatterns = [
-    # ...
-    path('payments/webhook/payme/', PaymeWebhookView.as_view(), name='payme_webhook'),
-]
-```
-
-### FastAPI Integration
-
-1. Create webhook handler:
-
-```python
-from fastapi import FastAPI, Request
-from paytechuz.integrations.fastapi import PaymeWebhookHandler
-
-app = FastAPI()
-
-class CustomPaymeWebhookHandler(PaymeWebhookHandler):
-    def successfully_payment(self, params, transaction):
-        # Handle successful payment
-        order = self.db.query(Order).filter(Order.id == transaction.account_id).first()
-        order.status = "paid"
-        self.db.commit()
-
-    def cancelled_payment(self, params, transaction):
-        # Handle cancelled payment
-        order = self.db.query(Order).filter(Order.id == transaction.account_id).first()
-        order.status = "cancelled"
-        self.db.commit()
-
-@app.post("/payments/payme/webhook")
-async def payme_webhook(request: Request):
-    handler = CustomPaymeWebhookHandler(
-        payme_id="your_merchant_id",
-        payme_key="your_merchant_key"
-    )
-    return await handler.handle_webhook(request)
-```
-
-## Documentation
-
-Detailed documentation is available in multiple languages:
-
-- 📖 [English Documentation](docs/en/index.md)
-- 📖 [O'zbek tilidagi hujjatlar](docs/uz/index.md)