Tag: Caching

# Anti-pattern 1: Only tracking successes
def process_subscription_payment(user, amount)
  payment = stripe_service.charge(user.stripe_customer_id, amount)

  if payment.succeeded?
    user.payment_records.create!(
      amount: amount,
      status: 'success',
      stripe_payment_id: payment.id
    )
    # ❌ Failed payments are lost forever
  end

  payment
end

# Anti-pattern 2: Missing associations
def charge_customer_wallet(customer, amount, description)
  charge = create_stripe_charge(customer, amount, description)

  # ❌ Charge created but not linked to customer
  Transaction.create!(
    amount: amount,
    success: charge.succeeded?,
    stripe_data: charge.to_hash
  )

  charge
end

# app/models/payment_record.rb
class PaymentRecord < ApplicationRecord
  belongs_to :transaction
  belongs_to :payable, polymorphic: true  # Customer, Order, Subscription, etc.
end

# app/models/customer.rb  
class Customer < ApplicationRecord
  has_many :payment_records, as: :payable
  has_many :transactions, through: :payment_records

  def charge(amount_cents, description = 'Payment')
    payment_service.charge(amount_cents, description, self)
  end
end

# app/models/transaction.rb
class Transaction < ApplicationRecord
  # amount_cents: integer
  # success: boolean  
  # stripe_data: jsonb (full Stripe response)
  # stripe_payment_id: string
  # error_code: string
  # error_message: text

  scope :successful, -> { where(success: true) }
  scope :failed, -> { where(success: false) }

  def declined?
    !success && stripe_data.dig('error', 'code') == 'card_declined'
  end

  def error_type
    stripe_data.dig('error', 'type')
  end
end

# app/services/payment_service.rb
class PaymentService
  class << self
    def charge(amount_cents, description, customer)
      return create_zero_transaction if amount_cents <= 0

      success = false
      stripe_response = nil

      begin
        stripe_response = Stripe::PaymentIntent.create({
          amount: amount_cents,
          currency: 'usd',
          description: description,
          customer: customer.stripe_customer_id,
          payment_method: customer.default_payment_method_id,
          off_session: true,
          confirm: true
        })

        success = (stripe_response.status == 'succeeded')

      rescue Stripe::CardError => e
        # Declined cards, insufficient funds
        stripe_response = { error: e.json_body['error'] }

      rescue Stripe::RateLimitError => e
        # Too many requests
        stripe_response = { error: { message: 'Rate limit exceeded', type: 'rate_limit' } }

      rescue Stripe::InvalidRequestError => e
        # Bad parameters
        stripe_response = { error: e.json_body['error'] }

      rescue Stripe::AuthenticationError => e
        # Bad API key
        stripe_response = { error: { message: 'Authentication failed', type: 'authentication' } }

      rescue Stripe::APIConnectionError => e
        # Network issues
        stripe_response = { error: { message: 'Network error', type: 'api_connection' } }

      rescue StandardError => e
        # Catch-all for unexpected errors
        stripe_response = { 
          error: { 
            message: e.message, 
            type: 'unexpected_error',
            backtrace: Rails.env.development? ? e.backtrace : nil
          } 
        }
      end

      # Always create transaction record
      transaction = Transaction.create!(
        amount_cents: amount_cents,
        success: success,
        stripe_data: stripe_response.try(:to_hash) || stripe_response,
        stripe_payment_id: stripe_response.try(:id),
        error_code: success ? nil : extract_error_code(stripe_response),
        error_message: success ? nil : extract_error_message(stripe_response)
      )

      transaction
    end

    private

    def create_zero_transaction
      Transaction.create!(
        amount_cents: 0,
        success: true,
        stripe_data: { type: 'zero_amount' }
      )
    end

    def extract_error_code(response)
      response.dig('error', 'code') || response.dig('error', 'type')
    end

    def extract_error_message(response)
      response.dig('error', 'message') || 'Unknown error occurred'
    end
  end
end

# app/services/subscription_billing_service.rb
class SubscriptionBillingService
  def initialize(customer, subscription_plan)
    @customer = customer
    @subscription_plan = subscription_plan
  end

  def process_monthly_billing
    transaction = PaymentService.charge(
      @subscription_plan.price_cents,
      "Monthly subscription - #{@subscription_plan.name}",
      @customer
    )

    # Always create payment record (success OR failure)
    @customer.payment_records.create!(transaction: transaction)

    if transaction.success?
      extend_subscription
      send_receipt_email
    else
      handle_payment_failure(transaction)
    end

    transaction
  end

  private

  def handle_payment_failure(transaction)
    # Retry logic, notifications, etc.
    PaymentFailureNotificationJob.perform_later(@customer.id, transaction.id)

    case transaction.error_code
    when 'card_declined'
      @customer.update!(payment_status: 'declined')
    when 'insufficient_funds'  
      @customer.update!(payment_status: 'insufficient_funds')
    else
      @customer.update!(payment_status: 'payment_failed')
    end
  end
