La guida descrive anche come creare un Liferay Plug-in Project. Sono avviabili tre tipologie di progetto: Portlet, Hook (plugin per la customizzazione ed estensione delle funzionalità base), Ext (plugin che permette una completa customizzazione di Liferay). Nell’immagine a lato una rappresentazione dell’alberatura di un progetto di tipo Portlet.

Questo articolo si limiterà a descrivervi come creare gli oggetti dell’area di configurazione della Portlet e quelli responsabili del rendering dei contenuti dinamici.

Area di Configurazione

In liferay-portlet.xml aggiungere la riga

<liferay-portlet-app>
   ...
   <portlet>
      ...
      <configuration-action-class>it.qbr.jsp.action.ConfigurationActionImpl</configuration-action-class>
      ...
   </portlet>
   ...
</liferay-portlet-app>

Creare in src la classe it.qbr.jsp.action.ConfigurationActionImpl che implementa com.liferay.portal.kernel.portlet.ConfigurationAction

@Override
public void processAction(PortletConfig portletConfig,
ActionRequest actionRequest, ActionResponse actionResponse)
throws Exception {

   String cmd = ParamUtil.getString(actionRequest, Constants.CMD);
   if (!cmd.equals(Constants.UPDATE)) {
      return;
   }

   String stringParameter = ParamUtil.getString(actionRequest, "stringParameter");
   long longParameter = ParamUtil.getLong(actionRequest, "longParameter");
   int intParameter = ParamUtil.getInteger(actionRequest, "intParameter");

   String portletResource = ParamUtil.getString(actionRequest,"portletResource");
   PortletPreferences preferences = PortletPreferencesFactoryUtil.getPortletSetup(actionRequest, portletResource);

   preferences.setValue("stringParameter", stringParameter);
   preferences.setValue("longParameter", String.valueOf(longParameter));
   preferences.setValue("intParameter", String.valueOf(intParameter));
   preferences.store();

   SessionMessages.add(actionRequest, portletConfig.getPortletName()+ ".doConfigure");
}

@Override
public String render(PortletConfig portletConfig,
RenderRequest renderRequest, RenderResponse renderResponse)
throws Exception {
   return "/configuration.jsp";
}

Creare init.jsp in modo da centralizzare il caricamento delle impostazioni della portlet.

<%@ taglib uri="http://java.sun.com/portlet" prefix="portlet" %>

<%@ taglib uri="http://liferay.com/tld/portlet" prefix="liferay-portlet" %>
<%@ taglib uri="http://liferay.com/tld/theme" prefix="liferay-theme" %>
<%@ taglib uri="http://liferay.com/tld/ui" prefix="liferay-ui" %>
<%@ taglib uri="http://liferay.com/tld/aui" prefix="aui" %>

<%@ page import="com.liferay.portal.util.PortalUtil" %>
<%@ page import="com.liferay.portal.kernel.util.Constants" %>
<%@ page import="com.liferay.portal.kernel.util.Validator" %>
<%@ page import="com.liferay.portlet.PortletPreferencesFactoryUtil" %>
<%@ page import="javax.portlet.PortletPreferences" %>
<%@ page import="com.liferay.portal.kernel.util.ParamUtil" %>
<%@ page import="com.liferay.portal.kernel.util.PrefsParamUtil" %>
<%@ page import="com.liferay.portal.kernel.util.StringPool" %>

<liferay-theme:defineObjects />
<portlet:defineObjects />

<%
String currentURL = PortalUtil.getCurrentURL(request);

PortletPreferences preferences = renderRequest.getPreferences();

String portletResource = ParamUtil.getString(request, "portletResource");

if (Validator.isNotNull(portletResource)) {
   preferences = PortletPreferencesFactoryUtil.getPortletSetup(request, portletResource);
}

String stringParameter = preferences.getValue("stringParameter", StringPool.BLANK);
long longParameter = Long.valueOf(preferences.getValue("longParameter", "0"));
int intParameter = Integer.valueOf(preferences.getValue("intParameter", "0"));
%>

A questo punto è possibile includere init.jsp in qualsiasi altra jsp per poter utilizzare le configurazioni.

Creare configuration.jsp, la pagina che renderizza il pannello di configurazione della portlet.

NOTA: il nome della jsp deve essere lo stesso del metodo render di ConfigurationActionImpl.

<%@include file="/init.jsp" %>
<liferay-portlet:actionURL portletConfiguration="true" var="configurationActionURL" />
<liferay-portlet:renderURL portletConfiguration="true" varImpl="configurationRenderURL" />
<aui:form action="<%= configurationActionURL %>" method="post" name="<portlet:namespace />fm">
   <aui:input name="<%= Constants.CMD %>" type="hidden" value="<%= Constants.UPDATE %>" />
   <aui:input name="redirect" type="hidden" value="<%= configurationRenderURL.toString() %>" />
   <liferay-ui:panel collapsible="<%= true %>" extended="<%= true %>" id="ap-abstract" persistState="<%= true %>" title="configuration">
      <aui:fieldset>
         <aui:input type="text" name="stringParameter" value="<%=stringParameter %>" />
         <aui:input type="text" name="longParameter" value="<%=longParameter %>" />
         <aui:input type="text" name="intParameter" value="<%=intParameter %>" />
      </aui:fieldset>
   </liferay-ui:panel>
   <aui:button-row>
      <aui:button type="submit" value="Save" />
   </aui:button-row>
</aui:form>

Rendering dei contenuti dinamici

In portlet.xml aggiungere

<portlet>
   ...
   <portlet-class>it.qbr.jsp.action.ApPortletAction</portlet-class>
   <init-param>
      <name>view-template</name>
      <value>/view.jsp</value>
   </init-param>
   ...
</portlet>

Creare in src la classe it.qbr.jsp.action.ApPortletAction che estende com.liferay.util.bridges.mvc.MVCPortlet. Questo vuol dire che la nostra Portlet utilizzerà l’MVC di Liferay, ma naturalmente è possibile realizzare portlet utilizzando MVC di Struts piuttosto che Spring MVC.

