Paginando en SharePoint 2013 con API REST

Muy buenas a todos,

Hoy quería contaros un tema con el que me he estado peleando hoy en mi proyecto con el que estoy haciendo un uso bastante intensivo de la API REST de SharePoint con AngularJS. Una experiencia que os debo decir, me está encantando.

El tema ha venido a la hora de “paginar” una consulta en SharePoint que estaba haciendo vía API REST. Según pensaba, usando las opciones $top y $skip se podría hacer la paginación sin problemas. Para ello pensaba usar el endpoint que habitualmente uso para trabajar con las listas de SharePoint

http://<misitio>/_api/web/lists/getbytitle(‘lista&#8217;)/items

Mi sorpresa ha sido darme cuenta que con este endpoint la opción $skip no funciona. Indagando un poco he descubierto que efectivamente, esta opción no funciona para lista de elementos, solo funciona para colecciones de datos como colecciones de listas.

http://sharepoint.stackexchange.com/questions/45719/paging-using-rest-odata-with-sp-2013

https://msdn.microsoft.com/en-us/library/office/fp142385.aspx

Para hacer la paginación via API REST podemos usar el antiguo endpoint OData V2 listdata.svc. Con esta versión si funciona la opción $skip correctamente:

http://<misitio>/_vti_bin/ListData.svc/<lista&gt;

Ejemplo: http://<misitio>/_vti_bin/ListData.svc/<lista&gt;?$top=2&$skip=2

Salvando este inconveniente sobre el endpoint que debemos usar, usando estas dos opciones $top y $skip, podremos paginar nuestras consultas de una forma muy sencilla.

Y esto es todo por hoy, espero que os resulte útil, como siempre, y que si os habéis encontrado con esta problemática, tardéis menos tiempo en resolverlo.

Saludos.

[OffTopic]

No suelo acostumbrar a hacer nada de esto. Pero hoy ha nacido mi sobrino, del que tendré la oportunidad además de ser su padrino. Así que esta entrada de hoy va dedicada a él y a sus padres. Aunque no lo podré conocer hasta dentro de 15 días porque me ha salido “conejero” y está en Lanzarote, que ilusión más grande.

Anuncios

Usando el nuevo modelo de desarrollo para SharePoint con PowerShell

Muy buenas a todos,

Hace unos meses, escribí acerca del nuevo modelo de desarrollo para SharePoint OnLine y SharePoint OnPremises propuesto por Microsoft e incluso una de mis colaboraciones en CompartiMOSS giró en torno a este tema.

Nuevo modelo de desarrollo de Sharepoint. Adaptando nuestras soluciones de granja

Número #24 de CompartiMOSS y nueva colaboración con la revista

Como ya decía en aquella ocasión, trabajar con las API cliente se podría hacer tanto por medio de la API REST, con la API CSOM o JSOM o incluso PowerShell. Tenía muchas ganas de ver cómo se podría trabajar con éste último y para un proyecto en el que estoy trabajando recientemente decidí que ya era el momento.

La primera intención, fue desarrollar mis propios Cmdlets o mis propios Scripts con funciones para realizar las distintas operaciones que fuese necesitando. Finalmente decidí previamente indagar por la cuenta de GitHub de OfficeDev/Pnp, donde encontré un gran trabajo especifico sobre PowerShell, proporcionando una gran cantidad de Cmdlets desarrollados que permiten trabajar con las API Cliente, concretamente CSOM, y PowerShell. Por supuesto, trabajo que decidí utilizar, y que os recomiendo a todos.

https://github.com/OfficeDev/PnP-powershell

En el artículo de hoy, os quiero mostrar cómo instalar y configurar en nuestro servidor estos Cmdlets y cómo se pueden usar algunos de ellos a modo de ejemplo. No obstante, en la página de Pnp hay una documentación muy buena sobre todas las opciones de que disponemos.

Instalando los Cmdlets en el servidor

Para poder tener disponibles todos los Cmdlets de PowerShell tendremos que seguir los siguientes pasos:

1.- En primer lugar descargar el proyecto Visual Studio desde la cuenta de GitHub de OfficeDev/Pnp-PowerShell.

download

2.- Para poder instalar el proyecto, es necesario descargar e instalar las WiX Tools en nuestro equipo.

wix

3.- A continuación abrimos la solución que descargamos anteriormente y para poder crear la solución, necesitamos agregar dos paquetes desde Nugets. El primero de ellos es el OfficeDev Core para SharePoint Online o OnPremises, en función de para qué lo vayamos a usar.

coreoffice

4.- El siguiente paquete es la librería ADAL para la autenticación.

