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 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_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

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 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 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_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_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_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 message_from_authorization has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def message_from_authorization(response)
        if response[:success]
          return SUCCESS_MESSAGE
        else
          return CARD_CODE_MESSAGES[response[:szCVV2ResponseCode]] if CARD_CODE_ERRORS.include?(response[:szCVV2ResponseCode])

• 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_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_3dsecure_params has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def add_3dsecure_params(post, options)
        post[:xid] = options[:xid] unless empty?(options[:xid])
        post[:cavv] = options[:cavv] unless empty?(options[:cavv])
        post[:ucaf_collection_ind] = options[:ucaf_collection_ind] unless empty?(options[:ucaf_collection_ind])
        post[:ucaf_auth_data] = options[:ucaf_auth_data] unless empty?(options[:ucaf_auth_data])

• 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 stored_credential_usage has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

      def stored_credential_usage(post, payment_method, options)
        return unless payment_method.brand == 'visa'

        stored_credential = options[:stored_credential]
        if stored_credential[:reason_type] == 'unscheduled'

• Read up
  Read up

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

Open

      def add_stored_credential(xml, options)
        network_transaction_id = options.dig(:stored_credential, :network_transaction_id)
        case
        when network_transaction_id.nil?
          return

• Read up
  Read up