spree_api 4.3.0.rc1 → 4.4.0.rc1

data/app/controllers/spree/api/v2/storefront/wishlists_controller.rb

@@ -0,0 +1,171 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class WishlistsController < ::Spree::Api::V2::ResourceController
+          before_action :require_spree_current_user, except: [:show]
+          before_action :ensure_valid_quantity, only: [:add_item, :set_item_quantity]
+
+          def show
+            spree_authorize! :show, resource
+            super
+          end
+
+          def create
+            spree_authorize! :create, Spree::Wishlist
+
+            @wishlist = spree_current_user.wishlists.new(wishlist_attributes)
+
+            ensure_current_store(@wishlist)
+
+            @wishlist.save
+
+            if @wishlist.persisted?
+              render_serialized_payload(201) { serialize_resource(@wishlist) }
+            else
+              render_error_payload(@wishlist.errors.full_messages.to_sentence)
+            end
+          end
+
+          def update
+            authorize! :update, resource
+
+            resource.update wishlist_attributes
+
+            if resource.errors.empty?
+              render_serialized_payload { serialize_resource(resource) }
+            else
+              render_error_payload(resource.errors.full_messages.to_sentence)
+            end
+          end
+
+          def destroy
+            authorize! :destroy, resource
+
+            if resource.destroy
+              head 204
+            else
+              render_error_payload(I18n.t('spree.api.v2.wishlist.errors.the_wishlist_could_not_be_destroyed'))
+            end
+          end
+
+          def default
+            spree_authorize! :create, Spree::Wishlist
+
+            @default_wishlist = spree_current_user.default_wishlist_for_store(current_store)
+
+            render_serialized_payload { serialize_resource(@default_wishlist) }
+          end
+
+          def add_item
+            spree_authorize! :create, Spree::WishedItem
+
+            if resource.wished_items.present? && resource.wished_items.detect { |wv| wv.variant_id.to_s == params[:variant_id].to_s }.present?
+              @wished_item = resource.wished_items.detect { |wi| wi.variant_id.to_s == params[:variant_id].to_s }
+              @wished_item.quantity = params[:quantity]
+            else
+              @wished_item = Spree::WishedItem.new(params.permit(:quantity, :variant_id))
+              @wished_item.wishlist = resource
+              @wished_item.save
+            end
+
+            resource.reload
+
+            if @wished_item.persisted?
+              render_serialized_payload { serialize_wished_item(@wished_item) }
+            else
+              render_error_payload(resource.errors.full_messages.to_sentence)
+            end
+          end
+
+          def set_item_quantity
+            spree_authorize! :update, wished_item
+
+            wished_item.update(params.permit(:quantity))
+
+            if wished_item.errors.empty?
+              render_serialized_payload { serialize_wished_item(wished_item) }
+            else
+              render_error_payload(resource.errors.full_messages.to_sentence)
+            end
+          end
+
+          def remove_item
+            spree_authorize! :destroy, wished_item
+
+            if wished_item.destroy
+              render_serialized_payload { serialize_wished_item(wished_item) }
+            else
+              render_error_payload(resource.errors.full_messages.to_sentence)
+            end
+          end
+
+          private
+
+          def scope(skip_cancancan: true)
+            if action_name == 'show'
+              super
+            else
+              super.where(user: spree_current_user)
+            end
+          end
+
+          def resource
+            @resource ||= scope.find_by(token: params[:id])
+          end
+
+          def model_class
+            Spree::Wishlist
+          end
+
+          def resource_serializer
+            ::Spree::V2::Storefront::WishlistSerializer
+          end
+
+          def collection_serializer
+            resource_serializer
+          end
+
+          def wishlist_attributes
+            params.require(:wishlist).permit(permitted_wishlist_attributes)
+          end
+
+          def wished_item_attributes
+            params.permit(permitted_wished_item_attributes)
+          end
+
+          def wished_item
+            @wished_item ||= resource.wished_items.find(params[:item_id])
+          end
+
+          def serialize_wished_item(wished_item)
+            ::Spree::V2::Storefront::WishedItemSerializer.new(
+              wished_item,
+              params: serializer_params,
+              include: resource_includes,
+              fields: sparse_fields
+            ).serializable_hash
+          end
+
+          def serializer_params
+            super.merge(is_variant_included: params[:is_variant_included])
+          end
+
+          def render_error_item_quantity
+            render json: { error: I18n.t('spree.api.v2.wishlist.wrong_quantity') }, status: 422
+          end
+
+          def ensure_valid_quantity
+            return render_error_item_quantity if params[:quantity].present? && params[:quantity].to_i <= 0
+
+            params[:quantity] = if params[:quantity].present?
+                                  params[:quantity].to_i
+                                else
+                                  1
+                                end
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/spree/api/v2/collection_options_helpers.rb

