spree_core 4.0.0 → 4.6.0

data/app/models/spree/data_feed.rb

@@ -0,0 +1,40 @@
+module Spree
+  class DataFeed < Base
+    belongs_to :store, class_name: 'Spree::Store', foreign_key: 'store_id'
+
+    scope :for_store, ->(store) { where(store: store) }
+
+    before_validation :generate_slug
+
+    with_options presence: true do
+      validates :store
+      validates :name, uniqueness: true
+      validates :slug, uniqueness: { scope: :store_id }
+    end
+
+    def formatted_url
+      "#{store.formatted_url}/api/v2/data_feeds/#{self.class.provider_name}/#{slug}.rss"
+    end
+
+    private
+
+    def generate_slug
+      new_slug = slug.blank? ? SecureRandom.uuid : slug.parameterize
+      write_attribute(:slug, new_slug)
+    end
+
+    class << self
+      def label
+        raise NotImplementedError
+      end
+
+      def provider_name
+        raise NotImplementedError
+      end
+
+      def available_types
+        Rails.application.config.spree.data_feed_types
+      end
+    end
+  end
+end

data/app/models/spree/digital.rb

@@ -0,0 +1,19 @@
+module Spree
+  class Digital < Spree::Base
+    belongs_to :variant
+    has_many :digital_links, dependent: :destroy
+
+    if defined?(Spree::Webhooks)
+      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
+
+    validates :attachment, attached: true
+    validates :variant, presence: true
+  end
+end

data/app/models/spree/digital_link.rb

@@ -0,0 +1,57 @@
+module Spree
+  class DigitalLink < Spree::Base
+    has_secure_token
+
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+    if defined?(Spree::Security::DigitalLinks)
+      include Spree::Security::DigitalLinks
+    end
+
+    belongs_to :digital
+    belongs_to :line_item
+
+    before_validation :set_defaults, on: :create
+    validates :digital, :line_item, presence: true
+    validates :access_counter, numericality: { greater_than_or_equal_to: 0 }
+
+    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
+      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
+      else
+        false
+      end
+    end
+
+    # 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
+    end
+
+    def reset!
+      self.access_counter = 0
+      self.created_at = Time.current
+      save!
+    end
+
+    private
+
+    def set_defaults
+      self.access_counter ||= 0
+    end
+  end
+end

data/app/models/spree/fulfilment_changer.rb

@@ -36,7 +36,7 @@ module Spree
     private
 
     attr_reader :variant, :quantity, :current_stock_location, :desired_stock_location,
-      :current_shipment, :desired_shipment, :available_quantity
+                :current_shipment, :desired_shipment, :available_quantity
 
     def handle_stock
       ActiveRecord::Base.transaction do
@@ -45,13 +45,64 @@ module Spree
           desired_stock_location.unstock(variant, unstock_quantity, desired_shipment)
         end
 
