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

payme/types/response/webhook.py

@@ -0,0 +1,136 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict
+
+
+class CommonResponse:
+    """
+    The common response structure
+    """
+    def as_resp(self):
+        response = {'result': {}}
+        for key, value in self.__dict__.items():
+            response['result'][key] = value
+        return response
+
+
+@dataclass
+class Shipping(CommonResponse):
+    """
+    Shipping information response structure
+    """
+    title: str
+    price: int
+
+
+@dataclass
+class Item(CommonResponse):
+    """
+    Item information response structure
+    """
+    discount: int
+    title: str
+    price: int
+    count: int
+    code: str
+    units: int
+    vat_percent: int
+    package_code: str
+
+    def as_resp(self):
+        return {
+            "discount": self.discount,
+            "title": self.title,
+            "price": self.price,
+            "count": self.count,
+            "code": self.code,
+            "units": self.units,
+            "vat_percent": self.vat_percent,
+            "package_code": self.package_code
+        }
+
+
+@dataclass
+class CheckPerformTransaction(CommonResponse):
+    """
+    Receipt information response structure for transaction checks.
+    """
+    allow: bool
+    additional: Optional[Dict[str, str]] = None
+    receipt_type: Optional[int] = None
+    shipping: Optional[Shipping] = None
+    items: List[Item] = field(default_factory=list)
+
+    def add_item(self, item: Item):
+        self.items.append(item)
+
+    def as_resp(self):
+        detail_dict = {}
+        receipt_dict = {"allow": self.allow}
+
+        if self.additional:
+            receipt_dict["additional"] = self.additional
+
+        if isinstance(self.receipt_type, int):
+            detail_dict["receipt_type"] = self.receipt_type
+
+        if self.shipping:
+            detail_dict["shipping"] = self.shipping.as_resp()
+
+        if self.items:
+            detail_dict["items"] = [item.as_resp() for item in self.items]
+
+        if detail_dict:
+            receipt_dict["detail"] = detail_dict
+
+        return {"result": receipt_dict}
+
+
+@dataclass
+class CreateTransaction(CommonResponse):
+    """
+    The create transaction request
+    """
+    transaction: str
+    state: str
+    create_time: str
+
+
+@dataclass
+class PerformTransaction(CommonResponse):
+    """
+    The perform transaction response
+    """
+    transaction: str
+    state: str
+    perform_time: str
+
+
+@dataclass
+class CancelTransaction(CommonResponse):
+    """
+    The cancel transaction request
+    """
+    transaction: str
+    state: str
+    cancel_time: str
+
+
+@dataclass
+class CheckTransaction(CommonResponse):
+    """
+    The check transaction request
+    """
+    transaction: str
+    state: str
+    reason: str
+    create_time: str
+    perform_time: Optional[str] = None
+    cancel_time: Optional[str] = None
+
+
+@dataclass
+class GetStatement(CommonResponse):
+    """
+    The check perform transactions response
+    """
+    transactions: List[str]

payme/urls.py

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

payme/util.py

@@ -0,0 +1,26 @@
+from datetime import datetime
+
+
+def time_to_payme(datatime) -> int:
+    """
+    Convert datetime object to Payme's datetime format.
+
+    Payme's datetime format is in the format: YYYY-MM-DD HH:MM:SS.ssssss
+
+    Args:
+    datatime (datetime): The datetime object to convert.
+
+    Returns:
+    str: The datetime object in Payme's datetime format.
+    """
+    if not datatime:
+        return 0
+
+    return int(datatime.timestamp() * 1000)
+
+
+def time_to_service(milliseconds: int) -> datetime:
+    """
+    Converts milliseconds since the epoch to a datetime object.
+    """
+    return datetime.fromtimestamp(milliseconds / 1000)

payme/views.py

@@ -1,163 +1,337 @@
 import base64
+import logging
 import binascii
+from decimal import Decimal
 
 from django.conf import settings
+from django.utils.module_loading import import_string
 
-from rest_framework.views import APIView
+from rest_framework import views
 from rest_framework.response import Response
-from rest_framework.exceptions import ValidationError
 
-from payme.utils.logging import logger
+from payme import exceptions
+from payme.types import response
+from payme.models import PaymeTransactions
+from payme.util import time_to_payme, time_to_service
 
-from payme.errors.exceptions import MethodNotFound
-from payme.errors.exceptions import PermissionDenied
-from payme.errors.exceptions import PerformTransactionDoesNotExist
+logger = logging.getLogger(__name__)
+AccountModel = import_string(settings.PAYME_ACCOUNT_MODEL)
 
