solidus_core 3.1.7 → 3.2.0.alpha

data/app/models/spree/promotion/rules/user.rb

@@ -9,6 +9,10 @@ module Spree
                                         dependent: :destroy
         has_many :users, through: :promotion_rule_users, class_name: Spree::UserClassHandle.new
 
+        def preload_relations
+          [:users]
+        end
+
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end

data/app/models/spree/promotion.rb

@@ -3,6 +3,7 @@
 module Spree
   class Promotion < Spree::Base
     MATCH_POLICIES = %w(all any)
+
     UNACTIVATABLE_ORDER_STATES = ["complete", "awaiting_return", "returned"]
 
     attr_reader :eligibility_errors
@@ -67,6 +68,19 @@ module Spree
       ).first
     end
 
+    # All orders that have been discounted using this promotion
+    def discounted_orders
+      Spree::Order.
+        joins(:all_adjustments).
+        where(
+          spree_adjustments: {
+            source_type: "Spree::PromotionAction",
+            source_id: actions.map(&:id),
+            eligible: true
+          }
+        ).distinct
+    end
+
     def as_json(options = {})
       options[:except] ||= :code
       super
@@ -151,7 +165,7 @@ module Spree
       return [] if rules.none?
 
       eligible = lambda { |rule| rule.eligible?(promotable, options) }
-      specific_rules = rules.for(promotable)
+      specific_rules = rules.select { |rule| rule.applicable?(promotable) }
       return [] if specific_rules.none?
 
       if match_all?
@@ -163,6 +177,12 @@ module Spree
         end
         specific_rules
       else
+        Spree::Deprecation.warn(
+        <<~WARN
+          Your promotion "#{name}" with ID #{id} has a match_policy of 'any'.
+          This is deprecated, please split the promotion into separate promotions for each rule.
+        WARN
+        )
         unless specific_rules.any?(&eligible)
           @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
           return nil
@@ -190,11 +210,11 @@ module Spree
     # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
     # @return [Integer] usage count
     def usage_count(excluded_orders: [])
-      Spree::Adjustment.promotion.
-        eligible.
-        in_completed_orders(excluded_orders: excluded_orders, exclude_canceled: true).
-        where(source_id: actions).
-        count(:order_id)
+      discounted_orders.
+        complete.
+        where.not(id: [excluded_orders.map(&:id)]).
+        where.not(spree_orders: { state: :canceled }).
+        count
     end
 
     def line_item_actionable?(order, line_item, promotion_code: nil)
@@ -215,21 +235,12 @@ module Spree
     end
 
     def used_by?(user, excluded_orders = [])
-      [
-        :adjustments,
-        :line_item_adjustments,
-        :shipment_adjustments
-      ].any? do |adjustment_type|
-        user.orders.complete.joins(adjustment_type).where(
-          spree_adjustments: {
-            source_type: "Spree::PromotionAction",
-            source_id: actions.map(&:id),
-            eligible: true
-          }
-        ).where.not(
-          id: excluded_orders.map(&:id)
-        ).any?
-      end
+      discounted_orders.
+        complete.
+        where.not(id: excluded_orders.map(&:id)).
+        where(user: user).
+        where.not(spree_orders: { state: :canceled }).
+        exists?
     end
 
     # Removes a promotion and any adjustments or other side effects from an
@@ -251,9 +262,9 @@ module Spree
     def blacklisted?(promotable)
       case promotable
       when Spree::LineItem
-        !promotable.product.promotionable?
+        !promotable.variant.product.promotionable?
       when Spree::Order
-        promotable.line_items.joins(:product).where(spree_products: { promotionable: false }).exists?
+        promotable.line_items.any? { |line_item| !line_item.variant.product.promotionable? }
       end
     end
 

data/app/models/spree/promotion_action.rb

@@ -16,6 +16,10 @@ module Spree
     scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
     scope :shipping, -> { of_type(Spree::Config.environment.promotions.shipping_actions.to_a) }
 
