Java - reporte de horarios e inicialización del table view de horarios de trabajo de médicos

 
Vista:
Imágen de perfil de Francisco
Val: 85
Ha disminuido su posición en 2 puestos en Java (en relación al último mes)
Gráfica de Java

reporte de horarios e inicialización del table view de horarios de trabajo de médicos

Publicado por Francisco (56 intervenciones) el 09/01/2019 22:22:17
Hola, espero que hayais tenido un feliz año nuevo y os hayais disfrutado muy bien en familia.

Necesito ayuda, por que estoy hacíendo una aplicación como autoevaluación y motivación personal, para mi gusto, para prepararme en la vida.


Estoy hacíendo una app de una clínica para practicar para mi personalidad: Les muestro la clase de la App Principal:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
public class AppPrincipal extends Application {
 
    //Escenario
 
    private Stage escenaPrincipal;
    //plantilla abmMedico;
    private BorderPane plantillaAbmMedico;
 
    //plantilla abmHorarios
 
    private BorderPane plantillaAbmHorarios;
 
 
    //Listas observables
 
    private ObservableList<ControladorDeBaseDeDatos>controladores = FXCollections.observableArrayList();
 
    private ObservableList<Usuario> datosDeUsuarios = FXCollections.observableArrayList();
 
    private ObservableList<Medico> datosDeMedicos = FXCollections.observableArrayList();
 
    private ObservableList<Persona>personas = FXCollections.observableArrayList();
 
    private ObservableList<HorarioDeTrabajo>datosDeHorarios = FXCollections.observableArrayList();
 
 
    //objetos controladores
 
    ControladorDeUsuarios controladorDeUsuarios = new ControladorDeUsuarios();
 
    ControladorDeMedicos controladorDeMedicos = new ControladorDeMedicos();
 
    ControladorDeVistasAbmHorarios controladorDeHorarios = new ControladorDeVistasAbmHorarios();
 
 
 @Override
    public void start(Stage escenaPrincipal) {
 
        this.escenaPrincipal = escenaPrincipal;
 
        escenaPrincipal.initStyle(StageStyle.UNDECORATED);
 
     // setDePruebas();
        inicio();
 
    }
    //Constructor por defecto
    public AppPrincipal(){
        controladores.add(new ControladorDeUsuarios());
        controladores.add(new ControladorDeMedicos());
        controladores.add(new ControladorDeHorariosDeTrabajo());
        controladores.add(new ControladorDePacientes());
        controladores.add(new ControladorDeTurnos());
 
        personas.add(new Administrador());
        personas.add(new Medico());
        personas.add(new Paciente());
 
 
        datosDeUsuarios = controladorDeUsuarios.buscarTodos();
 
        datosDeMedicos = controladorDeMedicos.buscarTodos();
 
    }
 
  //refrescar medicos 
 
    @FXML
    public void refrescarMedicos(){
        datosDeMedicos.clear();
 
        ObservableList<Medico> medicos = controladorDeMedicos.buscarTodos();
 
        datosDeMedicos.setAll(medicos);
    }
 
 //Getter medico
    public ObservableList<Medico> getDatosDeMedicos(){
        return datosDeMedicos;
    }
 
