payme-pkg 2.6.7__py3-none-any.whl → 3.0.18__py3-none-any.whl

payme/exceptions/webhook.py

@@ -0,0 +1,125 @@
+"""
+Init Payme base exception.
+"""
+import logging
+from rest_framework.exceptions import APIException
+
+logger = logging.getLogger(__name__)
+
+
+class BasePaymeException(APIException):
+    """
+    BasePaymeException inherits from APIException.
+    """
+    status_code = 200
+    error_code = None
+    message = None
+
+    # pylint: disable=super-init-not-called
+    def __init__(self, message: str = None):
+        detail: dict = {
+            "error": {
+                "code": self.error_code,
+                "message": self.message,
+                "data": message
+            }
+        }
+        logger.error(f"Payme error detail: {detail}")
+        self.detail = detail
+
+
+class PermissionDenied(BasePaymeException):
+    """
+    PermissionDenied APIException.
+
+    Raised when the client is not allowed to access the server.
+    """
+    status_code = 200
+    error_code = -32504
+    message = "Permission denied."
+
+
+class InternalServiceError(BasePaymeException):
+    """
+    InternalServiceError APIException.
+
+    Raised when a transaction fails to perform.
+    """
+    status_code = 200
+    error_code = -32400
+    message = {
+        "uz": "Tizimda xatolik yuzaga keldi.",
+        "ru": "Внутренняя ошибка сервиса.",
+        "en": "Internal service error."
+    }
+
+
+class MethodNotFound(BasePaymeException):
+    """
+    MethodNotFound APIException.
+
+    Raised when the requested method does not exist.
+    """
+    status_code = 405
+    error_code = -32601
+    message = "Method not found."
+
+
+class AccountDoesNotExist(BasePaymeException):
+    """
+    AccountDoesNotExist APIException.
+
+    Raised when an account does not exist or has been deleted.
+    """
+    status_code = 200
+    error_code = -31050
+    message = {
+        "uz": "Hisob topilmadi.",
+        "ru": "Счет не найден.",
+        "en": "Account does not exist."
+    }
+
+
+class IncorrectAmount(BasePaymeException):
+    """
+    IncorrectAmount APIException.
+
+    Raised when the provided amount is incorrect.
+    """
+    status_code = 200
+    error_code = -31001
+    message = {
+        'ru': 'Неверная сумма.',
+        'uz': "Noto'g'ri summa.",
+        'en': 'Incorrect amount.'
+    }
+
+
+class TransactionAlreadyExists(BasePaymeException):
+    """
+    TransactionAlreadyExists APIException.
+
+    Raised when a transaction already exists in the system,
+    preventing the creation of a new transaction with the same identifier.
+
+    Attributes:
+        status_code (int): The HTTP status code for the response.
+        error_code (int): The specific error code for this exception.
+        message (dict): A dictionary containing localized error messages.
+    """
+    status_code = 200
+    error_code = -31099
+    message = {
+        "uz": "Tranzaksiya allaqachon mavjud.",
+        "ru": "Транзакция уже существует.",
+        "en": "Transaction already exists."
+    }
+
+
+exception_whitelist = (
+    IncorrectAmount,
+    MethodNotFound,
+    PermissionDenied,
+    AccountDoesNotExist,
+    TransactionAlreadyExists
+)

payme/models.py

@@ -1,68 +1,135 @@
+"""
+This module contains models and functionality for tracking changes in payment transactions.
+It logs any significant modifications to payment transactions such as amount, state, or payment method,
+allowing for a detailed historical record of each transaction's state over time.
+"""
 from django.db import models
 from django.conf import settings
+from django.utils import timezone
+
 from django.utils.module_loading import import_string
-from django.core.exceptions import FieldError
-from django.utils.translation import gettext_lazy as _
 
-from payme.utils.logging import logger
+AccountModel = import_string(settings.PAYME_ACCOUNT_MODEL)
 
 
-class MerchantTransactionsModel(models.Model):
+class PaymeTransactions(models.Model):
     """
-    MerchantTransactionsModel class \
-        That's used for managing transactions in database.
+    Model to store payment transactions.
     """
-    _id = models.CharField(max_length=255, null=True, blank=False)
-    transaction_id = models.CharField(max_length=255, null=True, blank=False, verbose_name=_("Transaction ID"))
-    order_id = models.BigIntegerField(null=True, blank=True, verbose_name=_("Order ID"))
-    amount = models.FloatField(null=True, blank=True, verbose_name=_("Amount"))
-    time = models.BigIntegerField(null=True, blank=True, verbose_name=_("Time"))
-    perform_time = models.BigIntegerField(null=True, default=0, verbose_name=_("Perform Time"))
-    cancel_time = models.BigIntegerField(null=True, default=0, verbose_name=_("Cancel Time"))
-    state = models.IntegerField(null=True, default=1, verbose_name=_("State"))
-    reason = models.CharField(max_length=255, null=True, blank=True, verbose_name=_("Reason"))
-    created_at_ms = models.CharField(max_length=255, null=True, blank=True, verbose_name=_("Created At MS"))
-    created_at = models.DateTimeField(auto_now_add=True, verbose_name=_("Created At"))
-    updated_at = models.DateTimeField(auto_now=True, verbose_name=_("Updated At"))
+    CREATED = 0
+    INITIATING = 1
+    SUCCESSFULLY = 2
+    CANCELED = -2
+    CANCELED_DURING_INIT = -1
 
-    def __str__(self):
-        return str(self._id)
+    STATE = [
+        (CREATED, "Created"),
+        (INITIATING, "Initiating"),
+        (SUCCESSFULLY, "Successfully"),
+        (CANCELED, "Canceled after successful performed"),
+        (CANCELED_DURING_INIT, "Canceled during initiation"),
+    ]
+
+    transaction_id = models.CharField(max_length=50)
+    account = models.ForeignKey(
+        AccountModel,
+        related_name="payme_transactions",
+        on_delete=models.CASCADE
+    )
+    amount = models.DecimalField(max_digits=10, decimal_places=2)
+    state = models.IntegerField(choices=STATE, default=CREATED)
+    cancel_reason = models.IntegerField(null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True, db_index=True)
+    updated_at = models.DateTimeField(auto_now=True, db_index=True)
+    performed_at = models.DateTimeField(null=True, blank=True, db_index=True)
+    cancelled_at = models.DateTimeField(null=True, blank=True, db_index=True)
 
     class Meta:
-        verbose_name = _("Merchant Transaction")
-        verbose_name_plural = _("Merchant Transactions")
+        """
+        Model Meta options.
+        """
+        verbose_name = "Payme Transaction"
+        verbose_name_plural = "Payme Transactions"
+        ordering = ["-created_at"]
+        db_table = "payme_transactions"
+
+    def __str__(self):
+        """
+        String representation of the PaymentTransaction model.
+        """
+        return f"Payme Transaction #{self.transaction_id} Account: {self.account} - {self.state}"
+
+    @classmethod
+    def get_by_transaction_id(cls, transaction_id):
+        """
+        Class method to get a PaymentTransaction instance by its transaction ID.
+
+        :param transaction_id: The unique ID of the transaction.
+        :return: The PaymentTransaction instance or None if not found.
+        """
+        return cls.objects.get(transaction_id=transaction_id)
+
+    def is_performed(self) -> bool:
+        """
+        Check if the transaction is completed.
+
+        :return: True if the transaction is completed, False otherwise.
+        """
+        return self.state == self.SUCCESSFULLY
 
+    def is_cancelled(self) -> bool:
+        """
+        Check if the transaction is cancelled.
 
-try:
-    CUSTOM_ORDER = import_string(settings.ORDER_MODEL)
+        :return: True if the transaction is cancelled, False otherwise.
+        """
+        return self.state in [
+            self.CANCELED,
+            self.CANCELED_DURING_INIT
+        ]
+
+    def is_created(self) -> bool:
+        """
+        Check if the transaction is created.
 
-    if not isinstance(CUSTOM_ORDER, models.base.ModelBase):
-        raise TypeError("The input must be an instance of models.Model class")
+        :return: True if the transaction is created, False otherwise.
+        """
+        return self.state == self.CREATED
 