+    def preload_relations
+      []
+    end
+
     # Updates the state of the order or performs some other action depending on
     # the subclass options will contain the payload from the event that
     # activated the promotion. This will include the key :user which allows

data/app/models/spree/promotion_code.rb

@@ -28,10 +28,14 @@ class Spree::PromotionCode < Spree::Base
   # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
   # @return [Integer] usage count
   def usage_count(excluded_orders: [])
-    adjustments.
-    eligible.
-    in_completed_orders(excluded_orders: excluded_orders, exclude_canceled: true).
-    count(:order_id)
+    promotion.
+      discounted_orders.
+      complete.
+      where.not(spree_orders: { state: :canceled }).
+      joins(:order_promotions).
+      where(spree_orders_promotions: { promotion_code_id: self.id }).
+      where.not(id: excluded_orders.map(&:id)).
+      count
   end
 
   def usage_limit

data/app/models/spree/promotion_handler/cart.rb

@@ -33,23 +33,43 @@ module Spree
       private
 
       def promotions
-        connected_order_promotions | sale_promotions
+        promos = connected_order_promotions | sale_promotions
+        promos.flat_map(&:promotion_actions).group_by(&:preload_relations).each do |preload_relations, actions|
+          preload(records: actions, associations: preload_relations)
+        end
+        promos.flat_map(&:promotion_rules).group_by(&:preload_relations).each do |preload_relations, rules|
+          preload(records: rules, associations: preload_relations)
+        end
+        promos
+      end
+
+      def preload(records:, associations:)
+        if Rails::VERSION::MAJOR >= 7
+          ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
+        else
+          ActiveRecord::Associations::Preloader.new.preload(records, associations)
+        end
       end
 
       def connected_order_promotions
-        Spree::Promotion.active.includes(:promotion_rules).
-          joins(:order_promotions).
-          where(spree_orders_promotions: { order_id: order.id }).readonly(false).to_a
+        order.promotions.active.includes(promotion_includes)
       end
 
       def sale_promotions
-        Spree::Promotion.where(apply_automatically: true).active.includes(:promotion_rules)
+        Spree::Promotion.where(apply_automatically: true).active.includes(promotion_includes)
       end
 
       def promotion_code(promotion)
-        order_promotion = Spree::OrderPromotion.where(order: order, promotion: promotion).first
+        order_promotion = order.order_promotions.detect { |op| op.promotion_id == promotion.id }
         order_promotion.present? ? order_promotion.promotion_code : nil
       end
+
+      def promotion_includes
+        [
+          :promotion_rules,
+          :promotion_actions,
+        ]
+      end
     end
   end
 end

data/app/models/spree/promotion_rule.rb

@@ -14,9 +14,14 @@ module Spree
     validates :promotion, presence: true
     validate :unique_per_promotion, on: :create
 
+    def preload_relations
+      []
+    end
+
     def self.for(promotable)
       all.select { |rule| rule.applicable?(promotable) }
     end
+    deprecate :for, "Please select promotion rules by their applicable status on the promotable instead."
 
     def applicable?(_promotable)
       raise NotImplementedError, "applicable? should be implemented in a sub-class of Spree::PromotionRule"

data/app/models/spree/reimbursement.rb

@@ -92,10 +92,10 @@ module Spree
 
       if unpaid_amount_within_tolerance?
         reimbursed!
-        Spree::Event.fire 'reimbursement_reimbursed', reimbursement: self
+        Spree::Bus.publish :reimbursement_reimbursed, reimbursement: self
       else
         errored!
-        Spree::Event.fire 'reimbursement_errored', reimbursement: self
+        Spree::Bus.publish :reimbursement_errored, reimbursement: self
       end
 
       if errored?

data/app/models/spree/return_item.rb

@@ -30,7 +30,7 @@ module Spree
     self.refund_amount_calculator = Calculator::Returns::DefaultRefundAmount
 
     belongs_to :return_authorization, inverse_of: :return_items, optional: true
