✨ payments service: implementation of apis and db repos for one-time-payment workflow ⚠️

services/docker-compose.yml

@@ -219,6 +219,11 @@ services:
       - PAYMENTS_PASSWORD=${PAYMENTS_PASSWORD}
       - PAYMENTS_SWAGGER_API_DOC_ENABLED=${PAYMENTS_SWAGGER_API_DOC_ENABLED}
       - PAYMENTS_USERNAME=${PAYMENTS_USERNAME}
+      - POSTGRES_DB=${POSTGRES_DB}
+      - POSTGRES_HOST=${POSTGRES_HOST}
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
+      - POSTGRES_PORT=${POSTGRES_PORT}
+      - POSTGRES_USER=${POSTGRES_USER}
       - RABBIT_HOST=${RABBIT_HOST}
       - RABBIT_PASSWORD=${RABBIT_PASSWORD}
       - RABBIT_PORT=${RABBIT_PORT}

services/payments/VERSION

@@ -1 +1 @@
-1.1.0
+1.2.0

services/payments/openapi.json

@@ -3,7 +3,7 @@
   "info": {
     "title": "simcore-service-payments web API",
     "description": " Service that manages creation and validation of registration payments",
-    "version": "1.1.0"
+    "version": "1.2.0"
   },
   "paths": {
     "/": {
@@ -218,6 +218,13 @@
             "type": "string",
             "title": "Message"
           },
+          "invoice_url": {
+            "type": "string",
+            "maxLength": 2083,
+            "minLength": 1,
+            "format": "uri",
+            "title": "Invoice Url"
+          },
           "saved": {
             "allOf": [
               {
@@ -230,7 +237,8 @@
         },
         "type": "object",
         "required": [
-          "success"
+          "success",
+          "invoice_url"
         ],
         "title": "AckPayment"
       },

services/payments/scripts/fake_payment_gateway.py

@@ -77,7 +77,9 @@ def cancel_payment(
     return router
 
 
-def auth_session(x_init_api_secret: Annotated[str | None, Header()] = None):
+# NOTE: keep `X_Init_Api_Secret` with capital letters (even if headers are case-insensitive) to
+# to agree with the specs provided by our partners
+def auth_session(X_Init_Api_Secret: Annotated[str | None, Header()] = None):
     return 1
 
 

services/payments/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.1.0
+current_version = 1.2.0
 commit = True
 message = services/payments version: {current_version} → {new_version}
 tag = False

services/payments/src/simcore_service_payments/api/rest/_acknowledgements.py

@@ -2,15 +2,25 @@
 from typing import Annotated
 
 from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, status
+from servicelib.logging_utils import log_context
+from simcore_postgres_database.models.payments_transactions import (
+    PaymentTransactionState,
+)
 
+from ...db.payments_transactions_repo import (
+    PaymentNotFoundError,
+    PaymentsTransactionsRepo,
+)
 from ...models.auth import SessionData
+from ...models.db import PaymentsTransactionsDB
 from ...models.schemas.acknowledgements import (
     AckPayment,
     AckPaymentMethod,
     PaymentID,
     PaymentMethodID,
 )
-from ._dependencies import get_current_session
+from ...services.resource_usage_tracker import ResourceUsageTrackerApi
+from ._dependencies import get_current_session, get_repository, get_rut_api
 
 _logger = logging.getLogger(__name__)
 
@@ -19,34 +29,82 @@
 
 
 async def on_payment_completed(
-    payment_id: PaymentID, ack: AckPayment, session: SessionData
+    transaction: PaymentsTransactionsDB, rut_api: ResourceUsageTrackerApi
 ):
+    assert transaction.completed_at is not None  # nosec
+    assert transaction.initiated_at < transaction.completed_at  # nosec
+
+    _logger.debug("TODO next PR Notify front-end of payment -> sio ")
+
+    with log_context(
+        _logger,
+        logging.INFO,
+        "Top-up %s credits for %s in RUT",
+        f"{transaction.osparc_credits}",
+        f"{transaction.payment_id=}",
+    ):
+        credit_transaction_id = await rut_api.create_credit_transaction(
+            product_name=transaction.product_name,
+            wallet_id=transaction.wallet_id,
+            wallet_name="id={transaction.wallet_id}",
+            user_id=transaction.user_id,
+            user_email=transaction.user_email,
+            osparc_credits=transaction.osparc_credits,
+            payment_transaction_id=transaction.payment_id,
+            created_at=transaction.completed_at,
+        )
+
     _logger.debug(
-        "payment completed: %s",
-        f"{payment_id=}, {ack.success=}, {ack.message=}, {session.username=}",
+        "RUT response to %s was %s",
+        f"{transaction.payment_id=}",
+        f"{credit_transaction_id=}",
     )
-    _logger.debug("Notify front-end -> sio ")
-    _logger.debug("Authorize inc/dec credits -> RUT")
-    _logger.debug("Annotate RUT response")
 
 
 @router.post("/payments/{payment_id}:ack")
 async def acknowledge_payment(
     payment_id: PaymentID,
     ack: AckPayment,
-    session: Annotated[SessionData, Depends(get_current_session)],
+    _session: Annotated[SessionData, Depends(get_current_session)],
+    repo: Annotated[
+        PaymentsTransactionsRepo, Depends(get_repository(PaymentsTransactionsRepo))
+    ],
+    rut_api: Annotated[ResourceUsageTrackerApi, Depends(get_rut_api)],
     background_tasks: BackgroundTasks,
 ):
     """completes (ie. ack) request initated by `/init` on the payments-gateway API"""
-    _logger.debug(
-        "User %s is acknoledging payment with %s as %s", session, f"{payment_id=}", ack
-    )
-    _logger.debug("Validate and complete transaction -> DB")
-    _logger.debug(
-        "When annotated in db, respond and start a background task with the rest"
-    )
-    background_tasks.add_task(on_payment_completed, payment_id, ack, session)
-    raise HTTPException(status_code=status.HTTP_501_NOT_IMPLEMENTED)
+
+    with log_context(
+        _logger,
+        logging.INFO,
+        "Annotate ACK transaction %s in db",
+        f"{payment_id=}",
+    ):
+        try:
+            transaction = await repo.update_ack_payment_transaction(
+                payment_id=payment_id,
+                completion_state=(
+                    PaymentTransactionState.SUCCESS
+                    if ack.success
+                    else PaymentTransactionState.FAILED
+                ),
+                state_message=ack.message,
+                invoice_url=ack.invoice_url,
+            )
+        except PaymentNotFoundError as err:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail=f"{err}"
+            ) from err
+
+    if ack.saved:
+        _logger.debug("TODO Annotate CREATE payment method")
+        raise HTTPException(
+            status_code=status.HTTP_501_NOT_IMPLEMENTED,
+        )
+
+    if transaction.state == PaymentTransactionState.SUCCESS:
+        assert payment_id == transaction.payment_id  # nosec
+        background_tasks.add_task(on_payment_completed, transaction, rut_api)
 
 
 @router.post("/payments-methods/{payment_method_id}:ack")

services/payments/src/simcore_service_payments/api/rest/_dependencies.py

@@ -1,14 +1,18 @@
 import logging
-from typing import Annotated
+from collections.abc import AsyncGenerator, Callable
+from typing import Annotated, cast
 
 from fastapi import Depends, Request
 from fastapi.security import OAuth2PasswordBearer
 from servicelib.fastapi.dependencies import get_app, get_reverse_url_mapper
+from sqlalchemy.ext.asyncio import AsyncEngine
 
 from ..._meta import API_VTAG
 from ...core.settings import ApplicationSettings
+from ...db.payments_transactions_repo import BaseRepository
 from ...models.auth import SessionData
 from ...services.auth import get_session_data
+from ...services.resource_usage_tracker import ResourceUsageTrackerApi
 
 _logger = logging.getLogger(__name__)
 
@@ -27,11 +31,32 @@ def get_settings(request: Request) -> ApplicationSettings:
 assert get_reverse_url_mapper  # nosec
 assert get_app  # nosec
 
-
 #
-# auth dependencies
+# services dependencies
 #
 
+
+def get_rut_api(request: Request) -> ResourceUsageTrackerApi:
+    return cast(
+        ResourceUsageTrackerApi, ResourceUsageTrackerApi.get_from_app_state(request.app)
+    )
+
+
+def get_db_engine(request: Request) -> AsyncEngine:
+    engine: AsyncEngine = request.app.state.engine
+    assert engine  # nosec
+    return engine
+
+
+def get_repository(repo_type: type[BaseRepository]) -> Callable:
+    async def _get_repo(
+        engine: Annotated[AsyncEngine, Depends(get_db_engine)],
+    ) -> AsyncGenerator[BaseRepository, None]:
+        yield repo_type(db_engine=engine)
+
+    return _get_repo
+
+
 # Implements `password` flow defined in OAuth2
 _oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"/{API_VTAG}/token")
 

services/payments/src/simcore_service_payments/api/rest/_exceptions.py

@@ -0,0 +1,43 @@
+import logging
+
+from fastapi import HTTPException, Request, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse
+
+from ...models.schemas.errors import DefaultApiError
+
+_logger = logging.getLogger(__name__)
+
+
+# NOTE:  https://www.starlette.io/exceptions/
+# Handled exceptions **do not represent error cases** !
+# - They are coerced into appropriate HTTP responses, which are then sent through the standard middleware stack.
+# - By default the HTTPException class is used to manage any handled exceptions.
+
+
+async def http_exception_as_json_response(
+    request: Request, exc: HTTPException
+) -> JSONResponse:
+    assert request  # nosec
+    error = DefaultApiError.from_status_code(exc.status_code)
+
+    error_detail = error.detail or ""
+    if exc.detail not in error_detail:
+        # starlette.exceptions.HTTPException default to similar detail
+        error.detail = exc.detail
+
+    return JSONResponse(
+        jsonable_encoder(error, exclude_none=True), status_code=exc.status_code
+    )
+
+
+async def handle_errors_as_500(request: Request, exc: Exception) -> JSONResponse:
+    assert request  # nosec
+    assert isinstance(exc, Exception)  # nosec
+
+    error = DefaultApiError.from_status_code(status.HTTP_500_INTERNAL_SERVER_ERROR)
+    _logger.exception("Unhandled exeption responded as %s", error)
+    return JSONResponse(
+        jsonable_encoder(error, exclude_none=True),
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+    )

services/payments/src/simcore_service_payments/api/rest/routes.py

@@ -1,14 +1,18 @@
-from fastapi import APIRouter, FastAPI
+from fastapi import APIRouter, FastAPI, HTTPException
 
 from ..._meta import API_VTAG
 from . import _acknowledgements, _auth, _health, _meta
+from ._exceptions import handle_errors_as_500, http_exception_as_json_response
 
 
-def setup_rest_api_routes(app: FastAPI):
+def setup_rest_api(app: FastAPI):
     app.include_router(_health.router)
 
     api_router = APIRouter(prefix=f"/{API_VTAG}")
     api_router.include_router(_auth.router, tags=["auth"])
     api_router.include_router(_meta.router, tags=["meta"])
     api_router.include_router(_acknowledgements.router, tags=["acks"])
     app.include_router(api_router)
+
+    app.add_exception_handler(Exception, handle_errors_as_500)
+    app.add_exception_handler(HTTPException, http_exception_as_json_response)