spree_core 4.0.0 → 4.6.0

data/app/presenters/spree/filters/price_range_presenter.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Filters
+    class PriceRangePresenter
+      def self.from_param(param, currency:)
+        prices = param.split('-')
+
+        new(
+          min_price: PricePresenter.new(amount: prices.first, currency: currency),
+          max_price: PricePresenter.new(amount: prices.last, currency: currency)
+        )
+      end
+
+      def initialize(min_price:, max_price:)
+        @min_price = min_price
+        @max_price = max_price
+      end
+
+      attr_reader :min_price, :max_price
+
+      def to_param
+        "#{min_price.to_i}-#{max_price.to_i}"
+      end
+
+      def to_s
+        "#{min_price} - #{max_price}"
+      end
+    end
+  end
+end

data/app/presenters/spree/filters/properties_presenter.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Filters
+    class PropertiesPresenter
+      def initialize(product_properties_scope:)
+        @product_properties = product_properties_scope.includes(:property)
+      end
+
+      def to_a
+        grouped_options.map do |property, product_properties|
+          PropertyPresenter.new(property: property, product_properties: product_properties)
+        end
+      end
+
+      private
+
+      attr_reader :product_properties
+
+      def grouped_options
+        product_properties.group_by(&:property)
+      end
+    end
+  end
+end

data/app/presenters/spree/filters/property_presenter.rb

@@ -0,0 +1,42 @@
+module Spree
+  module Filters
+    class PropertyPresenter
+      def initialize(property:, product_properties:)
+        @property = property
+        @product_properties = product_properties
+      end
+
+      attr_reader :product_properties
+
+      delegate_missing_to :property
+
+      def uniq_values
+        property.uniq_values(product_properties_scope: product_properties)
+      end
+
+      def to_h
+        {
+          id: property.id,
+          name: property.name,
+          presentation: property.presentation,
+          values: values_hash
+        }
+      end
+
+      private
+
+      attr_reader :property
+
+      def values_hash
+        value_hashes = uniq_values.map do |filter_param, value|
+          {
+            value: value,
+            filter_param: filter_param
+          }
+        end
+
+        value_hashes.sort_by { |e| e[:value] }
+      end
+    end
+  end
+end

data/app/presenters/spree/filters/quantified_price_range_presenter.rb

@@ -0,0 +1,44 @@
+module Spree
+  module Filters
+    class QuantifiedPriceRangePresenter
+      ALLOWED_QUANTIFIERS = [
+        :less_than,
+        :more_than
+      ].freeze
+
+      def initialize(price:, quantifier:)
+        if ALLOWED_QUANTIFIERS.exclude?(quantifier.to_sym)
+          raise ArgumentError, "quantifier must be one of: #{ALLOWED_QUANTIFIERS.join(', ')}"
+        end
+
+        @price = price
+        @quantifier = quantifier.to_sym
+      end
+
+      def to_param
+        case quantifier
+        when :less_than
+          less_than_param
+        when :more_than
+          more_than_param
+        end
+      end
+
+      def to_s
+        "#{I18n.t("activerecord.attributes.spree/product.#{quantifier}")} #{price}"
+      end
+
+      private
+
+      attr_reader :price, :quantifier
+
+      def less_than_param
+        "0-#{price.to_i}"
+      end
+
+      def more_than_param
+        "#{price.to_i}-Infinity"
+      end
+    end
+  end
+end

data/app/presenters/spree/product_summary_presenter.rb

@@ -0,0 +1,26 @@
+module Spree
+  class ProductSummaryPresenter
+    include Rails.application.routes.url_helpers
+
+    def initialize(product)
+      @product = product
+    end
+
+    def call
+      {
+        name: @product.name,
+        images: images
+      }
+    end
+
+    private
+
+    def images
+      @product.images.map do |image|
+        {
+          url_product: rails_representation_url(image.url(:product), only_path: true)
+        }
+      end
+    end
+  end
+end

data/app/presenters/spree/variant_presenter.rb

