spree_core 4.10.1 → 5.0.0.rc1

data/app/models/spree/base_analytics_event_handler.rb

@@ -0,0 +1,49 @@
+module Spree
+  class BaseAnalyticsEventHandler
+    # Initializes the event handler
+    # @param client [Object] The client object
+    # @param opts [Hash] The options
+    # @option opts [User] :user
+    # @option opts [String] :session_id
+    def initialize(opts = {})
+      @user = opts[:user]
+      @session = opts[:session]
+      @request = opts[:request]
+    end
+
+    attr_reader :user, :session, :request
+
+    # Returns the client
+    # @return [Object] The client object
+    def client
+      raise NotImplementedError, 'Subclasses must implement the client method'
+    end
+
+    # Handles the event
+    # @param event_name [String] eg. 'order_completed'
+    # @param properties [Hash] eg. { product: Spree::Product, taxon: Spree::Taxon, query: String }
+    # rubocop:disable Lint/UnusedMethodArgument
+    def handle_event(event_name, properties = {})
+      raise NotImplementedError, 'Subclasses must implement the handle method'
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    # Returns the human name for the event
+    # @param event_name [String] eg. 'order_completed'
+    # @return [String] eg. 'Order Completed'
+    def event_human_name(event_name)
+      Analytics.events[event_name.to_sym]
+    end
+
+    protected
+
+    # Returns the identity hash for the event
+    # @return [Hash] eg. { user_id: 1, session_id: '123' }
+    def identity_hash
+      {
+        user_id: user&.id,
+        session_id: session&.id
+      }
+    end
+  end
+end

data/app/models/spree/calculator.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Calculator < Spree::Base
+  class Calculator < Spree.base_class
     acts_as_paranoid
 
     belongs_to :calculable, polymorphic: true, optional: true, inverse_of: :calculator

data/app/models/spree/classification.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Classification < Spree::Base
+  class Classification < Spree.base_class
     self.table_name = 'spree_products_taxons'
     acts_as_list scope: :taxon
 
@@ -14,5 +14,14 @@ module Spree
     validates :taxon_id, uniqueness: { scope: :product_id, message: :already_linked, allow_blank: true }
 
     self.whitelisted_ransackable_attributes = ['taxon_id', 'product_id']
+
+    scope :by_best_selling, lambda { |order_direction = :desc|
+      left_joins(product: :orders).
+        select("#{Spree::Classification.table_name}.*, COUNT(#{Spree::Order.table_name}.id) AS completed_orders_count, SUM(#{Spree::Order.table_name}.total) AS completed_orders_total").
+        where(Spree::Order.table_name => { id: nil }).
+        or(where.not(Spree::Order.table_name => { completed_at: nil })).
+        group("#{Spree::Classification.table_name}.id").
+        reorder(completed_orders_count: order_direction, completed_orders_total: order_direction)
+    }
   end
 end

data/app/models/spree/country.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Country < Spree::Base
+  class Country < Spree.base_class
     has_many :addresses, dependent: :restrict_with_error
     has_many :states,
              -> { order name: :asc },

data/app/models/spree/coupon_code.rb

@@ -0,0 +1,38 @@
+module Spree
+  class CouponCode < Spree.base_class
+    include Spree::Security::CouponCodes if defined?(Spree::Security::CouponCodes)
+
+    enum :state, %i(unused used)
+
+    acts_as_paranoid
+
+    scope :used_with_code, ->(code) { used.where(code: code.downcase) }
+    scope :with_order, ->(order_id) { where(order_id: order_id) }
+    scope :in_promotions, ->(promotion_ids) { where(promotion_id: promotion_ids) }
+    scope :not_in_promotions, ->(promotion_ids) { where.not(promotion_id: promotion_ids) }
+
+    belongs_to :promotion, class_name: 'Spree::Promotion', touch: true
+    belongs_to :order, class_name: 'Spree::Order'
+
+    validates :code, presence: true, uniqueness: { scope: spree_base_uniqueness_scope, conditions: -> { where(deleted_at: nil) } }
+    validates :state, :promotion, presence: true
+
+    self.whitelisted_ransackable_attributes = %w[state code]
+
+    def self.used?(code)
+      used_with_code(code).any?
+    end
+
+    def apply_order!(order)
+      update(order: order, state: 'used')
+    end
+
+    def remove_from_order
+      update(order: nil, state: 'unused')
+    end
+
+    def display_code
+      code.upcase
+    end
+  end
+end

