spree_core 5.6.1 → 6.0.0.beta2

data/app/models/spree/report.rb

@@ -1,140 +0,0 @@
-module Spree
-  class Report < Spree.base_class
-    has_prefix_id :rep
-
-    include Spree::SingleStoreResource
-    include Spree::VendorConcern if defined?(Spree::VendorConcern)
-
-    publishes_lifecycle_events
-
-    # Set event prefix for all Report subclasses
-    # This ensures Spree::Reports::SalesTotal publishes 'report.create' not 'sales_total.create'
-    self.event_prefix = 'report'
-
-    #
-    # 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
-    # NOTE: generate_async is now handled by Spree::ReportSubscriber listening to 'report.create' event
-
-    #
-    # Validations
-    #
-    validates :store, :date_from, :date_to, :currency, presence: true
-
-    #
-    # Attachments
-    #
-    has_one_attached :attachment, service: Spree.private_storage_service_name
-
-    def event_serializer_class
-      'Spree::Api::V3::ReportSerializer'.safe_constantize
-    end
-
-    # Registered report subclasses, mirroring Spree::Export/Spree::Import so
-    # `api_type_for` can resolve an STI column value without constantizing it.
-    #
-    # @return [Array<Class>]
-    def self.available_types
-      Spree.reports
-    end
-
-    # @deprecated Use `.api_type` — identical derivation, consistent with the
-    #   rest of the API's `type` fields.
-    def self.report_type
-      api_type
-    end
-
-    # 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 no_report_data_partial_path
-      'spree/admin/reports/no_report_data'
-    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

@@ -1,27 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

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

@@ -1,49 +0,0 @@
-module Spree
-  module ReportLineItems
-    class SalesTotal < Spree::ReportLineItem
-      attribute :date, :string
-      attribute :order, :string
-      attribute :product, :string
-      attribute :quantity, :integer
-      attribute :pre_tax_amount, :decimal
-      attribute :promo_total, :decimal
-      attribute :shipment_total, :decimal
-      attribute :tax_total, :decimal
-      attribute :total, :decimal
-
-      delegate :quantity, to: :record
-
-      def date
-        record.order.completed_at.strftime('%Y-%m-%d')
-      end
-
-      def order
-        record.order.number
-      end
-
-      def product
-        record.variant.descriptive_name
-      end
-
-      def total
-        Spree::Money.new(record.final_amount + record.shipping_cost, currency: record.currency)
-      end
-
-      def promo_total
-        record.display_promo_total
-      end
-
-      def pre_tax_amount
-        record.display_pre_tax_amount
-      end
-
-      def shipment_total
-        record.display_shipping_cost
-      end
-
-      def tax_total
-        record.display_tax_total
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-module Spree
-  module Reports
-    class ProductsPerformance < Spree::Report
-      def line_items_scope
-        line_items_scope = Spree::LineItem.
-                           select("
-                             #{Spree::LineItem.table_name}.quantity as quantity,
-                             #{Spree::LineItem.table_name}.pre_tax_amount as pre_tax_amount,
-                             #{Spree::LineItem.table_name}.promo_total as promo_total,
-                             #{Spree::LineItem.table_name}.included_tax_total + #{Spree::LineItem.table_name}.additional_tax_total AS tax_total,
-                             #{Spree::LineItem.table_name}.pre_tax_amount + #{Spree::LineItem.table_name}.adjustment_total AS total,
-                             #{Spree::Variant.table_name}.product_id AS product_id
-                           ").
-                           joins(:variant, :order).
-                           where(
-                             spree_line_items: {
-                               currency: currency
-                             },
-                             spree_orders: {
-                               completed_at: date_from..date_to
-                             }
-                           )
-
-        return Spree::Product.none if line_items_scope.empty?
-
-        line_items_sql = line_items_scope.to_sql
-
-        product_scope = store.products
-        product_scope = product_scope.where(vendor_id: vendor.id) if defined?(vendor) && vendor.present?
-
-        product_scope.includes(:taxons, :tax_category, variants: :prices, master: :prices).
-                              joins("LEFT JOIN (#{line_items_sql}) AS line_items ON #{Spree::Product.table_name}.id = line_items.product_id").
-                              select("
-                                spree_products.*,
-                                COALESCE(SUM(line_items.pre_tax_amount), 0.0) AS pre_tax_amount,
-                                COALESCE(SUM(line_items.quantity), 0) AS quantity,
-                                COALESCE(SUM(line_items.promo_total), 0.0) AS promo_total,
-                                COALESCE(SUM(line_items.tax_total), 0.0) AS tax_total,
-                                COALESCE(SUM(line_items.total), 0.0) AS total
-                              ").group('spree_products.id')
-      end
-    end
-  end
-end

data/app/models/spree/reports/sales_total.rb

@@ -1,18 +0,0 @@
-module Spree
-  module Reports
-    class SalesTotal < Spree::Report
-      def line_items_scope
-        scope = store.line_items.where(
-          order: Spree::Order.complete.where(
-            currency: currency,
-            completed_at: date_from..date_to
-          )
-        ).includes(:order, shipments: :inventory_units, variant: :product)
-
-        scope = scope.where(vendor_id: vendor.id) if defined?(vendor) && vendor.present?
-
-        scope
-      end
-    end
-  end
-end

data/app/models/spree/return_authorization.rb

@@ -1,109 +0,0 @@
-module Spree
-  class ReturnAuthorization < Spree.base_class
-    has_prefix_id :ra
-
-    include Spree::Core::NumberGenerator.new(prefix: 'RA', length: 9)
-    include Spree::NumberIdentifier
-
-    publishes_lifecycle_events
-
-    belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations
-
-    has_many :return_items, inverse_of: :return_authorization, dependent: :destroy
-    with_options through: :return_items do
-      has_many :inventory_units
-      has_many :customer_returns
-    end
-
-    has_many :reimbursements, through: :customer_returns
-    has_many :refunds, through: :reimbursements
-
-    belongs_to :stock_location
-    belongs_to :reason, class_name: 'Spree::ReturnAuthorizationReason', foreign_key: :return_authorization_reason_id
-
-    after_save :generate_expedited_exchange_reimbursements
-
-    accepts_nested_attributes_for :return_items, allow_destroy: true
-
-    validates :order, :reason, :stock_location, presence: true
-    validate :must_have_shipped_units, on: :create
-
-    # These are called prior to generating expedited exchanges shipments.
-    # Should respond to a "call" method that takes the list of return items
-    class_attribute :pre_expedited_exchange_hooks
-    self.pre_expedited_exchange_hooks = []
-
-    state_machine initial: :authorized do
-      before_transition to: :canceled, do: :cancel_return_items
-      after_transition to: :canceled, do: :publish_return_authorization_canceled_event
-
-      event :cancel do
-        transition to: :canceled, from: :authorized, if: ->(return_authorization) { return_authorization.can_cancel_return_items? }
-      end
-    end
-
-    extend DisplayMoney
-    money_methods :pre_tax_total
-
-    self.whitelisted_ransackable_attributes = ['memo', 'number', 'state']
-    self.whitelisted_ransackable_associations = ['order']
-
-    def pre_tax_total
-      return_items.sum(:pre_tax_amount)
-    end
-
-    def currency
-      # FIXME: we should associate ReturnAuthorization with Store
-      order.nil? ? Spree::Store.default.default_currency : order.currency
-    end
-
-    def refundable_amount
-      order.pre_tax_item_amount + order.promo_total
-    end
-
-    def customer_returned_items?
-      customer_returns.exists?
-    end
-
-    def can_cancel_return_items?
-      return_items.any?(&:can_cancel?) || return_items.blank?
-    end
-
-    private
-
-    def must_have_shipped_units
-      if order.nil? || order.inventory_units.shipped.none?
-        errors.add(:order, Spree.t(:has_no_shipped_units))
-      end
-    end
-
-    def cancel_return_items
-      return_items.each { |item| item.cancel! if item.can_cancel? }
-    end
-
-    def publish_return_authorization_canceled_event
-      publish_event('return_authorization.canceled')
-    end
-
-    def generate_expedited_exchange_reimbursements
-      return unless Spree::Config[:expedited_exchanges]
-
-      items_to_exchange = return_items.select(&:exchange_required?)
-      items_to_exchange.each(&:attempt_accept)
-      items_to_exchange.select!(&:accepted?)
-
-      return if items_to_exchange.blank?
-
-      pre_expedited_exchange_hooks.each { |h| h.call items_to_exchange }
-
-      reimbursement = Reimbursement.new(return_items: items_to_exchange, order: order)
-
-      if reimbursement.save
-        reimbursement.perform!
-      else
-        errors.add(:base, reimbursement.errors.full_messages)
-        raise ActiveRecord::RecordInvalid, self
-      end
-    end
-  end
-end

data/app/models/spree/return_item/eligibility_validator/base_validator.rb

@@ -1,24 +0,0 @@
-module Spree
-  class ReturnItem::EligibilityValidator::BaseValidator
-    attr_reader :errors
-
-    def initialize(return_item)
-      @return_item = return_item
-      @errors = {}
-    end
-
-    def eligible_for_return?
-      raise NotImplementedError, Spree.t(:implement_eligible_for_return)
-    end
-
-    def requires_manual_intervention?
-      raise NotImplementedError, Spree.t(:implement_requires_manual_intervention)
-    end
-
-    private
-
-    def add_error(key, error)
-      @errors[key] = error
-    end
-  end
-end

data/app/models/spree/return_item/eligibility_validator/default.rb

@@ -1,30 +0,0 @@
-module Spree
-  class ReturnItem::EligibilityValidator::Default < Spree::ReturnItem::EligibilityValidator::BaseValidator
-    class_attribute :permitted_eligibility_validators
-    self.permitted_eligibility_validators = [
-      ReturnItem::EligibilityValidator::OrderCompleted,
-      ReturnItem::EligibilityValidator::TimeSincePurchase,
-      ReturnItem::EligibilityValidator::RMARequired,
-      ReturnItem::EligibilityValidator::InventoryShipped,
-      ReturnItem::EligibilityValidator::NoReimbursements
-    ]
-
-    def eligible_for_return?
-      validators.all?(&:eligible_for_return?)
-    end
-
-    def requires_manual_intervention?
-      validators.any?(&:requires_manual_intervention?)
-    end
-
-    def errors
-      validators.map(&:errors).reduce({}, :merge)
-    end
-
-    private
-
-    def validators
-      @validators ||= permitted_eligibility_validators.map { |v| v.new(@return_item) }
-    end
-  end
-end

data/app/models/spree/return_item/eligibility_validator/inventory_shipped.rb

@@ -1,16 +0,0 @@
-module Spree
-  class ReturnItem::EligibilityValidator::InventoryShipped < Spree::ReturnItem::EligibilityValidator::BaseValidator
-    def eligible_for_return?
-      if @return_item.inventory_unit.shipped?
-        true
-      else
-        add_error(:inventory_unit_shipped, Spree.t('return_item_inventory_unit_ineligible'))
-        false
-      end
-    end
-
-    def requires_manual_intervention?
-      @errors.present?
-    end
-  end
-end

data/app/models/spree/return_item/eligibility_validator/no_reimbursements.rb

@@ -1,16 +0,0 @@
-module Spree
-  class ReturnItem::EligibilityValidator::NoReimbursements < Spree::ReturnItem::EligibilityValidator::BaseValidator
-    def eligible_for_return?
-      if Spree::ReturnItem.where(inventory_unit: @return_item.inventory_unit).where.not(reimbursement_id: nil).any?
-        add_error(:inventory_unit_reimbursed, Spree.t('return_item_inventory_unit_reimbursed'))
-        false
-      else
-        true
-      end
-    end
-
-    def requires_manual_intervention?
-      @errors.present?
-    end
-  end
-end

data/app/models/spree/return_item/eligibility_validator/order_completed.rb

@@ -1,16 +0,0 @@
-module Spree
-  class ReturnItem::EligibilityValidator::OrderCompleted < Spree::ReturnItem::EligibilityValidator::BaseValidator
-    def eligible_for_return?
-      if @return_item.inventory_unit.order.completed?
-        true
-      else
-        add_error(:order_not_completed, Spree.t('return_item_order_not_completed'))
-        false
-      end
-    end
-
-    def requires_manual_intervention?
-      false
-    end
-  end
-end

data/app/models/spree/return_item/eligibility_validator/rma_required.rb

@@ -1,16 +0,0 @@
-module Spree
-  class ReturnItem::EligibilityValidator::RMARequired < Spree::ReturnItem::EligibilityValidator::BaseValidator
-    def eligible_for_return?
-      if @return_item.return_authorization.present?
-        true
-      else
-        add_error(:rma_required, Spree.t('return_item_rma_ineligible'))
-        false
-      end
-    end
-
-    def requires_manual_intervention?
-      false
-    end
-  end
-end

data/app/models/spree/return_item/eligibility_validator/time_since_purchase.rb

@@ -1,16 +0,0 @@
-module Spree
-  class ReturnItem::EligibilityValidator::TimeSincePurchase < Spree::ReturnItem::EligibilityValidator::BaseValidator
-    def eligible_for_return?
-      if (@return_item.inventory_unit.order.completed_at + Spree::Config[:return_eligibility_number_of_days].days) > Time.current
-        true
-      else
-        add_error(:number_of_days, Spree.t('return_item_time_period_ineligible'))
-        false
-      end
-    end
-
-    def requires_manual_intervention?
-      false
-    end
-  end
-end

data/app/models/spree/return_item/exchange_variant_eligibility/same_option_value.rb

@@ -1,34 +0,0 @@
-module Spree
-  module ReturnItem::ExchangeVariantEligibility
-    class SameOptionValue
-      class_attribute :option_type_restrictions
-      self.option_type_restrictions = []
-      # This can be configured in an initializer, e.g.:
-      # Spree::ReturnItem::ExchangeVariantEligibility::SameOptionValue.option_type_restrictions = ["size", "color"]
-      #
-      # This restriction causes only variants that share the same option value for the
-      # specified option types to be returned. e.g.:
-      #
-      # option_type_restrictions = ["color", "waist"]
-      # Variant: blue pants with 32 waist and 30 inseam
-      #
-      # can be exchanged for:
-      # blue pants with 32 waist and 31 inseam
-      #
-      # cannot be exchanged for:
-      # green pants with 32 waist and 30 inseam
-      # blue pants with 34 waist and 32 inseam
-
-      def self.eligible_variants(variant)
-        product_variants = SameProduct.eligible_variants(variant).includes(option_values: :option_type)
-
-        relevant_option_values = variant.option_values.select { |ov| option_type_restrictions.include? ov.option_type.name }
-        if relevant_option_values.present?
-          product_variants.select { |v| (relevant_option_values & v.option_values) == relevant_option_values }
-        else
-          product_variants
-        end
-      end
-    end
-  end
-end

data/app/models/spree/return_item/exchange_variant_eligibility/same_product.rb

@@ -1,9 +0,0 @@
-module Spree
-  module ReturnItem::ExchangeVariantEligibility
-    class SameProduct
-      def self.eligible_variants(variant)
-        Spree::Variant.where(product_id: variant.product_id, is_master: variant.is_master?).in_stock_or_backorderable
-      end
-    end
-  end
-end