el core de alfresco 4.2

Alfresco 4.2 para desarrolladores

El núcleo de Alfresco


Preparado por Jesús Salinas Revelles

Índice del capítulo

‣ Introducción a Alfresco.

‣ Arquitectura de Alfresco.

‣ Alfresco Java Foundation Services.

‣ Java Script API.

‣ Freemarker Templating API.

‣ Subsistemas.

‣ Seguridad en Alfresco.

‣ Extension classpath.

‣ Extensiones en Alfresco: empaquetado y despliegue.



Introducción a Alfresco

‣ ¿Qué es Alfresco?

‣ Algunas características técnicas del proyecto Alfresco.

‣ Documentación.

‣ Funcionalidades más importantes de cara a los usuarios.

‣ Arquitectura técnica.

‣ Componentes y servicios.



¿Qué es Alfresco?

‣ Alfresco es un sistema de Gestión de Contenido Empresarial (ECM), normalmente utilizado para Gestión de Documentos Digitales en entornos exigentes (sometidos a importantes requisitos de escalabilidad, alta disponibilidad, capacidades de integración, auditabilidad, etc.).

‣ Es un proyecto OpenSource creado en 2005 por un equipo procedente de Documentum.

‣ Alfresco gestiona todos los contenidos en nuestra empresa: documentos, imágenes, fotos, páginas web, registros, documentos xml y cualquier otro fichero semiestructurado o no estructurado.

‣ Los servicios que ofrece Alfresco son una de sus grandes ventajas. Permiten gestionar el contenido de los documentos y características, tales como, gestión de metadatos, control de versiones, gestión del ciclo de vida, flujo de trabajo, búsquedas, asociaciones a otros contenidos, etiquetado, comentarios.



¿Qué es Alfresco?

‣ Para los usuarios finales, Alfresco se presenta como un conjunto de aplicaciones o extensiones de sus propias aplicaciones que gestionan sus contenidos. Alfresco puede aparecer como una unidad compartida con protocolo CIFS, WebDAV, IMAP y SharePoint. También proporciona por defecto un conjunto de aplicaciones para navegar por los contenidos, buscar, gestionar, etc.

‣ Para el negocio, Alfresco ha sido diseñado para soportar todo tipo de requisitos relacionados con los contenidos: herramientas para la gestión de documentos, aplicaciones, interfaces para trabajo de oficina. La gestión de flujos de trabajo soporta diferentes procesos de negocio.

‣ Para el desarrolllador, Alfresco proporciona un repositorio escalable y una plataforma de gestión que simplifica el desarrollo. Expone infinidad de capacidades de gestión en forma de servicios.



¿Qué es Alfresco?

‣ El núcleo de Alfresco es un repositorio gestionado por un servidor que persiste contenidos, metadatos, etc.



¿Qué es Alfresco?

‣ Alfresco incorpora una arquitectura moderna. El sistema ha crecido como una aplicación Java, eso significa que se puede ejecutar en cualquier plataforma donde corre JavaEE.

‣ El núcleo se basa en la plataforma Spring, proporcionando a Alfresco la capacidad de modularizar los diferentes elementos del sistema: versionado, seguridad, reglas, etc.

‣ Alfresco utiliza estrategias de scripting para simplificar la incorporación de nuevas funcionalidades dentro del sistema. Esto se conoce como Web scripts y puede utilizarse para la gestión de datos o servicios de presentación.



Algunas características técnicas del proyecto Alfresco

‣Open Source : Tenemos el código disponible (¡siempre, en cualquier versión!).

‣Fácilmente extensible y basado en tecnologías Java EE estándares y proyectos Open Source de éxito como Apache Lucene, OpenOffice, Spring Framework, SWFTools, Quartz Scheduler, etc.

‣Maduro (estamos en la v.4) y con multitud de casos de éxito documentados.



Algunas características de negocio del proyecto Alfresco

‣Dos versiones: Community y Enterprise. Esta última con un soporte profesional, con procesos de QA estrictos, SLA, etc.

‣La versión Community es suficientemente buena para ponerla en producción en proyectos no críticos. Es gratuita.

‣La versión Enterprise es de pago (aunque se puede probar gratuitamente) y la recomiendo para entornos críticos.



Documentación

‣Muy buena documentación (¡cosa muy rara en los proyectos y productos Open Source!).

‣La documentación de la versión Community está en la Wikihttp://wiki.alfresco.com

‣La documentación de la versión Enterprise está en la web oficialhttp://docs.alfresco.com

http://wiki.alfresco.com

http://wiki.alfresco.com

http://docs.alfresco.com






Funcionalidades más importantes de cara a los usuarios

‣ Un único repositorio unificado para gestionar cualquier tipo de contenido: documentos, imágenes, vídeo y audio.

‣ Puede ser usado como una unidad de red compartida con protocolo CIFS, WebDAV, IMAP y SharePoint.

‣ Vista previa en línea de los tipos de archivos populares (como documentos de Microsoft Office, PDFs e imágenes) directamente en el navegador sin necesidad de descargarlos.




‣ Integración en Microsoft Office. Alfresco tiene el mismo aspecto que SharePoint para Microsoft Office, permitiendo a los usuarios subir, acceder, salir y modificar contenido desde Office.

‣ Arrastrar y soltar desde el email. Alfresco se puede instalar como un servicio IMAP en su cliente de email, de manera que puede arrastrar y soltar contenido en Alfresco desde su email.




‣ Portales colaborativos en Web (basados en Alfresco Share). Permite a equipos globales colaborar para generar contenido de manera eficiente. Soporte a nuevas funciones sociales, como las actualizaciones de estado, los flujos de actividades, etiquetado y búsqueda.

‣ Capacidad para localizar documentos rápidamente con un sistema de búsquedas avanzadas preindexadas.



Componentes y servicios

‣ Cada parte del repositorio de Alfresco es un componente o un servicio.

‣ Un componente es una implementación que provee un capacidad o funcionalidad específica y que debe ser manejada como una caja negra por el resto del sistema.

‣ Un servicio es una interfaz de acceso y uso para los clientes. Es una abstracción.




‣ Los clientes de Alfresco se acoplan a los servicios y no a los componentes. Esto nos permite tener la libertad de cambiar las implementaciones de manera transparente.

‣ Puede haber más de un componente que implemente un servicio.

‣ Con Spring Framework seleccionamos qué componente está disponible en nuestro sistema para cada servicio y cómo está configurado.




‣ Los componentes pueden ser intercambiados por nuevas implementaciones y se pueden añadir nuevos componentes.

‣ El sistema es muy flexible ya que los clientes se conectan a los servicios y hacen uso de ellos sin saber como están implementados.




‣ La flexibilidad descrita anteriormente es posible gracias al uso interno del core de Spring Framework como núcleo de Alfresco.

‣ Los componentes son configurados de manera declarativa.

‣ La programación orientada a aspectos permite aplicar conceptos transversales de manera limpia.

‣ La inyección de dependencias permite establecer qué componente está activo y su configuración.



Estructura del repositorio de Alfresco

‣ La interfaz pública es conocida como Alfresco Repository Foundation Services.

‣ Cada servicio es expuesto como una interfaz Java sobre la que un cliente puede invocar operaciones sin conocer como están implementadas ni quién lo hace.

‣ Un registro de servicios está disponible.



Estructura del repositorio de Alfresco

‣ Detrás de los servicios están las implementaciones como cajas negras (componentes).

‣ Cada servicio o componente está configurado a través de Spring en ficheros de configuración XML o ficheros de contexto. En concreto, los servicios de Alfresco Repository Foundation Services están configurados en el fichero de Spring public-services-context.xml.



Foundation Services

‣ Es la interfaz de más bajo nivel para acceder a las capacidades del repositorio.

‣ El enlace con esta interfaz se realiza a través del Repository Service Registry o a través de inyección de dependencias de Spring (si el cliente usa Spring).

‣ El acceso a los Foundation Services está limitado a los clientes locales (en el mismo proceso que el repositorio).

‣ Los servicios de Foundation Services son transaccionales y seguros. Las políticas de seguridad y transaccionalidad están descritas de forma declarativa y se fuerza su aplicación para cada servicio.



Extensiones del repositorio

‣ Alfresco soporta una forma estándar para realizar extensiones al repositorio: configurar un componente, añadir un nuevo componente o servicio o borrar componentes.

‣ Las extensiones se encapsulan fuera del núcleo del repositorio y se instalan como pluging automáticamente.

‣ Las actualizaciones del núcleo del repositorio no afectan a nuestras extensiones.



Servicios básicos del repositorio

‣ Los 3 servicios más importantes de Foundation Services son :

‣ Servicio de nodos : provee los metadatos y la estructura a los contenidos. Un nodo debe soportar propiedades y asociaciones con otros nodos.

‣ Servicio de contenido : permite el acceso y modificación a la información que se ha grabado en el repositorio: un documento Word o un fragmento XML.

‣ Servicio de búsquedas : maneja la información del índice de búsquedas y permite recuperar los metadatos y el contenido del repositorio a través de distintas opciones de búsqueda.



Servicios básicos del repositorio



