A la hora de organizar, yo, personalmente tengo en cuenta dos cosas, que creo son muy importantes, la primera es el tema de la seguridad.

Seguridad

SharePoint cuenta con una serie de roles, grupos y acciones con las que hay que familiarizarse para poder desenvolverse correctamente.

Establecer a que información debe acceder cada cual, que puede ver y que puede editar, nos va a ayudar a tener una idea clara de cómo debemos organizar otras cosas.

Yo primero suelo hacer esto en dos pasos, en un primer paso repaso la información que va a contener la aplicación y los usuarios que van a acceder a ella; establezco una correspondencia creando una serie de grupos de usuarios. En un segundo paso, una vez tenemos clara la estructura que va a tener nuestra aplicación, colecciones de sitios, sitios y subsitios y la información que va a contener cada uno de ellos, vuelvo a ajustar los permisos.

Por ejemplo en el caso que comente anteriormente en donde teníamos el dilema de si establecer la jerarquía por Delegación o por Departamento, si hemos optado por establecerla por Delegación, tenemos que asegurarnos de que el jefe de almacén pueda acceder al departamento de almacén en cualquiera de las delegaciones, pero no podrá entrar en otros departamentos.

Cuando pensemos en la seguridad y los permisos de acceso también hay que tener en cuenta quien administrará los sitios ¿hay un departamento de sistemas encargado de ello? ¿Van a poderse crear nuevos subsitios? ¿Quién se va a encargar de mantener los permisos?

Existe también una jerarquía de permisos, de modo que podemos asignar permisos que se irán heredando en los distintos subsitios. Hay que recordar que los permisos no son como los de NTFS, es decir que no podemos heredar y tener permisos únicos al mismo tiempo, es o una cosa o la otra.

Acceso y Agregación de la información

La segunda cosa que suelo tener en cuenta es donde se va a localizar la información dentro de la aplicación, aspectos a tener en cuenta como el hecho de cómo se quieren agregar los datos y donde van a estar localizados los mismos son de vital importancia.

En MOSS disponemos del “Cotent Query Web Part” que nos va a permitir agregar datos de la misma colección de sitios, pero en WSS debemos hacerlo nosotros mismos, hay que tener en cuenta que información debemos agregar y como deseamos verla, para poder pensar cómo vamos a hacerlo.

Cuestiones que me han preguntado estos días

Bases de datos de Contenido

Como comente anteriormente cada aplicación web al menos contiene una base de datos de contenido, en ella se almacenará la colección de sitios principal y si lo deseamos otras colecciones. También una aplicación web puede tener más de una base de datos de contenido, que contendrán una o más colecciones de sitios, pero una colección de sitios no puede usar más de una base de datos.

Finalmente todo el almacenamiento de SharePoint recae en una base de datos, tenemos que tener en cuenta la capacidad de almacenamiento que esperamos tengan nuestras colecciones de sitios, no es lo mismo una aplicación web pública realizada con las características de CMS, que una intranet en donde vamos a almacenar miles de documentos de office.

Además y como es lógico debemos prever un plan de contingencias y de mantenimiento para nuestras bases de datos, pensad no es lo mismo una base de datos de 50GB que de 500GB, tiempo de respaldo, soportes necesarios, mantenimiento, horarios, etc…

SharePoint nos ofrece distintas posibilidades que veremos a continuación, pero también hay que tener en cuenta algunos factores importantes.

Granjas, Aplicaciones Web, Colecciones de Sitios, Sitios y Subsitios

En primer lugar tenemos que comprender las opciones que nos brinda SharePoint para estructurar nuestra solución.

Debemos de tener claro que todos los datos de SharePoint son almacenados en distintas bases de datos en un servidor de SQL. Con lo cual desde el punto de vista del diseño de aplicaciones de SharePoint, tenemos que contemplar cuando menos un plan de contingencias y de mantenimiento de las bases de datos que conforman nuestra instalación.

Bases de datos de SharePoint 2007

Dicho esto tenemos que entender ahora 5 piezas fundamentales. No quiero extenderme más de lo necesario, a modo de resumen:

Una granja de servidores es un conjunto de servidores que trabajan en unidos, donde podemos dividir distintas responsabilidades entre distintos servidores. Podemos tener una granja de un único servidor donde todos los servicios funcionen sobre una única máquina (servidor web, búsquedas, Excel services, Forms services, SQL Server …) lo más lógico desde el principio es dividir en dos partes la granja, es decir dejar un servidor para el SQL Server y otro con el resto de servicios. Conforme van aumentando los clientes o la demanda de servicios podemos ir añadiendo servidores y establecer las nuevas funcionalidades de las cuales se ocuparan esos servidores, así por ejemplo podemos añadir un nuevo servidor a nuestra granja que se ocupe únicamente del servicio de búsquedas de modo que descargaremos a otros servidores de dicha responsabilidad.
En el caso de una granja pequeña en crecimiento, pongamos por ejemplo 3 servidores, los roles podrían ser los siguientes, servidor de SQL, servidor Web Front End, y un servidor que se ocupara del resto de los servicios, búsquedas, Excel services, Form Services, Shared Services etc…

En el caso de una instalación de Windows SharePoint Services, también es recomendable dividir siempre que sea posible al menos los roles de SQL Server y de Web Front End.

Obviamente todo esto pasa por un estudio de las licencias necesarias, para montar la infraestructura que deseemos, esto lo dejaremos al margen.

Una vez que tenemos clara la estructura de nuestra granja, tenemos todavía una importante labor, establecer cómo será la jerarquía de nuestros sitios.

En la terminología de SharePoint, tenemos otro punto importante, el de la aplicación web. Una aplicación web será el punto raíz de la estructura de una solución, cuando creamos una aplicación web, SharePoint crea un nuevo sitio de IIS en una dirección y un puerto de nuestra máquina, así como una base de datos en donde albergará el contenido de dicha aplicación web.

Una aplicación web, no es más que un vinculo o una dirección y una base de datos de almacenamiento con el objetivo de albergar cuando menos una colección de sitios. Es por esto que una vez creada una aplicación web a través de la administración central de SharePoint, lo siguiente es crear una colección de sitios que quedará enlazada con la raíz de la aplicación web.