@@ -0,0 +1,80 @@
+module Spree
+  class VariantPresenter
+    include Rails.application.routes.url_helpers
+    include Spree::BaseHelper
+    include Spree::ProductsHelper
+
+    attr_reader :current_currency, :current_price_options, :current_store
+
+    def initialize(opts = {})
+      @variants = opts[:variants]
+      @is_product_available_in_currency = opts[:is_product_available_in_currency]
+      @current_currency = opts[:current_currency]
+      @current_price_options = opts[:current_price_options]
+      @current_store = opts[:current_store]
+    end
+
+    def call
+      @variants.map do |variant|
+        {
+          display_price: display_price(variant),
+          price: variant.price_in(current_currency),
+          display_compare_at_price: display_compare_at_price(variant),
+          should_display_compare_at_price: should_display_compare_at_price?(variant),
+          is_product_available_in_currency: @is_product_available_in_currency,
+          backorderable: backorderable?(variant),
+          in_stock: in_stock?(variant),
+          images: images(variant),
+          option_values: option_values(variant),
+        }.merge(
+          variant_attributes(variant)
+        )
+      end
+    end
+
+    def images(variant)
+      variant.images.map do |image|
+        {
+          alt: image.alt,
+          url_product: rails_representation_url(image.url(:product), only_path: true)
+        }
+      end
+    end
+
+    def option_values(variant)
+      variant.option_values.map do |option_value|
+        {
+          id: option_value.id,
+          name: option_value.name,
+          presentation: option_value.presentation,
+        }
+      end
+    end
+
+    private
+
+    def backorderable?(variant)
+      backorderable_variant_ids.include?(variant.id)
+    end
+
+    def backorderable_variant_ids
+      @backorderable_variant_ids ||= Spree::Variant.where(id: @variants.map(&:id)).backorderable.ids
+    end
+
+    def in_stock?(variant)
+      in_stock_variant_ids.include?(variant.id)
+    end
+
+    def in_stock_variant_ids
+      @in_stock_variant_ids ||= Spree::Variant.where(id: @variants.map(&:id)).in_stock.ids
+    end
+
+    def variant_attributes(variant)
+      {
+        id: variant.id,
+        sku: variant.sku,
+        purchasable: variant.purchasable?
+      }
+    end
+  end
+end

data/app/presenters/spree/variants/option_types_presenter.rb

@@ -0,0 +1,87 @@
+module Spree
+  module Variants
+    class OptionTypesPresenter
+      def initialize(option_types, variants, product)
+        @option_types = option_types
+        @variant_ids = variants.map(&:id)
+        @product = product
+      end
+
+      def default_variant
+        default_variant_data[:variant]
+      end
+
+      def options
+        option_types.map do |option_type|
+          {
+            id: option_type.id,
+            name: option_type.name,
+            presentation: option_type.presentation,
+            position: option_type.position,
+            option_values: option_values_options(option_type.option_values)
+          }
+        end
+      end
+
+      private
+
+      attr_reader :option_types
+
+      def default_variant_data
+        return {} if option_types.empty?
+
+        @default_variant_data ||= begin
+          try_default_variant || find_in_stock_variant_data || find_backorderable_variant_data || find_first_variant_data
+        end
+      end
+
+      def find_in_stock_variant_data
+        find_variant_data(&:in_stock?)
+      end
+
+      def find_backorderable_variant_data
+        find_variant_data(&:backorderable?)
+      end
+
+      def find_variant_data(&block)
+        option_types.first.option_values.each do |option_value|
+          variant = option_value.variants.where(id: @variant_ids).order(:position).find(&block)
+
+          return { variant: variant, option_value: option_value } if variant
+        end
+
+        nil
+      end
+
+      def try_default_variant
+        option_types.first.option_values.each do |option_value|
+          variant = option_value.variants.where(id: @product.default_variant_id).first
+
+          return { variant: variant, option_value: option_value } if variant
+        end
+
+        nil
+      end
+
+      def find_first_variant_data
+        option_value = option_types.first.option_values.first
+        variant = option_value.variants.where(id: @variant_ids).order(:position).first
+
+        { variant: variant, option_value: option_value }
+      end
+
+      def option_values_options(option_values)
+        option_values.map do |option_value|
+          {
+            id: option_value.id,
+            position: option_value.position,
+            presentation: option_value.presentation,
+            name: option_value.name,
+            variant_id: option_value.variants.where(id: @variant_ids).order(:position).first.id,
+            is_default: option_value == default_variant_data[:option_value]
+          }
+        end
+      end
+    end
+  end
+end

