spree_core 4.0.0 → 4.6.0

data/app/services/spree/cart/empty.rb

@@ -0,0 +1,36 @@
+module Spree
+  module Cart
+    class Empty
+      prepend Spree::ServiceModule::Base
+
+      def call(order:)
+        run :check_if_can_be_empty
+        run :empty_order
+      end
+
+      private
+
+      def check_if_can_be_empty(order:)
+        return failure(Spree.t(:cannot_empty)) if order.nil? || order.completed?
+
+        success(order: order)
+      end
+
+      def empty_order(order:)
+        ActiveRecord::Base.transaction do
+          order.line_items.destroy_all
+          order.updater.update_item_count
+          order.adjustments.destroy_all
+          order.shipments.destroy_all
+          order.state_changes.destroy_all
+          order.order_promotions.destroy_all
+          order.update_totals
+          order.persist_totals
+          order.restart_checkout_flow
+
+          success(order)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/cart/estimate_shipping_rates.rb

@@ -4,7 +4,7 @@ module Spree
       prepend Spree::ServiceModule::Base
 
       def call(order:, country_iso: nil)
-        country_id = country_id(country_iso)
+        country_id = country_id(order.store, country_iso)
         dummy_order = generate_dummy_order(order, country_id)
 
         packages = ::Spree::Stock::Coordinator.new(dummy_order).packages
@@ -20,11 +20,11 @@ module Spree
 
       private
 
-      def country_id(country_iso)
+      def country_id(store, country_iso)
         if country_iso.present?
           ::Spree::Country.by_iso(country_iso)&.id
         else
-          ::Spree::Country.default.id
+          store.default_country_id
         end
       end
 

data/app/services/spree/cart/remove_line_item.rb

@@ -11,6 +11,7 @@ module Spree
                                                                             line_item: line_item,
                                                                             options: options)
         end
+        order.reload
         success(line_item)
       end
     end

data/app/services/spree/cart/update.rb

@@ -25,10 +25,10 @@ module Spree
       def filter_order_items(order, params)
         return params if params[:line_items_attributes].nil? || params[:line_items_attributes][:id]
 
-        line_item_ids = order.line_items.pluck(:id)
+        line_item_ids = order.line_item_ids.map(&:to_s)
 
         params[:line_items_attributes].each_pair do |id, value|
-          params[:line_items_attributes].delete(id) unless line_item_ids.include?(value[:id].to_i) || value[:variant_id].present?
+          params[:line_items_attributes].delete(id) unless line_item_ids.include?(value[:id].to_s) || value[:variant_id].present?
         end
         params
       end

data/app/services/spree/checkout/add_store_credit.rb

@@ -9,9 +9,12 @@ module Spree
 
         remaining_total = amount ? [amount, @order.outstanding_balance].min : @order.outstanding_balance
 
+        return failure(nil, Spree.t(:error_user_does_not_have_any_store_credits)) unless @order.user&.store_credits&.any?
+
         ApplicationRecord.transaction do
           @order.payments.store_credits.where(state: :checkout).map(&:invalidate!)
-          apply_store_credits(remaining_total) if @order.user&.store_credits&.any?
+
+          apply_store_credits(remaining_total)
         end
 
         @order.reload.payments.store_credits.valid.any? ? success(@order) : failure(@order)
@@ -23,7 +26,7 @@ module Spree
         payment_method = Spree::PaymentMethod::StoreCredit.available.first
         raise 'Store credit payment method could not be found' unless payment_method
 
-        @order.user.store_credits.order_by_priority.each do |credit|
+        @order.user.store_credits.for_store(@order.store).order_by_priority.each do |credit|
           break if remaining_total.zero?
           next if credit.amount_remaining.zero?
 

data/app/services/spree/checkout/get_shipping_rates.rb

@@ -7,9 +7,7 @@ module Spree
         run :reload_order
         run :ensure_shipping_address
         run :ensure_line_items_present
