atkhayar-spree-dev-api 0.0.0

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

@@ -0,0 +1,27 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class StoresController < ::Spree::Api::V2::ResourceController
+          def current
+            render_serialized_payload { serialize_resource(current_store) }
+          end
+
+          private
+
+          def model_class
+            Spree::Store
+          end
+
+          def resource
+            @resource ||= scope.find_by!(code: params[:code])
+          end
+
+          def resource_serializer
+            Spree::Api::Dependencies.storefront_store_serializer.constantize
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class TaxonsController < ::Spree::Api::V2::ResourceController
+          private
+
+          def collection_serializer
+            Spree::Api::Dependencies.storefront_taxon_serializer.constantize
+          end
+
+          def resource_serializer
+            Spree::Api::Dependencies.storefront_taxon_serializer.constantize
+          end
+
+          def collection_finder
+            Spree::Api::Dependencies.storefront_taxon_finder.constantize
+          end
+
+          def paginated_collection
+            @paginated_collection ||= collection_paginator.new(collection, params).call
+          end
+
+          def resource
+            @resource ||= scope.find_by(permalink: params[:id]) || scope.find(params[:id])
+          end
+
+          def model_class
+            Spree::Taxon
+          end
+
+          def scope_includes
+            node_includes = %i[icon parent taxonomy]
+
+            {
+              parent: node_includes,
+              children: node_includes,
+              taxonomy: [root: node_includes],
+              icon: [attachment_attachment: :blob]
+            }
+          end
+
+          def serializer_params
+            super.merge(include_products: action_name == 'show')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Spree
+  module Api
+    module V2
+      module CollectionOptionsHelpers
+        def collection_links(collection)
+          {
+            self: request.original_url,
+            next: pagination_url(collection.next_page || collection.total_pages),
+            prev: pagination_url(collection.prev_page || 1),
+            last: pagination_url(collection.total_pages),
+            first: pagination_url(1)
+          }
+        end
+
+        def collection_meta(collection)
+          {
+            count: collection.size,
+            total_count: collection.total_count,
+            total_pages: collection.total_pages
+          }
+        end
+
+        # 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: {})
+        end
+
+        private
+
+        def pagination_url(page)
+          url_for(collection_permitted_params.merge(page: page))
+        end
+
+        def collection_options(collection)
+          {
+            links: collection_links(collection),
+            meta: collection_meta(collection),
+            include: resource_includes,
+            fields: sparse_fields
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Spree
+  module Api
+    module V2
+      module DisplayMoneyHelper
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def find_price(product_or_variant, currency)
+            product_or_variant.price_in(currency)
+          end
+
+          def price(product_or_variant, currency)
+            price = find_price(product_or_variant, currency)
+            return nil if price.new_record?
+
+            price.amount
+          end
+
+          def display_price(product_or_variant, currency)
+            price = find_price(product_or_variant, currency)
+            return nil if price.new_record?
+
+            Spree::Money.new(price.amount, currency: currency).to_s
+          end
+
+          def compare_at_price(product_or_variant, currency)
+            price = find_price(product_or_variant, currency)
+            return nil if price.new_record? || price.compare_at_amount.blank?
+
+            price.compare_at_amount
+          end
+
+          def display_compare_at_price(product_or_variant, currency)
+            price = find_price(product_or_variant, currency)
+            return nil if price.new_record? || price.compare_at_amount.blank?
+
+            Spree::Money.new(price.compare_at_amount, currency: currency).to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Spree
+  module Api
+    module V2
+      module StoreMediaSerializerImagesConcern
+        extend ActiveSupport::Concern
+
+        included do
+          def self.store_image_url_for(store, attribute_name)
+            attachment = store.send(attribute_name)&.attachment
+            return unless attachment&.attached?
+
+            url_helpers = Rails.application.routes.url_helpers
+            if Spree.public_storage_service_name
+              url_helpers.cdn_image_url(attachment)
+            else
+              url_helpers.rails_blob_path(attachment)
+            end
+          end
+
+          attribute :logo do |store|
+            store_image_url_for store, :logo
+          end
+
+          attribute :mailer_logo do |store|
+            store_image_url_for store, :mailer_logo
+          end
+
+          attribute :favicon_path do |store|
+            store_image_url_for store, :favicon_image
+          end
+        end
+      end
+    end
+  end
+end

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/user_api_authentication.rb

@@ -0,0 +1,19 @@
+module Spree
+  module UserApiAuthentication
+    def generate_spree_api_key!
+      self.spree_api_key = generate_spree_api_key
+      save!
+    end
+
+    def clear_spree_api_key!
+      self.spree_api_key = nil
+      save!
+    end
+
+    private
+
+    def generate_spree_api_key
+      SecureRandom.hex(24)
+    end
+  end
+end

data/app/models/concerns/spree/user_api_methods.rb

@@ -0,0 +1,7 @@
+module Spree
+  module UserApiMethods
+    extend ActiveSupport::Concern
+
+    include Spree::UserApiAuthentication
+  end
+end

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

@@ -0,0 +1,84 @@
+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?
+          return if Spree::Webhooks::Subscriber.active.with_urls_for(event_name).none?
+          return if update_event?(event_name) && updating_only_ignored_attributes?
+          return if webhook_payload_body.blank?
+
+          Spree::Webhooks::Subscribers::QueueRequests.call(
+            event_name: event_name, webhook_payload_body: webhook_payload_body, **webhooks_request_options
+          )
+        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, include: included_relationships).serializable_hash.to_json
+      end
+
+      def inferred_event_name(operation)
+        "#{self.class.name.demodulize.tableize.singularize}.#{operation}"
+      end
+
+      def included_relationships
+        if resource_serializer.relationships_to_serialize
+          resource_serializer.relationships_to_serialize.keys
+        else
+          []
+        end
+      end
+
+      def resource_serializer
+        @resource_serializer ||=
+          begin
+            demodulized_class_name = self.class.to_s.demodulize
+            "Spree::Api::V2::Platform::#{demodulized_class_name}Serializer".constantize
+          end
+      end
+
+      def updating_only_ignored_attributes?
+        (saved_changes.keys - ignored_attributes).empty?
+      end
+
+      def ignored_attributes
+        timestamps = %w[created_at updated_at deleted_at]
+        return timestamps unless self.class.respond_to?(:ignored_attributes_for_update_webhook_event)
+
+        timestamps + self.class.ignored_attributes_for_update_webhook_event
+      end
+
+      def update_event?(event_name)
+        event_name.end_with?('.update')
+      end
+
+      def disable_spree_webhooks?
+        ENV['DISABLE_SPREE_WEBHOOKS'] == 'true'
+      end
+
+      def webhooks_request_options
+        {}
+      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,46 @@
+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 product.activated product.archived product.drafted]
+          end
+
+          def base.ignored_attributes_for_update_webhook_event
+            %w[status]
+          end
+
+          base.after_update_commit :queue_webhooks_requests_for_product_discontinued!
+        end
+
+        def after_activate
+          super
+          queue_webhooks_requests!('product.activated')
+        end
+
+        def after_archive
+          super
+          queue_webhooks_requests!('product.archived')
+        end
+
+        def after_draft
+          super
+          queue_webhooks_requests!('product.drafted')
+        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)