atkhayar-spree-dev-api 0.0.0

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

@@ -0,0 +1,245 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class CartController < ::Spree::Api::V2::BaseController
+          include OrderConcern
+          include CouponCodesHelper
+          include Spree::Api::V2::Storefront::MetadataControllerConcern
+
+          before_action :ensure_valid_metadata, only: %i[create add_item]
+          before_action :ensure_order, except: %i[create associate]
+          before_action :load_variant, only: :add_item
+          before_action :require_spree_current_user, only: :associate
+
+
+          def create
+            spree_authorize! :create, Spree::Order
+
+            create_cart_params = {
+              user: spree_current_user,
+              store: current_store,
+              currency: current_currency,
+              public_metadata: add_item_params[:public_metadata],
+              private_metadata: add_item_params[:private_metadata],
+            }
+
+            order   = spree_current_order if spree_current_order.present?
+            order ||= create_service.call(create_cart_params).value
+
+            render_serialized_payload(201) { serialize_resource(order) }
+          end
+
+          def add_item
+            spree_authorize! :update, spree_current_order, order_token
+            spree_authorize! :show, @variant
+
+            result = add_item_service.call(
+              order: spree_current_order,
+              variant: @variant,
+              quantity: add_item_params[:quantity],
+              public_metadata: add_item_params[:public_metadata],
+              private_metadata: add_item_params[:private_metadata],
+              options: add_item_params[:options]
+            )
+
+            render_order(result)
+          end
+
+          def remove_line_item
+            spree_authorize! :update, spree_current_order, order_token
+
+            remove_line_item_service.call(
+              order: spree_current_order,
+              line_item: line_item
+            )
+
+            render_serialized_payload { serialized_current_order }
+          end
+
+          def empty
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = empty_cart_service.call(order: spree_current_order)
+
+            if result.success?
+              render_serialized_payload { serialized_current_order }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          def destroy
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = destroy_cart_service.call(order: spree_current_order)
+
+            if result.success?
+              head 204
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          def set_quantity
+            return render_error_item_quantity unless params[:quantity].to_i > 0
+
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = set_item_quantity_service.call(order: spree_current_order, line_item: line_item, quantity: params[:quantity])
+
+            render_order(result)
+          end
+
+          def show
+            spree_authorize! :show, spree_current_order, order_token
+
+            render_serialized_payload { serialized_current_order }
+          end
+
+          def apply_coupon_code
+            spree_authorize! :update, spree_current_order, order_token
+
+            spree_current_order.coupon_code = params[:coupon_code]
+            result = coupon_handler.new(spree_current_order).apply
+
+            if result.error.blank?
+              render_serialized_payload { serialized_current_order }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          def remove_coupon_code
+            spree_authorize! :update, spree_current_order, order_token
+
+            coupon_codes = select_coupon_codes
+
+            return render_error_payload(I18n.t('spree.api.v2.cart.no_coupon_code')) if coupon_codes.empty?
+
+            result_errors = coupon_codes.count > 1 ? select_errors(coupon_codes) : select_error(coupon_codes)
+
+            if result_errors.blank?
+              render_serialized_payload { serialized_current_order }
+            else
+              render_error_payload(result_errors)
+            end
+          end
+
+          def estimate_shipping_rates
+            spree_authorize! :show, spree_current_order, order_token
+
+            result = estimate_shipping_rates_service.call(order: spree_current_order, country_iso: params[:country_iso])
+
+            if result.error.blank?
+              render_serialized_payload { serialize_estimated_shipping_rates(result.value) }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          def associate
+            guest_order_token = params[:guest_order_token]
+            guest_order = ::Spree::Api::Dependencies.storefront_current_order_finder.constantize.new.execute(
+              store: current_store,
+              user: nil,
+              token: guest_order_token,
+              currency: current_currency
+            )
+
+            spree_authorize! :update, guest_order, guest_order_token
+
+            result = associate_service.call(guest_order: guest_order, user: spree_current_user)
+
+            if result.success?
+              render_serialized_payload { serialize_resource(guest_order) }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          def change_currency
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = change_currency_service.call(order: spree_current_order, new_currency: params[:new_currency])
+
+            render_order(result)
+          end
+
+          private
+
+          def resource_serializer
+            Spree::Api::Dependencies.storefront_cart_serializer.constantize
+          end
+
+          def create_service
+            Spree::Api::Dependencies.storefront_cart_create_service.constantize
+          end
+
+          def add_item_service
+            Spree::Api::Dependencies.storefront_cart_add_item_service.constantize
+          end
+
+          def empty_cart_service
+            Spree::Api::Dependencies.storefront_cart_empty_service.constantize
+          end
+
+          def destroy_cart_service
+            Spree::Api::Dependencies.storefront_cart_destroy_service.constantize
+          end
+
+          def set_item_quantity_service
+            Spree::Api::Dependencies.storefront_cart_set_item_quantity_service.constantize
+          end
+
+          def remove_line_item_service
+            Spree::Api::Dependencies.storefront_cart_remove_line_item_service.constantize
+          end
+
+          def coupon_handler
+            Spree::Api::Dependencies.storefront_coupon_handler.constantize
+          end
+
+          def estimate_shipping_rates_service
+            Spree::Api::Dependencies.storefront_cart_estimate_shipping_rates_service.constantize
+          end
+
+          def associate_service
+            Spree::Api::Dependencies.storefront_cart_associate_service.constantize
+          end
+
+          def change_currency_service
+            Spree::Api::Dependencies.storefront_cart_change_currency_service.constantize
+          end
+
+          def line_item
+            @line_item ||= spree_current_order.line_items.find(params[:line_item_id])
+          end
+
+          def load_variant
+            @variant = current_store.variants.find(add_item_params[:variant_id])
+          end
+
+          def render_error_item_quantity
+            render json: { error: I18n.t(:wrong_quantity, scope: 'spree.api.v2.cart') }, status: 422
+          end
+
+          def estimate_shipping_rates_serializer
+            Spree::Api::Dependencies.storefront_estimated_shipment_serializer.constantize
+          end
+
+          def serialize_estimated_shipping_rates(shipping_rates)
+            estimate_shipping_rates_serializer.new(
+              shipping_rates,
+              params: serializer_params
+            ).serializable_hash
+          end
+
+          def add_item_params
+            params.permit(:quantity, :variant_id, public_metadata: {}, private_metadata: {}, options: {})
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class CheckoutController < ::Spree::Api::V2::BaseController
+          include Spree::Api::V2::Storefront::OrderConcern
+          before_action :ensure_order
+
+          def next
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = next_service.call(order: spree_current_order)
+
+            render_order(result)
+          end
+
+          def advance
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = advance_service.call(order: spree_current_order)
+
+            render_order(result)
+          end
+
+          def complete
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = complete_service.call(order: spree_current_order)
+
+            render_order(result)
+          end
+
+          def update
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = update_service.call(
+              order: spree_current_order,
+              params: params,
+              # defined in https://github.com/spree/spree/blob/master/core/lib/spree/core/controller_helpers/strong_parameters.rb#L19
+              permitted_attributes: permitted_checkout_attributes,
+              request_env: request.headers.env
+            )
+
+            render_order(result)
+          end
+
+          def create_payment
+            result = create_payment_service.call(order: spree_current_order, params: params)
+
+            if result.success?
+              render_serialized_payload(201) { serialize_resource(spree_current_order.reload) }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          def select_shipping_method
+            result = select_shipping_method_service.call(order: spree_current_order, params: params)
+
+            render_order(result)
+          end
+
+          def add_store_credit
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = add_store_credit_service.call(
+              order: spree_current_order,
+              amount: params[:amount].try(:to_f)
+            )
+
+            render_order(result)
+          end
+
+          def remove_store_credit
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = remove_store_credit_service.call(order: spree_current_order)
+            render_order(result)
+          end
+
+          def shipping_rates
+            result = shipping_rates_service.call(order: spree_current_order)
+
+            if result.success?
+              render_serialized_payload { serialize_shipping_rates(result.value) }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          def payment_methods
+            render_serialized_payload { serialize_payment_methods(spree_current_order.available_payment_methods) }
+          end
+
+          private
+
+          def resource_serializer
+            Spree::Api::Dependencies.storefront_cart_serializer.constantize
+          end
+
+          def next_service
+            Spree::Api::Dependencies.storefront_checkout_next_service.constantize
+          end
+
+          def advance_service
+            Spree::Api::Dependencies.storefront_checkout_advance_service.constantize
+          end
+
+          def add_store_credit_service
+            Spree::Api::Dependencies.storefront_checkout_add_store_credit_service.constantize
+          end
+
+          def remove_store_credit_service
+            Spree::Api::Dependencies.storefront_checkout_remove_store_credit_service.constantize
+          end
+
+          def complete_service
+            Spree::Api::Dependencies.storefront_checkout_complete_service.constantize
+          end
+
+          def update_service
+            Spree::Api::Dependencies.storefront_checkout_update_service.constantize
+          end
+
+          def payment_methods_serializer
+            Spree::Api::Dependencies.storefront_payment_method_serializer.constantize
+          end
+
+          def shipping_rates_service
+            Spree::Api::Dependencies.storefront_checkout_get_shipping_rates_service.constantize
+          end
+
+          def shipping_rates_serializer
+            Spree::Api::Dependencies.storefront_shipment_serializer.constantize
+          end
+
+          def create_payment_service
+            Spree::Api::Dependencies.storefront_payment_create_service.constantize
+          end
+
+          def select_shipping_method_service
+            Spree::Api::Dependencies.storefront_checkout_select_shipping_method_service.constantize
+          end
+
+          def serialize_payment_methods(payment_methods)
+            payment_methods_serializer.new(payment_methods, params: serializer_params).serializable_hash
+          end
+
+          def serialize_shipping_rates(shipments)
+            shipping_rates_serializer.new(
+              shipments,
+              params: serializer_params,
+              include: [:shipping_rates, :stock_location, :line_items]
+            ).serializable_hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class CmsPagesController < ::Spree::Api::V2::ResourceController
+          private
+
+          def model_class
+            Spree::CmsPage
+          end
+
+          def resource
+            @resource ||= scope.find_by(slug: params[:id]) || scope.find(params[:id])
+          end
+
+          def resource_serializer
+            Spree::Api::Dependencies.storefront_cms_page_serializer.constantize
+          end
+
+          def collection_serializer
+            Spree::Api::Dependencies.storefront_cms_page_serializer.constantize
+          end
+
+          def collection_finder
+            Spree::Api::Dependencies.storefront_cms_page_finder.constantize
+          end
+
+          def scope
+            super.by_locale(I18n.locale)
+          end
+
+          def scope_includes
+            {
+              cms_sections: :linked_resource
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class CountriesController < ::Spree::Api::V2::ResourceController
+          before_action :set_default_per_page
+
+          private
+
+          def serialize_collection(collection)
+            collection_serializer.new(
+              collection,
+              collection_options(collection).merge(params: collection_serializer_params)
+            ).serializable_hash
+          end
+
+          def serializer_params
+            super.merge(include_states: true)
+          end
+
+          def collection_serializer_params
+            serializer_params.merge(include_states: false)
+          end
+
+          def resource
+            return current_store.default_country if params[:iso] == 'default'
+
+            scope.find_by(iso: params[:iso]&.upcase) ||
+              scope.find_by(id: params[:iso]&.upcase) ||
+              scope.find_by(iso3: params[:iso]&.upcase)
+          end
+
+          def resource_serializer
+            Spree::Api::Dependencies.storefront_country_serializer.constantize
+          end
+
+          def collection_serializer
+            Spree::Api::Dependencies.storefront_country_serializer.constantize
+          end
+
+          def collection_finder
+            Spree::Api::Dependencies.storefront_country_finder.constantize
+          end
+
+          def model_class
+            Spree::Country
+          end
+
+          # by default we want to return all countries on a single page
+          def set_default_per_page
+            params[:per_page] ||= Spree::Country.count
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class DigitalsController < ::Spree::Api::V2::ResourceController
+          def download
+            if attachment.present?
+              if digital_link.authorize!
+                if defined?(ActiveStorage::Service::DiskService) && ActiveStorage::Blob.service.instance_of?(ActiveStorage::Service::DiskService)
+                  # The asset is hosted on disk, use send_file.
+
+                  send_file(
+                    ActiveStorage::Blob.service.path_for(attachment.key),
+                    filename: attachment.filename.to_s,
+                    type: attachment.content_type.to_s,
+                    status: :ok
+                  ) and return
+
+                else
+                  # The asset is hosted on a 3rd party service, use an expiring url with disposition: 'attachment'.
+
+                  redirect_to attachment.url(
+                    expires_in: current_store.digital_asset_link_expire_time.seconds,
+                    disposition: 'attachment',
+                    host: digital_attachment_host
+                  ) and return
+
+                end
+              end
+            else
+              Rails.logger.error I18n.t('spree.api.v2.digitals.missing_file')
+            end
+
+            render json: { error: I18n.t('spree.api.v2.digitals.unauthorized') }, status: 403
+          end
+
+          private
+
+          def model_class
+            Spree::Digital
+          end
+
+          def digital_link
+            @digital_link ||= DigitalLink.find_by!(token: params[:token])
+          end
+
+          def attachment
+            @attachment ||= digital_link.digital.try(:attachment) if digital_link.present?
+          end
+
+          def digital_attachment_host
+            current_store.formatted_url
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class MenusController < ::Spree::Api::V2::ResourceController
+          private
+
+          def resource_serializer
+            Spree::Api::Dependencies.storefront_menu_serializer.constantize
+          end
+
+          def collection_serializer
+            Spree::Api::Dependencies.storefront_menu_serializer.constantize
+          end
+
+          def collection_finder
+            Spree::Api::Dependencies.storefront_menu_finder.constantize
+          end
+
+          def model_class
+            Spree::Menu
+          end
+
+          def scope
+            super.by_locale(I18n.locale)
+          end
+
+          def scope_includes
+            { menu_items: [:children, :parent, :icon] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class OrderStatusController < ::Spree::Api::V2::ResourceController
+          include Spree::Api::V2::Storefront::OrderConcern
+
+          before_action :ensure_order_token
+
+          private
+
+          def resource
+            resource = resource_finder.new(number: params[:number], token: order_token, store: current_store).execute.take
+            raise ActiveRecord::RecordNotFound if resource.nil?
+
+            resource
+          end
+
+          def resource_finder
+            Spree::Api::Dependencies.storefront_completed_order_finder.constantize
+          end
+
+          def resource_serializer
+            Spree::Api::Dependencies.storefront_cart_serializer.constantize
+          end
+
+          def ensure_order_token
+            raise ActiveRecord::RecordNotFound unless order_token.present?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class ProductsController < ::Spree::Api::V2::ResourceController
+          include ::Spree::Api::V2::ProductListIncludes
+
+          protected
+
+          def sorted_collection
+            collection_sorter.new(collection, current_currency, params, allowed_sort_attributes).call
+          end
+
+          def collection
+            @collection ||= collection_finder.new(scope: scope, params: finder_params).execute
+          end
+
+          def resource
+            @resource ||= scope.find_by(slug: params[:id]) || scope.find(params[:id])
+          end
+
+          def collection_sorter
+            Spree::Api::Dependencies.storefront_products_sorter.constantize
+          end
+
+          def collection_finder
+            Spree::Api::Dependencies.storefront_products_finder.constantize
+          end
+
+          def collection_serializer
+            Spree::Api::Dependencies.storefront_product_serializer.constantize
+          end
+
+          def resource_serializer
+            Spree::Api::Dependencies.storefront_product_serializer.constantize
+          end
+
+          def model_class
+            Spree::Product
+          end
+
+          def scope_includes
+            product_list_includes
+          end
+
+          def allowed_sort_attributes
+            super << :available_on
+          end
+
+          def collection_meta(collection)
+            super(collection).merge(filters: filters_meta)
+          end
+
+          def filters_meta
+            Spree::Api::Products::FiltersPresenter.new(current_store, current_currency, params).to_h
+          end
+        end
+      end
+    end
+  end
+end