-    # pylint: disable=protected-access
-    if 'amount' not in [f.name for f in CUSTOM_ORDER._meta.fields]:
-        raise FieldError("Missing 'amount' field in your custom order model")
+    def is_created_in_payme(self) -> bool:
+        """
+        Check if the transaction was created in Payme.
 
-    Order = CUSTOM_ORDER
-except (ImportError, AttributeError):
-    logger.warning("You have no payme custom order model")
+        :return: True if the transaction was created in Payme, False otherwise.
+        """
+        return self.state == self.INITIATING
 
-    CUSTOM_ORDER = None
+    def mark_as_cancelled(self, cancel_reason: int, state: int) -> "PaymeTransactions":
+        """
+        Mark the transaction as cancelled.
 
-    class Order(models.Model):
+        :param cancel_reason: The reason for cancelling the transaction.
+        :return: True if the transaction was successfully marked as cancelled, False otherwise.
         """
-        Order class \
-            That's used for managing order process
+        if self.state == state:
+            return self
+
+        self.state = state
+        self.cancel_reason = cancel_reason
+        self.cancelled_at = timezone.now()
+        self.save()
+        return self
+
+    def mark_as_performed(self) -> bool:
         """
-        amount = models.IntegerField(null=True, blank=True, verbose_name=_("Amount"))
-        created_at = models.DateTimeField(auto_now_add=True, verbose_name=_("Created At"))
-        updated_at = models.DateTimeField(auto_now=True, verbose_name=_("Updated At"))
+        Mark the transaction as performed.
 
-        def __str__(self):
-            return f"ORDER ID: {self.pk} - AMOUNT: {self.amount}"
+        :return: True if the transaction was successfully marked as performed, False otherwise.
+        """
+        if self.state != self.INITIATING:
+            return False
 
-        class Meta:
-            # pylint: disable=missing-class-docstring
-            managed = False
-            verbose_name = _("Order")
-            verbose_name_plural = _("Orders")
+        self.state = self.SUCCESSFULLY
+        self.performed_at = timezone.now()
+        self.save()
+        return True

payme/types/response/__init__.py

@@ -0,0 +1,4 @@
+"""
+init all response typing of payme provider
+"""
+from .webhook import * # noqa

payme/types/response/cards.py

@@ -0,0 +1,110 @@
+from typing import Dict, Optional
+from dataclasses import dataclass
+
+
+class Common:
+    """
+    The common response structure.
+    """
+
+    @classmethod
+    def from_dict(cls, data: Dict):
+        """
+        Prepare fields for nested dataclasses
+        """
+        field_values = {}
+        for field in cls.__dataclass_fields__:
+            field_type = cls.__dataclass_fields__[field].type
+            field_data = data.get(field)
+
+            if isinstance(field_data, dict) and issubclass(field_type, Common):
+                field_values[field] = field_type.from_dict(field_data)
+            else:
+                field_values[field] = field_data
+
+        return cls(**field_values)
+
+
+@dataclass
+class Card(Common):
+    """
+    The card object represents a credit card.
+    """
+    number: str
+    expire: str
+    token: str
+    recurrent: bool
+    verify: bool
+    type: str
+    number_hash: Optional[str] = None
+
+
+@dataclass
+class Result(Common):
+    """
+    The result object contains the created card.
+    """
+    card: Card
+
+
+@dataclass
+class CardsCreateResponse(Common):
+    """
+    The cards.create response.
+    """
+    jsonrpc: str
+    result: Result
+
+
+@dataclass
+class VerifyResult(Common):
+    """
+    The result object for the verification response.
+    """
+    sent: bool
+    phone: str
+    wait: int
+
+
+@dataclass
+class GetVerifyResponse(Common):
+    """
+    The verification response structure.
+    """
+    jsonrpc: str
+    result: VerifyResult
+
+
+@dataclass
+class VerifyResponse(Common):
+    """
+    The verification response structure.
+    """
+    jsonrpc: str
+    result: Result
+
+
+@dataclass
+class RemoveCardResult(Common):
+    """
+    The result object for the removal response.
+    """
+    success: bool
+
+
+@dataclass
+class RemoveResponse(Common):
+    """
+    The remove response structure.
+    """
+    jsonrpc: str
+    result: RemoveCardResult
+
+
+@dataclass
+class CheckResponse(Common):
+    """
+    The check response structure.
+    """
+    jsonrpc: str
+    result: Result

payme/types/response/receipts.py

