spree_core 5.6.1 → 6.0.0.beta2

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

@@ -1,332 +1,7 @@
 module Spree
-  module UserMethods
-    extend ActiveSupport::Concern
-
-    include Spree::PrefixedId
-    include Spree::Metafields
-    include Spree::Metadata
-    include Spree::UserPaymentSource
-    include Spree::UserReporting
-    include Spree::UserRoles
-    include Spree::RansackableAttributes
-    include Spree::Searchable
-    include Spree::Publishable
-
-    # Opt-in escape hatch for admin-side customer creation. When the host
-    # `Spree::User` includes Devise's `:validatable`, password presence is
-    # enforced on every create; admin-created customers don't pick a
-    # password upfront — they claim the account later via password reset.
-    # The admin Customers controller flips `skip_password_validation = true`
-    # when no password was supplied; the storefront registration path never
-    # sets it, so customer self-signup still requires a password.
-    #
-    # Prepended (not just defined) so it sits above Devise's own
-    # `password_required?` and can fall through with `super` when the flag
-    # isn't set. On `LegacyUser` (gem default, no Devise) `super` raises
-    # NoMethodError if invoked — but the early return covers the only
-    # branch that ever reaches this method on that path, and `LegacyUser`
-    # doesn't call `password_required?` at all, so the override is a no-op
-    # there.
-    module SkipPasswordValidation
-      def password_required?
-        return false if skip_password_validation && encrypted_password.blank? && password.blank?
-        super
-      end
-    end
-
-    included do
-      has_prefix_id :cus  # Stripe: cus_
-
-      attr_accessor :skip_password_validation
-
-      prepend SkipPasswordValidation
-
-      # Enable lifecycle events for user models
-      publishes_lifecycle_events
-
-      # Password reset token (Rails 7.1+ signed token, no DB column needed)
-      # Token auto-invalidates when password changes (salt changes)
-      # Expiration is configurable via Spree::Config.customer_password_reset_expires_in (in minutes)
-      generates_token_for :password_reset, expires_in: Spree::Config.customer_password_reset_expires_in.minutes do
-        # `try` rather than `&.`: models without a password_salt method or
-        # column at all (modern Devise) must fall through to encrypted_password
-        # — a bare call would raise NameError before the fallback.
-        try(:password_salt)&.last(10) || encrypted_password&.last(10)
-      end
-
-      # we need to have this callback before any dependent: :destroy associations
-      # https://github.com/rails/rails/issues/3458
-      before_validation :clone_billing_address, if: :use_billing?
-      before_destroy :check_completed_orders
-
-      after_save_commit :sync_newsletter_subscription_with_marketing_consent,
-                        if: :saved_change_to_accepts_email_marketing?
-
-      attr_accessor :use_billing
-
-      has_person_name
-      normalizes :email, :first_name, :last_name, with: ->(value) { value&.to_s&.squish&.presence }
-      acts_as_taggable_on :tags
-
-      def tags=(tags)
-        self.tag_list = tags
-      end
-
-      #
-      # Associations
-      #
-      has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser', foreign_key: :user_id, dependent: :destroy
-      has_many :promotion_rules, through: :promotion_rule_users, class_name: 'Spree::PromotionRule'
-      has_many :orders, foreign_key: :user_id, class_name: 'Spree::Order'
-      has_many :carts, -> { incomplete }, foreign_key: :user_id, class_name: 'Spree::Order'
-      has_many :completed_orders, -> { complete }, foreign_key: :user_id, class_name: 'Spree::Order'
-      has_many :store_credits, class_name: 'Spree::StoreCredit', foreign_key: :user_id, dependent: :destroy
-      has_many :wishlists, class_name: 'Spree::Wishlist', foreign_key: :user_id, dependent: :destroy
-      has_many :wished_items, through: :wishlists, source: :wished_items
-      has_many :gateway_customers, class_name: 'Spree::GatewayCustomer', foreign_key: :user_id
-      has_many :gift_cards, class_name: 'Spree::GiftCard', foreign_key: :user_id, dependent: :destroy
-      has_many :customer_group_users, class_name: 'Spree::CustomerGroupUser', foreign_key: :user_id, as: :user, dependent: :destroy
-      has_many :customer_groups, through: :customer_group_users, class_name: 'Spree::CustomerGroup'
-      has_many :identities, class_name: 'Spree::UserIdentity', as: :user, dependent: :destroy
-      belongs_to :ship_address, class_name: 'Spree::Address', optional: true
-      belongs_to :bill_address, class_name: 'Spree::Address', optional: true
-
-      # Replaces the customer's group membership. Accepts both prefixed IDs and
-      # raw integer IDs. Only groups belonging to the current store are
-      # assigned — ids from another store are dropped, preventing cross-store
-      # membership. Mirrors +Spree::Product#category_ids=+.
-      def customer_group_ids=(ids)
-        decoded_ids = Array(ids).filter_map do |id|
-          id.to_s.include?('_') ? Spree::CustomerGroup.decode_prefixed_id(id) : id
-        end
-        super(Spree::CustomerGroup.for_store(Spree::Current.store).where(id: decoded_ids).ids)
-      end
-
-      #
-      # Attachments
-      #
-      has_one_attached :avatar, service: Spree.public_storage_service_name
-      has_rich_text :internal_note
-
-      #
-      # Attributes
-      #
-      attr_accessor :confirm_email, :terms_of_service
-
-      def self.find_by_password_reset_token(token)
-        find_by_token_for(:password_reset, token)
-      end
-
-      def self.find_by_password_reset_token!(token)
-        find_by_token_for!(:password_reset, token)
-      end
-
-      def self.search(query)
-        return none if query.blank?
-
-        # `search_condition` handles sanitization itself — it escapes LIKE
-        # wildcards for plain columns and compares encrypted columns by
-        # equality. Pass the raw query so it can branch correctly.
-        conditions = []
-        conditions << search_condition(self, :email, query)
-        conditions << search_condition(self, :first_name, query)
-        conditions << search_condition(self, :last_name, query)
-
-        full_name = NameOfPerson::PersonName.full(query.to_s.strip)
-
-        if full_name.first.present? && full_name.last.present?
-          conditions << search_condition(self, :first_name, full_name.first)
-          conditions << search_condition(self, :last_name, full_name.last)
-        end
-
-        where(conditions.reduce(:or))
-      end
-
-      # Backward compatibility alias — remove in Spree 6.0
-      def self.multi_search(query) = search(query)
-
-      self.whitelisted_ransackable_associations = %w[bill_address ship_address addresses tags spree_roles orders customer_groups]
-      self.whitelisted_ransackable_attributes = %w[id email first_name last_name phone accepts_email_marketing
-                                                    created_at updated_at last_sign_in_at]
-      self.whitelisted_ransackable_scopes = %w[search multi_search with_min_total_spent]
-
-      scope :with_min_total_spent, ->(amount) {
-        joins(:orders).where(spree_orders: { state: 'complete' }).
-          group("#{table_name}.id").
-          having('SUM(spree_orders.total) >= ?', amount.to_d)
-      }
-
-      # Precomputes orders_count, total_spent, and last_order_completed_at via a
-      # single aggregate join so list endpoints avoid 4 queries per user. The
-      # values land on the user as virtual attributes.
-      scope :with_order_aggregates, -> {
-        order_table = Spree::Order.table_name
-        select(
-          "#{table_name}.*, " \
-          "COALESCE(orders_agg.orders_count, 0) AS orders_count, " \
-          "COALESCE(orders_agg.total_spent, 0) AS total_spent, " \
-          "orders_agg.last_order_completed_at AS last_order_completed_at"
-        ).joins(
-          "LEFT JOIN (" \
-            "SELECT user_id, COUNT(*) AS orders_count, SUM(total) AS total_spent, MAX(completed_at) AS last_order_completed_at " \
-            "FROM #{order_table} " \
-            "WHERE state = 'complete' AND user_id IS NOT NULL " \
-            "GROUP BY user_id" \
-          ") orders_agg ON orders_agg.user_id = #{table_name}.id"
-        )
-      }
-
-      def self.with_email(query)
-        where("#{table_name}.email LIKE ?", "%#{query}%")
-      end
-
-      def self.with_address(query, address = :ship_address)
-        left_outer_joins(address).
-          where("#{Spree::Address.table_name}.firstname like ?", "%#{query}%").
-          or(left_outer_joins(address).where("#{Spree::Address.table_name}.lastname like ?", "%#{query}%"))
-      end
-
-      def self.with_email_or_address(email, address)
-        left_outer_joins(:addresses).
-          where("#{Spree::Address.table_name}.firstname LIKE ? or #{Spree::Address.table_name}.lastname LIKE ? or #{table_name}.email LIKE ?",
-                "%#{address}%", "%#{address}%", "%#{email}%")
-      end
-
-      # We override this method because we cannot use for_store on users because it will return admin users
-      def self.for_store(store)
-        self
-      end
-    end
-
-    # Returns the last incomplete spree order for the current store
-    # @param [Spree::Store] store
-    # @param [Hash] options
-    # @option options [Array<Symbol>] :includes
-    # @return [Spree::Order]
-    def last_incomplete_spree_order(store, options = {})
-      orders.where(store: store).incomplete.not_canceled.
-        includes(options[:includes]).
-        order('created_at DESC').
-        first
-    end
-
-    # Returns the total available store credit for the current store per currency
-    # @param [Spree::Store] store
-    # @param [String] currency
-    # @return [Float]
-    def total_available_store_credit(currency = nil, store = nil)
-      store ||= Store.default
-      currency ||= store.default_currency
-
-      # When the association is already loaded (e.g. preloaded via the admin
-      # API's scope_includes), filter in memory to avoid an N+1 — but mirror
-      # the query branch exactly: non-gift-card credits, scoped to the store
-      # and currency. A gift card is identified by its originator_type.
-      if store_credits.loaded?
-        store_credits.
-          select { |sc| sc.originator_type != 'Spree::GiftCard' && sc.store_id.to_s == store.id.to_s && sc.currency == currency }.
-          sum(&:amount_remaining)
-      else
-        store_credits.without_gift_card.for_store(store).where(currency: currency).to_a.sum(&:amount_remaining)
-      end
-    end
-
-    # Returns the available store credits for the current store per currency
-    # @param [Spree::Store] store
-    # @return [Array<Spree::Money>]
-    def available_store_credits(store)
-      store ||= Store.default
-
-      store_credits.for_store(store).pluck(:currency).uniq.each_with_object([]) do |currency, arr|
-        arr << Spree::Money.new(total_available_store_credit(currency, store), currency: currency)
-      end
-    end
-
-    # Returns the default wishlist for the current store
-    # if no default wishlist exists, it creates one
-    # @param [Spree::Store] current_store
-    # @return [Spree::Wishlist]
-    def default_wishlist_for_store(current_store)
-      wishlists.find_by(is_default: true, store_id: current_store.id) || ActiveRecord::Base.connected_to(role: :writing) do
-        wishlists.create!(store: current_store, is_default: true, name: Spree.t(:default_wishlist_name))
-      end
-    end
-
-    # Returns true if the user can be deleted
-    # Customers can be deleted if they have no completed orders
-    # @return [Boolean]
-    def can_be_deleted?
-      orders.complete.none?
-    end
-
-    # Returns the CSV row representation of the user
-    # @param [Spree::Store] store
-    # @return [Array<String>]
-    def to_csv(_store = nil)
-      Spree::CSV::CustomerPresenter.new(self).call
-    end
-
-    # Returns the full name of the user
-    # @return [String]
-    def full_name
-      name&.full
-    end
-
-    def event_serializer_class
-      'Spree::Api::V3::CustomerSerializer'.safe_constantize
-    end
-
-    def event_prefix
-      if self.class == Spree.admin_user_class && Spree.admin_user_class != Spree.user_class
-        'admin'
-      else
-        'user'
-      end
-    end
-
-    # @param store [Spree::Store] store to scope the lookup to; defaults to the current store
-    # @return [Spree::NewsletterSubscriber, nil] this user's newsletter subscriber for the given store
-    def newsletter_subscriber(store = Spree::Current.store)
-      return unless store
-
-      Spree::NewsletterSubscriber.for_store(store).find_by(user_id: id)
-    end
-
-    private
-
-    def check_completed_orders
-      raise Spree::Core::DestroyWithOrdersError if !spree_admin? && orders.complete.present?
-    end
-
-    def clone_billing_address
-      if bill_address && ship_address.nil?
-        self.ship_address = bill_address.clone
-      else
-        ship_address.attributes = bill_address.attributes.except('id', 'updated_at', 'created_at')
-      end
-      true
-    end
-
-    def use_billing?
-      use_billing.in?([true, 'true', '1'])
-    end
-
-    # Scrambles the email and names of the user
-    def scramble_email_and_names
-      self.email = "#{SecureRandom.uuid}@example.net"
-      self.first_name = 'Deleted'
-      self.last_name = 'User'
-      self.login = email
-      save
-    end
-
-    def sync_newsletter_subscription_with_marketing_consent
-      if accepts_email_marketing?
-        Spree::NewsletterSubscriber.subscribe(email: email, user: self)
-      else
-        # Only remove the subscriber for the current store, mirroring the store-scoped subscribe path.
-        newsletter_subscriber&.destroy
-      end
-    end
-  end
+  # Deprecation alias for Spree::CustomerMethods, renamed from Spree::UserMethods in 6.0.
+  # True constant alias — the underlying module, its associations, and prefix (cust)
+  # are all Spree::CustomerMethods. Remove in Spree 6.1.
+  UserMethods = CustomerMethods
+  Spree::Deprecation.warn('Spree::UserMethods is deprecated and will be removed in Spree 6.1. Use Spree::CustomerMethods instead.')
 end

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

