payme-pkg 2.5.3__py3-none-any.whl

payme/admin.py

@@ -0,0 +1,11 @@
+from django.contrib import admin
+
+from payme.models import CUSTOM_ORDER
+from payme.models import Order as DefaultOrderModel
+
+from payme.models import MerchatTransactionsModel
+
+if not CUSTOM_ORDER:
+    admin.site.register(DefaultOrderModel)
+
+admin.site.register(MerchatTransactionsModel)

payme/apps.py

@@ -0,0 +1,10 @@
+from django.apps import AppConfig
+
+
+class PaymeConfig(AppConfig):
+    """
+    PaymeConfig AppConfig \
+        That is used to configure the payme application with django settings.
+    """
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'payme'

payme/cards/__init__.py

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

payme/cards/subscribe_cards.py

@@ -0,0 +1,166 @@
+from payme.utils.to_json import to_json
+from payme.decorators.decorators import payme_request
+
+
+class PaymeSubscribeCards:
+    """
+    The PaymeSubscribeCards class inclues
+    all paycom methods which are belongs to cards.
+
+    Parameters
+    ----------
+    base_url: str — The base url of the paycom api
+    paycom_id: str — The paycom_id uses to identify
+    timeout: int — How many seconds to wait for the server to send data
+
+    Full method documentation
+    -------------------------
+    https://developer.help.paycom.uz/metody-subscribe-api/
+    """
+    def __init__(
+        self,
+        base_url: str,
+        paycom_id: str,
+        timeout=5
+    ) -> "PaymeSubscribeCards":
+        self.base_url: str = base_url
+        self.timeout: int = timeout
+        self.headers: dict = {
+            "X-Auth": paycom_id,
+        }
+        self.__methods: dict = {
+            "cards_check": "cards.check",
+            "cards_create": "cards.create",
+            "cards_remove": "cards.remove",
+            "cards_verify": "cards.verify",
+            "cards_get_verify_code": "cards.get_verify_code",
+        }
+
+    @payme_request
+    def __request(self, data) -> dict:
+        """
+        Use this private method to request.
+        On success,response will be OK with format JSON.
+
+        Parameters
+        ----------
+        data: dict — Includes request data.
+
+        Returns dictionary Payme Response
+        ---------------------------------
+        """
+        return data
+
+    def cards_create(self, number: str, expire: str, save: bool = True) -> dict:
+        """
+        Use this method to create a new card's token.
+
+        Parameters
+        ----------
+        number: str — The card number maximum length 18 char
+        expire: str — The card expiration string maximum length 5 char
+        save: bool \
+            Type of token. Optional parameter
+            The option is enabled or disabled depending on the application's business logic
+            If the flag is true, the token can be used for further payments
+            if the flag is false the token can only be used once
+            The one-time token is deleted after payment
+
+        Full method documentation
+        -------------------------
+        https://developer.help.paycom.uz/metody-subscribe-api/cards.create
+        """
+        data: dict = {
+            "method": self.__methods.get("cards_create"),
+            "params": {
+                "card": {
+                    "number": number,
+                    "expire": expire,
+                },
+                "save": save,
+            }
+        }
+        return self.__request(to_json(**data))
+
+    def card_get_verify_code(self, token: str) -> dict:
+        """
+        Use this method to get the verification code.
+
+        Parameters
+        ----------
+        token: str — The card's non-active token
+
+        Full method documentation
+        -------------------------
+        https://developer.help.paycom.uz/metody-subscribe-api/cards.get_verify_code
+        """
+        data: dict = {
+            "method": self.__methods.get('cards_get_verify_code'),
+            "params": {
+                "token": token,
+            }
+        }
+        return self.__request(to_json(**data))
+
+    def cards_verify(self, verify_code: int, token: str) -> dict:
+        """
+        Verification of the card using the code sent via SMS.
+
+        Parameters
+        ----------
+        verify_code: int — Code for verification
+        token: str — The card's non-active token
+
+        Full method documentation
+        -------------------------
+        https://developer.help.paycom.uz/metody-subscribe-api/cards.verify
+        """
+        data: dict = {
+            "method": self.__methods.get("cards_verify"),
+            "params": {
+                "token": token,
+                "code": verify_code
+            }
+        }
+        return self.__request(to_json(**data))
+
+    def cards_check(self, token: str) -> dict:
+        """
+        Checking the card token active or non-active.
+
+        Parameters
+        ----------
+        token: str — The card's non-active token
+
+        Full method documentation
+        -------------------------
+        https://developer.help.paycom.uz/metody-subscribe-api/cards.check
+        """
+        data: dict = {
+            "method": self.__methods.get("cards_check"),
+            "params": {
+                "token": token,
+            }
+        }
+
+        return self.__request(to_json(**data))
+
+    def cards_remove(self, token: str) -> dict:
+        """
+        Delete card's token on success returns success.
+
+        Parameters
+        ----------
+        token: str — The card's non-active token
+
+        Full method documentation
+        -------------------------
+        https://developer.help.paycom.uz/metody-subscribe-api/cards.remove
+        """
+        data: dict = {
+            "method": self.__methods.get("cards_remove"),
+            "params": {
+                "token": token,
+            }
+        }
+        return self.__request(to_json(**data))

