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
Improve update service for `Spree::Address` (#12192)
Łukasz Adamczyk0b0b39048f2e
diff --git a/core/app/models/spree/address.rb b/core/app/models/spree/address.rbindex d78272c7c8..3dabc39c9a 100644--- a/core/app/models/spree/address.rb+++ b/core/app/models/spree/address.rb@@ -81,6 +81,14 @@ module Spreeend.flattenend+ def user_default_billing?+ user.present? && id == user.bill_address_id+ end++ def user_default_shipping?+ user.present? && id == user.ship_address_id+ end+def full_name"#{firstname} #{lastname}".stripenddiff --git a/core/app/services/spree/addresses/update.rb b/core/app/services/spree/addresses/update.rbindex 295bb3648a..0c94e0b311 100644--- a/core/app/services/spree/addresses/update.rb+++ b/core/app/services/spree/addresses/update.rb@@ -6,27 +6,99 @@ module Spreeattr_accessor :country- def call(address:, address_params:)- address_params[:country_id] ||= address.country_id- address_params = fill_country_and_state_ids(address_params)- address_params[:user_id] = address.user_id if address.user_id.present?+ def call(address:, address_params:, **opts)+ order = opts[:order]+ default_billing = opts.fetch(:default_billing, false)+ default_shipping = opts.fetch(:default_shipping, false)+ address_changes_except = opts.fetch(:address_changes_except, [])- if address&.editable?- address.update(address_params) ? success(address) : failure(address)- else- if new_address(address_params).valid?- address.destroy- success(new_address)+ prepare_address_params!(address, address_params)+ address.assign_attributes(address_params)++ address_changed = address.changes.except(*address_changes_except).any?++ if !address_changed && defaults_changed?(address, default_billing, default_shipping)+ assign_to_user_as_default(+ user: address.user,+ address_id: address.id,+ default_billing: default_billing,+ default_shipping: default_shipping+ )+ end++ return success(address) unless address_changed++ if address.editable?+ if address.update(address_params)+ if address.user.present?+ assign_to_user_as_default(+ user: address.user,+ address_id: address.id,+ default_billing: default_billing,+ default_shipping: default_shipping+ )+ end++ order.update(state: 'address') if order.present?++ success(address)else- failure(new_address)+ failure(address)+ end+ elsif new_address(address_params).valid?+ address.destroy++ if new_address.user.present?+ assign_to_user_as_default(+ user: new_address.user,+ address_id: new_address.id,+ default_billing: address.user_default_billing? || default_billing,+ default_shipping: address.user_default_shipping? || default_shipping+ )+ end++ if order.present?+ order.ship_address = new_address if order.ship_address_id == address.id+ order.bill_address = new_address if order.bill_address_id == address.id+ order.state = 'address'+ order.saveend++ success(new_address)+ else+ failure(new_address)endendprivate+ def prepare_address_params!(address, address_params)+ address_params[:user_id] = address&.user_id+ address_params[:country_id] ||= address.country_id+ address_params = fill_country_and_state_ids(address_params)+ address_params.transform_values!(&:presence)+ end++ def defaults_changed?(address, default_billing, default_shipping)+ user = address.user++ user.present? && (+ (default_billing.present? && user.bill_address != address) ||+ (default_shipping.present? && user.ship_address != address)+ )+ end++ def assign_to_user_as_default(user:, address_id:, default_billing: true, default_shipping: true)+ attributes_to_update = {+ ship_address_id: (address_id if default_shipping),+ bill_address_id: (address_id if default_billing),+ }.compact_blank++ user.update_columns(**attributes_to_update, updated_at: Time.current) if attributes_to_update.present?+ end+def new_address(address_params = {})- @new_address ||= ::Spree::Address.find_or_create_by(address_params.except(:id, :updated_at, :created_at))+ @new_address ||= ::Spree::Address.not_deleted.find_or_create_by(address_params.except(:id, :updated_at, :created_at))endendenddiff --git a/core/spec/services/spree/addresses/update_spec.rb b/core/spec/services/spree/addresses/update_spec.rbnew file mode 100644index 0000000000..7065eceba8--- /dev/null+++ b/core/spec/services/spree/addresses/update_spec.rb@@ -0,0 +1,260 @@+require 'spec_helper'++RSpec.describe Spree::Addresses::Update do+ subject { described_class }++ let(:user) { create(:user) }+ let(:country) { create(:country) }+ let(:state) { create(:state, country: country) }+ let!(:address) { create(:address, user: user) }+ let(:result) { subject.call(address: address, address_params: new_address_params, order: order) }+ let(:value) { result.value }+ let(:order) { nil }++ describe '#call' do+ context 'with valid params' do+ let(:new_address_params) do+ {+ firstname: FFaker::Name.first_name,+ lastname: FFaker::Name.last_name,+ address1: FFaker::Address.street_address,+ city: FFaker::Address.city,+ phone: FFaker::PhoneNumber.phone_number,+ zipcode: FFaker::AddressUS.zip_code,+ state_name: state.name,+ country_iso: country.iso+ }+ end++ shared_examples 'updating with same params' do+ context 'when params are the same' do+ before { result }++ it 'does not update address' do+ expect { subject.call(address: address, address_params: new_address_params, order: order) }.not_to change { address.reload }+ end++ it 'does not create new address' do+ expect { subject.call(address: address, address_params: new_address_params, order: order) }.not_to change { Spree::Address.count }+ end++ it 'returns success' do+ expect(subject.call(address: address, address_params: new_address_params, order: order)).to be_success+ end++ it 'does not update address nor create when attribute changed from nil to blank string' do+ result.value.update(address2: nil)++ new_address_params[:address2] = ''+ expect { subject.call(address: address, address_params: new_address_params, order: order) }.not_to change { address.reload }+ expect { subject.call(address: address, address_params: new_address_params, order: order) }.not_to change { Spree::Address.count }+ end+ end++ context 'when user only sets the address as default shipping' do+ let(:result) { subject.call(address: address, address_params: {}, order: order, default_shipping: true) }+ let!(:previous_address) { create(:address, user: user) }++ before { user.reload.update(ship_address: previous_address) }++ it 'updates user\'s ship address' do+ expect(user.ship_address_id).to eq(previous_address.id)+ result+ expect(user.reload.ship_address_id).to eq(value.id)+ end+ end++ context 'when user only sets the address as default billing' do+ let(:result) { subject.call(address: address, address_params: {}, order: order, default_billing: true) }+ let!(:previous_address) { create(:address, user: user) }++ before { user.reload.update(bill_address: previous_address) }++ it 'updates user\'s bill address' do+ expect(user.bill_address_id).to eq(previous_address.id)+ result+ expect(user.reload.bill_address_id).to eq(value.id)+ end+ end+ end++ context 'when address is editable' do+ it 'updates address' do+ expect { result }.not_to change(Spree::Address, :count)+ expect(result).to be_success+ expect(value).to have_attributes(new_address_params)+ expect(value.country).to eq(country)+ expect(value.state).to eq(state)+ end++ context 'when user sets address as default shipping' do+ let(:result) { subject.call(address: address, address_params: new_address_params, order: order, default_shipping: true) }+ let!(:previous_address) { create(:address, user: user) }++ before { user.reload.update(ship_address: previous_address) }++ it 'updates user\'s ship address' do+ expect(user.ship_address_id).to eq(previous_address.id)+ result+ expect(user.reload.ship_address_id).to eq(value.id)+ end+ end++ context 'when user sets address as default billing' do+ let(:result) { subject.call(address: address, address_params: new_address_params, order: order, default_billing: true) }+ let!(:previous_address) { create(:address, user: user) }++ before { user.reload.update(bill_address: previous_address) }++ it 'updates user\'s bill address' do+ expect(user.bill_address_id).to eq(previous_address.id)+ result+ expect(user.reload.bill_address_id).to eq(value.id)+ end+ end++ context 'when order is passed' do+ let(:order) { create(:order, user: user, state: 'delivery', ship_address: address, bill_address: address) }++ it 'updates order to address state' do+ expect { result }.to change { order.reload.state }.from('delivery').to('address')+ end+ end++ it_behaves_like 'updating with same params'+ end++ context 'when address in uneditable' do+ let!(:completed_order) { create(:completed_order_with_totals, user: user, ship_address: address, bill_address: address) }++ context 'when there have been created same address with new params' do+ let!(:same_address) { user.addresses.create(new_address_params.except(:country_iso).merge(country: country, state: state)) }++ context 'when is not deleted' do+ it 'takes that address' do+ expect(result.value.id).to eq same_address.id+ end+ end++ context 'when its soft deleted' do+ before { same_address.update!(deleted_at: Time.current) }++ it 'creates new address' do+ expect { result }.to change(Spree::Address, :count).by 1+ expect { result }.not_to change { same_address.reload }+ end+ end+ end++ context 'when there is no such existing address with given params' do+ it 'creates new address and soft-deletes the previous one' do+ expect { result }.to change(Spree::Address.unscoped, :count).by 1+ expect(result).to be_success+ expect(value).to have_attributes(new_address_params)+ expect(value.id).not_to eq(address.id)+ expect(value.country).to eq(country)+ expect(value.state).to eq(state)+ expect(value.user).to eq(user)+ expect(address.deleted_at).not_to be_nil+ end++ context 'when the old address was set as default billing' do+ let(:other_address) { create(:address, user: user) }++ before { user.update!(bill_address: address, ship_address: other_address) }++ it 'sets the new address as default billing' do+ expect(result).to be_success++ expect(address.deleted_at).to be_present++ expect(user.reload.bill_address).to eq(value)+ expect(user.ship_address).to eq(other_address)+ end+ end++ context 'when the old address was set as default shipping' do+ let(:other_address) { create(:address, user: user) }++ before { user.update!(bill_address: other_address, ship_address: address) }++ it 'sets the new address as default shipping' do+ expect(result).to be_success++ expect(address.deleted_at).to be_present++ expect(user.reload.ship_address).to eq(value)+ expect(user.bill_address).to eq(other_address)+ end+ end+ end++ context 'when user sets address as default shipping' do+ let(:result) { subject.call(address: address, address_params: new_address_params, order: order, default_shipping: true) }++ before { user.reload.update(ship_address: address) }++ it 'updates user\'s ship address' do+ expect(user.ship_address_id).to eq(address.id)+ result+ expect(address.id).not_to eq(value.id)+ expect(user.reload.ship_address_id).to eq(value.id)+ end+ end++ context 'when user sets address as default billing' do+ let(:result) { subject.call(address: address, address_params: new_address_params, order: order, default_billing: true) }++ before { user.reload.update(bill_address: address) }++ it 'updates user\'s bill address' do+ expect(user.bill_address_id).to eq(address.id)+ result+ expect(address.id).not_to eq(value.id)+ expect(user.reload.bill_address_id).to eq(value.id)+ end+ end++ context 'when order with deleted address is passed' do+ let(:order) { create(:order, user: user, state: 'delivery', ship_address: address, bill_address: address) }++ it 'updates order to address state' do+ expect { result }.to change { order.reload.state }.from('delivery').to('address')+ end++ it 'updates order ship address' do+ result+ expect(order.reload.ship_address_id).to eq(value.id)+ end++ it 'updates order bill address' do+ result+ expect(order.reload.bill_address_id).to eq(value.id)+ end+ end++ it_behaves_like 'updating with same params'+ end+ end++ context 'with invalid params' do+ let(:new_address_params) do+ {+ phone: '',+ zipcode: ''+ }+ end++ it 'returns errors' do+ expect { result }.not_to change(Spree::Address, :count)+ expect(result).to be_failure++ messages = result.error.value.messages+ expect(messages).to eq(+ phone: ["can't be blank"],+ zipcode: ["can't be blank"]+ )+ end+ end+ end+end