spree_core 4.10.1 → 5.0.0.rc1

data/app/models/spree/promotion_handler/coupon.rb

@@ -31,6 +31,13 @@ module Spree
           # Order promotion has to be destroyed before line item removing
           order.order_promotions.where(promotion_id: promotion.id).destroy_all
 
+          if promotion.multi_codes?
+            coupon_code = promotion.coupon_codes.find_by(order: order)
+            coupon_code&.remove_from_order
+          else
+            promotion.touch
+          end
+
           remove_promotion_adjustments(promotion)
           remove_promotion_line_items(promotion)
           order.update_with_updater!
@@ -47,17 +54,33 @@ module Spree
         @success = Spree.t(code)
       end
 
-      def set_error_code(code)
+      def set_error_code(code, locale_options = {})
         @status_code = code
-        @error = Spree.t(code)
+        @error = Spree.t(code, locale_options)
       end
 
+      # Returns the promotion for the order
+      #
+      # @return [Spree::Promotion]
       def promotion
         @promotion ||= store.promotions.active.includes(
           :promotion_rules, :promotion_actions
         ).with_coupon_code(order.coupon_code)
       end
 
+      # Returns the amount of adjustments for the promotion
+      #
+      # @return [Numeric]
+      def adjustments_amount
+        @adjustments_amount ||=
+          @order.all_adjustments.promotion.eligible.
+          where(source: promotion&.actions).
+          sum(:amount)
+      end
+
+      # Returns true if the code was applied successfully
+      #
+      # @return [Boolean]
       def successful?
         success.present? && error.blank?
       end
@@ -82,10 +105,11 @@ module Spree
       end
 
       def handle_present_promotion
-        return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?(order)
         return promotion_applied if promotion_exists_on_order?
+        return set_error_code :coupon_code_used if promotion.coupon_codes.used.where(code: order.coupon_code).exists?
+        return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?(order)
 
-        unless promotion.eligible?(order)
+        unless promotion.eligible?(order, options)
           self.error = promotion.eligibility_errors.full_messages.first unless promotion.eligibility_errors.blank?
           return (error || ineligible_for_this_order)
         end
@@ -116,9 +140,12 @@ module Spree
       end
 
       def determine_promotion_application_result
+        coupon_code = order.coupon_code.downcase
+
         # Check for applied adjustments.
         discount = order.all_adjustments.promotion.eligible.detect do |p|
-          p.source.promotion.code.try(:downcase) == order.coupon_code.downcase
+          p.source.promotion.code.try(:downcase) == coupon_code ||
+            p.source.promotion.coupon_codes.unused.where(code: coupon_code).exists?
         end
 
         # Check for applied line items.
@@ -129,18 +156,29 @@ module Spree
         end
 
         if discount || created_line_items
+          handle_coupon_code(discount, coupon_code) if discount
+
           order.update_totals
           order.persist_totals
           set_success_code :coupon_code_applied
         elsif order.promotions.with_coupon_code(order.coupon_code)
-          # if the promotion exists on an order, but wasn't found above,
-          # we've already selected a better promotion
-          set_error_code :coupon_code_better_exists
+          # since CouponCode is disposable...
+          if Spree::CouponCode.used?(order.coupon_code)
+            set_error_code :coupon_code_max_usage
+          else
+            # if the promotion exists on an order, but wasn't found above,
+            # we've already selected a better promotion
+            set_error_code :coupon_code_better_exists
+          end
         else
           # if the promotion was created after the order
           set_error_code :coupon_code_not_found
         end
       end
+
+      def handle_coupon_code(discount, coupon_code)
+        discount.source.promotion.coupon_codes.unused.find_by(code: coupon_code)&.apply_order!(order)
+      end
     end
   end
 end

data/app/models/spree/promotion_handler/free_shipping.rb

@@ -13,7 +13,7 @@ module Spree
 
       def activate
         promotions.each do |promotion|
-          next if promotion.code.present? && !order_promo_ids.include?(promotion.id)
+          next if promotion.coupon_code? && !order_promo_ids.include?(promotion.id)
 
           promotion.activate(order: order) if promotion.eligible?(order)
         end