-        update_current_shipment_inventory_units(new_on_hand_quantity, :on_hand)
-        update_current_shipment_inventory_units(quantity - new_on_hand_quantity, :backordered)
+        move_inventory_units_between_shipments
+      end
+    end
+
+    def move_inventory_units_between_shipments
+      update_desired_shipment_inventory_units
+      update_current_shipment_inventory_units
+    end
+
+    def current_shipment_units
+      @current_shipment_units ||= current_shipment.inventory_units.on_hand_or_backordered.where(variant_id: variant.id)
+    end
+
+    def update_desired_shipment_inventory_units
+      on_hand_unit = get_desired_shipment_inventory_unit(:on_hand)
+      on_hand_unit.update(quantity: on_hand_unit.quantity + new_on_hand_quantity)
+
+      new_backorder_quantity = current_on_hand_quantity - new_on_hand_quantity
+      if new_backorder_quantity > 0
+        backordered_unit = get_desired_shipment_inventory_unit(:backordered)
+        backordered_unit.update(quantity: backordered_unit.quantity + new_backorder_quantity)
+      end
+    end
+
+    def update_current_shipment_inventory_units
+      reduced_quantity = current_on_hand_quantity
+
+      # Reduce quantities from all backordered units first in case there is more than one.
+      backorder_units = current_shipment_units.backordered
+      reduced_quantity = reduce_units_quantities(reduced_quantity, backorder_units) if backorder_units.any?
+
+      # Reduce quantities from all on_hand units in case there is more than one.
+      if reduced_quantity > 0
+        on_hand_units = current_shipment_units.on_hand
+        reduce_units_quantities(reduced_quantity, on_hand_units) if on_hand_units.any?
+      end
+    end
+
+    def reduce_units_quantities(reduced_quantity, units)
+      units.each do |unit|
+        unit.quantity > reduced_quantity ? unit.update(quantity: unit.quantity - reduced_quantity) : unit.destroy!
+        reduced_quantity -= unit.quantity
+      end
+      reduced_quantity
+    end
+
+    def get_desired_shipment_inventory_unit(state)
+      desired_shipment.inventory_units.find_or_create_by(state: state, variant: variant) do |unit|
+        current_shipment_unit = current_shipment_units.first
+        unit.variant_id = current_shipment_unit.variant_id
+        unit.order_id = current_shipment_unit.order_id
+        unit.line_item_id = current_shipment_unit.line_item_id
+        unit.quantity = 0
       end
     end
 
     def after_process_shipments
-      if current_shipment.inventory_units.length.zero?
+      if current_shipment.inventory_units.sum(:quantity).zero?
         current_shipment.destroy!
       else
         current_shipment.refresh_rates
@@ -64,7 +115,7 @@ module Spree
     end
 
     def new_on_hand_quantity
-      [available_quantity, quantity].min
+      [available_quantity, current_on_hand_quantity].min
     end
 
     def unstock_quantity
@@ -72,16 +123,7 @@ module Spree
     end
 
     def current_on_hand_quantity
-      [current_shipment.inventory_units.on_hand_or_backordered.size, quantity].min
-    end
-
-    def update_current_shipment_inventory_units(quantity, state)
-      current_shipment.
-        inventory_units.
-        where(variant: variant).
-        order(state: :asc).
-        limit(quantity).
-        update_all(shipment_id: desired_shipment.id, state: state)
+      [current_shipment.inventory_units.on_hand_or_backordered.sum(:quantity), quantity].min
     end
 
     def reload_shipment_inventory_units
@@ -105,7 +147,7 @@ module Spree
     def enough_stock_at_desired_location
       return if Spree::Stock::Quantifier.new(variant, desired_stock_location).can_supply?(quantity)
 
-      errors.add(:desired_shipment, :not_enough_stock_at_desired_location)
+      errors.add(:desired_shipment, :has_not_enough_stock_at_desired_location)
     end
 
     def desired_shipment_different_from_current

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

@@ -9,14 +9,12 @@ module Spree
 
     attr_accessor :test
 
+    preference :dummy_key, :string, default: 'PUBLICKEY123'
+
     def provider_class
       self.class
     end
 
-    def preferences
-      {}
-    end
-
     def create_profile(payment)
       return if payment.source.has_payment_profile?
 
@@ -60,7 +58,7 @@ module Spree
       ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
-    def cancel(_response_code)
+    def cancel(_response_code, _payment = nil)
       ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
@@ -73,6 +71,10 @@ module Spree
       true
     end
 
+    def payment_source_class
+      CreditCard
+    end
+
     def actions
       %w(capture void credit)
     end
@@ -88,5 +90,9 @@ module Spree
       end
       random
     end
+
+    def public_preference_keys
+      [:dummy_key]
+    end
   end
 end

data/app/models/spree/icon.rb

@@ -0,0 +1,13 @@
+module Spree
+  class Icon < Spree::Asset
+    if Spree.public_storage_service_name
+      has_one_attached :attachment, service: Spree.public_storage_service_name
+    else
+      has_one_attached :attachment
+    end
+
+    ICON_TYPES = %i[png jpg jpeg gif svg]
+
+    validates :attachment, attached: true, content_type: ICON_TYPES
+  end
+end

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

