algoliasearch laravel
1.7.1
Algolia Search es un motor de búsqueda alojado de texto completo, numérico y facetado capaz de ofrecer resultados en tiempo real desde la primera pulsación de tecla.
Este paquete está en desuso, le recomendamos que utilice Laravel Scout . Si desea ampliar las capacidades de Scout, consulte nuestra documentación dedicada.
Este paquete PHP integra la API de búsqueda de Algolia en el ORM de Laravel Eloquent. Está basado en el paquete algoliasearch-client-php.
Nota: Si está utilizando Laravel 4, consulte el repositorio algoliasearch-laravel-4.
Puede encontrar la referencia completa en el sitio web de Algolia.
Instalar
Inicio rápido
Opciones
objectID personalizadoRelaciones
Indexación
Gestionar índices
Compatibilidad elocuente
Agregue algolia/algoliasearch-laravel a su archivo composer.json :
composer require algolia/algoliasearch-laravel Agregue el proveedor de servicios a config/app.php en la matriz providers .
AlgoliaSearch Laravel AlgoliaServiceProvider ::classLaravel Algolia requiere una configuración de conexión. Para comenzar, deberá publicar todos los activos del proveedor:
php artisan vendor:publish Puede agregar la opción --provider="VinklaAlgoliaAlgoliaServiceProvider" para publicar solo los activos del paquete Algolia.
Esto creará un archivo config/algolia.php en su aplicación que puede modificar para establecer su configuración. Además, asegúrese de verificar si hay cambios en comparación con el archivo de configuración original después de una actualización.
El siguiente código agrega capacidades de búsqueda a su modelo Contact creando un índice Contact :
use Illuminate Database Eloquent Model ;
use AlgoliaSearch Laravel AlgoliaEloquentTrait ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
}Por defecto se envían todos los atributos visibles. Si desea enviar atributos específicos, puede hacer algo como:
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public function getAlgoliaRecord ()
{
return array_merge ( $ this -> toArray (), [
' custom_name ' => ' Custom Name '
]);
}
} Después de configurar su modelo, debe realizar manualmente una importación inicial de sus datos. Puede hacer esto llamando reindex en su clase de modelo. Usando nuestro ejemplo anterior, esto sería:
Contact :: reindex ();Ofrecemos muchas formas de configurar los ajustes de su índice para ajustar la relevancia general, pero las más importantes son los atributos de búsqueda y los atributos que reflejan la popularidad récord . Puedes configurarlos con el siguiente código:
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public $ algoliaSettings = [
' searchableAttributes ' => [
' id ' ,
' name ' ,
],
' customRanking ' => [
' desc(popularity) ' ,
' asc(name) ' ,
],
];
} Puede propagar (guardar) la configuración en algolia utilizando el método setSetting :
Contact :: setSettings ();Los sinónimos se utilizan para informar al motor sobre palabras o expresiones que deben considerarse iguales en cuanto a relevancia textual.
Nuestra API de sinónimos ha sido diseñada para gestionar lo más fácilmente posible un gran conjunto de sinónimos para un índice y sus réplicas.
Puede usar la API de sinónimos agregando synonyms en la propiedad de clase $algoliaSettings como esta:
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public $ algoliaSettings = [
' synonyms ' => [
[
' objectID ' => ' red-color ' ,
' type ' => ' synonym ' ,
' synonyms ' => [ ' red ' , ' another red ' , ' yet another red ' ]
]
]
];
} Puede propagar (guardar) la configuración en algolia utilizando el método setSetting :
Contact :: setSettings ();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 red adicional y la latencia de 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.
En tu código JavaScript puedes hacer:
var client = algoliasearch ( 'ApplicationID' , 'Search-Only-API-Key' ) ;
var index = client . initIndex ( 'YourIndexName' ) ;
index . search ( 'something' , function ( success , hits ) {
console . log ( success , hits )
} , { hitsPerPage : 10 , page : 0 } ) ; También puedes usar el método search , pero no se recomienda implementar una experiencia de búsqueda instantánea/en tiempo real desde el backend (tener una búsqueda frontend brinda una mejor experiencia de usuario):
Contact :: search ( ' jon doe ' );Cada vez que se guarda un registro; será indexado, de forma asincrónica. Por otro lado, cada vez que se destruye un registro, se eliminará, de forma asincrónica, del índice.
Puede desactivar la indexación y eliminación automática configurando las siguientes opciones:
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public static $ autoIndex = false ;
public static $ autoDelete = false ;
}Puede desactivar temporalmente la indexación automática. Esto suele hacerse por motivos de rendimiento.
Contact :: $ autoIndex = false ;
Contact :: clearIndices ();
for ( $ i = 0 ; $ i < 10000 ; $ i ++) {
$ contact = Contact :: firstOrCreate ([ ' name ' => ' Jean ' ]);
}
Contact :: reindex (); // Will use batch operations.
Contact :: $ autoIndex = true ; También puede crear una condición dinámica para esos dos parámetros creando un autoDelete method autoIndex y/o autoDelete en su modelo.
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public function autoIndex ()
{
if ( App :: environment () === ' test ' ) {
return false ;
}
return true ;
}
public static autoDelete()
{
if ( App ::environment() === 'test') {
return false ;
}
return true ;
}
}Tenga cuidado al definir esos dos métodos en AlgoliaEloquentTrait. Al colocar esos métodos en una clase principal, AlgoliaEloquentTrait los "borrará" si se usan en una clase secundaria (debido a la herencia de php).
De forma predeterminada, el nombre del índice será el nombre de la clase en plural, por ejemplo, "Contactos". Puede personalizar el nombre del índice utilizando la opción $indices :
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public $ indices = [ ' contact_all ' ];
}Puede añadir el sufijo del nombre del índice al entorno de la aplicación actual utilizando la siguiente opción:
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public static $ perEnvironment = true ; // Index name will be 'Contacts_{App::environnement()}';
}objectID personalizado De forma predeterminada, el objectID se basa en keyName de su registro ( id de forma predeterminada). Puede cambiar este comportamiento especificando la opción objectIdKey (asegúrese de utilizar un campo uniq).
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public static $ objectIdKey = ' new_key ' ;
} Puede agregar restricciones que controlen si un registro debe indexarse definiendo el método indexOnly() .
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public function indexOnly ( $ index_name )
{
return ( bool ) $ condition ;
}
}De forma predeterminada, el paquete Algolia buscará las relaciones cargadas .
Si desea indexar registros que aún no han cargado ninguna relación, puede hacerlo cargándolos en getAlgoliaRecord que puede crear en su modelo.
Se verá así:
public function getAlgoliaRecord ()
{
/**
* Load the categories relation so that it's available
* in the laravel toArray method
*/
$ this -> categories ;
return $ this -> toArray ();
}En el objeto resultante, Laravel tendrá categorías convertidas en matrices. Si desea una estructura de relación personalizada, deberá hacer algo como:
public function getAlgoliaRecord ()
{
/**
* Load the categories relation so that it's available
* in the laravel toArray method
*/
$ extra_data = [];
$ extra_data [ ' categories ' ] = array_map ( function ( $ data ) {
return $ data [ ' name ' ];
}, $ this -> categories -> toArray ());
return array_merge ( $ this -> toArray (), $ extra_data );
} De forma predeterminada, Algolia sólo podrá acceder a los atributos visibles de su modelo. Entonces, por ejemplo, recibirá una excepción No content in PUT request cuando utilice este código de ejemplo, porque la clave invisible_attribute devuelve una variable vacía/nula.
protected $ visible = [ ' visible_attribute ' , ' other_visible_attribute ' ];
public function getAlgoliaRecord ()
{
return [
' invisible_attribute ' => $ this -> invisible_attribute
];
} Antes de indexar, asegúrese de haber enumerado correctamente sus atributos visibles. Para evitar esta máscara de seguridad impuesta por Laravel, puedes usar $this->attributes['invisible_attribute'] para acceder directamente al atributo incluso si no está visible, pero la recomendación es evitar este tipo de acceso a los atributos de tu Modelo.
Puede activar la indexación utilizando el método de instancia pushToIndex .
$ contact = Contact :: firstOrCreate ([ ' name ' => ' Jean ' ]);
$ contact -> pushToIndex (); Y active la eliminación utilizando el método de instancia removeFromIndex .
$ contact = Contact :: firstOrCreate ([ ' name ' => ' Jean ' ]);
$ contact -> removeFromIndex (); Para reindexar de forma segura todos sus registros (indexar a un índice temporal + mover el índice temporal al actual de forma atómica), utilice el método de clase reindex :
Contact :: reindex ();Para reindexar todos sus registros (en su lugar, sin eliminar registros obsoletos):
Contact :: reindex ( false );Para establecer la configuración durante el proceso de reindexación:
Contact :: reindex ( true , true );Para mantener la configuración que estableció en el panel de Algolia al reindexar y cambiar la configuración:
Contact :: reindex ( true , true , true );Para implementar una devolución de llamada que se llame cada vez que se indexa un lote de entidades:
Contact :: reindex ( true , true , false , function ( $ entities )
{
foreach ( $ entities as $ entity )
{
var_dump ( $ entity -> id ); // Contact::$id
}
}); Para borrar un índice, utilice el método de clase clearIndices :
Contact :: clearIndices ( ) ; Puede definir índices de réplica utilizando la variable $algolia_settings :
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public $ algoliaSettings = [
' searchableAttributes ' => [
' id ' ,
' name ' ,
],
' customRanking ' => [
' desc(popularity) ' ,
' asc(name) ' ,
],
' replicas ' => [
' contacts_desc ' ,
],
];
public $ replicasSettings = [
' contacts_desc ' => [
' ranking ' => [
' desc(name) ' ,
' typo ' ,
' geo ' ,
' words ' ,
' proximity ' ,
' attribute ' ,
' exact ' ,
' custom '
]
]
];
}Para buscar usando una réplica, use el siguiente código:
Book :: search ( ' foo bar ' , [ ' index ' => ' contacts_desc ' ]); Puedes indexar un registro en varios índices usando la propiedad $indices :
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public $ indices = [
' contact_public ' ,
' contact_private ' ,
];
public function indexOnly ( $ indexName )
{
if ( $ indexName == ' contact_public ' )
return true ;
return $ this -> private ;
}
}Para buscar usando un índice adicional, use el siguiente código:
Book :: search ( ' foo bar ' , [ ' index ' => ' contacts_private ' ]);Haciendo:
Ad :: where ( ' id ' , $ id )-> update ( $ attributes );no activará nada en el modelo (por lo que no se realizará ninguna actualización en Algolia). Esto se debe a que no es una llamada Elocuente. Es simplemente una forma conveniente de generar la consulta oculta detrás del modelo.
Para que esta consulta funcione con Algolia, debes hacerlo así:
Ad :: find ( $ id )-> update ( $ attributes );Compatible con aplicaciones 5.x
