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

Open

        def self.create_line_items_from_params(line_items, order)
          return {} unless line_items

          line_items.each do |line_item|
            adjustments = line_item.delete(:adjustments_attributes)

• Read up
  Read up

Consider simplifying this complex logical expression.

Open

      if value.is_a?(FalseClass) ||
          value.nil? ||
          value == 0 ||
          value&.to_s =~ /^(f|false|0)$/i ||
          (value.respond_to?(:empty?) && value.empty?)

Method process_spree_xhr_action has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def process_spree_xhr_action(action, parameters = nil, session = nil, flash = nil, method = :get)

Method create_refunds has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def create_refunds(reimbursement, payments, unpaid_amount, simulate, reimbursement_list = [])

Method process_spree_action has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

      def process_spree_action(action, parameters = nil, session = nil, flash = nil, method = 'GET')

Method eligible? has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

        def eligible?(order, options = {})
          @user = order.try(:user) || options[:user]
          @email = order.email
          @store = order.store

• Read up
  Read up

Method og_meta_data has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def og_meta_data
      og_meta = {}

      if object.is_a? Spree::Product
        image                             = default_image_for_product_or_variant(object)

• Read up
  Read up

Method remove_item has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def remove_item(shipment:, variant:, quantity:)
        result = remove_item_service.call(order: shipment.order,
                                          variant: variant,
                                          quantity: quantity,
                                          options: { shipment: shipment })

• Read up
  Read up

Method validate has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def validate(line_item)
        unit_count = line_item.inventory_units.reject(&:pending?).sum(&:quantity)
        return if unit_count >= line_item.quantity

        quantity = line_item.quantity - unit_count

• Read up
  Read up

Method validate_source has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def validate_source
      if source && !source.valid?
        source.errors.map { |error| { field: error.attribute, message: error&.message } }.each do |err|
          next if err[:field].blank? || err[:message].blank?

• Read up
  Read up

Method update_or_create_address has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def update_or_create_address(attributes = {})
        return if attributes.blank?

        attributes.transform_values! { |v| v == '' ? nil : v }
        attributes = attributes.to_h.symbolize_keys

• Read up
  Read up

Method copy_price has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def copy_price
      if variant
        update_price if price.nil?
        self.cost_price = variant.cost_price if cost_price.nil?
        self.currency = variant.currency if currency.nil?

• Read up
  Read up

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

Open

    def capture(amount, authorization_code, order_currency, options = {})
      return false unless authorize(amount, order_currency, action_authorization_code: authorization_code)

      if amount <= amount_authorized
        if currency != order_currency

• Read up
  Read up

Method default_image_for_product_or_variant has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def default_image_for_product_or_variant(product_or_variant)
      Rails.cache.fetch("spree/default-image/#{product_or_variant.cache_key_with_version}") do
        if product_or_variant.is_a?(Spree::Product)
          default_image_for_product(product_or_variant)
        elsif product_or_variant.is_a?(Spree::Variant)

• Read up
  Read up

Method change has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  def change
    if Spree.user_class.present?
      users_table_name = Spree.user_class.table_name
      add_column users_table_name, :first_name, :string unless column_exists?(users_table_name, :first_name)
      add_column users_table_name, :last_name, :string unless column_exists?(users_table_name, :last_name)

• Read up
  Read up

Method calculate_reimbursement_type has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def calculate_reimbursement_type(return_item)
      return exchange_reimbursement_type if return_item.exchange_required?
      return return_item.override_reimbursement_type.class if return_item.override_reimbursement_type.present?
      if return_item.preferred_reimbursement_type.present?
        return valid_preferred_reimbursement_type?(return_item) ? return_item.preferred_reimbursement_type.class : nil

• Read up
  Read up

Method void_transaction! has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def void_transaction!
        return true if void?

        protect_from_connection_error do
          if payment_method.payment_profiles_supported?

• Read up
  Read up

Method available has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def self.available(available_on = nil, currency = nil)
        if available_on
          scope = not_discontinued.where("#{Product.quoted_table_name}.available_on <= ?", available_on)
        else
          scope = where(status: 'active')

• Read up
  Read up

Method searcher_class has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

  def self.searcher_class(constantize: true)
    @@searcher_class ||= 'Spree::Core::Search::Base'

    if @@searcher_class.is_a?(Class)
      raise 'Spree.searcher_class MUST be a String or Symbol object, not a Class object.'

• Read up
  Read up

Method apply has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

      def apply
        if order.coupon_code.present?
          if promotion.present? && promotion.actions.exists?
            handle_present_promotion
          elsif store.promotions.with_coupon_code(order.coupon_code).try(:expired?)

• Read up
  Read up