data/app/models/spree/promotion_handler/promotion_duplicator.rb

@@ -2,7 +2,7 @@ module Spree
   module PromotionHandler
     class PromotionDuplicator
       def initialize(promotion, random_string: nil)
-        @promotion = promotion
+        @promotion = promotion.reload
         @random_string = random_string || generate_random_string(4)
       end
 
@@ -19,7 +19,7 @@ module Spree
           copy_actions
         end
 
-        @new_promotion
+        @new_promotion.reload
       end
 
       private
@@ -27,7 +27,8 @@ module Spree
       def copy_rules
         @promotion.promotion_rules.each do |rule|
           new_rule = rule.dup
-          @new_promotion.promotion_rules << new_rule
+          new_rule.promotion = @new_promotion
+          new_rule.save!
 
           new_rule.users = rule.users if rule.try(:users)
           new_rule.taxons = rule.taxons if rule.try(:taxons)
@@ -43,9 +44,9 @@ module Spree
       def copy_actions
         @promotion.promotion_actions.each do |action|
           new_action = action.dup
+          new_action.promotion = @new_promotion
           new_action.calculator = action.calculator.dup if action.try(:calculator)
-
-          @new_promotion.promotion_actions << new_action
+          new_action.save!
 
           next unless action.try(:promotion_action_line_items)
 

data/app/models/spree/promotion_rule.rb

@@ -1,12 +1,13 @@
 # Base class for all promotion rules
 module Spree
-  class PromotionRule < Spree::Base
+  class PromotionRule < Spree.base_class
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
 
     delegate :stores, to: :promotion
 
     scope :of_type, ->(t) { where(type: t) }
 
+    validates :promotion, presence: true
     validate :unique_per_promotion, on: :create
 
     def self.for(promotable)
@@ -31,6 +32,27 @@ module Spree
       @eligibility_errors ||= ActiveModel::Errors.new(self)
     end
 
+    # Returns the human name of the promotion rule
+    #
+    # @return [String] eg. Currency
+    def human_name
+      Spree.t("promotion_rule_types.#{key}.name")
+    end
+
+    # Returns the human description of the promotion rule
+    #
+    # @return [String]
+    def human_description
+      Spree.t("promotion_rule_types.#{key}.description")
+    end
+
+    # Returns the key of the promotion rule
+    #
+    # @return [String] eg. currency
+    def key
+      type.demodulize.underscore
+    end
+
     private
 
     def unique_per_promotion

data/app/models/spree/promotion_rule_taxon.rb

@@ -1,5 +1,5 @@
 module Spree
-  class PromotionRuleTaxon < Spree::Base
+  class PromotionRuleTaxon < Spree.base_class
     belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
     belongs_to :taxon, class_name: 'Spree::Taxon'
 

data/app/models/spree/promotion_rule_user.rb

@@ -1,5 +1,5 @@
 module Spree
-  class PromotionRuleUser < Spree::Base
+  class PromotionRuleUser < Spree.base_class
     belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
     belongs_to :user, class_name: "::#{Spree.user_class}"
 

data/app/models/spree/property.rb

@@ -1,14 +1,16 @@
 module Spree
-  class Property < Spree::Base
+  class Property < Spree.base_class
     include Spree::FilterParam
     include Spree::Metadata
+    include Spree::ParameterizableName
+    include Spree::DisplayOn
     include Spree::TranslatableResource
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks
     end
 
     if Spree.always_use_translations?
-      TRANSLATABLE_FIELDS = %i[name presentation filter_param].freeze
+      TRANSLATABLE_FIELDS = %i[name presentation].freeze
       translates(*TRANSLATABLE_FIELDS)
     else
       TRANSLATABLE_FIELDS = %i[presentation].freeze
@@ -20,6 +22,7 @@ module Spree
     end
 
     auto_strip_attributes :name, :presentation
+    acts_as_list
 
     has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
     has_many :prototypes, through: :property_prototypes, class_name: 'Spree::Prototype'
