payme-pkg 2.6.7__tar.gz → 3.0.3__tar.gz

{payme_pkg-2.6.7/lib/payme_pkg.egg-info → payme_pkg-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: payme-pkg
-Version: 2.6.7
+Version: 3.0.3
 Home-page: https://github.com/Muhammadali-Akbarov/payme-pkg
 Author: Muhammadali Akbarov
 Author-email: muhammadali17abc@gmail.com

payme_pkg-3.0.3/README.md

@@ -0,0 +1,125 @@
+<h1 align="center">Payme PKG</h1>
+
+
+<p align="center">
+  <a href="https://docs.pay-tech.uz"><img src="https://img.shields.io/static/v1?message=Documented%20on%20GitBook&logo=gitbook&logoColor=ffffff&label=%20&labelColor=5c5c5c&color=3F89A1"></a>
+  <a href="https://github.com/PayTechUz/payme-pkg"><img src="https://img.shields.io/badge/Open_Source-❤️-FDA599?"/></a>
+  <a href="t.me/+DK7n7lKx8GY5ZDZi"><img src="https://img.shields.io/badge/Community-Join%20Us-blueviolet"/></a>
+  <a href="https://github.com/PayTechUz/payme-pkg/issues"><img src="https://img.shields.io/github/issues/gitbookIO/gitbook"/></a>
+</p>
+
+<p align="center">Welcome to payme-pkg, the open source payme sdk for python.</p>
+
+<p align="center">You can use for test and production mode. Join our community and ask everything you need.
+</p>
+<a href="https://docs.pay-tech.uz">
+<p align="center">Visit to full documentation for Merchant and Subcribe Api</p>
+</a>
+<p align="center">
+ <img style="width: 60%;" src="https://i.postimg.cc/WbD32bHC/payme-pkg-demo-m4a.gif">
+</p>
+
+## Installation
+
+```shell
+pip install payme-pkg
+```
+
+## Installation to Django
+
+Add `'payme'` in to your settings.py
+
+```python
+INSTALLED_APPS = [
+    ...
+    'payme',
+    ...
+]
+```
+
+Add `'payme'` credentials inside to settings.py
+
+One time payment configuration settings.py
+```python
+PAYME_ID = "your-payme-id"
+PAYME_KEY = "your-payme-key"
+PAYME_ACCOUNT_FIELD = "id"
+PAYME_AMOUNT_FIELD = "total_amount"
+PAYME_ACCOUNT_MODEL = "orders.models.Orders"
+PAYME_ONE_TIME_PAYMENT = True
+```
+
+Multi payment configuration settings.py
+```python
+PAYME_ID = "your-payme-id"
+PAYME_KEY = "your-payme-key"
+PAYME_ACCOUNT_FIELD = "id"
+PAYME_ACCOUNT_MODEL = "clients.models.Client"
+PAYME_ONE_TIME_PAYMENT = False
+```
+
+Create a new View that about handling call backs
+```python
+from payme.views import PaymeWebHookAPIView
+
+
+class PaymeCallBackAPIView(PaymeWebHookAPIView):
+    def handle_created_payment(self, params, result, *args, **kwargs):
+        """
+        Handle the successful payment. You can override this method
+        """
+        print(f"Transaction created for this params: {params} and cr_result: {result}")
+
+    def handle_successfully_payment(self, params, result, *args, **kwargs):
+        """
+        Handle the successful payment. You can override this method
+        """
+        print(f"Transaction successfully performed for this params: {params} and performed_result: {result}")
+
+    def handle_cancelled_payment(self, params, result, *args, **kwargs):
+        """
+        Handle the cancelled payment. You can override this method
+        """
+        print(f"Transaction cancelled for this params: {params} and cancelled_result: {result}")
+```
+
+Add a `payme` path to core of urlpatterns:
+
+```python
+from django.urls import path
+from django.urls import include
+
+from your_app.views import PaymeCallBackAPIView
+
+urlpatterns = [
+    ...
+    path("payment/update/", PaymeCallBackAPIView.as_view()),
+    ...
+]
+```
+
+Run migrations
+```shell
+python3 manage.py makemigrations && python manage.py migrate
+```
+🎉 Congratulations you have been integrated merchant api methods with django, keep reading docs. After successfull migrations check your admin panel and see results what happened.
+
+## Generate Pay Link
+
+Example to generate link:
+
+- Input
+
+```python
+from payme import Payme
+
+payme = Payme(payme_id="your-payme-id")
+pay_link = payme.initializer.generate_pay_link(id=123456, amount=5000, return_url="https://example.com")
+print(pay_link)
+```
+
+- Output
+
+```
+https://checkout.paycom.uz/bT15b3VyLXBheW1lLWlkO2FjLmlkPTEyMzQ1NjthPTUwMDAwMDtjPWh0dHBzOi8vZXhhbXBsZS5jb20=
+```

payme_pkg-3.0.3/payme/__init__.py

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

payme_pkg-3.0.3/payme/admin.py

@@ -0,0 +1,17 @@
+from django.contrib import admin
+
+
+from payme.models import PaymeTransactions
+
+
+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_pkg-2.6.7/lib/my_app → payme_pkg-3.0.3/payme}/apps.py

@@ -1,6 +1,6 @@
 from django.apps import AppConfig
 
 
-class MyAppConfig(AppConfig):
+class PaymeConfig(AppConfig):
     default_auto_field = 'django.db.models.BigAutoField'
-    name = 'my_app'
+    name = 'payme'

payme_pkg-3.0.3/payme/classes/cards.py

@@ -0,0 +1,212 @@
+from typing import Optional
+
+from payme.util import input_type_checker
+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.
+    """
+
+    @input_type_checker
+    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)
+
+    @input_type_checker
+    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)
+
+    @input_type_checker
+    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)
+
+    @input_type_checker
+    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)
+
+    @input_type_checker
+    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)
+
+    @input_type_checker
+    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)
+
+    @input_type_checker
+    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_pkg-3.0.3/payme/classes/client.py

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

payme_pkg-3.0.3/payme/classes/http.py

@@ -0,0 +1,106 @@
+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)
+        raise exception_class(message=error_message, data=error_data)

payme_pkg-3.0.3/payme/classes/initializer.py

@@ -0,0 +1,77 @@
+import base64
+
+from payme.util import input_type_checker
+
+
+class Initializer:
+    """
+    Initialize the Payme class with necessary details.
+
+    Attributes
+    ----------
+    payme_id: str
+        The Payme ID associated with your account
+    """
+
+    @input_type_checker
+    def __init__(self, payme_id: str = None):
+        self.payme_id = payme_id
+
+    # pylint: disable=W0622
+    @input_type_checker
+    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.id={id};a={amount};c={return_url}'
+        )
+        params = base64.b64encode(params.encode("utf-8")).decode("utf-8")
+        return f"https://checkout.paycom.uz/{params}"
+
+    def test(self):
+        """
+        Test method for the Initializer class.
+
+        This method generates a payment link for a sample order and checks
+        if the result is a valid string. If successful, it prints a
+        confirmation message.
+        """
+        result = self.generate_pay_link(
+            id=12345,
+            amount=7000,
+            return_url="https://example.com"
+        )
+
+        assert isinstance(result, str), "Failed to generate payment link"
+        print("Success: Payment link generated successfully.")