module Elastic::EnterpriseSearch::AppSearch::Actions

Public Instance Methods

add_meta_engine_source(engine_name, arguments = {}) click to toggle source

Engine - Add a source engine to an existing meta engine

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Array] :source_engines List of engine names (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/meta-engines.html#meta-engines-add-source-engines

# File lib/elastic/app-search/api/add_meta_engine_source.rb, line 33
def add_meta_engine_source(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'source_engines' missing" unless arguments[:source_engines]

  source_engines = arguments.delete(:source_engines) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    "api/as/v1/engines/#{engine_name}/source_engines/",
    arguments,
    source_engines,
    headers
  )
end
api_key(arguments = {}) click to toggle source

Credentials - Get the details of an API key

@param arguments [Hash] endpoint arguments @option arguments [String] :api_key_name Name of an API key (Required) @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/credentials.html#credentials-single

# File lib/elastic/app-search/api/api_key.rb, line 33
def api_key(arguments = {})
  raise ArgumentError, "Required parameter 'api_key_name' missing" unless arguments[:api_key_name]

  api_key_name = arguments[:api_key_name]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/credentials/#{api_key_name}/",
    arguments,
    body,
    headers
  )
end
api_logs(engine_name, arguments = {}) click to toggle source

Logs - The API Log displays API request and response data at the Engine level

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [String] :from_date Filter date from (Required) @option arguments [String] :to_date Filter date to (Required) @option arguments [Integer] :current_page The page to fetch. Defaults to 1 @option arguments [Integer] :page_size The number of results per page @option arguments [String] :query Use this to specify a particular endpoint, like analytics, search, curations and so on @option arguments [String] :http_status_filter Filter based on a particular status code: 400, 401, 403, 429, 200 @option arguments [String] :http_method_filter Filter based on a particular HTTP method: GET, POST, PUT, PATCH, DELETE @option arguments [String] :sort_direction Would you like to have your results ascending, oldest to newest, or descending, newest to oldest? @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/api-logs.html

# File lib/elastic/app-search/api/api_logs.rb, line 41
def api_logs(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'from_date' missing" unless arguments[:from_date]
  raise ArgumentError, "Required parameter 'to_date' missing" unless arguments[:to_date]
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  arguments['filters[date][from]'] = date_to_rfc3339(arguments.delete(:from_date))
  arguments['filters[date][to]'] = date_to_rfc3339(arguments.delete(:to_date))

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/logs/api/",
    arguments,
    body,
    headers
  )
end
count_analytics(engine_name, arguments = {}) click to toggle source

Analytics - Returns the number of clicks and total number of queries over a period

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Array] :filters Analytics filters @option arguments [String] :interval You can define an interval along with your date range. Can be either hour or day @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/counts.html

# File lib/elastic/app-search/api/count_analytics.rb, line 35
def count_analytics(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/analytics/counts/",
    arguments,
    body,
    headers
  )
end
create_api_key(arguments = {}) click to toggle source

Credentials - Create an API key

@param arguments [Hash] endpoint arguments @option arguments [Object] :body API key details (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/credentials.html#credentials-create

# File lib/elastic/app-search/api/create_api_key.rb, line 32
def create_api_key(arguments = {})
  raise ArgumentError, "Required parameter 'body' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    'api/as/v1/credentials/',
    arguments,
    body,
    headers
  )
end
create_curation(engine_name, arguments = {}) click to toggle source

Curations - Create a new curation

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Array] :queries List of affected search queries (Required) @option arguments :promoted_doc_ids List of promoted document IDs @option arguments :hidden_doc_ids List of hidden document IDs @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/curations.html#curations-create

# File lib/elastic/app-search/api/create_curation.rb, line 36
def create_curation(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'queries' missing" unless arguments[:queries]
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    "api/as/v1/engines/#{engine_name}/curations/",
    arguments,
    body,
    headers
  )
