spree_api 3.0.10 → 3.1.0.rc1

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

@@ -0,0 +1,126 @@
+module Spree
+  module Api
+    module V1
+      class ProductsController < Spree::Api::BaseController
+
+        def index
+          if params[:ids]
+            @products = product_scope.where(id: params[:ids].split(",").flatten)
+          else
+            @products = product_scope.ransack(params[:q]).result
+          end
+
+          @products = @products.distinct.page(params[:page]).per(params[:per_page])
+          expires_in 15.minutes, :public => true
+          headers['Surrogate-Control'] = "max-age=#{15.minutes}"
+          respond_with(@products)
+        end
+
+        def show
+          @product = find_product(params[:id])
+          expires_in 15.minutes, :public => true
+          headers['Surrogate-Control'] = "max-age=#{15.minutes}"
+          headers['Surrogate-Key'] = "product_id=1"
+          respond_with(@product)
+        end
+
+        # Takes besides the products attributes either an array of variants or
+        # an array of option types.
+        #
+        # By submitting an array of variants the option types will be created
+        # using the *name* key in options hash. e.g
+        #
+        #   product: {
+        #     ...
+        #     variants: {
+        #       price: 19.99,
+        #       sku: "hey_you",
+        #       options: [
+        #         { name: "size", value: "small" },
+        #         { name: "color", value: "black" }
+        #       ]
+        #     }
+        #   }
+        #
+        # Or just pass in the option types hash:
+        #
+        #   product: {
+        #     ...
+        #     option_types: ['size', 'color']
+        #   }
+        #
+        # By passing the shipping category name you can fetch or create that
+        # shipping category on the fly. e.g.
+        #
+        #   product: {
+        #     ...
+        #     shipping_category: "Free Shipping Items"
+        #   }
+        #
+        def create
+          authorize! :create, Product
+          params[:product][:available_on] ||= Time.current
+          set_up_shipping_category
+
+          options = { variants_attrs: variants_params, options_attrs: option_types_params }
+          @product = Core::Importer::Product.new(nil, product_params, options).create
+
+          if @product.persisted?
+            respond_with(@product, :status => 201, :default_template => :show)
+          else
+            invalid_resource!(@product)
+          end
+        end
+
+        def update
+          @product = find_product(params[:id])
+          authorize! :update, @product
+
+          options = { variants_attrs: variants_params, options_attrs: option_types_params }
+          @product = Core::Importer::Product.new(@product, product_params, options).update
+
+          if @product.errors.empty?
+            respond_with(@product.reload, :status => 200, :default_template => :show)
+          else
+            invalid_resource!(@product)
+          end
+        end
+
+        def destroy
+          @product = find_product(params[:id])
+          authorize! :destroy, @product
+          @product.destroy
+          respond_with(@product, :status => 204)
+        end
+
+        private
+          def product_params
+            params.require(:product).permit(permitted_product_attributes)
+          end
+
+          def variants_params
+            variants_key = if params[:product].has_key? :variants
+              :variants
+            else
+              :variants_attributes
+            end
+
+            params.require(:product).permit(
+              variants_key => [permitted_variant_attributes, :id],
+            ).delete(variants_key) || []
+          end
+
+          def option_types_params
+            params[:product].fetch(:option_types, [])
+          end
+
+          def set_up_shipping_category
+            if shipping_category = params[:product].delete(:shipping_category)
+              id = ShippingCategory.find_or_create_by(name: shipping_category).id
+              params[:product][:shipping_category_id] = id
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Spree
+  module Api
+    module V1
+      class PromotionsController < Spree::Api::BaseController
+        before_action :requires_admin
+        before_action :load_promotion
+
+        def show
+          if @promotion
+            respond_with(@promotion, default_template: :show)
+          else
+            raise ActiveRecord::RecordNotFound
+          end
+        end
+
+        private 
+          def requires_admin
+            return if @current_user_roles.include?("admin")
+            unauthorized and return
+          end
+
+          def load_promotion
+            @promotion = Spree::Promotion.find_by_id(params[:id]) || Spree::Promotion.with_coupon_code(params[:id])
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Spree
+  module Api
+    module V1
+      class PropertiesController < Spree::Api::BaseController
+
+        before_action :find_property, only: [:show, :update, :destroy]
+
+        def index
+          @properties = Spree::Property.accessible_by(current_ability, :read)
+
+          if params[:ids]
+            @properties = @properties.where(id: params[:ids].split(",").flatten)
+          else
+            @properties = @properties.ransack(params[:q]).result
+          end
+
+          @properties = @properties.page(params[:page]).per(params[:per_page])
+          respond_with(@properties)
+        end
+
+        def show
+          respond_with(@property)
+        end
+
+        def new
+        end
+
+        def create
+          authorize! :create, Property
+          @property = Spree::Property.new(property_params)
+          if @property.save
+            respond_with(@property, status: 201, default_template: :show)
+          else
+            invalid_resource!(@property)
+          end
+        end
+
+        def update
+          if @property
+            authorize! :update, @property
+            @property.update_attributes(property_params)
+            respond_with(@property, status: 200, default_template: :show)
+          else
+            invalid_resource!(@property)
+          end
+        end
+
+        def destroy
+          if @property
+            authorize! :destroy, @property
+            @property.destroy
+            respond_with(@property, status: 204)
+          else
+            invalid_resource!(@property)
+          end
+        end
+
+        private
+
+          def find_property
+            @property = Spree::Property.accessible_by(current_ability, :read).find(params[:id])
+          rescue ActiveRecord::RecordNotFound
+            @property = Spree::Property.accessible_by(current_ability, :read).find_by!(name: params[:id])
+          end
+
+          def property_params
+            params.require(:property).permit(permitted_property_attributes)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+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, :read).
+                                   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, :read).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_attributes(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! :read, @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

@@ -0,0 +1,163 @@
+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! :read, @order
+          authorize! :create, Shipment
+          quantity = params[:quantity].to_i
+          @shipment = @order.shipments.create(stock_location_id: params.fetch(:stock_location_id))
+          @order.contents.add(variant, quantity, {shipment: @shipment})
+
+          @shipment.save!
+
+          respond_with(@shipment.reload, default_template: :show)
+        end
+
+        def update
+          @shipment = Spree::Shipment.accessible_by(current_ability, :update).readonly(false).friendly.find(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
+          unless @shipment.shipped?
+            @shipment.ship!
+          end
+          respond_with(@shipment, default_template: :show)
+        end
+
+        def add
+          quantity = params[:quantity].to_i
+
+          @shipment.order.contents.add(variant, quantity, {shipment: @shipment})
+
+          respond_with(@shipment, default_template: :show)
+        end
+
+        def remove
+          quantity = params[:quantity].to_i
+
+          @shipment.order.contents.remove(variant, quantity, {shipment: @shipment})
+          @shipment.reload if @shipment.persisted?
+          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('ArgumentError')
+            return
+          end
+
+          @original_shipment.transfer_to_location(@variant, @quantity, @stock_location)
+          render json: {success: true, message: Spree.t(:shipment_transfer_success)}, status: 201
+        end
+
+        def transfer_to_shipment
+          @target_shipment  = Spree::Shipment.friendly.find(params[:target_shipment_number])
+
+          if @quantity < 0 || @target_shipment == @original_shipment
+            unprocessable_entity('ArgumentError')
+            return
+          end
+
+          @original_shipment.transfer_to_shipment(@variant, @quantity, @target_shipment)
+          render json: {success: true, message: Spree.t(:shipment_transfer_success)}, status: 201
+        end
+
+        private
+
+        def load_transfer_params
+          @original_shipment         = Spree::Shipment.friendly.find(params[:original_shipment_number])
+          @variant                   = Spree::Variant.find(params[:variant_id])
+          @quantity                  = params[:quantity].to_i
+          authorize! :read, @original_shipment
+          authorize! :create, Shipment
+        end
+
+        def find_and_update_shipment
+          @shipment = Spree::Shipment.accessible_by(current_ability, :update).readonly(false).friendly.find(params[:id])
+          @shipment.update_attributes(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