workarea-api 4.4.6

data/lib/workarea/api/documentation.rb

@@ -0,0 +1,61 @@
+module Workarea
+  module Api
+    class Documentation < Raddocs::App
+      set :views, Workarea::Api.root.join(
+        'app',
+        'views',
+        'workarea',
+        'api',
+        'docs'
+      )
+
+      helpers do
+        def index_path
+          if request.path_info.starts_with?('/admin')
+            '/admin'
+          elsif request.path_info.starts_with?('/storefront')
+            '/storefront'
+          else
+            '/'
+          end
+        end
+
+        def markdown
+          Redcarpet::Markdown.new(
+            Redcarpet::Render::HTML,
+            autolink: true,
+            fenced_code_blocks: true,
+            no_intra_emphasis: true
+          )
+        end
+      end
+
+      get '/' do
+        content = File.read("#{Workarea::Api::Engine.root}/README.md")
+        haml :index, layout: false, locals: { content: content }
+      end
+
+      get '/admin' do
+        index = Raddocs::Index.new(File.join(docs_dir, 'admin', 'index.json'))
+        content = File.read("#{Workarea::Api::Admin::Engine.root}/README.md")
+        haml :engine_index, locals: { index: index, content: content }
+      end
+
+      get '/storefront' do
+        index = Raddocs::Index.new(File.join(docs_dir, 'storefront', 'index.json'))
+        content = File.read("#{Workarea::Api::Storefront::Engine.root}/README.md")
+        haml :engine_index, locals: { index: index, content: content }
+      end
+
+      get '/*' do
+        file = File.join(docs_dir, "#{params[:splat][0]}.json")
+        raise Sinatra::NotFound unless File.exists?(file)
+
+        index = Raddocs::Index.new(File.join(docs_dir, index_path, 'index.json'))
+        example = Raddocs::Example.new(file)
+
+        haml :example, locals: { index: index, example: example }
+      end
+    end
+  end
+end

data/lib/workarea/api/documentation_test.rb

