ExercicioDao xref

View Javadoc

1   /*
2    * Created on 27/10/2004
3    */
4   package ecar.dao;
5   
6   import java.util.ArrayList;
7   import java.util.Calendar;
8   import java.util.List;
9   
10  import javax.servlet.http.HttpServletRequest;
11  
12  import org.hibernate.HibernateException;
13  import org.hibernate.Query;
14  
15  import comum.database.Dao;
16  import comum.util.Data;
17  
18  import ecar.exception.ECARException;
19  import ecar.pojo.AcompRealFisicoArf;
20  import ecar.pojo.ExercicioExe;
21  import ecar.pojo.ItemEstruturaIett;
22  
23  /**
24   * @author evandro
25   */
26  public class ExercicioDao extends Dao {
27  
28    /**
29     * Construtor. Chama o Session factory do Hibernate
30     */
31    public ExercicioDao(HttpServletRequest request) {
32      super();
33      this.request = request;
34    }
35  
36    /**
37     * Verifica e exclui
38     * @author n/c
39     * @param exercicio
40     * @throws ECARException
41     */
42    public void excluir(ExercicioExe exercicio) throws ECARException {
43      boolean excluir = true;
44      if (contar(exercicio.getEfItemEstContaEfiecs()) > 0) {
45        excluir = false;
46        throw new ECARException("exercicio.exclusao.erro.efItemEstContaEfiecs");
47      }
48      if (contar(exercicio.getEfItemEstPrevisaoEfieps()) > 0) {
49        excluir = false;
50        throw new ECARException("exercicio.exclusao.erro.efItemEstPrevisaoEfieps");
51      }
52      if (contar(exercicio.getItemEstrutFisicoIettfs()) > 0) {
53        excluir = false;
54        throw new ECARException("exercicio.exclusao.erro.itemEstrutFisicoIettfs");
55      }
56      /*
57       * FIXME: Reaplicar validação para histórico.
58       * if(contar(exercicio.getEfItemEstPrevhistEfiephs()) > 0){ excluir = false;
59       * throw new
60       * ECARException("exercicio.exclusao.erro.efItemEstPrevhistEfiephs"); }
61       */
62      if (contar(exercicio.getAcompReferenciaArefs()) > 0) {
63        excluir = false;
64        throw new ECARException("exercicio.exclusao.erro.acompReferenciaArefs");
65      }
66      if (excluir)
67        super.excluir(exercicio);
68    }
69  
70    /**
71     * Retorna uma lista de exercicios que tem data inicial ou final que se
72     * sobrepoem ao exercicio informado como parâmetro. Não deve haver
73     * sobreposicao de datas de nenhum exercicio cadastrado, ou seja, quando
74     * termina um começa o outro. Isto porque em acomp_relatorio, precisamos
75     * determinar um e somente um exercicio para um dado mês e ano. A logica é a
76     * seguinte: dataInicialT = data inicial do exercicio que queremos cadastrar<br>
77     * dataFinalT = data final do exercicio que queremos cadastrar<br>
78     * dataInicialX = data inicial de um exercicio qualquer já cadastrado<br>
79     * dataFinalX = data final de um exercicio já cadastrado<br>
80     * 
81     * <pre>
82     * exercicioX								o-------------o					
83     * exercicioT                o------------o                 o-------------o      
84     * 
85     * se dataFinalT &lt; dataInicialX ou dataInicialT &gt; dataFinalX então&lt;br&gt; 
86     *    o exercicio T nao se sobrepoe ao exercicio X&lt;br&gt;
87     * </pre>
88     * @author garten
89     * @param exercicio
90     * @return
91     * @throws ECARException
92     */
93    public List getExerciciosComSobreposicaoData(ExercicioExe exercicio) throws ECARException {
94      List resultado = new ArrayList();
95  
96      try {
97        String select = "from ExercicioExe e " + " where not (:dataFinal < e.dataInicialExe or :dataInicial > e.dataFinalExe)";
98  
99        if (exercicio.getCodExe() != null)
100         select += " and e.codExe <> :codExe";
101 
102       Query q = this.session.createQuery(select);
103 
104       q.setDate("dataFinal", exercicio.getDataFinalExe());
105       q.setDate("dataInicial", exercicio.getDataInicialExe());
106 
107       if (exercicio.getCodExe() != null)
108         q.setLong("codExe", exercicio.getCodExe().longValue());
109 
110       resultado = q.list();
111     } catch (HibernateException e) {
112       this.logger.error(e);
113       throw new ECARException("erro.hibernateException");
114     }
115 
116     return (resultado);
117   }
118 
119   /**
120    * Salva um exercicio somente se não sobrepuser nenhum exercicio já cadastrado
121    * @author garten
122    * @param exercicio
123    * @throws ECARException
124    */
125   public void salvar(ExercicioExe exercicio) throws ECARException {
126     if (pesquisarDuplos(exercicio, new String[] { "descricaoExe" }, "codExe").size() > 0)
127       throw new ECARException("exercicio.validacao.registroDuplicado");
128 
129     List lExercicios = getExerciciosComSobreposicaoData(exercicio);
130     if (lExercicios != null && lExercicios.size() > 0) {
131       throw new ECARException("exercicio.validacao.erroSobreposicao");
132     }
133     else {
134       super.salvar(exercicio);
135     }
136   }
137 
138   /**
139    * Altera um exercicio somente se as datas não sobrepoem nenhum outro
140    * exercicio
141    * @author garten
142    * @param exercicio
143    * @throws ECARException
144    */
145   public void alterar(ExercicioExe exercicio) throws ECARException {
146     if (pesquisarDuplos(exercicio, new String[] { "descricaoExe" }, "codExe").size() > 0)
147       throw new ECARException("exercicio.validacao.registroDuplicado");
148 
149     List lExercicios = getExerciciosComSobreposicaoData(exercicio);
150     if (lExercicios != null && lExercicios.size() > 0) {
151       throw new ECARException("exercicio.validacao.erroSobreposicao");
152     }
153     else {
154       super.alterar(exercicio);
155     }
156   }
157 
158   /**
159    * Retorna uma lista de exercicios anteriores a um exercício
160    * @param exercicio
161    * @return
162    * @throws ECARException
163    */
164   public List getExerciciosAnteriores(ExercicioExe exercicio) throws ECARException {
165     List resultado = new ArrayList();
166 
167     try {
168       String select = "from ExercicioExe e where e.dataFinalExe < :dataFinal order by e.dataInicialExe";
169 
170       Query q = this.session.createQuery(select);
171 
172       q.setDate("dataFinal", exercicio.getDataInicialExe());
173 
174       resultado = q.list();
175     } catch (HibernateException e) {
176       this.logger.error(e);
177       throw new ECARException("erro.hibernateException");
178     }
179 
180     return (resultado);
181   }
182 
183   /**
184    * Retorna uma lista de todos os exercicios para um determinado item. 1- Se
185    * tiver data inicial e final informadas no cadastro do item, então retorna os
186    * exercícios com base nessas datas e no cadastro de exercícios, mesmo que não
187    * tenham indicadores cadastrados para alguma dessas datas, o qual, se
188    * acontecer, será apresentado com valor zero (0). 2- Se só tiver a data
189    * inicial informada no cadastro do item, então retorna os exercícios que
190    * começam a partir desta data inicial com base no cadastro de exercício até o
191    * último exercício informado nos indicadores de resultado daquele item. 3- Se
192    * só tiver a data final informada no cadastro do item, então retorna os
193    * exercícios que começam a partir do primeiro exercício com base no cadastro
194    * de exercício e nos indicadores de resultado até a data final informada. 4-
195    * Se não tiver nenhuma das datas no cadastro do item (nem inicial, nem final)
196    * então retorna os exercícios informados nos indicadores de resultado daquele
197    * item.
198    * @param Long codIett
199    * @return List
200    * @throws ECARException
201    * @throws HibernateException
202    */
203   public List getExerciciosProjecao(Long codIett) throws ECARException {
204     AcompRealFisicoDao acompRealFisicoDao = new AcompRealFisicoDao(null);
205     AcompReferenciaDao acompReferenciaDao = new AcompReferenciaDao(null);
206     ItemEstruturaDao estruturaDao = new ItemEstruturaDao(null);
207 
208     List resultado = new ArrayList();
209 
210     try {
211       String queryExeIndicadores = "select distinct ieFisico.exercicioExe from ItemEstrutFisicoIettf ieFisico" + " where ieFisico.itemEstrtIndResulIettr.itemEstruturaIett.codIett = :codIett" + " and ieFisico.itemEstrtIndResulIettr.itemEstruturaIett.indAtivoIett = 'S'" + " order by ieFisico.exercicioExe.dataFinalExe";
212 
213       Query q = this.getSession().createQuery(queryExeIndicadores);
214 
215       q.setLong("codIett", codIett.longValue());
216 
217       ItemEstruturaIett item = (ItemEstruturaIett) estruturaDao.buscar(ItemEstruturaIett.class, codIett);
218 
219       if (item != null) {
220 
221         // Nova regra (Mantis 6282) - inicio
222         long anoMesArfMaisRecente = 0;
223         long anoMesArfMaisAntigo = 0;
224 
225         AcompRealFisicoArf arfMaisRecente = acompRealFisicoDao.getArfMaisRecenteItem(item);
226         if (arfMaisRecente != null) {
227           String mesAux = arfMaisRecente.getMesArf().toString();
228           if (arfMaisRecente.getMesArf().longValue() < 10) {
229             mesAux = "0" + mesAux;
230           }
231           anoMesArfMaisRecente = Long.parseLong(arfMaisRecente.getAnoArf().toString() + mesAux);
232         }
233         AcompRealFisicoArf arfMaisAntigo = acompRealFisicoDao.getArfMaisAntigoItem(item);
234         if (arfMaisAntigo != null) {
235           String mesAux = arfMaisAntigo.getMesArf().toString();
236           if (arfMaisAntigo.getMesArf().longValue() < 10) {
237             mesAux = "0" + mesAux;
238           }
239           anoMesArfMaisAntigo = Long.parseLong(arfMaisAntigo.getAnoArf().toString() + mesAux);
240         }
241         // Nova regra (Mantis 6282) - fim
242 
243         /* Se não tiver nenhuma das datas */
244         if (item.getDataInicioIett() == null && item.getDataTerminoIett() == null) {
245           resultado = q.list();
246         }
247         else {
248           int mes = 0;
249           int ano = 0;
250           int mesFinal = 0;
251           int anoFinal = 0;
252 
253           /* Se tiver as 2 datas */
254           if (item.getDataInicioIett() != null && item.getDataTerminoIett() != null) {
255             mes = Data.getMes(item.getDataInicioIett()) + 1;
256             ano = Data.getAno(item.getDataInicioIett());
257             mesFinal = Data.getMes(item.getDataTerminoIett()) + 1;
258             anoFinal = Data.getAno(item.getDataTerminoIett());
259           }
260           /* se só tiver a data inicial */
261           else if (item.getDataInicioIett() != null && item.getDataTerminoIett() == null) {
262 
263             mes = Data.getMes(item.getDataInicioIett()) + 1;
264             ano = Data.getAno(item.getDataInicioIett());
265             mesFinal = 0;
266             anoFinal = 0;
267 
268             List exerciciosTemp = q.list();
269 
270             if (exerciciosTemp != null && exerciciosTemp.size() > 0) {
271               ExercicioExe exercicioFinal = (ExercicioExe) exerciciosTemp.get(exerciciosTemp.size() - 1);
272               mesFinal = Data.getMes(exercicioFinal.getDataFinalExe());
273               anoFinal = Data.getAno(exercicioFinal.getDataFinalExe());
274             }
275           }
276           /* se só tiver a data final */
277           else {
278             mes = Data.getMes(item.getDataTerminoIett()) + 2; // Acrescento +1
279                                                               // ao mes e ao ano
280                                                               // da data final
281                                                               // para ter
282                                                               // certeza de que
283                                                               // não
284             ano = Data.getAno(item.getDataTerminoIett()) + 1; // entre no while
285                                                               // se não achar
286                                                               // nenhum
287                                                               // exercicio na
288                                                               // query abaixo
289 
290             mesFinal = Data.getMes(item.getDataTerminoIett()) + 1;
291             anoFinal = Data.getAno(item.getDataTerminoIett());
292 
293             List exerciciosTemp = q.list();
294 
295             if (exerciciosTemp != null && exerciciosTemp.size() > 0) {
296               ExercicioExe exercicioInicial = (ExercicioExe) exerciciosTemp.get(0);
297               mes = Data.getMes(exercicioInicial.getDataInicialExe());
298               ano = Data.getAno(exercicioInicial.getDataInicialExe());
299             }
300           }
301 
302           // Nova regra (Mantis 6282) - inicio
303           String mesAux = String.valueOf(mes);
304           if (mes < 10) {
305             mesAux = "0" + mesAux;
306           }
307           long anoMesItemInicio = Long.parseLong(String.valueOf(ano) + mesAux);
308 
309           mesAux = String.valueOf(mesFinal);
310           if (mesFinal < 10) {
311             mesAux = "0" + mesAux;
312           }
313           long anoMesItemFim = Long.parseLong(String.valueOf(anoFinal) + mesAux);
314 
315           if (anoMesArfMaisAntigo > 0 && anoMesArfMaisAntigo < anoMesItemInicio) {
316             mes = arfMaisAntigo.getMesArf().intValue();
317             ano = arfMaisAntigo.getAnoArf().intValue();
318           }
319           if (anoMesArfMaisRecente > 0 && anoMesArfMaisRecente > anoMesItemFim) {
320             mesFinal = arfMaisRecente.getMesArf().intValue();
321             anoFinal = arfMaisRecente.getAnoArf().intValue();
322           }
323           // Nova regra (Mantis 6282) - fim
324 
325           while (ano < anoFinal || (ano == anoFinal && mes <= mesFinal)) {
326             ExercicioExe exercicio = acompReferenciaDao.getExercicio(String.valueOf(ano), String.valueOf(mes));
327             if (exercicio != null && !resultado.contains(exercicio)) {
328               resultado.add(exercicio);
329             }
330 
331             mes++;
332             if (mes > 12) {
333               mes = 1;
334               ano++;
335             }
336           }
337         }
338       }
339       /* item == null, portanto não tenho nenhuma das datas */
340       else {
341         resultado = q.list();
342       }
343     } catch (HibernateException e) {
344       this.logger.error(e);
345       throw new ECARException("erro.hibernateException");
346     }
347 
348     return (resultado);
349   }
350 
351   /**
352    * Retorna uma lista de exercicios posteriores a um exercício
353    * @param exercicio
354    * @return
355    * @throws ECARException
356    */
357   public List getExerciciosPosteriores(ExercicioExe exercicio) throws ECARException {
358     List resultado = new ArrayList();
359 
360     try {
361       String select = "from ExercicioExe e where e.dataFinalExe > :dataInicial order by e.dataInicialExe";
362 
363       Query q = this.getSession().createQuery(select);
364 
365       q.setDate("dataInicial", exercicio.getDataInicialExe());
366 
367       resultado = q.list();
368     } catch (HibernateException e) {
369       this.logger.error(e);
370       throw new ECARException("erro.hibernateException");
371     }
372 
373     return (resultado);
374   }
375 
376   /**
377    * Retorna uma lista com meses dentro de um exercício no formato mes-ano
378    * (01-2004)
379    * @param exercicio
380    * @return
381    */
382   public List getMesesDentroDoExercicio(ExercicioExe exercicio) {
383 
384     List retorno = new ArrayList();
385     Calendar dataInicialExe = Data.getCalendar(exercicio.getDataInicialExe());
386     Calendar dataFinalExe = Data.getCalendar(exercicio.getDataFinalExe());
387 
388     int anoInicial = dataInicialExe.get(Calendar.YEAR);
389     int anoFinal = dataFinalExe.get(Calendar.YEAR);
390     int mesInicial = dataInicialExe.get(Calendar.MONTH) + 1;
391     int mesFinal = dataFinalExe.get(Calendar.MONTH) + 1;
392 
393     while ((anoInicial != anoFinal) || (mesInicial != mesFinal && anoInicial == anoFinal)) {
394       retorno.add(mesInicial + "-" + anoInicial);
395       mesInicial++;
396       if (mesInicial == 13) {
397         mesInicial = 1;
398         anoInicial++;
399       }
400     }
401     retorno.add(mesInicial + "-" + anoInicial);
402 
403     return retorno;
404   }
405 
406   /**
407    * Retorna uma lista com meses dentro de um exercício no formato mes-ano
408    * (01-2004) até um determinado mês/ano
409    * @param exercicio
410    * @return
411    */
412   public List getMesesDentroDoExercicio(ExercicioExe exercicio, int mes, int ano) {
413 
414     List retorno = new ArrayList();
415     Calendar dataInicialExe = Data.getCalendar(exercicio.getDataInicialExe());
416     // Calendar dataFinalExe = Data.getCalendar(exercicio.getDataFinalExe());
417 
418     int anoInicial = dataInicialExe.get(Calendar.YEAR);
419     int anoFinal = ano;
420     int mesInicial = dataInicialExe.get(Calendar.MONTH) + 1;
421     int mesFinal = mes;
422 
423     while ((anoInicial != anoFinal) || (mesInicial != mesFinal && anoInicial == anoFinal)) {
424       retorno.add(mesInicial + "-" + anoInicial);
425       mesInicial++;
426       if (mesInicial == 13) {
427         mesInicial = 1;
428         anoInicial++;
429       }
430     }
431     retorno.add(mesInicial + "-" + anoInicial);
432 
433     return retorno;
434   }
435 
436   /**
437    * Retorna uma lista de todos os exercicios válidos para um determinado item.
438    * 1- Se tiver data inicial e final informadas no cadastro do item, então
439    * retorna os exercícios com base nessas datas e no cadastro de exercícios,
440    * mesmo que não tenham indicadores cadastrados para alguma dessas datas, o
441    * qual, se acontecer, será apresentado com valor zero (0). 2- Se só tiver a
442    * data inicial informada no cadastro do item, então retorna os exercícios que
443    * começam a partir desta data inicial com base no cadastro de exercício até o
444    * último exercício informado na tabela de exercicios (ExercicioExe). 3- Se só
445    * tiver a data final informada no cadastro do item, então retorna os
446    * exercícios que começam a partir do primeiro exercício com base no cadastro
447    * de exercício (ExercicioExe) até a data final do item informada. 4- Se não
448    * tiver nenhuma das datas no cadastro do item (nem inicial, nem final) então
449    * retorna os exercícios do cadastro de exercícios (ExercicioExe).
450    * @param Long codIett
451    * @return List
452    * @throws ECARException
453    */
454   public List getExerciciosValidos(Long codIett) throws ECARException {
455     AcompReferenciaDao acompReferenciaDao = new AcompReferenciaDao(null);
456     ItemEstruturaDao estruturaDao = new ItemEstruturaDao(null);
457 
458     List resultado = new ArrayList();
459 
460     String queryExercicios = "from ExercicioExe exercicio" + " order by exercicio.dataFinalExe";
461 
462     try {
463 
464       ItemEstruturaIett item = (ItemEstruturaIett) estruturaDao.buscar(ItemEstruturaIett.class, codIett);
465 
466       if (item != null) {
467         if (item.getDataInicioIett() == null && item.getDataTerminoIett() == null) {
468           /*
469            * Se não tiver nenhuma das datas 4- Se não tiver nenhuma das datas no
470            * cadastro do item (nem inicial, nem final) então retorna os
471            * exercícios do cadastro de exercícios (ExercicioExe).
472            */
473           resultado = session.createQuery(queryExercicios).list();
474         }
475         else {
476           int mes = 0;
477           int ano = 0;
478           int mesFinal = 0;
479           int anoFinal = 0;
480 
481           /*
482            * Se tiver as 2 datas 1- Se tiver data inicial e final informadas no
483            * cadastro do item, então retorna os exercícios com base nessas datas
484            * e no cadastro de exercícios, mesmo que não tenham indicadores
485            * cadastrados para alguma dessas datas, o qual, se acontecer, será
486            * apresentado com valor zero (0).
487            */
488           if (item.getDataInicioIett() != null && item.getDataTerminoIett() != null) {
489 
490             mes = Data.getMes(item.getDataInicioIett()) + 1;
491             ano = Data.getAno(item.getDataInicioIett());
492             mesFinal = Data.getMes(item.getDataTerminoIett()) + 1;
493             anoFinal = Data.getAno(item.getDataTerminoIett());
494 
495           }
496           /*
497            * se só tiver a data inicial 2- Se só tiver a data inicial informada
498            * no cadastro do item, então retorna os exercícios que começam a
499            * partir desta data inicial com base no cadastro de exercício até o
500            * último exercício informado na tabela de exercicios (ExercicioExe).
501            */
502           else if (item.getDataInicioIett() != null && item.getDataTerminoIett() == null) {
503 
504             mes = Data.getMes(item.getDataInicioIett()) + 1;
505             ano = Data.getAno(item.getDataInicioIett());
506             mesFinal = 0;
507             anoFinal = 0;
508 
509             List exerciciosTemp = session.createQuery(queryExercicios).list();
510 
511             if (exerciciosTemp != null && exerciciosTemp.size() > 0) {
512               ExercicioExe exercicioFinal = (ExercicioExe) exerciciosTemp.get(exerciciosTemp.size() - 1);
513               mesFinal = Data.getMes(exercicioFinal.getDataFinalExe());
514               anoFinal = Data.getAno(exercicioFinal.getDataFinalExe());
515             }
516 
517           }
518           /*
519            * se só tiver a data final 3- Se só tiver a data final informada no
520            * cadastro do item, então retorna os exercícios que começam a partir
521            * do primeiro exercício com base no cadastro de exercício
522            * (ExercicioExe) até a data final do item informada.
523            */
524           else {
525             mes = Data.getMes(item.getDataTerminoIett()) + 2; // Acrescento +1
526                                                               // ao mes e ao ano
527                                                               // da data final
528                                                               // para ter
529                                                               // certeza de que
530                                                               // não
531             ano = Data.getAno(item.getDataTerminoIett()) + 1; // entre no while
532                                                               // se não achar
533                                                               // nenhum
534                                                               // exercicio na
535                                                               // query abaixo
536 
537             mesFinal = Data.getMes(item.getDataTerminoIett()) + 1;
538             anoFinal = Data.getAno(item.getDataTerminoIett());
539 
540             List exerciciosTemp = session.createQuery(queryExercicios).list();
541 
542             if (exerciciosTemp != null && exerciciosTemp.size() > 0) {
543               ExercicioExe exercicioInicial = (ExercicioExe) exerciciosTemp.get(0);
544               mes = Data.getMes(exercicioInicial.getDataInicialExe());
545               ano = Data.getAno(exercicioInicial.getDataInicialExe());
546             }
547           }
548 
549           while (ano < anoFinal || (ano == anoFinal && mes <= mesFinal)) {
550             ExercicioExe exercicio = acompReferenciaDao.getExercicio(String.valueOf(ano), String.valueOf(mes));
551             if (exercicio != null && !resultado.contains(exercicio)) {
552               resultado.add(exercicio);
553             }
554 
555             mes++;
556             if (mes > 12) {
557               mes = 1;
558               ano++;
559             }
560           }
561         }
562       }
563       else {
564         /*
565          * item == null, portanto não tenho nenhuma das datas 4- Se não tiver
566          * nenhuma das datas no cadastro do item (nem inicial, nem final) então
567          * retorna os exercícios do cadastro de exercícios (ExercicioExe).
568          */
569         resultado = session.createQuery(queryExercicios).list();
570       }
571 
572     } catch (HibernateException e) {
573       this.logger.error(e);
574       throw new ECARException("erro.hibernateException");
575     }
576 
577     return (resultado);
578   }
579 
580   public List getExeByPerExe(ExercicioExe exeReferencia) throws ECARException {
581 
582     List retorno = new ArrayList();
583 
584     try {
585       StringBuilder select = new StringBuilder();
586       select.append("select exe from ExercicioExe exe");
587 
588       if (exeReferencia != null && exeReferencia.getPeriodoExercicioPerExe() != null) {
589         select.append(" where exe.periodoExercicioPerExe.codPerExe = :codPerExe");
590       }
591 
592       select.append(" order by exe.dataInicialExe desc");
593 
594       Query q = this.session.createQuery(select.toString());
595 
596       if (exeReferencia != null && exeReferencia.getPeriodoExercicioPerExe() != null) {
597         q.setLong("codPerExe", exeReferencia.getPeriodoExercicioPerExe().getCodPerExe().longValue());
598       }
599 
600       retorno = q.list();
601 
602       if (retorno == null || (retorno != null && retorno.isEmpty()))
603         retorno = new ArrayList();
604 
605     } catch (HibernateException he) {
606       this.logger.error(he);
607       throw new ECARException("erro.hibernateException");
608     }
609 
610     return retorno;
611   }
612 
613   /**
614    * Carrega listagem de Exercicios de acordo com a periodicidade
615    * @param codPerExe Identificador <PeriodoExercicioPerExe>
616    * @return List<ExercicioExe>
617    */
618   public List getExercicioByPeriodicidade(Long codPerExe) throws ECARException {
619 
620     try {
621       StringBuilder qry = new StringBuilder("from ExercicioExe as ex").append(" where ex.periodoExercicioPerExe.codPerExe  = :codigo").append(" order by ex.dataFinalExe");
622 
623       Query q = this.session.createQuery(qry.toString());
624       q.setLong("codigo", codPerExe.longValue());
625 
626       return q.list();
627 
628     } catch (HibernateException e) {
629       this.logger.error(e);
630       throw new ECARException("erro.hibernateException");
631     }
632 
633   }
634 
635   /**
636    * Retorna uma lista de todos os exercicios para um determinado item. 1- Se
637    * tiver data inicial e final informadas no cadastro do item, então retorna os
638    * exercícios com base nessas datas e no cadastro de exercícios, mesmo que não
639    * tenham indicadores cadastrados para alguma dessas datas, o qual, se
640    * acontecer, será apresentado com valor zero (0). 2- Se só tiver a data
641    * inicial informada no cadastro do item, então retorna os exercícios que
642    * começam a partir desta data inicial com base no cadastro de exercício até o
643    * último exercício informado nos indicadores de resultado daquele item. 3- Se
644    * só tiver a data final informada no cadastro do item, então retorna os
645    * exercícios que começam a partir do primeiro exercício com base no cadastro
646    * de exercício e nos indicadores de resultado até a data final informada. 4-
647    * Se não tiver nenhuma das datas no cadastro do item (nem inicial, nem final)
648    * então retorna os exercícios informados nos indicadores de resultado daquele
649    * item.
650    * @param Long codIett
651    * @return List
652    * @throws ECARException
653    * @throws HibernateException
654    */
655   public List getExerciciosProjecaoByExercicio(Long codIett, Long codExe) throws ECARException {
656     AcompRealFisicoDao acompRealFisicoDao = new AcompRealFisicoDao(null);
657     AcompReferenciaDao acompReferenciaDao = new AcompReferenciaDao(null);
658     ItemEstruturaDao estruturaDao = new ItemEstruturaDao(null);
659 
660     List resultado = new ArrayList();
661 
662     try {
663       String queryExeIndicadores = "select distinct ieFisico.exercicioExe from ItemEstrutFisicoIettf ieFisico" + " where ieFisico.itemEstrtIndResulIettr.itemEstruturaIett.codIett = :codIett" + " and ieFisico.itemEstrtIndResulIettr.itemEstruturaIett.indAtivoIett = 'S'" + " and ieFisico.exercicioExe.codExe = :codExe" + " order by ieFisico.exercicioExe.dataFinalExe";
664 
665       Query q = this.getSession().createQuery(queryExeIndicadores);
666 
667       q.setLong("codIett", codIett.longValue());
668       q.setLong("codExe", codExe);
669 
670       ItemEstruturaIett item = (ItemEstruturaIett) estruturaDao.buscar(ItemEstruturaIett.class, codIett);
671 
672       if (item != null) {
673 
674         long anoMesArfMaisRecente = 0;
675         long anoMesArfMaisAntigo = 0;
676 
677         AcompRealFisicoArf arfMaisRecente = acompRealFisicoDao.getArfMaisRecenteItem(item);
678         if (arfMaisRecente != null) {
679           String mesAux = arfMaisRecente.getMesArf().toString();
680           if (arfMaisRecente.getMesArf().longValue() < 10) {
681             mesAux = "0" + mesAux;
682           }
683           anoMesArfMaisRecente = Long.parseLong(arfMaisRecente.getAnoArf().toString() + mesAux);
684         }
685         AcompRealFisicoArf arfMaisAntigo = acompRealFisicoDao.getArfMaisAntigoItem(item);
686         if (arfMaisAntigo != null) {
687           String mesAux = arfMaisAntigo.getMesArf().toString();
688           if (arfMaisAntigo.getMesArf().longValue() < 10) {
689             mesAux = "0" + mesAux;
690           }
691           anoMesArfMaisAntigo = Long.parseLong(arfMaisAntigo.getAnoArf().toString() + mesAux);
692         }
693 
694         /* Se não tiver nenhuma das datas */
695         if (item.getDataInicioIett() == null && item.getDataTerminoIett() == null) {
696           resultado = q.list();
697         }
698         else {
699           int mes = 0;
700           int ano = 0;
701           int mesFinal = 0;
702           int anoFinal = 0;
703 
704           /* Se tiver as 2 datas */
705           if (item.getDataInicioIett() != null && item.getDataTerminoIett() != null) {
706             mes = Data.getMes(item.getDataInicioIett()) + 1;
707             ano = Data.getAno(item.getDataInicioIett());
708             mesFinal = Data.getMes(item.getDataTerminoIett()) + 1;
709             anoFinal = Data.getAno(item.getDataTerminoIett());
710           }
711           /* se só tiver a data inicial */
712           else if (item.getDataInicioIett() != null && item.getDataTerminoIett() == null) {
713 
714             mes = Data.getMes(item.getDataInicioIett()) + 1;
715             ano = Data.getAno(item.getDataInicioIett());
716             mesFinal = 0;
717             anoFinal = 0;
718 
719             List exerciciosTemp = q.list();
720 
721             if (exerciciosTemp != null && exerciciosTemp.size() > 0) {
722               ExercicioExe exercicioFinal = (ExercicioExe) exerciciosTemp.get(exerciciosTemp.size() - 1);
723               mesFinal = Data.getMes(exercicioFinal.getDataFinalExe());
724               anoFinal = Data.getAno(exercicioFinal.getDataFinalExe());
725             }
726           }
727           /* se só tiver a data final */
728           else {
729             mes = Data.getMes(item.getDataTerminoIett()) + 2; // Acrescento +1
730                                                               // ao mes e ao ano
731                                                               // da data final
732                                                               // para ter
733                                                               // certeza de que
734                                                               // não
735             ano = Data.getAno(item.getDataTerminoIett()) + 1; // entre no while
736                                                               // se não achar
737                                                               // nenhum
738                                                               // exercicio na
739                                                               // query abaixo
740 
741             mesFinal = Data.getMes(item.getDataTerminoIett()) + 1;
742             anoFinal = Data.getAno(item.getDataTerminoIett());
743 
744             List exerciciosTemp = q.list();
745 
746             if (exerciciosTemp != null && exerciciosTemp.size() > 0) {
747               ExercicioExe exercicioInicial = (ExercicioExe) exerciciosTemp.get(0);
748               mes = Data.getMes(exercicioInicial.getDataInicialExe());
749               ano = Data.getAno(exercicioInicial.getDataInicialExe());
750             }
751           }
752 
753           String mesAux = String.valueOf(mes);
754           if (mes < 10) {
755             mesAux = "0" + mesAux;
756           }
757           long anoMesItemInicio = Long.parseLong(String.valueOf(ano) + mesAux);
758 
759           mesAux = String.valueOf(mesFinal);
760           if (mesFinal < 10) {
761             mesAux = "0" + mesAux;
762           }
763           long anoMesItemFim = Long.parseLong(String.valueOf(anoFinal) + mesAux);
764 
765           if (anoMesArfMaisAntigo > 0 && anoMesArfMaisAntigo < anoMesItemInicio) {
766             mes = arfMaisAntigo.getMesArf().intValue();
767             ano = arfMaisAntigo.getAnoArf().intValue();
768           }
769           if (anoMesArfMaisRecente > 0 && anoMesArfMaisRecente > anoMesItemFim) {
770             mesFinal = arfMaisRecente.getMesArf().intValue();
771             anoFinal = arfMaisRecente.getAnoArf().intValue();
772           }
773 
774           while (ano < anoFinal || (ano == anoFinal && mes <= mesFinal)) {
775             ExercicioExe exercicio = acompReferenciaDao.getExercicio(String.valueOf(ano), String.valueOf(mes));
776             if (exercicio != null && !resultado.contains(exercicio)) {
777               resultado.add(exercicio);
778             }
779 
780             mes++;
781             if (mes > 12) {
782               mes = 1;
783               ano++;
784             }
785           }
786         }
787       }
788       /* item == null, portanto não tenho nenhuma das datas */
789       else {
790         resultado = q.list();
791       }
792     } catch (HibernateException e) {
793       this.logger.error(e);
794       throw new ECARException("erro.hibernateException");
795     }
796 
797     return (resultado);
798   }
799 
800 }