spree_api 4.4.0 → 4.5.0

data/app/controllers/spree/api/v1/return_authorizations_controller.rb

@@ -1,70 +0,0 @@
-module Spree
-  module Api
-    module V1
-      class ReturnAuthorizationsController < Spree::Api::BaseController
-        def create
-          authorize! :create, ReturnAuthorization
-          @return_authorization = order.return_authorizations.build(return_authorization_params)
-          if @return_authorization.save
-            respond_with(@return_authorization, status: 201, default_template: :show)
-          else
-            invalid_resource!(@return_authorization)
-          end
-        end
-
-        def destroy
-          @return_authorization = order.return_authorizations.accessible_by(current_ability, :destroy).find(params[:id])
-          @return_authorization.destroy
-          respond_with(@return_authorization, status: 204)
-        end
-
-        def index
-          authorize! :admin, ReturnAuthorization
-          @return_authorizations = order.return_authorizations.accessible_by(current_ability).
-                                   ransack(params[:q]).result.
-                                   page(params[:page]).per(params[:per_page])
-          respond_with(@return_authorizations)
-        end
-
-        def new
-          authorize! :admin, ReturnAuthorization
-        end
-
-        def show
-          authorize! :admin, ReturnAuthorization
-          @return_authorization = order.return_authorizations.accessible_by(current_ability, :show).find(params[:id])
-          respond_with(@return_authorization)
-        end
-
-        def update
-          @return_authorization = order.return_authorizations.accessible_by(current_ability, :update).find(params[:id])
-          if @return_authorization.update(return_authorization_params)
-            respond_with(@return_authorization, default_template: :show)
-          else
-            invalid_resource!(@return_authorization)
-          end
-        end
-
-        def cancel
-          @return_authorization = order.return_authorizations.accessible_by(current_ability, :update).find(params[:id])
-          if @return_authorization.cancel
-            respond_with @return_authorization, default_template: :show
-          else
-            invalid_resource!(@return_authorization)
-          end
-        end
-
-        private
-
-        def order
-          @order ||= Spree::Order.find_by!(number: order_id)
-          authorize! :show, @order
-        end
-
-        def return_authorization_params
-          params.require(:return_authorization).permit(permitted_return_authorization_attributes)
-        end
-      end
-    end
-  end
-end

data/app/controllers/spree/api/v1/shipments_controller.rb

