apress-api 1.22.0

data/lib/apress/api/api_controller/authentification.rb

@@ -0,0 +1,33 @@
+module Apress
+  module Api
+    module ApiController
+      module Authentification
+        extend ActiveSupport::Concern
+
+        included do
+          attr_reader :current_api_client
+
+          if (Rails::VERSION::MAJOR == 4 && Rails::VERSION::MINOR == 2) || Rails::VERSION::MAJOR > 4
+            before_action :find_session
+            before_action :authenticate
+          else
+            before_filter :find_session
+            before_filter :authenticate
+          end
+        end
+
+        private
+
+        def find_session
+          auth_service = AuthService.new(request)
+          return unless auth_service.call
+          @current_api_client = auth_service.client
+        end
+
+        def authenticate
+          forbidden unless @current_api_client
+        end
+      end
+    end
+  end
+end

data/lib/apress/api/api_controller/base.rb

@@ -0,0 +1,63 @@
+module Apress
+  module Api
+    module ApiController
+      class Base < ActionController::Metal
+        abstract!
+
+        if (Rails::VERSION::MAJOR == 4 && Rails::VERSION::MINOR > 0) || Rails::VERSION::MAJOR > 4
+          include AbstractController::Rendering
+          include ActionView::Rendering
+        end
+        include ActionController::HideActions if Rails::VERSION::MAJOR < 5
+        include ActionController::UrlFor
+        include ActionController::Redirecting
+        include ActionController::Rendering
+        include ActionController::Renderers::All
+        include ActionController::ConditionalGet
+        include ActionController::RackDelegation if Rails::VERSION::MAJOR < 5
+        include ActionController::ForceSSL
+        include AbstractController::Callbacks
+        include ActionController::Rescue
+        include ActionController::Instrumentation
+        include ActionController::StrongParameters if Rails::VERSION::MAJOR >= 4
+        include ActionController::MimeResponds
+        include ActionController::ImplicitRender
+        include ActionController::Helpers
+        include ActionController::Caching
+        include AbstractController::AssetPaths
+
+        # https://github.com/rails/strong_parameters/pull/199
+        if Rails::VERSION::MAJOR == 3
+          require "strong_parameters"
+          require "strong_parameters/version"
+        end
+
+        if defined?(StrongParameters::VERSION) &&
+          Gem::Version.new(StrongParameters::VERSION) <= Gem::Version.new("0.2.3")
+          include ActionController::StrongParameters
+        end
+
+        # :nocov:
+        if defined?(::NewRelic)
+          require "new_relic/agent/instrumentation/rails#{Rails::VERSION::MAJOR}/action_controller"
+
+          include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+          if Rails::VERSION::MAJOR == 3
+            include ::NewRelic::Agent::Instrumentation::Rails3::ActionController
+          end
+        end
+        # :nocov:
+
+        extend Compatibility
+        include Rescue
+        include Responds
+        include Authentification
+        include Pagination
+
+        ActiveSupport.run_load_hooks(:action_controller, self)
+        ActiveSupport.run_load_hooks(:"apress/api/api_controller", self)
+      end
+    end
+  end
+end

data/lib/apress/api/api_controller/compatibility.rb

@@ -0,0 +1,26 @@
+module Apress
+  module Api
+    module ApiController
+      module Compatibility
+        def assets_dir=(*); end
+
+        def javascripts_dir=(*); end
+
+        def stylesheets_dir=(*); end
+
+        def page_cache_directory=(*); end
+
+        def relative_url_root=(*); end
+
+        def helpers_path=(*); end
+
+        def allow_forgery_protection=(*); end
+
+        def helper(*); end
+
+        def include_all_helpers=(*); end
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/apress/api/api_controller/pagination.rb