@@ -5,39 +5,36 @@ module Spree
         extend ActiveSupport::Concern
 
         included do
-          validate :check_attachment_presence
-          validate :check_attachment_content_type
+          if Spree.public_storage_service_name
+            has_one_attached :attachment, service: Spree.public_storage_service_name
+          else
+            has_one_attached :attachment
+          end
+
+          validates :attachment, attached: true, content_type: /\Aimage\/.*\z/
 
-          has_one_attached :attachment
+          default_scope { includes(attachment_attachment: :blob) }
 
           def self.styles
             @styles ||= {
               mini: '48x48>',
               small: '100x100>',
               product: '240x240>',
-              large: '600x600>'
+              pdp_thumbnail: '160x200>',
+              plp_and_carousel: '448x600>',
+              plp_and_carousel_xs: '254x340>',
+              plp_and_carousel_sm: '350x468>',
+              plp_and_carousel_md: '222x297>',
+              plp_and_carousel_lg: '278x371>',
+              large: '600x600>',
+              plp: '278x371>',
+              zoomed: '650x870>'
             }
           end
 
           def default_style
             :product
           end
-
-          def accepted_image_types
-            %w(image/jpeg image/jpg image/png image/gif)
-          end
-
-          def check_attachment_presence
-            unless attachment.attached?
-              errors.add(:attachment, :attachment_must_be_present)
-            end
-          end
-
-          def check_attachment_content_type
-            if attachment.attached? && !attachment.content_type.in?(accepted_image_types)
-              errors.add(:attachment, :not_allowed_content_type)
-            end
-          end
         end
       end
     end

data/app/models/spree/image.rb

@@ -2,7 +2,8 @@ module Spree
   class Image < Asset
     include Configuration::ActiveStorage
     include Rails.application.routes.url_helpers
-  
+    include ::Spree::ImageMethods
+
     # In Rails 5.x class constants are being undefined/redefined during the code reloading process
     # in a rails development environment, after which the actual ruby objects stored in those class constants
     # are no longer equal (subclass == self) what causes error ActiveRecord::SubclassNotFound
@@ -12,14 +13,43 @@ module Spree
 
     def styles
       self.class.styles.map do |_, size|
-        width, height = size[/(\d+)x(\d+)/].split('x')
+        width, height = size.chop.split('x').map(&:to_i)
 
         {
-          url: polymorphic_path(attachment.variant(resize: size), only_path: true),
+          url: generate_url(size: size),
+          size: size,
           width: width,
           height: height
         }
       end
     end
+
+    def style(name)
+      size = self.class.styles[name]
+      return unless size
+
+      width, height = size.chop.split('x').map(&:to_i)
+
+      {
+        url: generate_url(size: size),
+        size: size,
+        width: width,
+        height: height
+      }
+    end
+
+    def style_dimensions(name)
+      size = self.class.styles[name]
+      width, height = size.chop.split('x').map(&:to_i)
+
+      {
+        width: width,
+        height: height
+      }
+    end
+
+    def plp_url
+      generate_url(size: self.class.styles[:plp_and_carousel])
+    end
   end
 end

data/app/models/spree/inventory_unit.rb

@@ -1,14 +1,18 @@
 module Spree
   class InventoryUnit < Spree::Base
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
     with_options inverse_of: :inventory_units do
-      belongs_to :variant, class_name: 'Spree::Variant'
+      belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant'
       belongs_to :order, class_name: 'Spree::Order'
       belongs_to :shipment, class_name: 'Spree::Shipment', touch: true, optional: true
-      belongs_to :return_authorization, class_name: 'Spree::ReturnAuthorization'
+      has_many :return_items, class_name: 'Spree::ReturnItem', inverse_of: :inventory_unit
+      has_many :return_authorizations, class_name: 'Spree::ReturnAuthorization', through: :return_items
       belongs_to :line_item, class_name: 'Spree::LineItem'
     end
 
-    has_many :return_items, inverse_of: :inventory_unit
     belongs_to :original_return_item, class_name: 'Spree::ReturnItem'
 
     scope :backordered, -> { where state: 'backordered' }