Una aplicación web como mínimo contiene una colección de sitios, pudiendo a través de de la administración central fijar un punto de anclaje para nuevas colecciones de sitios.

En una granja de servidores podemos tener distintas aplicaciones web como una intranet, una extranet, o un sitio web publico), ahora bien, aunque podemos usar la misma dirección web, cada aplicación web deberá tener su propio puerto; no podemos tener dos aplicaciones corriendo sobre el mismo puerto.

Una colección de sitios, es como un árbol, del cual pueden colgar sitios y subsitios, una colección de sitios es el inicio de una jerarquía de sitios, y al igual que en árbol una colección de sitios tiene un sitio raíz. Todo esto es importante porque debemos de tener en cuenta diversos factores como veremos luego que afectan en su conjunto a una colección de sitios.

Antes de continuar, terminaré de matizar que es un sitio y que es un subsitio. Un sitio es un apartado o nivel en el cual encontraremos contenido (entender aquí, páginas, listas, bibliotecas de documentos, subsitios, etc…) y un subsitio es un sitio que tiene padre.

La importancia de las colecciones de sitios consiste en que dentro de una colección de sitios existen ciertos elementos y recursos comunes dentro de la colección y este es un aspecto muy importante a la hora de diseñar una solución de SharePoint.

Dentro de esos elementos comunes estan:

-    Flujos de trabajo
-    Tipos de contenido
-    Columnas de sitio
-    Seguridad por grupos
-    Ámbito de búsquedas (WSS)
-    Características (features)
-    Papelera de reciclaje
-    Informes de uso
-    Web Parts
-    Páginas maestras
-    Plantillas de sitios
-    Plantillas de listas
-    Quotas (limites de espacio)
-    Copias de seguridad

Para que quede claro, dentro de una aplicación web como he dicho anteriormente puede haber más de una colección de sitios, pero todos estos elementos son dependientes de la colección de sitios, de modo que en una colección podemos tener una plantilla personalizada para crear listas de tipo “Pedido” pero en la otra colección esta plantilla puede no existir.

Organización

Al igual que las empresas y corporaciones tienen una estructura determinada debemos establecer cómo queremos estructurar nuestras aplicaciones web en SharePoint. Esto aunque puede parecer sencillo, es sin duda una de las cosas más complicadas.

Veamos un pequeño ejemplo, tomemos una organización dedicada a la fabricación de muebles, supongamos que tiene tres fábricas ó delegaciones en Madrid (central), Barcelona y Sevilla. Dentro de cada delegación, hay diversas divisiones  ó departamentos, Almacén, Fabricación, Ventas, Financiero y Postventa.

Podemos hacer una estructura por delegación

-    Madrid

o    Almacén
o    Fabricación
o    Ventas
o    …

-    Barcelona

o    Almacén
o    …

-    Sevilla

o    Almacén

O bien podemos hacerla por departamentos

-    Almacén

o    Madrid
o    Barcelona
o    Sevilla

-    Fabricación

o    Madrid
o    Barcelona
o    Sevilla

-    ….

Aquí empieza el dilema, ¿Cómo estructuramos nuestra aplicación web?.

Cada organización es muy particular, de modo que no existen formulas magistrales. Por proponer un comienzo, deberíamos analizar qué información es la que va almacenar cada sitio y que seguridad ha de tener cada elemento. ¿Los usuarios de Sevilla solo deben ver lo de Sevilla o pueden ver también lo de Barcelona y Madrid? ¿Deben los del departamento de Almacén ver los datos de Ventas? ¿Le interesan al departamento de Posventa los incidentes de las tres delegaciones?

¿Debo crear una colección de sitios por cada delegación? ¿Por cada departamento? ¿Debería una delegación ser un sitio y un departamento un subsitio? ¿Debería ser al revés? ¿Debería tener dos estructuras, por departamento y por delegación? ¿En colecciones de sitios diferentes o en la misma colección?

A la hora de desarrollar una solución debemos tener en cuenta un montón de aspectos, cuestiones como la seguridad, la información y su flujo, las búsquedas y los recursos con los que va a contar son algunas de las más importantes.

Debemos empezar haciendo un análisis muy cuidadoso de todos estos aspectos para no llevarnos sorpresas luego.

FeedBack

Uno de los aspectos que considero más importante es el feedback de los usuarios. Como mencione anteriormente muchos de sus problemas a veces se resuelven con imaginación y creatividad, siempre hay que estar atentos a lo que dicen los usuarios.

Por ello una de las partes principales de un desarrollo en SharePoint, puede comenzar por un simple foro de discusión en donde los usuarios puedan dejar sus opiniones tanto críticas como de mejora.

Evidentemente aquí no hay mucho de diseño, pero esto será un pilar fundamental si se hace un buen uso del mismo.

Para poder categorizar los temas que se tratarán en el foro, a la lista se le puede añadir un tipo de contenido o un campo que contenga los diversos asuntos a los que hace relación un post, así como otro campo que indique si el post es referente a una crítica o a una mejora.

En la mayoría de las organizaciones dinamizar un simple foro como este suele ser un problema si no existe una cultura de colaboración, en ocasiones a la gente le da vergüenza comentar cosas, pensando que lo único que van a decir son estupideces, bien, esto es una labor interna en la que hay que concienciar a la gente (y este es un buen punto de arranque) aludir a que jamás mejoraran las herramientas de las que disponen si ellos no hacen nada por mejorarlas; atacar ese pequeño orgullo que todos tenemos, tocar esa fibra, suele dar un buen resultado.

Esto tiene su contrapartida, si el usuario se expresa y pide cosas hay que dárselas (y rápido) si no toda labor anterior habrá caído en balde. Por parte del departamento de IT, habrá que valorar las peticiones de los usuarios y como mencione (y no dejaré de mencionar en lo sucesivo) deberemos realizar una valoración de dichas mejoras de modo que podamos encontrar quórum para llevarlas a cabo y que encajen en tiempo, coste y complejidad.

