spree_core 4.10.1 → 5.0.0.rc1

data/app/models/spree/order.rb

@@ -6,9 +6,10 @@ require_dependency 'spree/order/store_credit'
 require_dependency 'spree/order/emails'
 
 module Spree
-  class Order < Spree::Base
+  class Order < Spree.base_class
     PAYMENT_STATES = %w(balance_due credit_owed failed paid void)
     SHIPMENT_STATES = %w(backorder canceled partial pending ready shipped)
+    LINE_ITEM_REMOVABLE_STATES = %w(cart address delivery payment confirm resumed)
 
     include Spree::Order::Checkout
     include Spree::Order::CurrencyUpdater
@@ -19,13 +20,13 @@ module Spree
     include Spree::Order::Emails
     include Spree::Order::Webhooks
     include Spree::Core::NumberGenerator.new(prefix: 'R')
-    include Spree::Core::TokenGenerator
 
     include Spree::NumberIdentifier
     include Spree::NumberAsParam
     include Spree::SingleStoreResource
     include Spree::MemoizedData
     include Spree::Metadata
+    include Spree::MultiSearchable
     if defined?(Spree::Security::Orders)
       include Spree::Security::Orders
     end
@@ -33,13 +34,16 @@ module Spree
       include Spree::VendorConcern
     end
 
+    has_secure_token :token, length: 35
+
     MEMOIZED_METHODS = %w(tax_zone)
 
     extend Spree::DisplayMoney
     money_methods :outstanding_balance, :item_total,           :adjustment_total,
                   :included_tax_total,  :additional_tax_total, :tax_total,
                   :shipment_total,      :promo_total,          :total,
-                  :cart_promo_total,    :pre_tax_item_amount,  :pre_tax_total
+                  :cart_promo_total,    :pre_tax_item_amount,  :pre_tax_total,
+                  :payment_total
 
     alias display_ship_total display_shipment_total
     alias_attribute :ship_total, :shipment_total
@@ -75,28 +79,22 @@ module Spree
     self.whitelisted_ransackable_associations = %w[shipments user created_by approver canceler promotions bill_address ship_address line_items store]
     self.whitelisted_ransackable_attributes = %w[
       completed_at email number state payment_state shipment_state
-      total item_total considered_risky channel
+      total item_total item_count considered_risky channel
     ]
+    self.whitelisted_ransackable_scopes = %w[refunded partially_refunded multi_search]
 
     attr_reader :coupon_code
     attr_accessor :temporary_address, :temporary_credit_card
 
     attribute :state_machine_resumed, :boolean
 
-    if Spree.user_class
-      belongs_to :user, class_name: "::#{Spree.user_class}", optional: true
-    else
-      belongs_to :user, optional: true
-    end
-    if Spree.admin_user_class
-      belongs_to :created_by, class_name: "::#{Spree.admin_user_class}", optional: true
-      belongs_to :approver, class_name: "::#{Spree.admin_user_class}", optional: true
-      belongs_to :canceler, class_name: "::#{Spree.admin_user_class}", optional: true
-    else
-      belongs_to :created_by, optional: true
-      belongs_to :approver, optional: true
-      belongs_to :canceler, optional: true
-    end
+    acts_as_taggable_on :tags
+    acts_as_taggable_tenant :store_id
+
+    belongs_to :user, class_name: "::#{Spree.user_class}", optional: true, autosave: true
+    belongs_to :created_by, class_name: "::#{Spree.admin_user_class}", optional: true
+    belongs_to :approver, class_name: "::#{Spree.admin_user_class}", optional: true
+    belongs_to :canceler, class_name: "::#{Spree.admin_user_class}", optional: true
 
     belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address',
                               optional: true, dependent: :destroy
@@ -118,6 +116,7 @@ module Spree
       has_many :adjustments, -> { order(:created_at) }, as: :adjustable, class_name: 'Spree::Adjustment'
     end
     has_many :reimbursements, inverse_of: :order, class_name: 'Spree::Reimbursement'