data/app/presenters/spree/variants/options_presenter.rb

@@ -0,0 +1,49 @@
+module Spree
+  module Variants
+    class OptionsPresenter
+      WORDS_CONNECTOR = ', '.freeze
+
+      attr_reader :variant
+
+      delegate :option_values, to: :variant
+
+      def initialize(variant)
+        @variant = variant
+      end
+
+      def to_sentence
+        options = option_values
+        options = sort_options(options)
+        options = present_options(options)
+
+        join_options(options)
+      end
+
+      private
+
+      def sort_options(options)
+        options.sort_by { |o| o.option_type.position }
+      end
+
+      def present_options(options)
+        options.map do |ov|
+          method = "present_#{ov.option_type.name}_option"
+
+          respond_to?(method, true) ? send(method, ov) : present_option(ov)
+        end
+      end
+
+      def present_color_option(option)
+        "#{option.option_type.presentation}: #{option.name}"
+      end
+
+      def present_option(option)
+        "#{option.option_type.presentation}: #{option.presentation}"
+      end
+
+      def join_options(options)
+        options.to_sentence(words_connector: WORDS_CONNECTOR, two_words_connector: WORDS_CONNECTOR)
+      end
+    end
+  end
+end

data/app/services/spree/account/addresses/create.rb

@@ -0,0 +1,8 @@
+module Spree
+  module Account
+    module Addresses
+      class Create < Spree::Addresses::Create
+      end
+    end
+  end
+end

data/app/services/spree/account/addresses/update.rb

@@ -0,0 +1,8 @@
+module Spree
+  module Account
+    module Addresses
+      class Update < Spree::Addresses::Update
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Spree
+  module Account
+    class Create
+      prepend Spree::ServiceModule::Base
+
+      def call(user_params: {})
+        user = Spree.user_class.new(user_params)
+
+        if user.save
+          success(user)
+        else
+          failure(user)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Spree
+  module Account
+    class Update
+      prepend Spree::ServiceModule::Base
+
+      def call(user:, user_params: {})
+        if user.update(user_params)
+          success(user)
+        else
+          failure(user)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Spree
+  module Addresses
+    class Create
+      prepend Spree::ServiceModule::Base
+      include Spree::Addresses::Helper
+
+      attr_accessor :country
+
+      def call(address_params: {}, user: nil)
+        address_params = fill_country_and_state_ids(address_params)
+
+        address = Spree::Address.new(address_params)
+        address.user = user if user.present?
+
+        if address.save
+          assign_to_user_as_default(user: user, address_id: address.id) if user.present?
+          success(address)
+        else
+          failure(address)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Spree
+  module Addresses
+    module Helper
+      private
+
+      attr_accessor :country
+
+      def fill_country_and_state_ids(params)
+        replace_country_iso_with_id(params)
+        fill_state_id(params)
+      end
+
+      def replace_country_iso_with_id(params)
+        iso = params[:country_iso]
+        return params unless iso.present?
+
+        country = Spree::Country.by_iso(iso)
+        params[:country_id] = country&.id
+        params.delete(:country_iso)
+        params
+      end
+
+      def fill_state_id(params)
+        state_name = params[:state_name]
+        return params unless state_name.present?
+
+        country ||= Spree::Country.find(params[:country_id]) if params[:country_id].present?
+        return params unless country
+
+        params[:state_id] = country.states.find_by(name: state_name)&.id
+        params
+      end
+
+      def assign_to_user_as_default(user:, address_id:)
+        if user.addresses.pluck(:id) == [address_id] # check if it's user first address
+          user.update(bill_address_id: address_id, ship_address_id: address_id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Spree
+  module Addresses
+    class Update
+      prepend Spree::ServiceModule::Base
+      include Spree::Addresses::Helper
+
+      attr_accessor :country
+
+      def call(address:, address_params:)
+        address_params[:country_id] ||= address.country_id
+        address_params = fill_country_and_state_ids(address_params)
+
+        if address&.editable?
+          address.update(address_params) ? success(address) : failure(address)
+        else
+          if new_address(address_params).valid?
+            address.destroy
+            success(new_address)
+          else
+            failure(new_address)
+          end
+        end
+      end
+
+      private
+
+      def new_address(address_params = {})
+        @new_address ||= ::Spree::Address.find_or_create_by(address_params.except(:id, :updated_at, :created_at))
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module Spree
     class AddItem
       prepend Spree::ServiceModule::Base
 
-      def call(order:, variant:, quantity: nil, options: {})
+      def call(order:, variant:, quantity: nil, public_metadata: {}, private_metadata: {}, options: {})
         ApplicationRecord.transaction do
           run :add_to_line_item
           run Spree::Dependencies.cart_recalculate_service.constantize
@@ -12,7 +12,7 @@ module Spree
 
       private
 
-      def add_to_line_item(order:, variant:, quantity: nil, options: {})
+      def add_to_line_item(order:, variant:, quantity: nil, public_metadata: {}, private_metadata: {}, options: {})
         options ||= {}
         quantity ||= 1
 
@@ -32,6 +32,8 @@ module Spree
         end
 
         line_item.target_shipment = options[:shipment] if options.key? :shipment
+        line_item.public_metadata = public_metadata.to_h if public_metadata
+        line_item.private_metadata = private_metadata.to_h if private_metadata
 
         return failure(line_item) unless line_item.save
 

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

@@ -0,0 +1,16 @@
+module Spree
+  module Cart
+    class Associate
+      prepend Spree::ServiceModule::Base
+
+      def call(guest_order:, user:)
+        if guest_order.user.nil?
+          guest_order.associate_user!(user)
+          success(guest_order)
+        else
+          failure(guest_order, 'Already assigned to a user')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Spree
+  module Cart
+    class ChangeCurrency
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, new_currency:)
+        return failure('Currency not supported') unless supported_currency?(order, new_currency)
+
+        result = order.update!(currency: new_currency) rescue false
+
+        if result
+          success(order)
+        else
+          failure('Failed to update order')
+        end
+      end
+
+      private
+
+      def supported_currency?(order, currency)
+        store = order.store
+        supported_currencies = store.supported_currencies_list
+        supported_currencies.map(&:iso_code).include?(currency.upcase)
+      end
+    end
+  end
+end

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

