Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Java - Errore: impossibile trovare o caricare la classe principale
Forum - Java - Errore: impossibile trovare o caricare la classe principale

Pagine: [ 1 2 3 ] Precedente | Prossimo
Avatar
Bonnox (Member)
Pro


Messaggi: 85
Iscritto: 23/08/2014

Segnala al moderatore
Postato alle 10:16
Mercoledì, 15/07/2015
Ok, ammetto di sentirmi veramente #nabboh con questa domana, quasi me ne vergogno...

semplicemente non partono i file class.
Su eclipse invece si. dunque mi perdo qualcosa io. :/

da terminale faccio
Codice sorgente - presumibilmente Plain Text

  1. java nome_file_class_senza_estensione

e non va. :(

sistema windows 7 home 64 bit ultra buggato, jdk 7.

credo sia qualcosa del path, comunque ecco il mio:

;C:\windows\system32;C:\adt-bundle-windows-x86_64\sdk\platform-tools;C:\Program Files\Java\jdk1.7.0_75\bin;C:\adt-bundle-windows-x86_64-20140702\sdk\sdk\platform-tools;D:\programmazione\PASCAL\PROGETTI\file merger\CORRENTE\bin

PM Quote
Avatar
GN (Member)
Guru


Messaggi: 772
Iscritto: 30/04/2011

Segnala al moderatore
Postato alle 11:32
Mercoledì, 15/07/2015
Testo quotato

Postato originariamente da Bonnox:
da terminale faccio
Codice sorgente - presumibilmente Plain Text

  1. java nome_file_class_senza_estensione

e non va. :(


Ciao, potresti specificare cosa intendi per "non va"? Dà qualche errore? Se fosse un problema del path direbbe qualcosa come "java non è riconosciuto come comando interno o esterno, un programma eseguibile o un file batch" o qualcosa di simile.

PM Quote
Avatar
Bonnox (Member)
Pro


Messaggi: 85
Iscritto: 23/08/2014

Segnala al moderatore
Postato alle 12:33
Mercoledì, 15/07/2015
Testo quotato

Postato originariamente da GN:

Ciao, potresti specificare cosa intendi per "non va"? Dà qualche errore? Se fosse un problema del path direbbe qualcosa come "java non è riconosciuto come comando interno o esterno, un programma eseguibile o un file batch" o qualcosa di simile.



ciao, l'errore è quello riportato nel titolo: nessuna classe principale (ovviamente c'è)

Codice sorgente - presumibilmente Java

  1. public static void main(String[] args)
  2.         {
  3.                 if (DEBUG) myLib.util.Output.debug();
  4.                 benvenuto();
  5.                 ciclo();
  6.                 fine();
  7.                
  8.         }


Ultima modifica effettuata da Bonnox il 15/07/2015 alle 12:36
PM Quote
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6230
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 14:51
Mercoledì, 15/07/2015
Posta tutto il sorgente. Grazie.


Il mio blog: https://piero.dev
PM Quote
Avatar
Bonnox (Member)
Pro


Messaggi: 85
Iscritto: 23/08/2014

Segnala al moderatore
Postato alle 15:26
Mercoledì, 15/07/2015
Testo quotato

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



Codice sorgente - presumibilmente Java

  1. package corso;
  2.  
  3. //import java.io.BufferedOutputStream;
  4. //import java.io.File;
  5. //import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.io.ObjectInputStream;
  8. import java.io.ObjectOutputStream;
  9. //import java.lang.reflect.Array;
  10. import java.util.ArrayList;
  11. //import java.util.Collection;
  12. import java.util.Collections;
  13. import java.util.GregorianCalendar;
  14. //import java.util.ArrayList;
  15.  
  16. //import javax.swing.plaf.basic.BasicInternalFrameTitlePane.MaximizeAction;
  17.  
  18. import myLib.typedef.Ora;
  19. import corso.Medico.tipologia_medico;
  20. import corso.SlotTemporale.Stato_visita_slot;
  21. import corso.Visita.Stato_visita;
  22.  
  23. public class Classemain
  24.  
  25. {
  26.        
  27.         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.";
  28.         private static final String             SARA_MODIFICATO                                                         = "Questo utente sara' modificato:\n";
  29.         private static final String             DESIDERA_CONTINUARE                                                     = "si desidera continuare? S/N ";
  30.         private static final String             ERORE_CLASSCAST                                                         = " ERORE DI classcast ";
  31.         private static final String             ERRORE_CLASSNOTFOUND                                            = " ERRORE DI classnotfound ";
  32.         /**
  33.          * TODO CONTROLLO COERENZA FILE
  34.          *
  35.          */
  36.        
  37.         // private static final int INDICI = 0;
  38.         // private static final int NUMERI = 1;
  39.        
  40.         private static final String             I_O_ERROR                                                                       = " ERRORE DI I/O ";
  41.        
  42.         protected static final boolean  DEBUG                                                                           = true;
  43.         private static final int                MEDICO_ID                                                                       = 0;
  44.         private static final int                GIORNO_VALORE                                                           = 1;
  45.         private static final int                ORA_VAALORE                                                                     = 2;
  46.         private static final int                MEDICO_INDEX                                                            = 3;
  47.         private static final int                GIORNO_INDEX                                                            = 4;
  48.         private static final int                ORA_INDEX                                                                       = 5;
  49.         private static final int                DISPONIBILE                                                                     = 6;
  50.         private static final int                INFORMAZIONI_DIMENSIONE                                         = 7;
  51.        
  52.         private static int                              scelta;
  53.         static ArrayList<Utente>                clienti_clinica                                                         = new ArrayList<Utente>();
  54.         static ArrayList<Medico>                corpo_medici                                                            = new ArrayList<Medico>();
  55.         static ArrayList<Visita>                cache_visite                                                            = new ArrayList<Visita>();
  56.         static MiscData                                 dati                                                                            = new MiscData();
  57.        
  58.         static boolean                                  firstrun                                                                        = true;
  59.         static boolean                                  uscita                                                                          = false;
  60.        
  61.         static final String                             INDEX_ERROR                                                                     = "errore di indice";
  62.         static final String                             FILE_MEDICI                                                                     = "C:/medici.dat";
  63.         static final String                             FILE_UTENTI                                                                     = "C:/utenti.dat";
  64.         static final String                             FILE_VISITE                                                                     = "C:/visite.dat";
  65.         static final String                             FILE_DATI                                                                       = "C:/miscdata.dat";
  66.        
  67.         protected static final String   ORA_SCALATA                                                                     = "Ora scalata a: ";
  68.         static final String                             ANNULLATO                                                                       = "annullato";
  69.         static final String                             ERR_GENERICO                                                            = "errore ";
  70.         static final String                             PROSSIMA_PAGINA                                                         = "premere invio per passare alla prossima pagina";
  71.         static final String                             NIENTE                                                                          = "niente da visualizzare";
  72.         static final String                             IO_ERR                                                                          = "errore nei file: ";
  73.         static final String                             CERCA_ERR                                                                       = "nessun risultato";
  74.        
  75.         static final int                                ESCI_COM                                                                        = 0;
  76.         static final int                                AGG_UTEN_COM                                                            = 1;
  77.         static final int                                AGG_MED_COM                                                                     = 2;
  78.         static final int                                MOD_ORA_COM                                                                     = 3;
  79.         static final int                                GEST_VISI_COM                                                           = 4;
  80.         static final int                                VISUAL_E_MOD_COM                                                        = 5;
  81.         static final int                                SALVA_CARICA_COM                                                        = 6;
  82.        
  83.         static final int                                CERCA_MEDICI                                                            = 0;
  84.         static final int                                CERCA_UTENTI                                                            = 1;
  85.         static final int                                CERCA_MEDICO_SINGOLO                                            = 2;
  86.         static final int                                CERCA_UTENTE_SINGOLO                                            = 3;
  87.         static final int                                CERCA_MEDICO_VISITE                                                     = 4;
  88.         static final int                                CERCA_UTENTE_VISITE                                                     = 5;
  89.        
  90.         private static final String             INS_ID                                                                          = "inserire ID per la ricerca ";
  91.        
  92.         private static final String[]   TESTI_MENU                                                                      = { "esci", "aggiunta utente", "aggiunta medico", "gestione orari visita", "gestione visite", "visualizza e modifica dati", "salva o carica" };
  93.        
  94.         private static final int                NUMERO_SCELTE                                                           = TESTI_MENU.length;
  95.        
  96.         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)";
  97.        
  98.         // fatto
  99.         public static void main(String[] args)
  100.         {
  101.                 if (DEBUG) myLib.util.Output.debug();
  102.                 benvenuto();
  103.                 ciclo();
  104.                 fine();
  105.                
  106.         }
  107.        
  108.         // fatto
  109.         private static void benvenuto()
  110.         {
  111.                
  112.                 dati = new MiscData();
  113.                 final String MESSAGGIO_INIZIO = "PROGRAMMA GESTIONE CLINICA.";
  114.                 final String CARICA = "si desidera caricare da file?";
  115.                 System.out.println(MESSAGGIO_INIZIO);
  116.                 boolean risposta = myLib.util.Menu.yes_no_Box(CARICA, true);
  117.                 if (Classemain.DEBUG) System.out.println(risposta);
  118.                 if (risposta)
  119.                         {
  120.                                 try
  121.                                         {
  122.                                                 leggiFile();
  123.                                         } catch (IOException e)
  124.                                         {
  125.                                                 System.out.println(e.getMessage());
  126.                                         } catch (ClassNotFoundException e)
  127.                                         {
  128.                                                 System.out.println(e.getMessage());
  129.                                         } catch (ClassCastException e)
  130.                                         {
  131.                                                 System.out.println(e.getMessage());
  132.                                         }
  133.                                
  134.                         }
  135.                
  136.         }
  137.        
  138.         private static void scriviFile() throws IOException
  139.         {
  140.                
  141.                 // try
  142.                 // {
  143.                 // File f = new File("obj.dat");
  144.                 ObjectOutputStream archiviodati = myLib.util.Output.creaFileOggetto(FILE_DATI);
  145.                 archiviodati.writeObject(dati);
  146.                 archiviodati.close();
  147.                
  148.                 ObjectOutputStream archiviomedici = myLib.util.Output.creaFileOggetto(FILE_MEDICI);
  149.                 archiviomedici.writeObject(corpo_medici);
  150.                 archiviomedici.close();
  151.                
  152.                 ObjectOutputStream archiviopazienti = myLib.util.Output.creaFileOggetto(FILE_UTENTI);
  153.                 archiviopazienti.writeObject(clienti_clinica);
  154.                 archiviopazienti.close();
  155.                
  156.                 ObjectOutputStream archiviovisite = myLib.util.Output.creaFileOggetto(FILE_VISITE);
  157.                 archiviovisite.writeObject(cache_visite);
  158.                 archiviovisite.close();
  159.                
  160.                 // } catch (IOException e)
  161.                 // {
  162.                 // System.out.println(ERR+e.getMessage());
  163.                 // }
  164.                 // finally
  165.                 // {
  166.                
  167.                 // }
  168.                
  169.         }
  170.        
  171.         private static void leggiFile() throws IOException, ClassCastException, ClassNotFoundException
  172.         {
  173.                 // final String FILE_MEDICI
  174.                
  175.                 ObjectInputStream archiviodati = myLib.util.Input.aprifile(FILE_DATI);
  176.                 dati = (MiscData) archiviodati.readObject();
  177.                 archiviodati.close();
  178.                
  179.                 ObjectInputStream archiviomedici = myLib.util.Input.aprifile(FILE_MEDICI);
  180.                 corpo_medici = (ArrayList<Medico>) archiviomedici.readObject();
  181.                 archiviomedici.close();
  182.                
  183.                 ObjectInputStream archiviopazienti = myLib.util.Input.aprifile(FILE_UTENTI);
  184.                 clienti_clinica = (ArrayList<Utente>) archiviopazienti.readObject();
  185.                 archiviopazienti.close();
  186.                
  187.                 ObjectInputStream archiviovisite = myLib.util.Input.aprifile(FILE_VISITE);
  188.                 cache_visite = (ArrayList<Visita>) archiviovisite.readObject();
  189.                 archiviovisite.close();
  190.                
  191.                 firstrun = false;
  192.                
  193.         }
  194.        
  195.         private static void ciclo()
  196.         {
  197.                 // if (DEBUG) corpo_medici.get(0).ordinaGiorni();
  198.                
  199.                 while (!uscita)
  200.                         {
  201.                                 scelta = myLib.util.Menu.crea_menu_numero(NUMERO_SCELTE, TESTI_MENU);
  202.                                
  203.                                 switch (scelta)
  204.                                         {
  205.                                                 case ESCI_COM:
  206.                                                         esci();
  207.                                                         break;
  208.                                                 case AGG_UTEN_COM:
  209.                                                         aggiungiUtente();
  210.                                                         break;
  211.                                                 case AGG_MED_COM:
  212.                                                         try
  213.                                                                 {
  214.                                                                         aggiungiMedico();
  215.                                                                 } catch (Exception e)
  216.                                                                 {
  217.                                                                         System.err.println(ERR_GENERICO + e.getMessage());
  218.                                                                 }
  219.                                                         break;
  220.                                                 case MOD_ORA_COM:
  221.                                                         try
  222.                                                                 {
  223.                                                                         modificaOrariDottoriMain();
  224.                                                                 } catch (Exception e)
  225.                                                                 {
  226.                                                                         System.err.println(ERR_GENERICO + e.getMessage());
  227.                                                                 }
  228.                                                         break;
  229.                                                 case GEST_VISI_COM:
  230.                                                         gestioneVisite();
  231.                                                         break;
  232.                                                 case VISUAL_E_MOD_COM:
  233.                                                         visualizzaEModificaDati();
  234.                                                         break;
  235.                                                 case SALVA_CARICA_COM:
  236.                                                         gestioneIO();
  237.                                                         break;
  238.                                                 default:
  239.                                                         break;
  240.                                         }
  241.                         }
  242.         }
  243.        
  244.         // fatto
  245.         private static void fine()
  246.         {
  247.                 final String MESSAGGIO_FINE = "grazie per aver usato il programma, premere invio.";
  248.                
  249.                 System.out.println(MESSAGGIO_FINE);
  250.                 myLib.util.Input.leggi_stringa();
  251.                 myLib.util.Input.close_input();
  252.         }
  253.        
  254.         // fatto
  255.         private static void esci()
  256.         {
  257.                 uscita = true;
  258.         }
  259.        
  260.         // fatto
  261.         private static void aggiungiUtente()
  262.         {
  263.                 // Utente a=new Utente();
  264.                 // a=Utente.creaUtenteInterfaccia();
  265.                 // a.modificaUtenteInterfaccia();
  266.                 clienti_clinica.add(Utente.creaUtenteInterfaccia(dati.getCurrentUtenteID()));
  267.                 dati.setCurrentUtenteID(dati.getCurrentUtenteID() + 1);
  268.                 // clienti_clinica.get(clienti_clinica.size()-1).modificaUtenteInterfaccia();
  269.                 // return Utente.creaUtenteInterfaccia();
  270.                 // clienti_clinica.add(parametro);
  271.                 // System.out.println(clienti_clinica.toString());
  272.         }
  273.        
  274.         // fatto
  275.         private static void aggiungiMedico() throws Exception
  276.         {
  277.                 final String AGGIUNGI_ORARI = "definire gli orari del medico? è possibile farlo in seguito, ma nel frattempo non sarà possibile utilizzare il medico. (s/n) ";
  278.                
  279.                 corpo_medici.add(Medico.creaMedicoInterfaccia(dati.getCurrentMedicoID()));
  280.                
  281.                 dati.setCurrentMedicoID(dati.getCurrentMedicoID() + 1);
  282.                
  283.                 boolean scelta = myLib.util.Menu.yes_no_Box(AGGIUNGI_ORARI, false);
  284.                
  285.                 if (scelta == true)
  286.                         {
  287.                                 corpo_medici.get(corpo_medici.size() - 1).inizializzaOrari(false);
  288.                                 ;
  289.                         }
  290.         }
  291.        
  292.         private static void modificaOrariDottoriMain() throws Exception
  293.         {
  294.                 boolean finito = false;
  295.                 int scelta;
  296.                
  297.                 final String[] MENU_ORARI = { "indietro", "cerca orari", "modifica orari" };
  298.                
  299.                 final int IND = 0;
  300.                 final int CER = 1;
  301.                 final int MOD = 2;
  302.                
  303.                 while (!finito)
  304.                         {
  305.                                 scelta = myLib.util.Menu.crea_menu_numero(MENU_ORARI.length, MENU_ORARI);
  306.                                
  307.                                 switch (scelta)
  308.                                         {
  309.                                                 case IND:
  310.                                                         finito = true;
  311.                                                         break;
  312.                                                 case CER:
  313.                                                         cercaorari();
  314.                                                         break;
  315.                                                
  316.                                                 case MOD:
  317.                                                         {
  318.                                                                 try
  319.                                                                         {
  320.                                                                                 final String INTRO = "inserire l'ID del medico da modificare";
  321.                                                                                
  322.                                                                                 Integer id_cerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INTRO);
  323.                                                                                 if (id_cerca == null)
  324.                                                                                         {
  325.                                                                                                 System.out.println(ANNULLATO);
  326.                                                                                         }
  327.                                                                                 else
  328.                                                                                         {
  329.                                                                                                 int index = getIndexMedico(id_cerca);
  330.                                                                                                 modificaOrari(index, id_cerca);
  331.                                                                                         }
  332.                                                                         } catch (Exception e)
  333.                                                                         {
  334.                                                                                 System.err.println(ERR_GENERICO + e.getMessage());
  335.                                                                         }
  336.                                                         }
  337.                                                         break;
  338.                                                
  339.                                                 default:
  340.                                                         break;
  341.                                         }
  342.                                
  343.                         }
  344.                
  345.         }
  346.        
  347.         public static void modificaOrari(int index, int albo) throws Exception
  348.         {
  349.                 final String INTRO = "operazioni sugli orari";
  350.                
  351.                 boolean finito = false;
  352.                 final String[] VOCI_ORARI = { "indietro", "inizializza", "aggiungi", "elimina" };
  353.                 int scelta;
  354.                 final int INDIETRO = 0;
  355.                 final int AGGIORNA = 1;
  356.                 final int AGGIUNGI = 2;
  357.                 final int ELIMINA = 3;
  358.                
  359.                 while (!finito)
  360.                         {
  361.                                 System.out.println(INTRO);
  362.                                 scelta = myLib.util.Menu.crea_menu_numero(VOCI_ORARI.length, VOCI_ORARI);
  363.                                
  364.                                 switch (scelta)
  365.                                         {
  366.                                                 case INDIETRO:
  367.                                                         finito = true;
  368.                                                         break;
  369.                                                
  370.                                                 case AGGIORNA:
  371.                                                        
  372.                                                         corpo_medici.get(index).inizializzaOrari(false);
  373.                                                        
  374.                                                         break;
  375.                                                
  376.                                                 case AGGIUNGI:
  377.                                                        
  378.                                                         corpo_medici.get(index).aggiungiGiorno();
  379.                                                         break;
  380.                                                
  381.                                                 case ELIMINA:
  382.                                                        
  383.                                                         final int UNO = 1;
  384.                                                         final int TUTTI = 2;
  385.                                                        
  386.                                                         final String[] SCEGLI_ELIMINA = { "indietro", "elimina un giorno", "elimina tutti i giorni" };
  387.                                                         scelta = myLib.util.Menu.crea_menu_numero(SCEGLI_ELIMINA.length, SCEGLI_ELIMINA);
  388.                                                        
  389.                                                         switch (scelta)
  390.                                                                 {
  391.                                                                 /**
  392.                                                                  * no indietro perche non ha senso rimanere
  393.                                                                  * tante volte in queto menu
  394.                                                                  *
  395.                                                                  */
  396.                                                                
  397.                                                                         case UNO:
  398.                                                                                 corpo_medici.get(index).cancellaGiorno();
  399.                                                                                 break;
  400.                                                                        
  401.                                                                         case TUTTI:
  402.                                                                                 {
  403.                                                                                        
  404.                                                                                         /**
  405.                                                                                          * non elimina gli elementi dalla
  406.                                                                                          * lista ma li setta come non lavoro
  407.                                                                                          *
  408.                                                                                          *
  409.                                                                                          */
  410.                                                                                         try
  411.                                                                                                 {
  412.                                                                                                        
  413.                                                                                                         String nomefile = corpo_medici.get(index).trovaVisiteInteressate();
  414.                                                                                                        
  415.                                                                                                         System.out.printf(SICURO_FILE, nomefile);
  416.                                                                                                        
  417.                                                                                                         boolean conferma = myLib.util.Menu.yes_no_Box("", false);
  418.                                                                                                         if (conferma == true)
  419.                                                                                                                 {
  420.                                                                                                                        
  421.                                                                                                                         corpo_medici.get(index).resettaOrari();
  422.                                                                                                                         chiudiVisiteMedico(albo);
  423.                                                                                                                         corpo_medici.get(index).aggiungiOrari();
  424.                                                                                                                 }
  425.                                                                                                 } catch (Exception e)
  426.                                                                                                 {
  427.                                                                                                         System.err.println(ERR_GENERICO + e.getMessage());
  428.                                                                                                 }
  429.                                                                                 }
  430.                                                                                 break;
  431.                                                                        
  432.                                                                         default:
  433.                                                                                 break;
  434.                                                                 }
  435.                                                        
  436.                                                         break;
  437.                                                
  438.                                                 default:
  439.                                                         break;
  440.                                         }
  441.                                
  442.                         }
  443.         }
  444.        
  445.         private static void chiudiVisiteMedico(int id)
  446.         {
  447.                 for (int i = 0; i < cache_visite.size(); i++)
  448.                         {
  449.                                 if (cache_visite.get(i).getId_medico() == id)
  450.                                         {
  451.                                                 cache_visite.get(i).setStato_della_visita(Stato_visita.CONCLUSA);
  452.                                         }
  453.                         }
  454.         }
  455.        
  456.         private static void cercaorari()
  457.         {
  458.                 boolean finito = false;
  459.                
  460.                 final String[] TXT_CERCA = { "Indietro", "Cerca per Medico", "Cerca per Data & Ora" };
  461.                 final int IND = 0;
  462.                 final int MED = 1;
  463.                 final int DAT = 2;
  464.                
  465.                 while (!finito)
  466.                         {
  467.                                 int scelta = myLib.util.Menu.crea_menu_numero(TXT_CERCA.length, TXT_CERCA);
  468.                                
  469.                                 switch (scelta)
  470.                                         {
  471.                                                 case IND:
  472.                                                         finito = true;
  473.                                                         break;
  474.                                                 case MED:
  475.                                                         cercaOrariPerMedico();
  476.                                                         break;
  477.                                                 case DAT:
  478.                                                         cercaOrariPerData();
  479.                                                         break;
  480.                                                
  481.                                                 default:
  482.                                                         break;
  483.                                         }
  484.                                
  485.                         }
  486.                
  487.         }
  488.        
  489.         private static void cercaOrariPerMedico()
  490.         {
  491.                 final String NO_RIS = "se non sono stati visualizzati risultati, probabilmente il medico cercato non esiste.";
  492.                
  493.                 final String INTRO_CERCA = "inserire il numero d'albo del medico di cui vedere gli orari: ";
  494.                
  495.                 int query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INTRO_CERCA);
  496.                
  497.                 for (int i = 0; i < corpo_medici.size(); i++)
  498.                         {
  499.                                 if (corpo_medici.get(i).numero_iscrizione_albo == query)
  500.                                         {
  501.                                                 corpo_medici.get(i).visualizzaOrari();
  502.                                         }
  503.                                
  504.                         }
  505.                 System.out.println(NO_RIS);
  506.                
  507.         }
  508.        
  509.         private static void cercaOrariPerData()
  510.         {
  511.                 final String INTRO = "inserire la data da cercare";
  512.                
  513.                 GregorianCalendar ricercaData = myLib.util.Input.leggi_data(INTRO);
  514.                
  515.                 Ora ricercaOra = myLib.typedef.Ora.crea_ora();
  516.                 myLib.typedef.Ora.scala(ricercaOra, false, 0, 30, 60);
  517.                
  518.                 for (int i = 0; i < corpo_medici.size(); i++)
  519.                         {
  520.                                
  521.                                 corpo_medici.get(i).cercaorariMedico(ricercaData, ricercaOra);
  522.                                 myLib.util.Input.pause();
  523.                                
  524.                         }
  525.                
  526.                 boolean ancora = myLib.util.Menu.yes_no_Box("cercare ancora? (S/N) ", false);
  527.                
  528.                 if (ancora == true)
  529.                         {
  530.                                 cercaOrariPerData();
  531.                         }
  532.                
  533.         }
  534.        
  535.         // TODO metti medico disponibile
  536.         public static void eliminaVisite()
  537.         {
  538.                
  539.         }
  540.        
  541.         private static void gestioneVisite()
  542.         {
  543.                 try
  544.                         {
  545.                                 final int INDIETRO = 0;
  546.                                 final int CREA_VISITA = 1;
  547.                                 final int MODIFICA_VISITA = 2;
  548.                                 final int CERCA_VISITA = 3;
  549.                                 final String[] MENU_VISITE = { "indietro", "crea visita", "modifica visita", "cerca visita" };
  550.                                
  551.                                 int scelta;
  552.                                 boolean finito = false;
  553.                                 while (!finito)
  554.                                         {
  555.                                                 scelta = myLib.util.Menu.crea_menu_numero(MENU_VISITE.length, MENU_VISITE);
  556.                                                
  557.                                                 switch (scelta)
  558.                                                         {
  559.                                                                 case INDIETRO:
  560.                                                                         finito = true;
  561.                                                                         break;
  562.                                                                 case CREA_VISITA:
  563.                                                                         creaVisita();
  564.                                                                         break;
  565.                                                                 case MODIFICA_VISITA:
  566.                                                                         menuModificaVisita();
  567.                                                                         break;
  568.                                                                 case CERCA_VISITA:
  569.                                                                         cercaVisite();
  570.                                                                         break;
  571.                                                                
  572.                                                                 default:
  573.                                                                         break;
  574.                                                         }
  575.                                                
  576.                                         }
  577.                         } catch (Exception e)
  578.                         {
  579.                                 System.err.println(ERR_GENERICO + e.getMessage());
  580.                         }
  581.         }
  582.        
  583.         private static void creaVisita() throws Exception
  584.         {
  585.                
  586.                 final String SCALE = "Ora scalata a: %s";
  587.                 final String MEDICO_PREFERITO = "Si ha un medico preferito per la visita? (S/N) ";
  588.                 final String INSERIRE_ORA = "Inserire l'ora per la visita. Verra' scalata alla mezz'ora piu' vicina ";
  589.                 final String INSERIRE_DATA = "Inserire la data preferita per la visita: ";
  590.                 final String NON_ESISTE = "L'utente non esiste. rifare? (S/N)";
  591.                 final String INTRO = "Inserimento nuova visita\n";
  592.                 final String ID = "inserire ora l'ID utente che deve fare la visita: ";
  593.                 final String INS_MOTIVO = "Inserire il motivo della visita: ";
  594.                
  595.                
  596.                 Object[] INFORMAZIONI;
  597.                
  598.                 System.out.println(INTRO);
  599.                 Integer idUtenteScelto = 0;
  600.                 Integer indexUtente;
  601.                 boolean finito = false;
  602.                 while (!finito)
  603.                         {
  604.                                 idUtenteScelto = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, ID);
  605.                                 indexUtente = getIndexUtente(idUtenteScelto);
  606.                                 if (indexUtente == null)
  607.                                         {
  608.                                                 if (myLib.util.Menu.yes_no_Box(NON_ESISTE, false))
  609.                                                
  610.                                                         {
  611.                                                                 finito = false;
  612.                                                         }
  613.                                                 else
  614.                                                         {
  615.                                                                 finito = true;
  616.                                                         }
  617.                                         }
  618.                                 else
  619.                                         {
  620.                                                 if (!finito)
  621.                                                         {
  622.                                                                
  623.                                                                 /**
  624.                                                                  *
  625.                                                                  * continua immissione utente
  626.                                                                  */
  627.                                                                 String tempMotivo;
  628.                                                                 if (DEBUG) tempMotivo = "a";
  629.                                                                 else
  630.                                                                         tempMotivo = myLib.util.Input.leggi_stringa(INS_MOTIVO);
  631.                                                                
  632.                                                                 GregorianCalendar tempData = myLib.util.Input.leggi_data(INSERIRE_DATA);
  633.                                                                
  634.                                                                 Ora tempOra = myLib.typedef.Ora.crea_ora(INSERIRE_ORA);
  635.                                                                 myLib.typedef.Ora.scala(tempOra, false, 0, 30, 60);
  636.                                                                 System.out.println(ORA_SCALATA + tempOra.toString());
  637.                                                                
  638.                                                                 if (myLib.util.Menu.yes_no_Box(MEDICO_PREFERITO, false))
  639.                                                                         {
  640.                                                                                 /**
  641.                                                                                  * un medico
  642.                                                                                  */
  643.                                                                                
  644.                                                                                 int medicoRichiesto;
  645.                                                                                 Integer index = null;
  646.                                                                                
  647.                                                                                 while (index == null)
  648.                                                                                         {
  649.                                                                                                 medicoRichiesto = myLib.util.Input.leggi_int();
  650.                                                                                                 index = getIndexMedico(medicoRichiesto);
  651.                                                                                                
  652.                                                                                                 if (index == null)
  653.                                                                                                         {
  654.                                                                                                                 if (!myLib.util.Menu.yes_no_Box("Nessun medico. Rifare? ", false))
  655.                                                                                                                         {
  656.                                                                                                                                 finito = false;
  657.                                                                                                                         }
  658.                                                                                                                
  659.                                                                                                         }
  660.                                                                                                
  661.                                                                                         }
  662.                                                                                
  663.                                                                                 if (!finito)
  664.                                                                                         {
  665.                                                                                                 INFORMAZIONI=cercaOrarioUnMedico(index, tempData, tempOra);
  666.                                                                                                
  667.                                                                                                 if ((boolean)INFORMAZIONI[DISPONIBILE])
  668.                                                                                                         {
  669.                                                                                                                
  670.                                                                                                                 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]);
  671.                                                                                                                 finito=true;
  672.                                                                                                         }
  673.                                                                                                 else
  674.                                                                                                         {
  675.                                                                                                                
  676.                                                                                                                  INFORMAZIONI=cercaOrarioTraTuttiMedici(tempData, tempOra);
  677.                                                                                                                
  678.                                                                                                                 if (proponiMediciEOrari((int)INFORMAZIONI[MEDICO_INDEX], (GregorianCalendar)INFORMAZIONI[GIORNO_VALORE], (Ora)INFORMAZIONI[ORA_VAALORE]))
  679.                                                                                                                         {
  680.                                                                                                                                
  681.                                                                                                                                 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]);
  682.                                                                                                                                 finito=true;
  683.                                                                                                                         }
  684.                                                                                                                 else
  685.                                                                                                                         {
  686.                                                                                                                                 /**
  687.                                                                                                                                  * TODO RISCELTA
  688.                                                                                                                                  *
  689.                                                                                                                                  */
  690.                                                                                                                                 finito = true;
  691.                                                                                                                         }
  692.                                                                                                                
  693.                                                                                                         }
  694.                                                                                                
  695.                                                                                         }
  696.                                                                                
  697.                                                                         }
  698.                                                                 else
  699.                                                                         {
  700.                                                                                 /**
  701.                                                                                  *
  702.                                                                                  * tutti medici
  703.                                                                                  *
  704.                                                                                  */
  705.                                                                                
  706.                                                                                 INFORMAZIONI = cercaOrarioTraTuttiMedici(tempData, tempOra);
  707.                                                                                 /**
  708.                                                                                  *
  709.                                                                                  * se ha trovato uno slot per la tale
  710.                                                                                  * data ora
  711.                                                                                  *
  712.                                                                                  */
  713.                                                                                 if ((boolean) INFORMAZIONI[DISPONIBILE] == true)
  714.                                                                                         {
  715.                                                                                                 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]);
  716.                                                                                         }
  717.                                                                                
  718.                                                                                 /**
  719.                                                                                  *
  720.                                                                                  * se non ha trovato, propone il primo
  721.                                                                                  *
  722.                                                                                  */
  723.                                                                                 if ((boolean) INFORMAZIONI[DISPONIBILE] == false)
  724.                                                                                         {
  725.                                                                                                 if (proponiMediciEOrari((int) INFORMAZIONI[MEDICO_INDEX], (GregorianCalendar) INFORMAZIONI[GIORNO_VALORE], (Ora) INFORMAZIONI[ORA_VAALORE]))
  726.                                                                                                         {
  727.                                                                                                                 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]);
  728.                                                                                                                 finito = true;
  729.                                                                                                         }
  730.                                                                                                
  731.                                                                                                 else
  732.                                                                                                         {
  733.                                                                                                                 finito = true;
  734.                                                                                                         }
  735.                                                                                                
  736.                                                                                         }
  737.                                                                                
  738.                                                                                 /**
  739.                                                                                  *
  740.                                                                                  * non ha trovato niente
  741.                                                                                  *
  742.                                                                                  */
  743.                                                                                 if (INFORMAZIONI[DISPONIBILE] == null)
  744.                                                                                         {
  745.                                                                                                 System.out.println(NESSUN_RISULTATO_TROVATO_NE_DA_CONSIGLIARE);
  746.                                                                                                
  747.                                                                                                 return;
  748.                                                                                         }
  749.                                                                         }
  750.                                                                
  751.                                                         }
  752.                                                
  753.                                         }
  754.                         }
  755.                
  756.         }
  757.        
  758.         private static void aggiungiVisita(int IDutente, String motivo, Integer IDmedico, int indexMedico, GregorianCalendar data, Ora ora, int indexData, int indexOra)
  759.         {
  760.                
  761.                 cache_visite.add(new Visita(IDutente, motivo, IDmedico, data, ora));
  762.                
  763.                 corpo_medici.get(indexMedico).orari_visita.get(indexData).orari[indexOra].setStato_slot(Stato_visita_slot.PRENOTATA);
  764.                 corpo_medici.get(indexMedico).orari_visita.get(indexData).orari[indexOra].id_visita = cache_visite.get(cache_visite.size() - 1).getId_visita();
  765.                
  766.         }
  767.        
  768.  
  769.        
  770.         private static Object[] cercaOrarioUnMedico(int indice, GregorianCalendar data, Ora ora)
  771.        
  772.         {
  773.                
  774.                
  775.                
  776.                
  777.                
  778.                
  779.         }
  780.        
  781.         /**
  782.          *
  783.          *
  784.          * se quello fornito esiste, si ritornano gli stessi valori e true finale
  785.          * con indici corretti se non trovato si ritorna false e un consiglio, il
  786.          * piu vicino se nessun consiglio ritorna null finale e prima non importa
  787.          *
  788.          * usare costanti per accedere a campi
  789.          *
  790.          *
  791.          * @return
  792.          */
  793.         private static Object[] cercaOrarioTraTuttiMedici(GregorianCalendar dataRichiesta, Ora oraRichiesta)
  794.         {
  795.                 Object[] ritorno = new Object[INFORMAZIONI_DIMENSIONE];
  796.                
  797.                 /**
  798.                  * prima cerca per gli orari selezionati
  799.                  *
  800.                  */
  801.                 for (int i = 0; i < corpo_medici.size(); i++)
  802.                         {
  803.                                 for (int j = 0; j < corpo_medici.get(i).orari_visita.size(); j++)
  804.                                         {
  805.                                                 for (int k = 0; i < corpo_medici.get(i).orari_visita.get(j).orari.length; k++)
  806.                                                         {
  807.                                                                
  808.                                                                 if (
  809.                                                                
  810.                                                                 (corpo_medici.get(i).orari_visita.get(j).data.equals(dataRichiesta))
  811.                                                                
  812.                                                                 &&
  813.                                                                
  814.                                                                 (corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario().equals(oraRichiesta))
  815.                                                                
  816.                                                                 &&
  817.                                                                
  818.                                                                 (corpo_medici.get(i).orari_visita.get(j).orari[k].getStato_slot().equals(Stato_visita_slot.PRENOTABILE))
  819.                                                                
  820.                                                                 )
  821.                                                                
  822.                                                                         {
  823.                                                                                 ritorno[MEDICO_ID] = corpo_medici.get(i).numero_iscrizione_albo;
  824.                                                                                 ritorno[MEDICO_INDEX] = new Integer(i);
  825.                                                                                 ritorno[GIORNO_VALORE] = myLib.typedef.Data.clonaData(dataRichiesta);
  826.                                                                                 ritorno[GIORNO_INDEX] = new Integer(j);
  827.                                                                                 ritorno[ORA_VAALORE] = myLib.typedef.Ora.clone(oraRichiesta);
  828.                                                                                 ritorno[ORA_INDEX] = new Integer(k);
  829.                                                                                 ritorno[DISPONIBILE] = new Boolean(true);
  830.                                                                                
  831.                                                                                 return ritorno;
  832.                                                                                
  833.                                                                                 /**
  834.                                                                                  *
  835.                                                                                  *
  836.                                                                                  * TODO questo cerca solo il primo
  837.                                                                                  * risultato, fare che cerca anche il
  838.                                                                                  * minore
  839.                                                                                  */
  840.                                                                                
  841.                                                                         }
  842.                                                         }
  843.                                                
  844.                                         }
  845.                                
  846.                         }
  847.                
  848.                 /**
  849.                  * poi cerca tra tutti, il consiglio
  850.                  *
  851.                  */
  852.                
  853.                 ritorno[DISPONIBILE] = new Boolean(false);
  854.                
  855.                 /**
  856.                  * serve per cercare il minore
  857.                  *
  858.                  */
  859.                 boolean primorisultato = true;
  860.                 for (int i = 0; i < corpo_medici.size(); i++)
  861.                         {
  862.                                 for (int j = 0; j < corpo_medici.get(i).orari_visita.size(); j++)
  863.                                         {
  864.                                                 for (int k = 0; i < corpo_medici.get(i).orari_visita.get(j).orari.length; k++)
  865.                                                         {
  866.                                                                
  867.                                                                 if ((corpo_medici.get(i).orari_visita.get(j).orari[k].getStato_slot().equals(Stato_visita_slot.PRENOTABILE)) && (primorisultato))
  868.                                                                         {
  869.                                                                                 ritorno[MEDICO_ID] = corpo_medici.get(i).numero_iscrizione_albo;
  870.                                                                                 ritorno[MEDICO_INDEX] = new Integer(i);
  871.                                                                                
  872.                                                                                 ritorno[GIORNO_VALORE] = corpo_medici.get(i).orari_visita.get(j).data;
  873.                                                                                 ritorno[GIORNO_INDEX] = new Integer(j);
  874.                                                                                
  875.                                                                                 ritorno[ORA_VAALORE] = corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario();
  876.                                                                                 ritorno[ORA_INDEX] = new Integer(k);
  877.                                                                                 primorisultato = false;
  878.                                                                                
  879.                                                                         }
  880.                                                                
  881.                                                                 if ((corpo_medici.get(i).orari_visita.get(j).orari[k].getStato_slot().equals(Stato_visita_slot.PRENOTABILE)) && (!primorisultato))
  882.                                                                         {
  883.                                                                                 if (corpo_medici.get(i).orari_visita.get(j).data.before(ritorno[GIORNO_VALORE]))
  884.                                                                                         {
  885.                                                                                                
  886.                                                                                                 ritorno[MEDICO_ID] = corpo_medici.get(i).numero_iscrizione_albo;
  887.                                                                                                 ritorno[MEDICO_INDEX] = new Integer(i);
  888.                                                                                                
  889.                                                                                                 ritorno[GIORNO_VALORE] = corpo_medici.get(i).orari_visita.get(j).data;
  890.                                                                                                 ritorno[GIORNO_INDEX] = new Integer(j);
  891.                                                                                                
  892.                                                                                                 ritorno[ORA_VAALORE] = corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario();
  893.                                                                                                 ritorno[ORA_INDEX] = new Integer(k);
  894.                                                                                                
  895.                                                                                         }
  896.                                                                                 else
  897.                                                                                         {
  898.                                                                                                 if (corpo_medici.get(i).orari_visita.get(j).orari[k].orario.relazione((Ora) ritorno[ORA_VAALORE]) == Ora.CONFRONTA_ORE_ANTECEDENTE)
  899.                                                                                                         {
  900.                                                                                                                
  901.                                                                                                                 ritorno[MEDICO_ID] = corpo_medici.get(i).numero_iscrizione_albo;
  902.                                                                                                                 ritorno[MEDICO_INDEX] = new Integer(i);
  903.                                                                                                                
  904.                                                                                                                 ritorno[GIORNO_VALORE] = corpo_medici.get(i).orari_visita.get(j).data;
  905.                                                                                                                 ritorno[GIORNO_INDEX] = new Integer(j);
  906.                                                                                                                
  907.                                                                                                                 ritorno[ORA_VAALORE] = corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario();
  908.                                                                                                                 ritorno[ORA_INDEX] = new Integer(k);
  909.                                                                                                                
  910.                                                                                                         }
  911.                                                                                                
  912.                                                                                         }
  913.                                                                                
  914.                                                                         }
  915.                                                                
  916.                                                         }
  917.                                                
  918.                                         }
  919.                         }
  920.                
  921.                 if (!primorisultato)
  922.                         {
  923.                                 return ritorno;
  924.                                
  925.                         }
  926.                 else
  927.                         {
  928.                                 /**
  929.                                  *
  930.                                  * non c'è niente :(
  931.                                  *
  932.                                  */
  933.                                
  934.                                 ritorno[DISPONIBILE] = null;
  935.                                 return ritorno;
  936.                         }
  937.                
  938.         }
  939.        
  940.         /**
  941.          * propone una stringa col medico
  942.          *
  943.          * @param indiceMedico
  944.          * @param dataProposta
  945.          * @param oraProposta
  946.          * @return si no
  947.          */
  948.         private static boolean proponiMediciEOrari(int indiceMedico, GregorianCalendar dataProposta, Ora oraProposta)
  949.         {
  950.                 // for (int i=0; i<corpo_medici.size();i++)
  951.                 // {
  952.                 //
  953.                 // for (int j=0; i<corpo_medici.get(i).orari_visita.size();i++)
  954.                 // {
  955.                 // for (int k=0;
  956.                 // i<corpo_medici.get(i).orari_visita.get(j).orari.length;i++)
  957.                 // {
  958.                 //
  959.                 // if (
  960.                 // corpo_medici.get(i).orari_visita.get(j).orari[k].getOrario().equals(oraProposta)
  961.                 //
  962.                 // &&
  963.                 //
  964.                 // corpo_medici.get(i).orari_visita.get(j).data.equals(dataProposta)
  965.                 //
  966.                 // &&
  967.                 //
  968.                 // corpo_medici.get(i).orari_visita.get(j).orari[k].getStato_slot().equals(Stato_visita_slot.PRENOTABILE)
  969.                 //
  970.                 // )
  971.                 // {
  972.                 // /**
  973.                 // *
  974.                 // * todo
  975.                 // * NO SE PROPONE DEVE SOLO SCRIVERE
  976.                 // */
  977.                 // //return new Integer[]={corpo_medici.get(i).numero_iscrizione_albo,
  978.                 // corpo_medici.get(i).orari_visita.get(j).data }
  979.                 //
  980.                 // // xvsd;3
  981.                 // System.out.println("Ecco il prossimo risultato trovato:");
  982.                 // System.out.println("medico: " +
  983.                 // corpo_medici.get(i).getInfoBase()+"\ngiorno" +
  984.                 // myLib.util.Output.formatDate(corpo_medici.get(i).orari_visita.get(j).data)
  985.                 // + "\nora: " +
  986.                 // corpo_medici.get(i).orari_visita.get(j).orari[k].orario.toString());
  987.                 // return;
  988.                 // }
  989.                 //
  990.                 // }
  991.                 //
  992.                 // }
  993.                
  994.                 System.out.println("medico proposto:" + corpo_medici.get(indiceMedico).getInfoBase() + "data proposta: " + myLib.util.Output.formatDate(dataProposta) + "ora proposta: " + oraProposta.toString());
  995.                 return (myLib.util.Menu.yes_no_Box("accettare? (S/N", true));
  996.                
  997.                 //
  998.                 // }
  999.                 //
  1000.                 //
  1001.                 // System.out.println("nessun risultato");
  1002.                
  1003.         }
  1004.        
  1005.         /**
  1006.          * dato l'id dell'utente, ne ritorna l'indice nella lista, altrimenti null
  1007.          *
  1008.          * @return
  1009.          */
  1010.         private static Integer getIndexUtente(int id)
  1011.         {
  1012.                 for (int i = 0; i < clienti_clinica.size(); i++)
  1013.                         {
  1014.                                 if (clienti_clinica.get(i).id_utente == id) return i;
  1015.                         }
  1016.                 return null;
  1017.                
  1018.         }
  1019.        
  1020.         private static void menuModificaVisita()
  1021.         {
  1022.                 final String INS_ID = "inserire ID";
  1023.                
  1024.                 boolean finito = false;
  1025.                 int scelta;
  1026.                 int query;
  1027.                 final int INDIETRO = 0;
  1028.                 final int CONCLUDI = 1;
  1029.                 final int MODIFICA = 2;
  1030.                 final int ELIMINA = 3;
  1031.                
  1032.                 final String[] MENU_MODIFICA = { "indietro", "concludi visita", "modifica visita", "elimina visita" };
  1033.                
  1034.                 while (!finito)
  1035.                         {
  1036.                                 scelta = myLib.util.Menu.crea_menu_numero(MENU_MODIFICA.length, MENU_MODIFICA);
  1037.                                
  1038.                                 switch (scelta)
  1039.                                         {
  1040.                                                 case INDIETRO:
  1041.                                                         finito = true;
  1042.                                                         break;
  1043.                                                 case CONCLUDI:
  1044.                                                        
  1045.                                                         query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
  1046.                                                        
  1047.                                                         concludiVisita(query);
  1048.                                                         break;
  1049.                                                 case MODIFICA:
  1050.                                                        
  1051.                                                         query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
  1052.                                                        
  1053.                                                         modificaVisita(query);
  1054.                                                         break;
  1055.                                                 case ELIMINA:
  1056.                                                        
  1057.                                                         query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
  1058.                                                         eliminaVisita(query);
  1059.                                                         break;
  1060.                                                
  1061.                                                 default:
  1062.                                                         break;
  1063.                                         }
  1064.                                
  1065.                         }
  1066.                
  1067.         }
  1068.        
  1069.         // ok
  1070.         private static void concludiVisita(int id)
  1071.         {
  1072.                 try
  1073.                         {
  1074.                                 String temp_referto;
  1075.                                 String temp_prescrizione;
  1076.                                 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";
  1077.                                 final String INS_REF = "inserire ora il referto";
  1078.                                 final String INS_PRESCR = "inserire ora la prescrizione";
  1079.                                 final String ANNULL = "inserire ora la prescrizione";
  1080.                                
  1081.                                 System.out.println(AVVISO);
  1082.                                
  1083.                                 temp_referto = myLib.util.Input.leggi_stringa(INS_REF);
  1084.                                 temp_prescrizione = myLib.util.Input.leggi_stringa(INS_PRESCR);
  1085.                                
  1086.                                 if ((temp_referto.isEmpty()) && (temp_prescrizione.isEmpty()))
  1087.                                         {
  1088.                                                 System.out.println(ANNULL);
  1089.                                         }
  1090.                                 else
  1091.                                         {
  1092.                                                 cache_visite.get(getIndexVisita(id)).setStato_della_visita(Stato_visita.CONCLUSA);
  1093.                                                 cache_visite.get(getIndexVisita(id)).setReferto(temp_referto);
  1094.                                                 cache_visite.get(getIndexVisita(id)).setPrescrizione(temp_prescrizione);
  1095.                                         }
  1096.                         } catch (Exception e)
  1097.                         {
  1098.                                 System.err.println(ERR_GENERICO + e.getMessage());
  1099.                         }
  1100.         }
  1101.        
  1102.         // ok
  1103.        
  1104.         private static void modificaVisita(int id)
  1105.         {
  1106.                 try
  1107.                         {
  1108.                                 final String INTRO = "quale campo modificare?";
  1109.                                 final String[] CAMPI = { "indietro", "motivo", "referto", "prescrizione" };
  1110.                                
  1111.                                 final int INDIETRO = 0;
  1112.                                 final int MOTIVO = 1;
  1113.                                 final int REFERTO = 2;
  1114.                                 final int PRESCRI = 3;
  1115.                                
  1116.                                 int scelta;
  1117.                                 boolean finito = false;
  1118.                                
  1119.                                 while (!finito)
  1120.                                         {
  1121.                                                 System.out.println(INTRO);
  1122.                                                 scelta = myLib.util.Menu.crea_menu_numero(CAMPI.length, CAMPI);
  1123.                                                
  1124.                                                 switch (scelta)
  1125.                                                         {
  1126.                                                                 case INDIETRO:
  1127.                                                                         finito = true;
  1128.                                                                         break;
  1129.                                                                
  1130.                                                                 case MOTIVO:
  1131.                                                                        
  1132.                                                                         String temp_motivo;
  1133.                                                                        
  1134.                                                                         temp_motivo = myLib.util.Input.leggi_stringa("inserire nuovo motivo. vuoto per annullare");
  1135.                                                                        
  1136.                                                                         if (!temp_motivo.isEmpty())
  1137.                                                                                 {
  1138.                                                                                         cache_visite.get(getIndexVisita(id)).setMotivo(temp_motivo);
  1139.                                                                                 }
  1140.                                                                        
  1141.                                                                         break;
  1142.                                                                 case REFERTO:
  1143.                                                                         String temp_referto;
  1144.                                                                        
  1145.                                                                         temp_referto = myLib.util.Input.leggi_stringa("inserire nuovo referto. vuoto per annullare");
  1146.                                                                        
  1147.                                                                         if (!temp_referto.isEmpty())
  1148.                                                                                 {
  1149.                                                                                         cache_visite.get(getIndexVisita(id)).setMotivo(temp_referto);
  1150.                                                                                         cache_visite.get(getIndexVisita(id)).setStato_della_visita(Stato_visita.REFERTATA);
  1151.                                                                                 }
  1152.                                                                         break;
  1153.                                                                 case PRESCRI:
  1154.                                                                         String temp_prescriz;
  1155.                                                                        
  1156.                                                                         temp_prescriz = myLib.util.Input.leggi_stringa("inserire nuova prescrizione. vuoto per annullare");
  1157.                                                                        
  1158.                                                                         if (!temp_prescriz.isEmpty())
  1159.                                                                                 {
  1160.                                                                                         cache_visite.get(getIndexVisita(id)).setMotivo(temp_prescriz);
  1161.                                                                                 }
  1162.                                                                         break;
  1163.                                                                
  1164.                                                                 default:
  1165.                                                                         break;
  1166.                                                         }
  1167.                                                
  1168.                                         }
  1169.                         } catch (Exception e)
  1170.                         {
  1171.                                 System.err.println(ERR_GENERICO + e.getMessage());
  1172.                         }
  1173.                
  1174.         }
  1175.        
  1176.         // ok
  1177.         private static void eliminaVisita(int id)
  1178.         {
  1179.                 try
  1180.                         {
  1181.                                 boolean scelta = false;
  1182.                                 final String CONF = "l'azione non può essere annullata. continuare? (s/n) ";
  1183.                                
  1184.                                 scelta = myLib.util.Menu.yes_no_Box(CONF, false);
  1185.                                
  1186.                                 if (scelta = true)
  1187.                                         {
  1188.                                                
  1189.                                                 cache_visite.remove(getIndexVisita(id));
  1190.                                         }
  1191.                         } catch (Exception e)
  1192.                         {
  1193.                                 System.err.println(ERR_GENERICO + e.getMessage());
  1194.                         }
  1195.         }
  1196.        
  1197.         /**
  1198.          * ritorna l'indice nella lista visite, dato un id univoco
  1199.          *
  1200.          * @param _id
  1201.          * @return
  1202.          * @throws Exception
  1203.          */
  1204.         protected static int getIndexVisita(int _id) throws Exception
  1205.         {
  1206.                 for (int i = 0; i < cache_visite.size(); i++)
  1207.                         {
  1208.                                 if (cache_visite.get(i).matchID(_id)) return i;
  1209.                         }
  1210.                 throw new Exception(INDEX_ERROR);
  1211.         }
  1212.        
  1213.         /**
  1214.          * dato il numero albo di un medico, ritorna l'indice nella lista, se non
  1215.          * trovato null
  1216.          *
  1217.          * @param id
  1218.          * @return
  1219.          */
  1220.         private static Integer getIndexMedico(int id)
  1221.         {
  1222.                 final int NUM_ALB = 8;
  1223.                
  1224.                 for (int i = 0; i < corpo_medici.size(); i++)
  1225.                         {
  1226.                                 if (corpo_medici.get(i).matchcampo(NUM_ALB, id)) return i;
  1227.                         }
  1228.                 return null;
  1229.         }
  1230.        
  1231.         private static void cercaVisite()
  1232.         {
  1233.                 try
  1234.                         {
  1235.                                 final String PROMPT_QUERY = "inserire l'ID da cercare: ";
  1236.                                
  1237.                                 boolean finito = false;
  1238.                                 int scelta;
  1239.                                 int query;
  1240.                                
  1241.                                 /**
  1242.                                  * TODO RICERCA PER DATA NON RICHIEDE MOLTO
  1243.                                  *
  1244.                                  */
  1245.                                 final String[] MENU_CERCA = { "indietro", "cerca per utente", "cerca per medico" };
  1246.                                
  1247.                                 final int INDIETRO = 0;
  1248.                                 final int RICERCA_VISITA_UTENTE = 1;
  1249.                                 final int RICERCA_VISITA_MEDICO = 2;
  1250.                                 while (!finito)
  1251.                                         {
  1252.                                                 scelta = myLib.util.Menu.crea_menu_numero(MENU_CERCA.length, MENU_CERCA);
  1253.                                                
  1254.                                                 switch (scelta)
  1255.                                                         {
  1256.                                                                 case INDIETRO:
  1257.                                                                         finito = true;
  1258.                                                                         break;
  1259.                                                                
  1260.                                                                 case RICERCA_VISITA_UTENTE:
  1261.                                                                        
  1262.                                                                         query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, PROMPT_QUERY);
  1263.                                                                         visualizzaVisite(cercaVisita(RICERCA_VISITA_UTENTE, query));
  1264.                                                                         break;
  1265.                                                                
  1266.                                                                 case RICERCA_VISITA_MEDICO:
  1267.                                                                        
  1268.                                                                         query = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, PROMPT_QUERY);
  1269.                                                                        
  1270.                                                                         visualizzaVisite(cercaVisita(RICERCA_VISITA_MEDICO, query));
  1271.                                                                         break;
  1272.                                                                
  1273.                                                                 default:
  1274.                                                                         break;
  1275.                                                         }
  1276.                                                
  1277.                                         }
  1278.                         } catch (Exception e)
  1279.                         {
  1280.                                 System.err.println(ERR_GENERICO + e.getMessage());
  1281.                                
  1282.                         }
  1283.         }
  1284.        
  1285.         private static ArrayList<Visita> cercaVisita(int tipo_ricerca, int query) throws Exception
  1286.         {
  1287.                 final int RICERCA_VISITA_UTENTE = 1;
  1288.                 final int RICERCA_VISITA_MEDICO = 2;
  1289.                
  1290.                 ArrayList<Visita> ritorno = new ArrayList<Visita>();
  1291.                
  1292.                 if (tipo_ricerca == RICERCA_VISITA_UTENTE)
  1293.                         {
  1294.                                
  1295.                                 for (int i = 0; i < cache_visite.size(); i++)
  1296.                                         {
  1297.                                                 if (cache_visite.get(i).matchUtente(query))
  1298.                                                         {
  1299.                                                                 ritorno.add(cache_visite.get(i));
  1300.                                                         }
  1301.                                         }
  1302.                                 return ritorno;
  1303.                         }
  1304.                 if (tipo_ricerca == RICERCA_VISITA_MEDICO)
  1305.                         {
  1306.                                 for (int i = 0; i < cache_visite.size(); i++)
  1307.                                         {
  1308.                                                 if (cache_visite.get(i).matchMedico(query))
  1309.                                                         {
  1310.                                                                 ritorno.add(cache_visite.get(i));
  1311.                                                         }
  1312.                                         }
  1313.                                 return ritorno;
  1314.                         }
  1315.                 throw new Exception(CERCA_ERR);
  1316.                
  1317.         }
  1318.        
  1319.         private static void visualizzaVisite(ArrayList<Visita> input)
  1320.         {
  1321.                 final String INTRO_VISITE = "Visite:\n\tmedico\tutente\tstato\tdata\n\t";
  1322.                
  1323.                 if (input.size() == 0)
  1324.                         {
  1325.                                 System.out.println(NIENTE);
  1326.                         }
  1327.                 else
  1328.                         {
  1329.                                
  1330.                                 for (int i = 0; i < input.size(); i++)
  1331.                                         {
  1332.                                                 if ((i % myLib.util.Output.MAX_RIGHE) == 0)
  1333.                                                         {
  1334.                                                                 myLib.util.Input.pause(PROSSIMA_PAGINA);
  1335.                                                         }
  1336.                                                 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");
  1337.                                         }
  1338.                                
  1339.                         }
  1340.         }
  1341.        
  1342.         private static void visualizzaEModificaDati()
  1343.         {
  1344.                 /**
  1345.                  * TODO VISUALIZZA STATISTICHE VISITE CHE NON E DIFFICILE
  1346.                  *
  1347.                  *
  1348.                  *
  1349.                  */
  1350.                
  1351.                 final String[] TESTI_MENU = { "indietro", "visualizza utenti", "visualizza medici", "modifica utente", "modifica medico", "cerca utente", "cerca medico" };
  1352.                 final int COM_INDIETRO = 0;
  1353.                 final int COM_VISU_UTENTI = 1;
  1354.                 final int COM_VISU_MEDICI = 2;
  1355.                 final int COM_MOD_UTENTE = 3;
  1356.                 final int COM_MOD_MEDICO = 4;
  1357.                 final int COM_CERCA_UTENTE = 5;
  1358.                 final int COM_CERCA_MEDICO = 6;
  1359.                
  1360.                 boolean uscita = false;
  1361.                 int scelta;
  1362.                 while (!uscita)
  1363.                         {
  1364.                                 scelta = myLib.util.Menu.crea_menu_numero(TESTI_MENU.length, TESTI_MENU);
  1365.                                
  1366.                                 switch (scelta)
  1367.                                         {
  1368.                                                 case COM_INDIETRO:
  1369.                                                         uscita = true;
  1370.                                                         break;
  1371.                                                 case COM_VISU_UTENTI:
  1372.                                                         visualizzautenti();// ok
  1373.                                                         break;
  1374.                                                 case COM_VISU_MEDICI:
  1375.                                                         visualizzamedici();// ok
  1376.                                                         break;
  1377.                                                 case COM_MOD_UTENTE:
  1378.                                                         try
  1379.                                                                 {
  1380.                                                                         modificautenti();// ok
  1381.                                                                 } catch (NullPointerException e)
  1382.                                                                 {
  1383.                                                                         System.err.println(ERR_GENERICO + e.getMessage());
  1384.                                                                 }
  1385.                                                         break;
  1386.                                                 case COM_MOD_MEDICO:
  1387.                                                        
  1388.                                                         modificamedici();
  1389.                                                         // ok
  1390.                                                         break;
  1391.                                                 case COM_CERCA_UTENTE:
  1392.                                                         cercautenti(); // ok
  1393.                                                         break;
  1394.                                                 case COM_CERCA_MEDICO:
  1395.                                                        
  1396.                                                         cercamedici();// ok
  1397.                                                         break;
  1398.                                                
  1399.                                                 default:
  1400.                                                         break;
  1401.                                         }
  1402.                         }
  1403.         }
  1404.        
  1405.         private static void visualizzaBase(ArrayList<Visita> in)
  1406.         {
  1407.                
  1408.         }
  1409.        
  1410.         private static void visualizzaUtente(Utente risultato, ArrayList<Visita> elenco)
  1411.         {
  1412.                 final String INTRO_UTENTE = "Dati utente:\n\tcodice fiscale\tcognome\tnome\n\t";
  1413.                
  1414.                 final String INTRO_VISITE = "visite prenotate e concluse:\n\tdata\tmedico\treferto\tprescrizione\n\t";
  1415.                
  1416.                 System.out.println(INTRO_UTENTE + risultato.codice_fiscale + "\t" + risultato.cognome + "\t" + risultato.nome);
  1417.                
  1418.                 myLib.util.Input.pause(PROSSIMA_PAGINA);
  1419.                
  1420.                 if (elenco.size() == 0)
  1421.                         {
  1422.                                 System.out.println(NIENTE);
  1423.                         }
  1424.                 else
  1425.                         {
  1426.                                 System.out.println(INTRO_VISITE);
  1427.                                 for (int i = 0; i < elenco.size(); i++)
  1428.                                         {
  1429.                                                 /**
  1430.                                                  * ogni 25 righe si ferma
  1431.                                                  *
  1432.                                                  */
  1433.                                                 if ((i % myLib.util.Output.MAX_RIGHE) == 0)
  1434.                                                         {
  1435.                                                                 myLib.util.Input.pause(PROSSIMA_PAGINA);
  1436.                                                         }
  1437.                                                 if (elenco.get(i).getStato_della_visita() == Stato_visita.PRENOTATA)
  1438.                                                         {
  1439.                                                                 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");
  1440.                                                         }
  1441.                                                
  1442.                                         }
  1443.                         }
  1444.         }
  1445.        
  1446.         /**
  1447.          * aggiungere filtri di ricerca direttamente nella codifica
  1448.          *
  1449.          * @param risultato
  1450.          * @param elenco
  1451.          */
  1452.         private static void visualizzaMedico(Medico risultato, ArrayList<Visita> elenco)
  1453.         {
  1454.                 final String INTRO_MEDICO = "Dati medico:\n\talbo\tcognome\tnome\n\t";
  1455.                
  1456.                 final String INTRO_VISITE = "visite prenotate:\n\tdata\tmotivo\n\t";
  1457.                
  1458.                 System.out.println(risultato.numero_iscrizione_albo + "\t" + risultato.cognome + "\t" + risultato.nome);
  1459.                
  1460.                 myLib.util.Input.pause(PROSSIMA_PAGINA);
  1461.                
  1462.                 if (elenco.size() == 0)
  1463.                         {
  1464.                                 System.out.println(NIENTE);
  1465.                         }
  1466.                 else
  1467.                         {
  1468.                                 for (int i = 0; i < elenco.size(); i++)
  1469.                                         {
  1470.                                                 /**
  1471.                                                  * ogni 25 righe si ferma
  1472.                                                  *
  1473.                                                  */
  1474.                                                 if ((i % myLib.util.Output.MAX_RIGHE) == 0)
  1475.                                                         {
  1476.                                                                 myLib.util.Input.pause(PROSSIMA_PAGINA);
  1477.                                                         }
  1478.                                                 if (elenco.get(i).getStato_della_visita() == Stato_visita.PRENOTATA)
  1479.                                                         {
  1480.                                                                 System.out.println(myLib.util.Output.formatDate(elenco.get(i).getData()) + "\t" + elenco.get(i).getMotivo() + "\n\t");
  1481.                                                         }
  1482.                                                
  1483.                                         }
  1484.                         }
  1485.                
  1486.         }
  1487.        
  1488.         private static void visualizzautenti()
  1489.         {
  1490.                 try
  1491.                         {
  1492.                                 int ricerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
  1493.                                 visualizzaUtente((Utente) ricercaUnoID(CERCA_UTENTE_SINGOLO, ricerca), cercaVisite(CERCA_UTENTE_VISITE, ricerca));
  1494.                         } catch (Exception e)
  1495.                         {
  1496.                                 System.err.println(ERR_GENERICO + e.getMessage());
  1497.                         }
  1498.         }
  1499.        
  1500.         private static void visualizzamedici()
  1501.         {
  1502.                 try
  1503.                         {
  1504.                                 int ricerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INS_ID);
  1505.                                 visualizzaMedico((Medico) ricercaUnoID(CERCA_MEDICO_SINGOLO, ricerca), cercaVisite(CERCA_MEDICO_VISITE, ricerca));
  1506.                         } catch (Exception e)
  1507.                         {
  1508.                                 System.out.println(ERR_GENERICO + e.getMessage());
  1509.                         }
  1510.         }
  1511.        
  1512.         private static ArrayList<Visita> cercaVisite(int tipo_ricerca, int id_da_cercare) throws Exception
  1513.         {
  1514.                 final String ERR = "nessun risultato: visite";
  1515.                
  1516.                 if (tipo_ricerca == CERCA_MEDICO_VISITE)
  1517.                         {
  1518.                                 ArrayList<Visita> ritorno = new ArrayList<Visita>();
  1519.                                
  1520.                                 for (int i = 0; i < cache_visite.size(); i++)
  1521.                                         {
  1522.                                                 if (cache_visite.get(i).matchMedico(id_da_cercare))
  1523.                                                         {
  1524.                                                                 ritorno.add(cache_visite.get(i));
  1525.                                                         }
  1526.                                         }
  1527.                                 return ritorno;
  1528.                         }
  1529.                 if (tipo_ricerca == CERCA_UTENTE_VISITE)
  1530.                         {
  1531.                                 ArrayList<Visita> ritorno = new ArrayList<Visita>();
  1532.                                
  1533.                                 for (int i = 0; i < cache_visite.size(); i++)
  1534.                                         {
  1535.                                                 if (cache_visite.get(i).matchUtente(id_da_cercare))
  1536.                                                         {
  1537.                                                                 ritorno.add(cache_visite.get(i));
  1538.                                                         }
  1539.                                         }
  1540.                                 return ritorno;
  1541.                         }
  1542.                 throw new Exception(ERR);
  1543.                
  1544.         }
  1545.        
  1546.         private static Object ricercaUnoID(int tipo_ricerca, int id_ricerca) throws Exception
  1547.         {
  1548.                 final int CERCA_ID = 10;
  1549.                 final String ERR = "nessun risultato: medici/utenti";
  1550.                
  1551.                 if (tipo_ricerca == CERCA_MEDICO_SINGOLO)
  1552.                         {
  1553.                                 for (int i = 0; i < corpo_medici.size(); i++)
  1554.                                         {
  1555.                                                 if (corpo_medici.get(i).matchcampo(CERCA_ID, id_ricerca)) return corpo_medici.get(i);
  1556.                                         }
  1557.                         }
  1558.                 ;
  1559.                 if (tipo_ricerca == CERCA_UTENTE_SINGOLO)
  1560.                         {
  1561.                                 for (int i = 0; i < clienti_clinica.size(); i++)
  1562.                                         {
  1563.                                                 if (clienti_clinica.get(i).matchcampo(CERCA_ID, id_ricerca)) return clienti_clinica.get(i);
  1564.                                         }
  1565.                         }
  1566.                 throw new Exception(ERR);
  1567.                
  1568.         }
  1569.        
  1570.         private static void modificautenti() throws IndexOutOfBoundsException, NullPointerException
  1571.         {
  1572.                 boolean finito = false;
  1573.                 while (!finito)
  1574.                         {
  1575.                                 Integer ricerca;
  1576.                                 final String INTRO = "inserire l'id dell'utente da modificare";
  1577.                                 // System.out.println(INTRO);
  1578.                                 ricerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INTRO);
  1579.                                 if (ricerca == null)
  1580.                                         {
  1581.                                                 finito = true;
  1582.                                         }
  1583.                                 else
  1584.                                         {
  1585.                                                 ricerca = getIndexUtente(ricerca);
  1586.                                                 System.out.println(SARA_MODIFICATO + clienti_clinica.get(ricerca).toString());
  1587.                                                
  1588.                                                 finito = !myLib.util.Menu.yes_no_Box(DESIDERA_CONTINUARE, false);
  1589.                                                 if (myLib.math.Numeri.compreso_o_uguale(ricerca, 0, clienti_clinica.size() - 1, false)) { throw new IndexOutOfBoundsException(); }
  1590.                                                
  1591.                                                 clienti_clinica.get(ricerca).modificaUtenteInterfaccia();
  1592.                                         }
  1593.                         }
  1594.         }
  1595.        
  1596.         private static void modificamedici()
  1597.         {
  1598.                 boolean finito = !myLib.util.Menu.yes_no_Box(DESIDERA_CONTINUARE, false);
  1599.                 while (!finito)
  1600.                         {
  1601.                                
  1602.                                 Integer ricerca;
  1603.                                 final String INTRO = "inserire l'id del medico da modificare";
  1604.                                
  1605.                                 ricerca = myLib.util.Input.leggi_int(0, Integer.MAX_VALUE, INTRO);
  1606.                                 ricerca = getIndexMedico(ricerca);
  1607.                                
  1608.                                 if (ricerca == null)
  1609.                                         {
  1610.                                                 finito = true;
  1611.                                                 System.err.println(CERCA_ERR);
  1612.                                         }
  1613.                                 else
  1614.                                         {
  1615.                                                 if (myLib.math.Numeri.compreso_o_uguale(ricerca, 0, corpo_medici.size() - 1, false)) { throw new IndexOutOfBoundsException(); }
  1616.                                                
  1617.                                                 corpo_medici.get(ricerca).modificamedicoInterfaccia();
  1618.                                                
  1619.                                         }
  1620.                         }
  1621.         }
  1622.        
  1623.         private static void cercautenti()
  1624.         {
  1625.                 boolean uscita = false;
  1626.                 int scelta;
  1627.                 final int COM_IND = 0;
  1628.                 final int COM_NOME = 1;
  1629.                 final int COM_COGNOME_ = 2;
  1630.                 final int COM_DATA = 3;
  1631.                 final int COM_LUOGO = 4;
  1632.                 final int COM_TELEF = 5;
  1633.                 final int COM_GEN = 6;
  1634.                
  1635.                 final int COM_COD_FIS = 7;
  1636.                
  1637.                 final String[] TESTI_MENU = { "indietro", "per nome", "per cognome", "per data nascita", "per luogo di nascita", "per telefono", "per genere", "per codice fiscale" };
  1638.                
  1639.                 while (!uscita)
  1640.                         {
  1641.                                 final String S = "inserire dato da cercare\n";
  1642.                                 scelta = myLib.util.Menu.crea_menu_numero(TESTI_MENU.length, TESTI_MENU);
  1643.                                
  1644.                                 switch (scelta)
  1645.                                         {
  1646.                                                 case COM_IND:
  1647.                                                         uscita = true;
  1648.                                                         break;
  1649.                                                
  1650.                                                 case COM_NOME:
  1651.                                                        
  1652.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_NOME, myLib.util.Input.leggi_stringa(S)));
  1653.                                                         break;
  1654.                                                
  1655.                                                 case COM_COGNOME_:
  1656.                                                        
  1657.                                                         // final String S="inserire cognome da cercare";
  1658.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_COGNOME_, myLib.util.Input.leggi_stringa(S)));
  1659.                                                         break;
  1660.                                                
  1661.                                                 case COM_DATA:
  1662.                                                        
  1663.                                                         GregorianCalendar query = myLib.util.Input.leggi_data(S);
  1664.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_DATA, query));
  1665.                                                         break;
  1666.                                                
  1667.                                                 case COM_TELEF:
  1668.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_TELEF, myLib.util.Input.leggi_stringa(S)));
  1669.                                                         break;
  1670.                                                
  1671.                                                 case COM_GEN:
  1672.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_GEN, myLib.util.Input.scegligenerechar()));
  1673.                                                         break;
  1674.                                                
  1675.                                                 case COM_LUOGO:
  1676.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_LUOGO, myLib.util.Input.leggi_stringa(S)));
  1677.                                                         break;
  1678.                                                
  1679.                                                 case COM_COD_FIS:
  1680.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_UTENTI, COM_COD_FIS, myLib.util.Input.leggi_stringa(S)));
  1681.                                                        
  1682.                                                         break;
  1683.                                                
  1684.                                                 default:
  1685.                                                         break;
  1686.                                         }
  1687.                                
  1688.                         }
  1689.         }
  1690.        
  1691.         private static void cercamedici()
  1692.         {
  1693.                 boolean uscita = false;
  1694.                 int scelta;
  1695.                 final int COM_IND = 0;
  1696.                 final int COM_NOME = 1;
  1697.                 final int COM_COGNOME_ = 2;
  1698.                 final int COM_DATA = 3;
  1699.                 final int COM_LUOGO = 4;
  1700.                 final int COM_TELEF = 5;
  1701.                 final int COM_GEN = 6;
  1702.                
  1703.                 final int COM_COD_FIS = 7;
  1704.                 final int COM_NUM = 8;
  1705.                 final int COM_TIPO = 9;
  1706.                
  1707.                 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" };
  1708.                
  1709.                 while (!uscita)
  1710.                         {
  1711.                                 final String S = "inserire dato da cercare\n";
  1712.                                 scelta = myLib.util.Menu.crea_menu_numero(TESTI_MENU.length, TESTI_MENU);
  1713.                                
  1714.                                 switch (scelta)
  1715.                                         {
  1716.                                                 case COM_IND:
  1717.                                                         uscita = true;
  1718.                                                         break;
  1719.                                                
  1720.                                                 case COM_NOME:
  1721.                                                        
  1722.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_NOME, myLib.util.Input.leggi_stringa(S)));
  1723.                                                         break;
  1724.                                                
  1725.                                                 case COM_COGNOME_:
  1726.                                                        
  1727.                                                         // final String S="inserire cognome da cercare";
  1728.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_COGNOME_, myLib.util.Input.leggi_stringa(S)));
  1729.                                                         break;
  1730.                                                
  1731.                                                 case COM_DATA:
  1732.                                                        
  1733.                                                         GregorianCalendar query = myLib.util.Input.leggi_data(S);
  1734.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_DATA, query));
  1735.                                                         break;
  1736.                                                
  1737.                                                 case COM_TELEF:
  1738.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_TELEF, myLib.util.Input.leggi_stringa(S)));
  1739.                                                         break;
  1740.                                                
  1741.                                                 case COM_GEN:
  1742.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_GEN, myLib.util.Input.scegligenerechar()));
  1743.                                                         break;
  1744.                                                
  1745.                                                 case COM_LUOGO:
  1746.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_LUOGO, myLib.util.Input.leggi_stringa(S)));
  1747.                                                         break;
  1748.                                                 case COM_COD_FIS:
  1749.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_COD_FIS, myLib.util.Input.leggi_stringa(S)));
  1750.                                                         break;
  1751.                                                
  1752.                                                 case COM_NUM:
  1753.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_NUM, myLib.util.Input.leggi_integer(0, Integer.MAX_VALUE, S)));
  1754.                                                         break;
  1755.                                                
  1756.                                                 case COM_TIPO:
  1757.                                                         Medico.tipologia_medico query2 = tipologia_medico.sceglitipo();
  1758.                                                         visualizzaListaRisultati(cercaRitornaLista(CERCA_MEDICI, COM_TIPO, query2));
  1759.                                                         break;
  1760.                                                
  1761.                                                 default:
  1762.                                                         break;
  1763.                                         }
  1764.                                
  1765.                         }
  1766.                
  1767.         }
  1768.        
  1769.         // ok
  1770.         private static ArrayList<?> cercaRitornaLista(int tipo_ricerca, int campo, Object query)
  1771.         {
  1772.                
  1773.                 if (tipo_ricerca == CERCA_MEDICI)
  1774.                         {
  1775.                                 ArrayList<Medico> ritorno = new ArrayList<Medico>();
  1776.                                
  1777.                                 for (int i = 0; i < corpo_medici.size(); i++)
  1778.                                         {
  1779.                                                 if (corpo_medici.get(i).matchcampo(campo, query))
  1780.                                                         {
  1781.                                                                 ritorno.add(corpo_medici.get(i));
  1782.                                                         }
  1783.                                         }
  1784.                                 return ritorno;
  1785.                         }
  1786.                 if (tipo_ricerca == CERCA_UTENTI)
  1787.                         {
  1788.                                 ArrayList<Utente> ritorno = new ArrayList<Utente>();
  1789.                                
  1790.                                 for (int i = 0; i < clienti_clinica.size(); i++)
  1791.                                         {
  1792.                                                 if (clienti_clinica.get(i).matchcampo(campo, query))
  1793.                                                         {
  1794.                                                                 ritorno.add(clienti_clinica.get(i));
  1795.                                                         }
  1796.                                         }
  1797.                                 return ritorno;
  1798.                         }
  1799.                
  1800.                 /**
  1801.                  * stratagemma preso da
  1802.                  * http://stackoverflow.com/questions/1274792/is-returning
  1803.                  * -null-bad-design per evitare return null
  1804.                  */
  1805.                
  1806.                 return (ArrayList<?>) Collections.EMPTY_LIST;
  1807.         }
  1808.        
  1809.         // ok
  1810.         private static void visualizzaListaRisultati(ArrayList<?> risultatoRicerca)
  1811.         {
  1812.                 final String VUOTO = "nessun risultato";
  1813.                 final String RISULTATI = "risultati:\n";
  1814.                 final String CORRENTE = "elemento corrente: ";
  1815.                
  1816.                 if (risultatoRicerca.isEmpty())
  1817.                         {
  1818.                                 myLib.util.Output.stampa_testo(VUOTO);
  1819.                         }
  1820.                 else
  1821.                         {
  1822.                                 boolean finito = false;
  1823.                                 int i = 0;
  1824.                                 int scelta;
  1825.                                 final int INDIETRO = 0;
  1826.                                 final int PRECEDENTE = 1;
  1827.                                 final int SUCCESSIVO = 2;
  1828.                                 final String[] SCORRI_MENU = { "indietro", "precedente", "successivo" };
  1829.                                 System.out.println(RISULTATI);
  1830.                                
  1831.                                 while (!finito)
  1832.                                         {
  1833.                                                 System.out.println(CORRENTE + i + " \n");
  1834.                                                
  1835.                                                 System.out.println(risultatoRicerca.get(i).toString());
  1836.                                                
  1837.                                                 scelta = myLib.util.Menu.crea_menu_numero(SCORRI_MENU.length, SCORRI_MENU);
  1838.                                                 switch (scelta)
  1839.                                                         {
  1840.                                                                 case INDIETRO:
  1841.                                                                         finito = true;
  1842.                                                                         break;
  1843.                                                                
  1844.                                                                 case PRECEDENTE:
  1845.                                                                         if ((i - 1) >= 0)
  1846.                                                                                 {
  1847.                                                                                         i--;
  1848.                                                                                        
  1849.                                                                                 }
  1850.                                                                         break;
  1851.                                                                
  1852.                                                                 case SUCCESSIVO:
  1853.                                                                         if ((i + 1) < risultatoRicerca.size())
  1854.                                                                                 {
  1855.                                                                                         i++;
  1856.                                                                                 }
  1857.                                                                         break;
  1858.                                                                 default:
  1859.                                                                         break;
  1860.                                                         }
  1861.                                         }
  1862.                                
  1863.                         }
  1864.                
  1865.         }
  1866.        
  1867.         // OK
  1868.         private static void gestioneIO()
  1869.         {
  1870.                 boolean finito = false;
  1871.                 final String ERR = "errore. non è stato possibile scrivere i dati: ";
  1872.                 final int INDIETRO = 0;
  1873.                 final int CARICA = 1;
  1874.                 final int SALVA = 2;
  1875.                 final String[] MENU_IO = { "indietro", "carica i dati", "salva i dati" };
  1876.                
  1877.                 try
  1878.                         {
  1879.                                
  1880.                                 int scelta;
  1881.                                 while (!finito)
  1882.                                         {
  1883.                                                 scelta = myLib.util.Menu.crea_menu_numero(MENU_IO.length, MENU_IO);
  1884.                                                 switch (scelta)
  1885.                                                         {
  1886.                                                                 case INDIETRO:
  1887.                                                                         finito = true;
  1888.                                                                         break;
  1889.                                                                 case CARICA:
  1890.                                                                        
  1891.                                                                         leggiFile();
  1892.                                                                         finito = true;
  1893.                                                                 case SALVA:
  1894.                                                                        
  1895.                                                                         scriviFile();
  1896.                                                                         finito = true;
  1897.                                                                         break;
  1898.                                                                
  1899.                                                                 default:
  1900.                                                                         break;
  1901.                                                         }
  1902.                                                
  1903.                                         }
  1904.                         } catch (IOException e)
  1905.                         {
  1906.                                 System.err.println(ERR_GENERICO + I_O_ERROR + e.getMessage());
  1907.                         } catch (ClassNotFoundException e)
  1908.                         {
  1909.                                 System.err.println(ERR_GENERICO + ERRORE_CLASSNOTFOUND + e.getMessage());
  1910.                         } catch (ClassCastException e)
  1911.                         {
  1912.                                 System.err.println(ERR_GENERICO + ERORE_CLASSCAST + e.getMessage());
  1913.                         } finally
  1914.                         {
  1915.                                 finito = true;
  1916.                         }
  1917.                
  1918.         }
  1919.        
  1920.         protected static Integer cercaIndiceDatoIDVisita(int search)
  1921.         {
  1922.                 for (int i = 0; i < cache_visite.size(); i++)
  1923.                         {
  1924.                                
  1925.                                 if (cache_visite.get(i).getId_visita() == search) { return i; }
  1926.                                
  1927.                         }
  1928.                
  1929.                 return null;
  1930.                
  1931.         }
  1932. }