-        run :move_order_to_delivery_state
-        run :generate_shipping_rates
-        run :return_shipments
+        run :generate_or_return_shipping_rates
       end
 
       private
@@ -31,6 +29,11 @@ module Spree
         success(order: order)
       end
 
+      def generate_or_return_shipping_rates(order:)
+        generate_shipping_rates(order: order) if order.shipments.empty?
+        return_shipments(order: order)
+      end
+
       def generate_shipping_rates(order:)
         ApplicationRecord.transaction do
           order.create_proposed_shipments
@@ -42,13 +45,7 @@ module Spree
       end
 
       def return_shipments(order:)
-        success(order.shipments.includes([shipping_rates: :shipping_method]))
-      end
-
-      def move_order_to_delivery_state(order:)
-        Spree::Dependencies.checkout_next_service.constantize.call(order: order) until order.state == 'delivery'
-
-        success(order: order)
+        success(order.reload.shipments.includes([shipping_rates: :shipping_method]))
       end
     end
   end

data/app/services/spree/checkout/select_shipping_method.rb

@@ -0,0 +1,49 @@
+module Spree
+  module Checkout
+    class SelectShippingMethod
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, params:)
+        if params[:shipment_id].present?
+          shipment = order.shipments.valid.find_by(id: params[:shipment_id])
+          return failure(:shipment_not_found) if shipment.nil?
+        end
+
+        shipping_method = Spree::ShippingMethod.find_by(id: params[:shipping_method_id])
+        return failure(:shipping_method_not_found) if shipping_method.nil?
+
+        # single shipment passed
+        if shipment.present?
+          result = set_shipping_rate_based_on_method(shipment: shipment, shipping_method: shipping_method)
+
+          return failure(result.value, result.error) unless result.success?
+        else
+          # set shipping method for all shipments
+          order.shipments.valid.each do |s|
+            result = set_shipping_rate_based_on_method(shipment: s, shipping_method: shipping_method)
+
+            return failure(result.value, result.error) unless result.success?
+          end
+        end
+
+        success(order)
+      end
+
+      def set_shipping_rate_based_on_method(shipment:, shipping_method:)
+        selected_shipping_rate = shipment.shipping_rates.find_by(shipping_method: shipping_method)
+
+        if selected_shipping_rate.nil?
+          return failure(
+            :selected_shipping_method_not_found,
+            "Couldn't find shipping rates for Shipping Method with ID = #{shipping_method.id} and Shipment with ID = #{shipment.id}"
+          )
+        end
+
+        shipment.selected_shipping_rate_id = selected_shipping_rate.id
+        shipment.update_amounts
+
+        success(shipment)
+      end
+    end
+  end
+end

data/app/services/spree/checkout/update.rb

@@ -2,10 +2,15 @@ module Spree
   module Checkout
     class Update
       prepend Spree::ServiceModule::Base
+      include Spree::Addresses::Helper
 
       def call(order:, params:, permitted_attributes:, request_env:)
-        params = replace_country_iso_with_id(params, 'ship') if address_with_country_iso_present?(params, 'ship')
-        params = replace_country_iso_with_id(params, 'bill') if address_with_country_iso_present?(params, 'bill')
+        ship_changed = address_with_country_iso_present?(params, 'ship')
+        bill_changed = address_with_country_iso_present?(params, 'bill')
+        params[:order][:ship_address_attributes] = replace_country_iso_with_id(params[:order][:ship_address_attributes]) if ship_changed
+        params[:order][:bill_address_attributes] = replace_country_iso_with_id(params[:order][:bill_address_attributes]) if bill_changed
+        order.state = 'address' if (ship_changed || bill_changed) && order.has_checkout_step?('address')
+        order.state = 'delivery' if selected_shipping_rate_present?(params) && order.has_checkout_step?('delivery')
         return success(order) if order.update_from_params(params, permitted_attributes, request_env)
 
         failure(order)
@@ -20,12 +25,11 @@ module Spree
         true
       end
 
-      def replace_country_iso_with_id(params, address_kind = 'ship')
-        country_id = Spree::Country.by_iso(params[:order]["#{address_kind}_address_attributes"].fetch(:country_iso))&.id
+      def selected_shipping_rate_present?(params)
+        shipments_attributes = params.dig(:order, :shipments_attributes)
+        return false unless shipments_attributes
 
-        params[:order]["#{address_kind}_address_attributes"]['country_id'] = country_id
-        params[:order]["#{address_kind}_address_attributes"].delete(:country_iso)
-        params
+        shipments_attributes.any? { |s| s.dig(:selected_shipping_rate_id) }
       end
     end
   end

data/app/services/spree/classifications/reposition.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Classifications
+    class Reposition
+      prepend Spree::ServiceModule::Base
+
+      def call(classification:, position:)
+        if position.is_a?(String) && !position.match(/^\d+$/)
+          return failure(nil, I18n.t('errors.messages.not_a_number'))
+        end
+
+        # Because position we get back is 0-indexed.
+        # acts_as_list is 1-indexed.
+        classification.insert_at(position.to_i + 1)
+        success(classification)
+      end
+    end
+  end
+end

data/app/services/spree/compare_line_items.rb

@@ -1,9 +1,11 @@
 # This class should be refactored
 module Spree
   class CompareLineItems
-    prepend Spree::ServiceModule:: Base
+    prepend Spree::ServiceModule::Base
+
+    def call(order:, line_item:, options: {}, comparison_hooks: nil)
+      comparison_hooks ||= Rails.application.config.spree.line_item_comparison_hooks
 
-    def call(order:, line_item:, options: {}, comparison_hooks: Rails.application.config.spree.line_item_comparison_hooks)
       legacy_part = comparison_hooks.all? do |hook|
         order.send(hook, line_item, options)
       end

data/app/services/spree/credit_cards/destroy.rb

@@ -0,0 +1,41 @@
+module Spree
+  module CreditCards
+    class Destroy
+      prepend Spree::ServiceModule::Base
+
+      def call(card:)
+        ApplicationRecord.transaction do
+          run :invalidate_payments
+          run :void_payments
+          run :destroy
+        end
+      end
+
+      protected
+
+      def invalidate_payments(card:)
+        payment_scope(card).checkout.each(&:invalidate!)
+
+        success(card: card)
+      end
+
+      def void_payments(card:)
+        payment_scope(card).where.not(state: :checkout).each(&:void!)
+
+        success(card: card)
+      end
+
+      def destroy(card:)
+        if card.destroy
+          success(card: card)
+        else
+          failure(card.errors.full_messages.to_sentance)
+        end
+      end
+
+      def payment_scope(card)
+        card.payments.valid.joins(:order).merge(Spree::Order.incomplete)
+      end
+    end
+  end
+end

data/app/services/spree/data_feeds/google/optional_attributes.rb

@@ -0,0 +1,23 @@
+module Spree
+  module DataFeeds
+    module Google
+      class OptionalAttributes
+        prepend Spree::ServiceModule::Base
+
+        def call(input)
+          information = {}
+
+          input[:product].property_ids.each do |key|
+            name = Spree::Property.find(key)&.name
+            value = input[:product].property(name)
+            unless value.nil?
+              information[name] = value
+            end
+          end
+
+          success(information: information)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/data_feeds/google/optional_sub_attributes.rb

@@ -0,0 +1,21 @@
+module Spree
+  module DataFeeds
+    module Google
+      class OptionalSubAttributes
+        prepend Spree::ServiceModule::Base
+
+        def call(input)
+          information = {}
+
+          # This is a place where you can put attributes that have sub-attributes, example for shipping:
+          #
+          # information['shipping'] = {}
+          # information['shipping']['price'] = calculate_shipping(input[:product])
+          # information['shipping']['country'] = input[:store].default_country
+
+          success(information: information)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/data_feeds/google/products_list.rb

@@ -0,0 +1,14 @@
+module Spree
+  module DataFeeds
+    module Google
+      class ProductsList
+        prepend Spree::ServiceModule::Base
+
+        def call(store)
+          products = store.products.active
+          success(products: products)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/data_feeds/google/required_attributes.rb

@@ -0,0 +1,67 @@
+module Spree
+  module DataFeeds
+    module Google
+      class RequiredAttributes
+        prepend Spree::ServiceModule::Base
+
+        def call(input)
+          information = {}
+
+          return failure(nil, error: 'No image link') if get_image_link(input[:variant], input[:product]).nil?
+
+          information['id'] = input[:variant].id
+          information['title'] = format_title(input[:product], input[:variant])
+          information['description'] = get_description(input[:product], input[:variant])
+          information['link'] = "#{input[:store].url}/#{input[:product].slug}"
+          information['image_link'] = get_image_link(input[:variant], input[:product])
+          information['price'] = format_price(input[:variant])
+          information['availability'] = get_availability(input[:product])
+          information['availability_date'] = input[:product].available_on&.xmlschema unless input[:product].available_on.nil?
+
+          success(information: information)
+        end
+
+        private
+
+        def format_title(product, variant)
+          # Title of a variant is created by joining title of a product and variant's option_values, as they are
+          # what differentiates it from other variants.
+          title = product.name
+          variant.option_values.find_each do |option_value|
+            title << " - #{option_value.name}"
+          end
+          title
+        end
+
+        def get_description(product, variant)
+          return product.description unless product.description.nil?
+
+          format_title(product, variant)
+        end
+
+        def get_image_link(variant, product)
+          # try getting image from variant
+          img = variant.images.first&.plp_url
+
+          # if no image specified for variant try getting product image
+          if img.nil?
+            img = product.images.first&.plp_url
+          end
+
+          img
+        end
+
+        def format_price(variant)
+          "#{variant.price} #{variant.cost_currency}"
+        end
+
+        def get_availability(product)
+          return 'in stock' if product.available? && product.available_on&.past?
+          return 'backorder' if product.backorderable? && product.backordered? && product.available_on&.future?
+
+          'out of stock'
+        end
+      end
+    end
+  end
+end

data/app/services/spree/data_feeds/google/rss.rb

@@ -0,0 +1,107 @@
+require 'nokogiri'
+
+module Spree
+  module DataFeeds
+    module Google
+      class Rss
+        prepend Spree::ServiceModule::Base
+
+        def call(settings)
+          @settings = settings
+
+          return failure(store, error: "Store with id: #{settings.store_id} does not exist.") if store.nil?
+
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.rss('xmlns:g' => 'http://base.google.com/ns/1.0', 'version' => '2.0') do
+              xml.channel do
+                add_store_information_to_xml(xml)
+                result = products_list.call(store)
+                if result.success?
+                  result.value[:products].find_each do |product|
+                    product.variants.active.find_each do |variant|
+                      add_variant_information_to_xml(xml, product, variant)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          success(file: builder.to_xml)
+        end
+
+        private
+
+        def store
+          return @store if defined? @store
+
+          @store ||= Spree::Store.find_by(id: @settings.store_id)
+        end
+
+        def add_store_information_to_xml(xml)
+          xml.title store.name
+          xml.link store.url
+          xml.description store.meta_description
+        end
+
+        def add_variant_information_to_xml(xml, product, variant)
+          input = { product: product, variant: variant, settings: @settings, store: store }
+          result = required_attributes.call(input)
+
+          if result.success
+            xml.item do
+              result.value[:information]&.each do |key, value|
+                xml['g'].send(key, value)
+              end
+
+              add_optional_information(xml, product, variant)
+              add_optional_sub_attributes(xml, product, variant)
+            end
+          end
+        end
+
+        def add_optional_information(xml, product, variant)
+          input = { product: product, variant: variant, settings: @settings, store: store }
+          result = optional_attributes.call(input)
+          if result.success?
+            information = result.value[:information]
+            information.each do |key, value|
+              xml['g'].send(key, value)
+            end
+          end
+        end
+
+        def add_optional_sub_attributes(xml, product, variant)
+          input = { product: product, variant: variant, settings: @settings, store: store }
+          result = optional_sub_attributes.call(input)
+          if result.success?
+            information = result.value[:information]
+            information.each do |key, value|
+              xml['g'].send(key) do
+                value.each do |subkey, subvalue|
+                  xml['g'].send(subkey, subvalue)
+                end
+              end
+            end
+          end
+        end
+
+        def optional_attributes
+          Spree::Dependencies.data_feeds_google_optional_attributes_service.constantize.new
+        end
+
+        def required_attributes
+          Spree::Dependencies.data_feeds_google_required_attributes_service.constantize.new
+        end
+
+        def optional_sub_attributes
+          Spree::Dependencies.data_feeds_google_optional_sub_attributes_service.constantize.new
+        end
+
+        def products_list
+          Spree::Dependencies.data_feeds_google_products_list.constantize.new
+        end
+      end
+    end
+  end
+end