public class ApPortletAction extends MVCPortlet {

@Override
public void render(RenderRequest request, RenderResponse response)
throws PortletException, IOException {

   HttpServletRequest httpRequest = (HttpServletRequest) request.getAttribute(PortletServlet.PORTLET_SERVLET_REQUEST);
   ThemeDisplay themeDisplay = (ThemeDisplay) request.getAttribute(WebKeys.THEME_DISPLAY);
   Locale locale = themeDisplay.getLocale();

   PortletPreferences preferences = request.getPreferences();
   String portletResource = ParamUtil.getString(request, "portletResource");
   if (Validator.isNotNull(portletResource)) {
      try {
         preferences = PortletPreferencesFactoryUtil.getPortletSetup(request, portletResource);
      } catch (PortalException e) {
         e.printStackTrace();
      } catch (SystemException e) {
      e.printStackTrace();
      }
   }

   //Recupero parametri da portalResource
   String stringParameter = preferences.getValue("stringParameter", "");
   long longParameter = Long.valueOf(preferences.getValue("longParameter", "0"));
   int intParameter = Integer.valueOf(preferences.getValue("area", "0");

   String viewString = stringParameter + " è pari a " + longParameter*intParameter;
   request.setAttribute("viewString", viewString);
   super.render(request, response);
}

Modificare la view.jsp

<%@include file="/init.jsp" %>

<% String viewString = (String)renderRequest.getAttribute("viewString"); %>

<h3><%=viewString %></h3>

Finito. Supponendo di aver configurato la Portlet con i seguenti parametri:

stringParameter: “Il valore della moltiplicazione tra longParameter e intParameter”

longParameter: 3

intParameter: 4

la Portelet renderizzerà un frammento di codice che come quello che segue:

<h3>Il valore della moltiplicazione tra longParameter e intParameter è pari a 12</h3>

Ambiente di sviluppo e requisiti:

Eclipse Indigo Release (Build id: 20110319-2305)

Liferay IDE plugin per Eclipse v1.5.3.x o superiore

Sun jdk1.6.0_23 o superiore

Liferay: liferay-portal-6.1.0-ce-ga1, liferay-plugins-sdk-6.1.0

Gli Standard Java Portlet Specification (JSR168, JSR286) definiscono una convenzione tra il portlet container e le portlet e forniscono un modello pratico di programmazione per gli sviluppatori. Inoltre garantisce l’interoperabilità di portlet per diversi portali web. Questa specifica definisce un insieme di API per l’interazione tra il portlet container e la portlet in riferimento alle aree di personalizzazione, la presentazione e la sicurezza.

Liferay Portal aggiunge alla definizione di Portale una serie di caratteristiche che lo rendono unico:

Alfresco permette la gestione delle email secondo due modalità:

– Outbound email – Inbound email

Outbound email

Con questa modalità è possibile inviare email di notifica ad utenti registrati su Alfresco. Per tale operazione bisogna accedere con utenza di amministratore.

Per configurare Alfresco nella modalità Outbound è necessario modificare il file repository.properties posto nella directory seguente:

Alfresco_Home/tomcat/webapps/alfresco/WEBINF/classes/alfresco

Impostare le credenziali per l’accesso all’SMTP Server esterno, per esempio:

mail.host=out.alice.it mail.port=25 mail.username=anonymous mail.password=

Inbuound email

Con questa modalità è possibile configurare Alfresco come repository di email direttamente su un nodo. I test sono stati effettuati per email in ingresso, in un ambiente in cui è stato installato JAMES SMTPPOP3 Server e il modulo EmailCollector1.2 per Alfresco. Per configurare Alfresco in modalità Outbound procedere come segue:

– installare il modulo emailCollector ( http://forge.alfresco.com/frs/?group_id=166&release_id=380 ) utilizzando l’utility amp fornita in Alfresco

– abilitare il Servizio SMTP di Alfresco in ALFRESCO_HOME/tomcat/webapps/alfresco/WEBINF/classes/alfresco/emailse/emailserver.properties

– impostare:

mail.inbound.enabled=true email.inbound.unknownUser=anonymous

– copiare il file email.collector.properties fornito con il modulo emailCollector nella

directory seguente: ALFRESCO_HOME/tomcat/shared/classes/alfresco/extension

– impostare gli account POP dei vari utenti

– configurare gli utenti in Alfresco:

creazione account utenti

creazione utente anonymous

aggiunta degli utenti nel gruppo EMAL_CONTRIBUTORS

creazione degli space inbox “emailed” per tutti gli utenti

accesso in scrittura agli space per l’utente anonymous

– nel caso di problemi su “email alias” vedi http://forums.alfresco.com/en/viewtopic.php?f=9&t=13860

Liferay Portal dispone di molte portlet per la gestione integrata dei documenti e in generale di tutto il digital asset aziendale nei formati più conosciuti (testo, HTML, PDF, immagini, e altri media)

Nonostante questo supporto nativo alla gestione documentale sia fornito in modo eccellente dalla piattaforma, è spesso necessario pubblicare sul portale aziendale contenuti provenienti da altri ECMs (Enterprise Content Management System) esterni. E’ facile immaginare infatti che sul lungo periodo il portale Aziendale non si configuri sicuramente come l’unico strumento in cui i documenti sono prodotti (mentre probabilmente rimarrà il principale strumento di pubblicazione e fruizione degli stessi).

Ad esempio, il modello di riferimento in architetture Enterprise 2.0 per la gestione dei contenuti consiste nell’utilizzare internamente all’Azienda una piattaforma di Collaboration (come Alfresco Share o MS SharePoint) per organizzare i workflow di produzione dell’asset digitale. Tale produzione non dipende in genere dallo specifico canale di pubblicazione del contenuto. I documenti finalizzati dai vari workflow saranno ad esempio destinati all’archiviazione (inviati all’archivio corrente, al protocollo o in conservazione sostitutiva/legale) oppure alla pubblicazione su uno o più portali aziendali, in un’area pubblica o privata degli stessi, al fine di consentire ai documenti di essere facilmente accessibili attraverso un canale web (o mobile o comunque diretto ad un pubblico più ampio rispetto a quello accessibile dall’ambiente di Collaboration interno).

Al fine di semplificare l’interazione tra Area collaborativa interna e Liferay alcuni prodotti ECM come Alfresco forniscono alcune portlet che, opportunamente configurate, consentono di fruire dal portale Liferay dei documenti depositati sulla piattaforma ECM.

Nonostante questo supporto all’integrazione attraverso portlet sia supportato direttamente da Alfresco, spesso risulta insufficiente alle esigenze di verticalizzazione del Cliente finale che richiede forti personalizzazioni delle funzioni di comunicazione Portale-ECM. Tali spinte obbligano spesso ad abbandonare le soluzioni di integrazione fornite nativamente e procedere ad uno sviluppo “from scratch”. E’ questo il momento in cui si affronta la classica decisione buy vs build.

Buy

In passato, la mancanza di un protocollo di comunicazione standard, flessibile ed affidabile verso gli ambienti ECM rendeva questa decisione molto onerosa. Decidere verso il buy significava in genere utilizzare i componenti forniti e limitare le loro funzioni a quelle derivanti dalle possibilità di configurazione direttamente supportate. Questo naturalmente ha il grande svantaggio di non offrire al Cliente la flessibilità richiesta nel raggiungimento delle specifiche di integrazione percepite. Ha invece il grande vantaggio di fornire velocemente e a basso costo una soluzione usabile (utile sicuramente nelle iterazioni iniziali del processo di sviluppo).

Build

Decidere verso il build significava, in passato, addentrarsi in un campo oscuro in cui protocolli e standard di comunicazione non erano definiti ed ogni scelta aveva ricadute enormi sui costi di sviluppo e manutenzione della soluzione di integrazione ECM/WCM con ricadute dirette sia sulla Qualità percepita dal Cliente, sia sul tasso di riuso del codice sviluppato e sui relativi costi di manutenzione (e quindi in generale su tutta l’economia del progetto).

Decidere per il build

Oggi, grazie allo sviluppo e all’adozione da parte dei più diffusi ECM del protocollo di comunicazione CMIS (Content Management Interoperability Services) venire incontro alle esigenze di verticalizzazione del Cliente si rivela un compito molto economico e dai frutti sorprendenti.

Rimandiamo a questo articolo (english version) in cui si mostra in dettaglio come è stata realizzata una semplice portlet Liferay per l’integrazione con Alfresco utilizzando il protocollo CMIS. Nella versione completa questa portlet è uno dei componenti di integrazione della piattaforma Beefly.

Tra le funzioni offerte dal prototipo descritto nell’articolo evidenziamo:

1. Facile navigazione di un repository CMIS remoto
2. Impostazione della modalità di autenticazione
3. Impostazione del sub-tree di navigazione del repository
4. Supporto completo della profilazione dei contenuti
5. Navigazione dell’albero dei contenuti in modalità AJAX
6. Download dei contenuti selezionati, direttamente sul repository o tramite proxy
7. Multi-istanza. Più portlet possono essere configurate, anche sulla stessa pagina, per navigare porzioni diverse del repository

Dall’articolo (also available in the english version) è anche possibile scaricare il codice sorgente della portlet.

Buona lettura.

L’integrazione di applicativi eterogenei nell’ambito dei flussi documentali ed informativi aziendali è da sempre uno degli argomenti più complessi che un System Integrator deve affrontare.

Gli utenti dei vari applicativi aziendali sono spesso obbligati ad elaborare lo stesso documento tramite diverse applicazioni che purtroppo non sempre sono in grado di comunicare in modo “nativo”.

Nel caso dei sistemi di gestione dei contenuti, la comunicazione tra i sistemi potrebbebbe avvenire attraverso quello che è ormai divenuto uno standard consolidato, vale a dire il protocollo CMIS. Purtroppo utilizzare questo protocollo pretende, per quanto detto prima, il completo supporto da parte di tutti gli applicativi coinvolti in un workflow documentale.

Spesso l’integrazione tra applicativi che non “parlano” la stessa lingua (CMIS in questo caso) può avvenire attraverso l’integrazione con lo Spooler di stampa. L’idea è quella di convincere l’applicativo a “stampare” il documento su una stampante di rete condivisa. Tale stampante in realtà è virtuale e la stampa produce in realtà la spedizione del documento verso un’altro applicativo. Per integrare un tale tipo di funzionalità all’interno del nostro prodotto di gestione documentale Beefly abbiamo utilizzato il protocollo IPP (Internet Printing Protocol) e sviluppato l’integrazione tramite CUPS e Apache-Camel.

CUPS (Common Unix Printing System) è un Print Spooler modulare per sistemi operativi di tipo Unix che permette ad un computer di funzionare come un efficace print server.
Un computer con CUPS in esecuzione è in grado di accettare stampe da altri computer client, elaborarle ed inviarle alla stampante richiesta.

Il modulo realizzato è costituito da uno spooler/scheduler, un filtro che converte i dati di stampa ricevuti in un formato accettato dalla stampante ed un modulo che invia i dati elaborati al dispositivo di stampa.
CUPS si basa sull’Internet printing protocol (IPP) per gestire l’invio dei dati e le code di
stampa.
L’interfacciamento con i driver si basa sul formato PostScript printer description (PPD).
La gestione e configurazione di CUPS può essere effettuata attraverso l’interfaccia web
integrata.

Apache-Camel è un potente framework open-source d’integrazione che implementa i più noti Enterprise Application Patterns.
Questo framework permette di creare sistemi d’integrazione in ambienti distribuiti  permettendo di realizzare regole di routing e di mediazione sia in Domain Specific Language di tipo Java based sia tramite Spring e quindi in modo dichiarativo tramite XML.

Tecnicamente il modulo prevede linstallazione sul server su cui risiede CUPS di una stampante PDF virtuale. CUPS permette di realizzare ciò tramite l’installazione di un backend chiamato “cups-pdf”. Tale backend permetterà al sistema su cui è installato il server CUPS di installare una stampante virtuale PDF “CUPS-compliance”.
CUPS gestirà lo spool scheduler di tale stampante ed inoltre renderà disponibile via rete la stampante a tutti gli altri client che ne vorranno fare uso.

I client dovranno aggiungere una stampante di rete tramite una stringa di connessione di questo tipo:
http://{IP-CUPS-SERVER}:631/printers/{PDF-VIRTUAL-PRINTER-NAME}
dove:
- IP-CUPS-SERVER è l’indirizzo IP del servfer su cui è in esecuzione CUPS
- 631 è la porta sulla quale risponde il protocollo IPP
- PDF-VIRTUAL-PRINTER-NAME è il nome asseganto alla stampante pdf virtuale deciso in fase d’installazione sul server su cui risiede CUPS

I clients devono inoltre fornire alla stampante delle credenziali di accesso tramite le quali potersi autenticare sul sistema linux su cui è installato CUPS. Questo permetterà in seguito di classificare i documenti pervenuti a CUPS.

Una volta configurata la stampante sul client sarà possibile inviare un documento, da qualunque applicativo che permetta di stampare, al server CUPS ed ottenere quindi una versione PDF dello stesso.

Il backend cups-pdf permette di inviare tutti i documenti convertiti in PDF in una determinata cartella (/home/{LINUX USER}/PDF ad esempio)
in funzione dell’utente con il quale il client si è collegato al server CUPS. Una volta ottenuto tale documento questo sarà mandato in pasto al framework Apache-camel.
Apache-camel è configurato per essere in ascolto su i documenti pervenuti nella cartella di destinazione di cups-pdf e per ogni documento pervenuto apache-camel chiama un processo che tramite delle API CMIS caricano il file sul ECM alfresco.
Il seguente workflow descrive brevemente i passi previsti per il capturing tramite spool di stampa:

CLIENT
|
SERVER CUPS
|
CUPS-PDF
|
SERVER FOLDER
|
JAVA CAMEL PROCESSOR
|
ALFRESCO

Elenchiamo i passi uno ad uno:

===============================
2.1 INSTALLARE CUPS & CUPS-PDF
===============================
1) sudo apt-get install cups
2) sudo apt-get install cups-pdf

===============================
2.2 CONFIGURARE CUPS & CUPS-PDF
===============================
I file di configurazione per CUPS e CUPS-PDF sono rispettivamente in “/etc/cups/cupsd.conf” e “/etc/cups/cups-pdf.conf”;
I file per i log per cups e cups-pdf sono in “/var/log/cups/error_log” e “/var/log/cups/cups-pdf_log” rispettivamnte.

Per la configurazione di tutti e 2 procedere come segue:

1) Sovrascrivere il primo file con questo:

## Livello di debug messo a “debug” per farci stampare piu’ log
LogLevel debug
MaxLogSize 1m
SystemGroup lpadmin
# Allow remote access
Port 631
Listen /var/run/cups/cups.sock
# Enable printer sharing and shared printers.
Browsing On
BrowseOrder allow,deny
BrowseAllow all
BrowseRemoteProtocols CUPS
BrowseAddress @LOCAL
BrowseLocalProtocols cups

## Tipo di autorizzazione LINUX
DefaultAuthType Basic
## Necessario per far funzionare l’autenticazione con i clients WINDOWS
DefaultEncryption IfRequested

## Per accettare alias di qualunque tipo
ServerAlias *

###########################
# L O C A T I O N S
###########################
<Location />
# Allow shared printing and remote administration…
Order allow,deny
Allow all
</Location>
<Location /admin>
# Allow remote administration…
Order allow,deny
Allow all
</Location>
<Location /admin/conf>
# AuthType Default
# Require user @SYSTEM
# Allow remote access to the configuration files…
Order allow,deny
Allow all
</Location>

#############################
# P O L I C I E S
#############################
## ———> D E F A U L T
#############################

<Policy default>
<Limit Print-Job Send-Document Send-URI Hold-Job Release-Job Restart-Job Purge-Jobs Set-Job-Attributes Create-Job-Subscription Renew-Subscription Cancel-Subscription Get-Notifications Reprocess-Job Cancel-Current-Job Suspend-Current-Job Resume-Job CUPS-Move-Job CUPS-Get-Document>
## “Print Job” rappresenta la direttiva IPP per l’invio della stampa
## Stiamo dicendo di sottoporre tutte le diretive elencate
## sopra ad un autenticazione che richiede username e password con un utente che appartenga al
## sistema server
AuthClass User
AuthType Basic
Require user @SYSTEM
Order deny,allow
</Limit>
<Limit CUPS-Add-Modify-Printer CUPS-Delete-Printer CUPS-Add-Modify-Class CUPS-Delete-Class CUPS-Set-Default CUPS-Get-Devices>
AuthType None
# Require user @SYSTEM
Order deny,allow
</Limit>
<Limit Pause-Printer Resume-Printer Enable-Printer Disable-Printer Pause-Printer-After-Current-Job Hold-New-Jobs Release-Held-New-Jobs Deactivate-Printer Activate-Printer Restart-Printer Shutdown-Printer Startup-Printer Promote-Job Schedule-Job-After CUPS-Accept-Jobs CUPS-Reject-Jobs>
AuthType None
Require user @SYSTEM
Order deny,allow
</Limit>
<Limit Cancel-Job CUPS-Authenticate-Job>
Require user @OWNER @SYSTEM
Order deny,allow
</Limit>
<Limit All>
Order deny,allow
</Limit>
</Policy>