Codice sorgente - presumibilmente Java

  1. package corso;
  2.  
  3. import java.io.IOException;
  4. import java.io.Serializable;
  5. //import java.lang.reflect.Array;
  6. import java.util.ArrayList;
  7. import java.util.GregorianCalendar;
  8.  
  9. //import javax.script.CompiledScript;
  10.  
  11.  
  12.  
  13.  
  14. import corso.SlotTemporale.Stato_visita_slot;
  15. import corso.Visita.Stato_visita;
  16. import myLib.typedef.Ora;
  17. import myLib.typedef.Tempo;
  18.  
  19. public class Giorno implements Comparable<Giorno>, Serializable
  20. {
  21.         private static final String     TRENTA  = "/:30";
  22.  
  23.         private static final String     STRINGA_SPAZI   = "           ";
  24.  
  25.         private static final long serialVersionUID=0;
  26.        
  27.         GregorianCalendar                       data;
  28.        
  29.         /**
  30.          * deve essere un nnumero di ore intero
  31.          */
  32.         public static final Ora         apertura                                = new Ora(8, 0, 0);
  33.        
  34.         /**
  35.          * deve essere un nnumero di ore intero
  36.          */
  37.         public static final Ora         chiusura                                = new Ora(18, 0, 0);
  38.        
  39.         public static final int         lavorative                              = (chiusura.get_ore() - apertura.get_ore());
  40.        
  41.         public static final int         numero_slot_per_ora             = 2;
  42.         public static final int         minuti_per_slot                 = Tempo.MINUTI_PER_ORE / numero_slot_per_ora;
  43.        
  44.         public static final int         numero_slot_per_giorno  = lavorative * numero_slot_per_ora;
  45.        
  46.         /**
  47.          * gli orari di visita
  48.          *
  49.          */
  50.         protected SlotTemporale[]       orari                                   = new SlotTemporale[numero_slot_per_giorno];
  51.        
  52.         public Giorno (GregorianCalendar _data, Ora a, Ora b) throws Exception
  53.         {
  54.                
  55.                 data = (GregorianCalendar)_data.clone();
  56.                
  57.                 inizializzaTabella(a, b);
  58.                
  59.         }
  60.        
  61.         /**
  62.          * riempie la tabella degli orari con le varie cose a seconda delle ore
  63.          *
  64.          * @param apri
  65.          * @param chiudi
  66.          * @throws Exception
  67.          */
  68.         private void inizializzaTabella(Ora apri, Ora chiudi) throws Exception
  69.         {
  70.                 final String SWAP1 = "Le ore ";
  71.                 final String SWAP2 = "e ";
  72.                 final String SWAP3 = " saranno scambiate. Continuare? (S/N)";
  73.                
  74.                 final String ERR_ORA = "ore non corrette";
  75.                 if (apri.relazione(apertura) == Ora.CONFRONTA_ORE_ANTECEDENTE || (chiudi.relazione(chiusura)) == Ora.CONFRONTA_ORE_SEGUENTE) throw new Exception(ERR_ORA);
  76.                
  77.                 if (apri.relazione(chiudi) == Ora.CONFRONTA_ORE_SEGUENTE)
  78.                
  79.                 /**
  80.                  * perchè non posso swappare oggetti ;( dannata Sole (Sun)
  81.                  *
  82.                  */
  83.                         {
  84.                                 System.out.println(SWAP1 + apri.toString() + SWAP2 + chiudi.toString());
  85.                                
  86.                                 boolean scelta = myLib.util.Menu.yes_no_Box(SWAP3, true);
  87.                                
  88.                                 if (scelta == true)
  89.                                         {
  90.                                                 Ora transito = apri;
  91.                                                 apri = chiudi;
  92.                                                 chiudi = transito;
  93.                                         }
  94.                                 else
  95.                                         {
  96.                                                 throw new Exception(ERR_ORA);
  97.                                         }
  98.                                
  99.                         }
  100.                
  101.                 Ora corrente = Ora.clone(apertura);
  102.                 /**
  103.                  * riempio il vettore di slot temporali
  104.                  *
  105.                  *
  106.                  */
  107.                 for (int i = 0; i < orari.length; i++)
  108.                         {
  109.                                
  110.                                 if (corrente.compresaDoppia(true, false, apri, chiudi))
  111.                                         {
  112.                                                 //if (corrente.compresa(true, apri, chiudi))
  113.                                                 {orari[i] = new SlotTemporale(corrente, 0, Stato_visita_slot.PRENOTABILE);}
  114.                                         //      else
  115.                                                 //      {
  116.                                                         //      orari[i] = new SlotTemporale(corrente, 0, Stato_visita_slot.NON_PRENOTABILE);
  117.                                                         //}
  118.                                         }
  119.                                 else
  120.                                         {
  121.                                                 orari[i] = new SlotTemporale(corrente, 0, Stato_visita_slot.NON_PRENOTABILE);
  122.                                         }
  123.                                
  124.                                 corrente.add(new Ora(minuti_per_slot * Tempo.MILLISECONDI_PER_MINUTO));
  125.                         }
  126.                
  127.         }
  128.        
  129.         public ArrayList<String> aggiungiVisiteInteressate() throws Exception
  130.         {
  131.                 ArrayList<String> ritorno=new ArrayList<String>();
  132.                
  133.                 for (int i=0;i<orari.length;i++)
  134.                         {
  135.                                 if (orari[i].getStato_slot()==Stato_visita_slot.PRENOTATA)
  136.                                         {
  137.                                                 int id=orari[i].getId_visita();
  138.                                                
  139.                                                 String daAggiungere= Classemain.cache_visite.get(Classemain.cercaIndiceDatoIDVisita(id)).toString();
  140.                                                
  141.                                                 ritorno.add(daAggiungere);
  142.                                                
  143.                                         }
  144.                         }
  145.                 return ritorno;
  146.                
  147.         }
  148.        
  149.        
  150.         public void unisciOrari(Ora Inizio, Ora Fine)
  151.         {
  152.                 for (int i=0;i<orari.length;i++)
  153.                         {
  154.                                
  155.                                 if ((orari[i].getOrario().compresa(true, Inizio, Fine))&&(orari[i].getStato_slot().equals(Stato_visita_slot.NON_PRENOTABILE)))
  156.                                         {
  157.                                                 orari[i].setStato_slot(Stato_visita_slot.PRENOTABILE);
  158.                                         }
  159.                                
  160.                                
  161.                                
  162.                                
  163.                         }
  164.                
  165.                
  166.         }
  167.        
  168.         protected void sostituisciOrari(Ora inizio, Ora fine) throws IOException
  169.        
  170.         {
  171.                 /**
  172.                  *
  173.                  * processo ogni singolo slot, ogni singolo caso
  174.                  *
  175.                  * NP:  dentro: rendi prenotabile
  176.                  *              fuori:  N/A
  177.                  * PA:  dentro: N/A
  178.                  *              fuori:  aggiungi alla lista da cancellare
  179.                  * PE:  dentro: N/A
  180.                  *              fuori:  segna non prenotabile
  181.                  *
  182.                  *
  183.                  *
  184.                  *
  185.                  */
  186.         try{
  187.                 final String INFO="E' stato creato un file di dettagli (%s) delle visite eliminate.\n";
  188.                
  189.                 ArrayList<String> visiteScartate=new ArrayList<String>();
  190.                
  191.                 for (int i=0; i<orari.length;i++)
  192.                
  193.                         {
  194.                                 /**
  195.                                  * NP
  196.                                  */
  197.                                 if (orari[i].getStato_slot().equals(Stato_visita_slot.NON_PRENOTABILE))
  198.                                         {
  199.                                                 if (orari[i].getOrario().compresa(true, inizio, fine))
  200.                                                         {
  201.                                                                 /**
  202.                                                                  * DENTRO
  203.                                                                  */
  204.                                                                
  205.                                                                 orari[i].setStato_slot(Stato_visita_slot.PRENOTABILE);
  206.                                                                
  207.                                                                
  208.                                                         }else
  209.                                                                 {
  210.                                                                         /**
  211.                                                                          * FUORI
  212.                                                                          */
  213.                                                                        
  214.                                                                         /**
  215.                                                                          *
  216.                                                                          * NESSUNA AZIONE
  217.                                                                          *
  218.                                                                          */
  219.                                                                 }
  220.                                                
  221.                                         }
  222.                                 /**
  223.                                  * PE
  224.                                  */
  225.                                 if (orari[i].getStato_slot().equals(Stato_visita_slot.PRENOTABILE))
  226.                                         {
  227.                                                 if (orari[i].getOrario().compresa(true, inizio, fine))
  228.                                                         {
  229.                                                                 /**
  230.                                                                  *
  231.                                                                  * NESSUNA AZIONE
  232.                                                                  *
  233.                                                                  */
  234.                                                         }else
  235.                                                                 {
  236.                                                                         orari[i].setStato_slot(Stato_visita_slot.NON_PRENOTABILE);
  237.                                                                 }
  238.                                                
  239.                                         }
  240.                                 /**
  241.                                  * PA
  242.                                  */
  243.                                 if (orari[i].getStato_slot().equals(Stato_visita_slot.PRENOTATA))
  244.                                         {
  245.                                                 if (orari[i].getOrario().compresa(true, inizio, fine))
  246.                                                         {
  247.                                                                 /**
  248.                                                                  *
  249.                                                                  * NESSUNA AZIONE
  250.                                                                  *
  251.                                                                  */
  252.                                                         }else
  253.                                                                 {
  254.                                                                
  255.                                                                        
  256.                                                                         int ida=orari[i].getId_visita();
  257.                                                                        
  258.                                                                         orari[i].setStato_slot(Stato_visita_slot.NON_PRENOTABILE);
  259.                                                                         int index=Classemain.getIndexVisita(ida);
  260.                                                                         visiteScartate.add(Classemain.cache_visite.get(index).toString());
  261.                                                                        
  262.                                                                         Classemain.cache_visite.get(index).setStato_della_visita(Stato_visita.CONCLUSA);
  263.                                                                        
  264.                                                                        
  265.                                                                 }
  266.                                                
  267.                                         }
  268.                                
  269.                                
  270.                         }
  271.                
  272.                
  273.                
  274.                
  275.                 String nomefile=Medico.trovaNomeDaSalvare();
  276.                 Medico.salvaVisite(nomefile, visiteScartate);
  277.                
  278.                 System.out.printf(INFO, nomefile);
  279.                
  280.                
  281.                
  282.                
  283.                
  284.         } catch (Exception e)
  285.         {
  286.                 System.out.println(Classemain.ERR_GENERICO+e.getMessage());
  287.         }
  288.                
  289.         }
  290.        
  291.        
  292.        
  293. //      public static int primaslot(Ora iniz) throws Exception
  294. //      {
  295. //              Ora posticipo = Ora.clone(iniz);
  296. //              posticipo.sub(apertura);
  297. //             
  298. //              long temp = Ora.oratomilli(posticipo);
  299. //             
  300. //              return ((int) temp / minuti_per_slot * Tempo.SECONDI_PER_MINUTI * 1000);
  301. //             
  302. //      }
  303.        
  304. //     
  305. //      public static int contaslot(Ora diff)
  306. //      {
  307. //              long temp = Ora.oratomilli(diff);
  308. //              int dadividere = minuti_per_slot * Tempo.SECONDI_PER_MINUTI * 1000;
  309. //             
  310. //              return ((int) (temp / dadividere));
  311. //             
  312. //      }
  313. //     
  314.        
  315.         /**
  316.          * segna il giorno come di non lavoro, rendendo ogni visita non prenotabile
  317.          *
  318.          */
  319.         public void noLavoro()
  320.         {
  321.                 for (int i = 0; i < orari.length; i++)
  322.                         {
  323.                                 orari[i].setStato_slot(Stato_visita_slot.NON_PRENOTABILE);
  324.                         }
  325.                
  326.         }
  327.        
  328.         /**
  329.          *
  330.          * ritorna l'header della tabella di un giorno, con tutte le ore e le mezz'ore in cima
  331.          *
  332.          *
  333.          *
  334.          *
  335.          * @return
  336.          */
  337.        
  338.         /*
  339.          * prima era static perchè pensavo che gli orari fossero tutti uguali nella clinica,
  340.          * ma poi ho pensato di renderelo dipendente dall'oggetto perchè è possibile implementare
  341.          * una miglioria degli orari di apertura diversi nella clinica
  342.          *
  343.          * poi c'era un errore e ho rimesso static :p
  344.          *
  345.          */
  346.        
  347.         public static String getIntestazioneOrari()
  348.         {
  349.                 String ritorno = "Giorno:\n";
  350.                 ritorno += STRINGA_SPAZI;
  351.                 int corrente = apertura.get_ore();
  352.                 for (int i = 0; i < lavorative; i++, corrente++)
  353.                         {
  354.                                 ritorno += " ";
  355.                                 /**
  356.                                  * aggiunge lo spazio per ore < 10
  357.                                  */
  358.                                 if (corrente < 10)
  359.                                         {
  360.                                                 ritorno += "0";
  361.                                         }
  362.                                 ritorno += corrente;
  363.                                 ritorno += TRENTA;
  364.                                
  365.                         }
  366.                
  367.                 return (ritorno);
  368.                
  369.         }
  370.        
  371.         /**
  372.          * ritorna una stringa con la tabella degli orari di un giorno
  373.          *
  374.          * @return
  375.          */
  376.         public String getTabellaOrari()
  377.         {
  378.                 final String V = "D";
  379.                 final String F = "N";
  380.                 final String P = "P";
  381.                 String ritorno = myLib.util.Output.formatDate(data)+"  ";
  382.                 for (int i = 0; i < orari.length; i++)
  383.                         {
  384.                                
  385.                                 switch (orari[i].getStato_slot())
  386.                                         {
  387.                                                 case NON_PRENOTABILE:
  388.                                                         ritorno += F;
  389.                                                         break;
  390.                                                 case PRENOTABILE:
  391.                                                         ritorno += V;
  392.                                                         break;
  393.                                                
  394.                                                 case PRENOTATA:
  395.                                                         ritorno += P;
  396.                                                         break;
  397.                                                
  398.                                                 default:
  399.                                                         break;
  400.                                         }
  401.                                
  402.                                 ritorno += "  ";
  403.                                
  404.                         }
  405.                
  406.                 return ritorno;
  407.         }
  408.        
  409.         public Integer getIndexOra(Ora query)
  410.         {
  411.                
  412.                 for (int i=0; i<orari.length; i++)
  413.                         {
  414.                                 if (orari[i].getOrario().equals(query)) {return i;}
  415.                         }
  416.                 return null;
  417.         }
  418.        
  419.         public boolean comprendeOraDisponibile(Ora ricerca)
  420.         {
  421.                
  422.                 for (int i=0;i<orari.length;i++)
  423.                         {
  424.                                 if (orari[i].getOrario().equals(ricerca)&&orari[i].getStato_slot()==Stato_visita_slot.PRENOTABILE)
  425.                                         {
  426.                                                 return true;
  427.                                         }
  428.                         }
  429.                
  430.                 return false;
  431.         }
  432.        
  433.         public void setta(Ora query, Stato_visita_slot temp)
  434.         {
  435.                
  436.                 for (int i = 0; i < orari.length; i++)
  437.                         {
  438.                                 if (orari[i].getOrario().equals(query))
  439.                                         {
  440.                                                 orari[i].setStato_slot(temp);
  441.                                                 i = orari.length;
  442.                                         }
  443.                         }
  444.                
  445.         }
  446.        
  447.         public  String toString()
  448.         {
  449.                 return getIntestazioneOrari()+getTabellaOrari();
  450.                
  451.                
  452.         }
  453.        
  454.         public int compareTo(Giorno cfr)
  455.         {
  456.                
  457.                 long temp = (((Giorno) cfr).data.getTimeInMillis()) / Tempo.MILLISECONDI_PER_GIORNO;
  458.                
  459.                 int comparemillis = (int) temp;
  460.                
  461.                 long questo = this.data.getTimeInMillis() / Tempo.MILLISECONDI_PER_GIORNO;
  462.                
  463.                 int comparequesto = (int) questo;
  464.                
  465.                 int ritorno = (comparequesto - comparemillis);
  466.                
  467.                 return ritorno;
  468.         }
  469. }


