python-getpaid-payu 3.0.0a3__tar.gz → 3.0.0a4__tar.gz

{python_getpaid_payu-3.0.0a3 → python_getpaid_payu-3.0.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-getpaid-payu
-Version: 3.0.0a3
+Version: 3.0.0a4
 Summary: PayU payment gateway integration for python-getpaid ecosystem.
 Project-URL: Homepage, https://github.com/django-getpaid/python-getpaid-payu
 Project-URL: Repository, https://github.com/django-getpaid/python-getpaid-payu
@@ -20,6 +20,9 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: python-getpaid-core>=3.0.0a3
+Provides-Extra: simulator
+Requires-Dist: litestar>=2.0; extra == 'simulator'
+Requires-Dist: python-getpaid-simulator>=3.0.0a3; extra == 'simulator'
 Description-Content-Type: text/markdown
 
 # python-getpaid-payu
@@ -53,6 +56,39 @@ BGN, CHF, CZK, DKK, EUR, GBP, HRK, HUF, NOK, PLN, RON, RUB, SEK, UAH, USD.
 pip install python-getpaid-payu
 ```
 
+Install simulator support only when you want this package to register its local
+simulator plugin with `python-getpaid-simulator`:
+
+```bash
+pip install python-getpaid-payu[simulator]
+```
+
+This extra installs the simulator host and Litestar dependencies, then exposes
+the `payu` plugin through the `getpaid.simulator.providers` entry point.
+
+## Simulator Plugin
+
+When `python-getpaid-payu[simulator]` is installed alongside
+`python-getpaid-simulator`, the simulator host auto-discovers the PayU plugin.
+
+Typical local setup:
+
+```bash
+pip install python-getpaid-simulator python-getpaid-payu[simulator]
+getpaid-simulator
+```
+
+The plugin contributes:
+
+- PayU OAuth and order/refund simulator API routes
+- PayU authorization UI at `/sim/payu/authorize/{order_id}`
+- PayU-specific webhook signing and state transitions
+
+Useful simulator environment variables:
+
+- `SIMULATOR_PAYU_SECOND_KEY`
+- `SIMULATOR_PLUGIN_FAILURE_MODE` (`warn` or `strict`)
+
 ## Configuration
 
 To use the PayU backend, register it in your `getpaid` configuration and provide the following settings:

{python_getpaid_payu-3.0.0a3 → python_getpaid_payu-3.0.0a4}/README.md

@@ -29,6 +29,39 @@ BGN, CHF, CZK, DKK, EUR, GBP, HRK, HUF, NOK, PLN, RON, RUB, SEK, UAH, USD.
 pip install python-getpaid-payu
 ```
 
+Install simulator support only when you want this package to register its local
+simulator plugin with `python-getpaid-simulator`:
+
+```bash
+pip install python-getpaid-payu[simulator]
+```
+
+This extra installs the simulator host and Litestar dependencies, then exposes
+the `payu` plugin through the `getpaid.simulator.providers` entry point.
+
+## Simulator Plugin
+
+When `python-getpaid-payu[simulator]` is installed alongside
+`python-getpaid-simulator`, the simulator host auto-discovers the PayU plugin.
+
+Typical local setup:
+
+```bash
+pip install python-getpaid-simulator python-getpaid-payu[simulator]
+getpaid-simulator
+```
+
+The plugin contributes:
+
+- PayU OAuth and order/refund simulator API routes
+- PayU authorization UI at `/sim/payu/authorize/{order_id}`
+- PayU-specific webhook signing and state transitions
+
+Useful simulator environment variables:
+
+- `SIMULATOR_PAYU_SECOND_KEY`
+- `SIMULATOR_PLUGIN_FAILURE_MODE` (`warn` or `strict`)
+
 ## Configuration
 
 To use the PayU backend, register it in your `getpaid` configuration and provide the following settings:

{python_getpaid_payu-3.0.0a3 → python_getpaid_payu-3.0.0a4}/pyproject.toml

@@ -23,6 +23,12 @@ dependencies = [
     'httpx>=0.27.0',
 ]
 
+[project.optional-dependencies]
+simulator = [
+    'python-getpaid-simulator>=3.0.0a3',
+    'litestar>=2.0',
+]
+
 [dependency-groups]
 dev = [
     'pytest>=8.0',
@@ -48,6 +54,9 @@ Changelog = 'https://github.com/django-getpaid/python-getpaid-payu/releases'
 [project.entry-points."getpaid.backends"]
 payu = 'getpaid_payu.processor:PayUProcessor'
 
+[project.entry-points."getpaid.simulator.providers"]
+payu = 'getpaid_payu.simulator:get_plugin'
+
 [build-system]
 requires = ['hatchling']
 build-backend = 'hatchling.build'

{python_getpaid_payu-3.0.0a3 → python_getpaid_payu-3.0.0a4}/src/getpaid_payu/__init__.py

@@ -9,4 +9,4 @@ __all__ = [
     "PayUProcessor",
 ]
 
-__version__ = "3.0.0a3"
+__version__ = "3.0.0a4"

python_getpaid_payu-3.0.0a4/src/getpaid_payu/simulator/__init__.py

@@ -0,0 +1,6 @@
+"""PayU simulator plugin for python-getpaid-simulator."""
+
+from getpaid_payu.simulator.plugin import get_plugin
+
+
+__all__ = ["get_plugin"]

python_getpaid_payu-3.0.0a4/src/getpaid_payu/simulator/plugin.py

@@ -0,0 +1,58 @@
+"""PayU simulator plugin factory."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+from typing import Any
+
+from getpaid_simulator.spi import SIMULATOR_PLUGIN_API_VERSION
+from getpaid_simulator.spi import SimulatorProviderPlugin
+
+from getpaid_payu.simulator.routes import cancel_order
+from getpaid_payu.simulator.routes import capture_order
+from getpaid_payu.simulator.routes import create_order
+from getpaid_payu.simulator.routes import create_refund
+from getpaid_payu.simulator.routes import get_order_info
+from getpaid_payu.simulator.routes import oauth_endpoint
+from getpaid_payu.simulator.routes import payu_authorize_get
+from getpaid_payu.simulator.routes import payu_authorize_post
+from getpaid_payu.simulator.routes import test_protected_endpoint
+from getpaid_payu.simulator.transitions import PAYU_TRANSITIONS
+
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+
+def load_provider_config(
+    env: Mapping[str, str] | None = None,
+) -> dict[str, Any]:
+    environment = env or os.environ
+    return {
+        "second_key": environment.get(
+            "SIMULATOR_PAYU_SECOND_KEY",
+            "b6ca15b0d1020e8094d9b5f8d163db54",
+        ),
+    }
+
+
+def get_plugin() -> SimulatorProviderPlugin:
+    return SimulatorProviderPlugin(
+        api_version=SIMULATOR_PLUGIN_API_VERSION,
+        slug="payu",
+        display_name="PayU",
+        api_handlers=(
+            oauth_endpoint,
+            test_protected_endpoint,
+            create_order,
+            get_order_info,
+            cancel_order,
+            capture_order,
+            create_refund,
+        ),
+        ui_handlers=(payu_authorize_get, payu_authorize_post),
+        transitions=PAYU_TRANSITIONS,
+        load_config=load_provider_config,
+        authorize_path_template="/sim/payu/authorize/{entity_id}",
+    )

python_getpaid_payu-3.0.0a4/src/getpaid_payu/simulator/routes.py

@@ -0,0 +1,394 @@
+"""PayU simulator routes."""
+
+from __future__ import annotations
+
+from datetime import UTC
+from datetime import datetime
+from inspect import isawaitable
+from typing import Any
+from urllib.parse import parse_qsl
+
+from litestar import Request
+from litestar import delete
+from litestar import get
+from litestar import post
+from litestar.enums import MediaType
+from litestar.enums import RequestEncodingType
+from litestar.exceptions import HTTPException
+from litestar.exceptions import NotFoundException
+from litestar.params import Body
+from litestar.response import Redirect
+from litestar.response import Response
+from litestar.response import Template
+
+from getpaid_payu.simulator.webhooks import trigger_payu_webhook
+
+
+URL_ENCODED_BODY = Body(media_type=RequestEncodingType.URL_ENCODED)
+
+
+def _provider_config(request: Request[Any, Any, Any]) -> dict[str, Any]:
+    return dict(request.app.state.provider_configs["payu"])
+
+
+def _unauthorized_response() -> Response[dict[str, dict[str, str]]]:
+    return Response(
+        content={
+            "status": {
+                "statusCode": "UNAUTHORIZED",
+                "statusDesc": "Invalid or expired token",
+            }
+        },
+        status_code=401,
+        media_type=MediaType.JSON,
+    )
+
+
+def _not_found_response(order_id: str) -> Response[dict[str, dict[str, str]]]:
+    return Response(
+        content={
+            "status": {
+                "statusCode": "ERROR_ORDER_NOT_EXISTS",
+                "statusDesc": f"Order {order_id} not found",
+            }
+        },
+        status_code=404,
+        media_type=MediaType.JSON,
+    )
+
+
+def _extract_bearer_token(request: Request[Any, Any, Any]) -> str | None:
+    authorization_header = request.headers.get("authorization")
+    if authorization_header is None:
+        return None
+
+    token_type, _, token_value = authorization_header.partition(" ")
+    if token_type.lower() != "bearer" or not token_value:
+        return None
+    return token_value
+
+
+def _is_authorized(request: Request[Any, Any, Any]) -> bool:
+    token = _extract_bearer_token(request)
+    if token is None:
+        return False
+    return request.app.state.storage.validate_token(token)
+
+
+def _order_to_payu_order(
+    order_id: str,
+    order_data: dict[str, Any],
+) -> dict[str, Any]:
+    payu_order = dict(order_data)
+    payu_order.pop("id", None)
+    payu_order["orderId"] = order_id
+    return payu_order
+
+
+@post("/payu/pl/standard/user/oauth/authorize")
+async def oauth_endpoint(
+    request: Request[Any, Any, Any],
+) -> Response[dict[str, Any]]:
+    raw_body = await request.body()
+    form_data = dict(parse_qsl(raw_body.decode()))
+    client_id = form_data.get("client_id", "")
+    token_data = request.app.state.storage.create_token(
+        pos_id=client_id,
+        expires_in=43199,
+    )
+    return Response(
+        content={
+            "access_token": token_data["access_token"],
+            "token_type": "bearer",
+            "expires_in": 43199,
+            "grant_type": "client_credentials",
+        },
+        status_code=200,
+        media_type=MediaType.JSON,
+    )
+
+
+@get("/payu/api/v2_1/test-protected")
+async def test_protected_endpoint(
+    request: Request[Any, Any, Any],
+) -> Response[dict[str, Any]]:
+    if not _is_authorized(request):
+        return _unauthorized_response()
+
+    return Response(
+        content={"status": "ok"},
+        status_code=200,
+        media_type=MediaType.JSON,
+    )
+
+
+@post("/payu/api/v2_1/orders")
+async def create_order(
+    request: Request[Any, Any, Any],
+) -> Response[dict[str, Any]]:
+    if not _is_authorized(request):
+        return _unauthorized_response()
+
+    payload = await request.json()
+    if not isinstance(payload, dict):
+        payload = {}
+
+    order_data = dict(payload)
+    order_data["status"] = "NEW"
+    order_id = request.app.state.storage.create_order(
+        order_data,
+        provider="payu",
+    )
+    request.app.state.state_machine.transition(order_id, "PENDING")
+
+    host = request.headers.get("host", "localhost")
+    redirect_uri = f"http://{host}/sim/payu/authorize/{order_id}"
+    response_body = {
+        "status": {"statusCode": "SUCCESS"},
+        "orderId": order_id,
+        "extOrderId": order_data.get("extOrderId"),
+        "redirectUri": redirect_uri,
+    }
+    return Response(
+        content=response_body,
+        status_code=302,
+        headers={"Location": redirect_uri},
+        media_type=MediaType.JSON,
+    )
+
+
+@get("/payu/api/v2_1/orders/{order_id:str}")
+async def get_order_info(
+    request: Request[Any, Any, Any],
+    order_id: str,
+) -> Response[dict[str, Any]]:
+    if not _is_authorized(request):
+        return _unauthorized_response()
+
+    order = request.app.state.storage.get_order(order_id)
+    if order is None:
+        return _not_found_response(order_id)
+
+    return Response(
+        content={
+            "orders": [_order_to_payu_order(order_id, order)],
+            "status": {"statusCode": "SUCCESS"},
+        },
+        status_code=200,
+        media_type=MediaType.JSON,
+    )
+
+
+@delete("/payu/api/v2_1/orders/{order_id:str}", status_code=200)
+async def cancel_order(
+    request: Request[Any, Any, Any],
+    order_id: str,
+) -> Response[dict[str, Any]]:
+    if not _is_authorized(request):
+        return _unauthorized_response()
+
+    order = request.app.state.storage.get_order(order_id)
+    if order is None:
+        return _not_found_response(order_id)
+
+    try:
+        request.app.state.state_machine.transition(order_id, "CANCELED")
+    except request.app.state.invalid_transition_error as error:
+        return Response(
+            content=error.error_response,
+            status_code=200,
+            media_type=MediaType.JSON,
+        )
+
+    callback = trigger_payu_webhook(
+        order_id,
+        request.app.state.storage,
+        _provider_config(request),
+        request.app.state.webhook_transport,
+    )
+    if isawaitable(callback):
+        await callback
+
+    return Response(
+        content={"status": {"statusCode": "SUCCESS"}, "orderId": order_id},
+        status_code=200,
+        media_type=MediaType.JSON,
+    )
+
+
+@post("/payu/api/v2_1/orders/{order_id:str}/captures")
+async def capture_order(
+    request: Request[Any, Any, Any],
+    order_id: str,
+) -> Response[dict[str, Any]]:
+    if not _is_authorized(request):
+        return _unauthorized_response()
+
+    order = request.app.state.storage.get_order(order_id)
+    if order is None:
+        return _not_found_response(order_id)
+
+    try:
+        request.app.state.state_machine.transition(order_id, "COMPLETED")
+    except request.app.state.invalid_transition_error as error:
+        return Response(
+            content=error.error_response,
+            status_code=200,
+            media_type=MediaType.JSON,
+        )
+
+    callback = trigger_payu_webhook(
+        order_id,
+        request.app.state.storage,
+        _provider_config(request),
+        request.app.state.webhook_transport,
+    )
+    if isawaitable(callback):
+        await callback
+
+    return Response(
+        content={"status": {"statusCode": "SUCCESS"}, "orderId": order_id},
+        status_code=200,
+        media_type=MediaType.JSON,
+    )
+
+
+@post("/payu/api/v2_1/orders/{order_id:str}/refunds")
+async def create_refund(
+    request: Request[Any, Any, Any],
+    order_id: str,
+) -> Response[dict[str, Any]]:
+    if not _is_authorized(request):
+        return _unauthorized_response()
+
+    order = request.app.state.storage.get_order(order_id)
+    if order is None:
+        return _not_found_response(order_id)
+
+    payload = await request.json()
+    if not isinstance(payload, dict):
+        payload = {}
+
+    refund_info = payload.get("refund", {})
+
+    amount = refund_info.get("amount")
+    if amount is None:
+        amount = order.get("totalAmount", "0")
+
+    description = refund_info.get("description", "Refund")
+    ext_refund_id = refund_info.get("extRefundId")
+    currency_code = refund_info.get(
+        "currencyCode", order.get("currencyCode", "PLN")
+    )
+
+    now = datetime.now(UTC).isoformat()
+    refund_data = {
+        "amount": amount,
+        "currencyCode": currency_code,
+        "description": description,
+        "status": "FINALIZED",
+        "creationDateTime": now,
+        "statusDateTime": now,
+    }
+
+    if ext_refund_id is not None:
+        refund_data["extRefundId"] = ext_refund_id
+
+    refund_id = request.app.state.storage.create_refund(order_id, refund_data)
+
+    response_body = {
+        "status": {"statusCode": "SUCCESS"},
+        "orderId": order_id,
+        "refund": {
+            "refundId": refund_id,
+            "extRefundId": ext_refund_id,
+            "amount": amount,
+            "currencyCode": currency_code,
+            "description": description,
+            "status": "FINALIZED",
+            "statusDateTime": now,
+        },
+    }
+
+    return Response(
+        content=response_body,
+        status_code=200,
+        media_type=MediaType.JSON,
+    )
+
+
+@get("/sim/payu/authorize/{order_id:str}")
+async def payu_authorize_get(
+    order_id: str,
+    request: Request[Any, Any, Any],
+) -> Template:
+    order = request.app.state.storage.get_order(order_id)
+    if not order:
+        raise NotFoundException("Payment not found")
+
+    if order.get("status") in ("COMPLETED", "CANCELED"):
+        raise HTTPException(status_code=400, detail="Payment already processed")
+
+    amount_raw = order.get("totalAmount", 0)
+    try:
+        amount_value = float(amount_raw) / 100
+        formatted_amount = (
+            f"{amount_value:.2f} {order.get('currencyCode', 'PLN')}"
+        )
+    except (ValueError, TypeError):
+        formatted_amount = str(amount_raw)
+
+    return Template(
+        template_name="authorize.html",
+        context={
+            "provider": "PayU",
+            "payment": order,
+            "order_id": order_id,
+            "amount": formatted_amount,
+            "status": order.get("status", "NEW"),
+        },
+    )
+
+
+@post("/sim/payu/authorize/{order_id:str}")
+async def payu_authorize_post(
+    order_id: str,
+    request: Request[Any, Any, Any],
+    data: dict[str, str] = URL_ENCODED_BODY,
+) -> Redirect:
+    order = request.app.state.storage.get_order(order_id)
+    if not order:
+        raise NotFoundException("Payment not found")
+
+    current_status = order.get("status", "NEW")
+    if current_status in ("COMPLETED", "CANCELED"):
+        raise HTTPException(status_code=400, detail="Payment already processed")
+
+    action = data.get("action")
+    if action == "approve":
+        if current_status == "NEW":
+            request.app.state.state_machine.transition(order_id, "PENDING")
+            request.app.state.state_machine.transition(
+                order_id, "WAITING_FOR_CONFIRMATION"
+            )
+        elif current_status == "PENDING":
+            request.app.state.state_machine.transition(
+                order_id, "WAITING_FOR_CONFIRMATION"
+            )
+        request.app.state.state_machine.transition(order_id, "COMPLETED")
+    elif action == "reject":
+        if current_status == "NEW":
+            request.app.state.state_machine.transition(order_id, "PENDING")
+        request.app.state.state_machine.transition(order_id, "CANCELED")
+    else:
+        raise HTTPException(status_code=400, detail="Invalid action")
+
+    await trigger_payu_webhook(
+        order_id,
+        request.app.state.storage,
+        _provider_config(request),
+        request.app.state.webhook_transport,
+    )
+
+    continue_url = order.get("continueUrl", "/")
+    return Redirect(path=str(continue_url))

python_getpaid_payu-3.0.0a4/src/getpaid_payu/simulator/signing.py

@@ -0,0 +1,14 @@
+"""PayU webhook signing helpers for the simulator plugin."""
+
+from hashlib import sha256
+
+
+def compute_signature(body: bytes, second_key: str) -> str:
+    """Return the PayU callback signature."""
+    return sha256(body + second_key.encode()).hexdigest()
+
+
+def sign_payload(body: bytes, second_key: str) -> str:
+    """Return the full PayU signature header value."""
+    signature = compute_signature(body, second_key)
+    return f"signature={signature};algorithm=SHA-256;sender=checkout"

python_getpaid_payu-3.0.0a4/src/getpaid_payu/simulator/transitions.py

@@ -0,0 +1,9 @@
+"""PayU simulator state transitions."""
+
+PAYU_TRANSITIONS: dict[str, set[str]] = {
+    "NEW": {"PENDING"},
+    "PENDING": {"WAITING_FOR_CONFIRMATION", "CANCELED"},
+    "WAITING_FOR_CONFIRMATION": {"COMPLETED", "CANCELED"},
+    "COMPLETED": set(),
+    "CANCELED": set(),
+}

python_getpaid_payu-3.0.0a4/src/getpaid_payu/simulator/webhooks.py

@@ -0,0 +1,77 @@
+"""PayU webhook delivery for the simulator plugin."""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC
+from datetime import datetime
+from typing import TYPE_CHECKING
+from typing import Any
+
+from getpaid_payu.simulator.signing import sign_payload
+
+
+if TYPE_CHECKING:
+    from getpaid_simulator.core.storage import SimulatorStorage
+    from getpaid_simulator.core.webhooks import WebhookTransport
+
+
+def build_order_notification(
+    order_id: str,
+    order: dict[str, Any],
+) -> dict[str, Any]:
+    """Build the PayU OrderNotification payload."""
+    order_data: dict[str, Any] = {
+        "orderId": order_id,
+        "orderCreateDate": datetime.now(UTC).isoformat(),
+        "extOrderId": order.get("extOrderId"),
+        "notifyUrl": order.get("notifyUrl"),
+        "customerIp": order.get("customerIp", "127.0.0.1"),
+        "merchantPosId": order.get("merchantPosId"),
+        "description": order.get("description"),
+        "currencyCode": order.get("currencyCode"),
+        "totalAmount": order.get("totalAmount"),
+        "status": order.get("status"),
+        "buyer": order.get("buyer", {}),
+        "products": order.get("products", []),
+    }
+    return {
+        "order": order_data,
+        "localReceiptDateTime": datetime.now(UTC).isoformat(),
+        "properties": None,
+    }
+
+
+async def trigger_payu_webhook(
+    order_id: str,
+    storage: SimulatorStorage,
+    provider_config: dict[str, Any],
+    transport: WebhookTransport,
+) -> bool | None:
+    """Send a PayU order notification to the merchant callback URL."""
+    order = storage.get_order(order_id)
+    if order is None:
+        return None
+
+    notify_url = order.get("notifyUrl")
+    if not notify_url:
+        return None
+
+    payload = build_order_notification(order_id, order)
+    body = json.dumps(payload).encode("utf-8")
+    headers = {
+        "Content-Type": "application/json",
+        "OpenPayU-Signature": sign_payload(
+            body,
+            str(provider_config["second_key"]),
+        ),
+    }
+
+    result = await transport.deliver(
+        url=str(notify_url), body=body, headers=headers
+    )
+    storage.update_order(
+        order_id,
+        webhook_status="success" if result else "failed",
+    )
+    return result

{python_getpaid_payu-3.0.0a3 → python_getpaid_payu-3.0.0a4}/tests/test_public_api.py

@@ -4,4 +4,4 @@ import getpaid_payu
 
 
 def test_version() -> None:
-    assert getpaid_payu.__version__ == "3.0.0a3"
+    assert getpaid_payu.__version__ == "3.0.0a4"