payme/decorators/decorators.py

@@ -0,0 +1,34 @@
+import functools
+
+from requests import request
+from requests.exceptions import Timeout
+from requests.exceptions import RequestException
+
+from payme.utils.logging import logger
+
+from ..errors.exceptions import PaymeTimeoutException
+
+
+def payme_request(func):
+    """
+    Payme request decorator.
+    """
+    @functools.wraps(func)
+    def wrapper(self, data):
+        response = None
+        req_data = {
+            "method": "POST",
+            "url": self.base_url,
+            "data": data,
+            "headers": self.headers,
+            "timeout": self.timeout,
+        }
+        try:
+            response = request(**req_data)
+            response.raise_for_status()
+        except (Timeout, RequestException) as error:
+            logger.info("Payme request has been failed as error: %s", error)
+            raise PaymeTimeoutException() from error
+        return response.json()
+
+    return wrapper

payme/errors/exceptions.py

@@ -0,0 +1,89 @@
+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': 'Incorrect amount',
+        '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

@@ -0,0 +1,54 @@
+import time
+
+from django.db import transaction
+
+from payme.utils.logging import logger
+from payme.models import MerchatTransactionsModel
+from payme.errors.exceptions import PerformTransactionDoesNotExist
+from payme.serializers import MerchatTransactionsModelSerializer 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: MerchatTransactionsModel = \
+                    MerchatTransactionsModel.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

@@ -0,0 +1,26 @@
+from payme.utils.get_params import get_params
+from payme.serializers import MerchatTransactionsModelSerializer
+
+
+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) -> dict:
+        serializer = MerchatTransactionsModelSerializer(
+            data=get_params(params)
+        )
+        serializer.is_valid(raise_exception=True)
+
+        response = {
+            "result": {
+                "allow": True,
+                }
+            }
+
+        return None, response

payme/methods/check_transaction.py

@@ -0,0 +1,43 @@
+from django.db import DatabaseError
+
+from payme.utils.logging import logger
+from payme.models import MerchatTransactionsModel
+from payme.serializers import MerchatTransactionsModelSerializer 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) -> None:
+        clean_data: dict = MTMS.get_validated_data(
+            params=params
+        )
+
+        try:
+            transaction = \
+                MerchatTransactionsModel.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

@@ -0,0 +1,68 @@
+import uuid
+import time
+import datetime
+
+from payme.utils.logging import logger
+from payme.utils.get_params import get_params
+from payme.models import MerchatTransactionsModel
+from payme.errors.exceptions import TooManyRequests
+from payme.serializers import MerchatTransactionsModelSerializer
+
+
+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) -> dict:
+        serializer = MerchatTransactionsModelSerializer(
+            data=get_params(params)
+        )
+        serializer.is_valid(raise_exception=True)
+        order_id = serializer.validated_data.get("order_id")
+
+        try:
+            transaction = MerchatTransactionsModel.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, _ = \
+                MerchatTransactionsModel.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: str) -> int:
+        """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

@@ -0,0 +1,74 @@
+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
+
+    Returns str — pay link
+    ----------------------
+
+    Full method documentation
+    -------------------------
+    https://developer.help.paycom.uz/initsializatsiya-platezhey/
+    """
+    order_id: str
+    amount: Decimal
+
+    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}'
+
+        params = params.format(
+            payme_id=PAYME_ID,
+            payme_account=PAYME_ACCOUNT,
+            order_id=self.order_id,
+            amount=self.amount,
+            call_back_url=PAYME_CALL_BACK_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 soum to tiyin. 
+
+        Parameters 
+        ---------- 
+        amount: Decimal -> order amount 
+        """
+        return amount * 100
+
+    @staticmethod
+    def to_soum(amount: Decimal) -> Decimal:
+        """ 
+        Convert from tiyin to soum. 
+
+        Parameters 
+        ---------- 
+        amount: Decimal -> order amount 
+        """
+        return amount / 100

payme/methods/get_statement.py

@@ -0,0 +1,65 @@
+from django.db import DatabaseError
+
+from payme.utils.logging import logger
+from payme.models import MerchatTransactionsModel
+from payme.serializers import MerchatTransactionsModelSerializer 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):
+        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 = \
+                MerchatTransactionsModel.objects.filter(
+                    created_at__gte=start_date,
+                    created_at__lte=end_date
+                )
+
+            if not transactions:  # no transactions found for the period
+                return {"result": {"transactions": []}}
+
+            statements = [
+                {
+                    'id': t._id,
+                    'time': int(t.created_at.timestamp()),
+                    'amount': t.amount,
+                    'account': {'order_id': t.order_id},
+                    'create_time': t.state,
+                    'perform_time': t.perform_time,
+                    'cancel_time': t.cancel_time,
+                    'transaction': t.order_id,
+                    'state': t.state,
+                    'reason': t.reason,
+                    '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