@@ -1,196 +0,0 @@
-module Spree
-  module Api
-    module V1
-      class ShipmentsController < Spree::Api::BaseController
-        before_action :find_and_update_shipment, only: [:ship, :ready, :add, :remove]
-        before_action :load_transfer_params, only: [:transfer_to_location, :transfer_to_shipment]
-
-        def mine
-          if current_api_user.persisted?
-            @shipments = Spree::Shipment.
-                         reverse_chronological.
-                         joins(:order).
-                         where(spree_orders: { user_id: current_api_user.id }).
-                         includes(mine_includes).
-                         ransack(params[:q]).result.page(params[:page]).per(params[:per_page])
-          else
-            render 'spree/api/errors/unauthorized', status: :unauthorized
-          end
-        end
-
-        def create
-          @order = Spree::Order.find_by!(number: params.fetch(:shipment).fetch(:order_id))
-          authorize! :show, @order
-          authorize! :create, Shipment
-          quantity = params[:quantity].to_i
-          @shipment = @order.shipments.create(stock_location_id: params.fetch(:stock_location_id))
-
-          @line_item = Spree::Dependencies.cart_add_item_service.constantize.call(order: @order,
-                                                                                  variant: variant,
-                                                                                  quantity: quantity,
-                                                                                  options: { shipment: @shipment }).value
-
-          respond_with(@shipment.reload, default_template: :show)
-        end
-
-        def update
-          @shipment = Spree::Shipment.accessible_by(current_ability, :update).readonly(false).find_by!(number: params[:id])
-          @shipment.update_attributes_and_order(shipment_params)
-
-          respond_with(@shipment.reload, default_template: :show)
-        end
-
-        def ready
-          unless @shipment.ready?
-            if @shipment.can_ready?
-              @shipment.ready!
-            else
-              render 'spree/api/v1/shipments/cannot_ready_shipment', status: 422 and return
-            end
-          end
-          respond_with(@shipment, default_template: :show)
-        end
-
-        def ship
-          @shipment.ship! unless @shipment.shipped?
-          respond_with(@shipment, default_template: :show)
-        end
-
-        def add
-          quantity = params[:quantity].to_i
-
-          Spree::Dependencies.cart_add_item_service.constantize.call(order: @shipment.order,
-                                                                     variant: variant,
-                                                                     quantity: quantity,
-                                                                     options: { shipment: @shipment })
-
-          respond_with(@shipment, default_template: :show)
-        end
-
-        def remove
-          quantity = if params.key?(:quantity)
-                       params[:quantity].to_i
-                     else
-                       @shipment.inventory_units_for(variant).sum(:quantity)
-                     end
-
-          Spree::Dependencies.cart_remove_item_service.constantize.call(order: @shipment.order,
-                                                                        variant: variant,
-                                                                        quantity: quantity,
-                                                                        options: { shipment: @shipment })
-
-          if @shipment.inventory_units.any?
-            @shipment.reload
-          else
-            @shipment.destroy!
-          end
-
-          respond_with(@shipment, default_template: :show)
-        end
-
-        def transfer_to_location
-          @stock_location = Spree::StockLocation.find(params[:stock_location_id])
-
-          unless @quantity > 0
-            unprocessable_entity("#{Spree.t(:shipment_transfer_errors_occurred, scope: 'api')} \n #{Spree.t(:negative_quantity, scope: 'api')}")
-            return
-          end
-
-          transfer = @original_shipment.transfer_to_location(@variant, @quantity, @stock_location)
-          if transfer.valid?
-            transfer.run!
-            render json: { message: Spree.t(:shipment_transfer_success) }, status: 201
-          else
-            render json: { message: transfer.errors.full_messages.to_sentence }, status: 422
-          end
-        end
-
-        def transfer_to_shipment
-          @target_shipment = Spree::Shipment.find_by!(number: params[:target_shipment_number])
-
-          error =
-            if @quantity < 0 && @target_shipment == @original_shipment
-              "#{Spree.t(:negative_quantity, scope: 'api')}, \n#{Spree.t('wrong_shipment_target', scope: 'api')}"
-            elsif @target_shipment == @original_shipment
-              Spree.t(:wrong_shipment_target, scope: 'api')
-            elsif @quantity < 0
-              Spree.t(:negative_quantity, scope: 'api')
-            end
-
-          if error
-            unprocessable_entity("#{Spree.t(:shipment_transfer_errors_occurred, scope: 'api')} \n#{error}")
-          else
-            transfer = @original_shipment.transfer_to_shipment(@variant, @quantity, @target_shipment)
-            if transfer.valid?
-              transfer.run!
-              render json: { message: Spree.t(:shipment_transfer_success) }, status: 201
-            else
-              render json: { message: transfer.errors.full_messages }, status: 422
-            end
-          end
-        end
-
-        private
-
-        def load_transfer_params
-          @original_shipment         = Spree::Shipment.find_by!(number: params[:original_shipment_number])
-          @variant                   = Spree::Variant.find(params[:variant_id])
-          @quantity                  = params[:quantity].to_i
-          authorize! :show, @original_shipment
-          authorize! :create, Shipment
-        end
-
-        def find_and_update_shipment
-          @shipment = Spree::Shipment.accessible_by(current_ability, :update).readonly(false).find_by!(number: params[:id])
-          @shipment.update(shipment_params)
-          @shipment.reload
-        end
-
-        def shipment_params
-          if params[:shipment] && !params[:shipment].empty?
-            params.require(:shipment).permit(permitted_shipment_attributes)
-          else
-            {}
-          end
-        end
-
-        def variant
-          @variant ||= Spree::Variant.unscoped.find(params.fetch(:variant_id))
-        end
-
-        def mine_includes
-          {
-            order: {
-              bill_address: {
-                state: {},
-                country: {}
-              },
-              ship_address: {
-                state: {},
-                country: {}
-              },
-              adjustments: {},
-              payments: {
-                order: {},
-                payment_method: {}
-              }
-            },
-            inventory_units: {
-              line_item: {
-                product: {},
-                variant: {}
-              },
-              variant: {
-                product: {},
-                default_price: {},
-                option_values: {
-                  option_type: {}
-                }
-              }
-            }
-          }
-        end
-      end
-    end
-  end
-end

data/app/controllers/spree/api/v1/states_controller.rb

@@ -1,36 +0,0 @@
-module Spree
-  module Api
-    module V1
-      class StatesController < Spree::Api::BaseController
-        skip_before_action :authenticate_user
-
-        def index
-          @states = scope.ransack(params[:q]).result.includes(:country)
-
-          if params[:page] || params[:per_page]
-            @states = @states.page(params[:page]).per(params[:per_page])
-          end
-
-          state = @states.last
-          respond_with(@states) if stale?(state)
-        end
-
-        def show
-          @state = scope.find(params[:id])
-          respond_with(@state)
-        end
-
-        private
-
-        def scope
-          if params[:country_id]
-            @country = Country.accessible_by(current_ability, :show).find(params[:country_id])
-            @country.states.accessible_by(current_ability).order('name ASC')
-          else
-            State.accessible_by(current_ability).order('name ASC')
-          end
-        end
-      end
-    end
-  end
-end

