spree_core 5.4.0.beta3 → 5.4.0.beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea9fcfc9e4ac5937296c789f151d5d431b60a2fadb131e5a7bca034cae47b2ab
-  data.tar.gz: e89e3fd21bf14b0bb0bda0de42c0ecc49d173add3d9ce58c29b3c781eafb55fa
+  metadata.gz: a2a4eae0b4e102ba4160e435fe81d656ced27b014ed013670226bb8a522b5996
+  data.tar.gz: c8c6737253472a4456f29b06f1ae028b2c4144732fba6dae7d8dd8c5e2b92d8f
 SHA512:
-  metadata.gz: b9bd748be9f9b4949d9b71887990fe3ac2377a6f4e7ed3d3060b0be073d6c199bd92a633bb2c62e7b8ee13dc0d7dae07e1bedd3d4d9dc5edebf3e4fc3839cae7
-  data.tar.gz: 8f8639ca080722372b01f91df71e54e0dc3f8f39d82cdbd1b3ad72103d995dbaf9bc50ef0f2a6032b0d400c2e94387edd2e06f64a52f3932391ed49ee5650014
+  metadata.gz: ec9479d52b6bcbd036354511897d0ee360da7784aef051f20affe23991b1eaebe8525b7a0173fbc7cdc1310a977909e4b78a33b0cd677869d579d1666bbada7a
+  data.tar.gz: 44b40ddca311ed24ae26cd99b5455a7259a0aa986cb8a9a76598101e4c42ea48042b8f1256365b2734c7e43218337ec7963c78b0bcffc5ab70f62e0f794d4b9e

data/app/jobs/spree/exports/generate_job.rb

@@ -4,7 +4,7 @@ module Spree
       queue_as Spree.queues.exports
 
       def perform(export_id)
-        export = Spree::Export.find(export_id)
+        export = Spree::Export.find_by_prefix_id!(export_id)
         export.generate
       end
     end

data/app/jobs/spree/images/save_from_url_job.rb

@@ -1,12 +1,15 @@
 require 'open-uri'
 require 'openssl'
+require 'ssrf_filter'
+require 'tempfile'
 
 module Spree
   module Images
     class SaveFromUrlJob < ::Spree::BaseJob
       queue_as Spree.queues.images
-      retry_on ActiveRecord::RecordInvalid, OpenURI::HTTPError, wait: :polynomially_longer, attempts: Spree::Config.images_save_from_url_job_attempts.to_i
+      retry_on ActiveRecord::RecordInvalid, wait: :polynomially_longer, attempts: Spree::Config.images_save_from_url_job_attempts.to_i
       discard_on URI::InvalidURIError
+      discard_on SsrfFilter::Error
 
       def perform(viewable_id, viewable_type, external_url, external_id = nil, position = nil)
         viewable = viewable_type.safe_constantize.find(viewable_id)
@@ -29,34 +32,55 @@ module Spree
         # still trigger save! if position has changed
         image.save! and return if image_already_saved?(image, external_url)
 
-        uri = URI.parse(external_url)
-        unless %w[http https].include?(uri.scheme)
-          raise URI::InvalidURIError, "Invalid URL scheme: #{uri.scheme}. Only http and https are allowed."
-        end
-
-        file = uri.open(
-          'User-Agent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-          'Accept' => 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
-          'Accept-Language' => 'en-US,en;q=0.9',
-          'Accept-Encoding' => 'gzip, deflate, br',
-          'Cache-Control' => 'no-cache',
-          'Pragma' => 'no-cache',
-          read_timeout: 60,
-          ssl_verify_mode: OpenSSL::SSL::VERIFY_PEER,
-          redirect: true
-        )
-        filename = File.basename(uri.path)
-
-        image.attachment.attach(io: file, filename: filename)
-        image.external_url = external_url
-        image.external_id = external_id if external_id.present? && image.respond_to?(:external_id)
-        image.save!
+        download_and_attach_image(external_url, image, external_id)
       rescue ActiveStorage::IntegrityError => e
         raise e unless Rails.env.test?
       end
 
       private
 
