atkhayar-spree-dev-api 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e3422cd383dee5b3eab003ac439e73b42e9b16a2a99136d10aff461d94fc7933
+  data.tar.gz: 927ea34338f670d35054d095cdcf20f163ca817e3b481dd5eb03bf0bad5c3325
+SHA512:
+  metadata.gz: 3a7f3d940b4d0f6b5ac682892023dad9ab575c99411fb8deb16c16b6b85a8d8d9e98b4432448b34bf2423eb2bba7844975765fa97bba15cade335bed1e660e5a
+  data.tar.gz: 417f783cf21e0245ce6be284f859b72bab82f06cb55a6c3422fe59753441ca19ac4513f2698431c8113c6bfdf16d9713d6be63f22d70e80d7e3f896780190cbd

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+eval_gemfile('../common_spree_dependencies.rb')
+
+gem 'spree_core', path: '../core'
+
+gemspec

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2007-2015, Spree Commerce, Inc. and other contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Spree nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'spree/testing_support/common_rake'
+
+RSpec::Core::RakeTask.new
+
+task default: :spec
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  ENV['LIB_NAME'] = 'spree/api'
+  Rake::Task['common:test_app'].invoke
+end
+
+namespace :rswag do
+  namespace :specs do
+    desc 'Generate Swagger JSON files from integration specs'
+    RSpec::Core::RakeTask.new('swaggerize') do |t|
+      t.pattern = ENV.fetch(
+        'PATTERN',
+        'spec/integration/**/*_spec.rb'
+      )
+
+      t.rspec_opts = ['--format Rswag::Specs::SwaggerFormatter', '--order defined']
+    end
+  end
+end

data/app/controllers/concerns/spree/api/v2/caching.rb

@@ -0,0 +1,37 @@
+module Spree
+  module Api
+    module V2
+      module Caching
+        extend ActiveSupport::Concern
+
+        def collection_cache_key(collection)
+          ids_and_timestamps = collection.unscope(:includes).unscope(:order).pluck(:id, :updated_at)
+
+          ids = ids_and_timestamps.map(&:first)
+          max_updated_at = ids_and_timestamps.map(&:last).max
+
+          cache_key_parts = [
+            self.class.to_s,
+            max_updated_at,
+            ids,
+            resource_includes,
+            sparse_fields,
+            serializer_params,
+            params[:sort]&.strip,
+            params[:page]&.to_s&.strip,
+            params[:per_page]&.to_s&.strip,
+          ].flatten.join('-')
+
+          Digest::MD5.hexdigest(cache_key_parts)
+        end
+
+        def collection_cache_opts
+          {
+            namespace: Spree::Api::Config[:api_v2_collection_cache_namespace],
+            expires_in: Spree::Api::Config[:api_v2_collection_cache_ttl],
+          }
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/spree/api/v2/coupon_codes_helper.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Api
+    module V2
+      module CouponCodesHelper
+        def select_coupon_codes
+          params[:coupon_code].present? ? [params[:coupon_code]] : check_coupon_codes
+        end
+
+        def check_coupon_codes
+          spree_current_order.promotions.coupons.map(&:code)
+        end
+
+        def select_error(coupon_codes)
+          result = coupon_handler.new(spree_current_order).remove(coupon_codes.first)
+          result.error
+        end
+
+        def select_errors(coupon_codes)
+          results = []
+          coupon_codes.each do |coupon_code|
+            results << coupon_handler.new(spree_current_order).remove(coupon_code)
+          end
+
+          results.select(&:error)
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/spree/api/v2/number_resource.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Api
+    module V2
+      module NumberResource
+        def resource
+          @resource ||= scope.find_by(number: params[:id]) || scope.find(params[:id])
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/spree/api/v2/platform/nested_set_reposition_concern.rb

@@ -0,0 +1,37 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        module NestedSetRepositionConcern
+          def reposition
+            spree_authorize! :update, resource if spree_current_user.present?
+
+            @new_parent = scope.find(permitted_resource_params[:new_parent_id])
+            new_index = permitted_resource_params[:new_position_idx].to_i
+
+            if resource.move_to_child_with_index(@new_parent, new_index)
+              # If successful reposition call the custom method for handling success.
+              successful_reposition_actions
+            elsif resource.errors.any?
+              # If there are errors output them to the response
+              render_error_payload(resource.errors.full_messages.to_sentence)
+            else
+              # If the user drops the re-positioned item in the same location it came from
+              # we just render the serialized payload, nothing has changed, we don't need to
+              # render any errors, or fire any custom success methods.
+              render_serialized_payload { serialize_resource(resource) }
+            end
+          end
+
+          private
+
+          def successful_reposition_actions
+            # Call a separate method for a successful reposition so this can be easily overridden
+            # if a more complex set of events need to occur after a successful reposition.
+            render_serialized_payload { serialize_resource(resource) }
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/spree/api/v2/platform/promotion_calculator_params.rb

