WSS 3.0 & MOSS: Recopilación de enlaces interesantes (IV)

Siguiendo con la recopilación periódica de recursos sobre WSS 3.0 & MOSS, esta semana en el número IV destacamos los siguientes recursos:

Documentación


  • Aunque son de hace tiempo, aquí tenéis algunas presentaciones sobre desarrollo en WSS 3.0 que dio Patrick Tisseghem en Orlando.

  • Quixk reference de ID’s de los content types usados en WCM. Fuente: Blog de Robert Bogue.

  • Completísima referencia de los comandos de la herramienta de administración stsadm.

  • En la misma línea del vínculo anterior, en este link tenéis una referencia completa de todos los ID’s usados en los content types de WCM.

  • Seguro que una cuestión que os ha surgido es respecto a cómo desarrollar contra WSS 3.0 & MOSS. Pues bien, hay dos escenarios posibles: Local vs Remoto.

Recopilatorio_WSS_Y_MOSS_VII_1



Artículos Interesantes


MatrizDecision_MOSS_UIS_PostRecopilatorio9_WSS3



  • Artículo sobre personalización de estilos en WSS 3.0. Otro post en esta línea lo podéis encontrar aquí, en este caso se enumeran las tres áreas principales de personalización en WSS 3.0:


    • Master Page y Page Layouts.

    • Hojas de estilos CSS.

    • Los archivos xsl ItemStyle.xsl, Header.xsl y ContentQuery.xsl. Si bien estos archives y su gestión sólo los tenemos para sitios de publicación.

PostRecopilatorio_9_ItemStyles



Recursos


Recopilatorio_WSS_Y_MOSS_VIII_2



PostRecopilatorio_9_Matriz_Riesgos_Proyectos_WSS3.0


Tips & Tricks


Documentación Funcional de la Plataforma


Novedades y Otros:


  • Jesús Rodríguez nos adelanta en su blog lo que van a ser sus próximos post relacionados con el BDC de MOSS y la integración con WCF y el nuevo set de adaptadores WCF. Por lo que se comenta en este post, han construido un demostrador en el que el BDC de MOSS se alimenta de CRM Live, SAP y una BD de Oracle utilizando este nuevo set de adaptadores de WCF. Habrá que estar atentos a los posts prometidos.

  • Microsoft Office Interactive Developer Map: Aplicación WPF chulísima que muestra las herramientas, servicios,s ervidores, etc para desarrollar en la plataforma Office en un mapa con sus correspondientes enlaces a MSDN y efectos WPF para expandir contenidos.

Recopilatorio_WSS_Y_MOSS_VIII_3



Y hasta aqui ha llegado el cuarto capítulo de la serie de posts recopilatorios de WSS 3.0 & MOSS. Como siempre, espero que los recursos os sirvan de ayuda para las distintas batallas de WSS 3.0 & MOSS en las que estéis metidos.

WSS 3.0 & MOSS: Atacando los servicios web !

Estos días en el CIIN estamos preparando un curso de desarrollo en WSS 3.0 (Ángel y yo), y uno de los puntos que se tratará (de los muchos que hemos incluido, porque se pueden hacer muchas cosas como podéis comprobar en el Microsoft Office Interactive Developer Map) es como acceder a dato de una lista de WSS 3.0 de manera remota a través de la llamada a los servicios web de WSS 3.0 y como los datos que leamos los podemos volcar de manera remota en otra lista.

Recopilatorio_WSS_Y_MOSS_VIII_3


Este post extiende a otro previo en el que explicábamos como copiar datos entre listas de WSS 3.0 utilizando el modelo de objetos (OM) de WSS 3.0. Ahora bien, este ejemplo es válido siempre que las listas estén en el mismo servidor de WSS 3.0, es decir, en el mismo contexto. Sin embargo, el OM no es aplicable en el caso en el que queramos acceder de manera remota a datos de un servidor WSS 3.0. Para este escenario, tenemos dos posibilidades:


  • Atacando los servicios web que expone WSS 3.0.
  • Utilizando los dos protocolos RPC que tenemos para comunicaciones remotas en WSS 3.0 sin utilizar los servicios web que expone:

    • FrontPage Server Extensions Remote Procedure Call (FrontPage RPC).
    • Windows Sharepoint Services Remote Procedure Call (WSS 3.0 RPC).

