spree_core 4.0.0 → 4.5.1

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

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

@@ -0,0 +1,55 @@
+# removes an item (variant) from shipment
+# quantity can be passed
+# if there is no quantity left for this item for this shipent, shipment itself will be removed
+module Spree
+  module Shipments
+    class RemoveItem
+      prepend Spree::ServiceModule::Base
+      include Helper
+
+      def call(shipment:, variant_id:, quantity: nil)
+        ActiveRecord::Base.transaction do
+          run :prepare_arguments
+          run :remove_item
+        end
+      end
+
+      protected
+
+      def prepare_arguments(shipment:, variant_id:, quantity: nil)
+        variant = Spree::Variant.find_by(id: variant_id)
+        return failure(nil, :variant_not_found) if variant.nil? || !shipment.include?(variant)
+
+        # if quantity isn't passed let's remove all added qty of this variant
+        quantity = quantity&.to_i || shipment.inventory_units_for(variant).sum(:quantity)
+
+        success(shipment: shipment, variant: variant, quantity: quantity)
+      end
+
+      # if the removed variant was the only one shipped via this shipment
+      # we need to remove the shipment itself
+      def remove_item(shipment:, variant:, quantity:)
+        result = remove_item_service.call(order: shipment.order,
+                                          variant: variant,
+                                          quantity: quantity,
+                                          options: { shipment: shipment })
+
+        if result.success?
+          line_item = result.value
+          line_item.destroy if line_item.quantity.zero?
+
+          # `OrderInventory#remove_from_shipment` is called in `remove_item_service`
+          # which will delete the shipment if all inventory units were removed
+          if shipment.inventory_units.any?
+            success(shipment)
+          else
+            shipment.destroy!
+            success(:shipment_deleted)
+          end
+        else
+          failure(result.value, result.error)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# Update Shipment and make sure Order states follow the shipment changes
+module Spree
+  module Shipments
+    class Update
+      prepend Spree::ServiceModule::Base
+
+      def call(shipment:, shipment_attributes: {})
+        ActiveRecord::Base.transaction do
+          return failure(shipment) unless shipment.update(shipment_attributes)
+
+          if shipment_attributes.key?(:selected_shipping_rate_id)
+            order = shipment.order
+
+            # Changing the selected Shipping Rate won't update the cost (for now)
+            # so we persist the Shipment#cost before calculating order shipment
+            # total and updating payment state (given a change in shipment cost
+            # might change the Order#payment_state)
+            shipment.update_amounts
+
+            order.updater.update_shipment_total
+            order.updater.update_payment_state
+
+            # Update shipment state only after order total is updated because it
+            # (via Order#paid?) affects the shipment state (YAY)
+            shipment.update_columns(
+              state: shipment.determine_state(order),
+              updated_at: Time.current
+            )
+
+            # And then it's time to update shipment states and finally persist
+            # order changes
+            order.updater.update_shipment_state
+            order.updater.persist_totals
+          end
+        end
+        success(shipment)
+      end
+    end
+  end
+end

data/app/services/spree/stock_locations/stock_items/create.rb

@@ -0,0 +1,31 @@
+module Spree
+  module StockLocations
+    module StockItems
+      class Create
+        prepend Spree::ServiceModule::Base
+
+        def call(stock_location:, variants_scope: Spree::Variant)
+          if Rails::VERSION::MAJOR >= 6
+            prepared_stock_items = variants_scope.ids.map do |variant_id|
+              Hash[
+                'stock_location_id', stock_location.id,
+                'variant_id', variant_id,
+                'backorderable', stock_location.backorderable_default,
+                'created_at', Time.current,
+                'updated_at', Time.current
+              ]
+            end
+            if prepared_stock_items.any?
+              stock_location.stock_items.insert_all(prepared_stock_items)
+              variants_scope.touch_all
+            end
+          else
+            variants_scope.find_each do |variant|
+              stock_location.propagate_variant(variant)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/spree/variants/remove_line_items.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Variants
+    class RemoveLineItems
+      prepend Spree::ServiceModule::Base
+
+      def call(variant:)
+        variant.line_items.joins(:order).where.not(spree_orders: { state: 'complete' }).find_each do |line_item|
+          Spree::Variants::RemoveLineItemJob.perform_later(line_item: line_item)
+        end
+
+        success(true)
+      end
+    end
+  end
+end

data/app/services/spree/wallet/create_payment_source.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Wallet
+    class CreatePaymentSource
+      prepend Spree::ServiceModule::Base
+
+      def call(payment_method:, params: {}, user: nil)
+        return failure(nil, :missing_attributes) if params.nil?
+
+        source_attributes = {
+          payment_method_id: payment_method.id,
+          user_id: user&.id,
+          gateway_payment_profile_id: params[:gateway_payment_profile_id],
+          gateway_customer_profile_id: params[:gateway_customer_profile_id],
+          last_digits: params[:last_digits],
+          month: params[:month],
+          year: params[:year],
+          name: params[:name]
+        }
+
+        source = payment_method.payment_source_class.new(source_attributes)
+
+        source.save ? success(source) : failure(source)
+      end
+    end
+  end
+end