end

# app/models/order.rb
class Order < ApplicationRecord
  belongs_to :customer
  has_many :payment_records, as: :payable
  has_many :transactions, through: :payment_records

  def process_payment!
    transaction = PaymentService.charge(
      total_amount_cents,
      "Order ##{order_number}",
      customer
    )

    payment_records.create!(transaction: transaction)

    if transaction.success?
      update!(status: 'paid', paid_at: Time.current)
      fulfill_order
    else
      update!(status: 'payment_failed')
      cancel_inventory_hold
    end

    transaction
  end
end

# app/services/digital_product_purchase_service.rb
class DigitalProductPurchaseService
  def self.process_failed_purchase(purchase_params)
    stripe_payment = Stripe::PaymentIntent.retrieve(purchase_params[:payment_intent_id])

    transaction = Transaction.create!(
      amount_cents: purchase_params[:amount_cents],
      success: false,
      stripe_data: stripe_payment.to_hash,
      stripe_payment_id: stripe_payment.id,
      error_code: stripe_payment.last_payment_error&.code,
      error_message: stripe_payment.last_payment_error&.message
    )

    # Link to customer if email matches existing user
    if purchase_params[:customer_email].present?
      customer = Customer.find_by(email: purchase_params[:customer_email])
      customer.payment_records.create!(transaction: transaction) if customer
    end

    transaction
  end
end

{
  "id": "pi_1H7XYZabcd123456", 
  "status": "requires_payment_method",
  "last_payment_error": {
    "code": "card_declined",
    "decline_code": "insufficient_funds", 
    "message": "Your card has insufficient funds."
  }
}

# app/presenters/payment_details_presenter.rb
class PaymentDetailsPresenter
  def initialize(transaction, view_context)
    @transaction = transaction
    @view = view_context
  end

  def status_badge
    if @transaction.success?
      @view.content_tag(:span, 'SUCCESS', 
                       class: 'badge badge-success')
    else
      @view.content_tag(:span, 'FAILED', 
                       class: 'badge badge-danger')
    end
  end

  def stripe_dashboard_link
    return 'N/A' unless @transaction.stripe_payment_id

    @view.link_to(
      @view.truncate(@transaction.stripe_payment_id, length: 18),
      "https://dashboard.stripe.com/payments/#{@transaction.stripe_payment_id}",
      target: '_blank',
      class: 'btn btn-sm btn-outline-primary'
    )
  end

  def formatted_amount
    @view.number_to_currency(@transaction.amount_cents / 100.0)
  end

  def error_summary
    return 'N/A' if @transaction.success?

    error_type = @transaction.error_code&.humanize || 'Unknown'
    "#{error_type}: #{@transaction.error_message}"
  end

  def retry_action_link
    return '' if @transaction.success?

    @view.link_to('Retry Payment', 
                  @view.retry_payment_path(@transaction),
                  method: :post,
                  class: 'btn btn-sm btn-warning',
                  confirm: 'Are you sure you want to retry this payment?')
  end

  def documentation_link
    return '' if @transaction.success? || @transaction.stripe_data.dig('error', 'doc_url').blank?

    @view.link_to('View Docs', 
                  @transaction.stripe_data.dig('error', 'doc_url'),
                  target: '_blank',
                  class: 'btn btn-sm btn-info')
  end

  def receipt_link
    return '' unless @transaction.success? && 
                     @transaction.stripe_data.dig('charges', 'data', 0, 'receipt_url')

    @view.link_to('Receipt', 
                  @transaction.stripe_data.dig('charges', 'data', 0, 'receipt_url'),
                  target: '_blank',
                  class: 'btn btn-sm btn-secondary')
  end
end

# app/helpers/admin/payments_helper.rb
module Admin::PaymentsHelper
  def cached_payment_details(transaction)
    Rails.cache.fetch("payment_details_#{transaction.id}_#{transaction.updated_at.to_i}", 
                      expires_in: 1.hour) do
      presenter = PaymentDetailsPresenter.new(transaction, self)
      {
        status: presenter.status_badge,
        amount: presenter.formatted_amount,
        stripe_link: presenter.stripe_dashboard_link,
        error_summary: presenter.error_summary,
        retry_link: presenter.retry_action_link,
        docs_link: presenter.documentation_link,
        receipt_link: presenter.receipt_link,
        created_at: transaction.created_at.strftime('%m/%d/%Y %I:%M %p')
      }
    end
  end

  def payment_details_for_display(transaction)
    @payment_cache ||= {}
    @payment_cache[transaction.id] ||= cached_payment_details(transaction)
  end
