eamco_authorize/app/routers/payment.py

## 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
    )