+      def download_and_attach_image(external_url, image, external_id)
+        max_size = Spree::Config.max_image_download_size
+
+        response = SsrfFilter.get(
+          external_url,
+          headers: {
+            'User-Agent' => 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept' => 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
+            'Accept-Language' => 'en-US,en;q=0.9',
+            'Accept-Encoding' => 'gzip, deflate, br',
+            'Cache-Control' => 'no-cache',
+            'Pragma' => 'no-cache'
+          },
+          http_options: {
+            read_timeout: 60,
+            open_timeout: 30
+          }
+        )
+
+        body = response.body
+        if body.bytesize > max_size
+          raise StandardError, "Image file size exceeds the maximum allowed size of #{max_size} bytes"
+        end
+
+        uri = URI.parse(external_url)
+        filename = File.basename(uri.path)
+        tempfile = Tempfile.new(['spree_image', File.extname(uri.path)], binmode: true)
+
+        begin
+          tempfile.write(body)
+          tempfile.rewind
+
+          image.attachment.attach(io: tempfile, filename: filename)
+          image.external_url = external_url
+          image.external_id = external_id if external_id.present? && image.respond_to?(:external_id)
+          image.save!
+        ensure
+          tempfile.close
+          tempfile.unlink
+        end
+      end
+
       def image_already_saved?(image, external_url)
         image.persisted? && image.attachment.attached? && image.external_url.present? && external_url == image.external_url
       end

data/app/jobs/spree/reports/generate_job.rb

@@ -4,7 +4,7 @@ module Spree
       queue_as Spree.queues.reports
 
       def perform(report_id)
-        report = Spree::Report.find(report_id)
+        report = Spree::Report.find_by_prefix_id!(report_id)
         report.generate
       end
     end

data/app/models/concerns/spree/product_scopes.rb

@@ -41,32 +41,38 @@ module Spree
         order(price_table_name => { amount: :desc })
       end
 
-      # Price sorting scopes that use subqueries to get prices across all variants
-      # These ensure products with only variant prices (no master price) are included in results
+      # Price sorting scopes that use a derived table JOIN to get prices across all variants.
+      # These ensure products with only variant prices (no master price) are included in results.
+      #
+      # Uses Arel::Nodes::As for select expressions so that:
+      # - PG allows ORDER BY with DISTINCT (expressions must appear in SELECT list)
+      # - Mobility's select_for_count can safely call .right on all select_values
       add_search_scope :ascend_by_price do
-        price_subquery = Price
-          .non_zero
-          .joins(:variant)
-          .where("#{Variant.table_name}.product_id = #{Product.table_name}.id")
-          .select('MIN(amount)')
+        price_agg_sql = Price.non_zero.joins(:variant)
+                            .select("#{Variant.table_name}.product_id AS product_id, MIN(#{Price.table_name}.amount) AS agg_price")
+                            .group("#{Variant.table_name}.product_id")
+                            .to_sql
 
-        price_sort_sql = "COALESCE((#{price_subquery.to_sql}), 999999999)"
+        price_expr = Arel.sql('COALESCE(price_agg.agg_price, 999999999)')
 
-        select("#{Product.table_name}.*", "#{price_sort_sql} AS min_price").
-          order(Arel.sql("#{price_sort_sql} ASC"))
+        joins("LEFT JOIN (#{price_agg_sql}) AS price_agg ON price_agg.product_id = #{Product.table_name}.id").
+          select("#{Product.table_name}.*").
+          select(Arel::Nodes::As.new(price_expr, Arel.sql('min_price'))).
+          order(price_expr.asc)
       end
 
       add_search_scope :descend_by_price do
-        price_subquery = Price
-          .non_zero
-          .joins(:variant)
-          .where("#{Variant.table_name}.product_id = #{Product.table_name}.id")
-          .select('MAX(amount)')
+        price_agg_sql = Price.non_zero.joins(:variant)
+                            .select("#{Variant.table_name}.product_id AS product_id, MAX(#{Price.table_name}.amount) AS agg_price")
+                            .group("#{Variant.table_name}.product_id")
+                            .to_sql
 
-        price_sort_sql = "COALESCE((#{price_subquery.to_sql}), 0)"
+        price_expr = Arel.sql('COALESCE(price_agg.agg_price, 0)')
 
