algoliasearch rails
3.0.1
Documentation • Forum communautaire • Stack Overflow • Signaler un bug • FAQ • Support
Ce joyau vous permet d'intégrer facilement l'API Algolia Search à votre ORM préféré. Il est basé sur la gemme algoliasearch-client-ruby. Les Rails 6.x et 7.x sont pris en charge.
Vous pourriez être intéressé par l'exemple d'application Ruby on Rails fournissant une page de saisie semi-automatique basée sur autocomplete.js et une page de résultats de recherche instantanée basée sur InstantSearch.js : algoliasearch-rails-example.
Vous pouvez retrouver la référence complète sur le site d’Algolia.
Installation
Usage
Possibilités
objectID personnaliséIndices
Essai
Dépannage
gem install algoliasearch-rails Ajoutez la gemme à votre Gemfile :
gem "algoliasearch-rails"Et exécutez :
bundle install Créez un nouveau fichier config/initializers/algoliasearch.rb pour configurer votre APPLICATION_ID et API_KEY .
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' }La gemme est compatible avec ActiveRecord, Mongoid et Sequel.
Vous pouvez configurer différents seuils de délai d'attente en définissant les options suivantes au moment de l'initialisation :
AlgoliaSearch . configuration = {
application_id : 'YourApplicationID' ,
api_key : 'YourAPIKey' ,
} Cette gemme utilise largement les rappels de Rails pour déclencher les tâches d'indexation. Si vous utilisez des méthodes contournant les rappels after_validation , before_save ou after_commit , vos modifications n'indexeront pas. Par exemple : update_attribute n'effectue pas de contrôles de validation, pour effectuer des validations lors de la mise à jour, utilisez update_attributes .
Toutes les méthodes injectées par le module AlgoliaSearch sont préfixées par algolia_ et alias aux noms courts associés s'ils ne sont pas déjà définis.
Contact . algolia_reindex! # <=> Contact.reindex!
Contact . algolia_search ( "jon doe" ) # <=> Contact.search("jon doe") Le code suivant créera un index Contact et ajoutera des fonctionnalités de recherche à votre modèle Contact :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attributes :first_name , :last_name , :email
end
end Vous pouvez soit spécifier les attributs à envoyer (ici nous nous sommes limités à :first_name, :last_name, :email ) ou non (dans ce cas, tous les attributs sont envoyés).
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# all attributes will be sent
end
end Vous pouvez également utiliser la méthode add_attribute pour envoyer tous les attributs du modèle + ceux supplémentaires :
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 Nous proposons de nombreuses façons de configurer votre index, vous permettant d'ajuster la pertinence globale de votre index. Les plus importants sont les attributs consultables et les attributs reflétant une popularité record .
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 Pour indexer un modèle, appelez simplement reindex sur la classe :
Product . reindexPour indexer tous vos modèles, vous pouvez faire quelque chose comme ceci :
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 ) Les implémentations de recherche traditionnelles ont tendance à avoir une logique et des fonctionnalités de recherche sur le backend. Cela avait du sens lorsque l'expérience de recherche consistait en un utilisateur saisissant une requête de recherche, exécutant cette recherche, puis étant redirigé vers une page de résultats de recherche.
La mise en œuvre de la recherche sur le backend n’est plus nécessaire. En fait, dans la plupart des cas, cela nuit aux performances en raison de la latence supplémentaire du réseau et du traitement. Nous recommandons fortement l'utilisation de notre client API JavaScript qui émet toutes les requêtes de recherche directement à partir du navigateur, de l'appareil mobile ou du client de l'utilisateur final. Cela réduira la latence globale de la recherche tout en déchargeant vos serveurs en même temps.
Le client API JS fait partie de la gemme, il suffit d'exiger algolia/v3/algoliasearch.min quelque part dans votre manifeste JavaScript, par exemple dans application.js si vous utilisez Rails 3.1+ :
//= require algolia/v3/algoliasearch.minEnsuite, dans votre code JavaScript, vous pouvez faire :
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 ) ;
} ) ;Nous avons récemment (mars 2015) publié une nouvelle version (V3) de notre client JavaScript, si vous utilisiez notre version précédente (V2), lisez le guide de migration
Remarques : Nous recommandons l'utilisation de notre client API JavaScript pour effectuer des requêtes directement à partir du navigateur de l'utilisateur final sans passer par votre serveur.
Une recherche renvoie des objets conformes à ORM en les rechargeant depuis votre base de données. Nous recommandons l'utilisation de notre client API JavaScript pour effectuer des requêtes afin de réduire la latence globale et de décharger vos serveurs.
hits = Contact . search ( "jon doe" )
p hits
p hits . raw_answer # to get the original JSON raw answer Un attribut highlight_result est ajouté à chaque objet ORM :
hits [ 0 ] . highlight_result [ 'first_name' ] [ 'value' ]Si vous souhaitez récupérer la réponse JSON brute depuis l'API, sans recharger les objets depuis la base de données, vous pouvez utiliser :
json_answer = Contact . raw_search ( "jon doe" )
p json_answer
p json_answer [ 'hits' ]
p json_answer [ 'facets' ] Les paramètres de recherche peuvent être spécifiés soit via les paramètres de l'index de manière statique dans votre modèle, soit de manière dynamique au moment de la recherche, en spécifiant les paramètres de recherche comme deuxième argument de la méthode 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 } ) Même si nous recommandons fortement d'effectuer toutes les opérations de recherche (et donc de pagination) depuis votre frontend en utilisant JavaScript , nous prenons en charge à la fois will_paginate et kaminari comme backend de pagination.
Pour utiliser :will_paginate , spécifiez le :pagination_backend comme suit :
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' , pagination_backend : :will_paginate } Ensuite, dès que vous utilisez la méthode search , les résultats renvoyés seront un ensemble paginé :
# in your controller
@results = MyModel . search ( 'foo' , hitsPerPage : 10 )
# in your views
# if using will_paginate
<%= will_paginate @results %>
# if using kaminari
<%= paginate @results %> Utilisez la méthode tags pour ajouter des balises à votre enregistrement :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
tags [ 'trusted' ]
end
endou en utilisant des valeurs dynamiques :
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 Au moment de la requête, spécifiez { tagFilters: 'tagvalue' } ou { tagFilters: ['tagvalue1', 'tagvalue2'] } comme paramètres de recherche pour limiter l'ensemble de résultats à des balises spécifiques.
Les facettes peuvent être récupérées en appelant la méthode facets supplémentaires de la réponse de recherche.
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' ] Vous pouvez également rechercher des valeurs de facettes.
Product . search_for_facet_values ( 'category' , 'Headphones' ) # Array of {value, highlighted, count}Cette méthode peut également prendre n’importe quel paramètre qu’une requête peut prendre. Cela ajustera la recherche aux seuls résultats qui auraient correspondu à la requête.
# 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 Plus d’informations sur distinct pour le regroupement peuvent être trouvées ici.
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 Utilisez la méthode geoloc pour localiser votre enregistrement :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
geoloc :lat_attr , :lng_attr
end
end Au moment de la requête, spécifiez { aroundLatLng: "37.33, -121.89", aroundRadius: 50000 } comme paramètres de recherche pour limiter l'ensemble de résultats à 50 km autour de San José.
Chaque fois qu'un enregistrement est enregistré, il sera indexé de manière asynchrone . En revanche, chaque fois qu’un enregistrement est détruit, il sera – de manière asynchrone – supprimé de l’index. Cela signifie qu'un appel réseau avec l'opération ADD/DELETE est envoyé de manière synchrone à l'API Algolia mais le moteur traitera ensuite l'opération de manière asynchrone (donc si vous effectuez une recherche juste après, les résultats risquent de ne pas encore le refléter).
Vous pouvez désactiver l'indexation et la suppression automatiques en définissant les options suivantes :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch auto_index : false , auto_remove : false do
attribute :first_name , :last_name , :email
end
end Vous pouvez désactiver temporairement l'indexation automatique à l'aide de la portée without_auto_index . Ceci est souvent utilisé pour des raisons de performances.
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 operationsVous pouvez configurer le processus d'indexation et de suppression automatique pour utiliser une file d'attente pour effectuer ces opérations en arrière-plan. Les files d'attente ActiveJob (Rails >=4.2) sont utilisées par défaut mais vous pouvez définir votre propre mécanisme de mise en file d'attente :
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 vous effectuez des mises à jour et des suppressions en arrière-plan, une suppression d'enregistrement peut être validée dans votre base de données avant l'exécution réelle du travail. Ainsi, si vous deviez charger l'enregistrement pour le supprimer de la base de données, votre ActiveRecord#find échouera avec un RecordNotFound.
Dans ce cas, vous pouvez contourner le chargement de l'enregistrement depuis ActiveRecord et simplement communiquer directement avec l'index :
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 vous utilisez 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 vous utilisez delay_job :
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 Vous pouvez forcer l'indexation et la suppression à être synchrones (dans ce cas la gem appellera la méthode wait_task pour s'assurer que l'opération a été prise en compte une fois la méthode retournée) en définissant l'option suivante : (ce n'est PAS recommandé, sauf à des fins de test )
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch synchronous : true do
attribute :first_name , :last_name , :email
end
end Par défaut, le nom de l'index sera le nom de la classe, par exemple "Contact". Vous pouvez personnaliser le nom de l'index à l'aide de l'option index_name :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch index_name : "MyCustomName" do
attribute :first_name , :last_name , :email
end
end Vous pouvez suffixer le nom de l'index avec l'environnement Rails actuel en utilisant l'option suivante :
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 Vous pouvez utiliser un bloc pour spécifier une valeur d'attribut complexe
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 Notes : Dès que vous utilisez un tel code pour définir des attributs supplémentaires, la gem n'est plus en mesure de détecter si l'attribut a changé (le code utilise la méthode #{attribute}_changed? de Rails pour le détecter). En conséquence, votre enregistrement sera poussé vers l'API même si ses attributs n'ont pas changé. Vous pouvez contourner ce comportement en créant un _changed? méthode:
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 Vous pouvez facilement intégrer des objets imbriqués en définissant un attribut supplémentaire renvoyant n'importe quel objet compatible JSON (un tableau ou un hachage ou une combinaison des deux).
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 Avec ActiveRecord, nous utiliserons touch et after_touch pour y parvenir.
# 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 Avec Sequel, vous pouvez utiliser le plugin touch pour propager les modifications :
# 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 personnalisé Par défaut, l' objectID est basé sur id de votre enregistrement. Vous pouvez modifier ce comportement en spécifiant l'option :id (assurez-vous d'utiliser un champ uniq).
class UniqUser < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch id : :uniq_name do
end
end Vous pouvez ajouter des contraintes contrôlant si un enregistrement doit être indexé en utilisant les options :if ou :unless .
Il vous permet d’effectuer une indexation conditionnelle par document.
class Post < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch if : :published? , unless : :deleted? do
end
def published?
# [...]
end
def deleted?
# [...]
end
end Notes : Dès que vous utilisez ces contraintes, les appels addObjects et deleteObjects seront effectués afin de maintenir l'index synchronisé avec la base de données (la gemme sans état ne sait pas si l'objet ne correspond plus à vos contraintes ou n'a jamais correspondu). , nous forçons donc l'envoi des opérations ADD/DELETE). Vous pouvez contourner ce comportement en créant un _changed? méthode:
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
endVous pouvez indexer un sous-ensemble de vos enregistrements en utilisant soit :
# will generate batch API calls (recommended)
MyModel . where ( 'updated_at > ?' , 10 . minutes . ago ) . reindex!ou
MyModel . index_objects MyModel . limit ( 5 ) Vous pouvez nettoyer tous vos attributs à l’aide de l’option sanitize . Cela supprimera toutes les balises HTML de vos attributs.
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , sanitize : true do
attributes :name , :email , :company
end
end Si vous utilisez Rails 4.2+, vous devez également dépendre de rails-html-sanitizer :
gem 'rails-html-sanitizer' Vous pouvez forcer l'encodage UTF-8 de tous vos attributs en utilisant l'option force_utf8_encoding :
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch force_utf8_encoding : true do
attributes :name , :email , :company
end
endRemarques : Cette option n'est pas compatible avec Ruby 1.8
Vous pouvez désactiver les exceptions qui pourraient être déclenchées en essayant d'accéder à l'API d'Algolia en utilisant l'option 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 Voici un exemple de configuration réelle (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 Vous pouvez déclencher l'indexation à l'aide de l' index! méthode d'instance.
c = Contact . create! ( params [ :contact ] )
c . index! Et déclenchez la suppression de l'index à l'aide de remove_from_index! méthode d'instance.
c . remove_from_index!
c . destroy La gem propose 2 façons de réindexer tous vos objets :
Pour réindexer tous vos enregistrements (en tenant compte des objets supprimés), la méthode de classe reindex indexe tous vos objets vers un index temporaire appelé <INDEX_NAME>.tmp et déplace l'index temporaire vers le final une fois que tout est indexé (atomiquement). C'est le moyen le plus sûr de réindexer tout votre contenu.
Contact . reindex Remarques : si vous utilisez une clé API spécifique à l'index, assurez-vous d'autoriser à la fois <INDEX_NAME> et <INDEX_NAME>.tmp .
Avertissement : vous ne devez pas utiliser une telle opération de réindexation atomique lors de la portée/du filtrage du modèle, car cette opération remplace l'intégralité de l'index , en conservant uniquement les objets filtrés. c'est-à-dire : ne faites pas MyModel.where(...).reindex mais faites MyModel.where(...).reindex! (avec la fin ! ) !!!
Pour réindexer tous vos objets en place (sans index temporaire et donc sans supprimer les objets supprimés), utilisez le reindex! méthode de classe :
Contact . reindex! Pour effacer un index, utilisez clear_index! méthode de classe :
Contact . clear_index! Vous pouvez accéder à l'objet index sous-jacent en appelant la méthode de classe index :
index = Contact . index
# index.get_settings, index.partial_update_object, ... Vous pouvez définir des index de réplica à l'aide de la méthode add_replica . Utilisez inherit: true sur le bloc de réplique si vous souhaitez qu'il hérite des paramètres principaux.
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
endPour effectuer une recherche à l'aide d'une réplique, utilisez le code suivant :
Book . raw_search 'foo bar' , replica : 'Book_by_editor'
# or
Book . search 'foo bar' , replica : 'Book_by_editor' Il peut être judicieux de partager un index entre plusieurs modèles. Afin de mettre en œuvre cela, vous devrez vous assurer que vous n'avez aucun conflit avec l' objectID des modèles sous-jacents.
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 Notes : Si vous ciblez un seul index issu de plusieurs modèles, vous ne devez jamais utiliser MyModel.reindex et utiliser uniquement MyModel.reindex! . La méthode reindex utilise un index temporaire pour effectuer une réindexation atomique : si vous l'utilisez, l'index résultant ne contiendra que les enregistrements du modèle courant car il ne réindexera pas les autres.
Vous pouvez indexer un enregistrement dans plusieurs index à l'aide de la méthode 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
endPour effectuer une recherche à l'aide d'un index supplémentaire, utilisez le code suivant :
Book . raw_search 'foo bar' , index : 'Book_by_editor'
# or
Book . search 'foo bar' , index : 'Book_by_editor' Pour exécuter les spécifications, veuillez définir les variables d'environnement ALGOLIA_APPLICATION_ID et ALGOLIA_API_KEY . Étant donné que les tests créent et suppriment des index, N'utilisez PAS votre compte de production.
Vous souhaiterez peut-être désactiver tous les appels d'API d'indexation (opérations d'ajout, de mise à jour et de suppression), vous pouvez définir l'option 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 Vous rencontrez un problème ? Avant de contacter l'assistance, nous vous recommandons de consulter notre FAQ où vous trouverez des réponses aux problèmes et pièges les plus courants avec le client.
Si vous souhaitez contribuer à ce projet sans installer toutes ses dépendances, vous pouvez utiliser notre image Docker. Veuillez consulter notre guide dédié pour en savoir plus.
