spree_core 4.10.1 → 5.0.0.rc1

data/app/models/spree/payment/gateway_options.rb

@@ -1,18 +1,19 @@
 module Spree
-  class Payment < Spree::Base
+  class Payment < Spree.base_class
     class GatewayOptions
       def initialize(payment)
         @payment = payment
+        @order = payment.order
       end
 
+      attr_reader :payment, :order
+      delegate :currency, to: :payment
+      delegate :email, to: :order
+
       def statement_descriptor_suffix
         order.number
       end
 
-      def email
-        order.email
-      end
-
       def customer
         order.email
       end
@@ -26,7 +27,11 @@ module Spree
       end
 
       def order_id
-        "#{order.number}-#{@payment.number}"
+        "#{order.number}-#{payment.number}"
+      end
+
+      def payment_id
+        payment.number
       end
 
       def shipping
@@ -45,10 +50,6 @@ module Spree
         order.promo_total * exchange_multiplier
       end
 
-      def currency
-        @payment.currency
-      end
-
       def billing_address
         order.bill_address.try(:active_merchant_hash)
       end
@@ -64,6 +65,7 @@ module Spree
           :customer_id,
           :ip,
           :order_id,
+          :payment_id,
           :shipping,
           :tax,
           :subtotal,
@@ -82,12 +84,8 @@ module Spree
 
       private
 
-      def order
-        @payment.order
-      end
-
       def exchange_multiplier
-        @payment.payment_method.try(:exchange_multiplier) || 1.0
+        payment.payment_method.try(:exchange_multiplier) || 1.0
       end
     end
   end

data/app/models/spree/payment/processing.rb

@@ -1,7 +1,7 @@
 require_dependency 'spree/payment/gateway_options'
 
 module Spree
-  class Payment < Spree::Base
+  class Payment < Spree.base_class
     module Processing
       extend ActiveSupport::Concern
       included do

data/app/models/spree/payment/webhooks.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Payment < Spree::Base
+  class Payment < Spree.base_class
     module Webhooks
       extend ActiveSupport::Concern
 

data/app/models/spree/payment.rb

@@ -1,7 +1,7 @@
 require_dependency 'spree/payment/processing'
 
 module Spree
-  class Payment < Spree::Base
+  class Payment < Spree.base_class
     include Spree::Core::NumberGenerator.new(prefix: 'P', letters: true, length: 7)
     include Spree::NumberIdentifier
     include Spree::NumberAsParam
@@ -10,6 +10,8 @@ module Spree
       include Spree::Security::Payments
     end
 
+    extend Spree::DisplayMoney
+
     include Spree::Payment::Processing
     include Spree::Payment::Webhooks
 
@@ -35,20 +37,24 @@ module Spree
 
     before_validation :validate_source
 
-    after_save :create_payment_profile, if: :profiles_supported?
+    after_initialize :set_amount, if: -> { new_record? && order.present? && !amount_changed? }
 
+    #
+    # Callbacks
+    after_save :create_payment_profile, if: :profiles_supported?
     # update the order totals, etc.
-    set_callback :save, :after, :update_order, unless: -> { capture_on_dispatch }
-
+    after_save :update_order, unless: -> { capture_on_dispatch }
     # invalidate previously entered payments
     after_create :invalidate_old_payments
     after_create :create_eligible_credit_event
+    after_destroy :update_order
 
     attr_accessor :source_attributes, :request_env, :capture_on_dispatch
 
     after_initialize :build_source
 
     validates :amount, numericality: true
+    validate :amount_must_be_less_than_or_equal_to_max_amount, if: -> { new_record? || amount_changed? }
 
     delegate :store_credit?, to: :payment_method, allow_nil: true
     delegate :name,          to: :payment_method, allow_nil: true, prefix: true
@@ -77,12 +83,13 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[number amount state response_code avs_response cvv_response_code cvv_response_message]
 
     # transaction_id is much easier to understand
-    def transaction_id
-      response_code
-    end
+    alias_attribute :transaction_id, :response_code
 
     delegate :currency, to: :order
 
+    money_methods :amount, :credit_allowed
+    alias money display_amount # for compatibility with older versions of Spree
+
     # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine initial: :checkout do
       # With card payments, happens before purchase or authorization happens
@@ -131,10 +138,18 @@ module Spree
       payment_method.payment_source_class.unscoped { super }
     end
 
-    def money
-      Spree::Money.new(amount, currency: currency)
+    def max_amount
+      return amount if order.nil?
+
+      amount_from_order = order.total - order.payment_total
+
+      if payment_method&.store_credit?
+        store_credits = order.available_store_credits
+        store_credits.any? ? [store_credits.first.amount_remaining, amount_from_order].min : amount_from_order
+      else
+        amount_from_order
+      end
     end
-    alias display_amount money
 
     def amount=(amount)
       self[:amount] =
@@ -158,13 +173,28 @@ module Spree
       credit_allowed > 0
     end
 
+    # we shouldn't allow deleting payments via admin interface
+    def can_be_deleted?
+      false
+    end
+
     # see https://github.com/spree/spree/issues/981
     def build_source
       return unless new_record?
 
       if source_attributes.present? && source.blank? && payment_method.try(:payment_source_class)
-        self.source = payment_method.payment_source_class.new(source_attributes)
-        source.payment_method_id = payment_method.id
+        self.source = if source_attributes[:id].present? && source_attributes[:id] != :new
+                        payment_method.payment_source_class.find(source_attributes[:id])
+                      else
+                        payment_method.payment_source_class.new(source_attributes)
+                      end
+
+        if source.user_id.present? && source.user_id != order.user_id
+          self.source = nil
+          return
+        end
+
+        source.payment_method_id = payment_method.id if source.respond_to?(:payment_method_id)
         source.user_id = order.user_id if order
       end
     end
@@ -194,6 +224,10 @@ module Spree
       true
     end
 
+    def gateway_dashboard_payment_url
+      payment_method.try(:gateway_dashboard_payment_url, self)
+    end
+
     def captured_amount
       capture_events.sum(:amount)
     end
@@ -206,8 +240,23 @@ module Spree
       checkout? || pending?
     end
 
+    def display_source_name
+      return if source.blank?
+
+      source_class = source.class
+      source_class.respond_to?(:display_name) ? source_class.display_name : source_class.name.demodulize.split(/(?=[A-Z])/).join(' ')
+    end
+
     private
 
+    def set_amount
+      self.amount = order.total - order.payment_total
+    end
+
+    def amount_must_be_less_than_or_equal_to_max_amount
+      errors.add(:amount, :greater_than_max_amount, max_amount: max_amount) if amount > max_amount
+    end
+
     def after_void
       # Implement your logic here
     end

data/app/models/spree/payment_capture_event.rb

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

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

@@ -4,6 +4,14 @@ module Spree
       ::Spree::StoreCredit
     end
 
+    def method_type
+      'store_credit'
+    end
+
+    def description_partial_name
+      'store_credit'
+    end
+
     def can_capture?(payment)
       ['checkout', 'pending'].include?(payment.state)
     end
@@ -110,7 +118,7 @@ module Spree
             authorization: auth_code || response
           )
         else
-          ActiveMerchant::Billing::Response.new(false, store_credit.errors.full_messages.join, {}, {})
+          ActiveMerchant::Billing::Response.new(false, store_credit.errors.full_messages.to_sentence, {}, {})
         end
       end
     end

data/app/models/spree/payment_method.rb

@@ -1,22 +1,22 @@
 module Spree
-  class PaymentMethod < Spree::Base
+  class PaymentMethod < Spree.base_class
     acts_as_paranoid
     acts_as_list
 
     include Spree::MultiStoreResource
     include Spree::Metadata
+    include Spree::DisplayOn
     if defined?(Spree::Security::PaymentMethods)
       include Spree::Security::PaymentMethods
     end
 
-    DISPLAY = [:both, :front_end, :back_end].freeze
+    scope :active,    -> { where(active: true).order(position: :asc) }
+    scope :available, -> { active.where(display_on: [:front_end, :back_end, :both]) }
 
-    scope :active,                 -> { where(active: true).order(position: :asc) }
-    scope :available,              -> { active.where(display_on: [:front_end, :back_end, :both]) }
-    scope :available_on_front_end, -> { active.where(display_on: [:front_end, :both]) }
-    scope :available_on_back_end,  -> { active.where(display_on: [:back_end, :both]) }
+    after_initialize :set_name, if: :new_record?
 
     validates :name, presence: true