@@ -59,8 +63,7 @@ module Spree
     end
 
     def find_stock_item
-      Spree::StockItem.where(stock_location_id: shipment.stock_location_id,
-                             variant_id: variant_id).first
+      shipment.stock_location.stock_item_or_create(variant)
     end
 
     def self.split(original_inventory_unit, extract_quantity)
@@ -84,11 +87,6 @@ module Spree
       split_inventory!(1)
     end
 
-    # Remove variant default_scope `deleted_at: nil`
-    def variant
-      Spree::Variant.unscoped { super }
-    end
-
     def current_or_new_return_item
       Spree::ReturnItem.from_inventory_unit(self)
     end

data/app/models/spree/legacy_user.rb

@@ -4,10 +4,10 @@ module Spree
     include UserAddress
     include UserPaymentSource
     include UserMethods
+    include Spree::Metadata
 
     self.table_name = 'spree_users'
 
-    attr_accessor :password
-    attr_accessor :password_confirmation
+    attr_accessor :password, :password_confirmation
   end
 end

data/app/models/spree/line_item.rb

@@ -1,26 +1,39 @@
 module Spree
   class LineItem < Spree::Base
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
     before_validation :ensure_valid_quantity
 
     with_options inverse_of: :line_items do
       belongs_to :order, class_name: 'Spree::Order', touch: true
-      belongs_to :variant, class_name: 'Spree::Variant'
+      belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant'
     end
-    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
+    belongs_to :tax_category, -> { with_deleted }, class_name: 'Spree::TaxCategory'
 
     has_one :product, through: :variant
 
     has_many :adjustments, as: :adjustable, dependent: :destroy
     has_many :inventory_units, inverse_of: :line_item
+    has_many :digital_links, dependent: :destroy
 
     before_validation :copy_price
     before_validation :copy_tax_category
 
     validates :variant, :order, presence: true
-    validates :quantity, numericality: { only_integer: true, message: Spree.t('validation.must_be_int') }
+
+    # numericality: :less_than_or_equal_to validation is due to the restriction at the database level
+    #   https://github.com/spree/spree/issues/2695#issuecomment-143314161
+    validates :quantity, numericality: {
+      less_than_or_equal_to: DatabaseTypeUtilities.maximum_value_for(:integer),
+      only_integer: true, message: Spree.t('validation.must_be_int')
+    }
+
     validates :price, numericality: true
 
-    validates_with Spree::Stock::AvailabilityValidator
+    validates_with Spree::Stock::AvailabilityValidator, if: -> { variant.present? }
     validate :ensure_proper_currency, if: -> { order.present? }
 
     before_destroy :verify_order_inventory_before_destroy, if: -> { order.has_checkout_step?('delivery') }
@@ -32,14 +45,19 @@ module Spree
 
     after_create :update_tax_charge
 
-    delegate :name, :description, :sku, :should_track_inventory?, :product, :options_text, :slug, to: :variant
+    delegate :name, :description, :sku, :should_track_inventory?, :product, :options_text, :slug, :product_id, to: :variant
     delegate :brand, :category, to: :product
     delegate :tax_zone, to: :order
+    delegate :digital?, to: :variant
 
     attr_accessor :target_shipment
 
-    self.whitelisted_ransackable_associations = ['variant']
-    self.whitelisted_ransackable_attributes = ['variant_id']
+    self.whitelisted_ransackable_associations = %w[variant order tax_category]
+    self.whitelisted_ransackable_attributes = %w[variant_id order_id tax_category_id quantity
+                                                 price cost_price cost_currency adjustment_total
+                                                 additional_tax_total promo_total included_tax_total
+                                                 pre_tax_amount taxable_adjustment_total
+                                                 non_taxable_adjustment_total]
 
     def copy_price
       if variant
@@ -50,7 +68,13 @@ module Spree
     end
 
     def update_price
