braintree 2.10.0 → 4.26.0

data/lib/braintree/dispute.rb

@@ -0,0 +1,165 @@
+module Braintree
+  class Dispute
+    include BaseModule
+    include Braintree::Util::IdEquality
+
+    attr_reader :amount
+    attr_reader :amount_disputed
+    attr_reader :amount_won
+    attr_reader :case_number
+    # NEXT_MAJOR_VERSION Remove this attribute
+    # DEPRECATED The chargeback_protection_level attribute is deprecated in favor of protection_level
+    attr_reader :chargeback_protection_level #Deprecated
+    attr_reader :created_at
+    attr_reader :currency_iso_code
+    attr_reader :date_opened
+    attr_reader :date_won
+    attr_reader :evidence
+    attr_reader :graphql_id
+    attr_reader :id
+    attr_reader :kind
+    attr_reader :merchant_account_id
+    attr_reader :original_dispute_id
+    attr_reader :paypal_messages
+    attr_reader :pre_dispute_program
+    attr_reader :processor_comments
+    attr_reader :protection_level
+    attr_reader :reason
+    attr_reader :reason_code
+    attr_reader :reason_description
+    attr_reader :received_date
+    attr_reader :reference_number
+    attr_reader :reply_by_date
+    attr_reader :status
+    attr_reader :status_history
+    attr_reader :transaction
+    attr_reader :transaction_details
+    attr_reader :updated_at
+
+    module Status
+      Accepted = "accepted"
+      AutoAccepted = "auto_accepted"
+      Disputed = "disputed"
+      Expired = "expired"
+      Open = "open"
+      Lost = "lost"
+      UnderReview = "under_review"
+      Won = "won"
+
+      All = constants.map { |c| const_get(c) }
+    end
+
+    module Reason
+      CancelledRecurringTransaction = "cancelled_recurring_transaction"
+      CreditNotProcessed = "credit_not_processed"
+      Duplicate = "duplicate"
+      Fraud = "fraud"
+      General = "general"
+      InvalidAccount = "invalid_account"
+      NotRecognized = "not_recognized"
+      ProductNotReceived = "product_not_received"
+      ProductUnsatisfactory = "product_unsatisfactory"
+      TransactionAmountDiffers = "transaction_amount_differs"
+      Retrieval = "retrieval"
+
+      All = constants.map { |c| const_get(c) }
+    end
+
+    module Kind
+      Chargeback = "chargeback"
+      PreArbitration = "pre_arbitration"
+      Retrieval = "retrieval"
+
+      All = constants.map { |c| const_get(c) }
+    end
+
+    module ChargebackProtectionLevel
+      Effortless = "effortless"
+      Standard = "standard"
+      NotProtected = "not_protected"
+
+      All = constants.map { |c| const_get(c) }
+    end
+
+    module ProtectionLevel
+      EffortlessCBP = "Effortless Chargeback Protection tool"
+      StandardCBP = "Chargeback Protection tool"
+      NoProtection = "No Protection"
+
+      All = constants.map { |c| const_get(c) }
+    end
+
+    module PreDisputeProgram
+      None = "none"
+      VisaRdr = "visa_rdr"
+
+      All = constants.map { |c| const_get(c) }
+    end
+
+    class << self
+      protected :new
+      def _new(*args)
+        self.new(*args)
+      end
+    end
+
+    def self.accept(*args)
+      Configuration.gateway.dispute.accept(*args)
+    end
+
+    def self.add_file_evidence(*args)
+      Configuration.gateway.dispute.add_file_evidence(*args)
+    end
+
+    def self.add_text_evidence(*args)
+      Configuration.gateway.dispute.add_text_evidence(*args)
+    end
+
+    def self.finalize(*args)
+      Configuration.gateway.dispute.finalize(*args)
+    end
+
+    def self.find(*args)
+      Configuration.gateway.dispute.find(*args)
+    end
+
+    def self.remove_evidence(*args)
+      Configuration.gateway.dispute.remove_evidence(*args)
+    end
+
+    def self.search(&block)
+      Configuration.gateway.dispute.search(&block)
+    end
+
+    def initialize(attributes)
+      set_instance_variables_from_hash(attributes)
+      @date_opened = Date.parse(date_opened) unless date_opened.nil?
+      @date_won = Date.parse(date_won) unless date_won.nil?
+      @received_date = Date.parse(received_date)
+      @reply_by_date = Date.parse(reply_by_date) unless reply_by_date.nil?
+      @amount = Util.to_big_decimal(amount)
+      @amount_disputed = Util.to_big_decimal(amount_disputed)
+      @amount_won = Util.to_big_decimal(amount_won)
+      if (ChargebackProtectionLevel::All - [ChargebackProtectionLevel::NotProtected]).include?(chargeback_protection_level)
+        @protection_level = Dispute.const_get("ProtectionLevel::#{chargeback_protection_level.capitalize}CBP")
+      else
+        @protection_level = ProtectionLevel::NoProtection
+      end
+
+      @evidence = evidence.map do |record|
+        Braintree::Dispute::Evidence.new(record)
+      end unless evidence.nil?
+
+      @paypal_messages = paypal_messages.map do |record|
+        Braintree::Dispute::PayPalMessage.new(record)
+      end unless paypal_messages.nil?
+
+      @transaction_details = TransactionDetails.new(transaction)
+      @transaction = Transaction.new(transaction)
+
+      @status_history = status_history.map do |event|
+        Braintree::Dispute::StatusHistory.new(event)
+      end unless status_history.nil?
+    end
+  end
+end

