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

payme/__init__.py

@@ -0,0 +1 @@
+from payme.classes.client import Payme # noqa

payme/admin.py

@@ -1,11 +1,17 @@
 from django.contrib import admin
 
-from payme.models import CUSTOM_ORDER
-from payme.models import Order as DefaultOrderModel
 
-from payme.models import MerchantTransactionsModel
+from payme.models import PaymeTransactions
 
-if not CUSTOM_ORDER:
-    admin.site.register(DefaultOrderModel)
 
-admin.site.register(MerchantTransactionsModel)
+class PaymeTransactionsUI(admin.ModelAdmin):
+    """
+    Custom admin interface for PaymeTransactions model.
+    """
+    list_display = ('id', 'state', 'cancel_reason', 'created_at')
+    list_filter = ('state', 'cancel_reason', 'created_at')
+    search_fields = ('transaction_id', 'account__id')
+    ordering = ('-created_at',)
+
+
+admin.site.register(PaymeTransactions, PaymeTransactionsUI)

payme/apps.py

@@ -2,9 +2,5 @@ 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/classes/cards.py

@@ -0,0 +1,203 @@
+from typing import Optional
+
+from payme.classes.http import HttpClient
+from payme.types.response import cards as response
+
+
+ALLOWED_METHODS = {
+    "cards.create": response.CardsCreateResponse,
+    "cards.get_verify_code": response.GetVerifyResponse,
+    "cards.verify": response.VerifyResponse,
+    "cards.remove": response.RemoveResponse,
+    "cards.check": response.CheckResponse
+}
+
+
+class Cards:
+    """
+    The Cards class provides a simple interface to interact with Paycom card
+    services. It allows you to create new cards and retrieve verification
+    codes for existing cards.
+    """
+    def __init__(self, url: str, payme_id: str) -> "Cards":
+        """
+        Initialize the Cards client.
+
+        :param payme_id: The Paycom ID used for authentication.
+        :param url: The base URL for the Paycom card service API.
+        """
+        headers = {
+            "X-Auth": payme_id,
+            "Content-Type": "application/json"
+        }
+        self.http = HttpClient(url, headers)
+
+    def create(self, number: str, expire: str, save: bool = False,
+               timeout: int = 10) -> response.CardsCreateResponse:
+        """
+        Create a new card.
+
+        :param number: The card number.
+        :param expire: The expiration date of the card in MMYY format.
+        :param save: A boolean indicating whether to save the card for future
+            use (default is False).
+        :param timeout: The request timeout duration in seconds (default is
+            10 seconds).
+        :return: A CardsCreateResponse object containing the response data.
+        """
+        method = "cards.create"
+        params = {"card": {"number": number, "expire": expire}, "save": save}
+        return self._post_request(method, params, timeout)
+
+    def get_verify_code(self, token: str, timeout: int = 10) -> \
+            response.GetVerifyResponse:
+        """
+        Retrieve a verification code for a specified token.
+
+        :param token: The token associated with the card.
+        :param timeout: The request timeout duration in seconds (default is
+            10 seconds).
+        :return: A GetVerifyResponse object containing the response data.
+        """
+        method = "cards.get_verify_code"
+        params = {"token": token}
+        return self._post_request(method, params, timeout)
+
+    def verify(self, token: str, code: str, timeout: int = 10) -> \
+            response.VerifyResponse:
+        """
+        Verify a verification code for a specified token.
+
+        :param token: The token associated with the card.
+        :param code: The verification code to be verified.
+        :param timeout: The request timeout duration in seconds (default is
+            10 seconds).
+        :return: A VerifyResponse object containing the response data.
+        """
+        method = "cards.verify"
+        params = {"token": token, "code": code}
+        return self._post_request(method, params, timeout)
+
+    def remove(self, token: str, timeout: int = 10) -> response.RemoveResponse:
+        """
+        Remove a card from the Paycom system.
+
+        :param token: The token associated with the card.
+        :param timeout: The request timeout duration in seconds (default is
+            10 seconds).
+        :return: A RemoveResponse object containing the response data.
+        """
+        method = "cards.remove"
+        params = {"token": token}
+        return self._post_request(method, params, timeout)
+
+    def check(self, token: str, timeout: int = 10) -> response.CheckResponse:
+        """
+        Check the status of a card.
+
+        :param token: The token associated with the card.
+        :param timeout: The request timeout duration in seconds (default is
+            10 seconds).
+        :return: A CheckResponse object containing the response data.
+        """
+        method = "cards.check"
+        params = {"token": token}
+        return self._post_request(method, params, timeout)
+
+    def _post_request(self, method: str, params: dict,
+                      timeout: int = 10) -> response.Common:
+        """
+        Helper method to post requests to the HTTP client.
+
+        :param method: The API method to be called.
+        :param params: The parameters to be sent with the request.
+        :param timeout: The request timeout duration in seconds (default is
+            10 seconds).
+        :return: A response object corresponding to the method called.
+        """
+        json = {"method": method, "params": params}
+        dict_result = self.http.post(json, timeout)
+        response_class = ALLOWED_METHODS[method]
+        return response_class.from_dict(dict_result)
+
+    def test(self):
+        """
+        Run a comprehensive test suite for card functionalities including
+        creation, verification, status check, and removal.
+        """
+        # Expected values for verification
+        number = "8600495473316478"
+        expire = "0399"
+
+        expected_number = "860049******6478"
+        expected_expire = "03/99"
+        verify_code = "666666"
+
+        # Step 1: Create Card
+        create_response = self.create(number=number, expire=expire)
+        token = create_response.result.card.token
+
+        # Validate card creation response
+        self._assert_and_print(
+            create_response.result.card.number == expected_number,
+            "Card number matched.",
+            test_case="Card Creation - Number Validation"
+        )
+        self._assert_and_print(
+            create_response.result.card.expire == expected_expire,
+            "Expiration date matched.",
+            test_case="Card Creation - Expiration Date Validation"
+        )
+
+        # Step 2: Get Verification Code
+        get_verify_response = self.get_verify_code(token=token)
+        self._assert_and_print(
+            get_verify_response.result.sent is True,
+            "Verification code requested successfully.",
+            test_case="Verification Code Request"
+        )
+
+        # Step 3: Verify Code
+        verify_response = self.verify(token=token, code=verify_code)
+        self._assert_and_print(
+            verify_response.result.card.verify is True,
+            "Verification code validated successfully.",
+            test_case="Code Verification"
+        )
+
+        # Step 4: Check Card Status
+        check_response = self.check(token=token)
+        self._assert_and_print(
+            check_response.result.card.verify is True,
+            "Card status verified successfully.",
+            test_case="Card Status Check"
+        )
+
+        # Step 5: Remove Card
+        remove_response = self.remove(token=token)
+        self._assert_and_print(
+            remove_response.result.success is True,
+            "Card removed successfully.",
+            test_case="Card Removal"
+        )
+
+    def _assert_and_print(self, condition: bool, success_message: str,
+                          test_case: Optional[str] = None):
+        """
+        Assertion helper that prints success or failure messages based on
+        test outcomes.
+
+        :param condition: The test condition to check.
+        :param success_message: Message to print upon successful test.
+        :param test_case: A description of the test case (optional).
+        """
+        try:
+            assert condition, "Assertion failed!"
+            print(f"Success: {success_message}")
+        except AssertionError as exc:
+            error_message = (
+                f"Test Case Failed: {test_case or 'Unknown Test Case'}\n"
+                f"Error Details: {str(exc)}"
+            )
+            print(error_message)
+            raise AssertionError(error_message) from exc

