spree_api 3.6.6 → 3.7.0.rc1

data/app/controllers/spree/api/v2/storefront/account/credit_cards_controller.rb

@@ -0,0 +1,55 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Account
+          class CreditCardsController < ::Spree::Api::V2::BaseController
+            before_action :require_spree_current_user
+
+            def index
+              render_serialized_payload { serialize_collection(resource) }
+            end
+
+            def show
+              render_serialized_payload { serialize_resource(resource) }
+            end
+
+            private
+
+            def resource
+              dependencies[:resource_finder].new.execute(scope: scope, params: params)
+            end
+
+            def dependencies
+              {
+                resource_finder: Spree::CreditCards::Find,
+                collection_serializer: Spree::V2::Storefront::Account::CreditCardSerializer,
+                resource_serializer: Spree::V2::Storefront::Account::CreditCardSerializer
+              }
+            end
+
+            def serialize_collection(collection)
+              dependencies[:collection_serializer].new(
+                collection,
+                include: resource_includes,
+                fields: sparse_fields
+              ).serializable_hash
+            end
+
+            def serialize_resource(resource)
+              dependencies[:resource_serializer].new(
+                resource,
+                include: resource_includes,
+                fields: sparse_fields
+              ).serializable_hash
+            end
+
+            def scope
+              spree_current_user.credit_cards.accessible_by(current_ability, :read)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class AccountController < ::Spree::Api::V2::BaseController
+          before_action :require_spree_current_user
+
+          def show
+            render_serialized_payload { serialize_resource(resource) }
+          end
+
+          private
+
+          def resource
+            spree_current_user
+          end
+
+          def serialize_resource(resource)
+            dependencies[:resource_serializer].new(
+              resource,
+              include: resource_includes,
+              fields: sparse_fields
+            ).serializable_hash
+          end
+
+          def dependencies
+            { resource_serializer: Spree::V2::Storefront::AccountSerializer }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class CartController < ::Spree::Api::V2::BaseController
+          include Spree::Api::V2::Storefront::OrderConcern
+          before_action :ensure_order, except: :create
+
+          def create
+            spree_authorize! :create, Spree::Order
+
+            order_params = {
+              user: spree_current_user,
+              store: spree_current_store,
+              currency: current_currency
+            }
+
+            order   = spree_current_order if spree_current_order.present?
+            order ||= dependencies[:create_cart].call(order_params).value
+
+            render_serialized_payload(201) { serialize_order(order) }
+          end
+
+          def add_item
+            variant = Spree::Variant.find(params[:variant_id])
+
+            spree_authorize! :update, spree_current_order, order_token
+            spree_authorize! :show, variant
+
+            result = dependencies[:add_item_to_cart].call(
+              order: spree_current_order,
+              variant: variant,
+              quantity: params[:quantity],
+              options: params[:options]
+            )
+
+            render_order(result)
+          end
+
+          def remove_line_item
+            spree_authorize! :update, spree_current_order, order_token
+
+            dependencies[:remove_item_from_cart].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
+
+            spree_current_order.empty!
+
+            render_serialized_payload { serialized_current_order }
+          end
+
+          def set_quantity
+            return render_error_item_quantity unless params[:quantity].to_i > 0
+
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = dependencies[:set_item_quantity].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 = dependencies[: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
+
+            result = dependencies[:coupon_handler].new(spree_current_order).remove(params[:coupon_code])
+
+            if result.error.blank?
+              render_serialized_payload { serialized_current_order }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          private
+
+          def dependencies
+            {
+              create_cart: Spree::Cart::Create,
+              add_item_to_cart: Spree::Cart::AddItem,
+              remove_item_from_cart: Spree::Cart::RemoveLineItem,
+              cart_serializer: Spree::V2::Storefront::CartSerializer,
+              set_item_quantity: Spree::Cart::SetQuantity,
+              coupon_handler: Spree::PromotionHandler::Coupon
+            }
+          end
+
+          def line_item
+            @line_item ||= spree_current_order.line_items.find(params[:line_item_id])
+          end
+
+          def render_error_item_quantity
+            render json: { error: I18n.t(:wrong_quantity, scope: 'spree.api.v2.cart') }, status: 422
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+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 = dependencies[:next_state_handler].call(order: spree_current_order)
+
+            render_order(result)
+          end
+
+          def advance
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = dependencies[:advance_handler].call(order: spree_current_order)
+
+            render_order(result)
+          end
+
+          def complete
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = dependencies[:completer].call(order: spree_current_order)
+
+            render_order(result)
+          end
+
+          def update
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = dependencies[:updater].call(
+              order: spree_current_order,
+              params: params,
+              permitted_attributes: dependencies[:permitted_attributes],
+              request_env: request.headers.env
+            )
+
+            render_order(result)
+          end
+
+          def add_store_credit
+            spree_authorize! :update, spree_current_order, order_token
+
+            result = dependencies[:add_store_credit_handler].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 = dependencies[:remove_store_credit_handler].call(order: spree_current_order)
+            render_order(result)
+          end
+
+          def shipping_rates
+            result = dependencies[:shipping_rates_getter].call(order: spree_current_order)
+
+            render_serialized_payload { serialize_shipping_rates(result.value) }
+          end
+
+          def payment_methods
+            render_serialized_payload { serialize_payment_methods(spree_current_order.available_payment_methods) }
+          end
+
+          private
+
+          def dependencies
+            {
+              next_state_handler: Spree::Checkout::Next,
+              advance_handler: Spree::Checkout::Advance,
+              add_store_credit_handler: Spree::Checkout::AddStoreCredit,
+              remove_store_credit_handler: Spree::Checkout::RemoveStoreCredit,
+              completer: Spree::Checkout::Complete,
+              updater: Spree::Checkout::Update,
+              cart_serializer: Spree::V2::Storefront::CartSerializer,
+              payment_methods_serializer: Spree::V2::Storefront::PaymentMethodSerializer,
+              shipping_rates_getter: Spree::Checkout::GetShippingRates,
+              shipping_rates_serializer: Spree::V2::Storefront::ShipmentSerializer,
+              # defined in https://github.com/spree/spree/blob/master/core/lib/spree/core/controller_helpers/strong_parameters.rb#L19
+              permitted_attributes: permitted_checkout_attributes
+            }
+          end
+
+          def serialize_payment_methods(payment_methods)
+            dependencies[:payment_methods_serializer].new(payment_methods).serializable_hash
+          end
+
+          def serialize_shipping_rates(shipments)
+            dependencies[:shipping_rates_serializer].new(
+              shipments,
+              include: [:shipping_rates],
+              params: { show_rates: true }
+            ).serializable_hash
+          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::BaseController
+          include Spree::Api::V2::CollectionOptionsHelpers
+
+          def index
+            render_serialized_payload { serialize_collection(collection) }
+          end
+
+          def show
+            render_serialized_payload { serialize_resource(resource) }
+          end
+
+          private
+
+          def serialize_collection(collection)
+            dependencies[:collection_serializer].new(collection).serializable_hash
+          end
+
+          def serialize_resource(resource)
+            dependencies[:resource_serializer].new(
+              resource,
+              include: resource_includes,
+              fields: sparse_fields,
+              params: { include_states: true }
+            ).serializable_hash
+          end
+
+          def collection
+            dependencies[:collection_finder].new(scope, params).call
+          end
+
+          def resource
+            return scope.default if params[:iso] == 'default'
+
+            scope.find_by(iso: params[:iso]&.upcase) ||
+              scope.find_by(iso3: params[:iso]&.upcase)
+          end
+
+          def dependencies
+            {
+              collection_serializer: Spree::V2::Storefront::CountrySerializer,
+              resource_serializer: Spree::V2::Storefront::CountrySerializer,
+              collection_finder: Spree::Countries::Find
+            }
+          end
+
+          def scope
+            Spree::Country.accessible_by(current_ability, :read)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class ProductsController < ::Spree::Api::V2::BaseController
+          include Spree::Api::V2::CollectionOptionsHelpers
+
+          def index
+            render_serialized_payload { serialize_collection(paginated_collection) }
+          end
+
+          def show
+            render_serialized_payload { serialize_resource(resource) }
+          end
+
+          private
+
+          def serialize_collection(collection)
+            dependencies[:collection_serializer].new(
+              collection,
+              collection_options(collection)
+            ).serializable_hash
+          end
+
+          def serialize_resource(resource)
+            dependencies[:resource_serializer].new(
+              resource,
+              include: resource_includes,
+              fields: sparse_fields
+            ).serializable_hash
+          end
+
+          def paginated_collection
+            dependencies[:collection_paginator].new(sorted_collection, params).call
+          end
+
+          def sorted_collection
+            dependencies[:collection_sorter].new(collection, params, current_currency).call
+          end
+
+          def collection
+            dependencies[:collection_finder].new(scope: scope, params: params, current_currency: current_currency).execute
+          end
+
+          def resource
+            scope.find_by(slug: params[:id]) || scope.find(params[:id])
+          end
+
+          def dependencies
+            {
+              collection_sorter: Spree::Products::Sort,
+              collection_finder: Spree::Products::Find,
+              collection_paginator: Spree::Shared::Paginate,
+              collection_serializer: Spree::V2::Storefront::ProductSerializer,
+              resource_serializer: Spree::V2::Storefront::ProductSerializer
+            }
+          end
+
+          def collection_options(collection)
+            {
+              links: collection_links(collection),
+              meta: collection_meta(collection),
+              include: resource_includes,
+              fields: sparse_fields
+            }
+          end
+
+          def scope
+            Spree::Product.accessible_by(current_ability, :read).includes(scope_includes)
+          end
+
+          def scope_includes
+            {
+              master: :default_price,
+              variants: [],
+              variant_images: [],
+              taxons: [],
+              product_properties: :property,
+              option_types: :option_values,
+              variants_including_master: %i[default_price option_values]
+            }
+          end
+        end
+      end
+    end
+  end
+end