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

payme/errors/exceptions.py

@@ -1,89 +0,0 @@
-from rest_framework.exceptions import APIException
-
-
-class BasePaymeException(APIException):
-    """
-    BasePaymeException it's APIException.
-    """
-    status_code = 200
-    error_code = None
-    message = None
-
-    # pylint: disable=super-init-not-called
-    def __init__(self, error_message: str = None):
-        detail: dict = {
-            "error": {
-                "code": self.error_code,
-                "message": self.message,
-                "data": error_message
-            }
-        }
-        self.detail = detail
-
-
-class PermissionDenied(BasePaymeException):
-    """
-    PermissionDenied APIException \
-        That is raised when the client is not allowed to server.
-    """
-    status_code = 200
-    error_code = -32504
-    message = "Permission denied"
-
-
-class MethodNotFound(BasePaymeException):
-    """
-    MethodNotFound APIException \
-        That is raised when the method does not exist.
-    """
-    status_code = 405
-    error_code = -32601
-    message = 'Method not found'
-
-
-class TooManyRequests(BasePaymeException):
-    """
-    TooManyRequests APIException \
-        That is raised when the request exceeds the limit.
-    """
-    status_code = 200
-    error_code = -31099
-    message = {
-        "uz": "Buyurtma tolovni amalga oshirish jarayonida",
-        "ru": "Транзакция в очереди",
-        "en": "Order payment status is queued"
-    }
-
-
-class IncorrectAmount(BasePaymeException):
-    """
-    IncorrectAmount APIException \
-        That is raised when the amount is not incorrect.
-    """
-    status_code = 200
-    error_code = -31001
-    message = {
-        'ru': 'Неверная сумма',
-        'uz': "Noto'g'ri qiymat",
-        'en': 'Incorrect amount',
-    }
-
-
-class PerformTransactionDoesNotExist(BasePaymeException):
-    """
-    PerformTransactionDoesNotExist APIException \
-        That is raised when a transaction does not exist or deleted.
-    """
-    status_code = 200
-    error_code = -31050
-    message = {
-        "uz": "Buyurtma topilmadi",
-        "ru": "Заказ не существует",
-        "en": "Order does not exists"
-    }
-
-
-class PaymeTimeoutException(Exception):
-    """
-    Payme timeout exception that means that payme is working slowly.
-    """

payme/methods/cancel_transaction.py

@@ -1,54 +0,0 @@
-import time
-
-from django.db import transaction
-
-from payme.utils.logging import logger
-from payme.models import MerchantTransactionsModel
-from payme.errors.exceptions import PerformTransactionDoesNotExist
-from payme.serializers import MerchantTransactionsModelSerializer as MTMS
-
-
-class CancelTransaction:
-    """
-    CancelTransaction class
-    That is used to cancel a transaction.
-
-    Full method documentation
-    -------------------------
-    https://developer.help.paycom.uz/metody-merchant-api/canceltransaction
-    """
-
-    @transaction.atomic
-    def __call__(self, params: dict):
-        clean_data: dict = MTMS.get_validated_data(
-            params=params
-        )
-        try:
-            with transaction.atomic():
-                transactions: MerchantTransactionsModel = \
-                    MerchantTransactionsModel.objects.filter(
-                        _id=clean_data.get('_id'),
-                    ).first()
-                if transactions.cancel_time == 0:
-                    transactions.cancel_time = int(time.time() * 1000)
-                if transactions.perform_time == 0:
-                    transactions.state = -1
-                if transactions.perform_time != 0:
-                    transactions.state = -2
-                transactions.reason = clean_data.get("reason")
-                transactions.save()
-
-        except PerformTransactionDoesNotExist as error:
-            logger.error("Paycom transaction does not exist: %s", error)
-            raise PerformTransactionDoesNotExist() from error
-
-        response: dict = {
-            "result": {
-                "state": transactions.state,
-                "cancel_time": transactions.cancel_time,
-                "transaction": transactions.transaction_id,
-                "reason": int(transactions.reason),
-            }
-        }
-
-        return transactions.order_id, response

