feat: Enhance payment transaction handling by adding registration data support and updating dependencies

Author: Arnel Jan Sarmiento

backend/controller/payment_controller.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Query
+from fastapi import APIRouter, Body, Path, Query
 from fastapi.responses import JSONResponse
 from model.common import Message
 from model.payments.payments import PaymentTransactionIn, PaymentTransactionOut
@@ -66,8 +66,10 @@ def get_pending_payment_transactions():
     summary='Update payment transaction',
 )
 def update_payment_transaction(
-    payment_transaction_id: str,
-    payment_transaction: PaymentTransactionIn,
+    payment_transaction_id: str = Path(
+        ..., description='The ID of the payment transaction', alias='paymentTransactionId'
+    ),
+    payment_transaction: PaymentTransactionIn = Body(..., description='The payment transaction data'),
 ):
     """
     Update payment transaction

backend/model/payments/payments.py

@@ -2,9 +2,12 @@
 from typing import Optional
 
 from model.entities import Entities
-from model.pycon_registrations.pycon_registration import PyconRegistration
+from model.pycon_registrations.pycon_registration import (
+    PyconRegistration,
+    PyconRegistrationOut,
+)
 from pydantic import BaseModel, Field
-from pynamodb.attributes import NumberAttribute, UnicodeAttribute
+from pynamodb.attributes import BooleanAttribute, NumberAttribute, UnicodeAttribute
 
 
 class TransactionStatus(str, Enum):
@@ -21,15 +24,40 @@ class PaymentTransaction(Entities, discriminator='PaymentTransaction'):
     eventId = UnicodeAttribute(null=False)
     transactionStatus = UnicodeAttribute(null=False)
 
-    # registration data
-    firstName: str = Field(None, title='First Name')
-    lastName: str = Field(None, title='Last Name')
-    contactNumber: str = Field(None, title='Contact Number')
-    careerStatus: str = Field(None, title='Career Status')
-    yearsOfExperience: str = Field(None, title='Years of Experience')
-    organization: str = Field(None, title='Organization')
-    title: str = Field(None, title='Title')
-    paymentRequestId: str = Field(None, title='Payment Request ID')
+    # registration data - core info
+    firstName = UnicodeAttribute(null=True)
+    lastName = UnicodeAttribute(null=True)
+    nickname = UnicodeAttribute(null=True)
+    pronouns = UnicodeAttribute(null=True)
+    email = UnicodeAttribute(null=True)
+    contactNumber = UnicodeAttribute(null=True)
+    organization = UnicodeAttribute(null=True)
+    jobTitle = UnicodeAttribute(null=True)
+
+    # social media (will be stored as JSON string)
+    socials = UnicodeAttribute(null=True)
+
+    # ticket and event preferences
+    ticketType = UnicodeAttribute(null=True)
+    sprintDay = BooleanAttribute(null=True)
+
+    # t-shirt preferences
+    availTShirt = BooleanAttribute(null=True)
+    shirtType = UnicodeAttribute(null=True)
+    shirtSize = UnicodeAttribute(null=True)
+
+    # community and preferences
+    communityInvolvement = BooleanAttribute(null=True)
+    futureVolunteer = BooleanAttribute(null=True)
+    dietaryRestrictions = UnicodeAttribute(null=True)
+    accessibilityNeeds = UnicodeAttribute(null=True)
+
+    # discount and files
+    discountCode = UnicodeAttribute(null=True)
+    imageId = UnicodeAttribute(null=True)
+
+    # payment specific
+    paymentRequestId = UnicodeAttribute(null=True)
 
 
 class PaymentTransactionIn(BaseModel):
@@ -48,3 +76,4 @@ class Config:
         extra = 'ignore'
 
     entryId: str = Field(..., title='Entry ID')
+    registrationData: Optional[PyconRegistrationOut] = Field(None, title='Registration Data')

backend/model/pycon_registrations/pycon_registration.py

@@ -88,3 +88,8 @@ def check_shirt_availability(cls, values):
         if values.get('availTShirt') and (values.get('shirtType') is None or values.get('shirtSize') is None):
             raise ValueError('If availTShirt is True, then shirtType and shirtSize must be provided.')
         return values
+
+
+class PyconRegistrationOut(PyconRegistration):
+    class Config:
+        extra = 'ignore'

backend/pyproject.toml

@@ -17,11 +17,11 @@ dependencies = [
     "python-dateutil==2.9.0.post0",
     "requests==2.32.3",
     "pytz==2024.2",
-    "commitizen>=4.8.3",
 ]
 
 [dependency-groups]
 dev = [
+    "commitizen>=4.8.3",
     "boto3==1.40.11",
     "python-dotenv==1.0.0",
     "uvicorn==0.22.0",

backend/repository/payment_transaction_repository.py

@@ -46,6 +46,8 @@ def store_payment_transaction(
 
         """
         data = RepositoryUtils.load_data(pydantic_schema_in=payment_transaction_in)