data/app/controllers/spree/api/v1/stock_items_controller.rb

@@ -1,82 +0,0 @@
-module Spree
-  module Api
-    module V1
-      class StockItemsController < Spree::Api::BaseController
-        before_action :stock_location, except: [:update, :destroy]
-
-        def index
-          @stock_items = scope.ransack(params[:q]).result.page(params[:page]).per(params[:per_page])
-          respond_with(@stock_items)
-        end
-
-        def show
-          @stock_item = scope.find(params[:id])
-          respond_with(@stock_item)
-        end
-
-        def create
-          authorize! :create, StockItem
-
-          count_on_hand = 0
-          if params[:stock_item].key?(:count_on_hand)
-            count_on_hand = params[:stock_item][:count_on_hand].to_i
-          end
-
-          @stock_item = scope.new(stock_item_params)
-          if @stock_item.save
-            @stock_item.adjust_count_on_hand(count_on_hand)
-            respond_with(@stock_item, status: 201, default_template: :show)
-          else
-            invalid_resource!(@stock_item)
-          end
-        end
-
-        def update
-          @stock_item = StockItem.accessible_by(current_ability, :update).find(params[:id])
-
-          if params[:stock_item].key?(:backorderable)
-            @stock_item.backorderable = params[:stock_item][:backorderable]
-            @stock_item.save
-          end
-
-          count_on_hand = 0
-          if params[:stock_item].key?(:count_on_hand)
-            count_on_hand = params[:stock_item][:count_on_hand].to_i
-            params[:stock_item].delete(:count_on_hand)
-          end
-
-          updated = params[:stock_item][:force] ? @stock_item.set_count_on_hand(count_on_hand)
-          : @stock_item.adjust_count_on_hand(count_on_hand)
-
-          if updated
-            respond_with(@stock_item, status: 200, default_template: :show)
-          else
-            invalid_resource!(@stock_item)
-          end
-        end
-
-        def destroy
-          @stock_item = StockItem.accessible_by(current_ability, :destroy).find(params[:id])
-          @stock_item.destroy
-          respond_with(@stock_item, status: 204)
-        end
-
-        private
-
-        def stock_location
-          render 'spree/api/v1/shared/stock_location_required', status: 422 and return unless params[:stock_location_id]
-          @stock_location ||= StockLocation.accessible_by(current_ability, :show).find(params[:stock_location_id])
-        end
-
-        def scope
-          includes = { variant: [{ option_values: :option_type }, :product] }
-          @stock_location.stock_items.accessible_by(current_ability, :show).includes(includes)
-        end
-
-        def stock_item_params
-          params.require(:stock_item).permit(permitted_stock_item_attributes)
-        end
-      end
-    end
-  end
-end

data/app/controllers/spree/api/v1/stock_locations_controller.rb

@@ -1,53 +0,0 @@
-module Spree
-  module Api
-    module V1
-      class StockLocationsController < Spree::Api::BaseController
-        def index
-          authorize! :index, StockLocation
-          @stock_locations = StockLocation.accessible_by(current_ability).order('name ASC').
-                             ransack(params[:q]).result.page(params[:page]).per(params[:per_page])
-          respond_with(@stock_locations)
-        end
-
-        def show
-          respond_with(stock_location)
-        end
-
-        def create
-          authorize! :create, StockLocation
-          @stock_location = StockLocation.new(stock_location_params)
-          if @stock_location.save
-            respond_with(@stock_location, status: 201, default_template: :show)
-          else
-            invalid_resource!(@stock_location)
-          end
-        end
-
-        def update
-          authorize! :update, stock_location
-          if stock_location.update(stock_location_params)
-            respond_with(stock_location, status: 200, default_template: :show)
-          else
-            invalid_resource!(stock_location)
-          end
-        end
-
-        def destroy
-          authorize! :destroy, stock_location
-          stock_location.destroy
-          respond_with(stock_location, status: 204)
-        end
-
-        private
-
-        def stock_location
-          @stock_location ||= StockLocation.accessible_by(current_ability, :show).find(params[:id])
-        end
-
-        def stock_location_params
-          params.require(:stock_location).permit(permitted_stock_location_attributes)
-        end
-      end
-    end
-  end
-end

data/app/controllers/spree/api/v1/stock_movements_controller.rb

@@ -1,45 +0,0 @@
-module Spree
-  module Api
-    module V1
-      class StockMovementsController < Spree::Api::BaseController
-        before_action :stock_location, except: [:update, :destroy]
-
-        def index
-          authorize! :index, StockMovement
-          @stock_movements = scope.ransack(params[:q]).result.page(params[:page]).per(params[:per_page])
-          respond_with(@stock_movements)
-        end
-
-        def show
-          @stock_movement = scope.find(params[:id])
-          respond_with(@stock_movement)
-        end
-
-        def create
-          authorize! :create, StockMovement
-          @stock_movement = scope.new(stock_movement_params)
-          if @stock_movement.save
-            respond_with(@stock_movement, status: 201, default_template: :show)
-          else
-            invalid_resource!(@stock_movement)
-          end
-        end
-
-        private
-
-        def stock_location
-          render 'spree/api/v1/shared/stock_location_required', status: 422 and return unless params[:stock_location_id]
-          @stock_location ||= StockLocation.accessible_by(current_ability, :show).find(params[:stock_location_id])
-        end
-
-        def scope
-          @stock_location.stock_movements.accessible_by(current_ability, :show)
-        end
-
-        def stock_movement_params
-          params.require(:stock_movement).permit(permitted_stock_movement_attributes)
-        end
-      end
-    end
-  end
-end

data/app/controllers/spree/api/v1/stores_controller.rb

@@ -1,56 +0,0 @@
-module Spree
-  module Api
-    module V1
-      class StoresController < Spree::Api::BaseController
-        before_action :get_store, except: [:index, :create]
-
-        def index
-          authorize! :index, Store
-          @stores = Store.accessible_by(current_ability).all
-          respond_with(@stores)
-        end
-
-        def create
-          authorize! :create, Store
-          @store = Store.new(store_params)
-          @store.code = params[:store][:code]
-          if @store.save
-            respond_with(@store, status: 201, default_template: :show)
-          else
-            invalid_resource!(@store)
-          end
-        end
-
-        def update
-          authorize! :update, @store
-          if @store.update(store_params)
-            respond_with(@store, status: 200, default_template: :show)
-          else
-            invalid_resource!(@store)
-          end
-        end
-
-        def show
-          authorize! :show, @store
-          respond_with(@store)
-        end
-
-        def destroy
-          authorize! :destroy, @store
-          @store.destroy
-          respond_with(@store, status: 204)
-        end
-
-        private
-
-        def get_store
-          @store = Store.find(params[:id])
-        end
-
-        def store_params
-          params.require(:store).permit(permitted_store_attributes)
-        end
-      end
-    end
-  end
-end

data/app/controllers/spree/api/v1/taxonomies_controller.rb

@@ -1,67 +0,0 @@
-module Spree
-  module Api
-    module V1
-      class TaxonomiesController < Spree::Api::BaseController
-        def index
-          respond_with(taxonomies)
-        end
-
-        def show
-          respond_with(taxonomy)
-        end
-
-        # Because JSTree wants parameters in a *slightly* different format
-        def jstree
-          show
-        end
-
-        def new; end
-
-        def create
-          authorize! :create, Taxonomy
-          @taxonomy = current_store.taxonomies.new(taxonomy_params)
-          if @taxonomy.save
-            respond_with(@taxonomy, status: 201, default_template: :show)
-          else
-            invalid_resource!(@taxonomy)
-          end
-        end
-
-        def update
-          authorize! :update, taxonomy
-          if taxonomy.update(taxonomy_params)
-            respond_with(taxonomy, status: 200, default_template: :show)
-          else
-            invalid_resource!(taxonomy)
-          end
-        end
-
-        def destroy
-          authorize! :destroy, taxonomy
-          taxonomy.destroy
-          respond_with(taxonomy, status: 204)
-        end
-
-        private
-
-        def taxonomies
-          @taxonomies = Taxonomy.accessible_by(current_ability).order('name').includes(root: :children).
-                        ransack(params[:q]).result.
-                        page(params[:page]).per(params[:per_page])
-        end
-
-        def taxonomy
-          @taxonomy ||= Taxonomy.accessible_by(current_ability, :show).find(params[:id])
-        end
-
-        def taxonomy_params
-          if params[:taxonomy] && !params[:taxonomy].empty?
-            params.require(:taxonomy).permit(permitted_taxonomy_attributes)
-          else
-            {}
-          end
-        end
-      end
-    end
-  end
-end