+    has_many :customer_returns, class_name: 'Spree::CustomerReturn', through: :return_authorizations
     has_many :line_item_adjustments, through: :line_items, source: :adjustments
     has_many :inventory_units, inverse_of: :order, class_name: 'Spree::InventoryUnit'
     has_many :return_items, through: :inventory_units, class_name: 'Spree::ReturnItem'
@@ -151,9 +150,9 @@ module Spree
     before_validation :ensure_currency_presence
 
     before_validation :clone_billing_address, if: :use_billing?
-    attr_accessor :use_billing
+    before_validation :clone_shipping_address, if: :use_shipping?
+    attr_accessor :use_billing, :use_shipping
 
-    before_create :create_token
     before_create :link_by_email
     before_update :ensure_updated_shipments, :homogenize_line_item_currencies, if: :currency_changed?
 
@@ -187,13 +186,46 @@ module Spree
     scope :completed_between, ->(start_date, end_date) { where(completed_at: start_date..end_date) }
     scope :complete, -> { where.not(completed_at: nil) }
     scope :incomplete, -> { where(completed_at: nil) }
-    scope :not_canceled, -> { where.not(state: 'canceled') }
+    scope :canceled, -> { where(state: %w[canceled partially_canceled]) }
+    scope :not_canceled, -> { where.not(state: %w[canceled partially_canceled]) }
+    scope :ready_to_ship, -> { where(shipment_state: %w[ready pending]) }
+    scope :partially_shipped, -> { where(shipment_state: %w[partial]) }
+    scope :not_shipped, -> { where(shipment_state: %w[ready pending partial]) }
+    scope :shipped, -> { where(shipment_state: %w[shipped]) }
+    scope :refunded, lambda {
+      joins(:refunds).group(:id).having("sum(#{Spree::Refund.table_name}.amount) = #{Spree::Order.table_name}.total")
+    }
+    scope :partially_refunded, lambda {
+                                joins(:refunds).group(:id).having("sum(#{Spree::Refund.table_name}.amount) < #{Spree::Order.table_name}.total")
+                              }
     scope :with_deleted_bill_address, -> { joins(:bill_address).where.not(Address.table_name => { deleted_at: nil }) }
     scope :with_deleted_ship_address, -> { joins(:ship_address).where.not(Address.table_name => { deleted_at: nil }) }
 
     # shows completed orders first, by their completed_at date, then uncompleted orders by their created_at
     scope :reverse_chronological, -> { order(Arel.sql('spree_orders.completed_at IS NULL'), completed_at: :desc, created_at: :desc) }
 
+    def self.multi_search(query)
+      sanitized_query = sanitize_query_for_multi_search(query)
+      return none if query.blank?
+
+      query_pattern = "%#{sanitized_query}%"
+
+      conditions = []
+      conditions << arel_table[:number].lower.matches(query_pattern)
+
+      conditions << multi_search_condition(Spree::Address, :firstname, sanitized_query)
+      conditions << multi_search_condition(Spree::Address, :lastname, sanitized_query)
+
+      full_name = NameOfPerson::PersonName.full(sanitized_query)
+
+      if full_name.first.present? && full_name.last.present?
+        conditions << multi_search_condition(Spree::Address, :firstname, full_name.first)
+        conditions << multi_search_condition(Spree::Address, :lastname, full_name.last)
+      end
+
+      left_joins(:bill_address).where(email: sanitized_query).or(where(conditions.reduce(:or)))
+    end
+
     # Use this method in other gems that wish to register their own custom logic
     # that should be called after Order#update
     def self.register_update_hook(hook)
@@ -223,6 +255,19 @@ module Spree
       completed_at.present?
     end
 