Codice sorgente - presumibilmente Java

  1. package corso;
  2.  
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.io.PrintWriter;
  6. import java.util.ArrayList;
  7. import java.util.Calendar;
  8. //import java.util.Collection;
  9. import java.util.Collections;
  10. import java.util.GregorianCalendar;
  11. //import java.util.InputMismatchException;
  12. //import java.util.Vector;
  13.  
  14.  
  15.  
  16.  
  17. import javax.swing.DebugGraphics;
  18.  
  19. import corso.Visita.Stato_visita;
  20. import myLib.typedef.Data;
  21. import myLib.typedef.Ora;
  22.  
  23. //import myLib.typedef.Tempo;
  24.  
  25. public class Medico extends Persona
  26. {
  27.         private static final String     ORARI_GIA_INIZIALIZZATI = "Orari gia' inizializzati";
  28.  
  29.         private static final long serialVersionUID=1;  
  30.        
  31.         private boolean inizializzati_orari=false;
  32.        
  33.         public enum tipologia_medico
  34.         {
  35.                 NORMALE, SPECIALISTA;
  36.                 /*
  37.                  * public boolean equals(tipologia_medico cfr) { if ((this.)||()) return
  38.                  * true; else return false; }
  39.                  */
  40.                 public static tipologia_medico sceglitipo()
  41.                 {
  42.                         final String STRINGA_TIPO = "inserire tipologia ";
  43.                         String temp;
  44.                         boolean finito = false;
  45.                         tipologia_medico ritorno = NORMALE;
  46.                         while (!finito)
  47.                                 {
  48.                                         temp = myLib.util.Input.leggi_stringa(STRINGA_TIPO);
  49.                                         if (temp.toLowerCase().equals(NORMALE.toString().toLowerCase()))
  50.                                                 {
  51.                                                         finito = true;
  52.                                                         ritorno = NORMALE;
  53.                                                 }
  54.                                         ;
  55.                                         if (temp.toLowerCase().equals(SPECIALISTA.toString().toLowerCase()))
  56.                                                 {
  57.                                                         finito = true;
  58.                                                         ritorno = SPECIALISTA;
  59.                                                 }
  60.                                         ;
  61.                                 }
  62.                        
  63.                         return ritorno;
  64.                        
  65.                 }
  66.                
  67.                 public String toString()
  68.                 {
  69.                         return super.toString().toLowerCase();
  70.                 }
  71.         }
  72.        
  73.         final static String                     INS_1                   = "inserire data di inizio";
  74.         final static String                     INS_2                   = "inserire data di fine";
  75.         final static String                     ORA_1                   = "inserire l'ora di inizio lavoro";
  76.         final static String                     ORA_2                   = "inserire l'ora di fine lavoro";
  77.        
  78.         final String                            UN_GIORNO               = "inserimento del turno del medico: intervallo data, intervallo ora.\n per inserire un solo giorno, far coincidere gli estremi";
  79.        
  80.         static final String                     ERR_DATE                = "date o ore scorrette";
  81.         static final String                     ERRORE_ORA              = "errore nelle ore";
  82.        
  83.         protected int                           numero_iscrizione_albo;
  84.         protected tipologia_medico      tipo_del_medico;
  85.         // private int id_medico;
  86.         // boolean[][] orari_visita_standard;
  87.        
  88.         protected ArrayList<Giorno>     orari_visita    = new ArrayList<Giorno>();
  89.        
  90.         public String getInfoBase()
  91.         {
  92.                
  93.                 final String INFO_BASE = "Medico:\t" + this.numero_iscrizione_albo + " Nome:\t" + this.nome + " Cognome:\t" + this.cognome;
  94.                
  95.                 return INFO_BASE;
  96.         }
  97.        
  98.         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)
  99.         {
  100.                 super(_nome, _cognome, _data_nascita, _luogo_nascita, _telefono, _genere, _codice_fiscale);
  101.                 numero_iscrizione_albo = _numero_iscrizione_albo;
  102.                 tipo_del_medico = _tipologia_del_medico;
  103.                 // id_medico = _id + 1;
  104.         }
  105.        
  106.         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)
  107.         {
  108.                 super(_nome, _cognome, _data_nascita, _luogo_nascita, _telefono, _genere, _codice_fiscale);
  109.                 numero_iscrizione_albo = _numero_iscrizione_albo;
  110.                 tipo_del_medico = _tipologia_del_medico;
  111.                 // id_medico = _id + 1;
  112.                
  113.         }
  114.        
  115.         public static Medico creaMedicoInterfaccia(int _id)
  116.         {
  117.                 final String CREA_MEDICO_STRINGA = "Registrare un medico";
  118.                 myLib.util.Output.stampa_testo(CREA_MEDICO_STRINGA);
  119.                 final String RICAPITOLA = "ricapitolazione dell'input:\n\n\n";
  120.                 final String RIDEFINISCI = "si desidera modificare il medico? (S/N) ";
  121.                 final String STRINGA_NOME = "inserire nome ";
  122.                 final String STRINGA_COGNOME = "inserire cognome ";
  123.                 final String STRINGA_DATA = "inserire data di nascita ";
  124.                 final String STRINGA_LUOGO = "inserire luogo nascita ";
  125.                 final String STRINGA_TEL = "inserire telefono ";
  126.                 // final String STRINGA_ALBO = "inserire numero iscrizione ";
  127.                 final String STRINGA_TIPO = "inserire tipo medico ";
  128.                
  129.                 String temp_nome = myLib.util.Input.leggi_stringa(STRINGA_NOME);
  130.                 String temp_cognome = myLib.util.Input.leggi_stringa(STRINGA_COGNOME);
  131.                
  132.                 GregorianCalendar temp_data_nascita = myLib.util.Input.leggi_data(STRINGA_DATA);
  133.                
  134.                 String temp_luogo_nascita = myLib.util.Input.leggi_stringa(STRINGA_LUOGO);
  135.                 String temp_telefono = myLib.util.Input.leggi_stringa(STRINGA_TEL);
  136.                
  137.                 char temp_genere = myLib.util.Input.scegligenerechar();
  138.                 String temp_codice_fiscale;
  139.                 if (!Classemain.DEBUG)
  140.                 {temp_codice_fiscale = myLib.util.Input.inserisciCodiceFiscale();}
  141.                 else
  142.                         {temp_codice_fiscale=myLib.util.Input.leggi_stringa();}
  143.                 int temp_numero_iscrizione = _id;// myLib.util.Input.leggi_int(0,
  144.                                                                                         // Integer.MAX_VALUE, STRINGA_ALBO);
  145.                 System.out.println(STRINGA_TIPO);
  146.                 tipologia_medico temp_tipologia = tipologia_medico.sceglitipo();
  147.                
  148.                 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);
  149.                
  150.                 System.out.println(RICAPITOLA);
  151.                
  152.                 System.out.println(ritorno.toString());
  153.                
  154.                 if (myLib.util.Menu.yes_no_Box(RIDEFINISCI, false)) ritorno = creaMedicoInterfaccia(_id);
  155.                
  156.                 return ritorno;
  157.                
  158.         }
  159.        
  160.         public String toString()
  161.         {
  162.                
  163.                 final String NAL = "\n\tnumero iscrizione albo:\t";
  164.                 final String TIPO = "\n\ttipologia:\t";
  165.                 // final String ID = "\n\tid:\t";
  166.                
  167.                 String ritorno = super.toString();
  168.                 ritorno += (NAL + numero_iscrizione_albo + TIPO + tipo_del_medico.toString());
  169.                 return ritorno;
  170.                
  171.         }
  172.        
  173.         /*
  174.          * public String toString_extra() { final String NUMALB =
  175.          * "\n\tnumero albo:\t"; final String TIPO = "\n\ttipo medico:\t"; String
  176.          * ritorno; ritorno = (NUMALB + numero_iscrizione_albo + TIPO +
  177.          * tipo_del_medico); return ritorno; }
  178.          */
  179.        
  180.         /**
  181.          * inizializza gli orari di un medico.
  182.          * l'utilizzo della flag force è riservato al sistema.
  183.          *
  184.          * @param force
  185.          * @throws Exception
  186.          */
  187.         protected void inizializzaOrari(boolean force) throws Exception
  188.         {
  189.                 if (force) inizializzati_orari=false;
  190.                 if (!inizializzati_orari)
  191.                         {
  192.                                 inizializzati_orari=true;
  193.                 interfacciaCreazioneGiorni();
  194.                 segnafestivi();
  195.                 ordinaGiorni();
  196.                         }
  197.                 else throw new Exception(ORARI_GIA_INIZIALIZZATI);
  198.         }
  199.        
  200.         private void interfacciaCreazioneGiorni() throws Exception
  201.         {
  202.                 System.out.println(UN_GIORNO);
  203.                
  204.                 GregorianCalendar data_inizio = myLib.util.Input.leggi_data(INS_1);
  205.                
  206.                 GregorianCalendar corrente = (GregorianCalendar) data_inizio.clone();
  207.                
  208.                 GregorianCalendar data_fine = myLib.util.Input.leggi_data(INS_2);
  209.                
  210.                 System.out.println(ORA_1);
  211.                 Ora inizio = myLib.typedef.Ora.crea_ora();
  212.                 myLib.typedef.Ora.scala(inizio, false, 0, 30, 60);
  213.                 System.out.println(Classemain.ORA_SCALATA + inizio.toString());
  214.                
  215.                 System.out.println(ORA_2);
  216.                 Ora fine = myLib.typedef.Ora.crea_ora();
  217.                 myLib.typedef.Ora.scala(fine, false, 0, 30, 60);
  218.                 System.out.println(Classemain.ORA_SCALATA + fine.toString());
  219.                
  220.                 if ((data_inizio.after(data_fine)) || (inizio.relazione(fine) == Ora.CONFRONTA_ORE_SEGUENTE)) throw new Exception(ERR_DATE);
  221.                
  222.                 int differenza = myLib.typedef.Data.differenzaData(data_inizio, data_fine);
  223.                
  224.                
  225.                 for (int i = 0; i <= differenza; i++)
  226.                         {
  227.                                 // Giorno temp = ;
  228.                                 corrente = Data.sommagiorni(corrente, 1);
  229.                                 orari_visita.add(new Giorno(corrente, inizio, fine));
  230.                                 if (Classemain.DEBUG) {System.out.println("fatto un giorno ora:"+ inizio.toString());}
  231.                                
  232.                         }
  233.         }
  234.        
  235.         // ok?
  236.         protected void visualizzaOrari()
  237.         {
  238.                 final String NIENTE = "Niente da visualizzare. Aggiungere orari adesso?";
  239.                 final String FALLO_ORA = "E' consigliabile aggiungere gli orari quanto prima.";
  240.                 final String INTRO = "Orari del medico:\t%d\t%s\t%s\n\n";
  241.                
  242.                 final String TABELLA = Giorno.getIntestazioneOrari();
  243.                
  244.                 // final String ELEMENTO = "\t%s\t%s\t%s\n";
  245.                
  246.                 if (orari_visita.isEmpty())
  247.                         {
  248.                                
  249.                                 boolean scelta = myLib.util.Menu.yes_no_Box(NIENTE, true);
  250.                                 if (scelta == true)
  251.                                         {
  252.                                                 try
  253.                                                         {
  254.                                                                 inizializzaOrari(false);
  255.                                                         } catch (Exception e)
  256.                                                         {
  257.                                                                 System.out.println(e.getMessage() + "\n\n" + FALLO_ORA);
  258.                                                         }
  259.                                         }
  260.                                 else
  261.                                         {
  262.                                                 System.out.println(FALLO_ORA);
  263.                                         }
  264.                                
  265.                         }
  266.                 else
  267.                        
  268.                         {
  269.                                 System.out.printf(INTRO, this.numero_iscrizione_albo, this.nome, this.cognome);
  270.                                
  271.                                 System.out.println(TABELLA);
  272.                                
  273.                                 ordinaGiorni();
  274.                                
  275.                                 for (int i = 0; i < orari_visita.size(); i++)
  276.                                         {
  277.                                                 System.out.println(orari_visita.get(i).getTabellaOrari());
  278.                                                 if (((i % 10) == 0)&&(i!=0))
  279.                                                         {
  280.                                                                 myLib.util.Input.pause();
  281.                                                         }
  282.                                         }
  283.                         }
  284.                
  285.         }
  286.        
  287.         // ok?
  288.         protected void ordinaGiorni()
  289.         {
  290.                
  291.                 Collections.sort(orari_visita);
  292.                
  293.         }
  294.        
  295.         public void aggiungiOrari() throws Exception
  296.         {
  297.                 final String INTRO = "E' ora possibile modificare un solo giorno alla volta.";
  298.                
  299.                 System.out.println(INTRO);
  300.                
  301.                 int scelta;
  302.                 final String[] MENU_GIORNI = { "indietro", "cancella giorno", "aggiungi/estendi giorno" };
  303.                 final int IND = 0;
  304.                 final int CAN = 1;
  305.                 final int AGG = 2;
  306.                
  307.                 boolean finito = false;
  308.                
  309.                 while (!finito)
  310.                         {
  311.                                 scelta = myLib.util.Menu.crea_menu_numero(MENU_GIORNI.length, MENU_GIORNI);
  312.                                
  313.                                 switch (scelta)
  314.                                         {
  315.                                                 case IND:
  316.                                                         finito = true;
  317.                                                         break;
  318.                                                 case CAN:
  319.                                                         cancellaGiorno();
  320.                                                         break;
  321.                                                 case AGG:
  322.                                                         aggiungiGiorno();
  323.                                                         break;
  324.                                                
  325.                                                 default:
  326.                                                         break;
  327.                                         }
  328.                                
  329.                         }
  330.                
  331.         }
  332.        
  333.         protected void cancellaGiorno() throws Exception
  334.         {
  335.                 final String INTRO = "inserire il giorno da cancellare: ";
  336.                
  337.                 GregorianCalendar daCancellare = myLib.util.Input.leggi_data(INTRO);
  338.                
  339.                 Integer indiceCerca = cercaGiornoData(daCancellare);
  340.                 if (indiceCerca == null)
  341.                         {
  342.                                 final String NESSUNO = "Non trovato. Riprovare? (S/N)";
  343.                                
  344.                                 if (myLib.util.Menu.yes_no_Box(NESSUNO, false)) cancellaGiorno();
  345.                                
  346.                         }
  347.                 else
  348.                         {
  349.                                 int indice = (int) indiceCerca;
  350.                                
  351.                                 String nomefile = trovaNomeDaSalvare();
  352.                                
  353.                                 ArrayList<String> registro = orari_visita.get(indice).aggiungiVisiteInteressate();
  354.                                
  355.                                 salvaVisite(nomefile, registro);
  356.                                
  357.                                 System.out.printf(Classemain.SICURO_FILE, nomefile);
  358.                                
  359.                                 boolean conferma = myLib.util.Menu.yes_no_Box("", false);
  360.                                 if (conferma == true)
  361.                                         {
  362.                                                 orari_visita.get(indice).noLavoro();
  363.                                                
  364.                                                 chiudiVisitePerData(daCancellare, Classemain.cache_visite);
  365.                                                
  366.                                         }
  367.                         }
  368.                
  369.         }
  370.        
  371.         private void chiudiVisitePerData(GregorianCalendar data, ArrayList<Visita> visite)
  372.         {
  373.                 for (int i = 0; i < visite.size(); i++)
  374.                         {
  375.                                 if ((visite.get(i).getData().equals(data)) && (visite.get(i).getId_medico() == this.numero_iscrizione_albo))
  376.                                         {
  377.                                                 visite.get(i).setStato_della_visita(Stato_visita.CONCLUSA);
  378.                                                
  379.                                         }
  380.                                
  381.                         }
  382.         }
  383.        
  384.         protected void aggiungiGiorno() throws Exception
  385.         {
  386.                
  387.                 final String INTRO = "inserire il giorno da aggiungere/modificare";
  388.                 GregorianCalendar richiesta = myLib.util.Input.leggi_data(INTRO);
  389.                
  390.                 if (!esisteGiorno(richiesta))
  391.                         {
  392.                                
  393.                                 /**
  394.                                  * giorno non esiste
  395.                                  *
  396.                                  */
  397.                                 final String NON_ES = "il giorno non esiste. Inserire i nuovi orari.";
  398.                                
  399.                                 System.out.println(NON_ES);
  400.                                
  401.                                 System.out.println(ORA_1);
  402.                                 Ora inizio = myLib.typedef.Ora.crea_ora();
  403.                                 myLib.typedef.Ora.scala(inizio, false, 0, 30, 60);
  404.                                 System.out.println(Classemain.ORA_SCALATA + inizio.toString());
  405.                                
  406.                                 System.out.println(ORA_2);
  407.                                 Ora fine = myLib.typedef.Ora.crea_ora();
  408.                                 myLib.typedef.Ora.scala(fine, false, 0, 30, 60);
  409.                                 System.out.println(Classemain.ORA_SCALATA + fine.toString());
  410.                                
  411.                                 if ((inizio.relazione(fine) == Ora.CONFRONTA_ORE_SEGUENTE)) throw new Exception(ERR_DATE);
  412.                                
  413.                                 orari_visita.add(new Giorno(richiesta, inizio, fine));
  414.                                 ordinaGiorni();
  415.                                
  416.                         }
  417.                 else
  418.                         {
  419.                                
  420.                                 /**
  421.                                  * TODO VISUALIZZA GIORNO
  422.                                  *
  423.                                  */
  424.                                 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.";
  425.                                
  426.                                 System.out.println(ESISTE);
  427.                                
  428.                                 boolean finito = false;
  429.                                 final String[] OPZIONI = { "indietro", "sostituire", "unire" };
  430.                                 int scelta;
  431.                                 final int IND = 0;
  432.                                 final int SOS = 1;
  433.                                 final int UNI = 2;
  434.                                
  435.                                 while (!finito)
  436.                                         {
  437.                                                 scelta = myLib.util.Menu.crea_menu_numero(OPZIONI.length, OPZIONI);
  438.                                                 switch (scelta)
  439.                                                         {
  440.                                                                 case IND:
  441.                                                                         finito = true;
  442.                                                                         break;
  443.                                                                 case SOS:
  444.                                                                         sostituisciGiorno(richiesta);
  445.                                                                         finito=true;
  446.                                                                         break;
  447.                                                                 case UNI:
  448.                                                                         unisciGiorno(richiesta);
  449.                                                                         finito=true;
  450.                                                                         break;
  451.                                                                
  452.                                                                 default:
  453.                                                                         break;
  454.                                                         }
  455.                                                
  456.                                         }
  457.                         }
  458.                
  459.         }
  460.        
  461.         private boolean esisteGiorno(GregorianCalendar a)
  462.         {
  463.                 for (int i = 0; i < orari_visita.size(); i++)
  464.                         {
  465.                                 if (orari_visita.get(i).data.equals(a)) return true;
  466.                         }
  467.                 return false;
  468.         }
  469.        
  470.         private void sostituisciGiorno(GregorianCalendar a)
  471.         {
  472.                 try
  473.                         {
  474.                                
  475.                                 Ora nuovaInizio = myLib.typedef.Ora.crea_ora();
  476.                                 myLib.typedef.Ora.scala(nuovaInizio, false, 0, 30, 60);
  477.                                 System.out.println(Classemain.ORA_SCALATA + nuovaInizio.toString());
  478.                                 Ora nuovaFine = myLib.typedef.Ora.crea_ora();
  479.                                 myLib.typedef.Ora.scala(nuovaFine, false, 0, 30, 60);
  480.                                 System.out.println(Classemain.ORA_SCALATA + nuovaFine.toString());
  481.                                
  482.                                 if (nuovaInizio.relazione(nuovaFine) == Ora.CONFRONTA_ORE_SEGUENTE) { throw new Exception(ERRORE_ORA); }
  483.                                
  484.                                 int indice = cercaGiornoData(a);
  485.                                
  486.                                 orari_visita.get(indice).sostituisciOrari(nuovaInizio, nuovaFine);
  487.                                
  488.                         } catch (Exception e)
  489.                         {
  490.                                 System.out.println(e.getMessage());
  491.                                 sostituisciGiorno(a);
  492.                         }
  493.                
  494.         }
  495.        
  496.         private void unisciGiorno(GregorianCalendar data)
  497.         {
  498.                 try
  499.                         {
  500.                                
  501.                                 Ora nuovaInizio = myLib.typedef.Ora.crea_ora();
  502.                                 myLib.typedef.Ora.scala(nuovaInizio, false, 0, 30, 60);
  503.                                 System.out.println(Classemain.ORA_SCALATA + nuovaInizio.toString());
  504.                                 Ora nuovaFine = myLib.typedef.Ora.crea_ora();
  505.                                 myLib.typedef.Ora.scala(nuovaFine, false, 0, 30, 60);
  506.                                 System.out.println(Classemain.ORA_SCALATA + nuovaFine.toString());
  507.                                
  508.                                 if (nuovaInizio.relazione(nuovaFine) == Ora.CONFRONTA_ORE_SEGUENTE) { throw new Exception(ERRORE_ORA); }
  509.                                
  510.                                 int indice = cercaGiornoData(data);
  511.                                
  512.                                 orari_visita.get(indice).unisciOrari(nuovaInizio, nuovaFine);
  513.                                
  514.                         } catch (Exception e)
  515.                         {
  516.                                 System.out.println(e.getMessage());
  517.                                 unisciGiorno(data);
  518.                         }
  519.         }
  520.        
  521.         /**
  522.          * ritorna l'indice del giorno con tale data. null se non trovata
  523.          *
  524.          * @param query
  525.          * @return
  526.          */
  527.        
  528.         protected Integer cercaGiornoData(GregorianCalendar query)
  529.         {
  530.                 ordinaGiorni();
  531.                
  532.                 for (int i = 0; i < orari_visita.size(); i++)
  533.                         {
  534.                                
  535.                                 if (orari_visita.get(i).data.equals(query)) { return i; }
  536.                                
  537.                         }
  538.                 return null;
  539.                
  540.         }
  541.        
  542.         // ok
  543.         private void segnafestivi()
  544.         {
  545.                 for (int i = 0; i < orari_visita.size(); i++)
  546.                
  547.                         {
  548.                                 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))
  549.                                
  550.                                         {
  551.                                                
  552.                                                 orari_visita.get(i).noLavoro();
  553.                                                
  554.                                         }
  555.                                
  556.                         }
  557.         }
  558.        
  559.         // @SuppressWarnings ("static-access")
  560.         public void cercaorariMedico(GregorianCalendar queryData, Ora queryOra)
  561.         {
  562.                
  563.                 ordinaGiorni();
  564.                
  565.                 for (int i = 0; i < orari_visita.size(); i++)
  566.                         {
  567.                                 if (Data.dateUguali(orari_visita.get(i).data, queryData))
  568.                                         {
  569.                                                 if (orari_visita.get(i).comprendeOraDisponibile(queryOra))
  570.                                                         {
  571.                                                                 System.out.println(getInfoBase());
  572.                                                                
  573.                                                                 System.out.println(orari_visita.get(i).getIntestazioneOrari());
  574.                                                                 System.out.println(orari_visita.get(i).getTabellaOrari());
  575.                                                         }
  576.                                         }
  577.                                
  578.                         }
  579.                
  580.         }
  581.        
  582.         public void resettaOrari()
  583.         {
  584.                 for (int i = 0; i < orari_visita.size(); i++)
  585.                         {
  586.                                 orari_visita.get(i).noLavoro();
  587.                                
  588.                         }
  589.                
  590.                 // orari_visita = null;
  591.                 // inizializzaOrari();
  592.         }
  593.        
  594.         protected boolean isDisponibile  (GregorianCalendar data, Ora ora)
  595.         {
  596.                
  597.                
  598.                
  599.         }
  600.        
  601.        
  602.         /**
  603.          * trova le visite di un medico prima di eliminare i suoi orari
  604.          *
  605.          */
  606.         public String trovaVisiteInteressate() throws IOException, Exception
  607.         {
  608.                 ArrayList<String> visite = new ArrayList<String>();
  609.                
  610.                 for (int i = 0; i < orari_visita.size(); i++)
  611.                         {
  612.                                 visite.addAll(orari_visita.get(i).aggiungiVisiteInteressate());
  613.                                
  614.                         }
  615.                 String filename = trovaNomeDaSalvare();
  616.                 salvaVisite(filename, visite);
  617.                 return filename;
  618.         }
  619.        
  620.         protected static String trovaNomeDaSalvare()
  621.         {
  622.                 final String EXT = "txt";
  623.                 final String NOME = "visite";
  624.                 String soluzione;
  625.                
  626.                 int copia = 0;
  627.                 File test = new File(NOME + copia + EXT);
  628.                 boolean finito = false;
  629.                
  630.                 while (!finito)
  631.                         {
  632.                                 test = new File(NOME + copia + EXT);
  633.                                 if (test.exists())
  634.                                         {
  635.                                                 copia++;
  636.                                         }
  637.                                 else
  638.                                         {
  639.                                                 finito = true;
  640.                                         }
  641.                                
  642.                         }
  643.                 soluzione = NOME + copia + EXT;
  644.                
  645.                 soluzione += EXT;
  646.                 return soluzione;
  647.         }
  648.        
  649.         protected static void salvaVisite(String nome, ArrayList<String> oggetto) throws IOException
  650.         {
  651.                 PrintWriter scrivi = myLib.util.Output.creaFileTesto(nome);
  652.                 for (int i = 0; i < oggetto.size(); i++)
  653.                
  654.                         {
  655.                                 scrivi.write(oggetto.get(i));
  656.                         }
  657.                
  658.         }
  659.        
  660.         public void modificamedicoInterfaccia()
  661.         {
  662.                
  663.                 final String CREA_MEDICO_STRINGA = "Registrare un medico";
  664.                 myLib.util.Output.stampa_testo(CREA_MEDICO_STRINGA);
  665.                 final String RICAPITOLA = "ricapitolazione dell'input:\n\n\n";
  666.                 final String RIDEFINISCI = "si desidera modificare il medico? (S/N) ";
  667.                 final String STRINGA_NOME = "inserire nome ";
  668.                 final String STRINGA_COGNOME = "inserire cognome ";
  669.                 final String STRINGA_DATA = "inserire data di nascita ";
  670.                 final String STRINGA_LUOGO = "inserire luogo nascita ";
  671.                 final String STRINGA_TEL = "inserire telefono ";
  672.                
  673.                 final String STRINGA_TIPO = "inserire tipo medico ";
  674.                
  675.                 nome = myLib.util.Input.leggi_stringa(STRINGA_NOME);
  676.                 cognome = myLib.util.Input.leggi_stringa(STRINGA_COGNOME);
  677.                
  678.                 data_nascita = myLib.util.Input.leggi_data(STRINGA_DATA);
  679.                
  680.                 luogo_nascita = myLib.util.Input.leggi_stringa(STRINGA_LUOGO);
  681.                 telefono = myLib.util.Input.leggi_stringa(STRINGA_TEL);
  682.                
  683.                 genere = myLib.util.Input.scegligenerechar();
  684.                
  685.                 if (Classemain.DEBUG)
  686.                         {
  687.                                 codice_fiscale = myLib.util.Input.leggi_stringa();
  688.                         }
  689.                
  690.                 else
  691.                         {
  692.                                 codice_fiscale = myLib.util.Input.inserisciCodiceFiscale();
  693.                         }
  694.                
  695.                 if (!Classemain.DEBUG)
  696.                         {
  697.                                 System.out.println(STRINGA_TIPO);
  698.                                 tipo_del_medico = tipologia_medico.sceglitipo();
  699.                         }
  700.                 // Medico ritorno = new Medico(temp_nome, temp_cognome,
  701.                 // temp_data_nascita, temp_luogo_nascita, temp_telefono, temp_genere,
  702.                 // temp_codice_fiscale, temp_numero_iscrizione, temp_tipologia, _id);
  703.                
  704.                 System.out.println(RICAPITOLA);
  705.                
  706.                 System.out.println(this.toString());
  707.                
  708.                 if (myLib.util.Menu.yes_no_Box(RIDEFINISCI, false)) this.modificamedicoInterfaccia();
  709.                 ;
  710.                
  711.                 // return ritorno;
  712.                
  713.         }
  714.        
  715.         /**
  716.          * 1 NOME 2 COGNOME 3 DATA 4 LUOGO 5 TELEFONO 6 GENERE 7 CODICE FISCALE 8
  717.          * NUMERO ID ALBO 9 TIPO
  718.          *
  719.          *
  720.          *
  721.          */
  722.         // fatto
  723.         public boolean matchcampo(int campo, Object query)
  724.         {
  725.                 final String PARAM_ERR = "errore nella ricerca. Probabilmente il parametro è scorretto";
  726.                 final int NOME = 1;
  727.                 final int COGNOME = 2;
  728.                 final int DATA = 3;
  729.                 final int LUOGO = 4;
  730.                 final int TEL = 5;
  731.                 final int GENERE = 6;
  732.                 final int CODFISC = 7;
  733.                 final int NUM_ALB = 8;
  734.                 final int TIPO = 9;
  735.                 final int ID = 10;
  736.                
  737.                 switch (campo)
  738.                         {
  739.                                 case NOME:
  740.                                         return super.matchcampo(campo, query);
  741.                                        
  742.                                 case COGNOME:
  743.                                         return super.matchcampo(campo, query);
  744.                                        
  745.                                 case DATA:
  746.                                         return super.matchcampo(campo, query);
  747.                                        
  748.                                 case LUOGO:
  749.                                         return super.matchcampo(campo, query);
  750.                                        
  751.                                 case TEL:
  752.                                         return super.matchcampo(campo, query);
  753.                                        
  754.                                 case GENERE:
  755.                                         return super.matchcampo(campo, query);
  756.                                        
  757.                                 case CODFISC:
  758.                                         return super.matchcampo(campo, query);
  759.                                        
  760.                                 case NUM_ALB:
  761.                                 case ID:
  762.                                         try
  763.                                                 {
  764.                                                         int escamotage = (int) query;
  765.                                                         if (this.numero_iscrizione_albo == escamotage) return true;
  766.                                                 } catch (ClassCastException e)
  767.                                                 {
  768.                                                         throw new IllegalArgumentException(PARAM_ERR);
  769.                                                 }
  770.                                         break;
  771.                                 case TIPO:
  772.                                         query = (tipologia_medico) query;
  773.                                         if (this.tipo_del_medico.equals(query)) return true;
  774.                                        
  775.                                         break;
  776.                                 // case ID:
  777.                                 //
  778.                                 // if (this.id_medico == (int) query) return true;
  779.                                 //
  780.                                 // break;
  781.                                 default:
  782.                                         break;
  783.                         }
  784.                 return false;
  785.         }
  786.        
  787. }