-from payme.methods.get_statement import GetStatement
-from payme.methods.check_transaction import CheckTransaction
-from payme.methods.cancel_transaction import CancelTransaction
-from payme.methods.create_transaction import CreateTransaction
-from payme.methods.perform_transaction import PerformTransaction
-from payme.methods.check_perform_transaction import CheckPerformTransaction
 
+def handle_exceptions(func):
+    """
+    Decorator to handle exceptions and raise appropriate Payme exceptions.
+    """
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except KeyError as exc:
+            message = "Invalid parameters received."
+            logger.error(f"{message}: {exc}s {exc} {args} {kwargs}")
+            raise exceptions.InternalServiceError(message) from exc
+
+        except AccountModel.DoesNotExist as exc:
+            logger.error(f"Account does not exist: {exc} {args} {kwargs}")
+            raise exceptions.AccountDoesNotExist(str(exc)) from exc
+
+        except PaymeTransactions.DoesNotExist as exc:
+            logger.error(f"Transaction does not exist: {exc} {args} {kwargs}")
+            raise exceptions.AccountDoesNotExist(str(exc)) from exc
 
-class MerchantAPIView(APIView):
+        except exceptions.exception_whitelist as exc:
+            # No need to raise exception for exception whitelist
+            raise exc
+        except Exception as exc:
+            logger.error(f"Unexpected error: {exc} {args} {kwargs}")
+            raise exceptions.InternalServiceError(str(exc)) from exc
+
+    return wrapper
+
+
+class PaymeWebHookAPIView(views.APIView):
     """
-    MerchantAPIView class provides payme call back functionality.
+    A webhook view for Payme.
     """
-    permission_classes = ()
     authentication_classes = ()
 
-    def post(self, request) -> Response:
+    def post(self, request, *args, **kwargs):
+        """
+        Handle the incoming webhook request.
+        """
+        self.check_authorize(request)
+
+        payme_methods = {
+            "GetStatement": self.get_statement,
+            "CancelTransaction": self.cancel_transaction,
+            "PerformTransaction": self.perform_transaction,
+            "CreateTransaction": self.create_transaction,
+            "CheckTransaction": self.check_transaction,
+            "CheckPerformTransaction": self.check_perform_transaction,
+        }
+
+        try:
+            method = request.data["method"]
+            params = request.data["params"]
+        except KeyError as exc:
+            message = f"Error processing webhook: {exc}"
+            raise exceptions.InternalServiceError(message) from exc
+
+        if method in payme_methods:
+            result = payme_methods[method](params)
+            return Response(result)
+
+        raise exceptions.MethodNotFound("Method not supported yet!")
+
+    @staticmethod
+    def check_authorize(request):
         """
-        Payme sends post request to our call back url.
-        That methods are includes 6 methods
-            - CheckPerformTransaction
-            - CreateTransaction
-            - PerformTransaction
-            - CancelTransaction
-            - CheckTransaction
-            - GetStatement
+        Verify the integrity of the request using the merchant key.
         """
         password = request.META.get('HTTP_AUTHORIZATION')
-        if self.authorize(password):
-            incoming_data: dict = request.data
-            incoming_method: str = incoming_data.get("method")
-
-            logger.info("Call back data is incoming %s", incoming_data)
-
-            try:
-                paycom_method = self.get_paycom_method_by_name(
-                    incoming_method=incoming_method
-                )
-            except ValidationError as error:
-                logger.error("Validation Error occurred: %s", error)
-                raise MethodNotFound() from error
-
-            except PerformTransactionDoesNotExist as error:
-                logger.error("PerformTransactionDoesNotExist Error occurred: %s", error)
-                raise PerformTransactionDoesNotExist() from error
-
-            order_id, action = paycom_method(incoming_data.get("params"))
-
-        if isinstance(paycom_method, CreateTransaction):
-            self.create_transaction(
-                order_id=order_id,
-                action=action,
-            )
+        if not password:
+            raise exceptions.PermissionDenied("Missing authentication credentials")
 
-        if isinstance(paycom_method, PerformTransaction):
-            self.perform_transaction(
-                order_id=order_id,
-                action=action,
-            )
+        password = password.split()[-1]
+
+        try:
+            password = base64.b64decode(password).decode('utf-8')
+        except (binascii.Error, UnicodeDecodeError) as exc:
+            raise exceptions.PermissionDenied("Decoding error in authentication credentials") from exc
+
+        try:
+            payme_key = password.split(':')[-1]
+        except IndexError as exc:
+            message = "Invalid merchant key format in authentication credentials"
+            raise exceptions.PermissionDenied(message) from exc
+
+        if payme_key != settings.PAYME_KEY:
+            raise exceptions.PermissionDenied("Invalid merchant key specified")
+
+    @handle_exceptions
+    def fetch_account(self, params: dict):
+        """
+        Fetch account based on settings and params.
+        """
+        account_field = settings.PAYME_ACCOUNT_FIELD
+
+        account_value = params['account'].get(account_field)
+        if not account_value:
+            raise exceptions.InvalidAccount("Missing account field in parameters.")
+
+        # hard change
+        if account_field == "order_id":
+            account_field = "id"
+
+        account = AccountModel.objects.get(**{account_field: account_value})
+
+        return account
 
