elastic-workplace-search 0.4.0

data/lib/elastic-workplace-search.rb

@@ -0,0 +1 @@
+require 'elastic/workplace-search'

data/lib/elastic/workplace-search.rb

@@ -0,0 +1,7 @@
+require 'elastic/workplace-search/client'
+
+module Elastic
+  module WorkplaceSearch
+    extend Elastic::WorkplaceSearch::Configuration
+  end
+end

data/lib/elastic/workplace-search/client.rb

@@ -0,0 +1,53 @@
+require 'set'
+require 'elastic/workplace-search/configuration'
+require 'elastic/workplace-search/request'
+require 'elastic/workplace-search/utils'
+
+module Elastic
+  module WorkplaceSearch
+    # API client for the {Elastic Workplace Search API}[https://www.elastic.co/workplace-search].
+    class Client
+      autoload :ContentSourceDocuments, 'elastic/workplace-search/client/content_source_documents.rb'
+      autoload :Permissions, 'elastic/workplace-search/client/permissions.rb'
+
+      DEFAULT_TIMEOUT = 15
+
+      include Elastic::WorkplaceSearch::Request
+
+      def self.configure(&block)
+        Elastic::WorkplaceSearch.configure &block
+      end
+
+      # Create a new Elastic::WorkplaceSearch::Client client
+      #
+      # @param options [Hash] a hash of configuration options that will override what is set on the Elastic::WorkplaceSearch class.
+      # @option options [String] :access_token an Access Token to use for this client
+      # @option options [Numeric] :overall_timeout overall timeout for requests in seconds (default: 15s)
+      # @option options [Numeric] :open_timeout the number of seconds Net::HTTP (default: 15s)
+      #   will wait while opening a connection before raising a Timeout::Error
+      # @option options [String] :proxy url of proxy to use, ex: "http://localhost:8888"
+      def initialize(options = {})
+        @options = options
+      end
+
+      def access_token
+        @options[:access_token] || Elastic::WorkplaceSearch.access_token
+      end
+
+      def open_timeout
+        @options[:open_timeout] || DEFAULT_TIMEOUT
+      end
+
+      def proxy
+        @options[:proxy]
+      end
+
+      def overall_timeout
+        (@options[:overall_timeout] || DEFAULT_TIMEOUT).to_f
+      end
+
+      include Elastic::WorkplaceSearch::Client::ContentSourceDocuments
+      include Elastic::WorkplaceSearch::Client::Permissions
+    end
+  end
+end

data/lib/elastic/workplace-search/client/content_source_documents.rb

@@ -0,0 +1,45 @@
+module Elastic
+  module WorkplaceSearch
+    class Client
+      module ContentSourceDocuments
+
+        # Index a batch of documents.
+        #
+        # @param [String] content_source_key the unique Content Source key as found in your Content Sources dashboard
+        # @param [Array] documents an Array of Document Hashes
+        #
+        # @return [Array<Hash>] an Array of Document indexing Results
+        #
+        # @raise [Elastic::WorkplaceSearch::InvalidDocument] when a single document is missing required fields or contains unsupported fields
+        # @raise [Timeout::Error] when timeout expires waiting for results
+        def index_documents(content_source_key, documents)
+          documents = Array(documents).map! { |document| normalize_document(document) }
+
+          async_create_or_update_documents(content_source_key, documents)
+        end
+
+        # Destroy a batch of documents given a list of external IDs
+        #
+        # @param [Array<String>] document_ids an Array of Document External IDs
+        #
+        # @return [Array<Hash>] an Array of Document destroy result hashes
+        #
+        # @raise [Timeout::Error] when timeout expires waiting for results
+        def destroy_documents(content_source_key, document_ids)
+          document_ids = Array(document_ids)
+          post("sources/#{content_source_key}/documents/bulk_destroy.json", document_ids)
+        end
+
+        private
+
+        def async_create_or_update_documents(content_source_key, documents)
+          post("sources/#{content_source_key}/documents/bulk_create.json", documents)
+        end
+
+        def normalize_document(document)
+          Utils.stringify_keys(document)
+        end
+      end
+    end
+  end
+end