@@ -0,0 +1,210 @@
+require 'workarea/api/curl'
+
+if ENV['GENERATE_API_DOCS']
+  MiniTest.after_run do
+    Workarea::Api::DocumentationTest.build_index('admin')
+    Workarea::Api::DocumentationTest.build_index('storefront')
+  end
+end
+
+module Workarea
+  module Api
+    class DocumentationTest < Workarea::IntegrationTest
+      IGNORED_HEADERS = %w(Host Accept)
+
+      class Example
+        attr_accessor :resource, :http_method, :route, :description,
+          :explanation, :parameters, :response_fields, :requests
+
+        def initialize
+          @parameters = []
+          @response_fields = []
+          @requests = []
+        end
+
+        def file_name
+          name = @description.presence || "#{@http_method} #{@route}"
+          "#{name.systemize}.json"
+        end
+      end
+
+      class Request
+        attr_accessor :request_method, :request_path, :request_body,
+                        :request_headers, :request_query_parameters,
+                        :request_content_type, :response_status,
+                        :response_status_text, :response_body,
+                        :response_headers, :response_content_type, :curl
+
+        def initialize
+          @request_headers = {}
+          @request_query_parameters = {}
+          @response_headers = {}
+        end
+      end
+
+      class << self
+        def resource(val = nil)
+          @resource = val || @resource
+        end
+
+        def docs_root
+          @docs_root ||= if running_in_gem?
+            Workarea::Api.root.join('doc', 'api')
+          else
+            Rails.root.join('doc', 'api')
+          end
+        end
+
+        def running_in_gem?
+          Rails.root.to_s.include?('test/dummy')
+        end
+
+        def docs_dir
+          docs_root.join(engine, resource.systemize)
+        end
+
+        def engine
+          name.split('::')[-2].downcase
+        end
+
+        def build_index(engine)
+          results = { 'resources' => [] }
+          root = docs_root.join(engine)
+
+          FileUtils.mkdir_p(root)
+          begin
+            FileUtils.rm(root.join('index.json'))
+          rescue
+            nil
+          end
+
+          Dir.glob(root.join('**/*.json')) do |file|
+            example = JSON.parse(File.read(file))
+
+            existing_resource = results['resources'].detect do |resource|
+              resource['name'] == example['resource']
+            end
+
+            index_example = {
+              'description' => example['description'],
+              'link' => file.to_s.gsub("#{docs_root}/", ''),
+              'groups' => 'all',
+              'route' => example['route'],
+              'method' => example['http_method']
+            }
+
+            if existing_resource.present?
+              existing_resource['examples'] << index_example
+            else
+              results['resources'] << {
+                'name' => example['resource'],
+                'examples' => [index_example]
+              }
+            end
+          end
+
+          File.open(root.join('index.json'), 'w') do |file|
+            file.write(JSON.pretty_generate(results))
+          end
+        end
+      end
+
+      setup :setup_example
+      teardown :save_example
+
+      def parameter(name, description)
+        @example.parameters << { name: name, description: description }
+      end
+
+      def method_missing(method_name, *args, &block)
+        if @example.respond_to?("#{method_name}=")
+          @example.send("#{method_name}=", *args)
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_name, include_private = false)
+        @example.respond_to?("#{method_name}=") || super
+      end
+
+      def record_request
+        yield
+
+        @example.http_method = request.method.upcase if @example.http_method.blank?
+        headers = env_to_headers(request.env)
+        request_body = read_request_body
+
+        doc_request = Request.new
+        doc_request.request_method = request.method
+        doc_request.request_path = request.fullpath
+        doc_request.request_body = request_body.empty? ? nil : request_body.force_encoding('UTF-8')
+        doc_request.request_headers = headers
+        doc_request.request_query_parameters = request.query_parameters
+        doc_request.request_content_type = headers['Content-Type']
+        doc_request.response_status = response.status
+        doc_request.response_status_text = response.message
+        doc_request.response_body = formatted_response_body
+        doc_request.response_headers = filtered_response_headers
+        doc_request.response_content_type = response.content_type
+
+        curl = Curl.new(request.method, request.fullpath, request_body, headers)
+        doc_request.curl = curl.output("https://#{Workarea.config.host}")
+
+        @example.requests << doc_request
+      end
+
+      private
+
+      def setup_example
+        @example = Example.new
+        @example.resource = self.class.resource
+      end
+
+      def save_example
+        if passed? && ENV['GENERATE_API_DOCS']
+          FileUtils.mkdir_p(self.class.docs_dir)
+          File.open(self.class.docs_dir.join(@example.file_name), 'w') do |file|
+            file.write(JSON.pretty_generate(JSON.parse(@example.to_json)))
+          end
+        end
+      end
+
+      def read_request_body
+        input = request.env['rack.input']
+        input.rewind
+        input.read
+      end
+
+      def formatted_response_body
+        return nil if response.body.empty?
+
+        if response.body.encoding == Encoding::ASCII_8BIT
+          '[binary data]'
+        elsif response.content_type =~ %r{application/json}
+          JSON.pretty_generate(JSON.parse(response.body))
+        else
+          response.body
+        end
+      end
+
+      def filtered_response_headers
+        response.headers.except(*Workarea.config.suppress_api_response_headers)
+      end
+
+      def env_to_headers(env)
+        headers = {}
+        env.each do |key, value|
+          if key =~ /^(HTTP_|CONTENT_TYPE)/
+            header = key.gsub(/^HTTP_/, '').split('_').map { |s| s.titleize }.join('-')
+
+            if value.present? && !IGNORED_HEADERS.include?(header)
+              headers[header] = value
+            end
+          end
+        end
+        headers
+      end
+    end
+  end
+end

data/lib/workarea/api/engine.rb

@@ -0,0 +1,8 @@
+module Workarea
+  module Api
+    class Engine < ::Rails::Engine
+      include Workarea::Plugin
+      isolate_namespace Workarea::Api
+    end
+  end
+end

data/lib/workarea/api/version.rb

@@ -0,0 +1,5 @@
+module Workarea
+  module Api
+    VERSION = '4.4.6'.freeze
+  end
+end

data/lib/workarea/api.rb

@@ -0,0 +1,18 @@
+require 'responders'
+require 'raddocs'
+
+require 'workarea'
+require 'workarea/storefront'
+require 'workarea/admin'
+
+module Workarea
+  module Api
+  end
+end
+
+require 'workarea/api/engine'
+require 'workarea/api/version'
+
+require 'workarea/api/admin'
+require 'workarea/api/storefront'
+require 'workarea/api/documentation'

data/storefront/.gitignore