-        if isinstance(paycom_method, CancelTransaction):
-            self.cancel_transaction(
-                order_id=order_id,
-                action=action,
+    @handle_exceptions
+    def validate_amount(self, account, amount):
+        """
+        Validates if the amount matches for one-time payment accounts.
+        """
+        if not settings.PAYME_ONE_TIME_PAYMENT:
+            return True
+
+        expected_amount = Decimal(getattr(account, settings.PAYME_AMOUNT_FIELD)) * 100
+        received_amount = Decimal(amount)
+
+        if expected_amount != received_amount:
+            raise exceptions.IncorrectAmount(
+                f"Invalid amount. Expected: {expected_amount}, received: {received_amount}"
             )
 
-        return Response(data=action)
+        return True
 
-    def get_paycom_method_by_name(self, incoming_method: str) -> object:
+    @handle_exceptions
+    def check_perform_transaction(self, params) -> response.CheckPerformTransaction:
         """
-        Use this static method to get the paycom method by name.
-        :param incoming_method: string -> incoming method name
+        Handle the pre_create_transaction action.
         """
-        available_methods: dict = {
-            "CheckPerformTransaction": CheckPerformTransaction,
-            "CreateTransaction": CreateTransaction,
-            "PerformTransaction": PerformTransaction,
-            "CancelTransaction": CancelTransaction,
-            "CheckTransaction": CheckTransaction,
-            "GetStatement": GetStatement
-        }
+        account = self.fetch_account(params)
+        self.validate_amount(account, params.get('amount'))
 
-        try:
-            merchant_method = available_methods[incoming_method]
-        except Exception as error:
-            error_message = "Unavailable method: %s", incoming_method
-            logger.error(error_message)
-            raise MethodNotFound(error_message=error_message) from error
+        result = response.CheckPerformTransaction(allow=True)
+        return result.as_resp()
+
+    @handle_exceptions
+    def create_transaction(self, params) -> response.CreateTransaction:
+        """
+        Handle the create_transaction action.
+        """
+        transaction_id = params["id"]
+        amount = Decimal(params.get('amount', 0))
+        account = self.fetch_account(params)
 
-        merchant_method = merchant_method()
+        self.validate_amount(account, amount)
 
-        return merchant_method
+        defaults = {
+            "amount": amount,
+            "state": PaymeTransactions.INITIATING,
+            "account": account,
+        }
 
-    @staticmethod
-    def authorize(password: str) -> bool:
+        # Handle already existing transaction with the same ID for one-time payments
+        if settings.PAYME_ONE_TIME_PAYMENT:
+            # Check for an existing transaction with a different transaction_id for the given account
+            if PaymeTransactions.objects.filter(account=account).exclude(transaction_id=transaction_id).exists():
+                message = f"Transaction {transaction_id} already exists (Payme)."
+                logger.warning(message)
+                raise exceptions.TransactionAlreadyExists(message)
+
+        transaction, _ = PaymeTransactions.objects.get_or_create(
+            transaction_id=transaction_id,
+            defaults=defaults
+        )
+
+        result = response.CreateTransaction(
+            transaction=transaction.transaction_id,
+            state=transaction.state,
+            create_time=time_to_payme(transaction.created_at),
+        )
+        result = result.as_resp()
+
+        # callback event
+        self.handle_created_payment(params, result)
+
+        return result
+
+    @handle_exceptions
+    def perform_transaction(self, params) -> response.PerformTransaction:
         """
-        Authorize the Merchant.
-        :param password: string -> Merchant authorization password
+        Handle the successful payment.
         """
-        is_payme: bool = False
-        error_message: str = ""
+        transaction = PaymeTransactions.get_by_transaction_id(transaction_id=params["id"])
+
+        if transaction.is_performed():
+            result = response.PerformTransaction(
+                transaction=transaction.transaction_id,
+                state=transaction.state,
+                perform_time=time_to_payme(transaction.performed_at),
+            )
+            return result.as_resp()
 
-        if not isinstance(password, str):
-            error_message = "Request from an unauthorized source!"
-            logger.error(error_message)
-            raise PermissionDenied(error_message=error_message)
+        transaction.mark_as_performed()
 
-        password = password.split()[-1]
+        result = response.PerformTransaction(
+            transaction=transaction.transaction_id,
+            state=transaction.state,
+            perform_time=time_to_payme(transaction.performed_at),
+        )
+        result = result.as_resp()
 
-        try:
-            password = base64.b64decode(password).decode('utf-8')
-        except (binascii.Error, UnicodeDecodeError) as error:
-            error_message = "Error when authorize request to merchant!"
-            logger.error(error_message)
+        # callback successfully event
+        self.handle_successfully_payment(params, result)
 
-            raise PermissionDenied(error_message=error_message) from error
+        return result
 
-        merchant_key = password.split(':')[-1]
+    @handle_exceptions
+    def check_transaction(self, params: dict) -> dict | str | response.CheckPerformTransaction:
+        """
+        Handle check transaction request.
+        """
+        transaction = PaymeTransactions.get_by_transaction_id(transaction_id=params["id"])
+
+        result = response.CheckTransaction(
+            transaction=transaction.transaction_id,
+            state=transaction.state,
+            reason=transaction.cancel_reason,
+            create_time=time_to_payme(transaction.created_at),
+            perform_time=time_to_payme(transaction.performed_at),
+            cancel_time=time_to_payme(transaction.cancelled_at),
+        )
+
+        return result.as_resp()
 
-        if merchant_key == settings.PAYME.get('PAYME_KEY'):
-            is_payme = True
+    @handle_exceptions
+    def cancel_transaction(self, params) -> response.CancelTransaction:
+        """
+        Handle the cancelled payment.
+        """
+        transaction = PaymeTransactions.get_by_transaction_id(transaction_id=params["id"])
 
-        if merchant_key != settings.PAYME.get('PAYME_KEY'):
-            logger.error("Invalid key in request!")
+        if transaction.is_cancelled():
+            return self._cancel_response(transaction)
 
-        if is_payme is False:
-            raise PermissionDenied(
-                error_message="Unavailable data for unauthorized users!"
+        if transaction.is_performed():
+            transaction.mark_as_cancelled(
+                cancel_reason=params["reason"],
+                state=PaymeTransactions.CANCELED
             )
+        elif transaction.is_created_in_payme():
+            transaction.mark_as_cancelled(
+                cancel_reason=params["reason"],
+                state=PaymeTransactions.CANCELED_DURING_INIT
+            )
+
+        result = self._cancel_response(transaction)
 
-        return is_payme
+        # callback cancelled transaction event
+        self.handle_cancelled_payment(params, result)
+
+        return result
+
+    @handle_exceptions
+    def get_statement(self, params) -> response.GetStatement:
+        """
+        Retrieves a statement of transactions.
+        """
+        date_range = [time_to_service(params['from']), time_to_service(params['to'])]
+
+        transactions = PaymeTransactions.objects.filter(
+            created_at__range=date_range
+        ).order_by('-created_at')
+
+        result = response.GetStatement(transactions=[])
+
+        for transaction in transactions:
+            result.transactions.append({
+                "transaction": transaction.transaction_id,
+                "amount": transaction.amount,
+                "account": {
+                    settings.PAYME_ACCOUNT_FIELD: transaction.account.id
+                },
+                "reason": transaction.cancel_reason,
+                "state": transaction.state,
+                "create_time": time_to_payme(transaction.created_at),
+                "perform_time": time_to_payme(transaction.performed_at),
+                "cancel_time": time_to_payme(transaction.cancelled_at),
+            })
+
+        return result.as_resp()
+
+    def _cancel_response(self, transaction):
+        """
+        Helper method to generate cancel transaction response.
+        """
+        result = response.CancelTransaction(
+            transaction=transaction.transaction_id,
+            state=transaction.state,
+            cancel_time=time_to_payme(transaction.cancelled_at),
+        )
+        return result.as_resp()
+
+    def handle_pre_payment(self, params, result, *args, **kwargs):
+        """
+        Handle the pre_create_transaction action. You can override this method
+        """
+        print(f"Transaction pre_created for this params: {params} and pre_created_result: {result}")
 
-    def create_transaction(self, order_id, action) -> None:
+    def handle_created_payment(self, params, result, *args, **kwargs):
         """
-        need implement in your view class
+        Handle the successful payment. You can override this method
         """
-        pass
+        print(f"Transaction created for this params: {params} and cr_result: {result}")
 
-    def perform_transaction(self, order_id, action) -> None:
+    def handle_successfully_payment(self, params, result, *args, **kwargs):
         """
-        need implement in your view class
+        Handle the successful payment. You can override this method
         """
-        pass
+        print(f"Transaction successfully performed for this params: {params} and performed_result: {result}")
 
-    def cancel_transaction(self, order_id, action) -> None:
+    def handle_cancelled_payment(self, params, result, *args, **kwargs):
         """
-        need implement in your view class
+        Handle the cancelled payment. You can override this method
         """
-        pass
+        print(f"Transaction cancelled for this params: {params} and cancelled_result: {result}")