spree_core 4.1.1 → 4.5.0

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/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

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

@@ -0,0 +1,66 @@
+module Spree
+  module Payments
+    class Create
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, params: {})
+        ApplicationRecord.transaction do
+          run :prepare_payment_attributes
+          run :find_or_create_payment_source
+          run :save_payment
+        end
+      end
+
+      protected
+
+      def prepare_payment_attributes(order:, params:)
+        payment_method = order.available_payment_methods.find { |pm| pm.id.to_s == params[:payment_method_id]&.to_s }
+
+        payment_attributes = {
+          amount: params[:amount] || order.order_total_after_store_credit,
+          payment_method: payment_method
+        }
+
+        return failure(nil, :payment_method_not_found) if payment_method.blank?
+
+        success(order: order, params: params, payment_attributes: payment_attributes)
+      end
+
+      def find_or_create_payment_source(order:, params:, payment_attributes:)
+        payment_method = payment_attributes[:payment_method]
+
+        if payment_method&.source_required?
+          if order.user.present? && params[:source_id].present?
+            source = payment_method.payment_source_class.find_by(id: params[:source_id], user: order.user)
+
+            return failure(nil, :source_not_found) if source.nil?
+          else
+            result = Wallet::CreatePaymentSource.call(
+              payment_method: payment_method,
+              params: params.delete(:source_attributes),
+              user: order.user
+            )
+
+            return failure(nil, result.error.value) if result.failure?
+
+            source = result.value
+          end
+
+          payment_attributes[:source] = source
+        end
+
+        success(order: order, payment_attributes: payment_attributes)
+      end
+
+      def save_payment(order:, payment_attributes:)
+        payment = order.payments.new(payment_attributes)
+
+        if payment.save
+          success(payment)
+        else
+          failure(payment)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/seeds/all.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Seeds
+    class All
+      prepend Spree::ServiceModule::Base
+
+      def call
+        # GEO
+        Countries.call
+        States.call
+        Zones.call
+
+        # user roles
+        Roles.call
+
+        # additional data
+        DefaultReimbursementTypes.call
+        ShippingCategories.call
+        StoreCreditCategories.call
+
+        # store & stock location
+        Stores.call
+        StockLocations.call
+      end
+    end
+  end
+end

data/app/services/spree/seeds/countries.rb

@@ -0,0 +1,50 @@
+require 'carmen'
+
+module Spree
+  module Seeds
+    class Countries
+      prepend Spree::ServiceModule::Base
+
+      EXCLUDED_COUNTRIES = ['AQ', 'AX', 'GS', 'UM', 'HM', 'IO', 'EH', 'BV', 'TF'].freeze
+
+      def call
+        ApplicationRecord.transaction do
+          if Rails::VERSION::MAJOR >= 6
+            new_countries = Carmen::Country.all.map do |country|
+              # Skip the creation of some territories, uninhabited islands and the Antarctic.
+              next if EXCLUDED_COUNTRIES.include?(country.alpha_2_code)
+
+              Hash[
+                'name': country.name,
+                'iso3': country.alpha_3_code,
+                'iso': country.alpha_2_code,
+                'iso_name': country.name.upcase,
+                'numcode': country.numeric_code,
+              ]
+            end.compact.uniq
+            Spree::Country.insert_all(new_countries)
+          else
+            Carmen::Country.all.each do |country|
+              # Skip the creation of some territories, uninhabited islands and the Antarctic.
+              next if EXCLUDED_COUNTRIES.include?(country.alpha_2_code)
+
+              Spree::Country.where(
+                name: country.name,
+                iso3: country.alpha_3_code,
+                iso: country.alpha_2_code,
+                iso_name: country.name.upcase,
+                numcode: country.numeric_code
+              ).first_or_create!
+            end
+          end
+
+          # Find countries that do not use postal codes (by iso) and set 'zipcode_required' to false for them.
+          Spree::Country.where(iso: Spree::Address::NO_ZIPCODE_ISO_CODES).update_all(zipcode_required: false)
+
+          # Find all countries that require a state (province) at checkout and set 'states_required' to true.
+          Spree::Country.where(iso: Spree::Address::STATES_REQUIRED).update_all(states_required: true)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/seeds/default_reimbursement_types.rb

