Billing Refund Requests

CREATE TABLE billing_refund_requests (
  id BIGINT PRIMARY KEY,
  billing_payment_id BIGINT NOT NULL,
  status VARCHAR DEFAULT 'PENDING' NOT NULL,
  created_by_user_id BIGINT NOT NULL,
  reason TEXT,
  processed_at TIMESTAMP,
  created_at TIMESTAMP NOT NULL,
  updated_at TIMESTAMP NOT NULL
);

-- Indexes
CREATE INDEX idx_billing_refund_requests_status ON billing_refund_requests(status);
CREATE INDEX idx_billing_refund_requests_payment_status ON billing_refund_requests(billing_payment_id, status);

curl -X POST "https://api.kulcare.com/billing_payments/123/refund_request" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "reason": "Patient cancelled appointment due to emergency"
  }'

{
  "success": true,
  "message": "Refund request created successfully",
  "type": "create",
  "data": {
    "id": 456,
    "status": "PENDING",
    "reason": "Patient cancelled appointment due to emergency",
    "processed_at": null,
    "created_at": "2025-09-10T12:30:00Z",
    "updated_at": "2025-09-10T12:30:00Z",
    "billing_payment": {
      "id": 123,
      "razorpay_payment_id": "pay_abc123xyz",
      "amount": 500.0,
      "created_at": "2025-09-10T10:15:00Z"
    }
  }
}

// Payment not found
{
  "success": false,
  "errors": [
        {
            "source": "billing_payment",
            "title": "Billing Payment not found"
        }
    ]
}

// Payment not captured
{
  "success": false,
  "errors": [
        {
            "source": "billing_payment",
            "title": "Billing Payment is not captures"
        }
    ]
}

// Payment already refunded
{
  "success": false,
  "errors": [
        {
            "source": "billing_payment",
            "title": "Billing Payment is already refunded"
        }
    ]
}

// Refund request already exists
{
  "success": false,
  "errors": [
        {
            "source": "refund_request",
            "title": "Refund request already exists for this payment"
        }
    ]
}

// Validation errors
{
  "success": false,
  "errors": {
    "reason": ["can't be blank", "is too long (maximum is 500 characters)"]
  }
}

# Status transition methods
refund_request.approve!    # Sets status to APPROVED, processed_at to current time
refund_request.reject!     # Sets status to REJECTED, processed_at to current time
refund_request.mark_processed!  # Sets status to PROCESSED, processed_at to current time

def refund_request?
  user.user_accounts.clinic_accounts&.owner&.present?
end

class SlackRefundRequestNotification < ActiveJob::Base
  queue_as :slack_notifications
  retry_on StandardError, wait: :exponentially_longer, attempts: 3
end

# BillingPayment model
has_one :billing_refund_request

# BillingRefundRequest model
belongs_to :billing_payment
belongs_to :created_by_user, class_name: 'User'

{
  "payment_status": "captured",
  "billing_refund_request": {
    "id": 456,
    "status": "PENDING",
    "reason": "Patient cancelled appointment",
    "processed_at": null,
    "created_at": "2025-09-10T12:30:00Z"
  }
}

# Optimized query pattern
base_query = BillingPayment
              .joins(:telemedicine_order)
              .where(conditions)

paginated_payments = base_query.paginate(page: page, per_page: per_page)

payments_with_associations = BillingPayment
                              .where(id: paginated_payments.pluck(:id))
                              .includes(:billing_refund_request, ...)

RSpec.describe BillingPayments::SaveRefundRequest do
  it "creates refund request for valid payment" do
    payment = create(:billing_payment, status: 'captured')

    result = described_class.call(
      id: payment.id,
      reason: "Patient cancelled"
    )

    expect(result).to be_success
    expect(result.refund_request.status).to eq('PENDING')
  end

  it "fails for already refunded payment" do
    payment = create(:billing_payment, status: 'captured')
    create(:billing_refund, billing_payment: payment)

    result = described_class.call(id: payment.id, reason: "Test")

    expect(result).to be_failure
    expect(result.errors['billing_payment']).to include('is already refunded')
  end
end

RSpec.describe "POST /billing_payments/:id/refund_request" do
  it "creates refund request successfully" do
    payment = create(:billing_payment, status: 'captured')

    post "/billing_payments/#{payment.id}/refund_request",
         params: { reason: "Emergency cancellation" },
         headers: auth_headers

    expect(response).to have_http_status(:success)
    expect(json_response['data']['status']).to eq('PENDING')
  end
end