-    belongs_to :inventory_unit, inverse_of: :return_items, optional: true
+    belongs_to :inventory_unit, inverse_of: :return_items
     belongs_to :exchange_variant, class_name: 'Spree::Variant', optional: true
     belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item, optional: true
     belongs_to :customer_return, inverse_of: :return_items, optional: true
@@ -42,7 +42,6 @@ module Spree
     validate :eligible_exchange_variant
     validate :belongs_to_same_customer_order
     validate :validate_acceptance_status_for_reimbursement
-    validates :inventory_unit, presence: true
     validate :validate_no_other_completed_return_items
 
     after_create :cancel_others, unless: :cancelled?

data/app/models/spree/stock/allocator/on_hand_first.rb

@@ -7,11 +7,11 @@ module Spree
         def allocate_inventory(desired)
           # Allocate any available on hand inventory
           on_hand = allocate_on_hand(desired)
-          desired -= on_hand.values.sum if on_hand.present?
+          desired -= on_hand.values.reduce(&:+) if on_hand.present?
 
           # Allocate remaining desired inventory from backorders
           backordered = allocate_backordered(desired)
-          desired -= backordered.values.sum if backordered.present?
+          desired -= backordered.values.reduce(&:+) if backordered.present?
 
           # If all works at this point desired must be empty
           [on_hand, backordered, desired]

data/app/models/spree/stock/quantifier.rb

@@ -6,14 +6,18 @@ module Spree
       attr_reader :stock_items
 
       # @param [Variant] variant The variant to check inventory for.
-      # @param [StockLocation, Integer] stock_location The stock_location to check inventory in. If unspecified it will check inventory in all available StockLocations
-      def initialize(variant, stock_location = nil)
+      # @param [StockLocation, Integer] stock_location_or_id
+      #        The stock_location or stock location ID to check inventory in.
+      #        If unspecified it will check inventory in all available StockLocations
+      def initialize(variant, stock_location_or_id = nil)
         @variant = variant
-        @stock_items = Spree::StockItem.where(variant_id: variant)
-        if stock_location
-          @stock_items.where!(stock_location: stock_location)
-        else
-          @stock_items.joins!(:stock_location).merge!(Spree::StockLocation.active)
+        @stock_items = variant.stock_items.select do |stock_item|
+          if stock_location_or_id
+            stock_item.stock_location == stock_location_or_id ||
+              stock_item.stock_location_id == stock_location_or_id
+          else
+            stock_item.stock_location.active?
+          end
         end
       end
 
@@ -23,7 +27,7 @@ module Spree
       #   inventory is not tracked on the variant.
       def total_on_hand
         if @variant.should_track_inventory?
-          stock_items.sum(:count_on_hand)
+          stock_items.sum(&:count_on_hand)
         else
           Float::INFINITY
         end

data/app/models/spree/stock/simple_coordinator.rb

@@ -24,7 +24,8 @@ module Spree
 
       def initialize(order, inventory_units = nil)
         @order = order
-        @inventory_units = inventory_units || InventoryUnitBuilder.new(order).units
+        @inventory_units =
+          inventory_units || Spree::Config.stock.inventory_unit_builder_class.new(order).units
         @splitters = Spree::Config.environment.stock_splitters
 
         filtered_stock_locations = Spree::Config.stock.location_filter_class.new(Spree::StockLocation.all, @order).filter

data/app/models/spree/tax/item_tax.rb

@@ -5,9 +5,10 @@ module Spree
     # Simple object used to hold tax data for an item.
     #
     # This generic object will hold the amount of tax that should be applied to
-    # an item. (Either a {Spree::LineItem} or a {Spree::Shipment}.)
+    # an item. (Either a {Spree::Order}, a {Spree::LineItem} or a {Spree::Shipment}.)
     #
-    # @attr_reader [Integer] item_id the {Spree::LineItem} or {Spree::Shipment} ID
+    # @attr_reader [Integer] item_id the {Spree::LineItem} or {Spree::Shipment} ID.
+    #   Or blank if an order-level tax.
     # @attr_reader [String] label information about the taxes
     # @attr_reader [Spree::TaxRate] tax_rate will be used as the source for tax
     #   adjustments