+        registration_data = data.pop('registrationData', {}) or {}
+
         event_id = payment_transaction_in.eventId
         entry_id = ulid()
         hash_key = f'{self.core_obj}#{event_id}'
@@ -62,6 +64,7 @@ def store_payment_transaction(
                 entryStatus=EntryStatus.ACTIVE.value,
                 entryId=entry_id,
                 **data,
+                **registration_data,
             )
             payment_transaction_entry.save()
 
@@ -180,6 +183,54 @@ def query_payment_transaction_with_payment_transaction_id(
             logger.info(f'[{self.core_obj}={payment_transaction_id}] Fetch PaymentTransaction data successful')
             return HTTPStatus.OK, payment_transaction_entries[0], None
 
+    def query_payment_transaction_by_id_only(
+        self, payment_transaction_id: str
+    ) -> Tuple[HTTPStatus, PaymentTransaction, str]:
+        """Query payment_transaction by payment_transaction ID only (using scan).
+
+        :param payment_transaction_id: The ID of the payment_transaction to query.
+        :type payment_transaction_id: str
+
+        :return: The HTTP status, the queried payment_transaction or None, and a message.
+        :rtype: Tuple[HTTPStatus, PaymentTransaction, str]
+
+        """
+        try:
+            # Use scan to find payment transaction by ID across all events
+            range_key_suffix = f'#{payment_transaction_id}'
+
+            filter_condition = PaymentTransaction.rangeKey.contains(range_key_suffix)
+            filter_condition &= PaymentTransaction.entryStatus == EntryStatus.ACTIVE.value
+            filter_condition &= PaymentTransaction.rangeKey.startswith(f'v{self.latest_version}#')
+
+            payment_transaction_entries = list(
+                PaymentTransaction.scan(
+                    filter_condition=filter_condition,
+                )
+            )
+            if not payment_transaction_entries:
+                message = f'PaymentTransaction with ID = {payment_transaction_id} not found'
+                logger.error(f'[{self.core_obj} = {payment_transaction_id}] {message}')
+                return HTTPStatus.NOT_FOUND, None, message
+
+        except ScanError as e:
+            message = f'Failed to scan payment_transaction: {str(e)}'
+            logger.error(f'[{self.core_obj}={payment_transaction_id}] {message}')
+            return HTTPStatus.INTERNAL_SERVER_ERROR, None, message
+
+        except TableDoesNotExist as db_error:
+            message = f'Error on Table, Please check config to make sure table is created: {str(db_error)}'
+            logger.error(f'[{self.core_obj}={payment_transaction_id}] {message}')
+            return HTTPStatus.INTERNAL_SERVER_ERROR, None, message
+
+        except PynamoDBConnectionError as db_error:
+            message = f'Connection error occurred, Please check config(region, table name, etc): {str(db_error)}'
+            logger.error(f'[{self.core_obj}={payment_transaction_id}] {message}')
+            return HTTPStatus.INTERNAL_SERVER_ERROR, None, message
+        else:
+            logger.info(f'[{self.core_obj}={payment_transaction_id}] Fetch PaymentTransaction by ID successful')
+            return HTTPStatus.OK, payment_transaction_entries[0], None
+
     def update_payment_transaction(
         self, payment_transaction: PaymentTransaction, payment_transaction_in: PaymentTransactionIn
     ) -> Tuple[HTTPStatus, PaymentTransaction, str]:
@@ -199,11 +250,15 @@ def update_payment_transaction(
         new_version = current_version + 1
 
         data = RepositoryUtils.load_data(pydantic_schema_in=payment_transaction_in, exclude_unset=True)
+        registration_data = data.pop('registrationData', {}) or {}
+        merged_data = {**data, **registration_data}
+
         has_update, updated_data = RepositoryUtils.get_update(
-            old_data=RepositoryUtils.db_model_to_dict(payment_transaction), new_data=data
+            old_data=RepositoryUtils.db_model_to_dict(payment_transaction), new_data=merged_data
         )
         if not has_update:
             return HTTPStatus.OK, payment_transaction, 'no update'
+
         try:
             with TransactWrite(connection=self.conn) as transaction:
                 # Update Entry -----------------------------------------------------------------------------

backend/requirements.txt

@@ -1,50 +1,35 @@
 # This file was autogenerated by uv via the following command:
 #    uv export --format requirements-txt --no-hashes --output-file requirements.txt --no-dev
 anyio==4.9.0
-argcomplete==3.6.2
 boto3==1.40.11
 botocore==1.40.11
 certifi==2025.7.14
 cffi==1.17.1 ; platform_python_implementation != 'PyPy'
 charset-normalizer==3.4.2
-colorama==0.4.6
-commitizen==4.8.3
 cryptography==45.0.5
-decli==0.6.3
 dnspython==2.7.0
 ecdsa==0.19.1
 email-validator==2.2.0
 fastapi==0.96.0
 fastapi-cloudauth==0.4.3
 idna==3.10
-importlib-metadata==8.7.0
-jinja2==3.1.6
 jmespath==1.0.1
 lambda-decorators==0.6.0
 lambda-warmer-py==0.6.0
 mangum==0.15.0
-markupsafe==3.0.2
-packaging==25.0
-prompt-toolkit==3.0.51
 pyasn1==0.6.1
 pycparser==2.22 ; platform_python_implementation != 'PyPy'
 pydantic==1.10.22
 pynamodb==6.1.0
 python-dateutil==2.9.0.post0
 python-jose==3.5.0
 pytz==2024.2
-pyyaml==6.0.2
-questionary==2.1.0
 requests==2.32.3
 rsa==4.9.1
 s3transfer==0.13.1
 six==1.17.0
 sniffio==1.3.1
 starlette==0.27.0
-termcolor==3.1.0
-tomlkit==0.13.3
 typing-extensions==4.8.0
 ulid==1.1
 urllib3==1.26.20
-wcwidth==0.2.13
-zipp==3.23.0

backend/usecase/payment_usecase.py

@@ -6,9 +6,12 @@
     PaymentTransactionOut,
     TransactionStatus,
 )
+from model.pycon_registrations.pycon_registration import PyconRegistrationOut
+from pydantic import ValidationError
 from repository.events_repository import EventsRepository
 from repository.payment_transaction_repository import PaymentTransactionRepository
 from starlette.responses import JSONResponse
+from utils.logger import logger
 
 
 class PaymentUsecase:
@@ -17,41 +20,103 @@ def __init__(self):
         self.events_repo = EventsRepository()
 
     def create_payment_transaction(self, payment_transaction: PaymentTransactionIn) -> PaymentTransactionOut:
+        """
+        Create a new payment transaction
+
+        Arguments:
+            payment_transaction -- The payment transaction data
+
+        Returns:
+            PaymentTransactionOut -- The created payment transaction
+        """
+        logger.info(f'Creating payment transaction for {payment_transaction.eventId}')
         status, payment_transaction, message = self.payment_repo.store_payment_transaction(payment_transaction)
         if status != HTTPStatus.OK:
+            logger.error(f'[{payment_transaction.eventId}] {message}')
             return JSONResponse(status_code=status, content={'message': message})
 
+        logger.info(f'Payment transaction created for {payment_transaction.eventId}')
         payment_transaction_dict = self.__convert_data_entry_to_dict(payment_transaction)
         return PaymentTransactionOut(**payment_transaction_dict)
 
     def update_payment_transaction(
-        self, payment_transaction_id: str, payment_transaction: PaymentTransactionIn
+        self, payment_transaction_id: str, payment_transaction_in: PaymentTransactionIn
     ) -> PaymentTransactionOut:
-        status, payment_transaction, message = self.payment_repo.update_payment_transaction(
-            payment_transaction_id, payment_transaction
+        """
+        Update the payment transaction with the existing object
+
+        Arguments:
+            payment_transaction_id -- The ID of the payment transaction
+            payment_transaction_in -- The payment transaction data
+
+        Returns:
+            PaymentTransactionOut -- The updated payment transaction
+        """
+        logger.info(f'Updating payment transaction for {payment_transaction_id}')
+        status, existing_payment_transaction, message = self.payment_repo.query_payment_transaction_by_id_only(
+            payment_transaction_id=payment_transaction_id
         )
         if status != HTTPStatus.OK:
             return JSONResponse(status_code=status, content={'message': message})
 
-        payment_transaction_dict = self.__convert_data_entry_to_dict(payment_transaction)
+        # Now update the payment transaction with the existing object
+        status, updated_payment_transaction, message = self.payment_repo.update_payment_transaction(
+            existing_payment_transaction, payment_transaction_in
+        )
+        if status != HTTPStatus.OK:
+            logger.error(f'[{payment_transaction_id}] {message}')
+            return JSONResponse(status_code=status, content={'message': message})
+
+        logger.info(f'Payment transaction updated for {payment_transaction_id}')
+        payment_transaction_dict = self.__convert_data_entry_to_dict(updated_payment_transaction)
         return PaymentTransactionOut(**payment_transaction_dict)
 
     def query_pending_payment_transactions(self) -> list[PaymentTransactionOut]:
+        """
+        Query all pending payment transactions
+
+        Returns:
+            list[PaymentTransactionOut] -- The list of payment transactions
+        """
         status, payment_transactions, message = self.payment_repo.query_pending_payment_transactions()
         if status != HTTPStatus.OK:
+            logger.error(f'[{message}]')
             return JSONResponse(status_code=status, content={'message': message})
 
-        payment_transactions_out = [
-            PaymentTransactionOut(**self.__convert_data_entry_to_dict(payment_transaction))
-            for payment_transaction in payment_transactions
-        ]
-        return payment_transactions_out
+        payment_transaction_list = []
+        for payment_transaction in payment_transactions:
+            payment_transaction_data = self.__convert_data_entry_to_dict(payment_transaction)
+
+            try:
+                pycon_registration_out = PyconRegistrationOut(**payment_transaction_data)
+                payment_transaction_out = PaymentTransactionOut(
+                    **payment_transaction_data, registrationData=pycon_registration_out
+                )
+
+            except ValidationError as e:
+                logger.error(f'[{payment_transaction.rangeKey}] {e}, skipping this payment transaction')
+                continue
+
+            payment_transaction_list.append(payment_transaction_out)
+
+        return payment_transaction_list
 
     def payment_callback(self, payment_transaction_id: str, event_id: str):
+        """
+        Update the payment transaction status to SUCCESS and redirect to the success page
+
+        Arguments:
+            payment_transaction_id -- The ID of the payment transaction
+            event_id -- The ID of the event
+
+        Returns:
+            JSONResponse -- The response to the client
+        """
         status, payment_transaction, message = self.payment_repo.query_payment_transaction_with_payment_transaction_id(
             payment_transaction_id=payment_transaction_id, event_id=event_id
         )
         if status != HTTPStatus.OK:
+            logger.error(f'[{payment_transaction_id}] {message}')
             return JSONResponse(status_code=status, content={'message': message})
 
         success_payment_transaction_in = PaymentTransactionIn(
@@ -61,8 +126,10 @@ def payment_callback(self, payment_transaction_id: str, event_id: str):
             payment_transaction=payment_transaction, payment_transaction_in=success_payment_transaction_in
         )
         if status != HTTPStatus.OK:
+            logger.error(f'[{payment_transaction_id}] {message}')
             return JSONResponse(status_code=status, content={'message': message})
 
+        logger.info(f'Payment transaction updated for {payment_transaction_id}')
         frontend_base_url = os.getenv('FRONTEND_URL')
         redirect_url = (
             f'{frontend_base_url}/{event_id}/register?step=Success&paymentTransactionId={payment_transaction_id}'