spree_core 4.10.1 → 5.0.0.rc1

data/app/models/spree/product.rb

@@ -19,7 +19,7 @@
 #
 
 module Spree
-  class Product < Spree::Base
+  class Product < Spree.base_class
     extend FriendlyId
     include Spree::ProductScopes
     include Spree::MultiStoreResource
@@ -34,12 +34,26 @@ module Spree
 
     MEMOIZED_METHODS = %w[total_on_hand taxonomy_ids taxon_and_ancestors category
                           default_variant_id tax_category default_variant
-                          purchasable? in_stock? backorderable?]
+                          default_image secondary_image
+                          purchasable? in_stock? backorderable? has_variants?]
+
+    STATUS_TO_WEBHOOK_EVENT = {
+      'active' => 'activated',
+      'draft' => 'drafted',
+      'archived' => 'archived'
+    }.freeze
 
     TRANSLATABLE_FIELDS = %i[name description slug meta_description meta_keywords meta_title].freeze
     translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
 
     self::Translation.class_eval do
+      if defined?(PgSearch)
+        include PgSearch::Model
+
+        pg_search_scope :search_by_name, against: { name: 'A', meta_title: 'B' },
+                                         using: { tsearch: { prefix: true, any_word: true } }
+      end
+
       before_save :set_slug
       acts_as_paranoid
       # deleted translation values also need to be accessible for index views listing deleted resources
@@ -61,23 +75,23 @@ module Spree
       end
     end
 
-    friendly_id :slug_candidates, use: [:history, :mobility]
+    friendly_id :slug_candidates, use: [:history, :scoped, :mobility], scope: spree_base_uniqueness_scope
     acts_as_paranoid
     auto_strip_attributes :name
+    acts_as_taggable_on :tags, :labels
 
     # we need to have this callback before any dependent: :destroy associations
     # https://github.com/rails/rails/issues/3458
     before_destroy :ensure_not_in_complete_orders
 
-    has_many :product_option_types, dependent: :destroy, inverse_of: :product
+    has_many :product_option_types, -> { order(:position) }, dependent: :destroy, inverse_of: :product
     has_many :option_types, through: :product_option_types
     has_many :product_properties, dependent: :destroy, inverse_of: :product
     has_many :properties, through: :product_properties
 
-    has_many :menu_items, as: :linked_resource
-
-    has_many :classifications, dependent: :delete_all, inverse_of: :product
+    has_many :classifications, -> { order(created_at: :asc) }, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
+    has_many :taxonomies, through: :taxons
 
     has_many :product_promotion_rules, class_name: 'Spree::ProductPromotionRule'
     has_many :promotion_rules, through: :product_promotion_rules, class_name: 'Spree::PromotionRule'
@@ -117,26 +131,37 @@ module Spree
     has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
     has_many :variant_images_without_master, -> { order(:position) }, source: :images, through: :variants
 
+    has_many :option_value_variants, class_name: 'Spree::OptionValueVariant', through: :variants
+    has_many :option_values, class_name: 'Spree::OptionValue', through: :variants
+
+    has_many :prices_including_master, -> { non_zero }, through: :variants_including_master, source: :prices
+
     has_many :store_products, class_name: 'Spree::StoreProduct'
     has_many :stores, through: :store_products, class_name: 'Spree::Store'
     has_many :digitals, through: :variants_including_master
 
+    has_many :page_links, as: :linkable, class_name: 'Spree::PageLink', dependent: :destroy
+
+    after_initialize :ensure_master
+    after_initialize :assign_default_tax_category
+
+    before_validation :downcase_slug
+    before_validation :normalize_slug, on: :update
+    before_validation :validate_master
+    before_validation :ensure_default_shipping_category
+
     after_create :add_associations_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
     after_destroy :punch_slug
     after_restore :update_slug_history
 
-    after_initialize :ensure_master
-
     after_save :save_master
     after_save :run_touch_callbacks, if: :anything_changed?
     after_save :reset_nested_changes
     after_touch :touch_taxons
 