  //inicializar plantillaAbmMedico
    public void inicializarPlantillaAbmMedico() {
        try {
            // Load root layout from fxml file.
            FXMLLoader cargador = new FXMLLoader();
            cargador.setLocation(AppPrincipal.class.getResource("vistas/PlantillaMedicos.fxml"));
            plantillaAbmMedico = (BorderPane) cargador.load();
 
            // Show the scene containing the root layout.
            Scene escena = new Scene(plantillaAbmMedico);
            escenaPrincipal.setScene(escena);
 
            // Give the controller access to the main app.
            ControladorDePlantillaDeMedicos controladorDePlantillaDeMedicos = cargador.getController();
            controladorDePlantillaDeMedicos.setAplicacion(this);
 
 
            escenaPrincipal.show();
 
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        // Try to load last opened person file.
        File archivo = getRutaDeArchivoDeMedico();
        if (archivo != null) {
        cargarDatosMedicoDesdeArchivo(archivo);
       }
 
 
    }
    //mostrar vista medicos
 
     public void mostrarVistaMedicos() {
        try {
            // Load person overview.
            FXMLLoader cargador = new FXMLLoader();
            cargador.setLocation(AppPrincipal.class.getResource("vistas/VistaDeMedicos.fxml"));
            AnchorPane vistaMedicos = (AnchorPane) cargador.load();
 
            // Set person overview into the center of root layout.
              plantillaAbmMedico.setCenter(vistaMedicos);
 
           ControladorDeVistasAbmDeMedicos controladorDeVistasAbmDeMedicos = cargador.getController();
          controladorDeVistasAbmDeMedicos.setApp(this);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
      //inicializar plantillaAbmHorarios
    public void inicializarPlantillaAbmHorarios() {
        try {
            // Load root layout from fxml file.
            FXMLLoader cargador = new FXMLLoader();
            cargador.setLocation(AppPrincipal.class.getResource("vistas/PlantillaHorariosDeTrabajo.fxml"));
            plantillaAbmHorarios = (BorderPane) cargador.load();
 
            // Show the scene containing the root layout.
            Scene escena = new Scene(plantillaAbmHorarios);
            escenaPrincipal.setScene(escena);
 
            ControladorDePlantillaDeHorariosDeTrabajo controladorDePlantillaDeHorarios = cargador.getController();
 
            controladorDePlantillaDeHorarios.setAplicacion(this);
 
 
            escenaPrincipal.show();
 
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        // Try to load last opened person file.
        File archivo = getRutaDeArchivoDeMedico();
        if (archivo != null) {
        cargarDatosHorariosDesdeArchivo(archivo);
       }
 
 
    }
    //mostrar vista medicos
 
     public void mostrarVistaHorarios(HorarioDeTrabajo horario) {
        try {
            // Load person overview.
            FXMLLoader cargador = new FXMLLoader();
            cargador.setLocation(AppPrincipal.class.getResource("vistas/VistaDeHorariosDeTrabajo.fxml"));
            AnchorPane vistaHorarios= (AnchorPane) cargador.load();
 
            // Set person overview into the center of root layout.
              plantillaAbmHorarios.setCenter(vistaHorarios);
 
           ControladorDeVistasAbmHorarios controladorDeVistasAbmHorarios = cargador.getController();
          controladorDeVistasAbmHorarios.setApp(this);
          controladorDeVistasAbmHorarios.setHorarios(horario);
 
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }
}

La clase de vistas de Medicos:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
public class ControladorDeVistasAbmDeMedicos {
 
    @FXML
    private TableView<Medico> tbMedicos;
 
    @FXML
    private TableColumn<Medico,Integer>tbcMatricula;
    @FXML
    private TableColumn<Medico,String>tbcNombre;
    @FXML
    private TableColumn<Medico,String>tbcApellido;
    @FXML
    private TableColumn<Medico,String>tbcEspecialidad;
    @FXML
    private Label lbMatricula;
    @FXML
    private Label lbNombre;
    @FXML
    private Label lbApellido;
    @FXML
    private Label lbEspecialidad;
    @FXML
    private Label lbTelefono;
    @FXML
    private Label lbCorreo;
 
    private AppPrincipal aplicacion;
 
       ControladorDeHorariosDeTrabajo controladorDeHorarios = new ControladorDeHorariosDeTrabajo();
 
       private ObservableList<HorarioDeTrabajo> datosDeHorarios = FXCollections.observableArrayList();
 
 
      /* public int devolverMatricula(int matricula){
           
           return matricula;
       } */
              //Getter horarios
    public ObservableList<HorarioDeTrabajo> getDatosDeHorariosDeTrabajo(){
        return datosDeHorarios;
    }
 
 
       @FXML
    public void refrescarHorarios(int matricula){
 
 
        datosDeHorarios.clear();
 
        matricula = getMatricula();
 
        ObservableList<HorarioDeTrabajo> horarios = controladorDeHorarios.buscarTodos(matricula);
 
        datosDeHorarios.setAll(horarios);
 
    }
 
    public ControladorDeVistasAbmDeMedicos(){
        Localization.setLocale(new Locale("en","ES"));
 
 
    }
    private void mostrarMedicos(Medico medico) {
 
    if (medico != null) {
        // Fill the labels with info from the person object.
        lbMatricula.setText(Integer.toString(medico.getMatricula()));
        lbNombre.setText(medico.getNombre());
        lbApellido.setText(medico.getApellido());
        lbEspecialidad.setText(medico.getEspecialidad());
        lbTelefono.setText(Long.toString(medico.getTelefono()));
        lbCorreo.setText(medico.getCorreo());
 
        // TODO: We need a way to convert the birthday into a String! 
        // birthdayLabel.setText(...);
    } else {
        // Person is null, remove all the text.
        lbMatricula.setText("");
        lbNombre.setText("");
        lbApellido.setText("");
        lbEspecialidad.setText("");
        lbTelefono.setText("");
        lbCorreo.setText("");
    }
    }
      @FXML
    private void initialize(){
 
 
       /// Initialize the person table with the two columns.
        tbcMatricula.setCellValueFactory(cellData -> cellData.getValue().matriculaProperty().asObject());
        tbcNombre.setCellValueFactory(cellData -> cellData.getValue().nombreProperty());
        tbcApellido.setCellValueFactory(cellData -> cellData.getValue().apellidoProperty());
        tbcEspecialidad.setCellValueFactory(cellData -> cellData.getValue().especialidadProperty());
 
      //limpia los detalles personales
        mostrarMedicos(null);
 
 
        // Listen for selection changes and show the person details when changed.
 
     tbMedicos.getSelectionModel().selectedItemProperty().addListener(
             (observable, oldValue, newValue) -> mostrarMedicos(newValue));
 
    }
    public void setApp(AppPrincipal aplicacion){
        this.aplicacion = aplicacion;
 
        tbMedicos.setItems(aplicacion.getDatosDeMedicos());
    }
 
 
 
 
    //Alta-baja-modificacion de medicos
    @FXML
    private void btAgregar(){
         Medico medico = new Medico();
    boolean okClickeado = aplicacion.mostrarNuevoDialogoDeMedico(medico);
    if (okClickeado) {
        aplicacion.getDatosDeMedicos().add(medico);
        aplicacion.refrescarMedicos();
    }
    }
    @FXML
    private void btModificar(){
   /*  
     //Si pongo 0 en el get, .get(0) voy a seleccionar el registro, es decir, toma el indice, el 0 en este caso vendría síendo el primer campo, o mas bien, el identificador del registro.
     TablePosition posicion = tbMedicos.getSelectionModel().getSelectedCells().get(0);


         int registro = posicion.getRow();

         //Aqui cuando dice getColumns().get() el numero que ponga dentro del .get() va a hacer referencia a la columna seleccionada, es decir, selecciono el campo dererminado de la columna determinada, si pongo 1 en el .get(), es decir, .get(1), selecciono la segunda columna. Y si es .get(0) selecciono la primer columna.
    //     Object valorCelda =tbMedicos.getColumns().get(1).getCellObservableValue(registro).getValue();

        Object valorCelda = tbMedicos.getColumns().get(0).getCellObservableValue(registro).getValue();
         String valorCadena = valorCelda.toString();


       int valorMatricula = Integer.parseInt(valorCadena);

      //  System.out.println("valor de matricula: " + valorMatricula);

      */
   //HorarioDeTrabajo horario = new HorarioDeTrabajo();
 
       //     horario.setMatricula(valorMatricula);
       Medico medicoSeleccionado = tbMedicos.getSelectionModel().getSelectedItem();
    if (medicoSeleccionado != null) {
        boolean okClickeado = aplicacion.mostrarDialogoDeEdicionDeMedico(medicoSeleccionado);
        if (okClickeado) {
            mostrarMedicos(medicoSeleccionado);
            aplicacion.refrescarMedicos();
        }
 
    } else {
        // Nothing selected.
 
        Alert alerta = new Alert(Alert.AlertType.WARNING);
 
        alerta.setTitle("no seleccionado");
        alerta.setHeaderText("no se selecciono medico para cambiar sus datos.");
        alerta.setContentText("por favor, selecciona un medico para cambiarle los datos.");
        alerta.initStyle(StageStyle.UTILITY);
        alerta.showAndWait();
    }
}
 
 
 
    @FXML
    private void btEliminar(){
         int selectedIndex = tbMedicos.getSelectionModel().getSelectedIndex();
 
    if(selectedIndex >= 0){
 
   ControladorDeMedicos controladorDeMedicos = new ControladorDeMedicos();
 
   controladorDeMedicos.eliminar(Integer.parseInt(lbMatricula.getText()));
    tbMedicos.getItems().remove(selectedIndex);
 
    Alert alerta = new Alert(Alert.AlertType.CONFIRMATION);
    alerta.setTitle("Eliminando");
    alerta.setHeaderText("medico eliminado con éxito");
    alerta.showAndWait();
    aplicacion.refrescarMedicos();
    }else {
 
        Alert alerta = new Alert(Alert.AlertType.WARNING);
 
        alerta.setTitle("no seleccionada.");
        alerta.setHeaderText("no se seleccionó un medico");
        alerta.setContentText("por favor selecciona un medico de la tabla");
        alerta.showAndWait();
 
 
        }
    }
    @FXML
    private void btHorarios(){
 
        int valorMatricula = getMatricula();
 
           HorarioDeTrabajo horario = new HorarioDeTrabajo();
 
           horario.setMatricula(valorMatricula);
 
           aplicacion.inicializarPlantillaAbmHorarios();
           aplicacion.mostrarVistaHorarios(horario);
    }
    public int getMatricula(){
 
 
 
     //Si pongo 0 en el get, .get(0) voy a seleccionar el registro, es decir, toma el indice, el 0 en este caso vendría síendo el primer campo, o mas bien, el identificador del registro.
     //El .get(0) hace referencia a una convención de java.
     TablePosition posicion = tbMedicos.getSelectionModel().getSelectedCells().get(0);
 
 
         int registro = posicion.getRow();
 
         //Aqui cuando dice getColumns().get() el numero que ponga dentro del .get() va a hacer referencia a la columna seleccionada, es decir, selecciono el campo dererminado de la columna determinada, si pongo 1 en el .get(), es decir, .get(1), selecciono la segunda columna. Y si es .get(0) selecciono la primer columna.
    //     Object valorCelda =tbMedicos.getColumns().get(1).getCellObservableValue(registro).getValue();
 
        Object valorCelda = tbMedicos.getColumns().get(0).getCellObservableValue(registro).getValue();
         String valorCadena = valorCelda.toString();
 
 
       int valorMatricula = Integer.parseInt(valorCadena);
 
      //  System.out.println("valor de matricula: " + valorMatricula);
 
      return valorMatricula;
 
    }
    @FXML
    private void btVolver(){
        aplicacion.menuDeAdministrador();
    }
 
}

Y la clase de vistas de horarios:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
public class ControladorDeVistasAbmHorarios {
 
    @FXML
    private Label lbMatricula;
 
     @FXML
    private TableView<HorarioDeTrabajo> tbHorarios;
 
    @FXML
    private TableColumn<HorarioDeTrabajo,String>tbcDiaTrabajo;
    @FXML
    private TableColumn<HorarioDeTrabajo,LocalTime>tbcHoraEntrada;
    @FXML
    private TableColumn<HorarioDeTrabajo,LocalTime>tbcHoraSalida;
 
 
    private AppPrincipal aplicacionPrincipal;
 
 
  ControladorDeVistasAbmDeMedicos controladorDeHorariosDeMedicos = new ControladorDeVistasAbmDeMedicos();
 
 
 
      public void setApp(AppPrincipal aplicacion){
        this.aplicacionPrincipal = aplicacion;
 
        tbHorarios.setItems(controladorDeHorariosDeMedicos.getDatosDeHorariosDeTrabajo());
    }
 
        public void setHorarios(HorarioDeTrabajo horario){
 
            lbMatricula.setText(Integer.toString(horario.getMatricula()));
        }
        public ControladorDeVistasAbmHorarios(){
             Localization.setLocale(new Locale("en","ES"));
 
 
 
        }
 
    private void mostrarHorarios(HorarioDeTrabajo horario){
 
        if(horario != null){
             lbMatricula.setText(Integer.toString(horario.getMatricula()));
 
        }
        else{
             lbMatricula.setText("");
        }
 
    }
      @FXML
    private void initialize(){
 
 
        tbcDiaTrabajo.setCellValueFactory(cellData -> cellData.getValue().diaDeTrabajoProperty());
        tbcHoraEntrada.setCellValueFactory(cellData -> cellData.getValue().horaDeEntradaProperty());
        tbcHoraSalida.setCellValueFactory(cellData -> cellData.getValue().horaDeSalidaProperty());
 
      //limpia los detalles personales
        mostrarHorarios(null);
 
 
        // Listen for selection changes and show the person details when changed.
 
     tbHorarios.getSelectionModel().selectedItemProperty().addListener(
             (observable, oldValue, newValue) -> mostrarHorarios(newValue));
 
    }
 
 
       //Alta-baja-modificacion de medicos
    @FXML
    private void btAgregar(){
 
       int matricula = Integer.parseInt(lbMatricula.getText());
         HorarioDeTrabajo horario = new HorarioDeTrabajo();
 
         horario.setMatricula(Integer.parseInt(lbMatricula.getText()));
    boolean okClickeado = aplicacionPrincipal.mostrarNuevoDialogoDeHorarios(horario);
    if (okClickeado) {
        controladorDeHorariosDeMedicos.getDatosDeHorariosDeTrabajo().add(horario);
        controladorDeHorariosDeMedicos.refrescarHorarios(matricula);
    }
    }
    @FXML
    private void btModificar(){
   /*  
     //Si pongo 0 en el get, .get(0) voy a seleccionar el registro, es decir, toma el indice, el 0 en este caso vendría síendo el primer campo, o mas bien, el identificador del registro.
     TablePosition posicion = tbMedicos.getSelectionModel().getSelectedCells().get(0);
        
        
         int registro = posicion.getRow();
         
         //Aqui cuando dice getColumns().get() el numero que ponga dentro del .get() va a hacer referencia a la columna seleccionada, es decir, selecciono el campo dererminado de la columna determinada, si pongo 1 en el .get(), es decir, .get(1), selecciono la segunda columna. Y si es .get(0) selecciono la primer columna.
    //     Object valorCelda =tbMedicos.getColumns().get(1).getCellObservableValue(registro).getValue();
         
        Object valorCelda = tbMedicos.getColumns().get(0).getCellObservableValue(registro).getValue();
         String valorCadena = valorCelda.toString();

        
       int valorMatricula = Integer.parseInt(valorCadena);
        
      //  System.out.println("valor de matricula: " + valorMatricula);
      
      */
   //HorarioDeTrabajo horario = new HorarioDeTrabajo();
 
       //     horario.setMatricula(valorMatricula);
 
      int matricula = Integer.parseInt(lbMatricula.getText());
       HorarioDeTrabajo horarioSeleccionado = tbHorarios.getSelectionModel().getSelectedItem();
    if (horarioSeleccionado != null) {
        boolean okClickeado = aplicacionPrincipal.mostrarDialogoDeEdicionHorarios(horarioSeleccionado);
        if (okClickeado) {
            mostrarHorarios(horarioSeleccionado);
            controladorDeHorariosDeMedicos.refrescarHorarios(matricula);
        }
 
    } else {
        // Nothing selected.
 
        Alert alerta = new Alert(Alert.AlertType.WARNING);
 
        alerta.setTitle("no seleccionado");
        alerta.setHeaderText("no se selecciono horario para cambiar sus datos.");
        alerta.setContentText("por favor, selecciona un horario para cambiarle los datos.");
        alerta.initStyle(StageStyle.UTILITY);
        alerta.showAndWait();
    }
}
 
 
 
    @FXML
    private void btEliminar(){
         int selectedIndex = tbHorarios.getSelectionModel().getSelectedIndex();
 
    if(selectedIndex >= 0){
 
     //Si pongo 0 en el get, .get(0) voy a seleccionar el registro, es decir, toma el indice, el 0 en este caso vendría síendo el primer campo, o mas bien, el identificador del registro.
     //El .get(0) hace referencia a una convención de java.
     TablePosition posicionDias = tbHorarios.getSelectionModel().getSelectedCells().get(0);
 
 
         int registroDias = posicionDias.getRow();
 
         //Aqui cuando dice getColumns().get() el numero que ponga dentro del .get() va a hacer referencia a la columna seleccionada, es decir, selecciono el campo dererminado de la columna determinada, si pongo 1 en el .get(), es decir, .get(1), selecciono la segunda columna. Y si es .get(0) selecciono la primer columna.
    //     Object valorCelda =tbMedicos.getColumns().get(1).getCellObservableValue(registro).getValue();
 
        Object valorCelda = tbHorarios.getColumns().get(0).getCellObservableValue(registroDias).getValue();
         String valorCadena = valorCelda.toString();
 
 
     //Si pongo 0 en el get, .get(0) voy a seleccionar el registro, es decir, toma el indice, el 0 en este caso vendría síendo el primer campo, o mas bien, el identificador del registro.
     //El .get(0) hace referencia a una convención de java.
     TablePosition posicionHoraEntrada = tbHorarios.getSelectionModel().getSelectedCells().get(0);
 
 
         int registroHoraEntrada = posicionHoraEntrada.getRow();
 
         //Aqui cuando dice getColumns().get() el numero que ponga dentro del .get() va a hacer referencia a la columna seleccionada, es decir, selecciono el campo dererminado de la columna determinada, si pongo 1 en el .get(), es decir, .get(1), selecciono la segunda columna. Y si es .get(0) selecciono la primer columna.
    //     Object valorCelda =tbMedicos.getColumns().get(1).getCellObservableValue(registro).getValue();
 
        Object valorCeldaHorarios = tbHorarios.getColumns().get(1).getCellObservableValue(registroHoraEntrada).getValue();
         String valorCadenaHorarios = valorCeldaHorarios.toString();
 
         LocalTime horaEntrada = LocalTime.parse(valorCadenaHorarios);
 
   controladorDeHorariosDeMedicos.controladorDeHorarios.eliminar(Integer.parseInt(lbMatricula.getText()),valorCadena, horaEntrada);
 
    tbHorarios.getItems().remove(selectedIndex);
   int matricula = controladorDeHorariosDeMedicos.getMatricula();
 
    Alert alerta = new Alert(Alert.AlertType.CONFIRMATION);
    alerta.setTitle("Eliminando");
    alerta.setHeaderText("horario eliminado con éxito");
    alerta.showAndWait();
    controladorDeHorariosDeMedicos.refrescarHorarios(matricula);
    }else {
 
        Alert alerta = new Alert(Alert.AlertType.WARNING);
 
        alerta.setTitle("no seleccionada.");
        alerta.setHeaderText("no se seleccionó un horario");
        alerta.setContentText("por favor selecciona un horario");
        alerta.showAndWait();
 
        }
    }
 
    @FXML
    private void btVolver(){
        aplicacionPrincipal.inicializarPlantillaAbmMedico();
        aplicacionPrincipal.mostrarVistaMedicos();
    }
 
}

Y la clase de plantilla de horarios:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package programacion2ExamenFinal.vistas;
 
import java.io.File;
import java.util.List;
import javafx.fxml.FXML;
import javafx.scene.control.Alert;
import javafx.stage.FileChooser;
import javafx.stage.StageStyle;
import javax.swing.JOptionPane;
import programacion2ExamenFinal.AppPrincipal;
import programacion2ExamenFinal.clasesDeModelo.Persona;
import programacion2ExamenFinal.clasesDeReporte.DisplayReporteDeHorarios;
 
/**
 *
 * @author F
 */
public class ControladorDePlantillaDeHorariosDeTrabajo {
 
 
      private AppPrincipal aplicacionPrincipal;
 
    private List<Persona> personas;
 
     ControladorDeVistasAbmHorarios controladorDeHorarios = new ControladorDeVistasAbmHorarios();
 
     ControladorDeVistasAbmDeMedicos  controladorDeHorariosDeMedicos = new ControladorDeVistasAbmDeMedicos();
 
    public void setAplicacion(AppPrincipal aplicacion){
        this.aplicacionPrincipal = aplicacion;
    }
 
 
 
 
 
     @FXML
    private void btNuevo(){
        controladorDeHorariosDeMedicos.getDatosDeHorariosDeTrabajo().clear();
        aplicacionPrincipal.setRutaDeArchivoDeHorarios(null);
 
    }
    @FXML
    private void btGuardarComo(){
           FileChooser archivoEscogedor = new FileChooser();
 
 
        // Set extension filter
        FileChooser.ExtensionFilter filtroDeExtension = new FileChooser.ExtensionFilter(
                "XML files (*.xml)", "*.xml");
        archivoEscogedor.getExtensionFilters().add(filtroDeExtension);
 
        // Show save file dialog
        File archivo = archivoEscogedor.showSaveDialog(aplicacionPrincipal.getEscenaPrincipal());
 
        if (archivo != null) {
            // Make sure it has the correct extension
            if (!archivo.getPath().endsWith(".xml")) {
                archivo = new File(archivo.getPath() + ".xml");
            }
 
            aplicacionPrincipal.guardarDatosHorariosEnArchivo(archivo);
          Alert alerta = new Alert(Alert.AlertType.CONFIRMATION);
            alerta.initOwner(aplicacionPrincipal.getEscenaPrincipal());
            alerta.setTitle("Guardado");
            alerta.setHeaderText("archivo guardado con éxito.");
            alerta.setContentText("ruta del archivo: " + archivo.getPath());
            alerta.initStyle(StageStyle.UNDECORATED);
            alerta.showAndWait();
 
        }
    }
    @FXML
    private void btGuardar(){
         File archivoDeHorarios = aplicacionPrincipal.getRutaDeArchivoDeHorarios();
        if (archivoDeHorarios != null) {
 
            aplicacionPrincipal.guardarDatosHorariosEnArchivo(archivoDeHorarios);
 
             Alert alerta = new Alert(Alert.AlertType.INFORMATION);
            alerta.initOwner(aplicacionPrincipal.getEscenaPrincipal());
            alerta.setTitle("Guardado");
            alerta.setHeaderText("archivo guardado con éxito.");
            alerta.setContentText("ruta del archivo: " + archivoDeHorarios);
            alerta.initStyle(StageStyle.UNDECORATED);
            alerta.showAndWait();
 
        } else {
            btGuardarComo();
        }
 
    }
    @FXML
    private void btAbrir(){
         FileChooser archivoEscogedor = new FileChooser();
 
        // Set extension filter
        FileChooser.ExtensionFilter filtroDeExtension = new FileChooser.ExtensionFilter(
                "XML files (*.xml)", "*.xml");
        archivoEscogedor.getExtensionFilters().add(filtroDeExtension);
 
        // Show save file dialog
        File archivo = archivoEscogedor.showOpenDialog(aplicacionPrincipal.getEscenaPrincipal());
 
 
 
        if (archivo != null) {
            aplicacionPrincipal.cargarDatosHorariosDesdeArchivo(archivo);
            Alert alerta = new Alert(Alert.AlertType.CONFIRMATION);
            alerta.setTitle("Cargado");
            alerta.setHeaderText("archivo cargado exitosamente");
            alerta.setContentText("ruta del archivo: " + archivo.getPath());
            alerta.initStyle(StageStyle.UNDECORATED);
            alerta.showAndWait();
        }
    }
 
    @FXML
    private void btGestionarReporte(){
 
        DisplayReporteDeHorarios displayHorarios = new DisplayReporteDeHorarios();
 
        int matricula = Integer.parseInt(JOptionPane.showInputDialog(null,"ingrese matricula"));
        displayHorarios.mostrarHorariosDeTrabajo(matricula);
    }
    @FXML
    private void btPresentarse(){
 
        personas = aplicacionPrincipal.getPersonas();
 
        for(Persona t:this.personas){
            t.presentarse();
        }
    }
    @FXML
    private void btTrabajar(){
        personas = aplicacionPrincipal.getPersonas();
 
        for(Persona k:this.personas){
            k.trabajar();
        }
    }
}

El tema es que estoy hacíendo mal la inicialización del table view de los horarios de trabajo de los médicos. Se los escribo así en pseudocódigo, yo quiero algo así:

tbHorarios.setItems(controladorDeHorariosDeMedicos.getDatosDeHorariosDeTrabajo());

Y que en el constructor guarde en un Observable List de tipo HorarioDeTrabajo llamado horarios así

ObservableList<HorarioDeTrabajo> horarios = ControladorDeHorariosDeTrabajo.BuscarTodos(matricula);

Y matricula = Integer.parseInt(lbMatricula.getText());

o sea, lograr inicializar el tableView de los horarios.

Y que cuando agregue un horario y lo actualice se me refleje igual que en la bd para evitar inconsistencia.

Mi duda es si el metodo de refrescar horarios tiene que recibir o no el parametro matricula.

Y la última duda que tengo:

Yo en la plantilla de horarios de trabajo utilicé un JOptionPane que al ingresar la matricula me largue el reporte pero me explota el programa.

Yo cuando cree un report wizard lo híce con la siguiente consulta:

SELECT * FROM `horariosdetrabajo` WHERE `matricula`=(@matricula)

La app la estoy hacíendo en java fx.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder