Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
Rename `Orders::AddManualDiscount` to `Orders::Discounts::Create`
Damian Legawiec99d7bfbc0bf6
diff --git a/spree/api/app/controllers/spree/api/v3/admin/orders/discounts_controller.rb b/spree/api/app/controllers/spree/api/v3/admin/orders/discounts_controller.rbindex 1d3f628e7c..002df4a5dd 100644--- a/spree/api/app/controllers/spree/api/v3/admin/orders/discounts_controller.rb+++ b/spree/api/app/controllers/spree/api/v3/admin/orders/discounts_controller.rb@@ -16,7 +16,7 @@ module Spreewith_order_lock doline_item = @parent.line_items.find_by_prefix_id!(params[:line_item_id]) if params[:line_item_id].present?- result = Spree.order_add_manual_discount_service.call(+ result = Spree.order_discount_create_service.call(order: @parent,label: params[:label],value: params[:value].presence || params[:amount],diff --git a/spree/core/app/services/spree/orders/add_manual_discount.rb b/spree/core/app/services/spree/orders/add_manual_discount.rbdeleted file mode 100644index 50a0a517e3..0000000000--- a/spree/core/app/services/spree/orders/add_manual_discount.rb+++ /dev/null@@ -1,82 +0,0 @@-module Spree- module Orders- # Creates manual (admin-issued) discount rows on an order and re-sums its- # totals — the sanctioned post-placement discount path. A line-item target- # gets a single row; an order-level discount is distributed across line- # items largest-remainder over their discounted bases (there are no- # order-attached discount rows). Amounts are clamped so no line goes- # below zero.- class AddManualDiscount- prepend Spree::ServiceModule::Base-- # @param order [Spree::Order]- # @param label [String]- # @param value [Numeric] positive magnitude ("10" = 10 off / 10 percent off)- # @param value_type [String] 'flat' or 'percent'- # @param line_item [Spree::LineItem, nil] nil distributes order-level- # @return [Spree::ServiceModule::Result] value is the created rows- def call(order:, label:, value:, value_type: 'flat', line_item: nil)- value = BigDecimal(value.to_s)- return failure(nil, Spree.t('errors.messages.discount_value_must_be_positive')) unless value.positive?- return failure(nil, Spree.t('errors.messages.discount_value_type_invalid')) unless %w[flat percent].include?(value_type)-- rows = order.with_lock do- created = line_item ? [line_item_row(order, line_item, label, value, value_type)].compact : distributed_rows(order, label, value, value_type)- Spree.order_recalculate_totals_workflow.call(order: order) if created.any?- created- end-- return failure(nil, Spree.t('errors.messages.discount_has_no_effect')) if rows.empty?-- success(rows)- end-- private-- def line_item_row(order, line_item, label, value, value_type)- base = discountable_base(line_item)- amount = -[amount_for(base, value, value_type), base].min- return if amount.zero?-- create_row(order, line_item, label, amount, value, value_type)- end-- def distributed_rows(order, label, value, value_type)- line_items = order.line_items.to_a- bases = line_items.map { |line_item| [discountable_base(line_item), BigDecimal(0)].max }- bases_sum = bases.sum- return [] if bases_sum <= 0-- total = [amount_for(bases_sum, value, value_type), bases_sum].min- shares = Spree::Adjusters::LargestRemainder.largest_remainder_shares((total * 100).round, bases)-- line_items.each_with_index.filter_map do |line_item, index|- amount = -BigDecimal(shares[index]) / 100- next if amount.zero?-- create_row(order, line_item, label, amount, value, value_type)- end- end-- def amount_for(base, value, value_type)- value_type == 'percent' ? (base * value / 100).round(2) : value- end-- # Remaining discountable base: amount net of already-applied discounts.- def discountable_base(line_item)- line_item.amount + line_item.owner.discounts.where(line_item_id: line_item.id).sum(:amount)- end-- def create_row(order, line_item, label, amount, value, value_type)- order.discounts.create!(- line_item: line_item,- label: label,- amount: amount,- kind: 'manual',- value: value,- value_type: value_type- )- end- end- end-enddiff --git a/spree/core/app/services/spree/orders/discounts/create.rb b/spree/core/app/services/spree/orders/discounts/create.rbnew file mode 100644index 0000000000..deb72b4d75--- /dev/null+++ b/spree/core/app/services/spree/orders/discounts/create.rb@@ -0,0 +1,84 @@+module Spree+ module Orders+ module Discounts+ # Creates manual (admin-issued) discount rows on an order and re-sums its+ # totals — the sanctioned post-placement discount path. A line-item target+ # gets a single row; an order-level discount is distributed across line+ # items largest-remainder over their discounted bases (there are no+ # order-attached discount rows). Amounts are clamped so no line goes+ # below zero.+ class Create+ prepend Spree::ServiceModule::Base++ # @param order [Spree::Order]+ # @param label [String]+ # @param value [Numeric] positive magnitude ("10" = 10 off / 10 percent off)+ # @param value_type [String] 'flat' or 'percent'+ # @param line_item [Spree::LineItem, nil] nil distributes order-level+ # @return [Spree::ServiceModule::Result] value is the created rows+ def call(order:, label:, value:, value_type: 'flat', line_item: nil)+ value = BigDecimal(value.to_s)+ return failure(nil, Spree.t('errors.messages.discount_value_must_be_positive')) unless value.positive?+ return failure(nil, Spree.t('errors.messages.discount_value_type_invalid')) unless %w[flat percent].include?(value_type)++ rows = order.with_lock do+ created = line_item ? [line_item_row(order, line_item, label, value, value_type)].compact : distributed_rows(order, label, value, value_type)+ Spree.order_recalculate_totals_workflow.call(order: order) if created.any?+ created+ end++ return failure(nil, Spree.t('errors.messages.discount_has_no_effect')) if rows.empty?++ success(rows)+ end++ private++ def line_item_row(order, line_item, label, value, value_type)+ base = discountable_base(line_item)+ amount = -[amount_for(base, value, value_type), base].min+ return if amount.zero?++ create_row(order, line_item, label, amount, value, value_type)+ end++ def distributed_rows(order, label, value, value_type)+ line_items = order.line_items.to_a+ bases = line_items.map { |line_item| [discountable_base(line_item), BigDecimal(0)].max }+ bases_sum = bases.sum+ return [] if bases_sum <= 0++ total = [amount_for(bases_sum, value, value_type), bases_sum].min+ shares = Spree::Adjusters::LargestRemainder.largest_remainder_shares((total * 100).round, bases)++ line_items.each_with_index.filter_map do |line_item, index|+ amount = -BigDecimal(shares[index]) / 100+ next if amount.zero?++ create_row(order, line_item, label, amount, value, value_type)+ end+ end++ def amount_for(base, value, value_type)+ value_type == 'percent' ? (base * value / 100).round(2) : value+ end++ # Remaining discountable base: amount net of already-applied discounts.+ def discountable_base(line_item)+ line_item.amount + line_item.owner.discounts.where(line_item_id: line_item.id).sum(:amount)+ end++ def create_row(order, line_item, label, amount, value, value_type)+ order.discounts.create!(+ line_item: line_item,+ label: label,+ amount: amount,+ kind: 'manual',+ value: value,+ value_type: value_type+ )+ end+ end+ end+ end+enddiff --git a/spree/core/lib/spree/core/dependencies.rb b/spree/core/lib/spree/core/dependencies.rbindex 3dcd900e62..0e38d6d396 100644--- a/spree/core/lib/spree/core/dependencies.rb+++ b/spree/core/lib/spree/core/dependencies.rb@@ -57,7 +57,7 @@ module Spreeorder_cancel_workflow: 'Spree::Orders::Cancel',order_resume_workflow: 'Spree::Orders::Resume',order_complete_service: 'Spree::Orders::Complete',- order_add_manual_discount_service: 'Spree::Orders::AddManualDiscount',+ order_discount_create_service: 'Spree::Orders::Discounts::Create',order_discount_update_service: 'Spree::Orders::Discounts::Update',order_discount_destroy_service: 'Spree::Orders::Discounts::Destroy',order_fee_create_service: 'Spree::Orders::Fees::Create',diff --git a/spree/core/spec/services/spree/orders/discounts/create_spec.rb b/spree/core/spec/services/spree/orders/discounts/create_spec.rbnew file mode 100644index 0000000000..0cd2ef0c1c--- /dev/null+++ b/spree/core/spec/services/spree/orders/discounts/create_spec.rb@@ -0,0 +1,93 @@+require 'spec_helper'++module Spree+ RSpec.describe Orders::Discounts::Create do+ let(:store) { @default_store }+ let(:order) { create(:completed_order_with_totals, store: store, line_items_count: 2, line_items_price: 10) }+ let(:line_item) { order.line_items.first }++ describe '#call' do+ context 'targeting a line item' do+ it 'creates a flat manual discount row and re-sums the order totals' do+ expect do+ result = described_class.call(order: order, label: 'Appeasement', value: 3, line_item: line_item)++ expect(result).to be_success+ expect(result.value.sole).to have_attributes(+ line_item: line_item, label: 'Appeasement', amount: -3, kind: 'manual',+ value: 3, value_type: 'flat'+ )+ end.to change { order.reload.total }.by(-3).and change { order.adjustment_total }.by(-3)+ end++ it 'computes a percent discount from the line item amount' do+ result = described_class.call(order: order, label: 'Ten off', value: 10, value_type: 'percent', line_item: line_item)++ expect(result.value.sole.amount).to eq(-1)+ end++ it 'clamps the amount so the line item never goes below zero' do+ create(:discount, order: order, line_item: line_item, amount: -8, kind: 'manual')++ result = described_class.call(order: order, label: 'Big', value: 50, line_item: line_item)++ expect(result.value.sole.amount).to eq(-2)+ end++ it 'fails without creating a row when the line item is already fully discounted' do+ create(:discount, order: order, line_item: line_item, amount: -10, kind: 'manual')++ expect do+ result = described_class.call(order: order, label: 'Nothing left', value: 5, line_item: line_item)++ expect(result).to be_failure+ expect(result.error.to_s).to eq(Spree.t('errors.messages.discount_has_no_effect'))+ end.not_to change { order.discounts.count }+ end+ end++ context 'order-level (no line item)' do+ it 'distributes the amount across line items proportionally to their discountable bases' do+ expect do+ result = described_class.call(order: order, label: 'Order-wide', value: 10)++ expect(result).to be_success+ expect(result.value.map(&:line_item)).to match_array(order.line_items)+ expect(result.value.sum(&:amount)).to eq(-10)+ end.to change { order.reload.total }.by(-10)+ end++ it 'caps the distributed amount at the sum of the discountable bases' do+ result = described_class.call(order: order, label: 'Everything', value: 999)++ expect(result.value.sum(&:amount)).to eq(-20)+ expect(order.reload.total).to eq(order.delivery_total + order.additional_tax_total)+ end++ it 'skips line items with no remaining discountable base' do+ create(:discount, order: order, line_item: line_item, amount: -10, kind: 'manual')++ result = described_class.call(order: order, label: 'Rest', value: 4)++ expect(result.value.sole.line_item).to eq(order.line_items.second)+ end+ end++ context 'with invalid input' do+ it 'fails on a non-positive value' do+ result = described_class.call(order: order, label: 'Zero', value: 0)++ expect(result).to be_failure+ expect(result.error.to_s).to eq(Spree.t('errors.messages.discount_value_must_be_positive'))+ end++ it 'fails on an unknown value_type' do+ result = described_class.call(order: order, label: 'Odd', value: 5, value_type: 'points')++ expect(result).to be_failure+ expect(result.error.to_s).to eq(Spree.t('errors.messages.discount_value_type_invalid'))+ end+ end+ end+ end+enddiff --git a/spree/core/spec/services/spree/orders/discounts/destroy_spec.rb b/spree/core/spec/services/spree/orders/discounts/destroy_spec.rbnew file mode 100644index 0000000000..1b62e8a3ed--- /dev/null+++ b/spree/core/spec/services/spree/orders/discounts/destroy_spec.rb@@ -0,0 +1,33 @@+require 'spec_helper'++module Spree+ RSpec.describe Orders::Discounts::Destroy do+ let(:store) { @default_store }+ let(:order) { create(:completed_order_with_totals, store: store) }+ let!(:discount) do+ create(:discount, order: order, line_item: order.line_items.first, amount: -2, kind: 'manual').tap do+ order.recalculate_totals!+ end+ end++ describe '#call' do+ it 'destroys the row and re-sums the order totals' do+ expect do+ result = described_class.call(order: order, discount: discount)++ expect(result).to be_success+ end.to change { order.reload.total }.by(2).and change { order.discounts.count }.by(-1)+ end++ it 'refuses promotion-sourced rows' do+ discount.update_columns(kind: 'promotion')++ result = described_class.call(order: order, discount: discount)++ expect(result).to be_failure+ expect(result.error.value).to eq(:promotion_discount_not_editable)+ expect(Spree::Discount.exists?(discount.id)).to be(true)+ end+ end+ end+enddiff --git a/spree/core/spec/services/spree/orders/discounts/update_spec.rb b/spree/core/spec/services/spree/orders/discounts/update_spec.rbnew file mode 100644index 0000000000..fa3bbd3ec6--- /dev/null+++ b/spree/core/spec/services/spree/orders/discounts/update_spec.rb@@ -0,0 +1,37 @@+require 'spec_helper'++module Spree+ RSpec.describe Orders::Discounts::Update do+ let(:store) { @default_store }+ let(:order) { create(:completed_order_with_totals, store: store) }+ let(:discount) { create(:discount, order: order, line_item: order.line_items.first, amount: -2, kind: 'manual') }++ describe '#call' do+ it 'updates the row and re-sums the order totals' do+ expect do+ result = described_class.call(order: order, discount: discount, attributes: { amount: -5, label: 'Bigger' })++ expect(result).to be_success+ expect(discount.reload).to have_attributes(amount: -5, label: 'Bigger')+ end.to change { order.reload.total }.by(-5)+ end++ it 'refuses promotion-sourced rows' do+ discount.update_columns(kind: 'promotion')++ result = described_class.call(order: order, discount: discount, attributes: { label: 'Nope' })++ expect(result).to be_failure+ expect(result.error.value).to eq(:promotion_discount_not_editable)+ end++ it 'fails without touching totals when the update is invalid' do+ expect do+ result = described_class.call(order: order, discount: discount, attributes: { amount: 3 })++ expect(result).to be_failure+ end.not_to change { order.reload.total }+ end+ end+ end+enddiff --git a/spree/core/spec/services/spree/orders/fees/create_spec.rb b/spree/core/spec/services/spree/orders/fees/create_spec.rbnew file mode 100644index 0000000000..0a57c7eee8--- /dev/null+++ b/spree/core/spec/services/spree/orders/fees/create_spec.rb@@ -0,0 +1,34 @@+require 'spec_helper'++module Spree+ RSpec.describe Orders::Fees::Create do+ let(:store) { @default_store }+ let(:order) { create(:completed_order_with_totals, store: store) }++ describe '#call' do+ it 'creates a surcharge fee by default and re-sums the order totals' do+ expect do+ result = described_class.call(order: order, attributes: { label: 'Gift wrap', amount: 4 })++ expect(result).to be_success+ expect(result.value).to have_attributes(label: 'Gift wrap', amount: 4, kind: 'surcharge')+ end.to change { order.reload.total }.by(4).and change { order.fee_total }.by(4)+ end++ it 'keeps an explicit kind' do+ result = described_class.call(order: order, attributes: { label: 'Handling', amount: 2, kind: 'handling' })++ expect(result.value.kind).to eq('handling')+ end++ it 'fails without touching totals when the fee is invalid' do+ expect do+ result = described_class.call(order: order, attributes: { label: 'Bad', amount: -3 })++ expect(result).to be_failure+ expect(result.value.errors[:amount]).to be_present+ end.not_to change { [order.fees.count, order.reload.total] }+ end+ end+ end+enddiff --git a/spree/core/spec/services/spree/orders/fees/destroy_spec.rb b/spree/core/spec/services/spree/orders/fees/destroy_spec.rbnew file mode 100644index 0000000000..5b5aa7f039--- /dev/null+++ b/spree/core/spec/services/spree/orders/fees/destroy_spec.rb@@ -0,0 +1,21 @@+require 'spec_helper'++module Spree+ RSpec.describe Orders::Fees::Destroy do+ let(:store) { @default_store }+ let(:order) { create(:completed_order_with_totals, store: store) }+ let!(:fee) do+ create(:fee, order: order, amount: 4, kind: 'surcharge').tap { order.recalculate_totals! }+ end++ describe '#call' do+ it 'destroys the row and re-sums the order totals' do+ expect do+ result = described_class.call(order: order, fee: fee)++ expect(result).to be_success+ end.to change { order.reload.total }.by(-4).and change { order.fees.count }.by(-1)+ end+ end+ end+enddiff --git a/spree/core/spec/services/spree/orders/fees/update_spec.rb b/spree/core/spec/services/spree/orders/fees/update_spec.rbnew file mode 100644index 0000000000..a4bc8a35ba--- /dev/null+++ b/spree/core/spec/services/spree/orders/fees/update_spec.rb@@ -0,0 +1,30 @@+require 'spec_helper'++module Spree+ RSpec.describe Orders::Fees::Update do+ let(:store) { @default_store }+ let(:order) { create(:completed_order_with_totals, store: store) }+ let!(:fee) do+ create(:fee, order: order, amount: 4, kind: 'surcharge').tap { order.recalculate_totals! }+ end++ describe '#call' do+ it 'updates the row and re-sums the order totals' do+ expect do+ result = described_class.call(order: order, fee: fee, attributes: { amount: 6, label: 'Rush' })++ expect(result).to be_success+ expect(fee.reload).to have_attributes(amount: 6, label: 'Rush')+ end.to change { order.reload.total }.by(2)+ end++ it 'fails without touching totals when the update is invalid' do+ expect do+ result = described_class.call(order: order, fee: fee, attributes: { amount: -1 })++ expect(result).to be_failure+ end.not_to change { order.reload.total }+ end+ end+ end+end