Ora che abbiamo la form dobbiamo fare in modo di visualizzarla nel portale: lo faremo tramite un pulsante dentro la JSP che mostra la lista degli autori: cliccandolo ci verrà mostrata la vista che contiene la form. Basta pochissimo codice:

Questa riga crea l’URL da chiamare quando clicchiamo sul pulsante con la taglib di cui abbiamo parlato sopra. Ovviamente dentro la classe GestioneAutoriPortlet mi aspetto un metodo che si chiama addAutore.

"
onClick="location.href = '<%=addAutoreURL.toString() %>';" />

Questa riga mostra il nostro bottone. Sul click verrà chiamato l’URL che abbiamo creato nella riga precedente. Quella che segue, infine, è l’implementazione del metodo addAutore:

public void addAutore(ActionRequest request, ActionResponse response)
             throws Exception {
       //creiamo un oggeto AutoreImpl vuoto
       AutoreImpl autore = new AutoreImpl();
       //lo mettiamo in request,sarà recuperato nella JSP
       //tramite        request.setAttribute("autore", autore);
       //dichiariamo quale JSP utilizzare per renderizzare
                 //il risultato.In questo caso è quella che mostra la form
       response.setRenderParameter("jspPage",
             "/html/gestioneautoriportlet/edit_autore.jsp");
}

In figura 3 vediamo il pulsante aggiunto in pagina.

Figura 3 – Il pulsante aggiunto alla view.

Ed ecco il nostro form (figura 4).

Figura 4 – Il form per inserire un autore.

Salvare i dati

Ora manca il codice che salva l’autore sul database, in particolare il metodo updateAutore richiamato al submit. Prima di vederlo. però. completiamo la parte che ci consente di modificare un autore già inserito.Il form c’è già, manca la logica che recupera i dati dal database e popola l’oggetto Autore. Tale logica è racchiusa nel seguente metodo dentro GestioneAutoriPortlet.

public void editAutore(ActionRequest request, ActionResponse response)
       throws Exception {
       //recupero dalla request l'id dell'autore che voglio modificare.
       //Più avanti vedremo dove questo id sarà messo in request.
       String primKey = ParamUtil.getString(request, "resourcePrimKey");
       if (primKey != null) {
             try {
                    //Recupero dal database i dati del mio autore, utlizzando
                    //uno dei metodi generati automaticamente dal
                    //Service Builder
                    Autore autore = AutoreLocalServiceUtil.getAutore(Long
                                  .parseLong(primKey));
                    //metto l'oggetto autore in request
                    request.setAttribute("autore", autore);
                    //setto la JSP da utilizzare
                    response.setRenderParameter("jspPage",
                           "/html/gestioneautoriportlet/edit_autore.jsp");
             } catch (NumberFormatException e) {
                    SessionErrors.add(request, "failed-to-retrieve");
             } catch (PortalException e) {
                    SessionErrors.add(request, "failed-to-retrieve");
             } catch (SystemException e) {
                    SessionErrors.add(request, "failed-to-retrieve");
             }
       }
}

Come dicevamo prima, ora l’oggetto Autore in request non è vuoto, quindi nella JSP del form, grazie a questa riga vista sopra

troveremo i campi popolati, compreso resourcePrimKey, il quale conterrà l’id.

Vediamo ora dove viene invocato il metodo appena descritto. In figura 5 vediamo il particolare del pulsante “Action” mostrato in ogni riga della lista di autori, come si vedeva in figura 3.

Figura 5 – Particolare del menù delle azioni disponibili sugli autori.

Quando clicchiamo sul tasto Action si apre un menù che presenta due azioni disponibili: Delete e Edit. In particolare Edit ci permette di recuperare i dati dell’autore selezionato e di mostrarli nella form.

Questo menu viene renderizzato grazie a una JSP inclusa direttamente da codice quando si popola l’oggetto Search Container, nel metodo doView, analogamente a come abbiamo visto nel precedente articolo. L’unica cosa che cambia è proprio la JSP inclusa, che è questa:

<%@include file="/html/init.jsp" %>
<%
ResultRow row = (ResultRow)
       request.getAttribute(WebKeys.SEARCH_CONTAINER_RESULT_ROW);