Codice sorgente - presumibilmente Java

  1. package corso;
  2.  
  3. import java.io.Serializable;
  4.  
  5. public class MiscData implements Serializable
  6. {      
  7.         public int currentMedicoID;
  8.         public int currentVisitaID;
  9.        
  10.         /**
  11.          * @return the currentMedicoID
  12.          */
  13.         public int getCurrentMedicoID()
  14.         {
  15.                 return currentMedicoID;
  16.         }
  17.         /**
  18.          * @param currentMedicoID the currentMedicoID to set
  19.          */
  20.         public void setCurrentMedicoID(int currentMedicoID)
  21.         {
  22.                 this.currentMedicoID = currentMedicoID;
  23.         }
  24.         /**
  25.          * @return the currentVisitaID
  26.          */
  27.         public int getCurrentVisitaID()
  28.         {
  29.                 return currentVisitaID;
  30.         }
  31.         /**
  32.          * @param currentVisitaID the currentVisitaID to set
  33.          */
  34.         public void setCurrentVisitaID(int currentVisitaID)
  35.         {
  36.                 this.currentVisitaID = currentVisitaID;
  37.         }
  38.        
  39.         public int currentUtenteID;
  40.         /**
  41.          * @return the currentUtenteID
  42.          */
  43.         public int getCurrentUtenteID()
  44.         {
  45.                 return currentUtenteID;
  46.         }
  47.         /**
  48.          * @param currentUtenteID the currentUtenteID to set
  49.          */
  50.         public void setCurrentUtenteID(int currentUtenteID)
  51.         {
  52.                 this.currentUtenteID = currentUtenteID;
  53.         }
  54.        
  55.        
  56.         public MiscData()
  57.         {
  58.                 setCurrentMedicoID(1);
  59.                 setCurrentUtenteID(1);
  60.                 setCurrentVisitaID(1);
  61.                
  62.         }
  63.        
  64.  
  65. }