@@ -0,0 +1,60 @@
+require 'addressable/uri'
+require 'apress/api/api_controller/pagination_helper'
+module Apress
+  module Api
+    module ApiController
+      module Pagination
+        class InvalidPaginationError < StandardError; end
+        class LinkHeaderAppendNotImplemented < StandardError; end
+
+        extend ActiveSupport::Concern
+
+        included do
+          attr_reader :per_page, :page
+          alias_method :current_page, :page
+          rescue_from InvalidPaginationError, with: :bad_request
+        end
+
+        DEFAULT_PER_PAGE = 30
+        MAX_PER_PAGE = 100
+
+        # Public: sets page and per_page variables
+        #
+        # options - Hash, configuration
+        #           :per_page - Hash, per_page value configuration
+        #                       :max - Integer, max per_page value
+        #                       :defuault - Integer, default value for per_page
+        # Examples
+        #   prepare_pagination(per_page: {max: 110, default: 40})
+        #
+        #   or with defaults max - 100 and default - 30
+        #
+        #   prepare_pagination
+        #
+        # Returns nothing
+        def prepare_pagination(options = {})
+          per_page = options.fetch(:per_page, {})
+          max_per_page = per_page.fetch(:max, MAX_PER_PAGE)
+          default_per_page = per_page.fetch(:default, DEFAULT_PER_PAGE)
+
+          @page = params.fetch(:page, 1).to_i
+          raise InvalidPaginationError if @page <= 0
+
+          @per_page = params.fetch(:per_page, default_per_page).to_i
+          raise InvalidPaginationError unless (1..max_per_page).include?(@per_page)
+        end
+
+        # Public: sets pagination headers
+        #
+        # collection - WillPaginate::Collection
+        #
+        # Returns nothing
+        def pagination_headers(collection)
+          raise LinkHeaderAppendNotImplemented if headers['Link'].present?
+
+          headers.merge!(::Apress::Api::ApiController::PaginationHelper.headers(collection, request.url))
+        end
+      end
+    end
+  end
+end

data/lib/apress/api/api_controller/pagination_helper.rb