end

# app/admin/customers.rb (using ActiveAdmin)
ActiveAdmin.register Customer do
  show do |customer|
    panel "Payment History" do
      if customer.payment_records.any?
        table_for customer.payment_records.includes(:transaction)
                          .order(created_at: :desc).limit(50) do
          column('Amount') { |pr| payment_details_for_display(pr.transaction)[:amount] }
          column('Status') { |pr| payment_details_for_display(pr.transaction)[:status].html_safe }
          column('Date') { |pr| payment_details_for_display(pr.transaction)[:created_at] }
          column('Stripe ID') { |pr| payment_details_for_display(pr.transaction)[:stripe_link].html_safe }
          column('Error Details') { |pr| payment_details_for_display(pr.transaction)[:error_summary] }
          column('Actions') do |pr|
            details = payment_details_for_display(pr.transaction)
            [details[:retry_link], details[:docs_link], details[:receipt_link]]
              .select(&:present?).join(' ').html_safe
          end
        end
      else
        div "No payment history found.", class: 'text-muted'
      end
    end
  end
end

# app/controllers/webhooks/stripe_controller.rb
class Webhooks::StripeController < ApplicationController
  protect_from_forgery with: :null_session
  before_action :verify_webhook_signature

  def handle_webhook
    event_type = params[:type]
    event_data = params[:data][:object]

    case event_type
    when 'payment_intent.succeeded'
      handle_successful_payment(event_data)
    when 'payment_intent.payment_failed'
      handle_failed_payment(event_data)
    when 'customer.subscription.created'
      handle_subscription_created(event_data)
    when 'invoice.payment_failed'
      handle_invoice_payment_failed(event_data)
    end

    head :ok
  end

  private

  def verify_webhook_signature
    payload = request.body.read
    signature_header = request.env['HTTP_STRIPE_SIGNATURE']
    endpoint_secret = Rails.application.credentials.stripe[:webhook_secret]

    begin
      Stripe::Webhook.construct_event(payload, signature_header, endpoint_secret)
    rescue JSON::ParserError, Stripe::SignatureVerificationError => e
      Rails.logger.error "Webhook signature verification failed: #{e.message}"
      head :bad_request and return
    end
  end

  def handle_failed_payment(payment_intent)
    transaction = Transaction.find_or_create_by(stripe_payment_id: payment_intent['id']) do |t|
      t.amount_cents = payment_intent['amount']
      t.success = false
      t.stripe_data = payment_intent
      t.error_code = payment_intent.dig('last_payment_error', 'code')
      t.error_message = payment_intent.dig('last_payment_error', 'message')
    end

    # Find and associate with customer
    if payment_intent['customer']
      customer = Customer.find_by(stripe_customer_id: payment_intent['customer'])
      customer.payment_records.find_or_create_by(transaction: transaction) if customer
    end

    # Trigger business logic
    PaymentFailureHandlerJob.perform_later(transaction.id)
  end
end

# app/services/idempotent_payment_service.rb
class IdempotentPaymentService
  def self.charge_with_idempotency(customer, amount_cents, description, idempotency_key)
    # Check if we already processed this request
    existing_transaction = Transaction.find_by(idempotency_key: idempotency_key)
    return existing_transaction if existing_transaction

    begin
      payment_intent = Stripe::PaymentIntent.create({
        amount: amount_cents,
        currency: 'usd',
        description: description,
        customer: customer.stripe_customer_id,
        idempotency_key: idempotency_key  # Stripe-level idempotency
      })

      Transaction.create!(
        amount_cents: amount_cents,
        success: payment_intent.status == 'succeeded',
        stripe_data: payment_intent.to_hash,
        stripe_payment_id: payment_intent.id,
        idempotency_key: idempotency_key  # Application-level idempotency
      )

    rescue Stripe::IdempotencyError => e
      # Stripe detected duplicate request
      Rails.logger.warn "Stripe idempotency conflict: #{e.message}"
      Transaction.find_by(idempotency_key: idempotency_key)
    end
  end
end