En este post (y cuya redacción, código, etc hemos realizado conjuntamente Ángel y yo, de hecho Ángel se ha “pegado” mucho con los servicios web de WSS 3.0 & MOSS y ha sido quien me ha enseñado y explicado todos los aspectos a tener en cuenta, como funciona el proceso de lectura / escritura de datos en una lista de WSS 3.0, etc.) cubriremos el primer punto. El segundo punto aún no lo hemos probado, pero para los intrépidos deciros que el capítulo 9 de Developer’s Guide To Windows Sharepoint Services 3.0 de Tood C. Bleeker cubre este tópico.

En el ejemplo desarrollado, leeremos los datos de una lista de tipo calendario ubicada en un cierto site collection y los volcaremos en una lista del mismo tipo, pero ubicada en otro site collection distinto. Por lo tanto, en este sencillo caso sólo tendremos que añadir una referencia web al servicio web de WSS 3.0 http://[NommbreServidor]/_vti_bin/Lists.asmx pues vamos a mover datos entre listas que están en el servidor. Para el caso de trabajar con listas ubicadas en site collections pertenecientes a distintos servidores web habría que añadir una segunda referencia al servicio web donde reside la lista destino (si bien, y como veremos en el código utilizado para demostrar como operar con los servicios web, no es necesaria una segunda referencia): http://[NommbreServidor2]/_vti_bin/Lists.asmx. Empecemos.

Paso 1: Añadir la referencia web del servidor Origen

Lo primero que tenemos que hacer una vez creado nuestro proyecto de prueba (por simplicidad, hemos elegido uno de aplicación de consola) es añadir la referencia web al servicio web de WSS 3.0 que vamos a utilizar y que en este caso (para trabajar con listas) es http://[NommbreServidor]/_vti_bin/Lists.asmx:

Post_Atacando_ServiciosWeb_Add_WebReference

Una vez añadida la referencia web, en el archivo Program.cs añadimos las referencias necesarias para interactuar con servicios web y para trabajar con XML.

Using System.Net;

Using System.Xml;

Using Syste.Xml.XPath;

Paso 2: Lectura de los datos de una lista de WSS 3.0

Lo primero que tenemos que hacer es crear una instancia del objeto Lists() asociado al servicio web. Una vez hecho esto, le especificamos los siguientes miembros:



  • Las credenciales de acceso que especificamos a través de un objeto de tipo NerworkCredentials. El usuario y contraseña son los mismos con los que accedemos a la máquina virtual (Administrator, pass@word1).
  • La url del servicio web Lists.asmx para la lista origen: http://litwaredemo/sites/Desarrollo/_vti_bin/Lists.asmx.

LitwareDemo_WS.Lists servWeb = new LitwareDemo_WS.Lists();

//Credenciales para el acceso al servicio web

servWeb.Credentials = new NetworkCredential(“Administrator”, “pass@word1”);

servWeb.Url=http://litwaredemo/sites/Desarrollo/_vti_bin/Lists.asmx;

De esta forma ya podemos acceder a listas del site collection origen. Para acceder a los datos de la lista calendario tenemos que seguir los siguientes pasos:


  • Creamos un objeto de tipo XmlNode a partir del método GetListItems del objeto Lists() creado. De todos los parámetros que admite el método, basta con que especifiquemos el nombre de la lista (Nota: Hay que tener en cuenta que esto es así por la sencillez del escenario tratado).
  • Para ver que estamos accediendo correctamente a los datos de la lista, mostramos por pantalla la estructura interna XML a partir del miembro InnerXML (también podríamos visualizar la estructura XML con OuterXML).

XmlNode xmlNodo = servWeb.GetListItems(“Calendario”, null, null, null, null, null, null);

Console.WriteLine(xmlNodo.InnerXml);

Console.ReadLine();

Si probamos este código, la salida por pantalla que obtendremos debería ser la siguiente (en este caso hay tres eventos en el calendario):

Post_Atacando_ServiciosWeb_EstructuraXMLRecibida


Lo cual concuerda con los datos que tenemos en la lista Calendario del site collection origen:

Post_Atacando_ServiciosWeb_CalendarioOrigen


Paso 3: Escritura de los datos en la lista destino

En esta sección veremos cómo copiar los datos de la lista Calendario de http://litwaredemo/sites/Desarrollo a la lista Calendar de http://litware. Los pasos que seguiremos son los siguientes:


  • A partir de los datos leídos de la lista origen mediante GetListItems, crearemos la estructura XML necesaria para poder llevarlos a la lista destino, es decir, no es suficiente con pasar la estructura XML que estamos leyendo sino que tenemos que realizar las transformaciones necesarias para construir un documento XML que sea entendible en destino.
  • Mediante el método UpdateListItems (también del objeto Lists()), realizaremos la copia efectiva de los datos en la lista destino a partir del documento generado en el formato que espera este método. En este enlace de msdn podéis ver ejemplos de cómo tiene que ser el documento XML a construir para utilizarlo con UpdateListItems.

Para realizar los pasos anteriores, es necesario realizar los siguientes puntos:

i) Crear un objeto de tipo XDocument, y que va a representar un documento XML completo

ii) Crear un objeto de tipo XmlNamespaceManager a partir de la propiedad NameTable del objeto XDocument creado en el paso anterior. Este objeto nos permite añadir al documento a crear los espacios de nombres necesarios (y que identificamos a partir de la estructura Xml devuelta en el paso 1).

iii) Añadimos al XmlNameSpaceManager los siguientes espacios de nombres

a. Prefijo rs, nombre del esquema urn:schemas-microsoft-com:rowset. Este espacio de nombres se corresponde con el elemento rs:Data que identifica el número de elementos que constituyen el archivo Xml origen (devuelto en la llamada al método GetListItems()).

b. Prefijo z, nombre del esquema #RowsetSchema. Este espacio de nombres identifica un elemento concreto dentro del documento a generar.

XmlDocument xmlDoc = new XmlDocument();

XmlNamespaceManager xnsmManager = new XmlNamespaceManager(xmlDoc.NameTable);

xnsmManager.AddNamespace(“rs”,”urn:schemas-microsoft-com:rowset”);

xnsmManager.AddNamespace(“z”, “#RowsetSchema”);

iv) Crear un objeto de tipo XPathNavigator a partir del objeto XmlNode y su método CreateNavigator() para explorar el documento (XPathNavigator permite el desplazamiento por los nodos de atributo y por los nodos de espacio de nombres de un documento XML) obtenido en la sección anterior.

v) Crear un objeto de tipo XPathNodeIterator que nos proporciona un iterador sobre los elementos del objeto XPathNavigator utilizando el método Select del mismo. Comoo parámetros del método especificaremos:

a. La expresión XPath de búsqueda que es //z:row.

b. El objeto XmlNamespaceManager que contiene los espacios de nombres añadidos y que se utilizan en la correspondiente resolución de nombres.

vi) Creamos un objeto de tipo XmlElement que será el elemento primario del árbol XML a contruir y cuyo nombre ha de ser Batch. A este objeto le añadimos el atributo OnError con valor Continue.

XPathNavigator xpnNavegador = xmlNodo.CreateNavigator();

XPathNodeIterator xpniIterator = xpnNavegador.Select(“//z:row”, xnsmManager);

XmlElement xmlBatchElement = xmlDoc.CreateElement(“Batch”);

xmlBatchElement.SetAttribute(“OnError”, “Continue”);

Nota: En este enlace podéis ver cómo ha de ser la estructura del documento XML que hay que pasar al servicio Lists.asmx para escribir nuevos datos en una lista de WSS 3.0 o actualizar datos existentes.

vii) A continuación, nos tenemos que mover en modo iterativo (pues tenemos más de un elemento z: en la estructura XML devuelta en la llamada) por el objeto XPathNodeIterator utilizando para ello el método MoveNext(). Lo que haremos en cada iteración es lo siguiente:


a. Definir un objeto XmlElement con nombre Method. Le añadiremos dos atributos: ID con el valor de la iteración correspondiente (empezamos en 0) y que identifica el elemento a añadir (en el caso de actualización, identifica el elemento que se va actualizar y que no tiene porque corresponderse con el ID de lista del elemento que se está actualizando), y Cmd que significa que estamos creando un nuevo elemento en el árbol (de ahí que su valor sea New, en el caso de actualización sería update). A continuación añadimos el elemento creado al elemento Batch utilizando el método AppendChild al que le pasamos él elemento a añadir.