payme/classes/client.py

@@ -0,0 +1,30 @@
+
+from typing import Union
+
+from payme.const import Networks
+from payme.classes.cards import Cards
+from payme.classes.receipts import Receipts
+from payme.classes.initializer import Initializer
+
+
+class Payme:
+    """
+    The payme class provides a simple interface
+    """
+    def __init__(
+        self,
+        payme_id: str,
+        fallback_id: Union[str, None] = None,
+        payme_key: Union[str, None] = None,
+        is_test_mode: bool = False
+    ):
+
+        # initialize payme network
+        url = Networks.PROD_NET.value
+
+        if is_test_mode is True:
+            url = Networks.TEST_NET.value
+
+        self.cards = Cards(url=url, payme_id=payme_id)
+        self.initializer = Initializer(payme_id=payme_id, fallback_id=fallback_id)
+        self.receipts = Receipts(url=url, payme_id=payme_id, payme_key=payme_key)  # noqa

payme/classes/http.py

@@ -0,0 +1,111 @@
+import requests
+
+from payme.exceptions import general as exc
+
+
+networking_errors = (
+    requests.exceptions.Timeout,
+    requests.exceptions.HTTPError,
+    requests.exceptions.ConnectionError,
+    requests.exceptions.TooManyRedirects,
+    requests.exceptions.URLRequired,
+    requests.exceptions.MissingSchema,
+    requests.exceptions.InvalidURL,
+    requests.exceptions.InvalidHeader,
+    requests.exceptions.JSONDecodeError,
+    requests.exceptions.ConnectTimeout,
+    requests.exceptions.ReadTimeout,
+    requests.exceptions.SSLError,
+    requests.exceptions.ProxyError,
+    requests.exceptions.ChunkedEncodingError,
+    requests.exceptions.StreamConsumedError,
+    requests.exceptions.RequestException
+)
+
+
+class HttpClient:
+    """
+    A simple HTTP client to handle requests to a specified URL.
+    It provides methods for sending GET, POST, PUT, and DELETE requests
+    with error handling.
+    """
+
+    def __init__(self, url: str, headers: dict = None):
+        """
+        Initialize the HttpClient.
+
+        Parameters
+        ----------
+        url : str
+            The base URL for the API (e.g., 'https://checkout.paycom.uz/api').
+        headers : dict, optional
+            Optional default headers to include in all requests.
+            These headers will be sent with every request unless overridden.
+        """
+        self.url = url
+        self.headers = headers
+
+    def post(self, json: dict, timeout: int = 10):
+        """
+        Send a POST request to the specified URL with the provided JSON data.
+
+        Parameters
+        ----------
+        json : dict
+            The JSON data payload for the POST request. This will be sent
+            as the request body.
+        timeout : int, optional
+            The request timeout duration in seconds (default is 10 seconds).
+
+        Returns
+        -------
+        dict
+            A dictionary containing the response data if the request was
+            successful, or an error message if an error occurred.
+        """
+        try:
+            response = requests.post(
+                url=self.url,
+                headers=self.headers,
+                json=json,
+                timeout=timeout
+            )
+            response.raise_for_status()
+            response_data = response.json()
+
+            # Check if the response contains a specific error format
+            if "error" in response_data:
+                return self.handle_payme_error(response_data["error"])
+
+            return response_data
+
+        except networking_errors as exc_data:
+            raise exc.PaymeNetworkError(data=exc_data)
+
+    def handle_payme_error(self, error: dict):
+        """
+        Handle Paycom-specific errors from the JSON-RPC error response.
+
+        Parameters
+        ----------
+        error : dict
+            The error dictionary from Paycom's response, typically containing
+            error details such as code, message, and data.
+
+        Returns
+        -------
+        None
+            Raises an exception based on the error code received from
+            Paycom's response.
+        """
+        error_code = error.get("code", "Unknown code")
+        error_message = error.get("message", "Unknown error")
+        error_data = error.get("data", "")
+
+        exception_class = exc.errors_map.get(error_code, exc.BaseError)
+        exception_class.message = error_message
+
+        if exception_class == exc.BaseError:
+            raise exc.BaseError(code=error_code, message=error_message)
+
+        raise exception_class(data=error_data)

