Tutorial di Livebase

Tutorial di Livebase
Introduzione .................................................................................................................................. v
1. Panoramica generale ........................................................................................................... v
2. Per iniziare ....................................................................................................................... v
3. Riepilogo ........................................................................................................................ vii
A. Gestire il tuo account ................................................................................................................. 1
1. Gestire il tuo account ......................................................................................................... 2
1.1. Organizzazione del tuo account .................................................................................. 2
1.2. Dettagli sulla sottoscrizione ....................................................................................... 3
1.3. Fatturazione e metodi di pagamento ............................................................................ 4
1.4. Ordini .................................................................................................................... 4
1.5. Fatture ................................................................................................................... 5
1.6. Impostare i default per i nuovi Cloudlet ...................................................................... 6
1.7. Riepilogo ............................................................................................................... 7
B. Gestire modelli con una sola classe .............................................................................................. 8
2. Creazione di una semplice applicazione anagrafica .................................................................. 9
2.1. Creazione dell'applicazione ....................................................................................... 9
2.2. Inserire dati nell'applicazione ................................................................................... 12
3. Estendere la semplice applicazione ...................................................................................... 18
3.1. Modificare l'applicazione ........................................................................................ 18
3.2. Riallineare il database (problemi di media entità) ........................................................ 20
3.3. Salvare un engine nella Library ................................................................................ 21
3.4. Ripristinare un engine dalla Library .......................................................................... 21
4. Creare la stessa applicazione importando un file XLS ............................................................. 23
5. Lavorare con i dati nell'applicazione generata ........................................................................ 26
5.1. Ricercare una stringa .............................................................................................. 26
5.2. Ordinare la lista ..................................................................................................... 26
5.3. Restringere la lista a un insieme specifico di record ..................................................... 27
5.4. Statistiche sugli attributi .......................................................................................... 29
5.5. Dividere gli oggetti in gruppi ................................................................................... 30
5.6. Riepilogo .............................................................................................................. 33
6. Migliorare l'applicazione generata ....................................................................................... 34
6.1. Designare attributi come object title .......................................................................... 34
6.2. Attributi derivati definiti mediante espressioni matematiche ........................................... 35
6.3. Modificare il layout del form ................................................................................... 39
6.4. Modificare la rappresentazione della Livetable ............................................................ 40
6.5. Impostare valori di default per gli attributi di classe ..................................................... 41
6.6. Finalizzare e verificare le modifiche .......................................................................... 41
6.7. Riepilogo .............................................................................................................. 42
7. Imporre la qualità dei dati mediante class warning ................................................................. 43
7.1. Riepilogo .............................................................................................................. 46
C. Lavorare con più classi e relazioni .............................................................................................. 47
8. Lavorare con le associazioni .............................................................................................. 48
8.1. Aggiungere una nuova classe al modello .................................................................... 48
8.2. Rappresentare informazioni mediante classi distinte ..................................................... 49
8.3. Rendere le modifiche definitive ................................................................................ 52
8.4. Testare le modifiche ............................................................................................... 52
8.5. Aggiornare un engine archiviato ............................................................................... 53
8.6. Importazione di un file XLS complesso ..................................................................... 54
8.7. Ripristino di un engine dalla Libreria ........................................................................ 57
9. Lavorare con le composizioni ............................................................................................. 58
9.1. Introduzione alle composizioni multiple ..................................................................... 58
9.2. Introduzione alle composizioni singole ...................................................................... 59
9.3. Riepilogo .............................................................................................................. 61
ii
Tutorial di Livebase
10. Attributi derivati definiti mediante query ............................................................................ 62
10.1. Creare attributi di tipo query .................................................................................. 62
10.2. Riepilogo ............................................................................................................ 64
D. Tecniche di modellazione avanzate ............................................................................................. 65
11. Scomporre un modello esteso in diagrammi multipli ............................................................. 66
11.1. Espandere il modello con classi aggiuntive ............................................................... 66
11.2. Aggiungere nuovi diagrammi ................................................................................. 68
11.3. Ripulire il diagramma iniziale ................................................................................ 74
11.4. Riepilogo ............................................................................................................ 76
12. Personalizzazione delle applicazioni per specifici gruppi di membri ......................................... 77
12.1. Partizionamento verticale: abilitare e disabilitare classi ............................................... 77
12.2. Partizionamento per profilo utente ........................................................................... 87
12.3. Partizionamento orizzontale: filtrare i record ............................................................. 90
12.4. Riepilogo ............................................................................................................ 91
E. Localizzazione delle applicazioni generate .................................................................................... 92
13. Localizzazione dell'applicazione generata ............................................................................ 93
13.1. Personalizzare le stringhe generate automaticamente ................................................... 93
F. Gestire i Cloudlet ..................................................................................................................... 95
14. Lavorare con più Cloudlet ................................................................................................ 96
14.1. Esportare modelli in formato XML ......................................................................... 96
14.2. Clonare i Cloudlet ................................................................................................ 96
14.3. Copiare i singoli componenti .................................................................................. 97
14.4. Importare modelli in formato XML ......................................................................... 97
14.5. Eliminare i Cloudlet ............................................................................................. 97
14.6. Riepilogo ............................................................................................................ 98
15. Importare ed esportare i dati del Cloudlet ........................................................................... 99
15.1. Esportare il database da un Cloudlet come file SQL ................................................... 99
15.2. Popolare il database usando un file SQL ................................................................. 100
15.3. Esportare i dati nel formato Microsoft Access Database ............................................. 100
15.4. Riepilogo .......................................................................................................... 100
16. Configurare i default di un Cloudlet ................................................................................. 101
G. Lavorare con Excel ................................................................................................................ 104
17. Importare Flat e Star sheet ............................................................................................. 105
17.1. Preparazione dell'ambiente di lavoro ...................................................................... 105
17.2. Importare un semplice Flat sheet ........................................................................... 105
17.3. Importare un semplice Star sheet ........................................................................... 106
17.4. Star sheet con ruoli multipli ................................................................................. 106
17.5. Create sheet versus Append sheet ..................................................................... 107
17.6. Riepilogo .......................................................................................................... 107
18. Importare i Reference sheet ............................................................................................ 108
18.1. Struttura di un Reference sheet ............................................................................. 108
18.2. Create Reference sheet versus Append Reference sheet ......................................... 108
18.3. Testare un Reference sheet ................................................................................... 108
19. Importare i Relation sheet .............................................................................................. 110
19.1. Struttura di un Relation sheet ............................................................................... 110
19.2. Create Relation sheet versus Append Relation sheet ............................................. 110
19.3. Relation sheet all'opera ........................................................................................ 110
20. Connettersi ad un Cloudlet via Web ................................................................................. 113
20.1. Stabilire la connessione ....................................................................................... 113
20.2. Esplorare i dati .................................................................................................. 115
20.3. Selezionare i dati da importare .............................................................................. 115
20.4. Importare i dati selezionati ................................................................................... 116
20.5. Aggiornare i dati importati in modo automatico ....................................................... 117
iii
Tutorial di Livebase
20.6. Opzioni di una query Web ...................................................................................
20.7. Gestire query Web in file separati .........................................................................
H. Creare i report .......................................................................................................................
21. Creare un semplice report tabellare ..................................................................................
21.1. Costruire il modello ............................................................................................
21.2. Configurare il report ...........................................................................................
21.3. Stampare il report ...............................................................................................
21.4. Raggruppare i dati in sezioni multiple ....................................................................
22. Creare un report a campi incrociati ..................................................................................
22.1. Modificare il modello ..........................................................................................
22.2. Configurare il report ...........................................................................................
22.3. Stampare una versione preliminare del report ..........................................................
22.4. Raggruppare i dati per paese ................................................................................
22.5. Stampare il report ...............................................................................................
23. Creare grafici ...............................................................................................................
23.1. Rappresentare i dati in un grafico a torta ................................................................
23.2. Rappresentare i dati in un grafico a barre ................................................................
Glossario dei termini ..................................................................................................................
iv
118
119
121
122
122
123
124
125
127
127
131
132
132
133
134
134
136
139
Introduzione
In questo capitolo introduciamo la piattaforma Livebase. Descriviamo i componenti principali della piattaforma
fornendo una panoramica essenziale dei concetti che stanno alla base di Livebase e delle applicazioni costruite
con essa. Inoltre descriviamo l'interfaccia utente principale di Livebase (Dashboard).
1. Panoramica generale
Livebase è una piattaforma Web che consente di creare e gestire applicazioni database nel cloud. L'innovativa
tecnologia alla base di Livebase fornisce un valido ambiente in cui è possibile sviluppare e dispiegare applicazioni
database facilmente e velocemente. Non è necessario acquistare o installare nessun componente hardware o
software. Non sono necessari altri requisiti tecnici specifici se non una connessione ad Internet e un Web browser
aggiornati con Javascript e cookies abilitati. Tutte le applicazioni database create con Livebase sono eseguite online in un unico ambiente integrato, condividendo un modello di dati e un'interfaccia utente comune. Inoltre, per
ogni applicazione viene creata un'interfaccia REST per facilitarne l'integrazione con dati e applicazioni esterne
a Livebase.
Le applicazioni Livebase sono create e personalizzate utilizzando un approccio puramente concettuale, visuale e
model-driven ispirato al paradigma MDA. Questo approccio consente di focalizzarci solo sulle informazioni di
business che devono essere manipolate e di ottenere delle applicazioni di business funzionali ed efficaci molto
velocemente, utilizzando delle minime competenze tecniche. Mediante la definizione di classi e relazioni tra classi,
sarà possibile sviluppare applicazioni di business basate sul Web senza scrivere una sola riga di codice. Maggiori
dettagli sulle classi saranno forniti più avanti nel corso del tutorial.
2. Per iniziare
Una volta che hai effettuato il login, puoi avviare la Dashboard (Figura 1) dall'interfaccia della sezione My account
del portale. Ti verrà richiesto di scaricare un file JNLP: configura il tuo browser per aprirlo automaticamente per
avviare la Dashboard. Nella Dashboard puoi creare e gestire i tuoi sistemi informativi. Essa contiene tre sezioni
principali.
v
Introduzione
Figura 1. Dashboard
Cloudlets
Il riquadro Cloudlets mostra tutti i Cloudlet creati nel tuo account. Quando effettui il login per la prima volta,
non ci sono Cloudlet da mostrare. Il riquadro contiene sotto riquadri corrispondenti ai vari Cloudlet, disposti
verticalmente. In generale, un Cloudlet può essere considerato come un server virtuale composto da:
• l'insieme degli utenti finali che possono accedere al Cloudlet, chiamato registro dei membri del Cloudlet;
• l'insieme delle applicazioni in esecuzione sul server virtuale, chiamato Cloudlet engine;
• il database relazionale contenente i dati manipolati dall'engine, chiamato Cloudlet database.
L'engine consente ai membri di un Cloudlet di collaborare interrogando e aggiornando il database del Cloudlet in
maniera concorrente rispettando dei vincoli ben definiti in grado di assicurare l'integrità e la confidenzialità dei
dati. La tecnologia dei database relazionali consente ai membri di un Cloudlet di effettuare query complesse (non
semplici ricerche testuali) garantendo la sicurezza delle modifiche transazionali.
Ogni Cloudlet ha un nome univoco e una URI dedicata che dipende dal server di hosting dove l'applicazione
è stata dispiegata, dal tuo username e dal nome del Cloudlet. Per esempio, un Cloudlet chiamato
Workforce potrebbe avere come URI https://hs3.fhoster.com/your_username/Workforce,
dove hs3.fhoster.com identifica il server di hosting e your_username rappresenta lo username che hai
vi
Introduzione
utilizzato per effettuare il login in Livebase. Puoi accedere alla homepage del Cloudelt facendo click direttamente
sulla sua URI. La homepage si aprirà in una finestra separata del browser.
I Cloudlet che crei nel tuo account sono di tua proprietà. Il numero dei Cloudlet che puoi creare dipende dal
piano che hai sottoscritto. I membri di un Cloudlet vengono definiti da te, in quanto proprietario del Cloudlet
stesso. Anche il numero dei membri che puoi aggiungere a un Cloudlet dipende dal piano che hai sottoscritto. I
membri accedono al Cloudlet effettuando il login nella homepage del Cloudlet inserendo username e password, e le
password dei membri del Cloudlet non vengono mostrate al proprietario del Cloudlet. La gestione del tuo account
e delle risorse assegnate al piano sottoscritto verrà discussa più in dettaglio in Capitolo 1, Gestire il tuo account.
Un Cloudlet può essere avviato e arrestato in ogni momento dal suo proprietario. Lo stato in cui si trova il Cloudlet
è mostrato nella parte in basso a destra del riquadro del Cloudlet. Se il Cloudlet non è in esecuzione, la sua
homepage è accessibile ma i suoi membri non possono fare il login, mentre è possibile eseguire tutte le operazioni
di manutenzione. Invece, se il Cloudelt è in esecuzione i suoi membri possono effettuare il login, ma è possibile
eseguire solo alcune delle operazioni di manutenzione. Un Cloudlet non può essere avviato se non ha un engine o
il database, o se quest'ultimo è incompatibile con l'engine. I comandi che possono essere eseguiti su un Cloudlet
verranno descritti in dettaglio nel corso del tutorial.
Engines
Il riquadro Engines mostra gli engine che hai creato e archiviato precedentemente. Questa lista è la tua Libreria
privata. Gli engine presenti nella Libreria possono essere riutilizzati ed estesi in qualunque momento. Non c'è
praticamente limite al numero di engine che puoi memorizzare nella tua Libreria. L'archiviazione di un engine
nella Libreria sarà spiegata più avanti nel tutorial.
Trash
Il riquadro Trash è utilizzato per eliminare i componenti. L'eliminazione di un engine, di un database o addirittura
di un Cloudlet intero può essere fatta in modo molto semplice, e sarà mostrato nei capitoli successivi.
3. Riepilogo
In questo capitolo abbiamo introdotto la piattaforma Livebase ed alcuni dei suoi concetti di base. Nel corso
del tutorial mostreremo più in dettaglio come sia possibile usare la piattaforma per creare applicazioni database
personalizzate.
vii
Parte A. Gestire il tuo account
Capitolo 1. Gestire il tuo account
In questo capitolo descriviamo la sezione del portale Web di Fhoster in cui puoi gestire i dettagli relativi al tuo
account (il piano sottoscritto, le informazioni per la fatturazione e il metodo di pagamento scelto, gli ordini e le
ricevute) e personalizzare i default dei Cloudlet (impostazioni e preferenze utilizzate al livello di amministrazione).
L'accesso a questa sezione avviene automaticamente dopo il login, oppure cliccando sul link My account se hai
già effettuato il login.
1.1. Organizzazione del tuo account
Accendendo alla sezione My account viene mostrata lo sottosezione Home (Figura 1.1). Da qui puoi modificare i
tuoi dati personali, cioè l'indirizzo email (quello che hai fornito in fase di iscrizione) e la password (per motivi di
sicurezza i caratteri saranno sostituiti con degli asterischi *** o dei pallini •••). Sempre da questa pagina puoi
controllare lo stato del tuo account.
Figura 1.1. Pannello My account
Se il tuo account è attivo (Active), la tua sottoscrizione verrà rinnovata automaticamente alla fine di ogni mese. Puoi
disabilitare il rinnovo automatico in ogni momento facendo click sul bottone Disable automatic renewal. Facendo
ciò il tuo account passerà nello stato Active, automatic renewal disabled. Se non riattivi il rinnovo automatico
prima della fine dell'ultimo mese che hai già pagato, il tuo account verrà sospeso (Suspended). La sospensione
dell'account non elimina immediatamente tutte le informazioni ad esso associate ma non ti consente di accedere
alla Dashboard, di gestire i tuoi Cloudlet e di effettuare il download degli engine e dei database.
Nota
In caso di fallimento nei pagamenti il tuo account verrà automaticamente sospeso. Ciò potrebbe
essere dovuto al fatto che il metodo di pagamento specificato nella sezione del Billing non è valido.
Indipendentemente dal motivo per cui il tuo account è stato sospeso, hai 30 giorni (a partire dalla data di
sospensione) per riattivarlo. Terminati questi 30 giorni, al 31-esimo giorno dalla sospensione il tuo account sarà
eliminato definitivamente (irreversibilmente) e con esso saranno cancellati tutti i tuoi Cloudlet e le informazioni
2
Gestire il tuo account
in essi contenute. Ciò vuol dire che i membri dei tuoi Cloudlet perderanno irrimediabilmente tutti i dati che hanno
memorizzato nei Cloudlet. Invece, se riattivi il tuo account pagherai per il periodo intercorso dal momento in cui
hai sospeso l'account fino alla fine del mese corrente. Non sono previsti rimborsi per il periodo in cui l'account
è stato sospeso.
1.2. Dettagli sulla sottoscrizione
Al momento della registrazione su Livebase, ti è stato assegnato di default il piano gratuito che prevede risorse
sufficienti per valutare la piattaforma e per creare sia per uso personale che per uso commerciale piccole
applicazioni caratterizzate da pochi requisiti (ad esempio, meno di 1000 oggetti nel database). Puoi continuare ad
usare il piano gratuito quanto vuoi. Ricordati soltanto che la tua iscrizione verrà cancellata dopo due mesi di non
utilizzo. Un piano di sottoscrizione comprende un insieme di risorse del seguente tipo:
• Numero di membri del Cloudlet
• Numero di oggetti nel database
• Traffico dati mensile (espresso in MB)
• Spazio di archiviazione (espresso in MB)
• Numero di Cloudlet
• Spazio di backup (espresso in MB)
La quantità di risorse assegnate al tuo account e il loro livello di utilizzo sono mostrati nella sezione Subscription
(Figura 1.2). Puoi distribuire le risorse tra i vari Cloudlet del tuo account se è necessario. Livebase controllerà che
la quantità di risorse a te assegnate non venga superata impedendoti di utilizzare più risorse di quelle a disposizione
a meno di liberarne alcune o comprarne di nuove cambiando il tuo piano di sottoscrizione. In ogni momento
puoi modificare il tuo piano (upgrade/downgrade) e puoi comprare/dismettere risorse aggiuntive (extension pack).
Per esempio, puoi passare dal piano gratuito al piano team e comprare anche un extension pack che aggiunge 4
Cloudlet in più all'insieme delle risorse. Per cambiare il piano basta fare click sul bottone Change nella sezione
Subscription. Nota che se effettui dei cambiamenti al tuo piano è possibile che ti venga chiesto di inserire le
informazioni necessarie per la fatturazione e di specificare un metodo di pagamento valido (vedi la Sezione 1.3).
Figura 1.2. Sezione Subscription
3
Gestire il tuo account
1.3. Fatturazione e metodi di pagamento
Al momento della sottoscrizione, se hai utilizzato un voucher d'invito, ti è stato assegnato un credito promozionale
che può essere speso per valutare gratuitamente uno qualunque dei piani a pagamento disponibili. Il credito
promozionale può essere utilizzato per modificare il tuo piano facendo un upgrade o comprando degli extension
pack senza pagare nulla e senza che sia necessario fornire le informazioni per la fatturazione, almeno fintanto che
il credito promozionale rimanente sia sufficiente a coprire il costo dell'operazione di upgrade. Per inciso, il credito
promozionale è da considerarsi virtuale e dunque non ti verrà rimborsato se cancellerai la tua iscrizione.
Il tuo canone mensile è visualizzato nella sezione Subscription insieme al credito disponibile che verrà dedotto
dalle fatture successive. Il canone mensile viene pagato in anticipo il primo giorno del mese a cui si riferisce.
Se effettui un upgrade del piano gratuito, pagherai al momento dell'acquisto una rata proporzionata al periodo
rimanente fino alla fine del mese in corso (pagamento una-tantum), e successivamente pagherai il nuovo canone
complessivo il primo giorno di ogni mese (pagamento ricorrente). Se invece effettui un downgrade del tuo piano
o dismetti parzialmente degli extension pack nell'ambito di un ciclo mensile di fatturazione, ti verrà assegnato un
credito pari alla differenza tra l'ammontare del vecchio canone mensile e l'ammontare del nuovo canone per la
rimanente parte del ciclo di fatturazione. Puoi inserire le informazioni necessarie per la fatturazione nella pagina
del Billing (Figura 1.3) facendo click sul pulsante Edit e compilando il corrispondente form. Come avrai notato,
il form contiene dei campi diversi a seconda della tipologia di cliente (privato o business) e a seconda del paese di
riferimento. I pagamenti possono essere effettuati mediante PayPal o mediante una delle carte di credito supportate
da PayPal (Visa, MasterCard, Discover, American Express).
Figura 1.3. Pagina del Billing
1.4. Ordini
Ogni volta che modifichi il tuo piano (cioè ogni volta che fai un upgrade/dowgrade del piano o aggiungi/dismetti
un extesion pack) viene emesso un ordine. L'elenco degli ordini, a partire dalla tua iscrizione in poi, è visualizzato
nella pagina Orders (Figura 1.4). Ciascun ordine è identificato dalla data di emissione, un numero ed una breve
descrizione.
4
Gestire il tuo account
Figura 1.4. Pagina Orders
1.5. Fatture
Fhoster non emetterà alcuna fattura fintanto che il tuo piano è quello gratuito. Se passi da un piano gratuito ad uno a
pagamento, cominceremo a fatturare nel momento in cui ti addebiteremo dei soldi. Se ti è stato assegnato del credito
promozionale in fase di registrazione emetteremo fattura quando il credito residuo non sarà sufficiente a coprire
l'ammontare da pagare. A partire dal primo pagamento, noi emetteremo una fattura internazionale (comprensiva
di VAT, se applicabile) per ogni pagamento che effettuerai (anche se l'ammontare da pagare è € 0,00 perché avevi
già del credito). Ovviamente termineremo di emettere fattura qualora effettuerai un downgrade da un piano a
pagamento ad uno gratuito.
Le fatture possono riferirsi a pagamenti una-tantum (nel qual caso si riferiscono a degli ordini specifici) o a
pagamenti ricorrenti. La lista delle fatture è visibile nella pagina Invoices (Figura 1.5). Per ciascuna fattura sarà
disponibile un file PDF che potrà essere scaricato, stampato e avrà a tutti gli effetti il valore legale di una ricevuta.
5
Gestire il tuo account
Figura 1.5. Pagina Invoices
1.6. Impostare i default per i nuovi Cloudlet
I default di un Cloudlet sono impostazioni e parametri utilizzati di default da tutti i membri del Cloudlet. I default
sono visualizzati nella pagina Defaults nella sezione My account (Figura 1.6). Per personalizzare questi default
fai click sul pulsante Edit. I default possono essere impostati sia in Italiano che in Inglese. Per passare da una
lingua all'altra puoi fare click sul tab corrispondente Italiano/English. Tutto ciò che imposti in questa pagina sarà
applicato a tutti i Cloudlet che creerai nel tuo account. Nel Capitolo 16 mostreremo come invece sia possibile
impostare dei default per un Cloudlet specifico. I default di un Cloudlet si dividono in due categorie: i default
relativi alla homepage del Cloudlet e i defaults relativi ai template delle email.
6
Gestire il tuo account
Figura 1.6. Default per i nuovi Cloudlet
Homepage
Qui puoi specificare le informazioni che verranno visualizzate nella homepage del Cloudlet. Nel campo
Description puoi inserire una descrizione che sarà relativa a tutti i Cloudlet che creerai nel corso del tutorial (ad
esempio, Questo Cloudlet è stato creato utilizzando Livebase a scopi didattici).
Nel campo Warning and News, puoi digitare notifiche e comunicazioni per tutti i membri del Cloudlet (ad esempio,
Giovedì 20 Novembre il Cloudlet Workforce sarà in manutenzione). Infine nel campo
Terms and Conditions puoi specificare la polizza di accordo con i membri del Cloudlet. L'accordo è una sorta di
contratto tra te (proprietario del Cloudlet) e i membri del Cloudlet che regola l'utilizzo del Cloudlet da parte dei
suoi membri (ad esempio, La registrazione a questo Cloudlet consente l'inserimento,
la modifica e la cancellazione dei dati solo mediante le applicazioni fornite
con il Cloudlet stesso).
Mail templates
Qui puoi specificare il template delle email che verranno inviate ai membri del Cloudlet. Al momento sono
disponibili due tipi di template: Member account creation (quando viene creato un account per un
membro) and Member account data recovery (quando un membro deve recuperare la propria username/
password). In entrambi i casi viene visualizzata una email di esempio che può essere modificata e personalizzata
utilizzando gli elementi dalla lista Placeholders che trovi sulla destra, che a loro volta saranno sostituiti con i valori
effettivi relativi ai dettagli dell'account. Per esempio, nel template per l'email Member account creation,
${firstName} e ${lastName} saranno sostituiti con il nome ed il cognome del membro del Cloudlet per
il quale si sta creando l'account.
1.7. Riepilogo
In questo capitolo abbiamo spiegato gli aspetti relativi alla gestione del tuo account e della tua sottoscrizione
al servizio Livebase. Per ulteriori dettagli sulla nostra offerta commerciale (prezzi e piani di sottoscrizione) ti
invitiamo a visitare la pagina del pricing sul nosto sito Web aziendale (www.fhoster.com).
7
Parte B. Gestire modelli
con una sola classe
Capitolo 2. Creazione di una semplice
applicazione anagrafica
In questo capitolo mostriamo come sia possibile creare una semplice applicazione per gestire una lista di
dipendenti. Per fare ciò, dobbiamo creare un nuovo Cloudlet con un modello caratterizzato da una sola classe.
Successivamente, mostriamo come avviare il Cloudlet e provare l'applicazione generata.
2.1. Creazione dell'applicazione
Accedi a Livebase facendo il login. Una volta effettuato l'acceso, puoi avviare la Dashboard, nella quale sono
mostrati i vari Cloudlet che sono stati creati nel tuo account. Ovviamente al momento non ci sono Cloudlet.
Per crearne uno fai click sul bottone New cloudlet. Al nuovo Clouldet sarà assegnato il nome di default
NewCloudlet1. Rinomina il Cloudlet in Workforce facendo un doppio click su NewCloudlet1. Siccome
il Cloudlet Workforce è appena creato, nel riquadro ad esso relativo sarà mostrato No engine, ad indicare che
non c'è un engine e un database. Per creare un engine fai click su No engine. Ciò porterà alla creazione di un
engine vuoto e aprirà in una finestra separata del browser il Designer. Il Designer è quel componente di Livebase
che ti consente di progettare e modificare la struttura dell'applicazione. La finestra del Designer è divisa in tre
sezioni principali:
• una lista di viste e classi sulla sinistra;
• una panoramica in miniatura del diagramma disposta sotto di essa;
• il diagramma principale sulla destra.
Al momento ci focalizzeremo sulla vista Database ( ), che è attivata di default. A questo livello puoi definire il
modello dati dell'applicazione, cioè le classi e le relazioni tra le classi che ne formano la struttura.
Il concetto base nella nostra applicazione è persona. Quindi, creiamo una classe che rappresenti le persone e
aggiungiamo degli attributi per memorizzare le informazioni relative ad una persona che ci interessano, tipo nome
(first_name), cognome (last_name), titolo (title) e data di nascita (birthday). Fai click sull'icona
che trovi nella Palette toolbar (Figura 2.1) nella finestra del Designer. Una nuova classe chiamata Class1
viene creata. Il nome della classe è selezionato ad indicare il fatto che può essere cambiato immediatamente. Per
rinominare la classe in Person, scrivi semplicemente Person e premi Enter.
9
Creazione di una semplice applicazione anagrafica
Figura 2.1. La Palette toolbar
Aggiungiamo adesso degli attributi alla classe. Per fare ciò, fai click con il tasto destro del mouse sull'header della
classe Person e seleziona dal Class menu New attribute. Per ciascun attributo seleziona il tipo di dato
e assegna un nome. Una volta aggiunti i quattro attributi scelti per una persona (first_name, last_name,
title, birthday) la classe risultante dovrebbe essere come quella mostrata in Figura 2.2.
Figura 2.2. La classe Person
Perfezioniamo ulteriormente la definizione della classe Person imponendo dei vincoli sui valori che possono
memorizzati nei suoi attributi. Per come è stata definita attualmente la classe è ammissibile che gli attributi siano
vuoti, cioè non contengano valori. Potremmo quindi creare un oggetto della classe Person senza nome, cognome,
titolo e data di nascita, il che ovviamente non avrebbe senso. Per impedire queste situazioni dobbiamo imporre
che i campi degli attributi siano non nulli. A tale scopo, fai click con il tasto destro del mouse su first_name
e seleziona Required dall'Attribute menu. Osserva come in seguito a questa azione accanto al nome
dell'attributo compaia un asterisco rosso ad indicare appunto che l'attributo è richiesto. Fai la stessa cosa per
gli attributi last_name e birthday. Invece, per quanto riguarda title non è necessario impostarlo come
obbligatorio in quanto non è detto che una persona abbia un titolo.
Un altro aspetto che dobbiamo considerare è la presenza di duplicati. Potremmo ad esempio voler impedire
l'inserimento di due persone con medesimo nome, cognome e data di nascita (e.g. due oggetti della classe
Person aventi entrambi nome Bob, cognome Dole e data di nascita 15/03/1977). Per impedire ciò possiamo
aggiungere un vincolo di unicità. Seleziona contemporaneamente gli attributi first_name, last_name e
10
Creazione di una semplice applicazione anagrafica
birthday tenendo premuto il tasto Ctrl mentre fai click su di essi. A questo punto fai click con il tasto destro
del mouse su uno qualunque degli attributi e seleziona Make unique dall'Attribute menu. Al termine di
questa operazione apparirà sulla base del riquadro della classe un'icona ( ) ad indicare che sulla classe è stato
impostato un vincolo di unicità. Facendo click sull'icona gli attributi della classe coinvolti nel vincolo vengono
evidenziati. Il vincolo di unicità che abbiamo definito impedisce che due oggetti della classe Person abbiano lo
stesso nome, cognome e data di nascita, ma non impedisce che abbiano lo stesso valore per due dei tre attributi
(ad esempio, lo stesso nome e cognome ma diversa data di nascita). La classe Person così come risulta da queste
modifiche è mostrata in Figura 2.3.
Figura 2.3. La classe Person (cnt.)
A questo punto abbiamo una buona base di partenza per la nostra applicazione. Salva il tuo lavoro selezionando
File → Save (Ctrl+S). Osserva come in seguito al salvataggio la classe Person sia cambiata (Figura 2.4). In
particolare, l'attributo first_name è mostrato in neretto, ciò ad indicare che questo attributo è stato designato
come object title per la classe Person. Come spiegheremo più avanti, l'object title appare nel breadcrumb trail
ed è utilizzato per identificare l'oggetto della classe che si sta esaminando nell'applicazione generata. L'object title
è rappresentato dal valore di un singolo attributo. Se non viene indicato uno specifico attributo come object title
di una classe, Livebase di default definisce come object title il primo attributo che appare nella lista degli attributi
della classe nel momento in cui vengono salvate le modifiche per la prima volta (come è successo in questo caso).
Parleremo più in dettaglio degli object title nella Sezione 6.1.
Figura 2.4. La classe Person dopo il salvataggio
Chiudi la finestra del Designer selezionando File → Close (Ctrl+Q). Alla chiusura del Designer, si ritorna
alla Dashboard. Nel riquadro del Cloudlet Workforce adesso appare un engine chiamato NewEngine1 e No
database. Per rinominare l'engine fai doppio click su NewEngine1 e scrivi TutorialEngine. Alla base del
riquadro del Cloudlet è apparsa la scritta Cannot start (missing database) che ci informa che il Cloudlet ancora non
può essere avviato in quanto non è stato creato un database. Per creare un database avente la struttura necessaria
a supportare l'engine TutorialEngine è molto facile. Basta fare click su No database. In pochi istanti viene creato
il database e l'icona corrispondente appare nel riquadro del Cloudlet. Una volta creato il database, lo stato del
Cloudlet cambia in Stopped. A questo punto, facendo click sul comando Start in basso a destra nel riquadro del
Cloudlet, l'engine viene compilato e la corrispondente applicazione viene generata. Lo stato del Cloudlet al termine
della generazione passa a Running mentre il comando Start in basso a destra viene sostituito dal comando Stop
(Figura 2.5). Congratulazioni, la tua prima applicazione Livebase è ora in funzione!
11
Creazione di una semplice applicazione anagrafica
Figura 2.5. Il Cloudlet in azione
2.2. Inserire dati nell'applicazione
Ora che il Cloudlet è in esecuzione, fai click sulla sua URI (il link che si trova sotto il suo nome) per aprire
la homepage in una nuova finestra del browser. Nella homepage di Workforce sono visualizzati i defaults
Description, Warnings And News e Terms And Conditions oltre al form di login (Figura 2.6). Ogni Cloudlet ha
di default un membro auto-generato che ha la stessa username e password dell'account della piattaforma che lo
ha creato. Quindi, puoi effettuare il login nel tuo Cloudlet inserendo le stesse credenziali che usi per entrare in
Livebase.
12
Creazione di una semplice applicazione anagrafica
Figura 2.6. Homepage di Workforce
Una volta effettuato il login, verrà visualizzata una schermata divisa in tre pannelli (Figura 2.7):
• Applications sulla sinistra, in cui sono mostrate le applicazioni disponibili, in questo caso solo Application11
( );
• Members sulla destra, in cui sono elencati i membri del Cloudlet, in questo caso solo tu ( );
• Administration, in cui sono presenti due icone ( , e ) e facendo click su ciascuna di esse si aprirà una finestra
in cui è possibile rispettivamente configurare i default della homepage del Cloudlet, accedere al registro dei
membri del Cloudlet ed editare il css delle applicazioni disponibili nel Cloidlet.
1
Vedremo più avanti come cambiare ciò.
13
Creazione di una semplice applicazione anagrafica
Figura 2.7. Homepage di Workforce dopo il login
Fai click sull'icona di Application1 per far partire l'applicazione. Si apre una nuova schermata contente due
pannelli. A sinistra trovi la lista delle tabelle a cui l'applicazione può accedere (attualmente solo Open person).
Facendo click su Open person nel pannello di destra viene mostrato la Livetable relativa alla classe Person
(Figura 2.8)
14
Creazione di una semplice applicazione anagrafica
Figura 2.8. La Livetable di Person
Il nome della classe è mostrato nella parte alta della Livetable (Person). Immediatamente sotto è visualizzato
il breadcrumb che marca la posizione nella Livetable (in questo caso All instances) e, sulla destra, il bottone
Reload per ricaricare i dati dal database sottostante nel caso in cui più membri stiano utilizzando l'applicazione
contemporaneamente. La tabella ha quattro colonne che nel nostro caso corrispondono ai quattro attributi che
abbiamo aggiunto prima alla classe Person. Come puoi notare, i nomi degli attributi sono stati cambiati in modo
intellegibile per essere utilizzati come nomi delle colonne nella tabella.
Per aggiungere un record alla tabella, fai click sul bottone Create sulla destra. Quest'azione porta all'apertura
dell'Object editing panel dove puoi inserire i valori nei specifici campi dell'oggetto (Figura 2.9). In questo caso,
il pannello contiene quattro campi per il nome, cognome, titolo e data di nascita. Il breadcrumb è cambiato in All
instances > new object, indicando così che si sta creando un nuovo oggetto nella Livetable. Una volta che avrai
terminato di compilare i vari campi del form, fai click su Save per creare il record.
Suggerimento
Per muoverti velocemente da un campo all'altro del form puoi usare il tasto Tab.
15
Creazione di una semplice applicazione anagrafica
Figura 2.9. Object editing panel
Nel modello abbiamo specificato che i campi relativi al nome, cognome e data di nascita sono obbligatori. Se provi
a creare un record senza riempire uno di questi campi, una volta premuto Save ti verrà inviato un messaggio di Data
validation error con delle indicazioni in merito al tipo di errore. Inoltre, i campi vuoti (ma obbligatori) saranno
evidenziati con i contorni in rosso e accanto ad essi verrà visualizzata un'icona di errore ( ). Facendo click su
questa icona si aprirà una finestra in cui saranno forniti dei feedback in merito all'errore. Per esempio, prova ad
inserire John nel campo first_name e Doe nel campo last_name e a non scivere nulla nel campo birthday. A
questo punto facendo click su Ok dovresti ottenere l'errore indicato nella Figura 2.10.
Figura 2.10. Data Validation Error: campo Birthday vuoto
Inserisci cinque record in Person come in Figura 2.11. Una volta creato un record, l'Object editing panel si
chiude e si ritorna alla Livetable di Person. Il numero totale degli oggetti presenti nella Livetable è mostrato
in basso (in questo caso 5).
16
Creazione di una semplice applicazione anagrafica
Figura 2.11. La Livetable di Person con 5 oggetti
Se provi ad inserire un record duplicato, contenente per esempio gli stessi dettagli di John Doe, verrà visualizzato
il messaggio di errore mostrato in Figura 2.12. Il Data validation error è dovuto al fatto che sugli attributi
first_name, last_name e birthday è stato impostato un vincolo di unicità.
Figura 2.12. Data Validation Error: record duplicato
Per modificare un oggetto puoi fare semplicemente doppio click su di esso (oppure puoi selezionarlo e fare click
sul bottone Open sulla destra). Prima non abbiamo inserito un titolo per Bob Dole e Adam Snook. Inseriscilo
adesso. Ad esempio, fai doppio click su Adam Snook. Si apre il pannello relativo all'oggetto ed il breadcrumb
cambia in All instances > Adam ad indicare che stai modificando l'oggetto il cui object title è Adam (se ti ricordi
l'attributo first_name è stato designato come object title). Per modificare i valori nei campi dell'oggetto fai
click sul bottone Edit in alto a destra, in seguito al quale si apre l'Object editing panel dell'oggetto in cui puoi fare
le modifiche. Inserisci Mr. nel campo Title. Premendo su Save ritorni alla Livetable. Nota come per l'oggetto
appena modificato sia apparso il valore Mr. nella colonna Title. Ripeti queste operazioni per inserire il titolo Mr.
anche per l'oggetto Bob Dole. In realtà non abbiamo bisogno di così tanti oggetti. Prova ad eliminare ad esempio
Bob Dole. Selezionalo nella tabella e fai click sul bottone Delete sulla destra. L'oggetto verrà immediatamente
eliminato portando così il numero totale degli oggetti nella Livetable a 4 objects.
Come hai visto, con un minimo sforzo sei stato in grado di create un'applicazione funzionante corredata anche
di un'interfaccia grafica attraverso la quale è possibile creare, ispezionare, modificare ed eliminare oggetti nel
database sottostante. Questo è solo l'inizio. Livebase ti consente di fare molto di più, come avremo modo di spiegare
nei prossimi capitoli. Per terminare la sessione, fai il logout dal Cloudlet.
17
Capitolo 3. Estendere la semplice
applicazione
In questo capitolo mostriamo come sia possibile estendere l'applicazione TutorialEngine creata nel Capitolo 2
aggiungendo delle funzionalità più avanzate.
3.1. Modificare l'applicazione
Non è possibile modificare un'applicazione mentre è in esecuzione. Dunque, devi arrestare il Cloudlet
Workforce per modificare il suo modello. Fai click su Stop in basso a destra nel riquadro del Cloudelt. Lo stato
del Cloudlet cambierà in Stopped, e al posto di Stop apparirà Start.
Aggiungere nuovi campi
Perfezioniamo il modello dell'applicazione. Diciamo che in realtà siamo interessati non tanto alle persone in genere
quanto piuttosto ai dipendenti di un'azienda. Per ciascun dipendente vogliamo tenere traccia del suo ruolo in
azienda, della data di assunzione, del salario e dell'indirizzo di casa, comprensivo ad esempio di via, città, CAP
e paese. Per modificare TutorialEngine devi avviare il Designer facendo click sull'icona dell'engine stesso. Il
Designer si aprirà in una finestra separata del browser con il livello Database attivato. Rinomina la classe Person
in Employee. Semplicemente fai doppio click sul nome della classe, digita il nuovo nome e premi Enter.
Suggerimento
Altri modi per rinominare la classe sono: fai click con il tasto destro del mouse sull'header della
classe e seleziona la voce Rename dal Class menu; oppure seleziona la classe con il mouse e
successivamente premi il tasto F2.
A questo punto aggiungi gli attributi necessari per memorizzare le informazioni di cui abbiamo parlato prima
(postion, date_hired, salary, address, city, zip, country). Successivamente, rinomina l'attributo
birthday in date_of_birth per uniformità. Puoi rinominare un attributo in maniera analoga a come si
rinomina una classe, cioè facendo doppio click sul nome dell'attributo, digitando il nuovo nome e premendo Enter,
o alternativamente facendo click con il tasto destro del mouse sull'attributo e selezionando l'opzione Rename
dall'Attribute menu, oppure anche selezionando prima l'attributo con il mouse e premendo successivamente
il tasto F2. La classe risultante da queste modifiche è mostrata in Figura 3.1.
Figura 3.1. La classe Employee
18
Estendere la semplice applicazione
Per come è stata definita la classe Employee è possibile aggiungere qualunque valore nei nuovi attributi. Questo
può creare dei problemi soprattutto per due attributi in particolare: zip e position. Al fine di effettuare un
controllo più specifico su questi attributi, è necessario definire delle restrizioni sul dominio dei valori ammissibili.
Se sul dominio dei valori di un attributo sono state impostate delle restrizioni, tutte le volte che viene inserito
un valore specifico nell'attributo (indipendentemente dal fatto che tale valore sia inserito mediante l'applicazione
generata o importato da qualche altra parte), questo viene controllato e validato rispetto alla restrizioni impostate.
Valori non validi vengono dunque rigettati immediatamente.
Per cominciare, imponi delle restrizioni sul dominio dell'attributo position. Per i nostri scopi, sarebbe meglio
definire una lista di valori predefiniti di posizioni dalla quale scegliere quella specifica per il dipendente in esame.
Fai click con il tasto destro del mouse sull'attributo position e seleziona Edit domain.... Si apre la finestra
String domain editor che ti consente di impostare dei vincoli sul dominio dell'attributo. Seleziona il flag Value
must match any of the following patterns e fai click sul bottone Add per aprire la finestra String value editor.
Nel campo Allowed value digita CEO e seleziona il flag Match case (per indicare di tenere in considerazione
lettere maiuscole e minuscole) e fai click sul bottone OK. La stringa CEO verrà aggiunta alla lista degli schemi
ammissibili. In maniera analoga, aggiungi le seguenti stringhe: CTO, Software engineer, QA tester,
Salesperson, selezionando per ciascuno di essi il flag Match case. Una volta terminato di aggiungere i valori
alla lista, fai click su OK. La restrizione impostata assicura che per ogni oggetto della classe Employee il valore
per l'attributo position (se presente) deve essere uno dei possibili valori specificati nella lista predefinita. In
questo caso, visto che sono state fornite solo costanti, per l'attributo in questione il suo valore sarà sempre uno
di quelli specificati.
Suggerimento
Un modo veloce per aggiungere valori semplici tutti insieme è il seguente. Una volta fatto click sul
bottone Add per aprire la finestra String value editor, seleziona Set of constants dal menu
Pattern type. In questo modo, il campo di tipo testo verrà sostituito da uno spazio più grande dove
potrai scrivere i valori consentiti, uno per riga (digita il valore e poi premi Enter).
Da notare come in seguito alla definizione delle restrizioni sul dominio dell'attributo position, questo sia
visualizzato nella classe come position: [string]. Le parentesi quadre indicano appunto che sul dominio
sono stati definiti dei vincoli che restringono l'insieme dei valori ammissibili per quell'attributo. Per quanto
riguarda invece l'attributo zip, anche per esso dobbiamo imporre dei vincoli sull'insieme dei valori ammissibili.
Assumiamo che il CAP sia una stringa contenente non più di cinque caratteri. Apri lo String domain editor per
l'attributo zip, con lo stesso procedimento usato per position. Specifica 5 nel campo Min length e 5 nel campo
Max length field, e fai click su OK. Così facendo hai imposto che il valore dell'attributo zip (se presente) sia di
esattamente 5 caratteri. Tuttavia, osserviamo che un carattere può essere qualunque cosa: una lettera, un numero,
un simbolo e persino uno spazio. Per controllare in maniera più fine i valori del dominio, dobbiamo specificare
uno schema a cui i valori si devono conformare. Riapri nuovamente il domain editor per l'attributo zip. In questo
caso, seleziona il flag Value must match any of the following patterns e fai click su Add. Nel caso dell'attributo
position abbiamo aggiunto solo valori costanti. In questo caso non possiamo fare la stessa cosa: ci sono
troppe combinazioni di lettere e numeri che rappresentano CAP validi e non possiamo aggiungerli tutti. Piuttosto,
possiamo specificare un'espressione regolare. Nel menu Pattern type seleziona Regular Expression. Nello
spazio sottostante digita la seguente espressione ^[A-Za-z0-9]+$ mediante la quale stiamo specificando che
saranno ammissibili sequenze di caratteri alfanumerici, e fai click su OK. Per fare una verifica, inserisci nel campo
Test value dei valori di prova, come ad esempio ASD09, jfkdk, 55555, a, 123456. Come avrai notato gli
ultimi due valori della lista non sono ammissibili, ed infatti sono stati rifiutati (i contorni del campo di test sono
diventati di colore rosso). A questo punto fai click su OK per salvare le modifiche e chiudere la finestra del domain
editor. Una volta ritornato al Designer, nota come anche l'attributo zip sia cambiato in zip: [string] per
via delle restrizioni imposte sul suo dominio. La classe risultante da queste modifiche è mostrata in Figura 3.2
19
Estendere la semplice applicazione
Figura 3.2. La classe Employee (cnt.)
Salva le modifiche selezionando File → Save (Ctrl+S). Chiudi la finestra del Designer selezionando File
→ Close (Ctrl+Q) per ritornare alla Dashboard. Lo stato del Cloudlet Workforce è cambiato in Cannot start
(engine/database mismatch) ed è apparsa un'icona di warning sul database. Ciò è dovuto al fatto che abbiamo
effettuato dei cambiamenti nell'engine ma non abbiamo aggiornato conseguentemente il database sottostante.
Per riparare l'errore, fai click sull'icona del database per aprire la finestra di dialogo del database. Nel tab
Engine compatibility issues è mostrata la lista di tutti i problemi di allineamento del database, cioè relativi alla
compatibilità del database con l'engine, con l'indicazione del loro grado di gravità. Nel nostro caso abbiamo solo
low severity issue, cioè problematiche che Livebase può riparare automaticamente senza che vi sia perdita di dati.
Per consentire a Livebase di effettuare le dovute correzioni, fai click sul bottone Resolve all issues. Una volta che i
problemi sono state corretti, si riapre nuovamente la finestra di dialogo del database con il tab Engine compatibility
issues disabilitato e la lista dei problemi di allineamento vuota. Per ritornare alla Dashboard chiudi la finestra del
database. Nota come a questo punto, lo stato del Cloudlet Workforce sarà diventato Stopped e l'icona di warning
sarà scomparsa.
Inserire valori nei nuovi campi
Avvia il Cloudlet Workforce ed effettua il login dalla sua homepage. Fai click su Application1 per aprire
l'applicazione. Una volta partita l'applicazione, fai click su Open employees. La Livetable della classe Employee
si aprirà nel pannello di destra. Nella tabella saranno presenti delle nuove colonne corrispondenti agli attributi che
abbiamo aggiunto prima. Riempi i campi aggiuntivi per i pochi record presenti nella tabella. Fai doppio click su
uno dei record e poi premi il bottone Edit. Nota la presenza di un menu a tendina nel campo Position che mostra
la lista dei possibili valori che possono essere assegnati. Questo è il risultato del vincolo che abbiamo imposto
sul dominio dell'attributo position per restringere l'insieme dei valori ammissibili. Analogamente, se provi ad
inserire un CAP non valido nel campo Zip otterrai un errore di Data validation error. Questo perché abbiamo
definito un vincolo sul dominio dei valori ammissibili per l'attributo zip. Una volta terminato l'inserimento dei
dati nei nuovi campi, chiudi l'applicazione ed effettua il logout.
3.2. Riallineare il database (problemi di media
entità)
Eliminare un attributo
Siccome l'oggetto della nostra applicazione si è spostato dalle persone in generale ai dipendenti di un'azienda,
l'informazione relativa al titolo è superflua. Possiamo dunque eliminare l'attributo title dalla classe Employee.
20
Estendere la semplice applicazione
Ferma il Cloudlet Workforce ed avvia il Designer per modificare TutorialEngine. Per eliminare l'attributo title
fai click con il tasto destro del mouse sull'attributo stesso e seleziona Delete dall'Attribute menu. Fai click
su Yes nella finestra di conferma. Successivamente, salve le modifiche nel modello e chiudi il Designer.
Riallineare il database
Una volta tornato alla Dashboard dovresti trovare i seguenti cambiamenti:
• ci sarà un'icona di warning sul database ad indicare che ci sono dei problemi di allineamento tra il modello
ed il database;
• lo stato del Cloudlet Workforce è cambiato in Cannot start (engine/database mismatch).
Il database deve essere nuovamente riallineato con il modello. Fai click sull'icona del database per aprire la finestra
di dialogo relativa. Il tab Engine compatibility issues è selezionato, ma questa volta nella lista dei problemi di
allineamento sarà mostrato un solo medium severity issue. Il problema è di media severità ed è dovuto al fatto che
hai eliminato l'attributo title dalla classe Employee. Il che comporta la perdita di tutti i valori memorizzati
per l'attributo in questione negli oggetti del database. Fai click su Resolve all issues per fare in modo che Livebase
risolva il problema. Una volta risolto il problema, tornato alla Dashboard osserva come l'icona di warning sul
database sia scomparsa e lo stato del Cloudlet sia diventato Stopped.
Verificare i cambiamenti
Avvia nuovamente Workforce ed accedi facendo il login dalla sua homepage. Avvia Application1 e fai click su
Open employees per aprire la Livetable di Employee. Come puoi notare, nella Livetable manca la colonna Title.
Se fai click su uno dei record, osserva come il campo manchi anche nel form del singolo oggetto. A questo punto,
avendo verificato i cambiamenti nella Livetable, puoi chiudere l'applicazione e terminare la sessione facendo il
logout dal Cloudlet.
3.3. Salvare un engine nella Library
È utile fare un backup degli engine costruiti precedentemente, nella fattispecie se si prevede di apportare dei
cambiamenti radicali al modello. Per l'archiviazione degli engine Livebase fornisce la Library. Fare il backup
di TutorialEngine è molto semplice, basta trascinarne l'icona dell'engine e rilasciarla sulla Library nel pannello
Engines.
Suggerimento
Non è necessario arrestare il Cloudlet per fare il backup del suo engine.
Quando archivi un engine, ricordati di inserire anche la descrizione e un commento negli appositi campi. Ad
esempio, puoi scrivere come descrizione Engine creato per il tutorial e come commento Versione
iniziale. Una volta archiviato nella Library, all'engine viene assegnato un numero di versione, in questo caso
1.0.0 visto che è la prima versione archiviata dell'engine, ed un timestamp che indica la data e l'ora in cui è
stato effettuato il backup.
3.4. Ripristinare un engine dalla Library
Puoi ripristinare un engine dalla Library in ogni momento. Per dimostrare l'utilità di questa funzionalità, proviamo a
fare dei cambiamenti distruttivi nel modello. Arresta Workforce e avvia il Designer per modificare TutorialEngine.
Elimina gli attributi zip e address. Salva le modifiche e chiudi il Designer.
21
Estendere la semplice applicazione
Suggerimento
Una volta tornato alla Dashboard, noterai che al numero di versione di TutorialEngine è stato
aggiunto MODIFIED (seguito da data e ora). Questo per indicare che l'engine è stato modificato
rispetto alla versione indicata dal numero.
In seguito all'eliminazione degli attributi, il database presenterà dei problemi di allineamento di media entità che
possono essere risolti come hai fatto prima in Sezione 3.2. Ma cosa accade se ti rendi conto che non avresti dovuto
eliminare quegli attributi dal modello? L'unico modo per correggere quest'errore è ripristinare il modello che hai
archiviato nella Library. Per prima cosa, elimina il TutorialEngine che attualmente è nel Cloudlet Workforce.
Per fare ciò devi semplicemente trascinare l'icona dell'engine e rilasciarla sul pannello Trash1. A questo punto
trascina il TutorialEngine versione 1.0.0 dal pannello Engines e rilascialo su Workforce. In un attimo l'engine sarà
ripristinato nel Cloudlet con eventualmente alcuni problemi di allineamento del database da risolvere.
1
Nota che hai eliminato solo l'engine e non il database.
22
Capitolo 4. Creare la stessa
applicazione importando un file XLS
Fin qui abbiamo visto come creare un'applicazione da zero, cioè partendo dal disegno del modello nel Designer.
Alternativamente, è possibile creare un'applicazione importando un file XLS. Solitamente i dati sono disponibili
in un file Excel. Livebase è in grado di estrarre automaticamente il modello concettuale di un'applicazione che
consenta di gestire i dati memorizzati nel file, e di importare questo modello con tutti i dati del file in un Cloudlet,
unendolo con l'engine eventualmente già presente nel Cloudlet. Da osservare che l'operazione di importazione del
file XLS è atomica: o viene eseguita completamente o non viene eseguita affatto.
Il file XLS da importare deve avere un formato specifico in modo da consentire alla piattaforma di effettuare
l'importazione correttamente. Ciò vale in particolare nel caso in cui il Cloudlet nel quale si vuole importare il
file già possiede un engine. Se il modello concettuale dell'engine già esistente nel Cloudlet è compatibile con il
formato del documento XLS da importare, l'importazione del file nel Cloudlet comporterà semplicemente solo
l'importazione dei dati nel database. In questo capitolo, descriviamo il formato Flat sheet, il più semplice dei
formati ammessi in Livebase che consente di creare modelli caratterizzate da classi main, cioè classi che non sono
parti in una composizione. Un Flat sheet deve essere formattato secondo le seguenti regole:
• Un foglio di lavoro per classe: il file deve contenere un foglio di lavoro per ogni classe che si desidera creare
nel modello. Il nome della classe è dato dal nome del foglio di lavoro.
Suggerimento
I fogli il cui nome inizia con il prefisso # sono ignorati.
• Una riga per oggetto: ogni riga nel foglio di lavoro rappresenta un oggetto della classe.
• Una colonna per attributo: ogni attributo della classe è dato da una colonna di valori nel foglio di lavoro.
Suggerimento
Le colonne vuote che separano gruppi di attributi sono ignorate.
• Una riga d'intestazione opzionale in ogni foglio: ogni foglio di lavoro può avere come prima riga un'intestazione
in cui ci sono i nomi delle colonne di valori. Questi nomi sono usati come nomi per gli attributi della classe.
Nota
I nome delle colonne devono essere scritti secondo le stesse regole valide per gli identificatori.
Suggerimento
Le colonne il cui nome inizia con il prefisso # sono ignorate.
Se la classe (o le classi) descritta(e) nel file già sono presenti nel database, la classe (o le classi) importata nel
modello saranno rinominate nel seguente modo: Name_1, Name_2, ecc. Se vuoi sostituire le classi già esistenti,
devi eliminarle (se non addirittura eliminare l'intero engine) prima di fare l'import del file. I tipi di dato degli
attributi della classe sono dedotti automaticamente a partire dall'analisi del dato presente nella prima cella di ogni
colonna. In pratica, la sequenza (semplificata) di passi che viene eseguita è la seguente.
23
Creare la stessa applicazione importando un file XLS
1. Se la cella contiene solo numeri interi, l'attributo sarà di tipo integer.
2. Se la cella contiene un numero frazionario, l'attributo sarà di tipo real.
3. Se la cella è impostata come data con un componente di tipo tempo, l'attributo sarà di tipo datetime.
4. Se la cella è impostata come data, l'attributo sarà di tipo date.
5. Se la cella è impostata come tempo, l'attributo sarà di tipo time.
6. Se la cella contiene TRUE o FALSE, l'attributo sarà di tipo boolean.
7. In tutti gli altri casi, l'attributo sarà di tipo string.
Facciamo vedere come sia possibile utilizzare un foglio elettronico Excel per creare lo stesso modello che
abbiamo costruito precedentemente. A tale scopo, abbiamo preparato un file Excel Employee.xls. Questo
file contiene i dati di una lista di dipendenti. Come puoi notare, il file è stato formattato seguendo le regole
descritte prima. In particolare, il file contiene un singolo foglio di lavoro chiamato Employee. Ogni riga nel
foglio di lavoro corrisponde ad un oggetto di tipo Employee. Le colonne del foglio di lavoro corrispondono
agli attributi della classe Employee (first_name, last_name, date_of_birth, position, city,
date_hired, salary, country, address, zip). A questo punto, elimina dal Cloudlet Workforce sia
l'engine che il database. Trascina semplicemente con il mouse entrambe le icone e rilasciale sull'area Trash. Poi
importa in Workforce il file Excel. Ciò può essere fatto in due modi: trascinando e rilasciando il file sull'area di
Workforce, oppure utilizzando il comando Import Excel del Cloudlet in basso a destra nel box del Cloudlet. Il file
verrà prima analizzato e successivamente i dati in esso contenuti verranno importati. In particolare, nel Cloudlet
Workforce saranno creati un engine chiamato NewEngine11 un database contenente tanti oggetti quante sono le
righe presenti nel foglio di lavoro, esclusa la riga di intestazione (in questo caso 500). Puoi rinominare l'engine
appena creato ma devi utilizzare un nome mai usato finora, tipo per esempio TutorialEngine1. Infatti, in
Livebase non possono esistere due elementi con lo stesso nome. Nel nostro caso, se provi a dare all'engine appena
creato il nome TutorialEngine, otterrai un errore perché già esiste un engine con lo stesso nome (è quello
che abbiamo archiviato nella Libreria).
Se vuoi assegnare all'engine creato dall'importazione il nome TutorialEngine devi procedere in questo modo.
Elimina l'engine TutorialEngine1 e il database appena creati. Ripristina TutorialEngine dalla Libreria su
Workforce. Successivamente, avvia il Designer e modifica TutorialEngine eliminando tutte le classi nel modello,
cioè nel nostro caso solo la classe Employee. Salva le modifiche e chiudi il Designer. Una volta tornato
alla Dashboard, importa nuovamente il file Excel così come è stato precedentemente descritto. Essendo ora
TutorialEngine vuoto, l'importazione del file Excel ha come risultato l'aggiunta della classe Employee al
modello. In questo modo, abbiamo ottenuto un nuovo engine ma con lo stesso nome TutorialEngine. Nei capitoli
successivi del tutorial, parleremo più in dettaglio dell'importazione dei file Excel in Livebase.
Indipendentemente dal nome che hai assegnato all'engine, apri il Designer per modificarlo. Come puoi vedere
nel modello è presente una classe Employee che non è esattamente la stessa che abbiamo definito nel capitolo
precedente. Ci sono infatti delle differenze dovute al formato del foglio Excel:
• Non ci sono attributi richiesti. Definisci gli attributi first_name, last_name e date_of_birth come
richiesti.
• Non ci sono vincoli di unicità. Definisci un vincolo di unicità sugli attributi first_name, last_name e
date_of_birth.
• Non sono definite restrizioni sul dominio degli attributi. Definisci delle restrizioni sul dominio dell'attributo
zip imponendo come lunghezza minima e massima della stringa 5 e aggiungendo l'espressione regolare ^[AZa-z0-9]+$ come schema per i valori ammissibili. Restringi il dominio dell'attributo position al seguente
1
Il numero che appare alla fine del nome varia.
24
Creare la stessa applicazione importando un file XLS
insieme di valori costanti: CEO, CTO, Software engineer, QA tester, Salesperson. Ricordati di
impostare il flag Match case per distinguere le lettere maiuscole e minuscole.
Con queste modifiche a questo punto dovresti ottenere lo stesso modello elaborato nel precedente capitolo. Salva le
modiche e chiudi il Designer. Una volta tornato alla Dashboard, fai click sull'icona del database per aprire la finestra
di dialogo ad esso relativa. Le modifiche cha hai apportato nel modello hanno creato problemi di allineamento
nel database a bassa priorità che possono essere facilmente risolti facendo click sul bottone Resolve all issues. Al
termine, vedrai un singola tabella employee contenente 500 oggetti.
Avvia il Cloudlet Workforce ed effettua il login. Fai click Open Employee per aprire la Livetable della classe
Employee e fai una verifica sui dati (il file Excel che abbiamo preparato contiene dati significativi). Come puoi
notare, mediante l'importazione del file Excel siamo stati in grado di ottenere un modello molto simile a quello
desiderato, sul quale successivamente abbiamo dovuto apportare delle semplici modifiche. Nel prossimo capitolo
mostreremo come manipolare i dati nell'applicazione generata.
25
Capitolo 5. Lavorare con i dati
nell'applicazione generata
Al termine del Capitolo 4, abbiamo avviato il Cloudlet Workforce con un database di 500 oggetti. In questo
capitolo, facciamo vedere come sia possibile ispezionare e manipolare i dati mediante l'applicazione generata.
5.1. Ricercare una stringa
Apri la homepage di Workforce ed effettua il login. Fai click su Application1 e apri la Livetable di Employee
facendo click su Open employees. Supponiamo di voler ricercare un particolare oggetto della classe avente una
stringa specifica come valore di uno dei suoi attributi. Potresti ispezionare la lista dei 500 oggetti e ricercare la
stringa specifica manualmente, ricordandoti la posizione delle righe trovate. Livebase ti consente di effettuare la
ricerca in modo più semplice e veloce, grazie ad un meccanismo di ricerca più sicuro chiamato quick search.
Alla base della Livetable trovi un'icona per la ricerca ( ). Scrivi nel campo di testo accanto ad essa la stringa da
cercare (Morgan). Successivamente premi Enter per far partire la ricerca. Una volta terminata la ricerca dovresti
osservare quanto segue:
• Ogni oggetto corrispondente alla ricerca è evidenziato in giallo.
• La tabella è fatta scorrere fino al primo oggetto che corrisponde alla ricerca.
• Accanto al campo di ricerca c'è un numero (ad esempio, 1/7 indica che l'oggetto in esame è il primo di altri 7
che corrispondono alla ricerca) con delle frecce per andare su ( ) e giù ( ) e visionare i risultati della ricerca.
• A destra del campo di ricerca c'è anche un'icona (
) che consente di terminare la ricerca.
Usando le frecce, ispeziona i risultati fintanto che non trovi un dipendente chiamato Lesley Morgan nato il
6-Nov-1962.
Suggerimento
Grazie al vincolo di unicità impostato sulla combinazione dei campi name, surname e
data_of_birth, sei sicuro che ci sia un unico dipendente chiamato Lesley Morgan nato
il 6-Nov-1962.
Fai doppio click sull'oggetto trovato per aprire il pannello ad esso relativo ed ispezionarne i dettagli. Al termine,
ritorna alla Livetable chiudendo il pannello facendo click su All instances e fai click sulla croce per terminare
la ricerca.
5.2. Ordinare la lista
La lista degli oggetti mostrati nella Livetable è visualizzata in nessun ordine particolare. Probabilmente, l'ordine
mostrato è semplicemente quello in cui gli oggetti sono stati creati, che magari può non essere utile. Fortunatamente
puoi imporre un ordine specifico alla lista. Ad esempio, supponiamo di voler ordinare gli oggetti in ordine crescente
rispetto al nome. Per face ciò, fai click sull'intestazione della colonna First name. La lista verrà immediatamente
ordinata rispetto al criterio impostato. Se adesso fai click sull'intestazione del campo Last name, la lista verrà
ulteriormente ordinata in ordine crescente rispetto al valore del cognome, con gli oggetti caratterizzati dallo stesso
cognome ordinati a loro volta rispetto al nome. Così ad esempio, Paula Francis verrà dopo Brian Francis, ed
entrambi saranno posizionati tra Betty Francis e Von Francis.
26
Lavorare con i dati nell'applicazione generata
5.3. Restringere la lista a un insieme
specifico di record
La ricerca e l'ordinamento sono indubbiamente due strumenti utili. Tuttavia, qualche volta può essere utile riuscire
ad estrarre dalla lista un insieme specifico di record. A tale scopo, Livebase dispone di alcune funzionalità di
filtraggio. Fai click sull'icona a forma di imbuto ( ) per aprire la finestra di dialogo per la gestione dei filtri in
cui puoi definire delle condizioni di base o delle condizioni avanzate.
Filtri di base
Proviamo a definire un filtro di base che ci consenta di mostrare solo gli oggetti in cui position = Software
engineer. Fai click su Add basic. Un nuovo filtro verrà aggiunto alla lista con tre campi in cui specificare
la condizione da applicare: nome colonna (ad esempio, First name), operatore (ad esempio, =) e valore (ad
esempio Value se vuoto). La checkbox accanto al filtro controlla l'applicabilità del filtro (se c'è il flag il filtro è
applicato). Definisci la condizione del filtro selezionando dal menu a tendina del campo nome colonna Position
(eventualmente puoi scrivere il nome della colonna su cui vuoi definire la condizione direttamente nel campo).
L'operatore è =, mentre nel campo valore scrivi Software engineer (Figura 5.1).
Suggerimento
Naturalmente puoi anche scrivere il valore manualmente.
Fai click su Ok per applicare il filtro. Riapparirà la Livetable con un numero inferiore di righe, nella fattispecie
solo quelle contenenti oggetti la cui posizione è Software engineer. Nota che tutte le altre righe non sono
state eliminate dalla tabella bensì semplicemente non sono mostrate. Infatti se ci fai caso, sulla base della Livetable
viene visualizzato 96 of 500 objects e l'icona del filtro modificata ( ) ad indicare che sulla tabella è stato applicato
un filtro.
Figura 5.1. Filtro di base
27
Lavorare con i dati nell'applicazione generata
Filtri avanzati
Se hai la necessità di impostare un controllo maggiore sui filtri, puoi definire dei filtri avanzati in cui la condizione
è basata su un'espressione booleana. Proviamo ad esempio ad estrarre tutti i dipendenti che pagano 1.500.000
dollari o più di tasse. Apri nuovamente la finestra di gestione del filtro. Disattiva il filtro definito precedentemente
semplicemente togliendo il flag nella sua checkbox. A questo punto fai click sul bottone Add advanced. Un nuovo
filtro viene aggiunto alla lista, con in questo caso un unico campo (Expression) in cui scrivere l'espressione che
definisce il filtro. Accanto al campo è presente un'icona ( ). Facendo click su questa icona appare una lista di
possibili funzioni (Figura 5.2).
Figura 5.2. Expression wizard per un filtro avanzato
Scrivi nell'apposito campo, manualmente o usando l'expression wizard, la seguente espressione: salary * 0.2
>= 1500000 (Figura 5.3). Fai click su Ok per applicare il filtro. Anche in questo caso gli oggetti della Livetable
mostrati saranno quelli che soddisfano l'espressione del filtro: in tutto 122 oggetti il cui salario è appunto superiore
o uguale a 7.500.000 dollari.
28
Lavorare con i dati nell'applicazione generata
Figura 5.3. Filtro avanzato
Filtri combinati
Precedentemente abbiamo fatto vedere come è possibile definire un filtro e applicarlo separatamente. È
possibile fare in modo che i filtri attivi sulla Livetable siano più di uno. Nel nostro caso possiamo imporre
contemporaneamente il filtro di base ed il filtro avanzato che abbiamo appena definito. Apri nuovamente la finestra
di gestione dei filtri facendo click sull'icona del filtro a forma di imbuto. Noterai che il filtro avanzato appena
definito è attivo (c'è il flag nella sua checkbox). Applica anche il filtro di base mettendo il flag nella checkbox
relativa. Se adesso fai click sul bottone Ok noterai che gli oggetti della Livetable saranno ulteriormente filtrati. In
particolare verranno mostrati solo 21 oggetti corrispondenti in questo caso a dei fortunati software engineer che
guadagnano 7,500,000 o più dollari di stipendio.
Allo stesso modo puoi impostare una catena di filtri per far sì che nella Livetable vengano mostrati solo i dati che
ti interessano. Non c'è limite al numero dei filtri che puoi definire, così come non c'è limite al numero dei filtri
che possono essere attivati contemporaneamente sulla tabella. Per il momento non abbiamo bisogno di filtrare
gli oggetti, quindi puoi eliminare tutte e due i filtri appena definiti. Apri nuovamente la finestra di gestione dei
filtri e fai click sull'icona
i 500 oggetti originari.
per eliminare il corrispondente filtro. Facendo click su Ok la Livetable mostrerà tutti
5.4. Statistiche sugli attributi
Livebase consente di visualizzare in un colpo d'occhio delle statistiche per le colonne della tabella che contengono
valori numerici. Ad esempio, fai click sull'icona a forma di grafico ( ) che trovi nell'intestazione della colonna
Salary. Si apre una finestra nella quale è mostrato un grafico ad istogramma che fornisce la distribuzione dei valori
per il salario dei dipendenti. Sulla destra del grafico sono riportati la somma, la media e la deviazione standard. In
basso invece è riportato l'intervallo dei valori di salario presenti nella tabella. Per chiudere la finestra del grafico
fai click in un punto qualunque della finestra del browser.
29
Lavorare con i dati nell'applicazione generata
5.5. Dividere gli oggetti in gruppi
A volte è utile raggruppare gli oggetti nella tabella rispetto ad un valore specifico. Per esempio, supponiamo di
voler visualizzare insieme tutti i CEO, VP, e via dicendo, presenti nella lista dei dipendenti. Per fare questo, fai
click con il tasto destro del mouse sull'intestazione della colonna Position e seleziona Group by.
Suggerimento
Alternativamente, puoi trascinare la colonna rispetto alla quale vuoi raggruppare verso la sinistra
della tabella e rilasciarla nel momento in cui la barra all'estrema sinistra diventa arancione.
La colonna Position oltre a colorarsi di arancione viene posizionata davanti alla tabella ad indicare che viene
utilizzata per raggruppare gli oggetti. La lista degli oggetti viene collassata e vengono formati 5 gruppi, uno per
ciascun valore di position. Passando il mouse ad esempio su QA tester appare una piccola finestra che indicherà
che nel gruppo ci sono 109 oggetti. Stessa cosa per gli altri gruppi. Se fai click sul + accanto a un gruppo, il
gruppo viene espanso (il + si trasforma in un -) mostrando nella tabella sulla destra gli oggetti in esso contenuti.
Per collassare il gruppo fai semplicemente click sul - (che successivamente diventa nuovamente un +).
Suggerimento
Prova ad espandere il gruppo Salesperson e seleziona due oggetti qualunque. Successivamente
collassa nuovamente il gruppo. Nota come l'icona + a lato del gruppo è diventata parzialmente
ombreggiata. Ciò serve ad indicare che nel gruppo di sono degli oggetti selezionati.
Raggruppa adesso gli oggetti per paese (Country). Fai click con il tasto destro del mouse sull'intestazione della
colonna Country e seleziona Regroup by. La colonna Position diventa la prima colonna della tabella normale e
non è più utilizzata per raggruppare gli oggetti. Infatti il suo colore non è più arancione. Invece la colonna Country
si posiziona sul lato estremo della tabella diventando arancione ad indicare che il raggruppamento è fatto rispetto
ad essa.
Osserva la colonna Salary. Per ognuno dei quattro gruppi appena creati viene mostrata l'icona a forma di grafico.
Se fai click su ognuna di essa, verrà visualizzata la finestra con il grafico e le statistiche che abbiamo spiegato
prima, relative però solo ai valori dello specifico gruppo. Inoltre, alcune statistiche possono essere visualizzate
direttamente nella colonna. Fai click con il tasto destro del mouse sull'intestazione della colonna Salary e seleziona
Statistics.... Si apre la finestra delle statistiche (Figura 5.4) in cui puoi impostare le statistiche da mostrare
per ogni gruppo direttamente nella colonna. Seleziona min, max e avg e poi fai click su Ok. Per ogni gruppo nella
colonna Salary appaiono con un font diverso le statistiche selezionate (min, max, avg). Da notare che i numeri
delle statistiche sono mostrati solo quando il gruppo è collassato. Infatti, se provi ad espandere un gruppo noterai
che i valori di salary degli oggetti non sono cambiati.
30
Lavorare con i dati nell'applicazione generata
Figura 5.4. Finestra delle statistiche
Possiamo raggruppare ulteriormente gli oggetti della tabella usando lo stesso meccanismo. Ad esempio, trascina
la colonna City sulla sinistra della tabella e rilasciala immediatamente sulla destra della colonna Country nel punto
in cui la barra diventa arancione.
Suggerimento
Alternativamente fai click con il tasto destro del mouse sull'intestazione della colonna e seleziona
Subgroup by.
Gli oggetti della tabella saranno raggruppati prima per paese (country) e poi per città (city). Le statistiche
verranno mostrate corrispondentemente: per ogni paese verrà indicato il numero di oggetti contenuti nel gruppo,
mentre per ogni città verrà indicato il numero di oggetti contenuti nel sottogruppo.
Ogni livello di gruppo può essere ordinato separatamente. Fai click una volta sull'intestazione della colonna City
per ordinare in ordine crescente. A questo punto fai click due volte sull'intestazione della colonna Country per
ordinare in ordine decrescente. Corrispondentemente gli oggetti nella tabella vengono ordinati prima in ordine
decrescente rispetto al paese e quindi in ordine crescente rispetto alla città.
A questo punto elimina il gruppo rispetto alle città. Per fare ciò basta trascinare con il mouse l'intestazione della
colonna City verso destra e lasciarla in un qualunque punto in cui la barra diventa blu.
Suggerimento
Alternativamente per sciogliere il gruppo puoi fare click con il tasto destro del mouse
sull'intestazione della colonna e selezionare Ungroup.
Aggiungere colonne i cui valori sono calcolati da altre
colonne
È possibile aggiungere alla Livetable delle colonne che non esistono nella classe ma i cui valori sono calcolati
a partire dai valori presenti nelle colonne già esistenti. Proviamo ad esempio ad aggiungere alla tabella una
colonna che mostra l'ammontare delle tasse pagate da ogni dipendente. L'informazione sulle tasse può essere
31
Lavorare con i dati nell'applicazione generata
dedotta a partire dal valore del salario (ammettendo che le tasse incidano per il 20%). Fai click sull'icona delle
colonne calcolate ( ) per aprire la finestra di definizione delle colonne calcolate (Figura 5.5). Fai click su Add
column. Digita Tax nel campo Colum name (è il nome della colonna calcolata). Nel campo Expression digita la
seguente espressione: 0.2 * salary. Fai click Ok per tornare alla Livetable. La tabella adesso contiene una
nuova colonna (l'ultima sulla destra) chiamata Tax i cui valori sono calcolati automaticamente a partire dai valori
memorizzati nella colonna Salary. Corrispondentemente, l'icona delle colonne calcolate si colora di arancione ( )
ad indicare appunto la presenza di colonne calcolate nella tabella.
Figura 5.5. Finestra di definizione delle colonne calcolate
Questa colonna calcolata può essere utilizzata come una qualunque altra colonna. Ad esempio, fai click con il
tasto destro del mouse sulla sua intestazione e seleziona Subgroup by. In questo modo hai raggruppato gli
oggetti della tabella rispetto al paese e quindi rispetto alle tasse pagate. Per invertire l'ordine di raggruppamento
(prima rispetto alle tasse e poi rispetto al paese), posiziona la colonna Tax a sinistra di Country. Ed infine rimuovi
entrambi i raggruppamenti usando uno qualunque dei modi illustrati precedentemente.
Controllare la visibilità delle colonne
È possibile fare in modo che alcune colonne della Livetable non vengano mostrate. Ad esempio, fai click con
il tasto destro del mouse sull'intestazione della colonna City e seleziona Hide. La colonna delle città non verrà
mostrata nella tabella (attenzione: non viene eliminata ma semplicemente nascosta). Allo stesso modo nascondi
anche le colonne Address e Zip. Per visualizzare nuovamente la colonna City fai click sull'icona delle colonne
nascoste ( ). Si apre una finestra in cui sono elencate le tre colonne che hai appena nascosto. Se fai click su City,
la colonna riapparirà nuovamente nella Livetable in ultima posizione ma comunque prima di ogni altra colonna
calcolata (nel nostro caso prima di Tax).
Suggerimento
Se vuoi portare questa colonna in un'altra posizione semplicemente trascinala con il mouse e
rilasciala nel punto della tabella dove vuoi che appaia.
Esportare i dati dalla Livetable
È possibile esportare in un file di backup tutti i valori mostrati nella tabella. Fai click sull'icona per l'esportazione
dei dati ( ) che trovi in fondo alla Livetable. Si pare la finestra dell'export dei dati (Figura 5.6). Al momento
l'unico formato in cui possono essere esportati i dati è CSV. Selezionando i checkbox presenti nella finestra puoi
decidere se esportare anche i dati delle colonne calcolate (Include hidden columns) e se includere nei dati anche
32
Lavorare con i dati nell'applicazione generata
gli oggetti che sono stati filtrati in seguito all'applicazione di un filtro (Include filtered-out rows sarà abilitato solo
se sono attivati sulla tabella dei filtri). Per salvare il file contenente i dati fai click su Ok.
Figura 5.6. Finestra dell'export dei dati
5.6. Riepilogo
In questo capitolo abbiamo mostrato in quanti modi sia possibile lavorare sui dati mediante l'applicazione
generata. Nel prossimo capitolo mostreremo alcune tecniche per raffinare ulteriormente l'applicazione. Nota
che, rigenerando nuovamente l'applicazione dalla Dashboard, tutte le impostazioni personalizzate definite sulla
Livetable (l'ordine delle colonne, l'ordinamento dei dati, il raggruppamento, ecc.) verranno perse. Cosa che invece
non succede facendo semplicemente il logout. Quindi, per il momento chiudi l'applicazione e fai il logout per
terminare la sessione.
33
Capitolo 6. Migliorare l'applicazione
generata
Nel Capitolo 5 abbiamo creato un'applicazione versatile e completamente funzionante. Chiaramente, possiamo
migliorarla ulteriormente. In questo capitolo mostriamo come sia possibile apportare delle migliorie
all'applicazione generata impostando dei controlli specifici su alcuni dei suoi aspetti.
6.1. Designare attributi come object title
Come spiegato nella Sezione 2.1, quando salvi il modello per la prima volta, Livebase imposta di default il primo
attributo di una classe come suo object title, nel caso in cui non ne sia stato specificato ancora uno. In generale,
è possibile impostare come object title di una classe uno qualunque dei suoi attributi. Di seguito facciamo vedere
come.
Vogliamo fare in modo che nel momento in cui viene esaminato un oggetto di Employee nel breadcrumb
appaia il nome e cognome dell'impiegato corrispondente. Al momento appare solo il nome, visto che l'attributo
first_name è l'object title della classe. L'informazione sul cognome è disponibile ma in un altro attributo.
Siccome in Livebase è possibile impostare come object title un solo attributo abbiamo a questo punto un
problema. Fortunatamente questo problema può essere risolto facilmente facendo ricorso agli attributi derivati.
Gli attributi derivati sono simili alle colonne calcolate, nel senso che non esistono nel database e sono calcolati
nello strato applicativo. L'unica differenza è che mentre le colonne calcolate sono definite autonomamente da
ciascun utente finale e sono visibili solo da lui, gli attributi derivati sono definiti nel modello e quindi sono definiti
automaticamente per tutti i membri del Cloudlet.
Arresta il Cloudlet Workforce e apri il Designer per modificare TutorialEngine. Per creare l'attributo derivato,
seleziona contemporaneamente gli attributi first_name e last_name, fai click con il tasto destro del mouse
su uno dei due e seleziona dal menu Create object title. Si apre la finestra di editor per le espressioni
matematiche in cui è mostrata l'espressione concat(first_name, " ", last_name). Grazie a questa
espressione, ad esempio il valore nel breadcrumb per il dipendente John Smith diventa appunto John Smith
con lo spazio nel posto giusto (a separare il nome dal cognome). Al termine, fai click su OK. Come mostrato
nella Figura 6.1, nella classe Employee è comparso un nuovo attributo /title: string. Il carattere / (forward slash)
davanti al nome dell'attributo indica che l'attributo in questione è derivato. Inoltre è mostrato in neretto a indicare
che sarà utilizzato come object title.
Figura 6.1. La classe Employee (cnt.)
34
Migliorare l'applicazione generata
6.2. Attributi derivati definiti mediante
espressioni matematiche
Gli attributi derivati possono essere di due tipi: attributi derivati definiti medianti espressioni matematiche (nel
resto del tutorial semplicemente chiamati attributi di tipo math) e attibuti derivati definiti mediante query (nel
resto del tutorial chiamati semplicemente attributi di tipo query). In questo capitolo ci occuperemo degli attributi
di tipo math. Gli attributi di tipo query saranno trattati in dettaglio nel Capitolo 10.
Nella Sezione 6.1 abbiamo definito un attributo di tipo math mediante un'espressione piuttosto semplice basata
sulla concatenazione di stringhe. In generale, l'espressione che definisce un attributo di tipo math può essere
piuttosto complessa e può contenere riferimenti non solo agli attributi definiti dall'utente (come già descritto nella
Sezione 6.1), ma anche a:
• platform attributes, attributi gestiti dalla piattaforma e presenti in ciascuna classe;
• system properties, come ad esempio la data e l'ora corrente;
• user properties, proprietà del membro utente che sta usando l'applicazione (come ad esempio il suo
cognome o il suo profilo).
Inoltre, è possibile definire attributi di tipo math anche usando altri attributi derivati. Nel resto di questa sezione
saranno mostrati alcuni esempi di attributi di tipo math definiti mediante funzioni matematiche e altri attributi
di tipo math.
Attributi relativi alla piattaforma
Gli attributi relativi alla piattaforma sono gestiti automaticamente da Livebase per ogni classe, e pertanto
nel database schema non vengono mostrati a meno di aggiungerli esplicitamente alle classi. Questi attributi
contengono dei metadati relativi agli oggetti della classe. Li puoi aggiungere o rimuovere da una classe, ma non
li puoi modificare. Per aggiungere un attributo relativo alla piattaforma ad una classe, fai click con il tasto destro
del mouse sull'header della classe e seleziona l'attributo scelto dal sottomenu Add platform attribute
del mClass menu. L'attributo relativo alla piattaforma apparirà tra gli attributi della classe. Per rimuoverlo, fai
click con il tasto destro del mouse sull'attributo stesso e poi selziona Remove dall'Attribute menu.
Tabella 6.1. Attributi relativi alla piattaforma Livebase
Nome
Tipo
Descrizione
__id
integer
Numero gestito internamente che
indentifica in maniera univoca
l'oggetto
__createdby
string
Membro del Cloudlet che ha creato
l'oggetto
__createdon
datetime
Data e ora in cui l'oggetto è stato
creato
__lastmodifiedby
string
Membro del Cloudlet che ha
modificato che ha modificato per
ultimo l'oggetto
__lastmodifiedon
datetime
Data e ora in cui è stata effettuata
l'ultima modifica sull'oggetto
__ownedby
string
Membro a cui appartiene questo
oggetto
35
Migliorare l'applicazione generata
Nome
Tipo
Descrizione
__ownedon
datetime
Data e ora in cui il membro è
diventato proprietario dell'oggetto
Nota
L'attributo __id viene mostrato solo nelle classi senza attributi quando salvi il modello per la
prima volta.
Importante
Al momento le applicazioni create con Livebase non consentono di modificare l'utente possessore
di un oggetto. Pertanto __ownedby e __ownedon restano sempre rispettivamente uguali a
__createdby e __createdon.
Per usare un attributo relativo alla piattaforma, devi aggiungerlo preventivamente alla classe. Per ottenere ciò,
fai click con il mouse sull'intestazione della classe e seleziona l'attributo relativo alla piattaforma dal sottomenu
Add platform attribute del Class menu. L'attributo relativo alla piattaforma apparirà quindi tra gli
attributi della classe.
Proprietà di sistema
Queste proprietà possono essere considerate come attributi che appartengono al sistema nel suo insieme. Tra esse
vi sono quelle che hanno a che vedere con la data ed l'ora:
• __System.date
• __System.datetime
• __System.day
• __System.dayOfWeek
• __System.dayOfYear
• __System.month
• __System.time
• __System.year
Proprietà utente
I seguenti attributi si riferiscono al membro utente che sta usando correntemente l'applicazione.
• __User.eMail
• __User.firstName
• __User.isAdmin
• __User.isEnabled
36
Migliorare l'applicazione generata
• __User.isOnline
• __User.lastLogin
• __User.lastName
• __User.profile
• __User.skypeName
• __User.team
• __User.username
Definire attributi di tipo math
Puoi utilizzare gli attibuti relativi alla piattaforma, le proprietà di sistema e utente descritti precedentemente
per definire attributi di tipo math. Ad esempio, supponiamo di voler rappresentare anche l'età dei dipendenti.
L'informazione sull'età non è disponibile nella classe ma può essere dedotta a partire dalla data di nascita e dalla
data corrente.
Crea l'attributo derivato age. Questa volta fai click con il tasto destro del mouse sull'intestazione della classe
Employee e seleziona New derived attribute → Math. Si apre nuovamente la finestra di editor delle
espressioni matematiche. A partire dalla data di nascita e dalla data corrente, l'età può essere calcolata come
differenza tra le due date. L'espressione matematica da utilizzare è la seguente: dateDiff(__System.date,
date_of_birth, field.year). Puoi digitare la formula direttamente nell'area di testo della finestra di
dialogo. In alternativa, puoi utilizzare vari shortcut disponibili nei menu che trovi sotto l'area di testo della finestra
di dialogo che ti consentono di costruire e validare l'espressione matematica che definisce l'attributo di tipo math.
Il menu Functions ti aiuta ad individuare la funzione più appropriata da utilizzare nella espressione matematica.
Fai click su Choose... per aprire la lista delle funzioni disponibili. Selezionando una funzione nella lista ti viene
mostrata la sua descrizione. Puoi ridurre la lista delle funzioni utilizzando il menu Show che trovi in alto nella
finestra. Per calcolare l'età di un dipendente come differenza tra la data attuale e la sua data di nascita, abbiamo
bisogno di una funzione che consenta di manipolare valori di tipo Date. Quindi, seleziona Date dal menu Show.
Apparirà la lista delle funzioni che consentono di manipolare valori di tipo Date, Time e Datetime. Tra
queste funzioni, seleziona dateDiff(date1,date2,calendarField). Come puoi vedere dalla sua descrizione, questa è
la funzione che ci serve. Fai click su Insert per inserire la funzione nell'area di testo dell'editor. La finestra che
mostra la lista delle funzioni si chiuderà e la funzione dateDiff apparirà nell'area di testo.
Avendo selezionato dalla lista la funzione da utilizzare, essa conterrà come argomenti delle variabili generiche
che devono essere sostituite con i valori che servono effettivamente per il calcolo. Sostituisci date1 con l'attibuto
date_of_birth: date. Per fare ciò, seleziona date1 facendo ad esempio doppio click su di esso, e seleziona
date_of_birth: date dal menu Attributes. Allo stesso modo, sostituisci date2 con la proprietà di sistema date:
date che restituisce la data corrente (apparirà __System.date) scelta dal menu System properties. Ed infine,
scrivi field.year al posto di calendarField. Al termine vedrai apparire la scritta Expression has been
validated as INTEGER ad indicare che l'espressione così costruita è corretta (Figura 6.2). Fai click on OK. Un
nuovo attributo di tipo integer è aggiunto alla classe. Rinominalo in age.
37
Migliorare l'applicazione generata
Figura 6.2. Editor delle espressioni matematiche
Nello stesso modo puo aggiungere due ulteriori attributi di tipo math:
• senior, un attributo di tipo boolean che vale true se l'età dell'impiegato è superiore a 60. L'espressione da
usare è: age > 60;
• new_record, un attributo di tipo boolean che vale true se il record è stato creato negli ultimi 2 minuti.
L'espressione da usare è: dateDiff(__System.datetime, __createdon, field.minute) < 2.
Importante
Per definire l'attributo new_record devi prima aggiungere alla classe l'attributo relativo alla
piattaforma __createdon. Fai click sull'header della classe Employee. Nel Class menu,
seleziona Add platform attribute e poi seleziona __createdon dalla lista degli
attributi relativi alla piattaforma. L'attributo verrà aggiunto alla classe. Successivamente, procedi
come illustrato per definire l'attributo di tipo math new_record. Troverai l'attributo relativo
alla piattaforma __createdon nel menu Attributes della finestra dell'editor delle espressioni
matematiche.
38
Migliorare l'applicazione generata
Nota
Per quanto riguarda le costanti numeriche intere e reali, sono accettati tutti i letterali che rispettano
il formato Java standard.
Passando il mouse su un attributo di tipo math, apparirà un tooltip che mostra l'espressione matematica che
definisce l'attributo stesso. Inoltre, selezionando un attributo di tipo math tutti gli attributi della classe (derivati
e non) mostrati nel modello che sono usati per definire l'attributo di tipo math, saranno circoscritti con una linea
rossa. Ad esempio, in Figura 6.3 è mostrata la classe Employee con l'attributo /age di tipo math evidenziato e
l'attributo date_of_birth (usato nell'espressione matematica che definisce l'attributo di tipo math) circoscritto
in rosso.
Figura 6.3. La classe Employee con l'attributo /age di tipo math evidenziato
6.3. Modificare il layout del form
Puoi cambiare il layout del form che appare quando un oggetto viene creato o ispezionato. Per fare ciò devi operare
nell'Application layer. Sulla sinistra, appena sotto a Database appare una sola applicazione chiamata Application1
( ). Fai click su di essa per selezionarla. Sulla destra nella finestra principale del Designer verrà mostrato il livello
applicativo con i suoi comandi.
Passa il cursore sopra una classe. Sulla base del riquadro della classe Employee ci sono varie icone ( ,
,
, , ). Usa queste icone per visualizzare i vari aspetti della classe che puoi modificare. Fai click su
per
visualizzare il form layout della classe. Si apre l'editor del form layout in cui sono mostrati gli attributi nativi della
classe ma non quelli derivati. Proviamo a dividere i vari campi che appaiono nella pagina in sezioni in modo da
non confondere l'utente con un mare di campi. Fai click su New section. Una nuova sezione viene creata con il
nome Section1. Fai click con il tasto destro del mouse in un punto qualunque della sezione e seleziona Edit
per aprire la finestra di dialogo in cui settare le proprietà della sezione. Modifica il nome della sezione in Job.
Sposta nella sezione Job, trascinandoli con il mouse, i campi salary, position e date_hired. Analogamente, crea
una nuova sezione chiamata Address contenente i campi address, city, country e zip. Ed infine, aggiungi un
separatore tra i campi last_name e date_of_birth, prendendo il widget Separator dalla sezione Widgets sulla sinistra
e posizionandolo nel punto desiderato (Figura 6.4).
39
Migliorare l'applicazione generata
Figura 6.4. Editor del form layout
I widget HTML snippet possono essere utilizzati per inserire del codice di markup HTML arbitrario nel form. Ad
esempio, potresti inserire una breve descrizione sul formato degli input ammessi. Fai click su OK per salvare le
modifiche e per chiudere l'editor.
Suggerimento
Nota come una volta definito il form layout della classe, la corrispondente icona sia evidenziata.
In questo modo è possibile capire immediatamente che il form layout della classe è stato
personalizzato.
6.4. Modificare la rappresentazione della
Livetable
Così come puoi modificare la rappresentazione del form di un singolo oggetto, puoi modificare anche il modo in
cui vengono rappresentati più oggetti nella Livetable. Fai click su per aprire l'editor del list layout. Sulla sinistra
della finestra c'è la lista delle colonne nascoste (Hidden columns), in alto a destra la lista delle colonne rispetto
alle quali gli oggetti vengono raggruppati (GroupBy columns, vuota di default) e in basso a destra una lista di
colonne dati (Data columns, quelle definite mediante gli attributi della classe). A questo livello puoi impostare
il campo rispetto al quale gli oggetti nella Livetable debbano essere ordinati (in modo crescente o decrescente)
usando il menu a tendina order by.
Effettuiamo delle modifiche. Raggruppa i dipendenti per paese. Sposta la colonna country dalla lista Data
columns alla lista GroupBy columns. Poi ordina gli oggetti in ordine crescente rispetto al cognome selezionando
last_name dal menu order by. Nota la freccia blu rivolta verso il basso che appare nella lista delle colonne dati
40
Migliorare l'applicazione generata
accanto a last_name ad indicare che l'ordinamento è decrescente. Per ordinare in modo crescente basta fare
click sulla freccia (che diventa rivolta verso l'alto). Ed infine, nascondi l'indirizzo ed il cap tascinando le colonne
address e zip nella lista Hidden columns (Figura 6.5). Fai click su OK per salvare le modifiche e chiudi l'editor.
Figura 6.5. Editor del list layout
Anche in questo caso l'icona del list layout nella classe è evidenziata ad indicare che il list layout della classe è
stato personalizzato.
6.5. Impostare valori di default per gli attributi
di classe
In genere gli oggetti creati in un'applicazione possono avere dei valori di default per uno o più attributi. Livebase
consente di impostare ciò. Supponiamo che la maggior parte dei dipendenti viva a Claybay in Venezuela. Per
sfruttare questo fatto, possiamo impostare dei valori di dafault per gli attributi city e country. Fai click con il
tasto destro del mouse su city e seleziona Set default value.... Scrivi come valore di default Claybay
e fai click su OK. Allo stesso modo imposta Venezuela come valore di default per country.
6.6. Finalizzare e verificare le modifiche
La classe risultante da tutte queste modifiche è mostrata in Figura 6.6. Salva le modifiche nel modello e chiudi
il Designer. Nota come il database non sia stato toccato dalle modifiche fatte. Questo perché le varie modifiche
sono state apportate a livello applicativo e dunque si riflettono sull'applicazione costruita sopra il modello dati
esistente piuttosto che sul modello stesso.
41
Migliorare l'applicazione generata
Figura 6.6. La classe Employee nell'Application layer
Avvia il Cloudlet Workforce. Accedi alla sua homepage facendo il login. Fai click su Application1 e
successivamente apri la Livetable della classe Employee. Fai doppio click su uno qualunque degli oggetti della
tabella per aprire il pannello adesso relativo. Come puoi vedere i vari campi sono separati in sezioni proprio come
abbiamo impostato nel form layout. Puoi cambiare pannello passando da Job a Address e viceversa a piacimento.
Ritorna alla Livetable. Fai click su Create per creare un nuovo oggetto. Apri il pannello Address. Nota che,
come abbiamo definito, nei campi City e Country ci sono già dei valori preimpostati a Claybay e Venezuela
rispettivamente. Fai click su Cancel. Chiudi l'applicazione ed effettua il logout dal Cloudlet.
6.7. Riepilogo
In questo capitolo abbiamo descritto come sia possibile migliore alcuni aspetti particolari dell'applicazione
generata legati all'esperienza d'uso. Nel prossimo capitolo spiegheremo come impostare delle condizioni a livello
di classe che consentano un controllo sulla creazione degli oggetti ammissibili mediante l'applicazione generata.
42
Capitolo 7. Imporre la qualità dei dati
mediante class warning
Livebase consente di validare i dati inseriti in un'applicazione mediante due tipi di controlli:
• vincoli sul dominio degli attributi, che sono applicabili solo sugli attributi della classe modellati dall'utente
(come ad esempio la restrizione sul dominio che hai definito per l'attributo zip nella Sezione 3.1) e non sugli
attributi derivati (di tipo math e query), e tantomeno su gli attributi relativi alla piattaforma, le proprietà di
sistema e di utente;
• class warning, cioè condizioni di controllo basate su un'espressione booleana (chiamata condition) che può fare
riferimento ad attributi di qualsiasi tipo (anche derivati) e a combinazioni di più attributi anche quelli relativi
alla piattaforma, proprietà di sistema e proprietà utente.
Ad esempio, supponiamo di volere controllare che non venga assunto un dipendente di età inferiore a 21 anni.
Nel Capitolo 6 abbiamo definito un attributo di tipo math chiamato age per ottenere l'informazione sull'età di un
dipendente. Trattandosi di un attributo derivato, l'unico modo che abbiamo per imporre un controllo sul valore di
age è creare una class warning per la classe Employee, definita mediante un'espressione booelana che controlla
se il valore di age è inferiore a 21, e in caso di violazione della condizione impedisce la creazione di un oggetto
della classe.
Arresta il Cloudlet Workforce e apri il Designer per modificare TutorialEngine. Apri l'Application layer e
seleziona Application1. Fai click con il tasto destro del mouse sull'header della classe Employee e seleziona Set
Warnings.... Alternativamente puoi fare click sull'icona
posizionata in basso nel riquadro della classe. Si
apre la finestra di gestione dei class warning. Per aggiungere una condizione fai click su Add.
Una condizione è composta da un nome (utilizzato per indentificare univocamente la condizione), un'espressione
booleana (se l'espressione viene valutata a true é sollevato un warning/errore) e un messaggio (che viene
mostrato quando la condizione è violata). Quando la condizione è violata è possibile fare il modo che l'oggetto
non venga creato affatto oppure che venga creato comunque. Nel primo caso la condizione serve ad imporre dei
vincoli restrittivi, mentre nel secondo caso la condizione è flessibile e fornisce delle avvertenze sulla creazione
dell'oggetto.
Nel nostro esempio, scrivi under21 come nome della condizione e age < 21 come espressione. Nel campo del
messaggio scrivi Age is under 21!. Siccome vogliamo impedire che un oggetto della classe Employee sia
creato se la sua età è inferiore a 21 anni, devi specificare questa condizione come restrittiva. Per fare ciò metti un
flag nella checkbox accanto alla voce Blocking (object creation denied if warnings show up) (Figura 7.1). Facendo
click OK salvi la condizione.
43
Imporre la qualità dei dati mediante class warning
Figura 7.1. Editor dei Class warning
Analogamente, aggiungi una condizione che impedisce di creare un dipendente la cui data di assunzione è nel
futuro. Il controllo sulla data di assunzione è fatto confrontando il valore dell'attributo date_hired con la
data corrente, che può essere ottenuta mediante la proprietà di sistema __System.date. Anche in questo
caso devi definire un class warning, in quanto la condizione coinvolge una proprietà di sistema. Chiama questa
class warning hiredInFuture. L'espressione che definisce la class warning è la seguente: date_hired >
__System.date. Come messaggio puoi scrivere Date hired is in the future!. Disabilita la
creazione degli oggetti che violano la condizione. Se adesso provi a salvare questa condizione si aprirà una finestra
in cui verrà mostrato un messaggio che dice che siccome l'attributo date_hired non è stato definito come
obbligatorio, l'espressione non può essere valutata a runtime. In altre parole, l'attributo date_hired potrebbe
essere vuoto e quindi la condizione potrebbbe essere ignorata. A questo punto hai due opzioni: puoi lasciare le
cose come stanno ed ignorare il messaggio oppure puoi rendere l'attributo date_hired obbligatorio. Procedi
nel secondo modo e imposta date_hired come obbligatorio.
44
Imporre la qualità dei dati mediante class warning
Aggiungi un'altra condizione che impedisce di inserire un salario sbagliato per i dipendenti. Nel dominio di
riferimento per la nostra applicazione, il salario di un dipendente deve essere appropriato rispetto all'età del
dipendente stesso. La condizione da aggiungere alla classe non rappresenta un vincolo stretto tale da impedire la
creazione dell'oggetto. Tuttavia verrà mostrato un messaggio che avvisa che si sta creando un dipendente con un
valore per il salario non appropriato. L'informazione sul salario di un dipendente è data dall'attributo della classe
salary, mentre l'età è data dall'attributo di tipo math age. Anche in questo caso dobbiamo definire una class
warning in quanto l'espressione che definisce la condizione di controllo coinvolge un attibuto di classe (salary)
e un attributo derivato (age). Assegna a questa nuova condizione il nome lowSalary. Come espressione usa ad
esempio la seguente: salary < (30000 + age * 500); mentre come messaggio puoi scrivere Salary
is too low with respect to age. Anche in questo caso nel momento in cui salvi la condizione
verrai avvisato che l'attributo salary non è stato impostato come obbligatorio. A differenza di prima ignora
il messaggio e specifica di accettare l'espressione così come è stata definita. In Figura 7.2 sono mostrate le tre
condizioni appena definite. Fai click su OK per salvarle.
Figura 7.2. Finestra di gestione delle class warning per Employee
Nell'Application layer, la classe Employee mostrerà l'icona corrispondente alle condizioni di classe evidenziata
ad indicare appunto la presenza di tali condizioni (Figura 7.3). Salva le modifiche nel modello e chiudi il Designer.
Se vuoi puoi avviare il Cloudlet Workforce e verificare l'attivazione delle condizioni definite, ovviamente dopo
aver risolto gli eventuali problemi di allineamento del database.
45
Imporre la qualità dei dati mediante class warning
Figura 7.3. La classe Employee nell'Application layer (cnt.)
7.1. Riepilogo
Con questo capitolo concludiamo la prima parte del tutorial in cui abbiamo mostrato come creare e modificare
un'applicazione con una sola classe. Nella prossima parte del tutorial mostreremo come sia possibile lavorare con
applicazioni aventi più classi tra loro correlate con delle relazioni.
46
Parte C. Lavorare con
più classi e relazioni
Capitolo 8. Lavorare con le
associazioni
Nella prima parte del tutorial abbiamo spiegato come creare delle applicazioni il cui modello è formato da una
singola classe. In generale, però, è utile utilizzare più classi per rappresentare il dominio dell'applicazione. In questo
capitolo mostriamo come sia possibile aggiungere nuove classi al modello e ripartire in più classi le informazioni
presenti in una classe già esistente in modo da rappresentare meglio una categoria di dati. Inoltre, spieghiamo più in
dettaglio come usare la Libreria per memorizzare versioni multiple degli engine al fine di riutilizzarli agevolmente
in un momento successivo.
8.1. Aggiungere una nuova classe al modello
Arresta il Cloudlet Workforce se è in esecuzione e apri il Designer per modificare TutorialEngine. Vogliamo
rappresentare l'ufficio dove lavorano i dipendenti. Per fare ciò dobbiamo aggiungere una nuova classe chiamata
Office. In particolare, per ogni ufficio vogliamo rappresentare il nome e inserire delle note per descrivere
funzioni e caratteristiche dell'ufficio. Chiaramente, il nome dell'ufficio dovrà essere usato come object title della
classe e, visto che non vogliamo che esistano due uffici con lo stesso nome, questo deve essere impostato come
univoco.
Suggerimento
Nella Sezione 2.1 abbiamo spiegato come aggiungere una classe mediante l'icona
della Palette
toolbar. Altri modi per creare una classe sono i seguenti: fai click con il tasto destro del mouse in
un punto qualunque della finestra del Designer e seleziona dal menu New class; oppure premi
la combinazione dei tasti Ctrl+N. In entrambi i casi apparirà una nuova classe nella finestra del
Designer.
Suggerimento
Per aggiungere un vincolo di unicità sull'attributo name della classe Office, anziché selezionare
l'attributo e usare il menu (come mostrato nella Sezione 2.1), usiamo un metodo alternativo. Fai
click con il tasto destro del mouse sull'header della classe Office e seleziona Set unique
constraints.... Fai click su Add. Metti il flag nel box accanto a name: string e poi fai click
su OK. Il vincolo di unicità sull'attributo apparirà nella lista. A questo punto fai click su OK per
salvare le modifiche.
Adesso nel modello ci sono due classi Employee e Office che rappresentano due insiemi separati di dati relativi
al nostro dominio. Assumiamo che ogni dipendente possa lavorare in più uffici, (potendo anche essere nessuno nel
caso di dipendenti che lavorano da casa) ma che ogni ufficio abbia almeno un dipendente che in esso vi lavora. Per
rappresentare questo fatto dobbiamo collegare le classi Employee e Office usando una relazione. In questo
caso particolare utilizziamo un'associazione bidirezionale tra le due classi.
Dalla Palette toolbar fai click su . Con il mouse fai prima click sulla classe Employee e poi su Office
per aggiungere l'associazione tra le due. In questo caso specifico siccome stiamo aggiungendo un'associazione
bidirezionale l'ordine con cui selezioniamo le due classi è irrilevante. Agli estremi della linea che rappresenta
l'associazione compare un cerchio con dentro un asterisco (*). Il cerchio rappresenta il ruolo. Per esempio,
il cerchio al lato di Office rappresenta il ruolo office_ di Employee nell'ambito dell'associazione con
Office, cioè Employee.office_ (passando il mouse sul cerchio viene visualizzato il nome del ruolo).
L'asterisco all'interno del ruolo rappresenta la cardinalità del ruolo, cioè indica quanti sono gli oggetti di una classe
48
Lavorare con le associazioni
che sono associati ad un oggetto della classe a cui si riferisce il ruolo. Ad esempio, la cardinalità di default * indica
che ogni oggetto della classe Employee può essere associato ad un numero qualunque di oggetti della classe
Office (un dipendente può lavorare in più uffici). Per quanto riguarda la cardinalità del ruolo employee di
Office, il valore di default * deve essere cambiato in quanto vogliamo imporre che in un ufficio vi lavori almeno
un dipendente. Fai click con il tasto destro del mouse sul ruolo employee_ e seleziona One or more. Nel
ruolo al posto dell'asterisco apparirà 1N, ad indicare appunto che un oggetto della classe Office è associato ad
un insieme non vuoto di oggetti della classe Employee. I ruoli possono essere rinominati (i nomi che appaiono
passandoci sopra il mouse sono generati automaticamente dalla piattaforma). Fai click con il tasto destro del mouse
sul ruolo di Employee e seleziona su Rename. Scrivi offices e premi Enter per confermare. Allo stesso
modo rinomina il ruolo di Office in employees. Alternativamente, puoi rinominare un ruolo facendo doppio
click su di esso. Una volta terminato di fare le modifiche, dovresti ottenere un modello come quello in Figura 8.1.
Figura 8.1. Associazione tra Employee e Office
8.2. Rappresentare informazioni mediante
classi distinte
Miglioriamo il modello. Data la struttura attuale della classe Employee, l'informazione in merito alla posizione
deve essere inserita manualmente per ogni dipendente. Potremmo avere 40 software engineer ma ciascuno di essi
potrebbe ricoprire una posizione particolare a seconda delle competenze (software egnineer, QS tester,
ecc.). Inoltre, non c'è nessun controllo sulle posizioni speciali: dovremmo avere un solo CEO, CTO, ecc., mentre
al momento ce ne può essere più di uno.
Il problema nasce dal fatto che in realtà l'informazione sulla posizione non è parte integrante del concetto di
dipendente, ma per come abbiamo modellato il dominio di fatto lo è. L'approccio corretto in questo caso è
introdurre nel modello due classi: Area_of_expertise per rappresentare le aree di competenza dei dipendenti
e Chief_position per rappresentare le posizioni speciali. La classe Area_of_expertise dovrebbe essere
associata alla classe Employee facendo in modo che un'area di competenza corrisponda ad un numero qualunque
di dipendenti mentre un dipendente abbia al più, ad esempio, tre aree di competenza. Analogamente, la classe
Chief_position dovrebbe essere associata alla classe Employee facendo in modo che una posizione speciale
sia associata ad un solo dipendente mentre un dipendente possa essere associato ad al più una posizione speciale.
In questo modo saremmo sicuri che nel nostro ufficio vi possano essere più dipendenti con funzione di Software
engineer ma che non si possa avere più di un dipendente nei ruoli chiave di CEO, CTO, ecc. Inoltre, si potrebbe
fare in modo che sia l'area di competenza che la posizione siano scelti da una lista di valori minimizzando così
non solo lo sforzo ma anche gli eventuali errori di digitazione legati all'input dei valori nella lista.
49
Lavorare con le associazioni
Realizziamo le modifiche. Per prima cosa elimina l'attributo position dalla classe Employee. Poi, rinomina
l'attributo title in full_name. Successivamente crea la classe Chief_position. Aggiungi l'attributo
title di tipo string e impostalo come obbligatorio e come object title. Definisci inoltre su quest'attributo un
vincolo di unicità (dopotutto non avrebbe senso avere due posizioni chiamate CEO). A questo punto nasce un
altro problema. Di fatto non c'è limite al numero delle posizioni speciali che possono essere create nel sistema.
Praticamente ogni dipendente potrebbe creare una nuova posizione appositamente per se stesso. Per evitare la
proliferazione di posizioni, dobbiamo limitare il numero di oggetti della classe Chief_position che possono
essere creati settando opportunamente la cardinalità di classe. Come avrai notato, sopra il riquadro della classe
è presente un cerchio chiamato system role (ruolo di sistema). All'interno del cerchio è indicata la cardinalità del
ruolo che di default è * (è possibile creare un numero qualunque di oggetti della classe). Cambia il system role
della classe Chief_position. Fai click con il tasto destro del mouse sul ruolo e seleziona dal menu Custom
cardinality... (indicata con C). Si apre una finestra in cui puoi impostare la cardinalità. Lascia il valore
minimo inalterato e scrivi 10 come valore massimo. Avendo settato la cardinalità di classe a 10, Livebase non
consentirà di creare più di 10 oggetti per la classe Chief_position.
Ora che abbiamo la classe Chief_position possiamo creare l'associazione con la classe Employee. In
questo caso usiamo l'icona
dalla Palette toolbar per creare un'associazione unidirezionale da Employee
a Chief_position (l'ordine è importante). Un'associazione unidirezionale differisce da un'associazione
bidirezionale per il fatto che l'associazione è visibile solo a partire da una delle due classi. Nel nostro caso,
l'associazione è visibile da Employee verso Chief_position, cioè è possibile da un dipendente risalire alla
posizione al quale è associato, ma non è possibile il contrario, cioè da una posizione risalire al dipendente al quale
è associata. Imposta come cardinalità di entrambi i ruoli nell'associazione Zero or one (01). Cambia il nome
del ruolo di Employee da chief_position_ in chief_position
Ora crea la classe Area_of_expertise e aggiungi l'attributo label di tipo string. Imposta l'attributo
obbligatorio e come object title e definisci su di esso un vincolo di unicità. Crea un'associazione bidirezionale
tra Employee e Area_of_expertise. Imposta per il ruolo area_of_expertise_ di Employee una
cardinalità specifica da 0 a 3 e succesivamente rinomina il ruolo in areas_of_expertise. Il modello
risultante da tutte queste modifiche è mostrato in Figura 8.2.
Figura 8.2. La classe Employee e le associazioni con le classi satellite
50
Lavorare con le associazioni
Così come abbiamo fatto in Sezione 6.3, è possibile modificare il layout dei ruoli delle associazioni della classe
nell'applicazione generata. Come detto in precedenza, è necessario operare nell'Application layer: seleziona
l'applicazione sulla sinistra e fai click su
per visualizzare il form layout della classe. In corrispondenza dei
campi derivati dai ruoli delle associazioni, è possibile cliccare su
possibili per quel ruolo.
per visualizzare l'elenco delle rappresentazione
Le rappresentazioni disponibili per un dato ruolo dipendono dalla sua cardinalità. In particolare, se la cardinalità
massima è uno oppure è maggiore di uno, l'insieme delle rappresentazioni disponibili cambia di conseguenza. Ad
esempio, nel caso del ruolo appena rinominato in areas_of_expertise, è disponibile la rappresentazione Set
Of Checkbox mostrata in Figura 8.3. Tale rappresentazione non è disponibile per il ruolo chief_position,
per il quale è però disponibile, fra le altre, la rappresentazione denominata Dropdown mostrata in Figura 8.4.
Figura 8.3. La rappresentazione Set Of Checkbox
51
Lavorare con le associazioni
Figura 8.4. La rappresentazione Dropdown
8.3. Rendere le modifiche definitive
Salva le modifiche nel modello e chiudi il Designer. A causa delle modifiche apportate sul modello, il database
mostra un'icona di warning ad indicare che deve essere riallineato. Se fai click sull'icona del database si apre
la finestra con la lista delle problematiche da risolvere. L'eliminazione di Employee.position ha creato un
problema di media entità in quanto l'eliminazione dell'attributo comporta l'eliminazione di tutti i dati memorizzati
nella colonna corrispondente nella tabella stessa. Lascia che Livebase risolva tutte le problematiche e riallinei il
database. Chiudi la finestra del database e avvia il Cloudlet Workforce.
8.4. Testare le modifiche
Accedi alla homepage di Workforce, effettua il login e avvia Application1. Apri la Livetable relativa a Office
facendo click su Open office. Inserisci alcuni uffici. Ricorda che, in base alle cardinalità impostate sull'associazione
52
Lavorare con le associazioni
tra Office e Employee devi associare almeno un dipendente ad ogni ufficio. Infatti, se provi a creare un
ufficio senza dipendenti viene mostrato un Data validation error dovuto alla violazione del vincolo di cardinalità.
Successivamente, apri la Livetable relativa a Chief_position facendo click su Open chief position ed
inserisci delle posizioni. Poiché l'associazione che abbiamo inserito tra Employee e Chief_position è
unidirezionale non possiamo associare un dipendente ad una posizione speciale a partire dalla Livetable relativa a
Chief_position, mentre è possibile fare il contrario, cioè associare una posizione speciale ad un dipendente
a partire dalla Livetable di Employee.
Prova ad aggiungere più di 10 posizioni speciali nella Livetable di Chief_position. Livebase non ti
consentirà di creare l'undicesimo oggetto in quanto così facendo viene violata la cardinalità di classe impostata
su Chief_position (massimo 10 oggetti). Successivamente, apri la lista dei dipendenti e prova a modificare
alcuni dei dipendenti che sono stati inseriti precedentemente. Aggiungi gli uffici in cui lavorano i dipendenti. In
questo caso, siccome l'associazione tra Employee e Office è bidirezionale, puoi associare ad un dipendente
gli uffici in cui lavora direttamente dalla Livetable di Employee. Se adesso apri la lista degli uffici facendo
nuovamente click su Open offices vedrai che quei dipendenti appaiono negli uffici giusti.
Analogamente, puoi associare una posizione speciale ad un dipendente direttamente dalla Livetable di Employee.
Aprila facendo click con il mouse su Open employee. Prova, ad esempio ad assegnare ad un dipendente una
posizione speciale. Fai click sul bottone Set accanto al campo Chief position nell'Object editing panel. Si aprirà
la Livetable di Chief position. Nota che, a causa del vincolo impostato sulla cardinalità per la classe
Chief_position (non è possibile che più dipendenti ricoprano la posizione di CEO, CTO, ecc.), nella
Livetable di Chief_position verranno mostrate solo le posizioni speciale che ancora non sono state assegnate
ai dipendenti. Se tutte le posizioni speciali sono state assegnate, la lista sarà vuota. Sempre dalla Livetable di
Employee, puoi associare ad un dipendente le sue aree di competenza. Nota che se provi ad assegnare ad un
dipendente più di 3 aree di competenza otterrai nuovamente un errore dovuto in questo caso alla violazione del
vincolo di cardinalità per la classe Area_of_expertise.
Riapri per un momento la Livetable di Chief_position ed ispeziona le posizioni speciali che hai
precedentemente assegnato ai dipendenti. Come puoi notare questi dipendenti non sono mostrati nella Livetable
di Chief_position e ciò è dovuto al fatto che l'associazione tra Employee e Chief_position, essendo
undirezionale, è visibile solo da Employee. Una volta terminato le verifiche, chiudi l'applicazione ed effettua
il logout.
8.5. Aggiornare un engine archiviato
In alcuni casi è utile salvare delle copie di un engine soprattutto se questo deve subire delle modifiche sostanziali.
In questo modo, se ci siamo sbagliati possiamo ritornare indietro e ripristinare l'engine nel Cloudlet. Livebase
consente di fare questo grazie alla Libreria dove, come spiegato in Sezione 3.3, sono archiviati gli engine.
Per aggionare TutorialEngine, trascina l'icona ad esso associata dal box del Cloudlet e rilasciala su My library. Si
aprirà una finestra in cui puoi inserire una descrizione (il campo è precompilato con quanto inserito precedemente
quando hai archiviato l'engine) e un commento. Scrivi semplicemente nel campo commento: Aggiunto le
classi Office, Chief_position e Area_of_expertise . Fai click OK. Nota come il numero
di versione di TutorialEngine viene aggiornato a 2.0.0 1. Adesso nella Libreria ci sono due versioni dello stesso
engine. Passando il mouse su di esso, apparirà un nuovo link Versions. Facendo click su questo link si apre la
finestra di dialogo che mostra la lista delle versioni archiviate per l'engine, con il flag selezionato per quella
correntemente mostrata nella Library (nel nostro caso la versione 2.0.0.). Usando i bottoni in basso nella finestra
(che si attivano selezionando nella lista una delle versioni dell'engine archiviate) puoi visualizzare il modello nella
finestra del Designer (View), eliminare dalla lista la versione selezionata (Discard) o settare come corrente la
versione selezionata (Set as current). Chiudi la finestra di dialogo per tornare alla Dashboard.
1
Un aggiornamento nella prima parte del numero della versione indica che è stata apportata una modifica nel Database layer del modello.
53
Lavorare con le associazioni
8.6. Importazione di un file XLS complesso
In questa sezione mostriamo come sia possibile ottenere lo stesso engine che abbiamo costruito prima importando
nel Cloudlet un foglio di lavoro Excel già esistente. Nel Capitolo 4 abbiamo mostrato come sia possibile creare
un'applicazione importando un Flat sheet. Qui useremo per costruire il modello un foglio di lavoro Excel di tipo
Star sheet. Il formato Star sheet, a differenza del formato Flat sheet, definisce più classi simultaneamente. Il
modello ottenuto mediante l'importazione di uno Star sheet è costituito da una classe main che rappresenta il fulcro
del modello e alcune classi satellite ad essa connesse mediante delle associazioni in modo tale che il diagramma
risultante abbia una forma appunto a stella. La creazione delle classi satellite, così come la definizione degli
attributi della classe main, sono una conseguenza del modo in cui sono rappresentati i nomi delle colonne nel
foglio di lavoro. Nella fattispecie, uno Star sheet deve essere formattato secondo le seguenti regole:
• Un foglio di lavoro per la classe main: il file deve contenere un foglio di lavoro per la classe main. Il nome della
classe è dato dal nome del foglio di lavoro.
• Una colonna per attributo della classe main. Ogni attributo della classe main è dato da una colonna di valori
nel foglio di lavoro. I nomi che compaiono nell'header delle colonne sono scritti normalmente (come per i Flat
sheet).
• Una colonna per ciascun attributo delle classi satellite. Ad ogni attributo delle classi satellite corrisponde una
colonna di valori nel foglio di lavoro. I nomi che compaiono nell'header delle colonne sono scritti nel seguente
formato speciale: Nome_Classe.nome_attributo|nome_ruolo (il nome del ruolo può essere omesso
se c'è una sola associazione con quella classe).
Inoltre, la classe main deve avere almeno un attributo. Se poi ci sono più associazioni tra la classe main ed una
stessa classe satellite, è obbligatorio utilizzare i nomi dei ruoli nell'header delle colonne degli attributi delle classi
satellite per distinguere le associazioni.
Dai un'occhiata a questo file Excelche abbiamo preparato come esempio. Questo file contiene un foglio di
lavoro chiamato Employee. Osserva il modo in cui sono scritti i nomi degli header delle colonne. Nel folgio
di lavoro viene specificato un modello avente la classe Employee come classe main, e tre classi satellite:
Office, Chief_position e Area_of_expertise. Gli attributi propri della classe Employee sono
scritti normalmente, riportando nell'header della colonna corrispondente il nome dell'attributo stesso, mentre per
gli attributi delle classi Office, Chief_position e Area_of_expertise è stato adottato un formato
diverso. La corrispondenza fra le colonne del foglio di lavoro XLS e le classi del modello ottenuto dalla sua
importazione è mostrata nella seguente tabella.
Tabella 8.1.
Colonna nel foglio XLS
Classe nel modello
Attributo di classe nel modello
first_name
Employee
first_name
last_name
Employee
last_name
date_of_birth
Employee
date_of_birth
city
Employee
city
date_hired
Employee
date_hired
salary
Employee
salary
country
Employee
country
address
Employee
address
zip
Employee
zip
Office.name|offices
Office
name
54
Lavorare con le associazioni
Colonna nel foglio XLS
Classe nel modello
Attributo di classe nel modello
Office.notes|offices
Office
notes
Chief_position.title|
chief_position
Chief_position
title
Area_of_expertise.label| Area_of_expertise
areas_of_expertise
label
Prova ad importare il file Excel nel Cloudelt. Prima di fare ciò, elimina l'engine e il database presenti in modo
da iniziare con un Cloudlet vuoto. Una volta terminata l'importazione, sarà creato nel Cloudlet un nuovo engine
e un database con 109 oggetti: 50 oggeti di tipo Employee, 9 oggetti di tipo Office, 24 oggetti di tipo
Chief_position e 26 oggetti di tipo Area_of_expertise. Se apri l'engine nel Designer, dovresti vedere
il modello mostrato in figura Figura 8.5. Come puoi vedere, Employee è la classe main, mentre Office,
Chief_position, Area_of_expertise sono le classi satellite. Gli attributi delle classi sono definiti
automaticamente sulla base della corrispondenza sopra descritta.
Figura 8.5. La classe Employee e le classi satellite
Ti sarai accorto che il modello mostrato in Figura 8.5 non è uguale al modello mostrato in Figura 8.2. Ad
esempio, le cardinalità (sia quelle di classe che quelle di ruolo) e la navigabilità delle associazioni tra le classi
sono diverse. Inoltre, tutte le personalizzazioni sul form/list layout delle classi, la specifica degli attributi richiesti,
delle restrizioni sul dominio, degli attributi di tipo math, etc., che hai definito nel modello vecchio mancano in
quello nuovo.
Oltre a ciò, la classe Employee contiene quattro attributi di tipo query: /offices_name, /
offices_notes, /chief_position_title, /areas_of_expertise_label. Come accenato nel
Capitolo 6, gli attributi di tipo query sono attributi derivati definiti sulla base di una query. Gli attributi di
tipo query saranno descritti più in dettaglio nel Capitolo 10. In questo contesto, ti è sufficiente sapere che la
query alla base dell'attributo di tipo query estrae il valore di un attributo di una classe target collegata attraverso
un cammino di relazioni. Selezionando nel modello un attributo di tipo query, verranno evidenziati con una
evidenziato il cammino delle relazioni che specifica la query, la classe e l'attributo target. Per esempio, in Figura 8.6
55
Lavorare con le associazioni
è mostrato il cammino che specifica l'attributo di tipo query offices_name che estrae il valore dell'attributo
name della classe target Office. Gli attributi di tipo query aggiunti alla classe Employee class, sono definiti
automaticamente dall'importer XLS e corrispondono alle colonne nel foglio di lavoro XLS che hanno come
header Class.attribute|rolename. Il nome di un attributo di tipo query è specificato dall'espressione
rolename_attribute. Nel nostro esempio, la corrispondenza tra le colonne nel foglio di lavoro XLS che si
riferiscono alle classi satellite e gli attributi di tipo query nella classe main è descritta nella tabella seguente.
Tabella 8.2.
Colonna nel foglio XLS
Attributo di tipo query Classe satellite
nella classe main
Attributo
satellite
Office.name|
offices
/offices_name
Office
name
Office.notes|
offices
/offices_notes
Office
notes
Chief_position.title|
/
Chief_position
offices
chief_position_title
title
Area_of_experitse.label|
/
Area_of_expertise
areas_of_expertise areas_of_expertise
label
nella
classe
Nota
Gli attributi (di tipo query e non) della classe Employee sono stati definiti in modo da specificare
una corrispondenza tra la struttura della classe Employee e la struttura dello Star sheet utilizzato
per costruire il modello.
Figura 8.6. The path of relations that specifies the /offices_name query attribute in
Employee
56
Lavorare con le associazioni
Le differenze menzionate prima tra il modello della Figura 8.2 e il modello della Figura 8.5 ottenuto mediante
l'importazione del foglio XLS, hanno a che fare con la struttura dello schema. C'è però un altra questione che
dipende dai dati memorizzati nel foglio XLS e che non consente di allineare i due modelli. Infatti, prova ad
impostare la cardinalità di classe di Chief_position ad un valore massimo pari a 10. Una volta tornato alla
Dashboard noterai un disallineamento nel database. Se ora apri la finestra di dialogo del database troverai nella
lista delle problematiche di allineamento del database una high severity issue, cioè una problematica di grave entità
che non può essere risolta automaticamente da Livebase. Nel nostro caso la problematica è data dal fatto che non è
possibile applicare il vincolo di cardinalità di classe pari a 10 sulla classe Chief_position in quanto esistono
già 24 oggetti di classe. Chiudi la finestra di dialogo del database.
8.7. Ripristino di un engine dalla Libreria
Ripristiniamo nel Cloudelt l'engine costruito prima dell'importazione del file Excel (che fortunatamente abbiamo
salvato nella Libreria). Elimina l'engine che è stato creato con l'importazione ma non eliminare il database in quanto
vogliamo mantenere i dati. Ripristina il TutorialEngine dalla Libreria, trascinandolo da Engines e rilasciandolo
su Workforce. Una volta che l'engine sarà ripristinato, noterai che il database non è allineato. Se apri la finestra
di dialogo del database troverai che come prima, una high severity issue dovuta all'impossibilità di applicare il
vincolo di cardinalità di classe pari a 10 sulla classe Chief_position. Siccome vogliamo mantenere i dati nel
database, l'unico modo per risolvere questa problematica è modificare il vincolo di cardinalità di classe. Chiudi
la finestra di dialogo del database e apri il Designer per modificare TutorialEngine. Questa volta, ad esempio,
imposta 30 come valore massimo per la cardinalità di classe per Chief_position. Salva le modifiche e chiudi
il Designer. Una volta tornato alla Dashboard, nota come sul database sia ancora presente l'icona del warning.
Questa volta però, se apri nuovamente la finestra di dialogo del database troverai solamente low severity issue che
possono essere risolti automaticamente da Livebase. Fai click sul bottone Resolve all issues e successivamente
chiudi la finestra di dialogo del database.
Avvia il Cloudlet Workforce, accedi alla sua homepage ed effettua il login e avvia Application1. Controlla che
effettivamente l'applicazione non è cambiata rispetto a quella che abbiamo costruito precedentemente (a parte il
fatto che è possibile avere fino ad un massimo di 30 posizioni speciali). A questo punto puoi terminare la sessione
e fare il logout dal Cloudlet.
57
Capitolo 9. Lavorare con le
composizioni
Nel Capitolo 8 abbiamo mostrato come creare delle relazioni tra classi aventi uguale importanza. In questo capitolo
mostreremo come creare delle composizioni, relazioni tra una classe tutto e una classe parte in cui quest'ultima
appartiene o è parte dell'altra.
9.1. Introduzione alle composizioni multiple
Nella Sezione 8.7 apportando una semplice modifica a TutorialEngine, siamo stati in grado di allineare il database
con il modello così da mantenere i dati del file Excel importato in un passo precedente. In questo capitolo,
modificheremo l'engine in un modo tale da non consentire di allineare ulteriormente il database per via della
presenza di high severity issues. Di conseguenza, non possiamo mantenere i dati che sono memorizzati nel
database. Quindi prima di andare avanti è necessario eliminare il database. I dati potranno essere inseriti nel sistema
successivamente a mano una volta che l'applicazione sarà attiva.
Figura 9.1. Composizione tra Employee e Vacation
Arresta il Cloudlet Workforce. Elimina il database trascinando la sua icona e rilasciandola sull'area del Trash.
A questo punto apri TutorialEngine per effettuare delle modifiche. Crea una nuova classe chiamata Vacation
per rappresentare i periodi di ferie dei dipendenti dell'ufficio. Per ogni periodo di ferie, vogliamo memorizzare
la data di inizio (start_date), il numero dei giorni (num_days), e un commento opzionale (notes).
Designa l'attributo start_date come object title e definisci sia start_date che num_days come richiesti.
Successivamente, crea una relazione di composizione da Employee a Vacation. In questa composizione la
classe tutto è Employee mentre la classe parte è Vacation. Fai click sull'icona della Palette toolbar. Quindi
fai click prima su Employee e poi su Vacation. Una composizione tra le due classi apparirà nel modello.
Nota che è presente un solo ruolo nella composizione dalla parte di Vacation, ciò ad indicare che la classe
parte (Vacation) è accessibile solo dalla classe tutto (Employee). Infatti, non ha senso avere i periodi di ferie
come elementi a sé stanti nel sistema. Dopotutto, chi è che fa le ferie? I dipendenti. E quindi è utile fare in modo
che i periodi di ferie siano visibili solo a partire dai dipendenti a cui fanno riferimento. Rinomina questo ruolo
in vacations. Lascia la cardinalità di default * (ogni dipendente può prendere più periodi di ferie). Salva le
modifiche. La porzione del modello risultante è rappresentata in Figura 9.1. A Chiudi il Designer. Una volta
tornato alla Dashboard, crea il database e avvia Workforce.
58
Lavorare con le composizioni
Inserire dati nell'applicazione
Accedi alla homepage di Workforce, effettua il login e avvia Application1. Fai click su Open employees per aprire
la Livetable di Employee. Aggiungi vari dipendenti. Facendo click sul bottone Create si aprirà l'Object editing
panel della classe Employee. Inserisci dei dati significativi nei campi. Come puoi vedere, è apparso un nuovo
campo Vacations. Facendo click sul bottone Add si apre l'Object editing panel per aggiungere un periodo di ferie
alla classe Vacation.
Nota
Il breadcrumb in alto nella schermata mostra come se questo oggetto facesse parte della classe
Employee.
Inserisci la data di inizio ed il numero dei giorni relativi al periodo che si sta creando (ed eventualmente una nota).
Facendo clik su Ok si ritorna all'Object editing panel della classe Employee, in cui verrà mostrato nella lista
dei periodi di ferie quello appena inserito. Per salvare le modifiche apportate al dipendente, fai click su Ok. Allo
stesso modo puoi aggiungere quanti periodi di ferie vuoi sia a dipendenti già esistenti nel sistema, sia ai nuovi
dipendenti, contestualmente alla loro creazione. Una volta che avrai terminato di inserire i dati, effettua il logout
dall'applicazione.
9.2. Introduzione alle composizioni singole
La composizione definita nella Sezione 9.1 è caratterizzata da una cardinalità multipla (*). In questa sezione
introduciamo le composizioni caratterizzate da una cardinalità singola (01 o 1) le quali, come spiegheremo, sono
mostrate diversamente nell'applicazione generata.
Arresta il Cloudlet Workforce e apri il Designer per modificare TutorialEngine. Nella classe Employee abbiamo
introdotto quattro attributi che complessivamente servono a rappresentare l'indirizzo di un dipendente. Nella realtà,
un dipendente potrebbe avere sia un indirizzo di casa che un indirizzo di lavoro (quello dell'ufficio). A prima vista
non si capisce a quale dei due si riferisce l'informazione memorizzata nel sistema. Un approccio naïve potrebbe
essere quello di replicare gli attributi dell'indirizzo e distinguere quelli che si riferiscono all'indirizzo di casa
aggiungendo il prefisso home_ al nome (ad esempio home_address), e quelli relativi all'indirizzo dell'ufficio
con il prefisso office_ (ad esempio office_address). Chiaramente questa soluzione non è in grado di
scalare, perché adesso ogni dipendente ha due indirizzi, ma che succede se in futuro nel sistema sarà possibile
rappresentare indirizzi multipli per un dipendente? La soluzione migliore è quella di utilizzare una nuova classe
chiamata Address per rappresentare un indirizzo, e aggiungere una composizione da Employee a Address
e una composizione da Office a Address per rappresentare i due tipi di indirizzo.
Quindi, aggiungi al modello una nuova classe chiamata Address. Sposta gli attributi relativi all'indirizzo
(address, city, zip and country) dalla classe Employee alla classe Address. Per fare questo, basta
trascinare con il mouse ciascuno attributo dalla prima classe sulla seconda e selezionare Move here dal menu
che appare nel momento in cui si rilascia il mouse (in alternativa puoi spostare contemporaneamente tutti e quattro
gli attributi selezionandoli tenendo premuto il tasto Ctrl e trascinandoli tutti con il mouse sulla nuova classe).
Attenzione
Lo spostamento degli attributi comporta l'eliminazione degli stessi dalla classe d'origine. Ciò
implica che, se nei campi relativi a questi attributi sono memorizzati dei dati, questi verranno persi.
Definisci come obbligatori questi attributi nella classe Address. A questo punto, crea una composizione dalla
classe Employee alla classe Address. Rinomina il ruolo in home_address e modifica la cardinalità in 1.
59
Lavorare con le composizioni
Successivamente crea un'ulteriore composizione dalla classe Office alla classe Address impostando come
cardinalità del ruolo 1. Il modello risultante è illustrato in Figura 9.2. Salva le modifiche. Al momento del
salvataggio, l'attributo address della classe Address viene designato come object title per la classe stessa.
Chiudi il Designer per ritornare alla Dashboard.
Figura 9.2. La classe Employee con le classi satellite (cnt.)
Una volta tornato alla Dashboard, vedrai che il database è disallineato. Apri la finestra di dialogo del database. Ci
sono vari problemi di disallineamento del database, alcuni dei queli sono di tipo high severity issues. Per quanto
riguarda le high severity issue (che Livebase non può risolvere automaticamente), il problema nasce dalla presenza
di due composizioni caratterizzate da una cardinalità minima pari 1 che però non è rispettata per nessun record
presente nel database. Ci sono vari modi di risolvere questo problema:
• Rilassare il vincolo: se cambiamo la cardinalità delle due composizioni in 01, allora i dati attualmente presenti
nel database non violeranno più il vincolo.
• Svuotare il database: un database senza record non viola nessun vincolo.
Attenzione
Naturalmente, svuotare il database vuol dire perdere tutti i dati.
Una volta svuotato il database, puoi inserire nuovamente i dati sia manualmente usando l'applicazione generata,
sia usando il database filler.
60
Lavorare con le composizioni
Nella Sezione 8.7 per risolvere le high severity issue abbiamo rilassato il vincolo. In questa sede adottiamo la
seconda opzione e svuotiamo il database. Cambia tab e fai click sul bottone Clear. Anche in seguito a questa
operazione ci saranno degli altri problemi di allineamento del database però di tipo low. Lascia che la piattaforma
li risolva automaticamente. A questo punto avvia Workforce.
Verificare le composizioni singole
Accedi alla homepage di Workforce. Effettua il login e apri Application1, come al solito. Fai click su Open
employees per aprire la Livetable di Employee e prova a creare un nuovo dipendente. A differenza di quanto
visto per la classe Vacation, nel caso della classe Address è come se tutti i suoi campi fossero stati inglobati
nella classe Employee e quindi i campi relativi ai suoi attributi sono aggiunti direttamente al form di Employee.
Questa è una forma di riuso. Ogni volta che c'è l'esigenza di dover duplicare gli attributi tra le classi, bisogna
verificare se non sia più utile spostare questi attributi in una classe a parte e collegarli poi con una composizione.
Fai click su Open offices per aprire la Livetable di Office e prova a creare dei nuovi oggetti ufficio nel sistema.
Osserva come anche in questo caso i campi di Address siano apparsi direttamente nel form di Office. Una
volta terminato la creazione dei nuovi uffici, chiudi l'applicazione ed effettua il logout dal Cloudlet.
9.3. Riepilogo
In questo capitolo abbiamo descritto le composizioni. Nel prossimo, parleremo degli attributi di tipo query (altro
tipo di attributo derivato).
61
Capitolo 10. Attributi derivati definiti
mediante query
Nella Sezione 6.2, abbiamo visto come si possono creare degli attributi di tipo math, definiti sulla base di
un'espressione matematica che può comprendere operatori, funzioni di vario tipo, attributi di qualsiasi altro tipo
(purché presenti nella stessa classe) in cui si vogliono definire, user e system properties. Mediante gli attributi di
tipo query è possibile creare attributi i cui valori dipendono da altri attributi presenti in classi diverse da quelle in
cui vengono definiti, sfruttando le relazioni tra le classi nel modello. Come spiegato brevemente nella Sezione 8.6,
gli attributi di tipo query sono definiti sulla base di una query che estrae il valore di un attributo di una classe
target collegata attraverso un cammino di relazioni. Nel caso la query estragga più valori per l'attributo target (per
via delle cardinalità sulle relazioni attraversate), il modellatore deve definire un operatore di aggregazione che
fornisca il valore dell'attributo derivato a partire dai valori dell'attributo target. Gli attributi di tipo query descritti
nella Sezione 8.6 sono stati definiti automaticamente dall'importer XLS. In questo capitolo ti mostreremo come
creare i tuoi attributi di tipo query.
10.1. Creare attributi di tipo query
Arresta il Cloudlet Workforce e apri il Designer per modificare TutorialEngine. Seleziona il livello Database
nel Designer. Il primo attributo di tipo query che vogliamo definire è quello fornisce il ruolo di un impiegato.
Questa informazione è disponibile nell'attributo title della classe Chief_position, ma vogliamo che appaia
nella classe Employee. Per creare l'attributo di tipo query in Employee, trascina con il mouse title da
Chief_position su Employee. Nel menu che appare una volta rilasciato il mouse, seleziona Link here.
Assegna all'attributo il nome job_title e fai click su OK. Un nuovo attributo apparirà nella classe Employee: /
job_title: string. Mentre, nell'applicazione generata per ogni dipendente apparirà accanto ai campi definiti per
la classe, un nuovo campo chiamato job_title il cui valore sarà uguale a quello dell'oggetto della classe
Chief_position a cui il dipendente è associato.
Creiamo un altro attributo per memorizzare i giorni di ferie che un dipendente ha fatto. Il numero dei giorni relativi
ad un periodo di ferie è disponibile nell'attributo num_days della classe Vacation. Trascina questo attributo
da Vacation su Employee e seleziona nuovamente Link here dal menu che appare quando rilasci il mouse.
Assegna all'attributo il nome vacation_days. Nota che in questo caso nella finestra di dialogo devi selezionare
una funzione di aggregazione. Quando si definisce un attributo di tipo query a partire da un ruolo con cardinalità
superiore a 1, si deve specificare in che modo debbano essere combinati i valori letti dagli oggetti coinvolti in
quel ruolo. Siccome vogliamo tenere traccia del numero totale dei giorni di ferie presi da un dipendente, devi
selezionare dal menu Sum in modo che il valore di vacation_days sia ottenuto sommando tutti i valori di
num_days per ogni oggetto della classe Vacation che è associato al dipendente per cui è definito l'attributo
stesso. una volta fatto click su OK nella classe Employee apparirà l'attributo /vacation_days: integer.
Allo stesso modo possiamo mostrare per ogni dipendente il paese in cui abita. Questa informazione è disponibile
nell'attributo country della calsse Address. Per creare l'attributo di tipo query in Employee, trascina
l'attributo country dalla classe Address sulla classe Employee e seleziona dal menu Link here.
In questo caso il sistema mostrerà due percorsi possibili che collegano la classe Employee alla classe
Address. Il primo percorso è attraverso home_address.country e sfrutta la composizione tra Employee
e Address. Il secondo percorso invece è attraverso offices.address.country e sfrutta il cammino
composto dall'associazione tra Employee e Office e la composizione tra Office e Address. Passando
il mouse su un percorso tutte le classi coinvolte nel percorso verranno evidenziate in rosso. Ciò è molto utile
soprattutto in presenza di percorsi multipli anche complessi. Per definire l'attributo seleziona il percorso attraverso
home_country.address, assegna il nome home_address e fai click su OK.
Possiamo creare un ulteriore attributo per mostrare il paese in cui un dipendente lavora. Siccome un dipendente può
lavorare in più uffici dislocati in paesi diversi, in realtà avremmo a che fare con un insieme di valori per il paese.
62
Attributi derivati definiti mediante query
Allora possiamo pensare di creare un'unica stringa concatenando le stringhe dei vari paesi in cui il dipendente
lavora, separate mediante uno spazio bianco. Trascina l'attributo country dalla classe Address sulla classe
Employee, seleziona dal menu Link here e scegli il percorso via office.address.country. Assegna
a questo attributo il nome work_countries e seleziona Concatenation come funzione di aggregazione.
Infine, creiamo un attributo nella classe Office che mostri il numero di persone che lavorano in un ufficio. Si
tratta di contare il numero degli oggetti della classe Employee che sono associati ad ciascuno oggetto della classe
Office. Per indentificare in maniera univoca gli oggetti di Employee possiamo usare l'attributo relativo alla
piattaforma __id, che deve essere aggiunto alla lista degli attributi della classe. A tale scopo, fai click con il
tasto destro del mouse sull'header della classe Employee e seleziona Add platform attribute+__id.
Successivamente, definisci l'attributo di tipo query nella classe Office. Questa volta usiamo un metodo
alternativo. Fai click con il tasto destro del mouse sull'header della classe Office e seleziona New derived
attribute+Query. Si aprirà la finestra del query expression editor in cui puoi specificare l'espressione per il
calcolo della query, passo dopo passo. Facendo click su employees verranno mostrati tutti gli attributi della classe
Employee. Seleziona __id. Come funzione di aggregazione puoi scegliere indifferentemente sia Count distinct
che Count all. Visto che tutti gli __id sono unici entrambe le funzioni producono lo stesso risultato. Fai click su
OK. Assegna all'attributo il nome headcount. Salva le modifiche nel modello e chiudi il Designer. Il modello
risultante è mostrato in Figura 10.1.
Figura 10.1. La classe Employee con le classi satellite e gli attributi di tipo query
Tornato alla Dashboard, noterai che non ci sono problemi di allineamento del database da risolvere. Questo perché
gli attributi di tipo query sono calcolati nell'applicazione generata. Avvia nuovamente il Cloudlet Workforce.
63
Attributi derivati definiti mediante query
10.2. Riepilogo
Ciò che hai imparato su Livebase finora ti è sufficiente per verificare come vengono mostrati gli attributi di tipo
query nell'applicazione generata. Questo capitolo conclude la seconda parte del tutorial. Nei prossimi capitoli
mostreremo alcune tecniche di modellazione avanzate, a partire dalla possibilità di utilizzare diagrammi multipli
per rappresentare lo schema dei dati.
64
Parte D. Tecniche di
modellazione avanzate
Capitolo 11. Scomporre un modello
esteso in diagrammi multipli
Il modello su cui abbiamo lavorato finora è piuttosto semplice e composto da poche classi. A questo punto
proviamo ad espanderlo in modo da memorizzare più informazioni. Ad esempio, consideriamo i seguenti requisiti.
Vogliamo tener traccia dei visitatori e delle visite presso il nostro ufficio. Inoltre, vogliamo memorizzare nel
sistema anche le informazioni dei dispositivi presenti nell'ufficio (computer e stampanti) e dei loro produttori.
Vogliamo anche tener traccia delle richieste di supporto rappresentando lo stato in cui possono trovarsi, i clienti che
hanno inoltrato la richiesta, ed il prodotto a cui la richiesta si riferisce. Ed infine, vogliamo memorizzare i dettagli
dei prodotti e le loro parti presenti nei magazzini. Per soddisfare questi nuovi requisiti è necessario estendere il
modello con delle nuove classi. In questo capitolo mostreremo come sia possibile disegnare un modello piuttosto
complesso e suddividerlo in più diagrammi al fine di facilitarne la visualizzazione e comprensione.
11.1. Espandere il modello con classi
aggiuntive
Per iniziare, modifichiamo il modello in modo da memorizzare i visitatori e le visite fatte al nostro ufficio.
Per ogni visitatore dobbiamo memorizzare le informazioni personali (nome, cognome, e data di nascita). Invece
di replicare in una nuova classe gli attributi che memorizzano i dati personali che abbiamo già nella classe
Employee (first_name, last_name, date_of_birth), li riusiamo. A tale scopo, crea una nuova
classe chiamata Personal_data. Successivamente, come hai fatto nella Sezione 9.2 sposta gli attributi
first_name, last_name, date_of_birth da Employee a Personal_data. Lo spostamento di questi
attributi comporta la loro eliminazione dalla classe Employee. Di conseguenza, anche i class warning, i filtri, i
vincoli e gli attributi derivati definiti a partire da questi attributi in Employee, saranno comunque eliminati in
cascata. Una finestra di dialogo si aprirà avvisandoti di ciò (Figura 11.1).
Figura 11.1. Avviso di eliminazione di elementi
Puoi aggiungere nuovamente gli attributi derivati (nel nostro caso abbiamo definito soltanto full_name nella
classe Personal_data). Ed infine, crea una composizione da Employee a Personal_data con cardinalità
1 (Figura 11.2).
66
Scomporre un modello esteso in diagrammi multipli
Figura 11.2. Composizione tra la classe Employee e la classe Personal_data
A questo punto per rappresentare i visitatori, crea una classe chiamata Visitor. Per ogni visitatore vogliamo
memorizzare il tipo di documento d'identità presentato ed il numero del documento stesso. Aggiungi alla classe
Visitor due attributi di tipo string identification_type e identification_details. Marcali
entrambi come richiesti. L'attributo identification_type può assumere uno dei seguenti tre valori possibili:
Passport, Driving license, ID card. Per tenere traccia delle informazioni personali di un visitatore
aggiungi una composizione dalla classe Visitor alla classe Personal_data, come hai fatto precedentemente
tra Employee e Personal_data (Figura 11.3).
Figura 11.3. Composizione tra la classe Visitor e la classe Personal_data
Il nostro modello è ancora incompleto. Modifichiamolo per tenere conto dei seguenti requisiti. Innanzitutto, per
ogni visita vogliamo che sia memorizzato il giorno e l'istante di tempo (inizio e fine) in cui la visita è stata
organizzata, ed il motivo per cui è stata organizzata. Una visita viene effettuata presso un ufficio, mentre un ufficio
può essere oggetto di varie visite. Inoltre, ciascun visitatore può effettuare un numero qualunque di visite, mentre
ogni visita riguarda un solo visitatore. Infine, una visita è organizzata da un dipendente che rappresenta il contatto
di riferimento ed un dipendente può organizzare varie visite; ad una visita deve partecipare almeno un dipendente
per ricevere il visitatore, mentre un dipendente può partecipare ad un numero qualsiasi di visite.
Per modellare questi nuovi requisiti, crea una classe Visit e aggiungi gli attributi: date di tipo date,
start e end di tipo time (marcali tutti e tre come richiesti) e purpose di tipo text. A questo punto, crea
un'associazione bidireazionale tra Visit e Office; imposta la cardinalità del ruolo di Visit a 1; rinomina il
ruolo di Office in visits lasciando la sua cardinalità impostata al valore di default * (una visita viene effettuata
presso un ufficio, mentre un ufficio può essere oggetto di varie visite). Successivamente, crea un'altra associazione
bidirezionale tra Visit e Visitor; rinomia il ruolo di Visitor in visits e imposta la sua cardinalità a 1;
lascia invece la cardinalità del ruolo di Visitor impostata al valore di default * (ciascun visitatore può effettuare
un numero qualunque di visite, mentre ogni visita riguarda un solo visitatore).
67
Scomporre un modello esteso in diagrammi multipli
Ora dobbiamo mettere in relazione Visitor e Employee. I requisiti sopra menzionati indicano un doppio
ruolo per un dipendente rispetto ad una visita (partecipante e organizzatore). Per modellare questo fatto, dobbiamo
creare due associazioni bidirezionali tra le due classi. Nella prima associazione tra Employee e Visit,
rinomina il ruolo di Employee in visits_organized_by e lascia come valore per la sua cardinalità quello
di default *; rinomina il ruolo di Visit in responsible_employee ed imposta ad 1 la sua cardinalità
(una visita è organizzata da un dipendente che rappresenta il contatto di riferimento ed un dipendente può
organizzare varie visite). Nella seconda associazione tra Employee e Visit, rinomina il ruolo di Employee
in visits_participated_in e lascia come valore per la sua cardinalità quello di default *; rinomina il
ruolo di Visit in participants ed imposta a 1N la sua cardinalità (ad una visita deve partecipare almeno un
dipendente per ricevere il visitatore, mentre un dipendente può partecipare ad un numero qualsiasi di visite). La
porzione del diagramma risultante da tutte queste modifiche è mostrata in Figura 11.4.
Figura 11.4. La classe Visit con le classi satellite
11.2. Aggiungere nuovi diagrammi
Come abbiamo detto precedemente, vogliamo memorizzare nel sistema anche le informazioni dei dispositivi
presenti nell'ufficio (computer e stampanti) e dei loro produttori. A tale scopo, aggiungi al modello tre ulteriori
classi: Computer, Printer e Manufacturer, connesse tra loro mediante delle associazioni come spiegato
qui di seguito.
Nella classe Manufacturer aggiungi tre attributi per rappresentare il nome del produttore (name), il
nome e l'indirizzo email della persona incaricata di fornire il supporto (support_contact_name e
support_contact_email). Marca tutti e tre gli attributi come richiesti, designa il nome del produttore come
object title, ed imponi su di esso un vincolo di unicità. Per quanto riguarda l'attributo email, per come è stato
definito possiamo inserire un qualunque valore. Ma sappiamo che gli indirizzi email devono rispettare un formato
specifico. Per controllare i valori inseriti nel campo email, restringi il dominio dell'attributo usando la seguente
espressione regolare: [^@]+@[^@]+\.[^@]+1.
1
È consigliato che gli indirizzi email siano validati in modo lasco. Esempi di espressioni per validare in modo stringente indirizzi email sono
disponibili qui.
68
Scomporre un modello esteso in diagrammi multipli
Per quanto riguarda computer e stampanti, imponiamo delle ulteriori specifiche. Ogni dispositivo hardware è
caratterizzato da un indirizzo IP. Invece di aggiungere un attributo apposito per memorizzare questa informazione
nelle classi Computer e Printer, crea una nuova classe chiamata Hardware_address avente un solo
attributo IP_address di tipo string per rappresentare un indirizzo IP. Definisci questo attributo come object
title della classe, marcalo come richiesto ed imponi un vincolo di unicità su di esso. Infine, restringi il dominio dei
valori ammissibili usando la seguente espressione regolare: ^([0-9]{1,3}\.){3}[0-9]{1,3}$2.
A questo punto, crea la classe Printer. Aggiungi un attributo per rappresentare il suo nome (name), definiscilo
come object title, marcalo come richiesto e imponi su di esso un vincolo di unicità. Aggiungi un'associazione
bidirezionale tra Printer e Manufacturer (ogni stampante è prodotta da un solo produttore e un produttore
produce più stampanti), e un'associazione bidirezionale tra Printer e Office (in un ufficio ci possono essere
varie stampanti, e una stampante è posizionata in un solo ufficio).
Crea la classe Computer. Poi aggiungi due associazioni bidirezionali tra Computer e Manufacturer e
tra Computer e Office, impostando le cardinalità dei ruoli con gli stessi valori usati nelle corrispondenti
associazioni con Printer. Successivamente, aggiungi un'altra associazione bidirezionale tra Computer e
Employee impostando opportunamente le cardinalità dei ruoli (un computer è usato al più da un dipendente, e
un dipendente può usare più computer). A questo punto, ritornando alla classe Hardware_address, crea una
composizione da Computer a Hardware_address (ogni computer ha un indirizzo IP) e una composizione
da Printer a Hardware_address (ogni stampante ha un indirizzo IP). La porzione del modello ottenuto in
seguito alle modifiche descritte prima è mostrata in Figura 11.5.
2
Come prima, questa semplice espressione regolare ammette valida alcuni indirizzi IP in realtà non validi. Puoi trovare esempi di pattern
specifici per vari tipi di dati sono disponibili su questo sito Regular-Expressions.info’s examples page.
69
Scomporre un modello esteso in diagrammi multipli
Figura 11.5. Le classi per i dispositivi d'ufficio e Manufacturer
Tutte le classi che abbiamo aggiunto ci consentono di memorizzare le informazioni sui dispositivi hardware del
nostro ufficio. Tuttavia, come avrai notato è difficile visualizzare il modello in maniera chiara e ordinata. In
Livebase è possibile far fronte a questa esigenza utilizzando diagrammi multipli. In alto nella finestra di lavoro
trovi 3 tab: Diagram1, e . Il tab selezionato correntemente è Diagram1: è il diagramma che mostra il modello
che abbiamo costruito finora. Puoi suddividere il modello in vari diagrammi, visualizzando in ciascun diagramma
solo le classi rilevanti per quel diagramma. Ogni diagramma è mostrato in un tab separato.
Fai click con il mouse sul secondo tab
per creare un nuovo diagramma. Assegna il nome Resources e fai
click su OK. Alla finestra di lavoro verrà aggiunto un nuovo tab vuoto chiamato Resources, e sarà correntemente
mostrato nella finestra di lavoro. Se passi nuovamente al tab Diagram1, troverai tutte le tue classi e relazioni ancora
lì. Nel diagramma Resources vogliamo che siano mostrate le classi che rappresentano le risorse del nostro ufficio.
È possibile aggiungere al diagramma le classi in vari modi, come spiegato qui di seguito. Sulla parte sinistra della
finestra del Designer, seleziona il tab Classes. Ti verrà mostrata la lista delle classi presenti nel modello. Per
rendere visibile nel diagramma a Resources la classe Office, trascinala con il mouse dalla lista delle classi nel
diagramma. Nota che viene mostrata solo la classe e non le relazioni in cui essa è coinvolta. Piuttosto apparirà
attaccata alla classe una linea con un punto nero alla fine. Questo è un indicatore che la classe ha delle relazioni
che non sono mostrate nel diagramma. Se fai click con il tasto destro del mouse sul punto nero apparirà un menu
con la lista delle relazioni (per ogni relazione è mostrato il nome del ruolo e il nome della classe). Seleziona da
questo menu la voce printer_ --> Printer. Una versione trasparente della classe Printer apparirà sotto
il cursore del mouse. Posiziona il cursore nel punto del diagramma dove vuoi posizionare la classe e fai click
con il mouse. La classe Printer e l'associazione con Office verranno mostrate nel diagramma. Se adesso
70
Scomporre un modello esteso in diagrammi multipli
ritorni al diagramma Diagram1 vedrai che le classi e l'associazione sono ancora visibili in esso. Ciò vuol dire
che tutti i diagrammi in un modello fanno riferimento agli stessi dati. Essi fornisco semplicemente delle viste
del modello facilitandone la gestione. Come hai fatto precedentemente per visualizzare l'associazione printer
--> Printer, fai la stessa cosa per le associazioni computer_ --> Computer e employees -->
Employee. Una volta che verranno mostrate nel diagramma entrambe le classi Computer e Employee, anche
le associazioni tra esse verranno mostrate automaticamente.
Suggerimento
Puoi nascondere nel diagramma classi e relazioni facendo click con il tasto destro del mouse
e selezionando Hide dal menu. In alternativa, puoi nascondere le classi semplicemente
selezionandole e premendo il tasto Delete (purché vi sia almeno un diagramma in cui le classi
compaiono).
Per rendere la classe Manufacturer visibile, puoi selezionarla sia dalle relazioni con Printer o
con Computer, oppure trascinandola nel diagramma dalla lista Classes. Fai la stessa cosa per la classe
Hardware_address. Osserva per un momento il diagramma Resources (Figura 11.6). In esso sono mostrate
esattamente le classi che sono rilevanti per la gestione delle risorse hardware del nostro ufficio e nulla più. In questo
modo dunque siamo stati in grado di restringere la vista solo sulle parti del modello a cui siamo effettivamente
interessati.
Figura 11.6. Il diagramma Resources
Estendiamo ulteriormente il modello in modo da memorizzare anche le richieste di supporto. Dobbiamo introdurre
delle nuove classi per rappresentare i clienti, le richieste di supporto (ed ogni stato in cui possono trovarsi), ed
71
Scomporre un modello esteso in diagrammi multipli
i prodotti. Crea un altro diagramma chiamato Support per tutte queste classi. In questo diagramma, crea la
classe Customer per rappresentare i clienti. Invece di aggiungere degli attributi alla classe per memorizzare
le informazioni personali dei clienti, riusiamo la classe Personal_data. Mostra nel diagramma la classe
Personal_data facendo click con il tasto destro del mouse nel punto desiderato e selezionando dal menu Show
hidden class → Personal_data, e aggiungi una composizione da Customer a Personal_data
(imposta la cardinalità a 1). Le informazioni personali sono l'unica cosa che ci interessa sapere dei clienti.
Successivamente, aggiungi una nuova classa chiamata Support_request che servirà per rappresentare le
richieste di supporto pervenute al nostro ufficio. Non c'è bisogno di aggiungere alcun attributo a questa classe.
Piuttosto crea una composizione da Customer a Support_request (questa volta impostando la cardinalità
a * in quanto vogliamo che per ogni clienti siano memorizzate tutte le sue richieste di supporto), e un'associazione
bidirezionale tra Support_request e Employee (una richiesta di supporto sarà presa in carico da al più
un dipendente e un dipendente potrà gestire più richieste di supporto). Ovviamente per aggiungere quest'ultima
associazione devi rendere visibile la classe Employee nel diagramma.
Per memorizzare lo stato della richiesta di supporto, crea una classe Support_request_status con un
attributo chiamato label di tipo string (marcalo come richiesto e designalo come object title). Aggiungi
un'associazione bidirezionale tra Support_request e Support_request_status (una richiesta di
supporto è in un solo stato ma uno specifico stato può corrispondere a più richieste di supporto). Ed infine
crea un'ulteriore classe chiamata Product per rappresentare i prodotti. Aggiungi un attributo di tipo string
chiamato name, marcalo come richiesto e designalo come object title. Definiamo tra le classi delle associazioni per
modellare i seguenti requisiti: un prodotto può essere coinvolto in un numero qualunque di richieste di supporto; un
prodotto sarà lavorato da al più un dipendente; un prodotto può essere coinvolto in un numero qualunque di visite.
A tale scopo, crea un'associazione bidirezionale tra Product e Support_request, una seconda associazione
bidirezionale tra Product e Employee, ed un'ultima associazione tra Product e Visit. Nota che per creare
l'ultima associazione devi rendere visibile nel diagramma la classe Visit. Setta opportunamente le cardinalità
dei ruoli in modo da soddisfare i requisiti descritti in precedenza. Il diagramma risultante è mostrato in Figura 11.7.
72
Scomporre un modello esteso in diagrammi multipli
Figura 11.7. Il diagramma Support
Introduzione alle composizioni ricorsive
La nostra applicazione sarà utilizzata anche per gestire l'inventario, cioè per memorizzare i dettagli dei prodotti e
le loro parti presenti nei magazzini. Al modello abbiamo già aggiunto la classe Product. Ci mancano le classi
per rappresentare le parti di un prodotto, le sottoparti e i magazzini. Inoltre, abbiamo bisogno di una classe per
rappresentare il fatto che un prodotto è disponibile in una certa quantità presso uno specifico magazzino.
Crea un nuovo diagramma chiamato Products. Crea nel diagramma una nuova classe Product_part con un
solo attributo di tipo string chiamato name (marcalo come richiesto e designalo come object title). Aggiungi
una relazione bidirezioanle tra Product (rendila visibile nel diagramma) e Product_part (una prodotto è
composto da varie parti, mentre una parte fa riferimento ad un unico prodotto). Successivamente, crea una classe
Subpart e copia in essa l'attributo name di tipo string della classe Product_part. Per fare ciò trascina
l'attributo name dalla classe Product_part sulla classe Subpart e seleziona Copy here. Designa questo
attributo come object title di Subpart. Aggiungi un'associazione bidirezionale tra Subpart e Manufacturer
(un produttore produce vari sottoparti e una sottoparte è prodotto da un solo produttore). Ovviamente devi rendere
visibile la classe Manufacturer nel diagramma. In generale, i prodotti sono composti da parti costituite da
sottoparti che a loro volta hanno delle sottoparti, e così via. Il modo migliore per modellare ciò è creare una
composizione da Product_part a Subpart (con cardinalità * ad indicare che una parte è costituita da varie
sottoparti), e poi un'altra composizione da Subpart verso sè stessa (sempre con cardinalità * ad indicare che una
sottoparte è costituita da varie sottoparti). Questa ultima composizione è una composizione ricorsiva.
Crea una nuova classe chiamata Warehouse per rappresentare un magazzino, e definisci una composizione
da Warehouse a Address (ogni magazzino ha un solo indirizzo). Prima di fare ciò, ovviamente, rendi
visibile la classe Address nel diagramma. Per rappresentare il fatto che una parte sia disponibile in una certa
73
Scomporre un modello esteso in diagrammi multipli
quantità, crea un'ulteriore classe chiamata Part_availability caratterizzata da un unico attributo di tipo
integer chiamato quantity (marcalo come richiesto). Quindi, crea una composizione da Product_part a
Part_availability (impostando la cardinalità a *). Successivamente, per rappresentare il fatto che le parti di
un prodotto sono presenti in un vari magazzini definisci un'associazione bidirezionale tra Part_availability
e Warehouse. A questo punto abbiamo tutte le classi necessarie per gestire l'inventario. Il diagramma risultante
è mostrato in Figura 11.8.
Figura 11.8. Il diagramma Products
11.3. Ripulire il diagramma iniziale
I tre diagrammi che abbiamo creato prima sono ragionevolmente compatti. Tuttavia, il diagramma Diagram1 è
rimasto piuttosto disordinato. Bisogna spostare tutto ciò che ha a che fare con le visite in un diagramma a parte. A
tale scopo, crea un diagramma chiamato Visits. Visualizza nel diagramma le seguenti classi: Visit, Visitor,
Employee, Address, Personal_data, Office, Product. Successivamente, nascondi le seguenti
classi in Diagram1: Visit, Visitor, Computer, Printer, Manufacturer, Hardware_address. Il
diagramma Visits ottenuto è mostrato in Figura 11.9.
74
Scomporre un modello esteso in diagrammi multipli
Figura 11.9. Il diagramma Visits
Ed infine, rinomina Diagram1 in Employees facendo click con il tasto destro del mouse e selezionando Rename.
Il diagramma è riportato in Figura 11.10
75
Scomporre un modello esteso in diagrammi multipli
Figura 11.10. Il diagramma Employees
11.4. Riepilogo
In questo capitolo abbiamo mostrato come sia possibile organizzare il modello utilizzando diagrammi multipli.
Nel prossimo capitolo mostreremo come sia possibile personalizzare le applicazioni per diversi gruppi di membri.
76
Capitolo 12. Personalizzazione delle
applicazioni per specifici gruppi di
membri
L'applicazione che abbiamo creato può essere usata da tutti i membri del Cloudlet. Chiunque effettua l'accesso
al Cloudlet vedrà la lista completa dei dipendenti, dei periodi di ferie, le richieste di supporto, i prodotti, ecc. Ai
fini di una separazione delle responsabilità, possiamo partizionare i dati in modo tale che i membri del Cloudlet
accedano solo a quella parte dei dati che è rilevante per loro. Livebase consente di partizionare i dati in tre modi.
In questo capitolo spiegheremo tutti e tre questi modi.
12.1. Partizionamento verticale: abilitare e
disabilitare classi
Con il termine partizionamento verticale s'intende una restrizione dell'accesso per certi utenti a parti di un modello
ottenuta disabilitando classi, attributi e/o ruoli che non sono rilevanti in una specifica applicazione. Gli elementi
del modello vengono disabilitati nell'Application layer usando l'icona
della Palette (selezionata di default una
volta aperto l'Application layer). Facendo click con il mouse sull'elemento del modello da disabilitare, questo
viene colorato in grigio. A seconda di come è costruito il modello, può succedere che la disabilitazione di un
elemento comporti a casacata la disabilitazione di altri elementi nel diagramma. Gli elementi abilitati sono quelli
che rimangono colorati di giallo. Chiaramente, avendo noi diviso il modello in più diagrammi, ciò che viene
disabilitato in un diagramma lo sarà anche negli altri.
Ad esempio, definiamo un'applicazione che riguarda il supporto tecnico. Mediante questa applicazione sarà
possibile accedere a quella porzione di dati che riguarda le richieste di supporto. Arresta il Cloudlet Workforce
se è avviato e apri il suo engine per modificarlo. Apri l'Application layer e seleziona Application1. Rinominala in
Support_manager facendo doppio click su di essa.
Nota
Avrai notato che il ruolo Chief_position.employee è già disabilitato. Ciò è dovuto al fatto
che l'associazione tra la classe Employee e la classe Chief_position è unidirezionale (da
Employee a Chief_position). Infatti, nell'applicazione generata non sarà possibile visionare
i dependenti associati con una posizione speciale. Viceversa, a meno di disabilitare anche il ruolo
Employee.chief_position, sarà possibile visionare la posizione speciale ricoperta da un
dipendente.
La gestione del supporto tecnico comporta l'accesso alle informazioni relative al cliente che fa la richiesta di
supporto, la richiesta di supporto ed il suo stato, i dati del prodotto (ma non le parti, sottoparti, produttore,
disponibilità nei magazzini), i dipendenti coinvolti nelle visite per il prodotto (escluse le informazioni non rilevanti
tipo la data di assunzione, il salario, ecc.) e gli uffici in cui lavorano. Dunque, dobbiamo disabilitare quegli elementi
che non sono rilevanti per l'applicazione in tutti i diagrammi che compongono il nostro modello. A tale scopo, nel
diagramma Employees disabilita la classe Employee. Per disabilitare la classe devi fare click con il mouse (sul
quale compare l'icona ) sul ruolo di sistema della classe stessa. In questo caso, il ruolo di sistema della classe
Employee sarà colorato di grigio. Come ti sarai accorto, anche altri elementi nel diagramma sono diventati grigi.
In particolare, la disabilitazione della classe Employee ha comportato la disabilitazione dei seguenti elementi
nel diagramma.
77
Personalizzazione delle applicazioni per specifici gruppi di membri
• La classe Vacation: siccome la classe Vacation è accessibile soltanto a partire da Employee, questa
viene colorata completamente di grigio; di conseguenza in nessun modo sarà possibile visualizzare i periodi di
ferie degli impiegati nell'applicazione generata.
• Il ruolo Employee.personal_data_: visto che la classe Personal_data è in relazione con altre classi
nel modello che al momento non sono state disabilitate, rimane colorata in giallo; la disabilitazione del ruolo
implica che i dati personali di un dipendente non saranno vibili nell'applicazione generata.
• Il ruolo Employee.areas_of_expertise: l'associazione tra Employee e Area_of_expertise
diventa unidirezionale; ciò vuol dire che non sarà possibile visualizzare le aree di competenza di un dipendente
nell'applicazione generata.
• Il ruolo Employee.chief_position: l'associazione tra Employee e Chief_position è disabilitata
completamente; quindi non sarà più possibile visionare nell'applicazione generata la posizione ricoperta da un
dipedente.
• Il ruolo Employee.offices: l'associazione tra Employee e Office diventa unidirezionale; ciò implica
che nell'applicazione generata non sarà possibile visualizzare gli uffici in cui un dipendente lavora.
• Il ruolo Employee.address: visto che la classe Address è in relazione con altre classi nel modello che al
momento non sono state disabilitate, rimane colorata in giallo; la disabilitazione del ruolo implica che l'indirizzo
di un dipendente non sarà visibile nell'applicazione generata.
Allo stesso modo, disabilita le classi Area_of_expertise, Chief_position, Office. Anche in questo
caso, la disabilitazione delle classi comporterà la disabilitazione di altri elementi nel diagramma. Sempre nella
classe Employee disabilita i seguenti attributi:
• date_hired
• salary
• vacation_days
• home_country
• new_record
Per disabilitare un attributo in una classe basta semplicemente fare click con il mouse su di esso. Quando un
attributo in una classe viene disabilitato, i campi ad esso relativi non verranno mostrati nell'applicazione generata.
Il diagramma Employee modificato è visualizzato in Figura 12.1.
78
Personalizzazione delle applicazioni per specifici gruppi di membri
Figura 12.1. Support_manager: diagramma Employees
Analogamente, nel diagramma Resources disabilita le classi Printer, Computer e Manufacturer
(Figura 12.2).
79
Personalizzazione delle applicazioni per specifici gruppi di membri
Figura 12.2. Support_manager: diagramma Resources
Ed infine nel diagramma Products, disabilita le classi Product_part e Warehouse (Figura 12.3).
80
Personalizzazione delle applicazioni per specifici gruppi di membri
Figura 12.3. Support_manager: diagramma Products
Ora, creiamo un'altra applicazione chiamata Inventory_manager mediante la quale vogliamo gestire i
magazzini e i prodotti presenti in essi. Per creare una nuova applicazione fai click con il tasto destro del mouse
sul Database layer e seleziona New application dal Database menu. Un'applicazione verrà creata
sullo stesso modello dei dati. La gestione dell'inventario richiede che siano accessibili i dati relativi ai prodotti
(con parti e sottoparti) e alla loro disponibilità nei magazzini, ai produttori, e ai magazzini. A tale scopo, nel
diagramma Employees disabilita le classi Employee, Area_of_expertise, Chief_position e Office
(Figura 12.4).
81
Personalizzazione delle applicazioni per specifici gruppi di membri
Figura 12.4. Inventory_manager: diagramma Employees
Nel diagramma Resources disabilita le classi Printer, Computer (Figura 12.5).
82
Personalizzazione delle applicazioni per specifici gruppi di membri
Figura 12.5. Inventory_manager: diagramma Resources
Analogamente nel diagramma Support disabilita le classi Customer e Support_request_status. Inoltre
disabilita il ruolo Product.support_request_. Per fare ciò devi semplicemente fare click con il mouse
sul ruolo stesso (Figura 12.6).
83
Personalizzazione delle applicazioni per specifici gruppi di membri
Figura 12.6. Inventory_manager: diagramma Support
Ed infine nel diagramma Visits disabilita le classi Visit e Visitor (Figura 12.7).
84
Personalizzazione delle applicazioni per specifici gruppi di membri
Figura 12.7. Inventory_manager: diagramma Visits
Crea un'ultima applicazione chiamata Company_manager per gestire i dati relativi ai dipendenti. A tale
scopo nel diagramma Support disabilita le classi Customer, Support_request_status e i due ruoli
Product.support_request_, Employee.support_request_ (Figura 12.8).
85
Personalizzazione delle applicazioni per specifici gruppi di membri
Figura 12.8. Company_manager: diagramma Support
Mentre nel diagramma Products disabilita le classi Product, Product_part, Warehouse, e il ruolo
Manufacturer.subpart_ (Figura 12.9).
86
Personalizzazione delle applicazioni per specifici gruppi di membri
Figura 12.9. Company_manager: diagramma Products
Salva le modifiche nel modello e chiudi il Designer. Avvia il Cloudlet Workforce (non c'è bisogno di riallineare il
database poiché le modifiche sono state fatte a livello applicativo), effettua il login dall'homepage del Cloudlet e
dai un'occhiata alle tre applicazioni create prima. Nota come alcuni dettagli del modello non siano mostrati dalle
applicazioni. Per esempio, Area_of_expertise compare solo in Company_manager, e la classe Employee
può essere acceduta completamente in Company_manager, mentre attraverso le applicazioni Inventory_manager
e Support_manager è visibile nell'ambito delle relazioni con le altre classi ma con alcuni attributi oscurati. Quando
avrai terminato di fare le verifiche, effettua il logout e arresta il Cloudlet Workforce.
12.2. Partizionamento per profilo utente
Ogni membro del Cloudlet può accedere a qualunque delle applicazioni che abbiamo precedentemente creato.
Quindi, così come sono state pensate le applicazioni servono solo ad accedere ad una porzione specifica del
database. Sarebbe più utile poter restringere l'accesso anche in base al profilo utente dei membri del Cloudlet.
A tale scopo creiamo un profilo chiamato Admin per scopi di amministrazione, a cui consentiremo l'accesso a
tutte e tre le applicazioni. Successivamente creiamo tre nuovi profili utente chiamati Support, Inventory e
Company. Consentiamo a ciascun profilo di accedere solo all'applicazione che è rilevante per quel profilo:
• Support accederà all'applicazione Support_manager;
• Inventory accederà all'applicazione Inventory_manager;
• Company accederà all'applicazione Company_manager.
I profili utente sono mostrati nel Profile schema. Per visualizzarli devi fare click con il mouse su UserProfiles ( )
nella lista delle View disponibili sulla sinistra. Ad ogni profilo corrisponde un tab. Un profilo è caratterizzato da
un nome e una descrizione fornita nella parte del tab chiamata Profile description. Attualmente c'è un solo tab
corrispondente al profilo di default chiamato Profile1. Rinomina il profilo facendo click con il tasto destro del
87
Personalizzazione delle applicazioni per specifici gruppi di membri
mouse sul tab corrispondente e selezionando dal menu Rename. Digita come nome Admin e fai click su OK
(alternativamente puoi premere il tasto Enter). Scrivi nella finestra Profile description una breve descrizione del
tipo: Administration profile. Aggiungi un secondo profilo. Per aggiungere un nuovo profilo, fai click
sull'icona ( ). Scrivi il nome Support. Una volta fatto click su OK (o dopo aver premuto Enter) verrà creato un
nuovo tab per il profilo. Aggiungi come descrizione: Profile for support request management. Fai
la stessa cosa per creare gli altri due profili: Inventory avente come descrizione Profile for inventory
management, e Company avente come descrizione Profile for company management (Figura 12.10).
Suggerimento
Per eliminare un profilo dal modello basta semplicemente fare click con il tasto destro del mouse sul
tab del profilo e selezionare nel menu la voce Remove. Alternativamente, puoi fare click sull'icona
che compare a destra su tab del profilo quando passi il mouse.
Nota
Ci deve essere almeno un profilo definito nel Profile Schema. Se ce n'è solo uno, questo non può
essere eliminato.
Figura 12.10. I tab in UserProfiles
Affinché un profilo possa accedere ad una data applicazione è necessario assegnare all'applicazione i grant per
quel profilo. Una volta assegnati i grant questi saranno elencati sotto l'applicazione stessa. Assegna i grant del
profilo Admin alle applicazioni Support_manager, Inventory_manager e Company_manager. Per fare ciò fai
click con il tasto destro del mouse sul nome dell'applicazione Support_manager e seleziona dall'Application
menu la voce Add profile grants e poi Admin. Sotto l'applicazione apparirà Grants for Admin ad
indicare il fatto che utenti con il profilo Admin hanno i permessi sufficienti per accedere all'applicazione. Ripeti
la procedura sia per Inventory_manager che per Company_manager. Successivamente assegna i Grants for
Support all'applicazione Support_manager, Grants for Inventory all'applicazione Inventory_manager e i Grants
for Company all'applicazione Company_manager (Figura 12.11). Salva le modifiche apportate al modello e chiudi
il Designer.
88
Personalizzazione delle applicazioni per specifici gruppi di membri
Suggerimento
Per disabilitare un profilo in un'applicazione devi rimuovere i grant dall'applicazione. Fai click con
i tasto destro del mouse sul grant del profilo da disabilitare e seleziona Remove dal Profile
menu.
Figura 12.11. Grants per i profili utente
Adesso che sono stati definiti i profili utente, proviamo ad aggiungere dei nuovi membri al registro dei membri
del Cloudlet e assegnare loro gli opportuni profili. Una volta tornato alla Dashboard, apri il registro dei membri
di Workforce facendo click con il mouse sull'icona corrispondente. Nella finestra di dialogo, vedrai la lista dei
membri del Cloudlet. Attualmente c'è un solo membro avente come username il tuo (sei tu, appunto). Nella colonna
Profile viene mostrato il profilo assegnato all'utente. Nel tuo caso c'è Profile1 in quanto assegnato di default dalla
piattaforma al tuo account. Ora se provi ad avviare il Cloudlet, al termine della fase di avvio, ti verrà inviato un
messaggio di errore per informati che uno o più membri del Cloudlet hanno dei profili che non sono stati definiti
nel modello e dunque non potranno accedere a nessuna applicazione (Figura 12.12). Ed infatti, se accedi alla
homepage del Cloudlet ed effettui il login, non ti verrà mostrata alcuna applicazione.
Figura 12.12. Messaggio d'errore: profili non definiti nel modello
Nel modello il profilo Profile1 è stato ridenominato in Admin. Devi fare la stessa cosa nel registro dei membri
del Cloudlet. Riapri nuovamente la finestra di dialogo del registro dei membri (non c'è bisogno di arrestare il
89
Personalizzazione delle applicazioni per specifici gruppi di membri
Cloudlet). Seleziona la riga relativa al tuo account facendo click con il mouse in un campo qualunque. Vengono
attivati i bottoni nella parte bassa della finestra. Fai click su Edit per modificare l'utente selezionato. Si apre la
finestra di configurazione del membro del Cloudlet in cui puoi impostare una serie di campi relativi all'utente
(quelli obbligatori sono contrassegnati da un asterisco). Cambia solo il campo Profile, selezionando dal menu a
tendina Admin (alternativamente puoi scrivere direttamente nel campo il nome del profilo da assegnare). Fai click
su OK per chiudere la finestra. di configurazione. Se effettui nuovamente il login dalla homepage del Cloudlet,
verranno mostrate tutte e tre le applicazioni a cui hai accesso.
A questo punto aggiungi un nuovo utente chiamato John Doe il quale si occuperà di gestire le richieste di supporto.
Apri nuovamente la finestra di dialogo dei membri del Cloudlet. Fai click sul bottone Create in basso a sinistra.
Si apre nuovamente la finestra di configurazione. Nel campo Username digita JohnDoe, nel campo Email
digita [email protected], e in Profile seleziona il profilo Support. Una volta terminato fai click su OK per
ritornare alla lista dei membri del Cloudelt. Ripeti la stessa procedura per aggiungere altri due membri: Jane Doe
(JaneDoe, [email protected]) responsabile della gestione dell'inventario con profilo Inventory, e Bob
Miles (BobMiles, [email protected]) responsabile della gestione dei dipendenti con profilo Company.
Accedi nuovamente all'homepage di Workforce. Nota che nel pannello Members dell'homepage sono apparsi oltre
al tuo utente (attualmente online) altri tre utenti, per ciascuno dei quali è indicato il profilo corrispondente.
È possibile aggiungere i membri al Cloudlet direttamente dalla sua homepage. Una volta effettuato il login, fai
click sull'icona nel pannello Administration dell'homepage. Si aprirà la lista dei membri del Cloudlet in formato
tabellare (Figura 12.13). I bottoni Create, Edit, e Delete sulla destra consentono di creare, modificare ed eliminare
un membro nella lista, analogamente a quanto fatto prima dalla Dashboard.
Figura 12.13. Lista dei membri del Cloudlet
12.3. Partizionamento orizzontale: filtrare i
record
Cambia il profilo di Jane Doe a Company. In questo modo avremo due utenti con lo stesso profilo: Jane Doe e
Bob Miles. Supponiamo che Jane faccia parte del team A e che Bob appartenga al team B. Visto che i team di
cui fanno parte sono diversi, vogliamo fare in modo che ciascuno di essi veda solo una parte dei dati attraverso
la stessa applicazione Company_manager. Mediante il partizionamento orizzontale dei dati Livebase consente di
impedire l'accesso ad insiemi di record contenti dati che non rispettano certi criteri. Ovviamente, questo tipo di
90
Personalizzazione delle applicazioni per specifici gruppi di membri
partizionamento può essere utilizzato insieme agli altri due tipi (verticale e per profilo) discussi nella Sezione 12.1
e nella Sezione 12.2, rispettivamente.
Apri l'engine di Workforce per modificarlo. Nel diagramma Employee crea una classe Team con un solo attributo
chiamato name (di tipo string, marcato come richiesto e come object title, sul quale è definito un vincolo di
unicità). Crea un'associazione bidirezionale tra la classe Team e la classe Employee (un dipendente appartiene
ad un team e in un team ci sono vari dipendenti). Ed infine, crea un attributo di tipo query in Employee
chiamato teamName, mediante il percorso team.name. Salva le modifiche nel modello e chiudi il Designer.
Popola il database mediante il filler automatico. Dovrai riallineare prima il database. Se non fosse possibile farlo
automaticamente, ripulisci il database mediante il bottone Clear e poi popolalo usando il filler.
Una volta popolato automaticamente il database, chiudi la finestra di dialogo e avvia Workforce. Effettua il login
e, visto che puoi accedere a Company Manager, avvia questa applicazione. Apri la Livetable di Team e prendi
nota di alcuni nomi di team che sono stati generati automaticamente con il filler. A questo punto effettua il logout
e arresta il Cloudlet.
Apri nuovamente il Designer. Accedi all'Application layer e seleziona l'applicazione Company_manager. Fai click
con il tasto destro del mouse sulla classe Employee e seleziona Set Filters.... Si aprirà la finestra di
gestione dei filtri. Fai click su Add. Digita la seguente espressione: teamName = __User.team. Fai click su
OK per confermare. Un nuovo filtro verrà aggiunto alla lista dei filtri. Lascia selezionata la casella Reject object
creation. In questo modo, non sarà possibile creare oggetti che non soddisfano il filtro di classe. Al contrario,
deselezionando la casella sarà possibile creare nuovi oggetti che non soddisfano il filtro di classe. Fai click su
OK nuovamente per chiudere la finestra di gestione dei filtri. Per ogni associazione in cui la classe Employee è
coinvolta, su tutti i ruoli entranti della classe è apparso un cerchietto nero. Ciò indica appunto la presenza di un
filtro di classe. A questo punto salva le modifiche e chiudi il Designer.
Prima di continuare, modifica la lista dei membri di Workforce. Usando i nomi dei team che ti sei segnato prima,
assegna i membri ad alcuni dei team che hai segnato prima, purchè diversi e setta per tutti i membri (compreso
te stesso) lo stesso profilo (ad esempio Company). Successivamente, avvia Workforce ed effettua il login. Apri
Company Manager. Apri la Livetable di Employee. In essa sono mostrati solo quei dipendenti che appartengono
allo stesso team. Prova a creare un nuovo dipendente e ad assegnarlo ad un team diverso. Livebase non ti consentirà
di specificare nella form del dipendente un team diverso. Infatti se provi a fare click su Ok otterrai un errore.
Dovremmo fare in modo che l'unico team possibile sia quello a cui il membro appartiene. Effettua il logout,
arresta il Cloudlet e apri nuovamente il Designer per modificare l'engine. Seleziona nuovamente l'applicazione
Company_manager. Fai click con il tasto destro del mouse sul ruolo Right-click on the Employee.team_ e
seleziona dal menu Set relation role filters.... Come prima si aprirà la finestra di gestione dei
filtri, anche se senza i comandi specifici per le classi. Aggiungi l'espressione: name = __User.team. Fai click
on OK, e successivamente su OK di nuovo per chiudere le finestra di gestione del filtro. Salva le modifiche nel
modello e chiudi il Designer. Avvia il Cloudlet, effettua il login e apri nuovamente la Livetable di Employee
Livetable. Crea un nuovo dipendente. Nota come tra i team possibili appaia solo quello a cui tu appartieni.
In questo caso, il filtro che abbiamo definito si applica al ruolo e non alla classe. Quindi se apri la Livetable
di Team, vedrai la lista di tutti i team memorizzati nel sistema. Questo comportamento potrebbe non essere
quello desiderato. Dunque, potresti definire un filtro di classe su Team piuttosto che un filtro di ruolo su
Employee.teamName, nello stesso modo in cui abbiamo definito prima il filtro per la classe Employee.
Inoltre, è possibile disabilitare i filtri di classe su dei ruoli specifici.
12.4. Riepilogo
In questo capitolo abbiamo mostrato i tre modi in cui è possibile partizionare dati e membri del Cloudlet. Nel
prossimo capitolo parleremo della localizzazione, cioè della personalizzazione delle etichette dell'applicazione
generata in base alla lingua utilizzata.
91
Parte E. Localizzazione
delle applicazioni generate
Capitolo 13. Localizzazione
dell'applicazione generata
Come avrai notato, Livebase traduce automaticamente le stringhe nel modello in stringhe più intuitive per l'utente
nelle applicazioni finali. Per esempio, Personal_data.date_of_birth diventa Date of birth nella colonna
Personal data. Questa traduzione è realizzata nel Localization layer. Per ogni stringa del modello, nel momento in
cui viene creata, viene generata automaticamente la sua traduzione; è sempre possibile personalizzare la traduzione
generata automaticamente. Le localizzazioni attualmente supportate sono Inglese e Italiano. Il supporto per altre
lingue sarà disponibile nelle release future.
13.1. Personalizzare le stringhe generate
automaticamente
Arresta il Cloudlet Workforce e apri il suo engine per modificarlo. Seleziona l'elemento che indica la lingua
predefinita dalla lista sulla sinistra nella finestra del Designer. Sulla destra apparirà la lista delle classi e delle
applicazioni (Model item) e la localizzazione fornita per ciascun elemento della lista (Localization string).
Puoi anche aggiungere altre localizzazioni al tuo engine. Per farlo, clicca sull'icona Create new localization (
Viene mostrata la lista delle localizzazioni disponibili che ancora non sono stato aggiunte all'engine.
).
Solitamente, le stringhe della localizzazione generate automaticamente sono appropriate. A volte, però è
utile definirle diversamente. Proviamo a fare alcuni cambiamenti. Ad esempio cambia il nome plurale della
classe Part_availability in Parts available. Per fare questo, espandi la vista della classe
Part_availability facendo click sul pallino alla sua sinistra e poi fai doppio click con il mouse sul campo
plural name nella colonna Localization string. Cancella l'etichetta presente nel campo, scrivi Parts available
e premi Enter. Allo stesso modo, per la classe Employee cambia l'etichetta dell'attributo <new_record> in New
record? e l'etichetta del ruolo <product_> in Products worked on; per la classe Hardware_address
cambia l'etichetta dell'attributo IP_address in IP address; per la classe Subpart cambia l'etichetta del ruolo
subpart_Target in Subparts; ed infine per la classe Vacation cambia l'etichetta dell'attributo num_days in
Number of days.
Successivamente, espandi la vista dell'applicazione Company manager, facendo click con il mouse sul pallino alla
sua sinistra. Per ogni elemento della vista cambia l'etichetta come specificato nella seguente tabella:
Tabella 13.1.
Elemento
Stringa di localizzazione
Open class 'Employee'
Manage employees
Open class 'Office'
Manage offices
Open class 'Chief_position'
Manage chief positions
Open class 'Area_of_expertise'
Manage areas of expertise
Open class 'Visitor'
Manage visitors
Open class 'Visit'
Manage visits
Open class 'Printer'
Manage printers
Open class 'Computer'
Manage computers
Open class 'Manufacturer'
Manage manufacturers
93
Localizzazione dell'applicazione generata
A questo punto salva le modifiche nel modello e chiudi il Designer, avvia e accedi a Workforce, e apri
l'applicazione Company manager. Come puoi vedere le etichette sono state cambiate con le nuove che abbiamo
inserito prima. Ricorda che per usare una particolare localizzazione devi effettuare il login con un account
configurato per utilizzare tale lingua.
94
Parte F. Gestire i Cloudlet
Capitolo 14. Lavorare con più
Cloudlet
Finora abbiamo lavorato con un solo Cloudlet. A seconda del piano sottoscritto puoi gestire più Cloudlet nel tuo
account. Avere più Cloudlet può essere utile per vari scopi, come ad esempio per testare le modifiche e confrontare
soluzioni diverse. In questo capitolo mostriamo come lavorare con più Cloudlet.
14.1. Esportare modelli in formato XML
Prima di apportare delle modifiche, salva il tuo lavoro al fine di poterlo recuperare in futuro. Come spiegato
nella Sezione 3.3, puoi archiviare l'engine del tuo Cloudlet nella Libreria. In alternativa, puoi salvare solamente
il modello disegnato per l'engine esportandolo in formato XML. La versione XML dell'engine sarà salvata
localmente in un file in una directory sul file system del tuo computer. In questo modo, se ti sei sbagliato o hai
cambiato idea potrai sempre ritornare alla situazione inziale ripristinando il modello a partire dal file XML. Fai
click sull'engine del Cloudlet per aprire la finestra del Designer. Per esportare il modello correntemente mostrato
nel Designer, seleziona dal menu File la voce Export Xml... ( ). Specifica in quale punto del file system
vuoi salvare il modello e assegna il nome TutorialEngine.xml (l'estensione di default è .xml), e poi fai
click su Save.
Suggerimento
Per esportare il modello in formato XML puoi anche usare la combinazione dei tasti Ctrl+E.
Apri il file TutorialEngine.xml per esaminarne la struttura. Il tag <ENGINE MODEL> è alla radice del
documento XML. Comprende altri tag che descrivono gli elementi del modello. Il tag <DATABASE_SCHEMA>
descrive il modello al Database layer. I suoi sottoelementi descrivono le classi (e i loro attributi), le
associazioni e composizioni (insieme ai ruoli e le cardinalità). Analogamente il tag <APPLICATION_SCHEMA>
descrive l'Application layer (le impostazioni per il layout, gli elementi abilitati, i warning e filtri); il tag
<PROFILE_SCHEMA> descrive il Profile layer (con la lista per ogni profilo di tutti gli elementi su cui il profilo
è abilitato); e il tag <LOCALIZATION_SCHEMA> descrive il Localization layer (insieme a tutte le etichette
per ogni elemento dello schema). Nel momento in cui deciderai di ripristinare il tuo modello, il file XML verrà
interpretato opportunamente dalla piattaforma, senza che tu ti debba preoccupare nè di come il file è stato generato
nè del significato dei vari tag.
14.2. Clonare i Cloudlet
Un modo facile per testare delle modifiche senza toccare i dati esistenti è clonare il Cloudlet ed operare sul Cloudlet
clone. Nel momento in cui viene clonato un Cloudlet, viene creato un nuovo Cloudlet chiamato Cloudlet_Clone,
dove Cloudlet è il nome del Cloudlet originale. Il registro dei membri, l'engine ed il database del Cloudlet
originale vengono copiati nel Cloudlet clone.
A questo punto prova a clonare il Cloudlet Workforce: assicurati che il Cloudlet non sia in esecuzione, poi
apri il menu del Cloudlet facendo click con il mouse sulla freccia accanto a Start e seleziona il comando Clone
(Figura 14.1). Nel momento in cui il Cloudlet viene clonato, un nuovo Cloudlet chiamato Workforce_Clone
viene creato nella Dashboard. In esso saranno copiati il registro dei membri, l'engine ed il database del Cloudlet
Workforce.
96
Lavorare con più Cloudlet
Importante
Workforce_Clone è un Cloudlet a sè stante rispetto a Workforce anche se ha lo stesso registro dei
membri, engine e database. Quindi, qualunque cambiamento effettuato su Workforce_Clone non
si riflette su Workforce.
Figura 14.1. Il comando Clone
14.3. Copiare i singoli componenti
Piuttosto che clonare l'intero Cloudlet, puoi copiarne le singole parti. Per esempio, elimina l'engine da
Workforce_Clone. Poi trascina TutorialEngine da Workforce e rilascialo su Workforce_Clone. L'intero engine
sarà copiato nel secondo Cloudlet. Chiaramente, qualunque problematica di allineamento del database dovrà essere
risolta se il database è incompatibile con l'engine copiato. Analogamente, puoi copiare il registro dei membri e
il database.
14.4. Importare modelli in formato XML
Ripristina il vecchio modello TutorialEngine in Workforce_Clone. Elimina sia l'engine che il database
attualmente presenti nel Cloudlet. Fai click con il mouse sull'icona dell'engine per crearne uno nuovo ed aprire la
finestra del Designer. Per importare il modello TutorialEngine salvato precedentemente, seleziona Import
Xml... ( ) dal menu File. Accedi alla directory in cui hai memorizzato il file sul tuo computer, seleziona il
file TutorialEngine.xml e premi il bottone Open.
Suggerimento
Puoi importare un modello XML anche usando la combinazione dei tasti Ctrl+I.
La piattaforma leggerà il file XML e costruirà il corrispondente modello nell'engine del Cloudlet. Il modello verrà
mostrato nella finestra di lavoro del Designer con tutti i suoi elementi così come li avevi specificati nei vari livelli
(Database, Application, Profile, Localization). Salva le modifiche e chiudi il Designer. Una volta tornato alla
Dashboard puoi creare il database ed estendere il registro dei membri del Cloudlet come al solito.
14.5. Eliminare i Cloudlet
A questo punto possiamo ripulire quanto fatto finora. Elimina Workforce_Clone trascinandolo nell'area del Trash.
97
Lavorare con più Cloudlet
14.6. Riepilogo
In questo capitolo abbiamo mostrato alcune funzionalità che consentono di gestire più Cloudlet. Nel prossimo
capitolo mostreremo come sia possibile esportare/importare il database del Cloudlet.
98
Capitolo 15. Importare ed esportare i
dati del Cloudlet
Nella Sezione 14.2 abbiamo mostrato come clonare un Cloudlet mentre nella Sezione 14.1 abbiamo mostrato
come esportare solo il modello XML. In questo capitolo mostreremo come sia possibile gestire solo il database
del Cloudlet, indipendentemente da tutti gli altri suoi componenti.
15.1. Esportare il database da un Cloudlet
come file SQL
Per comodità, su un Cloudlet vuoto (uno nuovo appena creato oppure uno già esistente ma ripulito opportunamente
cancellando sia l'engine che il database) importa il file Excel Employee.xls che abbiamo già usato in un
capitolo precedente. In questo modo verrà creato un nuovo engine e un database contente 500 oggetti. Fai click
con il mouse sull'icona del database per aprire la sua finestra di dialogo (Figura 15.1). In basso a sinistra trovi il
bottone Download (SQL). Se fai click su di esso ti verrà chiesto di salvare un file localmente sul tuo computer
avente il nome di default Cloudlet_db.sql, dove Cloudlet è il nome del Cloudlet sul quale stai operando.
Se vuoi puoi cambiare questo nome. Facendo click sul bottone Save o premendo Enter il file verrà scaricato nel
punto del file system scelto.
Figura 15.1. Finestra di dialogo del database
Controlla il contenuto del file aprendolo con un editor SQL oppure con un semplice text editor. Come puoi vedere
per ogni tabella ci sono istruzioni SQL per creare la tabella e per popolarla con dei record. Nel file sono anche
presenti una serie di metadati che vengono utilizzati internamente da Livebase. Chiudi il file e ritorna alla finestra
di dialogo del database.
99
Importare ed esportare i dati del Cloudlet
15.2. Popolare il database usando un file SQL
Proviamo adesso a ricaricare nel sistema i dati. Cancella i dati nel database utilizzando il bottone Clear. Una volta
che nel database non ci saranno più oggetti fai click sul bottone Upload.
Importante
È possibile effettuare l'upload dei dati nel database solo quando questo è vuoto. Infatti, se nel
database sono presenti dei dati il bottone Upload sarà disabilitato.
Si apre una finestra di dialogo che ti consente di selezionare il file da caricare nel sistema. Il campo Files of Type
mostra come tipi di dato *.mdb, *.accdb (Microsoft Access Database files) e *.sql, *.txt. Seleziona
*.sql, *.txt. Tra i file mostrati nella finestra seleziona il file SQL che abbiamo esportato prima e premi il
tasto Enter oppure fai click su Open. In alternativa, puoi fare semplicemente doppio-click sul file. I dati specificati
nel file saranno importati nel database. Al termine dell'operazione il database conterrà nuovamente 500 oggetti.
15.3. Esportare i dati nel formato Microsoft
Access Database
Facendo click sulla freccia nera rivolta verso il basso del bottone Download (SQL) si apre un menu a tendina
nel quale ci sono due opzioni: Download (SQL) e Download (MDB). Seleziona la seconda opzione per effettuare
il download del database in formato MDB (Figura 15.2). Anche questa volta ti verrà chiesto di salvare il file in
un punto del file system del tuo computer. Per aprire il file devi usare Microsoft Access. Nota come la struttura
del database sia esattamente la stessa descritta nel file SQL che abbiamo esaminato prima. Analogamente a
quanto fatto precedentemente, puoi ripulire di nuovo il database, importare questo file e verificare che i dati siano
ripristinati correttamente.
Figura 15.2. Opzione Download (MDB)
15.4. Riepilogo
In questo capitolo hai visto come sia possibile importare ed esportare i dati di un Cloudlet in vari formati. Ciò, oltre
alla possibilità di importare ed esportare il modello in formato XML, rappresenta un utile strumento per salvare
localmente (a scopi di backup) i componenti di un Cloudlet.
100
Capitolo 16. Configurare i default di
un Cloudlet
Come spiegato nella prefazione Capitolo 1, Gestire il tuo account, i default dei Cloudlet sono configurazioni
e impostazioni usate per scopi relativi all'amministrazione dei Cloudlet. In questo capitolo descriveremo come
è possibile configurare un singolo Cloudlet usando il comando Configure del menu del Cloudlet (Figura 16.1).
I parametri di configurazione impostati da qui vengono applicati solo allo specifico Cloudlet, a differenza dei
parametri di configurazione impostati dalla pagina Defaults nella sezione My account, che vengono applicati a
ogni Cloudlet creato nel tuo account.
Figura 16.1. Il comando Configure
Ora torna alla Dashboard. Dal menu del Cloudlet Workforce seleziona il comando Configure. Si aprirà una finestra
di configurazione con tre tab: Home, Settings, Mail templates (Figura 16.2). In ogni tab è possibile configurare
i parametri corrispondenti. In particolare, in Home puoi specificare tutte le informazioni che saranno mostrate
nella homepage del Cloudlet; in Settings puoi specificare i parametri generali del Cloudlet; e in Mail templates
puoi definire i template delle email che saranno inviate in automatico a ogni membro del Cloudlet. Impostiamo
i default per ogni categoria.
101
Configurare i default di un Cloudlet
Figura 16.2. La finestra di configurazione dei default
Home
Nel campo Description digita una descrizione per il Cloudlet. Per esempio, puoi scrivere This is the
Workforce Cloudlet created using Livebase. Nel campo Warning and News puoi inserire
notizie e comunicazioni per gli utenti del Cloudlet. Per esempio, supponi di voler informare i membri del Cloudlet
Workforce che hai cambiato le etichette delle applicazioni (come hai fatto nel Capitolo 13). Perciò, puoi scrivere
Changed labels in English. Questa nota sarà mostrata nell'homepage del Cloudlet e vista da ogni
suo membro prima di effettuare il login in Workforce. Nel campo Terms and Conditions digita i termini e le
condizioni in base alle quali i membri usano il Cloudlet. Per esempio, supponi che il Cloudlet Workforce sia stato
installato per l'azienda AcmeStar Inc. per gestire dati interni relativi all'attività dell'azienda stessa. Per segnalare
che solo i membri autorizzati possono accedere e modificare i dati dell'azienda per mezzo delle applicazioni fornite
all'interno del Cloudlet, puoi scrivere: Registration to Workforce allows you to insert,
modify and delete data related to AcmeStar Inc.'s activity only by using
the applications provided with the Cloudlet. Any unauthorized disclosure of
data will be persecuted.
102
Configurare i default di un Cloudlet
Impostazioni
Qui puoi specificare alcune impostazioni generali che si applicano al Cloudlet Workforce, come la lingua, il
formato per data e ora, e il fuso orario. Al momento, l'unica scelta per la lingua è l'inglese, mentre per gli altri
parametri ci sono varie possibilità. Seleziona EEEE, MMMM d, yyyy per il campo Date format. In questo
modo, ogni data nell'applicazione generata sarà scritta in modo simile a Thursday, January 20, 2004.
Poi, imposta Time formata HH:mm in modo da rappresentare valori di tempo in modo simile a 08:55. Infine,
seleziona Europe/Rome come Time zone di riferimento. Considera che la scelta del fuso orario determina il
modo in cui i valori DateTime vengono calcolati e mostrati nell'applicazione generata.
Templates delle email
Qui puoi scrivere i template per le email che verranno inviate automaticamente ai membri del Cloudlet Workforce.
I template di default mostrati nella finestra rappresentano uno schema di base dai cui partire. Personalizziamoli
selezionando Member creation dal menu Template. Ora, scrivi il tuo indirizzo email nel campo From e cambia
il Subject in New Workforce Account. Infine, modifica il testo dell'email aggiungendo la frase finale: The
email address used for your subscription is ${mail} (clicca su ${mail} nella lista dei
marcatori sulla sinistra per inserirlo nel testo). Ora, seleziona Member data recovery dal menu Template.
Cambia semplicemente Livebase Team con Workforce Team.
103
Parte G. Lavorare con Excel
Capitolo 17. Importare Flat e Star
sheet
Nel Capitolo 4 abbiamo spiegato la struttura dei Flat sheet e i requisiti per la loro importazione. Le regole di base
per importare un file XLS sono:
• Un foglio di lavoro per classe
• Una riga per oggetto
• Una colonna per attributo
• Riga di intestazione opzionale in ogni foglio di lavoro
Hai già visto come usare queste regole. Ora estendiamo quanto mostrato.
17.1. Preparazione dell'ambiente di lavoro
Nell'ambito di questo capitolo importeremo vari fogli di lavoro Excel. Se li importassimo in dei Cloudlet già
esistenti potremmo avere dei problemi. Quindi è necessario utilizzare un nuovo Cloudlet da cui partire. Se il profilo
che hai sottoscritto ti consente di gestire più di un Cloudlet, allora creane uno nuovo al fine di utilizzarlo in questa
parte del tutorial. Se invece il tuo profilo ti consente di gestire solo un Cloudlet, esporta il modello in formato XML
(come mostrato nella Sezione 14.1) e esporta il database in formato SQL o MDB (come mostrato nel Capitolo 15)
in modo da poterli ripristinare in seguito. Una volta fatto ciò, elimina dal Cloudlet sia l'engine che il database,
così da partire da un Cloudlet vuoto.
17.2. Importare un semplice Flat sheet
Per cominciare, importa il file Excel Customer.xls. Nel foglio di lavoro sono memorizzati i dati personali
relativi ai clienti. In particolare, ci sono 100 record e cinque colonne: firstname, surname, birthdate,
phone, city. Importando il file nel Cloudlet, verranno creati un semplice engine e un database con 100 oggetti.
Apri il Designer facendo click con il mouse sull'icona dell'engine. Il modello dei dati ottenuto importando il file
è mostrato in Figura 17.1. Come puoi vedere, il modello contiene una sola classe chiamata Customer avente
cinque attributi. Il tipo degli attributi è dedotto automaticamente esaminando i dati nel file.
Figura 17.1. La classe Customer
Aggiungendo al nome di una o più colonne il postfisso (UC) la procedura di importazione provvederà a creare
una Unique Constraint per la classe, che comprenderà tutti e soli gli attributi corrispondenti alle colonne marcate.
Per maggiori informazioni sulle unique constraint fare riferimento alla Sezione 2.1.
105
Importare Flat e Star sheet
17.3. Importare un semplice Star sheet
Nel foglio di lavoro che abbiamo appena importato ci sono molti valori che si ripetono nella colonna city.
Sarebbe meglio se l'informazione sulla città venisse rappresentata mediante una classe separata. A tale scopo,
elimina l'engine ed il database creato prima. Successivamente, importa il file CustomerCity.xls. Questo file
è un esempio di Star sheet. Se lo apri noterai che le prime quattro colonne sono uguali alle prime quattro colonne
del file usato prima, mentre la quinta colonna riporta nell'intestazione City.name al posto di city. La presenza
di un punto per separare City e name, indica che l'attributo name appartiene alla classe City.
Al termine dell'importazione, nel Cloudlet verranno creati un nuovo engine ed il database. Se apri nuovamente
l'engine troverai il modello raffigurato in Figura 17.2. Il modello è formato da due classi (probabilmente è
necessario sistemare meglio le classi per visualizzarle correttamente): una classe City con un unico attributo
name di tipo string, e una classe Customer avente gli altri quattro attributi come prima. Inoltre, tra la classe
Customer e City c'è un'associazione bidirezionale con le cardinalità impostate opportunamente da Livebase.
In generale, Livebase sceglie la cardinalità più debole, per esempio 01 rispetto a 1, * rispetto a 1N, etc. Nel
nostro caso, la cardinalità di Customer è impostata a 01 (un cliente vive in al più una città), e la cardinalità di
City è impostata a * (in una città possono vivere più clienti). Per entrambe le classi i ruoli vengono generati
automaticamente come prima, cioè city_ e customer_. Invece il database questa volta contiene 121 oggetti:
100 oggetti customer e 21 oggetti city.
Figura 17.2. L'associazione fra le classi Customer e City
17.4. Star sheet con ruoli multipli
Quando specifichiamo attributi di altre classi, possiamo aggiungere |rolename nel nome delle colonne per
indicare che il ruolo generato deve avere il nome rolename. In questo modo possiamo ripetere gli attributi per
creare associazioni multiple. Per esempio, apri il file CustomerCity_residence_birthplace.xls. Se
lo confronti con quello usato prima, noterai che ci sono due colonne per la città: City.name|residence e
City.name|birthplace. Elimina di nuovo l'engine e il database creati prima. Successivamente importa il
file.
Come prima, saranno creati un engine e un database. Il modello creato a seguito dell'importazione è mostrato in
Figura 17.3. In questo caso sono state aggiunte due associazioni tra le classi Customer e City (anche in questo
caso potresti aver bisogno di sistemare meglio le classi per visualizzarle correttamente). I ruoli di City sono
chiamati residence e birthplace. Invece i ruoli di Customer hanno dei nomi generati automaticamente
come al solito. Visto che il numero dei clienti e delle città non è cambiato rispetto a quelli riportati nel foglio Excel
utilizzato precedentemente, il database conterrà sempre 121 oggetti: 100 oggetti customer e 21 oggetti city.
106
Importare Flat e Star sheet
Figura 17.3. Le associazioni fra le classi Customer e City
17.5. Create sheet versus Append sheet
La modalità di default dell'operazione di importazione dei file XLS è Create, ed è quella che abbiamo illustrato
finora. Un'altra modalità di importazione, disponibile solo per i Flat sheet, è Append, utilizzabile specificando
il prefisso + nel nome del foglio. Mediante questa modalità è possibile utilizzare i file XLS per aggiungere dati
ad un modello già esistente.
Ad esempio, apri il file Customer_Append.xls. Nota che le colonne riportano gli stessi nomi degli attributi
della classe Customer, ma il foglio di lavoro è chiamato +Customer. Importa questo file nel Cloudlet
mantenendo l'engine e il database creati prima. Al termine dell'importazione, apri il Designer per esaminare
nuovamente l'engine. Come vedi non è cambiato nulla nel modello. Invece, ciò che è cambiato è il numero degli
oggetti nel database. In particolare, visto che nel file che abbiamo importato ci sono 500 customer e nel database
c'erano 121 oggetti, dopo l'importazione del file avremo complessivamente 621 oggetti nel database: 600 oggetti
customer e 21 oggetti city.
17.6. Riepilogo
In questo capitolo abbiamo fatto un breve ripasso sui Flat e Star sheet, e abbiamo anche mostrato la modalità
Append per gli sheet. Nel prossimo capitolo descriveremo i Reference sheet.
107
Capitolo 18. Importare i Reference
sheet
Come abbiamo spiegato nel Capitolo 17, i Flat sheet e gli Star sheet consentono di creare delle classi e popolarle
con dei dati. I Flat sheet possono essere utilizzati anche in modalità Append, così da consentire l'aggiunta di nuovi
record a classi già presenti nel modello. I Reference sheet rappresentano un modo per creare delle nuove classi nel
modello ed eventualmente associarle a quelle già esistenti.
18.1. Struttura di un Reference sheet
I Reference sheet sono una generalizzazione degli Star sheet. La struttura è la stessa con l'unica differenza che il
nome delle colonne che si riferiscono ad attributi appartenenti a classi già esistenti nel modello, è preceduto da un
asterisco (*). Ad esempio *Person.name è il nome della colonna per l'attributo name della classe Person.
In questo modo è possibile distinguere queste colonne da quelle che si riferiscono ad attributi di nuove classi
da aggiungere al modello. L'associazione con le classi già esistenti non deve essere ambigua, nel senso che è
necessario specificare un attributo o un insieme di attributi per i quali è stato definito nel modello un vincolo di
unicità.
La possibilità di associare oggetti con classi già esistenti nel modello è l'unica caratteristica che differenzia
i Reference sheet dagli Star sheet. Dunque, un Reference sheet in cui non si referenziano classi esistenti è
semplicemente uno Star sheet. Nota che, gli attributi referenziati nel foglio di lavoro devono appartenere a delle
classi create nel modello prima dell'importazione del Reference sheet stesso (o mediante l'importazione di un Flat o
Star sheet, oppure usando il Designer). Non puoi referenziare attributi appartenenti a classi create contestualmente
all'importazione del foglio di lavoro. Per esempio, considera di nuovo la colonna *Person.name. In questo caso,
l'attributo name della classe Person può essere referenziato solo nel modello è già presente la classe Person.
18.2. Create Reference sheet versus Append
Reference sheet
Nel modalità Create, i Reference sheet specificano delle nuove classi da aggiungere a quelle esistenti nel
modello, e i dati con cui popolarle. Nella modalità Append, i Reference sheet specificano i dati che devono essere
aggiunti alle classi esistenti nel modello. Nota che in quest'ultimo caso puoi aggiungere dati ad una sola classe per
foglio di lavoro, mentre puoi referenziare un numero qualunque di attributi esterni. Se vuoi aggiungere dati a più
classi, devi creare un foglio di lavoro distinto per ogni classe (o utilizzare file diversi).
18.3. Testare un Reference sheet
Diamo un'occhiata ad un esempio di Reference sheet. Apri il file Sale.xls. Come puoi vedere c'è un foglio
di lavoro chiamato Sale con queste colonne: datetime (di tipo date & time), quantity (di tipo integer),
Product.name (di tipo string), *Customer.firstname (di tipo string, che fa riferimento alla classe
Customer già presente nel modello), *Customer.surname (di tipo string, che fa riferimento alla classe
Customer già presente nel modello), *Customer.birthdate (di tipo string, che fa riferimento alla classe
Customer già presente nel modello). Importando questo foglio di lavoro aggiungeremo due nuove classi al
modello: Sale e Product. Ogni vendita è associata a un prodotto e a un cliente.
Nota che nel foglio di lavoro sono referenziati tre attributi esistenti: Customer.firstname,
Customer.surname e Customer.birthdate. La classe Customer è già presente nel modello. Come
sottolineato prima, possono essere referenziati solo quegli attributi sui quali è imposto un vincolo di unicità. Quindi
108
Importare i Reference sheet
prima di importare il file, devi imporre un vincolo di unicità su tutti e tre gli attributi della classe Customer citati
prima. Per imporre il vincolo apri il Designer. Una volta creato il vincolo, dovrai riallineare il database. Fai click
con il mouse sull'icona del database per risolvere tutte le problematiche di compatibilità che possono essere sorte
a causa delle modifiche apportate sul modello.
Nota
Se non riesci a riallineare il database, elimina sia l'engine che il database e ricomincia
daccapo importando questa volta il file CustomerCity_residence_birthplace.xls
che abbiamo usato nel precedente capitolo. Dovresti ottenere il modello mostrato in Figura 17.3
e un database con 121 oggetti. Apri il Designer e imponi un vincolo di unicità sugli attributi
firstname, surname e birthdate della classe Customer. Risolvi tutte le problematiche
di allineamento del database.
Ora prova ad importare il file Sale.xls. Al termine dell'operazione di importazione apri il Designer facendo
click con il mouse sull'icona dell'engine per ispezionare il modello. Il modello creato è mostrato in Figura 18.1.
Come avrai notato, ci sono due nuove classi Sale e Product che sono state aggiunte al modello, insieme
alle corrispondenti associazioni con la classe Customer. Inoltre, anche il numero degli oggetti nel database è
aumentato.
Figura 18.1. Diagramma ottenuto importando il Reference sheet
109
Capitolo 19. Importare i Relation
sheet
Nel Capitolo 18, abbiamo mostrato come mediante l'uso dei Reference sheet è possibile aggiungere classi e dati
al modello senza sovrascrivere le classi già esistenti. In questo capitolo introduciamo i Relation sheet mediante i
quali è possibile definire delle associazioni tra oggetti.
19.1. Struttura di un Relation sheet
Il nome di un Relation sheet deve rispettare il seguente formato Class1-Class2|rolename, ad esempio
Family-Car|primary. Il rolename può essere omesso se non c'è ambiguità. Le due classi Class1 e
Class2 devono essere presenti nel modello prima dell'importazione del foglio di lavoro e non possono essere
definite come nuove classi nello stesso file XLS.
In un Reference sheet non vengono specificati nuovi attributi bensì vengono referenziati solo quelli che già
sono presenti nel modello. Quindi, l'intestazione di tutte le colonne nel foglio di lavoro deve avere il formato
*Class.attribute. Come per i Reference sheet, nella definizione dell'associazione non ci deve essere
ambiguità (cioè nel modello deve essere imposto un vincolo di unicità su gli attributi referenziati).
19.2. Create Relation sheet versus Append
Relation sheet
Un Relation sheet di tipo Create specifica una nuova associazione tra due classi e mette in relazione tra loro
gli oggetti già esistenti (Create è la modalità di default mode, e quindi può essere omessa). Invece, un Relation
sheet di tipo Append specifica solo le associazioni tra oggetti esistenti, e quindi presuppone che nel modello sia
già definita l'associazione in questione.
19.3. Relation sheet all'opera
Proviamo ad aggiungere un po' di clienti, prodotti e vendite in modo da poterli associare successivamente. Partiamo
da un Cloudlet vuoto, senza engine e database (puoi creare un nuovo Cloudlet se hai risorse sufficienti, oppure
archivia/elimina l'engine costruito precedentemente ed elimina il database). Poi, importa nel Cloudlet questi due
file: CustomerCity_residence_birthplace2.xls e Product2.xls. Dopodiché, apri il Designer e
definisci un vincolo di unicità sull'attributo name della classe Product e sugli attributi firstname, surname
e birthdate della classe Customer. Riallinea il database ed importa il terzo file Sale2.xls. In questo modo
hai costruito un engine e un database con 146 oggetti: 21 oggetti city, 50 oggetti customer, 47 oggetti product e
28 oggetti sale. Se apri il Designer dovresti vedere un modello come quello mostrato in Figura 19.1.
110
Importare i Relation sheet
Figura 19.1. Diagramma Customer-City-Product-Sale
Ora proviamo a definire un'associazione tra Customer e Product per tenere traccia di quali siano i prodotti
preferiti dai clienti. Apri il file CustomerProduct_prefBy2.xls. Questo è un esempio di Relation sheet
di tipo Create che aggiunge un'associazione tra la classe Customer e la classe Product e definisce il ruolo
prefPr di Customer e il ruolo preferredBy di Product, e mette in relazione gli oggetti delle due classi.
Importa il file nel Cloudlet. Una volta che l'importazione sarà terminata vedrai comparire la nuova associazione
nel modello (Figura 19.2). Nota che il numero degli oggetti nel database non è cambiato. Prova ad avviare il
Cloudlet, accedi e dai un'occhiata agli oggetti creati nel database. Fai click su Open product per aprire la Livetable
di Product. Ricerca un prodotto chiamato scissors. Fai doppio click su di esso con il mouse. Si apre l'Object
editing panel relativo all'oggetto selezionato che mostra che il prodotto chiamato scissors è il preferito del
cliente Ben Jobs. Successivamente, apri il file CustomerProduct_prefBy_Append2.xls. Questo file
è un Reference sheet di tipo Append che specifica semplicemente le associazioni tra gli oggetti delle due classi
(Customer e Product) visto che l'associazione tra le due classi è stata precedentemente definita. Importa
questo file nel Cloudlet e vedrai che non verranno apportate modifiche sia all'engine che il database; l'unica
modifica è a livello delle associazioni tra gli oggetti. Avvia il Cloudlet e verifica i cambiamenti. In particolare,
cerca nuovamente il prodotto scissors. In questo caso vedrai che il prodotto è il preferito non solo del cliente
Ben Jobs ma anche di altri tre clienti: Ben Miller, Ben Peterson e David Allan.
111
Importare i Relation sheet
Figura 19.2. Diagramma Customer-City-Product-Sale (cont.)
112
Capitolo 20. Connettersi ad un
Cloudlet via Web
Microsoft Excel permette di importare dati da sorgenti di diverso tipo, incluse pagine HTML scaricate attraverso il
protocollo HTTP. In questo modo è possibile importare i dati gestiti da un Cloudlet all'interno di un foglio Excel,
e tenere aggiornati tale dati in modo automatico. In questo capitolo, basato sulla versione 2010 di Excel, si offre
una panoramica sull'uso di questa funzionalità, che prende il nome di query Web.
Nota
Le immagini e le istruzioni sono relative ad Excel 2010, ma le query Web sono disponibili anche
in versioni antecedenti di Excel.
20.1. Stabilire la connessione
Con Excel 2010, è possibile definire una query Web in pochi semplici passi. Per prima cosa assicurati che il
Cloudlet con il quale vuoi collegarti sia in esecuzione, poi apri Excel, seleziona il foglio sul quale desideri importare
i dati provenienti dal Cloudlet e clicca sulla scheda Dati. In questa tale scheda, all'interno del gruppo Importa
dati esterni, clicca infine sull'icona Da Web: apparirà un browser Web speciale (che è parte di Excel) per
esplorare i dati forniti da fonti Web e per selezionare quali importare.
Figura 20.1. La scheda Dati
Inserisci nel campo indirizzo l'URL di accesso all'interfaccia REST del Cloudlet al quale vuoi collegarti. Questa
URL è composta dalla URL del Cloudlet (visibile sulla Dashboard) seguita dal postfisso /rest.
113
Connettersi ad un Cloudlet via Web
Figura 20.2. La finestra Excel per creare una query Web
Andando sulla Dashboard e cliccando sulla piccola icona spina ( ) che si trova nella intestazione del Cloudlet,
si apre una finestra che spiega come creare connessioni dati verso quel Cloudlet.
Figura 20.3. Il pulsante per ottenere informazioni riguardo all'API REST
Suggerimento
Da questa finestra è possibile selezionare e copiare negli appunti la URL da incollare nel campo
indirizzo del Web browser di Excel.
Una volta digitato (o copiato/incollato) l'URL dell'interfaccia REST del Cloudlet nel campo indirizzo, premi il
tasto Invio per stabilire il collegamento ed inserisci username e password di un membro del Cloudlet.
Suggerimento
Ogni Cloudlet alla creazione comprende di default un membro le cui credenziali (username e
password) sono le stesse usate dallo sviluppatore per accedere al portale Fhoster ed alla Dashboard.
In questo modo lo sviluppatore che crea un Cloudlet può immediatamente accedervi senza dover
creare un membro apposta.
Una volta autenticato con le credenziali di un certo membro, avrai accesso a tutti e soli i dati ai quali quel membro
avrebbe accesso utilizzando la normale interfaccia grafica del Cloudlet.
Il browser interno di Excel mostrerà inizialmente una semplice pagina HTML con il nome del Cloudlet ed i link
dai quali potrai cominciare la navigazione fino a individuare i dati da importare.
Nota
Excel utilizza le impostazioni di Microsoft Internet Explorer (MSIE) per connettersi a Internet.
In caso di problemi, verificare che il Cloudlet sia in esecuzione (stato Running) e che MSIE
consenta di navigare sul Web (provare una URL qualsiasi, ad esempio la home page di Google)
agendo eventualmente sulle proprietà di connessione (ad esempio impostando correttamente le
impostazioni dell’eventuale proxy).
114
Connettersi ad un Cloudlet via Web
20.2. Esplorare i dati
I dati del Cloudlet possono essere visualizzati e navigati utilizzando il browser interno di Excel semplicemente
cliccando i link visualizzati nelle varie pagine, esattamente come quando si navigano normali pagine Web con
un qualsiasi browser Web.
Nota
In funzione dello username utilizzato in fase di autenticazione è possibile che alcune delle pagine
non visualizzino alcun dato o link. In tal caso verificare, nel modello dell’Engine installato nel
Cloudlet, i diritti del profilo associato allo username.
Dalla pagina iniziale (cioè quella visualizzata subito dopo aver inserito username e password) clicca sul link
relativo a una delle applicazioni disponibili per visualizzare la pagina relativa.
La pagina relativa ad una applicazione contiene i link relativi alle classi di primo livello da essa gestite, cioè quelle
che nella interfaccia grafica interattiva compaiono nel menu a sinistra. Clicca sul link relativo a una delle classi
disponibili per visualizzare la pagina relativa.
La pagina relativa ad una classe conterrà la lista degli oggetti accessibili di quella classe, cioè gli oggetti che nella
interfaccia grafica interattiva compaiono in una LiveTable quando si clicca su una delle voci del menu principale
a sinistra. Clicca sul link relativo a uno degli oggetti per visualizzare la pagina relativa.
La pagina relativa ad un oggetto contiene informazioni sull’oggetto, il valore dei suoi attributi accessibili e le
tabelle degli oggetti collegati dalle relazioni di associazione o di composizione accessibili (cioè gli attributi e le
relazioni che compaiono nella maschera che la interfaccia grafica interattiva offre per creare o modificare oggetti
di quella classe).
Quali attributi e relazioni sono effettivamente accessibili nella pagina relativa ad un oggetto di una data classe
in una certa applicazione dipendono dal form layout definito per la classe nella specifica applicazione (come
spiegato in Sezione 6.3). Le colonne visualizzate in ciascuna tabella dipendono dai rispettivi list layout, definiti
come spiegato in Sezione 6.4.
Nella intestazione di ciascuna pagina sono presenti link per tornare ad una delle pagine precedenti (dall’oggetto
alla classe di appartenenza, dalla classe all’applicazione che la gestisce, etc.).
20.3. Selezionare i dati da importare
Il browser interno di Excel, per ciascuna pagina visualizzata, evidenzia i dati che possono essere importati (singoli
valori o tabelle di valori) con delle piccole icone ( ) sulle quali è possibile cliccare per selezionare/deselezionare
i dati relativi.
Selezionando più icone, i rispettivi dati sono importati sul foglio Excel di destinazione separati l’uno dall’altro da
una riga vuota, indipendentemente dalla loro posizione all’interno della pagina visualizzata dal browser Excel. È
anche possibile importare l'intera pagina.
Se preferisci importare dati su fogli Excel differenti, oppure in punti specifici di uno stesso foglio Excel, puoi
farlo definendo query Web distinte.
Volendo ad esempio importare la lista degli oggetti di una certa classe, basta navigare con il browser interno di
Excel sulla pagina relativa a quella classe e cliccare (selezionandola) la piccola icona (
Objects.
115
) relativa alla tabella
Connettersi ad un Cloudlet via Web
20.4. Importare i dati selezionati
Una volta selezionati i dati che ti interessano, clicca su Importa per importare i dati all'interno del tuo foglio di
lavoro.
Excel ti chiederà se vuoi importare i dati in un foglio esistente oppure in un nuovo foglio di lavoro. Una volta
confermato il loro posizionamento, i dati precedentemente selezionati vengono scaricati dal Cloudlet ed inseriti
nel foglio di lavoro in modo da essere disponibili anche in assenza di connessione.
Figura 20.4. Importazione dei dati
Figura 20.5. Posizionamento dei dati da importare
116
Connettersi ad un Cloudlet via Web
È comunque sempre possibile aggiornare i dati importati cliccando sul pulsante Aggiorna tutto del gruppo
Connessioni della scheda Dati. Nel caso in cui il Cloudlet risulti non raggiungibile (ad esempio perché non
in esecuzione, o per mancanza di connessione ad Internet) Excel mostrerà una notifica.
Figura 20.6. Il pulsante Aggiorna tutto
Nota
È sempre possibile modificare manualmente i dati importati, ma Excel sovrascriverà le modifiche in
caso di successivo aggiornamento. Ricorda anche che, se modifichi il modello e rigeneri il Cloudlet,
le query Web che hai definito potrebbero non essere più valide.
20.5. Aggiornare i dati importati in modo
automatico
Ad ogni singola query Web che hai definito corrisponde una connessione HTTP. Per visualizzarle, apri la scheda
Dati di Excel e, nel gruppo Connessioni, clicca sul pulsante Connessioni.
Figura 20.7. Il pulsante Connessioni
Si aprirà una finestra che mostra la lista di tutte le connessioni HTTP del tuo foglio Excel. Per modificare le
proprietà di una specifica connessione basta selezionarla e cliccare sul pulsante Proprietà. Dalla finestra che si
aprirà, è possibile definire molte opzioni utili.
117
Connettersi ad un Cloudlet via Web
Figura 20.8. La finestra per l'aggiunta delle connessioni
Fra le opzioni più utili di una connessione c’è quella di esecuzione automatica della query Web basata su di essa,
e quindi l’aggiornamento automatico dei dati importati da tale query Web. L'esecuzione automatica può essere
configurata per avvenire a intervalli predefiniti e/o in ogni caso a ogni apertura del foglio di lavoro.
Avvertimento
Eliminando una connessione utilizzata da una query Web i dati importati con tale query non
verranno più aggiornati.
20.6. Opzioni di una query Web
È possibile configurare le opzioni di una query Web sia durante la sua definizione, sia modificandola in seguito.
Se vuoi modificare una query Web già definita fai click destro su una cella qualsiasi di quelle importate e scegli
l'opzione Modifica query... dal menu contestuale. Apparirà una finestra per modificare la query Web con
la quale è stato importato il valore presente nella cella selezionata.
Nella finestra che appare, clicca sul pulsante Opzioni... per visualizzare le opzioni disponibili. Da questa finestra
è possibile, ad esempio, disabilitare il riconoscimento automatico delle date.
118
Connettersi ad un Cloudlet via Web
Figura 20.9. La finestra con le opzioni relative a una singola query Web
20.7. Gestire query Web in file separati
Excel permette di gestire una singola query Web in un file distinto. L'estensione che contraddistingue questo tipo
di file è .iqy. È possibile esportare in file distinti le single query Web definite in un foglio di lavoro. Per farlo,
è sufficiente cliccare sulla piccola icona a forma di dischetto posta in alto a destra nella finestra di configurazione
della query Web.
Figura 20.10. Il pulsante per il salvataggio di una query Web
Suggerimento
I file che definiscono le query Web sono salvati in chiaro: è quindi possibile modificarli anche
manualmente con un editor di testo per quanto riguarda le funzionalità più avanzate.
Per importare una query Web salvata in un file nel tuo foglio di lavoro, clicca su Connessioni nel gruppo
Connessioni della scheda Dati. Nella finestra che compare, clicca su Aggiungi... e poi su Sfoglia....
119
Connettersi ad un Cloudlet via Web
Figura 20.11. La finestra per la gestione delle connessioni
120
Parte H. Creare i report
Capitolo 21. Creare un semplice
report tabellare
Un report è un documento stampato che aggrega automaticamente dei dati dal database del Cloudlet e li presenta
in formati differenti. Livebase ti permette di costruire vari tipi di report, come tabellari, a campi incrociati, a torta
e a barre. I report sono stampati in formato PDF. Nota che, a seconda di come i dati nel Cloudlet siano stati alterati,
differenti record possono comparire nel report in momenti differenti. I report sono definiti nel Database layer e
su una singola classe del modello. I parametri e il layout (ovvero il formato) dei report sono configurati tramite
il Designer.
21.1. Costruire il modello
Abbiamo bisogno di dati da cui partire. Comincia con un Cloudlet privo di engine e database (puoi creare
un nuovo Cloudlet, o archiviare/cancellare l'engine che hai costruito in precedenza ed eliminare il database).
Successivamente, importa questi due fogli di lavoro: CustomerCity_residence_birthplace3.xls,
Product3.xls. Dopo di ciò, apri il Designer e definisci un vincolo di unicità sull'attributo name
della classe Product e sugli attributi firstname, surname e birthdate della classe Customer.
Riallinea il database e importa i fogli di lavoro Sale3.xls, CustomerProduct_prefBy3.xls e
CustomerProduct_prefBy_Append3.xls. Osserva un momento il modello. Il modello risultante
(Figura 21.1) è in qualche modo simile a quello ottenuto alla fine del precedente capitolo con qualche piccola
differenza, come ad esempio gli attributi state e country di City, che rappresentano lo stato e la regione
di una città, l'attributo age di Customer che rappresentà l'età di un cliente, e l'attributo price_per_unit di
Product che rappresenta il prezzo in Euro di una singola unità di prodotto. Il database contiene 146 oggetti: 21
oggetti città, 50 oggetti cliente, 47 oggetti prodotto e 28 oggetti vendita. Nel resto di questo capitolo descriveremo
come costruire un semplice report tabellare estraendo i dati dal database ottenuto con l'import dei file Excel. Un
report tabellare è il tipo più semplice di report che è possibile costruire. Le altre tipologie di report che possono
essere generate in Livebase saranno mostrate nei capitoli successivi.
122
Creare un semplice report tabellare
Figura 21.1. Il diagramma Customer-City-Product-Sale
21.2. Configurare il report
Un report tabellare mostra statistiche descrittive (come sum, min, max, avg, ecc.) in un formato tabellare. L'output
del report è organizzato in un formato multiriga e multicolonna, con ogni colonna che corrisponde a una colonna
di una tabella nel database del Cloudlet e ogni riga che corrisponde a un record di una tabella del database.
Il primo passo è quello di specificare i dati che devono essere estratti dal database. Supponiamo di voler mostrare
alcune statistiche sull'età dei clienti (minima, massima e media) oltre all'età di ogni cliente nel nostro insieme di
clienti. Tutte le informazioni di cui abbiamo bisogno sono contenute in Customer, perciò dobbiamo definire
un report su tale classe. Apri il Designer. Ora, fai click con il tasto destro del mouse sull'intestazione della classe
Customer e seleziona New report... dal Class menu. Comparirà una finestra di dialogo contenente i
quattro tipi di report che puoi definire in Livebase:
• Tabular report ( )
• Crosstab report ( )
• Piechart report (
)
• Barchart report ( )
Seleziona Tabular report. Si aprirà il pannello di configurazione del report, nel quale potrai specificarne il formato.
Come puoi vedere in Figura 21.2, il pannello è diviso in due aree. Sulla sinistra è mostrata la classe sulla quale
stai definendo il report (nel nostro caso Customer). Sulla destra ci sono i sottopannelli dove puoi definire il
layout del report.
123
Creare un semplice report tabellare
Figura 21.2. Pannello di configurazione del tabular report
Nel campo Title scrivi Customer's age statistics, mentre nel campo Description scrivi una
semplice descrizione per il documento, ad esempio Document reporting statistics about the
customers' age. Il titolo e la descrizione sono utili sono a fini descrittivi e non sono obbligatori. Saranno
mostrati nell'applicazione generata. Ora è il momento di specificare la colonna della tabella del database che deve
essere mostrata. Vogliamo mostrare il nome proprio, il cognome e l'età dei clienti. Inoltre, vogliamo mostrare
l'età minima, massima e media dei nostri clienti. Ora, nell'area Data columns seleziona l'attributo firstname
dal menu a tendina (dovrebbe essere mostrato di default, siccome firstname è il primo attributo della classe
Customer). Per aggiungere surname, fai click sull'icona . Fai lo stesso per aggiungere age e questa volta
seleziona i flag MIN, MAX, and AVG (siccome vogliamo mostrare statistiche sull'età).
Nota
Per rimuovere un campo dal formato del report, è sufficiente fare click sull'icona
accanto ad esso.
Infine, nell'area Grouping sections seleziona Just one per specificare che sarà stampata solo una tabella contenente
i dati estratti dal database. Nell'area Page options puoi indicare come la tabella sarà mostrata nella pagina. Nello
specifico, puoi scegliere fra due tipi di orientamento: portrait e landscape. Seleziona Portrait. Nota che l'icona
del report tabellare è apparsa nel pannello di navigazione della finestra del Designer sotto il livello database insieme
alle icone delle applicazioni definite per il modello. L'ultimo passo per la definizione del nostro semplice report
e quello di rinominarlo. È veramente semplice. Fai click sull'icona del report e seleziona Rename dal menu del
report. Dai al report il nome CustomerAge. In alternativa, puoi fare doppio click sull'icona del report e scrivere
il nome.
21.3. Stampare il report
Ora che hai completato la definizione del formato del report CustomerAge, salva i cambiamenti e chiudi il
Designer. Una volta tornato alla Dashboard avvia il Cloudlet. Appena il Cloudlet è in esecuzione, accedi alla sua
124
Creare un semplice report tabellare
homepage e autenticati nel Cloudlet. Dopo aver fatto il login, vedrai due tab sulla sinistra: Applications e Reports.
Fai click su Reports per vedere la lista dei report definiti per il Cloudlet (nel nostro caso solo CustomerAge).
Generare il report è veramente semplice. Fai click sull'incona del report. Dopo un paio di secondi, il report verrà
stampato in formato PDF e ti verrà chiesto di salvare il file. Salvalo e aprilo. Vedrai una tabella formattata come
specificato. Le righe della tabella conterranno i dati estratti dal database del Cloudlet, ovvero il nome di battesimo
e il cognome dei clienti del nostro insieme di clienti con la loro età. Nota che le statistiche (min, max e avg) sono
mostrate appena sotto l'intestazione della colonna. Il report generato per questo esempio può essere scaricato da
qui.
21.4. Raggruppare i dati in sezioni multiple
Ora modifichiamo il report CustomerAge. In particolare, vogliamo mostrare le statistiche sull'età dei nostri
clienti, per ogni città di residenza. Per farlo, abbiamo bisogno di conoscere la città di residenza di un cliente.
Questa informazione è ricavata dalla classe City. Arresta il Cloudlet e apri di nuovo il Designer.
Modificare il modello
L'informazione sulla città di residenza di un cliente è già disponibile nella classe Customer grazie all'attributo
di tipo query residence_name creato mediante l'import dei file Excel. Rinominalo in residence_city.
In Figura 21.3 è raffigurato il modello con il percorso usato per l'attributo di tipo query residence_city
evidenziato.
Figura 21.3. Il diagramma Customer-City-Product-Sale modificato
Modificare il report
Ora che abbiamo tutte le informazioni di cui abbiamo bisogno, modifichiamo il report CustomerAge. Fai click
sull'icona del pannello di configurazione del report. Dato che vogliamo dividere i dati dei clienti in tabelle multiple
125
Creare un semplice report tabellare
raggruppate secondo uno specifico attributo dobbiamo spuntare l'opzione Multiple sections, group by nell'area
Grouping sections. Fai click sull'icona
per aggiungere il campo i cui dati devono essere raggruppati. Dato
che vogliamo una tabella per ogni città seleziona residence_city. Ora siccome vogliamo mostrare per ogni
tabella la città di residenza, il numero di clienti residenti in tale città e le statistiche sull'età dei clienti per quella
città, dall'altro menu sulla destra seleziona Show section title, object count and statistics
(Figura 21.4). Salva i cambiamenti e chiudi il Designer. Avvia di nuovo il Cloudlet e genera il report CustomerAge.
Nota come gli stessi dati sui clienti sono stati divisi in 17 aree differenti, una per ogni città nella quale risiedono i
clienti. Come prima, il report generato per questo esempio può essere scaricato da qui.
Figura 21.4. Pannello di configurazione del tabular report modificato
126
Capitolo 22. Creare un report a campi
incrociati
I report a campi incrociati ti permettono di visualizzare informazioni su più dimensioni. Raggruppando gruppi e
record totali è possibile individuare pattern e ottenere risposte a domande di interesse. Come per i report tabellari,
i dati sono visualizzati in tabelle, ma in modo molto più flessibile. Infatti, in un report a campi incrociati, i record
sono raggruppati per righe e per colonne. Nello specifico, in Livebase puoi mostrare i dati secondo al più due livelli
di raggruppamento per le righe e le colonne. Ogni cella in un report a campi incrociati rappresenta un insieme di
record che soddisfano la combinazione di attributi che appaiono nelle intestazioni delle righe e delle colonne. In
questo capitolo descriveremo come creare un report a campi incrociati. Useremo il Cloudlet ottenuto alla fine del
Capitolo 21. Per praticità, in Figura 22.1 è riportato il modello che sarà usato in questo capitolo.
Figura 22.1. Il diagramma Customer-City-Product-Sale modificato
22.1. Modificare il modello
Vogliamo creare un documento che mostri i ricavi medi dalle vendine di prodotti nelle varie città divise per regione
e per paese. I dati sulle vendite sono riportati nella tabella corrispondente alla classe Sale. Tuttavia, avrai notato
che nella classe Sale manca parte delle informazioni di cui abbiamo bisogno per costruire il report (la città, la
regione e lo stato del cliente, il prodotto acquistato e il prezzo totale pagato). Queste informazioni, però, possono
essere derivate dalle classi Sale, Product, City e Customer per mezzo degli attributi derivati (di tipo math
e di tipo query).
127
Creare un report a campi incrociati
Arresta il Cloudlet, se è in esecuzione, e riapri nuovamente il Designer. Le informazioni sul prodotto coinvolto
nell'acquisto sono disponibili in Product. Perciò, trascina l'attributo name da Product e collegalo a Sale
selezionando il percorso product.name. Chiama la l'attributo di query purchased_product (Figura 22.2).
Figura 22.2. purchased_product derivato da Product
Ora abbiamo bisogno di rappresentare il prezzo totale pagato in una vendita. Conosciamo la quantità
di prodotti comprati in una vendita (attributo quantity in Sale) e il prezzo unitario di un prodotto
(attributo price_per_unit in Product). Perciò, trascina price_per_unit da Product e collegalo
a Sale selezionando il percorso product.price_per_unit. Chiama questo attributo di tipo query
product_price_per_unit. Successivamente, crea un nuovo attributo matematico su Sale di nome
total_price_paid usando questa espressione: quantity
*
product_price_per_unit
(Figura 22.3).
Figura 22.3. total_price_paid and product_price_per_unit derivato da
Product
Allo stesso modo, per ottenere la città, la regione e il paese nel quale la vendita ha avuto luogo (ovvero la città, la
regione e il paese dove il cliente risiede), crea i seguenti attributi di tipo query su Sale:
• customer_city trascinando name da City e selezionando il percorso customer.residence.name
(Figura 22.4)
• customer_state
trascinando
state
customer.residence.state (Figura 22.5)
da
• customer_country
trascinando
country
customer.residence.country (Figura 22.6)
128
City
da
City
e
selezionando
e
selezionando
il
percorso
il
percorso
Creare un report a campi incrociati
Figura 22.4. customer_city derivato da City e Customer
129
Creare un report a campi incrociati
Figura 22.5. customer_state derivato da City e Customer
130
Creare un report a campi incrociati
Figura 22.6. customer_country derivato da City e Customer
22.2. Configurare il report
A questo punto abbiamo tutte le informazioni necessarie e possiamo creare un report a campi incrociati. Fai click
con il tasto destro del mouse sull'intestazione di Sale e seleziona New report... dal Class menu. Facendo
click sull'icona del Crosstab report si apre il pannello di configurazione del report a campi incrociati (Figura 22.7).
Nell'area Structure of each crosstab devi selezionare l'intestazione per le colonne e le righe del report a campi
incrociati. Ci sono due tipi d'intestazione: il Master header e il Detail header. Dato che vogliamo che il nome del
paese appaia in alto nella tabella, seleziona come Master header per le colonne l'attributo customer_state.
Raggruppiamo ulteriormente le colonne considerando le città nel paese. Per farlo seleziona come Detail header
per le colonne l'attributo customer_city. Ora, dato che vogliamo visualizzare il prodotto acquistato, seleziona
come Master header per le righe l'attributo purchased_product. Non abbiamo bisogno di specificare ulteriori
sottogruppi per le righe. Perciò, seleziona <none> per il Detail header.
131
Creare un report a campi incrociati
Figura 22.7. Pannello di configurazione del crosstab report
In fine, nell'area Statistics seleziona Average come funzione statistica e total_price_paid come attributo
sul quale calcolare le statistiche. Lascia l'orientamento impostato su Portrait. Puoi scrivere un titolo e una
descrizione nei campi corrispondenti (ad esempio Products' average sales e Document reporting
the average sales revenue for each product, city and state, rispettivamente). Quando
hai fatto, chiama il report ProductAvgSales.
22.3. Stampare una versione preliminare del
report
Una volta completata la definizione del formato del report, salva i cambiamenti e chiudi il Designer. Avvia il
Cloudlet e effettua il login. Se fai click sul tab Report, vedrai una nuova icona che rappresenta il report a campi
incrociati che hai definito prima. Per generarlo, fai click sulla sua icona e attendi la preparazione del file PDF. A
scopo illustrativo, il report generato per questo esempio può essere scaricato da qui.
22.4. Raggruppare i dati per paese
Modifichiamo il report ProductAvgSales. Nello specifico, vogliamo visualizzare dati basati sul paese nel
quale il cliente risiede. Fortunatamente, l'informazione sul paese del cliente è già disponibile in Sale grazie
all'attributo derivato customer_state che abbiamo aggiunto in precedenza. Perciò, dobbiamo solo modificare
il formato del report.
Arresta il Cloudlet e apri nuovamente il Designer. Fai click sull'icona del report ProductAvgSales per aprire
il pannello di configurazione del report. Dato che vogliamo dividere i dati in tabelle multiple raggruppate secondo
il paese del cliente, dobbiamo spuntare l'opzione Multiple sections, group by nell'area Grouping sections. Fai click
132
Creare un report a campi incrociati
sull'icona
per aggiungere il campo i cui dati devono essere raggruppati. Seleziona customer_country
(vogliamo una tabella per ogni paese). Poi, dall'altro menu sulla destra seleziona Show section title,
object count and statistics (vogliamo mostrare per ogni tabella il paese e la regione di residenza, il
numero di tipi di prodotto acquistati dai clienti residenti nel paese, e le statistiche sulle vendite medie di prodotti in
ogni stato e città nell'ambito del paese). Lascia inalterate le altre opzioni e fai click sul pulsante OK (Figura 22.8).
Salva i cambiamenti e chiudi il Designer.
Figura 22.8. Il pannello di configurazione del crosstab report
22.5. Stampare il report
Avvia nuovamente il Cloudlet e genera il report ProductAvgSales. Nota come gli stessi dati sulle vendite medie
dei prodotti sono stati suddivisi in due differenti tabelle, una per ogni paese in cui i nostri clienti risiedono. Come
prima, per scopi illustrativi il report generato per questo esempio può essere scaricato da qui.
133
Capitolo 23. Creare grafici
I grafici presentano dati in formato visuale. Livebase offre due tipi di grafici: i grafici a torta e i grafici a barre. Ogni
tipo di grafico è progettato per comunicare un tipo specifico di informazione. Perciò, la scelta fra i due dipende
da quale informazione vuoi mostrare. In generale, i grafici a torta sono usati quando vuoi mostrare proporzioni
mentre i grafici a barre sono usati quando vuoi comparare valori. Questo capitolo descrive come puoi generare
report grafici in Livebase. Per comodità partiamo dal modello e dai dati che abbiamo costruito finora. Il modello
è raffigurato in Figura 23.1.
Figura 23.1. Il diagramma Customer-City-Product-Sales modificato (continua)
23.1. Rappresentare i dati in un grafico a torta
Siamo interessati a sapere (in percentuale) quanti clienti vivono nelle varie città. In questo caso è molto utile
rappresentare i dati in un grafico a torta. L'informazione sulla città nella quale risiedono i nostri clienti è già
disponibile nella classe Customer (nell'attributo di tipo query residence_city).
In Livebase un grafico a torta è definito come un Piechart report. Fai click destro sull'intestazione di Customer
e seleziona New report... dal Class menu. Facendo click sull'icona del grafico a torta si apre il pannello
di configurazione dei grafici a torta (Figura 23.2). Quando definisci una torta, devi specificare come costruire
le sue fette. Dato che i valori da mostrare nel grafico a torta sono le città, in Structure of each chart seleziona
134
Creare grafici
l'attributo residence_city per l'opzione Slice by. La dimensione di ogni fetta è determinata dal numero totale
di clienti residenti nella città. Per questa ragione, seleziona la funzione Count all per l'opzione Slice of each
size from. Infine, visto che siamo interessati semplicemente alla percentuale di clienti che vivono nella città,
seleziona Percentage size per l'opzione Slice label format. Come Chart width e Chart height spunta l'opzione
Force pie to be circular per configurare Livebase in modo da raffigurare una torta circolare. Nel campo Title puoi
scrivere Customers' distribution by city, mentre nel campo Description puoi scrivere una semplice
descrizione come Document reporting the distribution in percentage of customers
by city. Quando hai fatto, rinomina il report in CustomerDistribution. Salva e chiudi il Designer.
Nota
Puoi dividere i dati in grafici multipli raggruppandoli secondo specifici attributi. Per farlo
devi spuntare l'opzione Multiple charts, group by nell'area Number of charts e aggiungere i
campi rispetto ai quali effettuare il raggruppamento. Ad esempio, puoi raffinare ulteriormente la
distribuzione dei clienti raggruppando i dati secondo l'età dei clienti.
Figura 23.2. Pannello di configurazione del piechart report
Stampare il report
Avvia il Cloudlet e effettua il login. Nel tab Report vedrai una nuova icona che rappresenta il grafico a torta
che abbiamo definito in precedenza. Per generarlo, fai click sull'icona e attendi la preparazione del file PDF. A
fini illustrativi il report generato per questo esempio può essere scaricato da qui. Il grafico a torta è stato creato
recuperando i dati dal database del Cloudlet. Il grafico è diviso il fette. Ad ogni fetta corrisponde a un differente
colore. La percentuale è riferita al numero totale di clienti. Per esempio, la maggiore percentuale dei nostri clienti
vive a Denver (12%) e a Salt Lake City (10%), mentre pochi clienti vivono a Detroit (2%).
135
Creare grafici
23.2. Rappresentare i dati in un grafico a
barre
In questa sezione descriveremo l'ultima tipologia di report che è possibile definire in Livebase: il barchart report.
Come detto in precedenza, il grafico a barre è molto utile per comparare valori. Ad esempio, supponiamo di voler
mostrare per ogni prodotto l'età media dei clienti che lo preferiscono.
Modificare il modello
Per costruire il report, abbiamo bisogno di conoscere qual'è il prodotto preferito di un cliente. Come è possibile
vedere in Figura 23.1, questa informazione non è direttamente disponibile nella classe Customer, ma può
essere derivata dalla classe Product. Perciò, aggiungi un nuovo attributo di tipo query in Customer, di
nome preferred_product: trascina name da Product e collegalo a Customer selezionando il percorso
PrefPr.name (Figura 23.3).
Figura 23.3. preferred_product derivato da Product
Costruire il report
Per creare un Bartchart report, fai click con il tasto destro del mouse sull'intestazione di Customer e seleziona
New report... dal Class menu. Facendo click sull'icona del grafico a barre si apre il pannello di
configurazione per i grafici a barre (Figura 23.4). Il campo da visualizzare sull'asse x è impostato nell'area Show
one set of bars for each value of attribute. Per questo esempio, seleziona preferred_attribute dal menu.
Il valore da visualizzare sull'asse y è l'età media dei clienti. Perciò, in Bars displayed for each set of bars seleziona
prima Average e poi age. Imposta Chart width a 400 px e Chart height a 300 px. Configura Orientation su
Portrait. Quando hai fatto, fai click sul pulsante OK e rinomina il report in PreferredProductAvgAge. Salva
e chiudi il Designer.
136
Creare grafici
Nota
Puoi visualizzare barre aggiuntive nel grafico. Per farlo devi aggiungere altri campi nell'area Bars
displayed for each set of bars facendo click sull'icona
cancellare le barre di troppo.
. Al contrario,fai click sull'icona
per
Figura 23.4. Pannello di configurazione del barchart report
Stampare una versione preliminare del report
Come prima, se avvii il Cloudlet ed effettui il login, nel tab Report vedrai una nuova icona che rappresenta il report
grafico a barre che abbiamo definito in precedenze. Per generarlo, fai click sulla sua icona e attendi la preparazione
del file PDF. A fini illustrativi il report generato per questo esempio può essere scaricato da qui.
Raggruppare i dati per città
È utile dividere le preferenze sui prodotti per città. L'informazione sulla città nella quale il cliente vive è già
disponibile nella classe Customer grazie all'attributo di tipo query residence_city che abbiamo aggiunto in
precedenza. Perciò, dobbiamo solo modificare il formato del report PreferredProductAvgAge. Arresta il Cloudlet e
apri nuovamente il Designer. Fai click sull'icona del report PreferredProductAvgAge per aprire il pannello
di configurazione del report. Dato che vogliamo dividere i dati in grafici multipli raggruppati secondo la città dei
clienti, dobbiamo spuntare l'opzione Multiple charts, group by nell'area Number of charts e aggiungere i campi
secondo i quali effettuare il raggruppamento. Fai click sull'icona per aggiungere il campo residence_city
(vogliamo un grafico a barre per ogni città). Ora, dal menu sulla destra seleziona Show section title,
137
Creare grafici
object count and statistics (vogliamo visualizzare, per ogni grafico, la città di residenza, il nome
dei prodotti e l'età media dei clienti che preferiscono un prodotto). lascia le altre opzioni immutate e fai click sul
pulsante OK (Figura 23.5). Salva i cambiamenti e chiudi il Designer.
Figura 23.5. Pannello di configurazione del barchart report modificato
Stampare il report
Avvia nuovamente il Cloudlet e stampa il report PreferredProductAvgAge. Nota come gli stessi dati sulle
preferenze dei clienti sono stati suddivisi in grafici differenti, uno per ogni città nella quale i clienti risiedono.
Come prima, a fini illustrativi il report generato per questo esempio può essere scaricato da qui.
138
Glossario dei termini
Associazione
Relazione semplice tra due classi.
Vedi anche Relazione.
Attributo
Proprietà di una classe avente un valore specifico per ogni oggetto della classe.
Attributo derivato
Attributo di una classe il cui valore è calcolato a partire dal valore di altri
attributi.
Vedi anche Attributo.
Attributo di tipo math
Attributo il cui valore è calcolato mediante un'espressione matematica
contenente riferimenti ad altri attributi.
Attributo di tipo query
Attributo il cui valore è calcolato in base al valore di un attributo in una classe
correlata.
Vedi anche Attributo, Classe, Relazione, Attributo derivato.
Breadcrumb
Ausilio alla navigazione nell'interfaccia utente dell'applicazione generata.
Consente agli utenti di tenere traccia della loro posizione nell'ambito di
una classe. Il breadcrumb è disposto orizzontalmente nella parte superiore
della Livetable o dell'Object editing panel. Il nome deriva dal sentiero delle
molliche di pane lasciato da Hansel e Gretel nella nota favola.
Cambiamento distruttivo
Cambiamento sul modello che comporta perdita di dati (ad esempio,
eliminazione di un attributo che corrisponde ad un campo nel database
contente dei valori).
Carattere
Sequenza di byte che rappresenta ad esempio una lettera a.
Cardinalità
Numero di oggetti associati con un dato elemento.
Vedi anche Cardinalità di classe.
Cardinalità di classe
Numero di oggetti di una data classe che possono esistere simultaneamente.
Classe
Template per gli oggetti che verranno memorizzati nel database.
Classe parte
Classe contenuta in un'altra classe in una composizione.
Vedi anche Composizione, Classe tutto.
Classe tutto
In una composizione, la classe che contiene l'altra.
Vedi anche Composizione, Classe parte.
Cloudlet
Sistema informativo creato con Livebase che può essere gestito e utilizzato
nel cloud.
Composizione
Relazione tra due classi in cui una classe è considerata come parte dell'altra.
Vedi anche Classe tutto, Classe parte.
Composizione ricorsiva
Caso nel quale una classe è coinvolta in una composizione con se stessa.
Vedi anche Composizione.
Condizione filtro avanzato
Una condizione filtro che consiste in un'espressione arbitraria che ritorna un
valore di tipo boolean.
Condizione filtro di base
Una condizione di filtro che consiste in un campo, un operatore e un valore.
139
Glossario dei termini
Dashboard
Pagina principale di Livebase dove è possibile creare e gestire i Cloudlet.
Designer
È l'ambiente di modellazione di Livebase.
Diagramma
Vista di una specifica sezione di un modello.
Espressione regolare
Schema definito per le stringhe utilizzando una sintassi speciale. Maggiori
informazioni sono disponibili su Regular-Expressions.info e Wikipedia.
Flat sheet
Formato speciale di foglio Excel che rappresenta una singola classe main.
Funzione di aggregazione
Funzione usata per calcolare valori singoli sulla base di valori multipli da
classi correlate, ad esempio sum.
Vedi anche Attributo di tipo query.
High severity issue
Problema di allineamento del database che Livebase non può risolvere
automaticamente.
Identificatore
Nome di una parte di un programma, ad esempio first_name. Può
contenere solo lettere, numeri e underscore. Non può cominciare con un
underscore né contenerne due adiacenti (__).
Libreria
Archivio privato di engine pronti all'uso, mostrato nel riquadro Engines della
Dashboard.
Livetable
Componente interattivo di Livebase che unisce un aspetto familiare a tabella
con un insieme di funzionaità avanzate di business-intelligence (quali ad
esempio aggregazioni multi-livello, statistiche, definizione e applicazione di
filtri, elaborazione e visualizzazione di diagrammi, ecc.).
Low severity issue
Problema di allineamento del database che Livebase può risolvere
automaticamente senza alcuna perdita di dati.
Medium severity issue
Problema di allineamento del database che Livebase può risolvere
automaticamente ma solo con perdita di dati.
Object editing panel
Panello di una applicazione Livebase che consente di inserire in valori per un
oggetto di una classe.
Palette toolbar
Barra degli strumenti del Designer che contiene una serie di bottoni che
corrispondono ad elementi e funzionalità per disegnare un modello.
Partizionamento orizzontale
Restrizione dell'accesso a record (righe) di specifiche tabelle nel database
ottenuta definendo dei filtri sulle corrispondenti classi nell'Application
Schema di un modello.
Vedi anche Partizionamento verticale.
Partizionamento verticale
Restrizione dell'accesso a tabelle e colonne del database ottenuta disabilitando
attributi specifici e classi nell'Application Schema di un modello.
Vedi anche Partizionamento orizzontale.
Reference sheet
Formato speciale di foglio Excel che consente di creare nuove classi nel
modello e associarle a classi già esistenti. È una generalizzazione del formato
Star sheet.
Relation sheet
Formato speciale di foglio Excel che consente di definire associazioni tra
oggetti.
140
Glossario dei termini
Relazione
Relazione definita tra due classi, ad esempio un'associazione bidirezionale.
Vedi anche Classe, Cardinalità.
Restrizione sul dominio
Un insieme di restrizioni sull'insieme dei possibili valori per un attributo, ad
esempio intervallo [ 5 .. 10 ] per un attributo di tipo intero.
Ruolo
Rappresentazione di una classe in un dato contesto, ad esempio in una
relazione con un altra classe.
Vedi anche Classe, Relazione.
Ruolo di sistema
Rappresentazione di una classe nell'ambito del modello nel suo complesso.
Vedi anche Ruolo.
Star sheet
Formato speciale di foglio Excel che rappresenta una singola classe main con
almeno una classe satellite.
Trash
Pannello della Dashboard che viene utilizzato per eliminare gli elementi
(Cloudlet, engine, database).
141