Según mi experiencia, el usuario tiende a pedir en ocasiones cosas como ¿no podríamos tener un botón aquí que hiciera tal o cual cosa?, nosotros tenemos que pensar en que es lo que el usuario quiere hacer realmente, ¿Por qué, quiere hacerlo?, ¿Qué ventajas encuentra en ello? Y de qué modo podemos ofrecerle algo que le ayude sin que ello suponga demasiada complejidad; Igual el botón no pude estar allí, pero tal vez podamos poner un hipervínculo aquí para hacer lo mismo o casi lo mismo.

El vocabulario del usuario y el nuestro es distinto, hay que hacer un esfuerzo por entenderle, comprenderle y dar a entender lo que nosotros podemos hacer por él.

Una pequeña encuesta en donde los usuarios voten ó valoren las mejoras, puede ser de gran ayuda a la hora de determinar por dónde empezar, así como de tener una idea de a cuanta gente vamos a contentar y/o enfadar con la realización de los cambios.

Un escenario como este puede complicarse todo lo que uno quiera, pero en la práctica debe ser algo sencillo, empecemos dando algo con lo que todos podamos trabajar, un foro en SharePoint y dos o tres campos personalizados (diseño 0%, evangelización y concienciación sobre el uso 100%) pongámoslo en marcha y escuchemos a nuestros usuarios, ellos tienen cosas importantes que decir.

Vigilancia del Entorno

La rapidez con que una empresa sea capaz de reaccionar a los acontecimientos de su entorno, es una medida de los reflejos corporativos.

Sin duda es una parte muy importante, vigilar nuestro entorno; diseñar un portal de vigilancia del entorno dentro de una empresa es algo que aporta gran valor. Hace algún tiempo ayude a un amigo a realizar un portal de vigilancia del entorno y tuve la oportunidad de aprender algunas cosas importantes.

Gracias a internet tenemos a nuestro alcance una ingente cantidad de datos, muchos de ellos nos pueden ayudar a ver qué es lo que está ocurriendo en nuestro entorno, pero identificar la información que nos es útil entre tantos datos puede ser un problema.

Cuando mi amigo me pidió ayuda él había hecho gran parte del trabajo, el había buscado las fuentes de datos que consideraba más relevantes para el entorno de su empresa, clientes, proveedores, mercado, producto, marketing, competencia, tendencias y noticias del sector, incluso encontró algunos foros donde se mencionaba su empresa, todo ello estaba dentro de un site en donde había usado el web part de transformación de XSLT, para recuperar las feeds que él había considerado importantes y poderlas visualizar en varias páginas en función de las distintas categorías a las que hacían referencia.

El site, era útil, de un plumazo tenia agregadas muchas de las noticias que eran relevantes para la empresa, sin embargo la gran cantidad de noticias apabullaba a los usuarios; la gente entraba veía la ingente cantidad de noticias, leía una o dos y salía.

El site resolvía un problema, pero desde luego no lo hacía de la mejor manera posible, pero había algo por dónde empezar lo cual es como ya hemos comentado, bueno.

Le sugerí, que antes de hacer nada, hablara con los usuarios y les preguntará como se podría mejorar el site de vigilancia, tras unas cuantas sugerencias (feedback) por parte del personal de la empresa, había varios puntos en común, la focalización (o audiencia) de la información y la posibilidad de escalar noticias.

La focalización de la información hace referencia al hecho de donde se debe encontrar la información,  en vez de tener un site en donde concentrar toda la información, los usuarios opinaban que era mejor que cada web de departamento se viese un resumen de esas noticias, de este modo se orienta la información a una audiencia determinada.

En segundo lugar, debería existir un mecanismo de escalar las noticias importantes; cuando se cuenta con mucha información alguien debe poner está en su contexto, y valorarla de manera adecuada. En la empresa de mi amigo fabrican piezas con plásticos inyectados, de modo que la invención de un nuevo compuesto o mecanismo puede parecerle muy importante a la gente de producto pero a alguien de dirección un artículo más bien técnico puede parecerle intrascendente o un autentico coñazo. De modo que la información ha de ser valorada por alguien de las trincheras que la ponga en su contexto y le de la importancia que debe tener y luego la transmita dentro de su contexto al resto de la organización.

Eso dio pie a la creación de un site DAFO, (Debilidades, Amenazas, Fortalezas y Oportunidades).

Se hicieron los cambios necesarios para que cada departamento visualizara la información pertinente a su área, y como complemento de esa información con un simple click se podía llevar la información del agregador de noticias al sistema DAFO, con eso la noticia podía crear una alerta en el sistema, periódicamente se examina el site DAFO y se toman decisiones en función del contenido.

En un primer momento el sistema funcionaba de manera manual, es decir junto a cada noticia existía un enlace a la web DAFO, en donde el usuario debía crear un breve resumen de la noticia, el tipo de alerta Debilidad, Amenaza, Fortaleza o Oportunidad y un comentario personal de ¿Por qué? Se contempla la noticia como una alerta.

La gerencia de la empresa usa la web de DAFO de forma periódica en una reunión quincenal de seguimiento de diversos asuntos, se analizan todas las alertas y se hace un pequeño acta que se deja en ese mismo sitio.

Más adelante cuando el sistema demostró su utilidad, se mejoró sustancialmente incluyendo algo de programación y ahora permite que tras valorar la noticia, esta incluya un enlace a la fuente original, también el site DAFO cuenta ahora con una serie de gráficos y resúmenes quincenales de las alertas que se han producido así como una lista por cada departamento que permite introducir las fuentes desde donde cada departamento va a recibir las noticias así como los filtros que ha de pasar el contenido para ser agregado; de este modo se su pueden añadir y suprimir fuentes y filtros sin necesidad de programar absolutamente nada.

Sin embargo a la hora de diseñar estas soluciones no todo es tan sencillo, con esto me estoy refiriendo al hecho de que nos encontramos en innumerables ocasiones con problemáticas empresariales que no son excesivamente complejas pero que sin embargo a la hora de trasladarlas a SharePoint, se convierten en un verdadero infierno.