+    def order_refunded?
+      (payment_state == 'void' && refunds.sum(:amount).positive?) || refunds.sum(:amount) == total
+    end
+
+    def partially_refunded?
+      return false if refunds.empty?
+
+      # we must deduct not returned amount, otherwise it can look like order has not been fully refunded
+      amount_not_refunded = additional_tax_total.abs + total_applied_store_credit
+
+      refunds.sum(:amount) < total - amount_not_refunded
+    end
+
     # Indicates whether or not the user is allowed to proceed to checkout.
     # Currently this is implemented as a check for whether or not there is at
     # least one LineItem in the Order.  Feel free to override this logic in your
@@ -231,9 +276,9 @@ module Spree
       line_items.exists?
     end
 
-    # Does this order require a physical delivery.
+    # Does this order require a delivery (physical or digital).
     def delivery_required?
-      !digital?
+      true # true for Spree, can be decorated
     end
 
     # Is this a free order in which case the payment step should be skipped
@@ -251,10 +296,18 @@ module Spree
         confirm?
     end
 
+    def email_required?
+      require_email
+    end
+
     def backordered?
       shipments.any?(&:backordered?)
     end
 
+    def quick_checkout?
+      shipping_address.present? && shipping_address.quick_checkout?
+    end
+
     # Returns the relevant zone (if any) to be used for taxation purposes.
     # Uses default tax zone unless there is a specific match
     def tax_zone
@@ -285,7 +338,7 @@ module Spree
     def allow_cancel?
       return false if !completed? || canceled?
 
-      shipment_state.nil? || %w{ready backorder pending}.include?(shipment_state)
+      shipment_state.nil? || %w{ready backorder pending canceled}.include?(shipment_state)
     end
 
     def all_inventory_units_returned?
@@ -296,15 +349,19 @@ module Spree
     def associate_user!(user, override_email = true)
       self.user           = user
       self.email          = user.email if override_email
-      self.created_by   ||= user
-      self.bill_address ||= user.bill_address.try(:clone)
-      self.ship_address ||= user.ship_address.try(:clone)
+      # we need to check if user is of admin user class to avoid mismatch type error
+      # in a scenario where we have separate classes for admin and regular users
+      self.created_by   ||= user if user.is_a?(Spree.admin_user_class)
+      self.bill_address ||= user.bill_address
+      self.ship_address ||= user.ship_address
 
       changes = slice(:user_id, :email, :created_by_id, :bill_address_id, :ship_address_id)
 
       # immediately persist the changes we just made, but don't use save
       # since we might have an invalid address associated
-      self.class.unscoped.where(id: self).update_all(changes)
+      ActiveRecord::Base.connected_to(role: :writing) do
+        self.class.unscoped.where(id: self).update_all(changes)
+      end
     end
 
     def quantity_of(variant, options = {})
@@ -359,6 +416,37 @@ module Spree
       end
     end
 
+    def full_name
+      @full_name ||= if user.present? && user.name.present?
+                       user.name.full
+                     else
+                       billing_address&.full_name || email
+                     end
+    end
+
+    # Returns the payment method for the order
+    #
+    # @return [Spree::PaymentMethod] the payment method for the order
+    def payment_method
+      payments.valid.not_store_credits.first&.payment_method
+    end
+
+    # Returns the payment source for the order
+    #
+    # @return [Spree::PaymentSource] the payment source for the order
+    def payment_source
+      payments.valid.not_store_credits.first&.source
+    end
+
+    # Returns the backordered variants for the order
+    #
+    # @return [Array<Spree::Variant>] the backordered variants for the order
+    def backordered_variants
+      variants.
+        joins(:stock_items, :product).
+        where(Spree::StockItem.table_name => { count_on_hand: ..0, backorderable: true })
+    end
+
     def can_ship?
       complete? || resumed? || awaiting_return? || returned?
     end
@@ -451,17 +539,16 @@ module Spree
     end
 
     def empty!