data/app/models/spree/credit_card.rb

@@ -1,5 +1,5 @@
 module Spree
-  class CreditCard < Spree::Base
+  class CreditCard < Spree.base_class
     include ActiveMerchant::Billing::CreditCardMethods
     include Spree::Metadata
     if defined?(Spree::Webhooks::HasWebhooks)
@@ -12,8 +12,9 @@ module Spree
     acts_as_paranoid
 
     belongs_to :payment_method
-    belongs_to :user, class_name: "::#{Spree.user_class}", foreign_key: 'user_id',
-                      optional: true
+    belongs_to :user, class_name: "::#{Spree.user_class}", foreign_key: 'user_id', optional: true
+    belongs_to :gateway_customer, class_name: 'Spree::GatewayCustomer', optional: true
+
     has_many :payments, as: :source
 
     before_save :set_last_digits

data/app/models/spree/current.rb

@@ -0,0 +1,9 @@
+module Spree
+  class Current < ::ActiveSupport::CurrentAttributes
+    attribute :store
+
+    def store
+      super || Spree::Store.default
+    end
+  end
+end

data/app/models/spree/custom_domain.rb

@@ -0,0 +1,53 @@
+module Spree
+  class CustomDomain < Spree::Base
+    include Spree::SingleStoreResource
+    include Spree::Metadata
+
+    auto_strip_attributes :url
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store', inverse_of: :custom_domains, touch: true
+
+    #
+    # Validations
+    #
+    validates :url, presence: true, uniqueness: true, format: {
+      with: %r{[a-z][a-z0-9-]*[a-z0-9]}i
+    }, length: { in: 1..63 }
+    validate :url_is_valid
+
+    #
+    # Callbacks
+    #
+    before_validation :sanitize_url
+    after_save :ensure_has_one_default
+    after_validation :ensure_default, on: :create
+
+    def url_is_valid
+      parts = url.split('.')
+
+      errors.add(:url, 'use domain or subdomain') if (parts[0] != 'www' && parts.size > 3) || (parts[0] == 'www' && parts.size > 4) || parts.size < 2
+    end
+
+    def ensure_default
+      self.default = store.custom_domains.count.zero?
+    end
+
+    def ensure_has_one_default
+      store.custom_domains.where.not(id: id).update_all(default: false) if default?
+    end
+
+    def active?
+      true
+    end
+
+    private
+
+    # remove https:// and http:// from the url
+    def sanitize_url
+      self.url = url&.gsub(%r{https?://}, '')
+    end
+  end
+end

data/app/models/spree/customer_return.rb

@@ -1,5 +1,5 @@
 module Spree
-  class CustomerReturn < Spree::Base
+  class CustomerReturn < Spree.base_class
     include Spree::Core::NumberGenerator.new(prefix: 'CR', length: 9)
     include Spree::NumberIdentifier
     include Spree::Metadata
@@ -54,6 +54,18 @@ module Spree
       return_items.sum(:pre_tax_amount)
     end
 
+    def can_create_reimbursement?
+      !fully_reimbursed? && completely_decided? && no_pending_reimbursements?
+    end
+
+    def no_pending_reimbursements?
+      if association(:reimbursements).loaded?
+        reimbursements.select(&:pending?).empty?
+      else
+        reimbursements.where(reimbursement_status: :pending).none?
+      end
+    end
+
     private
 
     def inventory_units

data/app/models/spree/data_feed.rb

@@ -1,5 +1,5 @@
 module Spree
-  class DataFeed < Base
+  class DataFeed < Spree.base_class
     belongs_to :store, class_name: 'Spree::Store', foreign_key: 'store_id'
 
     scope :for_store, ->(store) { where(store: store) }

data/app/models/spree/digital.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Digital < Spree::Base
+  class Digital < Spree.base_class
     belongs_to :variant
     has_many :digital_links, dependent: :destroy
 
@@ -7,13 +7,12 @@ module Spree
       include Spree::Webhooks::HasWebhooks
     end
 
-    if Spree.private_storage_service_name
-      has_one_attached :attachment, service: Spree.private_storage_service_name
-    else
-      has_one_attached :attachment
-    end
+    has_one_attached :attachment, service: Spree.private_storage_service_name
 
     validates :attachment, attached: true
     validates :variant, presence: true
+
+    delegate :product, to: :variant
+    delegate :filename, :content_type, to: :attachment
   end
 end

data/app/models/spree/digital_link.rb

@@ -1,5 +1,5 @@
 module Spree
-  class DigitalLink < Spree::Base
+  class DigitalLink < Spree.base_class
     if Rails::VERSION::STRING >= '7.1.0'
       has_secure_token on: :save
     else
@@ -20,21 +20,24 @@ module Spree
     validates :digital, :line_item, presence: true
     validates :access_counter, numericality: { greater_than_or_equal_to: 0 }
 
+    delegate :filename, :content_type, to: :digital
+    delegate :order, to: :line_item
+
     def authorizable?
       !(expired? || access_limit_exceeded?)
     end
 
     def expired?
-      if line_item.order.store.limit_digital_download_days
-        created_at <= line_item.order.store.digital_asset_authorized_days.day.ago
+      if line_item.order.store.preferred_limit_digital_download_days
+        created_at <= line_item.order.store.preferred_digital_asset_authorized_days.day.ago
       else
         false
       end
     end
 
     def access_limit_exceeded?
-      if line_item.order.store.limit_digital_download_count
-        access_counter >= line_item.order.store.digital_asset_authorized_clicks
+      if line_item.order.store.preferred_limit_digital_download_count
+        access_counter >= line_item.order.store.preferred_digital_asset_authorized_clicks
       else
         false
       end
@@ -43,7 +46,9 @@ module Spree
     # This method should be called when a download is initiated.
     # It returns +true+ or +false+ depending on whether the authorization is granted.
     def authorize!
-      authorizable? && increment!(:access_counter, touch: true) ? true : false
+      ActiveRecord::Base.connected_to(role: :writing) do
+        authorizable? && increment!(:access_counter, touch: true)
+      end
     end
 
     def reset!

data/app/models/spree/export.rb

@@ -0,0 +1,172 @@
+require 'csv'
+
+module Spree
+  class Export < Spree.base_class
+    SUPPORTED_FILE_FORMATS = %i[csv].freeze
+
+    include Spree::SingleStoreResource
+    include Spree::NumberIdentifier
+    include Spree::NumberAsParam
+    include Spree::VendorConcern if defined?(Spree::VendorConcern)
+
+    include Spree::Core::NumberGenerator.new(prefix: 'EF')
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :user, class_name: Spree.admin_user_class.to_s
+    belongs_to :vendor, -> { with_deleted }, class_name: 'Spree::Vendor', optional: true
+
+    #
+    # Validations
+    #
+    validates :format, :store, :user, :type, presence: true
+
+    #
+    # Enums
+    #
+    enum :format, SUPPORTED_FILE_FORMATS.each_with_index.to_h
+
+    #
+    # Ransack configuration
+    #
+    self.whitelisted_ransackable_attributes = %w[number type format vendor_id]
+
+    #
+    # Attachments
+    #
+    has_one_attached :attachment, service: Spree.private_storage_service_name
+
+    #
+    # Callbacks
+    #
+    before_validation :set_default_format, on: :create
+    before_create :clear_search_params, if: -> { record_selection == 'all' }
+    after_commit :generate_async, on: :create
+
+    #
+    # Virtual attributes
+    #
+    attribute :record_selection, :string, default: 'filtered'
+
+    def done?
+      attachment.present? && attachment.attached?
+    end
+
+    def generate_async
+      Spree::Exports::GenerateJob.perform_later(id)
+    end
+
+    def generate
+      send(:"generate_#{format}")
+      handle_attachment
+      send_export_done_email
+    end
+
+    def generate_csv
+      ::CSV.open(export_tmp_file_path, 'wb', encoding: 'UTF-8', col_sep: ',', row_sep: "\r\n") do |csv|
+        csv << csv_headers
+        records_to_export.includes(scope_includes).find_in_batches do |batch|
+          batch.each do |record|
+            if multi_line_csv?
+              record.to_csv(store).each do |line|
+                csv << line
+              end
+            else
+              csv << record.to_csv(store)
+            end
+          end
+        end
+      end
+    end
+
+    def multi_line_csv?
+      false
+    end
+
+    def csv_headers
+      raise NotImplementedError, 'csv_headers must be implemented'
+    end
+
+    def build_csv_line(_record)
+      raise NotImplementedError, 'build_csv_line must be implemented'
+    end
+
+    def handle_attachment
+      file = ::File.open(export_tmp_file_path)
+      attachment.attach(io: file, filename: export_file_name)
+      ::File.delete(export_tmp_file_path) if ::File.exist?(export_tmp_file_path)
+    end
+
+    def scope
+      scope = model_class
+      scope = scope.for_store(store) if model_class.respond_to?(:for_store)
+      scope = scope.for_vendor(vendor) if model_class.respond_to?(:for_vendor) && vendor.present?
+      scope.accessible_by(current_ability)
+    end
+
+    def records_to_export
+      if search_params.present?
+        scope.ransack(search_params.is_a?(String) ? JSON.parse(search_params.to_s).to_h : search_params)
+      else
+        scope.ransack
+      end.result
+    end
+
+    def scope_includes
+      []
+    end
+
+    # eg. Spree::Exports::Products => Spree::Product
+    def model_class
+      "Spree::#{type.demodulize.singularize}".constantize
+    end
+
+    def current_ability
+      @current_ability ||= Spree::Dependencies.ability_class.constantize.new(user)
+    end
+
+    # eg. Spree::Exports::Products => products-store-my-store-code-20241030133348.csv
+    def export_file_name
+      "#{type.demodulize.underscore}-#{store.code}-#{created_at.strftime('%Y%m%d%H%M%S')}.#{format}"
+    end
+
+    def export_tmp_file_path
+      Rails.root.join('tmp', export_file_name)
+    end
+
+    def send_export_done_email
+      Spree::ExportMailer.export_done(self).deliver_later
+    end
+
+    class << self
+      def available_types
+        Rails.application.config.spree.export_types
+      end
+
+      def available_models
+        available_types.map(&:model_class)
+      end
+
+      def type_for_model(model)
+        available_types.find { |type| type.model_class.to_s == model.to_s }
+      end
+
+      # eg. Spree::Exports::Products => Spree::Product
+      def model_class
+        "Spree::#{to_s.demodulize.singularize}".constantize
+      end
+    end
+
+    private
+
+    def set_default_format
+      self.format = SUPPORTED_FILE_FORMATS.first if format.blank?
+    end
+
+    def clear_search_params
+      self.search_params = nil
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Spree
+  module Exports
+    class Orders < Spree::Export
+      def scope_includes
+        [
+          :payments,
+          :shipments,
+          { bill_address: :state },
+          { ship_address: :state },
+          { line_items: { variant: { product: [:taxons] } } }
+        ]
+      end
+
+      def multi_line_csv?
+        true
+      end
+
+      def csv_headers
+        Spree::CSV::OrderLineItemPresenter::HEADERS
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Spree
+  module Exports
+    class Products < Spree::Export
+      # to avoid N+1 queries
+      def scope_includes
+        [:tax_category, :master, { taxons: :taxonomy }, { product_properties: [:property] }, { variants_including_master: variant_includes }]
+      end
+
+      def variant_includes
+        [:images, :prices, :stock_items, { option_values: [:option_type] }]
+      end
+
+      def multi_line_csv?
+        true
+      end
+
+      # when doing full product export, we want to exclude archived products
+      def scope
+        if search_params.nil?
+          super.where.not(status: 'archived')
+        else
+          super
+        end
+      end
+
+      def csv_headers
+        @csv_headers ||= Spree::CSV::ProductVariantPresenter::CSV_HEADERS + properties_headers
+      end
+
+      def properties_headers
+        @properties_headers ||= Spree::Property.order(:position).count.times.flat_map { |n| ["property#{n + 1}_name", "property#{n + 1}_value"] }
+      end
+    end
+  end
+end

data/app/models/spree/gateway/bogus.rb

@@ -10,11 +10,16 @@ module Spree
     attr_accessor :test
 
     preference :dummy_key, :string, default: 'PUBLICKEY123'
+    preference :dummy_secret_key, :password, default: 'SECRETKEY123'
 
     def provider_class
       self.class
     end
 
+    def show_in_admin?
+      false
+    end
+
     def create_profile(payment)
       return if payment.source.has_payment_profile?
 

data/app/models/spree/gateway.rb

@@ -4,15 +4,19 @@ module Spree
 
     delegate :authorize, :purchase, :capture, :void, :credit, to: :provider
 
-    validates :type, presence: true
-
-    preference :server, :string, default: 'test'
-    preference :test_mode, :boolean, default: true
+    validates :type, presence: true, inclusion: { in: :valid_providers_list }
 
     def payment_source_class
       CreditCard
     end
 
+    # Override in the gateway to provide a payment url
+    # eg. for Stripe, this would be the payment intent url
+    # https://dashboard.stripe.com/payments/#{payment.transaction_id}
+    def gateway_dashboard_payment_url(_payment)
+      nil
+    end
+
     def provider
       gateway_options = options
       gateway_options.delete :login if gateway_options.key?(:login) && gateway_options[:login].nil?
@@ -77,5 +81,11 @@ module Spree
         end
       end
     end
+
+    private
+
+    def valid_providers_list
+      Spree::PaymentMethod.providers.map(&:to_s)
+    end
   end
 end

data/app/models/spree/gateway_customer.rb

@@ -0,0 +1,13 @@
+module Spree
+  class GatewayCustomer < Spree.base_class
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
+    belongs_to :user, class_name: Spree.user_class.to_s
+
+    validates :payment_method, presence: true
+    validates :user, presence: true
+    validates :profile_id, presence: true
+    validates :payment_method_id, uniqueness: { scope: :user_id }
+
+    encrypts :profile_id, deterministic: true if Rails.configuration.active_record.encryption.include?(:primary_key)
+  end
+end

data/app/models/spree/image/configuration/active_storage.rb

@@ -5,7 +5,7 @@ module Spree
         extend ActiveSupport::Concern
 
         included do
-          validates :attachment, attached: true, content_type: /\Aimage\/.*\z/
+          validates :attachment, attached: true, content_type: Rails.application.config.active_storage.web_image_content_types
 
           def self.styles
             @styles ||= {

data/app/models/spree/inventory_unit.rb

@@ -1,5 +1,5 @@
 module Spree
-  class InventoryUnit < Spree::Base
+  class InventoryUnit < Spree.base_class
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks
     end

data/app/models/spree/legacy_user.rb

@@ -1,6 +1,6 @@
 # Default implementation of User.  This class is intended to be modified by extensions (ex. spree_auth_devise)
 module Spree
-  class LegacyUser < Spree::Base
+  class LegacyUser < Spree.base_class
     include Spree::UserAddress
     include Spree::UserPaymentSource
     include Spree::UserMethods
@@ -9,5 +9,7 @@ module Spree
     self.table_name = 'spree_users'
 
     attr_accessor :password, :password_confirmation
+
+    validates :email, presence: true, uniqueness: { case_sensitive: false }
   end
 end