Durante estos años que llevo trabajando con SharePoint, me he encontrado con multitud de casos en los que cosas que parecían relativamente sencillas por que el 80% del trabajo ya estaba hecho, funcionalidades que de por sí contempla SharePoint el 20% restante ha supuesto una cantidad de trabajo terrible. Donde ese 20% has supuesto una cantidad de tiempo y un coste tan elevado que es casi imposible de justificar.

Vamos a dejar al margen las ocasiones en que el diseño de una solución debe ser estrictamente fiel a un procedimiento empresarial, y debe reflejar de manera completa y exacta dicho procedimiento; en este punto la postura es clara; tendremos que hacer lo que sea para que la solución cumpla al 100% los requerimientos del procedimiento.

En el resto de ocasiones, tenemos la disyuntiva de hasta qué punto debemos ser flexibles en el desarrollo de la solución. Según mi experiencia debemos ser flexibles y agiles.

Muchos de estos procesos requieren que seamos agiles, no podemos esperar meses a tener una herramienta para poder gestionar eficazmente. A esto debemos añadir el hecho de que muchos de estos procesos están vivos, es decir se empieza haciendo cosas de una manera, y tras evaluaciones sucesivas del procedimiento así como de la experiencia que se va adquiriendo del uso del mismo, se va optimizando, suprimimos, añadimos y cambiamos pasos, información y flujos de la información.

Tenemos que contemplar el diseño como una negociación Win-to-Win, en donde todos ganamos por una parte tendremos que adaptar los requisitos o los procedimientos para que estos sin perder en esencia su objetivo sean los menores para no tener que realizar complejos sistemas para sustentarlos. De esta manera y solo de esta manera seremos capaces de diseñar sistemas cuyo ROI, sea positivo desde el comienzo.

En esta negociación, se deben poner sobre la mesa los requerimientos y los recursos de que disponemos para trasladar estos a la plataforma.

Un sencillo ejercicio de ponderación, donde valoramos los requisitos de modo que los que más valor aportan tendrán una puntuación más elevada y los que menos valor aportan una puntuación inferior y del mismo modo, evaluamos la complejidad que entrama desarrollar cada una de las partes del sistema, valorando en términos de tiempo, coste y complejidad cada uno de los pasos necesarios para cumplimentar dichos requisitos.

A través de un ejercicio de esta índole, debemos suprimir todo aquello que en esencia sea superfluo y buscar alternativas a aquellas partes del sistema que por su tiempo, coste o complejidad vayan a ser cuellos de botella tanto en el uso como en el desarrollo de las mismas.

Otro punto importante, es el de la rapidez; cuanto antes demos a nuestros usuarios una herramienta y algo básico con lo que trabajar empezaremos a recibir feedback que deberemos tener en cuenta, muchas de las propuestas del usuario final son imaginativas y creativas (y generalmente más baratas).

En muchas ocasiones esto conlleva exprimir lo que tenemos al máximo, más adelante siempre tendremos oportunidades de realizar esas complejas partes que harán de nuestra solución una solución perfecta.

En próximos posts me gustaría comentar algunas experiencias tanto mías como de algunos colegas sobre el diseño de soluciones con SharePoint.

Cualquier comentario o aportación será bienvenido.

   1:              try

   2:              {

   3:                  var parser = new NParser(textTSql, new ASTNodeCAMLFactory());

   4:                  var generator = new CodeGenerator(parser.Parse());

   5:                  generator.Generate();

   6:                  return _formatTools.FormatXml(generator.Code);

   7:              }

   8:              catch (ParserException ex)

   9:              {

  10:                  _view.Status = ex.Message;

  11:              }

  12:              catch (ScannerException ex)

  13:              {

  14:                  _view.Status = ex.Message;

  15:              }

Instanciamos el Parser (NParser), le pasamos la consulta en TSQL (textSql) y la factoría correspondiente a lo que queremos generar, por el momento solo está disponible la de CAML, en breve completaré la de CAML.Net; Por último inyectamos el Parser en el Generador de código, llamamos al método Generate y recogemos la consulta en CAML en generator.Code.

Las posibles excepciones tanto del Parser como del generador de código se pueden atrapar con ParserException y ScannerException.

En el proyecto se incluye un pequeño subproyecto con una interfaz WinForms (no es que se me de especialmente bien)

Parte 2 http://www.ideseg.com/YACAMLQTYetAnotherCAMLQueryToolRedux2.aspx
Parte 1 http://www.ideseg.com/YACAMLQTYetAnotherCAMLQueryToolRedux1.aspx

Habíamos visto la parte relacionada con el Lexer el analizador morfológico. Como es obvio detrás debe haber un analizador sintáctico y semántico el Parser.

El analizador sintáctico y semántico (NParser) se ha implementado siguiendo el patrón interpeter, (seguramente sea uno de los que menos se ven), el objetivo es obtener los distintos Tokens desde el Scanner y montar un árbol sintáctico (AST) este árbol contiene Nodos (ASTNodeBase) y estos nodos representan de manera abstracta y simplificada la estructura sintáctica de la consulta en SQL.

(diagrama NParser)

A la clase NParser se le puede inyectar una factoria (ASTNodeFactoryBase) en función del código que queramos generar, por el momento solo esta implementado el CAML, pero se puede extender sencillamente para generar CAML.Net.

Partiendo de un nodo abstracto (ASTNodeBase) podemos definir las distintas unidades sintácticas, por medio de la herencia. Estos nodos abstractos (heredados de ASTNodeBase ) conforman las distintas expresiones que se usan en el analizador sintáctico y semántico (NParser), para ello se ha definido una clase para cada uno de los Tokens a modo de plantilla (template),  y estas clases son a su vez son las distintas expresiones abstractas, que se usan en  el patrón interpreter implementado en el parser. (NParser).

Todos estos nodos que forman las expresiones abstractas al fin al cabo son plantillas (templates), y podrían a su vez ser clases abstractas, yo opte por una implementarlas como clases normales. Ya que algunos de los nodos son terminales y otros intermedios y no tienen por qué ser heredados, de este modo la factoria base (ASTNodeFactoryBase) usa miembros virtuales parar crear dichos nodos.

