payme-pkg 2.5.3__py3-none-any.whl

payme/methods/perform_transaction.py

@@ -0,0 +1,47 @@
+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 MerchatTransactionsModel
+from payme.serializers import MerchatTransactionsModelSerializer
+
+
+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) -> dict:
+        serializer = MerchatTransactionsModelSerializer(
+            data=get_params(params)
+        )
+        serializer.is_valid(raise_exception=True)
+        clean_data: dict = serializer.validated_data
+        response: dict = None
+        try:
+            transaction = \
+                MerchatTransactionsModel.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

@@ -0,0 +1,48 @@
+# 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='MerchatTransactionsModel',
+            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/models.py

@@ -0,0 +1,61 @@
+from django.db import models
+from django.conf import settings
+from django.utils.module_loading import import_string
+from django.core.exceptions import FieldError
+
+from payme.utils.logging import logger
+
+
+class MerchatTransactionsModel(models.Model):
+    """
+    MerchatTransactionsModel class \
+        That's used for managing transactions in database.
+    """
+    _id = models.CharField(max_length=255, null=True, blank=False)
+    transaction_id = models.CharField(max_length=255, null=True, blank=False)
+    order_id = models.BigIntegerField(null=True, blank=True)
+    amount = models.FloatField(null=True, blank=True)
+    time = models.BigIntegerField(null=True, blank=True)
+    perform_time = models.BigIntegerField(null=True, default=0)
+    cancel_time = models.BigIntegerField(null=True, default=0)
+    state = models.IntegerField(null=True, default=1)
+    reason = models.CharField(max_length=255, null=True, blank=True)
+    created_at_ms = models.CharField(max_length=255, null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return str(self._id)
+
+
+try:
+    CUSTOM_ORDER = import_string(settings.ORDER_MODEL)
+
+    if not isinstance(CUSTOM_ORDER, models.base.ModelBase):
+        raise TypeError("The input must be an instance of models.Model class")
+
+    # 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")
+
+    Order = CUSTOM_ORDER
+except (ImportError, AttributeError):
+    logger.warning("You have no payme custom order model")
+
+    CUSTOM_ORDER = None
+
+    class Order(models.Model):
+        """
+        Order class \
+            That's used for managing order process
+        """
+        amount = models.IntegerField(null=True, blank=True)
+        created_at = models.DateTimeField(auto_now_add=True)
+        updated_at = models.DateTimeField(auto_now=True)
+
+        def __str__(self):
+            return f"ORDER ID: {self.id} - AMOUNT: {self.amount}"
+
+        class Meta:
+            # pylint: disable=missing-class-docstring
+            managed = False

payme/receipts/__init__.py

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

payme/receipts/subscribe_receipts.py

@@ -0,0 +1,217 @@
+from payme.utils.to_json import to_json
+from payme.decorators.decorators import payme_request
+
+
+
+class PaymeSubscribeReceipts:
+    """
+    The PaymeSubscribeReceipts class inclues
+    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 indentity 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 indentity 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 indentity 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 indentity 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 reciepts_get(self, invoice_id: str) -> dict:
+        """
+        Use this method check status for an exist receipt.
+
+        Parameters
+        ----------
+        invoice_id: str — The invoice id for indentity 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 reciepts_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: str = {
+            "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

@@ -0,0 +1,88 @@
+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 MerchatTransactionsModel
+from payme.errors.exceptions import IncorrectAmount
+from payme.errors.exceptions import PerformTransactionDoesNotExist
+
+
+class MerchatTransactionsModelSerializer(serializers.ModelSerializer):
+    """
+    MerchatTransactionsModelSerializer class \
+        That's used to serialize merchat transactions data.
+    """
+    start_date = serializers.IntegerField(allow_null=True)
+    end_date = serializers.IntegerField(allow_null=True)
+
+    class Meta:
+        # pylint: disable=missing-class-docstring
+        model: MerchatTransactionsModel = MerchatTransactionsModel
+        fields: str = "__all__"
+        extra_fields = ['start_date', 'end_date']
+
+    def validate(self, attrs) -> dict:
+        """
+        Validate the data given to the MerchatTransactionsModel.
+        """
+        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:
+        """
+        Validator for Transactions Amount.
+        """
+        if amount is None:
+            raise IncorrectAmount()
+
+        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 = MerchatTransactionsModelSerializer(
+            data=get_params(params)
+        )
+        serializer.is_valid(raise_exception=True)
+        clean_data: dict = serializer.validated_data
+
+        return clean_data

payme/urls.py

@@ -0,0 +1,8 @@
+from django.urls import path
+
+from payme.views import MerchantAPIView
+
+
+urlpatterns = [
+    path("merchant/", MerchantAPIView.as_view())
+]

payme/utils/get_params.py

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,21 @@
+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

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

payme/utils/to_json.py

@@ -0,0 +1,12 @@
+import json
+
+def to_json(**kwargs) -> dict:
+    """
+    Use this static method to data dumps.
+    """
+    data: dict = {
+        "method": kwargs.pop("method"),
+        "params": kwargs.pop("params"),
+    }
+
+    return json.dumps(data)