payme/methods/check_perform_transaction.py

@@ -1,26 +0,0 @@
-from payme.utils.get_params import get_params
-from payme.serializers import MerchantTransactionsModelSerializer
-
-
-class CheckPerformTransaction:
-    """
-    CheckPerformTransaction class
-    That's used to check perform transaction.
-
-    Full method documentation
-    -------------------------
-    https://developer.help.paycom.uz/metody-merchant-api/checktransaction
-    """
-    def __call__(self, params: dict) -> tuple:
-        serializer = MerchantTransactionsModelSerializer(
-            data=get_params(params)
-        )
-        serializer.is_valid(raise_exception=True)
-
-        response = {
-            "result": {
-                "allow": True,
-                }
-            }
-
-        return None, response

payme/methods/check_transaction.py

@@ -1,43 +0,0 @@
-from django.db import DatabaseError
-
-from payme.utils.logging import logger
-from payme.models import MerchantTransactionsModel
-from payme.serializers import MerchantTransactionsModelSerializer as MTMS
-
-
-class CheckTransaction:
-    """
-    CheckTransaction class
-    That's used to check transaction
-
-    Full method documentation
-    -------------------------
-    https://developer.help.paycom.uz/metody-merchant-api/checkperformtransaction
-    """
-    def __call__(self, params: dict) -> tuple:
-        clean_data: dict = MTMS.get_validated_data(
-            params=params
-        )
-
-        try:
-            transaction = \
-                MerchantTransactionsModel.objects.get(
-                    _id=clean_data.get("_id"),
-                )
-            response = {
-                "result": {
-                    "create_time": int(transaction.created_at_ms),
-                    "perform_time": transaction.perform_time,
-                    "cancel_time": transaction.cancel_time,
-                    "transaction": transaction.transaction_id,
-                    "state": transaction.state,
-                    "reason": None,
-                }
-            }
-            if transaction.reason is not None:
-                response["result"]["reason"] = int(transaction.reason)
-
-        except DatabaseError as error:
-            logger.error("Error getting transaction in database: %s", error)
-
-        return None, response

payme/methods/create_transaction.py

@@ -1,68 +0,0 @@
-import uuid
-import time
-import datetime
-
-from payme.utils.logging import logger
-from payme.utils.get_params import get_params
-from payme.models import MerchantTransactionsModel
-from payme.errors.exceptions import TooManyRequests
-from payme.serializers import MerchantTransactionsModelSerializer
-
-
-class CreateTransaction:
-    """
-    CreateTransaction class
-    That's used to create transaction
-
-    Full method documentation
-    -------------------------
-    https://developer.help.paycom.uz/metody-merchant-api/createtransaction
-    """
-    def __call__(self, params: dict) -> tuple:
-        serializer = MerchantTransactionsModelSerializer(
-            data=get_params(params)
-        )
-        serializer.is_valid(raise_exception=True)
-        order_id = serializer.validated_data.get("order_id")
-
-        try:
-            transaction = MerchantTransactionsModel.objects.filter(
-                order_id=order_id
-            ).last()
-
-            if transaction is not None:
-                if transaction._id != serializer.validated_data.get("_id"):
-                    raise TooManyRequests()
-
-        except TooManyRequests as error:
-            logger.error("Too many requests for transaction %s", error)
-            raise TooManyRequests() from error
-
-        if transaction is None:
-            transaction, _ = \
-                MerchantTransactionsModel.objects.get_or_create(
-                    _id=serializer.validated_data.get('_id'),
-                    order_id=serializer.validated_data.get('order_id'),
-                    transaction_id=uuid.uuid4(),
-                    amount=serializer.validated_data.get('amount'),
-                    created_at_ms=int(time.time() * 1000),
-                )
-
-        if transaction:
-            response: dict = {
-                "result": {
-                    "create_time": int(transaction.created_at_ms),
-                    "transaction": transaction.transaction_id,
-                    "state": int(transaction.state),
-                }
-            }
-
-        return order_id, response
-
-    @staticmethod
-    def _convert_ms_to_datetime(time_ms: int) -> datetime:
-        """Use this format to convert from time ms to datetime format.
-        """
-        readable_datetime = datetime.datetime.fromtimestamp(time_ms / 1000)
-
-        return readable_datetime