# app/services/resilient_payment_service.rb
class ResilientPaymentService
  MAX_RETRIES = 3
  RETRY_DELAYS = [1.second, 2.seconds, 5.seconds].freeze

  def self.charge_with_retries(customer, amount_cents, description)
    attempt = 0

    begin
      attempt += 1
      PaymentService.charge(amount_cents, description, customer)

    rescue Stripe::RateLimitError => e
      if attempt <= MAX_RETRIES
        delay = RETRY_DELAYS[attempt - 1] || 5.seconds
        Rails.logger.warn "Rate limited, retrying in #{delay}s (attempt #{attempt})"
        sleep(delay)
        retry
      else
        # Create failed transaction for rate limit exceeded
        Transaction.create!(
          amount_cents: amount_cents,
          success: false,
          stripe_data: { error: { type: 'rate_limit', message: 'Rate limit exceeded after retries' } },
          error_code: 'rate_limit_exceeded',
          error_message: 'Payment failed due to rate limiting'
        )
      end

    rescue Stripe::APIConnectionError => e
      if attempt <= MAX_RETRIES
        delay = RETRY_DELAYS[attempt - 1] || 5.seconds
        Rails.logger.warn "Network error, retrying in #{delay}s (attempt #{attempt})"
        sleep(delay)
        retry
      else
        raise e
      end
    end
  end
end

# app/services/connect_payment_service.rb
class ConnectPaymentService
  def self.charge_connected_account(platform_customer, connected_account_id, amount_cents, description)
    begin
      payment_intent = Stripe::PaymentIntent.create({
        amount: amount_cents,
        currency: 'usd',
        description: description,
        customer: platform_customer.stripe_customer_id,
        application_fee_amount: calculate_platform_fee(amount_cents),
        transfer_data: {
          destination: connected_account_id
        }
      }, {
        stripe_account: connected_account_id  # Execute on connected account
      })

      # Create transaction records for both platform and connected account
      Transaction.create!(
        amount_cents: amount_cents,
        success: payment_intent.status == 'succeeded',
        stripe_data: payment_intent.to_hash,
        stripe_payment_id: payment_intent.id,
        connected_account_id: connected_account_id,
        platform_fee_cents: calculate_platform_fee(amount_cents)
      )

    rescue Stripe::PermissionError => e
      # Connected account permissions issue
      Transaction.create!(
        amount_cents: amount_cents,
        success: false,
        stripe_data: { error: e.json_body },
        error_code: 'permission_error',
        error_message: 'Connected account permission denied'
      )
    end
  end

  private

  def self.calculate_platform_fee(amount_cents)
    # 2.9% + $0.30 platform fee
    (amount_cents * 0.029 + 30).round
  end
end

# ✅ Good: Comprehensive tracking
def process_payment(customer, amount, description)
  transaction = PaymentService.charge(amount, description, customer)
  customer.payment_records.create!(transaction: transaction)  # Always create

  if transaction.success?
    handle_successful_payment(transaction)
  else
    handle_failed_payment(transaction)
  end

  transaction
end

# ❌ Bad: Selective tracking
def process_payment(customer, amount, description)
  transaction = PaymentService.charge(amount, description, customer)

  if transaction.success?  # Only tracking successes
    customer.payment_records.create!(transaction: transaction)
    handle_successful_payment(transaction)
  end

  transaction
end

# Allows payments to be associated with any business entity
class PaymentRecord < ApplicationRecord
  belongs_to :payable, polymorphic: true  # Customer, Order, Subscription, etc.
end

# Preserve full context for debugging and analytics
Transaction.create!(
  amount_cents: amount,
  success: payment_successful?,
  stripe_data: stripe_response.to_hash,  # Complete response
  stripe_payment_id: stripe_response.id,
  error_code: extract_error_code(stripe_response),
  error_message: extract_error_message(stripe_response)
)

def payment_status_badge
  if transaction.success?
    content_tag(:span, 'SUCCESS', class: 'badge badge-success')
  else
    content_tag(:span, 'FAILED', class: 'badge badge-danger')  
  end
end

# Test both success and failure scenarios
describe 'payment processing' do
  it 'tracks successful payments' do
    expect { process_payment }.to change { customer.payment_records.count }.by(1)
    expect(customer.transactions.last.success?).to be true
  end

  it 'tracks failed payments' do
    stub_payment_failure
    expect { process_payment }.to change { customer.payment_records.count }.by(1)
    expect(customer.transactions.last.success?).to be false
  end
end

# Cache expensive payment details calculations
def payment_details_for_display(transaction)
  Rails.cache.fetch("payment_#{transaction.id}_#{transaction.updated_at.to_i}") do
    PaymentDetailsPresenter.new(transaction, self).to_hash
  end
end