-        select("#{Product.table_name}.*", "#{price_sort_sql} AS max_price").
-          order(Arel.sql("#{price_sort_sql} DESC"))
+        joins("LEFT JOIN (#{price_agg_sql}) AS price_agg ON price_agg.product_id = #{Product.table_name}.id").
+          select("#{Product.table_name}.*").
+          select(Arel::Nodes::As.new(price_expr, Arel.sql('max_price'))).
+          order(price_expr.desc)
       end
 
       add_search_scope :price_between do |low, high|
@@ -81,6 +87,25 @@ module Spree
         where(Price.table_name => { amount: price.. })
       end
 
+      # Joins spree_variants and spree_stock_items directly (without association
+      # aliases) so that the table names stay as-is. This avoids alias conflicts
+      # when combined with other scopes (e.g., price sorting) that also join
+      # spree_variants through associations which generate aliases.
+      def self.join_variants_and_stock_items
+        joins("INNER JOIN #{Variant.table_name} ON #{Variant.table_name}.deleted_at IS NULL AND #{Variant.table_name}.product_id = #{Product.table_name}.id").
+          joins("LEFT OUTER JOIN #{StockItem.table_name} ON #{StockItem.table_name}.deleted_at IS NULL AND #{StockItem.table_name}.variant_id = #{Variant.table_name}.id")
+      end
+      private_class_method :join_variants_and_stock_items
+
+      # Mirrors Spree::Variant.in_stock_or_backorderable logic using raw table
+      # names (to pair with join_variants_and_stock_items).
+      scope :in_stock_or_backorderable_condition, -> {
+        where(
+          "#{Variant.table_name}.track_inventory = ? OR #{StockItem.table_name}.count_on_hand > ? OR #{StockItem.table_name}.backorderable = ?",
+          false, 0, true
+        )
+      }
+
       # Can't use add_search_scope for this as it needs a default argument
       # Ransack calls with '1' to activate, '0' or nil to skip
       # In Ruby code: in_stock(true) for in-stock, in_stock(false) for out-of-stock
@@ -88,26 +113,34 @@ module Spree
         if in_stock == '0' || !in_stock
           all
         else
-          joins(:variants_including_master).merge(Spree::Variant.in_stock_or_backorderable)
+          join_variants_and_stock_items.in_stock_or_backorderable_condition
         end
       end
+
+      add_search_scope :price_lte do |price|
+        where(Price.table_name => { amount: ..price })
+      end
+
+      add_search_scope :price_gte do |price|
+        where(Price.table_name => { amount: price.. })
+      end
       search_scopes << :in_stock
 
       def self.out_of_stock(out_of_stock = true)
         if out_of_stock == '0' || !out_of_stock
           all
         else
-          where.not(id: joins(:variants_including_master).merge(Spree::Variant.in_stock_or_backorderable))
+          where.not(id: join_variants_and_stock_items.in_stock_or_backorderable_condition)
         end
       end
       search_scopes << :out_of_stock
 
       add_search_scope :backorderable do
-        joins(:variants_including_master).merge(Spree::Variant.backorderable)
+        join_variants_and_stock_items.where(StockItem.table_name => { backorderable: true })
       end
 
       add_search_scope :in_stock_or_backorderable do
-        joins(:variants_including_master).merge(Spree::Variant.in_stock_or_backorderable)
+        join_variants_and_stock_items.in_stock_or_backorderable_condition
       end
 
       # This scope selects products in taxon AND all its descendants
@@ -132,6 +165,11 @@ module Spree
           where("#{Classification.table_name}.taxon_id" => taxon.cached_self_and_descendants_ids).distinct
       end
 
+      # Alias for in_taxon — public API name
+      add_search_scope :in_category do |category|
+        in_taxon(category)
+      end
+
       # This scope selects products in all taxons AND all its descendants
       # If you need products only within one taxon use
       #
@@ -196,9 +234,7 @@ module Spree
 
         return none if actual_ids.empty?
 