@@ -3,7 +3,7 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
-      has_many :credit_cards, class_name: 'Spree::CreditCard', foreign_key: :user_id, dependent: :destroy
+      has_many :credit_cards, class_name: 'Spree::CreditCard', foreign_key: :customer_id, dependent: :destroy
       has_many :payment_setup_sessions, class_name: 'Spree::PaymentSetupSession', foreign_key: :customer_id, dependent: :destroy
 
       def default_credit_card

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

@@ -5,7 +5,8 @@ module Spree
     included do
       has_many :role_users, class_name: 'Spree::RoleUser', foreign_key: :user_id, as: :user, dependent: :destroy_async # async as we need to check if the user has admin role before destroying
       has_many :spree_roles, through: :role_users, class_name: 'Spree::Role', source: :role
-      has_many :stores, through: :role_users, source: :resource, source_type: 'Spree::Store'
+      has_many :stores, through: :spree_roles, source: :resource, source_type: 'Spree::Store'
+      has_many :sellers, through: :spree_roles, source: :resource, source_type: 'Spree::Seller'
       has_many :invitations, class_name: 'Spree::Invitation', as: :invitee, dependent: :destroy
       has_many :sent_invitations, class_name: 'Spree::Invitation', as: :inviter, dependent: :destroy
 
@@ -18,10 +19,10 @@ module Spree
       # @return [Spree::RoleUser] The role user created
       def add_role(role_name, resource = nil)
         resource ||= Spree::Store.current