XmlElement methodElement = xmlDoc.CreateElement(“Method”);

methodElement.SetAttribute(“ID”, i.ToString());

methodElement.SetAttribute(“Cmd”, “New”);

xmlBatchElement.AppendChild(methodElement);

Siguiendo la estructura del documento XML a generar que tenemos que pasarle a Lists.asmx, vemos que un elemento de tipo Method está compuesto de varios elementos de tipo Field, identificando el primero de ellos que vamos a hacer: crear un nuevo elemento (en este caso tendrá el atributo Name con valor New) o actualizar uno existente (en cuyo caso e atributo Name tendrá como valor el ID del elemento a actualizar). Por así decirlo, el primer elemento de tipo Field nos da la clave primaria del elemento correspondiente en la lista destino de WSS 3.0. Así, estos serían dos ejemplos de los documentos XML a generar para cada caso:

XML a generar para actualizar elementos de la lista destino

Post_Atacando_ServiciosWeb_EstructuraXMLUpdate

Como veis, en este caso el elemento Method tiene Cmd con valor Update, el ID vale 1 lo que indica que estamos trabajando con el primer elemento de la estructura a actualizar. A continuación vienen los elementos Field. El primero indica que vamos a actualizar el elemento de la lista destino con ID 4, y el segundo que actualizaremos el campo Field_Name con el valor Value.

XML a generar para crear nuevos elementos en la lista destino

Post_Atacando_ServiciosWeb_EstructuraXMLNew

En este caso la idea es la misma, salvo que ahora en Method el atributo Cmd tiene un valor New, y que el primer elemento Field tiene un valor New para el atributo ID.

En los siguientes puntos veremos cómo ir añadiendo al elemento Method los elementos Field necesarios, empezando por el primero que nos indica que se está añadiendo un nuevo elemento en la lista destino.


b. Definimos un objeto XElement con nombre Field. Este primer elemento Field tendrá un atributo Name con valor ID y propiedad InnterText con valor New para especificar que se va a añadir un nuevo elemento al árbol (como nodo hijo del elemento Method mediante el método AppendChild())


XmlElement fieldElement0 = xmlDoc.CreateElement(“Field”);

fieldElement0.SetAttribute(“Name”, “ID”);

fieldElement0.InnerText = “New”;

methodElement.AppendChild(fieldElement0);


c. Definir un objeto XmlElement por cada uno de los campos de la lista origen que queremos copiar / crear en la lista destino. Estos elementos los añadiremos como nodos hijos al elemento Method. El primer elemento que añadiremos es el título del evento, por lo que tendremos que añadir al elemento el atribute Title. El valor de la propiedad InnerText se obtiene en este caso de buscar en el ítem actual del iterador el atributo equivalente: ows_Title. Este valor lo obtenemos a través del método GetAttribute del elemento actual del objeto XPathNodeIterator al que le especificamos el string a buscar (el nombre del atributo) y el esquema en el que se encuentra:


XmlElement fieldElement1 = xmlDoc.CreateElement(“Field”);

fieldElement1.SetAttribute(“Name”, “Title”);

bool bAttrib = xpniIterator.Current.HasAttributes;

fieldElement1.InnerText = xpniIterator.Current.GetAttribute(“ows_Title”,

xnsmManager.DefaultNamespace);

methodElement.AppendChild(fieldElement1);


d. Lo que hemos hecho para el título del evento lo repetimos para los siguientes elementos:

Post_Atacando_ServiciosWeb_TablaDatos


El código completo de construcción del documento Xml necesario para copiar los datos indicados en la tabla en la lista destino es:

while (xpniIterator.MoveNext())