@@ -29,10 +32,15 @@ module Spree
 
     validates :name, :presentation, presence: true
 
+    default_scope { order(:position) }
     scope :sorted, -> { order(:name) }
     scope :filterable, -> { where(filterable: true) }
 
+    KIND_OPTIONS = { short_text: 0, long_text: 1, number: 2, rich_text: 3 }.freeze
+    enum :kind, KIND_OPTIONS
+
     after_touch :touch_all_products
+    after_update :touch_all_products, if: -> { saved_changes.key?(:presentation) }
     after_save :ensure_product_properties_have_filter_params
 
     self.whitelisted_ransackable_attributes = ['presentation', 'filterable']
@@ -48,7 +56,7 @@ module Spree
     private
 
     def touch_all_products
-      products.update_all(updated_at: Time.current)
+      products.touch_all
     end
 
     def with_uniq_values_cache_key(product_properties_scope, &block)

data/app/models/spree/property_prototype.rb

@@ -1,5 +1,5 @@
 module Spree
-  class PropertyPrototype < Spree::Base
+  class PropertyPrototype < Spree.base_class
     belongs_to :prototype, class_name: 'Spree::Prototype'
     belongs_to :property, class_name: 'Spree::Property'
 

data/app/models/spree/prototype.rb

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

data/app/models/spree/prototype_taxon.rb

@@ -1,5 +1,5 @@
 module Spree
-  class PrototypeTaxon < Spree::Base
+  class PrototypeTaxon < Spree.base_class
     belongs_to :taxon, class_name: 'Spree::Taxon'
     belongs_to :prototype, class_name: 'Spree::Prototype'
 

data/app/models/spree/refund.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Refund < Spree::Base
+  class Refund < Spree.base_class
     include Spree::Metadata
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks
@@ -58,6 +58,13 @@ module Spree
       reimbursement.customer_return&.return_items || reimbursement.return_items
     end
 
+    # Returns true if the refund is editable.
+    #
+    # @return [Boolean]
+    def editable?
+      !payment.order.canceled?
+    end
+
     private
 
     # attempts to perform the refund.
@@ -76,13 +83,17 @@ module Spree
 
     # return an activemerchant response object if successful or else raise an error
     def process!(credit_cents)
+      refund_total_in_cents = calculate_refund_amount(credit_cents)
+
       response = if payment.payment_method.payment_profiles_supported?
-                   payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, originator: self)
+                   payment.payment_method.credit(refund_total_in_cents, payment.source, payment.transaction_id, originator: self)
                  else
-                   payment.payment_method.credit(credit_cents, payment.transaction_id, originator: self)
+                   payment.payment_method.credit(refund_total_in_cents, payment.transaction_id, originator: self)
                  end
 
-      unless response.success?
+      if response.success?
+        track_order_as_refunded(refund_total_in_cents)
+      else
         Rails.logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
         text = response.params['message'] || response.params['response_reason_text'] || response.message
         raise Core::GatewayError, text
@@ -94,6 +105,15 @@ module Spree
       raise Core::GatewayError, Spree.t(:unable_to_connect_to_gateway)
     end
 
+    def calculate_refund_amount(credit_cents)
+      # Overwrite this for more complex calculations
+      credit_cents
+    end
+
+    def track_order_as_refunded(credit_cents)
+      # You can track refunds here
+    end
+
     def create_log_entry
       log_entries.create!(details: @response.to_yaml)
     end

data/app/models/spree/refund_reason.rb

@@ -1,13 +1,23 @@
 module Spree
-  class RefundReason < Spree::Base
+  class RefundReason < Spree.base_class
     include Spree::NamedType
 
     RETURN_PROCESSING_REASON = 'Return processing'
+    ORDER_CANCELED_REASON = 'Order Canceled'
+    SHIPMENT_CANCELED_REASON = 'Shipment Canceled'
 
     has_many :refunds, dependent: :restrict_with_error
 
     def self.return_processing_reason