-      Spree::Deprecation.warn(<<-DEPRECATION, caller)
-        `Order#empty!` is deprecated and will be removed in Spree 5.0.
-        Please use `Spree::Cart::Empty.call(order: order)` instead.
-      DEPRECATION
-
       raise Spree.t(:cannot_empty_completed_order) if completed?
 
       result = Spree::Dependencies.cart_empty_service.constantize.call(order: self)
       result.value
     end
 
+    def use_all_coupon_codes
+      Spree::CouponCodes::CouponCodesHandler.new(order: self).use_all_codes
+    end
+
     def has_step?(step)
       checkout_steps.include?(step)
     end
@@ -488,10 +575,10 @@ module Spree
 
     def coupon_code=(code)
       @coupon_code = begin
-                       code.strip.downcase
-                     rescue StandardError
-                       nil
-                     end
+        code.strip.downcase
+      rescue StandardError
+        nil
+      end
     end
 
     def can_add_coupon?
@@ -530,6 +617,22 @@ module Spree
       @total_weight ||= line_items.joins(:variant).includes(:variant).map { |li| li.variant.weight * li.quantity }.sum
     end
 
+    # Returns line items that have no shipping rates
+    #
+    # @return [Array<Spree::LineItem>]
+    def line_items_without_shipping_rates
+      @line_items_without_shipping_rates ||= shipments.map do |shipment|
+        shipment.manifest.map(&:line_item) if shipment.shipping_rates.blank?
+      end.flatten.compact
+    end
+
+    # Checks if all line items cannot be shipped
+    #
+    # @returns Boolean
+    def all_line_items_invalid?
+      line_items_without_shipping_rates.size == line_items.count
+    end
+
     def apply_free_shipping_promotions
       Spree::PromotionHandler::FreeShipping.new(self).activate
       shipments.each { |shipment| Spree::Adjustable::AdjustmentsUpdater.update(shipment) }
@@ -578,17 +681,28 @@ module Spree
       persist_totals
     end
 
+    def shipping_method
+      # This query will select the first available shipping method from the shipments.
+      # It will use subquery to first select the shipping method id from the shipments' selected_shipping_rate.
+      Spree::ShippingMethod.
+        where(id: shipments.with_selected_shipping_method.limit(1).pluck(:shipping_method_id)).
+        limit(1).
+        first
+    end
+
     def is_risky?
       !payments.risky.empty?
     end
 
-    def canceled_by(user)
+    def canceled_by(user, canceled_at = nil)
+      canceled_at ||= Time.current
+
       transaction do
-        cancel!
         update_columns(
           canceler_id: user.id,
-          canceled_at: Time.current
+          canceled_at: canceled_at
         )
+        cancel!
       end
     end
 
@@ -640,7 +754,7 @@ module Spree
     end
 
     def collect_backend_payment_methods
-      PaymentMethod.available_on_back_end.select { |pm| pm.available_for_order?(self) }
+      PaymentMethod.active.available_on_back_end.select { |pm| pm.available_for_order?(self) }
     end
 
     # determines whether the inventory is fully discounted
@@ -654,7 +768,7 @@ module Spree
     alias fully_discounted fully_discounted?
 
     def promo_code
-      promotions.pluck(:code).compact.first
+      Spree::CouponCode.find_by(order: self, promotion: promotions).try(:code) || promotions.pluck(:code).compact.first
     end
 
     def validate_payments_attributes(attributes)
@@ -700,6 +814,14 @@ module Spree
               spree_promotion_actions: { type: 'Spree::Promotion::Actions::FreeShipping' }).exists?
     end
 
+    def to_csv(_store = nil)
+      csv_lines = []
+      all_line_items.each_with_index do |line_item, index|
+        csv_lines << Spree::CSV::OrderLineItemPresenter.new(self, line_item, index).call
+      end
+      csv_lines
+    end
+
     private
 
     def link_by_email
