[SharePoint 2013] Acceso a las búsquedas mediante programación

En este artículo vamos a introducirnos en el mundo de las búsquedas dentro de SharePoint 2013. En esta versión hay muchas novedades relacionadas con la búsqueda, alguna de ellas muy sonadas como el Content Query by Search (que abordaré próximamente) y la introducción ya plena de FAST como motor principal para realizar las búsquedas.

Hoy vamos a ver cómo poder acceder a la información que nos da el servicio de búsquedas: utilizando la API Rest, el modelo de objetos cliente y el modelo de objetos servidor.

Antes de ponernos manos a la obra hay que tener en cuenta que el servicio Web que se utilizaba en anteriores versiones para hacer consultas de forma remota está obsoleto y que la sintaxis SQL Query se ha eliminado por completo.

Utilizando el motor de búsqueda usando REST

Como hemos visto en esta versión de SharePoint, Microsoft ha optado por hacer una versión mas proxima a los estandares web. Para ello, cada punto de acceso a un artefacto de SharePoint tiene su correspondiente servicio Rest para acceder a él independientemente de la plataforma. Para acceder al servicio Rest de la búsqueda tenemos que acceder a la siguiente dirección :http:///_api/search.

A continuación vemos un ejemplo de cómo hacer una llamada a la API Rest utilizando JavaScript

function getSearch(term) {
    $.ajax(
       {
           url: appweburl + "/_api/search/query?querytext='"+terme + "'",
           method: "GET",
           headers: { "Accept": "application/json; odata=verbose" },
           success: function (data) {
               successSearch(data);
           },
           error: function (xhr, ajaxOptions, thrownError) {
               failSearch(xhr, ajaxOptions, thrownError);
           }
       }
   );
}
function successSearch(data)
{
    var stringData = JSON.stringify(data);
    var jsonObject = JSON.parse(stringData);

    var result = data.d.query.PrimaryQueryResult.RelevantResults.Table.Rows.results;
    var html = "";
    for(var i=0;i<result.length;i++)
    {
        html += "Resultado " + i + " :" + result[i].Cells.results[3].Value +"<br/";
    }
    $("#MySearch").empty();
    $("#MySearch").html(html);
}
function failSearch(xhr, ajaxOptions, thrownError)
{
    alert("GET error:\n" + xhr.status + "\n" + thrownError);
}

Como vemos en el código, hemos implementando una función que como parámetro de entrada recibe el contenido a buscar. Realizamos la llamada a la API Rest enviando un GET y que nos devuelve el formato de respuesta de tipo JSon. Para finalizar, nos definimos dos funciones, una en caso de que la llamada funcione a la perfección y, otro, en caso de que nos devuelva algún tipo de error. En caso de éxito, extraemos la información de la búsqueda y la mostramos donde estimemos oportuno, en nuestro caso, dentro del identificador «MySearch». Si se produce un error, optamos por mostrar un mensaje indicando el error que se ha producido.

Tip para el uso de la API Rest
A parte de mirar la documentación para saber qué objetos no va a devolver, para comprobar que estoy realizando la llamada correcta y los campos que me devuelve, lo que hago es realizar una llamada a la API Rest desde el propio navegador:

¿Cual es la ventaja? La principal ventaja es que verificas que estas realizando la llamada REST correctamente y ademas obtienes la estructura de lo que te devuelve y de esta forma accedes directamente a la información que necesites.

Utilizando el modelo de objetos cliente .NET

Para hacer uso de ello, en primer lugar tenemos que añadir las referencias a las librerías clientes de SharePoint nativas y a las de búsqueda que son las siguientes: Microsoft.SharePoint.Client.Search.dll, Microsoft.SharePoint.Client.dll y Microsoft.SharePoint.Client.Runtime.dll.
Una vez añadidas las referencias vamos a crear un procedimiento que devuelve los diez primeros elementos. Para ello, implementamos la siguiente función:

IEnumerable<string> GetResult(string words)
        {
            var result = new List<string>();

            using(ClientContext context= new ClientContext("http://myserver"))
            {
                var query= new KeywordQuery(context);
                query.QueryText=words;
                var search= new SearchExecutor(context);
                ClientResult<ResultTableCollection> myResult= search.ExecuteQuery(query);
                context.ExecuteQuery();
                foreach(var itemResult in myResult.Value[0].ResultRows)
                {
                    result.Add(itemResult["Title"];
                }
            }

            return result;
        }

También hay un modelo de objetos cliente para JavaScript, pero como he comentado otras veces, en lugar de utilizar este modelo de objetos considero más adecuado y una mejor practica, utilizar la API Rest ya que nos proporciona lo mismo que el modelo de objetos en cliente y además nos vale en todas las plataformas.

Utilizando el modelo de objetos servidor

Al igual que en el modelo de objeto cliente, tendremos que añadir una serie de referencia. En este caso las dll son las siguientes: Microsoft.Office.Server.Search.dll y Microsoft.Office.Server.Search.Query.dll.

Una vez añadidas a nuestro proyecto, realizaremos un procedimiento similar al del modelo de objetos cliente en el que visualizaremos los diez primeros elementos. El código resultante seria el siguiente:

DataTable GetResult(string words)
        {
            var result = new DataTable();
            var site = SPContext.Current.site;
            using(KeywordQuery myQuery= new KeywordQuery(site))
            {
                    myQuery.QueryText=words;
                    myQuery.KeywordInclusion=KeywordInclusion.AllKeywords;
                    myQuery.RowLimit=500;
                    myQuery.SelectProperties.Add("Path");
                    myQuery.SelectProperties.Add("IsDocument");

                    var mySearchExecutor = new SearchExecutor();

                    var myResult = mySearchExecutor.ExecuteQuery(myQuery);

                    if(myResult.Count>0)
                    {
                        var results = myResult.Filter("TableType", KnowTableTypes.RelevantResults);
                        if (results != null && results.Count() == 1) result.Load(results.First(), LoadOption.OverwriteChanges);
                    }
            }
            return result;
        }

Como podemos observar, el código es muy similar al modelo de objetos en cliente. Creamos una variable para la consulta y usando el objeto «SearchExecutor» para enviar la consulta al servidor. Una vez obtenemos los resultados, lo almacenamos en el DataTable y devolvemos este valor de la función.

Conclusión

En este post hemos visto cómo utilizar programaticamente los servicios de búsqueda en nuestros desarrollos. En esta versión se ha dado un paso al frente con la finalidad de que podamos hacer uso del sistema de búsqueda desde cualquier dispositivo y en cualquier desarrollo que lo necesitemos. Esto, en anteriores versiones era relativamente complejo y con resultados bastantes malos para el esfuerzo empleado en los mismos. Pero el servicio de búsqueda no solamente tiene estas novedades. Para mi, el nuevo servicio de búsqueda es uno de los puntos fuertes que tiene esta versión de SharePoint que ya iremos desmenuzando próximamente.