-        role = Spree::Role.find_by(name: role_name)
+        role = Spree::Role.find_by(name: role_name, resource: resource)
         return if role.nil?
 
-        role_users.find_or_create_by!(role: role, resource: resource)
+        role_users.find_or_create_by!(role: role)
       end
 
       # Removes a role from a resource
@@ -30,10 +31,10 @@ module Spree
       # @param resource [Spree::Base] The resource to remove the role from
       def remove_role(role_name, resource = nil)
         resource ||= Spree::Store.current
-        role = Spree::Role.find_by(name: role_name)
+        role = Spree::Role.find_by(name: role_name, resource: resource)
         return if role.nil?
 
-        role_users.where(role: role, resource: resource).destroy_all
+        role_users.where(role: role).destroy_all
       end
 
       # has_spree_role? simply needs to return true or false whether a user has a role or not.
@@ -44,12 +45,7 @@ module Spree
       def has_spree_role?(role_name, resource = nil)
         resource ||= Spree::Store.current
 
-        role_users.where(resource: resource).joins(:role).where(Spree::Role.table_name => { name: role_name }).exists?
-      end
-
-      def self.spree_admin_created?
-        Spree::Deprecation.warn('Spree.admin_user_class.spree_admin_created? is deprecated and will be removed in Spree 5.5')
-        spree_admin.exists?
+        spree_roles.for_resource(resource).exists?(name: role_name)
       end
 
       # Returns true if the user has the admin role for a given resource