{

//Method element

XmlElement methodElement = xmlDoc.CreateElement(“Method”);

methodElement.SetAttribute(“ID”, i.ToString());

methodElement.SetAttribute(“Cmd”, “New”);

xmlBatchElement.AppendChild(methodElement);

//Field Element que especifica que se va a añadir un nuevo ítem

XmlElement fieldElement0 = xmlDoc.CreateElement(“Field”);

fieldElement0.SetAttribute(“Name”, “ID”);

fieldElement0.InnerText = “New”;

methodElement.AppendChild(fieldElement0);

//********************************************************************

//Field elements a actualizar

//********************************************************************

XmlElement fieldElement1 = xmlDoc.CreateElement(“Field”);

fieldElement1.SetAttribute(“Name”, “Title”);

bool bAttrib = xpniIterator.Current.HasAttributes;

fieldElement1.InnerText = xpniIterator.Current.GetAttribute(“ows_Title”, xnsmManager.DefaultNamespace);

methodElement.AppendChild(fieldElement1);

//Título

XmlElement fieldElement2 = xmlDoc.CreateElement(“Field”);

fieldElement2.SetAttribute(“Name”, “Location”);

fieldElement2.InnerText = xpniIterator.Current.GetAttribute(“ows_Location”, xnsmManager.DefaultNamespace);

methodElement.AppendChild(fieldElement2);

//Fecha de Inicio

XmlElement fieldElement3 = xmlDoc.CreateElement(“Field”);

fieldElement3.SetAttribute(“Name”, “EventDate”);

fieldElement3.InnerText = xpniIterator.Current.GetAttribute(“ows_EventDate”, xnsmManager.DefaultNamespace);

methodElement.AppendChild(fieldElement3);

//Fecha de Fin

XmlElement fieldElement4 = xmlDoc.CreateElement(“Field”);

fieldElement4.SetAttribute(“Name”, “EndDate”);

fieldElement4.InnerText = xpniIterator.Current.GetAttribute(“ows_EndDate”, xnsmManager.DefaultNamespace);

methodElement.AppendChild(fieldElement4);

//Descipción

XmlElement fieldElement5 = xmlDoc.CreateElement(“Field”);

fieldElement5.SetAttribute(“Name”, “Description”);

fieldElement5.InnerText = xpniIterator.Current.GetAttribute(“ows_Description”, xnsmManager.DefaultNamespace);

methodElement.AppendChild(fieldElement5);

//All Day Event

XmlElement fieldElement6 = xmlDoc.CreateElement(“Field”);

fieldElement6.SetAttribute(“Name”, “fAllDayEvent”);

fieldElement6.InnerText = xpniIterator.Current.GetAttribute(“ows_fAllDayEvent”, xnsmManager.DefaultNamespace);

methodElement.AppendChild(fieldElement6);

i++;

}

Una vez construido el documento Xml que se va a enviar al destino, la salida por pantalla que obtenemos es la siguiente:

Post_Atacando_ServiciosWeb_EstructuraXMLGenerada

Nota: La salida se ha obtenido con Console.WriteLine(xmlBatchElement.OuterXml)


e. Una vez que hemos añadido todos los elementos para cada iteracción, ya tendremos construida la estructura Xml necesaria para copiar los datos de la lista origen a la lista destino. Para ello, especificamos la url del servicio web Lists.asmx para la lista destino, indicamos las credenciales (que son las mismas en este caso) y llamamos al método UpdateListItems del objeto Lists() y al que le pasamos el nombre de la lista en la que vamos a añadir los datos y la estructura XML que hemos construido y que contiene los datos a crear:


//Creamos los elementos en el destino

servWeb.Url = “http://litwaredemo/_vti_bin/Lists.asmx”;

servWeb.Credentials = new NetworkCredential(“Administrator”, “pass@word1”);

try

{

servWeb.UpdateListItems(“Calendar”, xmlBatchElement);

Console.WriteLine(“Datos copiados en el destino”);

}

catch (Exception ex)

{

Console.WriteLine(ex.Message);

}

Console.ReadLine();

Sin más, comprobamos que la lista Calendar de http://litwaredemo tiene los eventos añadidos.

Post_Atacando_ServiciosWeb_CalendarioDestino


Lo mismo que hemos hecho con dos listas de sites collections diferentes, pero ubicados en el mismo servidor de WSS 3.0 se puede hacer para el caso en el que estén en servidores distintos. Lo único que habría que hacer es añadir una segunda referencia web al proyecto y utilizar dicha referencia web al copiar los elementos en la lista destino.


