spree_core 4.1.1 → 4.5.0

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

data/app/sorters/spree/base_sorter.rb

@@ -0,0 +1,47 @@
+module Spree
+  class BaseSorter
+    def initialize(scope, params = {}, allowed_sort_attributes = [])
+      @scope = scope
+      @allowed_sort_attributes = allowed_sort_attributes
+      @sort = sort_fields(params[:sort])
+    end
+
+    def call
+      by_param_attributes(scope)
+    end
+
+    protected
+
+    attr_reader :scope, :collection, :sort, :allowed_sort_attributes
+
+    def by_param_attributes(scope)
+      return scope if sort.empty?
+
+      sort.each do |value, order|
+        next if value.blank? || allowed_sort_attributes.exclude?(value.to_sym)
+
+        scope = scope.order("#{value}": order)
+      end
+
+      scope
+    end
+
+    def sort_fields(sort)
+      return [] if sort.nil?
+
+      sort.split(',').map { |field| [sort_field(field), order_direction(field)] }
+    end
+
+    def desc_order(field)
+      String(field)[0] == '-'
+    end
+
+    def sort_field(field)
+      desc_order(field) ? field[1..-1] : field
+    end
+
+    def order_direction(field)
+      desc_order(field) ? :desc : :asc
+    end
+  end
+end

data/app/sorters/spree/orders/sort.rb

@@ -1,42 +1,6 @@
 module Spree
   module Orders
-    class Sort
-      attr_reader :scope, :sort
-
-      def initialize(scope, params)
-        @scope = scope
-        @sort = params[:sort]
-      end
-
-      def call
-        orders = completed_at(scope)
-
-        orders
-      end
-
-      private
-
-      def desc_order
-        @desc_order ||= String(sort)[0] == '-'
-      end
-
-      def sort_field
-        @sort_field ||= desc_order ? sort[1..-1] : sort
-      end
-
-      def order_direction
-        desc_order ? :asc : :desc
-      end
-
-      def completed_at?
-        sort_field.eql?('completed_at')
-      end
-
-      def completed_at(orders)
-        return orders unless completed_at?
-
-        orders.order(completed_at: order_direction)
-      end
+    class Sort < ::Spree::BaseSorter
     end
   end
 end

data/app/sorters/spree/products/sort.rb

@@ -1,57 +1,50 @@
 module Spree
   module Products
-    class Sort
-      def initialize(scope, params, current_currency)
-        @scope    = scope
-        @sort     = params[:sort]
+    class Sort < ::Spree::BaseSorter
+      def initialize(scope, current_currency, params = {}, allowed_sort_attributes = [])
+        super(scope, params, allowed_sort_attributes)
         @currency = params[:currency] || current_currency
       end
 
       def call
-        products = updated_at(scope)
-        products = price(products)
+        products = by_param_attributes(scope)
+        products = by_price(products)
+        products = by_sku(products)
 
         products.distinct
       end
 
       private
 
-      attr_reader :sort, :scope, :currency
+      attr_reader :sort, :scope, :currency, :allowed_sort_attributes
 
-      def desc_order
-        @desc_order ||= String(sort)[0] == '-'
-      end
-
-      def sort_field
-        @sort_field ||= desc_order ? sort[1..-1] : sort
-      end
+      def by_price(scope)
+        return scope unless (value = sort_by?('price'))
 
-      def updated_at?
-        sort_field == 'updated_at'
-      end
-
-      def price?
-        sort_field == 'price'
+        scope.joins(master: :prices).
+          select("#{Spree::Product.table_name}.*, #{Spree::Price.table_name}.amount").
+          distinct.
+          where(spree_prices: { currency: currency }).
+          order("#{Spree::Price.table_name}.amount #{value[1]}")
       end
 
-      def order_direction
-        desc_order ? :desc : :asc
-      end
+      def by_sku(scope)
+        return scope unless (value = sort_by?('sku'))
 
-      def updated_at(products)
-        return products unless updated_at?
+        select_product_attributes = if scope.to_sql.include?("#{Spree::Product.table_name}.*")
+                                      ''
+                                    else
+                                      "#{Spree::Product.table_name}.*, "
+                                    end
 