payme/methods/generate_link.py

@@ -1,83 +0,0 @@
-import base64
-from decimal import Decimal
-from dataclasses import dataclass
-
-from django.conf import settings
-
-PAYME_ID = settings.PAYME.get('PAYME_ID')
-PAYME_ACCOUNT = settings.PAYME.get('PAYME_ACCOUNT')
-PAYME_CALL_BACK_URL = settings.PAYME.get('PAYME_CALL_BACK_URL')
-PAYME_URL = settings.PAYME.get("PAYME_URL")
-
-
-@dataclass
-class GeneratePayLink:
-    """
-    GeneratePayLink dataclass
-    That's used to generate pay lint for each order.
-
-    Parameters
-    ----------
-    order_id: int — The order_id for paying
-    amount: int — The amount belong to the order
-    callback_url: str \
-        The merchant api callback url to redirect after payment. Optional parameter.
-        By default, it takes PAYME_CALL_BACK_URL from your settings
-
-    Returns str — pay link
-    ----------------------
-
-    Full method documentation
-    -------------------------
-    https://developer.help.paycom.uz/initsializatsiya-platezhey/
-    """
-    order_id: str
-    amount: Decimal
-    callback_url: str = None
-
-    def generate_link(self) -> str:
-        """
-        GeneratePayLink for each order.
-        """
-        generated_pay_link: str = "{payme_url}/{encode_params}"
-        params: str = 'm={payme_id};ac.{payme_account}={order_id};a={amount};c={call_back_url}'
-
-        if self.callback_url:
-            redirect_url = self.callback_url
-        else:
-            redirect_url = PAYME_CALL_BACK_URL
-
-        params = params.format(
-            payme_id=PAYME_ID,
-            payme_account=PAYME_ACCOUNT,
-            order_id=self.order_id,
-            amount=self.amount,
-            call_back_url=redirect_url
-        )
-        encode_params = base64.b64encode(params.encode("utf-8"))
-        return generated_pay_link.format(
-            payme_url=PAYME_URL,
-            encode_params=str(encode_params, 'utf-8')
-        )
-
-    @staticmethod
-    def to_tiyin(amount: Decimal) -> Decimal:
-        """ 
-        Convert from sum to tiyin.
-
-        Parameters 
-        ---------- 
-        amount: Decimal -> order amount 
-        """
-        return amount * 100
-
-    @staticmethod
-    def to_sum(amount: Decimal) -> Decimal:
-        """ 
-        Convert from tiyin to sum.
-
-        Parameters
-        ---------- 
-        amount: Decimal -> order amount 
-        """
-        return amount / 100

payme/methods/get_statement.py

@@ -1,65 +0,0 @@
-from django.db import DatabaseError
-
-from payme.utils.logging import logger
-from payme.models import MerchantTransactionsModel
-from payme.serializers import MerchantTransactionsModelSerializer as MTMS
-from payme.utils.make_aware_datetime import make_aware_datetime as mad
-
-
-class GetStatement:
-    """
-    GetStatement class
-    Transaction information is used for reconciliation
-    of merchant and Payme Business transactions.
-
-    Full method documentation
-    -------------------------
-    https://developer.help.paycom.uz/metody-merchant-api/getstatement
-    """
-
-    def __call__(self, params: dict) -> tuple:
-        clean_data: dict = MTMS.get_validated_data(
-            params=params
-        )
-
-        start_date, end_date = mad(
-            int(clean_data.get("start_date")),
-            int(clean_data.get("end_date"))
-        )
-
-        try:
-            transactions = \
-                MerchantTransactionsModel.objects.filter(
-                    created_at__gte=start_date,
-                    created_at__lte=end_date
-                )
-
-            if not transactions:  # no transactions found for the period
-                return None, {"result": {"transactions": []}}
-
-            statements = [
-                {
-                    'id': t._id,
-                    'time': int(t.created_at.timestamp()),
-                    'amount': t.amount,
-                    'account': {'order_id': t.order_id},
-                    'create_time': int(t.created_at_ms),
-                    'perform_time': t.perform_time,
-                    'cancel_time': t.cancel_time,
-                    'transaction': t.order_id,
-                    'state': t.state,
-                    'reason': int(t.reason) if t.reason is not None else None,
-                    'receivers': []  # not implemented
-                } for t in transactions
-            ]
-
-            response: dict = {
-                "result": {
-                    "transactions": statements
-                }
-            }
-        except DatabaseError as error:
-            logger.error("Error getting transaction in database: %s", error)
-            response = {"result": {"transactions": []}}
-
-        return None, response