@@ -0,0 +1,17 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        module PromotionCalculatorParams
+          private
+
+          def calculator_params
+            [:preferred_flat_percent, :preferred_amount, :preferred_first_item, :preferred_additional_item,
+             :preferred_max_items, :preferred_percent, :preferred_minimal_amount, :preferred_normal_amount,
+             :preferred_discount_amount, :preferred_currency, :preferred_base_amount, :preferred_base_percent, { preferred_tiers: {} }]
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/spree/api/v2/platform/promotion_rule_params.rb

@@ -0,0 +1,16 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        module PromotionRuleParams
+          private
+
+          def rule_params
+            [:preferred_match_policy, :preferred_country_id, :preferred_amount_min, :preferred_operator_min, :preferred_amount_max,
+             :preferred_operator_max, { taxon_ids: [], user_ids: [], product_ids: [], preferred_eligible_values: {} }]
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/spree/api/v2/product_list_includes.rb

@@ -0,0 +1,25 @@
+module Spree
+  module Api
+    module V2
+      module ProductListIncludes
+        def product_list_includes
+          {
+            product_properties: [],
+            option_types: [],
+            variant_images: [],
+            master: product_variant_includes,
+            variants: product_variant_includes
+          }
+        end
+
+        def product_variant_includes
+          {
+            prices: [],
+            option_values: :option_type,
+            images: []
+          }
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/spree/api/v2/storefront/metadata_controller_concern.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module MetadataControllerConcern
+          protected
+
+          def ensure_valid_metadata
+            if params[:public_metadata].present? && !params[:public_metadata].is_a?(ActionController::Parameters) ||
+                params[:private_metadata].present? && !params[:private_metadata].is_a?(ActionController::Parameters)
+              render_error_payload(I18n.t(:invalid_params, scope: 'spree.api.v2.metadata'))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/spree/api/v2/storefront/order_concern.rb

