View Javadoc

1   /*
2    * Criado em 28/10/2004
3    */
4   package ecar.dao;
5   
6   import java.util.ArrayList;
7   import java.util.Calendar;
8   import java.util.Collections;
9   import java.util.Comparator;
10  import java.util.Date;
11  import java.util.HashSet;
12  import java.util.Iterator;
13  import java.util.List;
14  import java.util.Set;
15  
16  import javax.servlet.http.HttpServletRequest;
17  
18  import org.hibernate.Criteria;
19  import org.hibernate.HibernateException;
20  import org.hibernate.Query;
21  import org.hibernate.Session;
22  import org.hibernate.Transaction;
23  import org.hibernate.criterion.Order;
24  import org.hibernate.criterion.Restrictions;
25  
26  import comum.database.Dao;
27  import comum.util.Data;
28  
29  import ecar.bean.OrdenacaoDataTpfa;
30  import ecar.bean.OrdenacaoTpfaEstrutura;
31  import ecar.bean.SequenciaTipoFuncAcomp;
32  import ecar.exception.ECARException;
33  import ecar.login.SegurancaECAR;
34  import ecar.permissao.ControlePermissao;
35  import ecar.pojo.AcompRefItemLimitesArli;
36  import ecar.pojo.AcompRefLimitesArl;
37  import ecar.pojo.AcompReferenciaAref;
38  import ecar.pojo.AcompReferenciaItemAri;
39  import ecar.pojo.AcompRelatorioArel;
40  import ecar.pojo.EstrutTpFuncAcmpEtttfa;
41  import ecar.pojo.EstrutTpFuncAcmpEtttfaPK;
42  import ecar.pojo.EstruturaEtt;
43  import ecar.pojo.EstruturaFuncaoEttf;
44  import ecar.pojo.ItemEstUsutpfuacIettutfa;
45  import ecar.pojo.ItemEstruturaIett;
46  import ecar.pojo.SisAtributoSatb;
47  import ecar.pojo.SituacaoSit;
48  import ecar.pojo.TfuncacompConfigmailTfacfgm;
49  import ecar.pojo.TipoAcompanhamentoTa;
50  import ecar.pojo.TipoFuncAcompTpfa;
51  import ecar.pojo.UsuarioUsu;
52  import ecar.util.Dominios;
53  
54  /**
55   * @author felipev
56   */
57  public class TipoFuncAcompDao extends Dao {
58  
59    public TipoFuncAcompDao() {
60      super();
61    }
62  
63    /**
64     * Construtor. Chama o Session factory do Hibernate
65     */
66    public TipoFuncAcompDao(HttpServletRequest request) {
67      super();
68      this.request = request;
69    }
70  
71    /**
72     * Salva ...
73     * @param tipoFuncAcomp
74     * @param lstTFuncAcompCfgm
75     * @throws ECARException
76     */
77    public void salvar(TipoFuncAcompTpfa tipoFuncAcomp, List lstTFuncAcompCfgm) throws ECARException {
78      Transaction tx = null;
79      ArrayList objetos = new ArrayList();
80  
81      super.inicializarLogBean();
82  
83      try {
84        tx = session.beginTransaction();
85  
86        session.save(tipoFuncAcomp);
87        objetos.add(tipoFuncAcomp);
88  
89        // inserindo os TfuncacompConfigmailTfacfgm
90  
91        for (Iterator it = lstTFuncAcompCfgm.iterator(); it.hasNext();) {
92          TfuncacompConfigmailTfacfgm tFuncAcompCfgm = (TfuncacompConfigmailTfacfgm) it.next();
93  
94          tFuncAcompCfgm.getComp_id().setTipoFuncAcompTpfa(tipoFuncAcomp);
95  
96          session.save(tFuncAcompCfgm);
97          objetos.add(tFuncAcompCfgm);
98        }
99  
100       tx.commit();
101 
102       if (super.logBean != null) {
103         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
104         super.logBean.setOperacao("INC");
105 
106         for (Iterator itObj = objetos.iterator(); itObj.hasNext();) {
107           super.logBean.setObj(itObj.next());
108           super.loggerAuditoria.info(logBean.toString());
109         }
110       }
111     } catch (HibernateException e) {
112       if (tx != null)
113         try {
114           tx.rollback();
115         } catch (HibernateException r) {
116           this.logger.error(r);
117           throw new ECARException("erro.hibernateException");
118         }
119       this.logger.error(e);
120       throw new ECARException("erro.hibernateException");
121     }
122   } // fim salvar
123 
124   /**
125    * Altera
126    * @param tipoFuncAcomp
127    * @param lstTFuncAcompCfgm
128    * @throws ECARException
129    */
130   public void alterar(TipoFuncAcompTpfa tipoFuncAcomp, List lstTFuncAcompCfgm) throws ECARException {
131 
132     /*
133      * -- Alterado para salvar também o obj tFuncAcompConfigMailTfa.
134      * @author rogeriom
135      * @since 26/04/2006 --
136      */
137 
138     Transaction tx = null;
139     ArrayList objetos = new ArrayList();
140 
141     super.inicializarLogBean();
142 
143     try {
144       tx = session.beginTransaction();
145 
146       session.update(tipoFuncAcomp);
147       objetos.add(tipoFuncAcomp);
148 
149       // deletando os TfuncacompConfigmailTfacfgm gravados
150 
151       for (Iterator it = tipoFuncAcomp.getTfuncacompConfigmailTfacfgm().iterator(); it.hasNext();) {
152         TfuncacompConfigmailTfacfgm tFuncAcompCfgm = (TfuncacompConfigmailTfacfgm) it.next();
153         session.delete(tFuncAcompCfgm);
154       }
155 
156       // inserindo os TfuncacompConfigmailTfacfgm
157 
158       for (Iterator it = lstTFuncAcompCfgm.iterator(); it.hasNext();) {
159         TfuncacompConfigmailTfacfgm tFuncAcompCfgm = (TfuncacompConfigmailTfacfgm) it.next();
160         session.save(tFuncAcompCfgm);
161         objetos.add(tFuncAcompCfgm);
162       }
163       new ControlePermissao().atualizarPermissoesPorFuncaoDeAcompanhamento(tipoFuncAcomp);
164 
165       tx.commit();
166 
167       if (super.logBean != null) {
168         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
169         super.logBean.setOperacao("INC_ALT_EXC");
170 
171         for (Iterator itObj = objetos.iterator(); itObj.hasNext();) {
172           super.logBean.setObj(itObj.next());
173           super.loggerAuditoria.info(logBean.toString());
174         }
175       }
176     } catch (HibernateException e) {
177       if (tx != null)
178         try {
179           tx.rollback();
180         } catch (HibernateException r) {
181           this.logger.error(r);
182           throw new ECARException("erro.hibernateException");
183         }
184       this.logger.error(e);
185       throw new ECARException("erro.hibernateException");
186     }
187 
188   }
189 
190   /**
191    * Exclui...
192    * @param tipoFuncAcomp
193    * @param lstTFuncAcompCfgm
194    * @throws ECARException
195    */
196   public void excluir(TipoFuncAcompTpfa tipoFuncAcomp, List lstTFuncAcompCfgm) throws ECARException {
197 
198     /*
199      * -- Alterado para suportar transacao.
200      * @author rogeriom
201      * @since 02/05/2006 --
202      */
203 
204     Transaction tx = null;
205     ArrayList objetos = new ArrayList();
206 
207     super.inicializarLogBean();
208 
209     try {
210       boolean excluir = true;
211       if (contar(tipoFuncAcomp.getEstrutTpFuncAcmpEtttfas()) > 0) {
212         excluir = false;
213         throw new ECARException("tipoFuncAcomp.exclusao.erro.estrutTpFuncAcmpEtttfas");
214       }
215       if (contar(tipoFuncAcomp.getItemEstUsutpfuacIettutfas()) > 0) {
216         excluir = false;
217         throw new ECARException("tipoFuncAcomp.exclusao.erro.itemEstUsutpfuacIettutfas");
218       }
219       if (contar(tipoFuncAcomp.getSituacaoTpFuncAcmpSitfas()) > 0) {
220         excluir = false;
221         throw new ECARException("tipoFuncAcomp.exclusao.erro.situacaoTpFuncAcmpSitfas");
222       }
223       if (contar(tipoFuncAcomp.getTipoFuncAcompTpfas()) > 0) {
224         excluir = false;
225         throw new ECARException("tipoFuncAcomp.exclusao.erro.tipoFuncAcompTpfas");
226       }
227       if (contar(tipoFuncAcomp.getAcompRefItemLimitesArlis()) > 0) {
228         excluir = false;
229         throw new ECARException("tipoFuncAcomp.exclusao.erro.acompRefItemLimitesArlis");
230       }
231       if (contar(tipoFuncAcomp.getAcompRefLimitesArls()) > 0) {
232         excluir = false;
233         throw new ECARException("tipoFuncAcomp.exclusao.erro.acompRefLimitesArls");
234       }
235 
236       if (excluir) {
237         tx = session.beginTransaction();
238 
239         // deletando os TfuncacompConfigmailTfacfgm gravados
240 
241         for (Iterator it = tipoFuncAcomp.getTfuncacompConfigmailTfacfgm().iterator(); it.hasNext();) {
242           TfuncacompConfigmailTfacfgm tFuncAcompCfgm = (TfuncacompConfigmailTfacfgm) it.next();
243           session.delete(tFuncAcompCfgm);
244         }
245 
246         session.delete(tipoFuncAcomp);
247 
248         tx.commit();
249 
250         if (super.logBean != null) {
251           super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
252           super.logBean.setOperacao("EXC");
253 
254           for (Iterator itObj = objetos.iterator(); itObj.hasNext();) {
255             super.logBean.setObj(itObj.next());
256             super.loggerAuditoria.info(logBean.toString());
257           }
258         }
259       }
260     } catch (HibernateException e) {
261       if (tx != null)
262         try {
263           tx.rollback();
264         } catch (HibernateException r) {
265           this.logger.error(r);
266           throw new ECARException("erro.hibernateException");
267         }
268       this.logger.error(e);
269       throw new ECARException("erro.hibernateException");
270     }
271   }
272 
273   /**
274    * Recebe um array com os Códigos dos Tipos de Função e retorna um Set com
275    * objetos TipoFuncAcompTpfa correspondentes a estes códigos
276    * @param funcoes array com os Códigos dos Tipos de Função
277    * @return Set objetos TipoFuncAcompTpfa
278    */
279   public Set getSetFuncoesAcompanhamento(String funcoes[]) throws ECARException {
280     Set retorno = new HashSet();
281     if (funcoes != null) {
282       for (int i = 0; i < funcoes.length; i++) {
283         try {
284           TipoFuncAcompTpfa funcao = (TipoFuncAcompTpfa) this.buscar(TipoFuncAcompTpfa.class, Long.valueOf(funcoes[i]));
285           retorno.add(funcao);
286         } catch (ECARException e) {
287           this.logger.error(e);
288           throw e;
289         }
290       }
291     }
292     return retorno;
293   }
294 
295   /**
296    * Retorna as Funções abaixo da Função passada como parâmetro (filhos, netos,
297    * etc.)
298    * @param List listTipoFuncAcomp
299    * @return Set Coleção de Funções Pseudocodigo: Descendentes(g) { resultado =
300    *         {conjunto vazio} se (Filhos(g) != {conjunto vazio}) para cada f em
301    *         Filhos(g) faca resultado <- {f} U Descendentes(f) return
302    *         (resultado) }
303    */
304   public List getDescendentes(List listTipoFuncAcomp) {
305     List funcoes = new ArrayList();
306 
307     Iterator itPrincipal = listTipoFuncAcomp.iterator();
308 
309     while (itPrincipal.hasNext()) {
310       TipoFuncAcompTpfa tipoFuncAcomp = (TipoFuncAcompTpfa) itPrincipal.next();
311       if (tipoFuncAcomp.getTipoFuncAcompTpfas() != null) {
312         // Coleção dos Filhos
313         Iterator it = tipoFuncAcomp.getTipoFuncAcompTpfas().iterator();
314         while (it.hasNext()) {
315           TipoFuncAcompTpfa tipoFuncAcompFilho = (TipoFuncAcompTpfa) it.next();
316           if (!funcoes.contains(tipoFuncAcompFilho)) {
317             funcoes.add(tipoFuncAcompFilho);
318 
319             List listFilho = new ArrayList();
320             listFilho.add(tipoFuncAcompFilho);
321             funcoes.addAll(getDescendentes(listFilho));
322           }
323         }
324       }
325     }
326     return funcoes;
327   }
328 
329   /**
330    * @param objetosExcluídos - não aparecer na lista (filhos)
331    * @return Set Coleção de Funções
332    * @deprecated
333    * @throws HibernateException
334    */
335   public List getTipoFuncAcompPermitidos(List objetosExcluidos) throws HibernateException {
336     /*
337      * Não está sendo utilizado. Nao sei para que serve... (garten)
338      */
339     List funcoes = new ArrayList();
340 
341     Dao dao = new Dao();
342     Session session = dao.getSession();
343     Criteria select = session.createCriteria(TipoFuncAcompTpfa.class);
344     select.addOrder(Order.asc("descricaoTpfa"));
345     funcoes = select.list();
346 
347     funcoes.removeAll(objetosExcluidos);
348 
349     return funcoes;
350   }
351 
352   /**
353    * Retorna a funcao de acompanhamento de maior nivel, isto é, que não tem pai
354    * @author garten
355    * @return Objeto TipoFuncAcompTpfa
356    * @throws ECARException
357    */
358   public List getPrincipal() throws ECARException {
359     try {
360       return session.createQuery("from TipoFuncAcompTpfa as f where f.tipoFuncAcompTpfa is null").list();
361     } catch (HibernateException e) {
362       this.logger.error(e);
363       throw new ECARException("erro.hibernateException");
364     }
365   }
366 
367   /**
368    * Devolve todas as funcoes de acompanhamento que emitem posicao ordenadas do
369    * filho para o pai
370    * @author garten
371    * @return List TipoFuncAcompTpfa
372    * @throws ECARException
373    */
374   public List getTipoFuncAcompEmitePosicao() throws ECARException {
375     List lResultado = new ArrayList();
376     List descendentes = new ArrayList();
377     List principais = this.getPrincipal();
378 
379     descendentes.addAll(principais);
380     descendentes.addAll(getDescendentes(principais));
381 
382     for (Iterator itDescendentes = descendentes.iterator(); itDescendentes.hasNext();) {
383       TipoFuncAcompTpfa funcao = (TipoFuncAcompTpfa) itDescendentes.next();
384       if ("S".equals(funcao.getIndEmitePosicaoTpfa()))
385         lResultado.add(funcao);
386     }
387     Collections.reverse(lResultado);
388     return lResultado;
389   }
390 
391   // public List getTipoFuncAcompEmitePosicao (TipoFuncAcompTpfa ta){
392   // List lista = new ArrayList();
393   // Criteria select = this.getSession().createCriteria(TipoFuncAcompTpfa.class)
394   // .add(Restrictions.eq("indEmitePosicaoTpfa", Dominios.SIM));
395   //    	
396   // if(ta == null || ta.getCodTpfa() == null)
397   // select.add(Restrictions.isNotNull("tipoFuncAcompTpfas"));
398   // else
399   // select.add(Restrictions.eq("tipoFuncAcompTpfas", ta));
400   //    	
401   // List raiz = select.list();
402   //    	
403   // lista.addAll(raiz);
404   //    	
405   // Iterator it = raiz.iterator();
406   //    	
407   // while(it.hasNext()){
408   // lista.addAll(this.getTipoFuncAcompEmitePosicao((TipoFuncAcompTpfa)
409   // it.next()));
410   // }
411   // return lista;
412   // }
413 
414   // public List getTipoFuncAcompEmitePosicao (){
415   // return this.getTipoFuncAcompEmitePosicao(null);
416   // }
417 
418   /**
419    * Devolve todas as funcoes de acompanhamento ordenadas do filho para o pai
420    * @author garten
421    * @return List TipoFuncAcompTpfa
422    * @throws ECARException
423    */
424   public List getTipoFuncAcompOrdemFilhoAoPai() throws ECARException {
425     List descendentes = new ArrayList();
426     List principais = getPrincipal();
427     descendentes.addAll(principais);
428     descendentes.addAll(getDescendentes(principais));
429     Collections.reverse(descendentes);
430     return descendentes;
431   }
432 
433   /**
434    * Obter as funções de acompanhamento utilizadas pelos acompanhamentos(AREF ->
435    * ARL) e de determinado tipo de acompanhamento, ordenado por datas. Exemplo:
436    * Funções de acompanhamento do ARL: A, B, D e E. Funções de acompanhamento do
437    * TipoAcompanhamento: A, B, C e D. Este método retornará: A, B, C, D e E.
438    * @param Long codTa
439    * @param List listaAcompanhamentos utilizado para ordenar pelas datas do
440    *          primeiro acompanhamento
441    * @return List de OrdenacaoDataTpfa
442    * @throws ECARException
443    */
444   public List getTpfaOfArlAndTipoAcompanhamentoOrderByDatas(Long codTa, List listaAcompanhamentos) throws ECARException {
445     try {
446       AcompReferenciaDao acompDao = new AcompReferenciaDao(null);
447       List listOrdenacaoDataTpfa = new ArrayList();
448       List listTpfaCompleta = new ArrayList();
449 
450       Calendar calendar = Calendar.getInstance();
451       calendar.set(1990, 0, 1);
452 
453       // obter os TPFA do tipo de acompanhamento
454       List listTpfaDoTipoAcomp = new TipoAcompanhamentoDao(null).getTipoFuncaoAcompanhamento((TipoAcompanhamentoTa) super.buscar(TipoAcompanhamentoTa.class, codTa));
455 
456       // obter os TPFA dos ARLs
457       Query query = session.createQuery("select distinct tpfa from TipoFuncAcompTpfa as tpfa " + "join tpfa.acompRefLimitesArls as arls " + "where arls.acompReferenciaAref.tipoAcompanhamentoTa.codTa = :codTa ");
458       query.setLong("codTa", codTa.longValue());
459       List listTpfaDoArl = query.list();
460 
461       listTpfaCompleta.addAll(listTpfaDoArl);
462 
463       for (Iterator it = listTpfaDoTipoAcomp.iterator(); it.hasNext();) {
464         TipoFuncAcompTpfa tpfa = (TipoFuncAcompTpfa) it.next();
465 
466         if (!listTpfaCompleta.contains(tpfa)) {
467           listTpfaCompleta.add(tpfa);
468         }
469       }
470 
471       // ordenar datas do primeiro acompanhamento da lista
472       if (listaAcompanhamentos != null && listaAcompanhamentos.size() > 0) {
473         AcompReferenciaAref aref = (AcompReferenciaAref) listaAcompanhamentos.get(0);
474 
475         // datas fixas
476         OrdenacaoDataTpfa ordenacaoDataTpfa = new OrdenacaoDataTpfa();
477         ordenacaoDataTpfa.setData(aref.getDataInicioAref());
478         ordenacaoDataTpfa.setTpfaFixo(OrdenacaoDataTpfa.FUNCAO_INICIO);
479         ordenacaoDataTpfa.setLabel("Início");
480         listOrdenacaoDataTpfa.add(ordenacaoDataTpfa);
481 
482         ordenacaoDataTpfa = new OrdenacaoDataTpfa();
483         ordenacaoDataTpfa.setData(aref.getDataLimiteAcompFisicoAref());
484         ordenacaoDataTpfa.setTpfaFixo(OrdenacaoDataTpfa.FUNCAO_LIMITE);
485         ordenacaoDataTpfa.setLabel("Ac./Fis./Fin.");
486         listOrdenacaoDataTpfa.add(ordenacaoDataTpfa);
487 
488         // adiciona datas de TPFA variáveis
489         Iterator itTpfaCompleta = listTpfaCompleta.iterator();
490         while (itTpfaCompleta.hasNext()) {
491           TipoFuncAcompTpfa tpfa = (TipoFuncAcompTpfa) itTpfaCompleta.next();
492           ordenacaoDataTpfa = new OrdenacaoDataTpfa();
493 
494           ordenacaoDataTpfa.setTpfa(tpfa);
495           ordenacaoDataTpfa.setLabel(tpfa.getLabelPosicaoTpfa());
496           ordenacaoDataTpfa.setData(calendar.getTime());
497 
498           listOrdenacaoDataTpfa.add(ordenacaoDataTpfa);
499         }
500 
501         List arls = new ArrayList(acompDao.getAcompRefLimitesOrderByFuncaoAcomp(aref));
502 
503         Iterator itOrdenacaoDataTpfa = listOrdenacaoDataTpfa.iterator();
504         while (itOrdenacaoDataTpfa.hasNext()) {
505           OrdenacaoDataTpfa ord = (OrdenacaoDataTpfa) itOrdenacaoDataTpfa.next();
506 
507           Iterator itArls = arls.iterator();
508           while (itArls.hasNext()) {
509             AcompRefLimitesArl arl = (AcompRefLimitesArl) itArls.next();
510 
511             if (ord.getTpfa() != null && ord.getTpfa().equals(arl.getTipoFuncAcompTpfa())) {
512               ord.setData(arl.getDataLimiteArl());
513               break;
514             }
515           }
516         }
517 
518         // ordenar
519         Collections.sort(listOrdenacaoDataTpfa, new Comparator() {
520           public int compare(Object o1, Object o2) {
521             OrdenacaoDataTpfa ord1 = (OrdenacaoDataTpfa) o1;
522             OrdenacaoDataTpfa ord2 = (OrdenacaoDataTpfa) o2;
523 
524             String data1 = Data.parseDate(ord1.getData());
525             String data2 = Data.parseDate(ord2.getData());
526 
527             // dd/mm/yyyy -> yyyymmaa
528             data1 = data1.substring(6) + data1.substring(3, 5) + data1.substring(0, 2);
529             data2 = data2.substring(6) + data2.substring(3, 5) + data2.substring(0, 2);
530 
531             return data1.compareTo(data2);
532           }
533         });
534       }
535       else {
536         // se não tiver acompanhamentos
537 
538         // datas fixas
539         OrdenacaoDataTpfa ordenacaoDataTpfa = new OrdenacaoDataTpfa();
540         ordenacaoDataTpfa.setTpfaFixo(OrdenacaoDataTpfa.FUNCAO_INICIO);
541         ordenacaoDataTpfa.setLabel("Início");
542         listOrdenacaoDataTpfa.add(ordenacaoDataTpfa);
543 
544         ordenacaoDataTpfa = new OrdenacaoDataTpfa();
545         ordenacaoDataTpfa.setTpfaFixo(OrdenacaoDataTpfa.FUNCAO_LIMITE);
546         ordenacaoDataTpfa.setLabel("Ac./Fis./Fin.");
547         listOrdenacaoDataTpfa.add(ordenacaoDataTpfa);
548 
549         // adiciona datas de TPFA variáveis
550         Iterator itTpfaCompleta = listTpfaCompleta.iterator();
551         while (itTpfaCompleta.hasNext()) {
552           TipoFuncAcompTpfa tpfa = (TipoFuncAcompTpfa) itTpfaCompleta.next();
553           ordenacaoDataTpfa = new OrdenacaoDataTpfa();
554 
555           ordenacaoDataTpfa.setTpfa(tpfa);
556           ordenacaoDataTpfa.setLabel(tpfa.getLabelPosicaoTpfa());
557 
558           listOrdenacaoDataTpfa.add(ordenacaoDataTpfa);
559         }
560       }
561 
562       return listOrdenacaoDataTpfa;
563     } catch (Exception e) {
564       this.logger.error(e);
565       throw new ECARException(e);
566     }
567   }
568 
569   /**
570    * Ordena as Funções de Acompanhamento pela sequencia definida na estrutura.
571    * @param List<TipoFuncAcompTpfa> funcoes
572    * @param EstruturaEtt estrutura
573    * @return List
574    * @throws ECARException
575    */
576   public List ordenarTpfaBySequencia(List funcoes, EstruturaEtt estrutura) throws ECARException {
577     EstruturaTipoFuncAcompDao estruturaTipoFuncAcompDao = new EstruturaTipoFuncAcompDao(null);
578     List beans = new ArrayList();
579     Iterator itTpfa = funcoes.iterator();
580     while (itTpfa.hasNext()) {
581       TipoFuncAcompTpfa tpfa = (TipoFuncAcompTpfa) itTpfa.next();
582       EstrutTpFuncAcmpEtttfaPK comp_id = new EstrutTpFuncAcmpEtttfaPK(estrutura.getCodEtt(), tpfa.getCodTpfa());
583       // comp_id.setCodEtt(estrutura.getCodEtt());
584       // comp_id.setCodTpfa(tpfa.getCodTpfa());
585 
586       SequenciaTipoFuncAcomp seqTpfa = new SequenciaTipoFuncAcomp();
587       seqTpfa.setFuncao(tpfa);
588       seqTpfa.setSequencia(Integer.valueOf(0));
589       try {
590         EstrutTpFuncAcmpEtttfa ettTipoAcomp = (EstrutTpFuncAcmpEtttfa) estruturaTipoFuncAcompDao.buscar(EstrutTpFuncAcmpEtttfa.class, comp_id);
591         if (ettTipoAcomp.getSeqApresentTelaCampoEtttfa() != null) {
592           seqTpfa.setSequencia(ettTipoAcomp.getSeqApresentTelaCampoEtttfa());
593         }
594       } catch (ECARException e) {
595         if (!"erro.objectNotFound".equals(e.getMessageKey()))
596           throw e;
597       }
598 
599       beans.add(seqTpfa);
600     }
601 
602     Collections.sort(beans, new Comparator() {
603 
604       public int compare(Object arg1, Object arg2) {
605 
606         SequenciaTipoFuncAcomp s1 = (SequenciaTipoFuncAcomp) arg1;
607         SequenciaTipoFuncAcomp s2 = (SequenciaTipoFuncAcomp) arg2;
608 
609         return s1.getSequencia().compareTo(s2.getSequencia());
610       }
611     });
612 
613     List retorno = new ArrayList();
614     Iterator it = beans.iterator();
615     while (it.hasNext()) {
616       SequenciaTipoFuncAcomp seq = (SequenciaTipoFuncAcomp) it.next();
617       retorno.add(seq.getFuncao());
618     }
619 
620     return retorno;
621   }
622 
623   /**
624    * Retorna um bean contendo EstruturaEtt e um List<TipoFuncAcompTpfa>
625    * ordenados por EstruturaEtt. <br>
626    * Bean: OrdenacaoTpfaEstrutura
627    * @return List
628    * @throws ECARException
629    */
630   public List getFuncaoAcompOrderByEstruturas() throws ECARException {
631 
632     /*
633      * Chamar esse método nas telas que utilizam o método
634      * AcompReferenciaItemDao.getAcompRelatorioArelOrderByFuncaoAcomp() para
635      * que, ao inves de chamar o ordenarTpfaBySequencia() do método acima para
636      * cada item, só passar como parametro o bean contendo a estrutura e a lista
637      * de funções ordenadas na tela. A idéia é para não chamar esse método para
638      * cada item a ser exibido. Lembrar de verificar o tempo de execução da tela
639      * para verificar o desempenho.
640      */
641     List retorno = new ArrayList();
642 
643     List funAcomp = this.listar(TipoFuncAcompTpfa.class, new String[] { "codTpfa", "asc" });
644     // List estruturas = new EstruturaDao(null).getEstruturas();
645     List estruturas = new EstruturaDao(null).getListaEstruturas();
646 
647     for (Iterator it = estruturas.iterator(); it.hasNext();) {
648       EstruturaEtt estrutura = (EstruturaEtt) it.next();
649 
650       OrdenacaoTpfaEstrutura o = new OrdenacaoTpfaEstrutura();
651       o.setEstrutura(estrutura);
652       o.setTipoFuncAcomp(this.ordenarTpfaBySequencia(funAcomp, estrutura));
653 
654       retorno.add(o);
655     }
656 
657     return retorno;
658   }
659 
660   /**
661    * Retorna um bean contendo EstruturaEtt e um List<TipoFuncAcompTpfa>
662    * ordenados por EstruturaEtt na ordem hierárquica do parecer, ou seja, a
663    * ordem inversa de apresentação na tela. <br>
664    * Bean: OrdenacaoTpfaEstrutura
665    * @return List
666    * @throws ECARException
667    */
668   public List getFuncaoAcompOrderByEstruturasHierarquicamente() throws ECARException {
669 
670     List retorno = new ArrayList();
671 
672     List funAcomp = this.listar(TipoFuncAcompTpfa.class, new String[] { "codTpfa", "asc" });
673     // List estruturas = new EstruturaDao(null).getEstruturas();
674     List estruturas = new EstruturaDao(null).getListaEstruturas();
675 
676     for (Iterator it = estruturas.iterator(); it.hasNext();) {
677       EstruturaEtt estrutura = (EstruturaEtt) it.next();
678 
679       List tpfaHierarquica = this.ordenarTpfaBySequencia(funAcomp, estrutura);
680       Collections.reverse(tpfaHierarquica);
681 
682       OrdenacaoTpfaEstrutura o = new OrdenacaoTpfaEstrutura();
683       o.setEstrutura(estrutura);
684       o.setTipoFuncAcomp(tpfaHierarquica);
685 
686       retorno.add(o);
687     }
688 
689     return retorno;
690   }
691 
692   /**
693    * @author Robson
694    * @return List<TipoFuncAcompTpfa>
695    * @since 26/11/2007
696    */
697   public List getFuncAcompByLabel() {
698     return this.getSession().createCriteria(TipoFuncAcompTpfa.class).add(Restrictions.eq("indEmitePosicaoTpfa", Dominios.SIM)).addOrder(Order.asc("labelTpfa")).list();
699   }
700 
701   /**
702    * @author Robson
703    * @param TipoAcompanhamentoTa
704    * @return List<TipoFuncAcompTpfa>
705    * @since 13/12/2007 Inclusão
706    */
707   public List getFuncAcompComAcesso(TipoAcompanhamentoTa ta) {
708     return this.getSession().createQuery("select tpfa " + "from TipoFuncAcompTpfa tpfa " + "join tpfa.tipoAcompFuncAcompTafcs tafc " + "join tafc.tipoAcompanhamentoTa ta " + "where (tafc.indObrigatorio = :obrigatorio " + "or tafc.indOpcional = :opcional) " + "and ta.codTa = :codigo " + "order by tpfa.labelTpfa ").setString("obrigatorio", "S").setString("opcional", "S").setLong("codigo", ta.getCodTa()).list();
709   }
710 
711   /**
712    * Utilizado na alteração de referência da geração de período, caso a
713    * referencia já exista, o metodo verifica se foram adicionados novas funções
714    * de acompanhamento para o tipo de acompanhamento.
715    * @author Samuel
716    * @param AcompReferenciaAref, TipoAcompanhamentoTa
717    * @return List<TipoFuncAcompTpfa>
718    * @since 27/05/2009
719    */
720   public List<TipoFuncAcompTpfa> getFuncAcompArlComAcesso(AcompReferenciaAref aref, TipoAcompanhamentoTa ta) {
721 
722     // Lista completa da funções de acompanhamentos associadas ao tipo de
723     // acompanhamento
724     List<TipoFuncAcompTpfa> listaCompleta = this.getFuncAcompComAcesso(ta);
725     // Lista das funções de acompanhamentos já inseridos na referencia.
726     List<TipoFuncAcompTpfa> listaFuncoesIncluidas = this.getFuncAcompArlComAcesso(aref);
727     // Resultado são todas as funções já incluídas mais o que tem na lista
728     // completa e que não tem na lista de funções incluidas.
729     List<TipoFuncAcompTpfa> listaResultado = new ArrayList<TipoFuncAcompTpfa>(listaFuncoesIncluidas);
730 
731     for (TipoFuncAcompTpfa tipoFuncAcompTpfa : listaCompleta) {
732 
733       if (!listaFuncoesIncluidas.contains(tipoFuncAcompTpfa)) {
734         listaResultado.add(tipoFuncAcompTpfa);
735       }
736 
737     }
738 
739     return listaResultado;
740   }
741 
742   /**
743    * @author Robson
744    * @param AcompReferenciaAref
745    * @return List<TipoFuncAcompTpfa>
746    * @since 13/12/2007 Alteração
747    */
748   public List getFuncAcompArlComAcesso(AcompReferenciaAref aref) {
749     return this.getSession().createQuery("select tpfa " + "from TipoFuncAcompTpfa tpfa " + "join tpfa.acompRefLimitesArls arl " + "join arl.acompReferenciaAref aref " + "with aref.codAref = :codigo " + "order by tpfa.labelTpfa ").setLong("codigo", aref.getCodAref()).list();
750   }
751 
752   /**
753    * Procura a data limite equivalente a função de acompanhamento do relatório,
754    * @param datasLimites
755    * @param relatorio
756    * @return
757    */
758   public Date getDataLimiteDoTipoFuncaoDeAcomp(AcompRelatorioArel relatorio) {
759     Iterator<AcompRefItemLimitesArli> itDataLimites = relatorio.getAcompReferenciaItemAri().getAcompRefItemLimitesArlis().iterator();
760 
761     /* caso o parecer já tenha sido informado */
762     // if (relatorio.getDataUltManutArel()!= null ){
763     // return relatorio.getDataUltManutArel();
764     // }
765     /* Caso o parecer não tenha sido informado recupera a data limite */
766     while (itDataLimites.hasNext()) {
767       AcompRefItemLimitesArli dataLimite = (AcompRefItemLimitesArli) itDataLimites.next();
768       if (dataLimite.getTipoFuncAcompTpfa().equals(relatorio.getTipoFuncAcompTpfa())) {
769         return dataLimite.getDataLimiteArli();
770       }
771     }
772     return null;
773   }
774 
775   /**
776    * Nesta lista serão adicionadas as funções de acompanhamento pertencentes ao
777    * usuário (grupos)
778    * @param estruturaFuncaoEttf
779    * @return
780    */
781   public List getFuncoesAcompNaEstruturaDoUsuario(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) throws ECARException {
782 
783     // EstruturaFuncaoEttf estruturaFuncaoEttf
784     // Nesta lista serão adicionadas as funções de acompanhamento pertencentes
785     // ao usuário (grupos) logado
786     List listTipoFuncaoUsuario = new ArrayList<TipoFuncAcompTpfa>();
787     ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(null);
788 
789     // Informações da estrutura e das funções de acompanhamento que compõem a
790     // estrutura
791 
792     // estruturaFuncaoEttf.getEstruturaEtt().getEstrutTpFuncAcmpEtttfas()
793     Iterator itFuncoesAcompNaEstrutura = item.getEstruturaEtt().getEstrutTpFuncAcmpEtttfas().iterator();
794 
795     while (itFuncoesAcompNaEstrutura.hasNext()) {
796       EstrutTpFuncAcmpEtttfa estrutTpFuncAcmpEtttfa = (EstrutTpFuncAcmpEtttfa) itFuncoesAcompNaEstrutura.next();
797       TipoFuncAcompTpfa tpfaNaEstrutura = estrutTpFuncAcmpEtttfa.getTipoFuncAcompTpfa();
798 
799       UsuarioUsu usuarioFuncao = null;
800       SisAtributoSatb sisAtributoSatb = null;
801 
802       usuarioFuncao = (UsuarioUsu) itemEstruturaDao.getValorFunAcompItemEstrutura(item, tpfaNaEstrutura);
803       if (usuarioFuncao == null) {
804         sisAtributoSatb = (SisAtributoSatb) itemEstruturaDao.getValorSatbFunAcompItemEstrutura(item, tpfaNaEstrutura);
805       }
806 
807       if ((usuarioFuncao != null && usuarioFuncao.equals(usuario)) || (sisAtributoSatb != null && gruposUsuario.contains(sisAtributoSatb))) {
808         listTipoFuncaoUsuario.add(tpfaNaEstrutura);
809       }
810 
811     }
812 
813     return listTipoFuncaoUsuario;
814   }
815 }