View Javadoc

1   package ecar.dao;
2   
3   import java.util.ArrayList;
4   import java.util.Collections;
5   import java.util.Comparator;
6   import java.util.Date;
7   import java.util.HashSet;
8   import java.util.Iterator;
9   import java.util.List;
10  import java.util.Set;
11  
12  import javax.servlet.http.HttpServletRequest;
13  
14  import comum.database.Dao;
15  import comum.util.Data;
16  
17  import ecar.exception.ECARException;
18  import ecar.pojo.AcompReferenciaItemAri;
19  import ecar.pojo.HistoricoPtcH;
20  import ecar.pojo.ItemEstruturaIett;
21  import ecar.pojo.ParametroPar;
22  import ecar.pojo.PontoCriticoPtc;
23  import ecar.pojo.ServicoParametroSerPar;
24  import ecar.pojo.ServicoSer;
25  
26  public class ServicoDao extends Dao {
27  
28    public ServicoDao(HttpServletRequest request) {
29      super();
30      super.request = request;
31    }
32  
33    /**
34     * (1)Apuração de Conclusão de Datas Críticas (Pontos Críticos) Calcular o
35     * percentual de Datas Críticas que foram solucionadas (concluídas) - basear o
36     * cálculo nos dados que estiverem no cadastro/histórico de datas críticas do
37     * item. O cálculo deverá ser realizado em função do número de datas críticas
38     * concluídas até a data base passada como parâmetro. Basear os cálculos no
39     * estado do item no dia da data base
40     * @param itemEstrutura item para o qual se deseja fazer as apurações
41     * @param dataBase dia de referencia para realização das apurações
42     * @throws ECARException
43     * @author 05110500460
44     */
45  
46    public double apuracaoConclusaoPontosCriticos(ItemEstruturaIett itemEstrutura, Date dataBase) throws ECARException {
47      double numDataCadastrada = 0;
48      double numDataConcluida = 0;
49      PontoCriticoDao pontoCriticoDao = new PontoCriticoDao(null);
50  
51      if (itemEstrutura == null || dataBase == null) {
52        throw new ECARException();
53      }
54  
55      List<PontoCriticoPtc> pontosCriticos = pontoCriticoDao.listarItensIncluidosAntesDaDataBase(itemEstrutura, Data.addDias(1, dataBase));
56  
57      if (pontosCriticos != null && pontosCriticos.size() > 0) {
58        numDataCadastrada = getTotalPontosCriticos(pontosCriticos, dataBase);
59      }
60      if (numDataCadastrada == 0) {
61        return numDataCadastrada;
62      }
63  
64      for (Iterator itPontosCriticos = pontosCriticos.iterator(); itPontosCriticos.hasNext();) {
65        PontoCriticoPtc pontoCritico = (PontoCriticoPtc) itPontosCriticos.next();
66  
67        // se a última atualização no dia ou antes da dataBase
68        if ((pontoCritico.getDataUltManutencaoPtc() != null && Data.compareAnoMesDia(pontoCritico.getDataUltManutencaoPtc(), dataBase) <= 0) || (pontoCritico.getDataUltManutencaoPtc() == null)) {
69          // Verificar se o pontoCritico está concluído na data Base
70          if (pontoCritico.getDataSolucaoPtc() != null && (Data.compareAnoMesDia(pontoCritico.getDataSolucaoPtc(), dataBase) <= 0) && (!estaExcluido(pontoCritico))) {
71            numDataConcluida++;
72          }
73        }
74        else {
75          HistoricoPtcH historico = recuperaEstadoDasDatasNaDataBase(pontoCritico, dataBase);
76          // Verificar se no historico o Ponto Critico está concluido na
77          // data Base
78          if (historico != null && historico.getDataSolucaoPtc() != null && (Data.compareAnoMesDia(historico.getDataSolucaoPtc(), dataBase) <= 0) && (!estaExcluido(historico))) {
79            numDataConcluida++;
80          }
81        }
82      } // fim for
83  
84      return 100 * numDataConcluida / numDataCadastrada;
85    }
86  
87    /**
88     * (1)Apuração de Conclusão de Datas Críticas (Pontos Críticos) Calcular o
89     * percentual de Datas Críticas que foram solucionadas (concluídas) - basear o
90     * cálculo nos dados que estiverem no cadastro/histórico de datas críticas do
91     * item. O cálculo deverá ser realizado em função do número de datas críticas
92     * concluídas até a data base passada como parâmetro. Basear os cálculos no
93     * estado do item no dia da data base
94     * @param itemEstrutura item para o qual se deseja fazer as apurações
95     * @param dataBase dia de referência para realização das apurações no formato
96     *          dd/mm/aaaa
97     * @return percentual de Pontos Críticos concluídos no dia da dataBase
98     * @throws ECARException
99     * @author 05110500460
100    */
101   public double apuracaoConclusaoPontosCriticos(String codIett, String dataBase) throws ECARException {
102     ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, Long.valueOf(codIett));
103     Date data = Data.parseDate(dataBase);
104 
105     if (itemEstrutura == null || data == null) {
106       throw new ECARException();
107     }
108 
109     return this.apuracaoConclusaoPontosCriticos(itemEstrutura, data);
110   }
111 
112   /**
113    * (2)Apuração de Atraso de Conclusão de Datas Críticas (Pontos Críticos)
114    * Calcular o percentual de Datas Críticas que foram concluídas (solucionadas)
115    * depois da data fim - basear o cálculo nos dados que estiverem no cadastro
116    * do item. O cálculo deverá ser realizado em função do número de datas
117    * críticas concluídas depois da data fim, ou datas críticas não concluídas e
118    * cuja data de conclusão prevista já ultrapassa a data base passada como
119    * parâmetro. Basear os cálculos no estado do item no dia da data base.
120    * @param itemEstrutura item para o qual se deseja fazer as apurações
121    * @param dataBase dia de referência para realização das apurações
122    * @return percentual de Pontos Críticos com atraso de conclusão no dia da
123    *         dataBase
124    * @throws ECARException
125    * @author 05110500460
126    */
127   public double apuracaoAtrasoConclusaoPontosCriticos(ItemEstruturaIett itemEstrutura, Date dataBase) throws ECARException {
128     PontoCriticoDao pontoCriticoDao = new PontoCriticoDao(null);
129     double numDataCadastrada = 0;
130     double numDataAtrasoConclusao = 0;
131 
132     if (itemEstrutura == null) {
133       throw new ECARException();
134     }
135 
136     List<PontoCriticoPtc> pontosCriticos = pontoCriticoDao.listarItensIncluidosAntesDaDataBase(itemEstrutura, Data.addDias(1, dataBase));
137 
138     if (pontosCriticos != null && pontosCriticos.size() > 0) {
139       numDataCadastrada = getTotalPontosCriticos(pontosCriticos, dataBase);
140     }
141     if (numDataCadastrada == 0) {
142       return numDataCadastrada;
143     }
144 
145     for (Iterator itPontosCriticos = pontosCriticos.iterator(); itPontosCriticos.hasNext();) {
146       PontoCriticoPtc pontoCritico = (PontoCriticoPtc) itPontosCriticos.next();
147 
148       // Ultima modificação antes da database
149       if ((pontoCritico.getDataUltManutencaoPtc() != null && Data.compareAnoMesDia(pontoCritico.getDataUltManutencaoPtc(), dataBase) <= 0) || (pontoCritico.getDataUltManutencaoPtc() == null)) { // Não
150                                                                                                                                                                                                   // houve
151                                                                                                                                                                                                   // modificação
152         if (pontoCritico.getDataLimitePtc() != null && (!estaExcluido(pontoCritico))
153         // Verifica se a Data Limite é menor do que a data da solução
154         && (pontoCritico.getDataSolucaoPtc() != null && (Data.compareAnoMesDia(pontoCritico.getDataLimitePtc(), pontoCritico.getDataSolucaoPtc()) < 0))
155         // Verifica se já passou da data base e não foi solucionado
156         || (pontoCritico.getDataSolucaoPtc() == null && (Data.compareAnoMesDia(pontoCritico.getDataLimitePtc(), dataBase) < 0))
157 
158         ) {
159           numDataAtrasoConclusao++;
160         }
161       }
162       else {
163         // buscar no historico
164         HistoricoPtcH historico = this.recuperaEstadoDasDatasNaDataBase(pontoCritico, dataBase);
165 
166         if (historico != null && historico.getDataLimitePtc() != null && (!estaExcluido(historico)) && ( // Verifica
167                                                                                                          // se
168                                                                                                          // no
169                                                                                                          // dia
170                                                                                                          // da
171                                                                                                          // Data
172                                                                                                          // Base
173                                                                                                          // havia
174                                                                                                          // solução
175         (historico.getDataSolucaoPtc() != null
176         // Verifica no histórico se a Data Limite é menor do que a data da
177         // solução
178         && (Data.compareAnoMesDia(historico.getDataLimitePtc(), historico.getDataSolucaoPtc()) < 0))
179         // Verifica se já passou da data base e não foi solucionado
180         || (historico.getDataSolucaoPtc() == null && (Data.compareAnoMesDia(historico.getDataLimitePtc(), dataBase) < 0)))) {
181           numDataAtrasoConclusao++;
182         }
183       }// fim else - historico
184     }// fim for
185     return 100 * numDataAtrasoConclusao / numDataCadastrada;
186   }
187 
188   /**
189    * (2)Apuração de Atraso de Conclusão de Datas Críticas (Pontos Críticos)
190    * Calcular o percentual de Datas Críticas que foram concluídas (solucionadas)
191    * depois da data fim - basear o cálculo nos dados que estiverem no cadastro
192    * do item. O cálculo deverá ser realizado em função do número de datas
193    * críticas concluídas depois da data fim, ou datas críticas não concluídas e
194    * cuja data de conclusão prevista já ultrapassa a data base passada como
195    * parâmetro. Basear os cálculos no estado do item no dia da data base.
196    * @param itemEstrutura item para o qual se deseja fazer as apurações
197    * @param dataBase dia de referência para realização das apurações no formato
198    *          dd/mm/aaaa
199    * @return percentual de Pontos Críticos com atraso de conclusão no dia da
200    *         dataBase
201    * @throws ECARException
202    * @author 05110500460
203    */
204   public double apuracaoAtrasoConclusaoPontosCriticos(String codIett, String dataBase) throws ECARException {
205     ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, Long.valueOf(codIett));
206     Date data = Data.parseDate(dataBase);
207 
208     if (itemEstrutura == null || data == null) {
209       throw new ECARException();
210     }
211 
212     return apuracaoAtrasoConclusaoPontosCriticos(itemEstrutura, data);
213   }
214 
215   /**
216    * (3)Apuração de Total de Datas Críticas (Pontos Críticos) Calcular a
217    * quantidade total de Datas Críticas cadastradas para um item - basear o
218    * cálculo nos dados que estiverem no cadastro do item. Basear os cálculos no
219    * estado do item no dia da data base
220    * @param itemEstrutura item para o qual se deseja fazer as apurações
221    * @param dataBase dia de referência para realização das apurações
222    * @return quantidade de Pontos Críticos no cadastro no dia da dataBase
223    * @throws ECARException
224    * @author 05110500460
225    */
226   public double apuracaoTotalPontosCriticos(ItemEstruturaIett itemEstrutura, Date dataBase) throws ECARException {
227     if (itemEstrutura == null || dataBase == null) {
228       throw new ECARException();
229     }
230     double contTotal = 0;
231     List<PontoCriticoPtc> list = (new PontoCriticoDao(null)).listarItensIncluidosAntesDaDataBase(itemEstrutura, Data.addDias(1, dataBase));
232 
233     contTotal = getTotalPontosCriticos(list, dataBase);
234 
235     return contTotal;
236   }
237 
238   /**
239    * (3)Apuração de Total de Datas Críticas (Pontos Críticos) Calcular a
240    * quantidade total de Datas Críticas cadastradas para um item - basear o
241    * cálculo nos dados que estiverem no cadastro do item. Basear os cálculos no
242    * estado do item no dia da data base
243    * @param itemEstrutura item para o qual se deseja fazer as apurações
244    * @param dataBase dia de referência para realização das apurações no formato
245    *          dd/mm/aaaa
246    * @return quantidade de Pontos Críticos no cadastro no dia da dataBase
247    * @throws ECARException
248    * @author 05110500460
249    */
250   public double apuracaoTotalPontosCriticos(String codIett, String dataBase) throws ECARException {
251     ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, Long.valueOf(codIett));
252     Date data = Data.parseDate(dataBase);
253 
254     if (itemEstrutura == null || data == null) {
255       throw new ECARException();
256     }
257 
258     return this.apuracaoTotalPontosCriticos(itemEstrutura, data);
259   }
260 
261   /**
262    * (4)Apuração de Reprogramação de Datas Críticas (Pontos Críticos) - Cálculo
263    * de Extensão de Prazo Calcular a taxa de replanejamento das datas críticas -
264    * basear o cálculo nos dados que estiverem no cadastro do item e no histórico
265    * de datas críticas. O cálculo deverá ser realizado em função do número de
266    * extensões realizadas no prazo das datas críticas do item e o número total
267    * de datas críticas. Basear os cálculos no estado do item no dia da data base
268    * @param itemEstrutura item para o qual se deseja fazer as apurações
269    * @param dataBase dia de referência para realização das apurações
270    * @return percentual de Pontos Críticos que reprogramaram extenção de prazo
271    *         até o dia da Data Base
272    * @throws ECARException
273    * @author 05110500460
274    */
275 
276   public double apuracaoReprogramacaoExtensaoPontosCriticos(ItemEstruturaIett itemEstrutura, Date dataBase) throws ECARException {
277 
278     if (itemEstrutura == null) {
279       throw new ECARException();
280     }
281 
282     double numDataCadastrada = 0;
283     int numDatasExtendidas = 0;
284     PontoCriticoDao pontoCriticoDao = new PontoCriticoDao(null);
285     List<HistoricoPtcH> listHistPtc = null;
286     HistoricoPtcH historicoAnterior = null;
287     List<PontoCriticoPtc> pontosCriticos = pontoCriticoDao.listarItensIncluidosAntesDaDataBase(itemEstrutura, Data.addDias(1, dataBase));
288 
289     if (pontosCriticos != null && pontosCriticos.size() > 0) {
290       numDataCadastrada = getTotalPontosCriticos(pontosCriticos, dataBase);
291     }
292     if (numDataCadastrada == 0) {
293       return numDataCadastrada;
294     }
295 
296     for (PontoCriticoPtc pontoCritico : pontosCriticos) {
297       listHistPtc = pontoCriticoDao.listarHistorico(pontoCritico, Data.addDias(1, dataBase));
298       historicoAnterior = null;
299       Set<Date> datasLimites = null;
300 
301       // Não apresentou modificação no histórico
302       if (listHistPtc.size() == 0) {
303         continue;
304       }
305       datasLimites = new HashSet<Date>(listHistPtc.size());
306 
307       for (HistoricoPtcH historico : listHistPtc) {
308         // Se a última manutenção for antes da dataBase é para considerar a
309         // situação atual do item
310         if (pontoCritico.getDataUltManutencaoPtc() != null && Data.compareAnoMesDia(pontoCritico.getDataUltManutencaoPtc(), dataBase) <= 0) {
311 
312           if (estaExcluido(pontoCritico)) {
313             break;
314           }
315 
316           // Verifica se os valores são Nulos
317           else if ((pontoCritico.getDataLimitePtc() != null && historico != null && historico.getDataLimitePtc() != null)
318           // Verifica se a data Limite atual é maior do que a apresentada no
319           // historico
320           && Data.compareAnoMesDia(pontoCritico.getDataLimitePtc(), historico.getDataLimitePtc()) > 0) {
321             numDatasExtendidas++;
322             break; // pára o loop de histórico
323           }
324           else if (estaExcluido(pontoCritico)) {
325             break;
326           }
327         }
328 
329         if (historico != null && historicoAnterior != null) {
330           if (historico.getDataLimitePtc() != null && historicoAnterior.getDataLimitePtc() != null && (!estaExcluido(historico)) && Data.compareAnoMesDia(historico.getDataLimitePtc(), historicoAnterior.getDataLimitePtc()) > 0) {
331             numDatasExtendidas++;
332             break;
333           }
334         }
335 
336         if (historico != null && historico.getDataLimitePtc() != null && (!estaExcluido(historico))) {
337           boolean temNoHistorico = false;
338 
339           if (historico.getDataUltManutencaoPtc() == null && historico.getDataLimitePtc() != null) {
340             datasLimites.add(historico.getDataLimitePtc());
341           }
342           else {
343             for (Date date : datasLimites) {
344               // Se alguma data anterior for menor do que a data do
345               // historico
346               if (date.compareTo(historico.getDataLimitePtc()) < 0) {
347                 numDatasExtendidas++;
348                 temNoHistorico = true;
349                 break; // loop datasLimites
350               }
351             }
352             if (temNoHistorico) {
353               break; // para loop de historico
354             }
355             datasLimites.add(historico.getDataLimitePtc());
356           }
357         }
358 
359         if (historico.getDataUltManutencaoPtc() != null)
360           historicoAnterior = historico;// Para comparar com o valor anterior
361       } // fim for do loop de historico
362     }
363 
364     return 100 * numDatasExtendidas / numDataCadastrada;
365   }
366 
367   /**
368    * (4)Apuração de Reprogramação de Datas Críticas (Pontos Críticos) - Cálculo
369    * de Extensão de Prazo Calcular a taxa de replanejamento das datas críticas -
370    * basear o cálculo nos dados que estiverem no cadastro do item e no histórico
371    * de datas críticas. O cálculo deverá ser realizado em função do número de
372    * extensões realizadas no prazo das datas críticas do item e o número total
373    * de datas críticas. Basear os cálculos no estado do item no dia da data base
374    * @param itemEstrutura item para o qual se deseja fazer as apurações
375    * @param dataBase dia de referência para realização das apurações no formato
376    *          dd/mm/aaaa
377    * @return percentual de Pontos Críticos que reprogramaram extenção de prazo
378    *         até o dia da Data Base
379    * @throws ECARException
380    * @author 05110500460
381    */
382   public double apuracaoReprogramacaoExtensaoPontosCriticos(String codIett, String dataBase) throws ECARException {
383     ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, Long.valueOf(codIett));
384     Date data = Data.parseDate(dataBase);
385 
386     if (itemEstrutura == null || data == null) {
387       throw new ECARException();
388     }
389 
390     return this.apuracaoReprogramacaoExtensaoPontosCriticos(itemEstrutura, data);
391   }
392 
393   /**
394    * (5)Apuração de Reprogramação de Datas Críticas (Pontos Críticos) - Cálculo
395    * Redução de Prazo Calcular a taxa de replanejamento das datas críticas -
396    * basear o cálculo nos dados que estiverem no cadastro do item e no histórico
397    * de datas críticas. O cálculo deverá ser realizado em função do número de
398    * reduções realizadas no prazo das datas críticas do item e o número total de
399    * datas críticas. Basear os cálculos no estado do item no dia da data base
400    * @param itemEstrutura item para o qual se deseja fazer as apurações
401    * @param dataBase dia de referência para realização das apurações
402    * @return percentual de Pontos Críticos que reprogramaram redução de prazo até
403    *         o dia da Data Base
404    * @throws ECARException
405    * @author 05110500460
406    */
407   public double apuracaoReprogramacaoReducaoPontosCriticos(ItemEstruturaIett itemEstrutura, Date dataBase) throws ECARException {
408 
409     if (itemEstrutura == null) {
410       throw new ECARException();
411     }
412 
413     double numDataCadastrada = 0;
414     int numDatasReduzidas = 0;
415     PontoCriticoDao pontoCriticoDao = new PontoCriticoDao(null);
416     List<HistoricoPtcH> listHistPtc = null;
417     List<HistoricoPtcH> setHistPtc = null;
418     HistoricoPtcH historicoAnterior = null;
419     HistoricoPtcH primeiroRegistro = null; // O primeiro registro no histórico é
420                                            // a projeção inicial
421 
422     List<PontoCriticoPtc> pontosCriticos = pontoCriticoDao.listarItensIncluidosAntesDaDataBase(itemEstrutura, Data.addDias(1, dataBase)); // listar(itemEstrutura);
423 
424     if (pontosCriticos != null && pontosCriticos.size() > 0) {
425       numDataCadastrada = getTotalPontosCriticos(pontosCriticos, dataBase);
426     }
427     if (numDataCadastrada == 0) {
428       return numDataCadastrada;
429     }
430 
431     for (PontoCriticoPtc pontoCritico : pontosCriticos) {
432       listHistPtc = pontoCriticoDao.listarHistorico(pontoCritico, Data.addDias(1, dataBase));
433       historicoAnterior = null;
434       Set<Date> datasLimites = null;
435 
436       // Não apresentou modificação no histórico
437       if (listHistPtc == null || listHistPtc.size() == 0) {
438         continue;
439       }
440       datasLimites = new HashSet<Date>(listHistPtc.size());
441 
442       for (HistoricoPtcH historico : listHistPtc) {
443         // Se a última manutenção for antes da dataBase é para considerar a
444         // situação atual do item
445         if (pontoCritico.getDataUltManutencaoPtc() != null && (Data.compareAnoMesDia(pontoCritico.getDataUltManutencaoPtc(), dataBase) <= 0)) {
446 
447           if (estaExcluido(pontoCritico)) {
448             break;
449           }
450           // Verifica se os valores são Nulos
451           else if ((pontoCritico.getDataLimitePtc() != null && historico != null && historico.getDataLimitePtc() != null)
452           // Verifica se a Data Limite atual é menor do que a apresentada no
453           // historico
454           && Data.compareAnoMesDia(pontoCritico.getDataLimitePtc(), historico.getDataLimitePtc()) < 0) {
455             numDatasReduzidas++;
456             break; // pára o loop de histórico
457           }
458         }
459 
460         // Compara com valores no histórico
461         if (historico != null && historicoAnterior != null) {
462           if (historico.getDataLimitePtc() != null && historicoAnterior.getDataLimitePtc() != null && (!estaExcluido(historico))
463           // Verifica Data Limite do historico atual é menor do que do registro
464           // anterior
465           && Data.compareAnoMesDia(historico.getDataLimitePtc(), historicoAnterior.getDataLimitePtc()) < 0) {
466             numDatasReduzidas++;
467             break;// pára o loop de histórico
468           }
469         }
470 
471         if (historico != null && historico.getDataLimitePtc() != null && (!estaExcluido(historico))) {
472           boolean temNoHistorico = false;
473 
474           if (historico.getDataUltManutencaoPtc() == null && historico.getDataLimitePtc() != null) {
475             datasLimites.add(historico.getDataLimitePtc());
476           }
477           else {
478             for (Date date : datasLimites) {
479               // Se alguma data anterior for maior do que a data do historico
480               // atual
481               if (date.compareTo(historico.getDataLimitePtc()) > 0) {
482                 numDatasReduzidas++;
483                 temNoHistorico = true;
484                 break; // loop datasLimites
485               }
486             }
487             if (temNoHistorico) {
488               break; // para loop de historico
489             }
490             datasLimites.add(historico.getDataLimitePtc());
491           }
492         }
493 
494         if (historico.getDataUltManutencaoPtc() != null)
495           historicoAnterior = historico;// Para comparar com o valor anterior
496       } // fim for do loop de historico
497     }// fim for PontoCritico
498 
499     return 100 * numDatasReduzidas / numDataCadastrada;
500   }
501 
502   /**
503    * (4)Apuração de Reprogramação de Datas Críticas (Pontos Críticos) - Cálculo
504    * de Extensão de Prazo Calcular a taxa de replanejamento das datas críticas -
505    * basear o cálculo nos dados que estiverem no cadastro do item e no histórico
506    * de datas críticas. O cálculo deverá ser realizado em função do número de
507    * extensões realizadas no prazo das datas críticas do item e o número total
508    * de datas críticas. Basear os cálculos no estado do item no dia da data base
509    * @param itemEstrutura item para o qual se deseja fazer as apurações
510    * @param dataBase dia de referência para realização das apurações
511    * @return percentual de Pontos Críticos que reprogramaram redução de prazo até
512    *         o dia da Data Base
513    * @throws ECARException
514    * @author 05110500460
515    */
516   public double apuracaoReprogramacaoReducaoPontosCriticos(String codIett, String dataBase) throws ECARException {
517     ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, Long.valueOf(codIett));
518 
519     Date data = Data.parseDate(dataBase);
520 
521     if (itemEstrutura == null || data == null) {
522       throw new ECARException();
523     }
524 
525     return this.apuracaoReprogramacaoReducaoPontosCriticos(itemEstrutura, data);
526   }
527 
528   /**
529    * Recupera os valores dos atributos: - Data Limite - Data Solução No dia
530    * passado como parametro
531    * @param pontoCritico
532    * @param dataBase
533    * @return PontoCritico com os valores dos campos DataLimite e DataSolução
534    *         referentes ao dia da DataBase
535    * @author 05110500460
536    */
537   private HistoricoPtcH recuperaEstadoDasDatasNaDataBase(PontoCriticoPtc pontoCritico, Date dataBase) throws ECARException {
538     PontoCriticoDao ptcDao = new PontoCriticoDao(null);
539 
540     // se a ultima manutenção foi posterior a data base
541     if (pontoCritico.getDataUltManutencaoPtc() != null && Data.compareAnoMesDia(pontoCritico.getDataUltManutencaoPtc(), dataBase) > 0) {
542       // Set<HistoricoPtcH> setHistorico =
543       // pontoCritico.getHistoricoPtcHs();
544 
545       List<HistoricoPtcH> listHistorico = new PontoCriticoDao(null).listarHistorico(pontoCritico, Data.addDias(1, dataBase));
546 
547       if (listHistorico != null) {
548         for (HistoricoPtcH historico : listHistorico) {
549           // Parametros a recuperar o estado
550           if (historico != null && historico.getDataUltManutencaoPtc() != null && Data.compareAnoMesDia(historico.getDataUltManutencaoPtc(), dataBase) < 0) {
551             return historico;
552             // Verificar no historico a data da inclusão
553           }
554           else if (historico != null && historico.getDataUltManutencaoPtc() == null && historico.getDataInclusaoPtc() != null) {
555             if (Data.compareAnoMesDia(historico.getDataInclusaoPtc(), dataBase) < 0) {
556               return historico;
557             }
558           }
559         }// fim for
560       }// fim if
561     }// fim else
562 
563     return null;
564   }// fim recuperaEstadoDasDatasNaDataBase
565 
566   /**
567    * Retorna um array de objetos com os parâmetros setados para o serviço
568    * @param servicoSer
569    * @return Object[]
570    */
571 
572   public Object[] getParametrosServico(ServicoSer servicoSer, AcompReferenciaItemAri ari) {
573     Object[] parametros = null;
574 
575     if (servicoSer != null) {
576 
577       Set setParametros = servicoSer.getServicoParametros();
578 
579       List listParametros = new ArrayList(setParametros);
580 
581       Collections.sort(listParametros, new Comparator() {
582         public int compare(Object o1, Object o2) {
583           ServicoParametroSerPar a1 = (ServicoParametroSerPar) o1;
584           ServicoParametroSerPar a2 = (ServicoParametroSerPar) o2;
585           return a1.getSequencia().compareTo(a2.getSequencia());
586         }
587       });
588 
589       Iterator itParametros = listParametros.iterator();
590 
591       int countParametros = 0;
592 
593       parametros = new Object[listParametros.size()];
594 
595       while (itParametros.hasNext()) {
596 
597         ServicoParametroSerPar servicoParametroSerPar = (ServicoParametroSerPar) itParametros.next();
598 
599         if (servicoParametroSerPar.getParametroPar().getCodParametroPar().equals(ParametroPar.IDENTIFICADOR_ITEM_ESTRUTURA)) {
600           parametros[countParametros] = ari.getItemEstruturaIett().getCodIett().toString();
601           countParametros++;
602         }
603         else if (servicoParametroSerPar.getParametroPar().getCodParametroPar().equals(ParametroPar.DATA_ATUAL)) {
604           Date dataAtual = Data.getDataAtual();
605           String dataAtualStr = Data.parseDate(dataAtual);
606           parametros[countParametros] = dataAtualStr;
607           countParametros++;
608         }
609         else if (servicoParametroSerPar.getParametroPar().getCodParametroPar().equals(ParametroPar.DATA_LIMITE_REALIZADO_FISICO)) {
610           String dataLimiteRealizadoFisicoStr = Data.parseDate(ari.getDataLimiteAcompFisicoAri());
611           parametros[countParametros] = dataLimiteRealizadoFisicoStr;
612           countParametros++;
613         }
614         else if (servicoParametroSerPar.getParametroPar().getCodParametroPar().equals(ParametroPar.DATA_INICIO_ACOMPANHAMENTO)) {
615           String dataInicioAcompanhamentoStr = Data.parseDate(ari.getDataInicioAri());
616           parametros[countParametros] = dataInicioAcompanhamentoStr;
617           countParametros++;
618         }
619       }
620     }
621     return parametros;
622   }
623 
624   private boolean estaExcluido(PontoCriticoPtc pontoCritico) {
625     if (pontoCritico.getIndExcluidoPtc() != null && pontoCritico.getIndExcluidoPtc().equals("S")) {
626       return true;
627     }
628     return false;
629   }
630 
631   private boolean estaExcluido(HistoricoPtcH historico) {
632     if (historico.getIndExcluidoPtc() != null && historico.getIndExcluidoPtc().equals("S")) {
633       return true;
634     }
635     return false;
636   }
637 
638   private double getTotalPontosCriticos(List<PontoCriticoPtc> list, Date dataBase) throws ECARException {
639     double contTotal = 0;
640 
641     for (PontoCriticoPtc pontoCriticoPtc : list) {
642       if (pontoCriticoPtc.getDataUltManutencaoPtc() == null && (!estaExcluido(pontoCriticoPtc))) {
643         contTotal++;
644       }
645       else if (pontoCriticoPtc.getDataUltManutencaoPtc() != null && (Data.compareAnoMesDia(pontoCriticoPtc.getDataUltManutencaoPtc(), dataBase) <= 0) && (!estaExcluido(pontoCriticoPtc))) {
646         contTotal++;
647       }
648       else {
649         HistoricoPtcH historico = recuperaEstadoDasDatasNaDataBase(pontoCriticoPtc, dataBase);
650 
651         if (historico != null && historico.getDataUltManutencaoPtc() == null && (!estaExcluido(historico))) {
652           contTotal++;
653         }
654         else if (historico != null && historico.getDataUltManutencaoPtc() != null && (Data.compareAnoMesDia(historico.getDataUltManutencaoPtc(), dataBase) <= 0) && (!estaExcluido(historico))) {
655           contTotal++;
656         }
657 
658       }
659     }// fim for
660 
661     return contTotal;
662   }
663 
664 }