@@ -0,0 +1,12 @@
+module Spree
+  module Seeds
+    class DefaultReimbursementTypes
+      prepend Spree::ServiceModule::Base
+
+      def call
+        # FIXME: we should use translations here
+        Spree::RefundReason.find_or_create_by!(name: 'Return processing', mutable: false)
+      end
+    end
+  end
+end

data/app/services/spree/seeds/roles.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Seeds
+    class Roles
+      prepend Spree::ServiceModule::Base
+
+      def call
+        Spree::Role.where(name: 'admin').first_or_create!
+      end
+    end
+  end
+end

data/app/services/spree/seeds/shipping_categories.rb

@@ -0,0 +1,12 @@
+module Spree
+  module Seeds
+    class ShippingCategories
+      prepend Spree::ServiceModule::Base
+
+      def call
+        Spree::ShippingCategory.find_or_create_by!(name: I18n.t('spree.seed.shipping.categories.default'))
+        Spree::ShippingCategory.find_or_create_by!(name: I18n.t('spree.seed.shipping.categories.digital'))
+      end
+    end
+  end
+end

data/app/services/spree/seeds/states.rb

@@ -0,0 +1,72 @@
+require 'carmen'
+
+module Spree
+  module Seeds
+    class States
+      prepend Spree::ServiceModule::Base
+
+      EXCLUDED_US_STATES = ['UM', 'AS', 'MP', 'VI', 'PR', 'GU'].freeze
+      EXCLUDED_CN_STATES = ['HK', 'MO', 'TW'].freeze
+
+      def call
+        Spree::Country.where(states_required: true).each do |country|
+          carmen_country = Carmen::Country.named(country.name)
+          next unless carmen_country
+
+          carmen_country.subregions.each do |subregion|
+            if carmen_country.alpha_2_code == 'US'
+              # Produces 50 states, one postal district (Washington DC)
+              # and 3 APO's as you would expect to see on any good U.S. states list.
+              next if EXCLUDED_US_STATES.include?(subregion.code)
+
+              state_level(country, subregion)
+            elsif carmen_country.alpha_2_code == 'CA' || carmen_country.alpha_2_code == 'MX'
+              # Force Canada and Mexico to use state-level data import from Carmen Gem
+              # else we pull in a subset of provinces that are not common at checkout.
+              state_level(country, subregion)
+            elsif carmen_country.alpha_2_code == 'CN'
+              # Removes 3 "States" from that list that are also listed as Countries,
+              # Hong Kong, Taiwan and Macao
+              next if EXCLUDED_CN_STATES.include?(subregion.code)
+
+              state_level(country, subregion)
+            elsif subregion.subregions?
+              province_level(country, subregion)
+            else
+              state_level(country, subregion)
+            end
+          end
+        end
+      end
+
+      protected
+
+      def state_level(country, subregion)
+        country.states.where(
+          name: subregion.name,
+          abbr: subregion.code
+        ).first_or_create!
+      end
+
+      def province_level(country, subregion)
+        if Rails::VERSION::MAJOR >= 6
+          new_states = subregion.subregions.map do |province|
+            Hash[
+              name: province.name,
+              abbr: province.code,
+              country_id: country.id
+            ]
+          end.compact.uniq
+          Spree::State.insert_all(new_states)
+        else
+          subregion.subregions.each do |province|
+            country.states.where(
+              name: province.name,
+              abbr: province.code
+            ).first_or_create!
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/spree/seeds/stock_locations.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Seeds
+    class StockLocations
+      prepend Spree::ServiceModule::Base
+
+      def call
+        country = Spree::Store.default.default_country
+        Spree::StockLocation.find_or_create_by!(
+          name: 'default',
+          propagate_all_variants: false,
+          country: country,
+          active: true,
+          default: true
+        )
+      end
+    end
+  end
+end