2) Lasciare il file “/etc/cups/cups-pdf.conf” invariato e modficare soltanto la riga:

#UserUMask 0077
con
UserUMask 0002

Questo permette ai file pdf creati da cups-pdf nelle cartelle {$USER_HOME}/PDF del server di poter essere processati da Camel.

3) Lanciare il comando “sudo /etc/init.d/cups restart” per rendere effettive le modifiche del CUPS server

===============================
3 CONFIGURAZIONE SISTEMA LINUX
===============================
1) Vogliamo prevedere la presenza di un utente che abbia la possibilita di stampare e quindi autenticarsi con cups dal proprio client. Avendo scelto come tipo di autorizzazione quella di tipo Basic (LINUX authentication) dobbiamo creare un utente sulla macchina server: “spooluser”;
Eseguiamo:
sudo adduser spooluser

2) Se l’utente amministratore del server (cioè colui che avvia l’applicazione) è l’utente “my_user” appartenente al gruppo “my_user” allora per permettere la scrittura e lettura all’interno della cartella {$USER_HOME}/PDF dell’utente appena creato(spooluser) dobbiamo aggiungere l’utente “my_user” al gruppo “spooluser” che è stato creato automaticamente dal sistema al momento della creazione dell’utente in questione.
Eseguiamo:
sudo usermod -aG spooluser my_user

3) CUPS viene eseguito solo con utenti che appartengono al gruppo “lpadmin” quindi dobbiamo aggiungere tutti gli utenti che vogliamo usino cups a questo gruppo.
Eseguiamo:
sudo usermod -aG lpadmin my_user
sudo usermod -aG lpadmin spooluser

5) Riavviare la sessione della macchina per rendere effettive le modifiche.

=================================================
4 CONFIGURAZIONE E AGGIUNTA STAMPANTE DAL PANNELLO DI CONTROLLO DI CUPS
=================================================
1 – Accedera alla console di ammnistrazione di CUPS: “http://{CUPS_SERVER_URL}:631/admin”
2 – Nella pagina di amministrazione sotto la voce “Impostazioni server” attivare le checkbox relative a:

• Condividi stampanti connesse al sistema
• Consenti la stampa da Internet
• Consenti amministrazione remota

3 – Sotto la voce “Stampanti” in alto a sinistra premere su “aggiungi stampante”
4 – Sotto la voce “Stampanti locali” dovrebbe essere presente una checkbox “CUPS-PDF (Virtual PDF Printer)” selezionare la checkbox e premere su “avanti”
5 – Nel campo “Nome” inserire il nome che si vuole dare alla stampante che si sta aggiungendo, ad es.: “ToAlfresco”
6 – Rendere attivo la chekbox “Condividi la stampante” e premere su “continua”
7 – Nella lista denominata “Crea” selezionare “Generic” e poi “continua”
8 – Nella seconda lista denominata “Modello” selezionare esattamente “Generic PostScript Printer(en)” e premere su “add printer”
9 – Lasciare invariati i campi “General” e premere su “Imposta opzioni predefinite”

