spree_api 3.0.10 → 3.1.0.rc1

data/CHANGELOG.md

@@ -1,3 +0,0 @@
-## Spree 3.0.0 (unreleased) ##
-
-* Deprecate the Spree::Api::ConfigController

data/app/controllers/spree/api/addresses_controller.rb

@@ -1,43 +0,0 @@
-module Spree
-  module Api
-    class AddressesController < Spree::Api::BaseController
-      before_action :find_order
-
-      def show
-        authorize! :read, @order, order_token
-        find_address
-        respond_with(@address)
-      end
-
-      def update
-        authorize! :update, @order, order_token
-        find_address
-
-        if @address.update_attributes(address_params)
-          respond_with(@address, :default_template => :show)
-        else
-          invalid_resource!(@address)
-        end
-      end
-
-      private
-        def address_params
-          params.require(:address).permit(permitted_address_attributes)
-        end
-
-        def find_order
-          @order = Spree::Order.find_by!(number: order_id)
-        end
-
-        def find_address
-          @address = if @order.bill_address_id == params[:id].to_i
-            @order.bill_address
-          elsif @order.ship_address_id == params[:id].to_i
-            @order.ship_address
-          else
-            raise CanCan::AccessDenied
-          end
-        end
-    end
-  end
-end

data/app/controllers/spree/api/checkouts_controller.rb

@@ -1,98 +0,0 @@
-module Spree
-  module Api
-    class CheckoutsController < Spree::Api::BaseController
-      before_action :associate_user, only: :update
-
-      include Spree::Core::ControllerHelpers::Auth
-      include Spree::Core::ControllerHelpers::Order
-      # This before_action comes from Spree::Core::ControllerHelpers::Order
-      skip_before_action :set_current_order
-
-      def next
-        load_order(true)
-        authorize! :update, @order, order_token
-        @order.next!
-        respond_with(@order, default_template: 'spree/api/orders/show', status: 200)
-      rescue StateMachines::InvalidTransition
-        respond_with(@order, default_template: 'spree/api/orders/could_not_transition', status: 422)
-      end
-
-      def advance
-        load_order(true)
-        authorize! :update, @order, order_token
-        while @order.next; end
-        respond_with(@order, default_template: 'spree/api/orders/show', status: 200)
-      end
-
-      def update
-        load_order(true)
-        authorize! :update, @order, order_token
-
-        if @order.update_from_params(params, permitted_checkout_attributes, request.headers.env)
-          if current_api_user.has_spree_role?('admin') && user_id.present?
-            @order.associate_user!(Spree.user_class.find(user_id))
-          end
-
-          return if after_update_attributes
-
-          if @order.completed? || @order.next
-            state_callback(:after)
-            respond_with(@order, default_template: 'spree/api/orders/show')
-          else
-            respond_with(@order, default_template: 'spree/api/orders/could_not_transition', status: 422)
-          end
-        else
-          invalid_resource!(@order)
-        end
-      end
-
-      private
-        def user_id
-          params[:order][:user_id] if params[:order]
-        end
-
-        def nested_params
-          map_nested_attributes_keys Spree::Order, params[:order] || {}
-        end
-
-        # Should be overriden if you have areas of your checkout that don't match
-        # up to a step within checkout_steps, such as a registration step
-        def skip_state_validation?
-          false
-        end
-
-        def load_order(lock = false)
-          @order = Spree::Order.lock(lock).find_by!(number: params[:id])
-          raise_insufficient_quantity and return if @order.insufficient_stock_lines.present?
-          @order.state = params[:state] if params[:state]
-          state_callback(:before)
-        end
-
-        def raise_insufficient_quantity
-          respond_with(@order, default_template: 'spree/api/orders/insufficient_quantity')
-        end
-
-        def state_callback(before_or_after = :before)
-          method_name = :"#{before_or_after}_#{@order.state}"
-          send(method_name) if respond_to?(method_name, true)
-        end
-
-        def after_update_attributes
-          if nested_params && nested_params[:coupon_code].present?
-            handler = Spree::PromotionHandler::Coupon.new(@order).apply
-
-            if handler.error.present?
-              @coupon_message = handler.error
-              respond_with(@order, default_template: 'spree/api/orders/could_not_apply_coupon')
-              return true
-            end
-          end
-          false
-        end
-
-        def order_id
-          super || params[:id]
-        end
-    end
-  end
-end

data/app/controllers/spree/api/classifications_controller.rb

