EstruturaDao xref

View Javadoc

1   /*
2    * Criado em 28/10/2004
3    */
4   package ecar.dao;
5   
6   import java.util.ArrayList;
7   import java.util.Collection;
8   import java.util.Collections;
9   import java.util.Comparator;
10  import java.util.HashSet;
11  import java.util.Iterator;
12  import java.util.List;
13  import java.util.Set;
14  
15  import javax.servlet.http.HttpServletRequest;
16  
17  import org.hibernate.Criteria;
18  import org.hibernate.HibernateException;
19  import org.hibernate.Query;
20  import org.hibernate.SQLQuery;
21  import org.hibernate.Transaction;
22  import org.hibernate.criterion.Order;
23  import org.hibernate.criterion.Restrictions;
24  
25  import comum.database.Dao;
26  import comum.util.Data;
27  import comum.util.Pagina;
28  
29  import ecar.bean.EstruturaWebServiceBean;
30  import ecar.exception.ECARException;
31  import ecar.pojo.AtributosAtb;
32  import ecar.pojo.EstAtribTipoAcompEata;
33  import ecar.pojo.EstrutTpFuncAcmpEtttfa;
34  import ecar.pojo.EstruturaAtributoEttat;
35  import ecar.pojo.EstruturaEtt;
36  import ecar.pojo.EstruturaFuncaoEttf;
37  import ecar.pojo.FuncaoFun;
38  import ecar.pojo.ItemEstruturaIett;
39  import ecar.pojo.ObjetoEstrutura;
40  import ecar.pojo.PaiFilho;
41  import ecar.pojo.SituacaoSit;
42  import ecar.pojo.TipoAcompanhamentoTa;
43  import ecar.pojo.TipoFuncAcompTpfa;
44  import ecar.util.Dominios;
45  
46  /**
47   * @author felipev
48   * @author garten
49   */
50  public class EstruturaDao extends Dao {
51  
52    /**
53     * Construtor. Chama o Session factory do Hibernate
54     */
55    public EstruturaDao(HttpServletRequest request) {
56      super();
57      this.request = request;
58    }
59  
60    /**
61     * Altera o registro de estrutura recuperado a partir de variáveis do request
62     * passadas pelo formulario de alteração de estrutura
63     * (configuracao/estrutura/frm_alt.jsp)
64     * @param request
65     * @throws ECARException
66     */
67    public void alterar(HttpServletRequest request) throws ECARException {
68      Transaction tx = null;
69  
70      try {
71        ArrayList objetos = new ArrayList();
72  
73        super.inicializarLogBean();
74  
75        tx = session.beginTransaction();
76        EstruturaEtt estrutura = (EstruturaEtt) this.buscar(EstruturaEtt.class, Long.valueOf(Pagina.getParamLong(request, "codigo")));
77  
78        /* setar nome e sigla para usar na validação de duplos */
79        estrutura.setNomeEtt(Pagina.getParam(request, "nomeEtt"));
80        estrutura.setSiglaEtt(Pagina.getParam(request, "siglaEtt"));
81  
82        estrutura.setSeqApresentacaoEtt(Integer.valueOf(Pagina.getParam(request, "seqApresentacaoEtt")));
83  
84        if (pesquisarDuplos(estrutura, new String[] { "nomeEtt", "siglaEtt" }, "codEtt").size() > 0)
85          throw new ECARException("estrutura.validacao.registroDuplicado");
86  
87        Set atributosEstruturaAnteriores = estrutura.getEstruturaAtributoEttats();
88        Set funcoesEstruturaAnteriores = estrutura.getEstruturaFuncaoEttfs();
89        Set funcoesAcompanhamentoAnteriores = estrutura.getEstrutTpFuncAcmpEtttfas();
90  
91        /*
92         * Cria a nova Collection de Atributos da Estrutura, baseado no request e
93         * nos dados já existentes. Deve fazer isso antes de apagar a Collection
94         */
95        Set atributosEstrutura = this.getSetAtributosEstrutura(estrutura, request.getParameterValues("atributosAtb"), true);
96        Set funcoesEstrutura = this.getSetFuncoesEstrutura(estrutura, request.getParameterValues("funcaoFun"), true);
97        Set funcoesAcompanhamentoEstrutura = this.getSetFuncoesAcompEstrutura(estrutura, request.getParameterValues("tipoFuncAcompTpfa"));
98  
99        Iterator itAtbAnt = atributosEstruturaAnteriores.iterator();
100       while (itAtbAnt.hasNext()) {
101         EstruturaAtributoEttat estruturaAtributoAnt = (EstruturaAtributoEttat) itAtbAnt.next();
102 
103         boolean achou = false;
104         Iterator itAtb = atributosEstrutura.iterator();
105         while (itAtb.hasNext()) {
106           EstruturaAtributoEttat estruturaAtributo = (EstruturaAtributoEttat) itAtb.next();
107           if (estruturaAtributo.getAtributosAtb().equals(estruturaAtributoAnt.getAtributosAtb())) {
108             achou = true;
109             break;
110           }
111         }
112         if (!achou) {
113           session.delete(estruturaAtributoAnt);
114         }
115       }
116 
117       Iterator itFunAnt = funcoesEstruturaAnteriores.iterator();
118       while (itFunAnt.hasNext()) {
119         EstruturaFuncaoEttf estruturaFuncaoAnt = (EstruturaFuncaoEttf) itFunAnt.next();
120 
121         boolean achou = false;
122         Iterator itFun = funcoesEstrutura.iterator();
123         while (itFun.hasNext()) {
124           EstruturaFuncaoEttf estruturaFuncao = (EstruturaFuncaoEttf) itFun.next();
125           if (estruturaFuncao.getFuncaoFun().equals(estruturaFuncaoAnt.getFuncaoFun())) {
126             achou = true;
127             break;
128           }
129         }
130         if (!achou) {
131           session.delete(estruturaFuncaoAnt);
132         }
133       }
134 
135       Iterator itTpFunAnt = funcoesAcompanhamentoAnteriores.iterator();
136       while (itTpFunAnt.hasNext()) {
137         EstrutTpFuncAcmpEtttfa estruturaTpFuncaoAnt = (EstrutTpFuncAcmpEtttfa) itTpFunAnt.next();
138 
139         boolean achou = false;
140         Iterator itTpFun = funcoesAcompanhamentoEstrutura.iterator();
141         while (itTpFun.hasNext()) {
142           EstrutTpFuncAcmpEtttfa estruturaTpFuncao = (EstrutTpFuncAcmpEtttfa) itTpFun.next();
143           if (estruturaTpFuncao.getTipoFuncAcompTpfa().equals(estruturaTpFuncaoAnt.getTipoFuncAcompTpfa())) {
144             achou = true;
145             break;
146           }
147         }
148         if (!achou) {
149           session.delete(estruturaTpFuncaoAnt);
150         }
151       }
152 
153       /* recupera os novos dados da Estrutura */
154       this.setEstrutura(request, estrutura, true, true, false);
155 
156       estrutura.setEstruturaAtributoEttats(atributosEstrutura);
157       estrutura.setEstrutTpFuncAcmpEtttfas(funcoesAcompanhamentoEstrutura);
158       estrutura.setEstruturaFuncaoEttfs(funcoesEstrutura);
159 
160       estrutura.setDataUltManutEtt(Data.getDataAtual());
161 
162       session.update(estrutura);
163       objetos.add(estrutura);
164 
165       List filhos = new ArrayList();
166       filhos.addAll(atributosEstrutura);
167       filhos.addAll(funcoesEstrutura);
168       filhos.addAll(funcoesAcompanhamentoEstrutura);
169 
170       // if (estrutura.getEstruturaAtributoEttats() != null)
171       // filhos.addAll(estrutura.getEstruturaAtributoEttats());
172       // if (estrutura.getEstruturaFuncaoEttfs() != null)
173       // filhos.addAll(estrutura.getEstruturaFuncaoEttfs());
174       // if (estrutura.getEstrutTpFuncAcmpEtttfas() != null)
175       // filhos.addAll(estrutura.getEstrutTpFuncAcmpEtttfas());
176 
177       Iterator it = filhos.iterator();
178 
179       while (it.hasNext()) {
180         PaiFilho object = (PaiFilho) it.next();
181         object.atribuirPKPai();
182         session.saveOrUpdate(object);
183         objetos.add(object);
184       }
185 
186       tx.commit();
187 
188       if (super.logBean != null) {
189         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
190         super.logBean.setOperacao("INC_ALT_EXC");
191         Iterator itObj = objetos.iterator();
192 
193         while (itObj.hasNext()) {
194           super.logBean.setObj(itObj.next());
195           super.loggerAuditoria.info(logBean.toString());
196         }
197       }
198     } catch (HibernateException e) {
199       if (tx != null)
200         try {
201           tx.rollback();
202         } catch (HibernateException r) {
203           this.logger.error(r);
204           throw new ECARException("erro.hibernateException");
205         }
206       this.logger.error(e);
207       throw new ECARException("erro.hibernateException");
208     } catch (ECARException e) {
209       if (tx != null)
210         try {
211           tx.rollback();
212         } catch (HibernateException r) {
213           this.logger.error(r);
214           throw new ECARException("erro.hibernateException");
215         }
216       this.logger.error(e);
217       throw e;
218     }
219   }
220 
221   /**
222    * Recebe um array com os Códigos das Estruturas e retorna um Set com objetos
223    * EstruturaEtt correspondentes a estes códigos
224    * @param funcoes array com os Códigos das Estruturas
225    * @return Set objetos EstruturaEtt
226    */
227   public Set getSetEstruturas(String estruturas[]) throws ECARException {
228     Set retorno = new HashSet();
229     if (estruturas != null) {
230       for (int i = 0; i < estruturas.length; i++) {
231         try {
232           EstruturaEtt estrutura = (EstruturaEtt) this.buscar(EstruturaEtt.class, Long.valueOf(estruturas[i]));
233           retorno.add(estrutura);
234         } catch (ECARException e) {
235           this.logger.error(e);
236           throw e;
237         }
238       }
239     }
240     return retorno;
241 
242   }
243 
244   /**
245    * Atribui os valores dos atributos passados por request a um objeto Estrutura
246    * @param request Request
247    * @param estrutura Objeto Estrutura no qual serão atribuidos os valores
248    * @param usarParamStr <b>True </b> se os parâmetros serão recuperados por
249    *          Pagina.getParamStr <b>False </b> se os parãmetros serão
250    *          recuperados por Pagina.getParam
251    * @throws ECARException
252    */
253   public void setEstrutura(HttpServletRequest request, EstruturaEtt estrutura, boolean usarParamStr, boolean incluirObrigatorios, boolean criarCollections) throws ECARException {
254 
255     if (usarParamStr) {
256       estrutura.setNomeEtt(Pagina.getParamStr(request, "nomeEtt").trim());
257       estrutura.setSiglaEtt(Pagina.getParamStr(request, "siglaEtt").trim());
258       estrutura.setLabelEtt(Pagina.getParamStr(request, "labelEtt").trim());
259       estrutura.setIndAtivoEtt(Pagina.getParamStr(request, "indAtivoEtt").trim());
260       estrutura.setIndPrevFinanceiraEtt(Pagina.getParamStr(request, "indPrevFinanceiraEtt").trim());
261       if (!"".equals(Pagina.getParamStr(request, "seqApresentacaoEtt").trim())) {
262         estrutura.setSeqApresentacaoEtt(Integer.valueOf(Pagina.getParamStr(request, "seqApresentacaoEtt").trim()));
263       }
264       else {
265         estrutura.setSeqApresentacaoEtt(null);
266       }
267       estrutura.setCodCor1Ett(Pagina.getParamStr(request, "codCor1Ett").trim());
268       estrutura.setCodCor2Ett(Pagina.getParamStr(request, "codCor2Ett").trim());
269       estrutura.setCodCor3Ett(Pagina.getParamStr(request, "codCor3Ett").trim());
270       estrutura.setCodCor4Ett(Pagina.getParamStr(request, "codCor4Ett").trim());
271       estrutura.setIndExibirImprimirListagem(Pagina.getParamOrDefault(request, "indExibirImprimirListagem", Pagina.NAO));
272       estrutura.setIndExibirGerarArquivos(Pagina.getParamOrDefault(request, "indExibirGerarArquivos", Pagina.NAO));
273       estrutura.setIndEtapaNivelSuperiorEtt(Pagina.getParamOrDefault(request, "indEtapaNivelSuperiorEtt", Pagina.NAO));
274 
275       if (!"".equals(Pagina.getParamStr(request, "tamanhoListagemVerticalEtt")))
276         estrutura.setTamanhoListagemVerticalEtt(Long.valueOf(Pagina.getParamStr(request, "tamanhoListagemVerticalEtt")));
277       else
278         estrutura.setTamanhoListagemVerticalEtt(null);
279     }
280     else {
281       estrutura.setNomeEtt(Pagina.getParam(request, "nomeEtt"));
282       estrutura.setSiglaEtt(Pagina.getParam(request, "siglaEtt"));
283       estrutura.setLabelEtt(Pagina.getParam(request, "labelEtt"));
284       estrutura.setIndAtivoEtt(Pagina.getParam(request, "indAtivoEtt"));
285       estrutura.setIndPrevFinanceiraEtt(Pagina.getParam(request, "indPrevFinanceiraEtt"));
286 
287       if (Pagina.getParam(request, "seqApresentacaoEtt") != null) {
288         estrutura.setSeqApresentacaoEtt(Integer.valueOf(Pagina.getParam(request, "seqApresentacaoEtt")));
289       }
290       else {
291         estrutura.setSeqApresentacaoEtt(null);
292       }
293       estrutura.setCodCor1Ett(Pagina.getParam(request, "codCor1Ett"));
294       estrutura.setCodCor2Ett(Pagina.getParam(request, "codCor2Ett"));
295       estrutura.setCodCor3Ett(Pagina.getParam(request, "codCor3Ett"));
296       estrutura.setCodCor4Ett(Pagina.getParam(request, "codCor4Ett"));
297       estrutura.setIndExibirImprimirListagem(Pagina.getParam(request, "indExibirImprimirListagem"));
298       estrutura.setIndEtapaNivelSuperiorEtt(Pagina.getParam(request, "indEtapaNivelSuperiorEtt"));
299 
300       if (Pagina.getParam(request, "tamanhoListagemVerticalEtt") != null)
301         estrutura.setTamanhoListagemVerticalEtt(Long.valueOf(Pagina.getParam(request, "tamanhoListagemVerticalEtt")));
302       else
303         estrutura.setTamanhoListagemVerticalEtt(null);
304     }
305 
306     if (Pagina.getParam(request, "estruturaEttPai") != null)
307       estrutura.setEstruturaEtt((EstruturaEtt) this.buscar(EstruturaEtt.class, Long.valueOf(Pagina.getParam(request, "estruturaEttPai"))));
308     else
309       estrutura.setEstruturaEtt((EstruturaEtt) null);
310 
311     if (criarCollections) {
312 
313       if (request.getParameterValues("atributosAtb") != null) {
314         String[] atributos = request.getParameterValues("atributosAtb");
315         estrutura.setEstruturaAtributoEttats(this.getSetAtributosEstrutura(estrutura, atributos, incluirObrigatorios));
316       }
317       else {
318         if (incluirObrigatorios)
319           estrutura.setEstruturaAtributoEttats(this.getSetAtributosEstruturaObrigatorios(estrutura));
320         else
321           estrutura.setEstruturaAtributoEttats(null);
322       }
323 
324       if (request.getParameterValues("funcaoFun") != null) {
325         String[] funcoes = request.getParameterValues("funcaoFun");
326 
327         if (funcoes.length > 0)
328           estrutura.setEstruturaFuncaoEttfs(this.getSetFuncoesEstrutura(estrutura, funcoes, incluirObrigatorios));
329       }
330       else {
331         if (incluirObrigatorios)
332           estrutura.setEstruturaFuncaoEttfs(this.getSetFuncoesEstruturaObrigatorios(estrutura));
333         else
334           estrutura.setEstruturaFuncaoEttfs(null);
335       }
336 
337       if (request.getParameterValues("tipoFuncAcompTpfa") != null) {
338         String[] funcoesAcomp = request.getParameterValues("tipoFuncAcompTpfa");
339 
340         if (funcoesAcomp.length > 0)
341           estrutura.setEstrutTpFuncAcmpEtttfas(this.getSetFuncoesAcompEstrutura(estrutura, funcoesAcomp));
342       }
343       else {
344         estrutura.setEstrutTpFuncAcmpEtttfas(null);
345       }
346 
347       estrutura.setIndExibirGerarArquivos(Pagina.getParam(request, "indExibirGerarArquivos"));
348     }
349 
350   }
351 
352   /**
353    * Concatena todos as coleções existentes no objeto estrutura em uma única
354    * lista e chama o método salvar do Dao
355    * @param estrutura
356    * @throws ECARException
357    */
358   public void salvar(EstruturaEtt estrutura) throws ECARException {
359     if (pesquisarDuplos(estrutura, new String[] { "siglaEtt" }, "codEtt").size() > 0)
360       throw new ECARException("estrutura.validacao.registroDuplicado");
361 
362     estrutura.setDataInclusaoEtt(Data.getDataAtual());
363     List filhos = new ArrayList();
364     if (estrutura.getEstruturaAtributoEttats() != null)
365       filhos.addAll(estrutura.getEstruturaAtributoEttats());
366     if (estrutura.getEstruturaFuncaoEttfs() != null)
367       filhos.addAll(estrutura.getEstruturaFuncaoEttfs());
368     if (estrutura.getEstrutTpFuncAcmpEtttfas() != null)
369       filhos.addAll(estrutura.getEstrutTpFuncAcmpEtttfas());
370     try {
371       super.salvar(estrutura, filhos);
372     } catch (Exception e) {
373       e.printStackTrace();
374     }
375 
376   }
377 
378   /**
379    * Exclui um registro de Estrutura e seus registros filhos
380    * @author n/c
381    * @param estrutura
382    * @throws ECARException
383    */
384   public void excluir(EstruturaEtt estrutura) throws ECARException {
385     List objetosParaExcluir = new ArrayList();
386 
387     try {
388       boolean excluir = true;
389 
390       if (contar(estrutura.getTipoAcompanhamentoTas()) > 0) {
391         List list = new ArrayList(estrutura.getTipoAcompanhamentoTas());
392         TipoAcompanhamentoTa ocorrencia = (TipoAcompanhamentoTa) list.get(0);
393 
394         excluir = false;
395         throw new ECARException("estrutura.exclusao.erro.tipoAcompanhamentoTas", null, new String[] { ocorrencia.getDescricaoTa() });
396       }
397       if (contar(estrutura.getItemEstruturaIetts()) > 0) {
398         List list = new ArrayList(estrutura.getItemEstruturaIetts());
399         ItemEstruturaIett ocorrencia = (ItemEstruturaIett) list.get(0);
400 
401         excluir = false;
402         throw new ECARException("estrutura.exclusao.erro.itemEstruturaIetts", null, new String[] { ocorrencia.getNomeIett() });
403       }
404       if (contar(estrutura.getEstruturaSituacaoEtts()) > 0) {
405         List list = new ArrayList(estrutura.getEstruturaSituacaoEtts());
406         SituacaoSit ocorrencia = (SituacaoSit) list.get(0);
407 
408         excluir = false;
409         throw new ECARException("estrutura.exclusao.erro.estruturaSituacaoEtts", null, new String[] { ocorrencia.getDescricaoSit() });
410       }
411 
412       if (excluir) {
413         objetosParaExcluir.addAll(estrutura.getEstruturaAtributoEttats());
414         if (estrutura.getEstruturaAtributoEttats() != null) {
415           Iterator itEttat = estrutura.getEstruturaAtributoEttats().iterator();
416           while (itEttat.hasNext()) {
417             EstruturaAtributoEttat atributo = (EstruturaAtributoEttat) itEttat.next();
418             if (atributo.getEstAtribTipoAcompEatas() != null && atributo.getEstAtribTipoAcompEatas().size() > 0)
419               objetosParaExcluir.addAll(atributo.getEstAtribTipoAcompEatas());
420           }
421         }
422         objetosParaExcluir.addAll(estrutura.getEstruturaFuncaoEttfs());
423         objetosParaExcluir.addAll(estrutura.getEstrutTpFuncAcmpEtttfas());
424         objetosParaExcluir.addAll(estrutura.getEstruturaSituacaoEtts());
425         objetosParaExcluir.add(estrutura);
426         super.excluir(objetosParaExcluir);
427       }
428     } catch (ECARException e) {
429       throw e;
430     }
431   }
432 
433   /**
434    * Invoca o método pesquisar da classe Dao e filtra o resultado obtido para
435    * retornar somente os registros que tenham as Atributos e Funções informadas
436    * na pesquisa
437    * @param situacao
438    * @param ordem
439    * @return
440    * @throws ECARException
441    */
442   public List pesquisar(EstruturaEtt estrutura, String[] ordem) throws ECARException {
443 
444     List results = super.pesquisar(estrutura, ordem);
445     /* se a estrutura possui atributos */
446     if (estrutura.getEstruturaAtributoEttats() != null) {
447       // Cria uma lista com os objetos atributo a serem pesquisados
448       List atributosPesquisa = new ArrayList();
449       Iterator it = estrutura.getEstruturaAtributoEttats().iterator();
450       while (it.hasNext()) {
451         atributosPesquisa.add(((EstruturaAtributoEttat) it.next()).getAtributosAtb());
452       }
453       /*
454        * Percorre o resultado e retira dele todas as Estruturas onde dentro da
455        * coleção de Estrutura Atributo não existam todos os atributos de
456        * atributosPesquisa
457        */
458       Iterator itResults = results.iterator();
459       while (itResults.hasNext()) {
460         List atributosResultado = new ArrayList();
461         Iterator itAtributosResultado = ((EstruturaEtt) itResults.next()).getEstruturaAtributoEttats().iterator();
462         while (itAtributosResultado.hasNext())
463           atributosResultado.add(((EstruturaAtributoEttat) itAtributosResultado.next()).getAtributosAtb());
464         if (!atributosResultado.containsAll(atributosPesquisa))
465           itResults.remove();
466       }
467     }
468 
469     /* se a estrutura possui funções */
470     if (estrutura.getEstruturaFuncaoEttfs() != null) {
471       // Cria uma lista com os objetos função a serem pesquisados
472       List funcoesPesquisa = new ArrayList();
473       Iterator it = estrutura.getEstruturaFuncaoEttfs().iterator();
474       while (it.hasNext()) {
475         funcoesPesquisa.add(((EstruturaFuncaoEttf) it.next()).getFuncaoFun());
476       }
477       /*
478        * Percorre o resultado e retira dele todas as Estruturas onde dentro da
479        * coleção de Estrutura Função não existam todas as funções de
480        * funcoesPesquisa
481        */
482       Iterator itResults = results.iterator();
483       while (itResults.hasNext()) {
484         List funcoesResultado = new ArrayList();
485         Iterator itFuncoesResultado = ((EstruturaEtt) itResults.next()).getEstruturaFuncaoEttfs().iterator();
486         while (itFuncoesResultado.hasNext())
487           funcoesResultado.add(((EstruturaFuncaoEttf) itFuncoesResultado.next()).getFuncaoFun());
488         if (!funcoesResultado.containsAll(funcoesPesquisa))
489           itResults.remove();
490       }
491     }
492 
493     /* se a estrutura possui funções de Acompanhamento */
494     if (estrutura.getEstrutTpFuncAcmpEtttfas() != null) {
495       // Cria uma lista com os objetos função a serem pesquisados
496       List funcoesAcompPesquisa = new ArrayList();
497       Iterator it = estrutura.getEstrutTpFuncAcmpEtttfas().iterator();
498       while (it.hasNext()) {
499         funcoesAcompPesquisa.add(((EstrutTpFuncAcmpEtttfa) it.next()).getTipoFuncAcompTpfa());
500       }
501       /*
502        * Percorre o resultado e retira dele todas as Estruturas onde dentro da
503        * coleção de Estrutura-Tipo FunçãoAcompanhamento não existam todas as
504        * funções de funcoesAcompPesquisa
505        */
506       Iterator itResults = results.iterator();
507       while (itResults.hasNext()) {
508         List funcoesResultado = new ArrayList();
509         Iterator itFuncoesResultado = ((EstruturaEtt) itResults.next()).getEstrutTpFuncAcmpEtttfas().iterator();
510         while (itFuncoesResultado.hasNext())
511           funcoesResultado.add(((EstrutTpFuncAcmpEtttfa) itFuncoesResultado.next()).getTipoFuncAcompTpfa());
512         if (!funcoesResultado.containsAll(funcoesAcompPesquisa))
513           itResults.remove();
514       }
515     }
516     // inicializa as coleções do resultado
517     Iterator itResults = results.iterator();
518     while (itResults.hasNext()) {
519       EstruturaEtt est = (EstruturaEtt) itResults.next();
520       est.getEstruturaFuncaoEttfs().size();
521       est.getEstruturaAtributoEttats().size();
522       est.getEstrutTpFuncAcmpEtttfas().size();
523     }
524     return results;
525   }
526 
527   /**
528    * Recebe um array com os Códigos dos Atributos e retorna um Set com objetos
529    * EstruturaAtributoEttat com os Atributos correspondentes a estes códigos +
530    * os atributos obrigatórios
531    * @param funcoes array com os Códigos das Estruturas
532    * @return Set objetos EstruturaEtt
533    */
534   public Set getSetAtributosEstrutura(EstruturaEtt estrutura, String atributos[], boolean incluirObrigatorios) throws ECARException {
535     Set retorno = new HashSet();
536 
537     AtributoDao atributoDao = new AtributoDao(request);
538     EstruturaAtributoDao estruturaAtributoDao = new EstruturaAtributoDao(request);
539 
540     List atributosDaEstrutura = new EstruturaAtributoDao(request).getAtributos(estrutura);
541 
542     if (atributos != null) {
543       for (int i = 0; i < atributos.length; i++) {
544         EstruturaAtributoEttat estruturaAtributo = new EstruturaAtributoEttat();
545         /* carrega o atributo */
546         AtributosAtb atributo = (AtributosAtb) (atributoDao.buscar(AtributosAtb.class, Long.valueOf(atributos[i])));
547 
548         estruturaAtributo.setAtributosAtb(atributo);
549         estruturaAtributo.setEstruturaEtt(estrutura);
550 
551         if (atributosDaEstrutura.contains(atributo)) {
552           estruturaAtributo = (EstruturaAtributoEttat) estruturaAtributoDao.pesquisar(estruturaAtributo, null).iterator().next();
553         }
554         else {
555           estruturaAtributo.setLabelEstruturaEttat(atributo.getLabelPadraoAtb());
556           // Robson - incluir valores do campo documentacao do atributo no
557           // estruturaAtributo
558           estruturaAtributo.setDocumentacaoEttat(atributo.getDocumentacaoAtb());
559         }
560 
561         /* adiciona numa coleção de EstruturaAtributo */
562         retorno.add(estruturaAtributo);
563       }
564     }
565     if (incluirObrigatorios)
566       retorno.addAll(this.getSetAtributosEstruturaObrigatorios(estrutura));
567     return retorno;
568   }
569 
570   /**
571    * Retorna um set com de objetos EstruturaAtributo com os atributos
572    * obrigatórios
573    * @return Set objetos EstruturaAtributoEtta
574    */
575   public Set getSetAtributosEstruturaObrigatorios(EstruturaEtt estrutura) throws ECARException {
576     Set retorno = new HashSet();
577     Iterator it = new AtributoDao(request).getAtributosNaoOpcionais().iterator();
578 
579     List atributosDaEstrutura = new EstruturaAtributoDao(request).getAtributos(estrutura);
580 
581     while (it.hasNext()) {
582       EstruturaAtributoEttat estruturaAtributo = new EstruturaAtributoEttat();
583       /* carrega o atributo */
584       AtributosAtb atributo = (AtributosAtb) it.next();
585       estruturaAtributo.setAtributosAtb(atributo);
586       estruturaAtributo.setEstruturaEtt(estrutura);
587 
588       if (atributosDaEstrutura.contains(atributo)) {
589         estruturaAtributo = (EstruturaAtributoEttat) new EstruturaAtributoDao(request).pesquisar(estruturaAtributo, null).iterator().next();
590       }
591       else {
592         estruturaAtributo.setLabelEstruturaEttat(atributo.getLabelPadraoAtb());
593         // Robson - incluir valores do campo documentacao do atributo no
594         // estruturaAtributo
595         estruturaAtributo.setDocumentacaoEttat(atributo.getDocumentacaoAtb());
596       }
597 
598       retorno.add(estruturaAtributo);
599     }
600     return retorno;
601 
602   }
603 
604   /**
605    * Retorna um conjunto de estrutura_funcao com as funções que são
606    * obrigatórias, isto é, ind_opcional="N"
607    * @param estrutura
608    * @return Set
609    * @throws ECARException
610    */
611   public Set getSetFuncoesEstruturaObrigatorios(EstruturaEtt estrutura) throws ECARException {
612     Set retorno = new HashSet();
613     Iterator it = new FuncaoDao(request).getFuncoesNaoOpcionais().iterator();
614 
615     List funcoesDaEstrutura = new EstruturaFuncaoDao(request).getFuncoes(estrutura);
616 
617     while (it.hasNext()) {
618       EstruturaFuncaoEttf estruturaFuncao = new EstruturaFuncaoEttf();
619       FuncaoFun funcao = (FuncaoFun) it.next();
620       estruturaFuncao.setFuncaoFun(funcao);
621       estruturaFuncao.setEstruturaEtt(estrutura);
622 
623       if (funcoesDaEstrutura.contains(funcao)) {
624         estruturaFuncao = (EstruturaFuncaoEttf) new EstruturaFuncaoDao(request).pesquisar(estruturaFuncao, null).iterator().next();
625       }
626       else {
627         estruturaFuncao.setLabelEttf(funcao.getLabelPadraoFun());
628         // Robson - incluir valores do campo documentacao da função no
629         // estruturaFuncao
630         estruturaFuncao.setDocumentacaoEttf(funcao.getDocumentacaoFun());
631       }
632       retorno.add(estruturaFuncao);
633     }
634     return retorno;
635 
636   }
637 
638   /**
639    * Recebe um array com os Códigos das Funcoes e retorna um Set com objetos
640    * EstrutTpFuncAcmpEtttfa com as Funções de acompamnhamento correspondentes a
641    * estes códigos + funções obirgatórioas
642    * @author n/c
643    * @param funcoes array com os Códigos das Funções
644    * @return Set objetos EstruturaEtt
645    */
646   public Set getSetFuncoesEstrutura(EstruturaEtt estrutura, String funcoes[], boolean incluirObrigatorios) throws ECARException {
647     Set retorno = new HashSet();
648 
649     List funcoesDaEstrutura = new EstruturaFuncaoDao(request).getFuncoes(estrutura);
650 
651     if (funcoes != null) {
652       for (int i = 0; i < funcoes.length; i++) {
653         EstruturaFuncaoEttf estruturaFuncao = new EstruturaFuncaoEttf();
654         /* carrega a função */
655         FuncaoFun funcao = (FuncaoFun) (new FuncaoDao(request).buscar(FuncaoFun.class, Long.valueOf(funcoes[i])));
656 
657         estruturaFuncao.setFuncaoFun(funcao);
658         estruturaFuncao.setEstruturaEtt(estrutura);
659 
660         if (funcoesDaEstrutura.contains(funcao)) {
661           estruturaFuncao = (EstruturaFuncaoEttf) new EstruturaFuncaoDao(request).pesquisar(estruturaFuncao, null).iterator().next();
662         }
663         else {
664           estruturaFuncao.setLabelEttf(funcao.getLabelPadraoFun());
665           // Robson - incluir valores do campo documentacao da função no
666           // estruturaFuncao
667           estruturaFuncao.setDocumentacaoEttf(funcao.getDocumentacaoFun());
668         }
669 
670         // seta alguns valores default para atributos.
671         estruturaFuncao.setIndPodeBloquearEttf("N");
672         estruturaFuncao.setIndListagemImpressaResEttf("N");
673         estruturaFuncao.setIndListagemImpressCompEttf("S");
674         estruturaFuncao.setIndRevisaoEttf("S");
675 
676         /* adiciona numa coleção de EstruturaFuncao */
677         retorno.add(estruturaFuncao);
678       }
679     }
680 
681     if (incluirObrigatorios)
682       retorno.addAll(getSetFuncoesEstruturaObrigatorios(estrutura));
683 
684     return retorno;
685 
686   }
687 
688   /**
689    * Recebe um array com os Códigos das Funcoes de Acompanhamento e retorna um
690    * Set com objetos EstrutTpFuncAcmpEtttfa com as Funções correspondentes a
691    * estes códigos
692    * @param funcoes array com os Códigos das Funções
693    * @return Set objetos EstruturaEtt
694    */
695   public Set getSetFuncoesAcompEstrutura(EstruturaEtt estrutura, String funcoesAcompanhamento[]) throws ECARException {
696     Set retorno = new HashSet();
697 
698     List funcoesAcompanhamentoDaEstrutura = new EstruturaTipoFuncAcompDao(request).getTipoFuncAcomp(estrutura);
699 
700     if (funcoesAcompanhamento != null) {
701       for (int i = 0; i < funcoesAcompanhamento.length; i++) {
702         EstrutTpFuncAcmpEtttfa estruturaFuncaoAcomp = new EstrutTpFuncAcmpEtttfa();
703         /* carrega a função */
704         TipoFuncAcompTpfa funcaoAcomp = (TipoFuncAcompTpfa) (new TipoFuncAcompDao(request).buscar(TipoFuncAcompTpfa.class, Long.valueOf(funcoesAcompanhamento[i])));
705         estruturaFuncaoAcomp.setTipoFuncAcompTpfa(funcaoAcomp);
706         estruturaFuncaoAcomp.setEstruturaEtt(estrutura);
707 
708         if (funcoesAcompanhamentoDaEstrutura.contains(funcaoAcomp))
709           estruturaFuncaoAcomp = (EstrutTpFuncAcmpEtttfa) new EstruturaTipoFuncAcompDao(request).pesquisar(estruturaFuncaoAcomp, null).iterator().next();
710         /* adiciona numa coleção de EstruturaFuncao */
711         retorno.add(estruturaFuncaoAcomp);
712 
713       }
714     }
715     return retorno;
716 
717   }
718 
719   /**
720    * Recebe uma estrutura e retorna em qual nível ela está
721    * @param estrutura
722    * @return int Nível em que se encontra a estrutura
723    * @throws ECARException
724    */
725   public int getNivel(EstruturaEtt estrutura) throws ECARException {
726     int nivel = 1;
727 
728     while (estrutura.getEstruturaEtt() != null) {
729       estrutura = estrutura.getEstruturaEtt();
730       nivel++;
731 
732     }
733 
734     return nivel;
735   }
736 
737   /**
738    * Recebe uma estrutura e devolve todos os atributos permitidos que podem ser
739    * selecionados no checklist de atributos
740    * @param estruturaPai
741    * @return Conjunto de atributos ativos, <br>
742    *         opcionais, <br>
743    *         nao exclusivos, <br>
744    */
745   public List getAtributosPermitidos(EstruturaEtt estruturaPai) throws ECARException {
746     List retorno = new ArrayList();
747     List lAtributos;
748     int nivel;
749 
750     AtributosAtb atributo = new AtributosAtb();
751 
752     atributo.setIndAtivoAtb("S");
753     atributo.setIndOpcionalAtb("S");
754 
755     lAtributos = new AtributoDao(request).pesquisar(atributo, new String[] { "nomeAtb", AtributoDao.ORDEM_ASC });
756 
757     Iterator it = lAtributos.iterator();
758     while (it.hasNext()) {
759       atributo = (AtributosAtb) it.next();
760       if (atributo.getIndExclusivoEstruturaAtb() != null && "N".equals(atributo.getIndExclusivoEstruturaAtb())) {
761         retorno.add(atributo);
762       }
763       else {
764         // Se o Atributo não foi utilzado em nenhuma estrutura, é um
765         // atributo permitido
766         if (atributo.getEstruturaAtributoEttats() != null) {
767           if (atributo.getEstruturaAtributoEttats().isEmpty())
768             retorno.add(atributo);
769           // Senão precisa verificar em qual nível este atributo foi
770           // usado
771           else {
772             EstruturaAtributoEttat estruturaAtributo = (EstruturaAtributoEttat) (atributo.getEstruturaAtributoEttats().iterator().next());
773             /*
774              * Se o nível da estrutura na qual foi usada o atributo for igual ao
775              * nível do Pai + 1 (nível da nova estrutura) então é um atributo
776              * permitido
777              */
778             nivel = (estruturaPai == null) ? 1 : this.getNivel(estruturaPai) + 1;
779 
780             if (this.getNivel(estruturaAtributo.getEstruturaEtt()) == nivel)
781               retorno.add(atributo);
782           }
783         }
784         else {
785 
786           retorno.add(atributo);
787 
788         }
789       }
790     }
791 
792     return retorno;
793   }
794 
795   /**
796    * Recebe uma estrutura e devolve todos as Funções ser selecionados no
797    * checklist de afunções
798    * @param estruturaPai
799    * @return Conjunto de funções ativas, <br>
800    *         opcionais, <br>
801    *         nao exclusivos, <br>
802    */
803   public List getFuncoesPermitidas(EstruturaEtt estruturaPai) throws ECARException {
804     List retorno = new ArrayList();
805     List lFuncoes;
806     int nivel;
807 
808     FuncaoFun funcao = new FuncaoFun();
809 
810     funcao.setIndAtivoFun("S");
811     funcao.setIndOpcionalFun("S");
812 
813     lFuncoes = new FuncaoDao(request).pesquisar(funcao, new String[] { "nomeFun", AtributoDao.ORDEM_ASC });
814 
815     Iterator it = lFuncoes.iterator();
816     while (it.hasNext()) {
817       funcao = (FuncaoFun) it.next();
818       if (funcao.getIndExclusivoEstruturaFun() != null && !"S".equals(funcao.getIndExclusivoEstruturaFun())) {
819         retorno.add(funcao);
820       }
821       else {
822         // Se a Função não foi utilzado em nenhuma estrutura, é uma
823         // funcção permitida
824         if (funcao.getEstruturaFuncaoEttfs() != null) {
825           if (funcao.getEstruturaFuncaoEttfs().isEmpty())
826             retorno.add(funcao);
827           // Senão precisa verificar em qual nível esta Função foi
828           // usado
829           else {
830             EstruturaFuncaoEttf estruturaFuncao = (EstruturaFuncaoEttf) (funcao.getEstruturaFuncaoEttfs().iterator().next());
831             /*
832              * Se o nível da estrutura na qual foi usada a função for igual ao
833              * nível do Pai + 1 (nível da nova estrutura) então é um atributo
834              * permitido
835              */
836             nivel = (estruturaPai == null) ? 1 : this.getNivel(estruturaPai) + 1;
837 
838             if (this.getNivel(estruturaFuncao.getEstruturaEtt()) == nivel)
839               retorno.add(funcao);
840           }
841         }
842         else {
843 
844           retorno.add(funcao);
845 
846         }
847       }
848     }
849 
850     return retorno;
851   }
852 
853   /**
854    * Retorna um list com identificações de todas as Funções de uma Estrutura
855    * @param estrutura
856    * @return List de Long
857    */
858   public List getFuncoesById(EstruturaEtt estrutura) {
859     List lFuncoes = new ArrayList();
860     if (estrutura.getEstruturaFuncaoEttfs() != null) {
861       estrutura.getEstruturaFuncaoEttfs().size(); // Faz isso para
862       Iterator it = estrutura.getEstruturaFuncaoEttfs().iterator();
863       while (it.hasNext()) {
864         EstruturaFuncaoEttf estruturaFuncao = (EstruturaFuncaoEttf) it.next();
865         lFuncoes.add(estruturaFuncao.getFuncaoFun().getCodFun());
866       }
867     }
868     return lFuncoes;
869   }
870 
871   /**
872    * Retorna um list com identificações de todos as Atributos de uma Estrutura
873    * @param estrutura
874    * @return List de Long
875    */
876   public List getAtributosById(EstruturaEtt estrutura) {
877     List lAtributos = new ArrayList();
878     if (estrutura.getEstruturaAtributoEttats() != null) {
879       estrutura.getEstruturaAtributoEttats().size(); // Faz isso para
880       Iterator it = estrutura.getEstruturaAtributoEttats().iterator();
881       while (it.hasNext()) {
882         EstruturaAtributoEttat estruturaAtributo = (EstruturaAtributoEttat) it.next();
883         lAtributos.add(estruturaAtributo.getAtributosAtb().getCodAtb());
884       }
885     }
886     return lAtributos;
887   }
888 
889   /**
890    * Retorna um list com identificações de todos os Tipos de Função de
891    * Acompanhamento de uma Estrutura
892    * @param estrutura
893    * @return List de Long
894    */
895   public List getFuncoesAcompanhamentoById(EstruturaEtt estrutura) {
896     List lFuncoesAcompanhamento = new ArrayList();
897     if (estrutura.getEstrutTpFuncAcmpEtttfas() != null) {
898       estrutura.getEstrutTpFuncAcmpEtttfas().size();
899       Iterator it = estrutura.getEstrutTpFuncAcmpEtttfas().iterator();
900       while (it.hasNext()) {
901         EstrutTpFuncAcmpEtttfa estruturaTipoFuncAcomp = (EstrutTpFuncAcmpEtttfa) it.next();
902         lFuncoesAcompanhamento.add(estruturaTipoFuncAcomp.getTipoFuncAcompTpfa().getCodTpfa());
903       }
904     }
905     return lFuncoesAcompanhamento;
906   }
907 
908   /**
909    * Exclui todos os Registros de Atributos e Funçõe relacionados a uma
910    * estrutura
911    * @param estrutura
912    * @throws ECARException
913    */
914   public void deleteFilhos(EstruturaEtt estrutura) throws ECARException {
915     if (estrutura.getEstruturaAtributoEttats() != null) {
916       Iterator itAtb = estrutura.getEstruturaAtributoEttats().iterator();
917       while (itAtb.hasNext()) {
918         EstruturaAtributoEttat estruturaAtributo = (EstruturaAtributoEttat) itAtb.next();
919         this.excluir(estruturaAtributo);
920       }
921     }
922     if (estrutura.getEstruturaFuncaoEttfs() != null) {
923       Iterator itFun = estrutura.getEstruturaFuncaoEttfs().iterator();
924       while (itFun.hasNext()) {
925         EstruturaFuncaoEttf estruturaFuncao = (EstruturaFuncaoEttf) itFun.next();
926         this.excluir(estruturaFuncao);
927       }
928     }
929     if (estrutura.getEstrutTpFuncAcmpEtttfas() != null) {
930       Iterator itFun = estrutura.getEstrutTpFuncAcmpEtttfas().iterator();
931       while (itFun.hasNext()) {
932         EstrutTpFuncAcmpEtttfa estruturaFuncaoAcomp = (EstrutTpFuncAcmpEtttfa) itFun.next();
933         this.excluir(estruturaFuncaoAcomp);
934       }
935     }
936   }
937 
938   /**
939    * A partir de uma estrutura, devolve uma lista com a própria estrutura e mais
940    * seus ascendentes diretos ( pai, pai do pai, etc.)
941    * @param estrutura
942    * @return Lista de EstruturaEtt
943    */
944   public List getAscendentes(EstruturaEtt estrutura) {
945     List retorno = new ArrayList();
946     retorno.add(estrutura);
947     while (estrutura.getEstruturaEtt() != null) {
948       estrutura = estrutura.getEstruturaEtt();
949       retorno.add(estrutura);
950     }
951     Collections.reverse(retorno);
952     return retorno;
953   }
954 
955   /**
956    * A partir de uma estrutura, devolve uma lista com os seus descendentes
957    * diretos ( filho, neto, etc.)
958    * @param estrutura
959    * @return Lista de EstruturaEtt
960    */
961   // public List getDescendentes(EstruturaEtt estrutura) {
962   // List retorno = new ArrayList();
963   // if (estrutura.getEstruturaEtts() != null &&
964   // estrutura.getEstruturaEtts().size() > 0) {
965   // retorno.addAll(estrutura.getEstruturaEtts());
966   // Iterator it = estrutura.getEstruturaEtts().iterator();
967   //            
968   // while (it.hasNext()) {
969   // EstruturaEtt estruturaFilha = (EstruturaEtt) it.next();
970   // retorno.addAll(this.getDescendentes(estruturaFilha));
971   // }
972   // }
973   // return retorno;
974   // }
975 
976   /**
977    * Retorna um conjunto com as estruturas principais, isto é, estruturas de
978    * nivel 1 (sem pai) Teoricamente pode retornar uma lista com várias
979    * estruturas, mas na pratica deve retornar apenas uma estrutura
980    * @return List
981    * @throws ECARException
982    */
983   public List getEstruturaPrincipal() throws ECARException {
984     try {
985       // Query alterada devido ao BUG 894 e 2531
986       List list = session.createQuery("select e from EstruturaEtt as e where e.indAtivoEtt='S' and e.estruturaEtt is null order by e.seqApresentacaoEtt, e.nomeEtt").list();
987 
988       return list;
989     } catch (HibernateException e) {
990       this.logger.error(e);
991       throw new ECARException("erro.hibernateException");
992     }
993   }
994 
995   /**
996    * Retorna uma lista de atributos que serão utilizados para montar as colunas
997    * na tela 6.b.1 - Relação para acesso na estrutura Pseudo-codigo: Retorna os
998    * atributos de estrutura_atributo e funcao_acomp com ind_listagem_tela=S
999    * ordenados por seq_apres_listagem_tela_ettat
1000    * @return List ObjetoEstrutura
1001    */
1002   public List getAtributosAcessoEstrutura(EstruturaEtt estrutura) throws ECARException {
1003     List retorno = new ArrayList();
1004 
1005     try {
1006       retorno.addAll(session.createFilter(estrutura.getEstruturaAtributoEttats(), "where this.indListagemTelaEttat = 'S'").list());
1007       retorno.addAll(session.createFilter(estrutura.getEstrutTpFuncAcmpEtttfas(), "where this.indListagemTelaEtttfa = 'S'").list());
1008 
1009       Collections.sort(retorno, new Comparator() {
1010         public int compare(Object o1, Object o2) {
1011           return ((ObjetoEstrutura) o1).iGetSequenciaColunaEmListagem().intValue() - ((ObjetoEstrutura) o2).iGetSequenciaColunaEmListagem().intValue();
1012         }
1013       });
1014 
1015     } catch (HibernateException e) {
1016       this.logger.error(e);
1017       throw new ECARException("erro.hibernateException");
1018     }
1019     return retorno;
1020   }
1021 
1022   /**
1023    * Devolve uma lista de Atributos e Funcoes de Acompanhamento da Estrutura.
1024    * Essa lista contém objetos estruturaAtributo e estrutTipoFuncAcmp ordenados
1025    * pela ordem do campo na tela. O acesso aos objetos dessa lista se dá pela
1026    * interface ObjetoEstrutura que normaliza os métodos de acesso
1027    * @param estrutura
1028    * @return lista de objetos estruturaAtributo e estrutTipoFuncAcmp ordenados
1029    *         pela ordem do campo na tela.
1030    * @throws ECARException
1031    */
1032   public List getAtributosEstruturaDadosGerais(EstruturaEtt estrutura) throws ECARException {
1033     List retorno = new ArrayList();
1034 
1035     try {
1036       retorno.addAll(estrutura.getEstruturaAtributoEttats());
1037       retorno.addAll(estrutura.getEstrutTpFuncAcmpEtttfas());
1038 
1039       Collections.sort(retorno, new Comparator() {
1040         public int compare(Object o1, Object o2) {
1041           return ((ObjetoEstrutura) o1).iGetSequenciaCampoEmTela().intValue() - ((ObjetoEstrutura) o2).iGetSequenciaCampoEmTela().intValue();
1042         }
1043       });
1044 
1045     } catch (HibernateException e) {
1046       this.logger.error(e);
1047       throw new ECARException("erro.hibernateException");
1048     }
1049     return retorno;
1050   }
1051 
1052   /**
1053    * Devolve uma lista de Atributos e Funcoes de Acompanhamento da Estrutura.
1054    * Essa lista contém objetos estruturaAtributo e estrutTipoFuncAcmp ordenados
1055    * pela ordem do campo na tela. O acesso aos objetos dessa lista se dá pela
1056    * interface ObjetoEstrutura que normaliza os métodos de acesso
1057    * @param estrutura
1058    * @return lista de objetos estruturaAtributo e estrutTipoFuncAcmp ordenados
1059    *         pela ordem do campo na tela.
1060    * @throws ECARException
1061    */
1062   public List getAtributosEstruturaDadosGeraisEhFiltro(EstruturaEtt estrutura, TipoAcompanhamentoTa tipoAcompanhamentoTa) throws ECARException {
1063     List retorno = new ArrayList();
1064 
1065     try {
1066 
1067       Iterator itEstrutura = estrutura.getEstruturaAtributoEttats().iterator();
1068 
1069       while (itEstrutura.hasNext()) {
1070         EstruturaAtributoEttat estruturaAtributoEttat = (EstruturaAtributoEttat) itEstrutura.next();
1071         EstAtribTipoAcompEata estAtribTipoAcompEata = new EstAtribTipoAcompEata();
1072         estAtribTipoAcompEata.setEstruturaAtributoEttat(estruturaAtributoEttat);
1073         estAtribTipoAcompEata.setTipoAcompanhamentoTa(tipoAcompanhamentoTa);
1074         estAtribTipoAcompEata.setFiltroEata("S");
1075 
1076         if (this.pesquisar(estAtribTipoAcompEata, null).size() > 0) {
1077           retorno.add(estruturaAtributoEttat);
1078         }
1079 
1080       }
1081       // retorno.addAll(estrutura.getEstruturaAtributoEttats());
1082       // retorno.addAll(estrutura.getEstrutTpFuncAcmpEtttfas());
1083 
1084       Collections.sort(retorno, new Comparator() {
1085         public int compare(Object o1, Object o2) {
1086           return ((ObjetoEstrutura) o1).iGetSequenciaCampoEmTela().intValue() - ((ObjetoEstrutura) o2).iGetSequenciaCampoEmTela().intValue();
1087         }
1088       });
1089 
1090     } catch (HibernateException e) {
1091       this.logger.error(e);
1092       throw new ECARException("erro.hibernateException");
1093     }
1094     return retorno;
1095   }
1096 
1097   public List getAtributosLivresEstruturaDadosGeraisEhFiltro(EstruturaEtt estrutura, TipoAcompanhamentoTa tipoAcompanhamentoTa) throws ECARException {
1098     List retorno = new ArrayList();
1099 
1100     try {
1101 
1102       Iterator itEstrutura = estrutura.getEstruturaAtributoEttats().iterator();
1103 
1104       while (itEstrutura.hasNext()) {
1105 
1106         EstruturaAtributoEttat estruturaAtributoEttat = (EstruturaAtributoEttat) itEstrutura.next();
1107 
1108         if (estruturaAtributoEttat.iGetGrupoAtributosLivres() != null) {
1109           EstAtribTipoAcompEata estAtribTipoAcompEata = new EstAtribTipoAcompEata();
1110           estAtribTipoAcompEata.setEstruturaAtributoEttat(estruturaAtributoEttat);
1111           estAtribTipoAcompEata.setTipoAcompanhamentoTa(tipoAcompanhamentoTa);
1112           estAtribTipoAcompEata.setFiltroEata("S");
1113 
1114           if (this.pesquisar(estAtribTipoAcompEata, null).size() > 0) {
1115             retorno.add(estruturaAtributoEttat);
1116           }
1117         }
1118       }
1119       // retorno.addAll(estrutura.getEstruturaAtributoEttats());
1120       // retorno.addAll(estrutura.getEstrutTpFuncAcmpEtttfas());
1121 
1122       Collections.sort(retorno, new Comparator() {
1123         public int compare(Object o1, Object o2) {
1124           return ((ObjetoEstrutura) o1).iGetSequenciaCampoEmTela().intValue() - ((ObjetoEstrutura) o2).iGetSequenciaCampoEmTela().intValue();
1125         }
1126       });
1127 
1128     } catch (HibernateException e) {
1129       this.logger.error(e);
1130       throw new ECARException("erro.hibernateException");
1131     }
1132     return retorno;
1133   }
1134 
1135   public List getAtributosEstruturaRevisao(EstruturaEtt estrutura) throws ECARException {
1136     List retorno = new ArrayList();
1137 
1138     try {
1139       retorno.addAll(session.createFilter(estrutura.getEstruturaAtributoEttats(), "where this.indRevisaoEttat = 'S'").list());
1140       retorno.addAll(session.createFilter(estrutura.getEstrutTpFuncAcmpEtttfas(), "where this.indRevisao = 'S'").list());
1141       Collections.sort(retorno, new Comparator() {
1142         public int compare(Object o1, Object o2) {
1143           return ((ObjetoEstrutura) o1).iGetSequenciaCampoEmTela().intValue() - ((ObjetoEstrutura) o2).iGetSequenciaCampoEmTela().intValue();
1144         }
1145       });
1146     } catch (HibernateException e) {
1147       this.logger.error(e);
1148       throw new ECARException("erro.hibernateException");
1149     }
1150     return retorno;
1151   }
1152 
1153   /**
1154    * Devolve uma lista ordenada de ObjetoEstrutura, utilizando como base o tipo
1155    * do relatório (C, R ou L). É utilizada a mesma ordenação dos campos na tela.
1156    * @param estrutura
1157    * @param tipoRelatorio C - Completo R - Resumido L - listagem/relação
1158    * @return List ObjetoEstrutura ordenados por igetSequenciaCampoEmTela
1159    * @throws ECARException
1160    */
1161   public List getAtributosEstruturaRelatorio(EstruturaEtt estrutura, String tipoRelatorio) throws ECARException {
1162     List retorno = new ArrayList();
1163 
1164     try {
1165       if ("C".equals(tipoRelatorio)) { // COMPLETO
1166         retorno.addAll(session.createFilter(estrutura.getEstruturaAtributoEttats(), "where this.indListagemImpressCompEtta = 'S'").list());
1167         retorno.addAll(session.createFilter(estrutura.getEstrutTpFuncAcmpEtttfas(), "where this.indListagemImprCompEtttfa = 'S'").list());
1168       }
1169       else if ("R".equals(tipoRelatorio)) { // RESUMO
1170         retorno.addAll(session.createFilter(estrutura.getEstruturaAtributoEttats(), "where this.indListagemImpressaResEtta = 'S'").list());
1171         retorno.addAll(session.createFilter(estrutura.getEstrutTpFuncAcmpEtttfas(), "where this.indListagemImprResEtttfa = 'S'").list());
1172       }
1173       else if ("L".equals(tipoRelatorio)) { // RELAÇÃO
1174         retorno.addAll(session.createFilter(estrutura.getEstruturaAtributoEttats(), "where this.indRelacaoImpressaEttat = 'S'").list());
1175       }
1176       Collections.sort(retorno, new Comparator() {
1177         public int compare(Object o1, Object o2) {
1178           return ((ObjetoEstrutura) o1).iGetSequenciaCampoEmTela().intValue() - ((ObjetoEstrutura) o2).iGetSequenciaCampoEmTela().intValue();
1179         }
1180       });
1181 
1182     } catch (HibernateException e) {
1183       this.logger.error(e);
1184       throw new ECARException("erro.hibernateException");
1185     }
1186     return retorno;
1187   }
1188 
1189   /**
1190    * Retorna as estruturas filhas da estrutura de um item
1191    * @return List de estruturas
1192    */
1193   public List getSetEstruturasItem(ItemEstruturaIett item) throws ECARException {
1194     try {
1195       // Método alterado devido ao BUG 894 e 2531
1196 
1197       String select = "select e from EstruturaEtt as e " + " where e.indAtivoEtt='S' and" + " e.estruturaEtt.codEtt = :codEtt" + " order by e.seqApresentacaoEtt, e.nomeEtt";
1198       Query q = this.session.createQuery(select);
1199 
1200       q.setLong("codEtt", item.getEstruturaEtt().getCodEtt().longValue());
1201 
1202       return q.list();
1203     } catch (HibernateException e) {
1204       this.logger.error(e);
1205       throw new ECARException("erro.hibernateException");
1206     }
1207   }
1208 
1209   /**
1210    * Método retorna o label utilizado pelo atributo Órgão Responsável 1 na
1211    * estrutura de maior nível hieráqrquivo dentre as que possuam alguma função
1212    * de acompanhamento, Caso essa função não possua label definido para tal
1213    * atributo retorna um label padrão (Órgão Responsável)
1214    * @return
1215    * @throws ECARException
1216    */
1217   public String getLabelPadraoOrgaoResponsavel() throws ECARException {
1218     try {
1219       List estruturas = this.listar(EstruturaEtt.class, null);
1220       if (estruturas == null || estruturas.size() == 0)
1221         return "Órgão Responsável";
1222 
1223       int nivel = 0;
1224       EstruturaEtt maiorEstruturaComFuncao = null;
1225       Iterator it = estruturas.iterator();
1226       while (it.hasNext()) {
1227         EstruturaEtt estrutura = (EstruturaEtt) it.next();
1228         if (estrutura.getEstrutTpFuncAcmpEtttfas().size() > 0) {
1229           int nivelEstrut = this.getNivel(estrutura);
1230           if (nivel == 0 || nivelEstrut < nivel) {
1231             nivel = nivelEstrut;
1232             maiorEstruturaComFuncao = estrutura;
1233           }
1234         }
1235       }
1236       Collection atributo = this.getSession().createFilter(maiorEstruturaComFuncao.getEstruturaAtributoEttats(), " where this.atributosAtb.nomeAtb = 'orgaoOrgByCodOrgaoResponsavel1Iett'").list();
1237       if (atributo == null || atributo.size() == 0)
1238         return "Órgão Responsável";
1239       else
1240         return ((EstruturaAtributoEttat) atributo.iterator().next()).getLabelEstruturaEttat();
1241 
1242     } catch (HibernateException e) {
1243       this.logger.error(e);
1244       throw new ECARException(e);
1245     }
1246 
1247   }
1248 
1249   /**
1250    * Monta lista de estruturas a partir das principais, incluindo também os
1251    * descendentes em ordem de níveis
1252    * @return
1253    * @throws ECARException
1254    */
1255   // public List getEstruturas() throws ECARException {
1256   // List lista = new ArrayList();
1257   //		
1258   // List estruturasPrincipais = this.getEstruturaPrincipal();
1259   // Iterator it = estruturasPrincipais.iterator();
1260   //		
1261   // while(it.hasNext()){
1262   // EstruturaEtt principal = (EstruturaEtt) it.next();
1263   //			
1264   // /* seleciona estruturas descendentes */
1265   // lista.add(principal);
1266   // lista.addAll(this.getDescendentes(principal));
1267   // //Iterator itLista = lista.iterator();
1268   // }
1269   //		
1270   // return lista;
1271   // }
1272   /**
1273    * Verificar se um determinado atributo existe em um nível da estrutura
1274    * através do nome do atributo (atributo.nomeAtb)
1275    * @param EstruturaEtt estrutura
1276    * @param String nomeAtb
1277    * @return true existe, false não existe
1278    * @throws ECARException
1279    */
1280   public boolean verificaExistenciaAtributoNaEstruturaByNomeAtb(EstruturaEtt estrutura, String nomeAtb) throws ECARException {
1281     AtributosAtb atributo = new AtributosAtb();
1282     atributo.setNomeAtb(nomeAtb);
1283 
1284     List atb = super.pesquisar(atributo, null);
1285     if (atb.size() > 0) {
1286       atributo = (AtributosAtb) atb.get(0);
1287       EstruturaAtributoEttat estruturaAtributo = new EstruturaAtributoEttat();
1288       estruturaAtributo.setAtributosAtb(atributo);
1289       estruturaAtributo.setEstruturaEtt(estrutura);
1290       List estAtb = super.pesquisar(estruturaAtributo, null);
1291       if (estAtb.size() > 0) {
1292         return true;
1293       }
1294     }
1295     return false;
1296   }
1297 
1298   /**
1299    * Retorna uma lista de estruturas que são etapas da estrutura pai.
1300    * @author aleixo
1301    * @version 0.1, 22/03/2007
1302    * @param EstruturaEtt estruturaPai
1303    * @return List
1304    * @throws ECARException
1305    */
1306   public List getEstruturasEtapas(EstruturaEtt estruturaPai) throws ECARException {
1307     try {
1308       String select = "select e from EstruturaEtt as e " + " where e.indAtivoEtt='S' and" + " e.indEtapaNivelSuperiorEtt='S' and" + " e.estruturaEtt.codEtt = :codEtt" + " order by e.seqApresentacaoEtt, e.nomeEtt";
1309       Query q = this.session.createQuery(select);
1310 
1311       q.setLong("codEtt", estruturaPai.getCodEtt().longValue());
1312 
1313       List retorno = q.list();
1314 
1315       if (retorno != null)
1316         return retorno;
1317 
1318       return new ArrayList();
1319     } catch (HibernateException e) {
1320       this.logger.error(e);
1321       throw new ECARException("erro.hibernateException");
1322     }
1323   }
1324 
1325   /**
1326    * Retorna uma lista de {@link EstruturaWebServiceBean} para o Web Service.
1327    * @author aleixo
1328    * @version 0.1 - 10/04/2007
1329    * @return List
1330    */
1331   public List getListaEstruturaWebService() {
1332     List retorno = new ArrayList();
1333 
1334     StringBuilder select = new StringBuilder();
1335 
1336     select.append("select e.cod_ett, e.nome_ett from tb_estrutura_ett e order by e.nome_ett");
1337     SQLQuery q = this.session.createSQLQuery(select.toString());
1338 
1339     List objects = q.list();
1340 
1341     if (objects != null && !objects.isEmpty()) {
1342       Iterator itO = objects.iterator();
1343       while (itO.hasNext()) {
1344         Object[] o = (Object[]) itO.next();
1345 
1346         EstruturaWebServiceBean ewsBean = new EstruturaWebServiceBean();
1347 
1348         ewsBean.setCodigo((o[0] != null) ? Long.valueOf(o[0].toString()) : null);
1349         ewsBean.setNome((o[1] != null) ? o[1].toString() : null);
1350 
1351         retorno.add(ewsBean);
1352       }
1353     }
1354 
1355     return retorno;
1356   }
1357 
1358   /**
1359    * @author Robson
1360    * @since 19/11/2007
1361    * @return List<EstruturaEtt> Retorna uma lista das Estruturas em Arvore a
1362    *         partir de uma estrutura pai
1363    */
1364   public List getListaEstruturas(EstruturaEtt estruturaEtt) {
1365     List lista = new ArrayList();
1366 
1367     Criteria select = session.createCriteria(EstruturaEtt.class);
1368 
1369     if (estruturaEtt == null || estruturaEtt.getCodEtt() == null)
1370       select.add(Restrictions.isNull("estruturaEtt"));
1371     else
1372       select.add(Restrictions.eq("estruturaEtt", estruturaEtt));
1373 
1374     List pais = select.add(Restrictions.eq("indAtivoEtt", Dominios.ATIVO)).addOrder(Order.asc("nomeEtt")).list();
1375     Iterator it = pais.iterator();
1376 
1377     while (it.hasNext()) {
1378       estruturaEtt = (EstruturaEtt) it.next();
1379       lista.add(estruturaEtt);
1380       lista.addAll(this.getListaEstruturas(estruturaEtt));
1381     }
1382     return lista;
1383   }
1384 
1385   /**
1386    * @author Robson
1387    * @since 19/11/2007
1388    * @return List<EstruturaEtt> nó raiz
1389    */
1390 
1391   public List getListaEstruturas() {
1392     return this.getListaEstruturas(null);
1393   }
1394 }