Codice sorgente - presumibilmente Java

  1. package corso;
  2.  
  3. import java.io.Serializable;
  4. import java.util.Date;
  5. import java.util.GregorianCalendar;
  6. import java.util.InputMismatchException;
  7.  
  8. public class Persona implements Serializable
  9. {
  10.         protected String        nome;
  11.         protected String        cognome;
  12.         GregorianCalendar       data_nascita;
  13.         protected String        luogo_nascita;
  14.         protected String        telefono;
  15.         protected char          genere;
  16.         protected String        codice_fiscale;
  17.        
  18.         public Persona (String _nome, String _cognome, GregorianCalendar _data_nascita, String _luogo_nascita, String _telefono, char _genere, String _codice_fiscale)
  19.         {
  20.                 nome = _nome;
  21.                 cognome = _cognome;
  22.                 data_nascita = _data_nascita;
  23.                 luogo_nascita = _luogo_nascita;
  24.                 telefono = _telefono;
  25.                 genere = _genere;
  26.                 codice_fiscale = _codice_fiscale;
  27.                
  28.         }
  29.        
  30.         public Persona()
  31.         {
  32.                 nome = null;
  33.                 cognome = null;
  34.                 data_nascita = null;
  35.                 luogo_nascita = null;
  36.                 telefono = null;
  37.                 //genere = null;
  38.                 codice_fiscale = null;
  39.         }
  40.        
  41.        
  42.         public String toString()
  43.         {
  44.                 final String INTRO = "persona:\n\tcampo\tvalore\n\t";
  45.                 final String NOME = "nome:\t";
  46.                 final String COGNOME = "\n\tcognome:\t";
  47.                 final String DATA = "\n\tdata nascita:\t";
  48.                 final String LUOGO = "\n\tluogo di nascita:\t";
  49.                 final String TEL = "\n\ttelefono:\t";
  50.                 final String GEN = "\n\tgenere:\t";
  51.                 final String CODFIS = "\n\tcodice fiscale:\t";
  52.                
  53.                 return (INTRO + NOME + nome + COGNOME + cognome + DATA + myLib.util.Output.formatDate(data_nascita) + LUOGO + luogo_nascita + TEL + telefono + GEN + genere + CODFIS + codice_fiscale);
  54.                
  55.         }
  56.        
  57.         public boolean equals(Persona cfr)
  58.         {
  59.                 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;
  60.                 else
  61.                         return false;
  62.                
  63.         }
  64.        
  65.         /**
  66.          * restituisce vero se il campo i corrisponde alla query
  67.          *
  68.          *
  69.          * @param campo
  70.          *            i : nome=1, cognome, data nascita, luogo nascita, telefono,
  71.          *            genere, codice fiscale=7
  72.          * @param query
  73.          *            : in caso di numeri usare Integer
  74.          * @return true se corrisponde
  75.          */
  76.        
  77.         public boolean matchcampo(int campo, Object query) throws InputMismatchException
  78.         {
  79.                 final String PARAM_ERR = "errore nella ricerca. Probabilmente il parametro è scorretto";
  80.                 final int NOME = 1;
  81.                 final int COGNOME = 2;
  82.                 final int DATA = 3;
  83.                 final int LUOGO = 4;
  84.                 final int TEL = 5;
  85.                 final int GENERE = 6;
  86.                 final int CODFISC = 7;
  87.                
  88.                 switch (campo)
  89.                         {
  90.                                 case NOME:
  91.                                         if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
  92.                                         query = (String) query;
  93.                                         if (this.nome.equals(query)) return true;
  94.                                         break;
  95.                                
  96.                                 case COGNOME:
  97.                                         if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
  98.                                         query = (String) query;
  99.                                         if (this.cognome.equals(query)) return true;
  100.                                         break;
  101.                                
  102.                                 case DATA:
  103.                                         if (!(query instanceof GregorianCalendar)) throw new InputMismatchException(PARAM_ERR);
  104.                                         query = (GregorianCalendar) query;
  105.                                         if (this.data_nascita.equals(query)) return true;
  106.                                         break;
  107.                                
  108.                                 case LUOGO:
  109.                                         if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
  110.                                         query = (String) query;
  111.                                         if (this.luogo_nascita.equals(query)) return true;
  112.                                         break;
  113.                                
  114.                                 case TEL:
  115.                                         if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
  116.                                         query = (String) query;
  117.                                         if (this.telefono.equals(query)) return true;
  118.                                         break;
  119.                                
  120.                                 case GENERE:
  121.                                         try
  122.                                                 {
  123.                                                         //
  124.                                                         char escamotage = (char) query;
  125.                                                         //
  126.                                                         if (this.genere == escamotage) return true;
  127.                                                 } catch (ClassCastException e)
  128.                                                 {
  129.                                                         throw new InputMismatchException(PARAM_ERR);
  130.                                                 }
  131.                                         break;
  132.                                
  133.                                 case CODFISC:
  134.                                         if (!(query instanceof String)) throw new InputMismatchException(PARAM_ERR);
  135.                                         query = (String) query;
  136.                                         if (this.codice_fiscale.equals(query)) return true;
  137.                                         break;
  138.                                
  139.                                 default:
  140.                                         break;
  141.                         }
  142.                
  143.                 return false;
  144.         }
  145.        
  146. }


