harpiya_api 4.3.0.alpha

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

@@ -0,0 +1,30 @@
+module Harpiya
+  module Api
+    module V1
+      class PromotionsController < Harpiya::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 = Harpiya::Promotion.find_by(id: params[:id]) || Harpiya::Promotion.with_coupon_code(params[:id])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Harpiya
+  module Api
+    module V1
+      class PropertiesController < Harpiya::Api::BaseController
+        before_action :find_property, only: [:show, :update, :destroy]
+
+        def index
+          @properties = Harpiya::Property.accessible_by(current_ability)
+
+          @properties = if params[:ids]
+                          @properties.where(id: params[:ids].split(',').flatten)
+                        else
+                          @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 = Harpiya::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(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 = Harpiya::Property.accessible_by(current_ability, :show).find(params[:id])
+        rescue ActiveRecord::RecordNotFound
+          @property = Harpiya::Property.accessible_by(current_ability, :show).find_by!(name: params[:id])
+        end
+
+        def property_params
+          params.require(:property).permit(permitted_property_attributes)
+        end
+      end
+    end
+  end
+end

data/app/controllers/harpiya/api/v1/reimbursements_controller.rb

@@ -0,0 +1,25 @@
+module Harpiya
+  module Api
+    module V1
+      class ReimbursementsController < Harpiya::Api::BaseController
+        def index
+          collection(Harpiya::Reimbursement)
+          respond_with(@collection)
+        end
+
+        private
+
+        def collection(resource)
+          return @collection if @collection.present?
+
+          params[:q] ||= {}
+
+          @collection = resource.all
+          # @search needs to be defined as this is passed to search_form_for
+          @search = @collection.ransack(params[:q])
+          @collection = @search.result.order(created_at: :desc).page(params[:page]).per(params[:per_page])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Harpiya
+  module Api
+    module V1
+      class ReturnAuthorizationsController < Harpiya::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 ||= Harpiya::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/harpiya/api/v1/shipments_controller.rb

@@ -0,0 +1,196 @@
+module Harpiya
+  module Api
+    module V1
+      class ShipmentsController < Harpiya::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 = Harpiya::Shipment.
+                         reverse_chronological.
+                         joins(:order).
+                         where(harpiya_orders: { user_id: current_api_user.id }).
+                         includes(mine_includes).
+                         ransack(params[:q]).result.page(params[:page]).per(params[:per_page])
+          else
+            render 'harpiya/api/errors/unauthorized', status: :unauthorized
+          end
+        end
+
+        def create
+          @order = Harpiya::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 = Harpiya::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 = Harpiya::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 'harpiya/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
+
+          Harpiya::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
+
+          Harpiya::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 = Harpiya::StockLocation.find(params[:stock_location_id])
+
+          unless @quantity > 0
+            unprocessable_entity("#{Harpiya.t(:shipment_transfer_errors_occurred, scope: 'api')} \n #{Harpiya.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: Harpiya.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 = Harpiya::Shipment.find_by!(number: params[:target_shipment_number])
+
+          error =
+            if @quantity < 0 && @target_shipment == @original_shipment
+              "#{Harpiya.t(:negative_quantity, scope: 'api')}, \n#{Harpiya.t('wrong_shipment_target', scope: 'api')}"
+            elsif @target_shipment == @original_shipment
+              Harpiya.t(:wrong_shipment_target, scope: 'api')
+            elsif @quantity < 0
+              Harpiya.t(:negative_quantity, scope: 'api')
+            end
+
+          if error
+            unprocessable_entity("#{Harpiya.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: Harpiya.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         = Harpiya::Shipment.find_by!(number: params[:original_shipment_number])
+          @variant                   = Harpiya::Variant.find(params[:variant_id])
+          @quantity                  = params[:quantity].to_i
+          authorize! :show, @original_shipment
+          authorize! :create, Shipment
+        end
+
+        def find_and_update_shipment
+          @shipment = Harpiya::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 ||= Harpiya::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/harpiya/api/v1/states_controller.rb

@@ -0,0 +1,36 @@
+module Harpiya
+  module Api
+    module V1
+      class StatesController < Harpiya::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/harpiya/api/v1/stock_items_controller.rb

@@ -0,0 +1,82 @@
+module Harpiya
+  module Api
+    module V1
+      class StockItemsController < Harpiya::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 'harpiya/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