solidus_core 3.0.0 → 4.5.1

data/app/models/spree/permission_sets/super_user.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  module PermissionSets
+    # Full permissions for store administration.
+    #
+    # This permission set is always added to users with the `:admin` role.
+    #
+    # It grants permission to perform any read or write action on any resource.
+    class SuperUser < PermissionSets::Base
+      class << self
+        def privilege
+          :other
+        end
+
+        def category
+          :super_user
+        end
+      end
+
+      def activate!
+        can :manage, :all
+      end
+    end
+  end
+end

data/app/models/spree/permission_sets/user_display.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Spree
+  module PermissionSets
+    # Read-only permissions for users, roles and store credits.
+    #
+    # This permission set allows users to view all related information about
+    # users, roles and store credits, also from the admin panel.
+    class UserDisplay < PermissionSets::Base
+      class << self
+        def privilege
+          :display
+        end
+
+        def category
+          :user
+        end
+      end
+
+      def activate!
+        can [:read, :admin, :edit, :addresses, :orders, :items], Spree.user_class
+        can [:read, :admin], Spree::StoreCredit
+        can :read, Spree::Role
+      end
+    end
+  end
+end

data/app/models/spree/permission_sets/user_management.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Spree
+  module PermissionSets
+    # Full permissions for user management.
+    #
+    # This permission set grants full control over all user and
+    # related resources, including:
+    #
+    # - Users
+    # - Store credits
+    # - Roles
+    # - API keys
+    class UserManagement < PermissionSets::Base
+      class << self
+        def privilege
+          :management
+        end
+
+        def category
+          :user
+        end
+      end
+
+      def activate!
+        can [:admin, :read, :create, :update, :save_in_address_book, :remove_from_address_book, :addresses, :orders, :items], Spree.user_class
+
+        # NOTE: This does not work with accessible_by.
+        # See https://github.com/solidusio/solidus/pull/1263
+        can :update_email, Spree.user_class do |user|
+          user.spree_roles.none?
+        end
+        can :update_password, Spree.user_class do |user|
+          user.spree_roles.none?
+        end
+
+        cannot :destroy, Spree.user_class
+        can :manage, Spree::StoreCredit
+        can :manage, :api_key
+        can :read, Spree::Role
+      end
+    end
+  end
+end

data/app/models/spree/preference.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Spree::Preference < Spree::Base
-  serialize :value
+  serialize :value, coder: YAML
 
   validates :key, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
 end

data/app/models/spree/price.rb

@@ -13,7 +13,7 @@ module Spree
     delegate :tax_rates, to: :variant
 
     validate :check_price
-    validates :amount, allow_nil: true, numericality: {
+    validates :amount, numericality: {
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
     }
@@ -30,7 +30,7 @@ module Spree
     money_methods :amount, :price
     alias_method :money, :display_amount
 
-    self.whitelisted_ransackable_attributes = %w(amount variant_id currency country_iso)
+    self.allowed_ransackable_attributes = %w(amount variant_id currency country_iso)
 
     # An alias for #amount
     def price
@@ -55,7 +55,7 @@ module Spree
 
     def display_country
       if country_iso
-        "#{country_iso} (#{country.name})"
+        "#{country_iso} (#{I18n.t(country_iso, scope: [:spree, :country_names])})"
       else
         I18n.t(:any_country, scope: [:spree, :admin, :prices])
       end

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

@@ -29,25 +29,25 @@ module Spree
           scope :descend_by_name, -> { order(name: :desc) }
 
           add_search_scope :ascend_by_master_price do
-            joins(master: :default_price).select('spree_products.* , spree_prices.amount')
+            joins(master: :prices).select('spree_products.* , spree_prices.amount')
                                          .order(Spree::Price.arel_table[:amount].asc)
           end
 
           add_search_scope :descend_by_master_price do
-            joins(master: :default_price).select('spree_products.* , spree_prices.amount')
+            joins(master: :prices).select('spree_products.* , spree_prices.amount')
                                          .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 })
+            joins(master: :prices).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)
+            joins(master: :prices).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)
+            joins(master: :prices).where("#{price_table_name}.amount >= ?", price)
           end
 
           # This scope selects products in taxon AND all its descendants
@@ -158,7 +158,7 @@ module Spree
           # order: 'COALESCE(cnt, 0) DESC'
           add_search_scope :descend_by_popularity do
             joins(:master).
-              order(%{
+              order(Arel.sql(%{
            COALESCE((
              SELECT
                COUNT(#{Spree::LineItem.quoted_table_name}.id)
@@ -171,7 +171,7 @@ module Spree
              WHERE
                popular_variants.product_id = #{Spree::Product.quoted_table_name}.id
            ), 0) DESC
-        })
+        }))
           end
 
           add_search_scope :not_deleted do
@@ -194,10 +194,23 @@ module Spree
             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}%"
+          def self.with_all_variant_sku_cont(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])))
+            subquery = Spree::Variant.with_discarded.where(
+              variant_table[:sku].matches("%#{sku}%").and(
+                variant_table[:product_id].eq(arel_table[:id])
+              )
+            )
+            where(subquery.arel.exists)
+          end
+
+          def self.with_kept_variant_sku_cont(sku)
+            variant_table = Spree::Variant.arel_table
+            subquery = Spree::Variant.where(
+              variant_table[:sku].matches("%#{sku}%").and(
+                variant_table[:product_id].eq(arel_table[:id])
+              )
+            )
             where(subquery.arel.exists)
           end
 

data/app/models/spree/product.rb

@@ -16,7 +16,6 @@ module Spree
       self.product_option_types = []
       self.product_properties = []
       self.classifications.destroy_all
-      self.product_promotion_rules = []
     end
 
     has_many :product_option_types, dependent: :destroy, inverse_of: :product
@@ -31,11 +30,9 @@ module Spree
     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', optional: true
     belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products, optional: true
+    belongs_to :primary_taxon, class_name: 'Spree::Taxon', optional: true
 
     has_one :master,
       -> { where(is_master: true).with_discarded },
@@ -61,6 +58,19 @@ module Spree
     has_many :line_items, through: :variants_including_master
     has_many :orders, through: :line_items
 
+    has_many :option_values, -> { distinct }, through: :variants_including_master
+
+    scope :sort_by_master_default_price_amount_asc, -> {
+      with_default_price.order('spree_prices.amount ASC')
+    }
+    scope :sort_by_master_default_price_amount_desc, -> {
+      with_default_price.order('spree_prices.amount DESC')
+    }
+    scope :with_default_price, -> {
+      left_joins(master: :prices)
+        .where(master: { spree_prices: Spree::Config.default_pricing_options.desired_attributes })
+    }
+
     def find_or_build_master
       master || build_master
     end
@@ -72,8 +82,11 @@ module Spree
       :height,
       :price,
       :sku,
+      :track_inventory,
       :weight,
       :width,
+      :gtin,
+      :condition
     ]
     MASTER_ATTRIBUTES.each do |attr|
       delegate :"#{attr}", :"#{attr}=", to: :find_or_build_master
@@ -84,7 +97,7 @@ module Spree
              :display_price,
              :has_default_price?,
              :images,
-             :price_for,
+             :price_for_options,
              :rebuild_vat_prices=,
              to: :find_or_build_master
 
@@ -119,12 +132,9 @@ module Spree
 
     alias :options :product_option_types
 
-    self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
-    self.whitelisted_ransackable_attributes = %w[name slug]
-
-    def self.ransackable_scopes(_auth_object = nil)
-      %i(with_discarded with_variant_sku_cont)
-    end
+    self.allowed_ransackable_associations = %w[stores variants_including_master master variants option_values]
+    self.allowed_ransackable_attributes = %w[name slug]
+    self.allowed_ransackable_scopes = %i[available with_discarded with_all_variant_sku_cont with_kept_variant_sku_cont]
 
     # @return [Boolean] true if there are any variants
     def has_variants?
@@ -243,7 +253,7 @@ module Spree
       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 = Spree::ProductProperty.where(product: self, property:).first_or_initialize
         product_property.value = property_value
         product_property.save!
       end
@@ -251,8 +261,7 @@ module Spree
 
     # @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?)
+      Spree::Config.promotions.advertiser_class.for_product(self)
     end
 
     # The number of on-hand stock items; Infinity if any variant does not track
@@ -285,6 +294,10 @@ module Spree
       @gallery ||= Spree::Config.product_gallery_class.new(self)
     end
 
+    def brand
+      Spree::Config.brand_selector_class.new(self).call
+    end
+
     private
 
     def any_variants_not_track_inventory?
@@ -327,14 +340,8 @@ module Spree
     # If the master is invalid, the Product object will be assigned its errors
     def validate_master
       unless master.valid?
-        if Gem::Requirement.new(">= 6.1").satisfied_by?(Rails.gem_version)
-          master.errors.each do |error|
-            errors.add(error.attribute, error.message)
-          end
-        else
-          master.errors.each do |att, error|
-            errors.add(att, error)
-          end
+        master.errors.each do |error|
+          errors.add(error.attribute, error.message)
         end
       end
     end
@@ -363,7 +370,7 @@ module Spree
     end
 
     def remove_taxon(taxon)
-      removed_classifications = classifications.where(taxon: taxon)
+      removed_classifications = classifications.where(taxon:)
       removed_classifications.each(&:remove_from_list)
     end
   end

data/app/models/spree/product_property.rb

@@ -9,6 +9,6 @@ module Spree
     belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties, optional: true
     belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties, optional: true
 
-    self.whitelisted_ransackable_attributes = ['value']
+    self.allowed_ransackable_attributes = ['value']
   end
 end

data/app/models/spree/property.rb

@@ -11,7 +11,7 @@ module Spree
 
     after_touch :touch_all_products
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.allowed_ransackable_attributes = %w[name]
 
     private
 

data/app/models/spree/refund.rb

@@ -2,6 +2,8 @@
 
 module Spree
   class Refund < Spree::Base
+    include Metadata
+
     belongs_to :payment, inverse_of: :refunds, optional: true
     belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id, optional: true
     belongs_to :reimbursement, inverse_of: :refunds, optional: true
@@ -21,7 +23,7 @@ module Spree
     delegate :currency, to: :payment
 
     def money
-      Spree::Money.new(amount, { currency: currency })
+      Spree::Money.new(amount, { currency: })
     end
     alias display_amount money
 
@@ -31,6 +33,14 @@ module Spree
       end
     end
 
+    # Sets this price's amount to a new value, parsing it if the new value is
+    # a string.
+    #
+    # @param price [String, #to_d] a new amount
+    def amount=(price)
+      self[:amount] = Spree::LocalizedNumber.parse(price)
+    end
+
     def description
       payment.payment_method.name
     end
@@ -45,7 +55,7 @@ module Spree
       credit_cents = money.cents
 
       @perform_response = process!(credit_cents)
-      log_entries.build(details: perform_response.to_yaml)
+      log_entries.build(parsed_payment_response_details_with_fallback: perform_response)
 
       self.transaction_id = perform_response.authorization
       save!
@@ -82,7 +92,7 @@ module Spree
     end
 
     def update_order
-      payment.order.updater.update
+      payment.order.recalculate
     end
   end
 end

data/app/models/spree/refund_reason.rb

@@ -2,12 +2,17 @@
 
 module Spree
   class RefundReason < Spree::Base
-    include Spree::NamedType
+    scope :active, -> { where(active: true) }
+    default_scope -> { order(arel_table[:name].lower) }
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
 
     RETURN_PROCESSING_REASON = 'Return processing'
 
     has_many :refunds
 
+    self.allowed_ransackable_attributes = %w[name code]
+
     def self.return_processing_reason
       find_by!(name: RETURN_PROCESSING_REASON, mutable: false)
     end

data/app/models/spree/reimbursement.rb

@@ -57,7 +57,7 @@ module Spree
       def build_from_customer_return(customer_return)
         order = customer_return.order
         order.reimbursements.build({
-          customer_return: customer_return,
+          customer_return:,
           return_items: customer_return.return_items.accepted.not_reimbursed
         })
       end
@@ -88,14 +88,14 @@ module Spree
       reload
       update!(total: calculated_total)
 
-      reimbursement_performer.perform(self, created_by: created_by)
+      reimbursement_performer.perform(self, created_by:)
 
       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?
@@ -108,7 +108,7 @@ module Spree
       reload
       update!(total: calculated_total)
 
-      reimbursement_performer.simulate(self, created_by: created_by)
+      reimbursement_performer.simulate(self, created_by:)
     end
 
     def return_items_requiring_exchange
@@ -131,7 +131,7 @@ module Spree
     def return_all(created_by:)
       return_items.each(&:accept!)
       save!
-      perform!(created_by: created_by)
+      perform!(created_by:)
     end
 
     # The returned category is used as the category

data/app/models/spree/reimbursement_performer.rb

@@ -12,12 +12,12 @@ module Spree
       # - #display_amount
       # so they can be displayed in the Admin UI appropriately.
       def simulate(reimbursement, created_by:)
-        execute(reimbursement, true, created_by: created_by)
+        execute(reimbursement, true, created_by:)
       end
 
       # Actually perform the reimbursement
       def perform(reimbursement, created_by:)
-        execute(reimbursement, false, created_by: created_by)
+        execute(reimbursement, false, created_by:)
       end
 
       private
@@ -26,7 +26,7 @@ module Spree
         reimbursement_type_hash = calculate_reimbursement_types(reimbursement)
 
         reimbursement_type_hash.flat_map do |reimbursement_type, return_items|
