python-payway 0.0.8__tar.gz → 0.0.10__tar.gz

{python_payway-0.0.8/python_payway.egg-info → python_payway-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-payway
-Version: 0.0.8
+Version: 0.0.10
 Summary: Python client for working with Westpac's PayWay REST API
 Author-email: Ben Napper <reppan197@gmail.com>
 License: MIT
@@ -201,6 +201,27 @@ Poll a transaction using the `get_transaction` method.
 transaction, errors = client.get_transaction(transaction.transaction_id)
 ```
 
+## Search transactions
+
+PayWay has no plain `GET /transactions` resource, only three search paths. Each returns a
+paginated list (20 per page, most recent first) with `next`/`prev` links.
+
+```python
+response = client.search_transactions_by_customer(customer_number)
+response = client.search_transactions_by_receipt(receipt_number)
+response = client.search_transactions_by_order(order_number)
+
+transactions = response["data"]
+```
+
+Pass `page` to fetch a later page, using the number from the `next`/`prev` links:
+
+```python
+response = client.search_transactions_by_customer(customer_number, page=2)
+```
+
+`list_customers()` takes the same `page` argument.
+
 ## Process and capture a pre-authorisation
 
 To process a credit card pre-authorisation using a credit card stored against a customer use `preAuth` as the `transaction_type` along with the customer's PayWay number, amount and currency.
@@ -260,6 +281,21 @@ PayWay API documentation <https://www.payway.com.au/docs/rest.html>
 It is recommended to use PayWay's Trusted Frame <https://www.payway.com.au/docs/rest.html#trusted-frame>
 when creating a single use token of a card or bank account so your PCI-compliance scope is reduced.  
 
+## Keeping the raw response
+
+Models parsed from a PayWay response keep that response verbatim on `raw`:
+
+```python
+transaction, errors = client.process_payment(payment)
+transaction.raw  # exactly what PayWay returned
+```
+
+Parsing is lossy — keys PayWay sends that the dataclass does not declare are dropped,
+absent keys become `None`, and a few are renamed (`maskedCardNumber` is parsed into
+`card_number`). Store `raw` rather than `to_dict()` if you are persisting responses for
+auditing, reconciliation or dispute resolution. Models you construct yourself, such as a
+`PayWayPayment` you are about to send, leave `raw` as `None`.
+
 ## Fraud
 
 Please follow PayWay's advice about reducing your risk of fraudulent transactions. <https://www.payway.com.au/docs/card-testing.html#card-testing>

{python_payway-0.0.8 → python_payway-0.0.10}/README.md

@@ -178,6 +178,27 @@ Poll a transaction using the `get_transaction` method.
 transaction, errors = client.get_transaction(transaction.transaction_id)
 ```
 
+## Search transactions
+
+PayWay has no plain `GET /transactions` resource, only three search paths. Each returns a
+paginated list (20 per page, most recent first) with `next`/`prev` links.
+
+```python
+response = client.search_transactions_by_customer(customer_number)
+response = client.search_transactions_by_receipt(receipt_number)
+response = client.search_transactions_by_order(order_number)
+
+transactions = response["data"]
+```
+
+Pass `page` to fetch a later page, using the number from the `next`/`prev` links:
+
+```python
+response = client.search_transactions_by_customer(customer_number, page=2)
+```
+
+`list_customers()` takes the same `page` argument.
+
 ## Process and capture a pre-authorisation
 
 To process a credit card pre-authorisation using a credit card stored against a customer use `preAuth` as the `transaction_type` along with the customer's PayWay number, amount and currency.
@@ -237,6 +258,21 @@ PayWay API documentation <https://www.payway.com.au/docs/rest.html>
 It is recommended to use PayWay's Trusted Frame <https://www.payway.com.au/docs/rest.html#trusted-frame>
 when creating a single use token of a card or bank account so your PCI-compliance scope is reduced.  
 
+## Keeping the raw response
+
+Models parsed from a PayWay response keep that response verbatim on `raw`:
+
+```python
+transaction, errors = client.process_payment(payment)
+transaction.raw  # exactly what PayWay returned
+```
+
+Parsing is lossy — keys PayWay sends that the dataclass does not declare are dropped,
+absent keys become `None`, and a few are renamed (`maskedCardNumber` is parsed into
+`card_number`). Store `raw` rather than `to_dict()` if you are persisting responses for
+auditing, reconciliation or dispute resolution. Models you construct yourself, such as a
+`PayWayPayment` you are about to send, leave `raw` as `None`.
+
 ## Fraud
 
 Please follow PayWay's advice about reducing your risk of fraudulent transactions. <https://www.payway.com.au/docs/card-testing.html#card-testing>

{python_payway-0.0.8 → python_payway-0.0.10}/payway/client.py

@@ -15,7 +15,7 @@ from payway.constants import (
     CUSTOMER_URL,
     PAYWAY_ERROR_RESPONSE_CODES,
     RETRYABLE_STATUS_CODES,
-    TOKEN_NO_REDIRECT,
+    TOKEN_URL,
     TRANSACTION_URL,
     VALID_PAYMENT_METHOD_CHOICES,
     PaymentMethod,
@@ -190,7 +190,7 @@ class Client(CustomerRequest, TransactionRequest):
             data["paymentMethod"] = BANK_ACCOUNT_PAYMENT_CHOICE
         logger.info("Sending Create Token request to PayWay.")
         response = self.post_request(
-            TOKEN_NO_REDIRECT,
+            TOKEN_URL,
             data,
             auth=(self.publishable_api_key, ""),
             idempotency_key=idempotency_key,

{python_payway-0.0.8 → python_payway-0.0.10}/payway/constants.py

@@ -10,11 +10,9 @@ class PaymentMethod(StrEnum):
 
 
 PAYWAY_API_URL = "https://api.payway.com.au/rest/v1"
-TOKEN_URL = PAYWAY_API_URL + "/single-use-tokens-redirect"
+TOKEN_URL = PAYWAY_API_URL + "/single-use-tokens"
 TRANSACTION_URL = PAYWAY_API_URL + "/transactions"
 CUSTOMER_URL = PAYWAY_API_URL + "/customers"
-OWN_BANK_ACCOUNTS_URL = PAYWAY_API_URL + "/your-bank-accounts"
-TOKEN_NO_REDIRECT = PAYWAY_API_URL + "/single-use-tokens"
 TRANSACTION_APPROVED = "0"
 
 SUMMARY_CODES = {

{python_payway-0.0.8 → python_payway-0.0.10}/payway/customers.py

@@ -98,10 +98,10 @@ class CustomerRequest:
         )
 
     @json_list("list_customers")
-    def list_customers(self) -> requests.Response:
+    def list_customers(self, page: int | None = None) -> requests.Response:
         """
         List all customers in PayWay
         Returns paginated list of customerNumber, customerName
+        :param page: page number, taken from the `next`/`prev` links of a previous response
         """
-        # TODO: add page numbers
-        return self.session_no_headers.get(CUSTOMER_URL)
+        return self.session_no_headers.get(CUSTOMER_URL, params={"page": page})

{python_payway-0.0.8 → python_payway-0.0.10}/payway/model.py

@@ -15,9 +15,16 @@ class PayWayModel:
         alias:      PayWay key when it is not the camelCase of the field name
         exclude:    omit the field from to_dict output
         from_dict:  callable applied to a non-None raw value when parsing
+
+    Instances built by from_dict keep the response body they were parsed from
+    on ``raw``, unchanged. Parsing is lossy - undeclared PayWay keys are dropped,
+    absent ones become None, and aliases rename them - so callers persisting a
+    response for auditing or dispute resolution should store ``raw``, not
+    ``to_dict()``. Models you build yourself leave it None.
     """
 
     __dataclass_fields__: ClassVar[dict[str, Any]]
+    raw: dict[str, Any] | None = None
 
     def to_dict(self) -> dict[str, Any]:
         result = {}
@@ -39,7 +46,9 @@ class PayWayModel:
             if converter is not None and value is not None:
                 value = converter(value)
             kwargs[f.name] = value
-        return cls(**kwargs)
+        instance = cls(**kwargs)
+        instance.raw = data
+        return instance
 
 
 @dataclass
@@ -65,8 +74,10 @@ class PayWayCard(PayWayModel):
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> PayWayCard:
-        data = {**data, "cardNumber": data.get("maskedCardNumber") or data.get("cardNumber")}
-        return super().from_dict(data)
+        card = super().from_dict({**data, "cardNumber": data.get("maskedCardNumber") or data.get("cardNumber")})
+        # Keep PayWay's own body, not the copy rewritten for the alias above.
+        card.raw = data
+        return card
 
 
 @dataclass

python_payway-0.0.10/payway/transactions.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+
+from payway.constants import TRANSACTION_URL
+from payway.utils import json_list
+
+
+class TransactionRequest:
+    session = requests.Session()
+    session_no_headers = requests.Session()
+
+    def _search(self, path: str, params: dict[str, Any]) -> requests.Response:
+        return self.session_no_headers.get(f"{TRANSACTION_URL}/{path}", params=params)
+
+    @json_list("search_transactions_by_customer")
+    def search_transactions_by_customer(self, customer_number: int | str, page: int | None = None) -> requests.Response:
+        """
+        Returns a paginated list of transactions for a PayWay customer, most recent first
+        :param customer_number: PayWay customer number
+        :param page: page number, taken from the `next`/`prev` links of a previous response
+        """
+        return self._search("search-customer", {"customerNumber": customer_number, "page": page})
+
+    @json_list("search_transactions_by_receipt")
+    def search_transactions_by_receipt(self, receipt_number: int | str, page: int | None = None) -> requests.Response:
+        """
+        Returns a paginated list of transactions with the given receipt number, most recent first
+        :param receipt_number: PayWay receipt number
+        :param page: page number, taken from the `next`/`prev` links of a previous response
+        """
+        return self._search("search-receipt", {"receiptNumber": receipt_number, "page": page})
+
+    @json_list("search_transactions_by_order")
+    def search_transactions_by_order(self, order_number: str, page: int | None = None) -> requests.Response:
+        """
+        Returns a paginated list of transactions with the given order number, most recent first
+        :param order_number: your order number, supplied when the transaction was created
+        :param page: page number, taken from the `next`/`prev` links of a previous response
+        """
+        return self._search("search-order", {"orderNumber": order_number, "page": page})

{python_payway-0.0.8 → python_payway-0.0.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-payway"
-version = "0.0.8"
+version = "0.0.10"
 description = "Python client for working with Westpac's PayWay REST API"
 authors = [
     { name = "Ben Napper", email = "reppan197@gmail.com" }

{python_payway-0.0.8 → python_payway-0.0.10/python_payway.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-payway
-Version: 0.0.8
+Version: 0.0.10
 Summary: Python client for working with Westpac's PayWay REST API
 Author-email: Ben Napper <reppan197@gmail.com>
 License: MIT
@@ -201,6 +201,27 @@ Poll a transaction using the `get_transaction` method.
 transaction, errors = client.get_transaction(transaction.transaction_id)
 ```
 
+## Search transactions
+
+PayWay has no plain `GET /transactions` resource, only three search paths. Each returns a
+paginated list (20 per page, most recent first) with `next`/`prev` links.
+
+```python
+response = client.search_transactions_by_customer(customer_number)
+response = client.search_transactions_by_receipt(receipt_number)
+response = client.search_transactions_by_order(order_number)
+
+transactions = response["data"]
+```
+
+Pass `page` to fetch a later page, using the number from the `next`/`prev` links:
+
+```python
+response = client.search_transactions_by_customer(customer_number, page=2)
+```
+
+`list_customers()` takes the same `page` argument.
+
 ## Process and capture a pre-authorisation
 
 To process a credit card pre-authorisation using a credit card stored against a customer use `preAuth` as the `transaction_type` along with the customer's PayWay number, amount and currency.
@@ -260,6 +281,21 @@ PayWay API documentation <https://www.payway.com.au/docs/rest.html>
 It is recommended to use PayWay's Trusted Frame <https://www.payway.com.au/docs/rest.html#trusted-frame>
 when creating a single use token of a card or bank account so your PCI-compliance scope is reduced.  
 
+## Keeping the raw response
+
+Models parsed from a PayWay response keep that response verbatim on `raw`:
+
+```python
+transaction, errors = client.process_payment(payment)
+transaction.raw  # exactly what PayWay returned
+```
+
+Parsing is lossy — keys PayWay sends that the dataclass does not declare are dropped,
+absent keys become `None`, and a few are renamed (`maskedCardNumber` is parsed into
+`card_number`). Store `raw` rather than `to_dict()` if you are persisting responses for
+auditing, reconciliation or dispute resolution. Models you construct yourself, such as a
+`PayWayPayment` you are about to send, leave `raw` as `None`.
+
 ## Fraud
 
 Please follow PayWay's advice about reducing your risk of fraudulent transactions. <https://www.payway.com.au/docs/card-testing.html#card-testing>

{python_payway-0.0.8 → python_payway-0.0.10}/tests/test_client.py

@@ -179,6 +179,29 @@ class TestClient(unittest.TestCase):
         self.assertEqual(transaction.status, "approved")
         self.assertEqual(transaction.response_code, "11")
 
+    @patch("requests.post")
+    def test_process_payment_keeps_the_raw_response(self, mock_post) -> None:
+        """
+        Parsing drops keys PayWay sent, so ``raw`` keeps the body verbatim for
+        callers that persist responses for auditing or dispute resolution.
+        """
+        response = load_json_file("tests/data/transaction.json")
+        mock_post.return_value.status_code = 200
+        mock_post.return_value.json.return_value = response
+        payment = copy.deepcopy(self.payment)
+        payment.customer_number = "1"
+        payment.token = "2bcec36f-7b02-43db-b3ec-bfb65acfe272"
+        payment.order_number = "5200"
+        payment.merchant_id = self.client.merchant_id
+
+        transaction, _ = self.client.process_payment(payment)
+
+        self.assertEqual(transaction.raw, response)
+        # cardScheme and cardType are not modelled, so only raw still has them.
+        self.assertEqual(transaction.raw["creditCard"]["cardScheme"], "visa")
+        self.assertNotIn("cardScheme", transaction.to_dict()["creditCard"])
+        self.assertEqual(transaction.card.raw, response["creditCard"])
+
     @patch("requests.post")
     def test_process_payment_with_idempotency_key(self, mock_post) -> None:
         """

{python_payway-0.0.8 → python_payway-0.0.10}/tests/test_customers.py

@@ -211,6 +211,20 @@ class TestCustomerRequest(unittest.TestCase):
         mock_get.return_value.status_code = 200
         mock_get.return_value.json.return_value = load_json_file("tests/data/customers.json")
         response = self.client.list_customers()
+        mock_get.assert_called_once_with(
+            "https://api.payway.com.au/rest/v1/customers",
+            params={"page": None},
+        )
         self.assertEqual(response.__class__, dict)
         self.assertIsNotNone(response)
         self.assertIsNotNone(response.get("data"))
+
+    @patch("requests.Session.get")
+    def test_list_customers_with_page(self, mock_get) -> None:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = load_json_file("tests/data/customers.json")
+        self.client.list_customers(page=3)
+        mock_get.assert_called_once_with(
+            "https://api.payway.com.au/rest/v1/customers",
+            params={"page": 3},
+        )

python_payway-0.0.10/tests/test_transactions.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import unittest
+from unittest.mock import patch
+
+from payway.client import Client
+from payway.test_utils import load_json_file
+
+
+class TestTransactionRequest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        merchant_id = "TEST"
+        bank_account_id = "0000000A"
+        publishable_api_key = "TPUBLISHABLE-API-KEY"
+        secret_api_key = "TPUBLISHABLE-SECRET"
+
+        cls.client = Client(
+            merchant_id=merchant_id,
+            bank_account_id=bank_account_id,
+            publishable_api_key=publishable_api_key,
+            secret_api_key=secret_api_key,
+        )
+
+    @patch("requests.Session.get")
+    def test_search_transactions_by_customer(self, mock_get) -> None:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = load_json_file("tests/data/transactions.json")
+        response = self.client.search_transactions_by_customer(1)
+        mock_get.assert_called_once_with(
+            "https://api.payway.com.au/rest/v1/transactions/search-customer",
+            params={"customerNumber": 1, "page": None},
+        )
+        self.assertIsNotNone(response["data"])
+
+    @patch("requests.Session.get")
+    def test_search_transactions_by_customer_with_page(self, mock_get) -> None:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = load_json_file("tests/data/transactions.json")
+        self.client.search_transactions_by_customer(1, page=2)
+        mock_get.assert_called_once_with(
+            "https://api.payway.com.au/rest/v1/transactions/search-customer",
+            params={"customerNumber": 1, "page": 2},
+        )
+
+    @patch("requests.Session.get")
+    def test_search_transactions_by_receipt(self, mock_get) -> None:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = load_json_file("tests/data/transactions.json")
+        response = self.client.search_transactions_by_receipt("1234567")
+        mock_get.assert_called_once_with(
+            "https://api.payway.com.au/rest/v1/transactions/search-receipt",
+            params={"receiptNumber": "1234567", "page": None},
+        )
+        self.assertIsNotNone(response["data"])
+
+    @patch("requests.Session.get")
+    def test_search_transactions_by_order(self, mock_get) -> None:
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = load_json_file("tests/data/transactions.json")
+        response = self.client.search_transactions_by_order("ORDER-1")
+        mock_get.assert_called_once_with(
+            "https://api.payway.com.au/rest/v1/transactions/search-order",
+            params={"orderNumber": "ORDER-1", "page": None},
+        )
+        self.assertIsNotNone(response["data"])

python_payway-0.0.8/payway/transactions.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-import requests
-
-from payway.constants import TRANSACTION_URL
-from payway.utils import json_list
-
-
-class TransactionRequest:
-    session = requests.Session()
-    session_no_headers = requests.Session()
-
-    @json_list("search_transactions")
-    def search_transactions(self, query: str) -> requests.Response:
-        """
-        Returns a list of transactions
-        """
-        return self.session_no_headers.get(TRANSACTION_URL + query)

python_payway-0.0.8/tests/test_transactions.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-import unittest
-from unittest.mock import patch
-
-from payway.client import Client
-from payway.test_utils import load_json_file
-
-
-class TestTransactionRequest(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls) -> None:
-        merchant_id = "TEST"
-        bank_account_id = "0000000A"
-        publishable_api_key = "TPUBLISHABLE-API-KEY"
-        secret_api_key = "TPUBLISHABLE-SECRET"
-
-        cls.client = Client(
-            merchant_id=merchant_id,
-            bank_account_id=bank_account_id,
-            publishable_api_key=publishable_api_key,
-            secret_api_key=secret_api_key,
-        )
-
-    @patch("requests.Session.get")
-    def test_search_transactions(self, mock_get) -> None:
-        mock_get.return_value.status_code = 200
-        mock_get.return_value.json.return_value = load_json_file("tests/data/transactions.json")
-        query = "/search-customer?customerNumber=1"
-        response = self.client.search_transactions(query)
-        transactions = response["data"]
-        self.assertIsNotNone(transactions)