identity

5.- Tras esto ya se puede hacer el build del proyecto lo cual dejará instalados los Cmdlets en nuestro equipo

install

Si ahora abrimos por ejemplo el IDE de PowerShell, en la lista de comandos disponibles, si ponemos en el cajón de búsqueda SPO, filtrará todos los comandos que se han añadido.

Usando los nuevo Cmdlets

A continuación voy a mostrar un breve ejemplo de cómo podríamos usar los nuevos Cmdlets con PowerShell.

Connect-SPOnline -Url $url -Credentials (Get-Credential)

Add-SPOField -DisplayName "Example" -InternalName "Example" -Group "ExampleSPO" -Type Integer
Add-SPOField -DisplayName "Example1" -InternalName "Example1" -Group "ExampleSPO" -Type Text
Add-SPOField -DisplayName "Example2" -InternalName "Example2" -Group "ExampleSPO" -Type Choice -Choices "uno","dos","tres"

Add-SPOContentType -Name "ContentTypeExample" -Description "Description to Content Type" -Group "ExampleSPO"

Add-SPOFieldToContentType -Field "Example" -ContentType "ContentTypeExample"
Add-SPOFieldToContentType -Field "Example1" -ContentType "ContentTypeExample"
Add-SPOFieldToContentType -Field "Example2" -ContentType "ContentTypeExample"

New-SPOList -Title "List Title" -Template GenericList -EnableContentTypes
Add-SPOContentTypeToList -List "List Title" -ContentType "ContentTypeExample" -DefaultContentType

En el código de ejemplo se muestra cómo conectarse a un sitio de SharePoint OnLine, crear columnas de sitio, un tipo de contenido y asociarlo a una lista que se ha creado previamente.

Y esto es todo por hoy, por si aún no lo conocíais, espero que os sea de utilidad y que en la medida de lo posible, podáis usarlo en vuestros proyectos.

Hasta la próxima.

Resolviendo el error 403 cuando añadimos elementos por medio de API REST en SharePoint 2013

Hola a todos,

Hoy os quiero mostrar en una breve entrada cómo resolver el error 403 que surge cuando hacemos una petición POST para añadir elementos en una lista a través de la API REST de SharePoint 2013.

En mi caso, estoy trabajando en un proyecto en el que utilizo SharePoint y AngularJS, por eso, los ejemplos de las peticiones que os voy a mostrar, son usando el módulo $http de AngularJS.

Cuando hacemos una petición como esta:

$http({
            url: urlBase,
            method: "POST",
            data: JSON.stringify(likeJSON),
            headers: {
                "accept": "application/json;odata=verbose",
                "content-type": "application/json;odata=verbose",
            }
        });

El resultado que nos devuelve es un error como éste:

“The security validation for this page is invalid and might be corrupted. Please use your web browser’s Back button to try your operation again.”

Para solucionarlo, debemos añadir en la cabecera de la petición el parámetro X-RequestDigest como sigue:

$http({
            url: urlBase,
            method: "POST",
            data: JSON.stringify(likeJSON),
            headers: {
                "accept": "application/json;odata=verbose",
                "content-type": "application/json;odata=verbose",
                "X-RequestDigest": requestDigest,
            }
        });

Esta cabecera contiene información conocida como form digest. Ésta es un objeto que se inserta en una página por SharePoint y es usado para validar las peticiones de cliente

La pregunta ahora es: ¿Cómo conseguimos ese valor?. Pues lo podemos obtener por medio de la siguiente petición:

$http({
        url: "/_api/contextinfo",
        method: "POST",
        headers: {
            "accept": "application/json;odata=verbose",
            "content-type": "application/json;odata=verbose"
        }
    }).then(function (response) {
        requestDigest = response.data.d.GetContextWebInformation.FormDigestValue;
    },
    function () {

    });

Por medio de una petición POST al servicio REST con el EndPoint en la url /_api/contextinfo

De esta forma conseguimos resolver el error 403 que nos devuelven las peticiones POST al servicio REST en SharePoint.

Os dejo un enlace que me ha servido de guía, y en el que me he basado.

http://blogs.msdn.com/b/nadeemis/archive/2012/10/23/tip-handling-http-403-forbidden-when-querying-the-search-rest-service-using-the-postquery-method.aspx

Espero que os haya resultado interesante.

Un saludo

Número #24 de CompartiMOSS y nueva colaboración con la revista

Muy buenas a todos,