data/lib/elastic/workplace-search/client/permissions.rb

@@ -0,0 +1,29 @@
+module Elastic
+  module WorkplaceSearch
+    class Client
+      module Permissions
+
+        def list_all_permissions(content_source_key, current: 1, size: 25)
+          get("sources/#{content_source_key}/permissions", "page[current]" => current, "page[size]" => size )
+        end
+
+        def get_user_permissions(content_source_key, user)
+          get("sources/#{content_source_key}/permissions/#{user}")
+        end
+
+        def update_user_permissions(content_source_key, user, options)
+          post("sources/#{content_source_key}/permissions/#{user}", options)
+        end
+
+        def add_user_permissions(content_source_key, user, options)
+          post("sources/#{content_source_key}/permissions/#{user}/add", options)
+        end
+
+        def remove_user_permissions(content_source_key, user, options)
+          post("sources/#{content_source_key}/permissions/#{user}/remove", options)
+        end
+
+      end
+    end
+  end
+end

data/lib/elastic/workplace-search/configuration.rb

@@ -0,0 +1,54 @@
+require 'uri'
+require 'elastic/workplace-search/version'
+
+module Elastic
+  module WorkplaceSearch
+    module Configuration
+      DEFAULT_ENDPOINT = "http://localhost:3002/api/ws/v1/"
+
+      VALID_OPTIONS_KEYS = [
+        :access_token,
+        :user_agent,
+        :endpoint
+      ].freeze
+
+      attr_accessor *VALID_OPTIONS_KEYS
+
+      def self.extended(base)
+        base.reset
+      end
+
+      # Reset configuration to default values.
+      def reset
+        self.access_token = nil
+        self.endpoint = DEFAULT_ENDPOINT
+        self.user_agent = nil
+        self
+      end
+
+      # Yields the Elastic::WorkplaceSearch::Configuration module which can be used to set configuration options.
+      #
+      # @return self
+      def configure
+        yield self
+        self
+      end
+
+      # Return a hash of the configured options.
+      def options
+        options = {}
+        VALID_OPTIONS_KEYS.each{ |k| options[k] = send(k) }
+        options
+      end
+
+      # setter for endpoint that ensures it always ends in '/'
+      def endpoint=(endpoint)
+        if endpoint.end_with?('/')
+          @endpoint = endpoint
+        else
+          @endpoint = "#{endpoint}/"
+        end
+      end
+    end
+  end
+end

data/lib/elastic/workplace-search/exceptions.rb

@@ -0,0 +1,11 @@
+module Elastic
+  module WorkplaceSearch
+    class ClientException < StandardError; end
+    class NonExistentRecord < ClientException; end
+    class InvalidCredentials < ClientException; end
+    class BadRequest < ClientException; end
+    class Forbidden < ClientException; end
+    class UnexpectedHTTPException < ClientException; end
+    class InvalidDocument < ClientException; end
+  end
+end

data/lib/elastic/workplace-search/request.rb

