algoliasearch laravel
1.7.1
Algolia Search é um mecanismo de pesquisa hospedado de texto completo, numérico e facetado, capaz de fornecer resultados em tempo real desde o primeiro toque de tecla.
Este pacote está obsoleto, recomendamos que você use Laravel Scout . Se você deseja estender os recursos do Scout, consulte nossa documentação dedicada
Este pacote PHP integra a API Algolia Search no Laravel Eloquent ORM. É baseado no pacote algoliasearch-client-php.
Nota: Se você estiver usando Laravel 4, verifique o repositório algoliasearch-laravel-4.
Você pode encontrar a referência completa no site da Algolia.
Instalar
Início rápido
Opções
objectID personalizadoRelacionamentos
Indexação
Gerenciar índices
Compatibilidade eloquente
Adicione algolia/algoliasearch-laravel ao seu arquivo composer.json :
composer require algolia/algoliasearch-laravel Adicione o provedor de serviços a config/app.php na matriz providers .
AlgoliaSearch Laravel AlgoliaServiceProvider ::classLaravel Algolia requer uma configuração de conexão. Para começar, você precisará publicar todos os ativos do fornecedor:
php artisan vendor:publish Você pode adicionar a opção --provider="VinklaAlgoliaAlgoliaServiceProvider" para publicar apenas ativos do pacote Algolia.
Isso criará um arquivo config/algolia.php em seu aplicativo que você pode modificar para definir sua configuração. Além disso, verifique se há alterações em comparação com o arquivo de configuração original após uma atualização.
O código a seguir adiciona recursos de pesquisa ao seu modelo Contact criando um índice Contact :
use Illuminate Database Eloquent Model ;
use AlgoliaSearch Laravel AlgoliaEloquentTrait ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
}Por padrão, todos os atributos visíveis são enviados. Se quiser enviar atributos específicos, você pode fazer 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 '
]);
}
} Após configurar seu modelo, você precisa fazer manualmente uma importação inicial de seus dados. Você pode fazer isso chamando reindex na sua classe de modelo. Usando nosso exemplo anterior, isso seria:
Contact :: reindex ();Fornecemos muitas maneiras de definir as configurações do seu índice para ajustar a relevância geral, mas as mais importantes são os atributos pesquisáveis e os atributos que refletem a popularidade do registro . Você pode configurá-los com o seguinte código:
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public $ algoliaSettings = [
' searchableAttributes ' => [
' id ' ,
' name ' ,
],
' customRanking ' => [
' desc(popularity) ' ,
' asc(name) ' ,
],
];
} Você pode propagar (salvar) as configurações para algolia usando o método setSetting :
Contact :: setSettings ();Sinônimos são usados para informar ao mecanismo sobre palavras ou expressões que devem ser consideradas iguais em relação à relevância textual.
Nossa API de sinônimos foi projetada para gerenciar da maneira mais fácil possível um grande conjunto de sinônimos para um índice e suas réplicas.
Você pode usar a API de sinônimos adicionando synonyms na propriedade da classe $algoliaSettings como este:
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 ' ]
]
]
];
} Você pode propagar (salvar) as configurações para algolia usando o método setSetting :
Contact :: setSettings ();As implementações de pesquisa tradicionais tendem a ter lógica e funcionalidade de pesquisa no backend. Isso fazia sentido quando a experiência de pesquisa consistia em um usuário inserir uma consulta de pesquisa, executá-la e, em seguida, ser redirecionado para uma página de resultados de pesquisa.
A implementação da pesquisa no back-end não é mais necessária. Na verdade, na maioria dos casos é prejudicial ao desempenho devido à rede extra e à latência de processamento. É altamente recomendável usar nosso cliente JavaScript API emitindo todas as solicitações de pesquisa diretamente do navegador, dispositivo móvel ou cliente do usuário final. Isso reduzirá a latência geral da pesquisa e, ao mesmo tempo, descarregará seus servidores.
No seu código JavaScript você pode fazer:
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 } ) ; Você também pode usar o método search , mas não é recomendado implementar uma experiência de pesquisa instantânea/em tempo real no back-end (ter uma pesquisa no front-end proporciona uma melhor experiência do usuário):
Contact :: search ( ' jon doe ' );Cada vez que um registro é salvo; será - de forma assíncrona - indexado. Por outro lado, cada vez que um registro for destruído, ele será - de forma assíncrona - removido do índice.
Você pode desativar a indexação e a remoção automática definindo as seguintes opções:
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public static $ autoIndex = false ;
public static $ autoDelete = false ;
}Você pode desativar temporariamente a indexação automática. Isso geralmente é feito por motivos de desempenho.
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 ; Você também pode criar uma condição dinâmica para esses dois parâmetros criando um autoDelete method autoIndex e/ou autoDelete em seu 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 ;
}
}Tenha cuidado ao definir esses dois métodos em AlgoliaEloquentTrait. Ao colocar esses métodos em uma classe pai eles serão "apagados" pelo AlgoliaEloquentTrait se usados em uma classe filha (por causa da herança do php).
Por padrão, o nome do índice será o nome da classe no plural, por exemplo, "Contatos". Você pode personalizar o nome do índice usando a opção $indices :
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public $ indices = [ ' contact_all ' ];
}Você pode adicionar o sufixo ao nome do índice com o ambiente do aplicativo atual usando a seguinte opção:
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public static $ perEnvironment = true ; // Index name will be 'Contacts_{App::environnement()}';
}objectID personalizado Por padrão, o objectID é baseado no keyName do seu registro ( id por padrão). Você pode alterar esse comportamento especificando a opção objectIdKey (certifique-se de usar um campo uniq).
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public static $ objectIdKey = ' new_key ' ;
} Você pode adicionar restrições controlando se um registro deve ser indexado definindo o método indexOnly() .
use Illuminate Database Eloquent Model ;
class Contact extends Model
{
use AlgoliaEloquentTrait ;
public function indexOnly ( $ index_name )
{
return ( bool ) $ condition ;
}
}Por padrão, o pacote Algolia irá buscar os relacionamentos carregados .
Se quiser indexar registros que ainda não carregaram nenhuma relação, você pode fazer isso carregando-os no getAlgoliaRecord que você pode criar em seu modelo.
Será parecido com:
public function getAlgoliaRecord ()
{
/**
* Load the categories relation so that it's available
* in the laravel toArray method
*/
$ this -> categories ;
return $ this -> toArray ();
}No objeto resultante, você terá categorias convertidas em array pelo Laravel. Se você quiser uma estrutura de relacionamento personalizada, faça 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 );
} Por padrão, Algolia só poderá acessar atributos visíveis do seu modelo. Assim, por exemplo, você receberá uma exceção No content in PUT request ao usar este código de exemplo, porque a chave invisible_attribute retorna uma variável vazia/nula.
protected $ visible = [ ' visible_attribute ' , ' other_visible_attribute ' ];
public function getAlgoliaRecord ()
{
return [
' invisible_attribute ' => $ this -> invisible_attribute
];
} Antes da indexação, certifique-se de listar corretamente seus atributos visíveis. Para contornar essa máscara de segurança imposta pelo Laravel, você pode usar $this->attributes['invisible_attribute'] para acessar diretamente o atributo mesmo que não esteja visível, mas a recomendação é evitar esse tipo de acesso aos atributos do seu Model.
Você pode acionar a indexação usando o método de instância pushToIndex .
$ contact = Contact :: firstOrCreate ([ ' name ' => ' Jean ' ]);
$ contact -> pushToIndex (); E acione a remoção usando o método de instância removeFromIndex .
$ contact = Contact :: firstOrCreate ([ ' name ' => ' Jean ' ]);
$ contact -> removeFromIndex (); Para reindexar com segurança todos os seus registros (indexar para um índice temporário + mover o índice temporário para o atual atomicamente), use o método de classe reindex :
Contact :: reindex ();Para reindexar todos os seus registros (no local, sem excluir registros desatualizados):
Contact :: reindex ( false );Para definir configurações durante o processo de reindexação:
Contact :: reindex ( true , true );Para manter as configurações definidas no painel do Algolia ao reindexar e alterar as configurações:
Contact :: reindex ( true , true , true );Para implementar um retorno de chamada que é chamado sempre que um lote de entidades é indexado:
Contact :: reindex ( true , true , false , function ( $ entities )
{
foreach ( $ entities as $ entity )
{
var_dump ( $ entity -> id ); // Contact::$id
}
}); Para limpar um índice, use o método da classe clearIndices :
Contact :: clearIndices ( ) ; Você pode definir índices de réplica usando a variável $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 pesquisar usando uma réplica, use o seguinte código:
Book :: search ( ' foo bar ' , [ ' index ' => ' contacts_desc ' ]); Você pode indexar um registro em vários índices usando a propriedade $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 pesquisar usando um índice extra, use o seguinte código:
Book :: search ( ' foo bar ' , [ ' index ' => ' contacts_private ' ]);Fazendo:
Ad :: where ( ' id ' , $ id )-> update ( $ attributes );não acionará nada no modelo (portanto, nenhuma atualização acontecerá no Algolia). Isso ocorre porque não é uma chamada do Eloquent. É apenas uma maneira conveniente de gerar a consulta oculta atrás do modelo.
Para fazer esta consulta funcionar com Algolia você precisa fazer assim:
Ad :: find ( $ id )-> update ( $ attributes );Compatível com aplicativos 5.x