(diagrama parcial de ASTNodeBase)

Para crear todos estas expresiones abstractas existe una factoría abstracta (ASTNodeFactoryBase ) a través de la cual creamos los distintos nodos. Como puede verse, para añadir una variante como CAML.Net, solamente hay que añadir las expresiones abstractas heredando de las ya existentes e implementando PreCode() y PostCode().

Todos estos nodos que forman las expresiones abstractas al fin al cabo son plantillas (templates), y podrían a su vez ser clases abstractas, yo opte por una implementarlas como clases normales, debido a que algunos de los nodos son terminales y otros intermedios y no tienen por qué ser heredados, de este modo la factoria base (ASTNodeFactoryBase) usa miembros virtuales parar crear dichos nodos terminales e intermedios.

Después para poder inyectar en el parser dichas expresiones debemos crear una nueva factoría heredada de la factoría base (ASTNodeFactoryBase).

(diagrama ASTNodeFactoryBase)

Para generar CAML lo que he hecho es heredar de cada plantilla ó expresión abstracta definida, una nueva clase que redefine los métodos virtuales PreCode() y PostCode() que son los encargados de sustituir cada nodo del árbol sintáctico en CAML.

Y crear una factoría (ASTNodeCAMLFactory) que se encarga de crear las expresiones.

YACAMLQT, es una utilidad que convierte una sentencia SQL en CAML, el lenguaje de consulta de Sharepoint. (Véase YACAMLQT, YACAMLQT2 y YACAMLQT-CAML.Net)

Estos días entre rato bueno y rato malo, he reescrito totalmente el código de YACAMLQT, para hacerlo más sencillo (por supuesto usando TDD), en principio el objetivo ha sido emular el antiguo YACAMLQT, pero dotándolo de un diseño más sencillo y ampliable.

YACAMLQT, es un programa que convierte una sintaxis tipo SQL en CAML (el lenguaje de consulta de SharePoint).

Es decir esto:

WHERE ((Column1 = “Value1″) AND (Column2 = “Value2″)) OR ((Column3 = 10)
AND (Column3 <> NULL)) GROUPBY Column1 ORDERBY Column1, Column2 ASC, Column3 DESC

En esto:

<Query>

  <Where>

    <Or>

      <And>

        <Eq>

          <FieldRef Name="Column1" />

          <Value Type="Text">Value1</Value>

        </Eq>

        <Eq>

          <FieldRef Name="Column2" />

          <Value Type="Text">Value2</Value>

        </Eq>

      </And>

      <And>

        <Eq>

          <FieldRef Name="Column3" />

          <Value Type="Integer">10</Value>

        </Eq>

        <IsNotNull>

          <FieldRef Name="Column3" />

        </IsNotNull>

      </And>

    </Or>

  </Where>

  <GroupBy>

    <FieldRef Name="Column1" />

  </GroupBy>

  <OrderBy>

    <FieldRef Name="Column1" />

    <FieldRef Name="Column2" Ascending="True" />

    <FieldRef Name="Column3" Ascending="False" />

  </OrderBy>

</Query>

El proyecto completo lo subiré a CodePlex en unos días, con su código fuente que poco a poco y con ayuda espero ir ampliando.

Por si alguien quiere echar una mano en el proyecto, voy a contar alguno de los entresijos del diseño de la aplicación.

Lo primero que he diseñado es el analizador morfológico (lexer) que se encarga de identificar dentro de un string, las distintas unidades sintácticas (tokens) con las que construiremos un analizador sintáctico y semántico (parser) con el cual construiremos un árbol sintáctico (AST) que por último recorreremos para transformar el SQL en CAML u otra variante como CAML.Net.

El lexer, está compuesto por una clase base, ScannerBase que contiene las partes más básicas del lexer, he extraído esta clase base una vez que tenía el analizador morfológico completo ya que de esta manera podemos realizar otro tipo de analizadores.

Las funciones básicas como comerse los espacios (EatSpaces()), detectar si es el final de línea (EndOfLine()) , saltar caracteres (SkipChar()) son parte de ScannerBase. Lo más importante de esta clase es la propiedad CurrentChar que devuelve el último carácter leído y el método GetCharMoveNext(), que obtiene un carácter y se mueve a la siguiente posición.

Para los que habéis usado el unix flex, GetCharMoveNext() es similar a input().

Esta clase ScannerBase utiliza internamente una clase ScannerState que mantiene el estado para poder releer un token ó unidad sintáctica.

Los tokens en el caso de YACAMLQT, consisten en las palabras reservadas propias de SQL, así como los distintos operadores, los campos y los valores (cadena, fecha, lógico y numérico).

A diferencia del unix flex, esto no se trata de un unput(), ya que mediante este volveríamos al carácter anterior. En este caso, como lo importante del analizador es obtener una unidad sintáctica, o token, lo que he hecho es implementar un método llamado BackToken() que lo que hace es posicionar el lexer justo al comienzo del último token obtenido, de modo que GetToken() volverá a devolvernos el mismo token.

La clase Scanner, hereda como es de suponer de ScannerBase, e implementa GetToken(), el responsable de de devolver un token, y CheckCorrectBracketsAndQuotes() que es el responsable de comprobar que los paréntesis y las comillas están correctamente.

Dentro de la clase Scanner, el método GetToken() es el responsable de identificar cada uno de los tokens, para lo cual he realizado un método para identificar cada uno de los distintos tokens. GetToken() usa los métodos ScanDate(), ScanString(), ScanOperator(), ScanNumber() y ScanReservedWordOrSymbol().

ScanOperator() y ScanReservedWordOrSymbol() usan un diccionario para identificar los distintos operadores y palabras reservadas. En el caso de ScanReservedWordOrSymbol(), si el token leído no se encuentra en el diccionario de palabras reservadas estaremos identificando un símbolo ó identificador.

Para terminar con esta primera parte, y siguiendo el principio de responsabilidad única, se ha implementado la clase Token como un contenedor y TokenFactory como una factória encargada de crear los distintos tipos de tokens ó unidades sintácticas. La clase Scanner es la que usa la factória para crear los distintos Tokens.