Arquitectura de Alfresco

‣ Introducción.

‣ Servidor de aplicaciones de Alfresco.

‣ Repositorio de contenidos.

‣ Protocolos.

‣ Los servicios de Alfresco.



Introducción

‣ La gestión de contenidos empresarial cubre un amplio rango de aplicaciones: gestión de documental, gestión de contenidos web, gestión de registros, búsqueda, etc.

‣ La arquitectura de Alfresco ha sido diseñada para ser capaz de soportar los requisitos asociados a todas estas aplicaciones.

‣ Cada una de estas disciplinas tiene una serie de características únicas y otras que se solapan, de tal forma que, el diseño de cada capacidad no se ha realizado de forma aislada sino en el contexto de el sistema completo.

‣ Alfresco pretende ser lo más simple posible en todos los ámbitos: desarrollo, personalización, despliegue y uso. La solución más simple y extendida de una solución ECM es una unidad compartida. La arquitectura Alfresco tiene como objetivo ser tan simple como una unidad compartida.



Introducción

‣ Escalado.

‣ Solución modular.

‣ Incoporando las mejores librerías de terceros.

‣ Independencia del entorno.

‣ Núcleo robusto.

‣ Extensiones con scripts.

‣ Solución basada en estándares.



Introducción



Introducción

‣ Últimamente, Alfresco se usa para implementar un ECM para ofrecer gestión documental, gestión de registros, etc.

‣ La solución se divide típicamente en clientes y servidor. Los clientes ofrecen a los usuarios una interface de acceso a la solución y el servidor proporciona servicios de gestión de contenidos y almacenamiento.

‣ Es muy habitual que una solución ofrezca múltiple clientes sobre un mismo servidor compartido, cada cliente se adapta al entorno en el que va a ser utilizado.



Introducción

‣ El servidor de aplicaciones agrupa un repositorio de contenidos y un conjunto de servicios adicionales para construir la solución.

‣ El repositorio de contenidos ha sido definido siguiendo los siguientes estándares:

‣ CMIS (Content Management Interoperability Services).

‣ JCR (Java Content Repository / JSR-170/286).

‣ Estos estándares proporcionan una especificación para la definición de contenidos y su almacenamiento, recuperación de contenidos, versionado, etc.

‣ El almacenamiento de contenidos, por defecto, se realiza de forma combinada en base de datos y en el sistema de ficheros.



Introducción

‣ Aunque se ha realizado un esfuerzo de estandarización a la hora de definir los elementos del ECM, existe un salto entre las características ofrecidas por el repositorio y los requisitos típicos de la solución.

‣ El servidor de aplicaciones de contenido de Alfresco proporciona la siguiente categoría de servicios sobre el repositorio de contenidos:

‣ Servicios de contenidos (por ejemplo, transformación, etiquetados, extracción de metadatos).

‣ Servicios de control (por ejemplo, flujos de trabajo, gestión de registros).

‣ Servicios de colaboración (por ejemplo, actividades, wiki).



Introducción

‣ Alfresco proporciona dos clientes web principales: Alfresco Explorer y Alfresco Share.

‣ Alfresco Explorer aparece desde la primera versión de Alfresco. Ha sido implementado mediante Java Server Faces (JSF) y es altamente personalizable, pero y muy IMPORTANTE, sólo puede desplegarse como parte del servidor de aplicaciones de contenidos de Alfresco.

‣ Alfresco Share es un cliente algo más joven, centrado en aspectos de colaboración. El concepto principal de Alfresco Share es la noción de sitio web: un lugar donde los usuarios colaboran en la generación de contenidos. Ha sido desarrollado usando Spring Surf.

‣ Alfresco Share puede desplegarse de forma independiente al servidor de aplicaciones de contenidos de Alfresco. Durante los últimos años, ha evolucionado y ahora soporta todas las funcionalidades que ofrece Alfresco Explorer.



Introducción

‣ Alfresco ha sido diseñado como un sistema modular.

‣ Cada parte es un componente o servicio. Un componente es una implementación que provee un capacidad o funcionalidad específica y que debe ser manejada como una caja negra por el resto del sistema. Un servicio es una interfaz de acceso y uso para los clientes, es una abstracción.



Introducción

‣ Para soportar esta estrategía, Alfresco usa Spring framework aprovechando entre otras cosas su factoría, inyección de dependencias y programación orientada a aspectos:



Servidor de aplicaciones de Alfresco

‣ La responsabilidad más importante del servidor es proveer de un conjunto de servicios para ser usados en soluciones ECM.

‣ El servidor podemos verlo como una caja negra donde almacenamos y gestionamos contenidos. Alfresco Content Application Server expone un conjunto de interfaces remotas y públicas para permitir la comunicación con clientes.

‣ Estas intefaces públicas y remotas son el único elemento visible desde el cliente. Existen dos tipos:

‣ APIs remotas: permiten interacción programática con los servicios del servidor.

‣ Protocolos que ofrecen esos mismos servicios a los usuarios mediante un protocolo asociado al cliente.




‣ Esquema general del servidor:




‣ Intefaces públicas y remotas

Remote APIs

Protocols




‣ El servidor está formado por un conjunto de capas. Los elementos sobre los que se contruye el sistema son:

‣ La base del sistema es un conjunto de elementos de infraestructura: configuración, autenticación, permisos y transacciones que afectan a cualquier funcionalidad. Esta infraestructura también protege al servidor de atarse a una implementación específica (gestores de transacciones o mecanismos de caché).

‣ El repositorio de contenidos de Alfresco se construye sobre la base de esta infraestructura. Cada funcionalidad del repositorio se mapea a un módulo con su propia especificación e implementación.



Repositorio de contenidos

‣ El repositorio es el sistema que se encarga de manejar los contenidos dentro de Alfresco. Se encarga de:

‣ Definición de la estructura de los contenidos.

‣ Creación, actualización y borrado de contenidos, metadatos asociados y relaciones.

‣ Consultas a los contenidos, control de acceso (permisos) y versionado.

‣ Renderizado de contenidos, locking, eventos, auditoría.

‣ Importación y exportación.

‣ Multi-idioma.

‣ Reglas y acciones.




‣ Esquema del repositorio:

Content Repository




‣ El repositorio de contenidos proporciona una implementación de estos servicios y los expone mediante:

‣ API de Alfresco,

‣ CMIS y

‣ API Java JSR-170.

‣ El núcleo del repositorio es un motor de almacenamiento, responsable de almacenar y recuperar los contenidos que se gestionan. Este motor trabaja sobre dos conceptos:

‣ Nodo: esta entidad maneja los metadatos y estructura de un contenido. Un nodo soporta propiedades y relaciones con otros nodos.

‣ Contenido: contenido a guardar, por ejemplo, documento Excel y ODT.




‣ Servicios:

Content Repository

Embeddeb APIs

Content ServicesControl Services

Collaboration Services




‣ El motor de almacenamiento ofrece también mecanismos de consulta construidas sobre Apache Lucene. Ofrece los siguientes tipos de búsquedas:

‣ Filtrado por metadatos.

‣ Búsquedas por path.

‣ Búsquedas a texto completo.

‣ Cualquier combinación de las anteriores.




‣ Por defecto, Alfresco almacena los nodos en la base de datos y el contenido en el sistema de ficheros.

‣ El uso de base de datos proporciona el beneficio de años y años de experiencia (gestión de transacciones, escalado, administración). Alfresco usa un nivel de abstracción para aislar el motor de almacenamiento y el dialecto SQL utilizado.

‣ El contenido se almacena en el sistema de ficheros permitiendo acceso a contenidos muy grandes, streaming y la posibilidad de trabajar con diferentes dispositivos de almacenamiento.



Protocolos

‣ Para permitir el uso de Alfresco en diferentes ámbitos, el servidor de contenidos de Alfresco soporta diferentes protocolos para la gestión de carpetas y documentos.



Protocolos

‣ CIFS (Common Internet File System) es un protocolo que permite la proyección de Alfresco como una unidad de ficheros compartida nativa. Cualquier cliente puede leer y escribir en las unidades en las que puede leer y escribir en Alfresco, permitiendo el uso de unidades compartidas en vez del ECM sin que el usuario se entere. Alfresco adquirió la única implementación de servidor CIFS basada en Java, JLAN.

‣ WebDAV (Web-based Distributed Authoring and Versioning) es un conjunto de extensiones de HTTP que permite gestionar ficheros mediante servidores web. Muchas herramientas de contenidos ofrecen soporte a WebDAV. También existe herramientas que permite montar servidores WebDAV como unidad de red.

‣ FTP (File Transfer Protocol) es un protoloco estándar de red para el intercambio y manipulación de ficheros a través de la red. Este protocolo es particularmente útil en los procesos de carga masiva de carpetas y ficheros en el repositorio de contenidos de Alfresco.



Protocolos

‣ IMAP (Internet Message Access Protocol) es un estándar que permite acceder a email mediante un servidor de mail remoto. Alfresco se comporta como servidor de correo, permitiendo a clientes de correo como Microsoft Outlook, Apple Mail, y Thunderbird conectar e interactuar con carpetas y ficheros dentro del repositorio de contenidos de Alfresco.