-          reimbursement_type.reimburse(reimbursement, return_items, simulate, created_by: created_by)
+          reimbursement_type.reimburse(reimbursement, return_items, simulate, created_by:)
         end
       end
 

data/app/models/spree/reimbursement_tax_calculator.rb

@@ -12,7 +12,7 @@ module Spree
   class ReimbursementTaxCalculator
     class << self
       def call(reimbursement)
-        reimbursement.return_items.includes(:inventory_unit).each do |return_item|
+        reimbursement.return_items.includes(:inventory_unit).find_each do |return_item|
           set_tax!(return_item)
         end
       end
@@ -26,8 +26,8 @@ module Spree
         included_tax_total   = percent_of_tax * return_item.inventory_unit.included_tax_total
 
         return_item.update!({
-          additional_tax_total: additional_tax_total,
-          included_tax_total:   included_tax_total
+          additional_tax_total:,
+          included_tax_total:
         })
       end
     end

data/app/models/spree/reimbursement_type/credit.rb

@@ -7,7 +7,7 @@ module Spree
     class << self
       def reimburse(reimbursement, return_items, simulate, created_by:)
         unpaid_amount = return_items.sum(&:total).round(2, :down)
-        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, created_by: created_by)
+        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, created_by:)
         reimbursement_list
       end
     end

data/app/models/spree/reimbursement_type/reimbursement_helpers.rb

@@ -21,7 +21,7 @@ module Spree
     end
 
     def create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list = [], created_by:)
-      credits = [create_credit(reimbursement, unpaid_amount, simulate, created_by: created_by)]
+      credits = [create_credit(reimbursement, unpaid_amount, simulate, created_by:)]
       unpaid_amount -= credits.sum(&:amount)
       reimbursement_list += credits
 
@@ -32,8 +32,8 @@ module Spree
 
     def create_refund(reimbursement, payment, amount, simulate)
       refund = reimbursement.refunds.build({
-        payment: payment,
-        amount: amount,
+        payment:,
+        amount:,
         reason: Spree::RefundReason.return_processing_reason
       })
 
@@ -50,8 +50,8 @@ module Spree
     # If you have multiple methods of crediting a customer, overwrite this method
     # Must return an array of objects the respond to #description, #display_amount
     def create_credit(reimbursement, unpaid_amount, simulate, created_by:)
-      creditable = create_creditable(reimbursement, unpaid_amount, created_by: created_by)
-      credit = reimbursement.credits.build(creditable: creditable, amount: unpaid_amount)
+      creditable = create_creditable(reimbursement, unpaid_amount, created_by:)
+      credit = reimbursement.credits.build(creditable:, amount: unpaid_amount)
       simulate ? credit.readonly! : credit.save!
       credit
     end
@@ -61,7 +61,7 @@ module Spree
         user: reimbursement.order.user,
         amount: unpaid_amount,
         category: reimbursement.store_credit_category,
-        created_by: created_by,
+        created_by:,
         memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
         currency: reimbursement.order.currency
       )

data/app/models/spree/reimbursement_type/store_credit.rb

@@ -25,7 +25,7 @@ class Spree::ReimbursementType::StoreCredit < Spree::ReimbursementType
           unpaid_amount,
           simulate,
           reimbursement_list,
-          created_by: created_by
+          created_by:
         )
       end
 

data/app/models/spree/reimbursement_type.rb

@@ -2,12 +2,17 @@
 
 module Spree
   class ReimbursementType < Spree::Base
-    include Spree::NamedType
+    scope :active, -> { where(active: true) }
+    default_scope -> { order(arel_table[:name].lower) }
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
 
     ORIGINAL = 'original'
 
     has_many :return_items
 
+    self.allowed_ransackable_attributes = %w[name]
+
     # This method will reimburse the return items based on however it child implements it
     # By default it takes a reimbursement, the return items it needs to reimburse, and if
     # it is a simulation or a real reimbursement. This should return an array

data/app/models/spree/return_authorization.rb

@@ -4,6 +4,8 @@ module Spree
   # Models the return of Inventory Units to a Stock Location for an Order.
   #
   class ReturnAuthorization < Spree::Base
+    include Metadata
+
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations, optional: true
 
     has_many :return_items, inverse_of: :return_authorization, dependent: :destroy
@@ -27,7 +29,7 @@ module Spree
     extend DisplayMoney
     money_methods :amount, :total_excluding_vat
 
-    self.whitelisted_ransackable_attributes = ['memo']
+    self.allowed_ransackable_attributes = ['memo']
 
     def total_excluding_vat
       return_items.sum(&:total_excluding_vat)