@@ -707,8 +829,9 @@ module Spree
     end
 
     # Determine if email is required (we don't want validation errors before we hit the checkout)
+    # we need to add delivery to the list for quick checkouts
     def require_email
-      true unless new_record? || ['cart', 'address'].include?(state)
+      true unless new_record? || ['cart', 'address', 'delivery'].include?(state)
     end
 
     def ensure_line_items_present
@@ -718,11 +841,18 @@ module Spree
     end
 
     def ensure_available_shipping_rates
-      if shipments.empty? || shipments.any? { |shipment| shipment.shipping_rates.blank? }
+      if shipments.empty? || line_items_without_shipping_rates.present?
         # After this point, order redirects back to 'address' state and asks user to pick a proper address
         # Therefore, shipments are not necessary at this point.
         shipments.destroy_all
-        errors.add(:base, Spree.t(:items_cannot_be_shipped)) && (return false)
+
+        if line_items_without_shipping_rates.present?
+          errors.add(:base, Spree.t(:products_cannot_be_shipped, product_names: line_items_without_shipping_rates.map(&:name).to_sentence))
+        else
+          errors.add(:base, Spree.t(:items_cannot_be_shipped))
+        end
+
+        return false
       end
     end
 
@@ -748,12 +878,12 @@ module Spree
       use_billing.in?([true, 'true', '1'])
     end
 
-    def ensure_currency_presence
-      self.currency ||= store.default_currency
+    def use_shipping?
+      use_shipping.in?([true, 'true', '1'])
     end
 
-    def create_token
-      self.token ||= generate_token
+    def ensure_currency_presence
+      self.currency ||= store.default_currency
     end
 
     def collect_payment_methods(store = nil)

data/app/models/spree/order_promotion.rb

@@ -1,5 +1,5 @@
 module Spree
-  class OrderPromotion < Spree::Base
+  class OrderPromotion < Spree.base_class
     belongs_to :order, class_name: 'Spree::Order'
     belongs_to :promotion, class_name: 'Spree::Promotion'
 

data/app/models/spree/order_updater.rb

@@ -133,10 +133,16 @@ module Spree
         order.shipment_state = 'backorder'
       else
         # get all the shipment states for this order
-        shipment_states = shipments.states
+        shipment_states = shipments.states.uniq
+
         order.shipment_state = if shipment_states.size > 1
-                                 # multiple shipment states means it's most likely partially shipped
-                                 'partial'
+                                 if shipment_states.include?('shipped')
+                                   'partial'
+                                 elsif shipment_states.include?('pending')
+                                   'pending'
+                                 else
+                                   'ready'
+                                 end
                                else
                                  # will return nil if no shipments are found
                                  shipment_states.first

data/app/models/spree/page.rb