Y esto es lo que os queríamos contar respecto al trabajo con listas de WSS 3.0 a través de los servicios web que exponen. Esperamos que el post os haya resultado interesante y le encontréis utilidad. Os dejamos aquí el código completo del ejemplo desarrollado

Ángel y JC

Control de cambios con Word 2007 y SharePoint Services

Continuando con el post sobre versionado de documentos en SharePoint, cuando alguien tiene que revisar un documento, previo a su aprobación, necesita herramientas para conocer qué es lo que ha cambiado en el documento.


La opción de añadir una nota descriptiva en cada versión es una buena práctica para saber cuál es el motivo de un cambio, pero se necesita la posibilidad de controlar cuáles son realmente los cambios.


Para ello, tenemos la ayuda de Word 2007, sus nuevas funciones de comparación de documentos y su capacidad de dialogar directamente con SharePoint.


Cuando se abre un documento Word desde SharePoint, el menú Revisión –> Comparar se activa con un desplegable que nos permite comparar el documento abierto con otras versiones del mismo almacenadas en SharePoint.


menu_revision


Una vez hecho (en este caso comparamos entre las versiones 2.0 y 1.0 del documento) se abre una ventana con los siguientes elementos:



  • Documento original (el que abrimos en primer lugar)
  • Documento revisado
  • Documento comparado: la vista tradicional de word de control de cambios
  • Resumen de revisiones: una vista rápida de los cambios introducidos

Resulta muy útil para descubrir los cambios de un vistazo, sin tener que preocuparse de abrir manualmente los archivos de las diferentes versiones.


image

Versionado de documentos en SharePoint Services 2007

SharePoint Services incluye varias posibilidades para gestionar el trabajo de personas alrededor del ciclo de vida de un documento. Resumiendo mucho, cuando compartimos y modificados documentos entre un grupo de personas, necesitamos:



  • Un repositorio común
  • Un sistema para controlar versiones de documentos
  • Un sistema para aprobar documentos
  • La capacidad de que los cambios de un usuario no sobreescriban los de otro

Todo esto está implementado en las librerías de documentos de Sharepoint Services, y es un elemento clave en las capacidades de su ‘hermano mayor’, Office SharePoint Server, para construir intranets, sitios de publicación web, etc.


En lo que sigue, usaremos los grupos predefinidos de seguridad de Sharepoint:



  • Propietarios: pueden gestionar la configuración de un sitio
  • Miembros: pueden añadir y editar documentos de un sitio
  • Visitantes: pueden leer documentos

Por defecto, cuando creamos una librería de documentos, ninguna de estas opciones está activada. Tenemos que ir a la configuración de la librería, “configuración de versiones”, para lo que tendremos que tener al menos permisos de “Propietario” dentro de la librería.


Las opciones disponibles son:



  • Aprobación de contenido: Separa los documentos “aprobados” de los “pendientes”. Un miembro puede añadir un nuevo documento, pero sus cambios quedarán en ‘pendiente’ hasta que un propietario los apruebe. Mientras tanto, los visitantes verán el documento aprobado o nada, si el documento se acaba de crear.
  • Versiones Principales (1.0, 2.0…): cada vez que un miembro guarda una nueva copia, sharepoint almacena una nueva versión del documento, que queda archivada
  • Versiones principales y secundarias (1.0, 1.1, 1.2, 2.0…): las versiones secundarias guardan fotos de un documento en el proceso de revisión. Cuando se guarda un documento, se puede elegir crear una versión principal o una secundaria

    • Los documentos en versión secundaria aparecen con estado ‘borrador’
    • en ambos casos, es recomendable limitar el número de versiones que se almacenan, para evitar un consumo excesivo de disco. Esto hay que hacerlo librería a librería.

  • Seguridad de borradores: controla quién puede ver las versiones secundarias de un documento. El autor y los propietarios siempre las pueden ver, pero se puede hacer que las vean otros miembros o los visitantes (no recomendable)
  • Requerir desprotección: obliga a que se haga una desprotección obligatoria de un documento cuando se quiera modificar. De esta forma, se evita que otra persona sobrescriba cambios.

image


