spree_core 4.10.1 → 5.0.0.rc1

data/app/models/concerns/spree/stores/socials.rb

@@ -0,0 +1,68 @@
+module Spree
+  module Stores
+    module Socials
+      extend ActiveSupport::Concern
+
+      SUPPORTED_SOCIAL_NETWORKS = %w[instagram facebook twitter pinterest tiktok youtube spotify].freeze
+
+      SOCIAL_NETWORKS_CONFIG = {
+        twitter: {
+          input_placeholder: 'https://twitter.com/your_handle',
+          profile_link: 'https://twitter.com/your_handle'
+        },
+        instagram: {
+          input_placeholder: 'https://www.instagram.com/your_handle',
+          profile_link: 'https://www.instagram.com/your_handle'
+        },
+        facebook: {
+          input_placeholder: 'https://www.facebook.com/your_page',
+          profile_link: 'https://www.facebook.com/your_page'
+        },
+        youtube: {
+          input_placeholder: 'https://www.youtube.com/@your_channel',
+          profile_link: 'https://www.youtube.com/@your_channel'
+        },
+        pinterest: {
+          input_placeholder: 'https://pinterest.com/your_handle',
+          profile_link: 'https://pinterest.com/your_handle'
+        },
+        tiktok: {
+          input_placeholder: 'your_handle',
+          profile_link: 'https://www.tiktok.com/@your_handle'
+        },
+        spotify: {
+          input_placeholder: 'https://open.spotify.com/user/your_handle',
+          profile_link: 'https://open.spotify.com/user/your_handle'
+        }
+      }.freeze
+
+      included do
+        # generate methods for social links
+        SUPPORTED_SOCIAL_NETWORKS.each do |social|
+          # store the social handle in the public metadata
+          store_accessor :public_metadata, social
+
+          define_method "#{social}_link" do
+            return if send(social).blank?
+
+            send(social).match(/http/) ? send(social) : SOCIAL_NETWORKS_CONFIG[social.to_sym][:profile_link].gsub(/your_handle|your_page|your_channel/, send(social).sub(/^\//, '').sub(/^@/, ''))
+          end
+
+          define_method "#{social}_handle" do
+            return if send(social).blank?
+
+            (send(social).match(/http/) ? send(social).split('/').last : send(social)).sub(/^\//, '').gsub('@', '').split('?').first
+          end
+        end
+      end
+
+      def social_handle
+        @social_handle ||= instagram_handle || youtube_handle || tiktok_handle
+      end
+
+      def social_links
+        @social_links ||= [instagram_link, facebook_link, twitter_link, pinterest_link, youtube_link, tiktok_link, spotify_link].compact_blank
+      end
+    end
+  end
+end

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

@@ -20,6 +20,10 @@ module Spree
 
       validate :address_not_associated_with_other_user, :address_not_deprecated_in_completed_order
 
+      def address
+        @address ||= bill_address || ship_address || addresses.first
+      end
+
       def persist_order_address(order)
         # FIXME: we should check if the User's address is associated with country accepted by Store
         # if not we should try to find an address with valid country in User's address book

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

@@ -6,7 +6,7 @@ module Spree
     include Spree::UserReporting
     include Spree::UserRoles
     include Spree::RansackableAttributes
-
+    include Spree::MultiSearchable
     included do
       # we need to have this callback before any dependent: :destroy associations
       # https://github.com/rails/rails/issues/3458
@@ -16,19 +16,56 @@ module Spree
 
       attr_accessor :use_billing
 
+      has_person_name
+      auto_strip_attributes :email, :first_name, :last_name
+      acts_as_taggable_on :tags
+
+      #
+      # 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 :store_credits, foreign_key: :user_id, class_name: 'Spree::StoreCredit'
-
+      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'
       belongs_to :ship_address, class_name: 'Spree::Address', optional: true
       belongs_to :bill_address, class_name: 'Spree::Address', optional: true
 
-      has_many :wishlists, class_name: 'Spree::Wishlist', foreign_key: :user_id
+      #
+      # Attachments
+      #
+      has_one_attached :avatar, service: Spree.public_storage_service_name
+
+      #
+      # Attributes
+      #
+      attr_accessor :confirm_email, :terms_of_service
+
+      def self.multi_search(query)
+        sanitized_query = sanitize_query_for_multi_search(query)
+        return none if query.blank?
+
+        name_conditions = []
+
+        name_conditions << multi_search_condition(self, :first_name, sanitized_query)
+        name_conditions << multi_search_condition(self, :last_name, sanitized_query)
+
+        full_name = NameOfPerson::PersonName.full(sanitized_query)
 
-      self.whitelisted_ransackable_associations = %w[bill_address ship_address addresses]
-      self.whitelisted_ransackable_attributes = %w[id email]
+        if full_name.first.present? && full_name.last.present?
+          name_conditions << multi_search_condition(self, :first_name, full_name.first)
+          name_conditions << multi_search_condition(self, :last_name, full_name.last)
+        end
+
+        where(email: sanitized_query).or(where(name_conditions.reduce(:or)))
+      end
+
+      self.whitelisted_ransackable_associations = %w[bill_address ship_address addresses tags spree_roles]
+      self.whitelisted_ransackable_attributes = %w[id email first_name last_name accepts_email_marketing]
+      self.whitelisted_ransackable_scopes = %w[multi_search]
 
       def self.with_email(query)
         where("#{table_name}.email LIKE ?", "%#{query}%")
@@ -48,7 +85,7 @@ module Spree
     end
 
     def last_incomplete_spree_order(store, options = {})
-      orders.where(store: store).incomplete.
+      orders.where(store: store).incomplete.not_canceled.
         includes(options[:includes]).
         order('created_at DESC').
         first
@@ -69,12 +106,15 @@ module Spree
     end
 
     def default_wishlist_for_store(current_store)
-      wishlists.find_or_create_by(is_default: true, store_id: current_store.id) do |wishlist|
-        wishlist.name = Spree.t(:default_wishlist_name)
-        wishlist.save
+      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
 
+    def can_be_deleted?
+      orders.complete.none?
+    end
+
     private
 
     def check_completed_orders
@@ -82,6 +122,8 @@ module Spree
     end
 
     def nullify_approver_id_in_approved_orders
+      return unless Spree.admin_user_class != Spree.user_class
+
       Spree::Order.where(approver_id: id).update_all(approver_id: nil)
     end
 
@@ -97,5 +139,13 @@ module Spree
     def use_billing?
       use_billing.in?([true, 'true', '1'])
     end
+
+    def scramble_email_and_names
+      self.email = "#{SecureRandom.uuid}@example.net"
+      self.first_name = 'Deleted'
+      self.last_name = 'User'
+      self.login = email
+      save
+    end
   end
 end

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

@@ -6,7 +6,7 @@ module Spree
     def report_values_for(report_name, store)
       store ||= Store.default
 
-      completed_orders(store).pluck(:currency).uniq.each_with_object([]) do |currency, arr|
+      completed_orders_for_store(store).pluck(:currency).uniq.each_with_object([]) do |currency, arr|
         arr << send("display_#{report_name}", store: store, currency: currency)
       end
     end
@@ -31,17 +31,25 @@ module Spree
                       column: :all)
     end
 
+    def amount_spent_in(currency)
+      completed_orders.where(currency: currency).sum(:total)
+    end
+
+    def display_amount_spent_in(currency)
+      Money.new(amount_spent_in(currency), currency: currency).to_html
+    end
+
+    def completed_orders_for_store(store)
+      orders.for_store(store).complete.order(currency: :desc)
+    end
+
     private
 
     def order_calculate(operation:, column:, store: nil, currency: nil)
       store ||= Store.default
       currency ||= store.default_currency
 
-      completed_orders(store).where(currency: currency).calculate(operation, column) || BigDecimal('0.00')
-    end
-
-    def completed_orders(store)
-      orders.for_store(store).complete.order(currency: :desc)
+      completed_orders_for_store(store).where(currency: currency).calculate(operation, column) || BigDecimal('0.00')
     end
   end
 end

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

@@ -3,7 +3,7 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
-      has_many :role_users, class_name: 'Spree::RoleUser', foreign_key: :user_id, dependent: :destroy
+      has_many :role_users, class_name: 'Spree::RoleUser', foreign_key: :user_id, as: :user, dependent: :destroy
       has_many :spree_roles, through: :role_users, class_name: 'Spree::Role', source: :role
 
       scope :spree_admin, -> { joins(:spree_roles).where(Spree::Role.table_name => { name: 'admin' }) }

data/app/models/spree/ability.rb

@@ -58,12 +58,14 @@ module Spree
 
     def apply_admin_permissions(user)
       can :manage, :all
+      cannot :cancel, Spree::Order
+      can :cancel, Spree::Order, &:allow_cancel?
+      cannot [:edit, :update], Spree::RefundReason, mutable: false
+      cannot [:edit, :update], Spree::ReimbursementType, mutable: false
     end
 
     def apply_user_permissions(user)
       can :read, ::Spree::Country
-      can :read, ::Spree::Menu
-      can :read, ::Spree::CmsPage
       can :read, ::Spree::OptionType
       can :read, ::Spree::OptionValue
       can :create, ::Spree::Order

data/app/models/spree/address.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Address < Spree::Base
+  class Address < Spree.base_class
     require 'validates_zipcode'
 
     include Spree::Metadata
@@ -10,11 +10,7 @@ module Spree
       include Spree::Security::Addresses
     end
 
-    if Rails::VERSION::STRING >= '7.1.0'
-      serialize :preferences, type: Hash, coder: YAML, default: {}
-    else
-      serialize :preferences, Hash, default: {}
-    end
+    serialize :preferences, type: Hash, coder: YAML, default: {}
 
     NO_ZIPCODE_ISO_CODES ||= [
       'AO', 'AG', 'AW', 'BS', 'BZ', 'BJ', 'BM', 'BO', 'BW', 'BF', 'BI', 'CM', 'CF', 'KM', 'CG',
@@ -33,17 +29,31 @@ module Spree
     # we're not freezing this on purpose so developers can extend and manage
     # 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)
+    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)
 
     scope :not_deleted, -> { where(deleted_at: nil) }
 
+    scope :by_state_name_or_abbr, lambda { |state_name|
+      joins(:state).merge(Spree::State.where(name: state_name).or(Spree::State.where(abbr: state_name)))
+    }
+
+    scope :not_quick_checkout, -> { where(quick_checkout: false) }
+
     belongs_to :country, class_name: 'Spree::Country'
     belongs_to :state, class_name: 'Spree::State', optional: true
-    belongs_to :user, class_name: "::#{Spree.user_class}", optional: true
+    belongs_to :user, class_name: Spree.user_class.name, optional: true, touch: true
 
     has_many :shipments, inverse_of: :address
 
+    after_initialize :set_default_values, if: -> { new_record? && user.present? }
+
     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? }
+
+    after_commit :async_geocode
 
     with_options presence: true do
       validates :firstname, :lastname, if: :require_name?
@@ -64,8 +74,7 @@ module Spree
     delegate :name, :iso3, :iso, :iso_name, to: :country, prefix: true
     delegate :abbr, to: :state, prefix: true, allow_nil: true
 
-    alias_attribute :first_name, :firstname
-    alias_attribute :last_name, :lastname
+    alias_attribute :postal_code, :zipcode
 
     self.whitelisted_ransackable_attributes = ADDRESS_FIELDS
     self.whitelisted_ransackable_associations = %w[country state user]
@@ -76,6 +85,30 @@ module Spree
       end.flatten
     end
 
+    def user_default_billing?
+      user.present? && id == user.bill_address_id
+    end
+
+    def user_default_shipping?
+      user.present? && id == user.ship_address_id
+    end
+
+    def first_name
+      firstname
+    end
+
+    def first_name=(value)
+      self.firstname = value
+    end
+
+    def last_name
+      lastname
+    end
+
+    def last_name=(value)
+      self.lastname = value
+    end
+
     def full_name
       "#{firstname} #{lastname}".strip
     end
@@ -88,6 +121,10 @@ module Spree
       state_name.present? ? state_name : state&.name
     end
 
+    def street
+      [address1, address2].join(' ')
+    end
+
     def to_s
       [
         full_name,
@@ -136,23 +173,31 @@ module Spree
     end
 
     def require_zipcode?
-      country ? country.zipcode_required? : true
+      !quick_checkout && (country ? country.zipcode_required? : true)
     end
 
     def require_name?
-      true
+      !quick_checkout
+    end
+
+    def require_company?
+      false
     end
 
     def require_street?
-      true
+      !quick_checkout
+    end
+
+    def show_company_address_field?
+      false
     end
 
     def editable?
-      new_record? || (shipments.empty? && !Order.complete.where('bill_address_id = ? OR ship_address_id = ?', id, id).exists?)
+      new_record? || Order.complete.where('bill_address_id = ? OR ship_address_id = ?', id, id).none?
     end
 
     def can_be_deleted?
-      shipments.empty? && !Order.complete.where('bill_address_id = ? OR ship_address_id = ?', id, id).exists?
+      shipments.empty? && Order.complete.where('bill_address_id = ? OR ship_address_id = ?', id, id).none?
     end
 
     def check
@@ -162,16 +207,37 @@ module Spree
     end
 
     def destroy
+      assign_new_default_address_to_user
+
       if can_be_deleted?
         super
       else
         update_column :deleted_at, Time.current
-        assign_new_default_address_to_user
       end
     end
 
+    def async_geocode
+      Spree::Addresses::GeocodeAddressJob.perform_later(id) if should_geocode?
+    end
+
+    def geocoder_address
+      @geocoder_address ||= [street, city, state_text, country.to_s].compact.map(&:strip).join(', ')
+    end
+
     private
 
+    def should_geocode?
+      Spree::Config[:geocode_addresses] && (
+        saved_changes.key?(:address1) || saved_changes.key?(:city) || saved_changes.key?(:state_id) || saved_changes.key?(:country_id)
+      )
+    end
+
+    def set_default_values
+      self.firstname ||= user.first_name
+      self.lastname ||= user.last_name
+      self.phone ||= user.phone
+    end
+
     def clear_state
       self.state = nil
     end
@@ -188,6 +254,27 @@ 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
+        user.last_name = lastname
+      end
+      user.phone = user.phone.presence || phone.presence
+
+      user.save! if user.changed?
+    end
+
     def state_validate
       # Skip state validation without country (also required)
       # or when disabled by preference
@@ -206,16 +293,14 @@ module Spree
       end
 
       # ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
-      if state_name.present?
-        if country.states.present?
-          states = country.states.find_all_by_name_or_abbr(state_name)
-
-          if states.size == 1
-            self.state = states.first
-            clear_state_name
-          else
-            errors.add(:state, :invalid)
-          end
+      if state_name.present? && country.states.present?
+        states = country.states.find_all_by_name_or_abbr(state_name)
+
+        if states.size == 1
+          self.state = states.first
+          clear_state_name
+        else
+          errors.add(:state, :invalid)
         end
       end
 
@@ -238,9 +323,18 @@ module Spree
     def assign_new_default_address_to_user
       return unless user
 
-      user.bill_address = user.addresses.last if user.bill_address == self
-      user.ship_address = user.addresses.last if user.ship_address == self
+      user.reload
+      return if user.bill_address != self && user.ship_address != self
+
+      last_address = assign_new_default_address_to_user_scope.find { |address| address.id != id && address.valid? }
+
+      user.bill_address = last_address if user.bill_address == self
+      user.ship_address = last_address if user.ship_address == self
       user.save!
     end
+
+    def assign_new_default_address_to_user_scope
+      user.addresses.not_quick_checkout.reorder(created_at: :desc)
+    end
   end
 end

data/app/models/spree/adjustment.rb

@@ -21,7 +21,7 @@
 # total. This allows an adjustment to be preserved if it becomes ineligible so
 # it might be reinstated.
 module Spree
-  class Adjustment < Spree::Base
+  class Adjustment < Spree.base_class
     with_options polymorphic: true do
       belongs_to :adjustable, touch: true
       belongs_to :source
@@ -101,7 +101,10 @@ module Spree
       amount = source.compute_amount(target)
       attributes = { amount: amount, updated_at: Time.current }
       attributes[:eligible] = source.promotion.eligible?(target) if promotion?
+
       update_columns(attributes)
+      source.promotion.touch if promotion?
+
       amount
     end
 

data/app/models/spree/asset/support/active_storage.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Asset < Spree::Base
+  class Asset < Spree.base_class
     module Support
       module ActiveStorage
         extend ActiveSupport::Concern

data/app/models/spree/asset.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Asset < Spree::Base
+  class Asset < Spree.base_class
     include Support::ActiveStorage
     include Spree::Metadata
     if defined?(Spree::Webhooks::HasWebhooks)
@@ -9,12 +9,24 @@ module Spree
     belongs_to :viewable, polymorphic: true, touch: true
     acts_as_list scope: [:viewable_id, :viewable_type]
 
-    if Spree.public_storage_service_name
-      has_one_attached :attachment, service: Spree.public_storage_service_name
-    else
-      has_one_attached :attachment
-    end
+    delegate :key, :attached?, :variant, :variable?, :blob, :filename, to: :attachment
+
+    has_one_attached :attachment, service: Spree.public_storage_service_name
 
     default_scope { includes(attachment_attachment: :blob) }
+
+    store_accessor :private_metadata, :session_uploaded_assets_uuid
+    scope :with_session_uploaded_assets_uuid, lambda { |uuid|
+      case ActiveRecord::Base.connection.adapter_name
+      when 'PostgreSQL'
+        where("#{table_name}.private_metadata @> ?", { session_uploaded_assets_uuid: uuid }.to_json)
+      when 'Mysql2', 'SQLite'
+        where("JSON_EXTRACT(private_metadata, '$.session_uploaded_assets_uuid') = '#{uuid}'")
+      end
+    }
+
+    def product
+      @product ||= viewable_type == 'Spree::Variant' ? viewable&.product : nil
+    end
   end
 end

data/app/models/spree/base.rb

@@ -1,11 +1,5 @@
 class Spree::Base < ApplicationRecord
   include Spree::Preferences::Preferable
-  if Rails::VERSION::STRING >= '7.1.0'
-    serialize :preferences, type: Hash, coder: YAML
-  else
-    serialize :preferences, Hash
-  end
-
   include Spree::RansackableAttributes
   include Spree::TranslatableResourceScopes
 
@@ -23,6 +17,10 @@ class Spree::Base < ApplicationRecord
 
   self.abstract_class = true
 
+  scope :for_ordering_with_translations, lambda { |klass, fields = nil|
+    select("#{klass.table_name}.*").select(*(fields || klass::TRANSLATABLE_FIELDS))
+  }
+
   def self.belongs_to_required_by_default
     false
   end
@@ -50,8 +48,13 @@ class Spree::Base < ApplicationRecord
     false
   end
 
+  # this can overridden in subclasses to disallow deletion
+  def can_be_deleted?
+    true
+  end
+
   def self.json_api_columns
-    column_names.reject { |c| c.match(/_id$|id|preferences|(.*)password|(.*)token|(.*)api_key/) }
+    column_names.reject { |c| c.match(/_id$|id|preferences|(.*)password|(.*)token|(.*)api_key|^original_(.*)/) }
   end
 
   def self.json_api_permitted_attributes
@@ -67,4 +70,32 @@ class Spree::Base < ApplicationRecord
   def self.json_api_type
     to_s.demodulize.underscore
   end
+
+  def self.to_tom_select_json
+    pluck(:name, :id).map do |name, id|
+      {
+        id: id,
+        name: name
+      }
+    end.as_json
+  end
+
+  def uuid_for_friendly_id
+    SecureRandom.uuid
+  end
+
+  # Try building a slug based on the following fields in increasing order of specificity.
+  def slug_candidates
+    if defined?(:deleted_at) && deleted_at.present?
+      [
+        ['deleted', :name],
+        ['deleted', :name, :uuid_for_friendly_id]
+      ]
+    else
+      [
+        [:name],
+        [:name, :uuid_for_friendly_id]
+      ]
+    end
+  end
 end