@@ -0,0 +1,113 @@
+require 'net/https'
+require 'json'
+require 'elastic/workplace-search/exceptions'
+require 'openssl'
+
+module Elastic
+  module WorkplaceSearch
+    CLIENT_NAME = 'elastic-workplace-search-ruby'
+    CLIENT_VERSION = Elastic::WorkplaceSearch::VERSION
+
+    module Request
+      def get(path, params={})
+        request(:get, path, params)
+      end
+
+      def post(path, params={})
+        request(:post, path, params)
+      end
+
+      def put(path, params={})
+        request(:put, path, params)
+      end
+
+      def delete(path, params={})
+        request(:delete, path, params)
+      end
+
+      # Construct and send a request to the API.
+      #
+      # @raise [Timeout::Error] when the timeout expires
+      def request(method, path, params = {})
+        Timeout.timeout(overall_timeout) do
+          uri = URI.parse("#{Elastic::WorkplaceSearch.endpoint}#{path}")
+
+          request = build_request(method, uri, params)
+
+          if proxy
+            proxy_parts = URI.parse(proxy)
+            http = Net::HTTP.new(uri.host, uri.port, proxy_parts.host, proxy_parts.port, proxy_parts.user, proxy_parts.password)
+          else
+            http = Net::HTTP.new(uri.host, uri.port)
+          end
+
+          http.open_timeout = open_timeout
+          http.read_timeout = overall_timeout
+
+          if uri.scheme == 'https'
+            http.use_ssl = true
+            # st_ssl_verify_none provides a means to disable SSL verification for debugging purposes. An example
+            # is Charles, which uses a self-signed certificate in order to inspect https traffic. This will
+            # not be part of this client's public API, this is more of a development enablement option
+            http.verify_mode = ENV['st_ssl_verify_none'] == 'true' ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+            http.ca_file = File.realpath(File.join(File.dirname(__FILE__), '..', '..', 'data', 'ca-bundle.crt'))
+            http.ssl_timeout = open_timeout
+          end
+
+          response = http.request(request)
+          handle_errors(response)
+          JSON.parse(response.body) if response.body && response.body.strip != ''
+        end
+      end
+
+      private
+      def handle_errors(response)
+        case response
+        when Net::HTTPSuccess
+          response
+        when Net::HTTPUnauthorized
+          raise Elastic::WorkplaceSearch::InvalidCredentials
+        when Net::HTTPNotFound
+          raise Elastic::WorkplaceSearch::NonExistentRecord
+        when Net::HTTPBadRequest
+          raise Elastic::WorkplaceSearch::BadRequest, "#{response.code} #{response.body}"
+        when Net::HTTPForbidden
+          raise Elastic::WorkplaceSearch::Forbidden
+        else
+          raise Elastic::WorkplaceSearch::UnexpectedHTTPException, "#{response.code} #{response.body}"
+        end
+      end
+
+      def build_request(method, uri, params)
+        klass = case method
+                when :get
+                  Net::HTTP::Get
+                when :post
+                  Net::HTTP::Post
+                when :put
+                  Net::HTTP::Put
+                when :delete
+                  Net::HTTP::Delete
+                end
+
+        case method
+        when :get, :delete
+          uri.query = URI.encode_www_form(params) if params && !params.empty?
+          req = klass.new(uri.request_uri)
+        when :post, :put
+          req = klass.new(uri.request_uri)
+          req.body = JSON.generate(params) unless params.length == 0
+        end
+
+        req['User-Agent'] = Elastic::WorkplaceSearch.user_agent if Elastic::WorkplaceSearch.user_agent
+        req['Content-Type'] = 'application/json'
+        req['X-Swiftype-Client'] = CLIENT_NAME
+        req['X-Swiftype-Client-Version'] = CLIENT_VERSION
+        req['Authorization'] = "Bearer #{access_token}"
+        puts req
+
+        req
+      end
+    end
+  end
+end

data/lib/elastic/workplace-search/utils.rb

@@ -0,0 +1,15 @@
+module Elastic
+  module WorkplaceSearch
+    module Utils
+      extend self
+
+      def stringify_keys(hash)
+        output = {}
+        hash.each do |key, value|
+          output[key.to_s] = value
+        end
+        output
+      end
+    end
+  end
+end

data/lib/elastic/workplace-search/version.rb

@@ -0,0 +1,5 @@
+module Elastic
+  module WorkplaceSearch
+    VERSION = '0.4.0'
+  end
+end