@@ -1,18 +0,0 @@
-module Spree
-  module Api
-    class ClassificationsController < Spree::Api::BaseController
-      def update
-        authorize! :update, Product
-        authorize! :update, Taxon
-        classification = Spree::Classification.find_by(
-          :product_id => params[:product_id],
-          :taxon_id => params[:taxon_id]
-        )
-        # Because position we get back is 0-indexed.
-        # acts_as_list is 1-indexed.
-        classification.insert_at(params[:position].to_i + 1)
-        render :nothing => true
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module Spree
-  module Api
-    class CountriesController < Spree::Api::BaseController
-      skip_before_action :check_for_user_or_api_key
-      skip_before_action :authenticate_user
-
-      def index
-        @countries = Spree::Country.accessible_by(current_ability, :read).ransack(params[:q]).result.
-                     includes(:states).order('name ASC').
-                     page(params[:page]).per(params[:per_page])
-        country = Spree::Country.order("updated_at ASC").last
-        if stale?(country)
-          respond_with(@countries)
-        end
-      end
-
-      def show
-        @country = Spree::Country.accessible_by(current_ability, :read).find(params[:id])
-        respond_with(@country)
-      end
-    end
-  end
-end

data/app/controllers/spree/api/credit_cards_controller.rb

@@ -1,25 +0,0 @@
-module Spree
-  module Api
-    class CreditCardsController < Spree::Api::BaseController
-      before_action :user
-
-      def index
-        @credit_cards = user
-          .credit_cards
-          .accessible_by(current_ability, :read)
-          .with_payment_profile
-          .ransack(params[:q]).result.page(params[:page]).per(params[:per_page])
-        respond_with(@credit_cards)
-      end
-
-      private
-
-        def user
-          if params[:user_id].present?
-            @user ||= Spree::user_class.accessible_by(current_ability, :read).find(params[:user_id])
-          end
-        end
-
-    end
-  end
-end

data/app/controllers/spree/api/images_controller.rb

@@ -1,47 +0,0 @@
-module Spree
-  module Api
-    class ImagesController < Spree::Api::BaseController
-
-      def index
-        @images = scope.images.accessible_by(current_ability, :read)
-        respond_with(@images)
-      end
-
-      def show
-        @image = Spree::Image.accessible_by(current_ability, :read).find(params[:id])
-        respond_with(@image)
-      end
-
-      def create
-        authorize! :create, Spree::Image
-        @image = scope.images.create(image_params)
-        respond_with(@image, :status => 201, :default_template => :show)
-      end
-
-      def update
-        @image = scope.images.accessible_by(current_ability, :update).find(params[:id])
-        @image.update_attributes(image_params)
-        respond_with(@image, :default_template => :show)
-      end
-
-      def destroy
-        @image = scope.images.accessible_by(current_ability, :destroy).find(params[:id])
-        @image.destroy
-        respond_with(@image, :status => 204)
-      end
-
-      private
-        def image_params
-          params.require(:image).permit(permitted_image_attributes)
-        end
-
-        def scope
-          if params[:product_id]
-            scope = Spree::Product.friendly.find(params[:product_id])
-          elsif params[:variant_id]
-            scope = Spree::Variant.find(params[:variant_id])
-          end
-        end
-    end
-  end
-end

data/app/controllers/spree/api/inventory_units_controller.rb

@@ -1,52 +0,0 @@
-module Spree
-  module Api
-    class InventoryUnitsController < Spree::Api::BaseController
-      before_action :prepare_event, only: :update
-
-      def show
-        @inventory_unit = inventory_unit
-        respond_with(@inventory_unit)
-      end
-
-      def update
-        authorize! :update, inventory_unit.order
-
-        inventory_unit.transaction do
-          if inventory_unit.update_attributes(inventory_unit_params)
-            fire
-            render :show, :status => 200
-          else
-            invalid_resource!(inventory_unit)
-          end
-        end
-      end
-
-      private
-
-      def inventory_unit
-        @inventory_unit ||= Spree::InventoryUnit.accessible_by(current_ability, :read).find(params[:id])
-      end
-
-      def prepare_event
-        return unless @event = params[:fire]
-
-        can_event = "can_#{@event}?"
-
-        unless inventory_unit.respond_to?(can_event) &&
-               inventory_unit.send(can_event)
-          render :text => { :exception => "cannot transition to #{@event}" }.to_json,
-                 :status => 200
-          false
-        end
-      end
-
-      def fire
-        inventory_unit.send("#{@event}!") if @event
-      end
-      
-      def inventory_unit_params
-        params.require(:inventory_unit).permit(permitted_inventory_unit_attributes)
-      end
-    end
-  end
-end

data/app/controllers/spree/api/line_items_controller.rb

@@ -1,69 +0,0 @@
-module Spree
-  module Api
-    class LineItemsController < Spree::Api::BaseController
-      class_attribute :line_item_options
-
-      self.line_item_options = []
-
-      def create
-        variant = Spree::Variant.find(params[:line_item][:variant_id])
-        @line_item = order.contents.add(
-            variant,
-            params[:line_item][:quantity] || 1,
-            line_item_params[:options] || {}
-        )
-
-        if @line_item.errors.empty?
-          respond_with(@line_item, status: 201, default_template: :show)
-        else
-          invalid_resource!(@line_item)
-        end
-      end
-
-      def update
-        @line_item = find_line_item
-        if @order.contents.update_cart(line_items_attributes)
-          @line_item.reload
-          respond_with(@line_item, default_template: :show)
-        else
-          invalid_resource!(@line_item)
-        end
-      end
-
-      def destroy
-        @line_item = find_line_item
-        variant = Spree::Variant.unscoped.find(@line_item.variant_id)
-        @order.contents.remove(variant, @line_item.quantity)
-        respond_with(@line_item, status: 204)
-      end
-
-      private
-        def order
-          @order ||= Spree::Order.includes(:line_items).find_by!(number: order_id)
-          authorize! :update, @order, order_token
-        end
-
-        def find_line_item
-          id = params[:id].to_i
-          order.line_items.detect { |line_item| line_item.id == id } or
-              raise ActiveRecord::RecordNotFound
-        end
-
-        def line_items_attributes
-          {line_items_attributes: {
-              id: params[:id],
-              quantity: params[:line_item][:quantity],
-              options: line_item_params[:options] || {}
-          }}
-        end
-
-        def line_item_params
-          params.require(:line_item).permit(
-              :quantity,
-              :variant_id,
-              options: line_item_options
-          )
-        end
-    end
-  end
-end

data/app/controllers/spree/api/option_types_controller.rb

@@ -1,49 +0,0 @@
-module Spree
-  module Api
-    class OptionTypesController < Spree::Api::BaseController
-      def index
-        if params[:ids]
-          @option_types = Spree::OptionType.includes(:option_values).accessible_by(current_ability, :read).where(id: params[:ids].split(','))
-        else
-          @option_types = Spree::OptionType.includes(:option_values).accessible_by(current_ability, :read).load.ransack(params[:q]).result
-        end
-        respond_with(@option_types)
-      end
-
-      def show
-        @option_type = Spree::OptionType.accessible_by(current_ability, :read).find(params[:id])
-        respond_with(@option_type)
-      end
-
-      def create
-        authorize! :create, Spree::OptionType
-        @option_type = Spree::OptionType.new(option_type_params)
-        if @option_type.save
-          render :show, :status => 201
-        else
-          invalid_resource!(@option_type)
-        end
-      end
-
-      def update
-        @option_type = Spree::OptionType.accessible_by(current_ability, :update).find(params[:id])
-        if @option_type.update_attributes(option_type_params)
-          render :show
-        else
-          invalid_resource!(@option_type)
-        end
-      end
-
-      def destroy
-        @option_type = Spree::OptionType.accessible_by(current_ability, :destroy).find(params[:id])
-        @option_type.destroy
-        render :text => nil, :status => 204
-      end
-
-      private
-        def option_type_params
-          params.require(:option_type).permit(permitted_option_type_attributes)
-        end
-    end
-  end
-end

data/app/controllers/spree/api/option_values_controller.rb

@@ -1,58 +0,0 @@
-module Spree
-  module Api
-    class OptionValuesController < Spree::Api::BaseController
-      def index
-        if params[:ids]
-          @option_values = scope.where(:id => params[:ids])
-        else
-          @option_values = scope.ransack(params[:q]).result.distinct
-        end
-        respond_with(@option_values)
-      end
-
-      def show
-        @option_value = scope.find(params[:id])
-        respond_with(@option_value)
-      end
-
-      def create
-        authorize! :create, Spree::OptionValue
-        @option_value = scope.new(option_value_params)
-        if @option_value.save
-          render :show, :status => 201
-        else
-          invalid_resource!(@option_value)
-        end
-      end
-
-      def update
-        @option_value = scope.accessible_by(current_ability, :update).find(params[:id])
-        if @option_value.update_attributes(option_value_params)
-          render :show
-        else
-          invalid_resource!(@option_value)
-        end
-      end
-
-      def destroy
-        @option_value = scope.accessible_by(current_ability, :destroy).find(params[:id])
-        @option_value.destroy
-        render :text => nil, :status => 204
-      end
-
-      private
-
-        def scope
-          if params[:option_type_id]
-            @scope ||= Spree::OptionType.find(params[:option_type_id]).option_values.accessible_by(current_ability, :read)
-          else
-            @scope ||= Spree::OptionValue.accessible_by(current_ability, :read).load
-          end
-        end
-
-        def option_value_params
-          params.require(:option_value).permit(permitted_option_value_attributes)
-        end
-    end
-  end
-end