+    auto_strip_attributes :name
 
     has_many :store_payment_methods, class_name: 'Spree::StorePaymentMethod'
     has_many :stores, class_name: 'Spree::Store', through: :store_payment_methods
@@ -26,6 +26,8 @@ module Spree
       has_many :credit_cards, class_name: 'Spree::CreditCard'
     end
 
+    has_many :gateway_customers, class_name: 'Spree::GatewayCustomer'
+
     def self.providers
       Rails.application.config.spree.payment_methods
     end
@@ -47,6 +49,14 @@ module Spree
       type.demodulize.downcase
     end
 
+    def default_name
+      self.class.name.demodulize.titleize.gsub(/Gateway/, '').strip
+    end
+
+    def payment_icon_name
+      type.demodulize.gsub(/(^Spree::Gateway::|Gateway$)/, '').downcase.gsub(/\s+/, '').strip
+    end
+
     def self.find_with_destroyed(*args)
       unscoped { find(*args) }
     end
@@ -59,6 +69,10 @@ module Spree
       true
     end
 
+    def show_in_admin?
+      true
+    end
+
     # Custom gateways should redefine this method. See Gateway implementation
     # as an example
     def reusable_sources(_order)
@@ -83,8 +97,8 @@ module Spree
 
     # Custom PaymentMethod/Gateway can redefine this method to check method
     # availability for concrete order.
-    def available_for_order?(_order)
-      true
+    def available_for_order?(order)
+      !order.covered_by_store_credit?
     end
 
     def available_for_store?(store)
@@ -104,5 +118,9 @@ module Spree
     def public_preference_keys
       []
     end
+
+    def set_name
+      self.name ||= default_name
+    end
   end
 end

data/app/models/spree/payment_source.rb

@@ -1,9 +1,9 @@
 module Spree
-  class PaymentSource < Spree::Base
+  class PaymentSource < Spree.base_class
     include Spree::Metadata
 
     belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
-    belongs_to :user, class_name: 'Spree::User', optional: true
+    belongs_to :user, class_name: Spree.user_class.to_s, optional: true
 
     validates_uniqueness_of :gateway_payment_profile_id, scope: :type
   end

data/app/models/spree/post.rb

@@ -0,0 +1,108 @@
+module Spree
+  class Post < Spree.base_class
+    include Spree::SingleStoreResource
+    extend FriendlyId
+
+    friendly_id :slug_candidates, use: %i[slugged scoped history], scope: %i[store_id deleted?]
+    acts_as_paranoid
+    acts_as_taggable_on :tags
+    acts_as_taggable_tenant :store_id
+
+    if defined?(PgSearch)
+      include PgSearch::Model
+      pg_search_scope :search_by_title, against: :title
+    else
+      scope :search_by_title, ->(query) { where('title LIKE ?', "%#{query}%") }
+    end
+
+    #
+    # Ransack filtering
+    #
+    self.whitelisted_ransackable_attributes = %w[author_id post_category_id published_at]
+    self.whitelisted_ransackable_associations = %w[author post_category]
+    self.whitelisted_ransackable_scopes = %w[search_by_title]
+
+    #
+    # Attachments
+    #
+    has_one_attached :image, service: Spree.public_storage_service_name
+
+    #
+    # Rich Text
+    #
+    has_rich_text :content
+    has_rich_text :excerpt
+
+    #
+    # Associations
+    #
+    belongs_to :author, class_name: Spree.admin_user_class.to_s
+    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :post_category, class_name: 'Spree::PostCategory', optional: true
+    alias category post_category
+
+    #
+    # Validations
+    #
+    validates :title, :store, :author, presence: true
+    validates :slug, presence: true, uniqueness: { scope: :store_id, conditions: -> { where(deleted_at: nil) } }
+    validates :meta_title, length: { maximum: 160 }, allow_blank: true
+    validates :meta_description, length: { maximum: 320 }, allow_blank: true
+    validates :image, content_type: Rails.application.config.active_storage.web_image_content_types
+
+    #
+    # Scopes
+    #
+    scope :published, -> { where(published_at: [..Time.current]) }
+
+    delegate :name, to: :author, prefix: true, allow_nil: true
+    delegate :title, to: :post_category, prefix: true, allow_nil: true
+
+    def should_generate_new_friendly_id?
+      slug.blank? || (persisted? && title_changed?)
+    end
+
+    def slug_candidates
+      [
+        :title,
+        [:title, :id]
+      ]
+    end
+
+    def published?
+      published_at.present?
+    end
+
+    def page_builder_url
+      return unless Spree::Core::Engine.routes.url_helpers.respond_to?(:post_path)
+
+      Spree::Core::Engine.routes.url_helpers.post_path(self)
+    end
+
+    def publish(date = nil)
+      update(published_at: date || Time.current)
+    end
+
+    def unpublish
+      update(published_at: nil)
+    end
+
+    def description
+      excerpt.to_plain_text.presence || content.to_plain_text
+    end
+
+    def shortened_description
+      desc = excerpt.to_plain_text.presence || content.to_plain_text
+      desc.length > 320 ? "#{desc[0...320]}..." : desc
+    end
+
+    def self.to_tom_select_json
+      pluck(:id, :title).map do |id, title|
+        {
+          id: id,
+          name: title
+        }
+      end.as_json
+    end
+  end
+end

