Method success_from has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def success_from(action, response, options)
        if %w[RedirectShopper ChallengeShopper].include?(response.dig('resultCode')) && !options[:execute_threed] && (!options[:threed_dynamic] || options[:ignore_threed_dynamic])
          response['refusalReason'] = 'Received unexpected 3DS authentication response, but a 3DS initiation flag was not included in the request.'
          return false
        end

• Read up
  Read up

Method add_level_two_and_three_data has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_level_two_and_three_data(xml, amount, data)
        xml.invoiceReferenceNumber data[:invoice_reference_number] if data.include?(:invoice_reference_number)
        xml.customerReference data[:customer_reference] if data.include?(:customer_reference)
        xml.cardAcceptorTaxId data[:card_acceptor_tax_id] if data.include?(:card_acceptor_tax_id)
        {

• Read up
  Read up

Method add_surcharge_fields has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_surcharge_fields(xml, options)
        surcharge = options[:surcharge] if options[:surcharge]
        if surcharge.is_a?(Hash)
          xml.surcharge do
            xml.amount(amount(surcharge[:amount].to_i)) if surcharge[:amount]

• Read up
  Read up

Method capture has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def capture(money, authorization, options = {})
        authorization = order_id_from_authorization(authorization.to_s)
        MultiResponse.run do |r|
          r.process { inquire_request(authorization, options, 'AUTHORISED', 'CAPTURED') } unless options[:authorization_validated]
          if r.params

• Read up
  Read up

Method add_recurring_processing_model has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_recurring_processing_model(post, options)
        return unless options.dig(:stored_credential, :reason_type) || options[:recurring_processing_model]

        if options.dig(:stored_credential, :reason_type) == 'unscheduled'
          if options.dig(:stored_credential, :initiator) == 'merchant'

• Read up
  Read up

Method build_transaction_search has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def build_transaction_search(options)
        currency_code = options[:currency_code]
        currency_code ||= currency(options[:amount]) if options[:amount]
        transaction_search_optional_fields = %w{ Payer ReceiptID Receiver
                                                 TransactionID InvoiceID CardNumber

• Read up
  Read up

Method add_payment has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_payment(xml, payment)
        return unless payment

        if payment.is_a? String
          token = payment

• Read up
  Read up

Method add_additional_data has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_additional_data(post, options)
        post[:ponumber] = options[:po_number]
        post[:taxamnt] = options[:tax_amount] if options[:tax_amount]
        post[:frtamnt] = options[:freight_amount] if options[:freight_amount]
        post[:dutyamnt] = options[:duty_amount] if options[:duty_amount]

• Read up
  Read up

Method add_recurring_fields has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_recurring_fields(post, options)
        return unless options[:recurring_fields].is_a?(Hash)

        options[:recurring_fields].each do |key, value|
          if value == true

• Read up
  Read up

Method add_line_items has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_line_items(post, options)
        return unless options[:line_items].is_a?(Array)

        options[:line_items].each_with_index do |line_item, index|
          %w(product_ref_num sku qty name description taxable tax_rate tax_amount commodity_code discount_rate discount_amount).each do |key|

• Read up
  Read up

Method build_credit_request has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def build_credit_request(transaction_type, money, transaction_id, card, token, options)

Method add_passengers has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_passengers(airline_options)
        passengers = []
        airline_options[:passengers]&.each do |flyer|
          passenger = {}
          passenger['firstName'] = flyer[:first_name] if flyer[:first_name]

• Read up
  Read up

Method add_address has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_address(post, options)
        billing_address = options[:billing_address] || options[:address]
        if billing_address
          post[:address] = billing_address[:address1]
          post[:city] = billing_address[:city]

• Read up
  Read up

Method add_creditcard has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_creditcard(post, creditcard)
        post[:CARDFULLNAME]     = creditcard ? creditcard.name : ''
        post[:CARDCODE]         = creditcard ? creditcard.number : ''
        post[:CARDVALIDITYDATE] = creditcard ? '%02d-%02s' % [creditcard.month, creditcard.year.to_s[-2..-1]] : ''
        post[:CARDCVV]          = creditcard ? creditcard.verification_value : ''

• Read up
  Read up

Method build_xml_request has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def build_xml_request(transaction_type, options = {}, transaction_id = nil, &block)
        xml = Builder::XmlMarkup.new
        xml.tag! 'JetPay', 'Version' => API_VERSION do
          # Basic values needed for any request
          xml.tag! 'TerminalID', @options[:login]

• Read up
  Read up

Method add_stored_credential has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_stored_credential(post, options)
        return unless stored_credential = options[:stored_credential]

        post[:cof] = stored_credential[:initiator] == 'merchant' ? 'M' : 'C'
        post[:cofscheduled] = SCHEDULED_PAYMENT_TYPES.include?(stored_credential[:reason_type]) ? 'Y' : 'N'

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

              card[:fallback_reason] = 'no_chip' if creditcard.read_method == 'fallback_no_chip'

Method add_payment_method has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_payment_method(post, payment_method, options)
        if payment_method.is_a?(String)
          customer_vault_id, = split_authorization(payment_method)
          post[:customer_vault_id] = customer_vault_id
        elsif payment_method.is_a?(NetworkTokenizationCreditCard)

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

              card[:read_method] = 'contactless_magstripe_mode' if creditcard.read_method == 'contactless_magstripe'

Method message_from has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def message_from(success, response)
        return response['status'] if success
        return response['message'] if response['message']

        message = nil

• Read up
  Read up