data/spec/client/content_source_documents_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Elastic::WorkplaceSearch::Client::ContentSourceDocuments do
+  let(:engine_slug) { 'workplace-search-api-example' }
+  let(:client) { Elastic::WorkplaceSearch::Client.new }
+
+  before :each do
+    Elastic::WorkplaceSearch.access_token = 'cGUN-vBokevBhhzyA669'
+  end
+
+  def check_receipt_response_format(response, options = {})
+    expect(response.keys).to match_array(["document_receipts", "batch_link"])
+    expect(response["document_receipts"]).to be_a_kind_of(Array)
+    expect(response["document_receipts"].first.keys).to match_array(["id", "id", "links", "status", "errors"])
+    expect(response["document_receipts"].first["id"]).to eq(options[:id]) if options[:id]
+    expect(response["document_receipts"].first["status"]).to eq(options[:status]) if options[:status]
+    expect(response["document_receipts"].first["errors"]).to eq(options[:errors]) if options[:errors]
+  end
+
+  let(:content_source_key) { '59542d332139de0acacc7dd4' }
+  let(:documents) do
+    [{'id'=>'INscMGmhmX4',
+      'url' => 'http://www.youtube.com/watch?v=v1uyQZNg2vE',
+      'title' => 'The Original Grumpy Cat',
+      'body' => 'this is a test'},
+     {'id'=>'JNDFojsd02',
+             'url' => 'http://www.youtube.com/watch?v=tsdfhk2j',
+             'title' => 'Another Grumpy Cat',
+             'body' => 'this is also a test'}]
+  end
+
+  context '#index_documents' do
+    it 'returns results when successful' do
+      VCR.use_cassette(:async_create_or_update_document_success) do
+        response = client.index_documents(content_source_key, documents)
+          expect(response.size).to eq(2)
+      end
+    end
+  end
+
+  context '#destroy_documents' do
+    it 'returns #async_create_or_update_documents format return when async has been passed as true' do
+      VCR.use_cassette(:async_create_or_update_document_success) do
+        VCR.use_cassette(:document_receipts_multiple_complete) do
+          client.index_documents(content_source_key, documents)
+          VCR.use_cassette(:destroy_documents_success) do
+            response = client.destroy_documents(content_source_key, [documents.first['id']])
+            expect(response.size).to eq(1)
+            expect(response.first['success']).to eq(true)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/client/permissions_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Elastic::WorkplaceSearch::Client::Permissions do
+  let(:client) { Elastic::WorkplaceSearch::Client.new }
+
+  before :each do
+    Elastic::WorkplaceSearch.access_token = 'xyT3mm3ecPsPuYxd_6fX'
+  end
+
+  let(:content_source_key) { '5d96387b75444bf49532c24a' }
+  let(:user) { 'enterprise_search' }
+
+  context '#list_all_permissions' do
+    it 'lists all permissions' do
+      VCR.use_cassette(:list_all_permissions) do
+        response = client.list_all_permissions(content_source_key)
+        expect(response['results'].size).to eq(2)
+      end
+    end
+
+    it 'lists all permissions with paging' do
+      VCR.use_cassette(:list_all_permissions_with_paging) do
+        response = client.list_all_permissions(content_source_key, :current => 2, :size => 5)
+        expect(response['meta']['page']['current']).to eq(2)
+        expect(response['meta']['page']['size']).to eq(5)
+        expect(response['results'].size).to eq(0)
+      end
+    end
+  end
+
+  context '#add_user_permissions' do
+    let(:permissions) { ['permission1'] }
+
+    it 'adds permissions to a user' do
+      VCR.use_cassette(:add_user_permissions) do
+        response = client.add_user_permissions(content_source_key, user, :permissions => permissions)
+        expect(response['permissions']).to eq(['permission1'])
+      end
+    end
+  end
+
+  context '#get_user_permissions' do
+    let(:permissions) { ['permission1'] }
+
+    it 'gets permissions for a user' do
+      VCR.use_cassette(:get_user_permissions) do
+        response = client.get_user_permissions(content_source_key, user)
+        expect(response['permissions']).to eq(['permission1'])
+      end
+    end
+  end
+
+  context '#update_user_permissions' do
+    let(:permissions) { ['permission2'] }
+
+    it 'updates permissions for a user' do
+      VCR.use_cassette(:update_user_permissions) do
+        response = client.update_user_permissions(content_source_key, user, :permissions => permissions)
+        expect(response['permissions']).to eq(['permission2'])
+      end
+    end
+  end
+
+  context '#remove_user_permissions' do
+    let(:permissions) { ['permission2'] }
+
+    it 'removes permissions from a user' do
+      VCR.use_cassette(:remove_user_permissions) do
+        response = client.remove_user_permissions(content_source_key, user, :permissions => permissions)
+        expect(response['permissions']).to eq([])
+      end
+    end
+  end
+
+end