end
create_engine(arguments = {}) click to toggle source

Engine - Creates a new engine

@param arguments [Hash] endpoint arguments @option arguments [String] :name Engine name (Required) @option arguments [String] :language Engine language (null for universal) @option arguments [String] :type Engine type @option arguments [Array] :source_engines Sources engines list @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/engines.html#engines-create

# File lib/elastic/app-search/api/create_engine.rb, line 36
def create_engine(arguments = {})
  raise ArgumentError, "Required parameter 'name' missing" unless arguments[:name]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    'api/as/v1/engines/',
    arguments,
    body,
    headers
  )
end
create_synonym_set(engine_name, arguments = {}) click to toggle source

Synonyms - Create a new synonym set

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Object] :body Synonym set description (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-create

# File lib/elastic/app-search/api/create_synonym_set.rb, line 33
def create_synonym_set(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    "api/as/v1/engines/#{engine_name}/synonyms/",
    arguments,
    body,
    headers
  )
end
curation(engine_name, arguments = {}) click to toggle source

Curations - Retrieve a curation by ID

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [String] :curation_id (Required) @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/curations.html#curations-read

# File lib/elastic/app-search/api/curation.rb, line 34
def curation(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'curation_id' missing" unless arguments[:curation_id]

  curation_id = arguments[:curation_id]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/curations/#{curation_id}/",
    arguments,
    body,
    headers
  )
end
delete_api_key(arguments = {}) click to toggle source

Credentials - Delete an API key

@param arguments [Hash] endpoint arguments @option arguments [String] :api_key_name Name of an API key (Required) @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/credentials.html#credentials-destroy

# File lib/elastic/app-search/api/delete_api_key.rb, line 33
def delete_api_key(arguments = {})
  raise ArgumentError, "Required parameter 'api_key_name' missing" unless arguments[:api_key_name]

  api_key_name = arguments[:api_key_name]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :delete,
    "api/as/v1/credentials/#{api_key_name}/",
    arguments,
    body,
    headers
  )
end
delete_curation(engine_name, arguments = {}) click to toggle source

Curations - Delete a curation by ID

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [String] :curation_id (Required) @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/curations.html#curations-destroy

# File lib/elastic/app-search/api/delete_curation.rb, line 34
def delete_curation(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'curation_id' missing" unless arguments[:curation_id]

  curation_id = arguments[:curation_id]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/curations/#{curation_id}/",
    arguments,
    body,
    headers
  )
end
delete_documents(engine_name, arguments = {}) click to toggle source

Documents - Delete documents by ID

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Array] :document_ids List of document IDs (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/documents.html#documents-delete

# File lib/elastic/app-search/api/delete_documents.rb, line 33
def delete_documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'document_ids' missing" unless arguments[:document_ids]

  document_ids = arguments.delete(:document_ids) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/documents/",
    arguments,
    document_ids,
    headers
  )
end
delete_engine(engine_name, arguments = {}) click to toggle source

Engine - Delete an engine by name

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/engines.html#engines-delete

# File lib/elastic/app-search/api/delete_engine.rb, line 33
def delete_engine(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/",
    arguments,
    body,
    headers
  )
end
delete_meta_engine_source(engine_name, arguments = {}) click to toggle source