data/app/models/spree/tax/order_tax.rb

@@ -8,13 +8,15 @@ module Spree
     # adjustments on an order.
     #
     # @attr_reader [Integer] order_id the {Spree::Order} these taxes apply to
+    # @attr_reader [Array<Spree::Tax::ItemTax>] order_taxes an array of tax
+    #   data for the order
     # @attr_reader [Array<Spree::Tax::ItemTax>] line_item_taxes an array of
     #   tax data for order's line items
     # @attr_reader [Array<Spree::Tax::ItemTax>] shipment_taxes an array of
     #   tax data for the order's shipments
     class OrderTax
       include ActiveModel::Model
-      attr_accessor :order_id, :line_item_taxes, :shipment_taxes
+      attr_accessor :order_id, :order_taxes, :line_item_taxes, :shipment_taxes
     end
   end
 end

data/app/models/spree/tax/tax_location.rb

@@ -8,7 +8,7 @@ module Spree
     # @attr_reader [Integer] country_id the ID of a Spree::Country object
     # @attr_reader [Integer] state_id the ID of a Spree::State object
     class TaxLocation
-      attr_reader :country_id, :state_id
+      attr_reader :country, :state
 
       # Create a new TaxLocation object
       #
@@ -19,18 +19,15 @@ module Spree
       #
       # @return [Spree::Tax::TaxLocation] a Spree::Tax::TaxLocation object
       def initialize(country: nil, state: nil)
-        @country_id = country && country.id
-        @state_id = state && state.id
+        @country, @state = country, state
       end
+      delegate :id, to: :state, prefix: true, allow_nil: true
+      delegate :id, to: :country, prefix: true, allow_nil: true
 
       def ==(other)
         state_id == other.state_id && country_id == other.country_id
       end
 
-      def country
-        Spree::Country.find_by(id: country_id)
-      end
-
       def empty?
         country_id.nil? && state_id.nil?
       end

data/app/models/spree/tax_rate.rb

@@ -27,6 +27,8 @@ module Spree
 
     validates :amount, presence: true, numericality: true
 
+    self.whitelisted_ransackable_associations = %w[tax_categories zone]
+
     # Finds all tax rates whose zones match a given address
     scope :for_address, ->(address) { joins(:zone).merge(Spree::Zone.for_address(address)) }
     scope :for_country,

data/app/models/spree/variant.rb

@@ -66,7 +66,7 @@ module Spree
 
     validates :cost_price, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
     validates :price,      numericality: { greater_than_or_equal_to: 0, allow_nil: true }
-    validates_uniqueness_of :sku, allow_blank: true, case_sensitive: true, if: :enforce_unique_sku?
+    validates_uniqueness_of :sku, allow_blank: true, case_sensitive: true, conditions: -> { where(deleted_at: nil) }, if: :enforce_unique_sku?
 
     after_create :create_stock_items
     after_create :set_position

data/app/subscribers/spree/mailer_subscriber.rb

@@ -3,6 +3,10 @@
 require 'spree/event/subscriber'
 
 module Spree
+  # Legacy subscriber
+  #
+  # This subscriber module is used by the legacy pub/sub system (see
+  # {Spree::Event}).
   module MailerSubscriber
     include Spree::Event::Subscriber
 

