Personalize SharePoint 2013 Pesquisas

Introdução

Personalização de pesquisa no SharePoint 2013 pode ser conseguido de várias maneiras. A forma mais comum é a personalização de busca modelos de exibição e aplicá-las ao sair da parte de resultados de pesquisa caixa web.

Neste artigo, vamos aprender a personalizar usando o código. Personalização por meio de código pode ser obtido de duas maneiras diferentes: usando CSOM 

Vamos entender busca arquitetura brevemente antes de explorar código. 

Figura 1 : O modelo CSOM

O lado direito da Figura 1 mostra os vários sabores disponíveis com CSOM; OData representa o endpoint RESTful para acessar dados. No SharePoint 2010, o serviço web foi acessado pelo uso de '_vti_bin / client.svc'; com 2013, os serviços podem ser acessados ​​usando '_api'.

Propriedade rastreada e gerenciado

No SharePoint 2010, havia dois tipos de servidor de pesquisa disponíveis, rápido e Enterprise. Com SP2013, é tudo fundidos em um servidor da empresa. Para a busca para retornar resultados, dois tipos de propriedades desempenha um papel importante, propriedades rastreadas e propriedades gerenciadas. Os usuários podem pesquisar apenas em propriedades gerenciadas.

Metadados extraído de listas e documentos constitui a propriedade rastreada. Propriedade rastreada pode ser estruturado de dados, tais como colunas de lista ou palavras-chave como não estruturados extraídos de documentos. A propriedade rastreada pode ser adicionado a propriedade gerenciada múltipla e propriedade rastreada múltiplo também podem ser mapeados para única propriedade gerenciada.

Nota: propriedade gerenciada é criado automaticamente para colunas de site que contém dados durante o rastreamento.

Refinadores

As refinarias são baseados na agregação de propriedade gerenciada e contagem é calculado com base em todos os resultados de uma consulta de pesquisa, através de apenas alguns podem ser recuperadas. As refinarias são usados ​​para detalhar os resultados da pesquisa.

Vamos entender como usar as APIs do REST para realizar uma pesquisa. Os parâmetros básicos que podem ser usados ​​para buscar conjunto de resultados são:

• Palavras-chave : No parâmetro 'QUERYTEXT', critérios de pesquisa são especificados. O ' consulta 'é substituído com o texto de pesquisa / condição.
  http: // servidor / site / _api / pesquisa / consulta QUERYTEXT = 'consulta '
• Imóveis a Retirado : menciona explicitamente as propriedades gerenciadas para ser recuperado no parâmetro 'selectproperties'.
  http: // servidor / site / _api / pesquisa / consulta QUERYTEXT = '' & selectproperties = ''
• Classificando : Especifique os nomes (s) da coluna em que a classificação deve ser ativado usando o parâmetro 'sortlist'.
  http://server/site/_api/search/query?querytext=''&selectproperties=''&sortlist='firstname:ascending,joindate:descending '

O seguinte trecho de código usa o método JQuery Ajax para buscar os resultados de pesquisa usando REST. Na linha 3, "URL" é o parâmetro de consulta para pesquisa e Linha 5 direciona o resultado a ser devolvido em formato JSON.

 1. $ .ajax (
 2. {
 3.        url: " http: // servidor / site / _api / pesquisa / consulta QUERYTEXT = 'consulta '",
 4. método: "GET",
 5. cabeçalhos: {
 . 6           "aceitar": "application / json; OData = verbose"
 7.}
 . 8        Sucesso: onSuccess, 
 9.        Erro: onError
10.}
11.);

Linhas 8 e 9 tem as definições de sucesso e erro que são executados uma vez que a consulta é executada.

CSOM Usando JavaScript

Para usar CSOM em JavaScript, uma referência à necessidade 'search.js' para ser incluído; este está localizado na '_layouts / 15 / SP.search.js'. Neste exemplo, o resultado é obtido com base em critérios e também alguns refinadores.

Para começar, registrar os SP.Search.js usando o seguinte comando:

RegisterSod ("search.js", + _spPageContextInfo.webAbsoluteUrl
   /_layouts/15/SP.search.js "");

O próximo trecho de código recupera o conjunto de resultados com base na palavra-chave 'casa' e também recebe valores de refinamento para metadados gerenciados chamado 'FileType'; Em outras palavras, as refinarias.

 1. var ctx SP.ClientContext.get_current = ();
 2. var kquery = new 
       exec = new Microsoft.SharePoint.Client. Search.Query.SearchExecutor (CTX); 
 . 6 resultado var = exec.executeQuery (kquery); 
 7. ctx.executeQueryAsync (function ()
       
 8. {
 . 9     resultValues ​​var = result.m_value.ResultTables [0]; 
. 10     var resultRefiner = result.m_value.ResultTables [1];
. 11. $ ("# resultDiv") anexar ('');
12. $ .each (resultValues.ResultRows, function () {
13. $ ("# resultDiv") anexar ('
.');
. 14. $ ("# resultDiv") anexar ('
' + this.title + '</ td>');
. 15. $ ("# resultDiv") anexar ('
' + this.Path + '</ td>');
. 16. $ ("# resultDiv") anexar ('</ tr>');
17.});
. 18. $ ("# resultDiv") anexar ('</ table>');
. 19. $ ("# refinerDiv") anexar ('');
20. $ .each (resultRefiner.ResultRows, function () {
21. $ ("# refinerDiv") anexar ('
.');
22. $ ("# refinerDiv"). Append ('
' + this.RefinementName +
             '</ Td>');
23. $. (Quot; #refinerDiv ") anexar ('
 (' + this.RefinementCount +
             ') </ Td>');
. 24. $ ("# refinerDiv") anexar ('</ tr>');
25.});
. 26. $ ("# refinerDiv") anexar ('</ table>');
27.}
Função 28. (sender, args)
29. {});

Vamos analisar o código em detalhes. Linha 1 obtém o objeto contexto atual. Para criar um objeto do tipo KeywordQuery ( Microsoft.SharePoint.Client.Search.Query.KeywordQuery ), arquivos SP.Search.js precisam ser referenciado. A criação do objeto KeywordQuery leva o contexto atual como um parâmetro de entrada (Linha 2).

O objeto KeywordQuery tem duas propriedades, set_queryText e set_refiners . Use a set_queryTextpropriedade (Linhas 3 e 4) para definir a palavra-chave e / ou a condição de consulta e use set_refinerspara especificar as refinarias a serem recuperados para os critérios de pesquisa. Estes refinadores pode ser usado para perfurar os dados mais abaixo.

Linha 5 cria o objeto de busca e executor linha 6 usa executeQuery método para executar a pesquisa.A pesquisa ainda não é executada nesta fase; a pesquisa é executada rodando ctx.executeQueryAsync (linha 7).

Se a pesquisa é executada sem erros, um conjunto de tabelas de resultados é retornado. ResultTables [0] é os resultados da pesquisa retornou e as refinarias são preenchidos em ResultTables [1]. Neste exemplo, a linha 9 armazena os resultados da pesquisa e o mesmo está em loop através de e exibido na UI (linha 12-17). Linha 10 armazena os valores refinador eo mesmo é em loop através e exibido na UI (linhas 20-25).

Resumo

Neste artigo, nós cobrimos a personalização de uma pesquisa usando CSOM e REST. Isso lhe dá a flexibilidade para desenvolver aplicativos baseados em pesquisa. Nós também abordou como as refinarias podem ser recuperadas e estes podem ser ainda utilizado para detalhar a pesquisa.Podemos também usar sourceId para restringir os resultados da pesquisa de uma fonte resultado particular.

Referências

• http://msdn.microsoft.com/en-us/library/microsoft.sharepoint.client.search.query.keywordquery_properties.aspx
• http://msdn.microsoft.com/en-us/library/office/ff394639(v=office.15).aspx
• http://msdn.microsoft.com/en-us/library/office/ff394639(v=office.15).aspx
• http://msdn.microsoft.com/en-us/library/office/jj163876(v=office.15).aspx