spree_legacy_api_v2 1.0.0

data/app/controllers/spree/api/v2/platform/variants_controller.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class VariantsController < ResourceController
+          private
+
+          def model_class
+            Spree::Variant
+          end
+
+          def spree_permitted_attributes
+            super + [:option_value_ids, :price, :currency]
+          end
+
+          def resource_serializer
+            Spree.api.platform_variant_serializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/platform/wished_items_controller.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class WishedItemsController < ResourceController
+          private
+
+          def scope_includes
+            [:variant]
+          end
+
+          def model_class
+            Spree::WishedItem
+          end
+
+          def resource_serializer
+            Spree.api.platform_wished_item_serializer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class WishlistsController < ResourceController
+          private
+
+          def model_class
+            Spree::Wishlist
+          end
+
+          def scope_includes
+            [:wished_items]
+          end
+
+          def resource_serializer
+            Spree.api.platform_wishlist_serializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/platform/zones_controller.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class ZonesController < ResourceController
+          private
+
+          def model_class
+            Spree::Zone
+          end
+
+          def scope_includes
+            [:zone_members]
+          end
+
+          def resource_serializer
+            Spree.api.platform_zone_serializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/resource_controller.rb

@@ -0,0 +1,79 @@
+module Spree
+  module Api
+    module V2
+      class ResourceController < ::Spree::Api::V2::BaseController
+        include Spree::Api::V2::CollectionOptionsHelpers
+        include Spree::Api::V2::Caching
+
+        def index
+          render_serialized_payload do
+            Rails.cache.fetch(collection_cache_key(paginated_collection), collection_cache_opts) do
+              serialize_collection(paginated_collection)
+            end
+          end
+        end
+
+        def show
+          render_serialized_payload { serialize_resource(resource) }
+        end
+
+        protected
+
+        def sorted_collection
+          @sorted_collection ||= collection_sorter.new(collection, params, allowed_sort_attributes).call
+        end
+
+        def allowed_sort_attributes
+          default_sort_attributes
+        end
+
+        def default_sort_attributes
+          [:id, :name, :slug, :number, :position, :updated_at, :created_at, :deleted_at]
+        end
+
+        def scope(skip_cancancan: false)
+          base_scope = model_class.for_store(current_store)
+          base_scope = base_scope.accessible_by(current_ability, :show) unless skip_cancancan
+          base_scope = base_scope.includes(scope_includes) if scope_includes.any? && action_name == 'index'
+          model_class.include?(TranslatableResource) ? base_scope.i18n : base_scope
+        end
+
+        def scope_includes
+          []
+        end
+
+        def resource
+          @resource ||= if defined?(resource_finder)
+                          resource_finder.new(scope: scope, params: finder_params).execute
+                        else
+                          scope.find(params[:id])
+                        end
+        end
+
+        def collection
+          @collection ||= begin
+            result = if defined?(collection_finder)
+                       collection_finder.new(scope: scope, params: finder_params).execute
+                     else
+                       scope
+                     end
+            result.preload_associations_lazily
+          end
+        end
+
+        def finder_params
+          params.merge(
+            store: current_store,
+            locale: current_locale,
+            currency: current_currency,
+            user: spree_current_user
+          )
+        end
+
+        def collection_sorter
+          Spree.api.storefront_collection_sorter
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Account
+          class AddressesController < ::Spree::Api::V2::ResourceController
+            include Spree::BaseHelper
+
+            before_action :require_spree_current_user
+
+            def create
+              spree_authorize! :create, model_class
+
+              result = create_service.call(user: spree_current_user, address_params: address_params)
+              render_result(result)
+            end
+
+            def update
+              spree_authorize! :update, resource
+
+              result = update_service.call(address: resource, address_params: address_params)
+              render_result(result)
+            end
+
+            def destroy
+              spree_authorize! :destroy, resource
+
+              if resource.destroy
+                head 204
+              else
+                render_error_payload(resource.errors)
+              end
+            end
+
+            private
+
+            def collection
+              collection_finder.new(scope: scope, params: finder_params).execute
+            end
+
+            def scope
+              super.where(user: spree_current_user, country: available_countries).not_deleted
+            end
+
+            def model_class
+              Spree::Address
+            end
+
+            def collection_finder
+              Spree.api.storefront_address_finder
+            end
+
+            def collection_serializer
+              Spree.api.storefront_address_serializer
+            end
+
+            def resource_serializer
+              Spree.api.storefront_address_serializer
+            end
+
+            def create_service
+              Spree.api.storefront_address_create_service
+            end
+
+            def update_service
+              Spree.api.storefront_address_update_service
+            end
+
+            def address_params
+              params.require(:address).permit(permitted_address_attributes)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Account
+          class CreditCardsController < ::Spree::Api::V2::ResourceController
+            before_action :require_spree_current_user
+
+            def destroy
+              spree_authorize! :destroy, resource, resource
+
+              destroy_service.call(card: resource)
+            end
+
+            private
+
+            def resource
+              params[:id].eql?('default') ? scope.default.first! : scope.find(params[:id])
+            end
+
+            def model_class
+              Spree::CreditCard
+            end
+
+            def scope
+              super.not_expired.not_removed.where(
+                user: spree_current_user,
+                payment_method: current_store.payment_methods.available_on_front_end
+              )
+            end
+
+            def collection_serializer
+              Spree.api.storefront_credit_card_serializer
+            end
+
+            def collection_finder
+              Spree.api.storefront_credit_card_finder
+            end
+
+            def resource_serializer
+              Spree.api.storefront_credit_card_serializer
+            end
+
+            def destroy_service
+              Spree.api.storefront_credit_cards_destroy_service
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Account
+          class OrdersController < ::Spree::Api::V2::ResourceController
+            before_action :require_spree_current_user
+
+            private
+
+            def collection
+              collection_finder.new(user: spree_current_user, store: current_store).execute
+            end
+
+            def resource
+              resource = resource_finder.new(user: spree_current_user, number: params[:id], store: current_store).execute.take
+              raise ActiveRecord::RecordNotFound if resource.nil?
+
+              resource
+            end
+
+            def allowed_sort_attributes
+              super << :completed_at
+            end
+
+            def collection_serializer
+              Spree.api.storefront_order_serializer
+            end
+
+            def resource_serializer
+              Spree.api.storefront_order_serializer
+            end
+
+            def collection_finder
+              Spree.api.storefront_completed_order_finder
+            end
+
+            def resource_finder
+              Spree.api.storefront_completed_order_finder
+            end
+
+            def model_class
+              Spree::Order
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class AccountController < ::Spree::Api::V2::ResourceController
+          before_action :require_spree_current_user, except: :create
+
+          def create
+            result = create_service.call(user_params: user_create_params)
+            render_result(result)
+          end
+
+          def update
+            spree_authorize! :update, spree_current_user
+            result = update_service.call(user: spree_current_user, user_params: user_update_params)
+            render_result(result)
+          end
+
+          private
+
+          def resource
+            spree_current_user
+          end
+
+          def resource_serializer
+            Spree.api.storefront_user_serializer
+          end
+
+          def model_class
+            Spree.user_class
+          end
+
+          def create_service
+            Spree.api.storefront_account_create_service
+          end
+
+          def update_service
+            Spree.api.storefront_account_update_service
+          end
+
+          def user_create_params
+            user_update_params.except(:bill_address_id, :ship_address_id)
+          end
+
+          def user_update_params
+            params.require(:user).permit(permitted_user_attributes)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,246 @@
+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?
+              spree_current_order.reload
+              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?
+              spree_current_order.reload
+              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.storefront_current_order_finder.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.storefront_cart_serializer
+          end
+
+          def create_service
+            Spree.api.storefront_cart_create_service
+          end
+
+          def add_item_service
+            Spree.api.storefront_cart_add_item_service
+          end
+
+          def empty_cart_service
+            Spree.api.storefront_cart_empty_service
+          end
+
+          def destroy_cart_service
+            Spree.api.storefront_cart_destroy_service
+          end
+
+          def set_item_quantity_service
+            Spree.api.storefront_cart_set_item_quantity_service
+          end
+
+          def remove_line_item_service
+            Spree.api.storefront_cart_remove_line_item_service
+          end
+
+          def coupon_handler
+            Spree.api.storefront_coupon_handler
+          end
+
+          def estimate_shipping_rates_service
+            Spree.api.storefront_cart_estimate_shipping_rates_service
+          end
+
+          def associate_service
+            Spree.api.storefront_cart_associate_service
+          end
+
+          def change_currency_service
+            Spree.api.storefront_cart_change_currency_service
+          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.storefront_estimated_shipment_serializer
+          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