‣ Microsoft SharePoint, protocolo que permite Alfresco actuar como servidor SharePoint, creando integración con la suite Microsoft Office. Permite al usuario familiarizado con esta suite trabajar sobre documentos dentro de Alfresco.



Los servicios de Alfresco

‣ Introducción.

‣ Servicios del repositorio de contenidos.

‣ Servicios de aplicación de contenidos.

‣ Las APIs de Alfresco.



Introducción

‣ El servidor de contenidos de Alfresco proporciona funcionalidades para capturar, gestionar y colaborar sobre contenidos usando servicios. Estos servicios son la base de la funcionalidad proporcionada por Alfresco.

‣ Alfresco expone estos servicios en varios niveles, incluyendo Java, scripting, REST, y servicios web. Algunos servicios son internos y otros son públicos. Por ejemplo, los servicios Java son internos.

‣ Los servicios se dividen en dos categorías.

‣ Servicios del repositorio de contenidos.

‣ Servicios de aplicación de contenidos.



Servicios del repositorio de contenidos

‣ Los servicios del repositorio de contenidos están escritos en Java y son los servicios fundamentales para la gestión de contenidos.

‣ Gestión de ficheros y carpetas.

‣ Versionado y checkin/checkout.

‣ Auditoría.

‣ Autenticación, autorización y permisos.

‣ Modelado.

‣ Búsqueda.




Content Repository

Embeddeb APIs



Servicios de aplicación de contenidos

‣ Los servicios de apliación de contenidos extiendo los servicios del repositorio para proporcionar capacidades evolucionadas necesarias para las aplicaciones colaborativas que manejan contenidos ricos. Se organizan como:

‣ Servicios de contenidos: reglas y acciones, transformaciones, extracción de metadatos.

‣ Servicios de control: flujos de trabajo, proyectos web, etc.

‣ Servicios de colaboración: comentarios, etiquetado, actividades, etc.




Content Repository

Content ServicesControl Services

Collaboration Services



Estructura de los servicios

‣ La mayoría de los servicios se construyen en tres capas: núcleo Java, servicio de script público y API RESTful.



Las APIs de Alfresco

‣ El servidor de contenidos de Alfresco ofrece dos tipos de APIs:

‣ APIs remotas: usadas por clientes que se comunican con el servidor de contenidos de Alfresco de forma remota.

‣ APIs embebidas: usadas por extensiones que han sido desplegadas y se ejecutan dentro del servidor de contenidos de Alfresco.




Embeddeb APIs

Remote APIs




‣ Las APIs embebidas son usadas por extensiones de Alfresco que se ejecutan directamente contra el Servidor de contenidos de Alfresco. Existen tres APIs principales:

‣ Alfresco Java Foundation API: proporciona un conjunto de interfaces Java para el acceso a los servicios del repositorio.

‣ API JavaScript: javascript que nos permite acceder a los servicios de base.

‣ API Template: API de sólo lectura diseñada para renderizar salidas HTML, XML, JSON, y texto usando el motor de plantillas FreeMarker. Esta API usa una vista orientada a objetos del repositorio de contenidos combinándola con las plantillas.



‣ Alfresco permite definir extensiones sobre estas APIs:


Embeddeb APIs

Remote APIs

Extensions




‣ APIs embebidas:




‣ Las APIs remotas permiten a clientes conectarse desde una capa independiente para comunicarse con el servidor de aplicaciones de contenidos de Alfresco.

‣ Estas APIs se basan en servicios web basados en protocolos RESTful y CMIS, permitiendo así el desarrollo contra estas APIs usando un rango de lenguajes amplio (Java, PHP, Ruby, and .NET). Las APIs son:

‣ Alfresco API para contenido en Cloud: esta API permite acceder al contenido gestionado por Alfresco Cloud desde nuestra aplicación. Es RESTful, cada llamada es una petición HTTP, es decir, no se necesita ningún lenguaje de programación

‣ RESTful.

‣ CMIS: estándar que define servicios web y asociaciones tipo REST para trabajar con repositorios que cumplen este estándar.




‣ APIs remotas:



Alfresco Java Foundation Services

‣ Introducción.

‣ Acceso a la API.

‣ Los servicios disponibles.

‣ Conceptos importantes.

‣ Servicio de nodos NodeService.

‣ Inyección de servicios.

‣ Construir nuevos servicios.



Introducción

‣ Son el conjunto de servicios que propocionan acceso completo a todas las capacidades del repositorio de Alfresco.

‣ Es una API in-process, que significa que el cliente que la usa debe encontrarse en el mismo proceso que el repositorio.

‣ Por ejemplo, el cliente web Alfresco Explorer usa esta API y se encuentra empaquetado con el repositorio en el mismo war.

‣ Cada servicio se maneja en forma de interface Java. Spring Framework será el responsable de inyectar la implementación adecuada del servicio.



Acceso a la API

‣ Existen tres estrategias para acceder a estas interfaces en nuestro código:

‣ Mediante Inyección de dependencias.

‣ Acceso manual mediante el método Spring getBean() de Spring.

‣ Indirectamente mediante el servicio de Alfresco ServiceRegistry: el servicio de registro mantiene un listado de todos los servicios del repositorio disponibles.

Factory.getBean("AuthenticationService");

serviceRegistry.getAuthenticationService()



Acceso a la API

‣ La interface ServiceRegistry nos proporciona acceso a todos los servicios del core del repositorio:

// Inicializar el contextoApplicationContext ctx = ApplicationContextHelper.getApplicationContext();

// Se obtiene el servicio de registrosfinal ServiceRegistry serviceRegistry = (ServiceRegistry) ctx.getBean(ServiceRegistry.SERVICE_REGISTRY); // Se recupera el servicio de gestión de transaccionesTransactionService transactionService = serviceRegistry.getTransactionService();



Acceso a la API

‣ La interface ServiceRegistry se encuentra en el paquete org.alfresco.service, representa los servicios públicos del repositorio de Alfresco.

‣ Proporciona metadatos de cada servicio y acceso a cada uno de ellos mediante su interface:



Acceso a la API

‣ El servicio de registro proporciona diferentes métodos para acceder a los servicios:

‣ getActionService.

‣ getPermissionService.

‣ getAuthorityService.

‣ getFileFolderService.

‣ getScriptService.

‣ getWorkflowService.

‣ getNotificationService

‣ getAuditService

‣ ...



Los servicios disponibles

‣ Existe un servicio para cada funcionalidad disponible:

‣ NodeService: servicio de nodos. Nos permite crear, modificar, recuperar y borrar nodos, asociaciones, aspectos y propiedades.

‣ ContentService: servicio de contenidos. Proporciona métodos para acceder y transformar el contenido de los nodos.

‣ SearchService: servicio de búsqueda.

‣ Servicio AuthenticationService.

‣ Servicio TransactionService.

‣ ...



¿Cómo se crearon los servicios?

‣ Crear la implementación de la clase y la definición del bean:

<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN' 'http://www.springframework.org/dtd/spring-beans.dtd'>

<beans> <bean id="nodeService" class=” ... ”

... </bean>

http://www.springframework.org/dtd/spring-beans.dtd'






¿Cómo se crearon los servicios?

‣ Crear el proxy y la definición del bean:

‣ Por último, se registra el servicio.

<bean id="NodeService" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyInterfaces"> <list> <value>org.alfresco.service.cmr.repository.NodeService</value> </list> </property> <property name="target"> <ref bean="nodeService"/> </property>

...



Conceptos importantes

‣ Antes de seguir debemos tener en cuenta una series de conceptos importantes:

‣ Nodo y contenido.

‣ Namespaces o espacio de nombre.

‣ Los modelos de Alfresco.



Los nodos en Alfresco

‣ Cualquier nodo en Alfresco se modela mediante la clase NodeRef que se encuentra en el paquete org.alfresco.service.cmr.repository.

‣ Cualquier nodo de almacenamiento en Alfresco se modela mediante la clase StoreRef que se encuentra en el paquete org.alfresco.service.cmr.repository.

‣ Podemos encontrar más información en Alfresco Data Model API.




‣ El concepto StoreRef comprime dos elementos:

‣ Protocol del almacen: eso es el tipo de almacén.

‣ Store id: Idenficador del almacén.

‣ Ejemplos:

workspace://SpacesStore

archive://SpacesStore




‣ El concepto NodeRef comprime tres elementos:

‣ Los dos primeros asociados al store ref:

‣ protocolo: tipo de almacen.

‣ storeid: identificador del almacén.

‣ El tercero es el identificador del nodo dentro del almacén.

‣ UUID.

‣ Ejemplos:

workspace://SpacesStore/5af5a38b-e20a-4885-bbd1-4b3fde9b0dd3



Los espacios de nombre

‣ La clase NamespaceService nos proporciona acceso a los espacios de nombre que utiliza Alfresco por defecto para sus nodos:

// Espacio de nombres para contentNamespaceService.CONTENT_MODEL_1_0_URI

