payme-pkg 2.6.5__py3-none-any.whl → 3.0.17__py3-none-any.whl

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

payme/receipts/subscribe_receipts.py

@@ -1,217 +0,0 @@
-from ..decorators.decorators import payme_request
-from ..utils.to_json import to_json
-
-
-class PaymeSubscribeReceipts:
-    """
-    The PaymeSubscribeReceipts class includes
-    all paycom methods which are belongs receipts part.
-
-    Parameters
-    ----------
-    base_url string: The base url of the paycom api
-    paycom_id string: The paycom_id uses to identify
-    paycom_key string: The paycom_key uses to identify too
-
-    Full method documentation
-    -------------------------
-    https://developer.help.paycom.uz/metody-subscribe-api/
-    """
-
-    def __init__(
-        self,
-        base_url: str,
-        paycom_id: str,
-        paycom_key: str,
-        timeout: int = 5
-    ) -> "PaymeSubscribeReceipts":
-        self.base_url: str = base_url
-        self.headers: dict = {
-            "X-Auth": f"{paycom_id}:{paycom_key}"
-        }
-        self.__methods: dict = {
-            "receipts_get": "receipts.get",
-            "receipts_pay": "receipts.pay",
-            "receipts_send": "receipts.send",
-            "receipts_check": "receipts.check",
-            "receipts_cancel": "receipts.cancel",
-            "receipts_create": "receipts.create",
-            "receipts_get_all": "receipts.get_all",
-        }
-        self.timeout = timeout
-
-    @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 receipts_create(self, amount: float, order_id: int) -> dict:
-        """
-        Use this method to create a new payment receipt.
-
-        Parameters
-        ----------
-        amount: float — Payment amount in tiyins
-        order_id: int — Order object ID
-
-        Full method documentation
-        -------------------------
-        https://developer.help.paycom.uz/metody-subscribe-api/receipts.create
-        """
-        data: dict = {
-            "method": self.__methods.get("receipts_create"),
-            "params": {
-                "amount": amount,
-                "account": {
-                    "order_id": order_id,
-                }
-            }
-        }
-        return self.__request(to_json(**data))
-
-    def receipts_pay(self, invoice_id: str, token: str, phone: str) -> dict:
-        """
-        Use this method to pay for an exist receipt.
-
-        Parameters
-        ----------
-        invoice_id: str — Invoice id for identity transaction
-        token: str — The card's active token
-        phone: str —The payer's phone number
-
-        Full method documentation
-        -------------------------
-        https://developer.help.paycom.uz/metody-subscribe-api/receipts.pay
-        """
-        data: dict = {
-            "method": self.__methods.get("receipts_pay"),
-            "params": {
-                "id": invoice_id,
-                "token": token,
-                "payer": {
-                    "phone": phone,
-                }
-            }
-        }
-        return self.__request(to_json(**data))
-
-    def receipts_send(self, invoice_id: str, phone: str) -> dict:
-        """
-        Use this method to send a receipt for payment in an SMS message.
-
-        Parameters
-        ----------
-        invoice_id: str — The invoice id for identity transaction
-        phone: str — The payer's phone number
-
-        Full method documentation
-        -------------------------
-        https://developer.help.paycom.uz/metody-subscribe-api/receipts.send
-        """
-        data: dict = {
-            "method": self.__methods.get('receipts_send'),
-            "params": {
-                "id": invoice_id,
-                "phone": phone
-            }
-        }
-        return self.__request(to_json(**data))
-
-    def receipts_cancel(self, invoice_id: str) -> dict:
-        """
-        Use this method a paid check in the queue for cancellation.
-
-        Parameters
-        ----------
-        invoice_id: str — The invoice id for identity transaction
-
-        Full method documentation
-        -------------------------
-        https://developer.help.paycom.uz/metody-subscribe-api/receipts.cancel
-        """
-        data: dict = {
-            "method": self.__methods.get('receipts_cancel'),
-            "params": {
-                "id": invoice_id
-            }
-        }
-
-        return self.__request(to_json(**data))
-
-    def receipts_check(self, invoice_id: str) -> dict:
-        """
-        Use this method check for an exist receipt.
-
-        Parameters
-        ----------
-        invoice_id: str — The invoice id for identity transaction
-
-        Full method documentation
-        -------------------------
-        https://developer.help.paycom.uz/metody-subscribe-api/receipts.check
-        """
-        data: dict = {
-            "method": self.__methods.get('receipts_check'),
-            "params": {
-                "id": invoice_id
-            }
-        }
-
-        return self.__request(to_json(**data))
-
-    def receipts_get(self, invoice_id: str) -> dict:
-        """
-        Use this method check status for an exist receipt.
-
-        Parameters
-        ----------
-        invoice_id: str — The invoice id for identity transaction
-
-        Full method documentation
-        -------------------------
-        https://developer.help.paycom.uz/metody-subscribe-api/receipts.get
-        """
-        data: dict = {
-            "method": self.__methods.get('receipts_get'),
-            "params": {
-                "id": invoice_id
-            }
-        }
-
-        return self.__request(to_json(**data))
-
-    def receipts_get_all(self, count: int, _from: int, _to: int, offset: int) -> dict:
-        """
-        Use this method get all complete information, on checks for a certain period.
-
-        Parameters
-        ----------
-        count: int — The number of checks. Maximum value - 50
-        _from: str — The date of the beginning
-        _to: int — The date of the ending
-        offset: str — The number of subsequent skipped checks.
-
-        Full method documentation
-        -------------------------
-        https://developer.help.paycom.uz/metody-subscribe-api/receipts.get_all
-        """
-        data: dict = {
-            "method": self.__methods.get('receipts_get_all'),
-            "params": {
-                "count": count,
-                "from": _from,
-                "to": _to,
-                "offset": offset
-            }
-        }
-        return self.__request(to_json(**data))