data/lib/braintree/dispute_gateway.rb

@@ -0,0 +1,142 @@
+module Braintree
+  class DisputeGateway
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+      @config.assert_has_access_token_or_keys
+    end
+
+    def accept(dispute_id)
+      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
+
+      response = @config.http.put("#{@config.base_merchant_path}/disputes/#{dispute_id}/accept")
+      if response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        SuccessfulResult.new
+      end
+    rescue NotFoundError
+      raise NotFoundError, "dispute with id #{dispute_id} not found"
+    end
+
+    def add_file_evidence(dispute_id, document_id_or_request)
+      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
+      raise ArgumentError, "document_id_or_request cannot be blank" if document_id_or_request.nil?
+
+      request = document_id_or_request.is_a?(Hash) ? document_id_or_request : {document_id: document_id_or_request}
+
+      raise ArgumentError, "document_id contains invalid characters" unless request[:document_id].to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "document_id cannot be blank" if request[:document_id].nil? || dispute_id.to_s.strip == ""
+      raise ArgumentError, "category must be a string" if request[:category] && !request[:category].is_a?(String)
+
+      params = {
+        evidence: {
+          document_upload_id: request[:document_id],
+          category: request[:category],
+        }
+      }
+      response = @config.http.post("#{@config.base_merchant_path}/disputes/#{dispute_id}/evidence", params)
+
+      if response[:evidence]
+        SuccessfulResult.new(:evidence => Dispute::Evidence.new(response[:evidence]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise "expected :evidence or :api_error_response"
+      end
+    rescue NotFoundError
+      raise NotFoundError, "dispute with id #{dispute_id} not found"
+    end
+
+    def add_text_evidence(dispute_id, content_or_request)
+      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
+      raise ArgumentError, "content_or_request cannot be blank" if content_or_request.nil?
+
+      request = content_or_request.is_a?(String) ? {content: content_or_request} : content_or_request
+
+      raise ArgumentError, "content cannot be blank" if request[:content].nil? || request[:content].to_s.strip == ""
+      raise ArgumentError, "request can only contain the keys [:content, :category, :sequence_number]" if (request.keys - [:category, :content, :sequence_number]).any?
+      raise ArgumentError, "sequence_number must be an integer" if request[:sequence_number] && request[:sequence_number].to_s.match(/\D/)
+      raise ArgumentError, "category must be a string" if request[:category] && !request[:category].is_a?(String)
+
+      params_for_http_post = {
+        evidence: {
+          comments: request[:content]
+        }.tap do |evidence_params|
+          evidence_params[:category] = request[:category] if request[:category]
+          evidence_params[:sequence_number] = request[:sequence_number] if request[:sequence_number]
+        end
+      }
+      response = @config.http.post("#{@config.base_merchant_path}/disputes/#{dispute_id}/evidence", params_for_http_post)
+
+      if response[:evidence]
+        SuccessfulResult.new(:evidence => Dispute::Evidence.new(response[:evidence]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise "expected :evidence or :api_error_response"
+      end
+    rescue NotFoundError
+      raise NotFoundError, "dispute with id #{dispute_id} not found"
+    end
+
+    def finalize(dispute_id)
+      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
+
+      response = @config.http.put("#{@config.base_merchant_path}/disputes/#{dispute_id}/finalize")
+      if response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        SuccessfulResult.new
+      end
+    rescue NotFoundError
+      raise NotFoundError, "dispute with id #{dispute_id} not found"
+    end
+
+    def find(dispute_id)
+      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
+      response = @config.http.get("#{@config.base_merchant_path}/disputes/#{dispute_id}")
+      Dispute._new(response[:dispute])
+    rescue NotFoundError
+      raise NotFoundError, "dispute with id #{dispute_id} not found"
+    end
+
+    def remove_evidence(dispute_id, evidence_id)
+      raise ArgumentError, "dispute_id contains invalid characters" unless dispute_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "dispute_id cannot be blank" if dispute_id.nil? || dispute_id.to_s.strip == ""
+      raise ArgumentError, "evidence_id contains invalid characters" unless evidence_id.to_s =~ /\A[\w-]+\z/
+      raise ArgumentError, "evidence_id cannot be blank" if evidence_id.nil? || evidence_id.to_s.strip == ""
+
+      response = @config.http.delete("#{@config.base_merchant_path}/disputes/#{dispute_id}/evidence/#{evidence_id}")
+
+      if response.respond_to?(:to_hash) && response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        SuccessfulResult.new
+      end
+    rescue NotFoundError
+      raise NotFoundError, "evidence with id #{evidence_id} for dispute with id #{dispute_id} not found"
+    end
+
+    def search(&block)
+      search = DisputeSearch.new
+      block.call(search) if block
+
+      paginated_results = PaginatedCollection.new { |page| _fetch_disputes(search, page) }
+      SuccessfulResult.new(:disputes => paginated_results)
+    end
+
+    def _fetch_disputes(search, page)
+      response = @config.http.post("#{@config.base_merchant_path}/disputes/advanced_search?page=#{page}", {:search => search.to_hash, :page => page})
+      body = response[:disputes]
+      disputes = Util.extract_attribute_as_array(body, :dispute).map { |d| Dispute._new(d) }
+
+      PaginatedResult.new(body[:total_items], body[:page_size], disputes)
+    end
+  end
+end

data/lib/braintree/dispute_search.rb

@@ -0,0 +1,31 @@
+module Braintree
+  class DisputeSearch < AdvancedSearch
+    text_fields(
+      :case_number,
+      :customer_id,
+      :id,
+      :reference_number,
+      :transaction_id,
+    )
+    # NEXT_MAJOR_VERSION Remove this attribute
+    # DEPRECATED The chargeback_protection_level attribute is deprecated in favor of protection_level
+    multiple_value_field :chargeback_protection_level, :allows => Dispute::ChargebackProtectionLevel::All
+    multiple_value_field :protection_level, :allows => Dispute::ProtectionLevel::All
+    multiple_value_field :kind, :allows => Dispute::Kind::All
+    multiple_value_field :merchant_account_id
+    multiple_value_field :pre_dispute_program, :allows => Dispute::PreDisputeProgram::All
+    multiple_value_field :reason, :allows => Dispute::Reason::All
+    multiple_value_field :reason_code
+    multiple_value_field :status, :allows => Dispute::Status::All
+    multiple_value_field :transaction_source
+
+    range_fields(
+      :amount_disputed,
+      :amount_won,
+      :disbursement_date,
+      :effective_date,
+      :received_date,
+      :reply_by_date,
+    )
+  end
+end

data/lib/braintree/document_upload.rb

@@ -0,0 +1,37 @@
+module Braintree
+  class DocumentUpload
+    include BaseModule
+    include Braintree::Util::IdEquality
+
+    module Kind
+      IdentityDocument          = "identity_document"
+      EvidenceDocument          = "evidence_document"
+      PayoutInvoiceDocument     = "payout_invoice_document"
+    end
+
+    attr_reader :content_type
+    attr_reader :id
+    attr_reader :kind
+    attr_reader :name
+    attr_reader :size
+
+    def self.create(*args)
+      Configuration.gateway.document_upload.create(*args)
+    end
+
+    def self.create!(*args)
+      Configuration.gateway.document_upload.create!(*args)
+    end
+
+    def initialize(attributes)
+      set_instance_variables_from_hash(attributes)
+    end
+
+    class << self
+      protected :new
+      def _new(*args)
+        self.new(*args)
+      end
+    end
+  end
+end

data/lib/braintree/document_upload_gateway.rb

@@ -0,0 +1,38 @@
+module Braintree
+  class DocumentUploadGateway
+    include BaseModule
+
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+      @config.assert_has_access_token_or_keys
+    end
+
+    def create(attributes)
+      Util.verify_keys(DocumentUploadGateway._create_signature, attributes)
+      _do_create "/document_uploads", {"document_upload[kind]" => attributes[:kind]}, attributes[:file]
+    end
+
+    def create!(*args)
+      return_object_or_raise(:document_upload) { create(*args) }
+    end
+
+    def self._create_signature
+      [
+        :kind,
+        :file
+      ]
+    end
+
+    def _do_create(path, params, file)
+      response = @config.http.post("#{@config.base_merchant_path}#{path}", params, file)
+      if response[:document_upload]
+        SuccessfulResult.new(:document_upload => DocumentUpload._new(response[:document_upload]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :document_upload or :api_error_response"
+      end
+    end
+  end
+end

data/lib/braintree/enriched_customer_data.rb

@@ -0,0 +1,21 @@
+module Braintree
+  class EnrichedCustomerData
+    include BaseModule
+
+    attr_reader :fields_updated
+    attr_reader :profile_data
+
+    def initialize(attributes)
+      set_instance_variables_from_hash(attributes)
+      @profile_data = VenmoProfileData._new(attributes[:profile_data])
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args)
+      self.new(*args)
+    end
+  end
+end