data/app/services/spree/line_items/create.rb

@@ -0,0 +1,20 @@
+module Spree
+  module LineItems
+    class Create
+      prepend Spree::ServiceModule::Base
+      include Helper
+
+      def call(order:, line_item_attributes: {}, options: {})
+        line_item = order.line_items.new(line_item_attributes)
+
+        ActiveRecord::Base.transaction do
+          return failure(line_item) unless line_item.save
+
+          recalculate_service.call(order: order, line_item: line_item, options: options)
+        end
+
+        success(line_item)
+      end
+    end
+  end
+end

data/app/services/spree/line_items/destroy.rb

@@ -0,0 +1,18 @@
+module Spree
+  module LineItems
+    class Destroy
+      prepend Spree::ServiceModule::Base
+      include Helper
+
+      def call(line_item:, options: {})
+        order = line_item.order
+
+        ActiveRecord::Base.transaction do
+          line_item.destroy!
+          recalculate_service.call(order: order, line_item: line_item, options: options)
+        end
+        success(line_item)
+      end
+    end
+  end
+end

data/app/services/spree/line_items/helper.rb

@@ -0,0 +1,11 @@
+module Spree
+  module LineItems
+    module Helper
+      protected
+
+      def recalculate_service
+        Spree::Dependencies.cart_recalculate_service.constantize
+      end
+    end
+  end
+end

data/app/services/spree/line_items/update.rb

@@ -0,0 +1,17 @@
+module Spree
+  module LineItems
+    class Update
+      prepend Spree::ServiceModule::Base
+      include Helper
+
+      def call(line_item:, line_item_attributes: {}, options: {})
+        ActiveRecord::Base.transaction do
+          return failure(line_item) unless line_item.update(line_item_attributes)
+
+          recalculate_service.call(order: line_item.order, line_item: line_item, options: options)
+        end
+        success(line_item)
+      end
+    end
+  end
+end

data/app/services/spree/orders/approve.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Orders
+    class Approve
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, approver: nil)
+        if approver.present?
+          order.approved_by(approver)
+        else
+          order.approve!
+        end
+        success(order.reload)
+      rescue ActiveRecord::Rollback, ActiveRecord::RecordInvalid, StateMachines::InvalidTransition
+        failure(order)
+      end
+    end
+  end
+end

data/app/services/spree/orders/cancel.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Orders
+    class Cancel
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, canceler: nil)
+        if canceler.present?
+          order.canceled_by(canceler)
+        else
+          order.cancel!
+        end
+        success(order.reload)
+      rescue ActiveRecord::Rollback, ActiveRecord::RecordInvalid, StateMachines::InvalidTransition
+        failure(order)
+      end
+    end
+  end
+end