data/app/subscribers/spree/order_mailer_subscriber.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Spree
+  # Mailing after events on a {Spree::Order}
+  class OrderMailerSubscriber
+    include Omnes::Subscriber
+
+    handle :order_finalized,
+           with: :send_confirmation_email,
+           id: :spree_order_mailer_send_confirmation_email
+
+    handle :reimbursement_reimbursed,
+           with: :send_reimbursement_email,
+           id: :spree_order_mailer_send_reimbursement_email
+
+    # Sends confirmation email to the user
+    #
+    # @param event [Omnes::UnstructuredEvent]
+    def send_confirmation_email(event)
+      order = event[:order]
+      unless order.confirmation_delivered?
+        Spree::Config.order_mailer_class.confirm_email(order).deliver_later
+        order.update_column(:confirmation_delivered, true)
+      end
+    end
+
+    # Sends reimbursement email to the user
+    #
+    # @param event [Omnes::UnstructuredEvent]
+    def send_reimbursement_email(event)
+      reimbursement = event[:reimbursement]
+      Spree::Config.reimbursement_mailer_class.reimbursement_email(reimbursement.id).deliver_later
+    end
+  end
+end

data/config/locales/en.yml

@@ -365,7 +365,7 @@ en:
         amount_authorized: Amount Authorized
         amount_credited: Amount Credited
         amount_used: Amount Used
-        category_id: Credit Type
+        category_id: Category
         created_at: Issued On
         created_by_id: Created By
         invalidated_at: Invalidated
@@ -866,6 +866,10 @@ en:
           new_price: New Price
         new:
           new_price: New Price
+        master_variant_table:
+          master_variant: Master Variant Prices
+        table:
+          variant_pricing: Variant Prices
       promotions:
         actions:
           calculator_label: Calculated by
@@ -998,12 +1002,16 @@ en:
           edit_variant: Edit Variant
         form:
           dimensions: Dimensions
+          options: Options
           pricing: Pricing
           pricing_hint: These values are populated from the product details page and
             can be overridden below
+          properties: Properties
           use_product_tax_category: Use Product Tax Category
         new:
           new_variant: New Variant
+        table:
+          no_variants_found: No variants found for '%{term}'
         table_filter:
           show_deleted: Show Deleted Variants
     administration: Administration
@@ -2248,7 +2256,6 @@ en:
     value: Value
     variant: Variant
     variant_placeholder: Choose a Variant
-    variant_pricing: Variant Pricing
     variant_properties: Variant Properties
     variant_search: Variant Search
     variant_search_placeholder: SKU or Option Value

data/db/migrate/20201127212108_add_type_before_removal_to_spree_payment_methods.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddTypeBeforeRemovalToSpreePaymentMethods < ActiveRecord::Migration[5.2]
+  def change
+    add_column :spree_payment_methods, :type_before_removal, :string
+  end
+end

data/db/migrate/20220317165036_set_promotions_with_any_policy_to_all_if_possible.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class SetPromotionsWithAnyPolicyToAllIfPossible < ActiveRecord::Migration[5.2]
+  def up
+    Spree::Promotion.where(match_policy: :any).includes(:promotion_rules).all.each do |promotion|
+      if promotion.promotion_rules.length <= 1
+        promotion.update!(match_policy: :all)
+      else
+        raise StandardError, <<~MSG
+          You have promotions with a match policy of any and more than one rule. Please
+          run `bundle exec rake solidus:split_promotions_with_any_match_policy`.
+        MSG
+      end
+    end
+  end
+
+  def down
+    # No-Op
+  end
+end

