AcompReferenciaDao xref

View Javadoc

1   /*
2    * Created on 01/02/2005
3    */
4   package ecar.dao;
5   
6   import java.text.SimpleDateFormat;
7   import java.util.ArrayList;
8   import java.util.Calendar;
9   import java.util.Collection;
10  import java.util.Collections;
11  import java.util.Date;
12  import java.util.HashSet;
13  import java.util.Iterator;
14  import java.util.List;
15  import java.util.Set;
16  
17  import javax.servlet.http.HttpServletRequest;
18  
19  import org.hibernate.HibernateException;
20  import org.hibernate.Query;
21  
22  import comum.database.Dao;
23  import comum.util.Data;
24  import comum.util.Pagina;
25  
26  import ecar.bean.AtributoEstruturaListagemItens;
27  import ecar.exception.ECARException;
28  import ecar.login.SegurancaECAR;
29  import ecar.permissao.ValidaPermissao;
30  import ecar.pojo.AcompRealFisicoArf;
31  import ecar.pojo.AcompRefItemLimitesArli;
32  import ecar.pojo.AcompRefLimitesArl;
33  import ecar.pojo.AcompRefLimitesArlPK;
34  import ecar.pojo.AcompReferenciaAref;
35  import ecar.pojo.AcompReferenciaItemAri;
36  import ecar.pojo.ExercicioExe;
37  import ecar.pojo.ItemEstrutUsuarioIettus;
38  import ecar.pojo.ItemEstruturaIett;
39  import ecar.pojo.OrgaoOrg;
40  import ecar.pojo.TipoAcompanhamentoTa;
41  import ecar.pojo.TipoFuncAcompTpfa;
42  import ecar.pojo.UsuarioAtributoUsua;
43  import ecar.pojo.UsuarioUsu;
44  import ecar.util.Dominios;
45  
46  /**
47   * @author garten
48   */
49  public class AcompReferenciaDao extends Dao {
50  
51    ValidaPermissao validaPermissao = new ValidaPermissao();
52  
53    /**
54       * 
55       */
56    public AcompReferenciaDao(HttpServletRequest request) {
57      super();
58      this.request = request;
59    }
60  
61    /**
62     * Devolve uma lista de AcompReferencia ordenado por mes/ano
63     * @return
64     */
65    public List getListAcompReferencia() throws ECARException {
66      return listar(AcompReferenciaAref.class, new String[] { "anoAref", "desc", "mesAref", "desc", "dataInicioAref", "desc" });
67    }
68  
69    /*
70     * Método comentado (e modificado logo abaixo) devido ao bug 1893: Ao invés de
71     * retornar o mês mais próximo, ele retornava ou o mês mais antigo ou o mês
72     * atual. public AcompReferenciaAref getAcompSelecionado(List aref){ int
73     * mesAtual = Data.getCalendar(Data.getDataAtual()).get(Calendar.MONTH) + 1;
74     * int anoAtual = Data.getCalendar(Data.getDataAtual()).get(Calendar.YEAR);
75     * int mesAnoAtual = mesAtual + anoAtual; AcompReferenciaAref arefSelecionado
76     * = null; int menorDiferenca = 0; Iterator it = aref.iterator();
77     * while(it.hasNext()){ AcompReferenciaAref arefAtual = (AcompReferenciaAref)
78     * it.next(); int mesAno = Integer.valueOf(arefAtual.getMesAref()).intValue()
79     * + Integer.valueOf(arefAtual.getAnoAref()).intValue(); if(mesAno -
80     * mesAnoAtual == 0) return arefAtual; else{ int diferencaAtual = (mesAno -
81     * mesAnoAtual); if(diferencaAtual < 0) diferencaAtual = diferencaAtual * -1;
82     * if(diferencaAtual > menorDiferenca || menorDiferenca == 0){ menorDiferenca
83     * = diferencaAtual; arefSelecionado = arefAtual; } } } return
84     * arefSelecionado; }
85     */
86    /**
87     * Retorna o Mês mais próximo do atual para AcompReferenciaAref
88     * @return AcompReferenciaAref
89     */
90    public AcompReferenciaAref getAcompSelecionado(List aref) {
91      int mesAtual = Data.getCalendar(Data.getDataAtual()).get(Calendar.MONTH) + 1;
92      int anoAtual = Data.getCalendar(Data.getDataAtual()).get(Calendar.YEAR);
93      AcompReferenciaAref arefSelecionado = null;
94  
95      String anoMesAtual = "";
96      if (mesAtual < 10) {
97        anoMesAtual = "" + anoAtual + "0" + mesAtual;
98      }
99      else {
100       anoMesAtual = "" + anoAtual + mesAtual;
101 
102     }
103     Integer atual = Integer.valueOf(anoMesAtual);
104     int maisProximo = 0;
105 
106     for (Iterator it = aref.iterator(); it.hasNext();) {
107       AcompReferenciaAref itemAref = (AcompReferenciaAref) it.next();
108       Integer item = Integer.valueOf("" + itemAref.getAnoAref() + itemAref.getMesAref());
109       if (atual.intValue() == item.intValue()) {
110         return itemAref;
111       }
112       else if (item.intValue() < atual.intValue() && item.intValue() > maisProximo) {
113         maisProximo = item.intValue();
114         arefSelecionado = itemAref;
115       }
116       else if (item.longValue() > atual.longValue()) {
117         maisProximo = atual.intValue();
118         int mesItem = Integer.valueOf(itemAref.getMesAref()).intValue();
119         int anoItem = Integer.valueOf(itemAref.getAnoAref()).intValue();
120         int difItem;
121         int difProximo = atual.intValue() - maisProximo;
122 
123         if (anoItem == anoAtual) { // Se estiverem no mesmo ano
124           difItem = atual.intValue() - item.intValue();
125 
126           int anoProximo = Integer.valueOf(("" + maisProximo).substring(0, 4)).intValue();
127           int mesProximo = Integer.valueOf(("" + maisProximo).substring(4, 6)).intValue();
128 
129           if (anoProximo < anoAtual) { // testo com ano do Proximo maior que o
130                                        // ano atual
131             int qtd = 0;
132             int ano = anoAtual;
133             int mes = mesAtual;
134             while (ano >= anoProximo) {
135               while (mes >= 1) {
136                 if (ano == anoProximo && mes == mesProximo) {
137                   break;
138                 }
139                 qtd++;
140                 mes--;
141               }
142               mes = 12;
143               ano--;
144             }
145             difProximo = qtd;
146 
147           }
148           else if (anoProximo > anoAtual) { // testo com ano do Proximo menos
149                                             // que o atual
150             int qtd = 0;
151             int ano = anoAtual;
152             int mes = mesAtual;
153             while (ano <= anoProximo) {
154               while (mes <= 12) {
155                 if (ano == anoProximo && mes == mesProximo) {
156                   break;
157                 }
158                 qtd++;
159                 mes++;
160               }
161               mes = 1;
162               ano++;
163             }
164             difProximo = qtd;
165           }
166           else { // anoProximo == anoAtual
167             int mes = mesAtual;
168             if (mes == mesProximo) {
169               arefSelecionado = itemAref;
170             }
171             else {
172               difProximo = mes - mesProximo;
173             }
174           }
175 
176           /*
177            * Estas duas linhas abaixo servem para transformar a diferença em
178            * número positivo, caso dê negativo
179            */
180           difItem = (difItem < 0 ? (difItem * -1) : difItem);
181           difProximo = (difProximo < 0 ? (difProximo * -1) : difProximo);
182 
183           if (difItem < difProximo) {
184             maisProximo = item.intValue();
185             arefSelecionado = itemAref;
186           }
187         }
188         else if (anoItem > anoAtual) { // Se ano do item é maior que o ano atual
189           int qtdMesesMais = 0;
190           int mes = mesAtual;
191           int ano = anoAtual;
192 
193           while (ano <= anoItem) {
194             while (mes <= 12) {
195               if (ano == anoItem && mes == mesItem) {
196                 break;
197               }
198               qtdMesesMais++;
199               mes++;
200             }
201             mes = 1;
202             ano++;
203           }
204 
205           if (qtdMesesMais < difProximo) {
206             maisProximo = item.intValue();
207             arefSelecionado = itemAref;
208           }
209 
210           if (arefSelecionado == null) {
211             arefSelecionado = itemAref;
212           }
213         }
214         else { // Ano item é menor que ano atual
215           int qtdMesesMenos = 0;
216           int mes = mesAtual;
217           int ano = anoAtual;
218           while (ano >= anoItem) {
219             while (mes >= 1) {
220               if (ano == anoItem && mes == mesItem) {
221                 break;
222               }
223               qtdMesesMenos++;
224               mes--;
225             }
226             mes = 12;
227             ano--;
228           }
229 
230           if (qtdMesesMenos < difProximo) {
231             maisProximo = item.intValue();
232             arefSelecionado = itemAref;
233           }
234         }
235       }
236     }
237     return arefSelecionado;
238   }
239 
240   /**
241    * Devolve uma lista de AcompReferencia ordenado por mes/ano
242    * @return
243    */
244   public List getListAcompReferenciaOrderByNome() throws ECARException {
245     return listar(AcompReferenciaAref.class, new String[] { "nomeAref", "asc" });
246   }
247 
248   /**
249    * Devolve uma lista de AcompReferencia com
250    * tipoAcompanhamento.indMonitoramentoTa = 'S'
251    * @return
252    */
253   public List getListAcompReferenciaEmMonitoramento() throws ECARException {
254     List lista = null;
255 
256     try {
257       lista = this.session.createQuery("from AcompReferenciaAref a where a.tipoAcompanhamentoTa.indMonitoramentoTa = 'S' order by a.anoAref desc, a.mesAref desc").list();
258     } catch (HibernateException e) {
259       this.logger.error(e);
260       throw new ECARException("erro.hibernateException");
261     }
262 
263     return lista;
264   }
265 
266   /**
267    * Devolve uma lista de AcompReferencia com cod_ORG preenchido ordenado por
268    * cod_ORG
269    * @return
270    * @deprecated desde 21/05/2005
271    * @see getListAcompReferenciaPorOrgao(OrgaoOrg orgao)
272    */
273   public List getListAcompReferenciaPorOrgao() throws ECARException {
274     List lista = null;
275 
276     try {
277       lista = this.session.createQuery("from AcompReferenciaAref a where a.tipoAcompanhamentoTa.indMonitoramentoTa = 'N' order by a.orgaoOrg.codOrg asc, a.anoAref desc, a.mesAref desc").list();
278     } catch (HibernateException e) {
279       this.logger.error(e);
280       throw new ECARException("erro.hibernateException");
281     }
282 
283     return lista;
284   }
285 
286   /**
287    * Devolve uma lista de acompanhamento de referencia do orgao passado como
288    * param.
289    * @param orgao
290    * @return List AcompReferencia
291    * @throws ECARException
292    */
293   public List getListAcompReferenciaProprioOrgao(OrgaoOrg orgao) throws ECARException {
294     try {
295 
296       StringBuilder select = new StringBuilder("from AcompReferenciaAref a ").append("where a.orgaoOrg.codOrg = :codOrg ").append("order by a.orgaoOrg.codOrg asc, a.anoAref desc, a.mesAref desc");
297 
298       Query q = this.session.createQuery(select.toString());
299 
300       q.setLong("codOrg", orgao.getCodOrg().longValue());
301 
302       return q.list();
303     } catch (HibernateException e) {
304       this.logger.error(e);
305       throw new ECARException("erro.hibernateException");
306     }
307   }
308 
309   /**
310    * Devolve uma lista de acompanhamento de referencia cujos orgao sejam
311    * diferentes do passado como parametro.
312    * @param orgao
313    * @return List AcompReferencia
314    * @throws ECARException
315    */
316   public List getListAcompReferenciaOutrosOrgaos(OrgaoOrg orgao) throws ECARException {
317     try {
318       StringBuilder select = new StringBuilder("from AcompReferenciaAref a ").append("where (a.orgaoOrg.codOrg <> :codOrg or a.orgaoOrg is null) ").append("order by a.orgaoOrg.codOrg asc, a.anoAref desc, a.mesAref desc");
319 
320       Query q = this.session.createQuery(select.toString());
321 
322       q.setLong("codOrg", orgao.getCodOrg().longValue());
323 
324       return q.list();
325     } catch (HibernateException e) {
326       this.logger.error(e);
327       throw new ECARException("erro.hibernateException");
328     }
329   }
330 
331   /**
332    * Devolve a lista de datas limite ordenadas de acordo com a hierarquia de
333    * funcoes de acompanhamento de filho para pai, ou seja, do mais fraco para o
334    * mais forte na hierarquia
335    * @param AcompReferenciaAref acomp
336    * @return
337    */
338   public List getAcompRefLimitesOrderByFuncaoAcomp(AcompReferenciaAref acomp) throws ECARException {
339 
340     List lResultado = new ArrayList();
341     List lFuncAcomp = new TipoFuncAcompDao(request).getTipoFuncAcompEmitePosicao();
342 
343     TipoFuncAcompTpfa funcao;
344     AcompRefLimitesArl acompRefLimite;
345 
346     if (acomp != null && acomp.getAcompRefLimitesArls() != null) {
347       /* loop nas funcoes em ordem de filho para pai */
348 
349       for (Iterator itFunc = lFuncAcomp.iterator(); itFunc.hasNext();) {
350         funcao = (TipoFuncAcompTpfa) itFunc.next();
351 
352         for (Iterator itAcomp = acomp.getAcompRefLimitesArls().iterator(); itAcomp.hasNext();) {
353           acompRefLimite = (AcompRefLimitesArl) itAcomp.next();
354           if (acompRefLimite.getTipoFuncAcompTpfa().getCodTpfa().longValue() == funcao.getCodTpfa().longValue()) {
355             lResultado.add(acompRefLimite);
356             break;
357           }
358         }
359       }
360     }
361     return lResultado;
362   }
363 
364   /**
365    * Retorna um objeto AcompRefLimites a partir de uma Função de Acompanhamento
366    * e um Acompanhamento
367    * @param acomp
368    * @param funcaoAcomp
369    * @return
370    * @throws ECARException
371    */
372   public AcompRefLimitesArl getAcompRefLimitesByFuncaoAcomp(AcompReferenciaAref acomp, TipoFuncAcompTpfa funcaoAcomp) throws ECARException {
373     try {
374       return (AcompRefLimitesArl) this.getSession().get(AcompRefLimitesArl.class, new AcompRefLimitesArlPK(acomp.getCodAref(), funcaoAcomp.getCodTpfa()));
375     } catch (HibernateException e) {
376       this.logger.error(e);
377       throw new ECARException(e);
378     }
379   }
380 
381   /**
382    * Cria um objeto acompReferencia a partir de parâmetros passados no objeto
383    * request
384    * @param request
385    * @param acompREferencia
386    * @throws ECARException
387    */
388   public void setAcompReferencia(HttpServletRequest request, AcompReferenciaAref acompReferencia, Long orgaoOrg, TipoAcompanhamentoTa tipoAcompanhamento) throws ECARException {
389 
390     acompReferencia.setTipoAcompanhamentoTa(tipoAcompanhamento);
391 
392     if (orgaoOrg != null) {
393       acompReferencia.setOrgaoOrg((OrgaoOrg) this.buscar(OrgaoOrg.class, orgaoOrg));
394     }
395     else {
396       acompReferencia.setOrgaoOrg(null);
397     }
398 
399     acompReferencia.setNomeAref(Pagina.getParamStr(request, "nomeAref").trim());
400     acompReferencia.setAnoAref(Pagina.getParamStr(request, "anoAref").trim());
401     acompReferencia.setMesAref(Pagina.getParamStr(request, "mesAref"));
402     acompReferencia.setDataInicioAref(Data.parseDate(Pagina.getParamStr(request, "dataInicioAref")));
403     acompReferencia.setDataLimiteAcompFisicoAref(Data.parseDate(Pagina.getParamStr(request, "dataLimiteAcompFisicoAref")));
404     acompReferencia.setDataUltManutAref(Data.getDataAtual());
405     acompReferencia.setExercicioExe(getExercicio(acompReferencia.getAnoAref(), acompReferencia.getMesAref()));
406 
407     setAcompLimites(request, acompReferencia);
408 
409     this.validaInclusaoPeriodoReferencia(acompReferencia);
410   }
411 
412   /**
413    * Método para criar a coleção de acompLimites a partir de parâmetros passados
414    * por request
415    * @param request
416    * @param acomReferencia Objeto a ser manipulado
417    * @throws ECARException
418    */
419   public void setAcompLimites(HttpServletRequest request, AcompReferenciaAref acompReferencia) throws ECARException {
420 
421     Set limites = new HashSet();
422 
423     for (Iterator it = new TipoFuncAcompDao(request).getTipoFuncAcompEmitePosicao().iterator(); it.hasNext();) {
424       TipoFuncAcompTpfa funcao = (TipoFuncAcompTpfa) it.next();
425 
426       if (!"".equals(Pagina.getParamStr(request, "prazoFinalPara" + funcao.getCodTpfa().toString()))) {
427         AcompRefLimitesArl acompLimite;
428 
429         // busca um ARL para alterar a data
430         acompLimite = this.getAcompRefLimitesByFuncaoAcomp(acompReferencia, funcao);
431         if (acompLimite != null) {
432           acompLimite.setDataLimiteArl(Data.parseDate(Pagina.getParamStr(request, "prazoFinalPara" + funcao.getCodTpfa().toString())));
433 
434         }
435         else {
436           // senao insere um novo ARL
437           acompLimite = new AcompRefLimitesArl();
438           acompLimite.setAcompReferenciaAref(acompReferencia);
439           acompLimite.setTipoFuncAcompTpfa(funcao);
440           acompLimite.setDataLimiteArl(Data.parseDate(Pagina.getParamStr(request, "prazoFinalPara" + funcao.getCodTpfa().toString())));
441         }
442         limites.add(acompLimite);
443       }
444 
445     }
446 
447     // 
448     // acompReferencia.setAcompRefLimitesArls(null);
449     acompReferencia.setAcompRefLimitesArls(limites);
450   }
451 
452   /**
453    * Exclui acompReferencia, e seus filhos acompRefLimites relacionados;
454    * @param acompReferencia
455    * @throws ECARException
456    */
457   public void excluir(String[] codigosParaExcluir) throws ECARException, HibernateException {
458     AcompRealFisicoDao arfDao = new AcompRealFisicoDao(null);
459     List lista = new ArrayList();
460     for (int i = 0; i < codigosParaExcluir.length; i++) {
461       AcompReferenciaAref acompReferencia = (AcompReferenciaAref) buscar(AcompReferenciaAref.class, Long.valueOf(codigosParaExcluir[i]));
462       /*
463        * Validação referente ao bug 898
464        */
465       if (acompReferencia.getAcompReferenciaItemAris() != null) {
466         acompReferencia.getAcompReferenciaItemAris().size();
467         List itensAri = new ArrayList(acompReferencia.getAcompReferenciaItemAris());
468 
469         for (Iterator itItensAri = itensAri.iterator(); itItensAri.hasNext();) {
470           AcompReferenciaItemAri acompRefItAri = (AcompReferenciaItemAri) itItensAri.next();
471 
472           if (acompRefItAri.getStatusRelatorioSrl() != null && acompRefItAri.getStatusRelatorioSrl().getCodSrl() != null && acompRefItAri.getStatusRelatorioSrl().getCodSrl().intValue() == AcompReferenciaItemDao.STATUS_LIBERADO) {
473 
474             throw new ECARException("periodoReferencia.exclusao.posicaoJaLiberada", null, new String[] { acompRefItAri.getItemEstruturaIett().getNomeIett() });
475 
476           }
477           /*
478            * Código anterior --------------- if
479            * (acompRefItAri.getAcompRelatorioArels() != null){
480            * acompRefItAri.getAcompRelatorioArels().size(); List itensArel = new
481            * ArrayList(acompRefItAri.getAcompRelatorioArels()); Iterator
482            * itItensArel = itensArel.iterator(); while(itItensArel.hasNext()){
483            * AcompRelatorioArel aRel = (AcompRelatorioArel) itItensArel.next();
484            * if ("S".equals(aRel.getIndLiberadoArel())){ //throw new
485            * ECARException("periodoReferencia.exclusao.posicaoJaLiberada");
486            * throw new
487            * ECARException("periodoReferencia.exclusao.posicaoJaLiberada", null,
488            * new String[] {acompRefItAri.getItemEstruturaIett().getNomeIett()});
489            * } } }
490            */
491 
492           // Nova verificação devido ao Mantis 5518
493           // verificar o ARF correspondente ao ARI que podem ser excluído
494           StringBuilder query = new StringBuilder("select ARI from AcompReferenciaItemAri as ARI").append(" where ARI.itemEstruturaIett.codIett = :codIett").append(" and ARI.itemEstruturaIett.indAtivoIett = 'S'").append(" and ARI.acompReferenciaAref.mesAref = :mesAref").append(" and ARI.acompReferenciaAref.anoAref = :anoAref").append(" and ARI.codAri<> :codAri");
495 
496           Query q = this.getSession().createQuery(query.toString());
497 
498           q.setLong("codIett", acompRefItAri.getItemEstruturaIett().getCodIett().longValue());
499           q.setString("mesAref", acompRefItAri.getAcompReferenciaAref().getMesAref());
500           q.setString("anoAref", acompRefItAri.getAcompReferenciaAref().getAnoAref());
501           q.setLong("codAri", acompRefItAri.getCodAri().longValue());
502 
503           List listaARI = q.list();
504 
505           if (listaARI == null || listaARI.isEmpty()) {
506             // o ARF correspondente pode ser removido pois não está em uso
507             List listArf = arfDao.buscarPorIett(acompRefItAri.getItemEstruturaIett().getCodIett(), Long.valueOf(acompRefItAri.getAcompReferenciaAref().getMesAref()), Long.valueOf(acompRefItAri.getAcompReferenciaAref().getAnoAref()));
508 
509             if (listArf != null && !listArf.isEmpty()) {
510               lista.addAll(listArf);
511             }
512           }
513         }
514       }
515       lista.addAll(acompReferencia.getAcompRefLimitesArls());
516       lista.addAll(acompReferencia.getAcompReferenciaItemAris());
517       lista.add(acompReferencia);
518     }
519     super.excluir(lista);
520   }
521 
522   /**
523    * Lista todos os itensEstrutura de AcompReferenciaItem, para um
524    * AcompReferenciaAref lista[0] = retorna a arvore de itens lista[1] = retorna
525    * os itens selecionaveis
526    * @param acompReferencia AcompReferenciaAref
527    * @param usuario UsuarioUsu
528    * @param gruposUsuario Set
529    * @param tipoAcesso String
530    * @param somenteAcompanhamento String
531    * @return lista de itensEstrutura
532    * @throws ECARException
533    */
534   public List[] getItemEstruturaAcompanhamento(List listAris, TipoAcompanhamentoTa tipoAcompanhamento, UsuarioUsu usuario, Set gruposUsuario, String tipoAcesso, String somenteAcompanhamento, int nuPagina, int nuItensPaginacao) throws ECARException {
535 
536     ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(request);
537 
538     List[] retorno = new List[4];
539     List selecionaveis = new ArrayList();
540     List itensSemParecer = new ArrayList();
541     List selecionaveisOrdenadosPaginados = new ArrayList();
542 
543     // indices inicial e final para a consulta dos itensEstrutura
544     int indiceInicial = (nuPagina - 1) * nuItensPaginacao + 1;
545     int indiceFinal = (nuPagina - 1) * nuItensPaginacao + nuItensPaginacao;
546     int contador = 1; // variavel que guarda qual o indice no iterador
547 
548     for (Iterator it = listAris.iterator(); it.hasNext();) {
549       AcompReferenciaItemAri acompRefItem = (AcompReferenciaItemAri) it.next();
550       if (validaPermissao.permissaoAcessoItemElaboracaoAcomp(acompRefItem.getItemEstruturaIett(), usuario, gruposUsuario, tipoAcesso, tipoAcompanhamento)) {
551         if (acompRefItem.getAcompRelatorioArels() != null && acompRefItem.getAcompRelatorioArels().size() > 0) {
552           selecionaveis.add(acompRefItem.getItemEstruturaIett());
553         }
554         else if ("N".equals(somenteAcompanhamento)) {
555           selecionaveis.add(acompRefItem.getItemEstruturaIett());
556           itensSemParecer.add(acompRefItem.getItemEstruturaIett());
557         }
558       }
559     }
560 
561     // Selecionar os itens da pagina que esta sendo visualizada
562     List selecionaveisOrdenados = itemEstruturaDao.getItensOrdenados(selecionaveis, tipoAcompanhamento);
563     Iterator selecionaveisOrdenadosIt = selecionaveisOrdenados.iterator();
564     while (selecionaveisOrdenadosIt.hasNext()) {
565       AtributoEstruturaListagemItens atEstListagem = (AtributoEstruturaListagemItens) selecionaveisOrdenadosIt.next();
566       if (indiceInicial <= contador && contador <= indiceFinal) {
567         selecionaveisOrdenadosPaginados.add(atEstListagem);
568       }
569       else if (contador > indiceFinal) {
570         break;
571       }
572       contador++;
573     }
574     // selecionaveis ordenados e já paginados
575     retorno[0] = selecionaveisOrdenadosPaginados;
576     retorno[1] = selecionaveis;
577     retorno[2] = itensSemParecer;
578     retorno[3] = selecionaveisOrdenados;
579 
580     return retorno;
581   }
582 
583   /**
584    * Retorna o Exercício de um AcompReferencia, ou então de um ano e mes
585    * passados como parametro.
586    * @param ano
587    * @param mes
588    * @return
589    * @throws ECARException
590    */
591   public ExercicioExe getExercicio(String ano, String mes) throws ECARException {
592     ExercicioExe exercicio = new ExercicioExe();
593 
594     /* Padrão iniciar o Exercício é o dia 01 */
595     /* Padrão de data no HQL, é como no Banco de Dados */
596     StringBuilder select = new StringBuilder("select distinct exercicio from ExercicioExe as exercicio").append(" where exercicio.dataInicialExe <= :data").append(" and exercicio.dataFinalExe >= :data");
597 
598     Date data = Data.parseDate("01/" + mes + "/" + ano);
599 
600     try {
601 
602       Query q = this.getSession().createQuery(select.toString());
603 
604       q.setDate("data", data);
605 
606       List lista = q.list();
607 
608       Iterator it = lista.iterator();
609 
610       if (it.hasNext()) {
611         exercicio = (ExercicioExe) it.next();
612         return exercicio;
613       }
614       else {
615         return null;
616       }
617     } catch (HibernateException e) {
618       this.logger.error(e);
619       throw new ECARException(e);
620     }
621   }
622 
623   /**
624    * Retorna lista de itens descendentes (filhos) de um itemPai, que satisfaçam
625    * as regras abaixo: - os itens devem possuir indicador de resultado, e
626    * quantidade prevista. - os itens devem possuir o mesmo AcompReferencia do
627    * Pai. lista[0] = retorna a arvore de itens até o filho selecionavel lista[1]
628    * = retorna os filhos selecionaveis
629    * @param acompReferencia
630    * @param itemPai
631    * @return
632    * @throws HibernateException
633    * @throws ECARException
634    */
635   public List[] getItensFilhosByAcompReferencia(AcompReferenciaAref acompReferencia, ItemEstruturaIett itemPai, UsuarioUsu usuario) throws HibernateException, ECARException {
636     List[] retorno = new List[2];
637     List listaAux = new ArrayList();
638 
639     AcompReferenciaItemDao acompReferenciaItemDao = new AcompReferenciaItemDao(request);
640     ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(request);
641 
642     // Itens gravados para o acompanhamento
643     List listItensGravados = new ArrayList();
644     if (acompReferencia.getCodAref() != null) {
645       listItensGravados = acompReferenciaItemDao.getListaItensAcompanhamento(acompReferencia);
646     }
647 
648     // List listNiveis = new
649     // ArrayList(acompReferencia.getTipoAcompanhamentoTa().getSisAtributoSatbs());
650 
651     List listaItem = itemEstruturaDao.getDescendentes(itemPai, true);
652 
653     for (Iterator it = listaItem.iterator(); it.hasNext();) {
654       ItemEstruturaIett item = (ItemEstruturaIett) it.next();
655 
656       StringBuilder select = new StringBuilder("select item from ItemEstruturaIett as item").append(" left join item.itemEstrtIndResulIettrs as indResultados").append(" left join indResultados.itemEstrutFisicoIettfs as qtdPrevista").append(" where qtdPrevista.indAtivoIettf = 'S'").append(" and item.codIett = :codIett").append(" and item.indAtivoIett = 'S'");
657 
658       Query q = this.getSession().createQuery(select.toString());
659 
660       q.setLong("codIett", item.getCodIett().longValue());
661 
662       List<ItemEstruturaIett> listaQtdPrev = q.list();
663 
664       boolean permissaoParecerLeituraMetaIndicador = false;
665       // obtem a lista de itens
666       for (ItemEstruturaIett item_inner : listaQtdPrev) {
667 
668         Collection<ItemEstrutUsuarioIettus> listaIettus = item_inner.getItemEstrutUsuarioIettusesByCodIett();
669         // obtem a lista de permissões
670         for (ItemEstrutUsuarioIettus iettus : listaIettus) {
671 
672           // verifica se há alguma permissão de leitura de parecer e a permissão
673           // é para o usuário passado ou se o grupo de acesso contido no iettus
674           // está na lista de grupos de acesso do usuário.
675           if ((iettus.getIndLeituraParecerIettus() != null && iettus.getIndLeituraParecerIettus().equals(Dominios.SIM)) && (usuario.equals(iettus.getUsuarioUsu()) || consultarPermissaoUsuario(usuario, iettus))) {
676             permissaoParecerLeituraMetaIndicador = true;
677             break;// interrompe o loop mais interno
678           }
679         }
680         if (permissaoParecerLeituraMetaIndicador) {// Já encontrou portanto
681                                                    // interrompe o loop mais
682                                                    // externo
683           break;
684         }
685 
686       }
687 
688       if (!permissaoParecerLeituraMetaIndicador || listaQtdPrev.isEmpty() || !listItensGravados.contains(item)) {
689         listaAux.add(item);
690       }
691 
692       /*
693        * if (!permissaoParecerLeituraMetaIndicador) {
694        * if(listaQtdPrev.isEmpty()){ listaAux.add(item); }else{
695        * if(!listItensGravados.contains(item)){ listaAux.add(item); } } }
696        */
697     }
698 
699     listaItem.removeAll(listaAux);
700 
701     retorno[0] = itemEstruturaDao.getArvoreItens(listaItem, itemPai);
702     retorno[0].remove(itemPai);
703     retorno[1] = listaItem;
704 
705     return retorno;
706   }
707 
708   /**
709    * Verifica na lista de grupos do usuário se ele possui acesso a
710    * permissão(iettus) enviada como parâmetro.
711    * @param usuario
712    * @param iettus
713    * @return
714    */
715   private boolean consultarPermissaoUsuario(UsuarioUsu usuario, ItemEstrutUsuarioIettus iettus) {
716 
717     boolean ret = false;
718 
719     Set<UsuarioAtributoUsua> listaUsuarioAtributo = usuario.getUsuarioAtributoUsuas();
720 
721     for (UsuarioAtributoUsua usuarioAtributo : listaUsuarioAtributo) {
722 
723       if (usuarioAtributo.getSisAtributoSatb().equals(iettus.getSisAtributoSatb())) {
724         ret = true;
725         break;
726       }
727     }
728 
729     return ret;
730   }
731 
732   /**
733    * Valida a possibilidade de inclusão de um período de referência. Dispara
734    * exceções correspondetes a motivos que impeçam o cadastro de um
735    * acompanhemto:
736    * periodoReferencia.validacao.mesAnoTipoAcompanhamento.jaExistente = Já
737    * existe um acompanhamento para este mês/ano deste tipo de acompanhamento
738    * periodoReferencia.validacao.exercicioNaoEncontrado = Não existe um
739    * exercício cadastrado que compreenda o mês/ano informado
740    * @param acompanhamentoReferencia
741    * @throws ECARException
742    */
743   public void validaInclusaoPeriodoReferencia(AcompReferenciaAref acompanhamentoReferencia) throws ECARException {
744     if (getExercicio(acompanhamentoReferencia.getAnoAref(), acompanhamentoReferencia.getMesAref()) == null) {
745       throw new ECARException("periodoReferencia.validacao.exercicioNaoEncontrado");
746     }
747   }
748 
749   /**
750    * Retorna uma coleção com os n periodos anteriores a um periodo.
751    * @param codArefReferencia O Código do periodo de referencia
752    * @param numPeriodosAnteriores Quantos periodos devem ser retornados
753    * @param tipoAcompanhamento Tipo de Acompanhamento
754    * @return Coleçao de AcompReferenciaAref
755    * @throws ECARException
756    */
757   public Collection getPeriodosAnteriores(Long codArefReferencia, int numPeriodosAnteriores, Long tipoAcompanhamento) throws ECARException {
758     return getPeriodosAnterioresOrdenado(codArefReferencia, numPeriodosAnteriores, tipoAcompanhamento, true);
759   }
760 
761   /**
762    * Retorna uma coleção com os n periodos anteriores a um periodo.
763    * @param codArefReferencia O Código do periodo de referencia
764    * @param numPeriodosAnteriores Quantos periodos devem ser retornados
765    * @param tipoAcompanhamento Tipo de Acompanhamento
766    * @return Coleçao de AcompReferenciaAref
767    * @throws ECARException
768    */
769 
770   public Collection getPeriodosAnterioresOrdenado(Long codArefReferencia, int numPeriodosAnteriores, Long tipoAcompanhamento, boolean ordena) throws ECARException {
771 
772     try {
773 
774       AcompReferenciaAref aref = (AcompReferenciaAref) this.buscar(AcompReferenciaAref.class, codArefReferencia);
775 
776       // Descobre todos os Aref que serão considerados, dependendo da Data de
777       // Inicio do Aref e o número de meses anteriores
778       String mesReferencia = aref.getMesAref();
779       String anoReferencia = aref.getAnoAref();
780 
781       // pesquisa o periodo de referencia selecionado
782       StringBuilder query = new StringBuilder("select aref from AcompReferenciaAref aref").append(" where aref.codAref = :codArefReferencia").append(" and aref.tipoAcompanhamentoTa.codTa = :codTa");
783 
784       Query queryAcompanhamentos = this.getSession().createQuery(query.toString());
785       queryAcompanhamentos.setString("codArefReferencia", codArefReferencia.toString());
786       queryAcompanhamentos.setLong("codTa", tipoAcompanhamento.longValue());
787 
788       // adiciona a lista
789       List retorno = queryAcompanhamentos.list();
790       AcompReferenciaAref arefResultado = (AcompReferenciaAref) retorno.get(0);
791 
792       // diminui a quantidade de resultados maximos obtidos porque o primeiro já
793       // é a própria refereência
794       numPeriodosAnteriores = numPeriodosAnteriores - 1;
795 
796       if (numPeriodosAnteriores > 0) {
797 
798         query = new StringBuilder("select aref from AcompReferenciaAref aref ").append(" where (aref.anoAref < :anoReferencia  or (aref.anoAref = :anoReferencia and aref.mesAref <= :mesReferencia))").append("and aref.codAref <> :codArefReferencia").append(" and aref.tipoAcompanhamentoTa.codTa = :codTa").append(" order by aref.anoAref desc, aref.mesAref desc, aref.dataInicioAref desc");
799 
800         queryAcompanhamentos = this.getSession().createQuery(query.toString());
801         queryAcompanhamentos.setString("anoReferencia", anoReferencia);
802         queryAcompanhamentos.setString("mesReferencia", mesReferencia);
803         queryAcompanhamentos.setString("codArefReferencia", codArefReferencia.toString());
804         queryAcompanhamentos.setLong("codTa", tipoAcompanhamento.longValue());
805 
806         /* quantidade de resultados será o número de periodos anteriores */
807         queryAcompanhamentos.setMaxResults(numPeriodosAnteriores);
808 
809         if (queryAcompanhamentos != null) {
810           // adiciona a lista os periodos anteriores
811           Iterator it = queryAcompanhamentos.iterate();
812           while (it.hasNext()) {
813             AcompReferenciaAref arefTeste = (AcompReferenciaAref) it.next();
814             retorno.add(arefTeste);
815           }
816         }
817       }
818 
819       if (ordena) {
820         Collections.reverse(retorno);
821       }
822 
823       return retorno;
824 
825     } catch (HibernateException e) {
826       this.logger.error(e);
827       throw new ECARException(e);
828     }
829   }
830 
831   /**
832    * Retorna uma lista com todos os òrgãos que possuem algum acompanhamento de
833    * referência criado
834    * @return
835    * @throws ECARException
836    */
837   public Collection getOrgaosComAcompanhamentosCriados(String codTipoAcompanhamento) throws ECARException {
838     try {
839       StringBuilder query = new StringBuilder("select distinct aref.orgaoOrg from AcompReferenciaAref aref");
840       if (!"".equals(codTipoAcompanhamento)) {
841         query.append(" where aref.tipoAcompanhamentoTa.codTa=").append(codTipoAcompanhamento);
842       }
843       Query queryItens = this.getSession().createQuery(query.toString());
844 
845       return queryItens.list();
846     } catch (HibernateException e) {
847       this.logger.error(e);
848       throw new ECARException(e);
849     }
850 
851   }
852 
853   /**
854    * Verifica se existe quantidades de realizado físico.
855    * @param acompReferencia
856    * @throws ECARException
857    */
858   public boolean existeQuantidades(String[] codigos) throws ECARException {
859     AcompRealFisicoDao arfDao = new AcompRealFisicoDao(null);
860     for (int i = 0; i < codigos.length; i++) {
861 
862       AcompReferenciaAref acompReferencia = (AcompReferenciaAref) buscar(AcompReferenciaAref.class, Long.valueOf(codigos[i]));
863 
864       if (acompReferencia.getAcompReferenciaItemAris() != null) {
865         acompReferencia.getAcompReferenciaItemAris().size();
866 
867         for (Iterator itItensAri = acompReferencia.getAcompReferenciaItemAris().iterator(); itItensAri.hasNext();) {
868           AcompReferenciaItemAri acompRefItAri = (AcompReferenciaItemAri) itItensAri.next();
869 
870           List listArf = arfDao.buscarPorIett(acompRefItAri.getItemEstruturaIett().getCodIett(), Long.valueOf(acompRefItAri.getAcompReferenciaAref().getMesAref()), Long.valueOf(acompRefItAri.getAcompReferenciaAref().getAnoAref()));
871 
872           if (listArf != null) {
873 
874             for (Iterator itItensArfs = listArf.iterator(); itItensArfs.hasNext();) {
875               AcompRealFisicoArf acompRealFisicoArf = (AcompRealFisicoArf) itItensArfs.next();
876               if (acompRealFisicoArf.getQtdRealizadaArf() != null && acompRealFisicoArf.getQtdRealizadaArf().doubleValue() > 0) {
877                 return true;
878               }
879             }
880           }
881         }
882       }
883     }
884     return false;
885   }
886 
887   /**
888    * Obter os últimos acompanhamentos (AcompReferenciaAref) de um item.
889    * @param item
890    * @param qtdeUltimosAcompanhamentos
891    * @param soEmitidos
892    * @return
893    * @throws HibernateException
894    * @throws ECARException
895    */
896   public List getUltimoAcompanhamentoItem(ItemEstruturaIett item, Integer qtdeUltimosAcompanhamentos) throws HibernateException, ECARException {
897     try {
898       StringBuilder str = new StringBuilder();
899       str.append("select aref from AcompReferenciaAref aref");
900       str.append(" join aref.acompReferenciaItemAris as aris");
901       str.append(" where aris.itemEstruturaIett.codIett = :codItem");
902       str.append(" and aris.itemEstruturaIett.indAtivoIett = 'S'");
903       str.append(" order by aref.anoAref desc, aref.mesAref desc");
904 
905       Query query = this.getSession().createQuery(str.toString());
906       query.setLong("codItem", item.getCodIett().longValue());
907       if (qtdeUltimosAcompanhamentos != null) {
908         query.setMaxResults(qtdeUltimosAcompanhamentos.intValue());
909       }
910 
911       return query.list();
912 
913     } catch (HibernateException e) {
914       this.logger.error(e);
915       throw new ECARException(e);
916     }
917   }
918 
919   /**
920    * Obter os acompanhamentos (AcompReferenciaAref) que sejam de um tipo de
921    * acompanhamento
922    * @param codTipoAcompanhamento Long
923    * @return
924    * @throws HibernateException
925    * @throws ECARException
926    */
927   public List<AcompReferenciaAref> getListAcompReferenciaByTipoAcompanhamento(Long codTipoAcompanhamento) throws HibernateException, ECARException {
928     try {
929       StringBuilder str = new StringBuilder();
930       str.append("select aref from AcompReferenciaAref aref");
931       str.append(" where aref.tipoAcompanhamentoTa.codTa = :codTa");
932       str.append(" order by aref.anoAref desc, aref.mesAref desc, aref.dataInicioAref desc");
933 
934       Query query = this.getSession().createQuery(str.toString());
935       query.setLong("codTa", codTipoAcompanhamento.longValue());
936       return query.list();
937 
938     } catch (HibernateException e) {
939       this.logger.error(e);
940       throw new ECARException(e);
941     }
942   }
943 
944   /**
945    * Obtem a lista de acompanhamento que sejam de um tipo de acompanhamento que
946    * estão abertos. Abertos são os acompanhamento que tem pelo menos uma data
947    * para emitir parecer no futuro.
948    * @param codTipoAcompanhamento Long
949    * @return
950    * @throws HibernateException
951    * @throws ECARException
952    */
953   @SuppressWarnings("unchecked")
954   public List<AcompReferenciaAref> getListAcompReferenciaByTipoAcompanhamentoAbertos(Long codTipoAcompanhamento) throws HibernateException, ECARException {
955     try {
956       List<AcompReferenciaAref> listaAref = this.getListAcompReferenciaByTipoAcompanhamento(codTipoAcompanhamento);
957       List<AcompReferenciaAref> listaArefRetorno = new ArrayList<AcompReferenciaAref>();
958       for (AcompReferenciaAref aref : listaAref) {
959         Boolean aberto = false;
960         Set<AcompRefLimitesArl> limites = aref.getAcompRefLimitesArls();
961 
962         aberto = (aref.getDataLimiteAcompFisicoAref().before(new Date()));
963 
964         if (!aberto)
965           for (AcompRefLimitesArl arl : limites) {
966             SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
967             Integer hj = new Integer(sdf.format(new Date()));
968 
969             if (hj <= new Integer(sdf.format(arl.getDataLimiteArl()))) {
970               aberto = true;
971               break;
972             }
973           }
974         if (aberto) {
975           listaArefRetorno.add(aref);
976         }
977       }
978       return listaArefRetorno;
979     } catch (HibernateException e) {
980       this.logger.error(e);
981       throw new ECARException(e);
982     }
983   }
984 
985   /**
986    * Obtem a lista de acompanhamento que sejam de um tipo de acompanhamento que
987    * já foram concluidos. Concluídos são os acompanhamento que não tem nenhuma
988    * data limite para emitir parecer no futuro.
989    * @param codTipoAcompanhamento Long
990    * @return
991    * @throws HibernateException
992    * @throws ECARException
993    */
994   public List<AcompReferenciaAref> getListAcompReferenciaByTipoAcompanhamentoConcluidos(Long codTipoAcompanhamento) throws HibernateException, ECARException {
995     try {
996       List<AcompReferenciaAref> listaAref = this.getListAcompReferenciaByTipoAcompanhamento(codTipoAcompanhamento);
997       List<AcompReferenciaAref> listaArefRetorno = new ArrayList<AcompReferenciaAref>();
998       for (AcompReferenciaAref aref : listaAref) {
999         Boolean concluido = true;
1000         Set<AcompRefLimitesArl> limites = aref.getAcompRefLimitesArls();
1001 
1002         if (aref.getDataLimiteAcompFisicoAref().compareTo(new Date()) >= 0) {
1003           concluido = false;
1004         }
1005 
1006         if (concluido)
1007           for (AcompRefLimitesArl arl : limites) {
1008             SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
1009             Integer hj = new Integer(sdf.format(new Date()));
1010 
1011             if (hj <= new Integer(sdf.format(arl.getDataLimiteArl()))) {
1012               concluido = false;
1013               break;
1014             }
1015           }
1016         if (concluido) {
1017           listaArefRetorno.add(aref);
1018         }
1019       }
1020       return listaArefRetorno;
1021     } catch (HibernateException e) {
1022       this.logger.error(e);
1023       throw new ECARException(e);
1024     }
1025   }
1026 
1027   /**
1028    * Obter os ARIs de um AcompReferenciaAref
1029    * @param codAref Long
1030    * @return List de AcompReferenciaItemAri
1031    * @throws HibernateException
1032    * @throws ECARException
1033    */
1034   public List getAcompReferenciaItemAriByAref(Long codAref) throws HibernateException, ECARException {
1035     try {
1036       StringBuilder str = new StringBuilder();
1037       str.append("select ari from AcompReferenciaItemAri ari");
1038       str.append(" where ari.acompReferenciaAref.codAref = :codAref");
1039 
1040       Query query = this.getSession().createQuery(str.toString());
1041       query.setLong("codAref", codAref.longValue());
1042 
1043       return query.list();
1044 
1045     } catch (HibernateException e) {
1046       this.logger.error(e);
1047       throw new ECARException(e);
1048     }
1049   }
1050 
1051   public AcompRefItemLimitesArli getAcompRefItemLimitesArliByAriAndTpfa(Long codAri, Long codTpfa) throws ECARException {
1052     try {
1053       StringBuilder str = new StringBuilder();
1054       str.append("select arli from AcompRefItemLimitesArli arli");
1055       str.append(" where arli.acompReferenciaItemAri.codAri = :codAri");
1056       str.append(" and arli.tipoFuncAcompTpfa.codTpfa = :codTpfa");
1057 
1058       Query query = this.getSession().createQuery(str.toString());
1059       query.setLong("codAri", codAri.longValue());
1060       query.setLong("codTpfa", codTpfa.longValue());
1061       query.setMaxResults(1);
1062 
1063       return (AcompRefItemLimitesArli) query.uniqueResult();
1064 
1065     } catch (HibernateException e) {
1066       this.logger.error(e);
1067       throw new ECARException(e);
1068     }
1069   }
1070 
1071   /**
1072    * Devolve uma lista de AcompReferencia que o usuário faça parte como função
1073    * de acompanhamento'
1074    * @return
1075    */
1076   public List getListAcompReferenciaSuaResponsabilidade(SegurancaECAR seguranca) throws ECARException {
1077     List lista = null;
1078     // AcompReferenciaAref acompReferenciaAref = null;
1079     // acompReferenciaAref.getAcompReferenciaItemAris();
1080     // AcompReferenciaItemAri ari = null;
1081     // ari.getItemEstruturaIett().getItemEstUsutpfuacIettutfas()
1082 
1083     try {
1084 
1085       Query query = this.session.createQuery("select aref from AcompReferenciaAref aref " + "join aref.acompReferenciaItemAris as aris " + "join aref.acompReferenciaItemAris as aris " + "join iett.itemEstUsutpfuacIettutfas as iettutfas " + "where aris.itemEstruturaIett.indAtivoIett = 'S' " + "and " + "		(iettutfas.usuarioUsu = :usuario or iettutfas.sisAtributoSatb in (:gruposAcesso)) " + "order by aref.anoAref desc, aref.mesAref desc");
1086 
1087       query.setParameterList("gruposAcesso", seguranca.getGruposAcesso());
1088       query.setParameter("usuario", seguranca.getUsuario());
1089 
1090       lista = query.list();
1091 
1092     } catch (HibernateException e) {
1093       this.logger.error(e);
1094       throw new ECARException("erro.hibernateException");
1095     }
1096 
1097     return lista;
1098   }
1099 }