## File: your_app/views.py from fastapi import APIRouter, Depends, HTTPException from sqlalchemy.orm import Session from typing import Tuple, Optional import enum from .. import crud, models, schemas, database from ..services import payment_service import logging AuthNetResponse = object router = APIRouter( prefix="/payments", tags=["Payments & Transactions"], ) class TransactionStatus(enum.IntEnum): APPROVED = 0 DECLINED = 1 class TransactionType(enum.IntEnum): CHARGE = 0 AUTHORIZE = 1 CAPTURE = 3 # --- NEW CIM CORE FUNCTIONS --- STATE_ID_TO_ABBREVIATION = { 0: "MA", 1: "RI", 2: "NH", 3: "ME", 4: "VT", 5: "CT", 6: "NY" } # This helper function is perfect, keep it. def _parse_authnet_response(response: Optional[AuthNetResponse]) -> Tuple[TransactionStatus, Optional[str], Optional[str]]: # ... (Your existing _parse_authnet_response function code) ... if response is not None and hasattr(response, 'messages') and response.messages.resultCode == "Ok": status = TransactionStatus.APPROVED auth_net_transaction_id = str(response.transactionResponse.transId) if hasattr(response, 'transactionResponse') and response.transactionResponse.transId else None rejection_reason = None else: status = TransactionStatus.DECLINED auth_net_transaction_id = None rejection_reason = "Payment declined by gateway." if response is not None: if hasattr(response, 'transactionResponse') and response.transactionResponse and hasattr(response.transactionResponse, 'errors') and response.transactionResponse.errors: error = response.transactionResponse.errors[0] rejection_reason = f"{error.errorCode.text}: {error.errorText.text}" elif hasattr(response, 'messages') and response.messages and hasattr(response.messages, 'message') and response.messages.message: msg = response.messages.message[0] rejection_reason = f"{msg.code.text}: {msg.text.text}" return status, auth_net_transaction_id, rejection_reason @router.post("/customers/{customer_id}/cards", response_model=schemas.CustomerCardResponse, summary="Add a new payment card for a customer") def add_card_to_customer(customer_id: int, card_info: schemas.CardCreate, db: Session = Depends(database.get_db)): """ Adds a new credit card to a customer. - If the customer doesn't have an Authorize.Net profile, it creates one. - If they do, it adds a new payment method to their existing profile. """ db_customer = crud.get_customer(db, customer_id=customer_id) if not db_customer: raise HTTPException(status_code=404, detail="Customer not found") # We still need this schema for the payment service call customer_schema = schemas.Customer.from_orm(db_customer) payment_profile_id = None try: # This part now works because the service hard-codes the state to "MA" if not db_customer.auth_net_profile_id: profile_id, payment_id = payment_service.create_customer_profile( customer=customer_schema, card_info=card_info ) crud.update_customer_auth_net_profile_id(db, customer_id=customer_id, profile_id=profile_id) payment_profile_id = payment_id else: payment_profile_id = payment_service.add_payment_profile_to_customer( customer_profile_id=db_customer.auth_net_profile_id, customer=customer_schema, card_info=card_info ) # This creates the card in our local database new_card = crud.create_customer_card( db=db, customer_id=customer_id, card_info=card_info, payment_profile_id=payment_profile_id ) # ========= THIS IS THE FIX FOR THE FRONTEND ========= # 1. Convert the newly created card object into a Pydantic model, then a dictionary. # Make sure your schemas.Card uses `user_id` to match your model. response_data = schemas.Card.from_orm(new_card).model_dump() # 2. Manually add the 'customer_state' field that the frontend needs. response_data['customer_state'] = "MA" # 3. Return the complete dictionary. FastAPI validates it against CustomerCardResponse # and sends it to the frontend. return response_data except ValueError as e: # This will catch errors from the payment service raise HTTPException(status_code=400, detail=str(e)) except Exception as e: # This will catch any other unexpected errors, like from the database logger.error(f"An unexpected error occurred: {e}") raise HTTPException(status_code=500, detail="An internal server error occurred.") @router.post("/charge/saved-card/{customer_id}", response_model=schemas.Transaction, summary="Charge a customer using a saved card") def charge_saved_card(customer_id: int, transaction_req: schemas.TransactionCreateByCardID, db: Session = Depends(database.get_db)): db_customer = crud.get_customer(db, customer_id=customer_id) db_card = crud.get_card_by_id(db, card_id=transaction_req.card_id) if not db_customer or not db_card or db_card.customer_id != customer_id: raise HTTPException(status_code=404, detail="Customer or card not found for this account") if not db_customer.auth_net_profile_id or not db_card.auth_net_payment_profile_id: raise HTTPException(status_code=400, detail="Payment profile is not set up correctly for this customer/card") auth_net_response = payment_service.charge_customer_profile( customer_profile_id=db_customer.auth_net_profile_id, payment_profile_id=db_card.auth_net_payment_profile_id, transaction_req=transaction_req ) status, auth_net_transaction_id, rejection_reason = _parse_authnet_response(auth_net_response) transaction_data = schemas.TransactionBase( charge_amount=transaction_req.charge_amount, transaction_type=TransactionType.CHARGE, service_id=transaction_req.service_id, delivery_id=transaction_req.delivery_id, card_id=transaction_req.card_id, rejection_reason=rejection_reason ) return crud.create_transaction(db=db, transaction=transaction_data, customer_id=customer_id, status=status, auth_net_transaction_id=auth_net_transaction_id) @router.post("/authorize/saved-card/{customer_id}", response_model=schemas.Transaction, summary="Authorize a payment on a saved card") def authorize_saved_card(customer_id: int, transaction_req: schemas.TransactionAuthorizeByCardID, db: Session = Depends(database.get_db)): """ Creates a pre-authorization on a customer's saved card. This validates the card and reserves the funds. """ db_customer = crud.get_customer(db, customer_id=customer_id) db_card = crud.get_card_by_id(db, card_id=transaction_req.card_id) if not db_customer or not db_card or db_card.user_id != customer_id: raise HTTPException(status_code=404, detail="Customer or card not found for this account") if not db_customer.auth_net_profile_id or not db_card.auth_net_payment_profile_id: raise HTTPException(status_code=400, detail="Payment profile is not set up correctly for this customer/card") # Call the NEW service function for authorization auth_net_response = payment_service.authorize_customer_profile( customer_profile_id=db_customer.auth_net_profile_id, payment_profile_id=db_card.auth_net_payment_profile_id, transaction_req=transaction_req ) status, auth_net_transaction_id, rejection_reason = _parse_authnet_response(auth_net_response) # Create the transaction record in your database with the correct type transaction_data = schemas.TransactionBase( preauthorize_amount=transaction_req.preauthorize_amount, transaction_type=TransactionType.AUTHORIZE, # This is key service_id=transaction_req.service_id, delivery_id=transaction_req.delivery_id, card_id=transaction_req.card_id, rejection_reason=rejection_reason ) return crud.create_transaction( db=db, transaction=transaction_data, customer_id=customer_id, status=status, auth_net_transaction_id=auth_net_transaction_id ) # --- YOUR EXISTING CAPTURE ENDPOINT NEEDS NO CHANGES --- @router.post("/capture/", response_model=schemas.Transaction, summary="Capture a previously authorized amount") def capture_authorized_amount(transaction: schemas.TransactionCapture, db: Session = Depends(database.get_db)): # This endpoint continues to work perfectly. # It finds the original transaction by its ID and captures the funds. auth_transaction = crud.get_transaction_by_auth_id(db, auth_net_transaction_id=transaction.auth_net_transaction_id) if not auth_transaction: raise HTTPException(status_code=404, detail="Authorization transaction not found") # ... The rest of your existing capture logic remains the same ... auth_net_response = payment_service.capture_authorized_transaction(transaction) status, _, rejection_reason = _parse_authnet_response(auth_net_response) # The capture response doesn't return a new ID # Use your existing CRUD function to update the transaction return crud.update_transaction_for_capture( db=db, auth_net_transaction_id=transaction.auth_net_transaction_id, charge_amount=transaction.charge_amount, status=status, rejection_reason=rejection_reason )