trade_disputes_controller.rb

[geekelo]

module Api::V1
  class P2pTrades::TradeDisputesController < Api::BaseController
    before_action :find_trade

    def index
      render json: @trade.disputes, each_serializer: P2pTradeDisputeSerializer
    end

    def create
      p2p_trade_dispute = P2pTradeDispute.new(create_service.p2p_trade_dispute_params)
      if p2p_trade_dispute.save!
        P2pApi::TradeDispute::CreateJob.perform_later(current_user.id, @trade.id, p2p_trade_dispute.id)
        render json: p2p_trade_dispute, serializer: P2pTradeDisputeSerializer
      else
        errors = if p2p_trade_dispute && ResourceErrors
                   ResourceErrors.format(p2p_trade_dispute)
                 else
                   Rails.env.production? ? 'An error occurred' : e
                 end
        render json: { errors: errors }, status: :bad_request
      end
    rescue StandardError => e
      Rails.logger.info e

      render json: { errors: e }, status: :bad_request
    end

    private

    def create_service
      P2pApi::Requests::TradeDispute::CreateService.new(
        user: current_user,
        trade: @trade
      )
    end

    def find_trade
      @trade = P2pTrade.find_by(id: params[:trade_id])
      @trade if allow_trade_access
    end

    def allow_trade_access
      @trade&.user == current_user || @trade&.offer_user == current_user
    end
  end
end

[geekelo]

The P2pTrades::TradeDisputesController manages disputes related to P2P trades. Here’s a detailed overview of its functionality:

P2pTrades::TradeDisputesController Overview

• Namespace: Api::V1
• Base Class: Api::BaseController
• Before Action: find_trade

Actions

• index

  • Purpose: Retrieves and renders all disputes related to a specific trade.
  • Implementation: Uses the @trade.disputes association and renders it using the P2pTradeDisputeSerializer.

• create

  • Purpose: Creates a new dispute for the trade and triggers an asynchronous job.
  • Implementation:
  • Initializes a new P2pTradeDispute with parameters from create_service.
  • Saves the dispute and triggers P2pApi::TradeDispute::CreateJob if successful.
  • Handles errors by formatting them or providing a generic error message based on the environment.

Private Methods

• create_service

  • Purpose: Provides an instance of P2pApi::Requests::TradeDispute::CreateService with the current user and trade.
  • Usage: Used to fetch parameters and other required data for creating a dispute.

• find_trade

  • Purpose: Finds the trade by params[:trade_id] and checks access permissions.
  • Usage: Sets the @trade instance variable if access is allowed.

• allow_trade_access

  • Purpose: Checks if the current user has access to the trade.
  • Usage: Ensures that only authorized users (either the trade’s owner or the offer user) can access the trade.

Error Handling

• Error Handling in create:
  • Catches and logs StandardError.
  • Formats errors using ResourceErrors or provides a generic message in production.
  • Logs errors and returns a bad request status in case of exceptions.

Example Usage

1. Index:

   • Request to /api/v1/p2p_trades/:trade_id/trade_disputes
   • Returns a list of disputes related to the specified trade.

2. Create:

   • Request to /api/v1/p2p_trades/:trade_id/trade_disputes with appropriate parameters.
   • Creates a dispute, triggers a job, and returns the created dispute or errors.

Summary

• Purpose: Manages disputes for P2P trades.
• Data Handling: Retrieves disputes and handles creation, including job triggering and error management.
• Security: Ensures that only authorized users can access and create disputes for trades.

If you need further details on specific parts or have additional questions, let me know!