algoliasearch rails
3.0.1
Documentación • Foro de la comunidad • Desbordamiento de pila • Informar un error • Preguntas frecuentes • Soporte
Esta joya le permite integrar fácilmente la API de búsqueda de Algolia a su ORM favorito. Está basado en la gema algoliasearch-client-ruby. Se admiten los rieles 6.x y 7.x.
Quizás le interese la aplicación Ruby on Rails de muestra que proporciona un autocompletado basado en autocomplete.js y una página de resultados de búsqueda instantánea basada en InstantSearch.js : algoliasearch-rails-example.
Puede encontrar la referencia completa en el sitio web de Algolia.
Configuración
Uso
Opciones
objectID personalizadoÍndices
Pruebas
Solución de problemas
gem install algoliasearch-rails Agrega la gema a tu Gemfile :
gem "algoliasearch-rails"Y ejecuta:
bundle install Cree un nuevo archivo config/initializers/algoliasearch.rb para configurar su APPLICATION_ID y API_KEY .
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' }La gema es compatible con ActiveRecord, Mongoid y Sequel.
Puede configurar varios umbrales de tiempo de espera configurando las siguientes opciones en el momento de la inicialización:
AlgoliaSearch . configuration = {
application_id : 'YourApplicationID' ,
api_key : 'YourAPIKey' ,
} Esta gema hace un uso extensivo de las devoluciones de llamada de Rails para activar las tareas de indexación. Si está utilizando métodos que omiten las devoluciones de llamada after_validation , before_save o after_commit , no indexará sus cambios. Por ejemplo: update_attribute no realiza comprobaciones de validaciones; para realizar validaciones al actualizar, utilice update_attributes .
Todos los métodos inyectados por el módulo AlgoliaSearch tienen el prefijo algolia_ y se les asigna un alias a los nombres cortos asociados si aún no están definidos.
Contact . algolia_reindex! # <=> Contact.reindex!
Contact . algolia_search ( "jon doe" ) # <=> Contact.search("jon doe") El siguiente código creará un índice Contact y agregará capacidades de búsqueda a su modelo Contact :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attributes :first_name , :last_name , :email
end
end Puede especificar los atributos a enviar (aquí nos restringimos a :first_name, :last_name, :email ) o no (en ese caso, se envían todos los atributos).
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# all attributes will be sent
end
end También puede utilizar el método add_attribute para enviar todos los atributos del modelo + los adicionales:
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# all attributes + extra_attr will be sent
add_attribute :extra_attr
end
def extra_attr
"extra_val"
end
end Ofrecemos muchas formas de configurar su índice, lo que le permite ajustar la relevancia general de su índice. Los más importantes son los atributos buscables y los atributos que reflejan popularidad récord .
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# list of attribute used to build an Algolia record
attributes :title , :subtitle , :description , :likes_count , :seller_name
# the `searchableAttributes` (formerly known as attributesToIndex) setting defines the attributes
# you want to search in: here `title`, `subtitle` & `description`.
# You need to list them by order of importance. `description` is tagged as
# `unordered` to avoid taking the position of a match into account in that attribute.
searchableAttributes [ 'title' , 'subtitle' , 'unordered(description)' ]
# the `customRanking` setting defines the ranking criteria use to compare two matching
# records in case their text-relevance is equal. It should reflect your record popularity.
customRanking [ 'desc(likes_count)' ]
end
end Para indexar un modelo, simplemente llame reindex en la clase:
Product . reindexPara indexar todos sus modelos, puede hacer algo como esto:
Rails . application . eager_load! # Ensure all models are loaded (required in development).
algolia_models = ActiveRecord :: Base . descendants . select { | model | model . respond_to? ( :reindex ) }
algolia_models . each ( & :reindex ) Las implementaciones de búsqueda tradicionales tienden a tener lógica y funcionalidad de búsqueda en el backend. Esto tenía sentido cuando la experiencia de búsqueda consistía en que un usuario ingresara una consulta de búsqueda, ejecutara esa búsqueda y luego fuera redirigido a una página de resultados de búsqueda.
Ya no es necesario implementar la búsqueda en el backend. De hecho, en la mayoría de los casos es perjudicial para el rendimiento debido a la latencia adicional de red y procesamiento. Recomendamos encarecidamente el uso de nuestro cliente API de JavaScript para emitir todas las solicitudes de búsqueda directamente desde el navegador, dispositivo móvil o cliente del usuario final. Reducirá la latencia de búsqueda general y, al mismo tiempo, descargará sus servidores.
El cliente API JS es parte de la joya, solo requiere algolia/v3/algoliasearch.min en algún lugar de su manifiesto de JavaScript, por ejemplo en application.js si está usando Rails 3.1+:
//= require algolia/v3/algoliasearch.minLuego en tu código JavaScript puedes hacer:
var client = algoliasearch ( ApplicationID , Search - Only - API - Key ) ;
var index = client . initIndex ( 'YourIndexName' ) ;
index . search ( 'something' , { hitsPerPage : 10 , page : 0 } )
. then ( function searchDone ( content ) {
console . log ( content )
} )
. catch ( function searchFailure ( err ) {
console . error ( err ) ;
} ) ;Recientemente (marzo de 2015) lanzamos una nueva versión (V3) de nuestro cliente JavaScript. Si estaba utilizando nuestra versión anterior (V2), lea la guía de migración.
Notas: Recomendamos el uso de nuestro cliente API de JavaScript para realizar consultas directamente desde el navegador del usuario final sin pasar por su servidor.
Una búsqueda devuelve objetos compatibles con ORM recargándolos desde su base de datos. Recomendamos el uso de nuestro cliente API de JavaScript para realizar consultas para disminuir la latencia general y descargar sus servidores.
hits = Contact . search ( "jon doe" )
p hits
p hits . raw_answer # to get the original JSON raw answer Se agrega un atributo highlight_result a cada objeto ORM:
hits [ 0 ] . highlight_result [ 'first_name' ] [ 'value' ]Si desea recuperar la respuesta JSON sin formato de la API, sin volver a cargar los objetos de la base de datos, puede usar:
json_answer = Contact . raw_search ( "jon doe" )
p json_answer
p json_answer [ 'hits' ]
p json_answer [ 'facets' ] Los parámetros de búsqueda se pueden especificar a través de la configuración del índice de forma estática en su modelo o dinámicamente en el momento de la búsqueda especificando los parámetros de búsqueda como segundo argumento del método search :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attribute :first_name , :last_name , :email
# default search parameters stored in the index settings
minWordSizefor1Typo 4
minWordSizefor2Typos 8
hitsPerPage 42
end
end # dynamical search parameters
p Contact . raw_search ( 'jon doe' , { hitsPerPage : 5 , page : 2 } ) Incluso si recomendamos encarecidamente realizar todas las operaciones de búsqueda (y por lo tanto de paginación) desde su interfaz utilizando JavaScript , admitimos tanto will_paginate como kaminari como backend de paginación.
Para usar :will_paginate , especifique :pagination_backend de la siguiente manera:
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' , pagination_backend : :will_paginate } Luego, tan pronto como utilice el método search , los resultados que devolverán serán un conjunto paginado:
# in your controller
@results = MyModel . search ( 'foo' , hitsPerPage : 10 )
# in your views
# if using will_paginate
<%= will_paginate @results %>
# if using kaminari
<%= paginate @results %> Utilice el método tags para agregar etiquetas a su registro:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
tags [ 'trusted' ]
end
endo usando valores dinámicos:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
tags do
[ first_name . blank? || last_name . blank? ? 'partial' : 'full' , has_valid_email? ? 'valid_email' : 'invalid_email' ]
end
end
end En el momento de la consulta, especifique { tagFilters: 'tagvalue' } o { tagFilters: ['tagvalue1', 'tagvalue2'] } como parámetros de búsqueda para restringir el conjunto de resultados a etiquetas específicas.
Las facetas se pueden recuperar llamando al método de facets adicionales de la respuesta de búsqueda.
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# [...]
# specify the list of attributes available for faceting
attributesForFaceting [ :company , :zip_code ]
end
end hits = Contact . search ( 'jon doe' , { facets : '*' } )
p hits # ORM-compliant array of objects
p hits . facets # extra method added to retrieve facets
p hits . facets [ 'company' ] # facet values+count of facet 'company'
p hits . facets [ 'zip_code' ] # facet values+count of facet 'zip_code' raw_json = Contact . raw_search ( 'jon doe' , { facets : '*' } )
p raw_json [ 'facets' ] También puede buscar valores de faceta.
Product . search_for_facet_values ( 'category' , 'Headphones' ) # Array of {value, highlighted, count}Este método también puede tomar cualquier parámetro que pueda tomar una consulta. Esto ajustará la búsqueda a solo resultados que coincidan con la consulta.
# Only sends back the categories containing red Apple products (and only counts those)
Product . search_for_facet_values ( 'category' , 'phone' , {
query : 'red' ,
filters : 'brand:Apple'
} ) # Array of phone categories linked to red Apple products Puede encontrar más información sobre distintos para agrupar aquí.
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# [...]
# specify the attribute to be used for distinguishing the records
# in this case the records will be grouped by company
attributeForDistinct "company"
end
end Utilice el método geoloc para localizar su registro:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
geoloc :lat_attr , :lng_attr
end
end En el momento de la consulta, especifique { aroundLatLng: "37.33, -121.89", aroundRadius: 50000 } como parámetros de búsqueda para restringir el conjunto de resultados a 50 km alrededor de San José.
Cada vez que se guarda un registro, se indexará de forma asincrónica . Por otro lado, cada vez que se destruye un registro, se eliminará, de forma asincrónica, del índice. Eso significa que una llamada de red con la operación AGREGAR/ELIMINAR se envía sincrónicamente a la API de Algolia, pero luego el motor procesará la operación de forma asincrónica (por lo que si realiza una búsqueda justo después, es posible que los resultados no la reflejen todavía).
Puede desactivar la indexación y eliminación automática configurando las siguientes opciones:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch auto_index : false , auto_remove : false do
attribute :first_name , :last_name , :email
end
end Puede deshabilitar temporalmente la indexación automática utilizando el alcance without_auto_index . Esto se utiliza a menudo por motivos de rendimiento.
Contact . delete_all
Contact . without_auto_index do
1 . upto ( 10000 ) { Contact . create! attributes } # inside this block, auto indexing task will not run.
end
Contact . reindex! # will use batch operationsPuede configurar el proceso de indexación y eliminación automática para utilizar una cola para realizar esas operaciones en segundo plano. Las colas ActiveJob (Rails >=4.2) se utilizan de forma predeterminada, pero puede definir su propio mecanismo de cola:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch enqueue : true do # ActiveJob will be triggered using a `algoliasearch` queue
attribute :first_name , :last_name , :email
end
endSi realiza actualizaciones y eliminaciones en segundo plano, se puede confirmar la eliminación de un registro en su base de datos antes de que se ejecute el trabajo. Por lo tanto, si cargara el registro para eliminarlo de la base de datos, su ActiveRecord#find fallará con un RecordNotFound.
En este caso, puede omitir la carga del registro desde ActiveRecord y simplemente comunicarse con el índice directamente:
class MySidekiqWorker
def perform ( id , remove )
if remove
# the record has likely already been removed from your database so we cannot
# use ActiveRecord#find to load it
index = AlgoliaSearch . client . init_index ( "index_name" )
index . delete_object ( id )
else
# the record should be present
c = Contact . find ( id )
c . index!
end
end
endSi estás usando Sidekiq:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch enqueue : :trigger_sidekiq_worker do
attribute :first_name , :last_name , :email
end
def self . trigger_sidekiq_worker ( record , remove )
MySidekiqWorker . perform_async ( record . id , remove )
end
end
class MySidekiqWorker
def perform ( id , remove )
if remove
# the record has likely already been removed from your database so we cannot
# use ActiveRecord#find to load it
index = AlgoliaSearch . client . init_index ( "index_name" )
index . delete_object ( id )
else
# the record should be present
c = Contact . find ( id )
c . index!
end
end
endSi estás usando trabajo_retrasado:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch enqueue : :trigger_delayed_job do
attribute :first_name , :last_name , :email
end
def self . trigger_delayed_job ( record , remove )
if remove
record . delay . remove_from_index!
else
record . delay . index!
end
end
end Puede forzar que la indexación y la eliminación sean sincrónicas (en ese caso, la gema llamará al método wait_task para garantizar que la operación se haya tenido en cuenta una vez que el método regrese) configurando la siguiente opción: (esto NO se recomienda, excepto con fines de prueba). )
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch synchronous : true do
attribute :first_name , :last_name , :email
end
end De forma predeterminada, el nombre del índice será el nombre de la clase, por ejemplo, "Contacto". Puede personalizar el nombre del índice utilizando la opción index_name :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch index_name : "MyCustomName" do
attribute :first_name , :last_name , :email
end
end Puede añadir el sufijo del nombre del índice al entorno Rails actual utilizando la siguiente opción:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true do # index name will be "Contact_#{Rails.env}"
attribute :first_name , :last_name , :email
end
end Puede utilizar un bloque para especificar un valor de atributo complejo
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attribute :email
attribute :full_name do
" #{ first_name } #{ last_name } "
end
add_attribute :full_name2
end
def full_name2
" #{ first_name } #{ last_name } "
end
end Notas: Tan pronto como use dicho código para definir atributos adicionales, la gema ya no podrá detectar si el atributo ha cambiado (el código usa el método #{attribute}_changed? de Rails para detectarlo). Como consecuencia, su registro se enviará a la API incluso si sus atributos no cambiaron. Puede solucionar este comportamiento creando un _changed? método:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attribute :email
attribute :full_name do
" #{ first_name } #{ last_name } "
end
end
def full_name_changed?
first_name_changed? || last_name_changed?
end
end Puede incrustar fácilmente objetos anidados que definan un atributo adicional que devuelva cualquier objeto compatible con JSON (una matriz, un hash o una combinación de ambos).
class Profile < ActiveRecord :: Base
include AlgoliaSearch
belongs_to :user
has_many :specializations
algoliasearch do
attribute :user do
# restrict the nested "user" object to its `name` + `email`
{ name : user . name , email : user . email }
end
attribute :public_specializations do
# build an array of public specialization (include only `title` and `another_attr`)
specializations . select { | s | s . public? } . map do | s |
{ title : s . title , another_attr : s . another_attr }
end
end
end
end Con ActiveRecord, usaremos touch y after_touch para lograr esto.
# app/models/app.rb
class App < ApplicationRecord
include AlgoliaSearch
belongs_to :author , class_name : :User
after_touch :index!
algoliasearch do
attribute :title
attribute :author do
author . as_json
end
end
end
# app/models/user.rb
class User < ApplicationRecord
# If your association uses belongs_to
# - use `touch: true`
# - do not define an `after_save` hook
has_many :apps , foreign_key : :author_id
after_save { apps . each ( & :touch ) }
end Con Sequel, puedes usar el complemento touch para propagar los cambios:
# app/models/app.rb
class App < Sequel :: Model
include AlgoliaSearch
many_to_one :author , class : :User
plugin :timestamps
plugin :touch
algoliasearch do
attribute :title
attribute :author do
author . to_hash
end
end
end
# app/models/user.rb
class User < Sequel :: Model
one_to_many :apps , key : :author_id
plugin :timestamps
# Can't use the associations since it won't trigger the after_save
plugin :touch
# Define the associations that need to be touched here
# Less performant, but allows for the after_save hook to trigger
def touch_associations
apps . map ( & :touch )
end
def touch
super
touch_associations
end
end objectID personalizado De forma predeterminada, el objectID se basa en id de su registro. Puede cambiar este comportamiento especificando la opción :id (asegúrese de utilizar un campo uniq).
class UniqUser < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch id : :uniq_name do
end
end Puede agregar restricciones que controlen si un registro debe indexarse utilizando las opciones :if o :unless .
Le permite realizar una indexación condicional por documento.
class Post < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch if : :published? , unless : :deleted? do
end
def published?
# [...]
end
def deleted?
# [...]
end
end Notas: Tan pronto como use esas restricciones, se realizarán llamadas addObjects y deleteObjects para mantener el índice sincronizado con la base de datos (la gema sin estado no sabe si el objeto ya no coincide con sus restricciones o nunca coincidió). , por lo que forzamos el envío de operaciones AGREGAR/BORRAR). Puede solucionar este comportamiento creando un _changed? método:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch if : :published do
end
def published
# true or false
end
def published_changed?
# return true only if you know that the 'published' state changed
end
endPuede indexar un subconjunto de sus registros usando:
# will generate batch API calls (recommended)
MyModel . where ( 'updated_at > ?' , 10 . minutes . ago ) . reindex!o
MyModel . index_objects MyModel . limit ( 5 ) Puede desinfectar todos sus atributos usando la opción sanitize . Eliminará todas las etiquetas HTML de sus atributos.
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , sanitize : true do
attributes :name , :email , :company
end
end Si está utilizando Rails 4.2+, también debe depender de rails-html-sanitizer :
gem 'rails-html-sanitizer' Puedes forzar la codificación UTF-8 de todos tus atributos usando la opción force_utf8_encoding :
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch force_utf8_encoding : true do
attributes :name , :email , :company
end
endNotas: Esta opción no es compatible con Ruby 1.8
Puede desactivar las excepciones que podrían surgir al intentar acceder a la API de Algolia utilizando la opción raise_on_failure :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
# only raise exceptions in development env
algoliasearch raise_on_failure : Rails . env . development? do
attribute :first_name , :last_name , :email
end
end Aquí hay un ejemplo de configuración real (de HN Search):
class Item < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true do
# the list of attributes sent to Algolia's API
attribute :created_at , :title , :url , :author , :points , :story_text , :comment_text , :author , :num_comments , :story_id , :story_title
# integer version of the created_at datetime field, to use numerical filtering
attribute :created_at_i do
created_at . to_i
end
# `title` is more important than `{story,comment}_text`, `{story,comment}_text` more than `url`, `url` more than `author`
# btw, do not take into account position in most fields to avoid first word match boost
searchableAttributes [ 'unordered(title)' , 'unordered(story_text)' , 'unordered(comment_text)' , 'unordered(url)' , 'author' ]
# tags used for filtering
tags do
[ item_type , "author_ #{ author } " , "story_ #{ story_id } " ]
end
# use associated number of HN points to sort results (last sort criteria)
customRanking [ 'desc(points)' , 'desc(num_comments)' ]
# google+, $1.5M raises, C#: we love you
separatorsToIndex '+#$'
end
def story_text
item_type_cd != Item . comment ? text : nil
end
def story_title
comment? && story ? story . title : nil
end
def story_url
comment? && story ? story . url : nil
end
def comment_text
comment? ? text : nil
end
def comment?
item_type_cd == Item . comment
end
# [...]
end ¡Puede activar la indexación utilizando el index! método de instancia.
c = Contact . create! ( params [ :contact ] )
c . index! ¡Y active la eliminación del índice usando remove_from_index! método de instancia.
c . remove_from_index!
c . destroy La gema proporciona 2 formas de reindexar todos tus objetos:
Para reindexar todos sus registros (teniendo en cuenta los objetos eliminados), el método de la clase reindex indexa todos sus objetos en un índice temporal llamado <INDEX_NAME>.tmp y mueve el índice temporal al final una vez que todo está indexado (atómicamente). Esta es la forma más segura de reindexar todo su contenido.
Contact . reindex Notas : si está utilizando una clave API específica de índice, asegúrese de permitir tanto <INDEX_NAME> como <INDEX_NAME>.tmp .
Advertencia: No debe utilizar una operación de reindexación atómica de este tipo al determinar el alcance/filtrar el modelo porque esta operación reemplaza todo el índice y mantiene solo los objetos filtrados. es decir: ¡No haga MyModel.where(...).reindex , pero haga MyModel.where(...).reindex! (¡con el final ! )!!!
Para reindexar todos sus objetos en su lugar (sin índice temporal y, por lo tanto, sin eliminar objetos eliminados), utilice el reindex! método de clase:
Contact . reindex! Para borrar un índice, utilice clear_index! método de clase:
Contact . clear_index! Puede acceder al objeto index subyacente llamando al método de clase index :
index = Contact . index
# index.get_settings, index.partial_update_object, ... Puede definir índices de réplica utilizando el método add_replica . Utilice inherit: true en el bloque de réplica si desea que herede de la configuración principal.
class Book < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
algoliasearch per_environment : true do
searchableAttributes [ :name , :author , :editor ]
# define a replica index to search by `author` only
add_replica 'Book_by_author' , per_environment : true do
searchableAttributes [ :author ]
end
# define a replica index with custom ordering but same settings than the main block
add_replica 'Book_custom_order' , inherit : true , per_environment : true do
customRanking [ 'asc(rank)' ]
end
end
endPara buscar usando una réplica, use el siguiente código:
Book . raw_search 'foo bar' , replica : 'Book_by_editor'
# or
Book . search 'foo bar' , replica : 'Book_by_editor' Puede tener sentido compartir un índice entre varios modelos. Para implementar esto, deberá asegurarse de no tener ningún conflicto con el objectID de los modelos subyacentes.
class Student < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
algoliasearch index_name : 'people' , id : :algolia_id do
# [...]
end
private
def algolia_id
"student_ #{ id } " # ensure the teacher & student IDs are not conflicting
end
end
class Teacher < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
algoliasearch index_name : 'people' , id : :algolia_id do
# [...]
end
private
def algolia_id
"teacher_ #{ id } " # ensure the teacher & student IDs are not conflicting
end
end Notas: Si apunta a un único índice de varios modelos, nunca debe usar MyModel.reindex y solo debe usar MyModel.reindex! . El método reindex utiliza un índice temporal para realizar una reindexación atómica: si lo usa, el índice resultante solo contendrá registros para el modelo actual porque no reindexará los demás.
Puedes indexar un registro en varios índices usando el método add_index :
class Book < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
PUBLIC_INDEX_NAME = "Book_ #{ Rails . env } "
SECURED_INDEX_NAME = "SecuredBook_ #{ Rails . env } "
# store all books in index 'SECURED_INDEX_NAME'
algoliasearch index_name : SECURED_INDEX_NAME do
searchableAttributes [ :name , :author ]
# convert security to tags
tags do
[ released ? 'public' : 'private' , premium ? 'premium' : 'standard' ]
end
# store all 'public' (released and not premium) books in index 'PUBLIC_INDEX_NAME'
add_index PUBLIC_INDEX_NAME , if : :public? do
searchableAttributes [ :name , :author ]
end
end
private
def public?
released && ! premium
end
endPara buscar usando un índice adicional, use el siguiente código:
Book . raw_search 'foo bar' , index : 'Book_by_editor'
# or
Book . search 'foo bar' , index : 'Book_by_editor' Para ejecutar las especificaciones, configure las variables de entorno ALGOLIA_APPLICATION_ID y ALGOLIA_API_KEY . Dado que las pruebas crean y eliminan índices, NO utilice su cuenta de producción.
Es posible que desee deshabilitar todas las llamadas API de indexación (operaciones de agregar, actualizar y eliminar), puede configurar la opción disable_indexing :
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , disable_indexing : Rails . env . test? do
end
end
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , disable_indexing : Proc . new { Rails . env . test? || more_complex_condition } do
end
end ¿Tiene algún problema? Antes de comunicarse con el soporte, le recomendamos que consulte nuestras preguntas frecuentes, donde encontrará respuestas a los problemas y problemas más comunes con el cliente.
Si desea contribuir a este proyecto sin instalar todas sus dependencias, puede utilizar nuestra imagen de Docker. Consulte nuestra guía dedicada para obtener más información.