El pasado miércoles durante el CEUS by Iberian Conference se presentó un nuevo número de la revista especializada en SharePoint CompartiMOSS. En esta ocasión, la revista trae mucho contenido interesante y cada vez más comienzan a aparecer artículos relacionados con Azure, Machine Learning, SharePoint OnLine y siempre sin olvidar la versión de SharePoint OnPremise.

numero24

Para acceder al número de la revista, podéis hacer click aquí. Os dejo también acceso a todo el contenido del número de la revista, para que os podáis hacer una idea del contenido de la misma.

Una vez más he dejado mi pequeña aportación a esta revista que espero que os guste. En esta ocasión os escribo sobre el nuevo modelo de desarrollo que se propone desde Microsoft para SharePoint, tanto la versión OnLine como la versión OnPremise. Algo ya he comentado por aquí, con algunos artículos sobre el tema que iban saliendo mientras preparaba el artículo.

Para terminar muchas gracias a todos los que hacen posible que esta revista siga adelante.

Un saludo y hasta la próxima

Search Driven Development. Usando la API REST de SharePoint para el servicio de búsqueda

Muy buenas a todos,

Recientemente he publicado algunos artículos sobre Search Driven Development para SharePoint Online y SharePoint 2013. Además hace poco tiempo tuve la oportunidad de participar en una mesa redonda con la gente de MadPoint en la que se hablaba de técnicas de desarrollo tanto para SharePoint OnLine como 2013 y Office 365. En esta mesa redonda salió la posibilidad de usar en los desarrollos la API REST del servicio de búsquedas de SharePoint y los nuevos frameworks de Javascript para crear nuestra propia solución basada en búsquedas.

Hasta entonces no había tenido la oportunidad de probar esta API REST, pero hoy os traigo una entrada en la que os quiero enseñar como usar las búsquedas a través de la API REST que nos proporciona esta versión de SharePoint.

En una primera parte de la entrada os enseñaré que consultas REST podemos hacer al servicio y lo que nos devuelve y a continuación veremos ejemplos de cómo utilizar el mismo en una app for SharePoint (o SharePoint Add-ins??).

Llamadas REST para el servicio de búsqueda

Uno de los aspectos importantes que tenemos que tener en cuenta cuando trabajamos con la API REST del servicio de búsqueda es que las consultas al mismo podemos hacerlas a través de peticiones GET y a través de peticiones POST. Esto es así, porque como es sabido por todos, las peticiones GET tienen limitaciones en cuanto al número de caracteres y puede ocurrir que una consulta que queramos hacer sobrepase ese límite, por lo que tendremos la oportunidad de usar las peticiones POST para superar dicha restricción.

A continuación voy a enseñar algunos ejemplos básicos de cómo utilizar ambos tipos de peticiones, aunque las posibilidades que tenemos a la hora de hacer las peticiones son muy extensas. Para esto os dejo el enlace a la referencia de la MSDN, donde podréis analizar al completo las opciones de la API.

https://msdn.microsoft.com/es-es/library/office/jj163876.aspx

Usando peticiones GET

Las peticiones GET se hacen a través de la siguiente URL:

http://servidor/_api/search/query

Consulta con un texto a buscar
/_api/search/query?querytext=’textoAconsultar’
Consulta usando una query
/_api/search/query?querytemplate='{searchterms} FileExtension: doc’
Usando la ordenación
/_api/search/query?querytext=’textAconsultar’&sortlist=’created:ascending,rank:descending,’
Indicando los refinadores a utilizar
/_api/search/query?querytext=’textAconsultar’&refiners=’author,size,fileExtension’
Filtrando la consulta usando el refinamiento
/_api/search/query?querytext=’textAconsultar’&refinementfilters=’fileExtension:equals(“docx”)’

Usando peticiones POST

Las peticiones POST se hacen a través de la siguiente URL:

http://servidor/_api/search/postquery

Consulta con un texto a buscar
{'request':
    { 
      '__metadata' : {'type' : 
                   'Microsoft.Office.Server.Search.REST.SearchRequest'},
      'Querytext' : 'ejemploAconsultar'
    }
}

Son muy importantes las mayúsculas y minúsculas en las consultas usando el método POST. Por ejemplo, en la consulta anterior, tenemos que usar ‘Querytext’ y no ‘QueryText’ o ‘querytext’ como hacemos en la consulta GET.

Estas consultas devuelven un JSON con toda la información necesaria de la búsqueda. Al igual que el resto de servicios REST, este de búsquedas es compatible con JSON Light, por lo que si lo deseeamos podemos obtener respuestas más ligeras y rápidas. Los resultados se encuentran en el objeto devuelto en:

data.body.d.query.PrimaryQueryResult.RelevantResults.Table.Rows.results (para GET)
data.body.d.postquery.PrimaryQueryResult.RelevantResult.Table.Rows.results (para POST)

Este elemento “results” json es un array que contiene una fila para cada uno de los resultados, en cada columna o celda de esta fila tenemos una de las propiedades del objeto devuelto. Para simplificar un poco la tarea, os voy a indicar en qué posición se encuentra la información que habitualmente es más importante de los objetos devueltos.

  • Posición 3: Title
  • Posición 4: Author
  • Posición 5: Size
  • Posición 6: Path
  • Posición 7: Description
  • Posición 8: Write
  • Posición 11: HitHighlightedSummary
  • Posición 18: FileExtension
  • Posición 31: FileType

El mismo servicio, si le hemos indicado para qué propiedades queremos obtener refinadores, nos devuelve los refinadores para esa búsqueda en:

data.body.d.query.PrimaryQueryResult.RefinementResults.Refiners.results

Esto nos devuelve, para cada refinador, un objeto de la siguiente forma:

{'Entries':
    {'results'
         {
             RefinementCount: count,
             RefinementToken: token,
             RefinementName: name,
             RefinementValue: value
         },
         {
             RefinementCount: count,
             RefinementToken: token,
             RefinementName: name,
             RefinementValue: value
         }
    },
  'Name':Refiner
}

Cada uno de los elementos contenidos en el objeto Entries, nos indica una opción de refinamiento para el refinado correspondiente. A continuación vamos a ver cómo he usado este servicio en una aplicación para SharePoint a modo de prueba.

Usando la API REST para búsquedas en una App for SharePoint

El ejemplo lo he realizado usando JQuery para manipular el DOM de la página del mismo. En primer lugar vamos a ver una captura de la aplicación para explicar que hace cada sección de la misma:

appsearchexample

En la aplicación que os quiero enseñar he hecho 5 ejemplos de como usar la API REST del servicio de búsqueda:

  • El primero ejemplo es una consulta usando GET a partir de una cadena de texto.
  • El segundo ejemplo es una consulta por POST a partir de una cadena de texto.
  • El tercer ejemplo usar una query para hacer la llamada al servicio de búsqueda por GET.
  • En el cuarto ejemplo se usa la ordenación.
  • El quinto ejemplo utiliza los refinadores.

Código del primer ejemplo

$("#searchbutton1").click(function () {

        var searchText = $("#searchbox1").val();

        executor.executeAsync({
            method: "GET",
            url: appweburl + "/_api/search/query?querytext='" + searchText + "'",
            headers: {
                "accept": "application/json;odata=verbose",
                "content-type": "application/json;odata=verbose"
            },
            success: function (data) {

                var element = document.getElementById("resultsList1");

                $('#resultsList1 > li').remove();

                var jsonObject = JSON.parse(data.body);

                console.log(jsonObject);

                var results = jsonObject.d.query.PrimaryQueryResult.RelevantResults.Table.Rows.results;

                for(var i = 0; i < results.length; i++)
                {
                    var li = document.createElement("li");

                    li.innerText = results[i].Cells.results[3].Value + "
" + results[i].Cells.results[5].Value + "&nbsp;" + results[i].Cells.results[4].Value + "
" + results[i].Cells.results[11].Value;

                    element.appendChild(li);
                }
            },
            error: function (data) {
            }
        });

        return false;

    });

Código del segundo ejemplo

$("#searchbutton2").click(function () {

        var searchText = $("#searchbox2").val();

        executor.executeAsync({
            method: "POST",
            url: appweburl + "/_api/search/postquery",
            body: "{'request': { '__metadata' : {'type' : 'Microsoft.Office.Server.Search.REST.SearchRequest'}, 'Querytext' : '" + searchText + "' }}",
            headers: {
                "accept": "application/json;odata=verbose",
                "content-type": "application/json;odata=verbose"
            },
            success: function (data) {

                var element = document.getElementById("resultsList2");

                $('#resultsList2 > li').remove();

                var jsonObject = JSON.parse(data.body);
                var results = jsonObject.d.postquery.PrimaryQueryResult.RelevantResults.Table.Rows.results;

                for (var i = 0; i < results.length; i++) {
                    var li = document.createElement("li");

                    li.innerText = results[i].Cells.results[3].Value;

                    element.appendChild(li);
                }
            },
            error: function (data) {
            }
        });

        return false;

    });

Código del tercer ejemplo