payme/methods/perform_transaction.py

@@ -1,47 +0,0 @@
-import time
-
-from django.db import DatabaseError
-
-from payme.utils.logging import logger
-from payme.utils.get_params import get_params
-from payme.models import MerchantTransactionsModel
-from payme.serializers import MerchantTransactionsModelSerializer
-
-
-class PerformTransaction:
-    """
-    PerformTransaction class
-    That's used to perform a transaction.
-
-    Full method documentation
-    -------------------------
-    https://developer.help.paycom.uz/metody-merchant-api/performtransaction
-    """
-    def __call__(self, params: dict) -> tuple:
-        serializer = MerchantTransactionsModelSerializer(
-            data=get_params(params)
-        )
-        serializer.is_valid(raise_exception=True)
-        clean_data: dict = serializer.validated_data
-        response: dict = None
-        try:
-            transaction = \
-                MerchantTransactionsModel.objects.get(
-                    _id=clean_data.get("_id"),
-                )
-            transaction.state = 2
-            if transaction.perform_time == 0:
-                transaction.perform_time = int(time.time() * 1000)
-
-            transaction.save()
-            response: dict = {
-                "result": {
-                    "perform_time": int(transaction.perform_time),
-                    "transaction": transaction.transaction_id,
-                    "state": int(transaction.state),
-                }
-            }
-        except DatabaseError as error:
-            logger.error("error while getting transaction in db: %s", error)
-
-        return transaction.order_id, response

payme/migrations/0001_initial.py

@@ -1,48 +0,0 @@
-# pylint: disable=invalid-name
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-    # pylint: disable=missing-class-docstring
-    initial = True
-    dependencies = []
-
-    operations = [
-        migrations.CreateModel(
-            name='MerchantTransactionsModel',
-            fields=[
-                ('id', models.BigAutoField(
-                    auto_created=True,
-                    primary_key=True,
-                    serialize=False,
-                    verbose_name='ID')
-                 ),
-                ('_id', models.CharField(max_length=255, null=True)),
-                ('transaction_id', models.CharField(max_length=255, null=True)),
-                ('order_id', models.BigIntegerField(blank=True, null=True)),
-                ('amount', models.FloatField(blank=True, null=True)),
-                ('time', models.BigIntegerField(blank=True, null=True)),
-                ('perform_time', models.BigIntegerField(default=0, null=True)),
-                ('cancel_time', models.BigIntegerField(default=0, null=True)),
-                ('state', models.IntegerField(default=1, null=True)),
-                ('reason', models.CharField(blank=True, max_length=255, null=True)),
-                ('created_at_ms', models.CharField(blank=True, max_length=255, null=True)),
-                ('created_at', models.DateTimeField(auto_now_add=True)),
-                ('updated_at', models.DateTimeField(auto_now=True)),
-            ],
-        ),
-        migrations.CreateModel(
-            name='Order',
-            fields=[
-                ('id', models.BigAutoField(
-                    auto_created=True,
-                    primary_key=True,
-                    serialize=False,
-                    verbose_name='ID')
-                 ),
-                ('amount', models.IntegerField(blank=True, null=True)),
-                ('created_at', models.DateTimeField(auto_now_add=True)),
-                ('updated_at', models.DateTimeField(auto_now=True)),
-            ],
-        ),
-    ]

payme/receipts/__init__.py

@@ -1 +0,0 @@
-from .import subscribe_receipts