Dataset Viewer
id
stringlengths 12
33
| content
stringlengths 979
35k
| summary
stringlengths 0
1.65k
| layer
stringclasses 2
values |
|---|---|---|---|
F-GES-01.txt |
Requisito numero:
F-GES-01
Tipo:
Funzionale
Requisito:
Gestione dei prezzi delle camere.
Descrizione:
Per ogni camera deve essere possibile stabilire il suo prezzo base. Questo
prezzo deve essere impostabile dal gestore dell'albergo ogni qual volta egli lo
ritenga opportuno. Se si desidera modificare il prezzo base di una stanza che
in quel momento risulta occupata, il sistema dovrà avvisare l'operatore con un
messaggio per evitare che il cliente si lamenti di non aver pagato quanto
pattuito.
Input richiesto:
Si dovrà inserire l'identificatore di stanza e il prezzo ad essa relativo.
Output desiderato:
Conferma a video della modifica avvenuta, o eventuali messaggi di errore.
Criterio di accettazione:
Si deve poter accedere alla modifica del listino delle camere in ogni momento,
richiamare ogni stanza attraverso un opportuno identificatore (es. numero di
stanza); se la stanza richiesta non esiste dovrà essere visualizzato un
messaggio d'errore. Se la stanza risulta occupata, dovrà essere avvisato
l'operatore che sta facendo un'operazione rischiosa.
Aspettative collegate:
Supervisione e gestione dei prezzi delle stanze.
Requisiti collegati:
F-SOG-04, F-GES-05.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena comprensione
Software
Versione: 2.1
Data: 04/04/1998
Compilato da: Martini Roberto
Note:
| Requirement |
|
F-GES-02.txt |
Requisito numero:
F-GES-02
Tipo:
Funzionale
Requisito:
Gestione dei prezzi dei servizi e spese extra.
Descrizione:
Il sistema metterà a disposizione dell'utente le funzionalità necessarie alla
gestione del listino prezzi dei servizi extra. Dovrà quindi essere possibile
visualizzare il listino, apportare delle modifiche ai prezzi e inserire nuove
voci. Verrà anche prevista un campo "jolly" per gestire eventuali voci rare per
le quali non è conveniente prevedere una gestione specifica.
Input richiesto:
Dati del bene o servizio che si intende modificare.
Output desiderato:
Conferma della modifica effettuata e listino completo.
Criterio di
accettazione:
Si deve poter inserire il codice del servizio di cui si intende modificare il
prezzo. Il sistema ritornerà errore nel caso in cui nessuna corrispondenza sia
verificata, altrimenti restituirà i dati relativi al servizio e la possibilità di
modificarne il prezzo.
Aspettative collegate:
Supervisione e gestione dei prezzi dei servizi offerti.
Requisiti collegati:
F-SOG-02.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena comprensione
Software
Versione: 2.2
Data: 01/04/1998
Compilato da: Vincenti Paola
Note:
| Requirement |
|
F-GES-03.txt |
Requisito numero:
F-GES-03
Tipo:
Funzionale
Requisito:
Gestione archivio storico dei clienti.
Descrizione:
Il sistema deve tenere alcuni dati del cliente per tutto l'anno successivo a
quello di soggiorno. Se un cliente è già presente nell'elenco, dovranno essere
aggiornati i suoi dati. Nell’archivio saranno inseriti: nome, cognome e
indirizzo del cliente e il numero dell’ultima stanza da lui occupata
nell’albergo. Deve inoltre essere possibile recuperare e visualizzare i dati
contenuti nell’archivio storico perché l’albergatore possa avere informazioni a
lui utili in qualsiasi momento ne abbia necessità.
Input richiesto:
I dati del cliente che si ritiene utile salvare verranno presi dall'archivio clienti.
Output desiderato:
Aggiornamento archivio storico clienti.
Criterio di
accettazione:
I dati devono durare nell’archivio almeno fino alla fine dell'anno seguente a
quello di inserimento. Se un cliente è già presente nell'archivio i suoi dati
verranno aggiornati in base all'ultimo soggiorno.
Aspettative collegate:
Poter mantenere il contatto con i clienti più recenti al fine di promuovere e
pubblicizzare le offerte dell'albergo per la stagione seguente.
Requisiti collegati:
nn.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena comprensione
Software
Versione: 2.1
Data: 10/04/1998
Compilato da: Meneghini Matteo
Note:
| Requirement |
|
F-GES-04.txt |
Requisito numero:
F-GES-04
Tipo:
Funzionale
Requisito:
Configurazione delle opzioni di sistema.
Descrizione:
Alcuni parametri e dati che il sistema utilizza per svolgere le attività per cui è
stato realizzato devono poter essere impostate dal gestore dell'albergo. Dovrà
essere prevista perciò la possibilità di configurare il sistema in base alle
esigenze dell'utente. Ciò che dovrà sicuramente comparire sono le seguenti
impostazioni:
date di inizio e fine delle varie stagionalità
sconti e riduzioni da effettuare a neonati e bambini
durata massima per la quale una stanza può restare bloccata
supplemento per le varie stagionalità
costo di uno scatto telefonico
Input richiesto:
I dati di configurazione con le modifiche ritenute opportune dal gestore.
Output desiderato:
Aggiornamento configurazione di sistema.
Criterio di
accettazione:
I dati dovranno influire sulla gestione dell'albergo in base all'area di
competenza. Es. se viene previsto uno sconto per i bambini tale sconto dovrà
apparire chiaramente nel calcolo del conto finale e nella sua stampa.
Aspettative collegate:
Permettere una maggiore flessibilità al sistema.
Requisiti collegati:
F-PRE-03, F-SOG-03, F-SOG-04, F-GES-01
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Sospeso
2
Opzionale
Stabile
Piena comprensione
Software
Versione: 2.1
Data: 15/04/1998
Compilato da: Martini Roberto
Note:
| Requirement |
|
F-PRE-01.txt | Requisito numero:
F-PRE-01
Tipo:
Funzionale
Requisito:
Ricerca di camere disponibili.
Descrizione:
Permette di elencare tutte le stanze disponibili nel periodo richiesto dal
cliente. Nel caso non vi siano stanze disponibili esattamente in quel periodo
verrà mostrata la disponibilità di stanze in modo che l'operatore sia in grado
di fornire un suggerimento al cliente su come spostare o ridimensionare il
periodo di permanenza. Tale periodo è un intervallo di tempo espresso come
giorni che intercorrono tra due date. Ad esempio il periodo dal 05/07/1998 al
11/07/1998 implica 7 giorni di permanenza con liberazione della stanza il
giorno 12/07/1998 mattina, quindi già a partire da quel giorno la stanza deve
essere resa disponibile per eventuali altre prenotazioni. La fase di ricerca delle
camere disponibili, dovrà tenere conto dei vincoli imposti come stanze
bloccate, assegnate o commissionate ad agenzie viaggi.
Le prenotazioni fornite da un'agenzia dovranno prima di tutto coprire i
commissionamenti. Quando le stanze commissionate non permettono più
alcuna prenotazione, si potrà ricercare stanze disponibili tra quelle non
commissionate.
Input richiesto:
Periodo scelto per la permanenza.
Output desiderato:
Output a video delle disponibilità dell'albergo o di una tabella che riassuma la
disponibilità dell'albergo.
Criterio di
accettazione:
Dato un intervallo di tempo espresso da due date, il sistema dovrà ritornare
l'elenco di tutte le camere disponibili in quel periodo. Nel caso di nessuna
disponibilità esatta verrà mostrata a video una tabella che metterà in evidenza
le disponibilità dell'albergo.
Nel caso di prenotazione tramite agenzia, dovranno essere visualizzate le
stanze commissionate, ed eventualmente tutte le altre stanze.
Aspettative collegate:
Pronta verifica delle disponibilità dell'albergo.
Requisiti collegati:
F-PRE-02, F-PRE-03, F-PRE-04.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena comprensione
Software
Versione: 4.0
Data: 16/04/1998
Compilato da: Martini Roberto
Note:
| Requirement |
|
F-PRE-02.txt |
Requisito numero:
F-PRE-02
Tipo:
Funzionale
Requisito:
Prenotazione di camere da parte di un cliente.
Descrizione:
Quando un cliente effettua una prenotazione è necessario poter evidenziare
che la camera che egli desidera e per il periodo da lui scelto venga bloccata.
Nel caso in cui il cliente sia un habitué o un amico deve essere possibile
assegnargli direttamente la camera e quindi accertarsi che essa è stata
assegnata.
Input richiesto:
È necessario conoscere le stanze disponibili che possono soddisfare le richieste
del cliente (disponibilità nel periodo da lui richiesto, possibilità di avere il
letto aggiuntivo, vista mare/valle). Inoltre è necessario conoscere i dati forniti
dal cliente stesso e che permettono la sua prenotazione (vedi dati
prenotazione).
Output desiderato:
Registrazione della prenotazione e bloccaggio (o assegnamento) della stanza
per il periodo accordato.
Criterio di
accettazione:
Dopo che una prenotazione viene accettata la stanza dovrà risultare bloccata o
assegnata e perciò sottratta dalle disponibilità dell'albergo per il periodo
relativo alla prenotazione.
Aspettative collegate:
L'albergatore si aspetta in questo modo di avere un quadro generale della
situazione del suo albergo, di poter visualizzare in modo semplice la
situazione delle varie stanze ovvero di vedere se una stanza è bloccata,
assegnata, commissionata o disponibile, di avere un minimo di informazioni
per poter provvedere ad accogliere il cliente in modo adeguato e poter allo
stesso tempo organizzare il suo lavoro. Es.: se il cliente al momento della
prenotazione non ha fatto richiesta del letto aggiuntivo, ma in realtà lo
desidera e al momento del suo arrivo le stanze che permettono di supportare
il letto aggiuntivo sono occupate non si potrà più soddisfare la richiesta del
cliente.
Requisiti collegati:
F-PRE-01, F-PRE-03, F-PRE-04, F-PRE-05, F-PRE-06.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena comprensione
Software
Versione: 2.0
Data: 30/03/1998
Compilato da: Danzi Francesca
7Note:
| Requirement |
|
F-PRE-03.txt |
Requisito numero:
F-PRE-03
Tipo:
Funzionale
Requisito:
Gestione delle camere bloccate.
Descrizione:
Se al momento della prenotazione una stanza viene bloccata, tale stanza
rimarrà in quello stato per un certo periodo di tempo fissato (vedi F-GES-04)
dalla gestione dell'albergo. Trascorso tale periodo verrà inviato un messaggio
che faccia comprendere che la stanza è bloccata da troppo tempo in modo che
ci si possa informare se il ritardo è dovuto a un contrattempo del cliente
oppure se egli non intende più soggiornare nell'albergo. Nel primo caso si
provvederà a rinnovare il bloccaggio della stanza, mentre nel secondo a
cancellare la prenotazione. Una volta arrivata la caparra del cliente deve
essere possibile passare la stanza da bloccata ad assegnata.
Input richiesto:
Situazione delle stanze.
Output desiderato:
Situazione aggiornata delle stanze.
Criterio di
accettazione:
Trascorso il numero di giorni fissati dall'albergatore a partire dal giorno della
prenotazione il sistema dovrà garantire che:
una stanza bloccata sia passata a stato di assegnata;
venga visualizzato un messaggio che avvisi della situazione di ritardo
di pagamento della caparra.
Aspettative collegate:
L’albergatore si aspetta di poter tenere sotto controllo la situazione delle
stanze bloccate in modo tale che una camera non rimanga troppo a lungo in
tale stato rischiando di far perdere altri potenziali clienti all’albergo.
Requisiti collegati:
F-PRE-02, F-GES-04.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena Comprensione
Software
Versione: 2.0
Data: 30/03/1998
Compilato da: Danzi Francesca
Note:
| Requirement |
|
F-PRE-04.txt |
Requisito numero:
F-PRE-04
Tipo:
Funzionale
Requisito:
Gestione delle stanze commissionate ad agenzia.
Descrizione:
Alcune delle stanze dell’albergo per determinati periodi potrebbero essere date
in gestione ad una agenzia viaggi, in questo caso tali stanze risulteranno per
quei periodi commissionate, quindi non disponibili. Quando l’agenzia invia
delle prenotazioni deve essere possibile passare le stanze da commissionate ad
assegnate, ovviamente solo per il periodo della prenotazione. Le stanze
commissionate diventeranno disponibili, nel caso in cui nessuna prenotazione
giunga dall'agenzia entro la data concordata al momento della stipulazione del
contratto di commissionamento.
Input richiesto:
Informazioni sugli accordi presi con le agenzie ovvero numero di stanza
commissionata, periodo di commissionamento (data di inizio e di fine), data
dopo la quale la stanza, se non occupata, può essere considerata disponibile.
Output desiderato:
Situazione aggiornata delle stanze.
Criterio di
accettazione:
L’albergatore dovrà poter inserire informazioni relative agli accordi con
l’agenzia (data di inizio e fine commissione delle stanze) e verificare il loro
effettivo commissionamento. Inoltre si deve poter verificare che, se dopo la
data concordata con l’agenzia le stanze non sono ancora state occupate, esse
risultino allora disponibili.
Aspettative collegate:
Si desidera poter dare in gestione alcune stanze ad una agenzia e poter tenere
sotto controllo la situazione in modo tale che se l’agenzia non riesce ad
occuparle, entro la data concordata possano essere considerate disponibili.
Requisiti collegati:
F-PRE-01, F-PRE-02.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena comprensione
Software
Versione: 2.1
Data: 15/04/1998
Compilato da: Danzi Francesca
Note:
| Requirement |
|
F-PRE-05.txt |
Requisito numero:
F-PRE-05
Tipo:
Funzionale
Requisito:
Cancellazione di una prenotazione.
Descrizione:
A partire dai dati forniti dal cliente deve essere possibile disdire una
prenotazione. In tal caso le stanze che erano in stato di bloccato o assegnato
torneranno ad essere disponibili. Se le stanze per le quali è stato richiesto
l'annullamento della prenotazione erano state date in gestione ad un'agenzia
viaggi esse dovranno:
riassumere lo stato di commissionate nel caso in cui la data di disdetta sia
precedente alla data stabilita tra albergatore e agenzia come scadenza del
commissionamento;
ritornare ad essere disponibili nel caso in cui tale data sia altrepassata.
Input richiesto:
Nominativo del cliente che era stato lasciato al momento della prenotazione.
Output desiderato:
Modifica dello stato delle stanze che erano state prenotate ed eliminazione
della prenotazione dall'elenco delle prenotazioni.
Criterio di
accettazione:
Se i dati forniti corrispondono a quelli di una prenotazione esistente, essa
viene visualizzata e, dopo una richiesta di conferma, cancellata e lo stato delle
stanze coinvolte cambiato in disponibile (o commissionata). Se al contrario
non esiste una corrispondenza nell'elenco viene visualizzato un messaggio di
errore e viene data la possibilità di modificare i dati forniti o di annullare
l'operazione.
Aspettative collegate:
Cancellazione della prenotazione con conseguente aggiornamento a stanza
disponibile. Se la prenotazione da eliminare risulta inesistente un messaggio a
video ci avviserà dell'errore verificatosi.
Requisiti collegati:
F-PRE-02.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
1
Richiesto
Stabile
Piena comprensione
Software
Versione: 1.2
Data: 31/03/1998
Compilato da: Colombari Andrea
Note:
| Requirement |
|
F-PRE-06.txt |
Requisito numero:
F-PRE-06
Tipo:
Funzionale
Requisito:
Modifica di una prenotazione.
Descrizione:
Deve essere possibile apportare delle modifiche ad una prenotazione già
registrata nel sistema. Tali modifiche dovranno naturalmente aggiornare la
prenotazione del cliente nonché le disponibilità dell'albergo nel caso in cui sia
stato ritoccato il periodo di soggiorno.
Input richiesto:
Sarà richiesto il nominativo del cliente fornito al momento della prenotazione
e il tipo di modifica che vuole apportare.
Output desiderato:
Modifica della prenotazione esistente ed eventualmente delle disponibilità
dell'albergo.
Criterio di
accettazione:
Quando si cerca un prenotazione da modificare, se essa non esiste deve essere
mostrato un messaggio d'errore altrimenti devono essere mostrati i dati della
prenotazione precedente. Effettuate tutte le modifiche verrà richiesta la loro
conferma.
Aspettative collegate:
Modifica della prenotazione esistente.
Requisiti collegati:
F-PRE-02, F-PRE-05.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
1
Opzionale
Stabile
Piena comprensione
Software
Versione: 1.2
Data: 09/04/1998
Compilato da: Martini Roberto
Note:
| Requirement |
|
F-RIS-01.txt |
Requisito numero:
F-RIS-01
Tipo:
Funzionale
Requisito:
Gestione del servizio ristorante per clienti esterni.
Descrizione:
Il sistema dovrà essere in grado di gestire la contabilità immediata di un
normale ristorante i cui clienti non sono necessariamente soggiornanti
nell’hotel.
Il sistema dovrà essere quindi in grado di:
fornire i prezzi delle portate singole perché il cliente esterno non sia
vincolato alla scelta del menù fisso previsto per i soggiornanti;
accettare in ingresso le varie portate consumate;
stampare la ricevuta in base all'elenco delle consumazioni.
Input richiesto:
Dati relativi al cliente (numero persone, portate e bevande consumate,
modalità di pagamento).
Output desiderato:
Stampa del conto relativo alle consumazioni.
Criterio di
accettazione:
Tale requisito è soddisfatto se il sistema fornisce all’utente la possibilità di
visualizzare, modificare, aggiornare e stampare il conto del servizio di
ristorazione.
Aspettative collegate:
Semplice gestione dell'attività di ristorazione.
Requisiti collegati:
nn.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Stabile
2
Richiesto
Stabile
Piena comprensione
Organizzazione
Versione: 2.2
Data: 29/03/1998
Compilato da: Girelli Daria
Note:
| Requirement |
|
F-SOG-01.txt |
Requisito numero:
F-SOG-01
Tipo:
Funzionale
Requisito:
Gestione dell'arrivo di un cliente.
Descrizione:
All'arrivo di un cliente possono verificarsi le seguenti eventualità:
1. se il cliente ha precedentemente prenotato allora dalla prenotazione si
risale al numero delle camere che andrà ad occupare e la prenotazione verrà
cancellata dall'elenco delle prenotazioni;
2. se il cliente non ha precedentemente prenotato si procederà come se fosse
in atto una prenotazione, cioè:
a) si ricerca una camera disponibile;
b) nel caso l'esito sia favorevole, la si assegna al cliente per il periodo
specificato.
1. Il nuovo cliente richiede di aggiungersi a coloro che già occupano una
certa stanza.
A questo punto a partire dalle stanze assegnate (o tramite prenotazione o al
momento), si inseriscono nell'archivio degli ospiti, camera per camera, i dati
delle persone che vi soggiorneranno. Tali dati comprenderanno, oltre ai dati
personali (facoltativi per neonati, bambini e ragazzi che soggiornano con
adulti), il tipo di pensionamento (questo permette di avere persone con tipo di
pensionamento diverso in una stessa stanza). Deve essere anche possibile
distinguere i clienti che rientrano nelle categorie di neonati e bambini per
rendere possibile l'applicazione di eventuali sconti. Alle varie stanze che
vengono così ad essere utilizzate verrà dato l'appellativo di occupate.
Input richiesto:
Dati personali dei vari occupanti.
Output desiderato:
Aggiornamento archivio dei clienti e modifica dello stato delle stanze.
Criterio di
accettazione:
Se dai dati forniti dal cliente non si riesce a risalire alla prenotazione verrà
visualizzato un messaggio di errore e verrà chiesto di ripetere l'operazione o
annullarla. Se si tenta di inserire in una stanza piena un'ulteriore persona
apparirà un messaggio di avvertimento.
Aspettative collegate:
Conoscere per ogni stanza i dati di coloro che vi alloggiano.
Requisiti collegati:
F-PRE-01, F-PRE-02.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena comprensione
Software
Versione: 2.1
Data: 04/04/1998
Compilato da: Colombari Andrea
Note:
| Requirement |
|
F-SOG-02.txt |
Requisito numero:
F-SOG-02
Tipo:
Funzionale
Requisito:
Addebito servizi e spese extra per stanza.
Descrizione:
Tale requisito permette di valutare le eventuali spese extra effettuate dai
clienti occupanti una certa stanza e di addebitare i relativi prezzi sul conto-
spese previsto per ogni stanza. Il sistema dovrà quindi essere in grado, una
volta fissati i prezzi relativi ad ogni bene o servizio, di fornire al momento
della loro richiesta il relativo costo e di addebitarlo sul conto-spese delle
stanze i cui occupanti hanno usufruito di tale servizio.
Input richiesto:
Tipo e quantità del bene consumato.
Output desiderato:
Addebito sul conto-spese della stanza del consumatore.
Criterio di
accettazione:
Per soddisfare tale requisito il sistema dovrà tenere traccia di ogni spesa o
servizio extra di cui il cliente usufruisce. Tali informazioni dovranno essere
poi recuperate ogni qual volta un cliente richieda l'ammontare del conto.
Aspettative collegate:
Contabilizzazione automatica delle spese straordinarie.
Requisiti collegati:
F-SOG-04.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena comprensione
Efficienza
Versione: 2.1
Data: 15/04/1998
Compilato da: Vincenti Paola
Note:
| Requirement |
|
F-SOG-03.txt |
Requisito numero:
F-SOG-03
Tipo:
Funzionale
Requisito:
Addebito della spesa telefonica.
Descrizione:
Vista la normativa interna dell’hotel, che prevede il servizio telefonico in
camera indipendentemente dal tipo di soggiorno, deve essere possibile tener
conto del numero di scatti effettuati dal cliente a partire dall’inizio del
soggiorno. Tale numero moltiplicato al costo del singolo scatto, stabilito dal
proprietario, fornirà l’addebito della spesa telefonica che andrà poi ad
aggiungersi al conto totale del soggiorno.
Input richiesto:
Dati telefonate forniti dal centralino telefonica.
Output desiderato:
Addebito spesa telefonica.
Criterio di
accettazione:
Il sistema deve essere in grado di comunicare con il centralino e tener traccia
delle informazioni di una telefonata effettuata dal cliente durante il soggiorno
con relativo addebito della spesa. Tali informazioni dovranno essere
reperibili al momento della richiesta del conto.
Aspettative collegate:
L’albergatore si aspetta di poter controllare il sistema telefonico dell’hotel
ricavandone il vantaggio di disporre del costo telefonico da aggiungere al
conto totale del soggiorno al termine di quest’ultimo.
Requisiti collegati:
F-SOG-04, F-GES-05.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
2
Richiesto
Stabile
Piena comprensione
Software
Versione: 2.1
Data: 16/04/98
Compilato da: Girelli Daria
Note: Non è richiesta l'interfaccia con il centralino perché questa per ordine di chi ha commissionato la
realizzazione di questo progetto verrà simulata con una piccola routine software.
| Requirement |
|
F-SOG-04.txt |
Requisito numero:
F-SOG-04
Tipo:
Funzionale
Requisito:
Calcolo del conto complessivo.
Descrizione:
Al momento in cui lo si richiede si devono recuperare:
1. ammontare spese di soggiorno
2. ammontare spese telefoniche
3. ammontare spese per servizi extra
Successivamente si deve fornire a video l’ammontare parziale per ogni voce
sopraindicata e l'ammontare totale. Si deve inoltre poter facilmente
distinguere i tre totali parziali in modo da fornire al cliente l’informazione che
desidera. All’interno delle spese dei pernottamenti sono compresi i pasti
concordati in base al tipo di soggiorno.
Si distinguono 4 diversi casi:
- Calcolo totale del conto su un’unica stanza.
- Calcolo del conto separato nel caso in cui uno (o alcuni) tra gli
occupanti una certa stanza debba, per qualche motivo, lasciare l'albergo
in anticipo rispetto alla data prevista. In questo caso deve poter essere
applicato un supplemento per stanze parzialmente utilizzate. Nel conto
saranno escluse le spese extra che verranno poi riversate nel conto finale.
- Calcolo totale del conto su più stanze.
- Calcolo del conto per clienti mandati da un'agenzia. In questo caso il
conto consisterà solamente delle spese telefoniche e delle spese per
servizi e spese extra.
Input richiesto:
Dati di uno o più clienti, o numeri di una o più stanze.
Output desiderato:
Stampa a video del conto richiesto.
Criterio di
accettazione:
Si richiede la visualizzazione delle spese accumulate da parte dei clienti
dell’albergo quando se ne necessita.
Aspettative collegate:
Immediato resoconto del debito accumulato dal cliente fino al momento della
richiesta del conto.
Requisiti collegati:
F-SOG-02, F-SOG-03, F-SOG-05, F-GES-01.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
1
Richiesto
Stabile
Piena comprensione
Software
Versione: 2.0
Data: 02/04/1998
Compilato da: Meneghini Matteo
Note:
| Requirement |
|
F-SOG-05.txt |
Requisito numero:
F-SOG-05
Tipo:
Funzionale
Requisito:
Stampa dell'ammontare conto.
Descrizione:
Al momento in cui il cliente sta per lasciare l'albergo si deve recuperare il
conto finale e provvedere alla sua stampa con questa forma:
VOCE NUM. AMM. L.
Persone #
Notti # ###
Scatti tel. # ###
PARZIALE1 #####
Desc. extra # ###
... ... ...
PARZIALE2 #####
-----------------------------------------------------------------------
TOTALE #######
Input richiesto:
Dati relativi al pernottamento presi dall'archivio dei clienti e delle stanze.
Output desiderato:
Stampa del conto.
Criterio di
accettazione:
La stampa deve riportare i dati visualizzati a video.
Aspettative collegate:
Chiara rappresentazione delle spese del cliente.
Requisiti collegati:
F-SOG-04.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
1
Richiesto
Volatile
Piena comprensione
Software
Versione: 1
Data: 02/04/1998
Compilato da: Meneghini Matteo
Note:
| Requirement |
|
F-SOG-06.txt |
Requisito numero:
F-SOG-06
Tipo:
Funzionale
Requisito:
Gestione del cambio di stanza.
Descrizione:
Nel caso in cui il cliente desideri o sia costretto (es. per un guasto) a cambiare
stanza di soggiorno, il sistema dovrà fornire tutti gli strumenti necessari
affinché ciò sia possibile.
Input richiesto:
Numero di stanza da lasciare, numero della nuova stanza da occupare
Output desiderato:
Modifica dell’informazione che indicava la stanza che occupavano i clienti
con il nuovo dato, modifica dello status delle stanze.
Criterio di
accettazione:
Quando viene accolta una richiesta di cambio di stanza si dovrà poter
verificare che i dati degli occupanti non si riferiscono più alla stanza in
precedenza occupata ma alla nuova stanza in cui soggiornano. Il
cambiamento di stanza coinvolgerà lo stato delle stanze modificandolo
opportunamente
Aspettative collegate:
Permettere un eventuale spostamento di stanza.
Requisiti collegati:
nn.
Stato
Release
Priorità
Stabilità
Livello di comprensione
Categoria
Finale
1
Richiesto
Stabile
Piena comprensione
Software
Versione: 1
Data: 28/04/1998
Compilato da: Martini Roberto
Note:
| Requirement |
|
AggiungiBeneServizio.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import moduli.*;
public class AggiungiBeneServizio extends InserisciBeniServizi
{
Button annulla1, annulla2, conferma1, conferma2;
TextField tf_supp, tf_rid, tf_stanza_supp, tf_stanza_rid, tf_mot_supp, tf_mot_rid;
Label label_supp, label_rid, label_stanza_supp, label_stanza_rid, label_mot_supp, label_mot_rid;
public AggiungiBeneServizio(Frame parent)
{
super("Creazione di un nuovo bene/servizio/riduzione/supplemento");
padre = parent;
padre.setEnabled(false);
setupNuovi();
inizializza();
setSize(450,600);
setVisible(true);
}
void setupNuovi()
{
//Creo i pannelli
remove(panel[0]);
panel[0] = new Panel();
panel[0].setLayout(grid1);
panel[0].setVisible(false);
//Creo il pannello in alto
label = new Label("Tipi");
label.setFont(ConfigurazioneSistema.font_titolo);
tipi = new CheckboxGroup();
panel[0].add(label);
panel[0].add(prima_scelta[0]);
panel[0].add(prima_scelta[1]);
panel[0].add(prima_scelta[2]);
panel[0].add(prima_scelta[3]);
panel[0].add(prima_scelta[4]);
panel[0].setVisible(true);
//Attacco il pannello in alto al frame
this.setLayout(grid);
this.add(panel[0]);
//Creo il pannello supplemento
panel[11].setLayout(gridbag);
label_supp = new Label("Ammontare del supplemento "+(Principale.config).getValuta()+".");
tf_supp = new TextField("", 10);
label_stanza_supp = new Label("A carico della stanza numero");
tf_stanza_supp = new TextField("", 6);
if (padre instanceof MascheraContoRistorazione)
tf_stanza_supp.setEnabled(false);
label_mot_supp = new Label("Motivazione");
tf_mot_supp = new TextField("", 35);
annulla1 = new Button("Annulla");
conferma1 = new Button("Conferma");
Utils.constrain(panel[11], label_supp, 0, 0, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[11], tf_supp, 1, 0, 4, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[11], label_stanza_supp, 0, 1, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[11], tf_stanza_supp, 1, 1, 4, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[11], label_mot_supp, 0, 2, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[11], tf_mot_supp, 1, 2, 4, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[11], annulla1, 1, 3, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.EAST, 0.0, 0.0, 5, 0, 5, 10);
Utils.constrain(panel[11], conferma1, 3, 3, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 5, 10, 5, 0);
//Creo il pannello riduzione
panel[12].setLayout(gridbag);
label_rid = new Label("Ammontare della riduzione "+(Principale.config).getValuta()+".");
tf_rid = new TextField("",10);
label_stanza_rid = new Label("A carico della stanza numero");
tf_stanza_rid = new TextField("", 6);
if (padre instanceof MascheraContoRistorazione)
tf_stanza_rid.setEnabled(false);
label_mot_rid = new Label("Motivazione");
tf_mot_rid = new TextField("", 35);
annulla2 = new Button("Annulla");
conferma2 = new Button("Conferma");
Utils.constrain(panel[12], label_rid, 0, 0, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[12], tf_rid, 1, 0, 4, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[12], label_stanza_rid, 0, 1, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[12], tf_stanza_rid, 1, 1, 4, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[12], label_mot_rid, 0, 2, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[12], tf_mot_rid, 1, 2, 4, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[12], annulla2, 1, 3, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.EAST, 0.0, 0.0, 5, 5, 5, 0);
Utils.constrain(panel[12], conferma2, 2, 3, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 5, 0);
}
public void inizializza()
{
prima_scelta[3].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(prima_scelta[3].getState())
{
inComuneDE(11, BeneServizio.SUPPLEMENTI);
}
}
});
prima_scelta[4].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(prima_scelta[4].getState())
{
inComuneDE(12, BeneServizio.RIDUZIONI);
}
}
});
annulla1.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
padre.setEnabled(true);
}
});
annulla2.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
padre.setEnabled(true);
}
});
conferma1.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
scriviSuDB( tf_supp.getText(), tf_stanza_supp.getText(), tf_mot_supp.getText() );
}
});
conferma2.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
scriviSuDB( new String("-"+tf_rid.getText()), tf_stanza_rid.getText(), tf_mot_rid.getText() );
}
});
} // init
void inComuneDE(int numero_pannello, char c)
{
level = 0;
for(int i=1;i<13;++i)
{
if(panel[i].isVisible())
remove(panel[i]);
}
this.add(panel[numero_pannello]);
panel[numero_pannello].setVisible(true);
setVisible(true);
codice = composeCode(level, c);
}
void scriviSuDB(String sup_rid, String stanza, String mot)
{
MessageDialog msg;
completeCode();
Float px = Float.valueOf(sup_rid);
extra = new BeneServizio((new String(codice)) + tornaCodId((Principale.config).getIdBeneservizio()),
mot, px.floatValue());
if (padre instanceof MascheraAddebiti)
{
if ( ((Principale.db).readStanza(stanza) != null) && Utils.isFloatPos(sup_rid) && (mot.length() < 33) )
{
ListaSoggiornanti L_sogg = (Principale.db).foundSoggiornanti(stanza, false);
if (L_sogg != null)
{
if (!L_sogg.isEmpty())
{
int j;
if ((j = (Principale.db).newIdBeneservizio()) == DataBase.OK)
{
(Principale.config).updateIdBeneservizio();
if ((j = (Principale.db).writeBeneServizio(extra)) == DataBase.OK)
{
Addebito da_addebitare = new Addebito(stanza, extra.getCodExtra(),
1, px.floatValue());
if ((j = (Principale.db).writeAddebito(da_addebitare)) == DataBase.OK)
{
dispose();
if ( stanza.equals(((MascheraAddebiti) padre).stanza_prec) )
{
(((MascheraAddebiti) padre).elenco_addebiti).addAddebito(da_addebitare);
(((MascheraAddebiti) padre).elenco_extra_addebitati).addBeneServizio(extra);
/* travaso delle quantita modificate nel nuovo array per poi
aggiungere il supplemento o riduzione appena inseriti */
int nuove_quantita_mod[] = new int[((MascheraAddebiti) padre).elenco_addebiti.length()];
for (int i = 0; i < ((MascheraAddebiti) padre).quantita_mod.length; i++)
nuove_quantita_mod[i] = ((MascheraAddebiti) padre).quantita_mod[i];
nuove_quantita_mod[nuove_quantita_mod.length-1] = 0;
((MascheraAddebiti) padre).quantita_mod = nuove_quantita_mod;
((MascheraAddebiti) padre).continuaAggiornamento();
/* se il numero di stanza era stato cambiato senza addebiti
allora rimetto il precedente numero di stanza nel textfield
della finestra Addebiti */
}
if ( !(((MascheraAddebiti) padre).num_stanza.getText()).equals(((MascheraAddebiti) padre).stanza_prec) )
((MascheraAddebiti) padre).num_stanza.setText( ((MascheraAddebiti) padre).stanza_prec );
padre.setEnabled(true);
}
else
msg = new MessageDialog(this, "Errore nell'addebitare: "+DataBase.strErrore(j));
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j));
}
else
msg = new MessageDialog(this, "Errore nell'aggiornamento: "+DataBase.strErrore(j));
}
else
msg = new MessageDialog(this, " La stanza inserita non e' occupata! ");
}
else
msg = new MessageDialog(this, " Problemi con il database! ");
}
else
msg = new MessageDialog(this, "Errore nei parametri!");
}
else
{ // si tratta della maschera del conto ristorazione
dispose();
Addebito da_addebitare = new Addebito("RIST", extra.getCodExtra(),
1, px.floatValue());
(((MascheraContoRistorazione) padre).elenco_addebiti).addAddebito(da_addebitare);
(((MascheraContoRistorazione) padre).elenco_extra_addebitati).addBeneServizio(extra);
/* travaso delle quantita modificate nel nuovo array per poi
aggiungere il supplemento o riduzione appena inseriti */
int nuove_quantita_mod[] = new int[((MascheraContoRistorazione) padre).elenco_addebiti.length()];
for (int i = 0; i < ((MascheraContoRistorazione) padre).quantita_mod.length; i++)
nuove_quantita_mod[i] = ((MascheraContoRistorazione) padre).quantita_mod[i];
nuove_quantita_mod[nuove_quantita_mod.length-1] = 1;
((MascheraContoRistorazione) padre).quantita_mod = nuove_quantita_mod;
((MascheraContoRistorazione) padre).continuaAggiornamento();
padre.setEnabled(true);
}
}
} | This code provides users with the ability to create new `goods/services/reductions/supplements` within the software system. The user can access this functionality through a graphical user interface (GUI) that is launched as a separate window. The GUI allows the user to select the type of item they want to create and then enter the required information, such as the amount, the room number, and the motivation. Once the user has entered the necessary details, they can click the `Confirm` button to save the new item to the database. If the user decides to cancel the operation, they can click the "Cancel" button to close the window.
The code also includes additional functionality, such as automatically generating a unique code for the new item, updating the database with the new information, and updating the parent window with the new details. Overall, this code provides users with a user-friendly way to create new goods, services, reductions, and supplements within the software system. | Code |
AggiungiSoggiornante.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import moduli.*;
import common.utility.*;
import common.def.*;
import interfacce.*;
import java.util.Date;
public class AggiungiSoggiornante extends MascheraSoggiorno
{
Prenotazione prenotazione;
int num_sogg;
Stanza stanza;
public AggiungiSoggiornante(RicercaPrenotazione parent, Prenotazione p, Stanza s, int num)
{
super("Inserimento dati del soggiornante","Aggiungi agli altri", p.getPensionamento(), Flag.ADULTO);
padre = parent;
stanza = s;
num_sogg= num;
prenotazione = p;
inizializza();
}
public void inizializza()
{
testo1.setText(stanza.getNumStanza());
testo1.setEditable(false);
testo13.setText(DateUtils.giveStringOfDate(new Date()));
testo13.setEditable(false);
testo14.setText(DateUtils.giveStringOfDate(prenotazione.getFineSogg()));
testo14.setEditable(false);
Conferma.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startConferma();
}
});
}
void startConferma()
{
Frame msg;
if (!errori())
{
Soggiornante sogg = readDatiSogg(prenotazione, num_sogg+1);
sogg.setInizioSogg(new Date());
sogg.setFineSogg(prenotazione.getFineSogg());
sogg.setNumStanza(stanza.getNumStanza());
int j;
if ( (j = (Principale.db).writeSoggiornante(sogg)) == DataBase.OK )
{ // Modifico la prenotazione relativa
if (stanza.getPostiLetto() > num_sogg)
prenotazione.setNumPers(num_sogg+1);
else
if ( (stanza.getPostiLetto() == num_sogg) && (stanza.getDispLettoAgg() == Const.SI) )
prenotazione.setRichLettoAgg(Const.SI);
(Principale.db).changePrenotazione(prenotazione.getIdPrenotazione(), prenotazione.getNumStanza(),
prenotazione.getNumPers(),prenotazione.getNome(),prenotazione.getCognome(),
prenotazione.getNumTel(), prenotazione.getInizioSogg(), prenotazione.getFineSogg(), prenotazione.getDataPren(),
prenotazione.getCaparra(), prenotazione.getRichLettoAgg(), prenotazione.getPensionamento(),
prenotazione.getTramiteAgenzia(), prenotazione.getNomeAgenzia(), prenotazione.getRichParticolari());
msg = new AvvisoLocale(this, " Nuovo soggiornante registrato! ");
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j));
}
}
}
class AvvisoLocale extends Frame
{
Button OK;
AggiungiSoggiornante padre;
public AvvisoLocale(AggiungiSoggiornante parent, String testo)
{
super("Avviso");
padre = parent;
padre.setEnabled(false);
this.setFont(ConfigurazioneSistema.font_titolo);
Panel textPanel = new Panel();
Panel buttonPanel = new Panel();
textPanel.add(new Label(testo));
OK = new Button("OK");
buttonPanel.add(OK);
add("North",textPanel);
add("Center",buttonPanel);
init();
pack();
//setSize(250,100);
setVisible(true);
}
public void init()
{
OK.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
setVisible(false);
dispose();
padre.dispose();
padre.padre.setEnabled(true);
}
});
}
}
| The provided code allows users to add a new guest to an existing reservation. The "AggiungiSoggiornante" class serves as the user interface, displaying details about the reservation, such as the room number, start and end dates, and the current number of guests. Users can then input information about the new guest and confirm the addition, which will update the reservation in the database. If the new guest is successfully added, a confirmation message is displayed to the user through the "AvvisoLocale" class. If any issues arise with the database, an error message is shown instead. This functionality enables users to easily manage guest information and update reservations as needed, providing a seamless experience for handling changes to existing bookings. | Code |
AskChiudiConto.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import interfacce.MascheraVisualizzazioneConto;
public class AskChiudiConto extends Frame
{
Button button1, button2, button3;
MascheraVisualizzazioneConto padre;
Panel panel1, panel2;
Label message;
GridBagLayout gridbag = new GridBagLayout();
public AskChiudiConto(MascheraVisualizzazioneConto parent)
{
super("Cosa devo fare?");
padre = parent;
padre.setEnabled(false);
setupPanel();
init();
pack();
setVisible(true);
}
void setupPanel()
{
message = new Label("ATTENZIONE: questa operazione comporta comporta la chiusura del soggiorno.");
button1 = new Button(" Annulla ");
button2 = new Button(" Stampa e chiudi ");
this.setFont(ConfigurazioneSistema.font_titolo);
panel1 = new Panel();
panel1.setLayout(gridbag);
Utils.constrain(panel1, message, 0, 0, 4, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
//Creo il pannello in basso con due pulsanti
panel2 = new Panel();
panel2.setLayout(gridbag);
Utils.constrain(panel2, button1, 0, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 0.0, 0.0, 0, 0, 0, 15);
Utils.constrain(panel2, button2, 1, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 0.0, 0.0, 0, 15, 0, 0);
//Attacco i pannelli al frame
this.setLayout(gridbag);
Utils.constrain(this, panel1, 0, 1, 4, 2, GridBagConstraints.HORIZONTAL,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(this, panel2, 0, 14, 4, 1, GridBagConstraints.HORIZONTAL,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 5, 5);
}
public void init()
{
button1.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startAzione();
}
});
button2.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
padre.startChiusura();
startAzione();
}
});
}
void startAzione()
{
setVisible(false);
dispose();
padre.dispose();
padre.conto.setEnabled(true);
}
}
| The "AskChiudiConto" code provides a user interface that allows the user to close their current account or session. The interface displays a warning message to the user, informing them that the operation will result in the closure of their session. The user is presented with two options: "Annulla" (Cancel) and "Stampa e chiudi" (Print and Close).
If the user selects the "Annulla" option, the interface is closed, and the user is returned to the previous state. If the user selects the "Stampa e chiudi" option, the code initiates the closure of the account or session by calling a method on an instance of the "MascheraVisualizzazioneConto" class. After the closure is initiated, the code performs additional cleanup tasks, such as hiding the current GUI frame, disposing of it, and re-enabling the parent "MascheraVisualizzazioneConto" instance.
The code sets up event listeners for the two buttons, which handle the user's interactions with the GUI and trigger the appropriate actions based on the button clicked. This allows the user to easily navigate the account closure process and make an informed decision about whether to proceed with the closure or cancel the operation. | Code |
AskChiudiSingoloConAgenzia.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import interfacce.MascheraVisualizzazioneConto;
public class AskChiudiSingoloConAgenzia extends Frame
{
Button button1, button2, button3;
MascheraCalcoloConto padre;
Panel panel1, panel2;
Label message;
GridBagLayout gridbag = new GridBagLayout();
public AskChiudiSingoloConAgenzia(MascheraCalcoloConto parent)
{
super("Cosa devo fare?");
padre = parent;
padre.setEnabled(false);
setupPanel();
init();
pack();
setVisible(true);
}
void setupPanel()
{
message = new Label("Calcolare il conto di un soggiornante venuto con agenzia implica cambiare la sua data di partenza.");
button1 = new Button(" Annulla ");
button2 = new Button(" Cambia data ");
this.setFont(ConfigurazioneSistema.font_titolo);
panel1 = new Panel();
panel1.setLayout(gridbag);
Utils.constrain(panel1, message, 0, 0, 4, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
//Creo il pannello in basso con due pulsanti
panel2 = new Panel();
panel2.setLayout(gridbag);
Utils.constrain(panel2, button1, 0, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 0.0, 0.0, 0, 0, 0, 15);
Utils.constrain(panel2, button2, 1, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 0.0, 0.0, 0, 15, 0, 0);
//Attacco i pannelli al frame
this.setLayout(gridbag);
Utils.constrain(this, panel1, 0, 1, 4, 2, GridBagConstraints.HORIZONTAL,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(this, panel2, 0, 14, 4, 1, GridBagConstraints.HORIZONTAL,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 5, 5);
}
public void init()
{
button1.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startAzione();
}
});
button2.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
padre.startChiudiSingoloConAgenzia();
startAzione();
}
});
}
void startAzione()
{
setVisible(false);
dispose();
padre.setEnabled(true);
}
}
| The "AskChiudiSingoloConAgenzia" component provides a user interface that allows the user to either cancel or proceed with changing the departure date of a guest who has booked their stay through an agency. This is necessary because calculating the bill for such a guest requires modifying their departure date.
The component presents the user with a message explaining the situation and two buttons: "Annulla" (Cancel) and "Cambia data" (Change date). If the user clicks "Annulla", the component is closed, and the parent component is re-enabled. If the user clicks "Cambia data", the parent component's "startChiudiSingoloConAgenzia" method is called, and the component is then closed, and the parent component is re-enabled.
The component is designed to be part of a larger software system, and its purpose is to provide a clear and intuitive way for the user to handle the specific scenario of calculating the bill for a guest who has booked through an agency. By giving the user the option to either cancel or proceed with the change, the component ensures that the user can make an informed decision and take the appropriate action. | Code |
CancellaBeniServizi.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import moduli.BeneServizio;
import moduli.DataBase;
import moduli.ListaBeniServizi;
public class CancellaBeniServizi extends MascheraBeneServizio
{
BeneServizio extra = null;
Label elenco_extra1, elenco_extra2, desc_extra, px_extra;
TextField desc, prezzo;
Button annulla3, annulla_canc, conferma_canc;
public CancellaBeniServizi()
{
super("Cancellazione di un bene o servizio");
setupPannello();
initialize();
}
void setupPannello()
{
panel[11].setLayout(gridbag);
elenco_extra1 = new Label("Scegliere il bene o servizio, appartenente");
elenco_extra2 = new Label("alla categoria selezionata, da cancellare");
annulla3 = new Button(" Fine ");
Utils.constrain(panel[11], elenco_extra1, 0, 0, 5, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 0, 0, 0);
Utils.constrain(panel[11], elenco_extra2, 0, 1, 5, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 0, 5, 0);
Utils.constrain(panel[11], elenco, 0, 2, 5, 1,GridBagConstraints.HORIZONTAL,
GridBagConstraints.CENTER, 1.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[11], annulla3, 2, 3, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.CENTER, 1.0, 0.0, 5, 5, 5, 5);
panel[12].setLayout(gridbag);
desc_extra = new Label("Nome del bene");
px_extra = new Label("Prezzo del bene");
desc = new TextField("",40);
prezzo = new TextField("",10);
desc.setEditable(false);
prezzo.setEditable(false);
annulla_canc = new Button("Annulla");
conferma_canc = new Button("Conferma");
Utils.constrain(panel[12], desc_extra, 0, 0, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[12], desc, 1, 0, 4, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[12], px_extra, 0, 1, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 5, 5, 5, 0);
Utils.constrain(panel[12], prezzo, 1, 1, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 5, 0);
Utils.constrain(panel[12], annulla_canc, 1, 2, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.EAST, 1.0, 0.0, 5, 5, 0, 5);
Utils.constrain(panel[12], conferma_canc, 2, 2, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 0, 5);
}
public void initialize()
{
scelta_piatto[4].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_piatto[4].getState())
{
level = 1;
codice = composeCode(level, BeneServizio.DESSERT);
p();
}
}
});
scelta_piatto[5].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_piatto[5].getState())
{
level = 1;
codice = composeCode(level, BeneServizio.FRUTTA);
p();
}
}
});
scelta_servizio[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_servizio[0].getState())
{
level = 1;
codice = composeCode(level, BeneServizio.RICREATIVI);
o();
}
}
});
scelta_servizio[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_servizio[1].getState())
{
level = 1;
codice = composeCode(level, BeneServizio.ALTRO);
o();
}
}
});
scelta_bevanda[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_bevanda[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.CAFFETTERIA);
o();
}
}
});
scelta_bevanda[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_bevanda[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.ANALCOLICI);
o();
}
}
});
scelta_bevanda[2].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_bevanda[2].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.ALCOLICI);
o();
}
}
});
scelta_cibo[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_cibo[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.DOLCI);
o();
}
}
});
scelta_cibo[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_cibo[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.SALATI);
o();
}
}
});
scelta_antipasto[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_antipasto[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.FREDDI);
o();
}
}
});
scelta_antipasto[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_antipasto[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.CALDI);
o();
}
}
});
scelta_primo[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_primo[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.SOLIDI);
o();
}
}
});
scelta_primo[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_primo[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.LIQUIDI);
o();
}
}
});
scelta_secondo[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_secondo[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.CARNE);
o();
}
}
});
scelta_secondo[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_secondo[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.PESCE);
o();
}
}
});
scelta_contorno[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_contorno[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.VERDURA_COTTA);
o();
}
}
});
scelta_contorno[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_contorno[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.VERDURA_CRUDA);
o();
}
}
});
scelta_contorno[2].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_contorno[2].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.FORMAGGIO);
o();
}
}
});
conferma_canc.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startConfermaCanc();
}
});
annulla_canc.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
goBack();
}
});
annulla3.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
padre.setEnabled(true);
}
});
elenco.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
beneSelezionato();
}
});
} // init
void startConfermaCanc()
{
int id;
MessageDialog msg;
// questa e' una forzatura sporca
testo3 = desc;
testo4 = prezzo;
int j;
if ((j = (Principale.db).delBeneServizio(extra.getCodExtra())) == DataBase.OK)
{
for(int i=1;i<13;++i)
if(panel[i].isVisible())
remove(panel[i]);
panel[0].setVisible(true);
}
else
msg = new MessageDialog(this, "Problemi con il data base: "+DataBase.strErrore(j));
}
void beneSelezionato()
{
extra = L.getBeneServizio((elenco.getSelectedIndexes())[0]+1);
remove(panel[11]);
this.add(panel[12]);
desc.setText(extra.getDescrizione());
prezzo.setText(extra.getPxUnitario()+"");
panel[12].setVisible(true);
setVisible(true);
}
void goBack()
{
remove(panel[12]);
this.add(panel[11]);
panel[11].setVisible(true);
setVisible(true);
}
} | The CancellaBeniServizi class provides users with the ability to cancel a good or service from a database. Users can navigate through a series of checkboxes to select the category of the item they wish to cancel, such as desserts, fruits, recreational services, or other categories. Once the appropriate category is selected, a list of the available goods or services within that category is displayed, and the user can choose the specific item they wish to cancel.
After selecting the item, the user is presented with additional details about the selected good or service, including its description and price. The user is then given the option to either confirm the cancellation or go back to the previous screen. If the user confirms the cancellation, the item is removed from the database, and the user is returned to the main screen. If the user chooses to go back, they are returned to the previous screen without making any changes.
The code also includes error handling functionality, which displays a message dialog to the user if any issues occur during the cancellation process, such as problems with the database. | Code |
CancellaCommissioni.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import moduli.*;
import moduli.Commissionamento;
public class CancellaCommissioni extends MascheraCommissioni
{
Commissionamento commissione;
public CancellaCommissioni()
{
super("","","Cancella dati delle commissioni","Cancella", 3);
init();
}
public void init()
{
nome_agenzia.setEditable(true);
num_stanza.setEditable(false);
num_tel_agenzia.setEditable(false);
inizio_comm.setEditable(false);
fine_comm.setEditable(false);
scadenza_comm.setEditable(false);
num_stanza.setEditable(false);
Azione.setEnabled(false);
lista.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
commissione = L.getCommissionamento((lista.getSelectedIndexes())[0]+1);
writeDatiComm(commissione);
Azione.setEnabled(true);
panel5.setVisible(false);
pack();
}
});
nome_agenzia.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
creaLista();
}
});
Cerca.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
creaLista();
}
});
Azione.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startAzione();
}
});
}
void startAzione()
{
Frame msg;
if ( !errori() )
{
int j;
if ( (j = (Principale.db).delCommissionamento(commissione.getIdCommissionamento())) == DataBase.OK)
{
aggiornaDisp(commissione, Flag.DISPONIBILE);
num_tel_agenzia.setEditable(false);
scadenza_comm.setEditable(false);
Azione.setEnabled(false);
cleanFields();
nome_agenzia.setEditable(true);
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j));
}
}
}
| The provided code implements a user interface for canceling commissions within a software system. The "CancellaCommissioni" class allows users to view and edit the details of a selected commission, including the agency name, room number, telephone number, start date, end date, and expiration date. Users can select a commission from a list, which populates the corresponding fields. Once a commission is selected, the user can click the "Azione" button to cancel the selected commission.
The code includes error handling, where if there are no issues, the commission is deleted from the database, and the availability of the commission is updated. If there are any problems with the database, a message dialog is displayed to the user. Additionally, the code provides functionality to create a list of commissions based on the agency name entered by the user or by clicking the "Cerca" button.
Overall, this code enables users to efficiently manage and cancel commissions within the software system, providing a user-friendly interface and robust error handling to ensure a seamless experience. | Code |
CancellaPrenotazione.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import java.util.Date;
import moduli.*;
public class CancellaPrenotazione extends MascheraPrenotazione
{
Prenotazione p;
RicercaPrenotazione parent;
public CancellaPrenotazione(Prenotazione pren, Stanza room, RicercaPrenotazione papa)
{
super(room,"","","Cancellazione della prenotazione","Cancella",3, pren.getPensionamento());
p = pren;
parent = papa;
init();
}
public void init()
{
writeDatiPren(p);
for(int i=0; i<11; i++)
testo[i].setEditable(false);
myCheckbox.setEnabled(false);
myCheckbox1.setEnabled(false);
for (int i=0; i<checkboxes.length; i++)
checkboxes[i].setEnabled(false);
testo[9].setText(DateUtils.parseDate(DateUtils.giveStringOfDate(p.getDataPren())));
Azione.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startCancella();
}
});
}
void startCancella()
{
Frame msg;
(Principale.db).delPrenotazione(p.getIdPrenotazione());
aggiornaDisp(p, Flag.DISPONIBILE);
Utils.restoreCommissioni(p.getNumStanza());
parent.creaLista(1);
dispose();
padre.setEnabled(true);
}
}
| This code provides users with the ability to cancel an existing hotel reservation. The user is presented with a window that displays the details of the reservation, including the room, dates, and other relevant information. While the user cannot edit any of the reservation details, they can initiate the cancellation process by clicking the "Cancella" (Cancel) button.
When the user clicks the "Cancella" button, the code first removes the reservation from the database, then updates the availability status of the room to "available", and finally restores any commissions associated with the reservation. After these actions are completed, the code refreshes the list of reservations displayed in the parent window, and then closes the current window, returning control to the parent window. This allows the user to easily cancel a reservation and see the updated list of available reservations. | Code |
CancellaStanze.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import moduli.*;
public class CancellaStanze extends DescrittoreStanze
{
public CancellaStanze()
{
super("Cancellazione delle stanze", "Cancella", 3);
init();
}
public void init()
{
testo1.setEditable(true);
testo2.setEditable(false);
testo3.setEditable(false);
testo4.setEditable(false);
mycheckboxes.setEnabled(false);
Azione.setEnabled(false);
Azione.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startAzione();
}
});
testo1.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startTesto1();
}
});
Cerca.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startTesto1();
}
});
} // init
void startAzione()
{
MessageDialog msg;
int j;
if ( (j = (Principale.db).delStanza(testo1.getText())) != DataBase.OK )
msg = new MessageDialog(this, "Problemi con il data base: "+DataBase.strErrore(j));
else
{
cleanFields();
Azione.setEnabled(false);
}
testo1.setEditable(true);
}
void startTesto1()
{
MessageDialog msg;
Stanza room;
if ((room = (Principale.db).readStanza(testo1.getText())) != null)
{
writeDatiStanza(room);
testo1.setEditable(false);
Azione.setEnabled(true);
}
else
msg = new MessageDialog(this, "Stanza inesistente!");
}
}
| This code provides a user interface for a system that allows users to cancel or delete rooms or spaces. The user can enter the name of a room in the first text field, and the system will retrieve the details of that room and display them in the other text fields. Once the room details are displayed, the user can then initiate the deletion of that room by clicking the "Azione" button.
The interface is designed to guide the user through the process of deleting a room. The first text field is initially editable, allowing the user to enter a room name. When the user enters a room name and presses Enter or clicks the "Cerca" button, the system will attempt to retrieve the details of that room from a database. If the room is found, its details will be displayed in the other text fields, and the "Azione" button will be enabled, allowing the user to initiate the deletion process.
When the user clicks the "Azione" button, the system will attempt to delete the room from the database. If the deletion is successful, the fields will be cleared, and the "Azione" button will be disabled. If there are any issues with the database, an error message will be displayed to the user, providing feedback and guidance to the user. | Code |
ConfigurazioneSistema.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import java.lang.String;
import common.utility.*;
import common.def.*;
import moduli.*;
public class ConfigurazioneSistema extends Frame
{
// font costanti per uniformare l'aspetto delle finestre
public static final Font font_base = new Font("TimesRoman", Font.PLAIN, 12);
public static final Font font_sub = new Font("Courier", Font.BOLD, 18);
public static final Font font_titolo = new Font("Courier", Font.BOLD, 12);
public static final Font font_allineato = new Font("Courier", Font.PLAIN, 12);
// componenti della finestra di configurazione
TextField giorni_blocco, sup_bassissima, sup_bassa, sup_media, sup_alta,sup_letto_agg,
costo_x_scatto, sup_neonato, rid_bambino, rid_ragazzo, rid_comitiva,
password, num_max_stanze, px_colazione, px_mezza, px_intera, coperto,
min_pers_comitiva, cambio, albergo, indirizzo_alb, comune_alb,
citta_alb, rag_soc, licenza;
Label cambio_L_E;
Label etichetta, etich1, etich2, etich3, etich4, etich5, etich6, etich7, etich8,
etich9, etich10, etich11 ,etich11_1, etich12, etich13, etich14, etich15, etich16, etich17,
etich18, etich19, etich20, etichetta1, etichetta2, etichetta3,etichetta4,
etichetta5, etich21, etich22, etichetta6, etich23,etich24,etich25, etichetta7;
Panel panel0, panel1, panel2, panel3, panel4;
GridBagLayout gridbag = new GridBagLayout();
CheckboxGroup checkbox;
Checkbox[] checkboxes;
Button Annulla, Passwd, Conferma, Stagioni;
DefinizioneStagionalita def_stag;
// per il cambio di password e stagionalita
static String new_passwd;
static char[] new_stag_anno_corr, new_stag_anno_prox;
// per la gerarchia delle finestre
SubGestione padre = new SubGestione();
// per fregare l'ascoltatore
static Configurazione this_config;
DataBase db;
boolean first_start;
public ConfigurazioneSistema(Configurazione config, boolean prima_volta, DataBase archivio)
{
super("Configurazione di sistema");
this_config = config;
db = archivio;
new_passwd = this_config.getPassword();
new_stag_anno_corr = this_config.getStagionalita(Const.ANNO_CORRENTE);
new_stag_anno_prox = this_config.getStagionalita(Const.ANNO_PROSSIMO);
first_start = prima_volta;
setupPanels(prima_volta);
init();
pack();
}
public void setupPanels(boolean prima_volta)
{
this.setFont(font_base);
//creo le etichette
cambio_L_E = new Label("Cambio Lira <-> EURO");
etichetta = new Label("Licenza:");
etichetta.setFont(new Font("Courier", Font.BOLD, 12));
etichetta1 = new Label("DATI DI CONFIGURAZIONE");
etichetta1.setFont(new Font("Courier", Font.BOLD, 12));
etichetta2 = new Label("Supplementi dovuto alle stagionionalita'");
etichetta2.setFont(new Font("Courier", Font.BOLD, 12));
etichetta3 = new Label("Riduzioni");
etichetta3.setFont(new Font("Courier", Font.BOLD, 12));
etichetta4 = new Label("Ristorazione");
etichetta4.setFont(new Font("Courier", Font.BOLD, 12));
etichetta5 = new Label("Valuta");
etichetta5.setFont(new Font("Courier", Font.BOLD, 12));
etichetta6 = new Label("Cambio di password utente");
etichetta6.setFont(new Font("Courier", Font.BOLD, 12));
etichetta7 = new Label("Definizione delle stagionalita'");
etichetta7.setFont(new Font("Courier", Font.BOLD, 12));
licenza = new TextField("",35);
albergo = new TextField("",25);
comune_alb =new TextField("",35);
citta_alb = new TextField("",25);
indirizzo_alb = new TextField("",35);
rag_soc = new TextField("",35);
giorni_blocco = new TextField("",4);
sup_bassissima = new TextField("",9);
sup_bassa = new TextField("",9);
sup_media = new TextField("",9);
sup_alta = new TextField("",9);
sup_neonato = new TextField("",9);
sup_letto_agg = new TextField("",9);
rid_bambino = new TextField("",4);
rid_ragazzo = new TextField("",4);
rid_comitiva = new TextField("",4);
min_pers_comitiva = new TextField("",4);
num_max_stanze = new TextField("",4);
num_max_stanze.setEditable(false);
px_colazione = new TextField("",9);
px_mezza = new TextField("",9);
px_intera = new TextField("",9);
coperto = new TextField("",9);
costo_x_scatto = new TextField("",9);
password = new TextField("",20);
cambio = new TextField("",8);
//creo un Checkbox
checkbox = new CheckboxGroup();
checkboxes = new Checkbox[2];
checkboxes[0] = new Checkbox(" Lire",checkbox,true);
checkboxes[1] = new Checkbox(" EURO",checkbox,false);
writeDatiConf();
if (prima_volta)
licenza.setEditable(true);
else
licenza.setEditable(false);
licenza.setForeground(Color.red.darker());
albergo.setForeground(Color.blue);
comune_alb.setForeground(Color.blue);
citta_alb.setForeground(Color.blue);
rag_soc.setForeground(Color.blue);
password.setEchoChar('*');
etich1 = new Label("Dati dell'albergo");
etich1.setFont(new Font("Courier", Font.BOLD, 12));
etich2 = new Label("Nome dell'albergo:");
etich3 = new Label("Indirizzo dell'albergo:");
indirizzo_alb.setForeground(Color.blue);
etich4 = new Label("Comune dell'albergo:");
etich5 = new Label("Citta' dell'albergo:");
etich6 = new Label("Numero di giorni massimo di bloccaggio di una stanza");
etich7 = new Label("Supplemento bassisima stagione");
etich8 = new Label("Supplemento bassa stagione");
etich9 = new Label("Supplemento media stagione");
etich10 = new Label("Supplemento alta stagione");
etich11 = new Label("Supplemento per neonati");
etich11_1 = new Label("Supplemento letto aggiuntivo");
etich12 = new Label("Riduzione per bambini %");
etich13 = new Label("Riduzione per ragazzi %");
etich14 = new Label("Riduzione per comitive %");
etich15 = new Label("Numero minimo di persone per comitiva");
etich16 = new Label("Numero di stanze");
etich17 = new Label("Supplemento prima colazione");
etich18 = new Label("Supplemento mezza pensione");
etich19 = new Label("Supplemento pensione completa");
etich20 = new Label("Coperto per la ristorazione");
etich21 = new Label("Costo di uno scatto telefonico");
etich22 = new Label("Password utente");
etich23 = new Label("Lire");
etich24 = new Label("Dollari");
etich25 = new Label("Ragione sociale");
//creo i pulsanti
Annulla = new Button("Annulla");
Passwd = new Button("Cambio di password");
Conferma = new Button("Conferma");
Stagioni = new Button("Definisci Stagionalita'");
panel0 = new Panel();
panel0.setLayout(gridbag);
Utils.constrain(panel0, etichetta, 0, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 0, 0, 0);
Utils.constrain(panel0, licenza, 1, 0, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
Utils.constrain(panel0, etich1, 0, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 0, 0, 0);
Utils.constrain(panel0, etich2, 0, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel0, albergo, 1, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel0, etich3, 2, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel0, indirizzo_alb, 3, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel0, etich4, 0, 3, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel0, comune_alb, 1, 3, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel0, etich5, 2, 3, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel0, citta_alb, 3, 3, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel0, etich25, 0, 4, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel0, rag_soc, 1, 4, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
panel1 = new Panel();
panel1.setLayout(gridbag);
Utils.constrain(panel1, etichetta1, 0, 0, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 5, 5, 5);
Utils.constrain(panel1, etich6, 0, 1, 5, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 5, 5, 5);
Utils.constrain(panel1, giorni_blocco, 5, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 5, 5, 5);
Utils.constrain(panel1, etich21, 7, 1, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 5, 5, 5);
Utils.constrain(panel1, costo_x_scatto, 10, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 5, 5, 5);
Utils.constrain(panel1, etichetta2, 0, 2, 4, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etichetta3, 5, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etichetta4, 8, 2, 2, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
// supplementi
Utils.constrain(panel1, etich7, 0, 3, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, sup_bassissima, 3, 3, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich8, 0, 4, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, sup_bassa, 3, 4, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich9, 0, 5, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, sup_media, 3, 5, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich10, 0, 6, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, sup_alta, 3, 6, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich11, 0, 7, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, sup_neonato, 3, 7, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich11_1, 0, 8, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, sup_letto_agg, 3, 8, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
// riduzioni
Utils.constrain(panel1, etich12, 4, 3, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, rid_bambino, 7, 3, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich13, 4, 4, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, rid_ragazzo, 7, 4, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich14, 4, 5, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, rid_comitiva, 7, 5, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich15, 4, 6, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, min_pers_comitiva, 7, 6, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
// ristorazione
Utils.constrain(panel1, etich17, 8, 3, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, px_colazione, 11, 3, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich18, 8, 4, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, px_mezza, 11, 4, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich19, 8, 5, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, px_intera, 11, 5, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich20, 8, 6, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, coperto, 11, 6, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, cambio_L_E, 5, 7, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, cambio, 7, 7, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, etich16, 9, 7, 4, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, num_max_stanze, 11, 7, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
panel2 = new Panel();
panel2.setLayout(gridbag);
Utils.constrain(panel2, etichetta5, 0, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel2, checkboxes[0], 0, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel2, checkboxes[1], 0, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
panel3 = new Panel();
panel3.setLayout(gridbag);
Utils.constrain(panel3, etichetta6, 0, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel3, Passwd, 1, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel3, etichetta7, 0, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel3, Stagioni, 1, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
panel4 = new Panel();
panel4.setLayout(gridbag);
Utils.constrain(panel4, Annulla, 8, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTH, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel4, Conferma, 9, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTH, 0.0, 0.0, 5, 5, 5, 5);
this.setLayout(gridbag);
Utils.constrain(this,panel0, 0, 0, 12, 6, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(this,panel1, 0, 6, 12, 9, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(this,panel2, 0, 15, 1, 3, GridBagConstraints.HORIZONTAL,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(this,panel3, 1, 15, 11, 2, GridBagConstraints.HORIZONTAL,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(this,panel4, 0, 19, 12, 1, GridBagConstraints.HORIZONTAL,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
}
public void init()
{
Annulla.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
if (!first_start)
padre.setEnabled(true);
else
System.exit(0);
}
});
Conferma.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startConferma();
}
});
checkboxes[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(checkboxes[0].getState())
{
startAvviso(Const.LIRE);
}
}
});
checkboxes[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(checkboxes[1].getState())
{
startAvviso(Const.EURO);
}
}
});
Passwd.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startChangePwd();
}
});
Stagioni.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
setStagioni();
}
});
}
void startAvviso(char nuova_valuta)
{
Frame msg;
if (nuova_valuta != this_config.getValuta() && !first_start)
{
msg = new AvvisoDialog(this, "Attenzione: il cambio LIRA<->EURO effettuato alla conferma modifichera' le cifre della finestra corrente!");
}
}
void startChangePwd()
{
this.setEnabled(false);
CambioPassword cambio = new CambioPassword();
cambio.setVisible(true);
cambio.conf = this;
}
void startConferma()
{
MessageDialog msg;
int j;
if (!errore())
{
char vecchia_valuta = this_config.getValuta();
readDatiConf();
this_config.setPassword(new_passwd);
this_config.setStagionalita(new_stag_anno_corr, new_stag_anno_prox);
if ( (j = (db.writeConfigurazione(this_config))) != DataBase.OK )
{
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j));
}
else
{
if ( vecchia_valuta != this_config.getValuta() && !first_start)
{
j = (Principale.db).startCambioValuta();
if (j != DataBase.OK)
{
msg = new MessageDialog(this, "Errore con il database: "+DataBase.strErrore(j));
return;
}
this_config = (Principale.db).readConfigurazione();
Principale.config = this_config;
}
if (!(first_start))
{
padre.pass.p.setTitle(this_config.getNomeAlbergo());
padre.setEnabled(true);
}
else
{
Frame p = new Principale(this_config, db);
p.setVisible(true);
}
dispose();
}
}
}
void setStagioni()
{
def_stag = new DefinizioneStagionalita(this);
}
boolean errore()
{
Frame msg;
if ( !((licenza.getText()).length() < 33 ) )
{
msg = new MessageDialog(this, " La licenza deve essere composta da al piu' 32 caratteri! ");
return true;
}
if ( !((albergo.getText()).length() < 21 ))
{
msg = new MessageDialog(this, " Il nome dell'albergo deve essere composto da al piu' 20 caratteri! ");
return true;
}
if ( !((comune_alb.getText()).length() < 33 ) )
{
msg = new MessageDialog(this, " Il comune deve essere composto da al piu' 32 caratteri! ");
return true;
}
if ( !((indirizzo_alb.getText()).length() < 33 ) )
{
msg = new MessageDialog(this, " L'indirizzo deve essere composto da al piu' 32 caratteri! ");
return true;
}
if ( !((citta_alb.getText()).length() < 21 ) )
{
msg = new MessageDialog(this, " La citta' deve essere composta da al piu' 20 caratteri! ");
return true;
}
if ( !((rag_soc.getText()).length() < 33 ) )
{
msg = new MessageDialog(this, " La ragione sociale deve essere composta da al piu' 32 caratteri! ");
return true;
}
if ( !Utils.isIntPos(giorni_blocco.getText()) )
{
msg = new MessageDialog(this, " Il numero di giorni di blocco deve essere un numero intero positivo! ");
return true;
}
if ( !Utils.isFloatPos(sup_bassissima.getText()) ||
!Utils.isFloatPos(sup_bassa.getText()) ||
!Utils.isFloatPos(sup_media.getText()) ||
!Utils.isFloatPos(sup_alta.getText()) ||
!Utils.isFloatPos(sup_neonato.getText()) ||
!Utils.isFloatPos(sup_letto_agg.getText()) ||
!Utils.isFloatPos(px_colazione.getText()) ||
!Utils.isFloatPos(px_mezza.getText()) ||
!Utils.isFloatPos(px_intera.getText()) )
{
msg = new MessageDialog(this, " I supplementi devono essere numeri positivi! ");
return true;
}
if ( !Utils.isIntPos(rid_bambino.getText()) ||
!Utils.isIntPos(rid_ragazzo.getText()) ||
!Utils.isIntPos(rid_comitiva.getText()) )
{
msg = new MessageDialog(this, " deve essere un numero intero! ");
return true;
}
if ( !Utils.isIntPos(min_pers_comitiva.getText()) )
{
msg = new MessageDialog(this, " Il numero di persone comitiva deve essere un numero intero positivo! ");
return true;
}
if ( !Utils.isIntPos(num_max_stanze.getText()) )
{
msg = new MessageDialog(this, " Il numero di stanze deve essere un numero intero positivo! ");
return true;
}
if ( !Utils.isFloatPos(coperto.getText()) )
{
msg = new MessageDialog(this, " Il coperto deve essere un numero positivo! ");
return true;
}
if ( !Utils.isFloatPos(costo_x_scatto.getText()) )
{
msg = new MessageDialog(this, " Il costo dello scatto telefonico deve essere un numero positivo! ");
return true;
}
if ( !Utils.isFloatPos(cambio.getText()) )
{
msg = new MessageDialog(this, " Il coefficiente di cambio LIRE<->EURO deve essere un numero positivo e diverso da zero! ");
return true;
}
else
if ( !((Float.valueOf(cambio.getText())).floatValue() > 0) )
{
msg = new MessageDialog(this, " Il coefficiente di cambio LIRE<->EURO deve essere un numero positivo e diverso da zero! ");
return true;
}
return false;
}
void readDatiConf()
{
this_config.setLicenza(licenza.getText());
this_config.setNomeAlbergo(albergo.getText());
this_config.setComuneAlb(comune_alb.getText());
this_config.setIndirizzoAlb(indirizzo_alb.getText());
this_config.setCittaAlb(citta_alb.getText());
this_config.setRagSoc(rag_soc.getText());
this_config.setGiorniBlocco(Integer.parseInt(giorni_blocco.getText()));
this_config.setSupplemento((Float.valueOf(sup_bassissima.getText())).floatValue(),Flag.BASSISSIMA_STAGIONE);
this_config.setSupplemento((Float.valueOf(sup_bassa.getText())).floatValue(),Flag.BASSA_STAGIONE);
this_config.setSupplemento((Float.valueOf(sup_media.getText())).floatValue(),Flag.MEDIA_STAGIONE);
this_config.setSupplemento((Float.valueOf(sup_alta.getText())).floatValue(),Flag.ALTA_STAGIONE);
this_config.setSupNeonato((Float.valueOf(sup_neonato.getText())).floatValue());
this_config.setSupLettoAgg((Float.valueOf(sup_letto_agg.getText())).floatValue());
this_config.setRiduzione(Integer.parseInt(rid_bambino.getText()),Flag.BAMBINO);
this_config.setRiduzione(Integer.parseInt(rid_ragazzo.getText()),Flag.RAGAZZO);
this_config.setRiduzione(Integer.parseInt(rid_comitiva.getText()),Flag.COMITIVA);
this_config.setMinPersComit(Integer.parseInt(min_pers_comitiva.getText()));
this_config.setNumStanze(Integer.parseInt(num_max_stanze.getText()));
this_config.setPxColazione((Float.valueOf(px_colazione.getText())).floatValue());
this_config.setPxMezza((Float.valueOf(px_mezza.getText())).floatValue());
this_config.setPxIntera((Float.valueOf(px_intera.getText())).floatValue());
this_config.setCoperto((Float.valueOf(coperto.getText())).floatValue());
this_config.setCostoXScatto((Float.valueOf(costo_x_scatto.getText())).floatValue());
this_config.setCoeffXCambio((Float.valueOf(cambio.getText())).floatValue());
if (checkboxes[0].getState())
this_config.setValuta(Const.LIRE);
else
this_config.setValuta(Const.EURO);
}
void writeDatiConf()
{
//String s = new String(Principale.simbol);
licenza.setText(""+this_config.getLicenza());
albergo.setText(""+this_config.getNomeAlbergo());
comune_alb.setText(""+this_config.getComuneAlb());
indirizzo_alb.setText(""+this_config.getIndirizzoAlb());
citta_alb.setText(""+this_config.getCittaAlb());
rag_soc.setText(""+this_config.getRagSoc());
giorni_blocco.setText(""+this_config.getGiorniBlocco());
sup_bassissima.setText(""+this_config.getSupplemento(Flag.BASSISSIMA_STAGIONE));
sup_bassa.setText(""+this_config.getSupplemento(Flag.BASSA_STAGIONE));
sup_media.setText(""+this_config.getSupplemento(Flag.MEDIA_STAGIONE));
sup_alta.setText(""+this_config.getSupplemento(Flag.ALTA_STAGIONE));
sup_neonato.setText(""+this_config.getSupNeonato());
sup_letto_agg.setText(""+this_config.getSupLettoAgg());
rid_bambino.setText(""+this_config.getRiduzione(Flag.BAMBINO));
rid_ragazzo.setText(""+this_config.getRiduzione(Flag.RAGAZZO));
rid_comitiva.setText(""+this_config.getRiduzione(Flag.COMITIVA));
min_pers_comitiva.setText(""+this_config.getMinPersComit());
num_max_stanze.setText(""+this_config.getNumStanze());
px_colazione.setText(""+this_config.getPxColazione());
px_mezza.setText(""+this_config.getPxMezza());
px_intera.setText(""+this_config.getPxIntera());
coperto.setText(""+this_config.getCoperto());
costo_x_scatto.setText(""+this_config.getCostoXScatto());
cambio.setText(""+this_config.getCoeffXCambio());
if (this_config.getValuta() == Const.LIRE)
checkbox.setSelectedCheckbox(checkboxes[0]);
else
checkbox.setSelectedCheckbox(checkboxes[1]);
}
}
/****************************************************************************/
class CambioPassword extends Frame
{
TextField testo1, testo2, testo3;
Label label1, label2, label3;
GridBagLayout grid = new GridBagLayout();
Panel pannello, pannello_x_annulla;
Frame conf = new Frame();
Button conferma, cambio, annulla;
MessageDialog dialog;
public CambioPassword()
{
super("Cambio di password");
setupPanels();
init();
pack();
}
void setupPanels()
{
this.setFont(ConfigurazioneSistema.font_base);
//creo le etichette
label1 = new Label("Inserire vecchia password");
label2 = new Label("Inserire nuova password");
label3 = new Label("Reinserire la nuova password");
//creo i textField
testo1 = new TextField("",20);
testo2 = new TextField("",20);
testo1.setEchoChar('*');
testo2.setEchoChar('*');
testo2.setEditable(false);
conferma = new Button("Conferma");
cambio = new Button("Cambio di password");
cambio.setEnabled(false);
annulla = new Button("Annulla");
pannello = new Panel();
pannello.setLayout(grid);
Utils.constrain(pannello, label1, 0, 0, 2, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(pannello, testo1, 2, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(pannello, label2, 0, 1, 2, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(pannello, testo2, 2, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(pannello, conferma, 3, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(pannello, cambio, 3, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
pannello_x_annulla = new Panel();
pannello_x_annulla.setLayout(grid);
Utils.constrain(pannello_x_annulla, annulla, 0, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 1.0, 0.0, 5, 5, 5, 5);
this.setLayout(grid);
Utils.constrain(this,pannello, 0, 0, 4, 2, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(this,pannello_x_annulla, 0, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 1.0, 0.0, 5, 5, 5, 5);
}
void init()
{
annulla.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
conf.setEnabled(true);
}
});
conferma.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
g();
}
});
testo1.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
g();
}
});
cambio.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
i();
}
});
testo2.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
i();
}
});
}
void g()
{
String tmp = testo1.getText();
if(tmp.equals(ConfigurazioneSistema.new_passwd))
{
testo2.setEditable(true);
testo1.setEditable(false);
cambio.setEnabled(true);
conferma.setEnabled(false);
}
else
{
dialog = new MessageDialog(this,"La password non e' corretta");
dialog.setVisible(true);
testo1.setText("");
}
}
void i()
{
String tmp = testo2.getText();
Messaggio messaggio1 = new Messaggio(tmp);
messaggio1.setVisible(true);
messaggio1.c = this;
this.setEnabled(false);
}
}
/****************************************************************************/
class Messaggio extends Frame
{
Label msg;
Button OK;
CambioPassword c = new CambioPassword();
Avviso dialog;
GridBagLayout gridbag = new GridBagLayout();
TextField testo3;
Panel pannello;
String pwd_passata;
public Messaggio(String text)
{
super("Messaggio per il cambio di password");
setup();
pwd_passata = text;
init();
pack();
}
void setup()
{
this.setFont(ConfigurazioneSistema.font_base);
//creo un pulsante
OK = new Button("OK");
//creo un'etichetta
msg = new Label("Reinserire la nuova password");
//creo un textField
testo3 = new TextField("",20);
testo3.setEchoChar('*');
pannello = new Panel();
pannello.setLayout(gridbag);
Utils.constrain(pannello, msg, 0, 0, 2, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(pannello, testo3, 2, 0, 2, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(pannello, OK, 4, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
this.setLayout(gridbag);
Utils.constrain(this, pannello, 0, 0, 4, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
}
public void init()
{
OK.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startOK();
}
});
testo3.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startOK();
}
});
}
void startOK()
{
if((testo3.getText()).equals(pwd_passata))
{
ConfigurazioneSistema.new_passwd = testo3.getText();
dialog = new Avviso(this,"La password verra' cambiata alla conferma");
}
else
dialog = new Avviso(this,"La nuova password non e' stata accettata");
dialog.setVisible(true);
}
}
/****************************************************************************/
class Avviso extends Frame
{
Button OK;
Messaggio padre;
public Avviso(Messaggio parent, String testo)
{
super("Attenzione");
padre = parent;
padre.setEnabled(false);
this.setFont(ConfigurazioneSistema.font_titolo);
Panel textPanel = new Panel();
Panel buttonPanel = new Panel();
textPanel.add(new Label(testo));
OK = new Button("OK");
buttonPanel.add(OK);
add("North",textPanel);
add("Center",buttonPanel);
init();
pack();
setVisible(true);
}
public void init()
{
OK.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
esci();
}
});
}
void esci()
{
dispose();
padre.dispose();
padre.c.dispose();
padre.c.conf.setEnabled(true);
}
}
| The provided code allows users to configure various settings and parameters for a hotel management system. Users can access a comprehensive configuration window that enables them to modify a wide range of hotel-related information, including pricing, supplemental charges, discounts, telephone call charges, maximum room capacity, and password management. The configuration window is divided into distinct panels, each focusing on a specific set of settings, allowing users to navigate and make changes efficiently.
Users can define the hotel's seasonality, which affects the supplemental charges, and can also change their password and view the current exchange rate between the local currency and the Euro. The code includes robust error checking to ensure users enter valid values in the text fields, and any changes made are automatically saved to a database for future use. This configuration functionality empowers hotel management to tailor the system to their specific needs, optimizing operations and enhancing the overall guest experience. | Code |
ControllaPrenotazione.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import java.util.Date;
import moduli.*;
public class ControllaPrenotazione extends MascheraPrenotazione
{
Prenotazione p;
PrenotazioniScadute parent;
public ControllaPrenotazione(Prenotazione pren, Stanza room, PrenotazioniScadute papa)
{
super(room,"","","Controlla dei dati della prenotazione"," Rinnova ",5,pren.getPensionamento());
p = pren;
parent = papa;
init();
}
public void init()
{
writeDatiPren(p);
for(int i=0; i<11; i++)
testo[i].setEditable(false);
testo[9].setText(DateUtils.parseDate(DateUtils.giveStringOfDate(p.getDataPren())));
Azione.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startRinnova();
dispose();
parent.dispose();
startUpdate();
}
});
Cancella.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startCancella();
dispose();
parent.dispose();
startUpdate();
}
});
}
void startUpdate()
{
Frame supp = (parent.padre).p;
((Principale) supp).updateBloccate();
}
void startCancella()
{
Frame msg;
ListaDisponibilita elenco_disp = (Principale.db).elencoDisponibilita();
if (elenco_disp != null)
{
(Principale.db).delPrenotazione(p.getIdPrenotazione());
Utils.aggiornaDisp(elenco_disp, p.getNumStanza(), p.getInizioSogg(), p.getFineSogg(), Flag.DISPONIBILE, Flag.BLOCCATA, true);
if (p.getTramiteAgenzia() == Const.SI)
Utils.restoreCommissioni(p.getNumStanza());
dispose();
padre.setEnabled(true);
}
else
msg = new MessageDialog(this, " Problemi con il database nella lettura delle disponibilita! ");
}
void startRinnova()
{
p.setDataPren(new Date());
(Principale.db).changePrenotazione(p.getIdPrenotazione(), p.getNumStanza(),
p.getNumPers(),p.getNome(),p.getCognome(),
p.getNumTel(), p.getInizioSogg(), p.getFineSogg(), p.getDataPren(),
p.getCaparra(), p.getRichLettoAgg(), p.getPensionamento(),
p.getTramiteAgenzia(), p.getNomeAgenzia(), p.getRichParticolari());
dispose();
parent.setEnabled(true);
}
}
| This code provides a user interface for managing hotel reservations. Users can view the details of an existing reservation, including the room number, guest information, dates of stay, and any special requests. The code allows users to renew a reservation by updating the reservation date, or cancel a reservation entirely. When a reservation is canceled, the system automatically updates the room availability and restores any commissions paid through an external agency. The code also ensures that the overall system is updated with the changes made to the reservation, keeping the reservation status accurate across the application. This comprehensive set of features empowers users to fully control the lifecycle of a hotel reservation, from viewing the details to making updates or cancellations as needed. | Code |
DefinizioneStagionalita.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import moduli.*;
import common.def.*;
import common.utility.Utils;
import java.util.Date;
public class DefinizioneStagionalita extends Frame
{
//Dichiaro gli oggetti che mi serviranno per costruire la finestra
Panel panel1, panel2, panel3, panel4, panel5;
Label etichetta1, etichetta2, etichetta3, etichetta, etichetta4;
Button Annulla, Conferma, Aggiungi;
TextField data_inizio, data_fine;
List list;
GridBagLayout gridbag = new GridBagLayout();
CheckboxGroup checkbox_group;
Checkbox[] checkboxes;
// variabili locali di supporto
char conf_stag_corr[], conf_stag_prox[];
Configurazione config_locale;
int anno_corr, anno_prox;
// segue la finestra madre di questa
Frame config;
public DefinizioneStagionalita(Frame parent)
{
super("Definisione delle stagionalita'");
config = parent;
config.setEnabled(false);
setupPanels();
initVectors();
init();
pack();
setVisible(true);
}
void setupPanels()
{
this.setFont(ConfigurazioneSistema.font_base);
//Creo i TextField
data_inizio = new TextField("", 12);
data_fine = new TextField("", 12);
//Creo i pulsanti e ne disabilito due
Annulla = new Button("Annulla");
Conferma = new Button("Conferma");
Aggiungi = new Button("Aggiungi");
Aggiungi.setEnabled(false);
//Creo le etichette
etichetta= new Label("Periodo di soggiorno");
etichetta.setFont(ConfigurazioneSistema.font_titolo);
etichetta1 = new Label("Data inizio:");
etichetta2 = new Label(" Data fine:");
etichetta3 = new Label ("Prospetto della distriduzione delle staginalita':");
etichetta3.setFont(new Font("Courier", Font.BOLD, 12));
Label space = new Label(" ");
//Creo la lista
list = new List(15,false);
//Creo il pannello in alto
panel1 = new Panel();
panel1.setLayout(gridbag);
Utils.constrain(panel1, etichetta, 0, 0, 4, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 10, 0);
Utils.constrain(panel1, etichetta1, 0, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 0, 0, 0);
Utils.constrain(panel1, data_inizio, 1, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST,1.0,0.0,0,0,0,0);
//Utils.constrain(panel1, space, 2, 1, 1, 1, GridBagConstraints.NONE,
//GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 0, 0, 0);
Utils.constrain(panel1, etichetta2, 3, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 0, 0, 0);
Utils.constrain(panel1,data_fine, 4, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 0, 0);
Utils.constrain(panel1, space, 5, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 0, 0, 0, 0);
//Creo un pannello con due pulsanti
panel2 = new Panel();
panel2.setLayout(gridbag);
Utils.constrain(panel2, Aggiungi, 0, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 0.3, 0.0, 0, 0, 0, 10);
//Creo un Checkbox ad esclusione
checkbox_group = new CheckboxGroup();
checkboxes = new Checkbox[5];
checkboxes[0] = new Checkbox(" Alta stagione",checkbox_group,false);
checkboxes[1] = new Checkbox(" Media stagione",checkbox_group,false);
checkboxes[2] = new Checkbox(" Bassa stagione",checkbox_group,false);
checkboxes[3] = new Checkbox(" Bassissima stagione",checkbox_group,false);
checkboxes[4] = new Checkbox(" Chiusura",checkbox_group,false);
etichetta4= new Label("Stagionalita' disponibili");
etichetta4.setFont(new Font("Courier", Font.BOLD, 12));
//Creo il pannello
panel3 = new Panel();
panel3.setLayout(gridbag);
Utils.constrain(panel3, etichetta4, 0, 1, 4, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 0, 10, 0);
Utils.constrain(panel3, checkboxes[0], 0, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 5, 0, 0);
Utils.constrain(panel3, checkboxes[1], 0, 3, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 5, 0, 0);
Utils.constrain(panel3, checkboxes[2], 0, 4, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 5, 0, 0);
Utils.constrain(panel3, checkboxes[3], 0, 5, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 5, 0, 0);
Utils.constrain(panel3, checkboxes[4], 0, 6, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 0, 5, 0, 0);
//Creo il pannello contenente la TextArea
panel4 = new Panel();
panel4.setLayout(gridbag);
Utils.constrain(panel4, etichetta3, 0, 0, 2, 1, GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 0, 0, 0, 0);
Utils.constrain(panel4,list, 0, 1, 4, 3, GridBagConstraints.BOTH,
GridBagConstraints.CENTER, 3.0, 3.0, 0, 0, 0, 0);
//Creo il pannello in basso con due pulsanti
panel5 = new Panel();
panel5.setLayout(gridbag);
Utils.constrain(panel5, Annulla, 0, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.SOUTHEAST, 0.3, 0.0, 0, 0, 0, 10);
Utils.constrain(panel5, Conferma, 1, 1, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.SOUTHWEST, 0.3, 0.0, 0, 0, 0, 0);
//Attacco i pannelli al frame
this.setLayout(gridbag);
Utils.constrain(this, panel1, 0, 0, 4, 2, GridBagConstraints.HORIZONTAL,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 15, 10, 10, 10);
Utils.constrain(this, panel3, 0, 2, 4, 1,GridBagConstraints.HORIZONTAL,
GridBagConstraints.NORTHEAST, 1.0, 0.0, 10, 10, 0, 10);
Utils.constrain(this, panel2, 0, 5, 4, 1,GridBagConstraints.HORIZONTAL,
GridBagConstraints.NORTHEAST, 1.0, 0.0, 10, 10, 0, 10);
Utils.constrain(this, panel4, 0, 6, 4, 3, GridBagConstraints.BOTH,
GridBagConstraints.CENTER, 2.0, 2.0, 10, 10, 10, 10);
Utils.constrain(this, panel5, 0, 10, 4, 1, GridBagConstraints.HORIZONTAL,
GridBagConstraints.SOUTHWEST, 1.0, 1.0, 10, 10, 15, 10);
}
//Gestione degli eventi
public void init()
{
//Ascoltatore degli eventi della finestra
checkboxes[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if ( (checkboxes[0].getState()) && (!(data_inizio.getText()).equals("")) && (!(data_fine.getText()).equals("")) )
{
Aggiungi.setEnabled(true);
}
}
});
checkboxes[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if ( (checkboxes[1].getState()) && (!(data_inizio.getText()).equals("")) && (!(data_fine.getText()).equals("")) )
{
Aggiungi.setEnabled(true);
}
}
});
checkboxes[2].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if ( (checkboxes[2].getState()) && (!(data_inizio.getText()).equals("")) && (!(data_fine.getText()).equals("")) )
{
Aggiungi.setEnabled(true);
}
}
});
checkboxes[3].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if ( (checkboxes[3].getState()) && (!(data_inizio.getText()).equals("")) && (!(data_fine.getText()).equals("")) )
{
Aggiungi.setEnabled(true);
}
}
});
checkboxes[4].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if ( (checkboxes[4].getState()) && (!(data_inizio.getText()).equals("")) && (!(data_fine.getText()).equals("")) )
{
Aggiungi.setEnabled(true);
}
}
});
/* Nel caso di annullamento dell'operazione ripristino i vettori
* originali della Configurazione
*/
Annulla.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
config.setEnabled(true);
}
});
//Ascoltatore del pulsante Conferma, se il pulsante viene premuto si apre
//la finestra riguardante l'inserimento della prenotazione
Aggiungi.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startAggiungi();
}
});
Conferma.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
ConfigurazioneSistema.new_stag_anno_corr = (config_locale.getStagAnnoCorr());
ConfigurazioneSistema.new_stag_anno_prox = (config_locale.getStagAnnoProx());
dispose();
config.setEnabled(true);
}
});
}
void startAggiungi()
{
char flag;
String lista[];
if (Utils.dateEPeriodoCorretti(this, data_inizio.getText(), data_fine.getText()))
{
if (checkboxes[0].getState() == true)
flag = Flag.ALTA_STAGIONE;
else
if (checkboxes[1].getState() == true)
flag = Flag.MEDIA_STAGIONE;
else
if (checkboxes[2].getState() == true)
flag = Flag.BASSA_STAGIONE;
else
if (checkboxes[3].getState() == true)
flag = Flag.BASSISSIMA_STAGIONE;
else
flag = Flag.CHIUSO;
config_locale.setStagione(new Date(DateUtils.invertDate(DateUtils.parseDate(data_inizio.getText()))), new Date(DateUtils.invertDate(DateUtils.parseDate(data_fine.getText()))), flag);
conf_stag_corr = config_locale.getStagionalita(Const.ANNO_CORRENTE);
conf_stag_prox = config_locale.getStagionalita(Const.ANNO_PROSSIMO);
visStagionalita();
data_inizio.setText("");
data_fine.setText("");
for (int i = 0; i<checkboxes.length; i++)
checkboxes[i].setState(false);
Aggiungi.setEnabled(false);
}
}
/* Creo un duplicato dei vettori delle stagionalita per permettere
* l'annullamento delle operazioni
*/
void initVectors()
{
config_locale = new Configurazione();
config_locale.setStagAnnoCorr(ConfigurazioneSistema.new_stag_anno_corr);
config_locale.setStagAnnoProx(ConfigurazioneSistema.new_stag_anno_prox);
conf_stag_corr = config_locale.getStagionalita(Const.ANNO_CORRENTE);
conf_stag_prox = config_locale.getStagionalita(Const.ANNO_PROSSIMO);
Costanti cost = new Costanti();
anno_corr = cost.getAnnoCorr();
anno_prox = cost.getAnnoProx();
visStagionalita();
}
void visStagionalita()
{
String lista[] = reportStagionalita();
if (list.getItemCount() > 0)
list.removeAll();
for (int k = 0; k<lista.length; k++)
list.addItem(lista[k]);
}
String[] reportStagionalita()
{
String lista_loc[] = new String[30];
int index = 0;
String str_aus;
initLista(lista_loc);
//Scansione dei 5 tipi di stagionalita per l'anno corrente
str_aus = Utils.scanVector(Flag.ALTA_STAGIONE, conf_stag_corr, anno_corr);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di alta stagione per l'anno "+anno_corr);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
str_aus = Utils.scanVector(Flag.MEDIA_STAGIONE, conf_stag_corr, anno_corr);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di media stagione per l'anno "+anno_corr);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
str_aus = Utils.scanVector(Flag.BASSA_STAGIONE, conf_stag_corr, anno_corr);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di bassa stagione per l'anno "+anno_corr);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
str_aus = Utils.scanVector(Flag.BASSISSIMA_STAGIONE, conf_stag_corr, anno_corr);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di bassissima stagione per l'anno "+anno_corr);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
str_aus = Utils.scanVector(Flag.CHIUSO, conf_stag_corr, anno_corr);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di chiusura per l'anno "+anno_corr);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
// Scansione dei 5 tipi di stagionalita per l'anno seguente
str_aus = Utils.scanVector(Flag.ALTA_STAGIONE, conf_stag_prox, anno_prox);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di alta stagione per l'anno "+anno_prox);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
str_aus = Utils.scanVector(Flag.MEDIA_STAGIONE, conf_stag_prox, anno_prox);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di media stagione per l'anno "+anno_prox);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
str_aus = Utils.scanVector(Flag.BASSA_STAGIONE, conf_stag_prox, anno_prox);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di bassa stagione per l'anno "+anno_prox);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
str_aus = Utils.scanVector(Flag.BASSISSIMA_STAGIONE, conf_stag_prox, anno_prox);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di bassissima stagione per l'anno "+anno_prox);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
str_aus = Utils.scanVector(Flag.CHIUSO, conf_stag_prox, anno_prox);
if ( !( str_aus.equals("") ) )
{
lista_loc[index] = new String("Periodi di chiusura per l'anno "+anno_prox);
lista_loc[index+1] = new String(str_aus);
index = index+3;
}
return lista_loc;
}
void initLista(String lista[])
{
for (int k = 0; k < lista.length; k++)
lista[k] = new String("");
}
}
| This code provides a user interface for defining and managing the seasonality of a system. The user can access a window that displays the current and upcoming year's seasonality, including high, medium, low, very low, and closed seasons. The user can add new seasonal periods by specifying a start and end date, and then selecting the appropriate checkbox to indicate the type of season. The added seasonal periods are then displayed in a list within the window. The user can also cancel the operation, which will restore the original seasonality configuration, or confirm the changes, which will update the system's seasonality for the current and upcoming year. The code includes functionality to ensure that the user inputs valid dates and that the "Add" button is only enabled when the required fields are filled out. This user-friendly interface allows the user to easily define and update the seasonal periods as needed, providing a flexible and efficient way to manage the system's seasonality. | Code |
DescrittoreStanze.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import moduli.*;
public class DescrittoreStanze extends Frame
{
//Dichiaro gli oggetti che utilizzero' per costruire la finestra
Label etichetta, label1, label2, label3, label4;
TextField testo1, testo2, testo3, testo4;
Button Annulla, Azione, Cerca;
Panel panel1, panel2;
GridBagLayout gridbag = new GridBagLayout();
Checkbox mycheckboxes;
SubStanze stanze = new SubStanze();
int caller;
public DescrittoreStanze(String title, String caption, int c)
{
super(title);
caller = c;
setupPanels(caption);
inizializza();
pack();
}
void setupPanels(String caption)
{
this.setFont(ConfigurazioneSistema.font_base);
//Creo le etichette
etichetta=new Label("Informazioni sulle stanze");
etichetta.setFont(ConfigurazioneSistema.font_titolo);
label1 = new Label("Numero di stanza");
label2 = new Label("Numero di posti letto");
label3 = new Label("Prezzo base della stanza "+(Principale.config).getValuta()+".");
label4 = new Label("Descrizione delle caratteristiche peculiari della stanza");
//Creo i TextField
testo1 = new TextField("", 4);
testo2 = new TextField("", 4);
testo3 = new TextField("", 10);
testo4 = new TextField("", 50);
//Creo i bottoni
Annulla = new Button(" Fine ");
Azione = new Button(caption);
Cerca = new Button(" Cerca ");
mycheckboxes = new Checkbox(" Letto aggiuntivo", null, false);
//Creo il pannello in alto contenente i dati del cliente
panel1 = new Panel();
panel1.setLayout(gridbag);
Utils.constrain(panel1, etichetta, 0, 0, 2, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, label1, 0, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, testo1, 1, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, label2, 2, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 25);
Utils.constrain(panel1, testo2, 3, 1, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, label3, 0, 2, 1 ,1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, testo3, 1, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, mycheckboxes, 2, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, label4, 0, 3, 2, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 0.0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel1, testo4, 2, 3, 3, 1, GridBagConstraints.NONE,
GridBagConstraints.NORTHWEST, 1.0, 0.0, 5, 5, 5, 5);
//Creo il pannello in basso con due pulsanti
panel2 = new Panel();
panel2.setLayout(gridbag);
Utils.constrain(panel2, Annulla, 0, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 0, 0.0, 5, 5, 5, 5);
Utils.constrain(panel2, Azione, 1, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 0, 0.0, 5, 5, 5, 5);
if ((caller == 2) || (caller==3))
Utils.constrain(panel2, Cerca, 2, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 0, 0.0, 5, 5, 5, 5);
//Attacco i pannelli al frame
this.setLayout(gridbag);
Utils.constrain(this, panel1, 0, 0, 4, 4, GridBagConstraints.HORIZONTAL,
GridBagConstraints.NORTH, 1.0, 1.0, 5, 5, 5, 5);
Utils.constrain(this,panel2, 0, 4, 4, 1, GridBagConstraints.HORIZONTAL,
GridBagConstraints.CENTER, 1.0, 0.0, 5, 5, 5, 5);
}
public void inizializza()
{
Annulla.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
stanze.setEnabled(true);
}
});
}
protected Stanza readDatiStanza()
{
Stanza room = new Stanza();
room.setNumStanza(testo1.getText());
room.setPostiLetto(Integer.parseInt(testo2.getText()));
Float f = Float.valueOf(testo3.getText());
room.setPxBase(f.floatValue());
room.setDescrizione(testo4.getText());
if (mycheckboxes.getState())
room.setDispLettoAgg(Const.SI);
return room;
}
protected void writeDatiStanza(Stanza room)
{
testo1.setText(room.getNumStanza());
testo2.setText(""+room.getPostiLetto());
testo3.setText(""+room.getPxBase());
testo4.setText(room.getDescrizione());
if ( room.getDispLettoAgg() == Const.SI)
mycheckboxes.setState(true);
else
mycheckboxes.setState(false);
}
protected void cleanFields()
{
testo1.setText("");
testo2.setText("");
testo3.setText("");
testo4.setText("");
mycheckboxes.setState(false);
}
protected boolean errori()
{
Frame msg;
if ( !((testo1.getText()).length() <= 4) )
{
msg = new MessageDialog(this, " Il numero della stanza deve essere composto da al piu' 4 caratteri! ");
return true;
}
if ( ((testo1.getText()).equals("")) )
{
msg = new MessageDialog(this, " Manca il numero della stanza! ");
return true;
}
if ( ((testo2.getText()).equals("")) )
{
msg = new MessageDialog(this, " Manca il numero di posti letto! ");
return true;
}
if ( !Utils.isIntPos(testo2.getText()) )
{
msg = new MessageDialog(this, " Il numero di posti deve essere un numero positivo! ");
return true;
}
if ( ((testo3.getText()).equals("")) )
{
msg = new MessageDialog(this, " Manca il prezzo della stanza! ");
return true;
}
if ( !Utils.isFloatPos(testo3.getText()) )
{
msg = new MessageDialog(this, " Il prezzo della stanza deve essere un numero positivo! ");
return true;
}
if ( !((testo4.getText()).length() <= 52) )
{
msg = new MessageDialog(this, " La descrizione deve essere composta da al piu' 52 caratteri! ");
return true;
}
return false;
}
}
| This code provides a user interface for managing information about hotel rooms. Users can view, edit, and search for room details, including the room number, number of beds, base price, and a description of the room's features. The interface is divided into two panels, one for displaying the room information and one for the action buttons. Users can also indicate if an additional bed is available in the room.
The code sets up a graphical user interface using Java's Swing library, with various labels, text fields, and buttons for the user to interact with. It includes methods for reading and writing the room information to and from the text fields, as well as validating the user's input to ensure that it meets certain requirements, such as the room number being no more than 4 characters and the number of beds and price being positive numbers. The search functionality is only available in certain contexts, as indicated by the "caller" parameter passed to the constructor.
Overall, this code provides a comprehensive set of tools for managing hotel room information, allowing users to easily view, edit, and search for room details within a user-friendly graphical interface. | Code |
InserisciBeniServizi.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import moduli.BeneServizio;
import moduli.DataBase;
public class InserisciBeniServizi extends MascheraBeneServizio
{
BeneServizio extra = null;
public InserisciBeniServizi(String title)
{
super(title);
initialize();
setSize(350,520);
}
public void initialize()
{
scelta_piatto[4].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_piatto[4].getState())
{
level = 1;
codice = composeCode(level, BeneServizio.DESSERT);
p();
}
}
});
scelta_piatto[5].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_piatto[5].getState())
{
level = 1;
codice = composeCode(level, BeneServizio.FRUTTA);
p();
}
}
});
scelta_servizio[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_servizio[0].getState())
{
level = 1;
codice = composeCode(level, BeneServizio.RICREATIVI);
o();
}
}
});
scelta_servizio[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_servizio[1].getState())
{
level = 1;
codice = composeCode(level, BeneServizio.ALTRO);
o();
}
}
});
scelta_bevanda[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_bevanda[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.CAFFETTERIA);
o();
}
}
});
scelta_bevanda[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_bevanda[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.ANALCOLICI);
o();
}
}
});
scelta_bevanda[2].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_bevanda[2].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.ALCOLICI);
o();
}
}
});
scelta_cibo[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_cibo[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.DOLCI);
o();
}
}
});
scelta_cibo[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_cibo[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.SALATI);
o();
}
}
});
scelta_antipasto[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_antipasto[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.FREDDI);
o();
}
}
});
scelta_antipasto[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_antipasto[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.CALDI);
o();
}
}
});
scelta_primo[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_primo[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.SOLIDI);
o();
}
}
});
scelta_primo[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_primo[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.LIQUIDI);
o();
}
}
});
scelta_secondo[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_secondo[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.CARNE);
o();
}
}
});
scelta_secondo[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_secondo[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.PESCE);
o();
}
}
});
scelta_contorno[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_contorno[0].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.VERDURA_COTTA);
o();
}
}
});
scelta_contorno[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_contorno[1].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.VERDURA_CRUDA);
o();
}
}
});
scelta_contorno[2].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_contorno[2].getState())
{
level = 2;
codice = composeCode(level, BeneServizio.FORMAGGIO);
o();
}
}
});
conferma.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startConferma(padre);
}
});
} // init
void startConferma(Frame padre)
{
MessageDialog msg;
if (!errore())
{
Float px = Float.valueOf(testo4.getText());
extra = new BeneServizio((new String(codice))+tornaCodId((Principale.config).getIdBeneservizio()), testo3.getText(), px.floatValue());
int j;
if ( (j = (Principale.db).newIdBeneservizio()) == DataBase.OK )
{
(Principale.config).updateIdBeneservizio();
if ((j = (Principale.db).writeBeneServizio(extra)) == DataBase.OK)
{
if (padre instanceof MascheraAddebiti)
{ // questo serve in quanto l'AggiungiBeneServizio e' una estensione di questa classe
dispose();
padre.setEnabled(true);
((MascheraAddebiti) padre).inizExtra();
}
else
{ // questo serve in quanto AggiungiBeneServizio e' una estensione di questa
// classe ed e' utilizzata dalla maschera del conto ristorazione
if (padre instanceof MascheraContoRistorazione)
{
dispose();
padre.setEnabled(true);
((MascheraContoRistorazione) padre).inizExtra();
}
else
{
testo3.setText("");
testo4.setText("");
panel[10].setVisible(true);
}
}
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j));
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j));
}
}
void o()
{
completeCode();
this.add(panel[10]);
panel[10].setVisible(true);
testo3.setText("");
testo4.setText("");
setVisible(true);
}
void p()
{
completeCode();
if(panel[1].isVisible())
remove(panel[1]);
for(int i=3;i<13;++i)
{
if(panel[i].isVisible())
remove(panel[i]);
}
o();
}
String tornaCodId(long id)
{
completeCode();
String str_id = Long.toString(id);
while (str_id.length() < 5)
str_id = new String("0"+str_id);
return str_id;
}
} | This code provides a user interface for managing goods and services within a software system, likely related to a restaurant or catering business. Users can select from a variety of categories, including desserts, fruits, recreational services, and others, and create new items by entering a description and price. The code generates a unique identification code for each item based on the selected category and a sequential number, and stores the information in a database. The user interface includes error handling and messaging to provide feedback to the user during the process. This functionality is integrated into a larger software system, allowing the user to seamlessly add, view, and modify goods and services as needed to support the overall business operations. | Code |
InserisciCommissioni.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import moduli.*;
public class InserisciCommissioni extends MascheraCommissioni
{
MascheraRicercaStanza mask_ricerca = new MascheraRicercaStanza("",1);
public InserisciCommissioni(Stanza stanza, String data1, String data2)
{
super(data1, data2, "Inserimento dei dati delle commissioni","Inserisci",1);
init(stanza, data1, data2);
}
public void init(Stanza stanza, String data1, String data2)
{
num_stanza.setText(stanza.getNumStanza());
inizio_comm.setText(data1);
fine_comm.setText(data2);
num_stanza.setEditable(false);
inizio_comm.setEditable(false);
fine_comm.setEditable(false);
Annulla.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
mask_ricerca.setEnabled(true);
}
});
Azione.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startAzione();
}
});
}
void startAzione()
{
Frame msg;
if ( !errori() )
{
Commissionamento comm = readDatiComm();
int j;
if ( (j = (Principale.db).newIdCommissionamento()) == DataBase.OK )
{
(Principale.config).updateIdCommissionamento();
if ((j = (Principale.db).writeCommissionamento(comm)) == DataBase.OK)
{
aggiornaDisp(comm, Flag.COMMISSIONATA);
dispose();
mask_ricerca.restartAvvio();
mask_ricerca.setEnabled(true);
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j) );
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j) );
}
}
}
| The provided code allows users to insert and manage commission data for a specific room. Users can access this functionality through the "InserisciCommissioni" class, which extends the "MascheraCommissioni" class. Users can specify a start and end date for the commission, and the room number is automatically populated and made non-editable.
Users have two main actions available: 1) Cancel the commission entry, which will close the current window and re-enable the "MascheraRicercaStanza" window, and 2) Save the commission data, which will create a new commission in the database, update the availability status of the room, and then close the current window and re-enable the "MascheraRicercaStanza" window.
The code also includes error handling, where it will display a message dialog if there are any issues with the database operations. Overall, this code provides a user interface for managing commission data for a specific room, with the ability to save the data to the database and update the room's availability status accordingly. | Code |
InserisciPrenotazione.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import java.util.Date;
import moduli.*;
public class InserisciPrenotazione extends MascheraPrenotazione
{
MascheraRicercaStanza mask_ricerca = new MascheraRicercaStanza("",2);
String agenzia;
public InserisciPrenotazione(Stanza room, String data_i , String data_f, String nome_ag)
{
super(room, data_i, data_f, "Inserimento dei dati della prenotazione", "Inserisci",1, Flag.PENSIONE_COMPLETA);
agenzia = new String(nome_ag);
init(room, data_i, data_f);
}
public void init(Stanza room, String data_i, String data_f)
{
testo[0].setText(room.getNumStanza());
testo[0].setEditable(false);
testo[4].setText(DateUtils.parseDate(data_i));
testo[5].setText(DateUtils.parseDate(data_f));
testo[4].setEditable(false);
testo[5].setEditable(false);
testo[7].setText(room.getDescrizione());
testo[9].setText(DateUtils.parseDate(DateUtils.giveStringOfDate(new Date())));
testo[8].setText(agenzia);
testo[8].setEditable(false);
if (!agenzia.equals(""))
{
testo[6].setEditable(false);
myCheckbox1.setState(true);
}
Annulla.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
mask_ricerca.setEnabled(true);
}
});
Azione.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startAzione();
}
});
}
void startAzione()
{
Frame msg;
AskDialog ask;
int answer = 0;
if ( !errori() )
{
Prenotazione pren = readDatiPren();
pren.setDataPren(new Date());
int j;
if ( (j = (Principale.db).newIdPrenotazione()) == DataBase.OK )
{
(Principale.config).updateIdPrenotazione();
if ((j = (Principale.db).writePrenotazione(pren)) == DataBase.OK)
{
if (!myCheckbox1.getState())
ask = new AskDialog(this, " Assegnare la stanza o Bloccarla fino al ricevimento della caparra? ", " Assegnare ", " Bloccare ", pren);
else
startAggiornaDisp(pren, Flag.ASSEGNATA);
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j) );
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j) );
}
}
void startAggiornaDisp(Prenotazione p, char tipo)
{
aggiornaDisp(p, tipo);
dispose();
mask_ricerca.restartAvvio();
mask_ricerca.setEnabled(true);
}
}
| This code provides a user interface for inserting a new hotel room reservation. The user can input the necessary information, such as the room number, start and end dates, and the agency making the reservation. The code automatically populates some of the fields, such as the current date and the room description, based on the provided information.
The code then handles the creation of the new reservation in the system's database. It checks for any errors in the input data and, if there are no errors, creates a new reservation object and writes it to the database. If the writing to the database is successful, the code provides the user with the option to either assign the room to the reservation or to block the room until the deposit is received. The code then updates the room's availability status accordingly.
If the user chooses to cancel the reservation, the code disposes of the current window and enables the room search window, allowing the user to start a new reservation process. | Code |
InserisciSoggiornante.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import moduli.*;
import common.utility.*;
import common.def.*;
import interfacce.*;
import java.util.Date;
public class InserisciSoggiornante extends MascheraSoggiorno
{
Prenotazione prenotazione;
int counter_ins = 1;
int counter_tot;
public InserisciSoggiornante(RicercaPrenotazione parent, Prenotazione p)
{
super("Inserimento dati", "Inserisci", p.getPensionamento(), Flag.ADULTO);
padre = parent;
padre.setEnabled(false);
prenotazione = p;
inizializza();
}
public void inizializza()
{
testo1.setText(prenotazione.getNumStanza());
testo1.setEditable(false);
testo2.setText(prenotazione.getCognome());
testo3.setText(prenotazione.getNome());
testo7.setText(prenotazione.getNumTel());
testo13.setText(DateUtils.giveStringOfDate(prenotazione.getInizioSogg()));
testo13.setEditable(false);
testo14.setText(DateUtils.giveStringOfDate(prenotazione.getFineSogg()));
testo14.setEditable(false);
counter_tot = prenotazione.getNumPers();
if (prenotazione.getRichLettoAgg() == Const.SI)
counter_tot++;
changeTitle(counter_ins, counter_tot);
Conferma.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startConferma();
}
});
}
void startConferma()
{
Frame msg;
if (!erroriLocale())
{
Soggiornante sogg = readDatiSogg(prenotazione, counter_ins);
int j;
if ( (j = (Principale.db).writeSoggiornante(sogg)) == DataBase.OK )
{
Annulla.setEnabled(false);
cleanFields();
if (counter_ins == counter_tot)
{
aggiornaDisp(sogg, Flag.OCCUPATA );
dispose();
padre.creaLista(1);
padre.setEnabled(true);
}
counter_ins++;
changeTitle(counter_ins, counter_tot);
}
else
msg = new MessageDialog(this, "Problemi con il database: "+DataBase.strErrore(j));
}
}
boolean erroriLocale()
{
if (!errori())
{
if (counter_ins == 1)
{
Frame msg;
if ( (testo2.getText()).equals("") )
{
msg = new MessageDialog(this, " Per il primo soggiornante inserito deve essere digitato il cognome! ");
return true;
}
if ( (testo3.getText()).equals("") )
{
msg = new MessageDialog(this, " Per il primo soggiornante inserito deve essere digitato il nome! ");
return true;
}
if ( (testo6.getText()).equals("") )
{
msg = new MessageDialog(this, " Per il primo soggiornante inserito deve essere digitato il numero di documento! ");
return true;
}
if ( (testo7.getText()).equals("") )
{
msg = new MessageDialog(this, " Per il primo soggiornante inserito deve essere digitato il numero telefonico! ");
return true;
}
if ( (testo8.getText()).equals("") )
{
msg = new MessageDialog(this, " Per il primo soggiornante inserito deve essere digitato l'indirizzo! ");
return true;
}
if ( (testo9.getText()).equals("") )
{
msg = new MessageDialog(this, " Per il primo soggiornante inserito deve essere digitato il C.A.P.! ");
return true;
}
if ( (testo10.getText()).equals("") )
{
msg = new MessageDialog(this, " Per il primo soggiornante inserito deve essere digitato il comune! ");
return true;
}
if ( (testo11.getText()).equals("") )
{
msg = new MessageDialog(this, " Per il primo soggiornante inserito deve essere digitata la citta! ");
return true;
}
if ( (testo12.getText()).equals("") )
{
msg = new MessageDialog(this, " Per il primo soggiornante inserito deve essere digitata la nazione! ");
return true;
}
}
return false;
}
return true;
}
}
| The provided code allows users to manage guest information for a hotel or similar accommodation. The "InserisciSoggiornante" class presents a graphical user interface (GUI) that enables users to input and save details about guests, such as their name, contact information, document number, and address. The code retrieves relevant reservation details, such as the room number, check-in and check-out dates, and the number of people in the party, and pre-populates this information in the GUI.
The code includes input validation to ensure that required fields are filled out correctly before allowing the user to save the guest information. If any errors are detected, the code displays appropriate error messages to the user. Once the user has entered all the necessary information and confirmed the details, the code saves the guest information to a database and updates the availability of the room, marking it as "occupied" in the system.
The code also includes functionality to handle multiple guests in a single reservation, allowing the user to input information for each guest in a sequential manner. The GUI is updated to display the current guest number and the total number of guests, making it easy for the user to keep track of their progress. | Code |
InserisciStanze.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import moduli.*;
public class InserisciStanze extends DescrittoreStanze
{
public InserisciStanze()
{
super("Inserimento dei dati delle stanze", "Inserisci",1);
init();
}
public void init()
{
Cerca.setEnabled(false);
Azione.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
startAzione();
}
});
} // init
void startAzione()
{
Frame msg;
ListaStanze L_st = (Principale.db).elencoStanze();
if ( L_st.length() < (Principale.config).getNumStanze() )
{
if ( !errori() )
{
Stanza room = readDatiStanza();
int j;
if ((j = (Principale.db).writeStanza(room)) == DataBase.OK)
{
cleanFields();
}
else
msg = new MessageDialog(this, "Problemi con il data base: "+DataBase.strErrore(j));
}
}
else
msg = new AvvisoDialog(this, "Impossibile inserire la stanza: e' stato raggiunto il numero massimo di stanze gestibile");
}
}
| This code provides users with the ability to add new rooms or spaces to a larger software system. The "InserisciStanze" class serves as the user interface for this functionality, allowing users to input data about a new room and submit it to the system. When the user clicks the "Azione" (Action) button, the code checks if the maximum number of rooms has been reached, validates the user's input, and then writes the new room data to a database. If the write is successful, the input fields are cleared, and if any errors occur, appropriate messages are displayed to the user. This functionality allows users to expand the set of rooms or spaces managed by the overall software system. | Code |
MascheraAddebiti.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import common.def.*;
import moduli.*;
public class MascheraAddebiti extends MascheraPerAddebitare
{
// variabili per il travaso del database in memoria
String stanza_prec = new String("");
// oggetti per la costruzione della finestra
Label etich1, etich2, etich3;
TextField num_stanza;
public MascheraAddebiti(Frame parent)
{
super("Addebito spese e servizi extra", "Conferma l'addebito");
padre = parent;
padre.setEnabled(false);
inizExtra();
setupPanello();
inizializza();
pack();
setVisible(true);
}
// Travaso dati degli extra nelle strutture dati apposite
void inizExtra()
{
MessageDialog msg;
elenco_extra = (Principale.db).elencoSenzaSuppRid();
if (elenco_extra != null)
{
if (extra.getItemCount() > 0)
extra.removeAll();
int i=1;
while (i <= elenco_extra.length())
{
extra.addItem( (elenco_extra.getBeneServizio(i)).toString() );
i++;
}
}
}
// Creazione della finestra
void setupPanello()
{
num_stanza = new TextField("", 4);
num_stanza.setEditable(true);
// creo le label
etich1 = new Label("Gestione degli addebiti ");
etich1.setFont(ConfigurazioneSistema.font_titolo);
etich2 = new Label("Scegliere l'extra da addebitare ");
etich3 = new Label("Addebitare alla stanza numero ");
// creo pannello di sinistra
this.remove(panel1);
panel1 = new Panel();
panel1.setLayout(gridbag);
Utils.constrain(panel1, etich1, 0, 0, 6, 1);
Utils.constrain(panel1, etich2, 0, 1, 6, 1, 10, 0, 0, 0);
Utils.constrain(panel1, extra, 0, 2, 6, 4, GridBagConstraints.BOTH,
GridBagConstraints.WEST, 1.0, 1.0, 0, 20, 0, 20);
this.remove(panel4);
panel4 = new Panel();
panel4.setLayout(gridbag);
Utils.constrain(panel4, etich3, 0, 0, 1, 1, 5, 5, 5, 5);
Utils.constrain(panel4, num_stanza, 1, 0, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 5, 5);
// aggiungo i pannelli appena creati al resto
Utils.constrain(this, panel1, 0, 0, 1, 1, GridBagConstraints.VERTICAL,
GridBagConstraints.WEST, 0.5, 0.5, 5, 5, 5, 5);
Utils.constrain(this, panel4, 0, 2, 1, 1, GridBagConstraints.VERTICAL,
GridBagConstraints.WEST, 0.5, 0.5, 5, 5, 5, 5);
}
// Per la gestione degli eventi della finestra
void inizializza()
{
conferma.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
scriviSuDB(num_stanza.getText());
dispose();
padre.setEnabled(true);
}
});
addebita.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if (!errore())
{
addebito = true;
aggiornaAddebiti();
}
}
});
deaddebita.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if (!errore())
{
addebito = false;
aggiornaAddebiti();
}
}
});
num_stanza.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if (!errore())
{
addebito = true;
aggiornaAddebiti();
}
}
});
extra.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
if (!errore())
{
addebito = true;
aggiornaAddebiti();
}
}
});
}
// Ritorna false se si sta' cercando di addebitare un extra in
// mancanza dei dati necessari per l'addebito: num_stanza e extra.
boolean errore()
{
if ((num_stanza.getText()).equals("") && (extra.getSelectedIndex() == -1))
{
MessageDialog p = new MessageDialog(this, "Manca stanza e selezione!");
return true;
}
else if ((num_stanza.getText()).equals(""))
{
MessageDialog p = new MessageDialog(this, "Manca stanza!");
return true;
}
else if (extra.getSelectedIndex() == -1)
{
MessageDialog p = new MessageDialog(this, "Manca selezione!");
return true;
}
else if ( (num_stanza.getText()).length() > 4 )
{
MessageDialog p = new MessageDialog(this, "Errore nel numero di stanza!");
return true;
}
else
return false;
}
void annullaAddebitiStanzaPrec()
{
stanza_prec = new String(num_stanza.getText());
aggiornaAvideo();
}
// Aggiorna il panel2, che e' quello di informazione sugli addebiti
// di una data stanza, in modo che contenga le informazioni
// aggiornate sugli addebiti.
void aggiornaAddebiti()
{
if ( !(stanza_prec.equals(num_stanza.getText())) )
AltraStanza();
else
aggiornaAvideo();
}
boolean thereIsModifiche()
{
boolean modifiche = false;
for (int i = 0; i < quantita_mod.length; i++)
modifiche = modifiche || (quantita_mod[i] != 0);
return modifiche;
}
// Reinizzializza l'array degli addebiti in quanto si cambia stanza
// e chiede se gli addebiti fatti alla stanza precedente vanno
// confermati o meno.
void AltraStanza()
{
Frame msg;
FinModifiche p;
if ( (Principale.db).readStanza(num_stanza.getText()) != null )
{
ListaSoggiornanti L;
if ( (L = (Principale.db).foundSoggiornanti(num_stanza.getText(), false) ) != null )
{
if (!L.isEmpty())
{
if (!stanza_prec.equals("") && thereIsModifiche())
{
p = new FinModifiche(this, "Attenzione: cambio di stanza!");
}
else
{
riscriviElencoAddebiti();
annullaAddebitiStanzaPrec();
}
}
else
{
msg = new AvvisoDialog(this, "Nessun soggiornante occupa la stanza!");
num_stanza.setText(stanza_prec);
}
}
else
{
msg = new MessageDialog(this, "Problemi con il database: errore.");
}
}
else
{
msg = new MessageDialog(this, "Stanza inesistente!");
num_stanza.setText(stanza_prec);
}
}
void riscriviElencoAddebiti()
{
MessageDialog msg;
elenco_addebiti = (Principale.db).foundAddebiti(num_stanza.getText());
elenco_extra_addebitati = new ListaBeniServizi();
if (elenco_addebiti != null)
{
// inizializzo l'array delle modifiche e degli extra addebitati
quantita_mod = new int[elenco_addebiti.length()];
BeneServizio extra;
for (int i=0; i<quantita_mod.length; i++)
{
quantita_mod[i] = 0;
extra = (Principale.db).readBeneServizio( (elenco_addebiti.getAddebito(i+1)).getCodExtra() );
if (extra == null)
{
msg = new MessageDialog(this, "Uno degli extra addebitati non e' stato trovato!");
extra = new BeneServizio( (elenco_addebiti.getAddebito(i+1)).getCodExtra(), "Sconosciuto", 0 );
}
elenco_extra_addebitati.addBeneServizio( extra );
}
}
else
msg = new MessageDialog(this, "Errore nel database!");
}
int posExtraInAddebiti(BeneServizio b)
{
for (int i = 1; i <= elenco_addebiti.length(); i++)
if ( ((elenco_addebiti.getAddebito(i)).getCodExtra()).equals(b.getCodExtra()) )
return i;
return -1;
}
void aggiornaAvideo()
{
Frame msg;
int supp[];
BeneServizio extra_scelto = elenco_extra.getBeneServizio( extra.getSelectedIndex() + 1 );
int pos;
if ((pos = posExtraInAddebiti(extra_scelto)) < 0 && addebito)
{
Addebito a = new Addebito(num_stanza.getText(), extra_scelto.getCodExtra(), 0, 0);
elenco_addebiti.addAddebito( a );
elenco_extra_addebitati.addBeneServizio( extra_scelto );
// allungo l'array delle quantita' modificate
supp = new int[elenco_addebiti.length()];
for (int i = 0; i<quantita_mod.length; i++)
supp[i] = quantita_mod[i];
supp[supp.length - 1] = 1;
quantita_mod = supp;
pos = quantita_mod.length;
extra_add.setText(extra.getSelectedItem());
continuaAggiornamento();
}
else
{
if (pos < 0)
{
// sto cercando di togliere da un addebito inesistente
msg = new AvvisoDialog(this, "Stai cercando di togliere da un addebito ormai inesistente!");
}
else
{
// aggiorno tale array per contenere l'addebito appena effettuato
if (addebito)
{
quantita_mod[pos - 1]++;
extra_add.setText(extra.getSelectedItem());
continuaAggiornamento();
}
else
if ( (quantita_mod[pos - 1]+(elenco_addebiti.getAddebito(pos)).getQuantita()) > 0)
{
quantita_mod[pos - 1]--;
extra_add.setText(extra.getSelectedItem());
continuaAggiornamento();
}
else
msg = new AvvisoDialog(this, "Stai cercando di togliere da un addebito ormai inesistente!");
}
}
}
void continuaAggiornamento()
{
int i = 1;
BeneServizio e;
float conto = 0;
if (addebiti.getItemCount() > 0)
addebiti.removeAll();
while ( i <= elenco_addebiti.length() )
{
if ( ((elenco_addebiti.getAddebito(i)).getQuantita() + quantita_mod[i-1]) > 0 )
{
e = elenco_extra_addebitati.getBeneServizio(i);
if ( Integer.parseInt(e.getCodExtra()) >= 40000000 && Integer.parseInt(e.getCodExtra()) < 50000000)
addebiti.addItem("S "+Utils.completaStringa(e.getDescrizione(), 32)+" "+(Principale.config).getValuta()+"."+(elenco_addebiti.getAddebito(i)).getTotAddebito());
else if ( Integer.parseInt(e.getCodExtra()) >= 50000000)
addebiti.addItem("R "+Utils.completaStringa(e.getDescrizione(), 32)+" "+(Principale.config).getValuta()+"."+(elenco_addebiti.getAddebito(i)).getTotAddebito());
else
addebiti.addItem(Utils.completaStringa(e.getDescrizione(), 10)+
Utils.completaStringa(" x "+(elenco_addebiti.getAddebito(i)).getQuantita(), 5)+" +("+quantita_mod[i-1]+")");
conto = conto + (elenco_addebiti.getAddebito(i)).getTotAddebito() + quantita_mod[i-1]*e.getPxUnitario();
}
i++;
}
totale.setText((Principale.config).getValuta()+"."+conto);
}
void scriviSuDB(String stanza)
{
for (int i = 1; i <= elenco_addebiti.length(); i++)
{
if (quantita_mod[i-1] != 0)
{
if ( (quantita_mod[i - 1]+(elenco_addebiti.getAddebito(i)).getQuantita()) > 0)
{
int j = (Principale.db).addAddebito(stanza, (elenco_addebiti.getAddebito(i)).getCodExtra(), quantita_mod[i-1] );
if (j < 0)
DataBase.visErrore(j);
}
else
{
int j = (Principale.db).delAddebito(stanza, (elenco_addebiti.getAddebito(i)).getCodExtra() );
if (j < 0)
DataBase.visErrore(j);
}
}
}
}
}
/****************************************************************************/
class FinModifiche extends Frame
{
Button ok, annulla;
Label msg = new Label("Si vogliono salvare le modifiche degli addebiti della stanza precedente?");
GridBagLayout gridbag = new GridBagLayout();
String titolo;
MascheraAddebiti padre = null;
public FinModifiche(MascheraAddebiti parent, String title)
{
super(title);
padre = parent;
padre.setEnabled(false);
titolo = new String(title);
this.setLayout(gridbag);
ok = new Button("Salva le modifiche");
annulla = new Button("Annulla le modifiche");
Utils.constrain(this, msg, 0, 0, 5, 2, GridBagConstraints.BOTH,
GridBagConstraints.CENTER, 1.0, 1.0, 20, 20, 20, 20);
Utils.constrain(this, annulla, 1, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 1.0, 1.0, 20, 20, 20, 20);
Utils.constrain(this, ok, 3, 2, 1, 1, GridBagConstraints.NONE,
GridBagConstraints.CENTER, 1.0, 1.0, 20, 20, 20, 20);
this.pack();
init();
setVisible(true);
}
public void init()
{
ok.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
padre.scriviSuDB(padre.stanza_prec);
inComune();
}
});
annulla.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
inComune();
}
});
}
void inComune()
{
padre.riscriviElencoAddebiti();
padre.annullaAddebitiStanzaPrec();
padre.setEnabled(true);
dispose();
}
}
| This code provides a comprehensive system for managing the billing of extra services and charges for hotel guests. The user can access a graphical interface that allows them to view a list of available extra services, select a room number and extra service to be billed, and add or remove the billing of the extra service to the room. The system handles various error cases, such as missing information or attempting to bill a non-existent room, and prompts the user to save or discard any unsaved billing changes when switching rooms. The code also displays a detailed summary of the current billing for a room, including the description, quantity, and total cost of each extra service billed. This functionality allows hotel staff to efficiently manage the billing of additional services and charges, ensuring accurate and up-to-date records for their guests. | Code |
MascheraBeneServizio.java | package interfacce;
import java.awt.*;
import java.awt.event.*;
import common.utility.*;
import moduli.BeneServizio;
import moduli.ListaBeniServizi;
public class MascheraBeneServizio extends Frame
{
//Dichiarazioni di oggetti che ci serviranno per definire la finestra
protected Label label, label1, label2, label3, label4, label5, label6, label7, label8,
label9, label12, label13;
protected TextField testo3, testo4;
protected Panel panel[], buttons;
protected Button annulla, conferma;
protected CheckboxGroup tipi, bar, ristorante, servizi, bevande, cibi, antipasti,
primi, secondi, contorni;
protected Checkbox[] prima_scelta, scelta_bar, scelta_piatto, scelta_servizio,
scelta_bevanda, scelta_cibo, scelta_antipasto, scelta_primo,
scelta_secondo, scelta_contorno;
protected GridLayout grid = new GridLayout(4,1);
protected GridLayout grid1 = new GridLayout(7,1);
protected GridBagLayout gridbag = new GridBagLayout();
// i seguenti due campi sono condivisi da cancellazione e modifica
protected List elenco = new List(3, false);
protected ListaBeniServizi L;
// il seguente attributo e' necessario per la gerarchia delle finestre
Frame padre = new Frame();
// i seguenti gestiscono la formazione dei primi tre caratteri del cod_extra
int level = -1;
char codice[] = new char[3];
public MascheraBeneServizio(String title)
{
super(title);
setup();
init();
setSize(350,600);
}
void setup()
{
this.setFont(ConfigurazioneSistema.font_base);
elenco.setFont(ConfigurazioneSistema.font_allineato);
//Creo i pannelli
panel = new Panel[13];
for(int i=0;i<10;++i)
{
panel[i] = new Panel();
panel[i].setLayout(grid1);
panel[i].setVisible(false);
}
for(int i=10; i<13; ++i)
{
panel[i] = new Panel();
panel[i].setVisible(false);
}
//Creo il pannello in alto
label = new Label("Tipi");
label.setFont(ConfigurazioneSistema.font_titolo);
tipi = new CheckboxGroup();
prima_scelta = new Checkbox[5]; // mi serve piu' lungo per l'aggiungi
prima_scelta[0] = new Checkbox("BAR", tipi, false);
prima_scelta[1] = new Checkbox("RISTORANTE", tipi, false);
prima_scelta[2] = new Checkbox("SERVIZI", tipi, false);
prima_scelta[3] = new Checkbox("SUPPLEMENTI", tipi, false);
prima_scelta[4] = new Checkbox("RIDUZIONI", tipi, false);
panel[0].add(label);
panel[0].add(prima_scelta[0]);
panel[0].add(prima_scelta[1]);
panel[0].add(prima_scelta[2]);
panel[0].setVisible(true);
//Attacco il pannello in alto al frame
this.setLayout(grid);
this.add(panel[0]);
//Creo il pannello del bar
label1 = new Label("Bar");
label1.setFont(ConfigurazioneSistema.font_titolo);
bar = new CheckboxGroup();
scelta_bar = new Checkbox[2];
scelta_bar[0] = new Checkbox("Bevande", bar, false);
scelta_bar[1] = new Checkbox("Cibi", bar, false);
panel[1].add(label1);
panel[1].add(scelta_bar[0]);
panel[1].add(scelta_bar[1]);
//Creo il pannello dal ristorante
label2 = new Label("Ristorante");
label2.setFont(ConfigurazioneSistema.font_titolo);
ristorante = new CheckboxGroup();
scelta_piatto = new Checkbox[6];
scelta_piatto[0] = new Checkbox("Antipasti", ristorante, false);
scelta_piatto[1] = new Checkbox("Primi", ristorante, false);
scelta_piatto[2] = new Checkbox("Secondi", ristorante, false);
scelta_piatto[3] = new Checkbox("Contorni", ristorante, false);
scelta_piatto[4] = new Checkbox("Dessert", ristorante, false);
scelta_piatto[5] = new Checkbox("Frutta", ristorante, false);
panel[2].add(label2);
panel[2].add(scelta_piatto[0]);
panel[2].add(scelta_piatto[1]);
panel[2].add(scelta_piatto[2]);
panel[2].add(scelta_piatto[3]);
panel[2].add(scelta_piatto[4]);
panel[2].add(scelta_piatto[5]);
label3 = new Label("Servizi");
label3.setFont(ConfigurazioneSistema.font_titolo);
servizi = new CheckboxGroup();
scelta_servizio = new Checkbox[2];
scelta_servizio[0] = new Checkbox("Ricreativi", servizi, false);
scelta_servizio[1] = new Checkbox("Altro", servizi, false);
panel[3].add(label3);
panel[3].add(scelta_servizio[0]);
panel[3].add(scelta_servizio[1]);
label4 = new Label("Bevande");
label4.setFont(ConfigurazioneSistema.font_titolo);
bevande = new CheckboxGroup();
scelta_bevanda = new Checkbox[3];
scelta_bevanda[0] = new Checkbox("Caffetteria", bevande, false);
scelta_bevanda[1] = new Checkbox("Analcolici", bevande, false);
scelta_bevanda[2] = new Checkbox("Alcolici", bevande, false);
panel[4].add(label4);
panel[4].add(scelta_bevanda[0]);
panel[4].add(scelta_bevanda[1]);
panel[4].add(scelta_bevanda[2]);
//Creo il pannello dei cibi
label5 = new Label("Cibi");
label5.setFont(ConfigurazioneSistema.font_titolo);
cibi = new CheckboxGroup();
scelta_cibo = new Checkbox[3];
scelta_cibo[0] = new Checkbox("Dolci", cibi, false);
scelta_cibo[1]= new Checkbox("Salati", cibi, false);
panel[5].add(label5);
panel[5].add(scelta_cibo[0]);
panel[5].add(scelta_cibo[1]);
//Creo il pannello degli antipasti
label6 = new Label("Antipasti");
label6.setFont(ConfigurazioneSistema.font_titolo);
antipasti = new CheckboxGroup();
scelta_antipasto = new Checkbox[3];
scelta_antipasto[0] = new Checkbox("Freddi", antipasti, false);
scelta_antipasto[1] = new Checkbox("Caldi", antipasti, false);
panel[6].add(label6);
panel[6].add(scelta_antipasto[0]);
panel[6].add(scelta_antipasto[1]);
//Creo il pannello dei primi
label7=new Label("Primi");
label7.setFont(ConfigurazioneSistema.font_titolo);
primi=new CheckboxGroup();
scelta_primo=new Checkbox[3];
scelta_primo[0]=new Checkbox("Solidi",primi,false);
scelta_primo[1]=new Checkbox("Liquidi",primi,false);
panel[7].add(label7);
panel[7].add(scelta_primo[0]);
panel[7].add(scelta_primo[1]);
//Creo il pannello dei secondi
label8=new Label("Secondi");
label8.setFont(ConfigurazioneSistema.font_titolo);
secondi=new CheckboxGroup();
scelta_secondo=new Checkbox[3];
scelta_secondo[0]=new Checkbox("Carne",secondi,false);
scelta_secondo[1]=new Checkbox("Pesce",secondi,false);
panel[8].add(label8);
panel[8].add(scelta_secondo[0]);
panel[8].add(scelta_secondo[1]);
//Creo il pannello dei contorni
label9 = new Label("Contorni");
label9.setFont(ConfigurazioneSistema.font_titolo);
contorni = new CheckboxGroup();
scelta_contorno = new Checkbox[3];
scelta_contorno[0] = new Checkbox("Verdura cotta", contorni, false);
scelta_contorno[1] = new Checkbox("Verdura cruda", contorni, false);
scelta_contorno[2] = new Checkbox("Formaggio", contorni, false);
panel[9].add(label9);
panel[9].add(scelta_contorno[0]);
panel[9].add(scelta_contorno[1]);
panel[9].add(scelta_contorno[2]);
//Creo il pannello BAR-Bevande
panel[10].setLayout(gridbag);
label12 = new Label("Nome del bene");
label13 = new Label("Prezzo del bene "+(Principale.config).getValuta()+".");
testo3 = new TextField("",40);
testo4 = new TextField("",10);
annulla = new Button("Annulla");
conferma = new Button("Conferma");
Utils.constrain(panel[10], label12, 0, 0, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[10], testo3, 1, 0, 4, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 0, 5, 5, 0);
Utils.constrain(panel[10], label13, 0, 1, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 0.0, 0.0, 5, 5, 5, 0);
Utils.constrain(panel[10], testo4, 1, 1, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 5, 0);
Utils.constrain(panel[10], annulla, 1, 2, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.EAST, 1.0, 0.0, 5, 5, 0, 5);
Utils.constrain(panel[10], conferma, 2, 2, 1, 1,GridBagConstraints.NONE,
GridBagConstraints.WEST, 1.0, 0.0, 5, 5, 0, 5);
}
public void init()
{
prima_scelta[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(prima_scelta[0].getState())
{
inComuneABC(scelta_bar, 1, BeneServizio.BAR);
}
}
});
prima_scelta[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(prima_scelta[1].getState())
{
inComuneABC(scelta_piatto, 2, BeneServizio.RISTORANTE);
}
}
});
prima_scelta[2].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(prima_scelta[2].getState())
{
inComuneABC(scelta_servizio, 3, BeneServizio.SERVIZI);
}
}
});
scelta_bar[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_bar[0].getState())
{
inComuneGH(scelta_bevanda, 4, BeneServizio.BEVANDE);
}
}
});
scelta_bar[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_bar[1].getState())
{
inComuneGH(scelta_cibo, 5, BeneServizio.CIBI);
}
}
});
scelta_piatto[0].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_piatto[0].getState())
{
inComuneILMN(scelta_antipasto, 6, BeneServizio.ANTIPASTI);
}
}
});
scelta_piatto[1].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_piatto[1].getState())
{
inComuneILMN(scelta_primo, 7, BeneServizio.PRIMI);
}
}
});
scelta_piatto[2].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_piatto[2].getState())
{
inComuneILMN(scelta_secondo, 8, BeneServizio.SECONDI);
}
}
});
scelta_piatto[3].addItemListener(new ItemListener()
{
public void itemStateChanged(ItemEvent e)
{
if(scelta_piatto[3].getState())
{
inComuneILMN(scelta_contorno, 9, BeneServizio.CONTORNI);
}
}
});
annulla.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
dispose();
padre.setEnabled(true);
}
});
} // init
void inComuneABC(Checkbox[] scelte, int numero_pannello, char c)
{
level = 0;
for(int i=1;i<13;++i)
{
if(panel[i].isVisible())
remove(panel[i]);
}
this.add(panel[numero_pannello]);
panel[numero_pannello].setVisible(true);
setVisible(true);
codice = composeCode(level, c);
}
void inComuneGH(Checkbox[] scelte, int numero_pannello, char c)
{
level = 1;
for(int i=2;i<13;++i)
{
if(panel[i].isVisible())
remove(panel[i]);
}
this.add(panel[numero_pannello]);
panel[numero_pannello].setVisible(true);
setVisible(true);
codice = composeCode(level, c);
}
void inComuneILMN(Checkbox[] scelte, int numero_pannello, char c)
{
level = 1;
if (panel[1].isVisible())
remove(panel[1]);
for (int i = 3; i < 13; i++)
if (panel[i].isVisible())
remove(panel[i]);
this.add(panel[numero_pannello]);
panel[numero_pannello].setVisible(true);
setVisible(true);
codice = composeCode(level, c);
}
boolean errore()
{
Frame msg;
if ( !((testo3.getText()).length() < 33 ) )
{
msg = new MessageDialog(this, " La descrizione del bene o servizio deve essere di al piu' 32 caratteri! ");
return true;
}
if ( (testo3.getText()).equals("") )
{
msg = new MessageDialog(this, " Manca la descrizione del bene o servizio! ");
return true;
}
if ( (testo4.getText()).equals("") )
{
msg = new MessageDialog(this, " Manca il prezzo del bene o servizio! ");
return true;
}
if ( !(Utils.isFloatPos(testo4.getText())) )
{
msg = new MessageDialog(this, " Il prezzo deve essere un numero positivo! ");
return true;
}
return false;
}
char[] composeCode(int index, char tipo)
{
codice[index] = tipo;
for ( int i = index+1; i < 3; ++i)
codice[i] = ' ';
return codice;
}
char[] completeCode()
{
if (codice[1] == ' ')
codice[1] = '0';
if (codice[2] == ' ')
codice[2] = '0';
return codice;
}
void o()
{
if (panel[10].isVisible()) // necessario nella finestra di modifica
remove(panel[10]);
if (panel[12].isVisible()) // necessario nella finestra di cancellazione
remove(panel[12]);
inComuneOP();
}
void p() // Frutta o dessert
{
if(panel[1].isVisible())
remove(panel[1]);
for(int i=3;i<13;++i)
{
if(panel[i].isVisible())
remove(panel[i]);
}
inComuneOP();
}
void inComuneOP()
{
completeCode();
if (elenco.getItemCount() > 0) //per evitare warning
elenco.removeAll();
creaLista();
this.add(panel[11]);
panel[11].setVisible(true);
setVisible(true);
}
void creaLista()
{
int i=1;
BeneServizio b;
L = (Principale.db).elencoBeniServizi(new String(codice));
if (L != null)
{
while (i <= L.length())
{
b = L.getBeneServizio(i);
elenco.addItem(b.toString());
i++;
}
}
}
} | This Java GUI application provides a comprehensive interface for managing a database of goods and services. The main window allows the user to select the type of item they want to work with, such as a bar, restaurant, service, supplement, or reduction. Depending on the selection, the application displays additional panels that enable the user to further specify the details of the item, such as the type of food, drink, or service.
The application also includes a panel that allows the user to enter the name and price of a new good or service, with buttons to confirm or cancel the entry. Additionally, the application maintains a list of the existing goods and services, which the user can view and potentially modify or delete.
The code includes input validation to ensure that the user's entries are valid, such as the name not being too long and the price being a positive number. If the user attempts to enter invalid data, the application will display an error message.
Overall, this application provides a user-friendly and efficient way for the user to manage a database of goods and services, allowing them to easily add, modify, and view the available items. | Code |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 13