atkhayar-spree-dev-api 0.0.0

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

@@ -0,0 +1,144 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class UsersResourceController < ::Spree::Api::V2::ResourceController
+          # doorkeeper scopes usage: https://github.com/doorkeeper-gem/doorkeeper/wiki/Using-Scopes
+          before_action :validate_token_client
+
+          # optional authorization if using a user token instead of app token
+          before_action :authorize_spree_user
+
+          # index and show actions are defined in Spree::Api::V2::ResourceController
+          def create
+              resource = model_class.new(permitted_resource_params)
+              ensure_current_store(resource)
+              if resource.save
+              render_serialized_payload(201) { serialize_resource(resource) }
+              else
+              render_error_payload(resource.errors)
+              end
+          end
+
+          def update
+              resource.assign_attributes(permitted_resource_params)
+              ensure_current_store(resource)
+
+              if resource.save
+              render_serialized_payload { serialize_resource(resource) }
+              else
+              render_error_payload(resource.errors)
+              end
+          end
+
+          def destroy
+              if resource.destroy
+              head 204
+              else
+              render_error_payload(resource.errors)
+              end
+          end
+
+          protected
+
+          def resource_serializer
+              serializer_base_name = model_class.to_s.sub('Spree::', '')
+              "Spree::Api::V2::Platform::#{serializer_base_name}Serializer".constantize
+          end
+
+          def collection_serializer
+              resource_serializer
+          end
+
+          # overwriting to utilize ransack gem for filtering
+          # https://github.com/activerecord-hackery/ransack#search-matchers
+          def collection
+              @collection ||= scope.ransack(params[:filter]).result
+          end
+
+          # overwriting to skip cancancan check if API is consumed by an application
+          def scope
+              return super if spree_current_user.present?
+
+              super(skip_cancancan: true)
+          end
+
+          # We're overwriting this method because the original one calls `dookreeper_authorize`
+          # which breaks our application authorizations defined on top of this controller
+          def spree_current_user
+              return nil unless doorkeeper_token
+              return nil if doorkeeper_token.resource_owner_id.nil?
+              return @spree_current_user if @spree_current_user
+
+              @spree_current_user ||= doorkeeper_token.resource_owner
+          end
+
+          def access_denied(exception)
+              access_denied_401(exception)
+          end
+
+          def validate_token_client
+              return if doorkeeper_token.nil?
+
+              #raise Doorkeeper::Errors::DoorkeeperError if doorkeeper_token.application.nil?
+          end
+
+          # if using a user oAuth token we need to check CanCanCan abilities
+          # defined in https://github.com/spree/spree/blob/master/core/app/models/spree/ability.rb
+          def authorize_spree_user
+              return if spree_current_user.nil?
+
+              case action_name
+              when 'create'
+              spree_authorize! :create, model_class
+              when 'destroy'
+              spree_authorize! :destroy, resource
+              when 'index'
+              spree_authorize! :read, model_class
+              when 'show'
+              spree_authorize! :read, resource
+              else
+              spree_authorize! :update, resource
+              end
+          end
+
+          def model_param_name
+              model_class.to_s.demodulize.underscore
+          end
+
+          def spree_permitted_attributes
+              store_ids = if model_class.method_defined?(:stores)
+                          [{ store_ids: [] }]
+                          else
+                          []
+                          end
+
+              model_class.json_api_permitted_attributes + store_ids + metadata_params
+          end
+
+          def metadata_params
+              if model_class.include?(Metadata)
+              [{ public_metadata: {}, private_metadata: {} }]
+              else
+              []
+              end
+          end
+
+          def permitted_resource_params
+              # params.require(model_param_name).permit(spree_permitted_attributes)
+              params.require(model_param_name).permit(spree_permitted_attributes)
+          end
+
+          def allowed_sort_attributes
+              (super << spree_permitted_attributes).uniq.compact
+          end
+
+          def write_request?
+              %w[put patch post delete].include?(request.request_method.downcase)
+          end
+        end
+      end
+    end
+  end
+end
+  

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

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

data/app/controllers/spree/api/v2/platform/webhooks/events_controller.rb

@@ -0,0 +1,21 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        module Webhooks
+          class EventsController < ResourceController
+            private
+
+            def model_class
+              Spree::Webhooks::Event
+            end
+
+            def scope_includes
+              %i[subscriber]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/platform/webhooks/subscribers_controller.rb

@@ -0,0 +1,21 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        module Webhooks
+          class SubscribersController < ResourceController
+            private
+
+            def model_class
+              Spree::Webhooks::Subscriber
+            end
+
+            def spree_permitted_attributes
+              super + [{ subscriptions: [] }]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

@@ -0,0 +1,76 @@
+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'
+          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 ||= if defined?(collection_finder)
+                            collection_finder.new(scope: scope, params: finder_params).execute
+                          else
+                            scope
+                          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::Dependencies.storefront_collection_sorter.constantize
+        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::Dependencies.storefront_address_finder.constantize
+            end
+
+            def collection_serializer
+              Spree::Api::Dependencies.storefront_address_serializer.constantize
+            end
+
+            def resource_serializer
+              Spree::Api::Dependencies.storefront_address_serializer.constantize
+            end
+
+            def create_service
+              Spree::Api::Dependencies.storefront_address_create_service.constantize
+            end
+
+            def update_service
+              Spree::Api::Dependencies.storefront_address_update_service.constantize
+            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::Dependencies.storefront_credit_card_serializer.constantize
+            end
+
+            def collection_finder
+              Spree::Api::Dependencies.storefront_credit_card_finder.constantize
+            end
+
+            def resource_serializer
+              Spree::Api::Dependencies.storefront_credit_card_serializer.constantize
+            end
+
+            def destroy_service
+              Spree::Api::Dependencies.storefront_credit_cards_destroy_service.constantize
+            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::Dependencies.storefront_order_serializer.constantize
+            end
+
+            def resource_serializer
+              Spree::Api::Dependencies.storefront_order_serializer.constantize
+            end
+
+            def collection_finder
+              Spree::Api::Dependencies.storefront_completed_order_finder.constantize
+            end
+
+            def resource_finder
+              Spree::Api::Dependencies.storefront_completed_order_finder.constantize
+            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::Dependencies.storefront_user_serializer.constantize
+          end
+
+          def model_class
+            Spree.user_class
+          end
+
+          def create_service
+            Spree::Api::Dependencies.storefront_account_create_service.constantize
+          end
+
+          def update_service
+            Spree::Api::Dependencies.storefront_account_update_service.constantize
+          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