-      self.price = variant.price_including_vat_for(tax_zone: tax_zone)
+      currency_price = variant.price_in(order.currency)
+
+      self.price = if currency_price.amount.present?
+                     currency_price.price_including_vat_for(tax_zone: tax_zone)
+                   else
+                     0
+                   end
     end
 
     def copy_tax_category
@@ -59,7 +83,8 @@ module Spree
 
     extend DisplayMoney
     money_methods :amount, :subtotal, :discounted_amount, :final_amount, :total, :price,
-                  :adjustment_total, :additional_tax_total, :promo_total, :included_tax_total
+                  :adjustment_total, :additional_tax_total, :promo_total, :included_tax_total,
+                  :pre_tax_amount
 
     alias single_money display_price
     alias single_display_amount display_price
@@ -103,11 +128,6 @@ module Spree
       assign_attributes opts
     end
 
-    # Remove variant default_scope `deleted_at: nil`
-    def variant
-      Spree::Variant.unscoped { super }
-    end
-
     private
 
     def ensure_valid_quantity

data/app/models/spree/linkable/homepage.rb

@@ -0,0 +1,3 @@
+module Spree::Linkable::Homepage
+  # Placeholder for polymorphic lookup.
+end

data/app/models/spree/linkable/uri.rb

@@ -0,0 +1,3 @@
+module Spree::Linkable::Uri
+  # Placeholder for polymorphic lookup.
+end

data/app/models/spree/log_entry.rb

@@ -1,5 +1,9 @@
 module Spree
   class LogEntry < Spree::Base
+    if defined?(Spree::Security::LogEntries)
+      include Spree::Security::LogEntries
+    end
+
     belongs_to :source, polymorphic: true
 
     # Fix for #1767
@@ -11,7 +15,11 @@ module Spree
     end
 
     def parsed_details
-      @details ||= YAML.load(details)
+      @details ||= if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.1.0')
+                     YAML.safe_load(details, permitted_classes: [ActiveMerchant::Billing::Response])
+                   else
+                     YAML.safe_load(details, [ActiveMerchant::Billing::Response])
+                   end
     end
   end
 end

data/app/models/spree/menu.rb

@@ -0,0 +1,66 @@
+module Spree
+  class Menu < Spree::Base
+    include SingleStoreResource
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
+    MENU_LOCATIONS = ['Header', 'Footer']
+    MENU_LOCATIONS_PARAMETERIZED = []
+
+    MENU_LOCATIONS.each do |location|
+      parameterize_location = location.parameterize(separator: '_')
+      MENU_LOCATIONS_PARAMETERIZED << parameterize_location
+    end
+
+    has_many :menu_items, dependent: :destroy, class_name: 'Spree::MenuItem'
+    belongs_to :store, touch: true, class_name: 'Spree::Store'
+
+    before_validation :parameterize_location
+    after_create :set_root
+    after_save :update_root_name
+    after_touch :touch_store
+
+    validates :name, :store, :locale, presence: true
+    validates :location, uniqueness: { scope: [:store, :locale] }
+    validates :location, inclusion: { in: MENU_LOCATIONS_PARAMETERIZED }
+
+    has_one :root, -> { where(parent_id: nil) }, class_name: 'Spree::MenuItem', dependent: :destroy
+
+    default_scope { order(created_at: :asc) }
+
+    scope :by_locale, ->(locale) { where(locale: locale) }
+
+    self.whitelisted_ransackable_attributes = %w[name location locale store_id]
+
+    MENU_LOCATIONS_PARAMETERIZED.each do |location_name|
+      define_singleton_method("for_#{location_name}") do |locale|
+        menu = find_by(location: location_name, locale: locale.to_s)
+
+        menu.root if menu.present?
+      end
+    end
+
+    private
+
+    def parameterize_location
+      return unless location.present?
+
+      self.location = location.parameterize(separator: '_')
+    end
+
+    def set_root
+      self.root ||= menu_items.create!(name: name, item_type: 'Container')
+    end
+
+    def update_root_name
+      return unless saved_change_to_name?
+
+      root.update(name: name)
+    end
+
+    def touch_store
+      store.touch
+    end
+  end
+end