payme/classes/initializer.py

@@ -0,0 +1,82 @@
+import base64
+
+from django.conf import settings
+
+
+class Initializer:
+    """
+    Initialize the Payme class with necessary details.
+
+    Attributes
+    ----------
+    payme_id: str
+        The Payme ID associated with your account
+    """
+
+    def __init__(self, payme_id: str = None, fallback_id: str = None):
+        self.payme_id = payme_id
+        self.fallback_id = fallback_id
+
+
+    def generate_pay_link(
+        self,
+        id: int,
+        amount: int,
+        return_url: str
+    ) -> str:
+        """
+        Generate a payment link for a specific order.
+
+        This method encodes the payment parameters into a base64 string and
+        constructs a URL for the Payme checkout.
+
+        Parameters
+        ----------
+        id : int
+            Unique identifier for the account.
+        amount : int
+            The amount associated with the order in currency units.
+        return_url : str
+            The URL to which the user will be redirected after the payment is
+            processed.
+
+        Returns
+        -------
+        str
+            A payment link formatted as a URL, ready to be used in the payment
+            process.
+
+        References
+        ----------
+        For full method documentation, visit:
+        https://developer.help.paycom.uz/initsializatsiya-platezhey/
+        """
+        amount = amount * 100  # Convert amount to the smallest currency unit
+        params = (
+            f'm={self.payme_id};ac.{settings.PAYME_ACCOUNT_FIELD}={id};a={amount};c={return_url}'
+        )
+        params = base64.b64encode(params.encode("utf-8")).decode("utf-8")
+        return f"https://checkout.paycom.uz/{params}"
+
+    def generate_fallback_link(self, form_fields: dict = None):
+        """
+        Generate a fallback URL for the Payme checkout.
+
+        Parameters
+        ----------
+        fields : dict, optional
+            Additional query parameters to be appended to the fallback URL.
+
+        Returns
+        -------
+        str
+            A fallback URL formatted as a URL, ready to be used in the payment
+            process.
+        """
+        result = f"https://payme.uz/fallback/merchant/?id={self.fallback_id}"
+
+        if form_fields is not None:
+            for key, value in form_fields.items():
+                result += f"&{key}={value}"
+
+        return result