payme/serializers.py

@@ -1,86 +0,0 @@
-from django.conf import settings
-
-from rest_framework import serializers
-
-from payme.models import Order
-from payme.utils.logging import logger
-from payme.utils.get_params import get_params
-from payme.models import MerchantTransactionsModel
-from payme.errors.exceptions import IncorrectAmount
-from payme.errors.exceptions import PerformTransactionDoesNotExist
-
-
-class MerchantTransactionsModelSerializer(serializers.ModelSerializer):
-    """
-    MerchantTransactionsModelSerializer class \
-        That's used to serialize merchant transactions data.
-    """
-    start_date = serializers.IntegerField(allow_null=True)
-    end_date = serializers.IntegerField(allow_null=True)
-
-    class Meta:
-        # pylint: disable=missing-class-docstring
-        model: MerchantTransactionsModel = MerchantTransactionsModel
-        fields: str = "__all__"
-        extra_fields = ['start_date', 'end_date']
-
-    def validate(self, attrs) -> dict:
-        """
-        Validate the data given to the MerchantTransactionsModel.
-        """
-        if attrs.get("order_id") is not None:
-            try:
-                order = Order.objects.get(
-                    id=attrs['order_id']
-                )
-                if order.amount != int(attrs['amount']):
-                    raise IncorrectAmount()
-
-            except IncorrectAmount as error:
-                logger.error("Invalid amount for order: %s", attrs['order_id'])
-                raise IncorrectAmount() from error
-
-        return attrs
-
-    def validate_amount(self, amount: int) -> int:
-        """
-        Validator for Transactions Amount.
-        """
-        if amount is not None:
-            if int(amount) <= int(settings.PAYME.get("PAYME_MIN_AMOUNT", 0)):
-                raise IncorrectAmount("Payment amount is less than allowed.")
-
-        return amount
-
-    def validate_order_id(self, order_id) -> int:
-        """
-        Use this method to check if a transaction is allowed to be executed.
-
-        Parameters
-        ----------
-        order_id: str -> Order Indentation.
-        """
-        try:
-            Order.objects.get(id=order_id)
-        except Order.DoesNotExist as error:
-            logger.error("Order does not exist order_id: %s", order_id)
-            raise PerformTransactionDoesNotExist() from error
-
-        return order_id
-
-    @staticmethod
-    def get_validated_data(params: dict) -> dict:
-        """
-        This static method helps to get validated data.
-
-        Parameters
-        ----------
-        params: dict — Includes request params.
-        """
-        serializer = MerchantTransactionsModelSerializer(
-            data=get_params(params)
-        )
-        serializer.is_valid(raise_exception=True)
-        clean_data: dict = serializer.validated_data
-
-        return clean_data

payme/utils/get_params.py

@@ -1,24 +0,0 @@
-from django.conf import settings
-
-
-def get_params(params: dict) -> dict:
-    """
-    Use this function to get the parameters from the payme.
-    """
-    account: dict = params.get("account")
-
-    clean_params: dict = {}
-    clean_params["_id"] = params.get("id")
-    clean_params["time"] = params.get("time")
-    clean_params["amount"] = params.get("amount")
-    clean_params["reason"] = params.get("reason")
-
-    # get statement method params
-    clean_params["start_date"] = params.get("from")
-    clean_params["end_date"] = params.get("to")
-
-    if account is not None:
-        account_name: str = settings.PAYME.get("PAYME_ACCOUNT")
-        clean_params["order_id"] = account[account_name]
-
-    return clean_params

payme/utils/logging.py

@@ -1,9 +0,0 @@
-import logging
-
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s %(levelname)s %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S'
-)
-
-logger = logging.getLogger(__name__)

payme/utils/make_aware_datetime.py

@@ -1,21 +0,0 @@
-from django.utils.timezone import datetime as dt
-from django.utils.timezone import make_aware
-
-
-def make_aware_datetime(start_date: int, end_date: int):
-    """
-    Convert Unix timestamps to aware datetimes.
-
-    :param start_date: Unix timestamp (milliseconds)
-    :param end_date: Unix timestamp (milliseconds)
-
-    :return: A tuple of two aware datetimes
-    """
-    return map(
-        lambda timestamp: make_aware(
-            dt.fromtimestamp(
-                timestamp / 1000
-            )
-        ),
-        [start_date, end_date]
-    )

payme/utils/support.py

@@ -1,8 +0,0 @@
-"""
-Author: Muhammadali Akbarov
-Gmail: muhammadali17abc@gmail.com
-Phone: +998888351717
-Telegram: @Muhammadalive
-Twitter: https://twitter.com/muhammadali_abc
-GitHub: https://github.com/Muhammadali-Akbarov/
-"""