La clase Token, puede contener los distintos tipos de tokens, en principio todos aunque pueden ser de diferentes tipos, mantendrán su valor como un string. El resto de propiedades para identificar el tipo de token (TType) ó el tipo de valor (ValueType) son una enumeración.

Testing es algo que todos los desarrolladores deberíamos hacer, y muy pocos hacen. Por no decir “Testing intensivo y consecuente”, pues los números se reducen a prácticamente cero… si le da curiosidad, revise las estadísticas mostradas en:

• http://www.methodsandtools.com/dynpoll/oldpoll.php?UnitTest2


• http://blog.davebouwman.net/2008/06/04/DeveloperSurveyUnitTestingAmpOtherTools.aspx


• http://telerikwatch.com/2008/05/survey-says-unit-testing-still-not.html.

Especialmente el segundo vinculo es interesante, aunque por experiencia propia me arriesgaría a decir que los porcentajes de aplicación de testeo son mucho, mucho mas bajos.

Siendo sincero, escribir software es una de las cosas más divertidas para hacer en el mundo (lo digo por deformación profesional, probablemente), pero hacer pruebas para ese mismo software es una de las más aburridas. Y en algunos casos, es simplemente imposible, como lo es hacer pruebas para SharePoint.

Pero para comenzar por el principio, hay que hablar algo sobre testing en general.

El mundo del testing es amplio y ajeno: hay tantos tipos de testeo como tipos de desarrolladores… pero mirándolo desde una perspectiva global, podemos decir que hay:

- “Unit Test” (Prueba unitaria) – verifica que las unidades individuales de código fuente funcionan como se espera. Normalmente la unidad de código más pequeña es una función, método o propiedad.
- “Regression Test” (Pruebas de regresión) – Cuando se modifica algo que ya ha sido probado que funciona (con el Unit Test), es necesario garantizar que sigue funcionando apropiadamente después de algún tiempo: este es el trabajo de Regression Test
- “Integration Test” (Pruebas de Integración) – Cuando todas las unidades (que ya han sido probadas con Unit y Regression Test) se unen para trabajar conjuntamente, es necesario garantizar que todas funcionen como una unidad apropiadamente. Este es el trabajo del Integration Test
- “System Integration Test” (Pruebas de Integración de sistemas) – puede ser visto como una ampliación del anterior: este test garantiza que nuestro sistema (que ya ha sido probado con Unit, Regression e Integration Tests) puede funcionar con otros sistemas externos apropiadamente

En cuanto a metodologías, mis dos hermanas sicólogas me enseñaron que hay tres tipos de pruebas: Black Box, White Box y Grey Box testing (el modelo ha sido tomado “prestado” de la psicología).

- “Black Box Testing” – la prueba no sabe nada sobre cómo funciona internamente el sistema a probar… solamente que si se le entregan algunos parámetros de entrada, deben salir algunos resultados. Black Box Testing le entrega parámetros a una función (correctos e incorrectos) y observa los resultados que la función devuelve
- “White Box Testing” – por el contrario, la prueba conoce perfectamente el funcionamiento interno del sistema a probar, y crea las pruebas basado en el.
- “Grey Box Testing” – ya se imaginaran lo que es, una mezcla de los dos.

Finalmente, es necesario hablar de algo que está de moda, “Test-driven development” (TDD). Esta es una técnica de programación basada en escenarios de prueba o de funcionamiento (Test o User Cases), bastante ligada a metodologías de desarrollo como Agiles, que indica que primero hay que hacer el diseño del software (sus clases, métodos, propiedades y eventos), luego generar las definiciones (el “esqueleto” del código), luego crear los métodos de prueba ANTES que el código mismo, y finalmente, crear el código para rellenar el esqueleto.

Bien, esto es más o menos la parte teórica. Como los desarrolladores de código que somos, ¿Qué es lo importante de todo esto?

