solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/product/scopes.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module Spree
+  class Product < Spree::Base
+    cattr_accessor :search_scopes do
+      []
+    end
+
+    def self.add_search_scope(name, &block)
+      singleton_class.send(:define_method, name.to_sym, &block)
+      search_scopes << name.to_sym
+    end
+
+    def self.property_conditions(property)
+      properties = Property.table_name
+      case property
+      when String   then { "#{properties}.name" => property }
+      when Property then { "#{properties}.id" => property.id }
+      else { "#{properties}.id" => property.to_i }
+      end
+    end
+
+    scope :ascend_by_updated_at, -> { order(updated_at: :asc) }
+    scope :descend_by_updated_at, -> { order(updated_at: :desc) }
+    scope :ascend_by_name, -> { order(name: :asc) }
+    scope :descend_by_name, -> { order(name: :desc) }
+
+    add_search_scope :ascend_by_master_price do
+      joins(master: :default_price).order(Spree::Price.arel_table[:amount].asc)
+    end
+
+    add_search_scope :descend_by_master_price do
+      joins(master: :default_price).order(Spree::Price.arel_table[:amount].desc)
+    end
+
+    add_search_scope :price_between do |low, high|
+      joins(master: :default_price).where(Price.table_name => { amount: low..high })
+    end
+
+    add_search_scope :master_price_lte do |price|
+      joins(master: :default_price).where("#{price_table_name}.amount <= ?", price)
+    end
+
+    add_search_scope :master_price_gte do |price|
+      joins(master: :default_price).where("#{price_table_name}.amount >= ?", price)
+    end
+
+    # This scope selects products in taxon AND all its descendants
+    # If you need products only within one taxon use
+    #
+    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { id: taxon.id })
+    #
+    # If you're using count on the result of this scope, you must use the
+    # `:distinct` option as well:
+    #
+    #   Spree::Product.in_taxon(taxon).count(distinct: true)
+    #
+    # This is so that the count query is distinct'd:
+    #
+    #   SELECT COUNT(DISTINCT "spree_products"."id") ...
+    #
+    #   vs.
+    #
+    #   SELECT COUNT(*) ...
+    add_search_scope :in_taxon do |taxon|
+      includes(:classifications).
+      where("spree_products_taxons.taxon_id" => taxon.self_and_descendants.pluck(:id)).
+      order(Spree::Classification.arel_table[:position].asc)
+    end
+
+    # This scope selects products in all taxons AND all its descendants
+    # If you need products only within one taxon use
+    #
+    #   Spree::Product.taxons_id_eq([x,y])
+    add_search_scope :in_taxons do |*taxons|
+      taxons = get_taxons(taxons)
+      taxons.first ? prepare_taxon_conditions(taxons) : where(nil)
+    end
+
+    # a scope that finds all products having property specified by name, object or id
+    add_search_scope :with_property do |property|
+      joins(:properties).where(property_conditions(property))
+    end
+
+    # a simple test for product with a certain property-value pairing
+    # note that it can test for properties with NULL values, but not for absent values
+    add_search_scope :with_property_value do |property, value|
+      joins(:properties)
+        .where("#{Spree::ProductProperty.table_name}.value = ?", value)
+        .where(property_conditions(property))
+    end
+
+    add_search_scope :with_option do |option|
+      option_types = Spree::OptionType.table_name
+      conditions = case option
+                   when String     then { "#{option_types}.name" => option }
+                   when OptionType then { "#{option_types}.id" => option.id }
+      else { "#{option_types}.id" => option.to_i }
+      end
+
+      joins(:option_types).where(conditions)
+    end
+
+    add_search_scope :with_option_value do |option, value|
+      option_values = Spree::OptionValue.table_name
+      option_type_id = case option
+                       when String then Spree::OptionType.find_by(name: option) || option.to_i
+                       when Spree::OptionType then option.id
+        else option.to_i
+      end
+
+      conditions = "#{option_values}.name = ? AND #{option_values}.option_type_id = ?", value, option_type_id
+      group('spree_products.id').joins(variants_including_master: :option_values).where(conditions)
+    end
+
+    # Finds all products which have either:
+    # 1) have an option value with the name matching the one given
+    # 2) have a product property with a value matching the one given
+    add_search_scope :with do |value|
+      includes(variants_including_master: :option_values).
+      includes(:product_properties).
+      where("#{Spree::OptionValue.table_name}.name = ? OR #{Spree::ProductProperty.table_name}.value = ?", value, value)
+    end
+
+    # Finds all products that have a name containing the given words.
+    add_search_scope :in_name do |words|
+      like_any([:name], prepare_words(words))
+    end
+
+    # Finds all products that have a name or meta_keywords containing the given words.
+    add_search_scope :in_name_or_keywords do |words|
+      like_any([:name, :meta_keywords], prepare_words(words))
+    end
+
+    # Finds all products that have a name, description, meta_description or meta_keywords containing the given keywords.
+    add_search_scope :in_name_or_description do |words|
+      like_any([:name, :description, :meta_description, :meta_keywords], prepare_words(words))
+    end
+
+    # Finds all products that have the ids matching the given collection of ids.
+    # Alternatively, you could use find(collection_of_ids), but that would raise an exception if one product couldn't be found
+    add_search_scope :with_ids do |*ids|
+      where(id: ids)
+    end
+
+    # Sorts products from most popular (popularity is extracted from how many
+    # times use has put product in cart, not completed orders)
+    #
+    # there is alternative faster and more elegant solution, it has small drawback though,
+    # it doesn stack with other scopes :/
+    #
+    # joins: "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
+    # order: 'COALESCE(cnt, 0) DESC'
+    add_search_scope :descend_by_popularity do
+      joins(:master).
+      order(%{
+           COALESCE((
+             SELECT
+               COUNT(#{Spree::LineItem.quoted_table_name}.id)
+             FROM
+               #{Spree::LineItem.quoted_table_name}
+             JOIN
+               #{Spree::Variant.quoted_table_name} AS popular_variants
+             ON
+               popular_variants.id = #{Spree::LineItem.quoted_table_name}.variant_id
+             WHERE
+               popular_variants.product_id = #{Spree::Product.quoted_table_name}.id
+           ), 0) DESC
+        })
+    end
+
+    add_search_scope :not_deleted do
+      where("#{Spree::Product.quoted_table_name}.deleted_at IS NULL or #{Spree::Product.quoted_table_name}.deleted_at >= ?", Time.current)
+    end
+
+    scope :with_master_price, -> do
+      joins(:master).where(Spree::Price.where(Spree::Variant.arel_table[:id].eq(Spree::Price.arel_table[:variant_id])).arel.exists)
+    end
+
+    # Can't use add_search_scope for this as it needs a default argument
+    def self.available(available_on = nil)
+      with_master_price.where("#{Spree::Product.quoted_table_name}.available_on <= ?", available_on || Time.current)
+    end
+    search_scopes << :available
+
+    add_search_scope :taxons_name_eq do |name|
+      group("spree_products.id").joins(:taxons).where(Spree::Taxon.arel_table[:name].eq(name))
+    end
+
+    def self.with_variant_sku_cont(sku)
+      sku_match = "%#{sku}%"
+      variant_table = Spree::Variant.arel_table
+      subquery = Spree::Variant.where(variant_table[:sku].matches(sku_match).and(variant_table[:product_id].eq(arel_table[:id])))
+      where(subquery.arel.exists)
+    end
+
+    def self.distinct_by_product_ids(sort_order = nil)
+      Spree::Deprecation.warn "Product.distinct_by_product_ids is deprecated and should not be used"
+
+      sort_column = sort_order.split(" ").first
+
+      # Postgres will complain when using ordering by expressions not present in
+      # SELECT DISTINCT. e.g.
+      #
+      #   PG::InvalidColumnReference: ERROR:  for SELECT DISTINCT, ORDER BY
+      #   expressions must appear in select list. e.g.
+      #
+      #   SELECT  DISTINCT "spree_products".* FROM "spree_products" LEFT OUTER JOIN
+      #   "spree_variants" ON "spree_variants"."product_id" = "spree_products"."id" AND "spree_variants"."is_master" = 't'
+      #   AND "spree_variants"."deleted_at" IS NULL LEFT OUTER JOIN "spree_prices" ON
+      #   "spree_prices"."variant_id" = "spree_variants"."id" AND "spree_prices"."currency" = 'USD'
+      #   AND "spree_prices"."deleted_at" IS NULL WHERE "spree_products"."deleted_at" IS NULL AND ('t'='t')
+      #   ORDER BY "spree_prices"."amount" ASC LIMIT 10 OFFSET 0
+      #
+      # Don't allow sort_column, a variable coming from params,
+      # to be anything but a column in the database
+      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && !column_names.include?(sort_column)
+        all
+      else
+        distinct
+      end
+    end
+
+    class << self
+      private
+
+      def price_table_name
+        Spree::Price.quoted_table_name
+      end
+
+      # specifically avoid having an order for taxon search (conflicts with main order)
+      def prepare_taxon_conditions(taxons)
+        ids = taxons.map { |taxon| taxon.self_and_descendants.pluck(:id) }.flatten.uniq
+        joins(:taxons).where("#{Spree::Taxon.table_name}.id" => ids)
+      end
+
+      # Produce an array of keywords for use in scopes.
+      # Always return array with at least an empty string to avoid SQL errors
+      def prepare_words(words)
+        return [''] if words.blank?
+        a = words.split(/[,\s]/).map(&:strip)
+        a.any? ? a : ['']
+      end
+
+      def get_taxons(*ids_or_records_or_names)
+        taxons = Spree::Taxon.table_name
+        ids_or_records_or_names.flatten.map { |t|
+          case t
+          when Integer then Spree::Taxon.find_by(id: t)
+          when ActiveRecord::Base then t
+          when String
+            Spree::Taxon.find_by(name: t) ||
+              Spree::Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
+          end
+        }.compact.flatten.uniq
+      end
+    end
+  end
+end

data/app/models/spree/product.rb

@@ -0,0 +1,400 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+module Spree
+  # Products represent an entity for sale in a store. Products can have
+  # variations, called variants. Product properties include description,
+  # permalink, availability, shipping category, etc. that do not change by
+  # variant.
+  #
+  # @note this model uses {https://github.com/radar/paranoia paranoia}.
+  #   +#destroy+ will only soft-destroy records and the default scope hides
+  #   soft-destroyed records using +WHERE deleted_at IS NULL+.
+  class Product < Spree::Base
+    extend FriendlyId
+    friendly_id :slug_candidates, use: :history
+
+    acts_as_paranoid
+    include Spree::ParanoiaDeprecations
+
+    include Discard::Model
+    self.discard_column = :deleted_at
+
+    after_discard do
+      variants_including_master.discard_all
+      self.product_option_types = []
+      self.product_properties = []
+      self.classifications = []
+      self.product_promotion_rules = []
+    end
+
+    has_many :product_option_types, 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 :variant_property_rules
+    has_many :variant_property_rule_values, through: :variant_property_rules, source: :values
+    has_many :variant_property_rule_conditions, through: :variant_property_rules, source: :conditions
+
+    has_many :classifications, dependent: :delete_all, inverse_of: :product
+    has_many :taxons, through: :classifications, before_remove: :remove_taxon
+
+    has_many :product_promotion_rules, dependent: :destroy
+    has_many :promotion_rules, through: :product_promotion_rules
+
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products
+
+    has_one :master,
+      -> { where(is_master: true).with_deleted },
+      inverse_of: :product,
+      class_name: 'Spree::Variant',
+      autosave: true
+
+    has_many :variants,
+      -> { where(is_master: false).order(:position) },
+      inverse_of: :product,
+      class_name: 'Spree::Variant'
+
+    has_many :variants_including_master,
+      -> { order(:position) },
+      inverse_of: :product,
+      class_name: 'Spree::Variant',
+      dependent: :destroy
+
+    has_many :prices, -> { order(Spree::Variant.arel_table[:position].asc, Spree::Variant.arel_table[:id].asc, :currency) }, through: :variants_including_master
+
+    has_many :stock_items, through: :variants_including_master
+
+    has_many :line_items, through: :variants_including_master
+    has_many :orders, through: :line_items
+
+    def find_or_build_master
+      master || build_master
+    end
+
+    MASTER_ATTRIBUTES = [
+      :cost_currency,
+      :cost_price,
+      :depth,
+      :height,
+      :price,
+      :sku,
+      :weight,
+      :width,
+    ]
+    MASTER_ATTRIBUTES.each do |attr|
+      delegate :"#{attr}", :"#{attr}=", to: :find_or_build_master
+    end
+
+    delegate :amount_in,
+             :display_amount,
+             :display_price,
+             :has_default_price?,
+             :images,
+             :price_for,
+             :price_in,
+             :rebuild_vat_prices=,
+             to: :find_or_build_master
+
+    alias_method :master_images, :images
+
+    has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
+
+    after_create :build_variants_from_option_values_hash, if: :option_values_hash
+
+    after_destroy :punch_slug
+    after_discard :punch_slug
+
+    after_initialize :ensure_master
+
+    after_save :run_touch_callbacks, if: :saved_changes?
+    after_touch :touch_taxons
+
+    before_validation :normalize_slug, on: :update
+    before_validation :validate_master
+
+    validates :meta_keywords, length: { maximum: 255 }
+    validates :meta_title, length: { maximum: 255 }
+    validates :name, presence: true
+    validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
+    validates :shipping_category_id, presence: true
+    validates :slug, presence: true, uniqueness: { allow_blank: true }
+
+    attr_accessor :option_values_hash
+
+    accepts_nested_attributes_for :variant_property_rules, allow_destroy: true
+    accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp| pp[:property_name].blank? }
+
+    alias :options :product_option_types
+
+    self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
+    self.whitelisted_ransackable_attributes = %w[slug]
+
+    def self.ransackable_scopes(_auth_object = nil)
+      %i(with_deleted with_variant_sku_cont)
+    end
+
+    # @return [Boolean] true if there are any variants
+    def has_variants?
+      variants.any?
+    end
+
+    # @return [Spree::TaxCategory] tax category for this product, or the default tax category
+    def tax_category
+      super || Spree::TaxCategory.find_by(is_default: true)
+    end
+
+    # Ensures option_types and product_option_types exist for keys in
+    # option_values_hash.
+    #
+    # @return [Array] the option_values
+    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)
+      self.option_type_ids |= required_option_type_ids
+    end
+
+    # Creates a new product with the same attributes, variants, etc.
+    #
+    # @return [Spree::Product] the duplicate
+    def duplicate
+      duplicator = ProductDuplicator.new(self)
+      duplicator.duplicate
+    end
+
+    # Use for checking whether this product has been deleted. Provided for
+    # overriding the logic for determining if a product is deleted.
+    #
+    # @return [Boolean] true if this product is deleted
+    def deleted?
+      !!deleted_at
+    end
+
+    # Determines if product is available. A product is available if it has not
+    # been deleted and the available_on date is in the past.
+    #
+    # @return [Boolean] true if this product is available
+    def available?
+      !(available_on.nil? || available_on.future?) && !deleted?
+    end
+
+    # Groups variants by the specified option type.
+    #
+    # @deprecated This method is not called in the Solidus codebase
+    # @param opt_type [String] the name of the option type to group by
+    # @param pricing_options [Spree::Config.pricing_options_class] the pricing options to search
+    #   for, default: the default pricing options
+    # @return [Hash] option_type as keys, array of variants as values.
+    def categorise_variants_from_option(opt_type, pricing_options = Spree::Config.default_pricing_options)
+      return {} unless option_types.include?(opt_type)
+      variants.with_prices(pricing_options).group_by { |v| v.option_values.detect { |o| o.option_type == opt_type } }
+    end
+    deprecate :categorise_variants_from_option, deprecator: Spree::Deprecation
+
+    # Poor man's full text search.
+    #
+    # Filters products to those which have any of the strings in +values+ in
+    # any of the fields in +fields+.
+    #
+    # @param fields [Array{String,Symbol}] columns of the products table to search for values
+    # @param values [Array{String}] strings to search through fields for
+    # @return [ActiveRecord::Relation] scope with WHERE clause for search applied
+    def self.like_any(fields, values)
+      conditions = fields.product(values).map do |(field, value)|
+        arel_table[field].matches("%#{value}%")
+      end
+      where conditions.inject(:or)
+    end
+
+    # @param current_currency [String] currency to filter variants by; defaults to Spree's default
+    # @deprecated This method can only handle prices for currencies
+    # @return [Array<Spree::Variant>] all variants with at least one option value
+    def variants_and_option_values(current_currency = nil)
+      variants.includes(:option_values).active(current_currency).select do |variant|
+        variant.option_values.any?
+      end
+    end
+    deprecate variants_and_option_values: :variants_and_option_values_for,
+              deprecator: Spree::Deprecation
+
+    # @param pricing_options [Spree::Variant::PricingOptions] the pricing options to search
+    #   for, default: the default pricing options
+    # @return [Array<Spree::Variant>] all variants with at least one option value
+    def variants_and_option_values_for(pricing_options = Spree::Config.default_pricing_options)
+      variants.includes(:option_values).with_prices(pricing_options).select do |variant|
+        variant.option_values.any?
+      end
+    end
+
+    # Groups all of the option values that are associated to the product's variants, grouped by
+    # option type.
+    #
+    # @param variant_scope [ActiveRecord_Associations_CollectionProxy] scope to filter the variants
+    # used to determine the applied option_types
+    # @return [Hash<Spree::OptionType, Array<Spree::OptionValue>>] all option types and option values
+    # associated with the products variants grouped by option type
+    def variant_option_values_by_option_type(variant_scope = nil)
+      option_value_scope = Spree::OptionValuesVariant.joins(:variant)
+        .where(spree_variants: { product_id: id })
+      option_value_scope = option_value_scope.merge(variant_scope) if variant_scope
+      option_value_ids = option_value_scope.distinct.pluck(:option_value_id)
+      Spree::OptionValue.where(id: option_value_ids).
+        includes(:option_type).
+        order("#{Spree::OptionType.table_name}.position, #{Spree::OptionValue.table_name}.position").
+        group_by(&:option_type)
+    end
+
+    # @return [Boolean] true if there are no option values
+    def empty_option_values?
+      options.empty? || !option_types.left_joins(:option_values).where('spree_option_values.id IS NULL').empty?
+    end
+
+    # @param property_name [String] the name of the property to find
+    # @return [String] the value of the given property. nil if property is undefined on this product
+    def property(property_name)
+      return nil unless prop = properties.find_by(name: property_name)
+      product_properties.find_by(property: prop).try(:value)
+    end
+
+    # Assigns the given value to the given property.
+    #
+    # @param property_name [String] the name of the property
+    # @param property_value [String] the property value
+    def set_property(property_name, property_value)
+      ActiveRecord::Base.transaction do
+        # Works around spree_i18n https://github.com/spree/spree/issues/301
+        property = Spree::Property.create_with(presentation: property_name).find_or_create_by(name: property_name)
+        product_property = Spree::ProductProperty.where(product: self, property: property).first_or_initialize
+        product_property.value = property_value
+        product_property.save!
+      end
+    end
+
+    # @return [Array] all advertised and not-rejected promotions
+    def possible_promotions
+      promotion_ids = promotion_rules.map(&:promotion_id).uniq
+      Spree::Promotion.advertised.where(id: promotion_ids).reject(&:inactive?)
+    end
+
+    # The number of on-hand stock items; Infinity if any variant does not track
+    # inventory.
+    #
+    # @return [Fixnum, Infinity]
+    def total_on_hand
+      if any_variants_not_track_inventory?
+        Float::INFINITY
+      else
+        stock_items.sum(:count_on_hand)
+      end
+    end
+
+    # Image that can be used for the product.
+    #
+    # Will first search for images on the product, then those belonging to the
+    # variants. If all else fails, will return a new image object.
+    # @return [Spree::Image] the image to display
+    def display_image
+      Spree::Deprecation.warn('Spree::Product#display_image is DEPRECATED. Choose an image from Spree::Product#gallery instead.')
+      images.first || variant_images.first || Spree::Image.new
+    end
+
+    # Finds the variant property rule that matches the provided option value ids.
+    #
+    # @param option_value_ids [Array<Integer>] list of option value ids
+    # @return [Spree::VariantPropertyRule] the matching variant property rule
+    def find_variant_property_rule(option_value_ids)
+      variant_property_rules.find do |rule|
+        rule.matches_option_value_ids?(option_value_ids)
+      end
+    end
+
+    # The gallery for the product, which represents all the images
+    # associated with it, including those on its variants
+    #
+    # @return [Spree::Gallery] the media for a variant
+    def gallery
+      @gallery ||= Spree::Config.product_gallery_class.new(self)
+    end
+
+    private
+
+    def any_variants_not_track_inventory?
+      if variants_including_master.loaded?
+        variants_including_master.any? { |v| !v.should_track_inventory? }
+      else
+        !Spree::Config.track_inventory_levels || variants_including_master.where(track_inventory: false).exists?
+      end
+    end
+
+    # Builds variants from a hash of option types & values
+    def build_variants_from_option_values_hash
+      ensure_option_types_exist_for_values_hash
+      values = option_values_hash.values
+      values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
+
+      values.each do |ids|
+        variants.create(
+          option_value_ids: ids,
+          price: master.price
+        )
+      end
+      save
+    end
+
+    def ensure_master
+      return unless new_record?
+      find_or_build_master
+    end
+
+    def normalize_slug
+      self.slug = normalize_friendly_id(slug)
+    end
+
+    def punch_slug
+      # punch slug with date prefix to allow reuse of original
+      update_column :slug, "#{Time.current.to_i}_#{slug}" unless frozen?
+    end
+
+    # If the master is invalid, the Product object will be assigned its errors
+    def validate_master
+      unless master.valid?
+        master.errors.each do |att, error|
+          errors.add(att, error)
+        end
+      end
+    end
+
+    # Try building a slug based on the following fields in increasing order of specificity.
+    def slug_candidates
+      [
+        :name,
+        [:name, :sku]
+      ]
+    end
+
+    def run_touch_callbacks
+      run_callbacks(:touch)
+    end
+
+    # Iterate through this product's taxons and taxonomies and touch their timestamps in a batch
+    def touch_taxons
+      taxons_to_touch = taxons.map(&:self_and_ancestors).flatten.uniq
+      unless taxons_to_touch.empty?
+        Spree::Taxon.where(id: taxons_to_touch.map(&:id)).update_all(updated_at: Time.current)
+
+        taxonomy_ids_to_touch = taxons_to_touch.map(&:taxonomy_id).flatten.uniq
+        Spree::Taxonomy.where(id: taxonomy_ids_to_touch).update_all(updated_at: Time.current)
+      end
+    end
+
+    def remove_taxon(taxon)
+      removed_classifications = classifications.where(taxon: taxon)
+      removed_classifications.each(&:remove_from_list)
+    end
+  end
+end
+
+require_dependency 'spree/product/scopes'

data/app/models/spree/product_option_type.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Spree
+  class ProductOptionType < Spree::Base
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types, touch: true
+    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
+    acts_as_list scope: :product
+  end
+end

data/app/models/spree/product_promotion_rule.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class ProductPromotionRule < Spree::Base
+    belongs_to :product
+    belongs_to :promotion_rule
+  end
+end

data/app/models/spree/product_property.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Spree
+  class ProductProperty < Spree::Base
+    include Spree::OrderedPropertyValueList
+
+    acts_as_list scope: :product
+
+    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
+    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
+
+    self.whitelisted_ransackable_attributes = ['value']
+  end
+end