data/lib/generators/solidus/install/install_generator/bundler_context.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Solidus
+  class InstallGenerator < Rails::Generators::Base
+    # Bundler context during the install process.
+    #
+    # This class gives access to information about the bundler context in which
+    # the install generator is run. I.e., which solidus components are present
+    # in the user's Gemfile. It also allows modifying the Gemfile to add or
+    # remove gems.
+    #
+    # @api private
+    class BundlerContext
+      # Write and remove into and from a Gemfile
+      #
+      # This custom injector fixes support for path, git and custom sources,
+      # which is missing in bundler's upstream injector for a dependency fetched
+      # with `Bundled.locked_gems.dependencies`.
+      #
+      # @api private
+      class InjectorWithPathSupport < Bundler::Injector
+        private def build_gem_lines(conservative_versioning)
+          @deps.map do |d|
+            name = d.name.dump
+            is_local = d.source.instance_of?(Bundler::Source::Path)
+            is_git = d.source.instance_of?(Bundler::Source::Git)
+
+            requirement = if is_local
+                            ", path: \"#{d.source.path}\""
+                          elsif is_git
+                            ", git: \"#{d.git}\"".yield_self { |g| d.ref ? g + ", ref: \"#{d.ref}\"" : g }
+                          elsif conservative_versioning
+                            ", \"#{conservative_version(@definition.specs[d.name][0])}\""
+                          else
+                            ", #{d.requirement.as_list.map(&:dump).join(", ")}"
+                          end
+
+            source = ", :source => \"#{d.source.remotes.join(",")}\"" unless is_local || is_git || d.source.nil?
+
+            %(gem #{name}#{requirement}#{source})
+          end.join("\n")
+        end
+      end
+
+      attr_reader :dependencies, :injector
+
+      def self.bundle_cleanly(&block)
+        Bundler.respond_to?(:with_unbundled_env) ? Bundler.with_unbundled_env(&block) : Bundler.with_clean_env(&block)
+      end
+
+      def initialize
+        @dependencies = Bundler.locked_gems.dependencies
+        @injector = InjectorWithPathSupport
+      end
+
+      def solidus_in_gemfile?
+        !solidus_dependency.nil?
+      end
+
+      def component_in_gemfile?(name)
+        !@dependencies["solidus_#{name}"].nil?
+      end
+
+      def break_down_components(components)
+        raise <<~MSG  unless solidus_in_gemfile?
+          solidus meta gem needs to be present in the Gemfile to build the component dependency
+        MSG
+
+        @injector.inject(
+          components.map { |component| dependency_for_component(component) }
+        )
+      end
+
+      def remove(*args, **kwargs, &block)
+        @injector.remove(*args, **kwargs, &block)
+      end
+
+      private
+
+      def dependency_for_component(component)
+        Bundler::Dependency.new(
+          "solidus_#{component}",
+          solidus_dependency.requirement,
+          {
+            "source" => solidus_dependency.source,
+            "git" => solidus_dependency.source.try(:uri),
+            "ref" => solidus_dependency.source.try(:ref)
+          }
+        )
+      end
+
+      def solidus_dependency
+        @dependencies['solidus']
+      end
+    end
+  end
+end

data/lib/generators/solidus/install/install_generator/install_frontend.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Solidus
+  class InstallGenerator < Rails::Generators::Base
+    class InstallFrontend
+      attr_reader :bundler_context,
+                  :generator_context
+
+      def initialize(bundler_context:, generator_context:)
+        @bundler_context = bundler_context
+        @generator_context = generator_context
+      end
+
+      def call(frontend, installer_adds_auth:)
+        case frontend
+        when 'solidus_frontend'
+          install_solidus_frontend
+        when 'solidus_starter_frontend'
+          install_solidus_starter_frontend(installer_adds_auth)
+        end
+      end
+
+      private
+
+      def install_solidus_frontend
+        unless @bundler_context.component_in_gemfile?(:frontend)
+          BundlerContext.bundle_cleanly do
+            `bundle add solidus_frontend`
+            `bundle install`
+          end
+        end
+
+        @generator_context.generate('solidus_frontend:install')
+      end
+
+      def install_solidus_starter_frontend(installer_adds_auth)
+        @bundler_context.remove(['solidus_frontend']) if @bundler_context.component_in_gemfile?(:frontend)
+
+        # TODO: Move installation of solidus_auth_devise to the
+        # solidus_starter_frontend template
+        BundlerContext.bundle_cleanly { `bundle add solidus_auth_devise` } unless auth_present?(installer_adds_auth)
+        `LOCATION="https://raw.githubusercontent.com/solidusio/solidus_starter_frontend/main/template.rb" bin/rails app:template`
+      end
+
+      def auth_present?(installer_adds_auth)
+        installer_adds_auth || @bundler_context.component_in_gemfile?(:auth_devise)
+      end
+    end
+  end
+end