Engine - Delete a source engine from a meta engine

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Array] :source_engines List of engine names (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/meta-engines.html#meta-engines-remove-source-engines

# File lib/elastic/app-search/api/delete_meta_engine_source.rb, line 33
def delete_meta_engine_source(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'source_engines' missing" unless arguments[:source_engines]

  source_engines = arguments.delete(:source_engines) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/source_engines/",
    arguments,
    source_engines,
    headers
  )
end
delete_synonym_set(engine_name, arguments = {}) click to toggle source

Synonyms - Delete a synonym set by ID

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [String] :synonym_set_id (Required) @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-delete

# File lib/elastic/app-search/api/delete_synonym_set.rb, line 34
def delete_synonym_set(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'synonym_set_id' missing" unless arguments[:synonym_set_id]

  synonym_set_id = arguments[:synonym_set_id]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :delete,
    "api/as/v1/engines/#{engine_name}/synonyms/#{synonym_set_id}/",
    arguments,
    body,
    headers
  )
end
documents(engine_name, arguments = {}) click to toggle source

Documents - Retrieves one or more documents by ID

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Array] :document_ids List of document IDs (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/documents.html#documents-get

# File lib/elastic/app-search/api/documents.rb, line 33
def documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'document_ids' missing" unless arguments[:document_ids]

  document_ids = arguments.delete(:document_ids) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/documents/",
    arguments,
    document_ids,
    headers
  )
end
engine(engine_name, arguments = {}) click to toggle source

Engine - Retrieves an engine by name

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/engines.html#engines-get

# File lib/elastic/app-search/api/engine.rb, line 33
def engine(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/",
    arguments,
    body,
    headers
  )
end
index_documents(engine_name, arguments = {}) click to toggle source

Documents - Create or update documents

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Array] :documents List of document to index (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/documents.html#documents-create

# File lib/elastic/app-search/api/index_documents.rb, line 33
def index_documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'documents' missing" unless arguments[:documents]

  documents = arguments.delete(:documents) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    "api/as/v1/engines/#{engine_name}/documents/",
    arguments,
    documents,
    headers
  )
end
list_api_keys(arguments = {}) click to toggle source

Credentials - List the details of all API keys

@param arguments [Hash] endpoint arguments @option arguments [Integer] :current_page The page to fetch. Defaults to 1 @option arguments [Integer] :page_size The number of results per page @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/credentials.html#credentials-all

# File lib/elastic/app-search/api/list_api_keys.rb, line 34
def list_api_keys(arguments = {})
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    'api/as/v1/credentials/',
    arguments,
    body,
    headers
  )
end
list_curations(engine_name, arguments = {}) click to toggle source

Curations - Retrieve available curations for the engine

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Integer] :current_page The page to fetch. Defaults to 1 @option arguments [Integer] :page_size The number of results per page @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/curations.html#curations-read

# File lib/elastic/app-search/api/list_curations.rb, line 35
def list_curations(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/curations/",
    arguments,
    body,
    headers
  )
end
list_documents(engine_name, arguments = {}) click to toggle source

Documents - List all available documents with optional pagination support

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Integer] :current_page The page to fetch. Defaults to 1 @option arguments [Integer] :page_size The number of results per page @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/documents.html#documents-list

# File lib/elastic/app-search/api/list_documents.rb, line 35
def list_documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/documents/list/",
    arguments,
    body,
    headers
  )
end
list_engines(arguments = {}) click to toggle source

Engine - Retrieves all engines with optional pagination support

@param arguments [Hash] endpoint arguments @option arguments [Integer] :current_page The page to fetch. Defaults to 1 @option arguments [Integer] :page_size The number of results per page @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/engines.html#engines-list

# File lib/elastic/app-search/api/list_engines.rb, line 34
def list_engines(arguments = {})
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    'api/as/v1/engines/',
    arguments,
    body,
    headers
  )
end
list_synonym_sets(engine_name, arguments = {}) click to toggle source

Synonyms - Retrieve available synonym sets for the engine

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Integer] :current_page The page to fetch. Defaults to 1 @option arguments [Integer] :page_size The number of results per page @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-get

# File lib/elastic/app-search/api/list_synonym_sets.rb, line 35
def list_synonym_sets(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/synonyms/",
    arguments,
    body,
    headers
  )
end
log_clickthrough(engine_name, arguments = {}) click to toggle source

Click - Send data about clicked results

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [String] :query_text Search query text (Required) @option arguments :document_id The ID of the document that was clicked on (Required) @option arguments [String] :request_id The request ID returned in the meta tag of a search API response @option arguments [Array] :tags Array of strings representing additional information you wish to track with the clickthrough @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/clickthrough.html