executor.executeAsync({
        method: "GET",
        url: appweburl + "/_api/search/query?querytemplate='{searchterms} FileExtension: doc'",
        headers: {
            "accept": "application/json;odata=verbose",
            "content-type": "application/json;odata=verbose"
        },
        success: function (data) {

            var element = document.getElementById("resultsList3");

            $('#resultsList3 > li').remove();

            var jsonObject = JSON.parse(data.body);

            var results = jsonObject.d.query.PrimaryQueryResult.RelevantResults.Table.Rows.results;

            for (var i = 0; i < results.length; i++) {
                var li = document.createElement("li");

                li.innerText = results[i].Cells.results[3].Value;

                element.appendChild(li);
            }
        },
        error: function (data) {
        }
    });

Los tres primeros ejemplos son muy similares. Entre el primero y el segundo la única diferencia es que una petición se hace por GET y otra petición se hace por POST. En el tercero, se vuelve a usar una consulta por GET pero en este caso en lugar de un texto lo que se pasa es una consulta como tal. Todos los ejemplos usan una lista para representar los resultados devueltos.

Código del cuarto ejemplo

$("#searchbutton4").click(function () {

        var searchText = $("#searchbox4").val();

        executor.executeAsync({
            method: "POST",
            url: appweburl + "/_api/search/postquery",
            body: "{'request': { '__metadata' : {'type' : 'Microsoft.Office.Server.Search.REST.SearchRequest'}, 'Querytext' : '" + searchText + "' }}",
            headers: {
                "accept": "application/json;odata=verbose",
                "content-type": "application/json;odata=verbose"
            },
            success: function (data) {

                var element = document.getElementById("resultsList4");

                $('#resultsList4 > li').remove();

                var jsonObject = JSON.parse(data.body);
                var results = jsonObject.d.postquery.PrimaryQueryResult.RelevantResults.Table.Rows.results;

                for (var i = 0; i < results.length; i++) {
                    var li = document.createElement("li");

                    li.innerText = results[i].Cells.results[3].Value;

                    element.appendChild(li);
                }
            },
            error: function (data) {
            }
        });

        return false;

    });

    $("#orderbutton4").change(function () {

        var searchText = $("#searchbox4").val();
        var value = $("#orderbutton4").val();
        var order = "";

        if(value == "asc")
        {
            order = "created:ascending";
        }
        else
        {
            order = "created:descending";
        }

        executor.executeAsync({
            method: "GET",
            url: appweburl + "/_api/search/query?querytext='" + searchText + "'&sortlist='" + order + "'",
            headers: {
                "accept": "application/json;odata=verbose",
                "content-type": "application/json;odata=verbose"
            },
            success: function (data) {

                var element = document.getElementById("resultsList4");

                $('#resultsList4 > li').remove();

                var jsonObject = JSON.parse(data.body);

                var results = jsonObject.d.query.PrimaryQueryResult.RelevantResults.Table.Rows.results;

                for (var i = 0; i < results.length; i++) {
                    var li = document.createElement("li");

                    li.innerText = results[i].Cells.results[3].Value + " " + results[i].Cells.results[8].Value;

                    element.appendChild(li);
                }
            },
            error: function (data) {
            }
        });

        return false;
    });

Básicamente este ejemplo funciona de la misma forma que los anteriores. Lo único extraordinario, tiene que ver con que queremos usar la ordenación por la propiedad “size” de los resultados. Hemos creado un combo donde podemos seleccionar, si queremos, orden ascendente y descendente para el tamaño. Lo que se ha hecho es crear otro evento que se dispara cuando cambia el valor seleccionado del combo para que se haga la ordenación. Para ello se añade a la consulta la parte correspondiente (sortlist) en función de si hemos seleccionado ascendente o descendente.

Código del último ejemplo