Todas las opciones pueden ser combinadas. En ese caso, el ciclo completo de edición de un documento sería:


Un miembro trata de editar un documento existente ya aprobado. WSS le avisa de que es necesario desprotegerlo. El icono del documento cambia para marcar este estado 


image  image


Al guardar el documento, y salir de Word, se pregunta si se quiere proteger el documento. Si no se protege, el usuario continua con el control del mismo.


Si se protege, Word pregunta si se quiere crear una versión secundaria 1.1 o una principal 2.0. Mantendremos una versión secundaria 1.1, con el documento protegido


image


Los visitantes siguen viendo sólo la versión 1.0. Los miembros o propietarios ven que hay una versión en borrador del documento


image


Otra persona repite el proceso y realiza cambios, pero ahora quiere que se publique una versión 2.0


image


Como la librería requiere aprobación de contenidos, los visitantes siguen viendo la versión 1.0.


image


Un propietario aprueba la versión 2.0, y a partir de este momento, los visitantes pueden ya leer esta versión. Así queda el historial de versiones.


image


Comentarios:



  • Propietarios y miembros pueden acceder al historial de versiones de un documento en el desplegable que aparece al pasar el ratón por un elemento. Desde aquí, se puede volver a una versión anterior. En el ejemplo de antes, si se recupera el estado 1.0, esta versión se convertiría en la 3.0.
  • La desprotección se puede hacer en SharePoint o en una carpeta local “Borradores de Sharepoint”. En Windows Vista, con el modo protegido de Internet Explorer, sólo es posible la primera opción (salvo que se meta el sitio WSS en la zona de Sitios de Confianza de IE)
  • El proceso sería el mismo si se suben documentos con las opciones de carga manual, la ventaja de las aplicaciones Office es que entienden los mecanismos de Sharepoint y facilitan el trabajo
  • La aprobación se podría automatizar con un workflow. En Sharepoint Services no hay ningún template de workflow para aprobación, por lo que sería necesario usar Sharepoint Designer o Visual Studio. En MOSS hay un completo workflow de aprobación con modos serie, paralelo, con quorum mínimo…

WSS 3.0 & MOSS: Recopilación de enlaces interesantes (III)

Siguiendo con la serie de post sobre recursos de WSS 3.0 & MOSS que iniciamos con las entregas I y II, esta semana en la  recopilación de recursos interesantes sobre WSS 3.0 & MOSS destacamos los siguientes enlaces:

Documentación

·         En el blog del equipo de Sharepoint se están publicando una serie de post relativos a como realizar una buena arquitectura en cuanto a despliegue de soluciones de colaboración en Sharepoint. En este sentido, durante el último mes están apareciendo números white papers  con el tópico governance y management en sharepoint. Este es el enlace al segundo post de la serie (muy recomendable).


·         Excelente post de Todd Baginski sobre que plantilla de MOSS usar: out-of-the-box vs personalizadas.


Documentación Funcional de la Plataforma

·         Sitio online de Office en el que se pueden encontrar diversas demos funcionales de producto, los puntos fuertes, formación rápida al uso de la plataforma, etc.

Artículos Interesantes

·         Dentro de la línea de artículos espectaculares que Patrick Tisseghem está publicando en msdn, destacan los dos últimos dedicados a personalizar y extender las búsquedas en MOSS (estos artículos son parte del libro Inside Microsoft Office Sharepoint Server 2007 del propio Tisseghem):


o   En la parte 1 se detallan aspectos relativos a la arquitectura de búsqueda de MOSS, fuentes de contenidos y como se pueden manejar por programa, lo mismo con scopes de búsqueda, etc.


o   En la parte 2 se describen aspectos relativos al modelo de objetos utilizado en las consultas de búsqueda.


·         Excelente post de Joel Oleson sobre aspectos relativos a grupos de sharepoint, permisos y niveles de permisos, seguridad a nivel de sitio. En el post podéis encontrar buenas prácticas de Joel en el manejo de estos elementos así como varios enlaces sobre estos temas.


·         De nuevo en el blog de Joel Oleson podemos encontrar un estupendo post sobre recomendaciones y buenas prácticas en cuanto al tamaño y  nombre (longitud y uso de caracteres especiales) de archivos en sharepoint dada su importancia en procesos de migración.