@@ -0,0 +1,52 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module OrderConcern
+          private
+
+          def render_order(result)
+            if result.success?
+              render_serialized_payload { serialized_current_order }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          def ensure_order
+            raise ActiveRecord::RecordNotFound if spree_current_order.nil?
+          end
+
+          def order_token
+            request.headers['X-Spree-Order-Token'] || params[:order_token]
+          end
+
+          def spree_current_order
+            @spree_current_order ||= find_spree_current_order
+          end
+
+          def find_spree_current_order
+            Spree::Api::Dependencies.storefront_current_order_finder.constantize.new.execute(
+              store: current_store,
+              user: spree_current_user,
+              token: order_token,
+              currency: current_currency
+            )
+          end
+
+          def serialized_current_order
+            serialize_resource(spree_current_order)
+          end
+
+          def serialize_order(order)
+            ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+              `OrderConcern#serialize_order` is deprecated and will be removed in Spree 5.0.
+              Please use `serializer_resource` method
+            DEPRECATION
+            serialize_resource(order)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+module Spree
+  module Api
+    module V2
+      class BaseController < ActionController::API
+        include CanCan::ControllerAdditions
+        include Spree::Core::ControllerHelpers::StrongParameters
+        include Spree::Core::ControllerHelpers::Store
+        include Spree::Core::ControllerHelpers::Locale
+        include Spree::Core::ControllerHelpers::Currency
+
+        rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+        rescue_from CanCan::AccessDenied, with: :access_denied
+        rescue_from Doorkeeper::Errors::DoorkeeperError, with: :access_denied_401
+        rescue_from Spree::Core::GatewayError, with: :gateway_error
+        rescue_from ActionController::ParameterMissing, with: :error_during_processing
+        if defined?(JSONAPI::Serializer::UnsupportedIncludeError)
+          rescue_from JSONAPI::Serializer::UnsupportedIncludeError, with: :error_during_processing
+        end
+        rescue_from ArgumentError, with: :error_during_processing
+        rescue_from ActionDispatch::Http::Parameters::ParseError, with: :error_during_processing
+
+        def content_type
+          Spree::Api::Config[:api_v2_content_type]
+        end
+
+        protected
+
+        def serialize_collection(collection)
+          collection_serializer.new(
+            collection,
+            collection_options(collection).merge(params: serializer_params)
+          ).serializable_hash
+        end
+
+        def serialize_resource(resource)
+          resource_serializer.new(
+            resource,
+            params: serializer_params,
+            include: resource_includes,
+            fields: sparse_fields
+          ).serializable_hash
+        end
+
+        def paginated_collection
+          @paginated_collection ||= collection_paginator.new(sorted_collection, params).call
+        end
+
+        def collection_paginator
+          Spree::Api::Dependencies.storefront_collection_paginator.constantize
+        end
+
+        def render_serialized_payload(status = 200)
+          render json: yield, status: status, content_type: content_type
+        end
+
+        def render_error_payload(error, status = 422)
+          json = if error.is_a?(ActiveModel::Errors)
+                   { error: error.full_messages.to_sentence, errors: error.messages }
+                 elsif error.is_a?(Struct)
+                   { error: error.to_s, errors: error.to_h }
+                 else
+                   { error: error }
+                 end
+
+          render json: json, status: status, content_type: content_type
+        end
+
+        def render_result(result, ok_status = 200)
+          if result.success?
+            render_serialized_payload(ok_status) { serialize_resource(result.value) }
+          else
+            render_error_payload(result.error)
+          end
+        end
+
+        def spree_current_user
+          return nil unless doorkeeper_token
+          return @spree_current_user if @spree_current_user
+
+          doorkeeper_authorize!
+
+          @spree_current_user ||= doorkeeper_token.resource_owner
+        end
+
+        def spree_authorize!(action, subject, *args)
+          authorize!(action, subject, *args)
+        end
+
+        def require_spree_current_user
+          raise CanCan::AccessDenied if spree_current_user.nil?
+        end
+
+        # Needs to be overridden so that we use Spree's Ability rather than anyone else's.
+        def current_ability
+          @current_ability ||= Spree::Dependencies.ability_class.constantize.new(spree_current_user)
+        end
+
+        def request_includes
+          # if API user wants to receive only the bare-minimum
+          # the API will return only the main resource without any included
+          if params[:include]&.blank?
+            []
+          elsif params[:include].present?
+            params[:include].split(',')
+          end
+        end
+
+        def resource_includes
+          (request_includes || default_resource_includes).map(&:intern)
+        end
+
+        # overwrite this method in your controllers to set JSON API default include value
+        # https://jsonapi.org/format/#fetching-includes
+        # eg.:
+        # %w[images variants]
+        # ['variant.images', 'line_items']
+        def default_resource_includes
+          []
+        end
+
+        def sparse_fields
+          return unless params[:fields]&.respond_to?(:each)
+
+          fields = {}
+          params[:fields].
+            select { |_, v| v.is_a?(String) }.
+            each { |type, values| fields[type.intern] = values.split(',').map(&:intern) }
+          fields.presence
+        end
+
+        def serializer_params
+          {
+            currency: current_currency,
+            locale: current_locale,
+            price_options: current_price_options,
+            store: current_store,
+            user: spree_current_user,
+            image_transformation: params[:image_transformation],
+            taxon_image_transformation: params[:taxon_image_transformation]
+          }
+        end
+
+        def record_not_found
+          render_error_payload(I18n.t(:resource_not_found, scope: 'spree.api'), 404)
+        end
+
+        def access_denied(exception)
+          render_error_payload(exception.message, 403)
+        end
+
+        def access_denied_401(exception)
+          render_error_payload(exception.message, 401)
+        end
+
+        def gateway_error(exception)
+          render_error_payload(exception.message)
+        end
+
+        def error_during_processing(exception)
+          result = error_handler.call(exception: exception, opts: { user: spree_current_user })
+
+          render_error_payload(result.value[:message], 400)
+        end
+
+        def error_handler
+          Spree::Api::Dependencies.error_handler.constantize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class AddressesController < ResourceController
+          private
+
+          def model_class
+            Spree::Address
+          end
+
+          def scope_includes
+            [:country, :state, :user]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class AdjustmentsController < ResourceController
+          private
+
+          def model_class
+            Spree::Adjustment
+          end
+
+          def scope_includes
+            [:order, :adjustable]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class ClassificationsController < ResourceController
+          private
+
+          def model_class
+            Spree::Classification
+          end
+
+          def scope_includes
+            [
+              taxon: [],
+              product: [:variants_including_master, :variant_images, :master, { variants: [:prices] }]
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class CmsPagesController < ResourceController
+          private
+
+          def model_class
+            Spree::CmsPage
+          end
+
+          def scope_includes
+            [:cms_sections]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class CmsSectionsController < ResourceController
+          private
+
+          def model_class
+            Spree::CmsSection
+          end
+
+          def spree_permitted_attributes
+            stored_attributes = []
+
+            Spree::CmsSection::TYPES.each do |type|
+              type.constantize.stored_attributes.each do |_name, values|
+                values.each do |value|
+                  stored_attributes << value
+                end
+              end
+            end
+
+            super + stored_attributes.compact.uniq!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class CountriesController < ResourceController
+          private
+
+          def model_class
+            Spree::Country
+          end
+
+          def scope_includes
+            [:states, :zones]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        class DigitalLinksController < ResourceController
+          def reset
+            spree_authorize! :update, resource if spree_current_user.present?
+
+            if resource.reset!
+              render_serialized_payload { serialize_resource(resource) }
+            else
+              render_error_payload(resource.errors)
+            end
+          end
+
+          private
+
+          def model_class
+            Spree::DigitalLink
+          end
+        end
+      end
+    end
+  end
+end