Autore myAutore = (Autore)row.getObject();
long groupId = themeDisplay.getLayout().getGroupId();
String name = Autore.class.getName();
String primKey = String.valueOf(myAutore.getAuthorId());
%>

       
             
                    
             
                                        url="<%=editURL.toString() %>"/>
       
       
             
                    
             
             
       

Utilizzando un’altra taglib, Liferay UI [4], creare il menù è piuttosto semplice. Il primo pulsante che viene aggiunto è quello per la modifica, il cui URL punterà proprio al metodo editAutore visto sopra, al quale passerà come parametro il resourcePrimKey che utilizzeremo per fare la get dal database dei dati.

Il secondo pulsante serve per la cancellazione, richiama il metodo deleteAutore dentro GestioneAutoriPortlet mostrato qui sotto.

public void deleteAutore(ActionRequest request, ActionResponse response)
             throws Exception {
       //prendiamo dalla request l'id
       long autoreKey = ParamUtil.getLong(request, "resourcePrimKey");
       if (Validator.isNotNull(autoreKey)) {
             //se l'id non è nullo o vuoto invochiamo il metodo
             //per la cancellazione, creato anch'esso dal
             //Service Builder
             AutoreLocalServiceUtil.deleteAutore(autoreKey);
             SessionMessages.add(request, "autore-deleted");
       } else {
             SessionErrors.add(request, "error-deleting");
       }
}

A questo punto per completare la gestione della tabella autori manca solo il metodo che fa l’inserimento o l’aggiornamento dei dati, mostrato qui sotto.

public void updateAutore(ActionRequest request, ActionResponse response)
             throws PortletException {
       Autore autore = null;
       ThemeDisplay themeDisplay = (ThemeDisplay) request
                    .getAttribute(WebKeys.THEME_DISPLAY);
       ArrayList errors = new ArrayList();
       //nel metodo di util       autoreFromRequest andremo
       //semplicemente a recuperare i parametri passati
       //tramite la form
       autore = AutoreUtil.autoreFromRequest(request);
       long idAutore;
       if (autore.getAuthorId() > 0) {
             // se l'id passato è !=0 significa che abbiamo modificato
             //un autore che già esiste sul DB, quindi si tratta di
             //un update 
             try {  //recuperiamo I dati che già si trovano sul DB
                    Autore fromDB = AutoreLocalServiceUtil.getAutore(autore
                                  .getAuthorId());
                    if (fromDB != null
                                  && (autore.getAuthorId() == fromDB.getAuthorId())) {
                           autore.setModifiedDate(new Date());
                           autore.setCreateDate(fromDB.getCreateDate());
                           //facciamo l'update
                           fromDB = AutoreLocalServiceUtil.updateAutore(autore, false);
                           SessionMessages.add(request, "statement-added");
                           idAutore = fromDB.getAuthorId();
                    }
             } catch (PortalException e) {
                    errors.add("failed-to-update");
             } catch (SystemException e) {
                    errors.add("failed-to-update");
             }
       }
       else {
             //se entriamo qui vuol dire che stiamo facendo un nuovo inserimento
             try {
                    //inseriamo
                    idAutore = (AutoreLocalServiceUtil.addAutore(autore.getUserId(),
                                  autore.getName(), autore.getSurname(),
                                  themeDisplay.getScopeGroupId())).getAuthorId();
             } catch (SystemException e) {
                    errors.add("failed-to-add");
             } catch (PortalException e) {
                    errors.add("failed-to-add");
             }
       }
       if (errors.size() > 0) {
             for (String error : errors) {
                    SessionErrors.add(request, error);
             }
             request.setAttribute("autore", autore);
             response.setRenderParameter("jspPage",
                           "/html/gestioneautoriportlet/edit_autore.jsp");
       }
}

La gestione per la tabella Autore è terminata.

Torniamo alla tabella Libro sulla quale abbiamo lasciato in sospeso il discorso inserimento, dal momento che abbiamo detto di aver bisogno di almeno un autore al quale “assegnare” un libro. La logica e l’implementazione per tutte le operazioni sono quasi speculari a quelle viste per l’autore. L’unica differenza riguarda, appunto, l’inserimento. Il form per l’inserimento che vogliamo ottenere è mostrato in figura 6.

Figura 6 – Form per l’inserimento di un libro.