-        group("#{Spree::Product.table_name}.id").
-          joins(variants: :option_values).
-          where(Spree::OptionValue.table_name => { id: actual_ids })
+        joins(variants: :option_values).where(Spree::OptionValue.table_name => { id: actual_ids })
       end
 
       # Finds all products which have an option value with the name matching the one given
@@ -260,7 +296,7 @@ module Spree
 
       def self.not_discontinued(only_not_discontinued = true)
         if only_not_discontinued != '0' && only_not_discontinued
-          where(discontinue_on: [nil, Time.current..])
+          where(discontinue_on: [nil, Time.current.beginning_of_minute..])
         else
           all
         end
@@ -278,7 +314,10 @@ module Spree
       # Can't use add_search_scope for this as it needs a default argument
       def self.available(available_on = nil, currency = nil)
         scope = not_discontinued.where(status: 'active')
-        scope = scope.where("#{Product.quoted_table_name}.available_on <= ?", available_on) if available_on
+        if available_on
+          available_on = available_on.beginning_of_minute if available_on.respond_to?(:beginning_of_minute)
+          scope = scope.where("#{Product.quoted_table_name}.available_on <= ?", available_on)
+        end
 
         unless Spree::Config.show_products_without_price
           currency ||= Spree::Store.default.default_currency
@@ -314,25 +353,22 @@ module Spree
       end
 
       # Orders products by best selling based on units_sold_count and revenue
-      # stored in spree_products_stores table.
+      # from spree_products_stores (already joined via store.products).
       #
-      # These metrics are updated asynchronously when orders are completed
-      # via the ProductMetricsSubscriber.
-      #
-      # @param order_direction [Symbol] :desc (default) or :asc
-      # @return [ActiveRecord::Relation]
+      # Uses Arel::Nodes::As so that ORDER BY expressions appear in SELECT
+      # and work with DISTINCT (same pattern as the price sorting scopes).
       add_search_scope :by_best_selling do |order_direction = :desc|
-        store_id = Spree::Current.store&.id
-        sp_table = StoreProduct.arel_table
-        products_table = Product.arel_table
-
-        conditions = sp_table[:product_id].eq(products_table[:id]).and(sp_table[:store_id].eq(store_id))
-
-        units_sold = Arel::Nodes::NamedFunction.new('COALESCE', [sp_table.project(sp_table[:units_sold_count]).where(conditions), 0])
-        revenue = Arel::Nodes::NamedFunction.new('COALESCE', [sp_table.project(sp_table[:revenue]).where(conditions), 0])
+        sp_table = StoreProduct.table_name
+        units_expr = Arel.sql("COALESCE(#{sp_table}.units_sold_count, 0)")
+        revenue_expr = Arel.sql("COALESCE(#{sp_table}.revenue, 0)")
 
         order_dir = order_direction == :desc ? :desc : :asc
-        order(units_sold.send(order_dir)).order(revenue.send(order_dir))
+
+        select("#{Product.table_name}.*").
+          select(Arel::Nodes::As.new(units_expr, Arel.sql('best_selling_units'))).
+          select(Arel::Nodes::As.new(revenue_expr, Arel.sql('best_selling_revenue'))).
+          order(units_expr.send(order_dir)).
+          order(revenue_expr.send(order_dir))
       end
 
       # .search_by_name

data/app/models/concerns/spree/user_methods.rb

@@ -4,6 +4,7 @@ module Spree
 
     include Spree::PrefixedId
     include Spree::Metafields
+    include Spree::Metadata
     include Spree::UserPaymentSource
     include Spree::UserReporting
     include Spree::UserRoles

data/app/models/spree/address.rb

@@ -27,8 +27,6 @@ module Spree
     # those attributes depending of the logic of their applications
     ADDRESS_FIELDS = %w(firstname lastname company address1 address2 city state zipcode country phone)
     EXCLUDED_KEYS_FOR_COMPARISON = %w(id updated_at created_at deleted_at label user_id public_metadata private_metadata)
-    FIELDS_TO_NORMALIZE = %w(firstname lastname phone alternative_phone company address1 address2 city zipcode)
-
     if defined?(Spree::Security::Addresses)
       include Spree::Security::Addresses
     end
@@ -53,7 +51,6 @@ module Spree
     before_validation :normalize_country
     before_validation :normalize_state
     before_validation :clear_invalid_state_entities, if: -> { country.present? }, on: :update
-    before_validation :remove_emoji_and_normalize
 
     after_create :set_user_attributes, if: -> { user.present? }
 
@@ -294,17 +291,6 @@ module Spree
       end
     end
 
-    def remove_emoji_and_normalize
-      attributes_to_normalize = attributes.slice(*FIELDS_TO_NORMALIZE)
-      normalized_attributes = attributes_to_normalize.compact_blank.deep_transform_values do |value|
-        NormalizeString.remove_emoji_and_normalize(value.to_s).strip
-      end
-
-      normalized_attributes.transform_keys! { |key| key.gsub('original_', '') } if defined?(Spree::Security::Addresses)
-
-      assign_attributes(normalized_attributes)
-    end
-
     def set_user_attributes
       if user.name.blank?
         user.first_name = firstname

data/app/models/spree/category.rb

@@ -0,0 +1,6 @@
+module Spree
+  # Public API name for Taxon. Will become the base class in 6.0
+  # when spree_taxons table is renamed to spree_categories.
+  class Category < Taxon
+  end
+end

data/app/models/spree/country.rb

@@ -38,29 +38,8 @@ module Spree
       iso.upcase.chars.map { |c| (c.ord + 127397).chr(Encoding::UTF_8) }.join
     end
 
-    # Returns the currency for this country from its market in the current store.
-    # Looks up which market contains this country and returns that market's currency.
-    #
-    # @return [String, nil] currency code (e.g., 'USD', 'EUR') or nil if no market found
-    def market_currency
-      current_market&.currency
-    end
-
-    # Returns the default locale for this country from its market in the current store.
-    # Looks up which market contains this country and returns that market's default locale.
-    #
-    # @return [String, nil] locale code (e.g., 'en', 'de') or nil if no market found
-    def market_locale
-      current_market&.default_locale
-    end
-
-    # Returns the supported locales for this country from its market in the current store.
-    #
-    # @return [Array<String>] locale codes (e.g., ['en', 'fr']) or empty array if no market found
-    def market_supported_locales
-      current_market&.supported_locales_list || []
-    end
-
+    # Lookups Market for Country for the current Store
+    # @return [Spree::Market, nil]
     def current_market
       @current_market ||= Spree::Current.store&.market_for_country(self)
     end

data/app/models/spree/coupon_code.rb

@@ -19,7 +19,8 @@ module Spree
     validates :code, presence: true, uniqueness: { scope: spree_base_uniqueness_scope, conditions: -> { where(deleted_at: nil) } }
     validates :state, :promotion, presence: true
 
-    self.whitelisted_ransackable_attributes = %w[state code]
+    self.whitelisted_ransackable_attributes = %w[state code promotion_id]
+    self.whitelisted_ransackable_associations = %w[promotion]
 
     def self.used?(code)
       used_with_code(code).any?
@@ -36,5 +37,9 @@ module Spree
     def display_code
       code.upcase
     end
+
+    def to_csv(_store = nil)
+      Spree::CSV::CouponCodePresenter.new(self).call
+    end
   end
 end

data/app/models/spree/current.rb

@@ -34,10 +34,11 @@ module Spree
       super || market&.default_locale || store&.default_locale
     end
 
-    # Returns the current tax zone, falling back to the default tax zone.
+    # Returns the current tax zone.
+    # Fallback: market's tax zone (from default country) -> global default tax zone.
     # @return [Spree::Zone, nil]
     def zone
-      super || default_tax_zone
+      super || market&.tax_zone || default_tax_zone
     end
 
     # Returns the default tax zone (memoized per request).

data/app/models/spree/exports/coupon_codes.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Exports
+    class CouponCodes < Spree::Export
+      def csv_headers
+        Spree::CSV::CouponCodePresenter::HEADERS
+      end
+
+      def scope_includes
+        [:promotion, :order]
+      end
+
+      def scope
+        model_class.joins(promotion: :stores).where(spree_stores: { id: store.id })
+                   .accessible_by(current_ability)
+      end
+    end
+  end
+end