data/app/services/spree/seeds/store_credit_categories.rb

@@ -0,0 +1,14 @@
+module Spree
+  module Seeds
+    class StoreCreditCategories
+      prepend Spree::ServiceModule::Base
+
+      def call
+        # FIXME: we should use translations here
+        Spree::StoreCreditCategory.find_or_create_by!(name: 'Default')
+        Spree::StoreCreditCategory.find_or_create_by!(name: 'Non-expiring')
+        Spree::StoreCreditCategory.find_or_create_by!(name: 'Expiring')
+      end
+    end
+  end
+end

data/app/services/spree/seeds/stores.rb

@@ -0,0 +1,31 @@
+module Spree
+  module Seeds
+    class Stores
+      prepend Spree::ServiceModule::Base
+
+      def call
+        default_store = Spree::Store.default
+
+        if default_store.persisted?
+          default_store.update!(default_country_id: Spree::Config[:default_country_id])
+        else
+          Spree::Store.new do |s|
+            s.name                         = 'Spree Demo Site'
+            s.code                         = 'spree'
+            s.url                          = Rails.application.routes.default_url_options[:host] || 'demo.spreecommerce.org'
+            s.mail_from_address            = 'no-reply@example.com'
+            s.customer_support_email       = 'support@example.com'
+            s.default_currency             = 'USD'
+            s.default_country_id           = Spree::Config[:default_country_id]
+            s.default_locale               = I18n.locale
+            s.seo_title                    = 'Spree Commerce Demo Shop'
+            s.meta_description             = 'This is the new Spree UX DEMO | OVERVIEW: http://bit.ly/new-spree-ux | DOCS: http://bit.ly/spree-ux-customization-docs | CONTACT: https://spreecommerce.org/contact/'
+            s.facebook                     = 'spreecommerce'
+            s.twitter                      = 'spreecommerce'
+            s.instagram                    = 'spreecommerce'
+          end.save!
+        end
+      end
+    end
+  end
+end

data/app/services/spree/seeds/zones.rb

@@ -0,0 +1,39 @@
+module Spree
+  module Seeds
+    class Zones
+      prepend Spree::ServiceModule::Base
+
+      def call
+        eu_vat = Spree::Zone.where(name: 'EU_VAT', description: 'Countries that make up the EU VAT zone.', kind: 'country').first_or_create!
+        uk_vat = Spree::Zone.where(name: 'UK_VAT', kind: 'country').first_or_create!
+        north_america = Spree::Zone.where(name: 'North America', description: 'USA + Canada', kind: 'country').first_or_create!
+        south_america = Spree::Zone.where(name: 'South America', description: 'South America', kind: 'country').first_or_create!
+        middle_east = Spree::Zone.where(name: 'Middle East', description: 'Middle East', kind: 'country').first_or_create!
+        asia = Spree::Zone.where(name: 'Asia', description: 'Asia', kind: 'country').first_or_create!
+
+        %w(PL FI PT RO DE FR SK HU SI IE AT ES IT BE SE LV BG LT CY LU MT DK NL EE HR CZ GR).each do |name|
+          eu_vat.zone_members.where(zoneable: Spree::Country.find_by!(iso: name)).first_or_create!
+        end
+
+        uk_vat.zone_members.where(zoneable: Spree::Country.find_by(iso: 'GB')).first_or_create!
+
+        %w(US CA).each do |name|
+          north_america.zone_members.where(zoneable: Spree::Country.find_by!(iso: name)).first_or_create!
+        end
+
+        %w(BH CY EG IR IQ IL JO KW LB OM QA SA SY TR AE YE).each do |name|
+          middle_east.zone_members.where(zoneable: Spree::Country.find_by!(iso: name)).first_or_create!
+        end
+
+        %w(AF AM AZ BH BD BT BN KH CN CX CC GE HK IN ID IR IQ IL JP JO KZ KW KG LA LB MO MY MV MN MM NP
+          KP OM PK PS PH QA SA SG KR LK SY TW TJ TH TR TM AE UZ VN YE).each do |name|
+          asia.zone_members.where(zoneable: Spree::Country.find_by!(iso: name)).first_or_create!
+        end
+
+        %w(AR BO BR CL CO EC FK GF GY PY PE SR UY VE).each do |name|
+          south_america.zone_members.where(zoneable: Spree::Country.find_by!(iso: name)).first_or_create!
+        end
+      end
+    end
+  end
+end