// Prefijo utilizado en el espacio de nombres contentNamespaceService.CONTENT_MODEL_PREFIX



Los modelos en Alfresco

‣ La identificación de tipos, aspectos, asociaciones, propiedades, etc, se realiza mediante objeto de la clase QName.

‣ Para facilitar el trabajo cuando se manejan elementos definidos por defecto en Alfresco, tenemos una clase que define constantes muy útiles, ContentModel.

‣ Algún ejemplo de constante:

// Identifica al tipo cm:contentContentModel.TYPE_CONTENT

// Identifica al tipo cm:folderContentModel.TYPE_FOLDER

// Identifica a la propiedad cm:nameContentModel.PROP_NAME..



Servicio de nodos NodeService

‣ Se encuentra en el paquete org.alfresco.service.cmr.repository:




‣ Como ya se ha comentado anteriormente, este servicio permite crear, modificar, recuperar y borrar nodos, asociaciones, aspectos y propiedades.

‣ Alguno de sus métodos:

‣ addAspect: este método añade un nuevo aspecto a un nodo dado.

‣ createNode: crea un nodo.

‣ deleteNode: borra un nodo.

‣ exists: verifica si existe un nodo.

‣ ...




‣ Ejemplos:

// Se recupera el nombre del fichero asociado al nodoString fileName = (String) nodeService.getProperty( nodeRef, ContentModel.PROP_NAME);

// Se recupera el valor de una propiedadQName PROP_QNAME_MY_PROPERTY = QName.createQName( "custom.model", "myProperty");

value = nodeService.getProperty(nodeRef, PROP_QNAME_MY_PROPERTY);

// Actualizar el valor de una propiedadQName PROP_QNAME_MY_PROPERTY = QName.createQName( "custom.model", "myProperty");

nodeService.setProperty(nodeRef, PROP_QNAME_MY_PROPERTY, value);




‣ Ejemplos:

// Se recupera el nodo padreChildAssociationRef childAssocRef = nodeService.getPrimaryParent(nodeRef);NodeRef parent = childAssociationRef.getParentRef();

// Se anade un aspecto a un nodoQName CUSTOM_ASPECT_QNAME = QName.createQName( "custom.model", "MyAspect");QName PROP_QNAME_MY_PROPERTY = QName.createQName( "custom.model", "myProperty");

Map<QName,Serializable> aspectValues = new HashMap<QName,Serializable>();aspectValues.put(PROP_QNAME_MY_PROPERTY, value);nodeService.addAspect(nodeRef, CUSTOM_ASPECT_QNAME, aspectValues);




‣ Más ejemplo en la siguiente url:

‣ http://wiki.alfresco.com/wiki/NodeRef_cookbook

http://wiki.alfresco.com/wiki/NodeRef_cookbook

http://wiki.alfresco.com/wiki/NodeRef_cookbook



Servicio de contenido ContentService

‣ Como ya se ha comentado antes, este servicio proporciona métodos para acceder y transformar el contenido de los nodos.




‣ Alguno de sus métodos:

‣ getReader: recupera un lector para una determinada propiedad.

‣ getWriter: recupera un escritor para trabajar sobre una determinada propiedad.

‣ getTransformer: se recupera un transformador para llevar a cabo una transformación.




‣ Ejemplos:

// Leer el contenido de un nodoContentReader reader = contentService.getReader( nodeRef, ContentModel.PROP_CONTENT);String content = reader.getContentString();

// Leer el contenido de un nodo en binarioContentReader reader = contentService.getReader(nodeRef, ContentModel.PROP_CONTENT);InputStream originalInputStream = reader.getContentInputStream();ByteArrayOutputStream outputStream = new ByteArrayOutputStream();final int BUF_SIZE = 1 << 8; //1KiB bufferbyte[] buffer = new byte[BUF_SIZE];int bytesRead = -1;while((bytesRead = originalInputStream.read(buffer)) > -1) { outputStream.write(buffer, 0, bytesRead);}originalInputStream.close();byte[] binaryData = outputStream.toByteArray();




‣ Ejemplos:

// Escribir el contenido de un nodoContentWriter writer = contentService.getWriter(nodeRef, ContentModel.PROP_CONTENT, true);writer.putContent(new ByteArrayInputStream(content));

// Escribir el contenido de un fichero en un nodoContentWriter writer = contentService.getWriter(nodeRef, ContentModel.PROP_CONTENT, true);writer.setLocale(CONTENT_LOCALE);File file = new File("c:/temp/images/BigCheese1.bmp");writer.setMimetype("image/bmp");writer.putContent(file);



Inyección de servicios

‣ Si necesitamos utilizar alguno de estos servicios dentro de cualquiera de la extensiones desarrolladas en Alfresco, tendremos que aplicando Inyección de Dependencias (gracias a Spring Framework), ponerlos a disposición de nuestro código.

‣ El fichero public-services-context.xml que se encuentra en la carpeta “${tomcat}/webapps/alfresco/WEB-INF/classes/alfresco” define la mayor parte de los servicios:


<beans> <import resource="classpath:alfresco/public-services-security-context.xml"/>





‣ Servicio de registro: si queremos inyectar este servicio en nuestras clases tendremos que usar el id ServiceRegistry.


<beans> <import resource="classpath:alfresco/public-services-security-context.xml"/>

 <bean id="ServiceRegistry" class="org.alfresco.repo.service.ServiceDescriptorRegistry" />

‣ Servicio de búsqueda: si queremos hacer referencia a este servicio tendremos que usar el id SearchService:

<bean id="SearchService"

class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyInterfaces"> <value>org.alfresco.service.cmr.search.SearchService</value> </property> <property name="target"> <ref bean="searchService"/> </property> ...

</bean>

‣ Servicio de nodos: si queremos hacer referencia a este servicio tendremos que usar el id NodeService:

<bean id="NodeService" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyInterfaces"> <list> <value>org.alfresco.service.cmr.repository.NodeService</value> </list>

...

</bean>

‣ Servicio de contenidos: si queremos hacer referencia a este servicio tendremos que usar el id ContentService:

<bean id="ContentService" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyInterfaces"> <value>org.alfresco.service.cmr.repository.ContentService</value> </property> <property name="target"> <ref bean="contentService"/> </property> <property name="interceptorNames">

...

</bean>




‣ Ejemplos:


<beans> <bean id="webscript.org.alfresco.search.document-searcher.get" parent="webscript" class="com.ematiz.webscripts.ExpSearcher">

<property name="searchService"><ref bean="SearchService" />

</property>...

</bean> ...







Construir nuevos servicios

‣ Los servicios de Alfresco se contruyen usando tres capa:

‣ Core Java,

‣ Un servicio script público.

‣ Una API RESTful.



Construir nuevos servicios

‣ Cada capa tiene las siguientes características:

‣ API Java embebida: es una API implementada en Java, encapsulando todas las funcionalidades proporcionada por el servicio y es típicamente una collección de métodos sin estado. Se considera una API sólo accesible para los desarrolladores

‣ API JavaScript: es una interface desarrollada sobre la API Java embebida, proporcionando interfaces amigables sobre las capacidades del sistema.

‣ API RESTful: se diseña entorno a recursos y datos para proporcionar una API basada en URLs que pueden llamarse desde cualquier lenguaje. Habitualmente, se construyen sobre los servicios Script.



Alfresco API JavaScript

‣ Introducción.

‣ Objetos raíz (Root Scope Objects).

‣ ScriptNode API.

‣ API de creación y modificación.

‣ Ejemplos.



Introducción

‣ La API Alfresco JavaScript permite a los desarrolladores crear ficheros JavaScript para acceder, modificar y crear objetos en el repositorio de Alfresco. Proporciona un modelo orientado a objetos para manejar conceptos como nodos, propiedades, asociaciones y aspectos.

‣ La API es similar a API Template de Alfresco. La primera permite modificar, crear nodos, aspectos, etc.

‣ Usando esta API podemos:

‣ Encontrar nodos via XPath y directamente via NodeRef o path.

‣ Realizar búsquedas incluyendo búsquedas a texto completo con resultados ordenados.

‣ Navegando por jerarquía de nodos, examinar y modificar el valor de propiedades, aspectos y asociaciones.

‣ Transformar y manipular contenido.



Introducción

‣ Usando esta API podemos (cont.):

‣ Procesar proyectos web WCM y objetos AVM.

‣ Crear grupos, personas y modificar permisos.

‣ Además, estos scripts pueden crear nuevos ficheros, carpetas, nodos de cualquier tipo, copiar/mover/borrar nodos y crear/modificar/borrar hijos, etc.

‣ Los scripts pueden incluir otros scripts (import). Esto significa que el desarrollador puede utilizar librerías de scripts.



Introducción

‣ La API Alfresco JavaScript proporciona acceso a objetos Java.

‣ Tendremos acceso a objetos root por defecto, por ejemplo:

‣ Carpetas home del usuario y home company.

‣ Proyectos web WCM.

‣ Búsquedas.

‣ People API.

‣ Funcionalidades relacionadas con logging.

‣ Además es posible añadir otros objetos como objetos raíz para usar en nuestros scripts.



Objetos raíz (Root Scope Objects)