-      find_by(name: RETURN_PROCESSING_REASON, mutable: false)
+      find_or_create_by(name: RETURN_PROCESSING_REASON, mutable: false)
+    end
+
+    def self.order_canceled_reason
+      find_or_create_by(name: ORDER_CANCELED_REASON, mutable: false)
+    end
+
+    def self.shipment_canceled_reason
+      find_or_create_by(name: SHIPMENT_CANCELED_REASON, mutable: false)
     end
   end
 end

data/app/models/spree/reimbursement/credit.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Reimbursement::Credit < Spree::Base
+  class Reimbursement::Credit < Spree.base_class
     class_attribute :default_creditable_class
     self.default_creditable_class = nil
 

data/app/models/spree/reimbursement/emails.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Reimbursement < Spree::Base
+  class Reimbursement < Spree.base_class
     module Emails
       def send_reimbursement_email
         # you can overwrite this method in your application / extension to send out the confirmation email

data/app/models/spree/reimbursement.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Reimbursement < Spree::Base
+  class Reimbursement < Spree.base_class
     include Spree::Core::NumberGenerator.new(prefix: 'RI', length: 9)
     include Spree::NumberIdentifier
     if defined?(Spree::Webhooks::HasWebhooks)
@@ -20,6 +20,8 @@ module Spree
       has_many :return_items
     end
 
+    belongs_to :performed_by, class_name: Spree.admin_user_class.to_s, optional: true
+
     validates :order, presence: true
     validate :validate_return_items_belong_to_same_order
 
@@ -104,10 +106,10 @@ module Spree
       total - paid_amount
     end
 
-    def perform!
+    def perform!(performer = nil)
       reimbursement_tax_calculator.call(self)
       reload
-      update!(total: calculated_total)
+      update!(total: calculated_total, performed_by: performer)
 
       reimbursement_performer.perform(self)
 

data/app/models/spree/reimbursement_type.rb

@@ -1,5 +1,5 @@
 module Spree