$("#searchbutton5").click(function () {

        var searchText = $("#searchbox5").val();

        executor.executeAsync({
            method: "GET",
            url: appweburl + "/_api/search/query?querytext='" + searchText + "'&refiners='author,size'",
            headers: {
                "accept": "application/json;odata=verbose",
                "content-type": "application/json;odata=verbose"
            },
            success: function (data) {

                var element = document.getElementById("resultsList5");

                $('#resultsList5 > li').remove();

                var jsonObject = JSON.parse(data.body);

                console.log(jsonObject);

                var refiners = jsonObject.d.query.PrimaryQueryResult.RefinementResults.Refiners.results;

                $("#titlerefiner").text(refiners[0].Name);

                $.each(refiners[0].Entries.results, function (i, item) {
                    $('#valuerefiners').append($('<option>', {
                        value: refiners[0].Name + ":" + item.RefinementToken,
                        text: item.RefinementName
                    }));
                });

                var results = jsonObject.d.query.PrimaryQueryResult.RelevantResults.Table.Rows.results;

                for (var i = 0; i < results.length; i++) {
                    var li = document.createElement("li");

                    li.innerText = results[i].Cells.results[3].Value;

                    element.appendChild(li);
                }
            },
            error: function (data) {
            }
        });

        return false;

    });

    $("#valuerefiners").change(function () {

        var searchText = $("#searchbox5").val();
        var value = $("#valuerefiners").val();

        executor.executeAsync({
            method: "GET",
            url: appweburl + "/_api/search/query?querytext='" + searchText + "'&refinementfilters='" + value + "'",
            headers: {
                "accept": "application/json;odata=verbose",
                "content-type": "application/json;odata=verbose"
            },
            success: function (data) {

                var element = document.getElementById("resultsList5");

                $('#resultsList5 > li').remove();

                var jsonObject = JSON.parse(data.body);

                var results = jsonObject.d.query.PrimaryQueryResult.RelevantResults.Table.Rows.results;

                for (var i = 0; i < results.length; i++) {
                    var li = document.createElement("li");

                    li.innerText = results[i].Cells.results[3].Value;

                    element.appendChild(li);
                }
            },
            error: function (data) {
            }
        });

        return false;
    });

Este ejemplo igualmente es similar en cuanto a la forma en la que se representan los datos a los anteriores. La diferencia aquí es que a la petición le estamos indicando las propiedades de los resultados obtenidos por las que queremos poder refinar (Línea 7). Una vez que se obtienen los resultados, se carga uno de los refinadores en un combo preparado para tal efecto (Líneas 22 a 31), este combo se carga automáticamente con los valores de refinamiento obtenidos.

Además se añade otro evento para cuando ese combo cambia, con la selección de un refinamiento, de manera que se haga el filtrado correspondiente. Para ello, solo se añade a la petición el refinementfilters con el contenido a filtrar (Línea 58).

Conclusiones

Trabajar con las búsquedas de SharePoint OnLine y 2013 nos ofrece una gran cantidad de oportunidades a la hora de desarrollar de una forma sencilla, la API REST del servicio de búsqueda es muy potente y merece la pena tenerla en cuenta. En la entrada de hoy, os he introducido al uso de la misma y os he mostrado un ejemplo de cómo usarla en una ejemplo de una aplicación para SharePoint.

Y esto es todo por hoy, espero que os resulte interesante. ¿Cuál es el siguiente paso?, bueno, como sabéis me gusta mucho Polymer, y creo que podría ser interesante crear un componente Polymer que use este servicio de búsqueda de forma completa. Espero en breve compartirlo con vosotros y ponerlo disponible para que lo podáis utilizar.

Un saludo y hasta la próxima

Métodos de extensión en C#. Usándolos en desarrollo para SharePoint

Muy buenas a todos,

Hoy lo que os traigo es más una recopilación de información que una entrada de mi cosecha propiamente, aunque creo que es muy interesante. No pasan días sin que aprendas cosas nuevas. Todo viene de una entrada en el blog de desarrollo de Encamina, el cual os recomiendo que sigáis porque se suelen hacer entradas muy interesantes. En esta semana se ha estado haciendo un recorrido por buenas prácticas a la hora de desarrollar sobre SharePoint y entonces es cuando me topé con los “Métodos de extensión en C#”. Os dejo la entrada en cuestión.

http://blogs.encamina.com/desarrollandosobresharepoint/2015/05/05/como-aprovechar-la-potencia-de-c-en-nuestros-desarrollos/

Me ha llamado la atención el uso de los métodos de extensión de C#. Yo venía desde hace un tiempo usando algunas clases para facilitar determinadas acciones cuando desarrollo sobre SharePoint. Pero me ha resultado muy interesante ver que podemos, por medio de los métodos de extensión, asociarlos al objeto que afectan, de manera que el intellisense de VS lo detecta y además los puedes llamar como si fueran métodos del objeto propiamente dicho, sin tener que crear una clase derivada, ni heredar ni hacer nada con el objeto original. Os pongo un ejemplo de código con algo sencillo:

public static class Helper
{
   public static string MetodoExtensionEjemplo(this string s, string ejemplo)
   {
      //To do something
   }
}

Este método lo podríamos usar ahora de la siguiente forma

string s = "Hello Extension Methods";
s = s.MetodoExtensionEjemplo("hola");