@@ -0,0 +1,55 @@
+module Apress
+  module Api
+    module ApiController
+      module PaginationHelper
+        def self.headers(collection, url)
+          result = {}
+
+          result['X-Total-Count'] = collection.total_entries.to_s
+          result['X-Total-Pages'] = collection.total_pages.to_s
+          result['X-Per-Page'] = collection.per_page.to_s
+          result['X-Page'] = collection.current_page.to_s
+
+          numbers = page_numbers(collection)
+          links = header_link_values(url, numbers)
+
+          result['Link'] = links.join(', ') if links.present?
+
+          result
+        end
+
+        def self.header_link_values(url, page_numbers)
+          url = ::Addressable::URI.parse(url)
+          url.query_values ||= {}
+
+          page_numbers.map do |rel, number|
+            url.query_values = url.query_values.merge('page' => number)
+
+            %(<#{url}>; rel="#{rel}")
+          end
+        rescue ::Addressable::URI::InvalidURIError
+          []
+        end
+
+        def self.page_numbers(collection)
+          result = {}
+          return result unless collection.total_pages > 1
+
+          if collection.current_page > 1
+            result[:first] = 1
+            result[:prev] = collection.current_page - 1
+          end
+
+          if collection.current_page < collection.total_pages
+            result[:last] = collection.total_pages
+            result[:next] = collection.current_page + 1
+          end
+
+          result
+        end
+
+        private_class_method :header_link_values, :page_numbers
+      end
+    end
+  end
+end

data/lib/apress/api/api_controller/rescue.rb

@@ -0,0 +1,89 @@
+module Apress
+  module Api
+    module ApiController
+      module Rescue
+        extend ActiveSupport::Concern
+
+        included do
+          rescue_from "Exception", with: :server_error if Rails.env.production?
+
+          rescue_from "Pundit::NotAuthorizedError", with: :forbidden
+
+          rescue_from "ActiveRecord::RecordNotFound",
+                      "ActionView::MissingTemplate",
+                      "ActionController::UnknownFormat",
+                      "ActiveRecord::SubclassNotFound",
+                      with: :not_found unless Rails.env.development?
+
+          rescue_from 'ActiveRecord::RecordInvalid', with: :unprocessable
+
+          rescue_from 'ActionController::ParameterMissing',
+                      with: :parameter_missing
+
+          helper_method :show_errors?
+        end
+
+        private
+
+        def server_error(exception)
+          render_error(500, exception)
+        end
+
+        def not_found(exception = nil)
+          render_error(404, exception)
+        end
+
+        def forbidden(exception = nil)
+          render_error(403, exception)
+        end
+
+        def bad_request(exception = nil)
+          render_error(400, exception)
+        end
+
+        def unprocessable(exception_or_errors)
+          @status = 422
+
+          @errors =
+            if exception_or_errors.respond_to?(:record)
+              exception_or_errors.record.errors
+            elsif exception_or_errors.is_a?(StandardError)
+              {message: exception_or_errors.message}
+            else
+              exception_or_errors
+            end
+          @errors = Array.wrap(@errors)
+          render 'apress/api/shared/unprocessable_errors', status: @status
+        end
+
+        def parameter_missing(exception)
+          @status = 400
+          @errors = [{exception.param => 'missing'}]
+          render 'apress/api/shared/parameter_missing_errors', status: @status
+        end
+
+        def render_error(status, exception = nil)
+          @status = status
+          @exception = exception
+
+          log_error(exception) if exception
+
+          render "apress/api/shared/error", status: status
+        end
+
+        def log_error(exception)
+          Rails.logger.error(exception.message)
+          Rails.logger.error(exception.backtrace.join("/n")) if exception.backtrace.present?
+        end
+
+        def show_errors?
+          soft_environment?
+        end
+
+        def soft_environment?
+          Rails.env.staging? || !Rails.env.production?
+        end
+      end
+    end
+  end
+end

data/lib/apress/api/api_controller/responds.rb

@@ -0,0 +1,25 @@
+module Apress
+  module Api
+    module ApiController
+      module Responds
+        extend ActiveSupport::Concern
+
+        included do
+          if (Rails::VERSION::MAJOR == 4 && Rails::VERSION::MINOR == 2) || Rails::VERSION::MAJOR > 4
+            before_action :set_json_format
+          else
+            before_filter :set_json_format
+          end
+        end
+
+        private
+
+        # :nocov:
+        def set_json_format
+          request.format = :json
+        end
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/apress/api/callbacks/config.rb

@@ -0,0 +1,56 @@
+require 'singleton'
+
+module Apress
+  module Api
+    module Callbacks
+      class Config
+        include Singleton
+
+        class << self
+          delegate :add_service, :services, to: :instance
+          delegate :allowed_client?, :add_client, to: :instance
+          delegate :add_handler, :handlers, to: :instance
+          delegate :valid_event?, to: :instance
+        end
+
+        def add_service(event:, service:)
+          events[event] << service
+        end
+
+        def add_handler(service:, event:, handler:)
+          (handlers_config[service][event] ||= []) << handler
+        end
+
+        def add_client(access_id)
+          clients << access_id
+        end
+
+        def allowed_client?(client)
+          clients.include?(client.access_id)
+        end
+
+        def services(event)
+          events[event]
+        end
+
+        def handlers(service:, event:)
+          handlers_config.fetch(service).fetch(event)
+        end
+
+        private
+
+        def handlers_config
+          @handlers_config ||= ::Hash.new { |hash, key| hash[key] = {} }
+        end
+
+        def events
+          @events ||= ::Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def clients
+          @clients ||= Set.new
+        end
+      end
+    end
+  end
+end

data/lib/apress/api/callbacks/fire_callback_error.rb

@@ -0,0 +1,12 @@
+module Apress
+  module Api
+    module Callbacks
+      class FireCallbackError < StandardError
+        def initialize(message, backtrace)
+          super(message)
+          set_backtrace(backtrace)
+        end
+      end
+    end
+  end
+end

data/lib/apress/api/callbacks/integration.rb

@@ -0,0 +1,28 @@
+module Apress
+  module Api
+    module Callbacks
+      module Integration
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def notify_services(event:, params: {}, at:)
+            at = Array.wrap(at)
+            callback = at.shift
+
+            public_send(callback, *at) do
+              hash_params =
+                if params.respond_to?(:call)
+                  params.call(self)
+                else
+                  params.each_with_object({}) do |param, hash|
+                    hash[param] = public_send(param)
+                  end
+                end
+              ::Apress::Api::DelayedFireCallback.call!(event: event, params: hash_params)
+            end
+          end
+        end
+      end
+    end
+  end
+end