data/app/models/spree/post_category.rb

@@ -0,0 +1,33 @@
+module Spree
+  class PostCategory < Spree.base_class
+    include Spree::SingleStoreResource
+    extend FriendlyId
+
+    friendly_id :slug_candidates, use: %i[slugged scoped history], scope: %i[store_id]
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store'
+    has_many :posts, class_name: 'Spree::Post'
+
+    #
+    # Validations
+    #
+    validates :title, :store, presence: true
+    validates :slug, presence: true, uniqueness: { scope: :store_id }
+
+    has_rich_text :description
+
+    def should_generate_new_friendly_id?
+      slug.blank? || title_changed?
+    end
+
+    def slug_candidates
+      [
+        :title,
+        [:title, :id]
+      ]
+    end
+  end
+end

data/app/models/spree/preference.rb

@@ -1,4 +1,4 @@
-class Spree::Preference < Spree::Base
+class Spree::Preference < Spree.base_class
   if Rails::VERSION::STRING >= '7.1.0'
     serialize :value, coder: YAML
   else

data/app/models/spree/price.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Price < Spree::Base
+  class Price < Spree.base_class
     include Spree::VatPriceCalculation
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks
@@ -18,22 +18,25 @@ module Spree
     validates :amount, allow_nil: true, numericality: {
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
-    }, if: -> { Spree::RuntimeConfig.allow_empty_price_amount }
+    }, if: -> { Spree::Config.allow_empty_price_amount }
 
     # new behavior
     validates :amount, allow_nil: false, numericality: {
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
-    }, unless: -> { Spree::RuntimeConfig.allow_empty_price_amount }
+    }, unless: -> { Spree::Config.allow_empty_price_amount }
 
     validates :compare_at_amount, allow_nil: true, numericality: {
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
     }
 
+    validates :currency, presence: true
+
     scope :with_currency, ->(currency) { where(currency: currency) }
     scope :non_zero, -> { where.not(amount: [nil, 0]) }
     scope :discounted, -> { where('compare_at_amount > amount') }
+    scope :for_products, ->(products) { joins(variant: :product).where("#{Spree::Product.table_name}.id" => products) }
 
     extend DisplayMoney
     money_methods :amount, :price, :compare_at_amount
@@ -41,6 +44,10 @@ module Spree
 
     self.whitelisted_ransackable_attributes = ['amount', 'compare_at_amount']
 
+    attribute :eligible_for_taxon_matching, :boolean, default: false
+    before_validation -> { self.eligible_for_taxon_matching = new_record? ? discounted? : discounted? != was_discounted? }
+    after_commit -> { variant&.product&.auto_match_taxons }, if: -> { eligible_for_taxon_matching? }
+
     def money
       Spree::Money.new(amount || 0, currency: currency.upcase)
     end

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

@@ -1,5 +1,5 @@
 module Spree
-  class Product < Spree::Base
+  class Product < Spree.base_class
     module Webhooks
       def send_product_activated_webhook
         # Implement your logic here