data/app/services/spree/shipments/add_item.rb

@@ -0,0 +1,32 @@
+# adds item to an existing shipment
+# if this variant is already added to the cart it will increase the quantity
+# if not it will create new line item
+module Spree
+  module Shipments
+    class AddItem
+      prepend Spree::ServiceModule::Base
+      include Helper
+
+      def call(shipment:, variant_id:, quantity: nil)
+        ActiveRecord::Base.transaction do
+          run :prepare_arguments
+          run :add_or_update_line_item
+        end
+      end
+
+      protected
+
+      def prepare_arguments(shipment:, variant_id:, quantity: nil)
+        order = shipment.order
+        store = order.store
+
+        variant = store.variants.find_by(id: variant_id)
+        return failure(nil, :variant_not_found) if variant.nil?
+
+        quantity = quantity&.to_i || 1
+
+        success(order: order, shipment: shipment, variant: variant, quantity: quantity)
+      end
+    end
+  end
+end

data/app/services/spree/shipments/change_state.rb

@@ -0,0 +1,14 @@
+module Spree
+  module Shipments
+    class ChangeState
+      prepend Spree::ServiceModule::Base
+
+      def call(shipment:, state:)
+        shipment.send("#{state}!")
+        success(shipment.reload)
+      rescue ActiveRecord::Rollback, ActiveRecord::RecordInvalid, StateMachines::InvalidTransition
+        failure(shipment)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# creates new shipment record
+# if selected item (variant) is already added to order it will update line item
+# if not - it will create new line item record
+module Spree
+  module Shipments
+    class Create
+      prepend Spree::ServiceModule::Base
+      include Helper
+
+      def call(store:, shipment_attributes:)
+        ActiveRecord::Base.transaction do
+          run :prepare_arguments
+          run :create_shipment
+          run :add_or_update_line_item
+        end
+      end
+
+      protected
+
+      def prepare_arguments(store:, shipment_attributes:)
+        order_id_or_number = shipment_attributes[:order_id]
+        order = store.orders.find_by(number: order_id_or_number) || store.orders.find_by(id: order_id_or_number)
+
+        return failure(nil, :order_not_found) if order.nil?
+
+        variant = store.variants.find_by(id: shipment_attributes[:variant_id])
+        return failure(nil, :variant_not_found) if variant.nil?
+
+        stock_location = Spree::StockLocation.find_by(id: shipment_attributes[:stock_location_id])
+        return failure(nil, :stock_location_not_found) if stock_location.nil?
+
+        quantity = shipment_attributes[:quantity]&.to_i || 1
+
+        success(order: order, stock_location: stock_location, variant: variant, quantity: quantity)
+      end
+
+      def create_shipment(order:, stock_location:, variant:, quantity:)
+        shipment = order.shipments.create(
+          order_id: order.id,
+          stock_location_id: stock_location.id
+        )
+        return failure(shipment) unless shipment.persisted?
+
+        success(order: order, variant: variant, quantity: quantity, shipment: shipment)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Spree
+  module Shipments
+    module Helper
+      def add_or_update_line_item(order:, variant:, quantity:, shipment:)
+        result = add_item_service.call(order: order, variant: variant, quantity: quantity, options: { shipment: shipment })
+
+        if result.success?
+          success(shipment.reload)
+        else
+          failure(result.value, result.error)
+        end
+      end
+
+      def add_item_service
+        Spree::Dependencies.cart_add_item_service.constantize
+      end
+
+      def remove_item_service
+        Spree::Dependencies.cart_remove_item_service.constantize
+      end
+    end
+  end
+end