재능넷의 결제 시스템 구현 💰

재능넷은 다양한 결제 방식을 지원해야 하는 플랫폼이에요. 카드 결제, 계좌이체, 페이팔, 가상화폐 등 여러 결제 방식을 유연하게 추가하고 관리할 수 있어야 해요. 이런 상황에서 비헤이비어가 정말 유용하게 사용될 수 있어요!

defmodule JaenungNet.PaymentProcessor do
  @moduledoc """
  재능넷의 결제 처리를 위한 비헤이비어
  """
  
  @doc """
  결제를 처리하는 콜백
  """
  @callback process_payment(amount :: integer, user_id :: integer, options :: map) ::
    {:ok, transaction_id :: String.t} | {:error, reason :: atom}
  
  @doc """
  결제를 환불하는 콜백
  """
  @callback refund_payment(transaction_id :: String.t, amount :: integer, reason :: String.t) ::
    :ok | {:error, reason :: atom}
  
  @doc """
  결제 방식이 특정 금액을 지원하는지 확인하는 콜백
  """
  @callback supports_amount?(amount :: integer) :: boolean
  
  @doc """
  결제 방식이 특정 국가를 지원하는지 확인하는 콜백
  """
  @callback supports_country?(country_code :: String.t) :: boolean
  
  # 환불은 선택적으로 구현할 수 있음
  @optional_callbacks [refund_payment: 3]
end

이제 이 비헤이비어를 구현하는 여러 결제 모듈을 만들 수 있어요:

defmodule JaenungNet.CardPaymentProcessor do
  @behaviour JaenungNet.PaymentProcessor
  
  @impl JaenungNet.PaymentProcessor
  def process_payment(amount, user_id, options) do
    # 카드 결제 처리 로직
    card_number = Map.get(options, :card_number)
    expiry_date = Map.get(options, :expiry_date)
    cvv = Map.get(options, :cvv)
    
    # 실제로는 카드 결제 API를 호출할 것
    IO.puts("Processing card payment of #{amount} for user #{user_id}")
    {:ok, "card_transaction_#{:rand.uniform(1000)}"}
  end
  
  @impl JaenungNet.PaymentProcessor
  def refund_payment(transaction_id, amount, reason) do
    # 카드 환불 처리 로직
    IO.puts("Refunding #{amount} for transaction #{transaction_id}. Reason: #{reason}")
    :ok
  end
  
  @impl JaenungNet.PaymentProcessor
  def supports_amount?(amount) do
    # 카드 결제는 모든 금액 지원
    true
  end
  
  @impl JaenungNet.PaymentProcessor
  def supports_country?(country_code) do
    # 지원하는 국가 목록
    supported_countries = ["KR", "US", "JP", "CN", "SG"]
    country_code in supported_countries
  end
end

defmodule JaenungNet.CryptoPaymentProcessor do
  @behaviour JaenungNet.PaymentProcessor
  
  @impl JaenungNet.PaymentProcessor
  def process_payment(amount, user_id, options) do
    # 가상화폐 결제 처리 로직
    crypto_type = Map.get(options, :crypto_type, "BTC")
    wallet_address = Map.get(options, :wallet_address)
    
    # 실제로는 블록체인 API를 호출할 것
    IO.puts("Processing #{crypto_type} payment of #{amount} for user #{user_id}")
    {:ok, "crypto_transaction_#{:rand.uniform(1000)}"}
  end
  
  @impl JaenungNet.PaymentProcessor
  def supports_amount?(amount) do
    # 가상화폐 결제는 최소 금액 제한이 있음
    amount >= 10000
  end
  
  @impl JaenungNet.PaymentProcessor
  def supports_country?(country_code) do
    # 일부 국가에서는 가상화폐 결제가 제한됨
    restricted_countries = ["CN", "RU"]
    country_code not in restricted_countries
  end
  
  # refund_payment는 선택적이므로 구현하지 않음
end

이제 이 결제 프로세서들을 사용하는 코드를 작성해볼까요?

defmodule JaenungNet.PaymentService do
  @moduledoc """
  재능넷의 결제 서비스
  """
  
  @doc """
  사용자의 결제를 처리합니다.
  """
  def charge_user(user_id, amount, payment_method, options \\ %{}) do
    # 사용자 정보 가져오기
    user = JaenungNet.UserRepo.get(user_id)
    country_code = user.country_code
    
    # 적절한 결제 프로세서 선택
    processor = get_payment_processor(payment_method)
    
    # 결제 가능 여부 확인
    with true <- processor.supports_amount?(amount),
         true <- processor.supports_country?(country_code),
         {:ok, transaction_id} <- processor.process_payment(amount, user_id, options) do
      # 결제 성공 처리
      JaenungNet.TransactionRepo.create(%{
        user_id: user_id,
        amount: amount,
        payment_method: payment_method,
        transaction_id: transaction_id,
        status: "completed"
      })
      
      {:ok, transaction_id}
    else
      false -> {:error, :unsupported_payment_option}
      {:error, reason} -> {:error, reason}
    end
  end
  
  @doc """
  결제를 환불합니다.
  """
  def refund_transaction(transaction_id, reason) do
    # 트랜잭션 정보 가져오기
    transaction = JaenungNet.TransactionRepo.get_by_transaction_id(transaction_id)
    
    # 적절한 결제 프로세서 선택
    processor = get_payment_processor(transaction.payment_method)
    
    # 환불 기능 지원 여부 확인
    if function_exported?(processor, :refund_payment, 3) do
      case processor.refund_payment(transaction_id, transaction.amount, reason) do
        :ok ->
          # 환불 성공 처리
          JaenungNet.TransactionRepo.update(transaction, %{status: "refunded"})
          :ok
        {:error, reason} ->
          {:error, reason}
      end
    else
      # 자동 환불을 지원하지 않는 경우 수동 환불 요청
      JaenungNet.RefundQueue.enqueue(transaction, reason)
      {:ok, :manual_refund_requested}
    end
  end
  
  # 결제 방식에 따른 프로세서 반환
  defp get_payment_processor("card"), do: JaenungNet.CardPaymentProcessor
  defp get_payment_processor("crypto"), do: JaenungNet.CryptoPaymentProcessor
  defp get_payment_processor(method), do: raise "Unsupported payment method: #{method}"
end

이렇게 비헤이비어를 활용하면 새로운 결제 방식을 추가할 때 기존 코드를 수정할 필요 없이 새로운 모듈만 추가하면 돼요! 확장성과 유지보수성이 크게 향상되죠. 😎

또한 function_exported?/3 함수를 사용해 선택적 콜백의 구현 여부를 확인하는 방법도 볼 수 있어요. 이렇게 하면 모든 결제 방식이 환불을 지원하지 않더라도 유연하게 처리할 수 있답니다! 👍