@@ -23,7 +23,7 @@ module Spree
         # leaving this method in public scope so it's still possible to modify
         # those params to support non-standard non-JSON API parameters
         def collection_permitted_params
-          params.permit(:format, :page, :per_page, :sort, :include, :fields, filter: {})
+          params.permit(:format, :page, :per_page, :sort, :include, fields: {}, filter: {})
         end
 
         private

data/app/jobs/spree/webhooks/subscribers/make_request_job.rb

@@ -0,0 +1,17 @@
+module Spree
+  module Webhooks
+    module Subscribers
+      class MakeRequestJob < Spree::BaseJob
+        queue_as :spree_webhooks
+
+        def perform(webhook_payload_body, event_name, subscriber)
+          Spree::Webhooks::Subscribers::HandleRequest.new(
+            event_name: event_name,
+            subscriber: subscriber,
+            webhook_payload_body: webhook_payload_body
+          ).call
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/spree/webhooks/has_webhooks.rb

@@ -0,0 +1,58 @@
+module Spree
+  module Webhooks
+    module HasWebhooks
+      extend ActiveSupport::Concern
+
+      included do
+        after_create_commit(proc { queue_webhooks_requests!(inferred_event_name(:create)) })
+        after_destroy_commit(proc { queue_webhooks_requests!(inferred_event_name(:delete)) })
+        after_update_commit(proc { queue_webhooks_requests!(inferred_event_name(:update)) })
+
+        def queue_webhooks_requests!(event_name)
+          return if disable_spree_webhooks? || webhook_payload_body.blank?
+          return if update_event?(event_name) && updating_only_timestamps?
+
+          Spree::Webhooks::Subscribers::QueueRequests.call(event_name: event_name, webhook_payload_body: webhook_payload_body)
+        end
+
+        def self.default_webhook_events
+          model_name = name.demodulize.tableize.singularize
+          %W[#{model_name}.create #{model_name}.delete #{model_name}.update]
+        end
+
+        def self.supported_webhook_events
+          events = default_webhook_events
+          events += custom_webhook_events if respond_to?(:custom_webhook_events)
+          events
+        end
+      end
+
+      private
+
+      def webhook_payload_body
+        resource_serializer.new(self).serializable_hash.to_json
+      end
+
+      def inferred_event_name(operation)
+        "#{self.class.name.demodulize.tableize.singularize}.#{operation}"
+      end
+
+      def resource_serializer
+        demodulized_class_name = self.class.to_s.demodulize
+        "Spree::Api::V2::Platform::#{demodulized_class_name}Serializer".constantize
+      end
+
+      def updating_only_timestamps?
+        (saved_changes.keys - %w[created_at updated_at deleted_at]).empty?
+      end
+
+      def update_event?(event_name)
+        event_name.end_with?('.update')
+      end
+
+      def disable_spree_webhooks?
+        ENV['DISABLE_SPREE_WEBHOOKS'] == 'true'
+      end
+    end
+  end
+end

data/app/models/spree/api/webhooks/order_decorator.rb

@@ -0,0 +1,43 @@
+module Spree
+  module Api
+    module Webhooks
+      module OrderDecorator
+        def self.prepended(base)
+          def base.custom_webhook_events
+            %w[order.canceled order.placed order.resumed order.shipped]
+          end
+
+          base.after_update_commit :queue_webhooks_requests_for_order_resumed!
+        end
+
+        def after_cancel
+          super
+          queue_webhooks_requests!('order.canceled')
+        end
+
+        def finalize!
+          super
+          queue_webhooks_requests!('order.placed')
+        end
+
+        def after_resume
+          super
+          queue_webhooks_requests!('order.resumed')
+          self.state_machine_resumed = false
+        end
+
+        private
+
+        def queue_webhooks_requests_for_order_resumed!
+          return if state_machine_resumed?
+          return unless state_previously_changed?
+          return unless state_previous_change&.last == 'resumed'
+
+          queue_webhooks_requests!('order.resumed')
+        end
+      end
+    end
+  end
+end
+
+Spree::Order.prepend(Spree::Api::Webhooks::OrderDecorator)

data/app/models/spree/api/webhooks/payment_decorator.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Api
+    module Webhooks
+      module PaymentDecorator
+        def self.prepended(base)
+          def base.custom_webhook_events
+            %w[payment.paid payment.voided]
+          end
+        end
+
+        def after_void
+          super
+          queue_webhooks_requests!('payment.voided')
+        end
+
+        def after_completed
+          super
+          queue_webhooks_requests!('payment.paid')
+          order.queue_webhooks_requests!('order.paid') if order.paid?
+        end
+      end
+    end
+  end
+end
+
+Spree::Payment.prepend(Spree::Api::Webhooks::PaymentDecorator)

data/app/models/spree/api/webhooks/product_decorator.rb

@@ -0,0 +1,27 @@
+module Spree
+  module Api
+    module Webhooks
+      module ProductDecorator
+        def self.prepended(base)
+          def base.custom_webhook_events
+            %w[product.back_in_stock product.backorderable product.discontinued product.out_of_stock]
+          end
+
+          base.after_update_commit :queue_webhooks_requests_for_product_discontinued!
+        end
+
+        private
+
+        def queue_webhooks_requests_for_product_discontinued!
+          return unless discontinue_on_previously_changed?
+          return if (change = discontinue_on_previous_change).blank? || change.last.blank?
+
+          queue_webhooks_requests!('product.discontinued')
+        end
+      end
+    end
+  end
+end
+
+Spree::Product.prepend(Spree::Api::Webhooks::ProductDecorator)
+

data/app/models/spree/api/webhooks/shipment_decorator.rb

@@ -0,0 +1,21 @@
+module Spree
+  module Api
+    module Webhooks
+      module ShipmentDecorator
+        def self.prepended(base)
+          def base.custom_webhook_events
+            %w[shipment.shipped]
+          end
+        end
+
+        def after_ship
+          super
+          queue_webhooks_requests!('shipment.shipped')
+          order.queue_webhooks_requests!('order.shipped') if order.fully_shipped?
+        end
+      end
+    end
+  end
+end
+
+Spree::Shipment.prepend(Spree::Api::Webhooks::ShipmentDecorator)

data/app/models/spree/api/webhooks/stock_item_decorator.rb

@@ -0,0 +1,43 @@
+module Spree
+  module Api
+    module Webhooks
+      module StockItemDecorator
+        def self.prepended(base)
+          base.around_save :queue_webhooks_requests_for_variant_backorderable!
+          base.around_save :queue_webhooks_requests_for_product_backorderable!
+        end
+
+        private
+
+        def queue_webhooks_requests_for_variant_backorderable!
+          was_out_of_stock = !variant.in_stock_or_backorderable?
+          was_not_backorderable = !variant_backorderable?
+          yield
+          if was_out_of_stock && was_not_backorderable && variant_backorderable?
+            reload
+            variant.queue_webhooks_requests!('variant.backorderable')
+          end
+        end
+
+        def queue_webhooks_requests_for_product_backorderable!
+          product_was_out_of_stock = !product.any_variant_in_stock_or_backorderable?
+          product_was_not_backorderable = !product_backorderable?
+          yield
+          if product_was_out_of_stock && product_was_not_backorderable && product_backorderable?
+            variant.product.queue_webhooks_requests!('product.backorderable')
+          end
+        end
+
+        def product_backorderable?
+          Spree::StockItem.exists?(backorderable: true, variant_id: variant.product.variants.ids)
+        end
+
+        def variant_backorderable?
+          variant.stock_items.exists?(backorderable: true)
+        end
+      end
+    end
+  end
+end
+
+Spree::StockItem.prepend(Spree::Api::Webhooks::StockItemDecorator)

data/app/models/spree/api/webhooks/stock_movement_decorator.rb

@@ -0,0 +1,52 @@
+module Spree
+  module Api
+    module Webhooks
+      module StockMovementDecorator
+        def self.prepended(base)
+          base.around_save :queue_webhooks_requests_for_variant_out_of_stock!
+          base.around_save :queue_webhooks_requests_for_variant_back_in_stock!
+          base.around_save :queue_webhooks_requests_for_product_out_of_stock!
+          base.around_save :queue_webhooks_requests_for_product_back_in_stock!
+        end
+
+        private
+
+        def queue_webhooks_requests_for_variant_out_of_stock!
+          variant_in_stock_before_update = variant.in_stock_or_backorderable?
+          yield
+          if variant_in_stock_before_update && !variant.in_stock_or_backorderable?
+            reload
+            stock_item.variant.queue_webhooks_requests!('variant.out_of_stock')
+          end
+        end
+
+        def queue_webhooks_requests_for_variant_back_in_stock!
+          variant_was_out_of_stock = !variant.in_stock_or_backorderable?
+          yield
+          if variant_was_out_of_stock && variant.in_stock_or_backorderable?
+            reload
+            variant.queue_webhooks_requests!('variant.back_in_stock')
+          end
+        end
+
+        def queue_webhooks_requests_for_product_back_in_stock!
+          product_was_out_of_stock = !product.any_variant_in_stock_or_backorderable?
+          yield
+          if product_was_out_of_stock && product.any_variant_in_stock_or_backorderable?
+            product.queue_webhooks_requests!('product.back_in_stock')
+          end
+        end
+
+        def queue_webhooks_requests_for_product_out_of_stock!
+          product_was_in_stock = product.any_variant_in_stock_or_backorderable?
+          yield
+          if product_was_in_stock && !product.any_variant_in_stock_or_backorderable?
+            product.queue_webhooks_requests!('product.out_of_stock')
+          end
+        end
+      end
+    end
+  end
+end
+
+Spree::StockMovement.prepend(Spree::Api::Webhooks::StockMovementDecorator)

data/app/models/spree/api/webhooks/variant_decorator.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Api
+    module Webhooks
+      module VariantDecorator
+        def self.prepended(base)
+          def base.custom_webhook_events
+            %w[variant.back_in_stock variant.backorderable variant.discontinued variant.out_of_stock]
+          end
+
+          base.after_update_commit :queue_webhooks_requests_for_variant_discontinued!
+        end
+
+        private
+
+        def queue_webhooks_requests_for_variant_discontinued!
+          return unless discontinue_on_previously_changed?
+          return if (change = discontinue_on_previous_change).blank? || change.last.blank?
+
+          queue_webhooks_requests!('variant.discontinued')
+        end
+      end
+    end
+  end
+end
+
+Spree::Variant.prepend(Spree::Api::Webhooks::VariantDecorator)

data/app/models/spree/api_configuration.rb

@@ -1,8 +1,10 @@
 module Spree
   class ApiConfiguration < Preferences::Configuration
     preference :requires_authentication, :boolean, default: true
-    preference :api_v2_cache_ttl, :integer, default: 3600 # 1 hour in seconds
+    preference :api_v2_serializers_cache_ttl, :integer, default: 3600 # 1 hour in seconds
+    preference :api_v2_collection_cache_ttl, :integer, default: 3600 # 1 hour in seconds
+    preference :api_v2_collection_cache_namespace, :string, default: 'api_v2_collection_cache'
     preference :api_v2_content_type, :string, default: 'application/vnd.api+json'
-    preference :api_v2_per_page_limit, :integer, default: 100
+    preference :api_v2_per_page_limit, :integer, default: 500
   end
 end

data/app/models/spree/oauth_access_grant.rb

@@ -0,0 +1,7 @@
+module Spree
+  class OauthAccessGrant < Base
+    include ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessGrant
+
+    self.table_name = 'spree_oauth_access_grants'
+  end
+end

data/app/models/spree/oauth_access_token.rb

@@ -0,0 +1,7 @@
+module Spree
+  class OauthAccessToken < Base
+    include ::Doorkeeper::Orm::ActiveRecord::Mixins::AccessToken
+
+    self.table_name = 'spree_oauth_access_tokens'
+  end
+end

data/app/models/spree/oauth_application.rb

@@ -0,0 +1,15 @@
+module Spree
+  class OauthApplication < Base
+    include ::Doorkeeper::Orm::ActiveRecord::Mixins::Application
+
+    self.table_name = 'spree_oauth_applications'
+
+    before_validation :set_blank_for_redirect_uri
+
+    private
+
+    def set_blank_for_redirect_uri
+      self.redirect_uri = '' if redirect_uri.nil?
+    end
+  end
+end

data/app/models/spree/webhooks/base.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Webhooks
+    def self.table_name_prefix
+      'spree_webhooks_'
+    end
+
+    class Base < Spree::Base
+      self.abstract_class = true
+    end
+  end
+end

data/app/models/spree/webhooks/event.rb

@@ -0,0 +1,12 @@
+module Spree
+  module Webhooks
+    class Event < Spree::Webhooks::Base
+      validates :name, :subscriber, presence: true
+
+      belongs_to :subscriber, inverse_of: :events, optional: false
+
+      self.whitelisted_ransackable_associations = %w[subscriber]
+      self.whitelisted_ransackable_attributes = %w[name request_errors response_code success url]
+    end
+  end
+end

data/app/models/spree/webhooks/subscriber.rb

@@ -0,0 +1,57 @@
+module Spree
+  module Webhooks
+    class Subscriber < Spree::Webhooks::Base
+      has_many :events, inverse_of: :subscriber
+
+      validates :url, 'spree/url': true, presence: true
+
+      validate :check_uri_path
+
+      self.whitelisted_ransackable_attributes = %w[active subscriptions url]
+      self.whitelisted_ransackable_associations = %w[event]
+
+      scope :active, -> { where(active: true) }
+      scope :inactive, -> { where(active: false) }
+
+      before_save :parse_subscriptions
+
+      def self.with_urls_for(event)
+        where(
+          case ActiveRecord::Base.connection.adapter_name
+          when 'Mysql2'
+            ["('*' MEMBER OF(subscriptions) OR ? MEMBER OF(subscriptions))", event]
+          when 'PostgreSQL'
+            ["subscriptions @> '[\"*\"]' OR subscriptions @> ?", [event].to_json]
+          end
+        )
+      end
+
+      def self.supported_events
+        Spree::Base.descendants.
+          select { |model| model.included_modules.include? Spree::Webhooks::HasWebhooks }.
+          to_h do |model|
+          model_name = model.name.demodulize.underscore.to_sym
+          [model_name, model.supported_webhook_events]
+        end
+      end
+
+      private
+
+      def check_uri_path
+        uri = begin
+          URI.parse(url)
+        rescue URI::InvalidURIError
+          return false
+        end
+
+        errors.add(:url, 'the URL must have a path') if uri.blank? || uri.path.blank?
+      end
+
+      def parse_subscriptions
+        return if subscriptions.blank? || subscriptions.is_a?(Array)
+
+        self.subscriptions = JSON.parse(subscriptions)
+      end
+    end
+  end
+end

data/app/presenters/spree/api/products/filters_presenter.rb

@@ -0,0 +1,39 @@
+module Spree
+  module Api
+    module Products
+      class FiltersPresenter
+        def initialize(current_store, current_currency, params)
+          @products_for_filters = find_products_for_filters(current_store, current_currency, params)
+        end
+
+        def to_h
+          option_values = Spree::OptionValues::FindAvailable.new(products_scope: products_for_filters).execute
+          option_values_presenters = Spree::Filters::OptionsPresenter.new(option_values_scope: option_values).to_a
+          product_properties = Spree::ProductProperties::FindAvailable.new(products_scope: products_for_filters).execute
+          product_properties_presenters = Spree::Filters::PropertiesPresenter.new(product_properties_scope: product_properties).to_a
+          {
+            option_types: option_values_presenters.map(&:to_h),
+            product_properties: product_properties_presenters.map(&:to_h)
+          }
+        end
+
+        private
+
+        attr_reader :products_for_filters
+
+        def find_products_for_filters(current_store, current_currency, params)
+          current_taxons = find_current_taxons(current_store, params)
+          current_store.products.active(current_currency).in_taxons(current_taxons)
+        end
+
+        def find_current_taxons(current_store, params)
+          taxons_param = params.dig(:filter, :taxons)
+          return nil if taxons_param.nil? || taxons_param.to_s.blank?
+
+          taxon_ids = taxons_param.to_s.split(',')
+          current_store.taxons.where(id: taxon_ids)
+        end
+      end
+    end
+  end
+end