===============================
5 CONFIGUARAZIONE CAMEL
===============================
Camel CUPS viene configurato tramite il file di context spring:
“src/main/resources/META-INF/applicationContext.xml”
e dal file di properties;
“src/main/resources/META-INF/cupsCamelAlfresco.properties”

Di seguito riporto i 2 file correttamente configurati per il caso che stiamo prendendo in considerazione:

1) applicationContext.xml

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans”
xmlns:tx=”http://www.springframework.org/schema/tx”
xmlns:p=”http://www.springframework.org/schema/p”
xmlns:util=”http://www.springframework.org/schema/util”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xmlns:aop=”http://www.springframework.org/schema/aop”
xmlns:context=”http://www.springframework.org/schema/context”
xmlns:camel=”http://camel.apache.org/schema/spring”
xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring-2.3.0.xsd”
default-autowire=”byName”>

<!– ********************* C O N F I G U R E R ********************* –>
<bean id=”aldoCamelConfigurer” class=”org.springframework.beans.factory.config.PropertyPlaceholderConfigurer”>
<property name=”placeholderPrefix” value=”$props{” />
<property name=”placeholderSuffix” value=”}” />
<property name=”locations”>
<value>classpath:/META-INF/cupsCamelAlfresco.properties
</value>
</property>
</bean>

<!– ********************* C A M E L C O N T E X T ********************* –>
<camel:camelContext>

<!–
======================= E N D P O I N T S =======================
–>
<camel:endpoint id=”fileFromSpooluserDir” uri=”$props{camel.cups.endpoint.spooluser.cups.uri}” />

<!–
======================= R O U T E S =======================
–>
<camel:route id=”toAlfrescoSpooluserDir”>
<camel:from ref=”fileFromSpooluserDir” />
<camel:to uri=”bean:cupsSpooluserProcessor” />
</camel:route>
</camel:camelContext>

<!–
======================= P R O C E S S O R S =======================
–>
<bean id=”cupsSpooluserProcessor” class=”it.qbreng.cups.processors.CUPSToAlfrescoProcessor”>
<property name=”fromCUPSFolder” value=”$props{camel.cups.alfrescoFolder.spooluser.alfresco.uri}” />
<property name=”alfrescoUserUsername” value=”$props{camel.user.username}” />
<property name=”alfrescoUserPassword” value=”$props{camel.user.password}” />
<property name=”alfrescoUrl” value=”$props{camel.alfresco.repourl}” />
<property name=”alfrescoSpooluserFolderPath” value=”$props{camel.cups.alfrescoFolder.spooluser.alfresco.uri}” />
</bean>
</beans>
2) cupsCamelAlfresco.properties

camel.alfresco.repourl=http://{ALFRESCO_SERVER_URL}:8080/alfresco/s/cmis
camel.user.username=spooluser
camel.user.password=spooluser

## C U P S P A T H S E T T I N G S
camel.cups.endpoint.spooluser.cups.uri=file\:///home/spooluser/PDF?readLock=changed

## A L F R E S C O P A T H S E T T I N G S
camel.cups.alfrescoFolder.spooluser.alfresco.uri=/User Homes/spooluser

===============================
6 PROCESSOR
===============================
Il progetto che implementa il processor è fromato dalle seguenti classi:
it.qbreng.cups.processors.CUPSToAlfrescoProcessor.java –> PROCESSOR
it.qbreng.cups.App.java –> MAIN

1) CUPSToAlfrescoProcessor.java

package it.qbreng.cups.processors;

import java.io.File;
import java.io.FileInputStream;
import java.util.HashMap;
import java.util.Map;

import org.apache.camel.Exchange;
import org.apache.camel.Message;
import org.apache.camel.Processor;
import org.apache.chemistry.opencmis.client.api.CmisObject;
import org.apache.chemistry.opencmis.client.api.Folder;
import org.apache.chemistry.opencmis.client.api.Repository;
import org.apache.chemistry.opencmis.client.api.Session;
import org.apache.chemistry.opencmis.client.api.SessionFactory;
import org.apache.chemistry.opencmis.client.runtime.SessionFactoryImpl;
import org.apache.chemistry.opencmis.commons.SessionParameter;
import org.apache.chemistry.opencmis.commons.data.ContentStream;
import org.apache.chemistry.opencmis.commons.enums.BindingType;
import org.apache.chemistry.opencmis.commons.enums.VersioningState;
import org.apache.chemistry.opencmis.commons.exceptions.CmisObjectNotFoundException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.support.ApplicationObjectSupport;

public class CUPSToAlfrescoProcessor extends ApplicationObjectSupport implements Processor
{
   private String fromCUPSFolder;
   private String alfrescoUserUsername;
   private String alfrescoUserPassword;
   private String alfrescoUrl;
   private String alfrescoSpooluserFolderPath;

   private final String mimetype = "application/pdf";

   private Map<String, Object> nodeProperties;

   public CUPSToAlfrescoProcessor()
   {
      System.out.println( "App constructor" );
      //Endpoint initialize test
      logger.info("CUPS monitor instance started... " + this);
   }

   public void process(Exchange exchange) throws Exception {
      Message message = exchange.getIn();
      logger.info("new document to process... " + exchange.getExchangeId() + " !");

       File f= message.getBody(File.class);
       String filename=f.getName();

       nodeProperties = new HashMap<String,Object>();
       nodeProperties.put("cmis:name", filename);
       nodeProperties.put("cmis:objectTypeId", "cmis:document");

       //CMIS Session
       Session session = null;
       SessionFactory sessionFactory = SessionFactoryImpl.newInstance();
       Map<String, String> parameter = new HashMap<String, String>();

       // User credentials
       parameter.put(SessionParameter.USER, alfrescoUserUsername);
       parameter.put(SessionParameter.PASSWORD, alfrescoUserPassword);

       // Connection settings.
       parameter.put(SessionParameter.ATOMPUB_URL, alfrescoUrl);
       parameter.put(SessionParameter.BINDING_TYPE, BindingType.ATOMPUB.value());

       // Create session
       try {
          Repository soleRepository = sessionFactory.getRepositories(parameter).get(0);
          session = soleRepository.createSession();
       } catch (Exception e) {
          e.printStackTrace();
       }

       //Parent Folder
       CmisObject oCObject = null;
       try {
          oCObject = (CmisObject) session.getObjectByPath(alfrescoSpooluserFolderPath);
       } catch (CmisObjectNotFoundException e) {
          e.printStackTrace();
       }
       Folder parentFolder = (Folder) oCObject;

       //Content Stream
       ContentStream contentStream = session.getObjectFactory()
       .createContentStream(filename, f.length(), mimetype, new FileInputStream(f));

       //Create document into parent folder
       parentFolder.createDocument(nodeProperties, contentStream, VersioningState.NONE);
    }