-  class ReimbursementType < Spree::Base
+  class ReimbursementType < Spree.base_class
     include Spree::NamedType
 
     KINDS = %w(Spree::ReimbursementType::Credit

data/app/models/spree/report.rb

@@ -0,0 +1,110 @@
+module Spree
+  class Report < Spree.base_class
+    include Spree::SingleStoreResource
+    include Spree::VendorConcern if defined?(Spree::VendorConcern)
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :user, class_name: Spree.admin_user_class.to_s, optional: true
+
+    #
+    # Callbacks
+    #
+    after_initialize :set_default_values
+    after_commit :generate_async, on: :create
+
+    #
+    # Validations
+    #
+    validates :store, :date_from, :date_to, :currency, presence: true
+
+    #
+    # Attachments
+    #
+    has_one_attached :attachment, service: Spree.private_storage_service_name
+
+    # Returns a scope of records to be used for generating report lines
+    #
+    # @return [ActiveRecord::Relation]
+    def line_items_scope
+      raise NotImplementedError, "Subclass #{self.class.name} must implement #line_items_scope"
+    end
+
+    # Returns an array of report lines
+    #
+    # @return [Array<Spree::ReportLineItem>]
+    def line_items(options = {})
+      scope = line_items_scope
+      scope = scope.limit(options[:limit]) if options[:limit].present?
+
+      scope.map { |record| line_item_class.new(record: record, report: self) }
+    end
+
+    def to_partial_path
+      "spree/admin/reports/report"
+    end
+
+    def human_name
+      [Spree.t("report_names.#{type.demodulize.underscore}"), store.name, date_from.strftime('%Y-%m-%d'), date_to.strftime('%Y-%m-%d')].join(' - ')
+    end
+
+    def generate_async
+      Spree::Reports::GenerateJob.perform_later(id)
+    end
+
+    def generate
+      generate_csv
+      handle_attachment
+      send_report_done_email
+    end
+
+    def generate_csv
+      ::CSV.open(report_tmp_file_path, 'wb', encoding: 'UTF-8', col_sep: ',', row_sep: "\r\n") do |csv|
+        csv << line_item_class.csv_headers
+        line_items_scope.find_in_batches do |batch|
+          batch.each do |record|
+            csv << line_item_class.new(record: record, report: self).to_csv
+          end
+        end
+      end
+    end
+
+    def handle_attachment
+      file = ::File.open(report_tmp_file_path)
+      attachment.attach(io: file, filename: attachment_file_name)
+      ::File.delete(report_tmp_file_path) if ::File.exist?(report_tmp_file_path)
+    end
+
+    def send_report_done_email
+      return unless user.present?
+
+      Spree::ReportMailer.report_done(self).deliver_later
+    end
+
+    # eg. Spree::ReportLineItems::SalesTotal
+    def line_item_class
+      "Spree::ReportLineItems::#{type.demodulize}".safe_constantize
+    end
+
+    # eg. "store-sales-total-report-20250201120000.csv"
+    def attachment_file_name
+      @attachment_file_name ||= "#{store.code}-#{type.demodulize.parameterize}-report-#{created_at.strftime('%Y%m%d%H%M%S')}.csv"
+    end
+
+    private
+
+    def report_tmp_file_path
+      Rails.root.join('tmp', attachment_file_name)
+    end
+
+    def set_default_values
+      return if store.blank?
+
+      self.currency ||= store.default_currency
+      self.date_from ||= 1.month.ago.in_time_zone(store.preferred_timezone).beginning_of_day
+      self.date_to ||= Time.current.in_time_zone(store.preferred_timezone).end_of_day
+    end
+  end
+end

data/app/models/spree/report_line_item.rb

@@ -0,0 +1,27 @@
+module Spree
+  class ReportLineItem
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attr_accessor :record, :report
+
+    delegate :store, :currency, to: :report
+    delegate :id, to: :record, prefix: true
+
+    def self.headers
+      attribute_types.keys.map do |attribute|
+        { name: attribute.to_sym, label: Spree.t(attribute.to_sym) }
+      end
+    end
+
+    def self.csv_headers
+      attribute_types.keys
+    end
+
+    def to_csv
+      self.class.attribute_types.keys.map do |attribute|
+        send(attribute)
+      end
+    end
+  end
+end

data/app/models/spree/report_line_items/products_performance.rb

@@ -0,0 +1,76 @@
+module Spree
+  module ReportLineItems
+    class ProductsPerformance < Spree::ReportLineItem
+      attribute :sku, :string
+      attribute :name, :string
+      attribute :vendor, :string
+      attribute :brand, :string
+      attribute :category_lvl0, :string
+      attribute :category_lvl1, :string
+      attribute :category_lvl2, :string
+      attribute :price, :string
+      attribute :weeks_online, :integer
+      attribute :pre_tax_amount, :string
+      attribute :tax_total, :string
+      attribute :quantity, :integer
+      attribute :promo_total, :string
+      attribute :total, :string
+
+      delegate :sku, :name, to: :record
+
+      def vendor
+        record.try(:vendor_name)
+      end
+
+      def brand
+        record.try(:brand_name)
+      end
+
+      def category_lvl0
+        mapped_categories&.first
+      end
+
+      def category_lvl1
+        mapped_categories&.second
+      end
+
+      def category_lvl2
+        mapped_categories&.third
+      end
+
+      def price
+        record.price_in(currency).display_amount
+      end
+
+      def pre_tax_amount
+        Spree::Money.new(record.pre_tax_amount, currency: currency)
+      end
+
+      def promo_total
+        Spree::Money.new(record.promo_total, currency: currency)
+      end
+
+      def tax_total
+        Spree::Money.new(record.tax_total, currency: currency)
+      end
+
+      def quantity
+        record.quantity
+      end
+
+      def total
+        Spree::Money.new(record.total, currency: currency)
+      end
+
+      def weeks_online
+        start_date = record.available_on.presence || record.created_at
+
+        (Time.current - start_date.in_time_zone(store.preferred_timezone)).seconds.in_weeks.to_i
+      end
+
+      def mapped_categories
+        @mapped_categories ||= record.main_taxon&.pretty_name&.split('->')&.map(&:strip)
+      end
+    end
+  end
+end