-        products.order(updated_at: order_direction)
+        scope.joins(:master).
+          select("#{select_product_attributes}#{Spree::Variant.table_name}.sku").
+          where(Spree::Variant.table_name.to_s => { is_master: true }).
+          order("#{Spree::Variant.table_name}.sku #{value[1]}")
       end
 
-      def price(products)
-        return products unless price?
-
-        products.joins(master: :prices).
-          select("#{Spree::Product.table_name}.*, #{Spree::Price.table_name}.amount").
-          distinct.
-          where(spree_prices: { currency: currency }).
-          order("#{Spree::Price.table_name}.amount #{order_direction}")
+      def sort_by?(field)
+        sort.detect { |s| s[0] == field }
       end
     end
   end

data/app/validators/db_maximum_length_validator.rb

@@ -2,6 +2,11 @@
 # Validates a field based on the maximum length of the underlying DB field, if there is one.
 class DbMaximumLengthValidator < ActiveModel::EachValidator
   def validate_each(record, attribute, value)
+    ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+      `DbMaximumLengthValidator` is deprecated and will be removed in Spree 5.0.
+      Please remove any `db_maximum_length: true` validations from your codebase
+    DEPRECATION
+
     limit = if defined?(Globalize)
               record.class.translation_class.columns_hash[attribute.to_s].limit
             else

data/app/validators/email_validator.rb

@@ -1,7 +1,9 @@
 class EmailValidator < ActiveModel::EachValidator
+  EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
+
   def validate_each(record, attribute, value)
-    unless value =~ /\A[^@\s]+@[^@\s]+\z/
-      record.errors.add(attribute, :invalid, { value: value }.merge!(options))
+    unless value =~ EMAIL_REGEX
+      record.errors.add(attribute, :invalid, **{ value: value }.merge!(options))
     end
   end
 end

data/app/validators/spree/url_validator.rb

@@ -0,0 +1,23 @@
+module Spree
+  class UrlValidator < ActiveModel::EachValidator
+    def validate_each(record, attribute, value)
+      unless url_valid?(value)
+        record.errors.add(attribute, (options[:message] || ERROR_MESSAGE))
+      end
+    end
+
+    private
+
+    ERROR_MESSAGE = 'must be a valid URL'
+    private_constant :ERROR_MESSAGE
+
+    def url_valid?(url)
+      uri = begin
+        URI.parse(url)
+      rescue URI::InvalidURIError
+        return false
+      end
+      uri.host.present? && uri.is_a?(URI::HTTP)
+    end
+  end
+end

data/brakeman.ignore

@@ -0,0 +1,20 @@
+{
+    "ignored_warnings": [
+        {
+          "fingerprint": "011b2643940ba1112f7a737e403abe3616ad91764703c801cc35a48d36b721da",
+          "note": "interpolating table name"
+        },
+        {
+          "fingerprint": "965d3919f811ab63b7b8d62da528559a7f38dc122c57efea7136e7ec5ef1f062",
+          "note": "interpolating table name"
+        },
+        {
+          "fingerprint": "abd8e90e7a7dfbcdcd6d44fd3fb550598aee6d7a9ef2bb132ad1a18a3c50be30",
+          "note": "interpolating table name"
+        },
+        {
+          "fingerprint": "efcc57e1a5648d7db59d1beaf5e399d2278539a8667b19c520b305a6ca7e15e8",
+          "note": "interpolating table name"
+        }
+    ]
+}

data/config/initializers/active_storage.rb

@@ -1,5 +1 @@
-class ActiveStorage::PurgeJob < ActiveStorage::BaseJob
-  def perform(blob)
-    blob.purge unless blob.attachments.present?
-  end
-end
+Rails.application.config.active_storage.content_types_to_serve_as_binary.delete('image/svg+xml')

data/config/initializers/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.acronym 'RMA'
+end

data/config/initializers/rails61_fixes.rb

@@ -0,0 +1,3 @@
+if Rails::VERSION::STRING >= '6.1'
+  ActiveRecord::Base.has_many_inversing = false
+end