id
stringlengths 9
42
| content
stringlengths 221
38.3k
| summary
stringlengths 0
1.44k
| layer
stringclasses 2
values |
|---|---|---|---|
SMOS1.txt |
Nome: Login
Attori: Utente registrato
Descrizione: Permette ad un utente di loggarsi al sistema
Precondizioni:
L’utente non è loggato al sistema L’utente possiede username e password Compila e sottomette il form per il login
Sequenza degli eventi
Utente
Sistema
1. Verifica che username e password abbiano lunghezza >=5. Se la condizione è rispettata passa al punto due, altrimenti notifica l'errore all'utente.
2. Cerca nell’archivio se username e password inseriti dall’utente sono presenti tra gli utenti loggabili
3. Se la ricerca ha avuto successo l’utente viene loggato al sistema
Postcondizioni:
• Il sistema visualizza l’area di lavoro dell’Utente Registrato • Interruzione della connessione al server SMOS | Use Case |
|
SMOS10.txt | Nome: Assegna/RimuoviRuoliAdUnUtente
Attori: Amministratore
Descrizione: Consente di assegnare o rimuovere ruoli ad un utente
Precondizioni:
• L’utente è loggato come amministratore • L’utente ha svolto il caso d’uso “VisualizzaDettagliUtente” e il sistema sta
visualizzando i dettagli di un utente • L’utente clicca sul pulsante “Ruoli Utente”
Sequenza degli eventi
Utente
2. Seleziona i ruoli da assegnare o rimuovere all’utente
3. Clicca sul pulsante “Invia”
Sistema
1. Visualizza il form di gestione dei ruoli
4. Assegna o rimuove i ruoli dell’utente come indicato dall’Amministratore
Postcondizioni:
• • •
Sono modificati i ruoli dell’utente L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS11.txt | Nome: Assegna/RimuoviInsegnamentiAdUnDocente
Attori: Amministratore
Descrizione: Consente di assegnare o rimuovere insegnamenti ad un docente
Precondizioni:
• L’utente è loggato come amministratore • L’utente ha svolto il caso d’uso “VisualizzaDettagliUtente” e il sistema sta
visualizzando i dettagli di un docente • L’utente clicca sul pulsante “Insegnamenti Docente”
Sequenza degli eventi
Utente
2. Seleziona l'anno accademico
4. Seleziona la classe desiderata
6. Seleziona gli insegnamenti da associare o rimuovere al docente
Sistema
1. Visualizza il form di gestione degli insegnamenti per il docente in oggetto
3. Visualizza l'elenco delle classi disponibili per l'anno selezionato
5. Visualizza l'elenco degli insegnamenti associati a quella classe
7. Assegna o rimuove gli insegnamenti del docente come indicato dall’Amministratore
Postcondizioni:
• • •
Sono stati assegnati o rimossi uno o più insegnamenti al docente L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS12.txt | Nome: Assegna/RimuoviStudentiAdUnGenitore
Attori: Amministratore
Descrizione: Consente di associare nuovi studenti ad un genitore o di rimuovere le associazioni precedentemente inserite
Precondizioni:
• L’utente è loggato come amministratore • L’utente ha svolto il caso d’uso “VisualizzaDettagliUtente” e il sistema sta
visualizzando i dettagli di un genitore • L’utente clicca sul pulsante “Parentela”
Sequenza degli eventi
Utente
2. Selezione gli studenti da assegnare o rimuovere al genitore
3. Clicca sul pulsante “Invia”
Sistema
1. Visualizza il form di gestione dei figli per il genitore in oggetto
4. Assegna/Rimuove gli studenti associati ad un Genitore
Postcondizioni:
• • •
Sono stati associati o rimossi una o più figli ad un genitore. L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS13.txt | Nome: VisualizzaElencoClassi
Attori: Amministratore
Descrizione: Permette di visualizzare l’elenco delle classi
Precondizioni:
• L’utente è loggato al sistema con il ruolo di Amministratore • L’utente clicca sul pulsante “Gestione Classi”
Sequenza degli eventi
Utente
2. Seleziona l’anno accademico di interesse.
Sistema
1. Permette di selezionare l’anno accademico di cui si vuole visualizzare l’elenco delle classi.
3. Cerca le classi nell’archivio e visualizza la schermata di gestione delle classi
4. Visualizza l’elenco delle classi dell’anno accademico selezionato.
Postcondizioni:
• • •
Il sistema mostra l’elenco delle classi dell’anno accademico selezionato. L’Amministratore interrompe le operazioni. Connessione al server SMOS interrotta | Use Case |
|
SMOS14.txt | Nome: InserisciNuovaClasse
Attori: Amministratore
Descrizione: Inserisce una nuova classe nell’archivio
Precondizioni:
• L’utente è loggato al sistema come Amministratore • L’utente ha già eseguito il caso d’uso “VisualizzaElencoClassi” e il sistema
sta visualizzando l’elenco delle classi di un particolare anno accademico. • L’ utente clicca sul pulsante “Nuova Classe”
Sequenza degli eventi
Utente
2. Compila il form 3. Clicca sul pulsante “Salva”
Sistema
1. Il sistema mostra il form da compilare con: nome, indirizzo, anno accademico.
4. Effettua dei controlli sulla validità dei dati immessi e inserisce la nuova classe nell’archivio; nel caso in cui i dati inseriti non sono validi, attiva il caso d’uso “ErroreDati”.
Postcondizioni:
• • • •
L’utente ha inserito una classe nel sistema E’ notificato l’errore dati Connessione al server SMOS interrotta L’Amministratore interrompe l’operazione | Use Case |
|
SMOS15.txt | Nome:VisualizzaDettagliClasse
Attori: Amministratore
Descrizione: Permette di visualizzare i dettagli di una classe
Precondizioni:
• L’utente ha già effettuato il login • L’utente ha già eseguito il caso d’uso “VisualizzaElencoClassi” e il sistema
sta visualizzando l’elenco delle classi di un anno accademico • Clicca sul pulsante “mostra dettagli classe”
Sequenza degli eventi
Utente
Sistema
1. Visualizza la scherma con i dettagli di una singola classe: nome, indirizzo, anno scolastico.
Postcondizioni:
• L’utente visualizza le informazioni dettagliate relative ad una classe. • Connessione al server SMOS interrotta | Use Case |
|
SMOS16.txt | Nome: EliminaClasse
Attori: Amministratore
Descrizione: Elimina una classe dall’archivio
Precondizioni:
• • • •
L’utente è loggato al sistema come Amministratore L’utente ha eseguito il caso d’uso “VisualizzaDettagliClasse” L’utente visualizza le informazione dettagliate di una classe L’utente Clicca sul pulsante “Elimina”
Sequenza degli eventi
Utente
Sistema
1. Elimina la classe dall’archivio
2. Visualizza l’elenco delle classi aggiornato
Postcondizioni:
• L’utente ha eliminato una classe • Connessione al server SMOS interrotta | Use Case |
|
SMOS17.txt | Nome: VisualizzaElencoIndirizzi
Attori: Amministratore
Descrizione: Permette di visualizzare l’elenco degli Indirizzi
Precondizioni:
• L’utente è loggato al sistema con il ruolo di Amministratore • L’utente clicca sul pulsante “Gestione Indirizzi”
Sequenza degli eventi
Utente
Sistema
1. Visualizza l’elenco degli indirizzi.
Postcondizioni:
• Il sistema mostra l’elenco degli indirizzi presenti nell’archivio • Connessione al server SMOS interrotta | Use Case |
|
SMOS18.txt | Nome: InserisciNuovoIndirizzo
Attori: Amministratore
Descrizione: Inserisce un nuovo indirizzo nell’archivio
Precondizioni:
• •
•
L’utente è loggato al sistema come Amministratore L’utente ha già eseguito il caso d’uso “VisualizzaElencoIndirizzi” e il sistema sta visualizzando l’elenco degli indirizzi L’utente clicca sul pulsante “Nuovo Indirizzo”
Sequenza degli eventi
Utente
2. Compila il form 3. Clicca sul pulsante “Salva”
Sistema
1. Il sistema mostra il form da compilare con: nome indirizzo.
4. Effettua dei controlli sulla validità dei dati immessi e inserisce un nuovo indirizzo nell’archivio; nel caso in cui i dati inseriti non sono validi, attiva il caso d’uso “ErroreDati”.
Postcondizioni:
• • • •
L’utente ha inserito un indirizzo Viene notificato l’errore dati Connessione al server SMOS interrotta L’Amministratore interrompe l’operazione | Use Case |
|
SMOS19.txt | Nome:VisualizzaDettagliIndirizzo
Attori: Amministratore
Descrizione: Permette di visualizzare i dettagli di un indirizzo
Precondizioni:
• •
•
L’utente ha già effettuato il login L’utente ha già eseguito il caso d’uso “VisualizzaElencoIndirizzi” e il sistema sta visualizzando l’elenco degli indirizzi L’utente clicca sul pulsante “mostra dettagli indirizzo”
Sequenza degli eventi
Utente
Sistema
1. Visualizza la schermata con i dettagli di un singolo indirizzo; in particolare :nome indirizzo.
Postcondizioni:
• L’utente visualizza le informazioni dettagliate relative ad un singolo indirizzo.
• Connessione al server SMOS interrotta Connessione al server SMOS interrotta | Use Case |
|
SMOS2.txt | Nome: LoginErrato
Attori: Utente registrato
Descrizione: Si verifica quando l’utente ha inserito dati di autenticazione errati.
Precondizioni:
• I dati forniti per il login non sono corretti
Sequenza degli eventi
Utente
Sistema
1. Visualizza il form di login
Postcondizioni:
• L’utente può riprovare ad effettuare il login | Use Case |
|
SMOS20.txt | Nome: EliminaIndirizzo
Attori: Amministratore
Descrizione: Elimina un indirizzo dall’archivio
Precondizioni:
• • • •
L’utente è loggato al sistema come Amministratore L’utente ha eseguito il caso d’uso “VisualizzaDettagliIndirizzo” L’utente visualizza le informazione dettagliate di un indirizzo L’utente clicca sul pulsante “Elimina”
Sequenza degli eventi
Utente
Sistema
1. Verifica se l'indirizzo ha classi associate; in caso affermativo mostra un messaggio di errore “Impossibile eliminare l'indirizzo, cancellare le classi associate e riprovare”, altrimenti elimina l'indirizzo.
2. Visualizza l’elenco degli indirizzi aggiornato
Postcondizioni:
• L’utente ha eliminato un indirizzo • Connessione al server SMOS interrotta | Use Case |
|
SMOS21.txt | Nome:AssegnaRimuoviInsegnamenti
Attori: Amministratore
Descrizione: Assegna o rimuove uno o più insegnamenti da un indirizzo
Precondizioni:
• • • •
L’utente è loggato al sistema come Amministratore L’utente ha eseguito il caso d’uso “VisualizzaDettagliIndirizzo” L’utente visualizza le informazione dettagliate di un indirizzo L’utente clicca sul pulsante “Insegnamenti Indirizzo”
Sequenza degli eventi
Utente
2. Seleziona gli insegnamenti da assegnare o rimuovere all’indirizzo
3. Clicca sul pulsante “Invia”
Sistema
1. Visualizza un form da cui è possibile aggiungere e/o rimuovere insegnamenti all’indirizzo.
4. Associa o rimuove gli insegnamenti selezionati all’indirizzo.
5. Torna alla visualizzazione dei dettagli dell’indirizzo.
Postcondizioni:
• • •
L’Amministratore interrompe l’operazione Connessione al server SMOS interrotta Il sistema ha modificato gli insegnamenti relativi all’indirizzo | Use Case |
|
SMOS22.txt | Nome: VisualizzaElencoInsegnamenti
Attori: Amministratore
Descrizione: Permette di visualizzare l’elenco degli insegnamenti
Precondizioni:
• L’utente è loggato al sistema con il ruolo di Amministratore • L’utente clicca sul pulsante “Gestione Insegnamenti”
Sequenza degli eventi
Utente
Sistema
1.
2.
Cerca gli nell’archivio e schermata di insegnamenti
Visualizza insegnamenti
insegnamenti visualizza la gestione degli
l’elenco degli
Postcondizioni:
• Il sistema mostra l’elenco degli insegnamenti presenti nell’archivio • Connessione al server SMOS interrotta | Use Case |
|
SMOS23.txt | Nome:InserisciNuovoInsegnamento
Attori: Amministratore
Descrizione: Inserisce un nuovo insegnamento nell’archivio
Precondizioni:
• L’utente è loggato al sistema come Amministratore • L’utente ha già eseguito il caso d’uso “VisualizzaElencoInsegnamenti” e il
sistema sta visualizzando l’elenco degli insegnamenti • L’utente clicca sul pulsante “Nuovo Insegnamento”
Sequenza degli eventi
Utente
2. Compila il form 3. Clicca sul pulsante “Salva”
Sistema
1. Il sistema mostra il form da compilare con: nome insegnamento.
4. Effettua dei controlli sulla validità dei dati immessi e inserisce il nuovo insegnamento nell’archivio; nel caso in cui i dati inseriti non sono validi, attiva il caso d’uso “ErroreDati”.
Postcondizioni:
• • • •
L’utente ha inserito un insegnamento Viene notificato l’errore Connessione al server SMOS interrotta L’Amministratore interrompe l’operazione | Use Case |
|
SMOS24.txt | Nome:VisualizzaDettagliInsegnamento
Attori: Amministratore
Descrizione: Permette di visualizzare i dettagli di un insegnamento
Precondizioni:
• L’utente ha già effettuato il login • L’utente ha già eseguito il caso d’uso “VisualizzaElencoInsegnamenti” e il
sistema sta visualizzando l’elenco degli insegnamenti • L’utente clicca sul pulsante “dettagli insegnamento”
Sequenza degli eventi
Utente
Sistema
1. Visualizza la schermata con i dettagli di un singolo insegnamento.
Postcondizioni:
• L’utente visualizza le informazioni dettagliate di un singolo insegnamento • Connessione al server SMOS interrotta | Use Case |
|
SMOS25.txt | Nome:ModificaInsegnamento
Attori: Amministratore
Descrizione: Modifica dettagli di un insegnamento
Precondizioni:
• L’utente è loggato al sistema come Amministratore • L’utente ha eseguito il caso d’uso “VisualizzaDettagliInsegnamento” • L’utente visualizza le informazione dettagliate di un insegnamento • L’utente modifica una delle informazioni contenute nel form di
visualizzazione dei dettagli dell’insegnamento
Sequenza degli eventi
Utente
Sistema
1. Clicca sul pulsante “Salva”
2. Effettua dei controlli sulla validità dei dati immessi e modifica l’insegnamento nell’archivio; nel caso in cui i dati inseriti non sono validi, attiva il caso d’uso “ErroreDati”.
3. Visualizza l’elenco degli insegnamenti aggiornato
Postcondizioni:
• • • •
L’utente ha modificato un insegnamento Viene notificato l’errore dati Connessione al server SMOS interrotta L’Amministratore interrompe l’operazione | Use Case |
|
SMOS26.txt | Nome: EliminaInsegnamento
Attori: Amministratore
Descrizione: Elimina un insegnamento dall’archivio
Precondizioni:
• • • •
L’utente è loggato al sistema come Amministratore L’utente ha eseguito il caso d’uso “VisualizzaDettagliInsegnamento” L’utente visualizza le informazione dettagliate di un insegnamento L’utente clicca sul pulsante “Elimina”
Sequenza degli eventi
Utente
Sistema
1. Elimina l’insegnamento dall’archivio
2. Visualizza l’elenco degli insegnamenti aggiornato
Postcondizioni:
• L’utente ha eliminato un insegnamento • Connessione al server SMOS interrotta | Use Case |
|
SMOS27.txt | Nome: VisualizzaElencoRegistri
Attori: Amministratore
Descrizione: Visualizza l’elenco dei registri per un anno accademico
Precondizioni:
• L'utente deve essere loggato al sistema come Amministratore • Clicca sul pulsante “Registro Digitale”
Sequenza degli eventi
Utente
Sistema
2. Seleziona l’anno scolastico
1. Mostra una schermata per la selezione dell’anno accademico di interesse.
3. Cerca nell’archivio tutti i registri digitali di quell’anno e li visualizza associati alla classe cui appartengono.
Postcondizioni:
•
• •
Il sistema sta visualizzando l’elenco dei registri riferiti ad un particolare anno accademico L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS28.txt | Nome: VisualizzaDettagliSingoloRegistro
Attori: Amministratore
Descrizione: Visualizza i dettagli di uno dei registri di classe
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L’utente deve aver svolto il caso d’uso “VisualizzaElencoRegistri” Clicca sul pulsante “Dettagli” associato ad uno dei registri.
Sequenza degli eventi
Utente
Sistema
1. Visualizza a video le informazioni contenute nel registro organizzate per data. In particolare mostra, per la data odierna, l’elenco degli alunni, specificando: assenti/presenti, entrate in ritardo ed un form dal quale è possibile gestire giustifiche e note disciplinari.
Postcondizioni:
• Il sistema sta visualizzando i dettagli di un registro di classe • Connessione al server SMOS interrotta | Use Case |
|
SMOS29.txt | Nome: InserisciAssenzeAdmin
Attori: Amministratore
Descrizione: Digitalizzazione del Registro, inserimento dati da parte dell’Amministratore
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d’uso “VisualizzaDettagliSingoloRegistro” Seleziona la data in cui vuole inserire le informazioni.
Sequenza degli eventi
Utente
Sistema
2. Compila il form inserendo studenti assenti/presenti e clicca “Salva”
1. Aggiorna la schermata visualizzata in base alla data
3. Invia i dati al server. Il server per ogni assenza invia una e-mail di notifica al genitore dell'alunno.
4. Visualizza i dati del registro aggiornati.
Postcondizioni:
• I dati di assenze e ritardi sono stati inseriti nel sistema, ed il sistema ha inviato le notifiche ai genitori. Il sistema rimane sulla schermata del registro.
• L’amministratore interrompe l’operazione. • Connessione al server SMOS interrotta. | Use Case |
|
SMOS3.txt | Nome: Logout
Attori: Utente registrato
Descrizione: Permette ad un utente di uscire dal sistema
Precondizioni:
• L’utente è loggato al sistema • Clicca sul pulsante di logout
Sequenza degli eventi
Utente
Sistema
1. Visualizza il form di login
Postcondizioni:
• L’utente può nuovamente loggarsi al sistema | Use Case |
|
SMOS30.txt | Nome: InserisciRitardiAdmin
Attori: Amministratore
Descrizione: Digitalizzazione del Registro, inserimento dati da parte dell’Amministratore
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d’uso “VisualizzaDettagliSingoloRegistro” Seleziona la data in cui vuole inserire le informazioni.
Sequenza degli eventi
Utente
Sistema
2. Compila il form inserendo studenti con ritardo e clicca “Salva”
1. Aggiorna la schermata visualizzata in base alla data
3. Invia i dati al server.
4. Visualizza i dati del registro aggiornati.
Postcondizioni:
• I dati dei ritardi sono stati inseriti nel sistema, ed il sistema ha inviato le notifiche ai genitori. Il sistema rimane sulla schermata del registro.
• L’amministratore interrompe l’operazione. • Connessione al server SMOS interrotta. | Use Case |
|
SMOS31.txt | Nome: ModificaAssenza
Attori: Amministratore
Descrizione: Modifica delle assenze da parte dell'Amministratore. La modifica è da intendersi come inserimento/cancellazione dell’assenza.
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “VisualizzaDettagliSingoloRegistro” Seleziona la data in cui desidera modificare un’assenza
Sequenza degli eventi
Utente
Sistema
2. Modifica l'assenza (Inserisce o Elimina) e clicca “Salva”
1. Aggiorna la schermata in base alla data selezionata
3. Invia i dati modificati al server. Il sistema invia una e-mail di rettifica al genitore dell'alunno.
Postcondizioni:
• Il sistema ha modificato l'assenza selezionata ed ha inviato ai genitori una notifica della modifica. Il sistema rimane sulla schermata del registro.
• L’amministratore interrompe l’operazione • Connessione al server SMOS interrotta | Use Case |
|
SMOS32.txt | Nome: ModificaRitardo
Attori: Amministratore
Descrizione: modifica di un ritardo da parte dell'Amministratore
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d’uso “VisualizzaDettagliSingoloRegistro” Seleziona la data in cui desidera modificare il ritardo
Sequenza degli eventi
Utente
Sistema
2. L'utente modifica il ritardo e clicca su “Salva”
1. Aggiorna la schermata in base alla data selezionata
3. Il sistema invia i dati modificati al server .
Postcondizioni:
• Il sistema ha modificato i ritardi alla data inserita. Il sistema rimane sulla schermata del registro.
• L’amministratore interrompe l’operazione • Connessione al server SMOS interrotta | Use Case |
|
SMOS33.txt | Nome: EliminaRitardo
Attori: Amministratore
Descrizione: Eliminazione di un ritardo da parte dell'Amministratore
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “VisualizzaDettagliSingoloRegistro” Seleziona la data in cui desidera eliminare un ritardo.
Sequenza degli eventi
Utente
Sistema
2. Elimina l’entrata in ritardo di uno studente e clicca “Salva”
1. Aggiorna la schermata in base alla data selezionata
3. Elimina l’entrata in ritardo dall’archivio.
Postcondizioni:
• Il sistema ha eliminato il ritardo. Il sistema rimane sulla schermata del registro.
• L’amministratore interrompe l’operazione • Connessione al server SMOS interrotta | Use Case |
|
SMOS34.txt | Nome: VisualizzaElencoGiustifiche
Attori: Amministratore
Descrizione: Visualizza i l'elenco delle giustifiche
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “VisualizzaDettagliSingoloRegistro” Clicca il tasto “Giustifiche” relativo ad un alunno
Sequenza degli eventi
Utente
Sistema
1. Mostra tutte le assenze dell'alunno
registrate scolastico selezionato Le assenze già giustificate vengono
visualizzate in verde, quelle da giustificare in rosso
durante l'anno
Postcondizioni:
• • •
Il sistema sta visualizzando l'elenco delle giustifiche inerenti allo studente L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS35.txt | Nome: VisualizzaElencoNote
Attori: Amministratore
Descrizione: Visualizza l'elenco delle note inerente allo studente
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “VisualizzaDettagliSingoloRegistro” Clicca sul pulsante “Note” associato ad uno studente
Sequenza degli eventi
Utente
Sistema
1. Mostra tutte le note dell'alunno registrate durante l'anno scolastico
Postcondizioni:
• • •
Il sistema sta visualizzando l'elenco note riferite allo studente L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS36.txt | Nome: InserisciGiustifica
Attori: Amministratore
Descrizione: Inserimento Giustifica
Precondizioni:
• • • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “VisualizzaDettagliSingoloRegistro” L'utente ha svolto il caso d'uso “VisualizzaElencoGiustifiche” L'utente clicca su una delle assenze in rosso
Sequenza degli eventi
Utente
Sistema
2. Compila il form 3. Clicca su “Salva”
1. Mostra un form in cui inserire i campi della giustifica (data giustifica).
4. Salva la giustifica.
Postcondizioni:
• I dati della giustifica sono stati inseriti nel sistema. Il sistema ritorna alla schermata del registro.
• L’amministratore interrompe l’operazione • Connessione al server SMOS interrotta | Use Case |
|
SMOS37.txt | Nome: InserisciNota
Attori: Amministratore
Descrizione: Inserimento Note Disciplinari
Precondizioni:
• • • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “VisualizzaDettagliSingoloRegistro” L'utente ha già svolto il caso d'uso “VisualizzaElencoNote” L'utente clicca sul pulsante “Nuova nota”
Sequenza degli eventi
Utente
Sistema
2. Compila il form 3. Clicca su “Salva”
1. Mostra un form con i campi della nota (studente, data, docente , descrizione).
4. Salva la nota e invia una notifica via e-mail al genitore
Postcondizioni:
•
• •
I dati della nota sono stati inseriti nel sistema, ed il sistema ha inviato la notifica ai genitori. Il sistema ritorna alla schermata del registro. L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS38.txt | Nome: VisualizzaDettagliGiustifica
Attori: Amministratore
Descrizione: Visualizza i dettagli di una giustifica
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “VisualizzaElencoGiustifiche” Clicca su una delle assenze in verde
Sequenza degli eventi
Utente
Sistema
1. Mostra un form con i dettagli della giustifica e la possibilità di modificare o eliminare la giustifica.
Postcondizioni:
• • •
Il sistema sta visualizzando i dettagli di una giustifica. L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS39.txt | Nome: VisualizzaDettagliNota
Attori: Amministratore
Descrizione: Visualizza i dettagli di una nota
Precondizioni:
• • •
L'utente deve essere loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “VisualizzaElencoNote” Clicca sul pulsante “dettagli” associato ad una delle note
Sequenza degli eventi
Utente
Sistema
1. Mostra un form con i dettagli della nota: alunno, descrizione, docente, data.
Postcondizioni:
• • •
Il sistema sta visualizzando i dettagli di una nota. L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS4.txt | Nome: ModificaPassword
Attori: Utente registrato
Descrizione: Permette ad un utente di modificare la propria password
Precondizioni:
• L’utente è loggato al sistema • Clicca sul pulsante “Modifica Password”
Sequenza degli eventi
Utente
2. Compila il form e sottomette;
Sistema
1. Visualizza il form con i campi: vecchia password, nuova password, conferma nuova password.
3. Conferma l’avvenuta modifica della password
Postcondizioni:
• • •
La password dell’utente è stata modificata L’utente annulla l’operazione Interruzione della connessione al server SMOS | Use Case |
|
SMOS40.txt | Nome: ModificaGiustifica
Attori: Amministratore
Descrizione: Modifica di una Giustifica
Precondizioni:
• L'utente deve essere loggato al sistema come Amministratore • L'utente ha svolto il caso d'uso “VisualizzaDettagliGiustifica” e il sistema sta
visualizzando i dettagli di una giustifica
Sequenza degli eventi
Utente
Sistema
1. Modifica uno o più campi del form visualizzato: data giustifica.
2. Clicca su “Salva”
3. Modifica la giustifica.
Postcondizioni:
• • •
La giustifica è stata modificata. Il sistema ritorna alla schermata del registro. L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS41.txt | Nome: ModificaNota
Attori: Amministratore
Descrizione: Modifica di una Nota Disciplinare
Precondizioni:
• L'utente deve essere loggato al sistema come Amministratore • L'utente ha svolto il caso d’uso “VisualizzaDettagliNota”
Sequenza degli eventi
Utente
Sistema
1. L'utente modifica uno o più campi del form visualizzato: Studente, descrizione, docente, data.
2. L'utente clicca su “Salva”
3. Il sistema salva le modifiche
Postcondizioni:
• I dati della nota sono stati modificati. Il sistema ritorna alla schermata del registro.
• L’amministratore interrompe l’operazione • Connessione al server SMOS interrotta | Use Case |
|
SMOS42.txt | Nome: EliminaGiustifica
Attori: Amministratore
Descrizione: Elimina Giustifica
Precondizioni:
• L'utente deve essere loggato al sistema come Amministratore • L'utente ha svolto il caso d'uso “VisualizzaDettagliGiustifica” e il
sistema sta visualizzando i dettagli di una giustifica. • Clicca su “Elimina”
Sequenza degli eventi
Utente
Sistema
1. Elimina la giustifica.
Postcondizioni:
• La giustifica è stata eliminata dal sistema. Il sistema ritorna alla schermata del registro.
• L’amministratore interrompe l’operazione • Connessione al server SMOS interrotta | Use Case |
|
SMOS43.txt | Nome: EliminaNota
Attori: Amministratore
Descrizione: Eliminazione Note Disciplinari
Precondizioni:
• L'utente deve essere loggato al sistema come Amministratore • L'utente ha svolto il caso d'uso “VisualizzaDettagliNota” e il sistema sta
visualizzando I dettagli di una nota • L'utente clicca il pulsante “Elimina”
Sequenza degli eventi
Utente
Sistema
1. Il sistema invia una notifica di errata corrige ai genitori dello studente, poi elimina i dati della nota dall’archivio.
Postcondizioni:
• La nota è stata cancellata, ed il sistema ha inviato la notifica ai genitori. Il sistema ritorna alla schermata del registro.
• L’amministratore interrompe l’operazione • Connessione al server SMOS interrotta | Use Case |
|
SMOS44.txt | Nome: EffettuaMonitoraggioStudenti
Attori: Amministratore
Descrizione: Consente di interrogare il sistema circa il numero di assenze e note associate agli studenti
Precondizioni:
• L’utente è loggato al sistema come amministratore • L’utente clicca sul pulsante “Monitoraggio Studenti”
Sequenza degli eventi
Utente
Sistema
1. Cerca nell'archivio gli studenti che abbiano, per l'anno scolastico in corso un numero di assenze e note superiori ad una soglia prestabilita.
2. Visualizza una schermata di presentazione dei dati ottenuti.
Postcondizioni: :
• Sono state le informazioni circa assenze e note degli alunni. • Connessione al server SMOS interrotta. | Use Case |
|
SMOS45.txt | Nome: VisualizzazioneDiUnaPagella
Attori: Amministratore
Descrizione: Visualizzazione di una pagella
Precondizioni:
• L'utente si è loggato al sistema come Amministratore • L’utente clicca sul pulsante “Pagelle online”
Sequenza degli eventi
Utente
1. Seleziona l’anno accademico
3. Sceglie la classe dell'alunno di cui vuole visualizzare la pagella
5. Seleziona l'alunno e il quadrimestre di cui visualizzare la pagella cliccando sul relativo pulsante.
Sistema
2. Visualizza l’elenco delle classi presenti nel sistema con accanto un pulsante “Pagelle” associato ad ogni classe
4. Visualizza l'elenco degli alunni della classe scelta dall'utente
6. Visualizza la pagella dell'alunno scelto riferita al quadrimestre selezionato.
Postcondizioni:
• • •
Il sistema visualizza la pagella di uno studente L’utente interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS46.txt | Nome: InserimentoPagella
Attori: Amministratore
Descrizione: Inserimento di una pagella di uno studente eseguito dall’Amministratore
Precondizioni:
• L'utente si è loggato al sistema come Amministratore • L’utente clicca sul pulsante “Pagelle online”
Sequenza degli eventi
Utente
2. Sceglie la classe dell'alunno di cui inserire la pagella
4. Seleziona l'alunno a cui inserire la pagella cliccando sul relativo tasto
6. Inserisce i voti della pagella, tutti o in parte, e clicca sul tasto “salva”
Sistema
1. Visualizza l’elenco delle classi presenti nel sistema riferito all’anno accademico in corso con accanto un pulsante “Pagelle” associato ad ogni classe
3. Visualizza l'elenco degli alunni della classe scelta dall'utente
5. Visualizza il form per l'inserimento di una pagella
7. Inserisce i voti inseriti nell'archivio e riporta l'utente alla pagina di visualizzazione degli studenti della classe.
Postcondizioni:
• • •
Nel sistema è stata aggiunta la pagella relativa ad un alunno. L’utente interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS47.txt | Nome: ModificaDiUnaPagella
Attori: Amministratore
Descrizione: Caso d’uso per modificare la pagella di un alunno
Precondizioni:
• • •
L'utente si è loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “VisualizzazioneDiUnaPagella ” L’utente clicca sul tasto di modifica
Sequenza degli eventi
Utente
2. Inserisce i nuovi dati e clicca il tasto di conferma
Sistema
1. Visualizza il form con i campi da poter modificare tra cui i voti delle diverse materie
3. Il sistema visualizza un messaggio di conferma e visualizza il form con l'elenco degli alunni
Postcondizioni:
• • •
Una pagella relativa ad un alunno viene modificata L’utente interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS48.txt | Nome: CancellazioneDiUnaPagella
Attori: Amministratore
Descrizione: L’Amministratore elimina una pagella dal sistema
Precondizioni:
• • •
L'utente si è loggato al sistema come Amministratore L'utente ha svolto il caso d'uso “Visualizzazione di una pagella” L’utente clicca sul tasto “cancella”
Sequenza degli eventi
Utente
2. L'utente accetta la cancellazione premendo il tasto di conferma
Sistema
1. Il sistema visualizza un form per confermare la cancellazione
3. Visualizza un messaggio di corretta cancellazione e visualizza il form con l'elenco delle classi
Postcondizioni:
• Una pagella relativa ad un alunno viene cancellata • Connessione al server SMOS interrotta | Use Case |
|
SMOS49.txt | Nome: VisualizzaRichiesteDiIscrizione
Attori: Amministratore
Descrizione: Consente all'amministratore di visualizzare l'elenco delle richieste di iscrizione giunte al sistema
Precondizioni:
• L'utente è loggato al sistema come amministratore • L'utente clicca sul pulsante “Visualizza Elenco Richieste di Iscrizione”
presente nella home
Sequenza degli eventi
Utente
Sistema
1 . Visualizza l'elenco delle iscrizioni ancora da attivare.
Postcondizioni:
•
• •
L’utente sta visualizzando l'elenco di richieste di iscrizione al sistema da parte degli studenti L'utente interrompe l'operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS5.txt | Nome: VisualizzaElencoUtenti
Attori: Amministratore
Descrizione: Visualizza l’elenco degli utenti presenti nel sistema
Precondizioni:
• L’utente è loggato come amministratore • L’utente clicca sul pulsante “Gestione Utenti”
Sequenza degli eventi
Utente
Sistema
1. Cerca gli utenti nell’archivio e ne visualizza l’elenco
Postcondizioni:
• Il sistema visualizza l’elenco degli utenti presenti nel sistema • Connessione al server SMOS interrotta | Use Case |
|
SMOS50.txt | Nome: AccettaIscrizioneStudente
Attori: Amministratore
Descrizione: Consente all'amministratore di accettare l'iscrizione al sistema di uno studente
Precondizioni:
• L'utente ha già svolto il caso d'uso “Visualizza Richieste di Iscrizione” • L'utente clicca sul pulsante “Accetta” associato ad una richiesta di iscrizione
Sequenza degli eventi
Utente
Sistema
1 . Attiva il nuovo utente nel sistema.
2. Visualizza l'elenco delle iscrizioni ancora da attivare
Postcondizioni:
• • •
L’utente ha accettato una richiesta di iscrizione al sistema L'utente interrompe l'operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS51.txt | Nome: RifiutaIscrizioneStudente
Attori: Amministratore
Descrizione: Consente all'amministratore di rifiutare l'iscrizione al sistema di uno studente
Precondizioni:
• L'utente ha già svolto il caso d'uso “Visualizza Richieste di Iscrizione” • L'utente clicca sul pulsante “Rifiuta” associato ad una richiesta di iscrizione
Sequenza degli eventi
Utente
Sistema
1. Elimina la richiesta di iscrizione al sistema.
2. Visualizza l'elenco delle iscrizioni ancora da attivare
Postcondizioni:
• • •
L’utente ha rifiutato una richiesta di iscrizione al sistema L'utente interrompe l'operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS52.txt | Nome: Ricerca EntitaAttori: Amministratore
Descrizione: Consente all'amministratore di ricercare nel sistema tutte le entità caratterizzate dalle keywords inserite
Precondizioni:
• L'utente è loggato al sistema come amministrator • L'utente inserisce il testo da cercare e clicca sul pulsante “Ricerca”
Sequenza degli eventi
Utente
Sistema
1 . Visualizza l'elenco delle entità correlate alla keywords ricercate; in particolare vengono mostrate in una lista attiva: Classi, Insegnamenti, Indirizzi, Utenti trovati.
Postcondizioni:
• L’utente sta visualizzando una lista attiva di entità corrispondenti alle keyword inserite.
• L'utente interrompe l'operazione • Connessione al server SMOS interrotta | Use Case |
|
SMOS53.txt | Nome: VisualizzaElencoClassi
Attori: Personale ATA
Descrizione: Visualizzazione delle classi
Precondizioni:
• L'utente deve essere loggato al sistema come personale ATA
Sequenza degli eventi
Utente
Sistema
1. Il sistema mostra all'utente una schermata con tutte le classi presenti nel database, con un tasto per accedere al registro di ogni classe.
Postcondizioni:
All'utente viene visualizzata una lista da cui scegliere la classe. | Use Case |
|
SMOS54.txt | Nome: InserisciAssenze
Attori: Personale ATA
Descrizione: Digitalizzazione del Registro, raccolta dati dal personale ATA classe per classe
Precondizioni:
• • •
L'utente deve essere loggato al sistema come personale ATA L'utente ha svolto il caso d'uso VisualizzaElencoClassiATA Selezione una classe di cui inserire i dati nel sistema
Sequenza degli eventi
Utente
Sistema
2. L'utente seleziona gli studenti assenti 3. Clicca su salva
1. Mostra all'utente una schermata con gli alunni e dei radio button per selezionare se un alunno è assente o presente. Di default l'alunno è presente.
4. Il sistema invia i dati al server. Il server per ogni assenza invia una e- mail di notifica al genitore dell'alunno.
Postcondizioni:
• I dati di assenze sono stati inseriti nel sistema, ed il sistema ha inviato le notifiche ai genitori. All'utente è mostrata di nuovo la schermata iniziale.
• Connessione al server SMOS interrotta. • L’utente interrompe l’operazione. | Use Case |
|
SMOS55.txt | Nome: InserisciRitardiAta
Attori: Personale ATA
Descrizione: Digitalizzazione del Registro, raccolta dati dal personale ATA classe per classe
Precondizioni:
• • •
L'utente deve essere loggato al sistema come personale ATA L'utente ha svolto il caso d'uso VisualizzaElencoClassiATA Seleziona una classe di cui inserire i dati nel sistema
Sequenza degli eventi
Utente
Sistema
2. L'utente seleziona i ritardi 3. L'utente clicca “Conferma”
1. Il sistema mostra all'utente una schermata con tutti gli alunni presenti, con a fianco una checkbox “ritardo”. Se selezionata si attivano dei campi di select a lato per selezionare l'ora del ritardo
4. Il sistema invia i dati al server.
Postcondizioni:
•
• •
I dati dei ritardi sono stati inseriti nel sistema. All'utente è mostrata di nuovo la schermata iniziale. Connessione al server SMOS interrotta. L’utente interrompe le operazioni. | Use Case |
|
SMOS56.txt | Nome: VisualizzaElencoClassiDocente
Attori: Docente
Descrizione: Il presente caso d'uso consente ad un docente di visualizzare l'elenco delle classi in cui insegna
Precondizioni:
• L’utente è loggato al sistema come docente • L’ utente clicca il pulsante “Registro Digitale”
Sequenza degli eventi
Utente
Sistema
2. Seleziona l'anno accademico di interesse.
1. Visualizza l'elenco degli anni accademici in cui è presente almeno una classe in cui il docente insegna.
3. Visualizza le classi associate all'anno scolastico selezionato.
Postcondizioni:
• E’ stata mostrata la lista di tutte le classi in cui insegna il docente • Connessione al server SMOS interrotta. | Use Case |
|
SMOS57.txt | Nome: VisualizzaRegistro
Attori: Docente
Descrizione: Visualizzazione del registro di classe
Precondizioni:
• L’utente è loggato al sistema come docente • L’ utente ha svolto il caso d’ uso “VisualizzaElencoClassi” e il sistema sta
visualizzando l’ elenco di tutte le classi in cui insegna • L’ utente clicca sul pulsante “Registro” associato ad una delle classi
Sequenza degli eventi
Utente
Sistema
1. Visualizza le informazioni relative al registro di classe ed in particolare:Data, Assenze, Note disciplinari, Ritardi e Giustifiche.
Postcondizioni: :
• Sono state mostrate le informazioni relative al registro di classe • Connessione al server SMOS interrotta. | Use Case |
|
SMOS58.txt | Nome: VisualizzazioneDiUnaPagellaDocente
Attori: Docente
Descrizione: Visualizzazione di una pagella
Precondizioni:
• L'utente si è loggato al sistema come Docente • L’utente clicca sul pulsante “Pagelle on-line”
Sequenza degli eventi
Utente
Sistema
2. Seleziona l'anno accademico di interesse.
4. Seleziona una delle classi visualizzate.
6. Seleziona l'alunno di cui visualizzare la pagella e il quadrimestre di riferimento cliccando sull'apposito pulsante.
1 . Visualizza l'elenco degli anni accademici in cui è presente almeno una classe in cui il docente insegna.
3. Visualizza le classi associate all'anno scolastico selezionato.
5. Visualizza l'elenco degli alunni della classe scelta dall'utente
7. Visualizza la pagella dell'alunno scelto riferita al quadrimestre specificato.
Postcondizioni:
• • •
Il sistema visualizza la pagella di uno studente L’utente interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS59.txt | Nome: VisualizzazioneDiUnaPagellaStudente
Attori: Studente
Descrizione: Viene visualizzata la pagella dell’alunno che lo richiede
Precondizioni:
• L'utente si è loggato al sistema come Studente • L’utente clicca su “pagella online”
Sequenza degli eventi
Utente
Sistema
2. Seleziona la pagella di interesse
1. Il sistema visualizza le pagelle dello studente loggato presenti in archivio
3. Visualizza i dettagli della pagella selezionata
Postcondizioni:
• Il sistema visualizza la pagella di un alunno • Connessione al server SMOS interrotta | Use Case |
|
SMOS6.txt | Nome: NuovoUtente
Attori: Amministratore
Descrizione: Inserimento di un nuovo utente nel sistema
Precondizioni:
• L’utente è loggato come amministratore • L’utente ha svolto il caso d’uso “VisualizzaElencoUtenti” e il sistema sta
visualizzando l’elenco degli utenti presenti nel sistema • L’utente clicca sul pulsante “Nuovo Utente”
Sequenza degli eventi
Utente
2. Riempie i campi del form 3. Clicca sul pulsante “Salva”
Sistema
1. Visualizza il form di inserimento degli utenti costituito dai seguenti campi: Nome, Cognome, e-mail, cell, login, password, conferma password.
4. Effettua dei controlli sulla validità dei dati immessi e inserisce il nuovo utente nell’archivio; nel caso in cui i dati inseriti non sono validi, attiva il caso d’uso “ErroreDati”
Postcondizioni:
• • • •
E’ stato creato un nuovo utente Viene notificato l’errore dati L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS60.txt | Nome: VisualizzaDatiScolasticiStudente
Attori: Studente
Descrizione: Visualizzazione delle informazioni scolastiche riguardanti l’ utente
Precondizioni:
• L’utente è loggato al sistema come studente • L’utente clicca il pulsante “Registro Digitale”
Sequenza degli eventi
Utente
Sistema
1.
2.
Cerca nell’ archivio i dati relativi al registro della classe a cui appartiene lo studente
Visualizza i dati relativi allo studente ed in particolare: Data, Assenze, Note disciplinari, Ritardi e Giustifiche.
Postcondizioni:
• Sono stati mostrati i dati del registro di classe relativi allo studente • Connessione al server SMOS interrotta | Use Case |
|
SMOS61.txt | Nome: VisualizzaDatiStudenti
Attori: Genitore
Descrizione: Il presente caso d'uso consente ad un genitore di visualizzare le informazioni relative ai propri figli
Precondizioni:
• L’utente è loggato al sistema come genitore • L’ utente clicca il pulsante “Registro” associato ad uno dei suoi figli
Sequenza degli eventi
Utente
Sistema
1. Visualizza una tabella riassuntiva con le informazioni relative ai figli ed in particolare:Data, Assenze, Note disciplinari, Ritardi e Giustifiche.
Postcondizioni:
• Sono state mostrate le informazioni relative ad uno dei figli dell’ utente • Connessione al server SMOS interrotta | Use Case |
|
SMOS62.txt | Nome: VisualizzazioneDiUnaPagella
Attori: Genitore
Descrizione: Viene visualizzata la pagella dell’alunno richiesto
Precondizioni:
• L'utente si è loggato al sistema come Genitore • L’utente clicca sul pulsante pagella associato ad uno dei suoi figli
Sequenza degli eventi
Utente
Sistema
2. Seleziona la pagella di interesse
1. Visualizza le pagelle dello studente selezionato
3. Visualizza i dettagli della pagella selezionata
Postcondizioni:
• Il sistema visualizza la pagella di uno studente • Connessione al server SMOS interrotta | Use Case |
|
SMOS63.txt | Nom: EffettuaMonitoraggioStudenti
Attori: Direzione
Descrizione: Consente di visualizzare gli studenti con un numero di note e assenze superiore ad una soglia indicata dall'utente
Precondizioni:
• L’utente è loggato al sistema come direzione • L’ utente clicca sul pulsante “Monitoraggio Studenti”
Sequenza degli eventi
Utente
Sistema
1. Cerca gli studenti con un numero di assenze e note superiori alla soglia stabilita.
2. Visualizza le informazioni recuperate.
Postcondizioni: :
• Sono state visualizzate le informazioni inerenti i dati raccolti • Connessione al server SMOS interrotta. | Use Case |
|
SMOS64.txt | Nome: VisualizzaElencoRegistri
Attori: Direzione
Descrizione: Visualizza l’elenco dei registri per un anno accademico
Precondizioni:
• L'utente deve essere loggato al sistema come Direzione • L’ utente clicca sul pulsante “Registro Digitale”
Sequenza degli eventi
Utente
Sistema
2. Seleziona l’anno accademico
1.Mostra una schermata per la selezione dell’anno accademico di interesse.
3. Cerca nell’archivio tutti i registri digitali di quell’anno e li visualizza associati alla classe cui appartengono
Postcondizioni:
•
• •
Il sistema sta visualizzando l’elenco dei registri riferiti ad un particolare anno accademico La direzione interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS65.txt | Nome: VisualizzaRegistro
Attori: Direzione
Descrizione: Dettagli relativi al registro di una classe
Precondizioni:
• •
•
L’ utente è loggato al sistema direzione L’ utente ha svolto il caso d’ uso “VisualizzaElencoRegistri” e il sistema sta visualizzando l’ elenco di tutti i registri di un particolare anno accademico L’utente clicca il pulsante “Registro” associato ad una delle classi
Sequenza degli eventi
Utente
Sistema
1. Visualizza a video le informazioni contenute nel registro organizzate per data. In particolare mostra, per la data selezionata l’elenco degli alunni, specificando: assenti/presenti, entrate in ritardo ed un form dal quale è possibile gestire giustifiche e note disciplinari.
Postcondizioni:
• Sono state mostrate le informazioni relative al registro di classe • Connessione al server SMOS interrotta | Use Case |
|
SMOS66.txt | Nome: VisualizzazioneDiUnaPagella
Attori: Direzione
Descrizione: Visualizzazione di una pagella
Precondizioni:
• L'utente si è loggato al sistema come Direzione • L’utente clicca sul pulsante “Pagelle online”
Sequenza degli eventi
Utente
Sistema
1. Seleziona l’anno accademico
3 . Sceglie la classe dell'alunno di cui vuole visualizzare la pagella
5. Seleziona l'alunno di cui visualizzare la pagella e il quadrimestre di interesse cliccando sul relativo tasto
2. Visualizza l’elenco delle classi presenti nel sistema con accanto un pulsante “Pagelle” associato ad ogni classe
4. Visualizza l'elenco degli alunni della classe scelta dall'utente
6. Visualizza la pagella dell'alunno scelto riferita al semestre selezionato.
Postcondizioni:
• • •
Il sistema visualizza la pagella di uno studente L’utente interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS67.txt | Nome: RegistrazioneAlSito
Attori: Visitatore
Descrizione: Consente ad uno studente di registrarsi al sistema
Precondizioni:
• L'utente clicca sul pulsante “Registrati” presente nella home page
Sequenza degli eventi
Utente
Sistema
2. Riempie i campi del form 3. Sottomette il form
1 . Visualizza il form di registrazione contenente: Nome, Cognome, Cellulare, e-mail, username, password, conferma password.
4. Inserisce la richiesta di iscrizione nel sistema
Postcondizioni:
• • •
L’utente ha effettuato richiesta di iscrizione al sistema L'utente interrompe l'operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS7.txt |
Nome: VisualizzaDettagliUtente
Attori: Amministratore
Descrizione: Visualizza i dettagli di un utente
Precondizioni:
• •
•
L’utente è loggato come amministratore L’utente ha svolto il caso d’uso “VisualizzaElencoUtenti” e il sistema sta visualizzando l’elenco degli utenti presenti nel sistema L’utente clicca sul pulsante “Dettagli”
Sequenza degli eventi
Utente
Sistema
1. Visualizza le informazioni dettagliate dell’utente ed in particolare: Nome, Cognome, e-mail, cell, login, password.
Postcondizioni:
• Il sistema visualizza le informazioni dettagliate relative ad un utente • Connessione al server SMOS interrotta | Use Case |
|
SMOS8.txt | Nome: ModificaUtente
Attori: Amministratore
Descrizione: Modifica di uno o più dati riguardanti un utente presente nel sistema
Precondizioni:
• L’utente è loggato come amministratore • L’utente ha svolto il caso d’uso “VisualizzaDettagliUtente” e il sistema sta
visualizzando i dettagli di un utente • L’utente modifica una o più informazioni contenute nel form di
visualizzazione dei dettagli dell’utente.
Sequenza degli eventi
Utente
1. Clicca sul pulsante “modifica”
Sistema
2. Effettua dei controlli sulla validità dei dati immessi e modifica l’utente; nel caso in cui i dati inseriti non sono validi, attiva il caso d’uso “ErroreDati”
Postcondizioni:
• • • •
L’utente è stato modificato Viene notificato l’errore dati L’amministratore interrompe l’operazione Connessione al server SMOS interrotta | Use Case |
|
SMOS9.txt | Nome: EliminaUtente
Attori: Amministratore
Descrizione: Elimina un utente dal sistema
Precondizioni:
• L’utente è loggato come amministratore • L’utente ha svolto il caso d’uso “VisualizzaDettagliUtente” e il sistema sta
visualizzando i dettagli di un utente • L’utente clicca sul pulsante “Elimina”
Sequenza degli eventi
Utente
Sistema
1. Elimina l’utente dall’archivio
2. Visualizza l’elenco degli utenti aggiornato
Postcondizioni:
• L’utente è stato cancellato • Connessione al server SMOS interrotta | Use Case |
|
Absence.java | package smos.bean;
import java.io.Serializable;
import java.util.Date;
public class Absence implements Serializable {
/**
* Classe che modella l'assenza di uno studente
* @author Nicola Pisanti
* @version 1.0
*/
private static final long serialVersionUID = -8396513309450121449L;
private int idAbsence;
private int idUser;
private Date dateAbsence;
private Integer idJustify;
private int academicYear;
public Absence (){
}
/**
* Metodo che restituisce l'id dell'assenza
* @return un intero che rappresenta l'id dell'assenza
*/
public int getIdAbsence() {
return idAbsence;
}
/**
* Metodo che setta l'id dell'assenza
* @param un intero che rappresenta l'id da settare
*/
public void setIdAbsence(int pIdAbsence) {
this.idAbsence = pIdAbsence;
}
/**
* Metodo che restituisce l'id dello studente relativo all'assenza
* @return un intero che rappresenta l'id dello studente assente
*/
public int getIdUser() {
return idUser;
}
/**
* Metodo che setta l'id dello studente relativo all'assenza
* @param un intero che rappresenta l'id da settare
*/
public void setIdUser(int pIdUser) {
this.idUser = pIdUser;
}
/**
* Metodo che restituisce la data dell'assenza
* @return una stringa che rappresenta la data dell'assenza
*/
public Date getDateAbsence() {
return dateAbsence;
}
/**
* Metodo che setta la data dell'assenza
* @param una stringa con la data da settare
*/
public void setDateAbsence(Date pDateAbsence) {
this.dateAbsence = pDateAbsence;
}
/**
* Metodo che ritorna l'id della giustifica relativa all'assenza
* @return un intero che rappresenta l'id della giustifica relativa all'assenza, oppure null se l'assenza non è stata giustificata
*/
public Integer getIdJustify() {
return idJustify;
}
/**
* Metodo che setta l'id della giustifica relativa all'assenza
* @param un intero che rappresenta l'id della giustifica da settare
*/
public void setIdJustify(Integer pIdJustify) {
this.idJustify = pIdJustify;
}
/**
* Metodo che restituisce l'anno accademico relativo all'assenza
* @return un intero che rappresenta l'anno in cui è iniziato l'anno accademico
*/
public int getAcademicYear() {
return academicYear;
}
/**
* Metodo che setta l'anno accademico relativo all'assenza
* @param un intero che rappresenta l'anno accademico da settare
*/
public void setAcademicYear(int pAcademicYear) {
this.academicYear = pAcademicYear;
}
}
| This code provides a user with the ability to manage student absence records. The "Absence" class represents an individual absence, with properties such as the ID of the absence, the ID of the student who was absent, the date of the absence, the ID of any justification for the absence, and the academic year in which the absence occurred. The class provides methods to retrieve and set the values of these properties, allowing the user to create, view, and update absence records as needed. This functionality could be useful in an educational or institutional setting for tracking student attendance and managing student records. The code encapsulates the details of how this behavior is provided, focusing on the specific properties and methods that enable the user to manage absence records effectively. | Code |
AdaptorException.java | /*
* AdaptorException
*
*/
package smos.storage.connectionManagement.exception;
import java.rmi.RemoteException;
/**
* Thrown when a problem occurs running code in ensj.
*/
public class AdaptorException extends RemoteException {
private static final long serialVersionUID = 1L;
/**
*
*/
public AdaptorException() {
super();
}
/**
* @param pMessage
*/
public AdaptorException(String pMessage) {
super(pMessage + buildLabel());
}
/**
* @param pMessage
* @param pParentException
*/
public AdaptorException(String pMessage, Exception pParentException) {
super(pMessage + buildLabel(), pParentException);
}
/**
* @param pParentException
*/
public AdaptorException(Exception pParentException) {
super(buildLabel(), pParentException);
}
private static String buildLabel() {
return " [1]";
}
}
| The `AdaptorException` class is a custom exception type that extends the `RemoteException` class. This exception is designed to handle problems that occur when running code in the `ensj` system, a component of a larger software system. The exception provides several constructors that allow for different ways of creating the exception, such as providing a message string, a parent exception, or both. The `buildLabel()` method is used to append a label `[1]` to the end of the exception message, providing additional context about the error.
When an issue occurs in the `ensj` system, this exception can be thrown to indicate the problem and provide more information about the error. The different constructors allow the exception to be customized based on the specific circumstances of the error, such as including a detailed message or the original exception that caused the problem. This allows the software system to effectively communicate errors to the user, enabling them to understand the issue and potentially take appropriate action to address it. | Code |
Address.java | package smos.bean;
import java.io.Serializable;
/**
* Classe utilizzata per modellare un indirizzo.
*
*
*/
public class Address implements Serializable{
/**
*
*/
private static final long serialVersionUID = -9194626030239503689L;
private int idAddress;
private String name;
/**
* Il costruttore della classe.
*/
public Address(){
this.idAddress= 0;
}
/**
* @return Ritorna l' id dell' indirizzo.
*/
public int getIdAddress() {
return idAddress;
}
/**
* Setta l' id dell' indirizzo.
* @param pIdAddress
* l' id da settare.
*/
public void setIdAddress(int pIdAddress) {
this.idAddress = pIdAddress;
}
/**
* @return Ritorna il nome dell' indirizzo.
*/
public String getName() {
return name;
}
/**
* Setta il nome dell' indirizzo.
* @param pName
* Il nome da settare.
*/
public void setName(String pName) {
this.name = pName;
}
}
| The "Address" class in this code provides a way for users to model and manage address information within a software system. Users can create new addresses, retrieve the unique identifier and name of an address, and update the name of an address as needed. The class has two private instance variables, "idAddress" and "name", which represent the unique identifier and name of the address, respectively. The class provides a default constructor that initializes the "idAddress" variable to 0, as well as several methods to interact with the address data. The "getIdAddress()" and "setIdAddress(int pIdAddress)" methods allow users to retrieve and set the unique identifier of the address, while the "getName()" and "setName(String pName)" methods allow users to retrieve and set the name of the address. Overall, this code provides a simple and straightforward way for users to work with address information within the software system. | Code |
Classroom.java | package smos.bean;
import java.io.Serializable;
public class Classroom implements Serializable{
/**
* Classe impiegata per modellare una classe
* @author Nicola Pisanti
* @version 1.0
*/
private static final long serialVersionUID = -8295647317972301446L;
private int idClassroom; //Id della classe
private int idAddress; //Id dell'indirizzo
private String name; //Nome della classe
private int academicYear; //Anno accademico della classe, da inserire l'anno del primo semestre.
public Classroom(){
this.idAddress=0;
this.idClassroom=0;
}
/**
* Metodo che restituisce l'anno accademico
* @return Un intero che rappresenta l'anno scolastico del primo semestre della classe.
*/
public int getAcademicYear() {
return academicYear;
}
/**
* Metodo che setta l'anno accademico
* @param Il nuovo anno accademico da impostare
*/
public void setAcademicYear(int pAcademicYear) {
this.academicYear = pAcademicYear;
}
/**
* Metodo per avere l'ID dell'indirizzo della classe
* @return Un intero che rappresenta l'ID dell'indirizzo della classe
*/
public int getIdAddress() {
return idAddress;
}
/**
* Metodo che setta l'ID dell'indirizzo della classe
* @param Il nuovo ID da settare
*/
public void setIdAddress(int pIdAddress) {
this.idAddress = pIdAddress;
}
/**
* Metodo che restituisce l'ID della classe
* @return Un intero che rappresenta l'ID della classe
*/
public int getIdClassroom() {
return idClassroom;
}
/**
* Metodo che setta l'ID della classe
* @param Il nuovo ID da settare
*/
public void setIdClassroom(int pIdClassroom) {
this.idClassroom = pIdClassroom;
}
/**
* Metodo che restituisce il nome della classe
* @return Una stringa che rappresenta il nome della classe
*/
public String getName() {
return name;
}
/**
* Metodo che setta il nome della classe
* @param Il nuovo nome da settare
*/
public void setName(String pName) {
this.name = pName;
}
public String toString(){
return (name + " "+ academicYear+ " ID: "+ idClassroom);
}
}
| The "Classroom" class in this code provides users with the ability to create and manage information about classrooms within a software system. The class has several properties, including an ID for the classroom, an ID for the address of the classroom, the name of the classroom, and the academic year of the classroom. Users can access and modify these properties through the provided getter and setter methods, allowing them to create new classrooms and update existing ones as needed.
The class also includes a constructor that initializes the ID of the classroom and the address ID to 0, suggesting that the class is designed to be used to create new classroom objects, with the ID and address ID being set later. Additionally, the class includes a toString() method that returns a string representation of the classroom, including the name, academic year, and ID of the classroom, which can be useful for displaying information about a classroom to the user.
Overall, this code provides users with a way to create and manage information about classrooms within a software system, allowing them to access and modify the relevant details as needed. | Code |
ConnectionException.java | package smos.exception;
import java.lang.Exception;
/**
* Questa classe rappresenta l'eccezione generata quando non è possibile
* ottenere una connessione al database
*/
public class ConnectionException extends Exception {
private static final long serialVersionUID = -6593436034986073011L;
/**
* Genera l'eccezione senza un messagio di errore associato.
*/
public ConnectionException() {
super("Unable to Connect to the DataBase!");
}
/**
* Genera l'eccezione con un messagio di errore associato.
*
* @param pMessage Il messaggio di errore che deve essere associato
* all'eccezione.
*/
public ConnectionException(String pMessage) {
super(pMessage);
}
} | The code provided defines an exception class called `ConnectionException` that is used to represent an error that occurs when a connection to a database cannot be established. This custom exception class extends the `Exception` class, allowing it to be used in the same way as any other exception in the Java programming language.
The `ConnectionException` class provides two constructors: one that creates an exception with a default error message "Unable to Connect to the DataBase!", and another that allows the user to provide a custom error message. This allows the software system to provide more specific and meaningful error messages to the user, rather than relying on generic exception messages. By using a custom exception class, the system can better handle and report errors that occur when attempting to connect to a database, helping the user understand the nature of the problem and take appropriate action to resolve it. | Code |
ConnectionPoolDataSource.java | /*
* ConnectionPoolDataSource
*
*/
package smos.storage.connectionManagement;
import smos.storage.connectionManagement.exception.NotImplementedYetException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;
import java.util.Vector;
import javax.sql.DataSource;
/**
* Realizzazione del pool di connessioni tramite l'implementazione
* dell'interfaccia java.sql.DataSource. Il pool controlla periodicamente le
* connessioni attive e quelle che sono pool, ossia quelle rilasciate ma ancora
* utilizzabili (presenti cioe' in memoria). Il tempo di rilascio delle
* connessioni attive e di quelle pool � rappresentato da due parametri presenti
* all'interno della classe e che sono connectionPoolCloseTimeout e
* inactiveMaxTimeout; tali valori cosi come tutti gli altri inerenti al pool
* hanno un loro valore di default, parametrizzabile tramite il file di
* properties connection.properties
*/
public class ConnectionPoolDataSource implements DataSource {
/**
* Thread inside della classe ConnectionPoolDataSource che stabilisce ogni
* connectionPoolCloseTimeout millisecondi il rilascio delle connessioni
* pool.
*/
private class ConnectionCloser extends Thread {
private long connectionActionTimestamp = 0;
private int connectionPoolCloseTimeout = 300000;
private long timeStamp = 0;
/**
* Costruttore che setta il tempo di rilascio delle connessioni pool
*
* @author Di Giorgio Domenico, Cris Malinconico
* @param pTime
* intervallo di tempo entro cui il pool svuota la lista
* delle connessioni pool.
*/
private ConnectionCloser(int pTime) {
setDaemon(true);
setName("ConnectionPoolCloser");
if (pTime > 0)
this.connectionPoolCloseTimeout = pTime;
}
/**
* Ogni volta che una connessione genera un evento con un'invocazione di
* getConnection() o release() il timestamp viene settato al valore
* temporale corrente tramite questo metodo.
*/
public void connectionEvent() {
this.connectionActionTimestamp = System.currentTimeMillis();
}
/**
* Controlla ogni connectionPoolCloseTimeout millisecondi se le
* connessioni pool possono essere chiuse liberando in tal caso memoria.
*/
public void run() {
boolean working = true;
while (working) {
try {
this.timeStamp = System.currentTimeMillis();
Thread.sleep(this.connectionPoolCloseTimeout);
if (this.connectionActionTimestamp < this.timeStamp) {
closeAllConnections(ConnectionPoolDataSource.this.pool);
}
} catch (InterruptedException e) {
working = false;
e.printStackTrace();
} catch (SQLException e) {
working = false;
e.printStackTrace();
}
}
}
}
private List<SMOSConnection> active = new Vector<SMOSConnection>();
private Properties config = new Properties();
private ConnectionCloser connectionCloser;
private Driver driver;
private String fullConnectionString;
private long inactiveMaxTimeout = 20000;
private int maxPoolSize;
private List<Connection> pool = new Vector<Connection>();
/**
* Crea una nuova istanza del pool di connessioni.
*
* @param pJdbcDriverName
* nome del driver jdbc
* @param pFullConnectionString
* stringa di connessione con il database
* @param pUser
* nome utente (amministratore del database)
* @param pPassword
* password amministratore
* @param pMaxPoolSize
* massimo numero di connessioni attive nel pool, deve essere
* maggiore di 0
* @param pPoolTime
* intervallo di tempo entro il quale il pool sar� svuotato ogni
* volta delle sue connessioni pool (in ms).
* @throws ClassNotFoundException
* se il driver jdbc non pu� essere trovato
* @throws SQLException
* se occorre un problema durante la connessione al database
* @throws IllegalArgumentException
* se i parametri forniti in input non sono validi
*/
public ConnectionPoolDataSource(String pJdbcDriverName,
String pFullConnectionString, String pUser, String pPassword,
int pMaxPoolSize, int pPoolTime) throws ClassNotFoundException,
SQLException {
if (pMaxPoolSize < 1) {
throw new IllegalArgumentException(
"maxPoolSize deve essere >0 ma �: " + pMaxPoolSize);
}
if (pFullConnectionString == null) {
throw new IllegalArgumentException("fullConnectionString "
+ "ha valore Null");
}
if (pUser == null) {
throw new IllegalArgumentException("il nome utente ha valore Null");
}
this.maxPoolSize = pMaxPoolSize;
this.fullConnectionString = pFullConnectionString;
this.config.put("user", pUser);
if (pPassword != null) {
this.config.put("password", pPassword);
}
Class.forName(pJdbcDriverName);
this.driver = DriverManager.getDriver(pFullConnectionString);
this.connectionCloser = new ConnectionCloser(pPoolTime);
this.connectionCloser.start();
}
/**
* Restituisce la dimensione della lista delle connessioni attive.
*
* @return la dimensione della lista delle connessioni attualmente attive.
*/
public int activeSize() {
return this.active.size();
}
/**
* Svuota il pool di connessioni da quelle attive che non hanno pi� eseguito
* operazioni per inactiveMaxTimeout millisecondi.
*
*/
protected void clearActive() {
long temp = 0;
long TIME = System.currentTimeMillis();
SMOSConnection adc = null;
for (int count = 0; count < this.active.size(); count++) {
adc = (SMOSConnection) this.active.get(count);
temp = TIME - adc.getLastTime();
if (temp >= this.inactiveMaxTimeout) {
this.release(adc.getConnection());
}
}
}
/**
* Chiude tutte le connessioni del pool sia quelle attive e sia quelle che
* sono pool.
*
* @author Di Giorgio Domenico, Cris Malinconico
* @throws SQLException
*/
public synchronized void closeAllConnections() throws SQLException {
closeAllConnections(this.pool);
closeAllConnections(this.active);
}
/**
* Chiude tutte le connessioni indicate nella lista connection.
*
* @author Di Giorgio Domenico, Cris Malinconico
* @param pConnections
* la lista delle connesioni che devono essere chiuse.
* @throws SQLException
* qualora sia impossibile chiudere una connessione.
*/
private synchronized void closeAllConnections(List pConnections)
throws SQLException {
while (pConnections.size() > 0) {
ConnectionWrapper conn = (ConnectionWrapper) pConnections.remove(0);
conn.closeWrappedConnection();
}
}
/**
* Chiude tutte le connessioni del pool che sono nella lista pool.
*
* @throws SQLException
* qualora sia impossibile chiudere una connessione.
*/
public synchronized void closeAllPooledConnections() throws SQLException {
closeAllConnections(this.pool);
}
/**
* Metodo utilizzato da getConnection() per creare una nuova connessione
* qualora nella lista delle pool non siano presenti.
*
* @return una nuova connessione al DataBase.
*/
private synchronized Connection createNewConnection() {
Connection rawConn = null;
try {
rawConn = this.driver.connect(this.fullConnectionString, this.config);
Connection conn = new ConnectionWrapper(rawConn, this);
SMOSConnection ac = new SMOSConnection();
ac.setConnection(conn);
ac.setLastTime(System.currentTimeMillis());
this.active.add(ac);
return conn;
} catch (SQLException e) {
System.out.println("Creazione della connessione fallita "
+ "in ConnectionPoolDataSource:" + e);
return null;
}
}
/**
* Restituisce una connessione se il pool non � pieno, il controllo avviene
* prima nella lista delle connessioni pool per evitare delle creazioni
* inutili altrimenti una nuova connessione sar� creata.
*
* @return la connessione al database qualora fosse possibile altrimenti
* un'eccezione viene generata
* @see javax.sql.DataSource getConnection()
* @throws SQLException
* Se un problema occorre durante la connessione al database
* incluso il fatto che il limite massimo delle connessioni
* attive venga raggiunto.
*/
public synchronized Connection getConnection() throws SQLException {
Connection connection = getPooledConnection(0);
if (connection == null) {
if (this.active.size() >= this.maxPoolSize) {
throw new SQLException("Connection pool limit of "
+ this.maxPoolSize + " exceeded");
} else {
connection = createNewConnection();
}
}
this.connectionCloser.connectionEvent();
//System.out.println("GET CONNECTION: " + active.size() + "/" + pool.size());
return connection;
}
/**
* Metodo non implementato
* @param pArg1
* @param pArg2
* @return Connection
* @throws SQLException
*
* @throws NotImplementedYetException
*/
public Connection getConnection(String pArg1, String pArg2)
throws SQLException {
throw new NotImplementedYetException();
}
/**
* Metodo non implementato
* @return int
* @throws SQLException
*
* @throws NotImplementedYetException
*/
public int getLoginTimeout() throws SQLException {
throw new NotImplementedYetException();
}
/**
* Metodo non implementato
* @return PrintWriter
* @throws SQLException
*
* @throws NotImplementedYetException
*/
public PrintWriter getLogWriter() throws SQLException {
throw new NotImplementedYetException();
}
/**
* Restituisce il numero massimo di connessioni attive
*
* @return il numero massimo di connessioni attive.
*/
public int getMaxPoolSize() {
return this.maxPoolSize;
}
/**
* Metodo utilizzato da getConnection() per stabilire se nella lista delle
* connessioni pool ve ne sia qualcuna da poter riutilizzare.
*
* @param pPoolIndex
* indice della lista delle connessioni pool (sempre 0).
* @return una connesssione dalla lista di quelle pool qualora ne esista
* una.
*/
private synchronized Connection getPooledConnection(int pPoolIndex) {
SMOSConnection ac = new SMOSConnection();
Connection connection = null;
if (this.pool.size() > 0) {
connection = (Connection) this.pool.remove(pPoolIndex);
ac.setConnection(connection);
ac.setLastTime(System.currentTimeMillis());
this.active.add(ac);
}
return ac.getConnection();
}
/**
* Restituisce la dimensione della lista delle connessioni pool
*
* @return la dimensione della lista delle connessioni pool.
*/
public int poolSize() {
return this.pool.size();
}
/**
* Rilascia una connessione, eliminandola da quelle attive ed inserendola in
* quelle pool per poter essere successivamente riutilizzata.
*
* @param pConnection
* La connessione che deve essere ritornata al pool.
*/
public synchronized void release(Connection pConnection) {
boolean exists = false;
int activeIndex = 0;
if (pConnection != null) {
SMOSConnection adc = null;
while ((activeIndex < this.active.size()) && (!exists)) {
adc = (SMOSConnection) this.active.get(activeIndex);
if (adc.equals(pConnection)) {
this.active.remove(adc);
this.pool.add(adc.getConnection());
exists = true;
}
activeIndex++;
}
this.connectionCloser.connectionEvent();
//System.out.println("RELEASE CONNECTION: " + active.size() + "/" + pool.size());
}
}
/**
* Setta il tempo di vita delle connessioni attive in millisecondi.
*
* @param pTimeOut
* tempo di vita della connessione.
*/
public void setActivedTimeout(long pTimeOut) {
if (pTimeOut > 0) {
this.inactiveMaxTimeout = pTimeOut;
}
}
/**
* Riazzera il tempo di vita della connessione dovutocall'esecuzione di
* un'operazione.Da questo momento la connessione potr� essere attiva senza
* eseguire alcuna operazione per altri inactiveMaxTimeout millisecondi.
*
* @param pConnection
* la connessione che ha eseguito un'operazione e quindi pu�
* rimanere attiva.
*/
void setLastTime(Connection pConnection) {
boolean exists = false;
int count = 0;
SMOSConnection adc = null;
while ((count < this.active.size()) && (!exists)) {
adc = (SMOSConnection) this.active.get(count);
count++;
if (adc.equals(pConnection)) {
adc.setLastTime(System.currentTimeMillis());
exists = true;
}
}
}
/**
* Metodo non implementato
* @param pArg0
* @throws SQLException
*
* @throws NotImplementedYetException
*/
public void setLoginTimeout(int pArg0) throws SQLException {
throw new NotImplementedYetException();
}
/**
* Metodo non implementato
* @param pArg0
* @throws SQLException
*
* @throws NotImplementedYetException
*/
public void setLogWriter(PrintWriter pArg0) throws SQLException {
throw new NotImplementedYetException();
}
/**
* Converte un oggetto della classe ConnectionPoolDataSource in String
*
* @return la rappresentazione nel tipo String del pool di connessioni.
*/
public String toString() {
StringBuffer buf = new StringBuffer();
buf.append("[");
buf.append("maxPoolSize=").append(this.maxPoolSize);
buf.append(", activeSize=").append(activeSize());
buf.append(", poolSize=").append(poolSize());
buf.append(", fullConnectionString=").append(this.fullConnectionString);
buf.append("]");
return (buf.toString());
}
}
| The ConnectionPoolDataSource class provides a connection pool management system that allows users to efficiently manage a pool of database connections. Users can create a new instance of the connection pool, configuring it with parameters such as the maximum pool size, connection string, user and password, and timeout for inactive connections. The `getConnection()` method allows users to obtain a connection from the pool, which will either return an existing connection or create a new one if the pool is not full. When the user is done with the connection, they can release it back to the pool using the `release()` method, allowing it to be reused by other parts of the application. The code also includes a background thread that periodically checks the pool and closes any connections that have been inactive for too long, in order to free up resources. Users can also manually close all connections in the pool using the `closeAllConnections()` method. Overall, this code provides a way for users to efficiently manage a pool of database connections, allowing them to reuse connections and avoid the overhead of creating new connections for each database operation. | Code |
ConnectionWrapper.java | /*
* ConnectionWrapper
*
*/
package smos.storage.connectionManagement;
import java.io.Serializable;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Savepoint;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Map;
import java.util.logging.Logger;
/**
* ConnectionWrapper è una classe che aggiunge a tutti i metodi della classe
* Connection il settaggio del tempo in cui l'operazione sulla particolare
* connessione è avvenuta informando il pool di quanto accaduto.
*/
public class ConnectionWrapper implements Connection, Serializable {
private static final long serialVersionUID = 1L;
private static final Logger LOGGER = Logger
.getLogger(ConnectionWrapper.class.getName());
private Connection connection;
private ConnectionPoolDataSource manager;
private ArrayList<Statement> statements = new ArrayList<Statement>();
/**
* @param pConnection
* @param pPoolManager
*/
public ConnectionWrapper(Connection pConnection,
ConnectionPoolDataSource pPoolManager) {
this.connection = pConnection;
this.manager = pPoolManager;
LOGGER.fine("Creating ConnectionWrapper");
}
private PreparedStatement cachePreparedStatement(PreparedStatement pPrepSt) {
this.manager.setLastTime(this);
this.statements.add(pPrepSt);
return pPrepSt;
}
private Statement cacheStatement(Statement pStatement) {
this.manager.setLastTime(this);
this.statements.add(pStatement);
return pStatement;
}
/**
* @see java.sql.Connection#clearWarnings()
*/
public void clearWarnings() throws SQLException {
this.connection.clearWarnings();
}
/**
* @see java.sql.Connection#close()
*/
public void close() throws SQLException {
closeAndReleaseStatements();
this.manager.release(this);
}
private synchronized void closeAndReleaseStatements() throws SQLException {
final int n = this.statements.size();
for (int i = 0; i < n; i++) {
((Statement) this.statements.get(i)).close();
}
this.statements.clear();
}
/**
* Close the wrapped connection.
* @throws SQLException
*/
void closeWrappedConnection() throws SQLException {
closeAndReleaseStatements();
if (!this.connection.isClosed()) {
LOGGER.fine("Closing db connection: " + this.getClass().getName()
+ " [" + this + "]");
}
this.connection.close();
}
/**
* @see java.sql.Connection#commit()
*/
public void commit() throws SQLException {
this.manager.setLastTime(this);
this.connection.commit();
}
/**
* @see java.sql.Connection#createStatement()
*/
public Statement createStatement() throws SQLException {
this.manager.setLastTime(this);
return cacheStatement(this.connection.createStatement());
}
/**
* @see java.sql.Connection#createStatement(int, int)
*/
public Statement createStatement(int pResultSetType,
int pResultSetConcurrency) throws SQLException {
this.manager.setLastTime(this);
return cacheStatement(this.connection.createStatement(pResultSetType,
pResultSetConcurrency));
}
/**
* @see java.sql.Connection#createStatement(int, int, int)
*/
public Statement createStatement(int pResultSetType,
int pResultSetConcurrency, int pResultSetHoldability)
throws SQLException {
this.manager.setLastTime(this);
return cacheStatement(this.connection.createStatement(pResultSetType,
pResultSetConcurrency, pResultSetHoldability));
}
/**
* Closes the wrapped connection.
*/
protected void finalize() throws Throwable {
closeWrappedConnection();
}
/**
* @see java.sql.Connection#getAutoCommit()
*/
public boolean getAutoCommit() throws SQLException {
this.manager.setLastTime(this);
return this.connection.getAutoCommit();
}
/**
* @see java.sql.Connection#getCatalog()
*/
public String getCatalog() throws SQLException {
this.manager.setLastTime(this);
return this.connection.getCatalog();
}
/**
* @see java.sql.Connection#getHoldability()
*/
public int getHoldability() throws SQLException {
this.manager.setLastTime(this);
return this.connection.getHoldability();
}
/**
* @see java.sql.Connection#getMetaData()
*/
public DatabaseMetaData getMetaData() throws SQLException {
this.manager.setLastTime(this);
return this.connection.getMetaData();
}
/**
* @see java.sql.Connection#getTransactionIsolation()
*/
public int getTransactionIsolation() throws SQLException {
this.manager.setLastTime(this);
return this.connection.getTransactionIsolation();
}
/**
* @see java.sql.Connection#getTypeMap()
*/
@SuppressWarnings("unchecked")
public Map getTypeMap() throws SQLException {
this.manager.setLastTime(this);
return this.connection.getTypeMap();
}
/**
* @see java.sql.Connection#getWarnings()
*/
public SQLWarning getWarnings() throws SQLException {
this.manager.setLastTime(this);
return this.connection.getWarnings();
}
/**
* @see java.sql.Connection#isClosed()
*/
public boolean isClosed() throws SQLException {
this.manager.setLastTime(this);
return this.connection.isClosed();
}
/**
* @see java.sql.Connection#isReadOnly()
*/
public boolean isReadOnly() throws SQLException {
this.manager.setLastTime(this);
return this.connection.isReadOnly();
}
/**
* @see java.sql.Connection#nativeSQL(java.lang.String)
*/
public String nativeSQL(String sql) throws SQLException {
this.manager.setLastTime(this);
return this.connection.nativeSQL(sql);
}
/**
* @see java.sql.Connection#prepareCall(java.lang.String)
*/
public CallableStatement prepareCall(String sql) throws SQLException {
this.manager.setLastTime(this);
return this.connection.prepareCall(sql);
}
/**
* @see java.sql.Connection#prepareCall(java.lang.String, int, int)
*/
public CallableStatement prepareCall(String pStatementSql,
int pResultSetType, int pResultSetConcurrency) throws SQLException {
this.manager.setLastTime(this);
return this.connection.prepareCall(pStatementSql, pResultSetType,
pResultSetConcurrency);
}
/**
* @see java.sql.Connection#prepareCall(java.lang.String, int, int, int)
*/
public CallableStatement prepareCall(String pStatementSql,
int pResultSetType, int pResultSetConcurrency,
int pResultSetHoldability) throws SQLException {
this.manager.setLastTime(this);
return this.connection.prepareCall(pStatementSql, pResultSetType,
pResultSetConcurrency, pResultSetHoldability);
}
/**
* @see java.sql.Connection#prepareStatement(java.lang.String)
*/
public PreparedStatement prepareStatement(String pStatementSql)
throws SQLException {
this.manager.setLastTime(this);
return cachePreparedStatement(this.connection
.prepareStatement(pStatementSql));
}
/**
* @see java.sql.Connection#prepareStatement(java.lang.String, int)
*/
public PreparedStatement prepareStatement(String pStatementSql,
int pAutoGeneratedKeys) throws SQLException {
this.manager.setLastTime(this);
return cachePreparedStatement(this.connection.prepareStatement(
pStatementSql, pAutoGeneratedKeys));
}
/**
* @see java.sql.Connection#prepareStatement(java.lang.String, int, int)
*/
public PreparedStatement prepareStatement(String pStatementSql,
int pResultSetType, int pResultSetConcurrency) throws SQLException {
this.manager.setLastTime(this);
return cachePreparedStatement(this.connection.prepareStatement(
pStatementSql, pResultSetType, pResultSetConcurrency));
}
/**
* @see java.sql.Connection#prepareStatement(java.lang.String, int, int, int)
*/
public PreparedStatement prepareStatement(String pStatementSql,
int pResultSetType, int pResultSetConcurrency,
int pResultSetHoldability) throws SQLException {
this.manager.setLastTime(this);
return cachePreparedStatement(this.connection.prepareStatement(
pStatementSql, pResultSetType, pResultSetConcurrency,
pResultSetHoldability));
}
/**
* @see java.sql.Connection#prepareStatement(java.lang.String, int[])
*/
public PreparedStatement prepareStatement(String pStatementSql,
int[] columnIndexes) throws SQLException {
this.manager.setLastTime(this);
return cachePreparedStatement(this.connection.prepareStatement(
pStatementSql, columnIndexes));
}
/**
* @see java.sql.Connection#prepareStatement(java.lang.String, java.lang.String[])
*/
public PreparedStatement prepareStatement(String pStatementSql,
String[] pColumnNames) throws SQLException {
this.manager.setLastTime(this);
return cachePreparedStatement(this.connection.prepareStatement(
pStatementSql, pColumnNames));
}
/**
* @see java.sql.Connection#releaseSavepoint(java.sql.Savepoint)
*/
public void releaseSavepoint(Savepoint pSavepoint) throws SQLException {
this.manager.setLastTime(this);
this.connection.releaseSavepoint(pSavepoint);
}
/**
* @see java.sql.Connection#rollback()
*/
public void rollback() throws SQLException {
this.manager.setLastTime(this);
this.connection.rollback();
}
/**
* @see java.sql.Connection#rollback(java.sql.Savepoint)
*/
public void rollback(Savepoint pSavepoint) throws SQLException {
this.manager.setLastTime(this);
this.connection.rollback(pSavepoint);
}
/**
* @see java.sql.Connection#setAutoCommit(boolean)
*/
public void setAutoCommit(boolean pAutoCommit) throws SQLException {
this.manager.setLastTime(this);
if (this.connection.getAutoCommit() != pAutoCommit) {
this.connection.setAutoCommit(pAutoCommit);
}
}
/**
* @see java.sql.Connection#setCatalog(java.lang.String)
*/
public void setCatalog(String pCatalog) throws SQLException {
this.manager.setLastTime(this);
this.connection.setCatalog(pCatalog);
}
/**
* @see java.sql.Connection#setHoldability(int)
*/
public void setHoldability(int pHoldability) throws SQLException {
this.manager.setLastTime(this);
this.connection.setHoldability(pHoldability);
}
/**
* @see java.sql.Connection#setReadOnly(boolean)
*/
public void setReadOnly(boolean pReadOnly) throws SQLException {
this.manager.setLastTime(this);
this.connection.setReadOnly(pReadOnly);
}
/**
* @see java.sql.Connection#setSavepoint()
*/
public Savepoint setSavepoint() throws SQLException {
this.manager.setLastTime(this);
return this.connection.setSavepoint();
}
/**
* @see java.sql.Connection#setSavepoint(java.lang.String)
*/
public Savepoint setSavepoint(String pName) throws SQLException {
this.manager.setLastTime(this);
return this.connection.setSavepoint(pName);
}
/**
* @see java.sql.Connection#setTransactionIsolation(int)
*/
public void setTransactionIsolation(int pLevel) throws SQLException {
this.manager.setLastTime(this);
this.connection.setTransactionIsolation(pLevel);
}
/**
* @see java.sql.Connection#setTypeMap(java.util.Map)
*/
/**
* @see java.lang.Object#toString()
*/
public String toString() {
return this.connection.toString();
}
public void setTypeMap(Map<String, Class<?>> arg0) throws SQLException {
// TODO Auto-generated method stub
}
}
| The "ConnectionWrapper" class provides a wrapper around a standard JDBC "Connection" object, adding additional functionality and management capabilities. The primary purpose of this class is to track the last time the connection was used and inform a "ConnectionPoolDataSource" manager of this information. This allows the manager to better manage the pool of database connections and ensure they are being used efficiently.
The "ConnectionWrapper" class overrides all of the standard "Connection" methods, such as "createStatement()", "prepareStatement()", "commit()", and "rollback()", and before calling the underlying method, it informs the manager of the last time the connection was used. This allows the manager to keep track of the usage of each connection in the pool.
Additionally, the "ConnectionWrapper" class caches any "Statement" objects that are created, and when the "ConnectionWrapper" is closed, it also closes and releases all of the cached statements. This further enhances the manager's ability to track the usage of the connection and the statements associated with it.
Overall, the "ConnectionWrapper" class provides a way to wrap a standard "Connection" object and add additional functionality and management capabilities around it, allowing the system using this code to better control and optimize the usage of database connections, which is an important aspect of many enterprise-level applications. | Code |
ControlConnection.java | package smos.storage.connectionManagement;
import java.sql.*;
/**
* Implementazione del thread in grado di mantenere la connessione al database
* Mysql qualora non vi siano più connessioni attive (risoluzione del problema
* dell'autoreconnect di Mysql). Tale classe si occupa anche di richimare il
* metodo di rilascio delle connessioni attive che non hanno eseguito operazioni
* in un certo intervallo di tempo.
*/
public class ControlConnection extends Thread {
private static ConnectionPoolDataSource manager = null;
private static int waitTimeout;
/**
* Crea una nuova istanza del Thread.
*
* @author Di Giorgio Domenico, Cris Malinconico
* @param pManager
* il pool delle connessioni attulamente in esecuzione.
*/
public ControlConnection(ConnectionPoolDataSource pManager) {
ControlConnection.manager = pManager;
}
/**
* Crea una nuova istanza del Thread.
*
* @param pManager
* il pool delle connessioni attulamente in esecuzione.
* @param pTime
* Il tempo entro cui ristabilire la connessione con mysql prima
* che scada.Tale valore dovrà essere necessariamente minore del
* valore della variabile globale wait_timeout di Mysql.
*/
public ControlConnection(ConnectionPoolDataSource pManager, int pTime) {
ControlConnection.waitTimeout = pTime;
ControlConnection.manager = pManager;
}
/**
* Il thread non fa altro che dormire quando ci sono utenti attivi e
* mantenere aperta la connessione con MySQL altrimenti.
*
*/
public void run() {
try {
while (true) {
if (manager.activeSize() > 0) {
this.setPriority(Thread.MAX_PRIORITY);
manager.clearActive();
this.setPriority(Thread.NORM_PRIORITY);
}
if (manager.activeSize() == 0) {
while (true) {
try {
manager.closeAllPooledConnections();
Connection con = null;
con = manager.getConnection();
Statement st = con.createStatement();
st.executeQuery("show tables");
manager.release(con);
break;
} catch (Exception e) {
System.out.println("Eccezione geneata "
+ "nel Thread ControlConnection:" + e);
}
}
Thread.sleep(waitTimeout);
} else {
Thread.sleep(waitTimeout);
}
}
} catch (InterruptedException ex) {
System.out.println("Thread ControlConnection interrotto:" + ex);
}
}
}
| The code provides a mechanism to maintain a persistent connection to a MySQL database, even when there are no active users. The ControlConnection thread continuously monitors the connection pool, clearing any active connections and periodically executing a simple SQL query to keep the connection alive. This ensures that the application can quickly re-establish a connection to the database when needed, without encountering issues related to the MySQL auto-reconnect feature. The thread's behavior is configurable through the "waitTimeout" parameter, which allows the application to adjust the frequency of the connection checks based on the specific requirements of the system. By proactively managing the database connection, this code helps to improve the reliability and responsiveness of the application, providing a seamless experience for users. | Code |
DBConnection.java | /*
* DBConnection
*
*/
package smos.storage.connectionManagement;
import smos.Environment;
import smos.utility.Utility;
import java.sql.*;
import java.util.*;
import java.io.*;
/**
* Classe che s'interfaccia con il pool di connessioni. In particolare crea un
* unico oggetto ConnectionPoolDataSource (il pool di connessioni) ed ottiene i
* suoi parametri di configurazione dal file di properties
* connection.properties.
*/
public class DBConnection {
private static int ACTIVE_TIMEOUT;
private static String DRIVER_MYSQL = "";
private static String FULL_PATH_DATABASE = "";
private static ControlConnection linker = null;
private static ConnectionPoolDataSource manager = null;
private static int MAX_POOL_SIZE;
private static String PASSWORD = "";
private static int POOL_TIMEOUT;
private static Properties properties = null;
private static String USER_NAME = "";
private static int WAIT_TIMEOUT;
/**
* Blocco d'inizializzazione statico che si occupa di generare il pool nel
* momento in cui ci sarà una prima invocazione del metodo getConnection()
*/
static {
try {
properties = new Properties();
File fileProp = new File(Environment.getPoolPropertiesPath());
if (fileProp.exists()) {
properties.load(new FileInputStream(fileProp));
DRIVER_MYSQL = properties.getProperty("connection.jdbc.name");
if (DRIVER_MYSQL.equals("")) {
DRIVER_MYSQL = Utility.getDriverMySql();
}
FULL_PATH_DATABASE = properties
.getProperty("connection.jdbc.fullPath");
if (FULL_PATH_DATABASE.equals("")) {
FULL_PATH_DATABASE = Utility.getFullPathDatabase();
}
USER_NAME = properties.getProperty("connection.username");
if (USER_NAME.equals("")) {
USER_NAME = Utility.getUserName();
}
PASSWORD = properties.getProperty("connection.password");
if (PASSWORD.equals("")) {
PASSWORD = Utility.getPassword();
}
try {
MAX_POOL_SIZE = Integer.parseInt(properties
.getProperty("connection.maxPoolSize"));
} catch (Exception ex) {
MAX_POOL_SIZE = Utility.getMaxPoolSize();
}
try {
WAIT_TIMEOUT = Integer.parseInt(properties
.getProperty("connection.waitTimeout"));
} catch (Exception ex) {
WAIT_TIMEOUT = Utility.getWaitTimeout();
}
try {
ACTIVE_TIMEOUT = Integer.parseInt(properties
.getProperty("connection.activeTimeout"));
} catch (Exception ex) {
ACTIVE_TIMEOUT = Utility.getActiveTimeout();
}
try {
POOL_TIMEOUT = Integer.parseInt(properties
.getProperty("connection.poolTimeout"));
} catch (Exception ex) {
POOL_TIMEOUT = Utility.getPoolTimeout();
}
} else {
/* Se il file di properties non esiste carica valori di default */
DRIVER_MYSQL = Utility.getDriverMySql();
FULL_PATH_DATABASE = Utility.getFullPathDatabase();
USER_NAME = Utility.getUserName();
PASSWORD = Utility.getPassword();
MAX_POOL_SIZE = Utility.getMaxPoolSize();
WAIT_TIMEOUT = Utility.getWaitTimeout();
ACTIVE_TIMEOUT = Utility.getActiveTimeout();
POOL_TIMEOUT = Utility.getPoolTimeout();
}
loadPool(); // Crea il manager e prepara il pool di connessioni
} catch (Exception e) {
/* Se un'eccezione viene generata in precedenza */
DRIVER_MYSQL = Utility.getDriverMySql();
FULL_PATH_DATABASE = Utility.getFullPathDatabase();
USER_NAME = Utility.getUserName();
PASSWORD = Utility.getPassword();
MAX_POOL_SIZE = 100;
WAIT_TIMEOUT = 2000;
ACTIVE_TIMEOUT = 240000;
POOL_TIMEOUT = 300000;
loadPool(); // Crea il manager e prepara il pool di connessioni
}
}
/**
* Restituisce una connessione dal pool.
*
* @return la connessione se possibile null altrimenti
*/
public static Connection getConnection() {
try {
return manager.getConnection();
} catch (SQLException e) {
System.out.println("Eccezione generata"
+ "in DBConnection.getConnection() " + e);
return null;
}
}
/**
* Creazione effettiva del pool di connessione.
*
*/
private static void loadPool() {
try {
manager = new ConnectionPoolDataSource(DRIVER_MYSQL,
FULL_PATH_DATABASE, USER_NAME, PASSWORD, MAX_POOL_SIZE,
POOL_TIMEOUT);
manager.setActivedTimeout(ACTIVE_TIMEOUT);
linker = new ControlConnection(manager, WAIT_TIMEOUT);
linker.start();
} catch (Exception e) {
System.out.println("Impossibile creare il pool"
+ "di connessioni in DBConnection:" + e);
}
}
/**
* Restituisce una connessione al pool che sarà inserita nella lista delle
* connesioni pool, ossia quelle riutilizzabili in seguito.
*
* @param pConnection
* la connessione non più attiva.
*/
public static void releaseConnection(Connection pConnection) {
manager.release(pConnection);
}
}
| This code provides users with a robust and efficient way to manage database connections through the use of a connection pool. By reading configuration settings from a properties file, the code sets up a connection pool manager that handles the creation, management, and reuse of database connections. Users can obtain a connection from the pool by calling the `getConnection()` method, and return the connection to the pool when they are done using it by calling the `releaseConnection()` method. This allows users to efficiently interact with the database without having to worry about the overhead of creating and closing connections manually.
The code also includes a background thread that monitors the connection pool and performs maintenance tasks, such as closing idle connections and removing connections that have been active for too long. This helps to ensure that the connection pool remains healthy and efficient over time, providing users with a reliable and scalable way to interact with the database. | Code |
DefaultException.java | package smos.exception;
import java.lang.Exception;
/**
* Questa classe rappresenta l'eccezione predefinita generata dal sistema.
*/
public class DefaultException extends Exception {
private static final long serialVersionUID = -8985617134055655964L;
/**
* Genera l'eccezione senza un messagio di errore associato.
*/
public DefaultException() {
super();
}
/**
* Genera l'eccezione con un messagio di errore associato.
*
* @param pMessage Il messaggio di errore che deve essere associato
* all'eccezione.
*/
public DefaultException(String pMessage) {
super(pMessage);
}
} | This code defines a custom exception class called `DefaultException` that can be used to represent a generic error or exception that may occur within the system. The purpose of this exception class is to provide a standardized way for the system to handle and report errors, ensuring that they are consistently represented and communicated to users or other parts of the system.
The `DefaultException` class extends the base `Exception` class, inheriting all the standard functionality and behavior of an exception, such as the ability to be caught and handled by try-catch blocks, and the ability to provide a stack trace and other information about the error. The class provides two constructors: one that creates an instance of the exception without a specific error message, and another that allows the user to provide a custom error message to be associated with the exception.
By using this custom exception class, developers can ensure that errors are handled and reported in a consistent and reliable manner, rather than relying on generic exception types or ad-hoc error handling mechanisms. This can improve the overall robustness and maintainability of the system, as well as provide a more user-friendly experience for those interacting with it. | Code |
Delay.java | package smos.bean;
import java.io.Serializable;
import java.util.Date;
public class Delay implements Serializable {
/**
* Classe che modella un entrata in ritardo di uno studente
* @author Nicola Pisanti
* @version 1.0
*/
private static final long serialVersionUID = 78680884161960621L;
private int idDelay;
private int idUser;
private Date dateDelay;
private String timeDelay;
private int academicYear;
/**
* Metodo che restituisce l'id del Ritardo
* @return un intero che rappresenta l'id del ritardo
*/
public int getIdDelay() {
return idDelay;
}
/**
* Metodo che setta l'id del Ritardo
* @param intero che rappresenta l'id da settare
*/
public void setIdDelay(int pIdDelay) {
this.idDelay = pIdDelay;
}
/**
* Metodo che restituisce l'id dello studente ritardatario
* @return un intero che rappresenta l'id dello studente
*/
public int getIdUser() {
return idUser;
}
/**
* Metodo che setta l'id dello studente relativo al ritardo
* @param un intero che rappresenta l'id da settare
*/
public void setIdUser(int pIdUser) {
this.idUser = pIdUser;
}
/**
* Metodo che restituisce la data del ritardo
* @return una stringa che rappresenta la data del ritardo
*/
public Date getDateDelay() {
return dateDelay;
}
/**
* Metodo che setta la data del ritardo
* @param una stringa che rappresenta la data del ritardo
*/
public void setDateDelay(Date pDateDelay) {
this.dateDelay = pDateDelay;
}
/**
* Metodo che restituisce l'ora d'entrata dello studente
* @return una stringa che rappresenta l'ora di entrata dello studente ritardatario
*/
public String getTimeDelay() {
if (this.timeDelay.length() > 0){
return timeDelay.substring(0, 5);
} else {
return this.timeDelay;
}
}
/**
* Metodo che setta l'ora di entrata dello studente
* @param una stringa che rappresenta l'ora di entrata da settare
*/
public void setTimeDelay(String pTimeDelay) {
this.timeDelay = pTimeDelay;
}
/**
* Metodo che restituisce l'anno accademico relativo all'assenza
* @return un intero che rappresenta l'anno in cui è iniziato l'anno accademico
*/
public int getAcademicYear() {
return academicYear;
}
/**
* Metodo che setta l'anno accademico relativo all'assenza
* @param un intero che rappresenta l'anno accademico da settare
*/
public void setAcademicYear(int pAcademicYear) {
this.academicYear = pAcademicYear;
}
}
| The "Delay" class provides a way for users to create and manage records of student late arrivals. The class has several properties, including an ID for the delay, the ID of the student who was late, the date and time of the late arrival, and the academic year in which the late arrival occurred. The class provides a set of getter and setter methods for each of these properties, allowing the user to access and modify the values as needed.
The class also includes some additional logic, such as a method to extract the time of the late arrival from the "timeDelay" property. This suggests that the class is part of a larger system that tracks and manages student attendance and tardiness, and the "Delay" class is used to store and manipulate this information.
Overall, the "Delay" class provides a way for users to create, store, and manipulate records of student late arrivals, which could be useful for a variety of purposes, such as tracking attendance, enforcing school policies, or generating reports on student tardiness. | Code |
DeleteAdministratorException.java | package smos.exception;
/**
* Questa classe rappresenta l'eccezione generata quando un utente
* tenta di eliminare l'unico utente Admin nel database.
*/
public class DeleteAdministratorException extends Exception {
/**
*
*/
private static final long serialVersionUID = -2081143475624381775L;
/**
* Genera l'eccezione senza un messaggio di errore associato.
*
*/
public DeleteAdministratorException() {
super("Impossibile eliminare l'utente, l'utente selezionato e' l'unico Admin presente nel database! Creare un nuovo Manager e riprovare!");
}
/**
* Genera l'eccezione con un messagio di errore associato.
*
* @param pMessage Il messaggio di errore che deve essere associato
* all'eccezione.
*/
public DeleteAdministratorException(String pMessage) {
super(pMessage);
}
}
| The `DeleteAdministratorException` class provides a mechanism to prevent the deletion of the only administrator user in a software system's database. This exception is designed to ensure that there is always at least one administrator user available to manage the system, which is a critical security measure.
The exception class offers two constructors: one that generates the exception without a specific error message, and another that allows the caller to provide a custom error message. The default error message informs the user that the selected user is the only administrator in the database and that they must create a new manager user before attempting to delete the administrator.
This exception class is likely used in a larger software system that manages user accounts and permissions. When a user attempts to delete the last administrator user, the system would catch this exception and display the appropriate error message to the user, preventing the deletion and maintaining the system's administrative capabilities. | Code |
DeleteManagerException.java | package smos.exception;
import java.lang.Exception;
/**
* Questa classe rappresenta l'eccezione generata quando un utente
* tenta di eliminare l'unico utente Manager nel database.
*/
public class DeleteManagerException extends Exception {
private static final long serialVersionUID = -6441256751177339494L;
/**
* Genera l'eccezione senza un messaggio di errore associato.
*
*/
public DeleteManagerException() {
super("Impossibile eliminare l'utente, l'utente selezionato e' l'unico Manager presente nel database! Creare un nuovo Manager e riprovare!");
}
/**
* Genera l'eccezione con un messagio di errore associato.
*
* @param pMessage Il messaggio di errore che deve essere associato
* all'eccezione.
*/
public DeleteManagerException(String pMessage) {
super(pMessage);
}
}
| The `DeleteManagerException` class is designed to prevent the deletion of the last remaining "Manager" user in a software system's database. This exception is likely used in other parts of the system to handle the scenario where a user attempts to delete the sole Manager user.
The exception class provides two constructors: one that generates a default error message explaining the reason for the exception and suggesting a solution, and another that allows for a custom error message to be provided. When the `DeleteManagerException` is thrown, the system can then handle the exception appropriately, such as by displaying an error message to the user or taking some other action to prevent the deletion.
The purpose of this exception is to ensure that the critical Manager role is not accidentally or intentionally removed from the system, as this could have significant consequences for the overall functionality and security of the software. By providing this exception, the developers have implemented a safeguard to protect the integrity of the system and its data. | Code |
DuplicatedEntityException.java | package smos.exception;
import java.lang.Exception;
/**
* Questa classe rappresenta l'eccezione generata quando si
* tenta di inserire un'entità già presente nel database.
*/
public class DuplicatedEntityException extends Exception {
private static final long serialVersionUID = 4858261134352455533L;
/**
* Genera l'eccezione senza un messagio di errore associato.
*/
public DuplicatedEntityException() {
super("Duplicate Key into the Repository!");
}
/**
* Genera l'eccezione con un messagio di errore associato.
*
* @param pMessage Il messaggio di errore che deve essere associato
* all'eccezione.
*/
public DuplicatedEntityException (String pMessage) {
super(pMessage);
}
} | The `DuplicatedEntityException` class provides a way for the system to signal that an attempt has been made to insert an entity into a repository (such as a database) that already exists. This exception can be thrown when the system is trying to add a new entity, such as a user account, but the entity's identifier (e.g., username or email address) already exists in the repository.
By throwing this exception, the system can inform the calling code that the insert operation failed due to a duplicate entity, allowing the calling code to handle the situation appropriately (e.g., by notifying the user that the entity already exists and prompting them to choose a different identifier). The exception class extends the base `Exception` class, which means it can be caught and handled by the calling code using standard exception handling mechanisms, enabling the system to gracefully handle and recover from the duplicate entity situation. | Code |
EntityNotFoundException.java | package smos.exception;
import java.lang.Exception;
/**
* Questa classe rappresenta l'eccezione generata quando un'entita'
* non viene trovata nel database.
*/
public class EntityNotFoundException extends Exception {
private static final long serialVersionUID = -1236105333523133721L;
/**
* Genera l'eccezione senza un messagio di errore associato.
*/
public EntityNotFoundException() {
super("Object Not Found in Repository!");
}
/**
* Genera l'eccezione con un messagio di errore associato.
*
* @param pMessage Il messaggio di errore che deve essere associato
* all'eccezione.
*/
public EntityNotFoundException(String pMessage) {
super(pMessage);
}
} | The `EntityNotFoundException` class provides a way for the software system to handle situations where an expected entity (such as an object or record) is not found in the database or repository. When this exception is thrown, it indicates that the requested entity could not be located, allowing the system to provide more informative error handling and feedback to the user.
The class offers two constructors: one that generates the exception without a specific error message, and another that allows the user to provide a custom error message. By extending the base `Exception` class, the `EntityNotFoundException` can be caught and handled by the surrounding code, enabling the system to gracefully respond to the missing entity scenario and offer the user appropriate feedback or alternative actions to take.
This exception-handling mechanism is a crucial component of the software system, as it helps to ensure that users are informed when their requested data or functionality is not available, rather than encountering more generic or cryptic errors. By providing this level of transparency and error handling, the system can improve the overall user experience and help users navigate situations where the expected data or functionality is not present. | Code |
Environment.java | package smos;
/**
* Classe utilizzata per contenere le variabili d'ambiente di GESA
*/
public class Environment {
/**
* Messaggio di errore di default.
*/
public static String DEFAULT_ERROR_MESSAGE = "Un errore si e' verificato durante l'elaborazione della richiesta.<br><br>";
private static String poolPropertiesPath = "";
/**
* @return getPoolPropertiesPath()
*/
public static String getPoolPropertiesPath() {
return poolPropertiesPath;
}
/**
* @param poolPropertiesPath
*/
public static void setPoolPropertiesPath(String poolPropertiesPath) {
Environment.poolPropertiesPath = poolPropertiesPath;
}
} | The `Environment` class in this code provides a centralized location for managing environment-specific configuration information for the GESA software system. The class defines a default error message that can be used throughout the system, as well as methods for retrieving and setting the path to a properties file that contains configuration information for a connection pool used by the GESA system. This connection pool is likely used to manage database connections or other resources required by the GESA system.
By encapsulating these environment-specific variables and methods in a dedicated class, the code promotes modularity and maintainability, as changes to the environment configuration can be made in a single location without affecting the rest of the system. This allows the user to easily manage and update the GESA system's environment configuration as needed, ensuring that the system can adapt to changing requirements or infrastructure changes. | Code |
Justify.java | package smos.bean;
import java.io.Serializable;
import java.util.Date;
public class Justify implements Serializable {
/**
* Classe che modella una giustifica per un assenza
* @author Nicola Pisanti
* @version 1.0
*
*/
private static final long serialVersionUID = -4726381877687167661L;
private int idJustify;
private int idUser;
private Date dateJustify;
private int academicYear;
/**
* Metodo che restituisce l'id della giustifica
* @return un intero che rappresenta l'id della giustifica
*/
public int getIdJustify() {
return idJustify;
}
/**
* Metodo che setta l'id della giustifica
* @param un intero che rappresenta l'id da settare
*/
public void setIdJustify(int pIdJustify) {
this.idJustify = pIdJustify;
}
/**
* Metodo restituisce l'id dello studente relativo alla giustifica
* @return un intero che rappresenta l'id dello studente
*/
public int getIdUser() {
return idUser;
}
/**
* Metodo che setta l'id dello studente relativo alla giustifica
* @param un intero che rappresenta l'id da settare
*/
public void setIdUser(int pIdUser) {
this.idUser = pIdUser;
}
/**
* Metodo che restituisce la data alla quale è stata giustificata l'assenza
* @return una stringa che rappresenta la data giustificata
*/
public Date getDateJustify() {
return dateJustify;
}
/**
* Metodo che setta la data alla quale è stata giustificata l'assenza
* @param una stringa che rappresenta la data da settare
*/
public void setDateJustify(Date pDateJustify) {
this.dateJustify = pDateJustify;
}
/**
* Metodo che restituisce l'anno accademico relativo alla giustifica
* @return un intero che rappresenta l'anno in cui è iniziato l'anno accademico
*/
public int getAcademicYear() {
return academicYear;
}
/**
* Metodo che setta l'anno accademico relativo alla giustifica
* @param un intero che rappresenta l'anno accademico da settare
*/
public void setAcademicYear(int pAcademicYear) {
this.academicYear = pAcademicYear;
}
}
| The "Justify" class provides a way for users to manage justifications for absences within a software system. Users can create and store justifications, each with a unique ID, the ID of the associated user, the date the justification was made, and the academic year it is associated with. The class provides methods to retrieve and update these properties, allowing users to easily access and modify the details of each justification as needed. This functionality enables users to effectively track and manage the justifications for absences within the system, supporting the overall management of student attendance and academic records. | Code |
LoginException.java | package smos.exception;
import java.lang.Exception;
/**
* Questa classe rappresenta l'eccezione generata quando un utente
* inserisce una password errata durante l'autenticazione
*/
public class LoginException extends Exception {
private static final long serialVersionUID = -1213284697567763493L;
/**
* Genera l'eccezione senza un messagio di errore associato.
*/
public LoginException() {
super("Login or Password Incorrect or Invalid Session!");
}
/**
* Genera l'eccezione con un messagio di errore associato.
*
* @param pMessage Il messaggio di errore che deve essere associato
* all'eccezione.
*/
public LoginException(String pMessage) {
super(pMessage);
}
} | This code defines a specialized exception class called `LoginException` that is used to represent errors that occur during the user authentication process. The purpose of this exception class is to provide more detailed and meaningful error information to the software system, rather than relying on generic error messages or exceptions.
When a user attempts to log in with an incorrect username or password, or when their session becomes invalid, the system can throw a `LoginException` with a specific error message that provides more context about the nature of the error. This allows the user interface to display a more informative error message to the user, which can be helpful for debugging, logging, and providing feedback.
By using a specialized exception class like `LoginException`, the software system can handle authentication-related errors in a more structured and meaningful way, improving the overall user experience and making it easier to identify and address any issues that may arise. | Code |
MailUtility.java | package smos.utility;
import java.io.UnsupportedEncodingException;
import java.util.Properties;
import javax.mail.*;
import javax.mail.internet.*;
public class MailUtility {
public static void sendMail(String pSender, String pReceiver, String pSubject, String pText) throws MessagingException, UnsupportedEncodingException {
// Creazione di una mail session
Properties props = new Properties();
props.put("mail.smtp.host", Utility.getServerSmtp());
Session session = Session.getDefaultInstance(props);
// Creazione del messaggio da inviare
MimeMessage message = new MimeMessage(session);
message.setSubject(pSubject);
message.setText(pText);
// Aggiunta degli indirizzi del mittente e del destinatario
InternetAddress fromAddress = new InternetAddress(pSender);
InternetAddress toAddress = new InternetAddress(pReceiver);
message.setFrom(fromAddress);
message.setRecipient(Message.RecipientType.TO, toAddress);
// Invio del messaggio
Transport.send(message);
}
}
| The provided code offers a utility for sending emails programmatically, allowing users to easily integrate email functionality into their software systems. By configuring the SMTP server details and constructing a MIME message with the necessary parameters (sender, receiver, subject, and text), users can leverage this utility to send emails as part of their application's functionality. This can be particularly useful in scenarios where automated email notifications or email-based workflows are required, as the code abstracts away the low-level details of email creation and delivery, making it more accessible and easier to integrate into the user's application. The code's simplicity and flexibility make it a valuable tool for developers who need to incorporate email capabilities into their software solutions. | Code |
ManagerAddress.java | package smos.storage;
import smos.bean.Address;
import smos.bean.Teaching;
import smos.exception.DuplicatedEntityException;
import smos.exception.EntityNotFoundException;
import smos.exception.InvalidValueException;
import smos.exception.MandatoryFieldException;
import smos.storage.connectionManagement.DBConnection;
import smos.storage.connectionManagement.exception.ConnectionException;
import smos.utility.Utility;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Vector;
import java.sql.Connection;
/**
*
* Classe manager degli indirizzi
*
*/
public class ManagerAddress {
private static ManagerAddress instance;
/**
* Il nome della tabella degli indirizzi
*/
public static final String TABLE_ADDRESS = "address";
public static final String TABLE_ADDRESS_HAS_TEACHING = "address_has_teaching";
private ManagerAddress() {
super();
}
/**
* Ritorna la sola istanza della classe esistente.
*
* @return Ritorna l'istanza della classe.
*/
public static synchronized ManagerAddress getInstance(){
if(instance==null){
instance = new ManagerAddress();
}
return instance;
}
/**
* Verifica l'esistenza di un indirizzo nel database.
*
* @param pAddress
* L'indirizzo da controllare.
* @return Ritorna true se esiste già l'indirizzo passato come parametro,
* false altrimenti.
*
* @throws MandatoryFieldException
* @throws SQLException
* @throws MandatoryFieldException
* @throws ConnectionException
* @throws ConnectionException
* @throws SQLException
*/
public synchronized boolean hasTeaching(Teaching pTeaching, Address pAddress)
throws SQLException, EntityNotFoundException, ConnectionException,
InvalidValueException {
Connection connect = null;
boolean result = false;
if (pTeaching.getId() <= 0)
throw new EntityNotFoundException("Specificare l'insegnamento");
try {
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Preparimao la stringa sql
String sql = "SELECT * FROM "
+ ManagerTeaching.TABLE_ADDRESS_TEACHINGS
+ " WHERE id_teaching = "
+ Utility.isNull(pTeaching.getId())
+" AND id_address = "
+ Utility.isNull(pAddress.getIdAddress());
// Inviamo la Query al database
ResultSet pRs = Utility.queryOperation(connect, sql);
if (pRs.next())
result = true;
return result;
} finally {
// rilasciamo le risorse
DBConnection.releaseConnection(connect);
}
}
public synchronized boolean exists (Address pAddress) throws MandatoryFieldException, ConnectionException, SQLException {
boolean result= false;
Connection connect = null;
if (pAddress.getName() == null)
throw new MandatoryFieldException("Specificare il nome.");
try{
//Otteniamo la connessione al database
connect= DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
String sql =" SELECT * FROM "
+ ManagerAddress.TABLE_ADDRESS
+ " WHERE name = "
+ Utility.isNull(pAddress.getName());
ResultSet tRs = Utility.queryOperation(connect, sql);
if(tRs.next())
result = true;
return result;
}
finally{
DBConnection.releaseConnection(connect);
}
}
/**
* Inserisce un nuovo indirizzo nella tabella address.
*
* @param pAddress
* L'indirizzo da inserire.
*
* @throws SQLException
* @throws ConnectionException
* @throws MandatoryFieldException
* @throws EntityNotFoundException
* @throws InvalidValueException
*/
public synchronized void insert(Address pAddress)
throws MandatoryFieldException, ConnectionException,
SQLException, EntityNotFoundException,
InvalidValueException{
Connection connect= null;
try{
// controllo dei campi obbligatori
if(pAddress.getName()==null)
throw new MandatoryFieldException("Specificare il campo nome");
connect = DBConnection.getConnection();
if (connect==null)
throw new ConnectionException();
//Prepariamo la stringa Sql
String sql =
"INSERT INTO "
+ ManagerAddress.TABLE_ADDRESS
+ " (name) "
+ "VALUES ("
+ Utility.isNull(pAddress.getName())
+ ")";
Utility.executeOperation(connect,sql);
pAddress.setIdAddress(Utility.getMaxValue("id_address",ManagerAddress.TABLE_ADDRESS));
}finally {
//rilascia le risorse
DBConnection.releaseConnection(connect);
}
}
/**
* Elimina un indirizzo dalla tabella address.
*
* @param pAddress
* L'indirizzo da eliminare.
*
* @throws MandatoryFieldException
* @throws EntityNotFoundException
* @throws SQLException
* @throws ConnectionException
* @throws InvalidValueException
*
*/
public synchronized void delete (Address pAddress) throws ConnectionException,
SQLException, EntityNotFoundException, MandatoryFieldException, InvalidValueException {
Connection connect = null;
try {
//ManagerAddress.getInstance().AddressOnDeleteCascade(pAddress);
connect = DBConnection.getConnection();
//Prepariamo la stringa SQL
String sql = "DELETE FROM "
+ ManagerAddress.TABLE_ADDRESS
+ " WHERE id_address = "
+ Utility.isNull(pAddress.getIdAddress());
Utility.executeOperation(connect, sql);
}
finally {
//rilascia le risorse
DBConnection.releaseConnection(connect);
}
}
public synchronized void assignTeachingAsAddress (Address pAddress, Teaching pTeaching) throws ConnectionException,
SQLException, EntityNotFoundException, MandatoryFieldException, InvalidValueException, DuplicatedEntityException {
Connection connect = null;
ManagerAddress managerAddress = ManagerAddress.getInstance();
if(managerAddress.hasTeaching(pTeaching, pAddress))
throw new DuplicatedEntityException("Questo indirizzo ha già quest'insegnamento associato");
try {
//ManagerAddress.getInstance().AddressOnDeleteCascade(pAddress);
connect = DBConnection.getConnection();
//Prepariamo la stringa SQL
String sql = "INSERT INTO "
+ ManagerAddress.TABLE_ADDRESS_HAS_TEACHING
+ " (id_address, id_teaching) "
+ " VALUES( "
+ Utility.isNull(pAddress.getIdAddress())
+ " , "
+ Utility.isNull(pTeaching.getId())
+ " )";
Utility.executeOperation(connect, sql);
}
finally {
//rilascia le risorse
DBConnection.releaseConnection(connect);
}
}
public synchronized void removeTeachingAsAddress (Address pAddress, Teaching pTeaching) throws ConnectionException,
SQLException, EntityNotFoundException, MandatoryFieldException, InvalidValueException {
Connection connect = null;
ManagerAddress managerAddress = ManagerAddress.getInstance();
if(!managerAddress.hasTeaching(pTeaching, pAddress))
throw new EntityNotFoundException("Questo indirizzo non contiene l'insegnamento da rimuovere");
try {
//ManagerAddress.getInstance().AddressOnDeleteCascade(pAddress);
connect = DBConnection.getConnection();
//Prepariamo la stringa SQL
String sql = "DELETE FROM "
+ ManagerAddress.TABLE_ADDRESS_HAS_TEACHING
+ " WHERE id_address= "
+ Utility.isNull(pAddress.getIdAddress())
+ " AND id_teaching = "
+ Utility.isNull(pTeaching.getId());
Utility.executeOperation(connect, sql);
}
finally {
//rilascia le risorse
DBConnection.releaseConnection(connect);
}
}
/**
* Ritorna l'id dell'indirizzo passato come parametro.
*
* @param pAddress
* L'indirizzo di cui si richiede l'id.
* @return Ritorna l'id dell'indirizzo passato come parametro.
*
* @throws EntityNotFoundException
* @throws ConnectionException
* @throws SQLException
*/
public synchronized int getAddressId(Address pAddress)
throws EntityNotFoundException, ConnectionException, SQLException {
int result = 0;
Connection connect = null;
try {
if (pAddress == null)
throw new EntityNotFoundException("Impossibile trovare l'indirizzo!");
/*
* Prepariamo la stringa SQL per recuperare le informazioni
* corrispondenti all'id dell'indirizzo passato come parametro.
*/
String tSql = "SELECT id_address FROM "
+ ManagerAddress.TABLE_ADDRESS
+ " WHERE name = "
+ Utility.isNull(pAddress.getName());
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, tSql);
if (tRs.next())
result = tRs.getInt("id_address");
return result;
} finally {
DBConnection.releaseConnection(connect);
}
}
/**
* Ritorna l'indirizzo corrispondente all'id passato come parametro.
*
* @param pIdAddress
* L'id dell'indirizzo.
* @return Ritorna l'indirizzo associato all'id passato come parametro.
*
* @throws ConnectionException
* @throws SQLException
* @throws EntityNotFoundException
* @throws InvalidValueException
*/
public synchronized Address getAddressById (int pIdAddress) throws ConnectionException, SQLException, EntityNotFoundException, InvalidValueException{
Address result = null;
Connection connect = null;
try
{
if (pIdAddress <= 0)
throw new EntityNotFoundException("Impossibile trovare l'indirizzo!");
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Prepariamo la stringa SQL
String sql =
"SELECT * FROM "
+ ManagerAddress.TABLE_ADDRESS
+ " WHERE id_address = "
+ Utility.isNull(pIdAddress);
// Inviamo la Query al DataBase
ResultSet pRs = Utility.queryOperation(connect, sql);
if (pRs.next())
result = this.loadRecordFromRs(pRs);
else
throw new EntityNotFoundException("Impossibile trovare l'utente!");
return result;
}finally{
//rilascia le risorse
DBConnection.releaseConnection(connect);
}
}
/**
* Ritorna l'insieme di tutti gli indirizzi presenti nel database.
*
* @return Ritorna una collection di indirizzi.
*
* @throws ConnectionException
* @throws EntityNotFoundException
* @throws SQLException
* @throws InvalidValueException
*/
public synchronized Collection<Address> getAddressList() throws ConnectionException, EntityNotFoundException, SQLException, InvalidValueException{
Connection connect = null;
Collection<Address> result = new Vector<Address>();;
try {
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
//Prepariamo la stringa sql
String sql = "SELECT * "
+ " FROM "
+ ManagerAddress.TABLE_ADDRESS
+ " ORDER BY id_address";
//Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, sql);
if (tRs.next())
result = this.loadRecordsFromRs(tRs);
return result;
} finally {
//rilascia le risorse
DBConnection.releaseConnection(connect);
}
}
/**
* Ritorna il nome dell'indirizzo corrispondente all'id
* passato come parametro.
*
* @param pIdAddress
* L'id dell'indirizzo.
* @return Ritorna una stringa contenente il nome dell'indirizzo.
*
* @throws EntityNotFoundException
* @throws ConnectionException
* @throws SQLException
*/
public synchronized String getAddressNameById(int pIdAddress) throws EntityNotFoundException, ConnectionException, SQLException{
String result;
Connection connect = null;
try
{
// Se non e' stato fornito l'id restituiamo un codice di errore
if (pIdAddress <= 0)
throw new EntityNotFoundException("Impossibile trovare l'indirizzo!");
/*
* Prepariamo la stringa SQL per recuperare le informazioni
* corrispondenti all'id dell'utente passato come parametro
*/
String tSql =
"SELECT name FROM "
+ ManagerAddress.TABLE_ADDRESS
+ " WHERE id_address = "
+ Utility.isNull(pIdAddress) ;
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, tSql);
if (tRs.next())
result = tRs.getString("name");
else
throw new EntityNotFoundException("Impossibile trovare l'indirizzo!");
return result;
}finally{
DBConnection.releaseConnection(connect);
}
}
/**
* Ritorna una collection con gli id degli insegnamenti associati all'id
* passato come parametro.
*
* @param pIdAddress
* L'id dell'indirizzo.
* @return Ritorna una collection con di int
*
* @throws EntityNotFoundException
* @throws ConnectionException
* @throws SQLException
* @throws InvalidValueException
*/
public synchronized Collection<Integer> getAddressTechings(int pIdAddress) throws EntityNotFoundException, ConnectionException, SQLException, InvalidValueException{
Collection<Integer> result;
Connection connect = null;
try
{
// Se non e' stato fornito l'id restituiamo un codice di errore
if (pIdAddress <= 0)
throw new EntityNotFoundException("Impossibile trovare l'indirizzo!");
/*
* Prepariamo la stringa SQL per recuperare le informazioni
* corrispondenti all'id dell'utente passato come parametro
*/
String tSql =
"SELECT id_teaching FROM "
+ ManagerAddress.TABLE_ADDRESS_HAS_TEACHING
+ " WHERE id_address = "
+ Utility.isNull(pIdAddress) ;
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, tSql);
result = this.loadIntegersFromRs(tRs);
return result;
}finally{
DBConnection.releaseConnection(connect);
}
}
/*
* Consente la lettura di un record dal ResultSet.
*/
private Address loadRecordFromRs(ResultSet pRs) throws SQLException, InvalidValueException{
Address address = new Address();
address.setName(pRs.getString("name"));
address.setIdAddress(pRs.getInt("id_address"));
return address;
}
/*
* Consente la lettura dei record dal ResultSet.
*/
private Collection<Address> loadRecordsFromRs(ResultSet pRs) throws SQLException, InvalidValueException{
Collection<Address> result = new Vector<Address>();
do {
result.add(loadRecordFromRs(pRs));
} while (pRs.next());
return result;
}
private Collection<Integer> loadIntegersFromRs(ResultSet pRs) throws SQLException, InvalidValueException{
Collection<Integer> result = new Vector<Integer>();
while(pRs.next()) {
result.add(pRs.getInt("id_teaching"));
}
return result;
}
}
| This code provides a comprehensive set of functionalities for managing addresses within a database system. Users can perform various operations, such as checking if an address exists, inserting new addresses, deleting addresses, and associating or disassociating addresses with teachings. The code ensures data integrity by validating mandatory fields, handling duplicate entities, and managing the relationships between addresses and teachings. Additionally, users can retrieve address information, including the ID, name, and associated teachings, allowing them to efficiently manage and access address data within the system. The code's modular design and use of utility classes and exception handling make it a robust and maintainable solution for address management. | Code |
ManagerClassroom.java | package smos.storage;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;
import java.util.Iterator;
import java.util.Vector;
import smos.bean.Classroom;
import smos.bean.User;
import smos.exception.EntityNotFoundException;
import smos.exception.InvalidValueException;
import smos.exception.MandatoryFieldException;
import smos.storage.connectionManagement.DBConnection;
import smos.storage.connectionManagement.exception.ConnectionException;
import smos.utility.Utility;
public class ManagerClassroom {
/**
* Classe che gestiste le classi dell'istituto
* @author Nicola Pisanti
* @version 1.0
*/
private static ManagerClassroom instance;
public static final String TABLE_CLASSROOM = "classroom";
public static final String TABLE_ADDRESS ="address";
public static final String TABLE_TEACHER_HAS_CLASSROOM = "teacher_has_classroom";
public static final String TABLE_STUDENT_HAS_CLASSROOM = "student_has_classroom";
private ManagerClassroom(){
super();
}
/**
* Ritorna la sola istanza della classe esistente.
*
* @return Ritorna l'istanza della classe.
*/
public static synchronized ManagerClassroom getInstance(){
if(instance==null){
instance = new ManagerClassroom();
}
return instance;
}
/**
* Verifica se la classe data in input è nel database
* @param La classe di cui bisogna verificare l'esistenza
* @return true se la classe è nel database, altrimenti false
* @throws MandatoryFieldException
* @throws ConnectionException
* @throws SQLException
*/
public synchronized boolean exists (Classroom pClassroom) throws MandatoryFieldException, ConnectionException, SQLException {
boolean result = false;
Connection connect = null;
if (pClassroom.getName() == null)
throw new MandatoryFieldException("Specificare il nome della classe.");
if (pClassroom.getAcademicYear() <=1970)
throw new MandatoryFieldException("Specificare l'anno accademico");
if (pClassroom.getIdAddress()<=0){
throw new MandatoryFieldException("Specificare l'indirizzo");
//l'utente inserisce l'indirizzo, viene convertito in idAddress
}
try {
//Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
String sql = "SELECT * FROM "
+ ManagerClassroom.TABLE_CLASSROOM
+ " WHERE name = "
+ Utility.isNull(pClassroom.getName())
+ " AND accademic_year = "
+ Utility.isNull(pClassroom.getAcademicYear()
+ " AND id_address = "
+ Utility.isNull(pClassroom.getIdAddress())
);
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, sql);
if (tRs.next())
result = true;
return result;
} finally {
DBConnection.releaseConnection(connect);
}
}
/**
* Inserisce l'oggetto di tipo classe nel database
* @param la classe da inserire nel database
* @throws MandatoryFieldException
* @throws ConnectionException
* @throws SQLException
* @throws EntityNotFoundException
* @throws InvalidValueException
*/
public synchronized void insert(Classroom pClassroom) throws MandatoryFieldException,
ConnectionException, SQLException, EntityNotFoundException, InvalidValueException{
Connection connect= null;
try{
// controllo dei campi obbligatori
if (pClassroom.getName() == null)
throw new MandatoryFieldException("Specificare il nome della classe.");
if (pClassroom.getAcademicYear() <=1970)
throw new MandatoryFieldException("Specificare l'anno accademico");
if (pClassroom.getIdAddress()<=0){
throw new MandatoryFieldException("Specificare l'indirizzo");
//l'utente inserisce l'indirizzo, viene convertito in idAddress
}
connect = DBConnection.getConnection();
if (connect==null)
throw new ConnectionException();
//Prepariamo la stringa Sql
String sql =
"INSERT INTO "
+ ManagerClassroom.TABLE_CLASSROOM
+ " (id_address, name, accademic_year) "
+ "VALUES ("
+ Utility.isNull(pClassroom.getIdAddress())
+ ","
+ Utility.isNull(pClassroom.getName())
+ ","
+ Utility.isNull(pClassroom.getAcademicYear())
+ ")";
Utility.executeOperation(connect,sql);
pClassroom.setIdClassroom((Utility.getMaxValue("id_classroom",ManagerClassroom.TABLE_CLASSROOM)));
}finally {
//rilascia le risorse
DBConnection.releaseConnection(connect);
}
}
/**
* Aggiorna le statistiche di una classe
* @param La classe con le statistiche aggiornate (ma ID identico)
* @throws ConnectionException
* @throws SQLException
* @throws EntityNotFoundException
* @throws MandatoryFieldException
*/
public synchronized void update (Classroom pClassroom) throws ConnectionException,
SQLException, EntityNotFoundException, MandatoryFieldException{
Connection connect= null;
try{
if (pClassroom.getIdClassroom()<=0)
throw new EntityNotFoundException("Impossibile trovare la classe!");
if (pClassroom.getName() == null)
throw new MandatoryFieldException("Specificare il nome della classe.");
if (pClassroom.getAcademicYear() <=1970)
throw new MandatoryFieldException("Specificare l'anno accademico");
if (pClassroom.getIdAddress()<=0){
throw new MandatoryFieldException("Specificare l'indirizzo");
//l'utente inserisce l'indirizzo, viene convertito in idAddress
}
//Prepariamo la stringa SQL
String sql=
"UPDATE "
+ ManagerClassroom.TABLE_CLASSROOM
+ " SET"
+ " id_address = "
+ Utility.isNull(pClassroom.getIdAddress())
+ ", name = "
+ Utility.isNull(pClassroom.getName())
+ ", accademic_year = "
+ Utility.isNull(pClassroom.getAcademicYear())
+ " WHERE id_classroom = "
+ Utility.isNull(pClassroom.getIdClassroom());
//effettua una nuova connessione e invia la query
connect = DBConnection.getConnection();
if (connect==null)
throw new ConnectionException();
Utility.executeOperation(connect, sql);
}finally {
//rilascia le risorse
DBConnection.releaseConnection(connect);
}
}
/**
* Cancella una classe dal database
* @param La classe da cancellare
* @throws ConnectionException
* @throws SQLException
* @throws EntityNotFoundException
* @throws MandatoryFieldException
* @throws InvalidValueException
*/
public synchronized void delete (Classroom pClassroom) throws ConnectionException,
SQLException, EntityNotFoundException, MandatoryFieldException, InvalidValueException {
Connection connect = null;
try {
//ManagerUser.getInstance().userOnDeleteCascade(pUser);
connect = DBConnection.getConnection();
//Prepariamo la stringa SQL
String sql = "DELETE FROM "
+ ManagerClassroom.TABLE_CLASSROOM
+ " WHERE id_classroom = "
+ Utility.isNull(pClassroom.getIdClassroom());
Utility.executeOperation(connect, sql);
}finally {
//rilascia le risorse
DBConnection.releaseConnection(connect);
}
}
public synchronized Collection<Classroom> getClassroomsByStudent(User pUser) throws EntityNotFoundException, ConnectionException, SQLException, InvalidValueException, MandatoryFieldException{
Collection<Classroom> result=null;
Connection connect = null;
ManagerUser managerUser = ManagerUser.getInstance();
try
{
// Se non esiste l'utente
if (!managerUser.exists(pUser))
throw new EntityNotFoundException("L'utente non esiste!!!");
if(!managerUser.isStudent(pUser))
throw new InvalidValueException("L'utente non è uno studente!");
/*
* Prepariamo la stringa SQL per recuperare le informazioni
* corrispondenti alla classe dell'id passato
*/
int iduser=managerUser.getUserId(pUser);
String tSql =
"SELECT "
+ ManagerClassroom.TABLE_CLASSROOM
+".* FROM "
+ ManagerClassroom.TABLE_STUDENT_HAS_CLASSROOM
+ ", "
+ ManagerClassroom.TABLE_CLASSROOM
+ " WHERE "
+ ManagerClassroom.TABLE_STUDENT_HAS_CLASSROOM
+ ".id_user = "
+ Utility.isNull(iduser)
+" AND "
+ ManagerClassroom.TABLE_CLASSROOM
+".id_classroom = "
+ ManagerClassroom.TABLE_STUDENT_HAS_CLASSROOM
+".id_classroom";
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, tSql);
result = this.loadRecordsFromRs(tRs);
if(result.isEmpty())
throw new EntityNotFoundException("Impossibile Trovare Classi per l'utente inserito");
return result;
}finally{
DBConnection.releaseConnection(connect);
}
}
/**
* Restituisce la classe che ha l'ID passato
* @param L'ID della classe cercata
* @return una stringa che rappresenta la classe con l'ID fornito
* @throws EntityNotFoundException
* @throws ConnectionException
* @throws SQLException
* @throws InvalidValueException
*/
public synchronized Classroom getClassroomByID(int pId) throws EntityNotFoundException, ConnectionException, SQLException, InvalidValueException{
Classroom result=null;
Connection connect = null;
try
{
// Se non è stato fornito l'id restituiamo un codice di errore
if (pId <= 0)
throw new EntityNotFoundException("Impossibile trovare la classe!");
/*
* Prepariamo la stringa SQL per recuperare le informazioni
* corrispondenti alla classe dell'id passato
*/
String tSql =
"SELECT * FROM "
+ ManagerClassroom.TABLE_CLASSROOM
+ " WHERE id_classroom = "
+ Utility.isNull(pId) ;
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, tSql);
if (tRs.next())
result = this.loadRecordFromRs(tRs);
else
throw new EntityNotFoundException("Impossibile trovare l'utente!");
return result;
}finally{
DBConnection.releaseConnection(connect);
}
}
/**
* Restituisce una collezione di classi dello stesso anno accademico
*/
public synchronized Collection<Classroom> getClassroomsByAcademicYear(int pAcademicYear) throws EntityNotFoundException, ConnectionException, SQLException, InvalidValueException{
Collection<Classroom> result=null;
Connection connect = null;
try
{
// Se non è stato fornito l'id restituiamo un codice di errore
if (pAcademicYear <= 1970)
throw new EntityNotFoundException("Data troppo vecchia");
/*
* Prepariamo la stringa SQL per recuperare le informazioni
* corrispondenti alla classe dell'id passato
*/
String tSql =
"SELECT * FROM "
+ ManagerClassroom.TABLE_CLASSROOM
+ " WHERE accademic_year = "
+ Utility.isNull(pAcademicYear) ;
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, tSql);
result = this.loadRecordsFromRs(tRs);
if(result.isEmpty())
throw new EntityNotFoundException("Impossibile Trovare Classi per la data inserita");
return result;
}finally{
DBConnection.releaseConnection(connect);
}
}
public synchronized Collection<Integer> getAcademicYearList() throws EntityNotFoundException, ConnectionException, SQLException, InvalidValueException{
Collection<Integer> result=null;
Connection connect = null;
try
{
/*
* Prepariamo la stringa SQL per recuperare le informazioni
* corrispondenti alla classe dell'id passato
*/
String tSql =
"SELECT DISTINCT accademic_year FROM "
+ ManagerClassroom.TABLE_CLASSROOM
+ " order by accademic_year ";
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, tSql);
result = this.loadIntegersFromRs(tRs);
if(result.isEmpty())
throw new EntityNotFoundException("Impossibile Trovare Classi per la data inserita");
return result;
}finally{
DBConnection.releaseConnection(connect);
}
}
public synchronized Classroom getClassroomByUserAcademicYear(User pUser, int pAcademicYear) throws EntityNotFoundException, ConnectionException, SQLException, InvalidValueException, MandatoryFieldException{
Classroom result = null;
Classroom temp = null;
ManagerClassroom managerClassroom = ManagerClassroom.getInstance();
Collection<Classroom> list = null;
list = managerClassroom.getClassroomsByStudent(pUser);
Iterator<Classroom> it = list.iterator();
while(it.hasNext()){
temp = it.next();
if(temp.getAcademicYear()==pAcademicYear){
result = temp;
break;
}
}
return result;
}
public synchronized Collection<Classroom> getClassroomsByTeacherAcademicYear(User pUser, int pAcademicYear) throws EntityNotFoundException, ConnectionException, SQLException, InvalidValueException, MandatoryFieldException{
Collection<Classroom> result = null;
Connection connect = null;
int idUser = pUser.getId();
try
{
// Se non è stato fornito l'id restituiamo un codice di errore
if (pAcademicYear <= 1970)
throw new EntityNotFoundException("Data troppo vecchia");
/*
* Prepariamo la stringa SQL per recuperare le informazioni
*
*/
String tSql =
"SELECT DISTINCT "
+ ManagerClassroom.TABLE_CLASSROOM +".* FROM "
+ ManagerClassroom.TABLE_CLASSROOM + ", "
+ ManagerClassroom.TABLE_TEACHER_HAS_CLASSROOM
+ " WHERE "
+ ManagerClassroom.TABLE_CLASSROOM + ".id_classroom = "
+ ManagerClassroom.TABLE_TEACHER_HAS_CLASSROOM
+ ".id_classroom AND "
+ ManagerClassroom.TABLE_CLASSROOM + ".accademic_year = "
+ Utility.isNull(pAcademicYear)
+ " AND "
+ ManagerClassroom.TABLE_TEACHER_HAS_CLASSROOM + ".id_user = "
+ Utility.isNull(idUser)
;
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, tSql);
result = this.loadRecordsFromRs(tRs);
if(result.isEmpty())
throw new EntityNotFoundException("Impossibile Trovare Classi per l'utente e l'anno inseriti");
return result;
}finally{
DBConnection.releaseConnection(connect);
}
}
public synchronized Collection<Classroom> getClassroomsByTeacher(User pUser)
throws EntityNotFoundException, ConnectionException, SQLException, InvalidValueException, MandatoryFieldException{
Collection<Classroom> result=null;
Connection connect = null;
ManagerUser managerUser = ManagerUser.getInstance();
try
{
// Se non esiste l'utente
if (!managerUser.exists(pUser))
throw new EntityNotFoundException("L'utente non esiste!!!");
if(!managerUser.isTeacher(pUser))
throw new InvalidValueException("L'utente non è uno studente!");
/*
* Prepariamo la stringa SQL per recuperare le informazioni
* corrispondenti alla classe dell'id passato
*/
int iduser=managerUser.getUserId(pUser);
String tSql =
"SELECT DISTINCT "
+ ManagerClassroom.TABLE_CLASSROOM
+".* FROM "
+ ManagerClassroom.TABLE_TEACHER_HAS_CLASSROOM
+ ", "
+ ManagerClassroom.TABLE_CLASSROOM
+ " WHERE "
+ ManagerClassroom.TABLE_TEACHER_HAS_CLASSROOM
+ ".id_user = "
+ Utility.isNull(iduser)
+" AND "
+ ManagerClassroom.TABLE_CLASSROOM
+".id_classroom = "
+ ManagerClassroom.TABLE_TEACHER_HAS_CLASSROOM
+".id_classroom";
// Otteniamo una Connessione al DataBase
connect = DBConnection.getConnection();
if (connect == null)
throw new ConnectionException();
// Inviamo la Query al DataBase
ResultSet tRs = Utility.queryOperation(connect, tSql);
result = this.loadRecordsFromRs(tRs);
if(result.isEmpty()) {
throw new EntityNotFoundException("Impossibile Trovare Classi per l'utente inserito");
}
return result;
}finally{
DBConnection.releaseConnection(connect);
}
}
/** COnsente la lettura di un intero dal recod resultSet
*
* @param pRs
* resultSet
* @return
* collection<Integer>
* @throws SQLException
* @throws InvalidValueException
*/
private Collection<Integer> loadIntegersFromRs(ResultSet pRs) throws SQLException, InvalidValueException{
Collection<Integer> result = new Vector<Integer>();
while(pRs.next()) {
result.add(pRs.getInt("accademic_year"));
}
return result;
}
/**
* Consente la lettura di un solo record dal Result Set
* @param Il result set da cui estrarre l'oggetto Classroom
* @throws SQLException
* @throws InvalidValueException
*/
private Classroom loadRecordFromRs(ResultSet pRs) throws SQLException, InvalidValueException{
Classroom classroom = new Classroom();
classroom.setName(pRs.getString("name"));
classroom.setAcademicYear(pRs.getInt("accademic_year"));
classroom.setIdClassroom(pRs.getInt("id_classroom"));
classroom.setIdAddress(pRs.getInt("id_address"));
return classroom;
}
/**
* Consente la lettura di un più record dal Result Set
* @param Il result set da cui estrarre l'oggetto Classroom
* @throws SQLException
* @throws InvalidValueException
*/
private Collection<Classroom> loadRecordsFromRs(ResultSet pRs) throws SQLException, InvalidValueException{
Collection<Classroom> result = new Vector<Classroom>();
while(pRs.next()) {
result.add(loadRecordFromRs(pRs));
}
return result;
}
}
| This code provides a comprehensive set of functionalities for managing classrooms in an educational institution. Users can perform a wide range of operations, including checking the existence of a classroom, inserting new classrooms, updating existing ones, and deleting classrooms from the database. The code also allows users to retrieve information about classrooms, such as the list of classrooms associated with a specific student, teacher, or academic year, as well as the distinct academic years for which classrooms exist. The code includes robust exception handling mechanisms to ensure the integrity and reliability of the classroom management system. By encapsulating these functionalities within a singleton class, the code ensures efficient and consistent access to the classroom management functionality throughout the application. | Code |
End of preview. Expand
in Dataset Viewer.
README.md exists but content is empty.
- Downloads last month
- 36