-    before_validation :downcase_slug
-    before_validation :normalize_slug, on: :update
-    before_validation :validate_master
+    after_commit :auto_match_taxons, if: :eligible_for_taxon_matching?
 
     with_options length: { maximum: 255 }, allow_blank: true do
       validates :meta_keywords
@@ -152,26 +177,113 @@ module Spree
     validate :discontinue_on_must_be_later_than_make_active_at, if: -> { make_active_at && discontinue_on }
 
     scope :for_store, ->(store) { joins(:store_products).where(StoreProduct.table_name => { store_id: store.id }) }
+    scope :draft, -> { where(status: 'draft') }
+    scope :archived, -> { where(status: 'archived') }
+    scope :not_archived, -> { where.not(status: 'archived') }
+    scope :on_sale, lambda { |currency = nil|
+                      currency ||= Spree::Store.default.default_currency
+                      joins(:prices_including_master).with_currency(currency).
+                        where.not(spree_prices: { compare_at_amount: [nil, 0] }).
+                        where("#{Spree::Price.table_name}.compare_at_amount > #{Spree::Price.table_name}.amount")
+                    }
+
+    if defined?(PgSearch)
+      scope :multi_search, lambda { |query, include_options = false|
+        return none if query.blank?
+
+        product_ids = if Spree.use_translations?
+                        Spree::Product::Translation.search_by_name(query).pluck(:spree_product_id)
+                      else
+                        Spree::Product.search_by_name(query).ids
+                      end
+
+        variant_product_ids = if include_options.present?
+                                Spree::Variant.search_by_sku_or_options(query).pluck(:product_id)
+                              else
+                                Spree::Variant.search_by_sku(query).pluck(:product_id)
+                              end
+
+        where(id: (product_ids + variant_product_ids).uniq.compact)
+      }
+    else
+      scope :multi_search, lambda { |query|
+        return none if query.blank?
+
+        product_ids = Spree::Variant.search_by_product_name_or_sku(query).pluck(:product_id)
+        where(id: product_ids.uniq.compact)
+      }
+    end
+
+    scope :archivable, -> { where(status: %w[active draft]) }
+    scope :by_source, ->(source) { send(source) }
+    scope :paused, -> { where(status: 'paused') }
+    scope :published, -> { where(status: 'active') }
+    scope :in_stock_items, -> { joins(:variants).merge(Spree::Variant.in_stock_or_backorderable) }
+    scope :out_of_stock_items, lambda {
+      joins(variants_including_master: :stock_items).
+        where(spree_variants: { track_inventory: true }).
+        where.not(id: Spree::Variant.where(track_inventory: false).pluck(:product_id).uniq).
+        where(spree_stock_items: { backorderable: false }).
+        group(:id).
+        having("SUM(#{Spree::StockItem.table_name}.count_on_hand) <= 0")
+    }
+    scope :out_of_stock, lambda {
+                           joins(:stock_items).where("#{Spree::StockItem.table_name}.count_on_hand <= ? OR #{Spree::Variant.table_name}.track_inventory = ?", 0, false)
+                         }
+
+    scope :by_best_selling, lambda { |order_direction = :desc|
+      left_joins(:orders).
+        select("#{Spree::Product.table_name}.*, COUNT(#{Spree::Order.table_name}.id) AS completed_orders_count, SUM(#{Spree::Order.table_name}.total) AS completed_orders_total").
+        where(Spree::Order.table_name => { id: nil }).
+        or(where.not(Spree::Order.table_name => { completed_at: nil })).
+        group("#{Spree::Product.table_name}.id").
+        order(completed_orders_count: order_direction, completed_orders_total: order_direction)
+    }
 
     attr_accessor :option_values_hash
 
-    accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: ->(pp) { pp[:property_name].blank? }
+    accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp|
+                                                                                         pp[:property_id].blank? || (pp[:id].blank? && pp[:value].blank?)
+                                                                                       }
+    accepts_nested_attributes_for(
+      :variants,
+      allow_destroy: true,
+      reject_if: lambda do |v|
+        v[:option_value_variants_attributes].blank? && v[:stock_items_attributes].blank? && v[:prices_attributes].blank?
+      end
+    )
+    accepts_nested_attributes_for :master, reject_if: :all_blank
+    accepts_nested_attributes_for(
+      :product_option_types,
+      allow_destroy: true,
+      reject_if: ->(pot) { pot[:option_type_id].blank? || pot[:position].blank? }
+    )
 
     alias options product_option_types
 
-    self.whitelisted_ransackable_associations = %w[taxons stores variants_including_master master variants]
     self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status]
-    self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon price_between]
+    self.whitelisted_ransackable_associations = %w[taxons stores variants_including_master master variants tags labels
+                                                   shipping_category classifications option_types properties]
+    self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon price_between
+                                             multi_search in_stock_items out_of_stock_items]
 
     [
-      :sku, :barcode, :price, :currency, :weight, :height, :width, :depth, :is_master,
-      :cost_currency, :price_in, :amount_in, :cost_price, :compare_at_price, :compare_at_amount_in
+      :sku, :barcode, :weight, :height, :width, :depth, :is_master, :dimensions_unit, :weight_unit
     ].each do |method_name|
       delegate method_name, :"#{method_name}=", to: :find_or_build_master
     end
 
+    [
+      :price, :price_in, :amount_in, :compare_at_price, :compare_at_amount_in,
+      :currency, :cost_currency, :cost_price, :track_inventory
+    ].each do |method_name|
+      delegate method_name, :"#{method_name}=", to: :default_variant
+    end
+
     delegate :display_amount, :display_price, :has_default_price?,
-             :display_compare_at_price, :images, to: :find_or_build_master
+             :display_compare_at_price, :images, to: :default_variant
+
+    delegate :name, to: :brand, prefix: true, allow_nil: true
 
     alias master_images images
 
@@ -192,14 +304,31 @@ module Spree
       after_transition to: :draft, do: [:after_draft, :send_product_drafted_webhook]
     end
 
+    def self.bulk_auto_match_taxons(store, product_ids)
+      return if store.taxons.automatic.none?
+
+      products_to_auto_match_ids = store.products.not_deleted.not_archived.where(id: product_ids).ids
+
+      # for ActiveJob 7.1+
+      if ActiveJob.respond_to?(:perform_all_later)
+        auto_match_taxons_jobs = products_to_auto_match_ids.map do |product_id|
+          Spree::Products::AutoMatchTaxonsJob.new(product_id)
+        end
+
+        ActiveJob.perform_all_later(auto_match_taxons_jobs)
+      else
+        products_to_auto_match_ids.each { |product_id| Spree::Products::AutoMatchTaxonsJob.perform_later(product_id) }
+      end
+    end
+
     # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
     def purchasable?
-      default_variant.purchasable? || variants.any?(&:purchasable?)
+      @purchasable ||= default_variant.purchasable? || variants.in_stock_or_backorderable.any?
     end
 
     # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
     def in_stock?
-      default_variant.in_stock? || variants.any?(&:in_stock?)
+      @in_stock ||= default_variant.in_stock? || variants.in_stock.any?
     end
 
     # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
@@ -207,13 +336,17 @@ module Spree
       default_variant.backorderable? || variants.any?(&:backorderable?)
     end
 
+    def on_sale?(currency)
+      prices_including_master.find_all { |p| p.currency == currency }.any?(&:discounted?)
+    end
+
     def find_or_build_master
       master || build_master
     end
 
     # the master variant is not a member of the variants array
     def has_variants?
-      variants.any?
+      @has_variants ||= variants.loaded? ? variants.size.positive? : variants.any?
     end
 
     # Returns default Variant for Product
@@ -225,13 +358,11 @@ module Spree
     #
     # @return [Spree::Variant]
     def default_variant
-      @default_variant ||= Rails.cache.fetch(default_variant_cache_key) do
-        if Spree::Config[:track_inventory_levels] && available_variant = variants.detect(&:purchasable?)
-          available_variant
-        else
-          has_variants? ? variants.first : master
-        end
-      end
+      @default_variant ||= if Spree::Config[:track_inventory_levels] && available_variant = variants.detect(&:purchasable?)
+                             available_variant
+                           else
+                             has_variants? ? variants.first : find_or_build_master
+                           end
     end
 
     # Returns default Variant ID for Product
@@ -240,19 +371,87 @@ module Spree
       @default_variant_id ||= default_variant.id
     end
 
+    # Returns default Image for Product
+    # @return [Spree::Image]
+    def default_image
+      @default_image ||= if images.size.positive?
+                           images.first
+                         elsif default_variant.images.size.positive?
+                           default_variant.default_image
+                         elsif variant_images.size.positive?
+                           variant_images.first
+                         end
+    end
+    alias featured_image default_image
+
+    # Returns secondary Image for Product
+    # @return [Spree::Image]
+    def secondary_image
+      @secondary_image ||= if images.size > 1
+                             images.second
+                           elsif images.size == 1 && default_variant.images.size.positive?
+                             default_variant.images.first
+                           elsif default_variant.images.size > 1
+                             default_variant.secondary_image
+                           elsif variant_images.size > 1
+                             variant_images.second
+                           end
+    end
+
+    # Returns the short description for the product
+    # @return [String]
+    def storefront_description
+      property('short_description') || description
+    end
+
+    # Returns tax category for Product
+    # @return [Spree::TaxCategory]
     def tax_category
-      @tax_category ||= super || TaxCategory.find_by(is_default: true)
+      @tax_category ||= super || TaxCategory.default
     end
 
     # Adding properties and option types on creation based on a chosen prototype
     attr_accessor :prototype_id
 
+    def first_or_default_variant(currency)
+      if !has_variants?
+        default_variant
+      elsif first_available_variant(currency).present?
+        first_available_variant(currency)
+      else
+        variants.first
+      end
+    end
+
+    def first_available_variant(currency)
+      variants.find { |v| v.purchasable? && v.price_in(currency).amount.present? }
+    end
+
+    def price_varies?(currency)
+      prices_including_master.find_all { |p| p.currency == currency && p.amount.present? }.map(&:amount).uniq.count > 1
+    end
+
+    def any_variant_available?(currency)
+      if has_variants?
+        first_available_variant(currency).present?
+      else
+        master.purchasable? && master.price_in(currency).amount.present?
+      end
+    end
+
+    # returns the lowest price for the product in the given currency
+    # prices_including_master are usually already loaded, so this should not trigger an extra query
+    def lowest_price(currency)
+      prices_including_master.find_all { |p| p.currency == currency }.min_by(&:amount)
+    end
+
     # Ensures option_types and product_option_types exist for keys in option_values_hash
     def ensure_option_types_exist_for_values_hash
       return if option_values_hash.nil?
 
-      required_option_type_ids = option_values_hash.keys.map(&:to_i)
-      missing_option_type_ids = required_option_type_ids - option_type_ids
+      # we need to convert the keys to string to make it work with UUIDs
+      required_option_type_ids = option_values_hash.keys.map(&:to_s)
+      missing_option_type_ids = required_option_type_ids - option_type_ids.map(&:to_s)
       missing_option_type_ids.each do |id|
         product_option_types.create(option_type_id: id)
       end
@@ -261,8 +460,7 @@ module Spree
     # for adding products which are closely related to existing ones
     # define "duplicate_extra" for site-specific actions, eg for additional fields
     def duplicate
-      duplicator = ProductDuplicator.new(self)
-      duplicator.duplicate
+      Products::Duplicator.call(product: self)
     end
 
     # use deleted? rather than checking the attribute directly. this
@@ -276,7 +474,7 @@ module Spree
     # deleted products and products with status different than active
     # are not available
     def available?
-      active? && !deleted?
+      active? && !deleted? && (available_on.nil? || available_on <= Time.current)
     end
 
     def discontinue!
@@ -330,10 +528,15 @@ module Spree
     end
 
     def property(property_name)
-      product_properties.joins(:property).find_by(Property.table_name => { name: property_name }).try(:value)
+      if product_properties.loaded?
+        product_properties.detect { |property| property.property.name == property_name }.try(:value)
+      else
+        product_properties.joins(:property).find_by(spree_properties: { name: property_name }).try(:value)
+      end
     end
 
     def set_property(property_name, property_value, property_presentation = property_name)
+      property_name = property_name.to_s.parameterize
       ApplicationRecord.transaction do
         # Manual first_or_create to work around Mobility bug
         property = if Property.where(name: property_name).exists?
@@ -348,7 +551,7 @@ module Spree
         product_property = if ProductProperty.where(product: self, property: property).exists?
                              ProductProperty.where(product: self, property: property).first
                            else
-                             ProductProperty.create(product: self, property: property)
+                             ProductProperty.new(product: self, property: property)
                            end
 
         product_property.value = property_value
@@ -356,14 +559,16 @@ module Spree
       end
     end
 
+    def remove_property(property_name)
+      product_properties.joins(:property).find_by(spree_properties: { name: property_name.parameterize })&.destroy
+    end
+
     def total_on_hand
-      @total_on_hand ||= Rails.cache.fetch(['product-total-on-hand', cache_key_with_version]) do
-        if any_variants_not_track_inventory?
-          BigDecimal::INFINITY
-        else
-          stock_items.sum(:count_on_hand)
-        end
-      end
+      @total_on_hand ||= if any_variants_not_track_inventory?
+                           BigDecimal::INFINITY
+                         else
+                           stock_items.loaded? ? stock_items.sum(&:count_on_hand) : stock_items.sum(:count_on_hand)
+                         end
     end
 
     # Master variant may be deleted (i.e. when the product is deleted)
@@ -375,7 +580,7 @@ module Spree
 
     def brand
       @brand ||= if Spree.use_translations?
-                    taxons.joins(:taxonomy).
+                   taxons.joins(:taxonomy).
                      join_translation_table(Taxonomy).
                      find_by(Taxonomy.translation_table_alias => { name: Spree.t(:taxonomy_brands_name) })
                  else
@@ -394,6 +599,10 @@ module Spree
                     end
     end
 
+    def main_taxon
+      category || taxons.first
+    end
+
     def taxons_for_store(store)
       Rails.cache.fetch("#{cache_key_with_version}/taxons-per-store/#{store.id}") do
         taxons.for_store(store)
@@ -401,15 +610,60 @@ module Spree
     end
 
     def any_variant_in_stock_or_backorderable?
-      if variants.any?
+      if has_variants?
         variants_including_master.in_stock_or_backorderable.exists?
       else
         master.in_stock_or_backorderable?
       end
     end
 
+    # Check if the product is digital by checking if any of its shipping methods are digital delivery
+    # This is used to determine if the product is digital and should have a digital delivery price
+    # instead of a physical shipping price
+    #
+    # @return [Boolean]
     def digital?
-      shipping_category&.name == I18n.t('spree.seed.shipping.categories.digital')
+      shipping_category&.shipping_methods&.any? { |method| method.calculator.is_a?(Spree::Calculator::Shipping::DigitalDelivery) }
+    end
+
+    def auto_match_taxons
+      return if deleted?
+      return if archived?
+
+      store = stores.find_by(default: true) || stores.first
+      return if store.nil? || store.taxons.automatic.none?
+
+      Spree::Products::AutoMatchTaxonsJob.perform_later(id)
+    end
+
+    def to_csv(store = nil)
+      store ||= stores.default || stores.first
+      properties_for_csv ||= Spree::Property.order(:position).flat_map do |property|
+        [
+          property.name,
+          product_properties.find { |pp| pp.property_id == property.id }&.value
+        ]
+      end
+      taxons_for_csv ||= taxons.manual.reorder(depth: :desc).first(3).pluck(:pretty_name)
+      taxons_for_csv.fill(nil, taxons_for_csv.size...3)
+
+      csv_lines = []
+
+      if has_variants?
+        variants_including_master.each_with_index do |variant, index|
+          csv_lines << Spree::CSV::ProductVariantPresenter.new(self, variant, index, properties_for_csv, taxons_for_csv, store).call
+        end
+      else
+        csv_lines << Spree::CSV::ProductVariantPresenter.new(self, master, 0, properties_for_csv, taxons_for_csv, store).call
+      end
+
+      csv_lines
+    end
+
+    def page_builder_url
+      return unless Spree::Core::Engine.routes.url_helpers.respond_to?(:product_path)
+
+      Spree::Core::Engine.routes.url_helpers.product_path(self)
     end
 
     private
@@ -450,6 +704,8 @@ module Spree
     end
 
     def default_variant_cache_key
+      Spree::Deprecation.warn('Spree::Product#default_variant_cache_key is deprecated and will be removed in Spree 6. Please remove any occurrences of it.')
+
       "spree/default-variant/#{cache_key_with_version}/#{Spree::Config[:track_inventory_levels]}"
     end
 
@@ -459,6 +715,10 @@ module Spree
       self.master ||= build_master
     end
 
+    def assign_default_tax_category
+      self.tax_category = Spree::TaxCategory.default if new_record?
+    end
+
     def normalize_slug
       self.slug = normalize_friendly_id(slug)
     end
@@ -524,6 +784,15 @@ module Spree
       end
     end
 
+    def ensure_default_shipping_category
+      return if shipping_category.present?
+
+      if new_record?
+        name = I18n.t('spree.seed.shipping.categories.default')
+        self.shipping_category = Spree::ShippingCategory.find_or_create_by!(name: name)
+      end
+    end
+
     # Try building a slug based on the following fields in increasing order of specificity.
     def slug_candidates
       [
@@ -540,15 +809,13 @@ module Spree
       @taxon_and_ancestors ||= taxons.map(&:self_and_ancestors).flatten.uniq
     end
 
-    # Get the taxonomy ids of all taxons assigned to this product and their ancestors.
-    def taxonomy_ids
-      @taxonomy_ids ||= taxon_and_ancestors.map(&:taxonomy_id).flatten.uniq
-    end
-
     # Iterate through this products taxons and taxonomies and touch their timestamps in a batch
     def touch_taxons
-      Spree::Taxon.where(id: taxon_and_ancestors.map(&:id)).update_all(updated_at: Time.current)
-      Spree::Taxonomy.where(id: taxonomy_ids).update_all(updated_at: Time.current)
+      if taxons.any?
+        Spree::Products::TouchTaxonsJob.
+          set(wait: 5.seconds).
+          perform_later(taxon_and_ancestors.map(&:id), taxonomy_ids.uniq)
+      end
     end
 
     def ensure_not_in_complete_orders
@@ -560,7 +827,7 @@ module Spree
 
     def remove_taxon(taxon)
       removed_classifications = classifications.where(taxon: taxon)
-      removed_classifications.each &:remove_from_list
+      removed_classifications.each(&:remove_from_list)
     end
 
     def discontinue_on_must_be_later_than_make_active_at
@@ -577,6 +844,10 @@ module Spree
       true
     end
 
+    def eligible_for_taxon_matching?
+      previously_new_record? || tag_list_previously_changed? || available_on_previously_changed?
+    end
+
     def downcase_slug
       slug&.downcase!
     end

data/app/models/spree/product_option_type.rb

@@ -1,5 +1,5 @@
 module Spree
-  class ProductOptionType < Spree::Base
+  class ProductOptionType < Spree.base_class
     with_options inverse_of: :product_option_types do
       belongs_to :product, class_name: 'Spree::Product'
       belongs_to :option_type, class_name: 'Spree::OptionType'

data/app/models/spree/product_promotion_rule.rb

@@ -1,5 +1,5 @@
 module Spree
-  class ProductPromotionRule < Spree::Base
+  class ProductPromotionRule < Spree.base_class
     belongs_to :product, class_name: 'Spree::Product'
     belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
 

data/app/models/spree/product_property.rb

@@ -1,5 +1,5 @@
 module Spree
-  class ProductProperty < Spree::Base
+  class ProductProperty < Spree.base_class
     include Spree::FilterParam
     include Spree::TranslatableResource
 
@@ -32,6 +32,9 @@ module Spree
 
     scope :filterable, -> { joins(:property).where(Property.table_name => { filterable: true }) }
     scope :for_products, ->(products) { joins(:product).merge(products) }
+    scope :sort_by_property_position, -> {
+      joins(:property).order("spree_properties.position ASC")
+    }
 
     self.whitelisted_ransackable_attributes = ['value', 'filter_param']
     self.whitelisted_ransackable_associations = ['property']