1. Primero que todo, y antes que nada, Unit Test. Unit Test me permite dormir tranquilo, pues me asegura que mi código funciona correctamente y seguirá funcionando después de que lo he modificado (¿se puede usar Unit Test como Regression Test? Esta es una discusión bizantina a la que nunca nadie llega a una conclusión, algo por el estilo a que es mejor CSharp o Visual Basic, o Windows o Linux. Vea por la ejemplo la discusión que surgió en el ultimo PDC al respecto en http://channel9.msdn.com/pdc2008/TL61/).


2. Como segunda medida, si se está usando (o se quiere usar) TDD, la decisión de usar Black o White Test es importante… o, mejor dicho, si se quiere usar TDD, hay que usar Black Box Testing. Punto. O hay que iniciar una nueva discusión bizantina sobre si es posible iniciar el desarrollo en Black Box y luego continuarlo en White Box, lo que lleva al modelo de Grey Box…

Noten que hasta ahora he intentado no tomar partido por ninguno de los puntos mencionados. Todo porque mi punto es SharePoint, no discusiones teológicas sobre cómo, cuando y donde hacer testeo de software. Pero llegamos a la parte interesante: SharePoint.

Cuando se trata de crear Testeo Unitario para software creado por uno mismo, es decir, en donde se tiene el código fuente, construir las clases de prueba es largo y tedioso, pero es posible de hacer con las herramientas estándar para el efecto (como las que tiene Visual Studio mismo, por ejemplo). Cuando lo que se desea es testear código que utiliza el Modelo de Objetos de otro programa, como ocurre cuando se escribe software para SharePoint o cualquier otro servidor (SQL, Exchange, BizTalk, etc), es necesario “hacerle creer” a nuestro código que esta interactuando con el servidor, pero sin que lo haga en realidad, porque no se desean tener dependencias con él.

Imagínese una situación no tan hipotética: se crea un método que comprueba los derechos de una Librería de SharePoint; si se utiliza una instalación real de SharePoint para hacer las pruebas, es necesario mantener esa configuración por todo el tiempo del desarrollo y mas allá para garantizar que los resultados de las pruebas sean consistentes en el tiempo. Peor aún, todos los desarrolladores del grupo tienen que disponer de la misma instalación para que sus pruebas también sean consistentes entre desarrolladores. Esto es prácticamente imposible de conseguir y, además, muy engorroso. Para solucionar el problema existen diferentes tipos de herramientas que “falsifican” el Modelo de Objetos del servidor (Mockers, Stubbers, etc)

Como ya hemos dicho varias veces Carlos y yo, el problema con SharePoint y Unit Test es que el Modelo de Objetos de SharePoint tiene muchas clases selladas o sin constructor público. Este ha sido el gran problema hasta ahora para poder usar Mockers y Stubbers, pues ellos no saben qué hacer con un objeto sellado o sin constructor público. El posting “Testeo Unitario para SharePoint: acercándose a la respuesta definitiva – parte 1” que escribimos anteriormente comenzó a mostrar cómo se puede iniciar el testeo unitario para SharePoint usando la última versión de TypeMock. Las próximas partes continuaran con la parte práctica de la creación y codificación de las clases de prueba. Pero en esta segunda parte se trata de discutir la importancia de Unit Test, Regression Test, Black y White Box Testing y TDD.

Uno de las características más importantes de TypeMock es la relación intrínseca entre el código de trabajo y el código de testeo, es decir, el fabricante ha escogido por un modelo de “White Box Testing”. Veamos un ejemplo el ejemplo de una función que simplemente imprime los elementos de una Lista de SharePoint:

Código de trabajo:

        public void GetCollection01()

        {

            SPSite mySite = new SPSite(“http://wsses”);

            using (SPWeb myWeb = mySite.OpenWeb())

            {

                foreach (SPList myList in myWeb.Lists)

                {

                    foreach (SPItem myItem in myList.Items)

                    {

                        Console.WriteLine(mySite.Url + ” – “ + myWeb.Title + ” – “ + myList.Title + ” – “ + myItem.ID.ToString());

                    }

                }

            }

        }

        [TestMethod()]

        public void GetCollection01Test()

        {

            SPWeb fakeWeb = Isolate.Fake.Instance<SPWeb>(Members.ReturnRecursiveFakes);

            SPList fakeList = Isolate.Fake.Instance<SPList>(Members.ReturnRecursiveFakes);

            SPItem fakeItem01 = Isolate.Fake.Instance<SPItem>(Members.ReturnRecursiveFakes);

            using (var recorder = RecorderManager.StartRecording())

            {

                SPSite myFakeSite = new SPSite(“”);

                recorder.ExpectAndReturn(myFakeSite.Url, “fakeSiteUrl”).RepeatAlways();

                recorder.ExpectAndReturn(myFakeSite.OpenWeb(), fakeWeb);

            }
            Isolate.WhenCalled(() => fakeWeb.Title).WillReturn(“fakeWeb”);

            Isolate.WhenCalled(() => fakeWeb.Lists[2].Title).WillReturn(“fakeList”);

            Isolate.WhenCalled(() => fakeItem01.ID).WillReturn(1);
            Isolate.WhenCalled(() => fakeWeb.Lists[2].Items).WillReturnCollectionValuesOf(new List<SPItem>

               {

                    fakeItem01

               });
            Class1 target = new Class1();

            target.GetCollection01();
            var fakeItemList = fakeWeb.Lists[2].Items;
            foreach (SPItem item in fakeItemList)

            {

                Isolate.Verify.WasCalledWithAnyArguments(() => item.ID);

            }

        }

Para la prueba unitaria se está usando una combinación de “Natural Mocks” y el nuevo “AAA API” de TypeMocks. Observe un par de puntos específicos:

• Cada objeto “real” necesita un objeto “mockeado”: myWeb -> fakeWeb, myList -> fakeList, etc


• Para cinco líneas de código de trabajo se necesitan 17 líneas de código de prueba

Esto conlleva las siguientes consecuencias generales:

Para poder crear un objeto “fantasma” (un mock) que sustituya efectivamente al objeto “real” en la clase de trabajo, es necesario conocer explícitamente su construcción. Esto excluye directamente la utilización de TDD: código de prueba debe ser escrito antes del código de trabajo

• Una consecuencia de esta consecuencia es que el código unitario deberá ser escrito por el desarrollador mismo que está escribiendo el código de trabajo: al final, es él/ella el que sabe que está haciendo. El peligro con esta construcción es que se van a escribir clases de prueba que casi siempre van a pasar el examen… voluntaria o involuntariamente, el desarrollador va a omitir las pruebas que tienen más posibilidades de fallar


• Una segunda consecuencia de esta consecuencia es que el desarrollador probablemente utilizara más tiempo creando las clases de prueba que las clases de trabajo


• Por la relación tan estrecha entre código de trabajo y de prueba, cuando se modifica algo en el código de trabajo, hay que modificar también el código de prueba. Es decir, Regression Test es imposible de realizar

El fabricante de TypeMocks está trabajando intensivamente para darle solución a estos problemas, y los primeros resultados van saliendo: ciertas partes del Framework de TypeMocks es capaz de crear mocks para trabajar con Black Box Testing, es decir, entregando un objeto “mockeado” al método de trabajo y revisando los resultados producidos, sin tener conocimientos de su funcionamiento interno.

En cualquier caso, la discusión de si testeo blanco o negro es el mejor, o si Test-Driven Development es realmente valido continuaran hasta el fin de los siglos. Lo importante para nosotros, los que estamos metidos en el lio de hacer que código funcione apropiadamente no son las discusiones teóricas, sino los Frameworks que nos permitan trabajar confortablemente. TypeMocks es hasta el momento lo que más se acerca a una solución viable para hacer testeo de código de SharePoint, así que vale más que la pena de darle por lo menos una mirada e intentar hacerlo funcionar.

El próximo día 18 de diciembre tendremos en el Grupo de Usuarios de Navarra la charla (de los huevos y de los CKarlos), Karlos G. Liberal y un servidor hablaremos de algunas de las bondades de nuestras herramientas de trabajo (Drupal y SharePoint).

El magnifico cartel ha sido realizado por nuestros amigos de Sistema Formación.

La Agenda del evento es la siguiente:

La jornada será el jueves, 18 de diciembre
Hora de recepción: 18:00

Centros de Excelencia Software
Salón de actos
Plaza Cein, 1, Polígono Mocholi
Noáin Navarra 31110
España

AGENDA
18:30 – 19:30: Drupal and SharePoint. Dos formas de hacer una tortilla. Los CKarlos.
19:30 – 20:00: Celebración 2º aniversario de NavarraDotNet: zorionak zuri y tarta de cumpleaños
20:00 – 21:00: Drupal and SharePoint. Dos formas de hacer una tortilla. Los CKarlos
21:00 – … : Cena!

Para apuntarse podéis hacerlos desde este enlace*
http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032393640&Culture=es-ES

Cenando

El otro día paso Unai por Pamplona y estuvimos cenando y departiendo sobre todas esas cosas frikis que nos gustan. Una suerte para los que habéis podido asistir a los cursos que ha impartido de Entity Framework  y WCF.

Durante la cena, [[degustábamos unos “Penne Arrabiata” (no seáis mal pensados, que son macarrones con tomate un poco picante) y un “Ochoa Tempranillo” (recomendado)]], hablamos de; libros, de código, de más código, de bugs, de depuración, de tecnología, del bien y del mal (lo típico), no sé si ayer hablamos de sexo (no me acuerdo, pero con el frio que hacía es posible que no .

Bueno, la cosa es que le comenté algunas de las cositas del Api de SharePoint.

¿Buenas Prácticas?

Como ya he contado en alguna ocasión, las colecciones de SharePoint, son a la antigua usanza (Net 1.0), es decir que implementan IEnumerable, en una clase contenida, esto lo hacen en una clase abstracta SPBaseCollection del cual heredan el resto de colecciones de SP.

Bien, hasta el momento no hay mucho problema, es un tema de diseño, necesario para implementar las serializaciones de los objetos además de la persistencia que realiza sharepoint via COM.

Si realicemos una consulta usando SPQuery, (SPQuery nos permite recuperar elementos de una lista usando CAML, que es un meta-lenguaje basado en XML que tiene SharePoint para muchas cosas, entre ellas recuperar elementos de las listas)

<Where>

  <Geq>

    <FieldRef Name=”ID” />

    <Value Type=”Integer”>10</Value>

  </Geq>

</Where>

SPQuery query = new SPQuery

                {

                   Query = “CONSULTITA EN CAML”

                };

SPListItemCollection ítems = lista.GetItems(query);

public SPListItemCollection GetItems(SPQuery query)

{

    return new SPListItemCollection(this, query);

}

Pero qué pasa si la consulta está mal formada ó es incompleta.  Lo que cabe de esperar es:

1.- Que nos devuelva una excepción en el momento de crear SPQuery (cosa que no hace)
2.- Que nos ofrezca una propiedad o algo para comprobar si la consulta es correcta (cosa que no hace)
3.- Que nos devuelva una colección vacía (cosa que hace peligrosamente a medias)

¿Por qué lo hace a medias? Porque aparentemente nos devuelve una colección vacía, es decir si la consulta está mal, ítems no es null. Pero OJO no es una colección valida.

SPQuery query = new SPQuery

                {

                        Query = “MI mala CAML Query”

                };

SPListItemCollection items = list.GetItems(query);
if (items!= null)

{

    Debug.WriteLine(“Soy una colección no nula. Parece que valgo…”);
    // Ahora reviento

    foreach (SPListItem item in items)

    {

    }

}

Las colecciones de este tipo en SharePoint, son de carga retardada de modo que la colección se carga cuando realmente vamos a usarla (Lazy-Load / Proxy), en ese momento se hace una petición SPRequest que es al que se encarga de recuperar el contenido y obtener la colección de elementos. (fundamento)

En ese momento se usa la consulta SPQuery que le hemos pasado para recuperar los datos, y al tratar de cargarla, como la consulta está mal formada, da una excepción (no advertida ni documentada), y la colección sigue siendo una colección hasta que usemos alguna de sus propiedades o tratemos de recorrerla. Es decir no es una colección vacia, si no una colección donde todo se ha quedado mal inicializado si intentas un items.Count antes de recorrer la colección tambien dará una excepción ya esta va a producirse de igual manera al cargar los datos.

De modo que la buena práctica se convierte en mala práctica ya que se pasa de hacer una comprobación de null antes, a tener que hacer un Try/Catch en el momento de recorrer la colección (como decimos por aquí, cojonudo).

Como alternativa, se puede implementar un método por ejemplo, vía extensión;  para comprobar que la consulta es valida y en caso de no serla que nos devuelva una colección bien formada cuando menos. Otra alternativa podría ser otro método como EnsureCollection, a través del cual podamos recuperar la excepción si nos interesa comunicar que la consulta esta mál formada.

La cosa sería algo así:

public static SPListItemCollection TryGetItems(this SPList list, SPQuery query)

{

    SPListItemCollection items; 

    try

    {

        items = list.GetItems(query);

        int count = items.Count;

    }

    catch(SPException ex)

    {

        query.Query = string.Empty;

        items = list.GetItems(query);

    }
    return items;

}

JA, pero ahí no termina la cosa …  los señores de SharePoint son unos fenómenos optimizando y lo que hacen SPQuery internamente es generar una Vista (propiedad ViewXml de SPQuery), para optimizar el rendimiento, esta vista en Xml, se genera reuniendo todas las propiedades de SPQuery, y se genera siempre y cuando no se ha generado antes (optimización)

De modo, que si cambiamos la propiedad Query de SPQuery, la consulta interna ViewXml no cambia (ya se genero antes), manteniendo la última consulta generada, para lo cual debemos limpiar ViewXml.

query.Query = string.Empty;

query.ViewXml = string.Empty;

items = list.GetItems(query); 

¿Por qué que les habría costado implementar un flag de suciedad y reconstruir la ViewXml cada vez que el objeto este sucio? ¿por qué no documentarlo?

En fin, la cena estuvo genial.