‣ La mayor parte de estos objetos se conocen como Script Node objects y modelan conceptos como nodos, aspectos, asociaciones, etc.

‣ Tenemos a nuestra disposición diferentes APIs para manejar estos objetos:

‣ ScriptContent API.

‣ Permission and Security API.

‣ Check in/Check out API.

‣ Versions API.

‣ Transformation API.

‣ ...

‣ Para más información http://wiki.alfresco.com/wiki/4.0_JavaScript_API.

http://wiki.alfresco.com/wiki/4.0_JavaScript_API






Objetos raíz (Root Scope Objects)



ScriptNode API

‣ Los objetos companyhome, userhome, document, space, y person representan objetos de tipo nodo y proporcionan acceso a propiedades, aspectos y asociaciones.

‣ La API ScriptNode puede utilizarse dentro de nuestros scripts:



ScriptNode API

‣ Una funcionalidad muy útil es que cualquier propiedad de tipo d:noderef se convierte automáticamente en otro objeto de tipo ScriptNode.

‣ Si un documento tiene una propiedad locale de tipo nodeRef:

‣ Adicionalmente, cualquier propiedad de tipo d:content se convierte en objeto de tipo ScriptContent. Por ejemplo:

var name = person.properties.usernamevar locale = document.properties.locale.properties.name;

var mimetype = document.properties.content.mimetype;var content = document.properties.content.content;



ScriptNode API



ScriptNode API

‣ Ejemplo:

mynode.assocs["cm:translations"][0]

mynode.sourceAssocs["cm:translations"][0]

myforumnode.childAssocs["fm:discussion"][0]

mynode.parentAssocs["cm:contains"][0]



ScriptNode API



API de creación y modificación

‣ La ScriptNode API no permite modificar muchas propiedades puesto que son de sólo lectura. Sin embargo provee alternativas para hacerlo.

‣ La API de creación y modificación nos ofrece cantidad de funciones para realizar este tipo de operaciones.




‣ Ejemplo: se añade un aspecto. El método addAspect realiza esta operación.

var props = new Array(1);props["cm:template"] = document.nodeRef;document.addAspect("cm:templatable", props);

props = new Array(1);props["cm:lockIsDeep"] = true;document.addAspect("cm:lockable", props);

props = new Array(1);props["cm:hits"] = 1;document.addAspect("cm:countable", props);




‣ Ejemplo: se crea un documento en la carpeta de usuario.

‣ El método createFile realiza esta operación.

var doc = userhome.createFile("checkmeout.txt");doc.content = "original text";




‣ Ejemplo: se crean nodos mediante diferentes estrategias.

‣ El método createFile realiza esta operación.

var node1 = userhome.createNode("create test1.txt", "cm:content");node1.content = "node1 content";

var node2 = userhome.createNode(null, "sys:base");

var props = new Array();props["cm:name"] = "create test3.txt";var node3 = userhome.createNode(null, "cm:content", props);

props["cm:name"] = "node name4.txt";props["cm:title"] = "node title4";var node4 = userhome.createNode(null, "cm:content", props, "cm:contains");



Ejemplos

‣ Crear el backup de un documento:

// find the backup folder - create if not already existsvar backupFolder = space.childByNamePath("Backup");if (backupFolder == null && space.hasPermission("CreateChildren")){ // create the folder for the first time backupFolder = space.createFolder("Backup");}if (backupFolder != null && backupFolder.hasPermission("CreateChildren")){ // copy the doc into the backup folder var copy = document.copy(backupFolder); if (copy != null) { // change the name so we know it's a backup copy.name = "Backup of " + copy.name; copy.save(); }}



Ejemplos

‣ Crear el backup de un documento:

‣ Se utilizar el objeto raíz space y apoyándose en el método childByNamePath se recupera el nodo que representa a la carpeta de backup.

‣ El método hasPermission comprueba si el usuario tiene permisos para crear hijos. El método createFolder crea la carpeta

// find the backup folder - create if not already existsvar backupFolder = space.childByNamePath("Backup");