# File lib/elastic/app-search/api/log_clickthrough.rb, line 37
def log_clickthrough(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'query_text' missing" unless arguments[:query_text]
  raise ArgumentError, "Required parameter 'document_id' missing" unless arguments[:document_id]
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}
  arguments['query'] = arguments.delete(:query_text)

  request(
    :post,
    "api/as/v1/engines/#{engine_name}/click/",
    arguments,
    body,
    headers
  )
end
put_api_key(arguments = {}) click to toggle source

Credentials - Update an API key

@param arguments [Hash] endpoint arguments @option arguments [String] :api_key_name Name of an API key (Required) @option arguments [Object] :body API key details (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/credentials.html#credentials-update

# File lib/elastic/app-search/api/put_api_key.rb, line 33
def put_api_key(arguments = {})
  raise ArgumentError, "Required parameter 'api_key_name' missing" unless arguments[:api_key_name]
  raise ArgumentError, "Required parameter 'body' missing" unless arguments[:body]

  api_key_name = arguments[:api_key_name]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :put,
    "api/as/v1/credentials/#{api_key_name}/",
    arguments,
    body,
    headers
  )
end
put_curation(engine_name, arguments = {}) click to toggle source

Curations - Update an existing curation

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Array] :queries List of affected search queries (Required) @option arguments [String] :curation_id (Required) @option arguments :promoted_doc_ids List of promoted document IDs @option arguments :hidden_doc_ids List of hidden document IDs @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/curations.html#curations-update

# File lib/elastic/app-search/api/put_curation.rb, line 37
def put_curation(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'queries' missing" unless arguments[:queries]
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'curation_id' missing" unless arguments[:curation_id]

  curation_id = arguments[:curation_id]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :put,
    "api/as/v1/engines/#{engine_name}/curations/#{curation_id}/",
    arguments,
    body,
    headers
  )
end
put_documents(engine_name, arguments = {}) click to toggle source