·         Muy buen artículo en The Code Project sobre desarrollo de soluciones basadas en MOSS.


·         Serie de artículos en msdn sobre personalización de sitios WCM. Los artículos, no sé porque no me sorprende, son de Patrick Thisseghem.


·         Comparación de las características de Web Content Management de MOSS y Microsoft Content Management System 2002 (CMS 2002): MOSS vs CMS 2002.


·         Artículo de Sahil Malik sobre el flujo de información de los user profiles. El diagrama del flujo de información en los user profiles es realmente  espectacular.


·         Todo sobre Site Templates en Sharepoint. Fuente: Blog de Sahil Malik.



·         De nuevo en el blog de Sahil Malik podemos encontrar información de interés sobre los user profiles: ¿qué son?, ¿para qué sirven? ¿dónde se almacenan?, etc. El título del post es autoexplicativo: SharePoint 2007: All you ever wanted to know about User Profiles.  

Tips & Tricks

·         Consideraciones a tener en cuenta cuando estamos pensando en hacer un content deployement en MOSS.


·         Data view tips en el blog de Mark Kruger.


·         Configurando un blog en sharepoint para añadir más de una categoría en un post.


·         Personalización de la content query web part para tener una visualización de los datos tipo grid.


·         Estupendo post en el blog de Andrew Connel sobre content deployement en sitios de publishing de MOSS.


·         ¿Dónde se está utilizando la master page del sitio de publicación? En este post de Andrew Connel lo podemos ver.


·         Ejemplo de script para hacer un backup completo o a nivel de sitio.


·         ¿Se pueden exportar workflows creados con Sharepoint Designer 2007 a Visual Studio? Pues sí, porque los workflows creados con SD cumplen el estándar XOML. En el blog del equipo de SD 2007 podéis encontrar un estupendo how to de cómo hacerlo.


·         Cómo seguir utilizando tu máquina de MOSS si ha caducado tu licencia trial.


·         Cómo añadir programáticamente un evento de calendario llamando al serivico web list.asmx (http://Server_Name/Site_Name/_vti_bin/Lists.asmx).


·         Cómo modificar el número de posts que se visualizan en un sitio blog. El truco está en cambiar la propiedad RowLimit en la página Category.aspx del sitio blog.


·         Añadir código javascript a la content editor web part.

Recursos

·         Recopilatorio de componentes útiles para WCM en MOSS.


·         Portal dedicado a la seguridad en sitios de Sharepoint.

·         Sharepoint Server Frequently Asked Questions.

·         Ya tenemos en codeplex la beta 2 de la enhaced content query web part.


Otros:


·         Espectacular recopilatorio sobre recursos de WCM en el blog de Andrew Connel. Los recursos están agrupados por categorías.


·         Recopilatorio de libros de sharepoint de recomendada lectura.


·         Siguiendo con la serie de cómo se construyó la web Glu’s Mobile, Lawrence nos muestra en este post aspectos relativos a como se hizo la personalización de dicha web: master page y controles, CSS,…


·         Hojas de estilos para Sharepoint 2007 (Parte I, y Parte II), muy visual y por área de uso. Fuente: Blog de Gustavo Velez.


·         Otro estupendo post con los CSS utilizados en Sharepoint 2007, no tan visual como el anterior pero igualmente útil. Fuente: www.heathersolomon.com.


·         Ejemplo de sitio web hecho con MOSS para una escuela de Florida: Orange County Public Schools. Fuente: Blog de Andrew Connel.


·         Point Fire 2007: Multilingual User Interface for Sharepoint 2007. Cómo sabéis, MOSS soporta sitios multiidioma para sitios de publicación utilizando las variations de MOSS. Sin embargo, esta característica no está disponible para sitios de otros tipos. IceFire Studios acaba de sacar a la venta una solución multilingüe para WSS 3.0 & MOSS que es independiente de la tipología de solución a implementar y de la arquitectura hardware que se haya montado.



Sin más, agradecer los comentarios y acogida que están teniendo este tipo de posts. Espero que os resulten de ayuda, y seguro que os sacan de más de un apuro. Próximamente publicaremos la entrega IV de la serie (en este caso las secuelas son buenas :P).