@@ -0,0 +1,184 @@
+module Spree
+  class Page < Spree.base_class
+    include Spree::Previewable
+
+    #
+    # Magic methods
+    #
+    extend FriendlyId
+    friendly_id :slug_candidates, use: [:slugged, :scoped, :history], scope: :pageable
+    acts_as_paranoid
+
+    #
+    # Associations
+    #
+    belongs_to :pageable, polymorphic: true # this can be either Store or Theme
+    has_many :sections, -> { order(position: :asc) }, class_name: 'Spree::PageSection', dependent: :destroy_async, as: :pageable
+    has_many :page_links, as: :linkable, class_name: 'Spree::PageLink', dependent: :destroy
+    alias page_sections sections
+
+    #
+    # Validations
+    #
+    validates :name, presence: true
+    validates :pageable, presence: true
+    validates :slug, uniqueness: { scope: :pageable, conditions: -> { where(deleted_at: nil).where.not(slug: nil) } }
+
+    #
+    # Callbacks
+    #
+    before_validation :set_name
+    after_create :create_default_sections, unless: :duplicating
+
+    #
+    # Scopes
+    #
+    scope :linkable, lambda {
+                        where(type: [
+                                'Spree::Pages::Homepage',
+                                'Spree::Pages::ShopAll',
+                                'Spree::Pages::PostList',
+                                'Spree::Pages::Custom',
+                                'Spree::Pages::Account',
+                                'Spree::Pages::Login'
+                              ])
+                     }
+    scope :product_details, -> { where(type: 'Spree::Pages::ProductDetails') }
+    scope :standard, -> { where.not(type: 'Spree::Pages::Custom') }
+    scope :custom, -> { where(type: 'Spree::Pages::Custom') }
+
+    #
+    # Virtual attributes
+    #
+    attribute :duplicating, :boolean, default: false
+
+    def icon_name
+      'file-earmark-richtext'
+    end
+
+    def store
+      if pageable.is_a?(Spree::Store)
+        pageable
+      else
+        pageable.store
+      end
+    end
+
+    def create_preview
+      return self if preview? # no need to create a preview for the preview
+
+      ActiveRecord::Base.connected_to(role: :writing) do
+        ApplicationRecord.transaction do
+          new_preview = dup
+          new_preview.parent = self
+          new_preview.duplicating = true
+          new_preview.save!
+
+          sections.includes(:links, { asset_attachment: :blob }, { blocks: [:rich_text_text, :links] }).each do |section|
+            section.deep_clone(new_preview)
+          end
+
+          new_preview
+        end
+      end
+    end
+
+    # Promotes the page preview to the main page
+    def promote
+      return unless preview?
+
+      ApplicationRecord.transaction do
+        old_page = parent
+        old_page.page_links.update_all(linkable_id: id)
+        update(parent: nil) # clear reference to the old page
+        Spree::Page.find(old_page.id).destroy # destroy the old page with their other previews, etc.
+      end
+    end
+
+    def default_sections
+      []
+    end
+
+    def customizable?
+      false
+    end
+
+    def layout_sections?
+      true
+    end
+
+    def preview_url(theme_preview = nil, page_preview = nil)
+      return if page_builder_url.blank?
+
+      "#{page_builder_url}?#{url_query_params(theme_preview, page_preview).to_query}"
+    end
+
+    def display_name
+      if custom?
+        name
+      else
+        name.titleize
+      end
+    end
+
+    def custom?
+      type == 'Spree::Pages::Custom'
+    end
+
+    def duplicate(target_pageable)
+      duplicated_page = dup
+      duplicated_page.duplicating = true
+      duplicated_page.pageable = target_pageable
+      duplicated_page.save!
+
+      sections_scope = sections.includes(:links, :blocks, { asset_attachment: :blob },
+                                         { blocks: [:rich_text_text, :links, { asset_attachment: :blob }] })
+      sections_scope.each { |section| section.deep_clone(duplicated_page) }
+
+      duplicated_page
+    end
+
+    def theme
+      @theme ||= if pageable.is_a?(Spree::Theme)
+                   pageable
+                 else
+                   pageable.default_theme
+                 end
+    end
+
+    private
+
+    def create_default_sections
+      default_sections.each do |section|
+        section.pageable = self
+        section.save!
+      end
+    end
+
+    def url_query_params(theme_preview, page_preview)
+      theme_preview_cache = theme_preview.updated_at.to_i.to_s + rand(999_999).to_s if theme_preview
+
+      {
+        theme_id: theme.id,
+        page_preview_id: page_preview&.id,
+        theme_preview_id: theme_preview&.id,
+        theme_preview_cache: theme_preview_cache
+      }
+    end
+
+    def set_name
+      return if custom?
+      return if name.present?
+
+      self.name = self.class.name.demodulize
+    end
+
+    def should_generate_new_friendly_id?
+      name_changed? && custom?
+    end
+
+    def page_builder_url_exists?(path)
+      Spree::Core::Engine.routes.url_helpers.respond_to?(path)
+    end
+  end
+end