Codice sorgente - presumibilmente Java

  1. package corso;
  2.  
  3. import java.io.Serializable;
  4. //import java.util.GregorianCalendar;
  5. import java.util.Vector;
  6.  
  7. public class Settimana implements Serializable
  8. {
  9.         private static final int        GIORNI_SETTIMANA                        = 7;
  10.        
  11. //      public int                                      mese;
  12. //      public int                                      anno;
  13.        
  14. //      public GregorianCalendar        inizio;
  15. //                      public GregorianCalendar        fine;
  16.        
  17.         // private Vector<Giorno> giorni = new Vector<Giorno>();
  18.        
  19. //      public int                                      numero_settimana;
  20.        
  21.         // protected Giorno[] giorni_settimana = new Giorno[GIORNI_SETTIMANA];
  22.        
  23.         public static final int         ore_lavorative_al_giorno        = 10;
  24.        
  25.         public static final int         numero_slot_per_ora                     = 2;
  26.        
  27.         public static final int         NUMERO_SLOT_PER_GIORNO          = ore_lavorative_al_giorno * numero_slot_per_ora;
  28.        
  29.         public boolean[][]                      orari_visita                            = new boolean[NUMERO_SLOT_PER_GIORNO][GIORNI_SETTIMANA];
  30.        
  31. }