@@ -66,6 +62,17 @@ module Spree
       def invited_by
         invitations.first&.inviter
       end
+
+      # Whether this user belongs to any marketplace seller. The seller login
+      # refuses anyone this is false for, so a store's own staff cannot mint a
+      # seller token — the same rule the admin SSO callback applies to
+      # unprovisioned subjects.
+      #
+      # @return [Boolean]
+      def seller_member?
+        spree_roles.where(resource_type: 'Spree::Seller').exists?
+      end
+
     end
   end
 end

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

@@ -0,0 +1,53 @@
+module Spree
+  # Declares an attribute unique within its store, ignoring rows that are gone.
+  # Included in {Spree::Base}, so any model can declare one directly:
+  #
+  #   validates_store_uniqueness :name
+  #   validates_store_uniqueness :name, scope: [:seller_id]
+  #   validates_store_uniqueness :name, soft_delete_column: :revoked_at
+  #
+  # Nothing here resolves a record from a string — finding one by a slug or
+  # permalink is FriendlyId's job.
+  module ValidatesStoreUniqueness
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # @param attribute [Symbol] the column to keep unique
+      # @param soft_delete_column [Symbol] the column a removed row is stamped
+      #   with, so removed rows free their value. Defaults to `deleted_at`;
+      #   a model without that column simply has none, and every row counts.
+      # @param scope [Array<Symbol>] extra columns the value is unique within,
+      #   e.g. `:seller_id` on a table sellers share with the operator
+      def validates_store_uniqueness(attribute, soft_delete_column: :deleted_at, scope: [])
+        # Resolved inside the lambda, not here: reading `column_names` while
+        # the class body runs would hit the database during boot.
+        conditions = lambda do
+          klass = respond_to?(:klass) ? self.klass : self
+          if klass.column_names.include?(soft_delete_column.to_s)
+            where(soft_delete_column => nil)
+          else
+            all
+          end
+        end
+
+        uniqueness_scope = [*spree_base_uniqueness_scope, :store_id, *scope]
+
+        validates attribute,
+                  uniqueness: { case_sensitive: false,
+                                scope: uniqueness_scope,
+                                conditions: conditions },
+                  # Checked only when the value or the scope it is unique
+                  # within changes — moving a delivery method to another
+                  # seller has to be checked too. A row that already shares
+                  # its value with another (from before this rule) stays
+                  # saveable until the follow-up adds the unique index and
+                  # renames existing duplicates.
+                  if: lambda { |record|
+                    [attribute, *uniqueness_scope].any? do |column|
+                      record.will_save_change_to_attribute?(column)
+                    end
+                  }
+      end
+    end
+  end
+end

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

@@ -1,13 +1,35 @@
 module Spree
+  # Restates a VAT-inclusive price for a customer in another country: the
+  # home-country VAT comes out, the destination's goes on.
   module VatPriceCalculation
+    # Cheapest test first: a domestic sale needs no restatement whatever the
+    # provider is, so the provider lookup (a constantize and an instantiation) is
+    # skipped for every home-country price — and a market pointing at a provider
+    # class that is no longer loadable keeps failing only where tax is computed,
+    # not on every price read.
     def gross_amount(amount, price_options)
       return amount if amount.nil? || !outside_default_vat_zone?(price_options)
+      return amount unless restatement_available?(price_options)
 
       round_to_two_places(add_foreign_vat_for(amount, price_options))
     end
 
     private
 
+    # Restatement reads nothing but TaxRate rows, for both halves of the sum, so
+    # it only means anything where those rows are the whole truth — the Internal
+    # provider. Elsewhere an absent row is ambiguous: it reads as "no tax is due
+    # here" and deducts the home VAT, when it may only mean "this market's tax is
+    # computed by an engine that keeps no rows here". A market on such an engine
+    # would see every foreign destination treated as a zero-rated export. It
+    # states its destination prices through a geo-scoped price list instead.
+    def restatement_available?(price_options)
+      market = price_options[:market] || Spree::Current.market
+      provider = market&.tax_provider_instance || Spree.default_tax_provider.new
+
+      provider.is_a?(Spree::TaxProvider::Internal)
+    end
+
     def add_foreign_vat_for(amount, price_options)
       amount = net_amount(amount, price_options[:tax_category])
       amount_with_foreign_vat(amount, price_options)