@@ -0,0 +1,12 @@
+.bundle/
+Gemfile.lock
+.sass-cache/
+log/*.log
+pkg/
+test/dummy/public/system/dragonfly
+test/dummy/db/*.sqlite3
+test/dummy/log/*.log
+test/dummy/tmp/
+test/dummy/.sass-cache
+**/.DS_Store
+docs/build

data/storefront/README.md

@@ -0,0 +1,58 @@
+# Workarea Storefront API
+
+Part of the [Workarea API][], the Storefront API provides programmatic
+access to operations and resources to alternative user interfaces to
+your Workarea application, like on-premises kiosks, mobile applications,
+and client-side storefront implementations.
+
+## Getting Started
+
+To use this plugin, install the **workarea-api** gem.
+
+For more information on the API as a whole, and to learn how to set up
+the API plugin, consult the [main README][Workarea API].
+
+## Authenticating
+
+The Storefront API requires the use of a temporary authentication token,
+analogous to the user ID in the session, which tells the backend of
+Workarea whether a User is authenticated. It uses the
+`Workarea::UrlToken` mixin from core to generate this token.
+
+To obtain an authentication token, make a POST request like so:
+
+```bash
+curl \
+  --request POST \
+  --data '{ "email": "your@email.address", "password": "Password1!" }' \
+  "http://yourincredibleheadlesscommercesolution.biz/api/authentication_tokens.json"
+```
+
+You should get a response that looks like this:
+
+```json
+{
+  "token": "tL6Scp6ubsufq76FZHLbhLWs",
+  "expires_at": "2018-12-25T11:58:43.674-05:00"
+}
+```
+
+Use the `token` in this response to make further authenticated requests
+to the API:
+
+
+```bash
+curl \
+  --request GET \
+  --header 'Authorization: Token token="tL6Scp6ubsufq76FZHLbhLWs"' \
+  "http://yourincredibleheadlesscommercesolution.biz/api/carts.json"
+```
+
+## Copyright & Licensing
+
+Copyright Workarea 2017-2019. All rights reserved.
+
+For licensing, contact [sales@workarea.com][].
+
+[Workarea API]: https://homebase.weblinc.com/plugins/workarea-api-admin
+[sales@workarea.com]: mailto:sales@workarea.com

data/storefront/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+# Load the dummy app's rake tasks
+APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'

data/storefront/app/controllers/workarea/api/storefront/accounts_controller.rb

@@ -0,0 +1,31 @@
+module Workarea
+  module Api
+    module Storefront
+      class AccountsController < Api::Storefront::ApplicationController
+        def show
+        end
+
+        def create
+          @user = User.create!(user_params)
+
+          Workarea::Storefront::AccountMailer
+            .creation(@user.id.to_s)
+            .deliver_later
+
+          @authentication_token = @user.authentication_tokens.create!
+        end
+
+        def update
+          current_user.update_attributes!(user_params)
+          render :show
+        end
+
+        private
+
+        def user_params
+          params.permit(:email, :password, :first_name, :last_name)
+        end
+      end
+    end
+  end
+end

data/storefront/app/controllers/workarea/api/storefront/analytics_controller.rb

@@ -0,0 +1,41 @@
+module Workarea
+  module Api
+    module Storefront
+      class AnalyticsController < ActionController::Metal
+        include ActionController::Head
+        include ActionController::Instrumentation
+
+        def category_view
+          Metrics::CategoryByDay.inc(key: { category_id: params[:category_id] }, views: 1)
+          head :ok
+        end
+
+        def product_view
+          Metrics::ProductByDay.inc(key: { product_id: params[:product_id] }, views: 1)
+          head :ok
+        end
+
+        def search
+          Metrics::SearchByDay.save_search(params[:q], params[:total_results])
+          head :ok
+        end
+
+        def search_abandonment
+          warn <<~eos
+DEPRECATION WARNING: Search abandonment tracking is deprecated and will be removed \
+in Workarea 3.5.
+          eos
+          head :ok
+        end
+
+        def filters
+          warn <<~eos
+DEPRECATION WARNING: Filter analytics tracking is deprecated and will be removed \
+in Workarea 3.5.
+          eos
+          head :ok
+        end
+      end
+    end
+  end
+end

data/storefront/app/controllers/workarea/api/storefront/application_controller.rb

