Postato originariamente da pierotofy:
Posta tutto il sorgente. Grazie.
mah, secondo me è ancora il computer, oppure io che non sono in grado di configurarlo... dubito sia il sergente..
però vabbè, l'avete voluto voi :p (si fa per scherzare ovviamente
) io volevo risparmiarvi di guardare al sorgente
il progetto è ancora in corso perciò alcuni metodi avranno errori
package corso;
//import java.io.BufferedOutputStream;
//import java.io.File;
//import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
//import java.lang.reflect.Array;
import java.util.ArrayList;
//import java.util.Collection;
import java.util.Collections;
import java.util.GregorianCalendar;
//import java.util.ArrayList;
//import javax.swing.plaf.basic.BasicInternalFrameTitlePane.MaximizeAction;
import myLib.typedef.Ora;
import corso.Medico.tipologia_medico;
import corso.SlotTemporale.Stato_visita_slot;
import corso.Visita.Stato_visita;
public class Classemain
{
private static final String NESSUN_RISULTATO_TROVATO_NE_DA_CONSIGLIARE = "Nessun risultato trovato ne' da consigliare. Si torna indietro. E' necessario aggiungere medici o orari.";
private static final String SARA_MODIFICATO = "Questo utente sara' modificato:\n";
private static final String DESIDERA_CONTINUARE = "si desidera continuare? S/N ";
private static final String ERORE_CLASSCAST = " ERORE DI classcast ";
private static final String ERRORE_CLASSNOTFOUND = " ERRORE DI classnotfound ";
/**
* TODO CONTROLLO COERENZA FILE
*
*/
// private static final int INDICI = 0;
// private static final int NUMERI = 1;
private static final String I_O_ERROR = " ERRORE DI I/O ";
protected static final boolean DEBUG = true;
private static final int MEDICO_ID = 0;
private static final int GIORNO_VALORE = 1;
private static final int ORA_VAALORE = 2;
private static final int MEDICO_INDEX = 3;
private static final int GIORNO_INDEX = 4;
private static final int ORA_INDEX = 5;
private static final int DISPONIBILE = 6;
private static final int INFORMAZIONI_DIMENSIONE = 7;
private static int scelta;
static ArrayList<Utente> clienti_clinica = new ArrayList<Utente>();
static ArrayList<Medico> corpo_medici = new ArrayList<Medico>();
static ArrayList<Visita> cache_visite = new ArrayList<Visita>();
static MiscData dati = new MiscData();
static boolean firstrun = true;
static boolean uscita = false;
static final String INDEX_ERROR = "errore di indice";
static final String FILE_MEDICI = "C:/medici.dat";
static final String FILE_UTENTI = "C:/utenti.dat";
static final String FILE_VISITE = "C:/visite.dat";
static final String FILE_DATI = "C:/miscdata.dat";
protected static final String ORA_SCALATA = "Ora scalata a: ";
static final String ANNULLATO = "annullato";
static final String ERR_GENERICO = "errore ";
static final String PROSSIMA_PAGINA = "premere invio per passare alla prossima pagina";
static final String NIENTE = "niente da visualizzare";
static final String IO_ERR = "errore nei file: ";
static final String CERCA_ERR = "nessun risultato";
static final int ESCI_COM = 0;
static final int AGG_UTEN_COM = 1;
static final int AGG_MED_COM = 2;
static final int MOD_ORA_COM = 3;
static final int GEST_VISI_COM = 4;
static final int VISUAL_E_MOD_COM = 5;
static final int SALVA_CARICA_COM = 6;
static final int CERCA_MEDICI = 0;
static final int CERCA_UTENTI = 1;
static final int CERCA_MEDICO_SINGOLO = 2;
static final int CERCA_UTENTE_SINGOLO = 3;
static final int CERCA_MEDICO_VISITE = 4;
static final int CERCA_UTENTE_VISITE = 5;
private static final String INS_ID = "inserire ID per la ricerca ";
private static final String[] TESTI_MENU = { "esci", "aggiunta utente", "aggiunta medico", "gestione orari visita", "gestione visite", "visualizza e modifica dati", "salva o carica" };
private static final int NUMERO_SCELTE = TESTI_MENU.length;
public static final String SICURO_FILE = "E' stato creato un file di dettgli (%s) per le visite coinvolte nell'operazione. Questa azione non potra' essere annullata. Le visite saranno chiuse. procedere? (S/N)";
// fatto
public static void main(String[] args)
{
if (DEBUG) myLib.util.Output.debug();
benvenuto();
ciclo();
fine();
}
// fatto
private static void benvenuto()
{
dati = new MiscData();
final String MESSAGGIO_INIZIO = "PROGRAMMA GESTIONE CLINICA.";
final String CARICA = "si desidera caricare da file?";
System.out.println(MESSAGGIO_INIZIO);
boolean risposta = myLib.util.Menu.yes_no_Box(CARICA, true);
if (Classemain.DEBUG) System.out.println(risposta);
if (risposta)
{
try
{
leggiFile();
} catch (IOException e)
{
System.out.println(e.getMessage());
} catch (ClassNotFoundException e)
{
System.out.println(e.getMessage());
} catch (ClassCastException e)
{
System.out.println(e.getMessage());
}
}
}
private static void scriviFile() throws IOException
{
// try
// {
// File f = new File("obj.dat");
ObjectOutputStream archiviodati = myLib.util.Output.creaFileOggetto(FILE_DATI);
archiviodati.writeObject(dati);
archiviodati.close();
ObjectOutputStream archiviomedici = myLib.util.Output.creaFileOggetto(FILE_MEDICI);
archiviomedici.writeObject(corpo_medici);
archiviomedici.close();
ObjectOutputStream archiviopazienti = myLib.util.Output.creaFileOggetto(FILE_UTENTI);
archiviopazienti.writeObject(clienti_clinica);
archiviopazienti.close();
ObjectOutputStream archiviovisite = myLib.util.Output.creaFileOggetto(FILE_VISITE);
archiviovisite.writeObject(cache_visite);
archiviovisite.close();
// } catch (IOException e)
// {
// System.out.println(ERR+e.getMessage());
// }
// finally
// {
// }
}
private static void leggiFile() throws IOException, ClassCastException, ClassNotFoundException
{
// final String FILE_MEDICI
ObjectInputStream archiviodati = myLib.util.Input.aprifile(FILE_DATI);
dati = (MiscData) archiviodati.readObject();
archiviodati.close();
ObjectInputStream archiviomedici = myLib.util.Input.aprifile(FILE_MEDICI);
corpo_medici = (ArrayList<Medico>) archiviomedici.readObject();
archiviomedici.close();
ObjectInputStream archiviopazienti = myLib.util.Input.aprifile(FILE_UTENTI);
clienti_clinica = (ArrayList<Utente>) archiviopazienti.readObject();
archiviopazienti.close();
ObjectInputStream archiviovisite = myLib.util.Input.aprifile(FILE_VISITE);
cache_visite = (ArrayList<Visita>) archiviovisite.readObject();
archiviovisite.close();
firstrun = false;
}
private static void ciclo()
{
// if (DEBUG) corpo_medici.get(0).ordinaGiorni();
while (!uscita)
{
scelta = myLib.util.Menu.crea_menu_numero(NUMERO_SCELTE, TESTI_MENU);
switch (scelta)
{
case ESCI_COM:
esci();
break;
case AGG_UTEN_COM:
aggiungiUtente();
break;
case AGG_MED_COM:
try
{
aggiungiMedico();
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
break;
case MOD_ORA_COM:
try
{
modificaOrariDottoriMain();
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
break;
case GEST_VISI_COM:
gestioneVisite();
break;
case VISUAL_E_MOD_COM:
visualizzaEModificaDati();
break;
case SALVA_CARICA_COM:
gestioneIO();
break;
default:
break;
}
}
}
// fatto
private static void fine()
{
final String MESSAGGIO_FINE = "grazie per aver usato il programma, premere invio.";
System.out.println(MESSAGGIO_FINE);
myLib.util.Input.leggi_stringa();
myLib.util.Input.close_input();
}
// fatto
private static void esci()
{
uscita = true;
}
// fatto
private static void aggiungiUtente()
{
// Utente a=new Utente();
// a=Utente.creaUtenteInterfaccia();
// a.modificaUtenteInterfaccia();
clienti_clinica.add(Utente.creaUtenteInterfaccia(dati.getCurrentUtenteID()));
dati.setCurrentUtenteID(dati.getCurrentUtenteID() + 1);
// clienti_clinica.get(clienti_clinica.size()-1).modificaUtenteInterfaccia();
// return Utente.creaUtenteInterfaccia();
// clienti_clinica.add(parametro);
// System.out.println(clienti_clinica.toString());
}
// fatto
private static void aggiungiMedico() throws Exception
{
final String AGGIUNGI_ORARI = "definire gli orari del medico? è possibile farlo in seguito, ma nel frattempo non sarà possibile utilizzare il medico. (s/n) ";
corpo_medici.add(Medico.creaMedicoInterfaccia(dati.getCurrentMedicoID()));
dati.setCurrentMedicoID(dati.getCurrentMedicoID() + 1);
boolean scelta = myLib.util.Menu.yes_no_Box(AGGIUNGI_ORARI, false);
if (scelta == true)
{
corpo_medici.get(corpo_medici.size() - 1).inizializzaOrari(false);
;
}
}
private static void modificaOrariDottoriMain() throws Exception
{
boolean finito = false;
int scelta;
final String[] MENU_ORARI = { "indietro", "cerca orari", "modifica orari" };
final int IND = 0;
final int CER = 1;
final int MOD = 2;
while (!finito)
{
scelta = myLib.util.Menu.crea_menu_numero(MENU_ORARI.length, MENU_ORARI);
switch (scelta)
{
case IND:
finito = true;
break;
case CER:
cercaorari();
break;
case MOD:
{
try
{
final String INTRO = "inserire l'ID del medico da modificare";
Integer id_cerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INTRO);
if (id_cerca == null)
{
System.out.println(ANNULLATO);
}
else
{
int index = getIndexMedico(id_cerca);
modificaOrari(index, id_cerca);
}
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
}
break;
default:
break;
}
}
}
public static void modificaOrari(int index, int albo) throws Exception
{
final String INTRO = "operazioni sugli orari";
boolean finito = false;
final String[] VOCI_ORARI = { "indietro", "inizializza", "aggiungi", "elimina" };
int scelta;
final int INDIETRO = 0;
final int AGGIORNA = 1;
final int AGGIUNGI = 2;
final int ELIMINA = 3;
while (!finito)
{
System.out.println(INTRO);
scelta = myLib.util.Menu.crea_menu_numero(VOCI_ORARI.length, VOCI_ORARI);
switch (scelta)
{
case INDIETRO:
finito = true;
break;
case AGGIORNA:
corpo_medici.get(index).inizializzaOrari(false);
break;
case AGGIUNGI:
corpo_medici.get(index).aggiungiGiorno();
break;
case ELIMINA:
final int UNO = 1;
final int TUTTI = 2;
final String[] SCEGLI_ELIMINA = { "indietro", "elimina un giorno", "elimina tutti i giorni" };
scelta = myLib.util.Menu.crea_menu_numero(SCEGLI_ELIMINA.length, SCEGLI_ELIMINA);
switch (scelta)
{
/**
* no indietro perche non ha senso rimanere
* tante volte in queto menu
*
*/
case UNO:
corpo_medici.get(index).cancellaGiorno();
break;
case TUTTI:
{
/**
* non elimina gli elementi dalla
* lista ma li setta come non lavoro
*
*
*/
try
{
String nomefile = corpo_medici.get(index).trovaVisiteInteressate();
System.out.printf(SICURO_FILE, nomefile);
boolean conferma = myLib.util.Menu.yes_no_Box("", false);
if (conferma == true)
{
corpo_medici.get(index).resettaOrari();
chiudiVisiteMedico(albo);
corpo_medici.get(index).aggiungiOrari();
}
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
}
break;
default:
break;
}
break;
default:
break;
}
}
}
private static void chiudiVisiteMedico(int id)
{
for (int i = 0; i < cache_visite.size(); i++)
{
if (cache_visite.get(i).getId_medico() == id)
{
cache_visite.get(i).setStato_della_visita(Stato_visita.CONCLUSA);
}
}
}
private static void cercaorari()
{
boolean finito = false;
final String[] TXT_CERCA = { "Indietro", "Cerca per Medico", "Cerca per Data & Ora" };
final int IND = 0;
final int MED = 1;
final int DAT = 2;
while (!finito)
{
int scelta = myLib.util.Menu.crea_menu_numero(TXT_CERCA.length, TXT_CERCA);
switch (scelta)
{
case IND:
finito = true;
break;
case MED:
cercaOrariPerMedico();
break;
case DAT:
cercaOrariPerData();
break;
default:
break;
}
}
}
private static void cercaOrariPerMedico()
{
final String NO_RIS = "se non sono stati visualizzati risultati, probabilmente il medico cercato non esiste.";
final String INTRO_CERCA = "inserire il numero d'albo del medico di cui vedere gli orari: ";
int query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INTRO_CERCA);
for (int i = 0; i < corpo_medici.size(); i++)
{
if (corpo_medici.get(i).numero_iscrizione_albo == query)
{
corpo_medici.get(i).visualizzaOrari();
}
}
System.out.println(NO_RIS);
}
private static void cercaOrariPerData()
{
final String INTRO = "inserire la data da cercare";
GregorianCalendar ricercaData = myLib.util.Input.leggi_data(INTRO);
Ora ricercaOra = myLib.typedef.Ora.crea_ora();
myLib.typedef.Ora.scala(ricercaOra, false, 0, 30, 60);
for (int i = 0; i < corpo_medici.size(); i++)
{
corpo_medici.get(i).cercaorariMedico(ricercaData, ricercaOra);
myLib.util.Input.pause();
}
boolean ancora = myLib.util.Menu.yes_no_Box("cercare ancora? (S/N) ", false);
if (ancora == true)
{
cercaOrariPerData();
}
}
// TODO metti medico disponibile
public static void eliminaVisite()
{
}
private static void gestioneVisite()
{
try
{
final int INDIETRO = 0;
final int CREA_VISITA = 1;
final int MODIFICA_VISITA = 2;
final int CERCA_VISITA = 3;
final String[] MENU_VISITE = { "indietro", "crea visita", "modifica visita", "cerca visita" };
int scelta;
boolean finito = false;
while (!finito)
{
scelta = myLib.util.Menu.crea_menu_numero(MENU_VISITE.length, MENU_VISITE);
switch (scelta)
{
case INDIETRO:
finito = true;
break;
case CREA_VISITA:
creaVisita();
break;
case MODIFICA_VISITA:
menuModificaVisita();
break;
case CERCA_VISITA:
cercaVisite();
break;
default:
break;
}
}
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
}
private static void creaVisita() throws Exception
{
final String SCALE = "Ora scalata a: %s";
final String MEDICO_PREFERITO = "Si ha un medico preferito per la visita? (S/N) ";
final String INSERIRE_ORA = "Inserire l'ora per la visita. Verra' scalata alla mezz'ora piu' vicina ";
final String INSERIRE_DATA = "Inserire la data preferita per la visita: ";
final String NON_ESISTE = "L'utente non esiste. rifare? (S/N)";
final String INTRO = "Inserimento nuova visita\n";
final String ID = "inserire ora l'ID utente che deve fare la visita: ";
final String INS_MOTIVO = "Inserire il motivo della visita: ";
Object[] INFORMAZIONI;
System.out.println(INTRO);
Integer idUtenteScelto = 0;
Integer indexUtente;
boolean finito = false;
while (!finito)
{
idUtenteScelto = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, ID);
indexUtente = getIndexUtente(idUtenteScelto);
if (indexUtente == null)
{
if (myLib.util.Menu.yes_no_Box(NON_ESISTE, false))
{
finito = false;
}
else
{
finito = true;
}
}
else
{
if (!finito)
{
/**
*
* continua immissione utente
*/
String tempMotivo;
if (DEBUG) tempMotivo = "a";
else
tempMotivo = myLib.util.Input.leggi_stringa(INS_MOTIVO);
GregorianCalendar tempData = myLib.util.Input.leggi_data(INSERIRE_DATA);
Ora tempOra = myLib.typedef.Ora.crea_ora(INSERIRE_ORA);
myLib.typedef.Ora.scala(tempOra, false, 0, 30, 60);
System.out.println(ORA_SCALATA + tempOra.toString());
if (myLib.util.Menu.yes_no_Box(MEDICO_PREFERITO, false))
{
/**
* un medico
*/
int medicoRichiesto;
Integer index = null;
while (index == null)
{
medicoRichiesto = myLib.util.Input.leggi_int();
index = getIndexMedico(medicoRichiesto);
if (index == null)
{
if (!myLib.util.Menu.yes_no_Box("Nessun medico. Rifare? ", false))
{
finito = false;
}
}
}
if (!finito)
{
INFORMAZIONI=cercaOrarioUnMedico(index, tempData, tempOra);
if ((boolean)INFORMAZIONI[DISPONIBILE])
{
aggiungiVisita(idUtenteScelto, tempMotivo, (int)INFORMAZIONI[MEDICO_ID], (int)INFORMAZIONI[MEDICO_INDEX], (GregorianCalendar)INFORMAZIONI[GIORNO_VALORE], (Ora)INFORMAZIONI[ORA_VAALORE], (int)INFORMAZIONI[GIORNO_INDEX], (int)INFORMAZIONI[ORA_INDEX]);
finito=true;
}
else
{
INFORMAZIONI=cercaOrarioTraTuttiMedici(tempData, tempOra);
if (proponiMediciEOrari((int)INFORMAZIONI[MEDICO_INDEX], (GregorianCalendar)INFORMAZIONI[GIORNO_VALORE], (Ora)INFORMAZIONI[ORA_VAALORE]))
{
aggiungiVisita(idUtenteScelto, tempMotivo, (int)INFORMAZIONI[MEDICO_ID], (int)INFORMAZIONI[MEDICO_INDEX], (GregorianCalendar)INFORMAZIONI[GIORNO_VALORE], (Ora)INFORMAZIONI[ORA_VAALORE], (int)INFORMAZIONI[GIORNO_INDEX], (int)INFORMAZIONI[ORA_INDEX]);
finito=true;
}
else
{
/**
* TODO RISCELTA
*
*/
finito = true;
}
}
}
}
else
{
/**
*
* tutti medici
*
*/
INFORMAZIONI = cercaOrarioTraTuttiMedici(tempData, tempOra);
/**
*
* se ha trovato uno slot per la tale
* data ora
*
*/
if ((boolean) INFORMAZIONI[DISPONIBILE] == true)
{
if (proponiMediciEOrari((int) INFORMAZIONI[MEDICO_INDEX], (GregorianCalendar) INFORMAZIONI[GIORNO_VALORE], (Ora) INFORMAZIONI[ORA_VAALORE])) aggiungiVisita(idUtenteScelto, tempMotivo, (int) INFORMAZIONI[MEDICO_ID], (int) INFORMAZIONI[MEDICO_INDEX], (GregorianCalendar) INFORMAZIONI[GIORNO_VALORE], (Ora) INFORMAZIONI[ORA_VAALORE], (int) INFORMAZIONI[GIORNO_INDEX], (int) INFORMAZIONI[ORA_INDEX]);
}
/**
*
* se non ha trovato, propone il primo
*
*/
if ((boolean) INFORMAZIONI[DISPONIBILE] == false)
{
if (proponiMediciEOrari((int) INFORMAZIONI[MEDICO_INDEX], (GregorianCalendar) INFORMAZIONI[GIORNO_VALORE], (Ora) INFORMAZIONI[ORA_VAALORE]))
{
aggiungiVisita(idUtenteScelto, tempMotivo, (int) INFORMAZIONI[MEDICO_ID], (int) INFORMAZIONI[MEDICO_INDEX], (GregorianCalendar) INFORMAZIONI[GIORNO_VALORE], (Ora) INFORMAZIONI[ORA_VAALORE], (int) INFORMAZIONI[GIORNO_INDEX], (int) INFORMAZIONI[ORA_INDEX]);
finito = true;
}
else
{
finito = true;
}
}
/**
*
* non ha trovato niente
*
*/
if (INFORMAZIONI[DISPONIBILE] == null)
{
System.out.println(NESSUN_RISULTATO_TROVATO_NE_DA_CONSIGLIARE);
return;
}
}
}
}
}
}
private static void aggiungiVisita(int IDutente, String motivo, Integer IDmedico, int indexMedico, GregorianCalendar data, Ora ora, int indexData, int indexOra)
{
cache_visite.add(new Visita(IDutente, motivo, IDmedico, data, ora));
corpo_medici.get(indexMedico).orari_visita.get(indexData).orari[indexOra].setStato_slot(Stato_visita_slot.PRENOTATA);
corpo_medici.get(indexMedico).orari_visita.get(indexData).orari[indexOra].id_visita = cache_visite.get(cache_visite.size() - 1).getId_visita();
}
private static Object[] cercaOrarioUnMedico(int indice, GregorianCalendar data, Ora ora)
{
}
/**
*
*
* se quello fornito esiste, si ritornano gli stessi valori e true finale
* con indici corretti se non trovato si ritorna false e un consiglio, il
* piu vicino se nessun consiglio ritorna null finale e prima non importa
*
* usare costanti per accedere a campi
*
*
* @return
*/
private static Object[] cercaOrarioTraTuttiMedici(GregorianCalendar dataRichiesta, Ora oraRichiesta)
{
Object[] ritorno = new Object[INFORMAZIONI_DIMENSIONE];
/**
* prima cerca per gli orari selezionati
*
*/
for (int i = 0; i < corpo_medici.size(); i++)
{
for (int j = 0; j < corpo_medici.get(i).orari_visita.size(); j++)
{
for (int k = 0; i < corpo_medici.get(i).orari_visita.get(j).orari.length; k++)
{
if (
(corpo_medici.get(i).orari_visita.get(j).data.equals(dataRichiesta))
&&
(corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario().equals(oraRichiesta))
&&
(corpo_medici.get(i).orari_visita.get(j).orari[k].getStato_slot().equals(Stato_visita_slot.PRENOTABILE))
)
{
ritorno[MEDICO_ID] = corpo_medici.get(i).numero_iscrizione_albo;
ritorno[MEDICO_INDEX] = new Integer(i);
ritorno[GIORNO_VALORE] = myLib.typedef.Data.clonaData(dataRichiesta);
ritorno[GIORNO_INDEX] = new Integer(j);
ritorno[ORA_VAALORE] = myLib.typedef.Ora.clone(oraRichiesta);
ritorno[ORA_INDEX] = new Integer(k);
ritorno[DISPONIBILE] = new Boolean(true);
return ritorno;
/**
*
*
* TODO questo cerca solo il primo
* risultato, fare che cerca anche il
* minore
*/
}
}
}
}
/**
* poi cerca tra tutti, il consiglio
*
*/
ritorno[DISPONIBILE] = new Boolean(false);
/**
* serve per cercare il minore
*
*/
boolean primorisultato = true;
for (int i = 0; i < corpo_medici.size(); i++)
{
for (int j = 0; j < corpo_medici.get(i).orari_visita.size(); j++)
{
for (int k = 0; i < corpo_medici.get(i).orari_visita.get(j).orari.length; k++)
{
if ((corpo_medici.get(i).orari_visita.get(j).orari[k].getStato_slot().equals(Stato_visita_slot.PRENOTABILE)) && (primorisultato))
{
ritorno[MEDICO_ID] = corpo_medici.get(i).numero_iscrizione_albo;
ritorno[MEDICO_INDEX] = new Integer(i);
ritorno[GIORNO_VALORE] = corpo_medici.get(i).orari_visita.get(j).data;
ritorno[GIORNO_INDEX] = new Integer(j);
ritorno[ORA_VAALORE] = corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario();
ritorno[ORA_INDEX] = new Integer(k);
primorisultato = false;
}
if ((corpo_medici.get(i).orari_visita.get(j).orari[k].getStato_slot().equals(Stato_visita_slot.PRENOTABILE)) && (!primorisultato))
{
if (corpo_medici.get(i).orari_visita.get(j).data.before(ritorno[GIORNO_VALORE]))
{
ritorno[MEDICO_ID] = corpo_medici.get(i).numero_iscrizione_albo;
ritorno[MEDICO_INDEX] = new Integer(i);
ritorno[GIORNO_VALORE] = corpo_medici.get(i).orari_visita.get(j).data;
ritorno[GIORNO_INDEX] = new Integer(j);
ritorno[ORA_VAALORE] = corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario();
ritorno[ORA_INDEX] = new Integer(k);
}
else
{
if (corpo_medici.get(i).orari_visita.get(j).orari[k].orario.relazione((Ora) ritorno[ORA_VAALORE]) == Ora.CONFRONTA_ORE_ANTECEDENTE)
{
ritorno[MEDICO_ID] = corpo_medici.get(i).numero_iscrizione_albo;
ritorno[MEDICO_INDEX] = new Integer(i);
ritorno[GIORNO_VALORE] = corpo_medici.get(i).orari_visita.get(j).data;
ritorno[GIORNO_INDEX] = new Integer(j);
ritorno[ORA_VAALORE] = corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario();
ritorno[ORA_INDEX] = new Integer(k);
}
}
}
}
}
}
if (!primorisultato)
{
return ritorno;
}
else
{
/**
*
* non c'è niente :(
*
*/
ritorno[DISPONIBILE] = null;
return ritorno;
}
}
/**
* propone una stringa col medico
*
* @param indiceMedico
* @param dataProposta
* @param oraProposta
* @return si no
*/
private static boolean proponiMediciEOrari(int indiceMedico, GregorianCalendar dataProposta, Ora oraProposta)
{
// for (int i=0; i<corpo_medici.size();i++)
// {
//
// for (int j=0; i<corpo_medici.get(i).orari_visita.size();i++)
// {
// for (int k=0;
// i<corpo_medici.get(i).orari_visita.get(j).orari.length;i++)
// {
//
// if (
// corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario().equals(oraProposta)
//
// &&
//
// corpo_medici.get(i).orari_visita.get(j).data.equals(dataProposta)
//
// &&
//
// corpo_medici.get(i).orari_visita.get(j).orari[k].getStato_slot().equals(Stato_visita_slot.PRENOTABILE)
//
// )
// {
// /**
// *
// * todo
// * NO SE PROPONE DEVE SOLO SCRIVERE
// */
// //return new Integer[]={corpo_medici.get(i).numero_iscrizione_albo,
// corpo_medici.get(i).orari_visita.get(j).data }
//
// // xvsd;3
// System.out.println("Ecco il prossimo risultato trovato:");
// System.out.println("medico: " +
// corpo_medici.get(i).getInfoBase()+"\ngiorno" +
// myLib.util.Output.formatDate(corpo_medici.get(i).orari_visita.get(j).data)
// + "\nora: " +
// corpo_medici.get(i).orari_visita.get(j).orari[k].orario.toString());
// return;
// }
//
// }
//
// }
System.out.println("medico proposto:" + corpo_medici.get(indiceMedico).getInfoBase() + "data proposta: " + myLib.util.Output.formatDate(dataProposta) + "ora proposta: " + oraProposta.toString());
return (myLib.util.Menu.yes_no_Box("accettare? (S/N", true));
//
// }
//
//
// System.out.println("nessun risultato");
}
/**
* dato l'id dell'utente, ne ritorna l'indice nella lista, altrimenti null
*
* @return
*/
private static Integer getIndexUtente(int id)
{
for (int i = 0; i < clienti_clinica.size(); i++)
{
if (clienti_clinica.get(i).id_utente == id) return i;
}
return null;
}
private static void menuModificaVisita()
{
final String INS_ID = "inserire ID";
boolean finito = false;
int scelta;
int query;
final int INDIETRO = 0;
final int CONCLUDI = 1;
final int MODIFICA = 2;
final int ELIMINA = 3;
final String[] MENU_MODIFICA = { "indietro", "concludi visita", "modifica visita", "elimina visita" };
while (!finito)
{
scelta = myLib.util.Menu.crea_menu_numero(MENU_MODIFICA.length, MENU_MODIFICA);
switch (scelta)
{
case INDIETRO:
finito = true;
break;
case CONCLUDI:
query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
concludiVisita(query);
break;
case MODIFICA:
query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
modificaVisita(query);
break;
case ELIMINA:
query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
eliminaVisita(query);
break;
default:
break;
}
}
}
// ok
private static void concludiVisita(int id)
{
try
{
String temp_referto;
String temp_prescrizione;
final String AVVISO = "Sta per essere registrata come conclusa una visita. L'azione non può essere annullata. inserire referto e prescrizione. per annullare inserire entrambi vuoti";
final String INS_REF = "inserire ora il referto";
final String INS_PRESCR = "inserire ora la prescrizione";
final String ANNULL = "inserire ora la prescrizione";
System.out.println(AVVISO);
temp_referto = myLib.util.Input.leggi_stringa(INS_REF);
temp_prescrizione = myLib.util.Input.leggi_stringa(INS_PRESCR);
if ((temp_referto.isEmpty()) && (temp_prescrizione.isEmpty()))
{
System.out.println(ANNULL);
}
else
{
cache_visite.get(getIndexVisita(id)).setStato_della_visita(Stato_visita.CONCLUSA);
cache_visite.get(getIndexVisita(id)).setReferto(temp_referto);
cache_visite.get(getIndexVisita(id)).setPrescrizione(temp_prescrizione);
}
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
}
// ok
private static void modificaVisita(int id)
{
try
{
final String INTRO = "quale campo modificare?";
final String[] CAMPI = { "indietro", "motivo", "referto", "prescrizione" };
final int INDIETRO = 0;
final int MOTIVO = 1;
final int REFERTO = 2;
final int PRESCRI = 3;
int scelta;
boolean finito = false;
while (!finito)
{
System.out.println(INTRO);
scelta = myLib.util.Menu.crea_menu_numero(CAMPI.length, CAMPI);
switch (scelta)
{
case INDIETRO:
finito = true;
break;
case MOTIVO:
String temp_motivo;
temp_motivo = myLib.util.Input.leggi_stringa("inserire nuovo motivo. vuoto per annullare");
if (!temp_motivo.isEmpty())
{
cache_visite.get(getIndexVisita(id)).setMotivo(temp_motivo);
}
break;
case REFERTO:
String temp_referto;
temp_referto = myLib.util.Input.leggi_stringa("inserire nuovo referto. vuoto per annullare");
if (!temp_referto.isEmpty())
{
cache_visite.get(getIndexVisita(id)).setMotivo(temp_referto);
cache_visite.get(getIndexVisita(id)).setStato_della_visita(Stato_visita.REFERTATA);
}
break;
case PRESCRI:
String temp_prescriz;
temp_prescriz = myLib.util.Input.leggi_stringa("inserire nuova prescrizione. vuoto per annullare");
if (!temp_prescriz.isEmpty())
{
cache_visite.get(getIndexVisita(id)).setMotivo(temp_prescriz);
}
break;
default:
break;
}
}
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
}
// ok
private static void eliminaVisita(int id)
{
try
{
boolean scelta = false;
final String CONF = "l'azione non può essere annullata. continuare? (s/n) ";
scelta = myLib.util.Menu.yes_no_Box(CONF, false);
if (scelta = true)
{
cache_visite.remove(getIndexVisita(id));
}
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
}
/**
* ritorna l'indice nella lista visite, dato un id univoco
*
* @param _id
* @return
* @throws Exception
*/
protected static int getIndexVisita(int _id) throws Exception
{
for (int i = 0; i < cache_visite.size(); i++)
{
if (cache_visite.get(i).matchID(_id)) return i;
}
throw new Exception(INDEX_ERROR);
}
/**
* dato il numero albo di un medico, ritorna l'indice nella lista, se non
* trovato null
*
* @param id
* @return
*/
private static Integer getIndexMedico(int id)
{
final int NUM_ALB = 8;
for (int i = 0; i < corpo_medici.size(); i++)
{
if (corpo_medici.get(i).matchcampo(NUM_ALB, id)) return i;
}
return null;
}
private static void cercaVisite()
{
try
{
final String PROMPT_QUERY = "inserire l'ID da cercare: ";
boolean finito = false;
int scelta;
int query;
/**
* TODO RICERCA PER DATA NON RICHIEDE MOLTO
*
*/
final String[] MENU_CERCA = { "indietro", "cerca per utente", "cerca per medico" };
final int INDIETRO = 0;
final int RICERCA_VISITA_UTENTE = 1;
final int RICERCA_VISITA_MEDICO = 2;
while (!finito)
{
scelta = myLib.util.Menu.crea_menu_numero(MENU_CERCA.length, MENU_CERCA);
switch (scelta)
{
case INDIETRO:
finito = true;
break;
case RICERCA_VISITA_UTENTE:
query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, PROMPT_QUERY);
visualizzaVisite(cercaVisita(RICERCA_VISITA_UTENTE, query));
break;
case RICERCA_VISITA_MEDICO:
query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, PROMPT_QUERY);
visualizzaVisite(cercaVisita(RICERCA_VISITA_MEDICO, query));
break;
default:
break;
}
}
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
}
private static ArrayList<Visita> cercaVisita(int tipo_ricerca, int query) throws Exception
{
final int RICERCA_VISITA_UTENTE = 1;
final int RICERCA_VISITA_MEDICO = 2;
ArrayList<Visita> ritorno = new ArrayList<Visita>();
if (tipo_ricerca == RICERCA_VISITA_UTENTE)
{
for (int i = 0; i < cache_visite.size(); i++)
{
if (cache_visite.get(i).matchUtente(query))
{
ritorno.add(cache_visite.get(i));
}
}
return ritorno;
}
if (tipo_ricerca == RICERCA_VISITA_MEDICO)
{
for (int i = 0; i < cache_visite.size(); i++)
{
if (cache_visite.get(i).matchMedico(query))
{
ritorno.add(cache_visite.get(i));
}
}
return ritorno;
}
throw new Exception(CERCA_ERR);
}
private static void visualizzaVisite(ArrayList<Visita> input)
{
final String INTRO_VISITE = "Visite:\n\tmedico\tutente\tstato\tdata\n\t";
if (input.size() == 0)
{
System.out.println(NIENTE);
}
else
{
for (int i = 0; i < input.size(); i++)
{
if ((i % myLib.util.Output.MAX_RIGHE) == 0)
{
myLib.util.Input.pause(PROSSIMA_PAGINA);
}
System.out.println(input.get(i).id_medico + "\t" + input.get(i).id_utente + "\t" + input.get(i).getStato_della_visita() + "\t" + myLib.util.Output.formatDate(input.get(i).getData()) + "\n\t");
}
}
}
private static void visualizzaEModificaDati()
{
/**
* TODO VISUALIZZA STATISTICHE VISITE CHE NON E DIFFICILE
*
*
*
*/
final String[] TESTI_MENU = { "indietro", "visualizza utenti", "visualizza medici", "modifica utente", "modifica medico", "cerca utente", "cerca medico" };
final int COM_INDIETRO = 0;
final int COM_VISU_UTENTI = 1;
final int COM_VISU_MEDICI = 2;
final int COM_MOD_UTENTE = 3;
final int COM_MOD_MEDICO = 4;
final int COM_CERCA_UTENTE = 5;
final int COM_CERCA_MEDICO = 6;
boolean uscita = false;
int scelta;
while (!uscita)
{
scelta = myLib.util.Menu.crea_menu_numero(TESTI_MENU.length, TESTI_MENU);
switch (scelta)
{
case COM_INDIETRO:
uscita = true;
break;
case COM_VISU_UTENTI:
visualizzautenti();// ok
break;
case COM_VISU_MEDICI:
visualizzamedici();// ok
break;
case COM_MOD_UTENTE:
try
{
modificautenti();// ok
} catch (NullPointerException e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
break;
case COM_MOD_MEDICO:
modificamedici();
// ok
break;
case COM_CERCA_UTENTE:
cercautenti(); // ok
break;
case COM_CERCA_MEDICO:
cercamedici();// ok
break;
default:
break;
}
}
}
private static void visualizzaBase(ArrayList<Visita> in)
{
}
private static void visualizzaUtente(Utente risultato, ArrayList<Visita> elenco)
{
final String INTRO_UTENTE = "Dati utente:\n\tcodice fiscale\tcognome\tnome\n\t";
final String INTRO_VISITE = "visite prenotate e concluse:\n\tdata\tmedico\treferto\tprescrizione\n\t";
System.out.println(INTRO_UTENTE + risultato.codice_fiscale + "\t" + risultato.cognome + "\t" + risultato.nome);
myLib.util.Input.pause(PROSSIMA_PAGINA);
if (elenco.size() == 0)
{
System.out.println(NIENTE);
}
else
{
System.out.println(INTRO_VISITE);
for (int i = 0; i < elenco.size(); i++)
{
/**
* ogni 25 righe si ferma
*
*/
if ((i % myLib.util.Output.MAX_RIGHE) == 0)
{
myLib.util.Input.pause(PROSSIMA_PAGINA);
}
if (elenco.get(i).getStato_della_visita() == Stato_visita.PRENOTATA)
{
System.out.println(myLib.util.Output.formatDate(elenco.get(i).getData()) + "\t" + elenco.get(i).id_medico + "\t" + elenco.get(i).getReferto() + "\t" + elenco.get(i).getPrescrizione() + "\n\t");
}
}
}
}
/**
* aggiungere filtri di ricerca direttamente nella codifica
*
* @param risultato
* @param elenco
*/
private static void visualizzaMedico(Medico risultato, ArrayList<Visita> elenco)
{
final String INTRO_MEDICO = "Dati medico:\n\talbo\tcognome\tnome\n\t";
final String INTRO_VISITE = "visite prenotate:\n\tdata\tmotivo\n\t";
System.out.println(risultato.numero_iscrizione_albo + "\t" + risultato.cognome + "\t" + risultato.nome);
myLib.util.Input.pause(PROSSIMA_PAGINA);
if (elenco.size() == 0)
{
System.out.println(NIENTE);
}
else
{
for (int i = 0; i < elenco.size(); i++)
{
/**
* ogni 25 righe si ferma
*
*/
if ((i % myLib.util.Output.MAX_RIGHE) == 0)
{
myLib.util.Input.pause(PROSSIMA_PAGINA);
}
if (elenco.get(i).getStato_della_visita() == Stato_visita.PRENOTATA)
{
System.out.println(myLib.util.Output.formatDate(elenco.get(i).getData()) + "\t" + elenco.get(i).getMotivo() + "\n\t");
}
}
}
}
private static void visualizzautenti()
{
try
{
int ricerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
visualizzaUtente((Utente) ricercaUnoID(CERCA_UTENTE_SINGOLO, ricerca), cercaVisite(CERCA_UTENTE_VISITE, ricerca));
} catch (Exception e)
{
System.err.println(ERR_GENERICO + e.getMessage());
}
}
private static void visualizzamedici()
{
try
{
int ricerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
visualizzaMedico((Medico) ricercaUnoID(CERCA_MEDICO_SINGOLO, ricerca), cercaVisite(CERCA_MEDICO_VISITE, ricerca));
} catch (Exception e)
{
System.out.println(ERR_GENERICO + e.getMessage());
}
}
private static ArrayList<Visita> cercaVisite(int tipo_ricerca, int id_da_cercare) throws Exception
{
final String ERR = "nessun risultato: visite";
if (tipo_ricerca == CERCA_MEDICO_VISITE)
{
ArrayList<Visita> ritorno = new ArrayList<Visita>();
for (int i = 0; i < cache_visite.size(); i++)
{
if (cache_visite.get(i).matchMedico(id_da_cercare))
{
ritorno.add(cache_visite.get(i));
}
}
return ritorno;
}
if (tipo_ricerca == CERCA_UTENTE_VISITE)
{
ArrayList<Visita> ritorno = new ArrayList<Visita>();
for (int i = 0; i < cache_visite.size(); i++)
{
if (cache_visite.get(i).matchUtente(id_da_cercare))
{
ritorno.add(cache_visite.get(i));
}
}
return ritorno;
}
throw new Exception(ERR);
}
private static Object ricercaUnoID(int tipo_ricerca, int id_ricerca) throws Exception
{
final int CERCA_ID = 10;
final String ERR = "nessun risultato: medici/utenti";
if (tipo_ricerca == CERCA_MEDICO_SINGOLO)
{
for (int i = 0; i < corpo_medici.size(); i++)
{
if (corpo_medici.get(i).matchcampo(CERCA_ID, id_ricerca)) return corpo_medici.get(i);
}
}
;
if (tipo_ricerca == CERCA_UTENTE_SINGOLO)
{
for (int i = 0; i < clienti_clinica.size(); i++)
{
if (clienti_clinica.get(i).matchcampo(CERCA_ID, id_ricerca)) return clienti_clinica.get(i);
}
}
throw new Exception(ERR);
}
private static void modificautenti() throws IndexOutOfBoundsException, NullPointerException
{
boolean finito = false;
while (!finito)
{
Integer ricerca;
final String INTRO = "inserire l'id dell'utente da modificare";
// System.out.println(INTRO);
ricerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INTRO);
if (ricerca == null)
{
finito = true;
}
else
{
ricerca = getIndexUtente(ricerca);
System.out.println(SARA_MODIFICATO + clienti_clinica.get(ricerca).toString());
finito = !myLib.util.Menu.yes_no_Box(DESIDERA_CONTINUARE, false);
if (myLib.math.Numeri.compreso_o_uguale(ricerca, 0, clienti_clinica.size() - 1, false)) { throw new IndexOutOfBoundsException(); }
clienti_clinica.get(ricerca).modificaUtenteInterfaccia();
}
}
}
private static void modificamedici()
{
boolean finito = !myLib.util.Menu.yes_no_Box(DESIDERA_CONTINUARE, false);
while (!finito)
{
Integer ricerca;
final String INTRO = "inserire l'id del medico da modificare";
ricerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INTRO);
ricerca = getIndexMedico(ricerca);
if (ricerca == null)
{
finito = true;
System.err.println(CERCA_ERR);
}
else
{
if (myLib.math.Numeri.compreso_o_uguale(ricerca, 0, corpo_medici.size() - 1, false)) { throw new IndexOutOfBoundsException(); }
corpo_medici.get(ricerca).modificamedicoInterfaccia();
}
}
}
private static void cercautenti()
{
boolean uscita = false;
int scelta;
final int COM_IND = 0;
final int COM_NOME = 1;
final int COM_COGNOME_ = 2;
final int COM_DATA = 3;
final int COM_LUOGO = 4;
final int COM_TELEF = 5;
final int COM_GEN = 6;
final int COM_COD_FIS = 7;
final String[] TESTI_MENU = { "indietro", "per nome", "per cognome", "per data nascita", "per luogo di nascita", "per telefono", "per genere", "per codice fiscale" };
while (!uscita)
{
final String S = "inserire dato da cercare\n";
scelta = myLib.util.Menu.crea_menu_numero(TESTI_MENU.length, TESTI_MENU);
switch (scelta)
{
case COM_IND:
uscita = true;
break;
case COM_NOME:
visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_NOME, myLib.util.Input.leggi_stringa(S)));
break;
case COM_COGNOME_:
// final String S="inserire cognome da cercare";
visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_COGNOME_, myLib.util.Input.leggi_stringa(S)));
break;
case COM_DATA:
GregorianCalendar query = myLib.util.Input.leggi_data(S);
visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_DATA, query));
break;
case COM_TELEF:
visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_TELEF, myLib.util.Input.leggi_stringa(S)));
break;
case COM_GEN:
visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_GEN, myLib.util.Input.scegligenerechar()));
break;
case COM_LUOGO:
visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_LUOGO, myLib.util.Input.leggi_stringa(S)));
break;
case COM_COD_FIS:
visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_COD_FIS, myLib.util.Input.leggi_stringa(S)));
break;
default:
break;
}
}
}
private static void cercamedici()
{
boolean uscita = false;
int scelta;
final int COM_IND = 0;
final int COM_NOME = 1;
final int COM_COGNOME_ = 2;
final int COM_DATA = 3;
final int COM_LUOGO = 4;
final int COM_TELEF = 5;
final int COM_GEN = 6;
final int COM_COD_FIS = 7;
final int COM_NUM = 8;
final int COM_TIPO = 9;
final String[] TESTI_MENU = { "indietro", "per nome", "per cognome", "per data nascita", "per luogo di nascita", "per telefono", "per genere", "per codice fiscale", "per numero iscrizione" };
while (!uscita)
{
final String S = "inserire dato da cercare\n";
scelta = myLib.util.Menu.crea_menu_numero(TESTI_MENU.length, TESTI_MENU);
switch (scelta)
{
case COM_IND:
uscita = true;
break;
case COM_NOME:
visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_NOME, myLib.util.Input.leggi_stringa(S)));
break;
case COM_COGNOME_:
// final String S="inserire cognome da cercare";
visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_COGNOME_, myLib.util.Input.leggi_stringa(S)));
break;
case COM_DATA:
GregorianCalendar query = myLib.util.Input.leggi_data(S);
visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_DATA, query));
break;
case COM_TELEF:
visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_TELEF, myLib.util.Input.leggi_stringa(S)));
break;
case COM_GEN:
visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_GEN, myLib.util.Input.scegligenerechar()));
break;
case COM_LUOGO:
visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_LUOGO, myLib.util.Input.leggi_stringa(S)));
break;
case COM_COD_FIS:
visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_COD_FIS, myLib.util.Input.leggi_stringa(S)));
break;
case COM_NUM:
visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_NUM, myLib.util.Input.leggi_integer(0, Integer.MAX_VALUE, S)));
break;
case COM_TIPO:
Medico.tipologia_medico query2 = tipologia_medico.sceglitipo();
visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_TIPO, query2));
break;
default:
break;
}
}
}
// ok
private static ArrayList<?> cercaRitornaLista(int tipo_ricerca, int campo, Object query)
{
if (tipo_ricerca == CERCA_MEDICI)
{
ArrayList<Medico> ritorno = new ArrayList<Medico>();
for (int i = 0; i < corpo_medici.size(); i++)
{
if (corpo_medici.get(i).matchcampo(campo, query))
{
ritorno.add(corpo_medici.get(i));
}
}
return ritorno;
}
if (tipo_ricerca == CERCA_UTENTI)
{
ArrayList<Utente> ritorno = new ArrayList<Utente>();
for (int i = 0; i < clienti_clinica.size(); i++)
{
if (clienti_clinica.get(i).matchcampo(campo, query))
{
ritorno.add(clienti_clinica.get(i));
}
}
return ritorno;
}
/**
* stratagemma preso da
* http://stackoverflow.com/questions/1274792/is-returning
* -null-bad-design per evitare return null
*/
return (ArrayList<?>) Collections.EMPTY_LIST;
}
// ok
private static void visualizzaListaRisultati(ArrayList<?> risultatoRicerca)
{
final String VUOTO = "nessun risultato";
final String RISULTATI = "risultati:\n";
final String CORRENTE = "elemento corrente: ";
if (risultatoRicerca.isEmpty())
{
myLib.util.Output.stampa_testo(VUOTO);
}
else
{
boolean finito = false;
int i = 0;
int scelta;
final int INDIETRO = 0;
final int PRECEDENTE = 1;
final int SUCCESSIVO = 2;
final String[] SCORRI_MENU = { "indietro", "precedente", "successivo" };
System.out.println(RISULTATI);
while (!finito)
{
System.out.println(CORRENTE + i + " \n");
System.out.println(risultatoRicerca.get(i).toString());
scelta = myLib.util.Menu.crea_menu_numero(SCORRI_MENU.length, SCORRI_MENU);
switch (scelta)
{
case INDIETRO:
finito = true;
break;
case PRECEDENTE:
if ((i - 1) >= 0)
{
i--;
}
break;
case SUCCESSIVO:
if ((i + 1) < risultatoRicerca.size())
{
i++;
}
break;
default:
break;
}
}
}
}
// OK
private static void gestioneIO()
{
boolean finito = false;
final String ERR = "errore. non è stato possibile scrivere i dati: ";
final int INDIETRO = 0;
final int CARICA = 1;
final int SALVA = 2;
final String[] MENU_IO = { "indietro", "carica i dati", "salva i dati" };
try
{
int scelta;
while (!finito)
{
scelta = myLib.util.Menu.crea_menu_numero(MENU_IO.length, MENU_IO);
switch (scelta)
{
case INDIETRO:
finito = true;
break;
case CARICA:
leggiFile();
finito = true;
case SALVA:
scriviFile();
finito = true;
break;
default:
break;
}
}
} catch (IOException e)
{
System.err.println(ERR_GENERICO + I_O_ERROR + e.getMessage());
} catch (ClassNotFoundException e)
{
System.err.println(ERR_GENERICO + ERRORE_CLASSNOTFOUND + e.getMessage());
} catch (ClassCastException e)
{
System.err.println(ERR_GENERICO + ERORE_CLASSCAST + e.getMessage());
} finally
{
finito = true;
}
}
protected static Integer cercaIndiceDatoIDVisita(int search)
{
for (int i = 0; i < cache_visite.size(); i++)
{
if (cache_visite.get(i).getId_visita() == search) { return i; }
}
return null;
}
}
package corso;
import java.io.IOException;
import java.io.Serializable;
//import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.GregorianCalendar;
//import javax.script.CompiledScript;
import corso.SlotTemporale.Stato_visita_slot;
import corso.Visita.Stato_visita;
import myLib.typedef.Ora;
import myLib.typedef.Tempo;
public class Giorno implements Comparable<Giorno>, Serializable
{
private static final String TRENTA = "/:30";
private static final String STRINGA_SPAZI = " ";
private static final long serialVersionUID=0;
GregorianCalendar data;
/**
* deve essere un nnumero di ore intero
*/
public static final Ora apertura = new Ora(8, 0, 0);
/**
* deve essere un nnumero di ore intero
*/
public static final Ora chiusura = new Ora(18, 0, 0);
public static final int lavorative = (chiusura.get_ore() - apertura.get_ore());
public static final int numero_slot_per_ora = 2;
public static final int minuti_per_slot = Tempo.MINUTI_PER_ORE / numero_slot_per_ora;
public static final int numero_slot_per_giorno = lavorative * numero_slot_per_ora;
/**
* gli orari di visita
*
*/
protected SlotTemporale[] orari = new SlotTemporale[numero_slot_per_giorno];
public Giorno (GregorianCalendar _data, Ora a, Ora b) throws Exception
{
data = (GregorianCalendar)_data.clone();
inizializzaTabella(a, b);
}
/**
* riempie la tabella degli orari con le varie cose a seconda delle ore
*
* @param apri
* @param chiudi
* @throws Exception
*/
private void inizializzaTabella(Ora apri, Ora chiudi) throws Exception
{
final String SWAP1 = "Le ore ";
final String SWAP2 = "e ";
final String SWAP3 = " saranno scambiate. Continuare? (S/N)";
final String ERR_ORA = "ore non corrette";
if (apri.relazione(apertura) == Ora.CONFRONTA_ORE_ANTECEDENTE || (chiudi.relazione(chiusura)) == Ora.CONFRONTA_ORE_SEGUENTE) throw new Exception(ERR_ORA);
if (apri.relazione(chiudi) == Ora.CONFRONTA_ORE_SEGUENTE)
/**
* perchè non posso swappare oggetti ;( dannata Sole (Sun)
*
*/
{
System.out.println(SWAP1 + apri.toString() + SWAP2 + chiudi.toString());
boolean scelta = myLib.util.Menu.yes_no_Box(SWAP3, true);
if (scelta == true)
{
Ora transito = apri;
apri = chiudi;
chiudi = transito;
}
else
{
throw new Exception(ERR_ORA);
}
}
Ora corrente = Ora.clone(apertura);
/**
* riempio il vettore di slot temporali
*
*
*/
for (int i = 0; i < orari.length; i++)
{
if (corrente.compresaDoppia(true, false, apri, chiudi))
{
//if (corrente.compresa(true, apri, chiudi))
{orari[i] = new SlotTemporale(corrente, 0, Stato_visita_slot.PRENOTABILE);}
// else
// {
// orari[i] = new SlotTemporale(corrente, 0, Stato_visita_slot.NON_PRENOTABILE);
//}
}
else
{
orari[i] = new SlotTemporale(corrente, 0, Stato_visita_slot.NON_PRENOTABILE);
}
corrente.add(new Ora(minuti_per_slot * Tempo.MILLISECONDI_PER_MINUTO));
}
}
public ArrayList<String> aggiungiVisiteInteressate() throws Exception
{
ArrayList<String> ritorno=new ArrayList<String>();
for (int i=0;i<orari.length;i++)
{
if (orari[i].getStato_slot()==Stato_visita_slot.PRENOTATA)
{
int id=orari[i].getId_visita();
String daAggiungere= Classemain.cache_visite.get(Classemain.cercaIndiceDatoIDVisita(id)).toString();
ritorno.add(daAggiungere);
}
}
return ritorno;
}
public void unisciOrari(Ora Inizio, Ora Fine)
{
for (int i=0;i<orari.length;i++)
{
if ((orari[i].getOrario().compresa(true, Inizio, Fine))&&(orari[i].getStato_slot().equals(Stato_visita_slot.NON_PRENOTABILE)))
{
orari[i].setStato_slot(Stato_visita_slot.PRENOTABILE);
}
}
}
protected void sostituisciOrari(Ora inizio, Ora fine) throws IOException
{
/**
*
* processo ogni singolo slot, ogni singolo caso
*
* NP: dentro: rendi prenotabile
* fuori: N/A
* PA: dentro: N/A
* fuori: aggiungi alla lista da cancellare
* PE: dentro: N/A
* fuori: segna non prenotabile
*
*
*
*
*/
try{
final String INFO="E' stato creato un file di dettagli (%s) delle visite eliminate.\n";
ArrayList<String> visiteScartate=new ArrayList<String>();
for (int i=0; i<orari.length;i++)
{
/**
* NP
*/
if (orari[i].getStato_slot().equals(Stato_visita_slot.NON_PRENOTABILE))
{
if (orari[i].getOrario().compresa(true, inizio, fine))
{
/**
* DENTRO
*/
orari[i].setStato_slot(Stato_visita_slot.PRENOTABILE);
}else
{
/**
* FUORI
*/
/**
*
* NESSUNA AZIONE
*
*/
}
}
/**
* PE
*/
if (orari[i].getStato_slot().equals(Stato_visita_slot.PRENOTABILE))
{
if (orari[i].getOrario().compresa(true, inizio, fine))
{
/**
*
* NESSUNA AZIONE
*
*/
}else
{
orari[i].setStato_slot(Stato_visita_slot.NON_PRENOTABILE);
}
}
/**
* PA
*/
if (orari[i].getStato_slot().equals(Stato_visita_slot.PRENOTATA))
{
if (orari[i].getOrario().compresa(true, inizio, fine))
{
/**
*
* NESSUNA AZIONE
*
*/
}else
{
int ida=orari[i].getId_visita();
orari[i].setStato_slot(Stato_visita_slot.NON_PRENOTABILE);
int index=Classemain.getIndexVisita(ida);
visiteScartate.add(Classemain.cache_visite.get(index).toString());
Classemain.cache_visite.get(index).setStato_della_visita(Stato_visita.CONCLUSA);
}
}
}
String nomefile=Medico.trovaNomeDaSalvare();
Medico.salvaVisite(nomefile, visiteScartate);
System.out.printf(INFO, nomefile);
} catch (Exception e)
{
System.out.println(Classemain.ERR_GENERICO+e.getMessage());
}
}
// public static int primaslot(Ora iniz) throws Exception
// {
// Ora posticipo = Ora.clone(iniz);
// posticipo.sub(apertura);
//
// long temp = Ora.oratomilli(posticipo);
//
// return ((int) temp / minuti_per_slot * Tempo.SECONDI_PER_MINUTI * 1000);
//
// }
//
// public static int contaslot(Ora diff)
// {
// long temp = Ora.oratomilli(diff);
// int dadividere = minuti_per_slot * Tempo.SECONDI_PER_MINUTI * 1000;
//
// return ((int) (temp / dadividere));
//
// }
//
/**
* segna il giorno come di non lavoro, rendendo ogni visita non prenotabile
*
*/
public void noLavoro()
{
for (int i = 0; i < orari.length; i++)
{
orari[i].setStato_slot(Stato_visita_slot.NON_PRENOTABILE);
}
}
/**
*
* ritorna l'header della tabella di un giorno, con tutte le ore e le mezz'ore in cima
*
*
*
*
* @return
*/
/*
* prima era static perchè pensavo che gli orari fossero tutti uguali nella clinica,
* ma poi ho pensato di renderelo dipendente dall'oggetto perchè è possibile implementare
* una miglioria degli orari di apertura diversi nella clinica
*
* poi c'era un errore e ho rimesso static :p
*
*/
public static String getIntestazioneOrari()
{
String ritorno = "Giorno:\n";
ritorno += STRINGA_SPAZI;
int corrente = apertura.get_ore();
for (int i = 0; i < lavorative; i++, corrente++)
{
ritorno += " ";
/**
* aggiunge lo spazio per ore < 10
*/
if (corrente < 10)
{
ritorno += "0";
}
ritorno += corrente;
ritorno += TRENTA;
}
return (ritorno);
}
/**
* ritorna una stringa con la tabella degli orari di un giorno
*
* @return
*/
public String getTabellaOrari()
{
final String V = "D";
final String F = "N";
final String P = "P";
String ritorno = myLib.util.Output.formatDate(data)+" ";
for (int i = 0; i < orari.length; i++)
{
switch (orari[i].getStato_slot())
{
case NON_PRENOTABILE:
ritorno += F;
break;
case PRENOTABILE:
ritorno += V;
break;
case PRENOTATA:
ritorno += P;
break;
default:
break;
}
ritorno += " ";
}
return ritorno;
}
public Integer getIndexOra(Ora query)
{
for (int i=0; i<orari.length; i++)
{
if (orari[i].getOrario().equals(query)) {return i;}
}
return null;
}
public boolean comprendeOraDisponibile(Ora ricerca)
{
for (int i=0;i<orari.length;i++)
{
if (orari[i].getOrario().equals(ricerca)&&orari[i].getStato_slot()==Stato_visita_slot.PRENOTABILE)
{
return true;
}
}
return false;
}
public void setta(Ora query, Stato_visita_slot temp)
{
for (int i = 0; i < orari.length; i++)
{
if (orari[i].getOrario().equals(query))
{
orari[i].setStato_slot(temp);
i = orari.length;
}
}
}
public String toString()
{
return getIntestazioneOrari()+getTabellaOrari();
}
public int compareTo(Giorno cfr)
{
long temp = (((Giorno) cfr).data.getTimeInMillis()) / Tempo.MILLISECONDI_PER_GIORNO;
int comparemillis = (int) temp;
long questo = this.data.getTimeInMillis() / Tempo.MILLISECONDI_PER_GIORNO;
int comparequesto = (int) questo;
int ritorno = (comparequesto - comparemillis);
return ritorno;
}
}
package corso;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Calendar;
//import java.util.Collection;
import java.util.Collections;
import java.util.GregorianCalendar;
//import java.util.InputMismatchException;
//import java.util.Vector;
import javax.swing.DebugGraphics;
import corso.Visita.Stato_visita;
import myLib.typedef.Data;
import myLib.typedef.Ora;
//import myLib.typedef.Tempo;
public class Medico extends Persona
{
private static final String ORARI_GIA_INIZIALIZZATI = "Orari gia' inizializzati";
private static final long serialVersionUID=1;
private boolean inizializzati_orari=false;
public enum tipologia_medico
{
NORMALE, SPECIALISTA;
/*
* public boolean equals(tipologia_medico cfr) { if ((this.)||()) return
* true; else return false; }
*/
public static tipologia_medico sceglitipo()
{
final String STRINGA_TIPO = "inserire tipologia ";
String temp;
boolean finito = false;
tipologia_medico ritorno = NORMALE;
while (!finito)
{
temp = myLib.util.Input.leggi_stringa(STRINGA_TIPO);
if (temp.toLowerCase().equals(NORMALE.toString().toLowerCase()))
{
finito = true;
ritorno = NORMALE;
}
;
if (temp.toLowerCase().equals(SPECIALISTA.toString().toLowerCase()))
{
finito = true;
ritorno = SPECIALISTA;
}
;
}
return ritorno;
}
public String toString()
{
return super.toString().toLowerCase();
}
}
final static String INS_1 = "inserire data di inizio";
final static String INS_2 = "inserire data di fine";
final static String ORA_1 = "inserire l'ora di inizio lavoro";
final static String ORA_2 = "inserire l'ora di fine lavoro";
final String UN_GIORNO = "inserimento del turno del medico: intervallo data, intervallo ora.\n per inserire un solo giorno, far coincidere gli estremi";
static final String ERR_DATE = "date o ore scorrette";
static final String ERRORE_ORA = "errore nelle ore";
protected int numero_iscrizione_albo;
protected tipologia_medico tipo_del_medico;
// private int id_medico;
// boolean[][] orari_visita_standard;
protected ArrayList<Giorno> orari_visita = new ArrayList<Giorno>();
public String getInfoBase()
{
final String INFO_BASE = "Medico:\t" + this.numero_iscrizione_albo + " Nome:\t" + this.nome + " Cognome:\t" + this.cognome;
return INFO_BASE;
}
public Medico (String _nome, String _cognome, GregorianCalendar _data_nascita, String _luogo_nascita, String _telefono, char _genere, String _codice_fiscale, int _numero_iscrizione_albo, tipologia_medico _tipologia_del_medico)
{
super(_nome, _cognome, _data_nascita, _luogo_nascita, _telefono, _genere, _codice_fiscale);
numero_iscrizione_albo = _numero_iscrizione_albo;
tipo_del_medico = _tipologia_del_medico;
// id_medico = _id + 1;
}
public Medico (String _nome, String _cognome, GregorianCalendar _data_nascita, String _luogo_nascita, String _telefono, char _genere, String _codice_fiscale, int _numero_iscrizione_albo, tipologia_medico _tipologia_del_medico, boolean[][] _orari_visita)
{
super(_nome, _cognome, _data_nascita, _luogo_nascita, _telefono, _genere, _codice_fiscale);
numero_iscrizione_albo = _numero_iscrizione_albo;
tipo_del_medico = _tipologia_del_medico;
// id_medico = _id + 1;
}
public static Medico creaMedicoInterfaccia(int _id)
{
final String CREA_MEDICO_STRINGA = "Registrare un medico";
myLib.util.Output.stampa_testo(CREA_MEDICO_STRINGA);
final String RICAPITOLA = "ricapitolazione dell'input:\n\n\n";
final String RIDEFINISCI = "si desidera modificare il medico? (S/N) ";
final String STRINGA_NOME = "inserire nome ";
final String STRINGA_COGNOME = "inserire cognome ";
final String STRINGA_DATA = "inserire data di nascita ";
final String STRINGA_LUOGO = "inserire luogo nascita ";
final String STRINGA_TEL = "inserire telefono ";
// final String STRINGA_ALBO = "inserire numero iscrizione ";
final String STRINGA_TIPO = "inserire tipo medico ";
String temp_nome = myLib.util.Input.leggi_stringa(STRINGA_NOME);
String temp_cognome = myLib.util.Input.leggi_stringa(STRINGA_COGNOME);
GregorianCalendar temp_data_nascita = myLib.util.Input.leggi_data(STRINGA_DATA);
String temp_luogo_nascita = myLib.util.Input.leggi_stringa(STRINGA_LUOGO);
String temp_telefono = myLib.util.Input.leggi_stringa(STRINGA_TEL);
char temp_genere = myLib.util.Input.scegligenerechar();
String temp_codice_fiscale;
if (!Classemain.DEBUG)
{temp_codice_fiscale = myLib.util.Input.inserisciCodiceFiscale();}
else
{temp_codice_fiscale=myLib.util.Input.leggi_stringa();}
int temp_numero_iscrizione = _id;// myLib.util.Input.leggi_int(0,
// Integer.MAX_VALUE, STRINGA_ALBO);
System.out.println(STRINGA_TIPO);
tipologia_medico temp_tipologia = tipologia_medico.sceglitipo();
Medico ritorno = new Medico(temp_nome, temp_cognome, temp_data_nascita, temp_luogo_nascita, temp_telefono, temp_genere, temp_codice_fiscale, temp_numero_iscrizione, temp_tipologia);
System.out.println(RICAPITOLA);
System.out.println(ritorno.toString());
if (myLib.util.Menu.yes_no_Box(RIDEFINISCI, false)) ritorno = creaMedicoInterfaccia(_id);
return ritorno;
}
public String toString()
{
final String NAL = "\n\tnumero iscrizione albo:\t";
final String TIPO = "\n\ttipologia:\t";
// final String ID = "\n\tid:\t";
String ritorno = super.toString();
ritorno += (NAL + numero_iscrizione_albo + TIPO + tipo_del_medico.toString());
return ritorno;
}
/*
* public String toString_extra() { final String NUMALB =
* "\n\tnumero albo:\t"; final String TIPO = "\n\ttipo medico:\t"; String
* ritorno; ritorno = (NUMALB + numero_iscrizione_albo + TIPO +
* tipo_del_medico); return ritorno; }
*/
/**
* inizializza gli orari di un medico.
* l'utilizzo della flag force è riservato al sistema.
*
* @param force
* @throws Exception
*/
protected void inizializzaOrari(boolean force) throws Exception
{
if (force) inizializzati_orari=false;
if (!inizializzati_orari)
{
inizializzati_orari=true;
interfacciaCreazioneGiorni();
segnafestivi();
ordinaGiorni();
}
else throw new Exception(ORARI_GIA_INIZIALIZZATI);
}
private void interfacciaCreazioneGiorni() throws Exception
{
System.out.println(UN_GIORNO);
GregorianCalendar data_inizio = myLib.util.Input.leggi_data(INS_1);
GregorianCalendar corrente = (GregorianCalendar) data_inizio.clone();
GregorianCalendar data_fine = myLib.util.Input.leggi_data(INS_2);
System.out.println(ORA_1);
Ora inizio = myLib.typedef.Ora.crea_ora();
myLib.typedef.Ora.scala(inizio, false, 0, 30, 60);
System.out.println(Classemain.ORA_SCALATA + inizio.toString());
System.out.println(ORA_2);
Ora fine = myLib.typedef.Ora.crea_ora();
myLib.typedef.Ora.scala(fine, false, 0, 30, 60);
System.out.println(Classemain.ORA_SCALATA + fine.toString());
if ((data_inizio.after(data_fine)) || (inizio.relazione(fine) == Ora.CONFRONTA_ORE_SEGUENTE)) throw new Exception(ERR_DATE);
int differenza = myLib.typedef.Data.differenzaData(data_inizio, data_fine);
for (int i = 0; i <= differenza; i++)
{
// Giorno temp = ;
corrente = Data.sommagiorni(corrente, 1);
orari_visita.add(new Giorno(corrente, inizio, fine));
if (Classemain.DEBUG) {System.out.println("fatto un giorno ora:"+ inizio.toString());}
}
}
// ok?
protected void visualizzaOrari()
{
final String NIENTE = "Niente da visualizzare. Aggiungere orari adesso?";
final String FALLO_ORA = "E' consigliabile aggiungere gli orari quanto prima.";
final String INTRO = "Orari del medico:\t%d\t%s\t%s\n\n";
final String TABELLA = Giorno.getIntestazioneOrari();
// final String ELEMENTO = "\t%s\t%s\t%s\n";
if (orari_visita.isEmpty())
{
boolean scelta = myLib.util.Menu.yes_no_Box(NIENTE, true);
if (scelta == true)
{
try
{
inizializzaOrari(false);
} catch (Exception e)
{
System.out.println(e.getMessage() + "\n\n" + FALLO_ORA);
}
}
else
{
System.out.println(FALLO_ORA);
}
}
else
{
System.out.printf(INTRO, this.numero_iscrizione_albo, this.nome, this.cognome);
System.out.println(TABELLA);
ordinaGiorni();
for (int i = 0; i < orari_visita.size(); i++)
{
System.out.println(orari_visita.get(i).getTabellaOrari());
if (((i % 10) == 0)&&(i!=0))
{
myLib.util.Input.pause();
}
}
}
}
// ok?
protected void ordinaGiorni()
{
Collections.sort(orari_visita);
}
public void aggiungiOrari() throws Exception
{
final String INTRO = "E' ora possibile modificare un solo giorno alla volta.";
System.out.println(INTRO);
int scelta;
final String[] MENU_GIORNI = { "indietro", "cancella giorno", "aggiungi/estendi giorno" };
final int IND = 0;
final int CAN = 1;
final int AGG = 2;
boolean finito = false;
while (!finito)
{
scelta = myLib.util.Menu.crea_menu_numero(MENU_GIORNI.length, MENU_GIORNI);
switch (scelta)
{
case IND:
finito = true;
break;
case CAN:
cancellaGiorno();
break;
case AGG:
aggiungiGiorno();
break;
default:
break;
}
}
}
protected void cancellaGiorno() throws Exception
{
final String INTRO = "inserire il giorno da cancellare: ";
GregorianCalendar daCancellare = myLib.util.Input.leggi_data(INTRO);
Integer indiceCerca = cercaGiornoData(daCancellare);
if (indiceCerca == null)
{
final String NESSUNO = "Non trovato. Riprovare? (S/N)";
if (myLib.util.Menu.yes_no_Box(NESSUNO, false)) cancellaGiorno();
}
else
{
int indice = (int) indiceCerca;
String nomefile = trovaNomeDaSalvare();
ArrayList<String> registro = orari_visita.get(indice).aggiungiVisiteInteressate();
salvaVisite(nomefile, registro);
System.out.printf(Classemain.SICURO_FILE, nomefile);
boolean conferma = myLib.util.Menu.yes_no_Box("", false);
if (conferma == true)
{
orari_visita.get(indice).noLavoro();
chiudiVisitePerData(daCancellare, Classemain.cache_visite);
}
}
}
private void chiudiVisitePerData(GregorianCalendar data, ArrayList<Visita> visite)
{
for (int i = 0; i < visite.size(); i++)
{
if ((visite.get(i).getData().equals(data)) && (visite.get(i).getId_medico() == this.numero_iscrizione_albo))
{
visite.get(i).setStato_della_visita(Stato_visita.CONCLUSA);
}
}
}
protected void aggiungiGiorno() throws Exception
{
final String INTRO = "inserire il giorno da aggiungere/modificare";
GregorianCalendar richiesta = myLib.util.Input.leggi_data(INTRO);
if (!esisteGiorno(richiesta))
{
/**
* giorno non esiste
*
*/
final String NON_ES = "il giorno non esiste. Inserire i nuovi orari.";
System.out.println(NON_ES);
System.out.println(ORA_1);
Ora inizio = myLib.typedef.Ora.crea_ora();
myLib.typedef.Ora.scala(inizio, false, 0, 30, 60);
System.out.println(Classemain.ORA_SCALATA + inizio.toString());
System.out.println(ORA_2);
Ora fine = myLib.typedef.Ora.crea_ora();
myLib.typedef.Ora.scala(fine, false, 0, 30, 60);
System.out.println(Classemain.ORA_SCALATA + fine.toString());
if ((inizio.relazione(fine) == Ora.CONFRONTA_ORE_SEGUENTE)) throw new Exception(ERR_DATE);
orari_visita.add(new Giorno(richiesta, inizio, fine));
ordinaGiorni();
}
else
{
/**
* TODO VISUALIZZA GIORNO
*
*/
final String ESISTE = "Il giorno selezionato esiste gia'. E' necessario specificare se sostituire o unire gli orari.\nSostituendo gli orari, le relative visite saranno chiuse.";
System.out.println(ESISTE);
boolean finito = false;
final String[] OPZIONI = { "indietro", "sostituire", "unire" };
int scelta;
final int IND = 0;
final int SOS = 1;
final int UNI = 2;
while (!finito)
{
scelta = myLib.util.Menu.crea_menu_numero(OPZIONI.length, OPZIONI);
switch (scelta)
{
case IND:
finito = true;
break;
case SOS:
sostituisciGiorno(richiesta);
finito=true;
break;
case UNI:
unisciGiorno(richiesta);
finito=true;
break;
default:
break;
}
}
}
}
private boolean esisteGiorno(GregorianCalendar a)
{
for (int i = 0; i < orari_visita.size(); i++)
{
if (orari_visita.get(i).data.equals(a)) return true;
}
return false;
}
private void sostituisciGiorno(GregorianCalendar a)
{
try
{
Ora nuovaInizio = myLib.typedef.Ora.crea_ora();
myLib.typedef.Ora.scala(nuovaInizio, false, 0, 30, 60);
System.out.println(Classemain.ORA_SCALATA + nuovaInizio.toString());
Ora nuovaFine = myLib.typedef.Ora.crea_ora();
myLib.typedef.Ora.scala(nuovaFine, false, 0, 30, 60);
System.out.println(Classemain.ORA_SCALATA + nuovaFine.toString());
if (nuovaInizio.relazione(nuovaFine) == Ora.CONFRONTA_ORE_SEGUENTE) { throw new Exception(ERRORE_ORA); }
int indice = cercaGiornoData(a);
orari_visita.get(indice).sostituisciOrari(nuovaInizio, nuovaFine);
} catch (Exception e)
{
System.out.println(e.getMessage());
sostituisciGiorno(a);
}
}
private void unisciGiorno(GregorianCalendar data)
{
try
{
Ora nuovaInizio = myLib.typedef.Ora.crea_ora();
myLib.typedef.Ora.scala(nuovaInizio, false, 0, 30, 60);
System.out.println(Classemain.ORA_SCALATA + nuovaInizio.toString());
Ora nuovaFine = myLib.typedef.Ora.crea_ora();
myLib.typedef.Ora.scala(nuovaFine, false, 0, 30, 60);
System.out.println(Classemain.ORA_SCALATA + nuovaFine.toString());
if (nuovaInizio.relazione(nuovaFine) == Ora.CONFRONTA_ORE_SEGUENTE) { throw new Exception(ERRORE_ORA); }
int indice = cercaGiornoData(data);
orari_visita.get(indice).unisciOrari(nuovaInizio, nuovaFine);
} catch (Exception e)
{
System.out.println(e.getMessage());
unisciGiorno(data);
}
}
/**
* ritorna l'indice del giorno con tale data. null se non trovata
*
* @param query
* @return
*/
protected Integer cercaGiornoData(GregorianCalendar query)
{
ordinaGiorni();
for (int i = 0; i < orari_visita.size(); i++)
{
if (orari_visita.get(i).data.equals(query)) { return i; }
}
return null;
}
// ok
private void segnafestivi()
{
for (int i = 0; i < orari_visita.size(); i++)
{
if ((orari_visita.get(i).data.get(Calendar.DAY_OF_WEEK) == GregorianCalendar.SATURDAY) || (orari_visita.get(i).data.get(Calendar.DAY_OF_WEEK) == GregorianCalendar.SUNDAY))
{
orari_visita.get(i).noLavoro();
}
}
}
// @SuppressWarnings ("static-access")
public void cercaorariMedico(GregorianCalendar queryData, Ora queryOra)
{
ordinaGiorni();
for (int i = 0; i < orari_visita.size(); i++)
{
if (Data.dateUguali(orari_visita.get(i).data, queryData))
{
if (orari_visita.get(i).comprendeOraDisponibile(queryOra))
{
System.out.println(getInfoBase());
System.out.println(orari_visita.get(i).getIntestazioneOrari());
System.out.println(orari_visita.get(i).getTabellaOrari());
}
}
}
}
public void resettaOrari()
{
for (int i = 0; i < orari_visita.size(); i++)
{
orari_visita.get(i).noLavoro();
}
// orari_visita = null;
// inizializzaOrari();
}
protected boolean isDisponibile (GregorianCalendar data, Ora ora)
{
}
/**
* trova le visite di un medico prima di eliminare i suoi orari
*
*/
public String trovaVisiteInteressate() throws IOException, Exception
{
ArrayList<String> visite = new ArrayList<String>();
for (int i = 0; i < orari_visita.size(); i++)
{
visite.addAll(orari_visita.get(i).aggiungiVisiteInteressate());
}
String filename = trovaNomeDaSalvare();
salvaVisite(filename, visite);
return filename;
}
protected static String trovaNomeDaSalvare()
{
final String EXT = "txt";
final String NOME = "visite";
String soluzione;
int copia = 0;
File test = new File(NOME + copia + EXT);
boolean finito = false;
while (!finito)
{
test = new File(NOME + copia + EXT);
if (test.exists())
{
copia++;
}
else
{
finito = true;
}
}
soluzione = NOME + copia + EXT;
soluzione += EXT;
return soluzione;
}
protected static void salvaVisite(String nome, ArrayList<String> oggetto) throws IOException
{
PrintWriter scrivi = myLib.util.Output.creaFileTesto(nome);
for (int i = 0; i < oggetto.size(); i++)
{
scrivi.write(oggetto.get(i));
}
}
public void modificamedicoInterfaccia()
{
final String CREA_MEDICO_STRINGA = "Registrare un medico";
myLib.util.Output.stampa_testo(CREA_MEDICO_STRINGA);
final String RICAPITOLA = "ricapitolazione dell'input:\n\n\n";
final String RIDEFINISCI = "si desidera modificare il medico? (S/N) ";
final String STRINGA_NOME = "inserire nome ";
final String STRINGA_COGNOME = "inserire cognome ";
final String STRINGA_DATA = "inserire data di nascita ";
final String STRINGA_LUOGO = "inserire luogo nascita ";
final String STRINGA_TEL = "inserire telefono ";
final String STRINGA_TIPO = "inserire tipo medico ";
nome = myLib.util.Input.leggi_stringa(STRINGA_NOME);
cognome = myLib.util.Input.leggi_stringa(STRINGA_COGNOME);
data_nascita = myLib.util.Input.leggi_data(STRINGA_DATA);
luogo_nascita = myLib.util.Input.leggi_stringa(STRINGA_LUOGO);
telefono = myLib.util.Input.leggi_stringa(STRINGA_TEL);
genere = myLib.util.Input.scegligenerechar();
if (Classemain.DEBUG)
{
codice_fiscale = myLib.util.Input.leggi_stringa();
}
else
{
codice_fiscale = myLib.util.Input.inserisciCodiceFiscale();
}
if (!Classemain.DEBUG)
{
System.out.println(STRINGA_TIPO);
tipo_del_medico = tipologia_medico.sceglitipo();
}
// Medico ritorno = new Medico(temp_nome, temp_cognome,
// temp_data_nascita, temp_luogo_nascita, temp_telefono, temp_genere,
// temp_codice_fiscale, temp_numero_iscrizione, temp_tipologia, _id);
System.out.println(RICAPITOLA);
System.out.println(this.toString());
if (myLib.util.Menu.yes_no_Box(RIDEFINISCI, false)) this.modificamedicoInterfaccia();
;
// return ritorno;
}
/**
* 1 NOME 2 COGNOME 3 DATA 4 LUOGO 5 TELEFONO 6 GENERE 7 CODICE FISCALE 8
* NUMERO ID ALBO 9 TIPO
*
*
*
*/
// fatto
public boolean matchcampo(int campo, Object query)
{
final String PARAM_ERR = "errore nella ricerca. Probabilmente il parametro è scorretto";
final int NOME = 1;
final int COGNOME = 2;
final int DATA = 3;
final int LUOGO = 4;
final int TEL = 5;
final int GENERE = 6;
final int CODFISC = 7;
final int NUM_ALB = 8;
final int TIPO = 9;
final int ID = 10;
switch (campo)
{
case NOME:
return super.matchcampo(campo, query);
case COGNOME:
return super.matchcampo(campo, query);
case DATA:
return super.matchcampo(campo, query);
case LUOGO:
return super.matchcampo(campo, query);
case TEL:
return super.matchcampo(campo, query);
case GENERE:
return super.matchcampo(campo, query);
case CODFISC:
return super.matchcampo(campo, query);
case NUM_ALB:
case ID:
try
{
int escamotage = (int) query;
if (this.numero_iscrizione_albo == escamotage) return true;
} catch (ClassCastException e)
{
throw new IllegalArgumentException(PARAM_ERR);
}
break;
case TIPO:
query = (tipologia_medico) query;
if (this.tipo_del_medico.equals(query)) return true;
break;
// case ID:
//
// if (this.id_medico == (int) query) return true;
//
// break;
default:
break;
}
return false;
}
}
package corso;
import java.io.Serializable;
public class MiscData implements Serializable
{
public int currentMedicoID;
public int currentVisitaID;
/**
* @return the currentMedicoID
*/
public int getCurrentMedicoID()
{
return currentMedicoID;
}
/**
* @param currentMedicoID the currentMedicoID to set
*/
public void setCurrentMedicoID(int currentMedicoID)
{
this.currentMedicoID = currentMedicoID;
}
/**
* @return the currentVisitaID
*/
public int getCurrentVisitaID()
{
return currentVisitaID;
}
/**
* @param currentVisitaID the currentVisitaID to set
*/
public void setCurrentVisitaID(int currentVisitaID)
{
this.currentVisitaID = currentVisitaID;
}
public int currentUtenteID;
/**
* @return the currentUtenteID
*/
public int getCurrentUtenteID()
{
return currentUtenteID;
}
/**
* @param currentUtenteID the currentUtenteID to set
*/
public void setCurrentUtenteID(int currentUtenteID)
{
this.currentUtenteID = currentUtenteID;
}
public MiscData()
{
setCurrentMedicoID(1);
setCurrentUtenteID(1);
setCurrentVisitaID(1);
}
}
package corso;
import java.io.Serializable;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.InputMismatchException;
public class Persona implements Serializable
{
protected String nome;
protected String cognome;
GregorianCalendar data_nascita;
protected String luogo_nascita;
protected String telefono;
protected char genere;
protected String codice_fiscale;
public Persona (String _nome, String _cognome, GregorianCalendar _data_nascita, String _luogo_nascita, String _telefono, char _genere, String _codice_fiscale)
{
nome = _nome;
cognome = _cognome;
data_nascita = _data_nascita;
luogo_nascita = _luogo_nascita;
telefono = _telefono;
genere = _genere;
codice_fiscale = _codice_fiscale;
}
public Persona()
{
nome = null;
cognome = null;
data_nascita = null;
luogo_nascita = null;
telefono = null;
//genere = null;
codice_fiscale = null;
}
public String toString()
{
final String INTRO = "persona:\n\tcampo\tvalore\n\t";
final String NOME = "nome:\t";
final String COGNOME = "\n\tcognome:\t";
final String DATA = "\n\tdata nascita:\t";
final String LUOGO = "\n\tluogo di nascita:\t";
final String TEL = "\n\ttelefono:\t";
final String GEN = "\n\tgenere:\t";
final String CODFIS = "\n\tcodice fiscale:\t";
return (INTRO + NOME + nome + COGNOME + cognome + DATA + myLib.util.Output.formatDate(data_nascita) + LUOGO + luogo_nascita + TEL + telefono + GEN + genere + CODFIS + codice_fiscale);
}
public boolean equals(Persona cfr)
{
if ((cfr.nome.equals(this.nome)) && (cfr.cognome.equals(this.cognome)) && (cfr.data_nascita.equals(this.data_nascita)) && (cfr.luogo_nascita.equals(this.luogo_nascita)) && (cfr.telefono.equals(this.telefono)) && (cfr.genere == this.genere) && (cfr.codice_fiscale.equals(this.codice_fiscale))) return true;
else
return false;
}
/**
* restituisce vero se il campo i corrisponde alla query
*
*
* @param campo
* i : nome=1, cognome, data nascita, luogo nascita, telefono,
* genere, codice fiscale=7
* @param query
* : in caso di numeri usare Integer
* @return true se corrisponde
*/
public boolean matchcampo(int campo, Object query) throws InputMismatchException
{
final String PARAM_ERR = "errore nella ricerca. Probabilmente il parametro è scorretto";
final int NOME = 1;
final int COGNOME = 2;
final int DATA = 3;
final int LUOGO = 4;
final int TEL = 5;
final int GENERE = 6;
final int CODFISC = 7;
switch (campo)
{
case NOME:
if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
query = (String) query;
if (this.nome.equals(query)) return true;
break;
case COGNOME:
if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
query = (String) query;
if (this.cognome.equals(query)) return true;
break;
case DATA:
if (!(query instanceof GregorianCalendar)) throw new InputMismatchException(PARAM_ERR);
query = (GregorianCalendar) query;
if (this.data_nascita.equals(query)) return true;
break;
case LUOGO:
if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
query = (String) query;
if (this.luogo_nascita.equals(query)) return true;
break;
case TEL:
if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
query = (String) query;
if (this.telefono.equals(query)) return true;
break;
case GENERE:
try
{
//
char escamotage = (char) query;
//
if (this.genere == escamotage) return true;
} catch (ClassCastException e)
{
throw new InputMismatchException(PARAM_ERR);
}
break;
case CODFISC:
if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
query = (String) query;
if (this.codice_fiscale.equals(query)) return true;
break;
default:
break;
}
return false;
}
}
package corso;
import java.io.Serializable;
//import java.util.GregorianCalendar;
import java.util.Vector;
public class Settimana implements Serializable
{
private static final int GIORNI_SETTIMANA = 7;
// public int mese;
// public int anno;
// public GregorianCalendar inizio;
// public GregorianCalendar fine;
// private Vector<Giorno> giorni = new Vector<Giorno>();
// public int numero_settimana;
// protected Giorno[] giorni_settimana = new Giorno[GIORNI_SETTIMANA];
public static final int ore_lavorative_al_giorno = 10;
public static final int numero_slot_per_ora = 2;
public static final int NUMERO_SLOT_PER_GIORNO = ore_lavorative_al_giorno * numero_slot_per_ora;
public boolean[][] orari_visita = new boolean[NUMERO_SLOT_PER_GIORNO][GIORNI_SETTIMANA];
}
package corso;
import java.io.Serializable;
import myLib.typedef.Ora;
public class SlotTemporale implements Serializable
{
private static final long serialVersionUID=0;
public enum Stato_visita_slot
{
PRENOTABILE, PRENOTATA, NON_PRENOTABILE;
public String toString()
{
return super.toString().toLowerCase();
}
}
// Ora
public Ora orario;
protected int id_visita;
public Stato_visita_slot stato_slot;
protected SlotTemporale (Ora _ora, int _id, Stato_visita_slot _stato)
{
setOrario(_ora);
setId_visita(_id);
setStato_slot(_stato);
}
/**
* @return the orario
*/
public Ora getOrario()
{
return orario;
}
/**
* @param orario
* the orario to set
*/
private void setOrario(Ora orario)
{
Ora nuovo = myLib.typedef.Ora.clone(orario);
this.orario = nuovo;
}
/**
* @return the id_visita
*/
public int getId_visita()
{
return id_visita;
}
/**
* @param id_visita
* the id_visita to set
*/
private void setId_visita(int id_visita)
{
this.id_visita = id_visita;
}
/**
* @return the stato_slot
*/
public Stato_visita_slot getStato_slot()
{
return stato_slot;
}
/**
* @param stato_slot
* the stato_slot to set
*/
public void setStato_slot(Stato_visita_slot stato_slot)
{
switch (stato_slot)
{
case NON_PRENOTABILE:
this.stato_slot = Stato_visita_slot.NON_PRENOTABILE;
break;
case PRENOTABILE:
this.stato_slot = Stato_visita_slot.PRENOTABILE;
break;
case PRENOTATA:
this.stato_slot = Stato_visita_slot.PRENOTATA;
break;
default:
break;
}
}
}
package corso;
import java.util.GregorianCalendar;
import java.util.InputMismatchException;
import java.util.Scanner;
import corso.Medico.tipologia_medico;
import myLib.typedef.Enumerations.genere;
public class Utente extends Persona
{
private static final long serialVersionUID=0;
int id_utente;
/**
* costruttore
*
* @param _nome
* @param _cognome
* @param _data_nascita
* @param _luogo_nascita
* @param _telefono
* @param _genere
* @param _codice_fiscale
*/
public Utente (String _nome, String _cognome, GregorianCalendar _data_nascita,
String _luogo_nascita, String _telefono, char _genere,
String _codice_fiscale, int _id)
{
super(_nome, _cognome, _data_nascita, _luogo_nascita, _telefono, _genere, _codice_fiscale);
id_utente=_id+1;
}
public Utente()
{
super();
}
/**
* interfaccia per creare utente
*
* @return variabile utente
*/
public static Utente creaUtenteInterfaccia(int _id)
{
final String RICAPITOLA = "ricapitolazione dell'input:\n\n\n ";
final String RIDEFINISCI = "si desidera modificare l'utente? (S/N) ";
final String STRINGA_NOME = "inserire nome ";
final String STRINGA_COGNOME = "inserire cognome ";
final String STRINGA_DATA = "inserire data di nascita ";
final String STRINGA_LUOGO = "inserire luogo nascita ";
final String STRINGA_TEL = "inserire telefono ";
Utente ritorno;
String temp_nome = myLib.util.Input.leggi_stringa(STRINGA_NOME);
String temp_cognome = myLib.util.Input.leggi_stringa(STRINGA_COGNOME);
GregorianCalendar temp_data_nascita = myLib.util.Input.leggi_data(STRINGA_DATA);
String temp_luogo_nascita = myLib.util.Input.leggi_stringa(STRINGA_LUOGO);
String temp_telefono = myLib.util.Input.leggi_stringa(STRINGA_TEL);
char temp_genere=myLib.util.Input.scegligenerechar();
String temp_codice_fiscale = myLib.util.Input.inserisciCodiceFiscale();
ritorno = new Utente(temp_nome, temp_cognome, temp_data_nascita, temp_luogo_nascita, temp_telefono, temp_genere, temp_codice_fiscale, _id);
System.out.println(RICAPITOLA);
System.out.println(ritorno.toString());
if (myLib.util.Menu.yes_no_Box(RIDEFINISCI, false)) ritorno = creaUtenteInterfaccia(_id);
return ritorno;
}
/**
* serve per confrontare uno dei campi
*
*/
public boolean matchcampo(int campo, Object query)
{
final String PARAM_ERR = "errore nella ricerca. Probabilmente il parametro è scorretto";
final int NOME = 1;
final int COGNOME = 2;
final int DATA = 3;
final int LUOGO = 4;
final int TEL = 5;
final int GENERE = 6;
final int CODFISC = 7;
final int ID=10;
switch (campo)
{
case NOME:
return super.matchcampo(campo, query);
case COGNOME:
return super.matchcampo(campo, query);
case DATA:
return super.matchcampo(campo, query);
case LUOGO:
return super.matchcampo(campo, query);
case TEL:
return super.matchcampo(campo, query);
case GENERE:
return super.matchcampo(campo, query);
case CODFISC:
return super.matchcampo(campo, query);
case ID:
if (this.id_utente==(int)query) return true;
break;
default:
break;
}
return false;
}
public void modificaUtenteInterfaccia()
{
final String RICAPITOLA = "ricapitolazione dell'input:\n\n\n ";
final String RIDEFINISCI = "si desidera modificare l'utente? (S/N) ";
final String STRINGA_NOME = "inserire nome. Precedente: ";
final String STRINGA_COGNOME = "inserire cognome. Precedente: ";
final String STRINGA_DATA = "inserire data di nascita. Precedente: ";
final String STRINGA_LUOGO = "inserire luogo nascita. Precedente: ";
final String STRINGA_TEL = "inserire telefono. Precedente: ";
nome = myLib.util.Input.leggi_stringa(STRINGA_NOME+this.nome);
cognome = myLib.util.Input.leggi_stringa(STRINGA_COGNOME+this.cognome);
data_nascita = myLib.util.Input.leggi_data(STRINGA_DATA+myLib.util.Output.formatDate(this.data_nascita));
luogo_nascita = myLib.util.Input.leggi_stringa(STRINGA_LUOGO+this.luogo_nascita);
telefono = myLib.util.Input.leggi_stringa(STRINGA_TEL+this.telefono);
genere=myLib.util.Input.scegligenerechar();
System.out.println("Precedente codice fiscale: "+ this.codice_fiscale);
codice_fiscale = myLib.util.Input.inserisciCodiceFiscale();
//ritorno = new Utente(temp_nome, temp_cognome, temp_data_nascita, temp_luogo_nascita, temp_telefono, temp_genere, temp_codice_fiscale);
System.out.println(RICAPITOLA);
System.out.println(this.toString());
if (myLib.util.Menu.yes_no_Box(RIDEFINISCI, false)) modificaUtenteInterfaccia();
//return ritorno;
}
public String toString()
{
final String ID = "\n\tid:\t";
String ritorno = super.toString()+ID+id_utente;
return ritorno;
}
public boolean equals(Utente confronto)
{
if (confrontapersona(this, confronto) && confrontautente(this, confronto)) return true;
else
return false;
}
private boolean confrontautente(Utente _1, Utente _2)
{
return (this.id_utente==_2.id_utente);
}
private boolean confrontapersona(Utente _1, Utente _2)
{
Persona confronto1 = (Persona) _1;
Persona confronto2 = (Persona) _2;
if (confronto1.equals(confronto2)) return true;
else
return false;
}
}
package corso;
//import java.sql.Time;
import java.util.GregorianCalendar;
import myLib.typedef.Ora;
public class Visita
{
public enum Stato_visita
{
//NON_PRENOTABILE,
//PRENOTABILE,
PRENOTATA,
CONCLUSA,
REFERTATA;
public String toString()
{
return super.toString().toLowerCase();
}
}
public int id_visita;
public Visita(int utente, String motivo, int medico, GregorianCalendar _data, Ora _ora)
{
setId_utente(utente);
setMotivo(motivo);
setId_medico(medico);
data=_data;
ora_visita=_ora;
id_visita=calcolaID();
}
private int calcolaID()
{
int ritorno=Classemain.dati.currentVisitaID;
Classemain.dati.currentVisitaID++;
return ritorno;
}
/**
*
*
* TODO DA MIGLIORARE
*
*/
public String toString()
{
return (getId_visita()+getId_utente()+getId_medico()+getMotivo()+getPrescrizione()+getReferto()+getData()+getOra()+getStato_della_visita());
}
/**
* @return the id_utente
*/
private int getId_utente()
{
return id_utente;
}
/**
* @param id_utente the id_utente to set
*/
private void setId_utente(int id_utente)
{
this.id_utente = id_utente;
}
/**
* @return the id_medico
*/
public int getId_medico()
{
return id_medico;
}
/**
* @param id_medico the id_medico to set
*/
private void setId_medico(int id_medico)
{
this.id_medico = id_medico;
}
/**
* @param id_visita the id_visita to set
*/
private void setId_visita(int id_visita)
{
this.id_visita = id_visita;
}
/**
* @return the id_visita
*/
public int getId_visita()
{
return id_visita;
}
/**
* @param id_visita the id_visita to set
*/
public boolean matchID(int cfr)
{
if (id_visita==cfr) return true; else return false;
}
public int id_utente;
private GregorianCalendar data;
public GregorianCalendar getData()
{
return data;
}
private Ora ora_visita;
public Ora getOra()
{
return ora_visita;
}
public int id_medico;
private String motivo;
/**
* @param motivo the motivo to set
*/
public void setMotivo(String motivo)
{
this.motivo = motivo;
}
public String getMotivo()
{
return motivo;
}
/**
* @return the stato_della_visita
*/
public Stato_visita getStato_della_visita()
{
return stato_della_visita;
}
/**
* @param stato_della_visita the stato_della_visita to set
*/
public void setStato_della_visita(Stato_visita stato_della_visita)
{
this.stato_della_visita = stato_della_visita;
}
/**
* @return the referto
*/
public String getReferto()
{
return referto;
}
/**
* @param referto the referto to set
*/
public void setReferto(String referto)
{
this.referto = referto;
}
/**
* @return the prescrizione
*/
public String getPrescrizione()
{
return prescrizione;
}
/**
* @param prescrizione the prescrizione to set
*/
public void setPrescrizione(String prescrizione)
{
this.prescrizione = prescrizione;
}
private Stato_visita stato_della_visita;
private String referto;
private String prescrizione;
public boolean matchMedico(int query)
{
if (id_medico==query) return true; else return false;
}
public boolean matchUtente(int query)
{
if (id_utente==query) return true; else return false;
}
}
Bonnox