if (backupFolder == null && space.hasPermission("CreateChildren")){ // create the folder for the first time backupFolder = space.createFolder("Backup");}



Ejemplos

‣ Para ver más ejemplos:

‣ http://wiki.alfresco.com/wiki/JavaScript_API_Cookbook

http://wiki.alfresco.com/wiki/JavaScript_API_Cookbook

http://wiki.alfresco.com/wiki/JavaScript_API_Cookbook



Alfresco Freemarker Templating API

‣ Introducción.

‣ Lenguaje de plantillas Freemarker.

‣ Modelo de datos.

‣ TemplateNode Model API.

‣ Más APIs.



Introducción

‣ Una plantilla es un documento que puede aplicarse a uno o varios objetos (por ejemplo, uno o más documentos de un repositorio) para generar otro documento. FreeMarker o XSLT son plantillas.

‣ La plantilla se escribe en un lenguage de plantillas específico.

‣ El modelo de datos será el conjunto de objetos disponible en la plantilla.

‣ Plantilla + Modelo de datos = salida

‣ El desarrollador necesita conocer el lenguaje de plantillas que debemos utilizar y el modelo de datos disponible.

http://www.freemarker.org/

http://www.freemarker.org/



Lenguaje de plantillas Freemarker

‣ Introducción.

‣ Trabajando con variables.

‣ Operadores de comparación.

‣ Operadores lógicos.

‣ Operadores numéricos.

‣ Operador concatenación.

‣ Vectores.

‣ Estructuras selectivas.

‣ Iteraciones.

‣ Directivas en Freemarker.



Introducción

‣ Alfresco trabaja por defecto con Freemarker.

‣ La extensión de los ficheros es ftl.

‣ Debemos ser capaces de generar plantillas siguiendo su sintaxis:

<html><head> <title>Welcome!</title></head><body> <h1>Welcome ${user}!</h1> <p>Our latest product: <a href="${latestProduct.url}">${latestProduct.name}</a>!</body></html>



Introducción

‣ FreeMarker es un motor de plantillas basado en Java. Se definen plantillas que no son más que ficheros de texto que contienen la salida deseada, excepto determinadas variables ${name}, y directivas (if, bucles, etc).



Trabajando con variables

‣ Definición de variable:

‣ Ejemplo:

<#assign var_link= "http://www.ematiz.com">

<#assign nombreVariable [= valor]>

http://www.ematiz.com

http://www.ematiz.com




‣ Referencia de variables:

‣ Ejemplo:

<a href="${var_link}">Navega a la web</a>

${nombreVariable}




‣ El operador punto:

(root) |+- book | | | +- title = "Breeding green mouses" | | | +- author

${book.title}

Otra alternativabook["title"]



Operadores de comparación

‣ = y == son equivalentes.

‣ !=

<#if user = "Big Joe"> It is Big Joe</#if><#if user != "Big Joe"> It is not Big Joe</#if>



Operadores de comparación

‣ <, <=, >= y >

‣ Cuidado con > y >=

‣ Podemos usar > y <

‣ También se puede utilizar \lt, \lte, \gt y \gte

<#if (x > y)>...

<#if (x > y)>...



Operadores lógicos

‣ Función OR: ||

‣ Función AND: &&

‣ Función NOT: !

‣ Ejemplo:

<#if x < 12 && color = "green"> We have less than 12 things, and they are green.</#if><#if !hot> <#-- here hot must be a boolean --> It's not hot.</#if>



Operadores numéricos

‣ Suma: +, Resta: -, Multiplicación: *, División: /, Módulo (resto): %

‣ Ejemplos:

${100 - x * x}${x / 2}${12 % 10}

752.52



Operador concatenación

‣ Operador suma.

${3 * "5"} <#-- Error -->

${3 + "5"} <#-- OK -->



Vectores

‣ Sintaxis:

‣ Ejemplo:

<#assign seq = ["winter", "spring", "summer", "autumn"]>

<#assign nombreArray = ["value1", "value2", ... ]>



Vectores

‣ Propiedades:

‣ first, last

‣ join

‣ seq_contains, seq_index_of, seq_last_index_of

‣ reverse

‣ size

‣ sort, sort_by

‣ chunk

‣ Más información:

‣ http://freemarker.org/docs/ref_builtins_sequence.html.

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_first

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_first

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_last

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_last

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_join

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_join

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_seq_contains

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_seq_contains

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_seq_index_of

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_seq_index_of

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_seq_last_index_of

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_seq_last_index_of

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_reverse

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_reverse

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_size

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_size

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_sort

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_sort

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_sort_by

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_sort_by

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_chunk

http://freemarker.org/docs/ref_builtins_sequence.html#ref_builtin_chunk

http://freemarker.org/docs/ref_builtins_sequence.html

http://freemarker.org/docs/ref_builtins_sequence.html



Vectores

‣ Ejemplos:

<#assign colors = ["red", "green", "blue"]>${colors?join(", ")}

Salida

red, green, blue

<#assign seq = ["winter", "spring", "summer", "autumn"]>${seq?size}

Salida

4



Estructuras selectivas

‣ Sintaxis:

‣ Ejemplo:

<#if condition> ...

<#elseif condition2> ...

<#elseif condition3> ...

<#else> ...

</#if>

<#if x == 1> x is 1<#else> x is not 1</#if>



Iteraciones

‣ Sintaxis:

‣ Tiene dos variables especiales disponibles dentro del bucle:

‣ item_index: valor numérico que contiene el índice del elemento sobre el que se está iterando.

‣ item_has_next: booleando que indica si el elemento sobre el que nos encontramos es el último.

‣ Ejemplo:

<#list sequence as item> ...</#list>

<#assign seq = ["winter", "spring", "summer", "autumn"]><#list seq as x> ${x_index + 1}. ${x}<#if x_has_next>,</#if></#list>



Iteraciones

‣ Ejemplos:

<#assign x=3><#list 1..x as i>

${i}</#list>

<#list seq as x> ${x} <#if x = "spring"><#break></#if> </#list>



Directivas en Freemarker

‣ assign.

‣ import.

‣ include.

‣ macro.

‣ ...



Más información

‣ http://freemarker.org/docs/index.html

http://freemarker.org/docs/index.html

http://freemarker.org/docs/index.html



Modelo de datos

‣ El modelo es un objeto o jerarquía de objetos que puede utilizar la plantilla para generar la salida.

‣ Se muestran a continuación:



Modelo por defecto



TemplateNode Model API

‣ Esta API proporciona un conjunto de propiedades:

‣ properties, children

‣ assocs, childAssocs

‣ aspects, hasAspect(String aspectName)

‣ isContainer, isDocument, isCategory

‣ content, url, downloadUrl, ...

‣ Más información

‣ http://wiki.alfresco.com/wiki/Template_Guide#TemplateNode_Model_API




‣ Ejemplo: properties es un mapa que almacena las propiedades de los nodos.

‣ Ejemplo:

<#assign props = document.properties?keys>

Found: ${companyhome.nodeByReference["workspace://SpacesStore/e661dccb-ecc0-11da-9974-63f65406985a"].id}




‣ Ejemplos:

<b>Company Home Space:</b> ${companyhome.properties.name}

<b>My Home Space children count:</b> ${userhome.children?size}

<b>Locked:</b> <#if document.isLocked>Yes<#else>No</#if>




‣ Ejemplos: Para acceder a una propiedad, sólo la segunda opción es correcta.

<b>wrong:</b> ${document.properties.myprop} <br> <b>ok:</b> ${document.properties["my:myprop"]}




‣ Ejemplos: Iteración sobre todas las propiedades del documento.

<table> <#assign props = document.properties?keys> <#list props as t> <#-- If the property exists --> <#if document.properties[t]?exists> <#if document.properties[t]?is_date> <tr><td>${t} = ${document.properties[t]?date}</td></tr> <#elseif document.properties[t]?is_boolean> <tr><td>${t} = ${document.properties[t]?string("yes", "no")}</td></tr> <#else> <tr><td>${t} = ${document.properties[t]}</td></tr> </#if> </#if> </#list> </table>




‣ Ejemplos: listado de los documentos dentro de la carpeta de usuario.

<table> <#list userhome.children as child> <#if child.isDocument> <tr><td>${child.properties.name}</td></tr> <#if child.mimetype = "text/plain"> <tr><td style='padding-left:16px'>${child.content}</td></tr> <#elseif child.mimetype = "image/jpeg"> <tr> <td style='padding-left:16px'> <img width=100 height=65 src="/alfresco${child.url}"> <td> </tr> </#if> </#if> </#list> </table>




‣ Ejemplo:

‣ El método childrenByLuceneSearch devuelve un mapa con el resultado de la búsqueda contra el repositorio completo basado en la cadena de búsqueda Lucene.

‣ Todos los nodos que coinciden con el criterio son recuperados, la búsqueda se realiza sobre todo el repositorio.

userhome.childrenByLuceneSearch (‘cadenaLucene’)



Más APIs

‣ Tenemos a nuestra disposición otras APIs responsables de:

‣ Versionado.

‣ Clasificación.

‣ Procesado XML.

‣ Flujos de trabajo.

‣ ...

‣ Para más información:

‣ http://wiki.alfresco.com/wiki/Template_Guide#Version_History



Subsistemas

‣ Introducción.

‣ Listado de subsistemas.



Introducción

‣ Un subsistema es un módulo configurable responsable de una parte de una funcionalidad de Alfresco. Típicamente, un subsistema envuelve un área funcional opcional, tales como, IMAP binding o con varias implementaciones alternativas como el subsistema de autenticación.

‣ Podemos imaginarlo como un miniservidor embebido dentro del servidor principal. Se puede arrancar y parar de forma independiente y, también se configura de forma independiente.

‣ Tiene su propio contexto de Spring (Spring Application Context) y su configuración.

‣ Este contexto es hijo del principal. Eso significa que puede referenciar cualquier bean del contexto principla.

‣ Sin embargo, los beans de los subsistemas no se ven desde el contexto principal y la comunicación entre ellos sólo puede realizarse mediante la importación explícita de interfaces.



Introducción

‣ Esto significa que:

‣ Podemos tener múltiples instancias del mismo tipo: la misma plantilla de configuración de Spring puede inicializarse con diferentes parámetros en diferentes instancias. Esto permite, por ejemplo, la definición de una cadena de múltiples subsistemas de autenticación gracias a la edición de ficheros de propiedades (o JMX para la versión empresarial).

‣ Los subsistemas puede controlarse vía JMX (versión empresarial).

‣ Tienen su propio espacio de nombres para sus beans: de esa forma no existe la posibilidad de conflictos de nombrado.

‣ Interfaces perfectamente definidas: se pueden importar en cualquier otro sitio del sistema.

‣ Implementaciones específicas ocultas.

‣ Pueden cambiar de implementación.



Listado de subsistemas

‣ Authentication.

‣ Synchronization.

‣ File Servers.

‣ Third Party.

‣ IMAP.

‣ WCM Deployment Receiver.

‣ sysAdmin.



Seguridad y autenticación en Alfresco

‣ Introducción.

‣ Seguridad en Alfresco.

‣ Autenticación.

‣ Autorización.

‣ Definición de permisos.



Introducción

‣ En este capítulo vamos a hablar sobre la autenticación y las funcionalidades contruidas sobre Alfresco para gestionar usuarios y grupos, autenticación de usuarios, permisos y control de acceso.

‣ También analizaremos cómo personalizar Alfresco para que trabaje con módulos, tales como, LDAP, NTLM, Kerberos y otros protocolos de autenticación.



Introducción

‣ La primera vez que se accede a una instalación de Alfresco mediante el cliente web Explorer, Alfresco nos identifica como usuario guest.

‣ Nos podemos autenticar con otro usuario haciendo click en el enlace de login y poniendo nuestro usuario y contraseña.

‣ Si se autentica con privilegios de administrador, podrá usar la consola de administración para crear nuevos usuarios y asignar contraseñas.

‣ Por defecto, puedes gestionar los usuarios base y sus contraseñas manualmente, y los usuarios no autenticados tendrá acceso limitado como usuarios guest.



Introducción

‣ A partir de aquí, hay un conjunto de personalizaciones que podemos realizar si queremos mejorar las posibilidades del sistema, por ejemplo:

‣ Deshabilitar el acceso usuarios no autenticados, guest.

‣ Habilitar autenticación automática usando las credenciales del sistema operativo o un servidor de SSO para eliminar la necesidad de una página de login.

‣ Delegar la responsabilidad de la autenticación en un servidor de directorio, eliminando así la necesidad de configurar manualmente usuarios desde la consola de administración.



Seguridad en Alfresco

‣ La seguridad en Alfresco trabaja con dos conceptos importantes: autenticación y autorización.

‣ Alfresco normalmente trabaja con el concepto de usuario y sus credenciales pueden encontrarse en diferentes formatos y validarse de diferentes formas. Por ejemplo, una contraseña puede validarse contra un LDAP o un ticket de Kerberos puede validarse contra Microsoft Active Directory Server.

‣ Alfresco incluye:

‣ Implementación de autenticación interna basada en contraseñas.

‣ Soporte para integrarse con diferentes entornos de autenticación externos.

‣ La posibilidad de generar una integración de autenticación propia.




‣ La autorización determina qué operaciones puede realizar un usuario autenticado. Existen diferentes modelos de autenticación: Role Based Access Control (RBAC), UNIX-style Access Control Lists (ACLs), extended ACLs, Windows-style ACLs y otros muchos.

‣ La autorización en Alfresco se basa en UNIX-extended ACLs. Cada nodo tiene un ACL que usa para asignar permisos a grupos y usuarios.

‣ Operaciones, tales como crear un nodo, describen qué permisos son necesarios para realizar la operación. Las ACLs se usan para determinar si un usuario dado puede ejecutar la operación basada en los permisos que han sido asignados directamente al usuario o indirectamente al grupo.

‣ Las operaciones en Alfresco se ejecutan a partir de un método público asociado a un bean. La invocación del método comprueba que el usuario tiene permisos para realizar esta operación.




‣ Por convención, los beans que ofrecen estos servicios públicos son los beans cuyos nombres empiezan en mayúscula, por ejemplo, NodeService, SearchService o ContentService.

‣ La configuración de requisitos de seguridad para estos beans se definen en ficheros xml. Un determinado método puede estar disponible para todos los usuarios, todos los usuarios de un determinado grupo, todos los usuarios de un determinado role, etc.

‣ Adicionalmente, para los métodos que devuelven colecciones o arrays pueden filtrarse en función de los permisos del usuario. Si los requisitos de autorización no se cumplen, la llamada al método fallará y lanzará la excepción AccessDeniedException.




‣ La asignación de permisos se realiza mediante listas de control de acceso (Access Control Lists, ACLs).

‣ Estas listas son listas de control de entradas (Access Control Entries, ACEs). Éstas asocian una autoridad con un permiso o conjunto de permisos, y define si el permiso se deniega o permite para la autoridad.

‣ Cada nodo tiene un ACL. Cuando se crea un nodo, éste automáticamente hereda la ACL de su padre. Una vez que el nodo se ha creado, se puede alterar su comportamiento rompiendo la herencia o modificando su ACL.

‣ La configuración XML para los permisos también define un contexto ACL libre para los ACEs que se aplican sobre los nodos.

‣ Por ejemplo, puedes usarlo para asignar acceso en modo lectura para todo el mundo para todos los nodos independientemente de que ACLs individuales asignadas a cualquier nodo.

<globalPermission permission="Read" authority="GROUP_EVERYONE" />



Autenticación

‣ Introducción.

‣ Subsistemas de autenticación.

‣ Tipos de subsistemas.

‣ Cadena de autenticación.

‣ AlfrescoNTML.

‣ pass-through.



Introducción

‣ La autenticación es una de las categorías de subsistemas que encontramos en Alfresco.

‣ El subsistema de autenticación es una pila coordinada de componentes compatibles responsables de proporcionar funcionalidades de autenticación e identificación en Alfresco.

‣ Alfresco ofrece diferentes implementaciones del subsistema de autenticación.



Subsistemas de autenticación

‣ La autenticación y la gestión de identidades se gestiona gracias a un conjunto de módulos software configurables llamados subsistemas.

‣ El subsistema de autenticación proprociona las siguientes funciones a Alfresco:

‣ Autenticación basada en contraseña para navegador, protocolo Microsoft SharePoint, FTP y WebDAV.

‣ Autenticación para los sistemas de ficheros CIFS y NFS.

‣ Single sign-on (SSO) para navegador, protocolo Microsoft SharePoint y WebDAV.

‣ Exportación de registro de usuarios.



Tipos de subsistemas



Cadena de autenticación

‣ Es muy habitual que al menos uno de los tipos anteriormente comentados nos permita integrar Alfresco con el servidor de autenticación que se utiliza en nuestra organización.

‣ Sin embargo, puede ocurrir que la integración con alguno de estos sistemas no sea suficiente. Por diferentes razones, puede ocurrir que queramos mezclar diferentes protocolos de autenticación.

‣ Esta es la razón por la cuál Alfresco ha diseñado una cadena de autenticación. No es más que una lista de subsistemas de autenticación ordenada por prioridad. Cada subsistema tiene:

‣ Un tipo.

‣ Un nombre único que lo distingue de otras instancias del mismo tipo.

‣ Un conjunto de valores proporcionados por la configuración del usuario.



Cadena de autenticación

‣ Configuración de la cadena de autenticación:

‣ Edición del fichero alfresco-global.properties que se encuentra en la ruta <installLocation>\shared\classes.

‣ La propiedad authentication.chain declara la cadena de autenticación de Alfresco. Su valor será una lista separada por comas de instancias de autenticación.

‣ Cada instancia se declara con un nombre seguido de “:” y el tipo de subsistema.

instance_name1:type1, instance_name2:type2, ..., instance_namen:typen



AlfrescoNTML

‣ El mecanismo de autenticación que ofrece Alfresco, por defecto, es una cadena de autenticación con una única instancia de un subsistema de tipo alfrescoNtlm.

‣ El proceso de autentición se basa en la información de usuarios y contraseñas almacenada en el repositorio de Alfresco.

‣ Proporciona soporte a autenticación mediante formulario y SSO basada en NTLM, además de, autenticación mediante servidor CIFS.

‣ Nota: SSO con NTML, por defecto, se encuentra desactivado.



AlfrescoNTML

‣ Edición del fichero alfresco-global.properties que se encuentra en la ruta <installLocation>\shared\classes.

‣ La propiedad authentication.chain declara la cadena de autenticación de Alfresco. Su valor será una lista separada por comas de instancias de autenticación.

‣ Cada instancia se declara con un nombre seguido de “:” y el tipo de subsistema.

authentication.chain=alfinst:alfrescoNtlm



AlfrescoNTML

‣ Configuración de la instancia:

‣ Debemos crear un directorio dentro de la carpeta de extensiones de Alfresco, <installLocation>\shared\classes\alfresco\extension\subsystems\Authentication\alfrescoNtlm\alfinst



pass-through

‣ El subsistema passthru puede reemplazar el sistema de autenticación con un controlador Windows server/domain para autenticar a los usuarios en Alfresco. Este sistema elimina la necesidad de crear cuentas de usuarios dentro de Alfresco.

‣ Passthru ofrece soporte a Single Sign-On (SSO) mediante NTLM para WebDav y los clientes web Alfresco Explorer and Share, autenticación CIFS mediante servidores CIFS.

‣ Sólo ofrece soporte a NTLM v.1. La versión 2 de NTLM ha sido diseñado para evitar ataques "man-in-the-middle", no es posible implementarla en pass-through.



LDAP

‣ El sistema LDAP ofrece dos funciones principales:

‣ Autenticación de usuario: comprobación del id de usuario y contraseña usando un LDAP.

‣ Exportación del registro de usuario: se expone información sobre usuarios y grupos para la sincronización del subsistema.

‣ Estas funciones pueden utilizarse de forma aislado o en conjunción. Cuando la autenticación se usa sin la exportación de registro de usuarios, los objetos se crean automáticamente para todos los usuarios que hacen log in.



Kerberos

‣ El servicio de autenticación y autorización Java (JAAS) se usa dentro del subsistema Kerberos para soportar autenticación Kerberos mediante nombres de usuarios y contraseña.

‣ Debemos seleccionar Kerberos contra un servidor Active Directory.

‣ Los incovenientes de usar autenticación LDAP contra Active Directory comparados con JAAS/Kerberos son:

‣ La solución más simple es usar el protocolo de autenticación SIMPLE LDAP, usado con SSL.

‣ AD necesita un setup especial para usar autentiación digest MD5.

‣ LDAP puede usar GSSAPI y Kerberos, sería equivalente pero más complejo a la hora de aplicar su configuración.



External

‣ El subsistema external se usa con cualquier sistema de autenticación externo.

‣ Este sistema puede integrarse con un servidor de aplicaciones de tal forma que la identidad de los usuarios logados se pasan a los servlets mediante el método HttpServletRequest.getRemoteUser().

‣ Como esta es la forma estándar de propagar las identidades de los usuarios a los servlets, sería compatible con un número de soluciones SSO, incluyendo Central Authentication Service (CAS).

‣ La activación de autenticación external hace que Alfresco acepte tokens de autenticación externos, debemos asegurar que no se producen accesos directos a los puertos HTTP o AJP de Alfresco.



Autoridades

‣ Las autoridades que maneja Alfresco son personas o grupos de personas.

‣ Un grupo puede contener personas u otros grupos.

‣ Las autoridades asignadas a un usuario son su userName (Person node), todos los grupos a los que pertenece y cualquier autoridad dinámica. Las autoridades dinámicas son usadas por roles internos.



Definición de permisos

‣ Los permisos se definen en un fichero de configuración XML. El fichero por defecto se encuentra en:

‣ Esta configuración puede ser reemplazada o extendida seguiendo la DTD definida en:

<installLocation>\tomcat\webapps\alfresco\WEB-INF\classes\alfresco\model\permissionDefinitions.xml

<installLocation>\tomcat\webapps\alfresco\WEB-INF\classes\alfresco\model\permissionSchema.dtd

Definición de permisos

‣ Ejemplo: definición de permisos asociados al aspecto Ownable.

<permissionSet type="cm:ownable" expose="selected">  <permissionGroup name="TakeOwnership" requiresType="false" expose="false"> <includePermissionGroup permissionGroup="SetOwner" type="cm:ownable" /> </permissionGroup> <permissionGroup name="SetOwner" requiresType="false" expose="false"/>  <permission name="_SetOwner" expose="false" requiresType="false"> <grantedToGroup permissionGroup="SetOwner" /> <requiredPermission on="node" type="sys:base" name="_WriteProperties" /> </permission></permissionSet>



Extension classpath

‣ Introducción.

‣ Sintaxis.

‣ Ejemplo.



Introducción

‣ El fichero alfresco-global.properties sólo puede usarse para definir propiedades globales a todo el sistema.

‣ Pero la verdad es que también podemos controlar propiedades que afectan a subsistemas, por ejemplo, los subsistemas de autenticación.

‣ Ahora bien, para hacer esto, necesitamos definir diferentes valores para las mismas propiedades, para cada instancia del subsistema.

‣ Para resolver este problema aparece un mecanismo llamado extension classpath.



Sintaxis

‣ Añadir un fichero de propiedades al classpath global del servidor.

‣ Para el caso de Tomcat sería $TOMCAT_HOME/shared/classes

‣ Se crea la ruta que coincide con el siguiente patrón para sobreescribir las propiedades específicas de la instancia del subsistemas:

‣ <id> es el identificador de la instancia del subsistema, que debe ser el valor por defecto para subsistemas con una única instancia o el identificador proporcionado en la cadena de subsistemas.

alfresco/extension/subsystems/<category>/<type>/<id>/*.properties



Ejemplo

‣ Si la cadena de autenticación fuera la siguiente:

‣ Entonces podríamos sobreescribir propiedades del subsistema alfrescoNtlm1 en el siguiente fichero:

authentication.chain=alfrescoNtlm1:alfrescoNtlm,ldap1:ldap

alfresco/extension/subsystems/Authentication/alfrescoNtlm/alfrescoNtlm1/mychanges.properties



Ejemplo

‣ El tipo por defecto y el id de subsistema sin cadenas es default, por lo tanto, para sobreescribir propiedades del servidor de ficheros (fileserver) tendríamos que añadir propiedades en el siguiente fichero:

alfresco/extension/subsystems/fileServers/default/default/mychanges.properties



Extensiones en Alfresco

‣ Alfresco can be freely customized and extended according to your needs.

‣ These customizations can be as simple as tweaking a single configuration file, or the development of a sophisticated module such as Records Management.



Extensiones en Alfresco: empaquetado y despliegue

‣ Introducción.

‣ Ficheros sin empaquetar o zips.

‣ Ficheros JAR.

‣ Ficheros AMP.

‣ Rutas de despliegue.

‣ Carpeta Shared Classpath.



Introducción

‣ Existen varias formas de empaquetar extensiones de Alfresco. Pasamos a describir cada una de ellas, incluyendo el empaquetado como módulo usando ficheros AMP.

‣ El mecanismo de empaquetado seleccionado depende mucho del tipo de extensión que se vaya a desarrollar.

‣ Para una extensión sencilla que consiste en uno o dos web scripts, la mejor opción será un fichero JAR que contenga los scripts, colocándolo en el classpath del servidor, por ejemplo, en tomcat ${tomcat_home}/shared/lib.

‣ Para extensiones más complejas, el desarrollo de un módulo sería la mejor opción, éste se empaqueta como fichero AMP y posteriormente se aplica al war en cuestión (alfresco.war or share.war).



Introducción

‣ Las opciones de empaquetado son:

‣ Ficheros sin empaquetar: ficheros individuales tales como web scripts pueden copiarse en el directorio de extensión.

‣ Ficherso zip: las extensiones se pueden empaquetar con ficheros Zip.

‣ Ficheros JAR: las extensiones se pueden empaquetar siguiendo el formato estándar JAR y ser cargado en el sistema mediante el shared classpath.

‣ Fichero AMP: este formato que debemos elegir en la mayor parte de la extensiones, especialemente cuando van a utilizarse en muchos sitios. La forma más recomendable de despliegue de extensiones en entornos de producción es ésta.



Ficheros sin empaquetar o zips

‣ La técnica de empaquetado más simple es copiar o descomprimir los ficheros de extensión en la jerarquía de directorios de Alfresco. Podemos mejorar el proceso utilizando algún lenguaje de script o herramientas de build como ANT. Con estas herramientas podemos empaquetar los ficheros en formato zip con la estructura de directorios adecuada, y descomprimirlos en la instalación de Alfresco.

‣ Esta técnica puede ser muy efectiva durante las primeras fases del desarrollo. Muchos entornos de desarrollo emplean procesos de build que pueden ejecutar scripts para mover los ficheros modificados hasta la aplicación (Ant, Bash, Maven o lenguajes de script).

‣ Mover ficheros independientes tiene la ventaja de ser rápido y fácil de entender, pero es mejor idea empaquetar en zip y, posteriormente, descomprimir en el sistema.

‣ Esta técnica no se recomienda en entornos QA o producción.



Ficheros JAR

‣ El formato JAR puede utilizarse para empaquetar diferentes tipos de extensiones. Una vez que la extensión se empaqueta en formato JAR, se puede cargar en las rutas estándares de classpath del servidor. Por ejemplo, para Tomcat sería ${tomcat}/shared/lib, o ${tomcat}/webapps/alfresco/WEB-INF/lib.

‣ Desde Alfresco 3.4, el cliente web Share soporta extensiones empaquetadas como ficheros JAR. Esto permite múltiples personalizaciones aisladas unas de otras y un orden de selección

‣ Los ficheros estáticos (JavaScript, CSS, o imágenes) pueden colocarse en el web root de Share, aunque también pueden empaquetarse dentro de JARs. Para desplegar estos JARs, se recomienda colocarlos en uno o más ficheros AMP, y desplegarlos posteriormente en Share.

‣ La instalación directa de JARs en la estructura de directorios de la aplicación no es una práctica recomendable, el servidor de aplicaciones puede sobreescribir los cambios.



Ficheros AMP

‣ Los ficheros AMP (Alfresco Module Packages) son la mejor forma de empaquetar extensiones en Alfresco.

‣ Estos ficheros son ZIPs que siguen un layout específico y puede ser fusionado con otros WAR tales como alfresco.war o share.war usando la herramienta Alfresco Module Management Tool (MMT). Esta herramienta está disponible en el directorio de instalación de Alfresco en alfresco-mmt.jar.

‣ El Alfresco SDK incluye varias herramientas (ANT) para gestionar estos procesos.

‣ En los últimos tiempos Maven Alfresco SDK proporciona un conjunto de herramientas para construir y desplegar ficheros AMP.

https://artifacts.alfresco.com/nexus/content/repositories/alfresco-docs/alfresco-lifecycle-aggregator/latest/index.html

https://artifacts.alfresco.com/nexus/content/repositories/alfresco-docs/alfresco-lifecycle-aggregator/latest/index.html



Rutas de despliegue

‣ Existen diferentes rutas donde poder desplegar las extensiones desarrolladas para Alfresco, dependiendo de la fase del ciclo de vida de desarrollo en el que nos encontremos, tipo de empaquetado y servidor de aplicaciones.

‣ Para Tomcat:

‣ Cuando el servidor está arrancado, alfresco.war se encuentra en formato carpeta en $CATALINA_HOME/webapps/alfresco. Para el servidor si está corriendo, copiar los ficheros de extensión a $CATALINA_HOME/webapps/alfresco/WEB-INF/ y reinciar Tomcat. Si por cualquier razón el servidor redespliega alfresco.war, las extensiones serán borradas y tendremos que redesplegarlas otra vez.

‣ Una solución es cambiar permanently exploded deployment. Crea un directorio llamado alfresco en el directorio webapps y extrae alfresco.war en él. Después copia los ficheros de extensión a $CATALINA_HOME/webapps/alfresco/WEB-INF/ y reinicia.



Carpeta Shared Classpath

‣ Muchas personalizaciones se pueden colocar en el servidor de aplicaciones. Por ejemplo:

‣ Ficheros de configuración de Alfresco, tales como share-config-custom.xml.

‣ Ficheros de contexto de Spring.

‣ Ficheros de propiedades, tales como, webclient.properties.

‣ Para Tomcat, la carpeta shared class loader es $CATALINA_HOME/shared/classes/alfresco/ para ficheros con clases.

‣ Para JBoss, la carpeta shared class loader es $JBOSS_HOME/server/default/conf/alfresco/.



Carpeta Shared Classpath

‣ En esta carpeta encontramos subdirectorios estándares:

‣ extension: para cambios en el repositorio o la interfaz de Alfresco Explorer.

‣ web-extension: para cambios en la interfaz de Alfresco Share.

‣ messages: para cadenas de caracteriors i18n.

‣ Los ficheros que se empaqueta en formato JAR debe colocarse en el directorio lib, por ejemplo, $CATALINA_HOME/shared/lib.



Classpath específico WAR

‣ Una mejor ruta para personalizaciones sería:

‣ $CATALINA_HOME/webapps/alfresco/WEB-INF/classes

‣ $CATALINA_HOME/webapps/alfresco/WEB-INF/lib (para JARs)

‣ $CATALINA_HOME/webapps/share/WEB-INF/classes

‣ $CATALINA_HOME/webapps/share/WEB-INF/lib (para JARs)

‣ Es muy común aplicar parches sobre los war de Explorer y Share para poner nuestro código en el lugar adecuado preservándolo de redespliegues del servidor de aplicaciones.

‣ Esto es lo que hace el script apply_amps, aplica tu fichero AMP al war que necesites usando Module Management Tool (MMT). Para tener mayor control sobre el proceso, en vez de usar este script se recomienda usar MMT directamente.

el core de alfresco 4.2

Technology