@@ -0,0 +1,65 @@
+module Workarea
+  module Api
+    module Storefront
+      class ApplicationController < Workarea::ApplicationController
+        include Workarea::Storefront::HttpCaching
+        include Api::Storefront::Authentication
+        include Api::Storefront::UserActivity
+
+        respond_to :json
+
+        before_action :set_json_format
+        before_action :skip_session
+        before_action { params.permit! }
+        after_action :disable_cors_protection
+
+        rescue_from Mongoid::Errors::DocumentNotFound, with: :handle_not_found
+        rescue_from Mongoid::Errors::Validations, with: :handle_invalid
+        rescue_from Mongoid::Errors::UnknownAttribute, with: :handle_unknown_attribute
+        rescue_from Authentication::InvalidError, with: :handle_invalid_auth
+
+        helper :all
+
+        def cache_page
+          expires_in Workarea.config.page_cache_ttl, public: true
+        end
+
+        def skip_session
+          request.session_options[:skip] = true
+        end
+
+        private
+
+        def set_json_format
+          request.format = :json
+        end
+
+        def handle_not_found(e)
+          payload = { params: e.params, problem: e.problem }
+          render json: payload, status: :not_found
+        end
+
+        def handle_invalid(e)
+          render(
+            json: { problems: e.document.errors.full_messages },
+            status: :unprocessable_entity
+          )
+        end
+
+        def handle_unknown_attribute(e)
+          render json: e.as_json.slice('problem'), status: :unprocessable_entity
+        end
+
+        def handle_invalid_auth
+          request_http_token_authentication
+        end
+
+        def disable_cors_protection
+          headers['Access-Control-Allow-Origin'] = '*'
+          headers['Access-Control-Allow-Headers'] = '*'
+          headers['Access-Control-Allow-Methods'] = 'GET, POST, PATCH, PUT, DELETE, OPTIONS'
+        end
+      end
+    end
+  end
+end

data/storefront/app/controllers/workarea/api/storefront/assets_controller.rb

@@ -0,0 +1,11 @@
+module Workarea
+  module Api
+    module Storefront
+      class AssetsController < Api::Storefront::ApplicationController
+        def show
+          @asset = Content::Asset.find(params[:id])
+        end
+      end
+    end
+  end
+end

data/storefront/app/controllers/workarea/api/storefront/authentication.rb

@@ -0,0 +1,30 @@
+module Workarea
+  module Api
+    module Storefront
+      module Authentication
+        extend ActiveSupport::Concern
+
+        class InvalidError < RuntimeError; end
+
+        included do
+          helper_method :current_user
+        end
+
+        def current_user
+          return @current_user if defined?(@current_user)
+
+          user = authenticate_with_http_token do |token, options|
+            User::AuthenticationToken.authenticate(token, options).try(:user)
+          end
+
+          @current_user = user || raise(InvalidError)
+        end
+
+        def authentication?
+          regex = ActionController::HttpAuthentication::Token::TOKEN_REGEX
+          request.authorization.to_s[regex].present?
+        end
+      end
+    end
+  end
+end

data/storefront/app/controllers/workarea/api/storefront/authentication_tokens_controller.rb

@@ -0,0 +1,50 @@
+module Workarea
+  module Api
+    module Storefront
+      class AuthenticationTokensController < Api::Storefront::ApplicationController
+        before_action :ensure_not_locked, only: :create
+
+        def create
+          user = User.find_for_login(params[:email], params[:password])
+
+          if user.blank?
+            render(
+              json: { problem: t('workarea.api.storefront.authentication_tokens.error') },
+              status: :unprocessable_entity
+            )
+          else
+            @authentication_token = User::AuthenticationToken.create!(user: user)
+          end
+        end
+
+        def update
+          @authentication_token = authenticate_with_http_token do |token, options|
+            User::AuthenticationToken.refresh!(token, options)
+          end
+
+          if @authentication_token.blank?
+            render(
+              json: { problem: t('workarea.api.storefront.authentication_tokens.error') },
+              status: :unprocessable_entity
+            )
+          end
+        end
+
+        private
+
+        def ensure_not_locked
+          if User.login_locked?(params[:email])
+            render(
+              json: {
+                problem: t('workarea.api.storefront.authentication_tokens.login_locked')
+              },
+              status: :unprocessable_entity
+            )
+
+            return false
+          end
+        end
+      end
+    end
+  end
+end