Come si vede c’è una select che è popolata con la lista degli autori. Nella nostra classe GestioneLibriPortlet scriviamo questo metodo:

private void addAutoriListToRequest(ActionRequest request)throws Exception {
       ThemeDisplay themeDisplay =
             (ThemeDisplay) request.getAttribute(WebKeys.THEME_DISPLAY);
       //recuperiamo lo scope della community
       long groupId = themeDisplay.getScopeGroupId();
       //leggiamo dal DB tutti gli autori inseriti per la community corrente
       List autoriList = AutoreLocalServiceUtil.findByGroupId(groupId);
       //mettiamo in request la lista appena recuperata
       request.setAttribute("autoriList", autoriList);
}

Questo metodo sarà chiamato da addLibro e editLibro. Qui sotto vediamo la JSP che renderizza la form.

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

             type="java.util.List" scope="request" />




       
                                 type="hidden" />
             
                                 autoFocus="true" size="45" />
             
             <%
                    for (int i = 0; i < autoriList.size(); i++) {
                           Autore autore=(Autore)autoriList.get(i);
             %>
                    "
                    selected="<%=autore.getAuthorId()==libro.getAuthorId() %>"
                           value="<%= autore.getAuthorId() %>" />
             <%
                    }
             %>
             
             
                    
             
       

Soffermiamoci sul pezzo di codice che popola la tendina. Utilizziamo ancora le taglib Alloy UI. Per generare le option cicliamo sulla lista degli autori che è stata messa in request con il  metodo addAutoriListToRequest di sopra. In particolare questa istruzione

selected="<%=autore.getAuthorId()==libro.getAuthorId() %>"

fa sì che, quando vogliamo modificare un libro, l’elemento della tendina selezionato di default è proprio quello corrispondente all’autore per il libro.

Se adesso inseriamo un libro, questo avrà anche un autore!

Conclusioni

In questo articolo abbiamo descritto un tool fondamentale nello sviluppo di portlet per Liferay, il Service Builder. È un generatore di codice che produce, organizzate in una precisa struttura in livelli, le classi e le interfacce per gestire i dati su tabelle custom che creiamo sul database. I metodi base che crea sono quelli per inserimento, lettura, cancellazione e aggiornamento.

Tutto quello di cui abbiamo bisogno è un file xml dove , con un preciso DTD, dichiariamo le tabelle che vogliamo creare e le rispettive colonne. Sarà il portale a creare gli script SQL e a eseguirli sul nostro database la prima volta che lo facciamo ripartire.

Abbiamo visto poi come sia possibile affiancare dei metodi “finder” custom ai metodi di default. Nell’articolo sono serviti per recuperare libri e autori con un determinato community id; naturalmente non è l’unica applicazione possibile. Si possono ad esempio creare dei “finder” per fare delle ricerche sui campi titolo, nome o cognome. Inoltre è possibile, sempre dentro l’XML, specificare l’ordinamento dei dati dichiarando su quale colonna ordinare, e se in modo ascendente o discendente.

Abbiamo anche visto come aggiungere della logica custom costruita sui metodi che già esistono: creando dei metodi dentro la classe LocalServiceImpl.java, il ServiceBuilder, una volta lanciato, crea dentro l’interfaccia LocalService.java un metodo con la stessa firma del nostro, e dentro LocalServiceUtil.java la sua implementazione. Questa classe in pratica altro non è che un wrapper per la LocalServiceImpl.java che contiene la nostra implementazione custom.

Con quest’approccio è possibile quindi costruire query complesse per applicazioni più vaste e articolate risparmiando, oltretutto, una notevole quantità di tempo.

Riferimenti

[1] Service Builder

http://www.liferay.com/community/wiki/-/wiki/Main/Service+Builder

[2] JSR 286 tag library

http://www.oracle.com/technetwork/java/jsr286-2-141964.html#Tag_Library

[3] Liferay Alloy UI

http://www.liferay.com/web/guest/community/wiki/-/wiki/Main/Alloy+UI+Forms+(aui)

[4] Liferay UI

http://www.liferay.com/community/wiki/-/wiki/Main/Liferay+UI+Taglib

[5] Service Builder tips

http://blog.d-vel.com/web/blog/home/-/blogs/query-su-colonne-unique:-come-configurare-il-servicebuilder