@@ -0,0 +1,215 @@
+from dataclasses import dataclass
+from typing import Dict, Optional, Union
+
+
+class Common:
+    """
+    The common response structure.
+    """
+    jsonrpc: str
+    id: int
+
+    @classmethod
+    def from_dict(cls, data: Dict):
+        """
+        Prepare fields for nested dataclasses
+        """
+        field_values = {}
+        for field in cls.__dataclass_fields__:
+            field_type = cls.__dataclass_fields__[field].type
+            field_data = data.get(field)
+
+            if isinstance(field_data, dict) and issubclass(field_type, Common):
+                field_values[field] = field_type.from_dict(field_data)
+            else:
+                field_values[field] = field_data
+
+        return cls(**field_values)
+
+
+@dataclass
+class Account(Common):
+    """
+    The account object represents a user's banking account.
+    """
+    _id: str
+    account_number: str
+    account_name: str
+    account_type: str
+    bank_name: str
+    currency: str
+    status: str
+
+
+@dataclass
+class PaymentMethod(Common):
+    """
+    The payment method object represents a user's payment method.
+    """
+    name: str
+    title: str
+    value: str
+    main: Optional[bool] = None
+
+
+@dataclass
+class Detail(Common):
+    """
+    The detail object represents additional details for a receipt.
+    """
+    discount: Optional[str] = None
+    shipping: Optional[str] = None
+    items: Optional[str] = None
+
+
+# pylint: disable=C0103
+@dataclass
+class MerchantEpos(Common):
+    """
+    The merchantEpos object represents a user's ePOS.
+    """
+    eposId: str
+    eposName: str
+    eposType: str
+    eposTerminalId: str
+
+
+@dataclass
+class Meta(Common):
+    """
+    The meta object represents additional metadata for a receipt.
+    """
+    source: any = None
+    owner: any = None
+    host: any = None
+
+
+@dataclass
+class Merchant:
+    """
+    The merchant object represents a user's merchant.
+    """
+    _id: str
+    name: str
+    organization: str
+    address: Optional[str] = None
+    business_id: Optional[str] = None
+    epos: Optional[MerchantEpos] = None
+    restrictions: Optional[str] = None
+    date: Optional[int] = None
+    logo: Optional[str] = None
+    type: Optional[str] = None
+    terms: Optional[str] = None
+
+
+@dataclass
+class Payer(Common):
+    """
+    The payer object represents a user's payer.
+    """
+    phone: str
+
+
+@dataclass
+class Receipt(Common):
+    """
+    The receipt object represents a payment receipt.
+    """
+    _id: str
+    create_time: int
+    pay_time: int
+    cancel_time: int
+    state: int
+    type: int
+    external: bool
+    operation: int
+    error: any = None
+    description: str = None
+    detail: Detail = None
+    currency: int = None
+    commission: int = None
+    card: str = None
+    creator: str = None
+    payer: Payer = None
+    amount: Union[float, int] = None
+    account: list[Account] = None
+    merchant: Merchant = None
+    processing_id: str = None
+    meta: Meta = None
+
+
+@dataclass
+class CreateResult(Common):
+    """
+    The result object for the create response.
+    """
+    receipt: Receipt
+
+
+@dataclass
+class CreateResponse(Common):
+    """
+    The create response structure.
+    """
+    result: CreateResult
+
+
+@dataclass
+class PayResponse(CreateResponse):
+    """
+    The pay response structure.
+    """
+
+
+@dataclass
+class SendResult(Common):
+    """
+    The result object for the send response.
+    """
+    success: bool
+
+
+@dataclass
+class SendResponse(Common):
+    """
+    The send response structure.
+    """
+    result: SendResult
+
+
+@dataclass
+class CancelResponse(CreateResponse):
+    """
+    The cancel response structure.
+    """
+
+
+@dataclass
+class CheckResult(Common):
+    """
+    The result object for the check response.
+    """
+    state: int
+
+
+@dataclass
+class CheckResponse(Common):
+    """
+    The check response structure.
+    """
+    result: CheckResult
+
+
+@dataclass
+class GetResponse(CreateResponse):
+    """
+    The result object for the get response.
+    """
+
+
+@dataclass
+class GetAllResponse(Common):
+    """
+    The result object for the get all response.
+    """
+    result: list[Receipt] = None