    //SETTER
    public void setFromCUPSFolder(String fromCUPSFolder) {
       this.fromCUPSFolder = fromCUPSFolder;
    }
    public void setAlfrescoUserUsername(String alfrescoUserUsername) {
       this.alfrescoUserUsername = alfrescoUserUsername;
    }
    public void setAlfrescoUserPassword(String alfrescoUserPassword) {
       this.alfrescoUserPassword = alfrescoUserPassword;
    }
    public void setAlfrescoUrl(String alfrescoUrl) {
       this.alfrescoUrl = alfrescoUrl;
    }
    public void setAlfrescoSpooluserFolderPath(String alfrescoSpooluserFolderPath) {
       this.alfrescoSpooluserFolderPath = alfrescoSpooluserFolderPath;
    }
}

2) App.java

package it.qbreng.cups;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App
{
   public static void main( String[] args )
   {
      ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("META-INF/applicationContext.xml");
      try {
          // Camel processor listening for 60 sec
          Thread.sleep(60000);
          System.out.println("Stop monitor...");
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
   }
}

Queste invece sono le dipendenze del progetto (definite nel pom.xml)

3) pom.xml

<project xmlns=”http://maven.apache.org/POM/4.0.0″ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd”>
<modelVersion>4.0.0</modelVersion>

<groupId>it.qbreng.cups</groupId>
<artifactId>cups-camel-alfresco</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

<name>cups-camel-alfresco</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>

<!– CAMEL DEPENDENCIES –>
<dependency>
<groupId>org.apache.camel</groupId>
<artifactId>camel-spring</artifactId>
<version>2.3.0</version>
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
<artifactId>camel-mail</artifactId>
<version>2.3.0</version>
</dependency>

<!– OPEN CMIS DEPENDENCIES –>
<dependency>
<groupId>org.apache.chemistry.opencmis</groupId>
<artifactId>chemistry-opencmis-client-api</artifactId>
<version>0.5.0</version>
</dependency>
<dependency>
<groupId>org.apache.chemistry.opencmis</groupId>
<artifactId>chemistry-opencmis-client-impl</artifactId>
<version>0.5.0</version>
</dependency>
<dependency>
<groupId>org.apache.chemistry.opencmis</groupId>
<artifactId>chemistry-opencmis-commons-api</artifactId>
<version>0.5.0</version>
</dependency>
<dependency>
<groupId>org.apache.chemistry.opencmis</groupId>
<artifactId>chemistry-opencmis-commons-impl</artifactId>
<version>0.5.0</version>
</dependency>
<dependency>
<groupId>org.apache.chemistry.opencmis</groupId>
<artifactId>chemistry-opencmis-client-bindings</artifactId>
<version>0.5.0</version>
</dependency>
<dependency>
<groupId>org.apache.chemistry.opencmis</groupId>
<artifactId>chemistry-opencmis-test-util</artifactId>
<version>0.5.0</version>
</dependency>
</dependencies>

<build>
<resources>
<resource>
<directory>src/resources</directory>
</resource>
</resources>
</build>
</project>

===============================
7 CONFIGURAZIONE ALFRESCO SHARE
===============================
Bisogna creare un utente da share “spooluser” con la propria user home in:
/Company Home/User Homes/spooluser
L’utente avrà le seguenti credenziali d’accesso:
username: spooluser
password: spooluser

================================
8 CONFIGURAZIONE CLIENTS WINDOWS
================================
1) Aggiungere una stampante di rete con indirizzo: “http://{CUPS_SERVER_URL}:631/printers/ToAlfresco”
2) Nella finestra “Add printer wizard” appena aperta selezionare dalla lista “Manifacturer” “General” e dalla
lista “Printers” “MS publisher Color Printer” e cliccare su ok
3) Selezionare “Printer properties” della stampante appena creata
4) Selezionare il tab “Ports”
5) Premere sul tasto “Configure Port…”
6) Attivare “Use the specified user account” ed inserire l’utente creato con il quale ci si vuole
autenticare, quindi “spooluser”.

================================
9 RISULTATI CUPS
================================
Provare, da uno dei clients configurati, a stampare un file inviandolo alla stampante “ToAlfresco”.
Se la stampante era configurata ad autenticarsi come “beeflycapture” dovrebbe, dopo pochi secondi, comparire
lo stesso file dentro la cartella “/Company Home/User Homes/spooluser” di alfresco.

Gli Aspetti di Alfresco sono una caratteristica nativa della piattaforma che non è prevista dalle specifiche 1.0 del protocollo CMIS.

Tuttavia essi rappresentano uno strumento fondamentale per la gestione avanzata dei tipi documentali all’interno dell’ECM. Per questo motivo Alfresco ha fornito una libreria java che estende le funzioni CMIS utilizzando la più importante implementazione java per CMIS: opencmis.

La libreria è denominata Alfresco OpenCMIS Extension, ed è rilasciata con licenza Apache 2.0. La trovate qui.

In opencmis tutti gli oggetti, di qualunque tipo, possiedono il concetto di “extensions”. Questa soluzione è stata adottata per poter aggiungere all’occorrenza delle funzionalità non previste dallo standard. Alfresco utilizza proprio queste “extensions” per lavorare con gli aspetti tramite CMIS.

Lavorare con questa libreria è piuttosto semplice. Il primo passo è aggiungere il  parametro SessionParameter.OBJECT_FACTORY_CLASS in fase di creazione della sessione CMIS, in modo da “racchiudere” (wrapping) gli oggetti CMIS in un oggetto più grande che permette l’integrazione degli aspetti.

Map<String, String> parameter = new HashMap<String, String>();

// Set the user credentials
parameter.put(SessionParameter.USER, "admin");
parameter.put(SessionParameter.PASSWORD, "admin");

// Specify the connection settings
parameter.put(SessionParameter.ATOMPUB_URL, "http://localhost:8080/alfresco/service/cmis");
parameter.put(SessionParameter.BINDING_TYPE, BindingType.ATOMPUB.value());

// Set the alfresco object factory
parameter.put(SessionParameter.OBJECT_FACTORY_CLASS, "org.alfresco.cmis.client.impl.AlfrescoObjectFactoryImpl");

// Create a session
SessionFactory factory = SessionFactoryImpl.newInstance();
Session session = factory.getRepositories(parameter).get(0).createSession();

Eseguendo questo codice abbiamo già conluso la fase di “impostazione” di opencmis per lavorare con gli aspetti.

Esempio:

Document doc = (Document) session.getObject(...);

AlfrescoDocument alfDoc = (AlfrescoDocument) doc;
alfDoc.addAspect("P:cm:taggable");