data/app/models/spree/market.rb

@@ -64,6 +64,14 @@ module Spree
       countries.order(:name).first
     end
 
+    # Returns the tax zone matching this market's default country.
+    # Used by Spree::Current to determine the browsing tax zone before a customer enters an address.
+    #
+    # @return [Spree::Zone, nil]
+    def tax_zone
+      @tax_zone ||= Spree::Zone.match(default_country)
+    end
+
     # Returns supported locales as an array, always including default_locale
     #
     # @return [Array<String>]

data/app/models/spree/payment/gateway_options.rb

@@ -34,6 +34,10 @@ module Spree
         payment.number
       end
 
+      def idempotency_key
+        "spree-#{payment.number}"
+      end
+
       def shipping
         order.ship_total * exchange_multiplier
       end
@@ -66,6 +70,7 @@ module Spree
           :ip,
           :order_id,
           :payment_id,
+          :idempotency_key,
           :shipping,
           :tax,
           :subtotal,

data/app/models/spree/product.rb

@@ -40,9 +40,9 @@ module Spree
 
     publishes_lifecycle_events
 
-    MEMOIZED_METHODS = %w[total_on_hand taxonomy_ids taxon_and_ancestors category
+    MEMOIZED_METHODS = %w[total_on_hand taxonomy_ids taxon_and_ancestors
                           default_variant_id tax_category default_variant variant_for_images
-                          category_taxon brand_taxon main_taxon
+                          brand_taxon main_taxon
                           purchasable? in_stock? backorderable? digital?]
 
     STATUSES = %w[draft active archived].freeze
@@ -74,6 +74,7 @@ module Spree
     has_many :option_types, through: :product_option_types
     has_many :classifications, -> { order(created_at: :asc) }, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
+    has_many :categories, through: :classifications, class_name: 'Spree::Category', source: :taxon
     has_many :taxonomies, through: :taxons
 
     has_many :product_promotion_rules, class_name: 'Spree::ProductPromotionRule'
@@ -217,10 +218,12 @@ module Spree
     alias options product_option_types
 
     self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status available_on created_at updated_at]
-    self.whitelisted_ransackable_associations = %w[taxons stores variants_including_master master variants tags labels
+    self.whitelisted_ransackable_associations = %w[taxons categories stores variants_including_master master variants tags labels
                                                    shipping_category classifications option_types]
     self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon price_between
+                                             price_lte price_gte
                                              multi_search in_stock out_of_stock with_option_value_ids
+
                                              ascend_by_price descend_by_price]
 
     [
@@ -554,40 +557,10 @@ module Spree
       brand&.name
     end
 
-    # Returns the category for the product
-    # If a category association is defined (e.g., belongs_to :category), it will be used
-    # Otherwise, falls back to category_taxon for compatibility
-    # @return [Spree::Category, Spree::Taxon]
-    def category
-      if self.class.reflect_on_association(:category)
-        super
-      else
-        Spree::Deprecation.warn('Spree::Product#category is deprecated and will be removed in Spree 5.5. Please use Spree::Product#category_taxon instead.')
-        category_taxon
-      end
-    end
-
-    # Returns the category taxon for the product
-    # @return [Spree::Taxon]
-    def category_taxon
-      @category_taxon ||= if classification_count.zero?
-                            nil
-                          elsif Spree.use_translations?
-                            taxons.joins(:taxonomy).
-                              join_translation_table(Taxonomy).
-                              order(depth: :desc).
-                              find_by(Taxonomy.translation_table_alias => { name: Spree.t(:taxonomy_categories_name) })
-                          elsif taxons.loaded?
-                            taxons.find { |taxon| taxon.taxonomy.name == Spree.t(:taxonomy_categories_name) }
-                          else
-                            taxons.joins(:taxonomy).order(depth: :desc).find_by(Taxonomy.table_name => { name: Spree.t(:taxonomy_categories_name) })
-                          end
-    end
-
     def main_taxon
       return if classification_count.zero?
 
-      @main_taxon ||= category_taxon || taxons.first
+      @main_taxon ||= taxons.first
     end
 
     def taxons_for_store(store)