@@ -3,17 +3,21 @@ module Spree
     class Create
       prepend Spree::ServiceModule::Base
 
-      def call(user:, store:, currency:, order_params: nil)
+      def call(user:, store:, currency:, public_metadata: {}, private_metadata: {}, order_params: {})
         order_params ||= {}
 
+        # we cannot create an order without store
+        return failure(:store_is_required) if store.nil?
+
         default_params = {
           user: user,
-          store: store,
-          currency: currency,
-          token: Spree::GenerateToken.new.call(Spree::Order)
+          currency: currency || store.default_currency,
+          token: Spree::GenerateToken.new.call(Spree::Order),
+          public_metadata: public_metadata.to_h,
+          private_metadata: private_metadata.to_h
         }
 
-        order = Spree::Order.create!(default_params.merge(order_params))
+        order = store.orders.create!(default_params.merge(order_params))
         success(order)
       end
     end

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

@@ -0,0 +1,40 @@
+module Spree
+  module Cart
+    class Destroy
+      prepend Spree::ServiceModule::Base
+
+      def call(order:)
+        run :check_if_can_be_destroyed
+        run :cancel_shipments
+        run :void_payments
+        run :destroy_order
+      end
+
+      private
+
+      def check_if_can_be_destroyed(order:)
+        return failure(Spree.t(:cannot_be_destroyed)) unless order&.can_be_destroyed?
+
+        success(order: order)
+      end
+
+      def cancel_shipments(order:)
+        order.shipments.each(&:cancel!)
+
+        success(order: order)
+      end
+
+      def void_payments(order:)
+        order.payments.each(&:void!)
+
+        success(order: order)
+      end
+
+      def destroy_order(order:)
+        order.destroy
+
+        success(order)
+      end
+    end
+  end
+end