Codice sorgente - presumibilmente Java

  1. package corso;
  2.  
  3. import java.io.Serializable;
  4.  
  5. import myLib.typedef.Ora;
  6.  
  7. public class SlotTemporale implements Serializable
  8. {
  9.         private static final long serialVersionUID=0;
  10.        
  11.         public enum Stato_visita_slot
  12.         {
  13.                
  14.                 PRENOTABILE, PRENOTATA, NON_PRENOTABILE;
  15.                
  16.                 public String toString()
  17.                 {
  18.                         return super.toString().toLowerCase();
  19.                 }
  20.                
  21.         }
  22.        
  23.         // Ora
  24.        
  25.         public Ora                                      orario;
  26.         protected int                           id_visita;
  27.         public Stato_visita_slot        stato_slot;
  28.        
  29.         protected SlotTemporale (Ora _ora, int _id, Stato_visita_slot _stato)
  30.         {
  31.                
  32.                 setOrario(_ora);
  33.                 setId_visita(_id);
  34.                 setStato_slot(_stato);
  35.                
  36.         }
  37.        
  38.         /**
  39.          * @return the orario
  40.          */
  41.         public Ora getOrario()
  42.         {
  43.                 return orario;
  44.         }
  45.        
  46.         /**
  47.          * @param orario
  48.          *            the orario to set
  49.          */
  50.         private void setOrario(Ora orario)
  51.         {
  52.                 Ora nuovo = myLib.typedef.Ora.clone(orario);
  53.                 this.orario = nuovo;
  54.         }
  55.        
  56.         /**
  57.          * @return the id_visita
  58.          */
  59.         public int getId_visita()
  60.         {
  61.                 return id_visita;
  62.         }
  63.        
  64.         /**
  65.          * @param id_visita
  66.          *            the id_visita to set
  67.          */
  68.         private void setId_visita(int id_visita)
  69.         {
  70.                 this.id_visita = id_visita;
  71.         }
  72.        
  73.         /**
  74.          * @return the stato_slot
  75.          */
  76.         public Stato_visita_slot getStato_slot()
  77.         {
  78.                 return stato_slot;
  79.         }
  80.        
  81.         /**
  82.          * @param stato_slot
  83.          *            the stato_slot to set
  84.          */
  85.         public void setStato_slot(Stato_visita_slot stato_slot)
  86.         {
  87.                 switch (stato_slot)
  88.                         {
  89.                                 case NON_PRENOTABILE:
  90.                                         this.stato_slot = Stato_visita_slot.NON_PRENOTABILE;
  91.                                         break;
  92.                                 case PRENOTABILE:
  93.                                         this.stato_slot = Stato_visita_slot.PRENOTABILE;
  94.                                         break;
  95.                                 case PRENOTATA:
  96.                                         this.stato_slot = Stato_visita_slot.PRENOTATA;
  97.                                         break;
  98.                                 default:
  99.                                         break;
  100.                         }
  101.                
  102.         }
  103.        
  104. }