La verdad es que resulta muy cómodo usarlo de esta forma. Como véis la sintaxis para definir este tipo de métodos es muy sencilla y lo vemos en el primer código.

  • La clase a la que pertenezca el método tiene que ser estática, así como el método propiamente dicho
  • El primer parámetro del método es del tipo al que queremos asociarle el método y lleva delante la palabra reservada this.

En mi caso usar esta opción que nos brinda C#, me da como resultado un código más limpio e intuitivo, así que por mi parte, merece la pena tenerlo en cuenta.

Y bueno, como me gusta compartir con la comunidad todo lo que puedo o creo que puede ser interesante, he subido a GitHub las dos clases que estoy usando como Helpers y en las que estoy usando los métodos de extensión. Por si os interesa, veréis que he creado dos clases, una que tiene las acciones “atómicas” (la clase Helpers) y otra que tiene acciones necesarias pero que son un poco “más complejas” (la clase Utility).

https://github.com/jcroav/SPHelpers

Sentíos libres de cogerlas, modificarlas, mejorarlas, proponer cambios, todo lo que suponga mejorar bienvenido sea. Por otro lado, si conocéis otros trabajos similares que se puedan utilizar y estén en fases más avanzadas, estaré encantado de saberlo. Yo de momento he creado los métodos que necesito para mi último proyecto y a medida que vaya necesitando modificar los mismos para añadir funcionalidad o mejoras o añadir nuevos los iré publicando en el repositorio.

Os dejo también el enlace de la MSDN sobre el tema de los métodos de extensión:

https://msdn.microsoft.com/es-es/library/bb383977.aspx

Search Driven Development (IV): Cross-site publishing

Muy buenas a todos,

Tarde de lluvia aquí en Madrid y que mejor que ponerse a escribir en el blog para contar algunas cosas interesantes :). Hace unos meses escribí una serie de artículos en la que hablaba sobre “Search Driven Development”, como configurar nuestros sitios, la navegación basada en metadatos y todos los aspectos necesarios para tener un catálogo y elementos de ese catálogo sin escribir código. Aquí os dejo los enlaces en los que hablaba de todos esos temas.

Primeros Pasos con SharePoint OnLine: Search Driven Development

Search Driven Development en SharePoint (II): Catálogos y Elementos de Catálogo

Search Driven Development (III): El WebPart de Refinamiento

Preparando una ejemplo para una mesa redonda en la que colaboraré con la gente de MadPoint el próximo 7 de Mayo, he decidido retomar el artículo que me faltaba en esta serie y aquí os lo traigo. Me había quedado pendiente montar un entorno de cross-site publishing en el que en un sitio de publicación se publicarán los elementos del catálogo y en un sitio de consumo, se pudieran, usando los webpart de búsqueda, consumir esos elementos, incluyendo URLs amigables y navegación basada en metadatos. Todo esto puede parecer muy complejo, y que necesitará de muchísima configuración, pero ya veréis que es algo muy sencillo. La estructura que queremos conseguir es como la siguiente:

crosssiteschem

Esta característica de cross-site publishing es otra de las nuevas e interesantes funcionalidades que nos ofrece SharePoint 2013. Para conseguir esta configuración, vamos a llevar a cabo una serie de pasos que veremos a continuación, y que podremos aplicar tanto a SharePoint OnLine como SharePoint 2013 en su versión On-Premises. El objetivo de nuestro ejemplo, será crear un sitio de consumo que nos permita organizar una serie de productos de un catálogo en base a categorías y elementos que pertenecen a cada una de dichas categorías, y que dichas categorías sean las que definan la navegación de nuestro sitio, además los elementos serán publicados desde un sitio de publicación.

Creando las colecciones de sitios

El primer paso es crear las colecciones de sitios que vamos a utilizar en el ejemplo. En este caso crearemos dos, una primera de publicación y otra de consumo. Ambas colecciones de sitios las crearé bajo la plantilla de publicación, yo he llamado a una publicador y otro consumidor.

Las colecciones de sitio se crean de forma relativamente distintas si estamos en SharePoint OnLine o SharePoint 2013, yo las he creado en SharePoint OnLine para el ejemplo.

Captura de pantalla 2015-04-26 a las 20.19.13

Creando el almacén de términos

El siguiente paso, es definir el almacén de términos que va a categorizar los elementos que forman parte de nuestro catálogo, para ello accedemos a la administración de nuestro almacén de términos, que como sabéis está disponible tanto desde la administración central (o el panel de administración de SharePoint OnLine) como desde la configuración del sitio, y creamos la estructura, tiene que quedar de una forma similar a la siguiente:

Captura de pantalla 2015-04-26 a las 20.34.23

Configurando el sitio de publicación

Una vez que ya tenemos la categorización que tendrá nuestro catálogo de productos vamos a configurar el sitio de publicación con todos los elementos necesarios. Lo que vamos a hacer en el este sitio es lo siguiente:

  • El primer paso es activar en las “Características de la colección de sitios”, la característica “Publicación de colecciones entre sitios”.
  • Crear cuatro columnas de sitio: Una llamada Resumen de varias líneas de text, otra FechaPublicacion de tipo Fecha, otra llamada Clasificación de tipo metadatos administrados asociada al almacén creado en el apartado anterior y otras llamada autores que será de una línea de texto.
  • Crear un tipo de contenido que herede del Tipo de Contenido Elemento y al que se asocien las cuatro columnas anteriores y que se llamará “Libros”.
  • Crear una lista llamada “Productos”, para la que habilitaremos en la configuración de la misma la Administración de tipos de contenido y le asociaremos el tipo de contenido que acabamos de crear

Con esto ya tendremos preparado nuestro sitio de publicación. Este puede ser el momento para añadir algunos elementos a la lista que hemos creado también.

Creando el catálogo del sitio de publicación

Antes de pasar a la configuración del sitio de consumo, vamos a habilitar la lista para que pueda ser utilizada como catálogo. Para ello, dentro de la lista “Productos” que hemos creado, vamos a Configuración de la lista->Configuración del catálogo, esto nos llevará hasta la página que vemos a continuación.

Captura de pantalla 2015-04-26 a las 21.04.30

Aquí tendremos que indicar varias cosas, por un lado indicar que queremos habilitar esta lista para ser un catálogo, a continuación también indicaremos que columnas de la lista queremos que formen parte de la url del catálogo, y por último el campo, que normalmente se carga automáticamente, que establecerá la jerarquía de navegación. Una vez completados todos los aspectos de configuración, pulsamos en aceptar. Ahora ya podremos pasar a configurar el sitio de consumo. No obstante antes, en el apartado de Configuración Avanzada en la configuración de la lista indicaremos que se vuelva a indexar la lista en el próximo rastreo.

Configurando el sitio de consumo

Para terminar, nos vamos a la colección de sitios que hemos creado para trabajar como consumidor. Para configurar esta colección de sitios nos vamos a la configuración del sitios y entramos en Administrar conexiones del catálogo.

Captura de pantalla 2015-04-26 a las 21.13.46

Cuando entramos en esta opción pulsamos sobre Conectar a un catálogo y después seleccionamos la opción del catálogo que creamos en el sitio de publicación, observaremos que tenemos esa opción disponible.

managercatalog

Si todo lo hemos configurado correctamente, solo tendremos que configurar un aspecto, y es la raíz de la jerarquía de elementos, en donde tendremos que indicar la misma desde nuestro almacén de términos. Tras esto pulsamos sobre Aceptar y automáticamente todo estará funcionando correctamente como vemos en la figura siguiente.

Captura de pantalla 2015-04-26 a las 21.27.38

Como se puede observar automáticamente se ha creado toda la estructura de navegación usando el almacén de términos que habíamos creado. Además si accedemos, vemos que podemos entrar a todos los elementos de cada categoría, o si entramos a alguno de ellos al detalle. Es decir, configurando el catálogo toda la configuración de los webparts de búsqueda y de la navegación basada en metadatos se ha realizado automáticamente.

Captura de pantalla 2015-04-26 a las 21.32.24

Captura de pantalla 2015-04-26 a las 21.32.36

Lo único que faltaría sería usar los Display Templates para dar formato a las visualizaciones de los elementos. Para ello se puede usar lo que ya comenté en la entrada del post sobre ese tema:

Introducción al uso de Display Templates en SharePoint OnLine

Os dejo también un enlace con un tutorial muy detallado y completo sobre cómo configurar una solución Cross-Site Publishing y Search Driven Development.

http://blogs.technet.com/b/tothesharepoint/archive/2013/02/20/stage-1-create-site-collections-for-cross-site-publishing.aspx

Espero que os haya resultado interesante. Como os digo en la mesa redonda del evento que organiza MadPoint el próximo 7 de Mayo, mostraré el ejemplo completo funcionando, donde usaré ya los DisplayTemplates.

Os dejo también el enlace del evento por si alguien se quiere apuntar, se hablará no solo de SSD, sino de todas las formas de extender SharePoint OnLine y On-Premises, creo que va a ser muy interesante.

http://www.madpoint.net/2015/04/22/ciclo-de-mesas-redondas-opciones-de-desarrollo-en-sharepoint-y-office-365/

Un saludo a todos.