if(alfDoc.hasAspect("P:cm:titled")) {
Map<String, Object> properties = new HashMap<String, Object>();
properties.put("cm:description", "My taggable document");
alfDoc.updateProperties(properties);
}

Come si vede dal codice appena scritto, per poter utilizzare i metodi implementati dalla libreria, si deve effettuare un cast esplicito ad un tipo di oggetto della libreria stessa. Se vogliamo lavorare con i documenti, il tipo “Document” di opencmis deve essere convertito in “AlfrescoDocument”, mentre il tipo “Folder” in “AlfrescoFolder”. Il nuovo oggetto permetterà di richiamare su se stesso tutti i metodi per utilizzare gli aspetti ed erediterà quelli del tipo originale.

A seguire, l’elenco dei metodi aggiunti dalla libreria “Alfresco OpenCMIS Extensions”.

Per controllare se un oggetto/tipo ha un aspetto:

boolean hasAspect(String id);
boolean hasAspect(ObjectType type);

Per farsi restituire tutti gli aspetti di un determinato oggetto

Collection<ObjectType> getAspects();

Per cercare un aspetto

ObjectType findAspect(String propertyId);

Per aggiungere e rimuovere aspetti

void addAspect(String... id);
void addAspect(ObjectType... type);
void removeAspect(String... id);
void removeAspect(ObjectType... type);

Si possono trovare dei frammenti di codice di esempio sul sito della libreria Alfresco OpenCMIS Extension.

Quello che invece non è riportato, ma che è di fondamentale importanza, è il modo in cui cambia la ricerca tramite CMIS quando si vogliono utilizzare gli aspetti. Cmis usa un suo linguaggio (CMIS QL) per eseguire le query, ed è basato sullo standard SQL-92 (trovate qui una panoramica).

Supponiamo di avere un aspetto di nome “qbr:SampleAspect” che possiede una proprietà “qbr:SampleProp”. Per poter eseguire query che tengano conto degli aspetti si deve effettuare un join tra il tipo di documento e l’aspetto che vogliamo gestire.

SELECT D.*, O.* FROM cmis:document AS D JOIN qbr:SampleAspect AS O ON D.cmis:objectId = O.cmis:objectId

In questo modo ci vengono restituiti tutti i documenti di tipo “cmis:document” che possiedono l’aspetto “qbr:SampleAspect”. Se vogliamo aggiungere la clausola WHERE per gestire anche la proprietà dell’aspetto dobbiamo scrivere

SELECT D.*, O.* FROM cmis:document AS D JOIN qbr:SampleAspect AS O ON D.cmis:objectId = O.cmis:objectId WHERE O.qbr:SampleProp = 'test'

In questo modo filtriamo ulteriormente la ricerca sfruttando il valore di una proprietà. Come si vede dalla query, quando vogliamo usare qualsiasi proprietà relativa all’aspetto, nella query è necessario specificare la “tabella” (in questo caso “O”).

BEEFLY

BEEFLY uses CMIS protocol to communicate with the Alfresco platform. BEEFLY allows users to store digital documents in the Alfresco repository, by simply using a TWAIN compatible scanner. Users can also index, share, version, number and search for different kinds of documents and contents (images, videos, e-mails, faxes, etc…).

Solution Details

Beefly Touch is a Rich Internet Application, available in a user-friendly touch screen interface.

The intuitive touch screen interface enables users to index and store documents by following a few simple steps. It has been developed by using Flash/Flex and Java Technologies.

The system administrator can use an intuitive web-based interface, called ADAMO (Alfresco.DAta MOdel), to create ad hoc custom models and to customize the related metadata.

The main features of Beefly Touch are:

• Integrated document preview (available for the following file formats: pdf, MS Office, Open Office, images, xml e txt).

• Document properties preview.

• Remote scanning, by using a TWAIN compatible scanner. Multi-document scanning with Barcode Page Separator.

• Document upload from file system.

• Electronic Document Numbering (“Digital Protocol”), complying with the Italian records management standards (DigitPA).

• Full-text search.

• Advanced search: search by custom type and by metadata.

• Cut, move, copy, paste and delete.

• Search results preview.

• Alphanumeric touch screen keyboard.

• Ad hoc metadata attributes, characterizing files and folders.

• Advanced file and folder search.

• Easy scanner configuration through the following parameters: resolution, scanning pixel types (colours/black and white), file format selection (Tiff, Pdf, Jpeg). OCR support.

• Integrated address book, to provide an integrated collection of addressing information.

• Multi-language user interface (supported languages: English, French, Italian and other languages).

• OCR scanning software (Tesseract-OCR and Abbyy ).

Beefly can be easily installed on a virtual machine. Application modules are handled through Apache Maven.

Product Features

• Touch screen user interface: intuitive and user-friendly front-end interface, enabling users to easily store and search for business documents.

• Remote scanning: documents can be scanned, indexed, stored and accessed through any web client. Multi-document scanning with Barcode Page Separator. OCR support.

• Electronic document numbering (“Digital protocol”), compling with the Italian records management standards (DigitPA)

• Integrated address book

• Custom Type Management: users can index different kinds of documents by simply using ad hoc Custom models and their related metadata. Only the system administrator is allowed to create and manage Custom models by using an intuitive web-based interface.

• Full-text and advanced search: documents can be searched by custom type or by metadata, directly by using the touch screen interface.

• Electronic Folder Management: folders can be characterized by ad hoc metadata, which enable users to quickly view and search for folder contents.

• BEEFLY uses CMIS protocol to communicate with the Alfresco platform.

Screenshots

Visit Beefly website.

• Registrazione di protocollo sia di documenti analogici che digitali
• Classificazione della registrazione
• Gestione del titolario di classificazione
• Stampa della segnatura di protocollo contenente le informazioni della registrazione
• Stampa del giornale di protocollo con le registrazioni di protocollo effettuate nella giornata o in un intervallo temporale selezionato
• Annullamento della registrazione di protocollo con inserimento della motivazione
• Ri-classificazione di una registrazione di protocollo
• Gestione dei dati relativi all’AOO
• Rubrica dei Mittenti e dei Destinatari associati alle registrazioni di protocollo
• Ricerche delle registrazioni di protocollo e dei fascicoli sia in modalità full-text che sulla base degli attributi specifici
• Apertura o chiusura di un fascicolo
• Associazione di un documento scansionato ad una registrazione di protocollo effettuata
• Invio della ricevuta di protocollo tramite email PEC al mittente
• Assegnazione ad un ufficio (UOR) o ad una persona (RPA) di una registrazione di protocollo per competenza o per conoscenza
• Presa in carico della registrazione di protocollo assegnata
• Rifiuto di una registrazione di protocollo assegnata con inserimento della motivazione