Codice sorgente - presumibilmente Java

  1. package corso;
  2.  
  3. import java.util.GregorianCalendar;
  4. import java.util.InputMismatchException;
  5. import java.util.Scanner;
  6.  
  7. import corso.Medico.tipologia_medico;
  8. import myLib.typedef.Enumerations.genere;
  9.  
  10. public class Utente extends Persona
  11. {
  12.         private static final long serialVersionUID=0;
  13.         int id_utente;
  14.        
  15.         /**
  16.          * costruttore
  17.          *
  18.          * @param _nome
  19.          * @param _cognome
  20.          * @param _data_nascita
  21.          * @param _luogo_nascita
  22.          * @param _telefono
  23.          * @param _genere
  24.          * @param _codice_fiscale
  25.          */
  26.         public Utente (String _nome, String _cognome, GregorianCalendar _data_nascita,
  27.                         String _luogo_nascita, String _telefono, char _genere,
  28.                         String _codice_fiscale, int _id)
  29.         {
  30.                 super(_nome, _cognome, _data_nascita, _luogo_nascita, _telefono, _genere, _codice_fiscale);
  31.                 id_utente=_id+1;
  32.         }
  33.        
  34.         public Utente()
  35.         {
  36.                 super();
  37.         }
  38.        
  39.        
  40.         /**
  41.          * interfaccia per creare utente
  42.          *
  43.          * @return variabile utente
  44.          */
  45.        
  46.         public static Utente creaUtenteInterfaccia(int _id)
  47.         {
  48.                 final String RICAPITOLA = "ricapitolazione dell'input:\n\n\n ";
  49.                 final String RIDEFINISCI = "si desidera modificare l'utente? (S/N) ";
  50.                 final String STRINGA_NOME = "inserire nome ";
  51.                 final String STRINGA_COGNOME = "inserire cognome ";
  52.                 final String STRINGA_DATA = "inserire data di nascita ";
  53.                 final String STRINGA_LUOGO = "inserire luogo nascita ";
  54.                 final String STRINGA_TEL = "inserire telefono ";
  55.                
  56.                 Utente ritorno;
  57.                
  58.                 String temp_nome = myLib.util.Input.leggi_stringa(STRINGA_NOME);
  59.                 String temp_cognome = myLib.util.Input.leggi_stringa(STRINGA_COGNOME);
  60.                
  61.                 GregorianCalendar temp_data_nascita = myLib.util.Input.leggi_data(STRINGA_DATA);
  62.                
  63.                 String temp_luogo_nascita = myLib.util.Input.leggi_stringa(STRINGA_LUOGO);
  64.                 String temp_telefono = myLib.util.Input.leggi_stringa(STRINGA_TEL);
  65.                
  66.                 char temp_genere=myLib.util.Input.scegligenerechar();
  67.                 String temp_codice_fiscale = myLib.util.Input.inserisciCodiceFiscale();
  68.                
  69.                 ritorno = new Utente(temp_nome, temp_cognome, temp_data_nascita, temp_luogo_nascita, temp_telefono, temp_genere, temp_codice_fiscale, _id);
  70.                
  71.                 System.out.println(RICAPITOLA);
  72.                
  73.                 System.out.println(ritorno.toString());
  74.                
  75.                 if (myLib.util.Menu.yes_no_Box(RIDEFINISCI, false)) ritorno = creaUtenteInterfaccia(_id);
  76.                
  77.                 return ritorno;
  78.                
  79.         }
  80.        
  81.         /**
  82.          * serve per confrontare uno dei campi
  83.          *
  84.          */
  85.                 public boolean matchcampo(int campo, Object query)
  86.                 {
  87.                         final String PARAM_ERR = "errore nella ricerca. Probabilmente il parametro è scorretto";
  88.                         final int NOME = 1;
  89.                         final int COGNOME = 2;
  90.                         final int DATA = 3;
  91.                         final int LUOGO = 4;
  92.                         final int TEL = 5;
  93.                         final int GENERE = 6;
  94.                         final int CODFISC = 7;
  95.                        
  96.                         final int ID=10;
  97.                        
  98.                         switch (campo)
  99.                                 {
  100.                                         case NOME:
  101.                                                 return super.matchcampo(campo, query);
  102.                                                
  103.                                         case COGNOME:
  104.                                                 return super.matchcampo(campo, query);
  105.                                                
  106.                                         case DATA:
  107.                                                 return super.matchcampo(campo, query);
  108.                                                
  109.                                         case LUOGO:
  110.                                                 return super.matchcampo(campo, query);
  111.                                                
  112.                                         case TEL:
  113.                                                 return super.matchcampo(campo, query);
  114.                                                
  115.                                         case GENERE:
  116.                                                 return super.matchcampo(campo, query);
  117.                                                
  118.                                         case CODFISC:
  119.                                                 return super.matchcampo(campo, query);
  120.                                                
  121.                                         case ID:
  122.                                                
  123.                                                 if (this.id_utente==(int)query) return true;
  124.                                        
  125.                                         break;
  126.                                        
  127.                                         default:
  128.                                                 break;
  129.                                 }
  130.                         return false;
  131.                 }
  132.                
  133.  
  134.         public void modificaUtenteInterfaccia()
  135.         {
  136.                 final String RICAPITOLA = "ricapitolazione dell'input:\n\n\n ";
  137.                 final String RIDEFINISCI = "si desidera modificare l'utente? (S/N) ";
  138.                 final String STRINGA_NOME = "inserire nome. Precedente: ";
  139.                 final String STRINGA_COGNOME = "inserire cognome. Precedente: ";
  140.                 final String STRINGA_DATA = "inserire data di nascita. Precedente: ";
  141.                 final String STRINGA_LUOGO = "inserire luogo nascita. Precedente: ";
  142.                 final String STRINGA_TEL = "inserire telefono. Precedente: ";
  143.                
  144.                
  145.                
  146.                 nome = myLib.util.Input.leggi_stringa(STRINGA_NOME+this.nome);
  147.                 cognome = myLib.util.Input.leggi_stringa(STRINGA_COGNOME+this.cognome);
  148.                
  149.                 data_nascita = myLib.util.Input.leggi_data(STRINGA_DATA+myLib.util.Output.formatDate(this.data_nascita));
  150.                
  151.                 luogo_nascita = myLib.util.Input.leggi_stringa(STRINGA_LUOGO+this.luogo_nascita);
  152.                 telefono = myLib.util.Input.leggi_stringa(STRINGA_TEL+this.telefono);
  153.                
  154.                 genere=myLib.util.Input.scegligenerechar();
  155.                 System.out.println("Precedente codice fiscale: "+ this.codice_fiscale);
  156.                 codice_fiscale = myLib.util.Input.inserisciCodiceFiscale();
  157.                
  158.                 //ritorno = new Utente(temp_nome, temp_cognome, temp_data_nascita, temp_luogo_nascita, temp_telefono, temp_genere, temp_codice_fiscale);
  159.                
  160.                 System.out.println(RICAPITOLA);
  161.                
  162.                 System.out.println(this.toString());
  163.                
  164.                 if (myLib.util.Menu.yes_no_Box(RIDEFINISCI, false)) modificaUtenteInterfaccia();
  165.                
  166.                 //return ritorno;
  167.                
  168.         }
  169.        
  170.        
  171.         public String toString()
  172.         {
  173.                 final String ID = "\n\tid:\t";
  174.                
  175.                 String ritorno = super.toString()+ID+id_utente;
  176.                 return ritorno;
  177.         }
  178.        
  179.        
  180.        
  181.         public boolean equals(Utente confronto)
  182.         {
  183.                        
  184.                 if (confrontapersona(this, confronto) && confrontautente(this, confronto)) return true;
  185.                 else
  186.                         return false;
  187.                
  188.         }
  189.        
  190.         private boolean confrontautente(Utente _1, Utente _2)
  191.         {
  192.                 return (this.id_utente==_2.id_utente);
  193.         }
  194.        
  195.         private boolean confrontapersona(Utente _1, Utente _2)
  196.         {
  197.                 Persona confronto1 = (Persona) _1;
  198.                 Persona confronto2 = (Persona) _2;
  199.                
  200.                 if (confronto1.equals(confronto2)) return true;
  201.                 else
  202.                         return false;
  203.                
  204.         }
  205. }


Codice sorgente - presumibilmente Java

  1. package corso;
  2.  
  3. //import java.sql.Time;
  4. import java.util.GregorianCalendar;
  5.  
  6. import myLib.typedef.Ora;
  7.  
  8. public class Visita
  9. {      
  10.         public enum Stato_visita
  11.         {
  12.                 //NON_PRENOTABILE,
  13.                 //PRENOTABILE,
  14.                 PRENOTATA,
  15.                 CONCLUSA,
  16.                 REFERTATA;
  17.                
  18.                 public String toString()
  19.                 {
  20.                         return super.toString().toLowerCase();
  21.                 }
  22.                
  23.         }
  24.        
  25.         public int id_visita;
  26.        
  27.         public Visita(int utente, String motivo, int medico, GregorianCalendar _data, Ora _ora)
  28.         {
  29.                 setId_utente(utente);
  30.                 setMotivo(motivo);
  31.                 setId_medico(medico);
  32.                 data=_data;
  33.                 ora_visita=_ora;
  34.                 id_visita=calcolaID();
  35.         }
  36.        
  37.        
  38.         private int calcolaID()
  39.         {
  40.                 int ritorno=Classemain.dati.currentVisitaID;
  41.                 Classemain.dati.currentVisitaID++;
  42.                 return ritorno;
  43.         }
  44.        
  45.         /**
  46.        
  47.  
  48.  *
  49.  *
  50.  * TODO DA MIGLIORARE
  51.          *
  52.          */
  53.        
  54.        
  55.         public String toString()
  56.         {
  57.                 return (getId_visita()+getId_utente()+getId_medico()+getMotivo()+getPrescrizione()+getReferto()+getData()+getOra()+getStato_della_visita());
  58.         }
  59.        
  60.        
  61.         /**
  62.          * @return the id_utente
  63.          */
  64.         private int getId_utente()
  65.         {
  66.                 return id_utente;
  67.         }
  68.  
  69.  
  70.         /**
  71.          * @param id_utente the id_utente to set
  72.          */
  73.         private void setId_utente(int id_utente)
  74.         {
  75.                 this.id_utente = id_utente;
  76.         }
  77.  
  78.  
  79.         /**
  80.          * @return the id_medico
  81.          */
  82.         public int getId_medico()
  83.         {
  84.                 return id_medico;
  85.         }
  86.  
  87.  
  88.         /**
  89.          * @param id_medico the id_medico to set
  90.          */
  91.         private void setId_medico(int id_medico)
  92.         {
  93.                 this.id_medico = id_medico;
  94.         }
  95.  
  96.  
  97.         /**
  98.          * @param id_visita the id_visita to set
  99.          */
  100.         private void setId_visita(int id_visita)
  101.         {
  102.                 this.id_visita = id_visita;
  103.         }
  104.  
  105.  
  106.         /**
  107.          * @return the id_visita
  108.          */
  109.         public int getId_visita()
  110.         {
  111.                 return id_visita;
  112.         }
  113.  
  114.         /**
  115.          * @param id_visita the id_visita to set
  116.          */
  117.        
  118.         public boolean matchID(int cfr)
  119.         {
  120.                 if (id_visita==cfr) return true; else return false;
  121.         }
  122.  
  123.         public int id_utente;
  124.        
  125.         private GregorianCalendar data;
  126.        
  127.         public GregorianCalendar getData()
  128.         {
  129.                 return data;
  130.         }
  131.        
  132.         private Ora ora_visita;
  133.        
  134.         public Ora getOra()
  135.         {
  136.                 return ora_visita;
  137.         }
  138.        
  139.         public int id_medico;
  140.        
  141.         private String motivo;
  142.         /**
  143.          * @param motivo the motivo to set
  144.          */
  145.         public void setMotivo(String motivo)
  146.         {
  147.                 this.motivo = motivo;
  148.         }
  149.  
  150.         public String getMotivo()
  151.         {
  152.                 return motivo;
  153.         }
  154.        
  155.         /**
  156.          * @return the stato_della_visita
  157.          */
  158.         public Stato_visita getStato_della_visita()
  159.         {
  160.                 return stato_della_visita;
  161.         }
  162.         /**
  163.          * @param stato_della_visita the stato_della_visita to set
  164.          */
  165.         public void setStato_della_visita(Stato_visita stato_della_visita)
  166.         {
  167.                 this.stato_della_visita = stato_della_visita;
  168.         }
  169.         /**
  170.          * @return the referto
  171.          */
  172.         public String getReferto()
  173.         {
  174.                 return referto;
  175.         }
  176.         /**
  177.          * @param referto the referto to set
  178.          */
  179.         public void setReferto(String referto)
  180.         {
  181.                 this.referto = referto;
  182.         }
  183.         /**
  184.          * @return the prescrizione
  185.          */
  186.         public String getPrescrizione()
  187.         {
  188.                 return prescrizione;
  189.         }
  190.         /**
  191.          * @param prescrizione the prescrizione to set
  192.          */
  193.         public void setPrescrizione(String prescrizione)
  194.         {
  195.                 this.prescrizione = prescrizione;
  196.         }
  197.  
  198.         private Stato_visita stato_della_visita;
  199.        
  200.         private String referto;
  201.        
  202.         private String prescrizione;
  203.        
  204.        
  205.        
  206.         public boolean matchMedico(int query)
  207.         {
  208.                 if (id_medico==query) return true; else return false;
  209.         }
  210.         public boolean matchUtente(int query)
  211.         {
  212.                 if (id_utente==query) return true; else return false;
  213.         }
  214.        
  215. }


PM Quote
Avatar
GN (Member)
Guru


Messaggi: 772
Iscritto: 30/04/2011

Segnala al moderatore
Postato alle 15:46
Mercoledì, 15/07/2015
Testo quotato

Postato originariamente da Bonnox:
l'errore è quello riportato nel titolo


Ops non l'avevo visto, dev'essere il caldo che gioca brutti scherzi xD
Non sono sicuro sia questo il problema, ma se non ricordo male il file deve chiamarsi come la classe, hai controllato? Altra cosa, forse devi passare non il nome del file ma quello esatto della classe (con il package), quindi potresti provare con
Codice sorgente - presumibilmente Plain Text

  1. java corso.Classemain


PM Quote
Avatar
Bonnox (Member)
Pro


Messaggi: 85
Iscritto: 23/08/2014

Segnala al moderatore
Postato alle 16:20
Mercoledì, 15/07/2015
Testo quotato

Postato originariamente da GN:

Testo quotato

Postato originariamente da Bonnox:
l'errore è quello riportato nel titolo


Ops non l'avevo visto, dev'essere il caldo che gioca brutti scherzi xD
Non sono sicuro sia questo il problema, ma se non ricordo male il file deve chiamarsi come la classe, hai controllato? Altra cosa, forse devi passare non il nome del file ma quello esatto della classe (con il package), quindi potresti provare con
Codice sorgente - presumibilmente Plain Text

  1. java corso.Classemain




si tranquillo;

no purtroppo non va nemmeno così ;(
ho pure provato ad esportare in jar ma ovviamente è stato inutile

Siccome poi questi file class li devo consegnare, mi puoi confermare che su altri computer andranno? perchè comunque se su eclipse va, il problema sta da me; sicuramente i professori sapranno come configurare il tutto per farlo partire! :rofl:

ah, lo fa anche con altri progetti. è definitivamente colpa mia/del pc, non del sorgente. :yup:

Ultima modifica effettuata da Bonnox il 15/07/2015 alle 16:22
PM Quote
Avatar
TheDarkJuster (Member)
Guru^2


Messaggi: 1620
Iscritto: 27/09/2013

Segnala al moderatore
Postato alle 19:12
Mercoledì, 15/07/2015
Il file deve chiamarsi  come la classe in cui è presente public static void main(String[] args)

PM Quote
Avatar
pierotofy (Admin)
Guru^2


Messaggi: 6230
Iscritto: 04/12/2003

Segnala al moderatore
Postato alle 0:45
Giovedì, 16/07/2015
Da quale directory stai eseguendo il comando?

La tua classe è dentro il file Classemain.java?

Puoi fare un "ls" oppure "dir" dalla directory?

Dove sono i .class?

Ultima modifica effettuata da pierotofy il 16/07/2015 alle 0:48


Il mio blog: https://piero.dev
PM Quote
Pagine: [ 1 2 3 ] Precedente | Prossimo