@@ -18,7 +40,7 @@ module Spree
     end
 
     def default_vat(tax_category)
-      included_tax_amount(tax_zone: default_zone, tax_category: tax_category)
+      included_tax_amount(country: default_tax_country, tax_category: tax_category)
     end
 
     def foreign_vat(price_options)
@@ -29,20 +51,50 @@ module Spree
       amount * (1 + foreign_vat(price_options))
     end
 
+    # Whether the price has to be restated at all.
     def outside_default_vat_zone?(price_options)
-      price_options[:tax_zone] && default_zone && price_options[:tax_zone] != default_zone
+      country = country_from(price_options)
+
+      country.present? && default_tax_country.present? && country != default_tax_country
     end
 
     def included_tax_amount(price_options)
-      Spree::TaxRate.included_tax_amount_for(price_options).to_f
+      lookup = { tax_category: price_options[:tax_category] }
+      if price_options[:address]
+        lookup[:address] = price_options[:address]
+      else
+        lookup[:country] = country_from(price_options)
+      end
+
+      Spree::TaxRate.included_tax_amount_for(lookup).to_f
     end
 
-    def default_zone
-      @default_zone ||= Spree::Zone.default_tax
+    # +current_price_options+ is documented as an override point, so an app may
+    # still be handing us the pre-6.0 zone. Say so instead of quietly reporting
+    # no country, which would leave a foreign customer looking at home VAT.
+    def country_from(price_options)
+      if price_options[:tax_zone].present? && price_options[:country].blank? && price_options[:address].blank?
+        Spree::Deprecation.warn(
+          'Passing tax_zone: in price options no longer determines tax and is ignored. ' \
+          'Pass country: (a Spree::Country) or address: instead.'
+        )
+      end
+
+      price_options[:country] || price_options[:address]&.country
+    end
+
+    # The country whose VAT the catalogue prices already include. Deliberately
+    # the store's own country and NOT Spree::Current.market, which follows the
+    # buyer: reading the destination here would make every sale look domestic
+    # and the restatement would never fire.
+    def default_tax_country
+      return @default_tax_country if defined?(@default_tax_country)
+
+      @default_tax_country = Spree::Current.store&.default_country
     end
 
     def round_to_two_places(amount)
-      BigDecimal(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
+      Spree::Money::Rounding.quantize(amount, 2)
     end
   end
 end

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

@@ -17,7 +17,7 @@ module Spree
     extend ActiveSupport::Concern
 
     # Payload keys under `data` whose values are live credentials.
-    SENSITIVE_PAYLOAD_KEYS = %w[reset_token unsubscribe_token verification_token].freeze
+    SENSITIVE_PAYLOAD_KEYS = %w[reset_token unsubscribe_token verification_token download_url].freeze
 
     REDACTION_PLACEHOLDER = '[REDACTED]'