L’obiettivo principale che ci siamo posti all’avvio del progetto è stato quello di realizzare un software per la gestione del Protocollo Informatico che rispondesse ai seguenti requisiti:

• Completa conformità alla normativa CNIPA (ora DIGITPA)
• Installabile sulla piattaforma documentale Alfresco
• Multi Organizzazione, in modo da consentire, con un’unica installazione del prodotto, la creazione di molteplici sistemi di protocollo all’interno di un Ente della P.A.  (ad esempio diversi protocolli per differenti A.O.O.)
• Integrabile con gli altri sistemi informatici adottati dall’Ente (es. sistemi di Enterprise Content Mangement, Business Process Management, Portali Internet etc.)

Il risultato ottenuto è stata la realizzazione di un nuovo modulo applicativo nella suite Beefly denominato Beefly Protocol. Tale modulo applicativo, una volta installato sulla piattaforma Beefly (o direttamente su Alfresco Share) permette di usufruire di un sistema di gestione del protocollo informatico che risponde pienamente alle disposizioni sul protocollo informatico emanate dal DigitPA per la Pubblica Amministrazione Centrale e Locale.

L’adozione di Beefly Protocol permette all’Ente di usufruire, oltre che delle cosiddette funzionalità minime o “nucleo minimo” per la gestione informatica dei documenti, anche di tutte le funzionalità aggiuntive necessarie alla gestione dei flussi documentali, alla conservazione e all’accessibilità dei documenti archiviati.

Architettura sistema di protocollo a norma CNIPA

Come è evidente dal diagramma precedente, Beefly Protocol, posizionandosi al livello più elevato della piramide documentale, è in grado di usufruire delle funzionalità di gestione documentale e workflow management erogate dalle piattaforme sottostanti.

Il DigitPA infatti classifica le applicazioni di protocollo informatico in tre macro livelli realizzativi (scenari) di complessità crescente:

1. Modalità base del protocollo informatico – Nucleo minimo di protocollo
2. Gestione informatica dei documenti e notifica
3. Flussi documentali – Esecuzione dei workflow

Il software che abbiamo sviluppato permette all’Ente di implementare la gestione del protocollo informatico che soddisfa tutti e tre i livelli necessari per usufruire della piena integrazione delle funzioni di Protocollo con le funzioni ECM necesarie all’erogazione dei servizi documentali.

1. Nucleo minimo di protocollo (rif. Testo unico DPR 445/2000 e s.m.i): Beefly Protocol fornisce le funzionalità di registrazione dei documenti in ingresso, in uscita e interni, oltre che la classificazione, la fascicolazione e l’archiviazione  degli stessi all’interno del titolario di classificazione adottato dall’Ente.

2. Gestione Documentale: Beefly Protocol, avvalendosi, oltre che della piattaforma Alfresco anche delle funzionalità aggiuntive fornite dalla piattaforma Beefly, offre una serie di funzionalità aggiuntive fra cui, la dematerializzazione dei documenti cartacei, anche massiva, l’archiviazione delle email provenienti dalle caselle di posta certificata dell’ente, la firma digitale e marcatura temporale dei documenti elettronici, l’integrazione con lo Spooler di stampa etc.

3. Flussi documentali: Beefly Protocol supporta le funzionalità di notifica delle registrazioni di protocollo sulla scrivania di lavoro e sull’email dell’utente. Grazie alla forte integrazione fra il software di protocollo e Beefly (o Alfresco Share) l’utente riceve sulla propria Dashboard o sulla propria email la notifica di nuove assegnazioni di protocollo.

Funzionalità di Beefly Protocol

Beefly Protocol è dotato delle seguenti caratteristiche principali:

• Archiviazione e registrazione di protocollo dei documenti rispondente alla normativa CNIPA con la possibilità di registrare un documento, classificarlo all’interno del titolario di classificazione adottato dall’Ente e assegnarlo ad un Ufficio (UOR) o al responsabile del procedimento (RPA).
• Scansione dei documenti da scanner direttamente dall’applicativo (Remote Scanning).
• Gestione del Titolario di classificazione dell’Ente con la possibilità di creare tipologie di fascicoli elettronici e documenti personalizzati (Fascicoli estesi e Documenti estesi). Possibilità di chiudere un fascicolo relativo ad un procedimento terminato.
• Gestione con un sistema di Access Control List (ACL) dei criteri di accesso ad un documento o ad un Fascicolo.
• Gestione del flusso di lavoro con l’assegnazione dei documenti protocollati agli uffici (UOR) o direttamente ai responsabili del procedimento amministrativo (RPA).
• Possibilità di notificare per conoscenza i documenti protocollati ad Uffici e singoli Responsabili.
• Possibilità di creare più sistemi di protocollo in base alle Aree Organizzative Omogenee (AOO) presenti nell’Ente o in base alle funzioni individuate nell’organizzazione aziendale (es. Organigramma, divisioni aziendali, più aziende appartenenti allo stesso gruppo etc.).
• Apposizione da parte dell’utente, tramite la propria SmartCard, della Firma digitale a norma direttamente ai documenti archiviati sul gestore documentale Beefly.
• Archiviazione automatica e protocollazione sul gestore documentale delle email scaricate dagli account email istituzionali, anche da account di Posta Elettronica (PEC).
• Funzionalità di Audit che permette di tracciare tramite log tutte le attività effettuate dagli utenti sul sistema.
• Cloud Compliat. Pieno supporto al modello di distribuzione dell’applicativo in modalità Software as a Service (SaaS).

Le funzionalità in dettaglio di Beefly Protocol sono riportate qui.

Caratteristiche Tecniche

Beefly Protocol si basa sulla piattaforma Open Source di Alfresco Share di cui eredita le funzionalità di social collaboration, gestione documentale ed esecuzione dei workflow personalizzati, nonché di integrazione con Microsoft Office.

Il modulo espone un insieme di RESTful Web Service API che gli permettono di comunicare con le funzionalità del repository documentale di Alfresco (json) e con eventuali applicazioni esterne. I dati vengono scambiati utilizzando formati standard, quali JSON, Atom/RSS etc. (vedi fig. seguente).

Beefly Protocollo Componenti

Il modulo di protocollo è costituito da due componenti (vedi fig. seguente):

• Cnipa Protocol Share: Presentation layer – E’ stato implementato un nuovo tipo di site (custom site) in Alfresco Share.
• Cnipa Protocol Alfresco: Business Layer – Logica di back-end del modulo di protocollo.

Beefly Protocollo architettura

Scarica la presentazione completa del prodotto Beefly Protocol da questo link.

Per ulteriori informazioni visita www.beefly.it