Documents - Partial update of documents

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Array] :documents List of documents to update (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/documents.html#documents-partial

# File lib/elastic/app-search/api/put_documents.rb, line 33
def put_documents(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'documents' missing" unless arguments[:documents]

  documents = arguments.delete(:documents) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :patch,
    "api/as/v1/engines/#{engine_name}/documents/",
    arguments,
    documents,
    headers
  )
end
put_schema(engine_name, arguments = {}) click to toggle source

Schema - Update schema for the current engine

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Object] :schema Schema description (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/schema.html#schema-patch

# File lib/elastic/app-search/api/put_schema.rb, line 33
def put_schema(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'schema' missing" unless arguments[:schema]

  schema = arguments.delete(:schema) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    "api/as/v1/engines/#{engine_name}/schema/",
    arguments,
    schema,
    headers
  )
end
put_search_settings(engine_name, arguments = {}) click to toggle source

Searchsettings - Update search settings for the engine

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Object] :body Search settings (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/search-settings.html#search-settings-update

# File lib/elastic/app-search/api/put_search_settings.rb, line 33
def put_search_settings(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'body' missing" unless arguments[:body]

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :put,
    "api/as/v1/engines/#{engine_name}/search_settings/",
    arguments,
    body,
    headers
  )
end
put_synonym_set(engine_name, arguments = {}) click to toggle source

Synonyms - Update a synonym set by ID

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [String] :synonym_set_id (Required) @option arguments [Object] :body Synonym set description (Required) @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-update

# File lib/elastic/app-search/api/put_synonym_set.rb, line 34
def put_synonym_set(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'synonym_set_id' missing" unless arguments[:synonym_set_id]
  raise ArgumentError, "Required parameter 'body' missing" unless arguments[:body]

  synonym_set_id = arguments[:synonym_set_id]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :put,
    "api/as/v1/engines/#{engine_name}/synonyms/#{synonym_set_id}/",
    arguments,
    body,
    headers
  )
end
query_suggestion(engine_name, arguments = {}) click to toggle source

Querysuggestion - Provide relevant query suggestions for incomplete queries

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [String] :query A partial query for which to receive suggestions (Required) @option arguments [Array] :fields List of fields to use to generate suggestions. Defaults to all text fields @option arguments [Integer] :size Number of query suggestions to return. Must be between 1 and 20. Defaults to 5 @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/query-suggestion.html

# File lib/elastic/app-search/api/query_suggestion.rb, line 36
def query_suggestion(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'query' missing" unless arguments[:query]
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    "api/as/v1/engines/#{engine_name}/query_suggestion/",
    arguments,
    body,
    headers
  )
end
reset_search_settings(engine_name, arguments = {}) click to toggle source

Searchsettings - Reset search settings for the engine

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/search-settings.html#search-settings-reset

# File lib/elastic/app-search/api/reset_search_settings.rb, line 33
def reset_search_settings(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :post,
    "api/as/v1/engines/#{engine_name}/search_settings/reset/",
    arguments,
    body,
    headers
  )
end
schema(engine_name, arguments = {}) click to toggle source

Schema - Retrieve current schema for the engine

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/schema.html#schema-read

# File lib/elastic/app-search/api/schema.rb, line 33
def schema(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/schema/",
    arguments,
    body,
    headers
  )
end
search_settings(engine_name, arguments = {}) click to toggle source

Searchsettings - Retrieve current search settings for the engine

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/search-settings.html#search-settings-show

# File lib/elastic/app-search/api/search_settings.rb, line 33
def search_settings(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/search_settings/",
    arguments,
    body,
    headers
  )
end
synonym_set(engine_name, arguments = {}) click to toggle source

Synonyms - Retrieve a synonym set by ID

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [String] :synonym_set_id (Required) @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/synonyms.html#synonyms-list-one

# File lib/elastic/app-search/api/synonym_set.rb, line 34
def synonym_set(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name
  raise ArgumentError, "Required parameter 'synonym_set_id' missing" unless arguments[:synonym_set_id]

  synonym_set_id = arguments[:synonym_set_id]
  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/synonyms/#{synonym_set_id}/",
    arguments,
    body,
    headers
  )
end
top_clicks_analytics(engine_name, arguments = {}) click to toggle source

Analytics - Returns the number of clicks received by a document in descending order

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [String] :query Filter clicks over a search query @option arguments [Integer] :current_page The page to fetch. Defaults to 1 @option arguments [Integer] :page_size The number of results per page @option arguments [Array] :filters Analytics filters @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/clicks.html

# File lib/elastic/app-search/api/top_clicks_analytics.rb, line 37
def top_clicks_analytics(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/analytics/clicks/",
    arguments,
    body,
    headers
  )
end
top_queries_analytics(engine_name, arguments = {}) click to toggle source

Analytics - Returns queries analytics by usage count

@param engine_name [String] (Required) @param arguments [Hash] endpoint arguments @option arguments [Integer] :current_page The page to fetch. Defaults to 1 @option arguments [Integer] :page_size The number of results per page @option arguments [Array] :filters Analytics filters @option arguments [Hash] :body The request body @option arguments [Hash] :headers optional HTTP headers to send with the request

@see www.elastic.co/guide/en/app-search/current/queries.html#queries-top-queries

# File lib/elastic/app-search/api/top_queries_analytics.rb, line 36
def top_queries_analytics(engine_name, arguments = {})
  raise ArgumentError, "Required parameter 'engine_name' missing" unless engine_name

  body = arguments.delete(:body) || {}
  headers = arguments.delete(:headers) || {}

  request(
    :get,
    "api/as/v1/engines/#{engine_name}/analytics/queries/",
    arguments,
    body,
    headers
  )
end