View Javadoc

1   /*
2    * Criado em 13/12/2004
3    */
4   package ecar.dao;
5   
6   import java.math.BigDecimal;
7   
8   import java.util.ArrayList;
9   import java.util.Collection;
10  import java.util.Collections;
11  import java.util.Comparator;
12  import java.util.Date;
13  import java.util.Enumeration;
14  import java.util.HashMap;
15  import java.util.HashSet;
16  import java.util.Iterator;
17  import java.util.List;
18  import java.util.Set;
19  
20  import javax.servlet.ServletContext;
21  import javax.servlet.http.HttpServletRequest;
22  
23  import org.hibernate.HibernateException;
24  import org.hibernate.Query;
25  import org.hibernate.SQLQuery;
26  import org.hibernate.Transaction;
27  
28  import comum.database.Dao;
29  import comum.util.Data;
30  import comum.util.Mensagem;
31  import comum.util.Pagina;
32  import comum.util.Util;
33  
34  import ecar.bean.AtributoEstruturaBean;
35  import ecar.bean.AtributoEstruturaListagemItens;
36  import ecar.bean.IndicativoItemWebServiceBean;
37  import ecar.bean.ItemWSMinBean;
38  import ecar.bean.ItemWebServiceBean;
39  import ecar.bean.NomeImgsNivelPlanejamentoBean;
40  import ecar.bean.OrdenacaoIett;
41  import ecar.bean.OrdenacaoPorNivel;
42  import ecar.exception.ECARException;
43  import ecar.historico.HistoricoIett;
44  import ecar.login.SegurancaECAR;
45  import ecar.permissao.ControlePermissao;
46  import ecar.permissao.ValidaPermissao;
47  import ecar.pojo.AcompReferenciaAref;
48  import ecar.pojo.AreaAre;
49  import ecar.pojo.EstrutTpFuncAcmpEtttfa;
50  import ecar.pojo.EstruturaAtributoEttat;
51  import ecar.pojo.EstruturaEtt;
52  import ecar.pojo.EstruturaFuncaoEttf;
53  import ecar.pojo.ItemEstUsutpfuacIettutfa;
54  import ecar.pojo.ItemEstrutUsuarioIettus;
55  import ecar.pojo.ItemEstruturaIett;
56  import ecar.pojo.ItemEstruturaIettMin;
57  import ecar.pojo.ItemEstruturaIettPPA;
58  import ecar.pojo.ItemEstruturaSisAtributoIettSatb;
59  import ecar.pojo.ItemFuncaoLink;
60  import ecar.pojo.ObjetoEstrutura;
61  import ecar.pojo.OrgaoOrg;
62  import ecar.pojo.PaiFilho;
63  import ecar.pojo.PeriodicidadePrdc;
64  import ecar.pojo.SisAtributoSatb;
65  import ecar.pojo.SisGrupoAtributoSga;
66  import ecar.pojo.SisTipoExibicGrupoSteg;
67  import ecar.pojo.SituacaoSit;
68  import ecar.pojo.SubAreaSare;
69  import ecar.pojo.TipoAcompFuncAcompTafc;
70  import ecar.pojo.TipoAcompanhamentoTa;
71  import ecar.pojo.TipoFuncAcompTpfa;
72  import ecar.pojo.UnidadeOrcamentariaUO;
73  import ecar.pojo.UsuarioUsu;
74  import ecar.util.Dominios;
75  
76  /**
77   * @author felipev, aleixo
78   */
79  public class ItemEstruturaDao extends Dao {
80    /**
81     * Construtor. Chama o Session factory do Hibernate
82     */
83    public ItemEstruturaDao(HttpServletRequest request) {
84      super();
85      this.request = request;
86    }
87  
88    /**
89     * Retorna o valor de um atributo em um itemEstrutura
90     * @param itemEstrutura
91     * @param nomeAtributo
92     * @param fkAtributo
93     * @return
94     * @throws ECARException
95     */
96    public String getValorAtributoItemEstrutura(ItemEstruturaIett itemEstrutura, String nomeAtributo, String fkAtributo) throws ECARException {
97      try {
98        Object retorno = Util.invocaGet(itemEstrutura, nomeAtributo);
99        if (retorno != null) {
100         if (fkAtributo != null && !"".equals(fkAtributo)) {
101           retorno = Util.invocaGet(retorno, fkAtributo);
102           if (retorno != null)
103             return retorno.toString();
104           else
105             return "";
106         }
107         else {
108           if (retorno.getClass().equals(Date.class) || retorno.getClass().equals(Date.class))
109             retorno = Data.parseDate((Date) retorno);
110           return retorno.toString();
111         }
112       }
113     } catch (Exception e) {
114 
115     }
116     return "";
117   }
118 
119   /**
120    * Retorna o usuário associoado a uma função de acompanhamento em um
121    * itemEstrutura
122    * @param itemEstrutura
123    * @param funAcomp
124    * @return
125    * @throws ECARException
126    */
127   public UsuarioUsu getValorFunAcompItemEstrutura(ItemEstruturaIett itemEstrutura, TipoFuncAcompTpfa funAcomp) throws ECARException {
128     ItemEstUsutpfuacIettutfa ieUsuTf = new ItemEstUsutpfuacIettutfa();
129     ieUsuTf.setItemEstruturaIett(itemEstrutura);
130     ieUsuTf.setTipoFuncAcompTpfa(funAcomp);
131     try {
132       List result = this.pesquisar(ieUsuTf, null);
133       if (result != null) {
134         for (Iterator it = result.iterator(); it.hasNext();) {
135           ItemEstUsutpfuacIettutfa element = (ItemEstUsutpfuacIettutfa) it.next();
136           return element.getUsuarioUsu();
137         }
138         return null;
139       }
140       else {
141         return null;
142       }
143     } catch (ECARException e) {
144       this.logger.error(e);
145       return null;
146     }
147 
148   }
149 
150   /**
151    * Retorna o SisAtributoSatb associado a uma função de acompanhamento em um
152    * itemEstrutura
153    * @param itemEstrutura
154    * @param funAcomp
155    * @return
156    * @throws ECARException
157    */
158   public SisAtributoSatb getValorSatbFunAcompItemEstrutura(ItemEstruturaIett itemEstrutura, TipoFuncAcompTpfa funAcomp) throws ECARException {
159     ItemEstUsutpfuacIettutfa ieUsuTf = new ItemEstUsutpfuacIettutfa();
160     ieUsuTf.setItemEstruturaIett(itemEstrutura);
161     ieUsuTf.setTipoFuncAcompTpfa(funAcomp);
162     try {
163       List result = this.pesquisar(ieUsuTf, null);
164       if (result != null) {
165         for (Iterator it = result.iterator(); it.hasNext();) {
166           ItemEstUsutpfuacIettutfa element = (ItemEstUsutpfuacIettutfa) it.next();
167           return element.getSisAtributoSatb();
168         }
169         return null;
170       }
171       else {
172         return null;
173       }
174     } catch (ECARException e) {
175       this.logger.error(e);
176       return null;
177     }
178 
179   }
180 
181   /**
182    * Cria um objeto ItemEstruturaIett a partir de parâmetros passados no objeto
183    * request
184    * @param request
185    * @param EfIettFonteTotEfieft
186    * @throws ECARException
187    */
188   public void setItemEstrutura(HttpServletRequest request, ItemEstruturaIett itemEstrutura) throws ECARException {
189     // Verifica se o planejamento está bloqueado
190     Boolean planejamentoBloqueado = false;
191     if (itemEstrutura.getIndBloqPlanejamentoIett() != null && itemEstrutura.getIndBloqPlanejamentoIett().equals("S")) {
192       planejamentoBloqueado = true;
193     }
194 
195     // SegurancaECAR seg =
196     // (SegurancaECAR)request.getSession().getAttribute("seguranca");
197     // List funcoesDoUsuario = (new
198     // TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura
199     // , seg.getUsuario(), seg.getGruposAcesso());
200 
201     // Define os atributos que são independentes de o planejamento estar
202     // bloqueado
203     itemEstrutura.setDataUltManutencaoIett(Data.getDataAtual());
204     if (!"".equals(Pagina.getParamStr(request, "codIettPai"))) {
205       itemEstrutura.setItemEstruturaIett((ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIettPai"))));
206     }
207     if (!"".equals(Pagina.getParamStr(request, "codIett"))) {
208       itemEstrutura.setCodIett(Long.valueOf(Pagina.getParamStr(request, "codIett")));
209     }
210     itemEstrutura.setEstruturaEtt((EstruturaEtt) new EstruturaDao(request).buscar(EstruturaEtt.class, Long.valueOf(Pagina.getParamStr(request, "codEtt"))));
211 
212     // hint de desempenho. Já diz a qual nivel o item pertence.
213     itemEstrutura.setNivelIett(Integer.valueOf(getNivel(itemEstrutura)));
214 
215     SegurancaECAR seg = (SegurancaECAR) request.getSession().getAttribute("seguranca");
216     List funcoesDoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura, seg.getUsuario(), seg.getGruposAcesso());
217 
218     // Busca a lista de atributos definidos para estrutura. Está lista é
219     // necessária para saber
220     // se, no caso do planejamento estar bloqueado, o atributo pode ou não ser
221     // alterado.
222     // No caso de o planejamento não estar bloqueado ou ser a inserção de um
223     // novo item,
224     // não faz diferença.
225     List atributos = new ArrayList();
226     EstruturaDao estruturaDao = new EstruturaDao(request);
227     EstruturaEtt estrutura = itemEstrutura.getEstruturaEtt();
228     atributos = estruturaDao.getAtributosEstruturaDadosGerais(estrutura);
229     // Realiza iteração entre todos os atributos configurados na estrutura.
230     Iterator it = atributos.iterator();
231     while (it.hasNext()) {
232       ObjetoEstrutura element = (ObjetoEstrutura) it.next();
233 
234       // Verifica se o atritubo é "siglaIett".
235       if (element.iGetNome().equals("siglaIett")) {
236         // Verifica se o planejamento não está bloqueado ou se, caso bloqueado,
237         // o campo não está
238         // bloqueado. Satisfeito estas condições, o atributo pode ser definido.
239         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
240           if ("".equals(itemEstrutura.getSiglaIett())) {
241             itemEstrutura.setSiglaIett(null);
242           }
243           else {
244             itemEstrutura.setSiglaIett(Pagina.getParamStr(request, "siglaIett"));
245           }
246         }
247         else {
248 
249         }
250       }
251       else if (element.iGetNome().equals("nomeIett")) {
252         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
253           itemEstrutura.setNomeIett(Pagina.getParamStr(request, "nomeIett"));
254         }
255       }
256       else if (element.iGetNome().equals("descricaoIett")) {
257         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
258           itemEstrutura.setDescricaoIett(Pagina.getParamStr(request, "descricaoIett"));
259         }
260       }
261       else if (element.iGetNome().equals("origemIett")) {
262         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
263           itemEstrutura.setOrigemIett(Pagina.getParamStr(request, "origemIett"));
264         }
265       }
266       else if (element.iGetNome().equals("indAtivoIett")) {
267         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
268           String indAtivo = Pagina.getParamStr(request, "indAtivoIett");
269           if ("".equals(indAtivo.trim())) {
270             indAtivo = "S";
271           }
272           itemEstrutura.setIndAtivoIett(indAtivo);
273         }
274       }
275       else if (element.iGetNome().equals("indMonitoramentoIett")) {
276         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
277           String indMonitoramento = Pagina.getParamStr(request, "indMonitoramentoIett");
278           if ("".equals(indMonitoramento.trim())) {
279             indMonitoramento = "N";
280           }
281           itemEstrutura.setIndMonitoramentoIett(indMonitoramento);
282         }
283       }
284       else if (element.iGetNome().equals("indBloqPlanejamentoIett")) {
285         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
286           String indBloqPlanejamento = Pagina.getParamStr(request, "indBloqPlanejamentoIett");
287           if ("".equals(indBloqPlanejamento.trim())) {
288             indBloqPlanejamento = "N";
289           }
290           itemEstrutura.setIndBloqPlanejamentoIett(indBloqPlanejamento);
291         }
292       }
293       else if (element.iGetNome().equals("objetivoGeralIett")) {
294         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
295           itemEstrutura.setObjetivoGeralIett(Pagina.getParamStr(request, "objetivoGeralIett"));
296         }
297       }
298       else if (element.iGetNome().equals("objetivoEspecificoIett")) {
299         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
300           itemEstrutura.setObjetivoEspecificoIett(Pagina.getParamStr(request, "objetivoEspecificoIett"));
301         }
302       }
303       else if (element.iGetNome().equals("beneficiosIett")) {
304         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
305           itemEstrutura.setBeneficiosIett(Pagina.getParamStr(request, "beneficiosIett"));
306         }
307       }
308       else if (element.iGetNome().equals("dataInicioIett")) {
309         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
310           if (!"".equals(Pagina.getParamStr(request, "dataInicioIett"))) {
311             itemEstrutura.setDataInicioIett(Pagina.getParamDataBanco(request, "dataInicioIett"));
312           }
313           else {
314             itemEstrutura.setDataInicioIett(null);
315           }
316         }
317       }
318       else if (element.iGetNome().equals("dataTerminoIett")) {
319         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
320           if (!"".equals(Pagina.getParamStr(request, "dataTerminoIett"))) {
321             itemEstrutura.setDataTerminoIett(Pagina.getParamDataBanco(request, "dataTerminoIett"));
322           }
323           else {
324             itemEstrutura.setDataTerminoIett(null);
325           }
326         }
327       }
328       else if (element.iGetNome().equals("areaAre")) {
329         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
330           if (!"".equals(Pagina.getParamStr(request, "areaAre"))) {
331             itemEstrutura.setAreaAre((AreaAre) new AreaDao(request).buscar(AreaAre.class, Long.valueOf(Pagina.getParamStr(request, "areaAre"))));
332           }
333           else {
334             itemEstrutura.setAreaAre(null);
335           }
336         }
337       }
338       else if (element.iGetNome().equals("subAreaSare")) {
339         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
340           if (!"".equals(Pagina.getParamStr(request, "subAreaSare"))) {
341             itemEstrutura.setSubAreaSare((SubAreaSare) new SubAreaDao(request).buscar(SubAreaSare.class, Long.valueOf(Pagina.getParamStr(request, "subAreaSare"))));
342           }
343           else {
344             itemEstrutura.setSubAreaSare(null);
345           }
346         }
347       }
348       else if (element.iGetNome().equals("unidadeOrcamentariaUO")) {
349         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
350           if (!"".equals(Pagina.getParamStr(request, "unidadeOrcamentariaUO"))) {
351             itemEstrutura.setUnidadeOrcamentariaUO((UnidadeOrcamentariaUO) new UnidadeOrcamentariaDao(request).buscar(UnidadeOrcamentariaUO.class, Long.valueOf(Pagina.getParamStr(request, "unidadeOrcamentariaUO"))));
352           }
353           else {
354             itemEstrutura.setUnidadeOrcamentariaUO(null);
355           }
356         }
357       }
358       else if (element.iGetNome().equals("orgaoOrgByCodOrgaoResponsavel1Iett")) {
359         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
360           if (!"".equals(Pagina.getParamStr(request, "orgaoOrgByCodOrgaoResponsavel1Iett"))) {
361             itemEstrutura.setOrgaoOrgByCodOrgaoResponsavel1Iett((OrgaoOrg) new OrgaoDao(request).buscar(OrgaoOrg.class, Long.valueOf(Pagina.getParamStr(request, "orgaoOrgByCodOrgaoResponsavel1Iett"))));
362           }
363           else {
364             itemEstrutura.setOrgaoOrgByCodOrgaoResponsavel1Iett(null);
365           }
366         }
367       }
368       else if (element.iGetNome().equals("orgaoOrgByCodOrgaoResponsavel2Iett")) {
369         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
370           if (!"".equals(Pagina.getParamStr(request, "orgaoOrgByCodOrgaoResponsavel2Iett"))) {
371             itemEstrutura.setOrgaoOrgByCodOrgaoResponsavel2Iett((OrgaoOrg) new OrgaoDao(request).buscar(OrgaoOrg.class, Long.valueOf(Pagina.getParamStr(request, "orgaoOrgByCodOrgaoResponsavel2Iett"))));
372           }
373           else {
374             itemEstrutura.setOrgaoOrgByCodOrgaoResponsavel2Iett(null);
375           }
376         }
377       }
378       else if (element.iGetNome().equals("periodicidadePrdc")) {
379         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
380           if (!"".equals(Pagina.getParamStr(request, "periodicidadePrdc"))) {
381             itemEstrutura.setPeriodicidadePrdc((PeriodicidadePrdc) new PeriodicidadeDao(request).buscar(PeriodicidadePrdc.class, Long.valueOf(Pagina.getParamStr(request, "periodicidadePrdc"))));
382           }
383           else {
384             itemEstrutura.setPeriodicidadePrdc(null);
385           }
386         }
387       }
388       else if (element.iGetNome().equals("indCriticaIett")) {
389         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
390           String indCritica = Pagina.getParamStr(request, "indCriticaIett");
391           if ("".equals(indCritica.trim())) {
392             indCritica = "N";
393           }
394           itemEstrutura.setIndCriticaIett(indCritica);
395         }
396       }
397       else if (element.iGetNome().equals("valPrevistoFuturoIett")) {
398         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
399           if (!"".equals(Pagina.getParamStr(request, "valPrevistoFuturoIett"))) {
400             itemEstrutura.setValPrevistoFuturoIett(new BigDecimal(Double.valueOf(Util.formataNumero(Pagina.getParamStr(request, "valPrevistoFuturoIett"))).doubleValue()));
401           }
402           else {
403             itemEstrutura.setValPrevistoFuturoIett(null);
404           }
405         }
406       }
407       else if (element.iGetNome().equals("dataR1")) {
408         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
409           if (!"".equals(Pagina.getParamStr(request, "dataR1"))) {
410             itemEstrutura.setDataR1(Pagina.getParamDataBanco(request, "dataR1"));
411           }
412           else {
413             itemEstrutura.setDataR1(null);
414           }
415         }
416       }
417       else if (element.iGetNome().equals("dataR2")) {
418         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
419           if (!"".equals(Pagina.getParamStr(request, "dataR2"))) {
420             itemEstrutura.setDataR2(Pagina.getParamDataBanco(request, "dataR2"));
421           }
422           else {
423             itemEstrutura.setDataR2(null);
424           }
425         }
426       }
427       else if (element.iGetNome().equals("dataR3")) {
428         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
429           if (!"".equals(Pagina.getParamStr(request, "dataR3"))) {
430             itemEstrutura.setDataR3(Pagina.getParamDataBanco(request, "dataR3"));
431           }
432           else {
433             itemEstrutura.setDataR3(null);
434           }
435         }
436       }
437       else if (element.iGetNome().equals("dataR4")) {
438         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
439           if (!"".equals(Pagina.getParamStr(request, "dataR4"))) {
440             itemEstrutura.setDataR4(Pagina.getParamDataBanco(request, "dataR4"));
441           }
442           else {
443             itemEstrutura.setDataR4(null);
444           }
445         }
446       }
447       else if (element.iGetNome().equals("dataR5")) {
448         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
449           if (!"".equals(Pagina.getParamStr(request, "dataR5"))) {
450             itemEstrutura.setDataR5(Pagina.getParamDataBanco(request, "dataR5"));
451           }
452           else {
453             itemEstrutura.setDataR5(null);
454           }
455         }
456       }
457       else if (element.iGetNome().equals("descricaoR1")) {
458         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
459           itemEstrutura.setDescricaoR1(Pagina.getParamStr(request, "descricaoR1"));
460         }
461       }
462       else if (element.iGetNome().equals("descricaoR2")) {
463         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
464           itemEstrutura.setDescricaoR2(Pagina.getParamStr(request, "descricaoR2"));
465         }
466       }
467       else if (element.iGetNome().equals("descricaoR3")) {
468         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
469           itemEstrutura.setDescricaoR3(Pagina.getParamStr(request, "descricaoR3"));
470         }
471       }
472       else if (element.iGetNome().equals("descricaoR4")) {
473         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
474           itemEstrutura.setDescricaoR4(Pagina.getParamStr(request, "descricaoR4"));
475         }
476       }
477       else if (element.iGetNome().equals("descricaoR5")) {
478         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
479           itemEstrutura.setDescricaoR5(Pagina.getParamStr(request, "descricaoR5"));
480         }
481       }
482       else if (element.iGetNome().equals("situacaoSit")) {
483         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
484           if (!"".equals(Pagina.getParamStr(request, "situacaoSit"))) {
485             String codSit = Pagina.getParamStr(request, "situacaoSit");
486             itemEstrutura.setSituacaoSit((SituacaoSit) new SituacaoDao(null).buscar(SituacaoSit.class, Long.valueOf(codSit)));
487           }
488           else {
489             itemEstrutura.setSituacaoSit(null);
490           }
491         }
492       }
493       else if (element.iGetNome().equals("nivelPlanejamento")) {
494         if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
495           itemEstrutura.setItemEstruturaNivelIettns(new HashSet());
496           ConfiguracaoDao configuracaoDao = new ConfiguracaoDao(request);
497           String campoNivelPlanejamento = "a" + configuracaoDao.getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan().getCodSga().toString();
498           if (request.getParameterValues(campoNivelPlanejamento) != null) {
499             String[] atributosLivres = request.getParameterValues(campoNivelPlanejamento);
500             for (int i = 0; i < atributosLivres.length; i++) {
501               if (!atributosLivres[i].equals("")) {
502                 itemEstrutura.getItemEstruturaNivelIettns().add((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(atributosLivres[i])));
503               }
504             }
505           }
506         }
507       }
508     }
509     // Define as Funções de acompanhamentos.
510     setFuncoesAcompanhamentoItemEstrutura(request, itemEstrutura);
511   }
512 
513   /**
514    * Devolve um int indicando em qual nível da hierarquia de itens o Item se
515    * encontra
516    * @param itemEstrutura
517    * @return
518    * @throws ECARException
519    */
520   private int getNivel(ItemEstruturaIett itemEstrutura) throws ECARException {
521     int nivel = 1;
522 
523     while (itemEstrutura.getItemEstruturaIett() != null) {
524       itemEstrutura = itemEstrutura.getItemEstruturaIett();
525       nivel++;
526 
527     }
528 
529     return nivel;
530   }
531 
532   /**
533    * Seta os atributos livres vindos do request para um itemEstrutura
534    * @author aleixo
535    * @since 28/05/2007
536    * @param request
537    * @param itemEstrutura
538    * @throws ECARException
539    */
540   private List getAtributosLivresItemEstrutura(HttpServletRequest request, ItemEstruturaIett itemEstrutura) throws ECARException {
541     Boolean planejamentoBloqueado = false;
542     if (itemEstrutura.getIndBloqPlanejamentoIett() != null && itemEstrutura.getIndBloqPlanejamentoIett().equals("S")) {
543       planejamentoBloqueado = true;
544     }
545 
546     SegurancaECAR seg = (SegurancaECAR) request.getSession().getAttribute("seguranca");
547     List funcoesDoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura, seg.getUsuario(), seg.getGruposAcesso());
548 
549     /*
550      * Obter o código do grupo do atributo livre para pegar pelo campo "a" +
551      * codSga;
552      */
553     List sgas = new ArrayList();
554     if (itemEstrutura.getEstruturaEtt() != null && itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats() != null && !itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats().isEmpty()) {
555       for (Iterator it = itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats().iterator(); it.hasNext();) {
556         EstruturaAtributoEttat ettat = (EstruturaAtributoEttat) it.next();
557         if (ettat.getAtributosAtb() != null && ettat.getAtributosAtb().getSisGrupoAtributoSga() != null) {
558           if (!planejamentoBloqueado || (planejamentoBloqueado && !ettat.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, ettat, funcoesDoUsuario)) {
559             sgas.add(ettat.getAtributosAtb().getSisGrupoAtributoSga());
560           }
561         }
562       }
563     }
564 
565     List atributosLivres = new ArrayList();
566     // Percorrer grupo de atributos para selecionar os atributos livres...
567     for (Iterator it = sgas.iterator(); it.hasNext();) {
568       SisGrupoAtributoSga grupoAtributo = (SisGrupoAtributoSga) it.next();
569 
570       String nomeCampo = "a" + grupoAtributo.getCodSga().toString();
571       String tipoCampo = grupoAtributo.getSisTipoExibicGrupoSteg().getCodSteg().toString();
572 
573       // Se for CheckBox ou RadioButton ou ListBox, não gravar
574       // InformacaoIettSatb
575       // Alterado por José André Fernandes, foi acrescentado ListBox
576       if (tipoCampo.equals(SisTipoExibicGrupoDao.CHECKBOX) || tipoCampo.equals(SisTipoExibicGrupoDao.LISTBOX)) {
577         String[] atributos = request.getParameterValues(nomeCampo);
578         int numAtributos = 0;
579         if (atributos != null) {
580           numAtributos = atributos.length;
581         }
582         for (int i = 0; i < numAtributos; i++) {
583           // Não seto todos os outros campos, pois eles serão setados depois de
584           // gravar o item.
585           ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
586           atributoLivre.setDataUltManutencaoIettSatb(Data.getDataAtual());
587           atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
588           atributoLivre.setItemEstruturaIett(itemEstrutura);
589           atributoLivre.setSisAtributoSatb((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(atributos[i])));
590           atributoLivre.atribuirPKPai();
591 
592           atributosLivres.add(atributoLivre);
593         }
594       }
595       // Se for Radio Button...
596       else if (tipoCampo.equals(SisTipoExibicGrupoDao.RADIO_BUTTON) || tipoCampo.equals(SisTipoExibicGrupoDao.COMBOBOX)) {
597 
598         if (!"".equals(Pagina.getParamStr(request, nomeCampo))) {
599           // Não seto todos os outros campos, pois eles serão setados depois de
600           // gravar o item.
601           ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
602           atributoLivre.setDataUltManutencaoIettSatb(Data.getDataAtual());
603           atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
604           atributoLivre.setItemEstruturaIett(itemEstrutura);
605           atributoLivre.setSisAtributoSatb((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(Pagina.getParamStr(request, nomeCampo))));
606           atributoLivre.atribuirPKPai();
607 
608           atributosLivres.add(atributoLivre);
609         }
610       }
611       // Se for TEXT Field
612       else if (tipoCampo.equals(SisTipoExibicGrupoDao.TEXT) || tipoCampo.equals(SisTipoExibicGrupoDao.TEXTAREA)) {
613 
614         // System.out.println(Pagina.getParamStr(request, atributosLivres));
615         if (!"".equals(Pagina.getParamStr(request, nomeCampo))) {
616 
617           // Não seto todos os outros campos, pois eles serão setados depois de
618           // gravar o item.
619           ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
620           atributoLivre.setDataUltManutencaoIettSatb(Data.getDataAtual());
621           atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
622           atributoLivre.setItemEstruturaIett(itemEstrutura);
623           atributoLivre.setSisAtributoSatb((SisAtributoSatb) grupoAtributo.getSisAtributoSatbs().iterator().next());
624           atributoLivre.setInformacaoIettSatb(Pagina.getParamStr(request, nomeCampo));
625           atributoLivre.atribuirPKPai();
626 
627           atributosLivres.add(atributoLivre);
628         }
629 
630       }
631       else if (tipoCampo.equals(SisTipoExibicGrupoDao.IMAGEM)) {
632         if (!"".equals(Pagina.getParamStr(request, nomeCampo))) {
633 
634           // Não seto todos os outros campos, pois eles serão setados depois de
635           // gravar o item.
636           ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
637           atributoLivre.setDataUltManutencaoIettSatb(Data.getDataAtual());
638           atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
639           atributoLivre.setItemEstruturaIett(itemEstrutura);
640           atributoLivre.setSisAtributoSatb((SisAtributoSatb) grupoAtributo.getSisAtributoSatbs().iterator().next());
641           atributoLivre.setInformacaoIettSatb(Pagina.getParamStr(request, nomeCampo));
642           atributoLivre.atribuirPKPai();
643 
644           atributosLivres.add(atributoLivre);
645         }
646       }
647       else if (tipoCampo.equals(SisTipoExibicGrupoDao.MULTITEXTO)) {
648         Enumeration lAtrib = request.getParameterNames();
649         while (lAtrib.hasMoreElements()) {
650           String atrib = (String) lAtrib.nextElement();
651           if (atrib.lastIndexOf('_') > 0) {
652             // System.out.println("nomeatributo" + atrib);
653             String nomeAtrib = atrib.substring(0, atrib.lastIndexOf('_'));
654             String codSisAtrib = atrib.substring(atrib.lastIndexOf('_') + 1);
655             nomeCampo = "a" + grupoAtributo.getCodSga().toString() + "_" + codSisAtrib;
656 
657             if (nomeAtrib.equals("a" + grupoAtributo.getCodSga().toString()) && !"".equals(Pagina.getParamStr(request, atrib))) {
658               ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
659               atributoLivre.setDataUltManutencaoIettSatb(Data.getDataAtual());
660               atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
661               atributoLivre.setItemEstruturaIett(itemEstrutura);
662               atributoLivre.setSisAtributoSatb((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(codSisAtrib)));
663               atributoLivre.setInformacaoIettSatb(Pagina.getParamStr(request, nomeCampo));
664               atributoLivre.atribuirPKPai();
665               atributosLivres.add(atributoLivre);
666             }
667           }
668         }
669 
670       }
671       else if (tipoCampo.equals(SisTipoExibicGrupoDao.VALIDACAO)) {
672         if (!"".equals(Pagina.getParamStr(request, nomeCampo))) {
673 
674           // Não seto todos os outros campos, pois eles serão setados depois de
675           // gravar o item.
676           ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
677           atributoLivre.setDataUltManutencaoIettSatb(Data.getDataAtual());
678           atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
679           atributoLivre.setItemEstruturaIett(itemEstrutura);
680           atributoLivre.setSisAtributoSatb((SisAtributoSatb) grupoAtributo.getSisAtributoSatbs().iterator().next());
681           atributoLivre.setInformacaoIettSatb(Pagina.getParamStr(request, nomeCampo));
682           atributoLivre.atribuirPKPai();
683 
684           atributosLivres.add(atributoLivre);
685         }
686 
687       }
688 
689     }
690 
691     return atributosLivres;
692   }
693 
694   /**
695    * Adiciona elementos à coleção de Funções de Acompanhamento de um
696    * ItemEstrutura
697    * @param request
698    * @param itemEstrutura
699    * @throws ECARException
700    */
701   public void setFuncoesAcompanhamentoItemEstrutura(HttpServletRequest request, ItemEstruturaIett itemEstrutura) throws ECARException {
702     // Verifica se o planejamento está bloqueado
703     Boolean planejamentoBloqueado = false;
704     if (itemEstrutura.getIndBloqPlanejamentoIett() != null && itemEstrutura.getIndBloqPlanejamentoIett().equals("S")) {
705       planejamentoBloqueado = true;
706     }
707 
708     /* obtem as funcoes de acompanhamento exercidas pelo usuario */
709     SegurancaECAR seg = (SegurancaECAR) request.getSession().getAttribute("seguranca");
710     List funcoesDoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura, seg.getUsuario(), seg.getGruposAcesso());
711 
712     // Limpa a collection
713     itemEstrutura.setItemEstUsutpfuacIettutfas(new HashSet());
714     // Descobre a Estrutura do item
715     EstruturaEtt estrutura = itemEstrutura.getEstruturaEtt();
716     // Descobre as funções de acompanhamento de uma estrutura
717     Set funcoesAcomp = estrutura.getEstrutTpFuncAcmpEtttfas();
718 
719     // Itera pelas funções buscando no request o valor passado.
720     if (funcoesAcomp != null) {
721 
722       for (Iterator it = funcoesAcomp.iterator(); it.hasNext();) {
723         EstrutTpFuncAcmpEtttfa funcao = (EstrutTpFuncAcmpEtttfa) it.next();
724         if (!planejamentoBloqueado || (planejamentoBloqueado && !funcao.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, funcao, funcoesDoUsuario)) {
725           if (!"".equals(Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()))) {
726             ItemEstUsutpfuacIettutfa funcaoItemEstrutura = new ItemEstUsutpfuacIettutfa();
727             funcaoItemEstrutura.setItemEstruturaIett(itemEstrutura);
728             funcaoItemEstrutura.setTipoFuncAcompTpfa(funcao.getTipoFuncAcompTpfa());
729             if (Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()).startsWith("U")) {
730               funcaoItemEstrutura.setUsuarioUsu((UsuarioUsu) this.buscar(UsuarioUsu.class, Long.valueOf(Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()).substring(1))));
731             }
732             else if (Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()).startsWith("G")) {
733               funcaoItemEstrutura.setSisAtributoSatb((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()).substring(1))));
734             }
735             itemEstrutura.getItemEstUsutpfuacIettutfas().add(funcaoItemEstrutura);
736           }
737         }
738       }
739     }
740   }
741 
742   /**
743    * Salva um registro de itemEstrutura. Salva à parte os
744    * item-estrutura-funcao-tipo-acomp devido a chave composta. (que deve ser
745    * setada depois de gravar o item)
746    * @param itemEstrutura
747    * @throws ECARException
748    */
749   public void salvar(HttpServletRequest request, ItemEstruturaIett itemEstrutura) throws ECARException {
750     Transaction tx = null;
751 
752     try {
753       ArrayList objetos = new ArrayList();
754 
755       super.inicializarLogBean();
756 
757       tx = session.beginTransaction();
758 
759       itemEstrutura.setDataInclusaoIett(Data.getDataAtual());
760       List filhos = new ArrayList();
761       if (itemEstrutura.getItemEstUsutpfuacIettutfas() != null)
762         filhos.addAll(itemEstrutura.getItemEstUsutpfuacIettutfas());
763 
764       session.save(itemEstrutura);
765       objetos.add(itemEstrutura);
766 
767       /*
768        * Salvar os atributos livres, pois agora já tenho o codIett
769        */
770       List atributosLivres = this.getAtributosLivresItemEstrutura(request, itemEstrutura);
771       for (Iterator it = atributosLivres.iterator(); it.hasNext();) {
772         ItemEstruturaSisAtributoIettSatb atbLivre = (ItemEstruturaSisAtributoIettSatb) it.next();
773         session.save(atbLivre);
774         objetos.add(atbLivre);
775       }
776 
777       //
778       // controlar as permissoes passando o item e a lista das funcoes de
779       // acompanhamento velhas (vai ser uma lista vazia)
780       //
781       new ControlePermissao().atualizarPermissoesItemEstrutura(itemEstrutura, null, session, true, request);
782 
783       // gravar permissão para o usuário que criou o item
784       ItemEstrutUsuarioIettus itemEstrutUsuario = new ItemEstrutUsuarioIettus();
785 
786       itemEstrutUsuario.setItemEstruturaIett(itemEstrutura);
787       itemEstrutUsuario.setItemEstruturaIettOrigem(itemEstrutura);
788       itemEstrutUsuario.setCodTpPermIettus(ControlePermissao.PERMISSAO_USUARIO);
789       itemEstrutUsuario.setUsuarioUsu(itemEstrutura.getUsuarioUsuByCodUsuIncIett());
790 
791       itemEstrutUsuario.setIndLeituraIettus("S");
792       itemEstrutUsuario.setIndEdicaoIettus("S");
793       itemEstrutUsuario.setIndExcluirIettus("S");
794 
795       itemEstrutUsuario.setIndAtivMonitIettus("N");
796       itemEstrutUsuario.setIndDesatMonitIettus("N");
797       itemEstrutUsuario.setIndBloqPlanIettus("N");
798       itemEstrutUsuario.setIndDesblPlanIettus("N");
799       itemEstrutUsuario.setIndInfAndamentoIettus("N");
800       itemEstrutUsuario.setIndEmitePosIettus("N");
801       itemEstrutUsuario.setIndProxNivelIettus("N");
802 
803       itemEstrutUsuario.setDataInclusaoIettus(Data.getDataAtual());
804 
805       Iterator it = filhos.iterator();
806       while (it.hasNext()) {
807         PaiFilho object = (PaiFilho) it.next();
808         object.atribuirPKPai();
809         // salva os filhos
810         session.save(object);
811         objetos.add(object);
812       }
813 
814       session.save(itemEstrutUsuario);
815       objetos.add(itemEstrutUsuario);
816 
817       tx.commit();
818 
819       if (super.logBean != null) {
820         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
821         super.logBean.setOperacao("INC");
822         Iterator itObj = objetos.iterator();
823 
824         while (itObj.hasNext()) {
825           super.logBean.setObj(itObj.next());
826           super.loggerAuditoria.info(logBean.toString());
827         }
828       }
829     } catch (HibernateException e) {
830       e.printStackTrace();
831       if (tx != null)
832         try {
833           tx.rollback();
834         } catch (HibernateException r) {
835           this.logger.error(r);
836           throw new ECARException("erro.hibernateException");
837         }
838       this.logger.error(e);
839       throw new ECARException("erro.hibernateException");
840     }
841   }
842 
843   public ItemEstruturaIett alterar(HttpServletRequest request, UsuarioUsu usuarioLogado, HistoricoIett historico) throws ECARException {
844     SegurancaECAR seguranca = (SegurancaECAR) request.getSession().getAttribute("seguranca");
845     return this.alterar(request, usuarioLogado, seguranca.getGruposAcesso(), historico);
846   }
847 
848   /**
849    * Altera um item estrutura com as funcoes de acompanhamento na mesma
850    * transação.
851    * @param request
852    * @param usuarioLogado
853    * @return ItemEstruturaIett
854    */
855   public ItemEstruturaIett alterar(HttpServletRequest request, UsuarioUsu usuarioLogado, Set gruposAcesso, HistoricoIett historico) throws ECARException {
856     Transaction tx = null;
857 
858     try {
859       ArrayList objetos = new ArrayList();
860       super.inicializarLogBean();
861 
862       tx = session.beginTransaction();
863       ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIett")));
864       ItemEstruturaIett old = (ItemEstruturaIett) itemEstrutura.clone();
865 
866       String indBloqPlanejamentoAnterior = itemEstrutura.getIndBloqPlanejamentoIett();
867       String indMonitoramentoAnterior = itemEstrutura.getIndMonitoramentoIett();
868 
869       itemEstrutura.getItemEstUsutpfuacIettutfas().size();
870       Set lFuac = itemEstrutura.getItemEstUsutpfuacIettutfas();
871 
872       /*** Historico ***/
873       historico.gerarHistorico(old);
874       /*** Historico ***/
875 
876       // Verifica se o planejamento está bloqueado
877       Boolean planejamentoBloqueado = false;
878       if (itemEstrutura.getIndBloqPlanejamentoIett() != null && itemEstrutura.getIndBloqPlanejamentoIett().equals("S")) {
879         planejamentoBloqueado = true;
880       }
881 
882       List funcoesDoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura, usuarioLogado, gruposAcesso);
883 
884       List funcoesBloqueadas = new ArrayList();
885       // Caso o planejamento esteja bloqueado, Busca as funções de
886       // acompanhamento que
887       // estão bloqueadas e adiciona elas na lista "funcoesBloqueadas".
888       if (planejamentoBloqueado) {
889         // Descobre a Estrutura do item
890         EstruturaEtt estrutura = itemEstrutura.getEstruturaEtt();
891         // Descobre as funções de acompanhamento de uma estrutura
892         Set funcoesAcomp = estrutura.getEstrutTpFuncAcmpEtttfas();
893         // Itera pelas funções buscando as que estão bloqueadas para alteração
894         if (funcoesAcomp != null) {
895           for (Iterator it = funcoesAcomp.iterator(); it.hasNext();) {
896             EstrutTpFuncAcmpEtttfa funcao = (EstrutTpFuncAcmpEtttfa) it.next();
897             if (funcao.iGetBloqueado() && (!podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, funcao, funcoesDoUsuario))) {
898               funcoesBloqueadas.add(funcao);
899             }
900           }
901         }
902       }
903 
904       List funcoesNaoAlteradas = new ArrayList();
905       // apagar as funcoes de acompanhamento do item
906       if (itemEstrutura.getItemEstUsutpfuacIettutfas() != null) {
907         Iterator it = itemEstrutura.getItemEstUsutpfuacIettutfas().iterator();
908         while (it.hasNext()) {
909           ItemEstUsutpfuacIettutfa obj = (ItemEstUsutpfuacIettutfa) it.next();
910           // Assume que a função está desbloqueada
911           Boolean podeAlterar = true;
912           // Itera entre as funções que estão bloqueadas. Só haverá valores
913           // nesta lista,
914           // caso o planejamento esteja bloqueado.
915           Iterator it2 = funcoesBloqueadas.iterator();
916           while (it2.hasNext()) {
917             EstrutTpFuncAcmpEtttfa funcaoBloqueada = (EstrutTpFuncAcmpEtttfa) it2.next();
918             // compara a função e verifica se a confiração está para bloqueada.
919             // Caso bloqueada, define que o usuário não pode ter alterado a
920             // função.
921             if (funcaoBloqueada.getComp_id().getCodTpfa().equals(obj.getComp_id().getCodTpfa())) {
922               podeAlterar = false;
923               break;
924             }
925           }
926           // Só remove do banco de dados as funções que o usuário poderia ter
927           // alterado.
928           if (podeAlterar) {
929             obj.setDataUltManutencao(Data.getDataAtual());
930             obj.setUsuManutencao(usuarioLogado);
931             // System.out.println("Deletou Função Acomp: " +
932             // obj.getTipoFuncAcompTpfa().getDescricaoTpfa());
933             session.delete(obj);
934             objetos.add(obj);
935           }
936           else {
937             funcoesNaoAlteradas.add(obj);
938           }
939         }
940       }
941 
942       // Verifica quais são os atributos livres vinculados a estrutura.
943       // Isto só é feito se o planejamento estiver bloqueado.
944       List sgas = new ArrayList();
945       if (planejamentoBloqueado) {
946         // busca os atributos livre configurados para o item em seu nível na
947         // estrutura
948         if (itemEstrutura.getEstruturaEtt() != null && itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats() != null && !itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats().isEmpty()) {
949           for (Iterator it = itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats().iterator(); it.hasNext();) {
950             EstruturaAtributoEttat ettat = (EstruturaAtributoEttat) it.next();
951             if (ettat.getAtributosAtb() != null && ettat.getAtributosAtb().getSisGrupoAtributoSga() != null) {
952               // verifica se o atributo livre esta configurado para estar
953               // bloqueado.
954               if (ettat.iGetBloqueado() && (!podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, ettat, funcoesDoUsuario))) {
955                 // System.out.println("Atributo Livre" +
956                 // ettat.getLabelEstruturaEttat());
957                 sgas.add(ettat.getAtributosAtb().getSisGrupoAtributoSga());
958               }
959             }
960           }
961         }
962       }
963 
964       // apagar os atributos livres do item
965       if (itemEstrutura.getItemEstruturaSisAtributoIettSatbs() != null) {
966         // busca os atributos livre configurados para este nível da estrutura
967         Iterator it = itemEstrutura.getItemEstruturaSisAtributoIettSatbs().iterator();
968         while (it.hasNext()) {
969           ItemEstruturaSisAtributoIettSatb obj = (ItemEstruturaSisAtributoIettSatb) it.next();
970           // assumo que o usuário poderia alterar este atributo.
971           Boolean podeAlterar = true;
972           if (planejamentoBloqueado) {
973             for (Iterator it2 = sgas.iterator(); it2.hasNext();) {
974               SisGrupoAtributoSga grupoAtributo = (SisGrupoAtributoSga) it2.next();
975               if (grupoAtributo.getCodSga().equals(obj.getSisAtributoSatb().getSisGrupoAtributoSga().getCodSga())) {
976                 // System.out.println("Atributo livre não editavel: " +
977                 // grupoAtributo.getDescricaoSga());
978                 podeAlterar = false;
979                 break;
980               }
981             }
982           }
983           if (podeAlterar) {
984             // System.out.println("Apagou Atributo Livre" +
985             // obj.getSisAtributoSatb().getDescricaoSatb());
986             session.delete(obj);
987             objetos.add(obj);
988           }
989         }
990       }
991 
992       // seta o novo item_estrutura
993       this.setItemEstrutura(request, itemEstrutura);
994       itemEstrutura.setUsuarioUsuByCodUsuUltManutIett(usuarioLogado);
995       itemEstrutura.setDataUltManutencaoIett(Data.getDataAtual());
996 
997       /*
998        * Salvar os atributos livres, pois agora já tenho o codIett
999        */
1000       List atributosLivres = this.getAtributosLivresItemEstrutura(request, itemEstrutura);
1001       for (Iterator it = atributosLivres.iterator(); it.hasNext();) {
1002         ItemEstruturaSisAtributoIettSatb atbLivre = (ItemEstruturaSisAtributoIettSatb) it.next();
1003         // System.out.println(atbLivre.getSisAtributoSatb().getCodSatb());
1004         session.save(atbLivre);
1005         objetos.add(atbLivre);
1006       }
1007 
1008       // Salva as Funções de acompanhamento do item.
1009       if (itemEstrutura.getItemEstUsutpfuacIettutfas() != null) {
1010         Iterator it = itemEstrutura.getItemEstUsutpfuacIettutfas().iterator();
1011         while (it.hasNext()) {
1012           PaiFilho object = (PaiFilho) it.next();
1013           object.atribuirPKPai();
1014           // salva os filhos
1015           session.save(object);
1016           objetos.add(object);
1017         }
1018       }
1019 
1020       // Seta no itemEstrutura as funções de acompanhamento que o usuário não
1021       // podia modificar.
1022       // para atualizar logo abaixo as permissões do item.
1023       Iterator it = funcoesNaoAlteradas.iterator();
1024       while (it.hasNext()) {
1025         itemEstrutura.getItemEstUsutpfuacIettutfas().add((ItemEstUsutpfuacIettutfa) it.next());
1026       }
1027 
1028       //
1029       // controlar as permissoes passando o item e a lista das funcoes de
1030       // acompanhamento antigas
1031       //
1032       new ControlePermissao().atualizarPermissoesItemEstrutura(itemEstrutura, lFuac, session, false, request);
1033 
1034       if (Dominios.SIM.equals(Pagina.getParamStr(request, "ativarRetirarMonitoramentoItensFilho"))) {
1035         if (indMonitoramentoAnterior != null && !indMonitoramentoAnterior.equals(itemEstrutura.getIndMonitoramentoIett())) {
1036           this.propagarMonitoramento(itemEstrutura, historico);
1037         }
1038       }
1039 
1040       if (indBloqPlanejamentoAnterior != null && !indBloqPlanejamentoAnterior.equals(itemEstrutura.getIndBloqPlanejamentoIett())) {
1041         this.propagarPlanejamento(itemEstrutura, historico);
1042       }
1043 
1044       // Salva o ItemEstrutura
1045       session.update(itemEstrutura);
1046       objetos.add(itemEstrutura);
1047 
1048       tx.commit();
1049 
1050       if (super.logBean != null) {
1051         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
1052         super.logBean.setOperacao("INC_ALT_EXC");
1053         Iterator itObj = objetos.iterator();
1054 
1055         while (itObj.hasNext()) {
1056           super.logBean.setObj(itObj.next());
1057           super.loggerAuditoria.info(logBean.toString());
1058         }
1059       }
1060 
1061       return itemEstrutura;
1062     } catch (Exception e) {
1063       e.printStackTrace();
1064       if (tx != null)
1065         try {
1066           tx.rollback();
1067         } catch (HibernateException r) {
1068           this.logger.error(r);
1069           throw new ECARException("erro.hibernateException");
1070         }
1071       this.logger.error(e);
1072       throw new ECARException("erro.hibernateException");
1073     }
1074   }
1075 
1076   /**
1077    * Método está sendo usado para excluir Item-estrutura-usuario-funcao-acomp de
1078    * um ItemEstrutura quando o item é excluido
1079    * @param itemEstrutura
1080    * @throws ECARException
1081    */
1082   public void excluirItemEstruturaTipoFuncaoAcomp(ItemEstruturaIett itemEstrutura) throws ECARException {
1083     List<ItemEstUsutpfuacIettutfa> filhos = new ArrayList<ItemEstUsutpfuacIettutfa>();
1084     if (itemEstrutura.getItemEstUsutpfuacIettutfas() != null) {
1085       for (Iterator it = itemEstrutura.getItemEstUsutpfuacIettutfas().iterator(); it.hasNext();) {
1086         ItemEstUsutpfuacIettutfa ieFun = (ItemEstUsutpfuacIettutfa) it.next();
1087         filhos.add(ieFun);
1088       }
1089       super.excluir(filhos);
1090     }
1091   }
1092 
1093   /**
1094    * Recebe um array contendo códigos de itens da estrutura e exclui todos os
1095    * registros. Todas os dados do item e todos os dados dos dependentes são
1096    * excluidos também
1097    * @param codigosParaExcluir
1098    * @throws ECARException
1099    */
1100   public void excluir(String[] codigosParaExcluir, UsuarioUsu usuario) throws ECARException {
1101     Transaction tx = null;
1102 
1103     try {
1104       ArrayList<ItemEstruturaIett> objetos = new ArrayList<ItemEstruturaIett>();
1105       super.inicializarLogBean();
1106       tx = session.beginTransaction();
1107 
1108       for (int i = 0; i < codigosParaExcluir.length; i++) {
1109         ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) buscar(ItemEstruturaIett.class, Long.valueOf(codigosParaExcluir[i]));
1110 
1111         ItemEstruturaIett old = (ItemEstruturaIett) itemEstrutura.clone();
1112 
1113         itemEstrutura.setDataUltManutencaoIett(Data.getDataAtual());
1114         itemEstrutura.setUsuarioUsuByCodUsuUltManutIett(usuario);
1115         itemEstrutura.setIndAtivoIett(Dominios.NAO);
1116 
1117         /******** Historico *********/
1118         HistoricoIett historico = new HistoricoIett(itemEstrutura, HistoricoIett.exclusao, session, new ConfiguracaoDao(request), request);
1119         historico.gerarHistorico(old);
1120         /******** Historico *********/
1121 
1122         session.update(itemEstrutura);
1123 
1124         objetos.add(itemEstrutura);
1125 
1126         List iettFilhos = this.getDescendentes(itemEstrutura, false);
1127 
1128         for (Iterator it = iettFilhos.iterator(); it.hasNext();) {
1129           ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
1130 
1131           old = (ItemEstruturaIett) itemEstruturaFilho.clone();
1132 
1133           /*** Historico ***/
1134           historico.gerarHistorico(old);
1135           /*** Historico ***/
1136 
1137           itemEstruturaFilho.setDataUltManutencaoIett(Data.getDataAtual());
1138           itemEstruturaFilho.setUsuarioUsuByCodUsuUltManutIett(usuario);
1139           itemEstruturaFilho.setIndAtivoIett(Dominios.NAO);
1140 
1141           session.update(itemEstruturaFilho);
1142 
1143           objetos.add(itemEstruturaFilho);
1144         }
1145 
1146       }
1147       tx.commit();
1148 
1149       if (super.logBean != null) {
1150         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
1151         super.logBean.setOperacao("EXC");
1152 
1153         for (Iterator itObj = objetos.iterator(); itObj.hasNext();) {
1154           Object element = (Object) itObj.next();
1155           super.logBean.setObj(element);
1156           super.loggerAuditoria.info(logBean.toString());
1157         }
1158       }
1159     } catch (HibernateException e) {
1160       if (tx != null)
1161         try {
1162           tx.rollback();
1163         } catch (HibernateException r) {
1164           this.logger.error(r);
1165           throw new ECARException("erro.hibernateException");
1166         }
1167       this.logger.error(e);
1168       throw new ECARException("erro.hibernateException");
1169     }
1170   }
1171 
1172   /**
1173    * Retorna uma lista com todos os itens de Estrutura acima de um dado Item
1174    * @param itemEstrutura
1175    * @return
1176    */
1177   public List getAscendentes(ItemEstruturaIett itemEstrutura) {
1178     List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
1179     while (itemEstrutura.getItemEstruturaIett() != null) {
1180       itemEstrutura = itemEstrutura.getItemEstruturaIett();
1181       retorno.add(itemEstrutura);
1182     }
1183     Collections.reverse(retorno);
1184     return retorno;
1185   }
1186 
1187   public ItemEstruturaIett getAscendenteMaximo(ItemEstruturaIett itemEstrutura) {
1188     while (itemEstrutura.getItemEstruturaIett() != null) {
1189       itemEstrutura = itemEstrutura.getItemEstruturaIett();
1190     }
1191     return itemEstrutura;
1192   }
1193 
1194   /**
1195    * Retorna uma lista com todos os itens de Estrutura acima de um dado Item
1196    * cujo nível mais alto da hierarquia é o itemPai passado como parâmetro
1197    * @param itemEstrutura
1198    * @return
1199    */
1200   public List getAscendentes(ItemEstruturaIett itemEstrutura, ItemEstruturaIett itemPai) {
1201     List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
1202     while (!itemEstrutura.equals(itemPai)) {
1203       itemEstrutura = itemEstrutura.getItemEstruturaIett();
1204       retorno.add(itemEstrutura);
1205     }
1206     Collections.reverse(retorno);
1207     return retorno;
1208   }
1209 
1210   /**
1211    * Retorna uma lista com todos os itens de Estrutura abaixo de um dado Item
1212    * @param itemEstrutura
1213    * @return
1214    */
1215   public List getDescendentes(ItemEstruturaIett itemEstrutura, boolean efetuarRefreshItemEstrutura) throws ECARException {
1216     List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
1217 
1218     if (efetuarRefreshItemEstrutura) {
1219       try {
1220         this.session.refresh(itemEstrutura);
1221       } catch (HibernateException e) {
1222         this.logger.error(e);
1223         throw new ECARException(e);
1224       }
1225     }
1226 
1227     if (itemEstrutura.getItemEstruturaIetts() != null) {
1228 
1229       for (Iterator it = itemEstrutura.getItemEstruturaIetts().iterator(); it.hasNext();) {
1230         ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
1231         if (!retorno.contains(itemEstruturaFilho))
1232           retorno.add(itemEstruturaFilho);
1233         retorno.addAll(this.getDescendentes(itemEstruturaFilho, efetuarRefreshItemEstrutura));
1234       }
1235     }
1236     return retorno;
1237   }
1238 
1239   /**
1240    * recupera descendentes com pojo (ItemEstruturaIettMin)
1241    */
1242   public List getDescendentesMin(ItemEstruturaIettMin itemEstrutura, boolean efetuarRefreshItemEstrutura) throws ECARException {
1243     List<ItemEstruturaIettMin> retorno = new ArrayList<ItemEstruturaIettMin>();
1244 
1245     if (efetuarRefreshItemEstrutura) {
1246       try {
1247         this.session.refresh(itemEstrutura);
1248       } catch (HibernateException e) {
1249         this.logger.error(e);
1250         throw new ECARException(e);
1251       }
1252     }
1253 
1254     if (itemEstrutura.getItemEstruturaIetts() != null) {
1255 
1256       for (ItemEstruturaIettMin itemEstruturaFilho : itemEstrutura.getItemEstruturaIetts()) {
1257         if (!retorno.contains(itemEstruturaFilho))
1258           retorno.add(itemEstruturaFilho);
1259         retorno.addAll(this.getDescendentesMin(itemEstruturaFilho, efetuarRefreshItemEstrutura));
1260       }
1261     }
1262     return retorno;
1263   }
1264 
1265   /**
1266    * Retorna uma lista com todos os itens de Estrutura abaixo de um dado Item -
1267    * Busca os itens no BD.
1268    * @param itemEstrutura
1269    * @return
1270    */
1271   @SuppressWarnings("unchecked")
1272   public List<ItemEstruturaIett> getDescendentesViaQry(ItemEstruturaIett itemEstrutura) throws ECARException {
1273     try {
1274       return this.getSession().createQuery("select iett from ItemEstruturaIett iett " + "where iett.itemEstruturaIett.codIett = :codPai " + "and iett.itemEstruturaIett.indAtivoIett = 'S'").setLong("codPai", itemEstrutura.getCodIett().longValue()).list();
1275 
1276     } catch (HibernateException e) {
1277       this.logger.error(e);
1278       throw new ECARException(e);
1279     }
1280   }
1281 
1282   /**
1283    * Retorna uma lista com todos os itens de Estrutura abaixo de um dado Item,
1284    * recursivamente. Verifica também se o usuário tem permissão para dado item.
1285    * Se não tem permissão para o item, verifica se tem para algum filho
1286    * @param itemEstrutura
1287    * @return
1288    */
1289   public List getDescendentesComPermissao(ItemEstruturaIett itemEstrutura, boolean efetuarRefreshItemEstrutura, UsuarioUsu usuario, Set gruposUsuario) throws ECARException {
1290     ValidaPermissao validaPermissao = new ValidaPermissao();
1291     List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
1292 
1293     if (efetuarRefreshItemEstrutura) {
1294       /*
1295        * faz um refresh no item para que não seja aproveitado o objeto existente
1296        * na session do Hibernate e termos um objeto com a coleçaõ de filhos
1297        * completa
1298        */
1299       try {
1300         this.session.refresh(itemEstrutura);
1301       } catch (HibernateException e) {
1302         this.logger.error(e);
1303         throw new ECARException(e);
1304       }
1305     }
1306 
1307     if (itemEstrutura.getItemEstruturaIetts() != null) {
1308 
1309       Iterator it = itemEstrutura.getItemEstruturaIetts().iterator();
1310       while (it.hasNext()) {
1311         ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
1312 
1313         if (!retorno.contains(itemEstruturaFilho)) {
1314           validaPermissao.permissoesItem(itemEstruturaFilho, usuario, gruposUsuario);
1315           if (validaPermissao.permissaoConsultarItem())
1316             retorno.add(itemEstruturaFilho);
1317         }
1318 
1319         retorno.addAll(this.getDescendentesComPermissao(itemEstruturaFilho, efetuarRefreshItemEstrutura, usuario, gruposUsuario));
1320       }
1321     }
1322     return retorno;
1323   }
1324 
1325   /**
1326    * Retorna uma lista com todos os itens de Estrutura abaixo de um dado Item
1327    * que sejam de um dos níveis de palenjamento passados como parâmetros na
1328    * Lista
1329    * @param itemEstrutura
1330    * @return
1331    */
1332   public List getDescendentesPorNivelPlanejamento(ItemEstruturaIett itemEstrutura, List niveisPlanejamento) throws ECARException {
1333     List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
1334 
1335     try {
1336       this.session.refresh(itemEstrutura);
1337     } catch (HibernateException e) {
1338       this.logger.error(e);
1339       throw new ECARException(e);
1340     }
1341 
1342     if (itemEstrutura.getItemEstruturaIetts() != null) {
1343       for (Iterator it = itemEstrutura.getItemEstruturaIetts().iterator(); it.hasNext();) {
1344         ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
1345         if (!retorno.contains(itemEstruturaFilho) && Util.intersecao(itemEstruturaFilho.getItemEstruturaNivelIettns(), niveisPlanejamento).size() > 0) {
1346           retorno.add(itemEstruturaFilho);
1347         }
1348         retorno.addAll(this.getDescendentesPorNivelPlanejamento(itemEstruturaFilho, niveisPlanejamento));
1349       }
1350     }
1351     return retorno;
1352   }
1353 
1354   /**
1355    * Retorna os Itens filhos de um Item cujo nível seja no máximo nivel pai +
1356    * (nivel)
1357    * @param itemEstrutura
1358    * @param nivel
1359    * @return
1360    */
1361   public List getDescendentes(ItemEstruturaIett itemEstrutura, int nivel) throws ECARException {
1362     List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
1363     int nivelMaximo = nivel + itemEstrutura.getNivelIett().intValue();
1364     if (itemEstrutura.getItemEstruturaIetts() != null) {
1365       for (Iterator it = itemEstrutura.getItemEstruturaIetts().iterator(); it.hasNext();) {
1366         ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
1367         if (itemEstruturaFilho.getNivelIett().intValue() <= nivelMaximo && !retorno.contains(itemEstruturaFilho))
1368           retorno.add(itemEstruturaFilho);
1369         retorno.addAll(this.getDescendentes(itemEstruturaFilho, true));
1370       }
1371     }
1372     return retorno;
1373   }
1374 
1375   /**
1376    * Devolve uma lista de itens da estrutura ordenados (estrutura + primeiro
1377    * campo da listagem de colunas da estrutura) e somente os itens que o usuário
1378    * pode consultar.
1379    * @param ItemEstruturaIett itemEstrutura
1380    * @param UsuarioUsu usuarioUsu
1381    * @param Set gruposUsuario
1382    * @return List
1383    */
1384   public List getDescendentesComPermissoesOrdenado(ItemEstruturaIett itemEstrutura, UsuarioUsu usuarioUsu, Set gruposUsuario) throws ECARException {
1385     ValidaPermissao validaPermissao = new ValidaPermissao();
1386     List retorno = new ArrayList();
1387 
1388     /*
1389      * 1.Obter um conjunto de estrutura do item passado como parâmetro
1390      * (EstruturaDao.getSetEstruturasItem(item);)
1391      */
1392     EstruturaDao estruturaDao = new EstruturaDao(request);
1393     List itens = estruturaDao.getSetEstruturasItem(itemEstrutura);
1394 
1395     /* 2.Para cada estrutura 'e' obtida no passo anterior */
1396 
1397     Iterator itEstrutura = itens.iterator();
1398     while (itEstrutura.hasNext()) {
1399       EstruturaEtt e = (EstruturaEtt) itEstrutura.next();
1400 
1401       /*
1402        * 3.Obter as colunas dessa estrutura
1403        * (EstruturaDao.getAtributosAcessoEstrutura('e');)
1404        */
1405       List atributos = estruturaDao.getAtributosAcessoEstrutura(e);
1406       if (atributos != null && atributos.size() > 0) {
1407         ObjetoEstrutura objeto = (ObjetoEstrutura) atributos.get(0); // primeira
1408                                                                      // coluna
1409                                                                      // obtida
1410 
1411         /*
1412          * 4.Obter os itens filhos da estrutura 'e', ordenados pela primeira
1413          * coluna obtida no passo anterior;
1414          * ItemEstruturaDao.getItensFilhos(item, 'e',
1415          * ObjetoEstrutura.iGetNomeOrdenarLista())
1416          */
1417         List itensFilhos = getItensFilho(itemEstrutura, e, objeto.iGetNomeOrdenarLista());
1418 
1419         /* 5.Para cada item 'it' obtido no passo anterior */
1420         Iterator itFilhos = itensFilhos.iterator();
1421         while (itFilhos.hasNext()) {
1422           ItemEstruturaIett itemFilho = (ItemEstruturaIett) itFilhos.next();
1423 
1424           /*
1425            * 6.Obter a permissao do usuario para este item
1426            * (ValidaPermissao.permissoesItem('it', usuario, grupos);
1427            */
1428           validaPermissao.permissoesItem(itemFilho, usuarioUsu, gruposUsuario);
1429 
1430           /* 7.Se validaPermissao.permissaoConsultarItem() */
1431           if (validaPermissao.permissaoConsultarItem()) {
1432             /* 8.Adiciona o item 'it' na lista de retorno */
1433             retorno.add(itemFilho);
1434             /*
1435              * 9.Chama o método recursivamente
1436              * (getDescendentesComPermissoesOrdenado('it', usuario, grupos);)
1437              */
1438             retorno.addAll(getDescendentesComPermissoesOrdenado(itemFilho, usuarioUsu, gruposUsuario));
1439           }
1440         }
1441       }
1442     }
1443     return retorno;
1444   }
1445 
1446   /**
1447    * Devolve uma lista de itens da estrutura ordenados (estrutura + primeiro
1448    * campo da listagem de colunas da estrutura) e somente os itens que o usuário
1449    * pode consultar por estrutura.
1450    * @param estrutura
1451    * @param usuarioUsu
1452    * @param gruposUsuario
1453    * @return
1454    * @throws ECARException
1455    */
1456   public List getDescendentesComPermissoesOrdenadoByEstrutura(EstruturaEtt estrutura, long codItemPai, UsuarioUsu usuarioUsu, Set gruposUsuario) throws ECARException {
1457     ValidaPermissao validaPermissao = new ValidaPermissao();
1458     List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
1459     try {
1460       String select = "select iett from ItemEstruturaIett iett" + " where iett.estruturaEtt.codEtt = :codEstrutura" + " and iett.indAtivoIett = 'S'";
1461 
1462       if (codItemPai != 0) {
1463         select += " and iett.itemEstruturaIett.codIett = :codPai";
1464       }
1465 
1466       Query q = this.session.createQuery(select);
1467       q.setLong("codEstrutura", estrutura.getCodEtt().longValue());
1468 
1469       if (codItemPai != 0) {
1470         q.setLong("codPai", codItemPai);
1471       }
1472 
1473       List itensEstrutura = q.list();
1474 
1475       if (itensEstrutura != null && !itensEstrutura.isEmpty()) {
1476         for (Iterator itEtt = itensEstrutura.iterator(); itEtt.hasNext();) {
1477           ItemEstruturaIett iett = (ItemEstruturaIett) itEtt.next();
1478           validaPermissao.permissoesItem(iett, usuarioUsu, gruposUsuario);
1479           if (validaPermissao.permissaoConsultarItem()) {
1480             retorno.add(iett);
1481             retorno.addAll(this.getDescendentesComPermissoesOrdenado(iett, usuarioUsu, gruposUsuario));
1482           }
1483         }
1484       }
1485     } catch (HibernateException e) {
1486       this.logger.error(e);
1487       throw new ECARException(e);
1488     }
1489 
1490     return retorno;
1491   }
1492 
1493   /**
1494    * Retorna um list com identificações de todas os Atributos de Nível de Acesso
1495    * de um item
1496    * @param situacao
1497    * @return List de Long
1498    */
1499   public ArrayList getNivelAcessoById(ItemEstruturaIett item) {
1500     /*
1501      * comentado bug #880 A idéia é que os níveis de acesso venham na ordem da
1502      * maneira que está cadastrado no grupo de atributos, ou seja, por
1503      * informações complementares. Do jeito que está vem em qualquer ordem. List
1504      * lNiveis = new ArrayList(); if(item.getItemEstruturaNivelIettns()!= null
1505      * && item.getItemEstruturaNivelIettns().size() > 0){ Iterator it =
1506      * item.getItemEstruturaNivelIettns().iterator(); while(it.hasNext()){
1507      * SisAtributoSatb atributo = (SisAtributoSatb) it.next();
1508      * lNiveis.add(atributo.getCodSatb()); } } return lNiveis;
1509      */
1510 
1511     // obter os niveis de acesso do item na ordem
1512     List lNiveis = getNivelAcesso(item);
1513     ArrayList<Long> resultado = new ArrayList<Long>();
1514 
1515     // extrair os códigos
1516     for (Iterator iter = lNiveis.iterator(); iter.hasNext();) {
1517       SisAtributoSatb atributo = (SisAtributoSatb) iter.next();
1518       resultado.add(atributo.getCodSatb());
1519     }
1520     return resultado;
1521   }
1522 
1523   /**
1524    * Retorna um list com os os Atributos de Nível de Acesso de um item
1525    * @param situacao
1526    * @return List de SisAtributoSatb
1527    */
1528   public List getNivelAcesso(ItemEstruturaIett item) {
1529     /*
1530      * comentando por causa do bug 880; List lNiveis = new ArrayList();
1531      * if(item.getItemEstruturaNivelIettns()!= null &&
1532      * item.getItemEstruturaNivelIettns().size() > 0){ Iterator it =
1533      * item.getItemEstruturaNivelIettns().iterator(); while(it.hasNext()){
1534      * SisAtributoSatb atributo = (SisAtributoSatb) it.next();
1535      * lNiveis.add(atributo); } } return lNiveis;
1536      */
1537 
1538     /*
1539      * funcionamento: 1. Determinar um atributo do nivel de acesso para obter o
1540      * grupo de atributos; 2. a partir do grupo obter todos os atributos
1541      * ordenados; 3. retirar do resultado de 2 os atributos que não fazem parte
1542      * do item
1543      */
1544 
1545     List lNiveis = new ArrayList();
1546     if (item.getItemEstruturaNivelIettns() != null && item.getItemEstruturaNivelIettns().size() > 0) {
1547       // 1.
1548       SisGrupoAtributoSga grupoAtributo = ((SisAtributoSatb) item.getItemEstruturaNivelIettns().iterator().next()).getSisGrupoAtributoSga();
1549 
1550       try {
1551         // 2.
1552         lNiveis = new SisGrupoAtributoDao().getAtributosOrdenados(grupoAtributo);
1553 
1554         // 3.
1555         lNiveis.retainAll(item.getItemEstruturaNivelIettns());
1556 
1557       } catch (ECARException e) {
1558         this.logger.error(e);
1559       }
1560     }
1561 
1562     return lNiveis;
1563 
1564   }
1565 
1566   /**
1567    * Devolve uma Lista com todos os itens filho do item passado que sejam da
1568    * estrutura passada como parâmetro. Caso o item seja nulo, retorna uma
1569    * Collection com os itens que pertencem a estrutura passada como parâmetro.
1570    * Recebe como argumento o item, a estrutura e o nome do campo pelo qual se
1571    * deseja ordenar a lista
1572    * @param item
1573    * @param estrutura
1574    * @return List de itemEstruturaIett
1575    * @throws ECARException
1576    */
1577   public List getItensFilho(ItemEstruturaIett item, EstruturaEtt estrutura, String nomeCampoOrderBy) throws ECARException {
1578     List lista = new ArrayList();
1579     String nomeOrder;
1580 
1581     /*
1582      * assume um default quando nao pode mapear o campo para ordenar no cadastro
1583      * de itens por exemplo, quando colocar a primeira coluna com uma funcao de
1584      * acompanhamento
1585      */
1586     if (nomeCampoOrderBy == null || "".equals(nomeCampoOrderBy))
1587       nomeOrder = "this.nomeIett";
1588     else
1589       nomeOrder = "this." + nomeCampoOrderBy;
1590 
1591     try {
1592       if (item != null) {
1593         lista.addAll(this.getSession().createFilter(item.getItemEstruturaIetts(), "where this.estruturaEtt.codEtt = " + estrutura.getCodEtt() + " order by " + nomeOrder).list());
1594       }
1595       else {
1596         lista.addAll(this.getSession().createFilter(estrutura.getItemEstruturaIetts(), "order by " + nomeOrder).list());
1597       }
1598       return lista;
1599     } catch (HibernateException e) {
1600       this.logger.error(e);
1601       throw new ECARException(e);
1602     }
1603   }
1604 
1605   /**
1606    * Devolve uma Lista com todos os itens filho do item passado que sejam da
1607    * estrutura passada como parâmetro, ordenados conforme a ordem de
1608    * apresentação das colunas (campos) da lista de colunas.
1609    * @author aleixo
1610    * @since 26/06/2007
1611    * @param item
1612    * @param estrutura
1613    * @param colunas
1614    * @return List
1615    * @throws ECARException
1616    */
1617   public List getItensFilho(ItemEstruturaIett item, EstruturaEtt estrutura, List colunas) throws ECARException {
1618     List lista = new ArrayList();
1619     List<OrdenacaoIett> listaOrdem = new ArrayList<OrdenacaoIett>();
1620 
1621     Set itensFilhos = (item != null) ? item.getItemEstruturaIetts() : estrutura.getItemEstruturaIetts();
1622     if (itensFilhos != null && !itensFilhos.isEmpty()) {
1623       int tamanho = this.getTamanhoMaximoCampo(colunas, itensFilhos);
1624 
1625       for (Iterator it = itensFilhos.iterator(); it.hasNext();) {
1626         ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
1627 
1628         if (!iett.getEstruturaEtt().equals(estrutura)) {
1629           continue;
1630         }
1631 
1632         OrdenacaoIett ordem = new OrdenacaoIett();
1633         ordem.setIett(iett);
1634 
1635         String campo = "";
1636         if (colunas != null && !colunas.isEmpty()) {
1637           for (Iterator it2 = colunas.iterator(); it2.hasNext();) {
1638             ObjetoEstrutura atb = (ObjetoEstrutura) it2.next();
1639             String valor = this.getValorAtributoItemEstrutura(iett, atb.iGetNome(), atb.iGetNomeFk());
1640             Date data = Data.parseDate(valor, "dd/MM/yyyy");
1641             if (data != null) { // É campo data!
1642               // Conseguiu converter para objeto Date!!!
1643               int d = Data.getDia(data);
1644               int m = Data.getMes(data) + 1;
1645               int a = Data.getAno(data);
1646               String dia = (d < 10) ? "0" + String.valueOf(d) : String.valueOf(d);
1647               String mes = (m < 10) ? "0" + String.valueOf(m) : String.valueOf(m);
1648               String ano = String.valueOf(a);
1649 
1650               valor = ano + mes + dia;
1651             }
1652 
1653             campo += this.completarParaOrdenacao(valor, tamanho);
1654           }
1655         }
1656         else {
1657           campo = this.completarParaOrdenacao(iett.getNomeIett(), tamanho);
1658         }
1659 
1660         ordem.setCampoOrdenar(campo.toUpperCase());
1661 
1662         listaOrdem.add(ordem);
1663       }
1664 
1665     }
1666     // Ordenando pelo campo de ordenação
1667     Collections.sort(listaOrdem, new Comparator() {
1668 
1669       public int compare(Object arg0, Object arg1) {
1670         OrdenacaoIett o1 = (OrdenacaoIett) arg0;
1671         OrdenacaoIett o2 = (OrdenacaoIett) arg1;
1672 
1673         return o1.getCampoOrdenar().compareTo(o2.getCampoOrdenar());
1674       }
1675 
1676     });
1677 
1678     for (OrdenacaoIett o : listaOrdem) {
1679       lista.add(o.getIett());
1680     }
1681 
1682     return lista;
1683   }
1684 
1685   /**
1686    * Retorna o tamanho máximo da string dos valores de uma lista de campos numa
1687    * lista de itens.
1688    * @author aleixo
1689    * @since 26/06/2007
1690    * @param colunas
1691    * @param itens
1692    * @return
1693    * @throws ECARException
1694    */
1695   public int getTamanhoMaximoCampo(List colunas, Set itens) throws ECARException {
1696     int tam = 0;
1697     for (Iterator it = itens.iterator(); it.hasNext();) {
1698       ItemEstruturaIett item = (ItemEstruturaIett) it.next();
1699 
1700       if (colunas != null && !colunas.isEmpty()) {
1701         for (Iterator it2 = colunas.iterator(); it2.hasNext();) {
1702           ObjetoEstrutura atb = (ObjetoEstrutura) it2.next();
1703           String valor = this.getValorAtributoItemEstrutura(item, atb.iGetNome(), atb.iGetNomeFk());
1704 
1705           if (valor != null) {
1706             if (valor.length() > tam) {
1707               tam = valor.length();
1708             }
1709           }
1710         }
1711       }
1712       else {
1713         String valor = item.getNomeIett();
1714         if (valor != null) {
1715           if (valor.length() > tam) {
1716             tam = valor.length();
1717           }
1718         }
1719       }
1720 
1721     }
1722     return tam;
1723   }
1724 
1725   /**
1726    * @param lItens
1727    * @param indConclusao
1728    * @return List
1729    */
1730   public List getItensIndConclusao(List lItens, String indConclusao) {
1731     ArrayList<ItemEstruturaIett> lItensIndConclusao = new ArrayList<ItemEstruturaIett>();
1732     Iterator itLista = lItens.iterator();
1733     if ("T".equals(indConclusao))
1734       return lItens;
1735     else {
1736       while (itLista.hasNext()) {
1737         ItemEstruturaIett item = (ItemEstruturaIett) itLista.next();
1738         if ("C".equals(indConclusao)) {
1739           if (item.getSituacaoSit() != null && "S".equals(item.getSituacaoSit().getIndConcluidoSit())) {
1740             lItensIndConclusao.add(item);
1741           }
1742         }
1743         else {
1744           if (item.getSituacaoSit() == null || !"S".equals(item.getSituacaoSit().getIndConcluidoSit().toString())) {
1745             lItensIndConclusao.add(item);
1746           }
1747         }
1748       }
1749     }
1750     return lItensIndConclusao;
1751   }
1752 
1753   /**
1754    * Select para descobrir os itens selecionáveis. Item Selecionável é o que:
1755    * (1) Possui ind_monitoramento = 'S' caso a seleção seja por itens EM
1756    * MONITORAMENTO ou possui Órgão Responavel 1 ou 2 igual ao Órgçao escolhido
1757    * em um seleção POR ÒRGÃO e (2) Possui alguma função de acompanhamento que
1758    * ind_emite_posicao = 'S' ou informa_andamento = 'S' OU (3) Possui quantidade
1759    * Prevista Cadstrada e (4) O item ainda nao terminou (data atual <= data de
1760    * termino) ALGORITMO: X = itens do select; Z = { }; para cada i em X { L = i
1761    * sem os filhos + ascendentes de i sem os filhos (caso já nao tenha limpado
1762    * os filhos); aux = L.primeiroDaLista; ultimo = null; enquanto ( aux != null
1763    * ) { filhos = aux.getFilhos(); se ( !filhos.contains( ultimo ) ){
1764    * filhos.add(ultimo) aux.setFilhos(filhos); } ultimo = aux; aux =
1765    * aux.getPai(); } se (! Z.cotains(ultimo) ) Z.add(ultimo); } return X, Z
1766    * Mostra em tela todos de Z Item é selecionavel se está contido em X. <br>
1767    * @author N/C, rogerio
1768    * @since N/C
1769    * @version 0.2, 19/03/2007
1770    * @param OrgaoOrg orgao
1771    * @param AcompReferenciaAref acompReferencia
1772    * @param List listNiveis
1773    * @param String indMonitoramento
1774    * @return List
1775    * @throws ECARException
1776    */
1777 
1778   private List getItensSelecionaveisGeracaoPeriodoReferencia(OrgaoOrg orgao, AcompReferenciaAref acompReferencia, List listNiveis, String indMonitoramento) throws ECARException {
1779 
1780     try {
1781       StringBuilder query = new StringBuilder("select distinct item from ItemEstruturaIett as item").append(" join item.itemEstUsutpfuacIettutfas as itemFuncao");
1782 
1783       query.append(" left join item.itemEstrtIndResulIettrs as indResultados");
1784       query.append(" where ");
1785       query.append(" item.indAtivoIett = 'S' AND ");
1786       query.append(" (itemFuncao.tipoFuncAcompTpfa.indInformaAndamentoTpfa='S' ");
1787 
1788       query.append("   OR itemFuncao.tipoFuncAcompTpfa.indEmitePosicaoTpfa='S')");
1789 
1790       // FIXME: Não funcionou no Hibernate 3
1791       // query.append(" AND (item.situacaoSit is null ");
1792       // query.append("       OR (item.situacaoSit is not null AND item.situacaoSit.indConcluidoSit != 'S'))");;
1793 
1794       if (!"".equals(indMonitoramento)) {
1795         query.append(" AND item.indMonitoramentoIett = :indMonitoramento");
1796       }
1797 
1798       List listaCodSatb = new ArrayList();
1799       if (listNiveis != null && listNiveis.size() > 0) {
1800         query.append(" AND (");
1801         // int cont = 0;
1802 
1803         Iterator itNiveis = listNiveis.iterator();
1804         while (itNiveis.hasNext()) {
1805           SisAtributoSatb nivel = (SisAtributoSatb) itNiveis.next();
1806 
1807           listaCodSatb.add(nivel.getCodSatb());
1808           // query.append("niveis = " + nivel.getCodSatb().toString());
1809 
1810           // if((cont + 1) < listNiveis.size()) {
1811           // query.append(" OR ");
1812           // }
1813           // cont++;
1814         }
1815         query.append("item.itemEstruturaNivelIettns.codSatb in (:listaNiveis) ");
1816         query.append(") ");
1817       }
1818 
1819       if (orgao != null) {
1820         query.append(" AND item.orgaoOrgByCodOrgaoResponsavel1Iett.codOrg = :codOrg");
1821       }
1822 
1823       Query queryItens = this.getSession().createQuery(query.toString());
1824 
1825       if (!"".equals(indMonitoramento)) {
1826         queryItens.setString("indMonitoramento", indMonitoramento);
1827       }
1828       if (orgao != null) {
1829         queryItens.setLong("codOrg", orgao.getCodOrg().longValue());
1830       }
1831       if (!listaCodSatb.isEmpty()) {
1832         queryItens.setParameterList("listaNiveis", listaCodSatb);
1833       }
1834 
1835       List itens = queryItens.list();
1836 
1837       for (Iterator itItens = itens.iterator(); itItens.hasNext();) {
1838         ItemEstruturaIett iett = (ItemEstruturaIett) itItens.next();
1839         if (iett.getSituacaoSit() != null && ("S".equals(iett.getSituacaoSit().getIndConcluidoSit()) || "S".equals(iett.getSituacaoSit().getIndSemAcompanhamentoSit()))) {
1840           itItens.remove();
1841         }
1842         else {
1843           // verificar o pai do item (Mantis: 7507)
1844 
1845           ItemEstruturaIett itemPai = iett.getItemEstruturaIett();
1846           if (itemPai != null && (itemPai.getSituacaoSit() != null && ("S".equals(itemPai.getSituacaoSit().getIndConcluidoSit()) || "S".equals(itemPai.getSituacaoSit().getIndSemAcompanhamentoSit())))) {
1847             itItens.remove();
1848           }
1849         }
1850       }
1851 
1852       // Mantis 5257: Filtrar os itens conforme associação de função de
1853       // acompanhamento (obrigatória/opcional) e tipo de acompanhamento.
1854       // Gerar acompanhamento para as funções obrigatórias e opcionais se o item
1855       // possuir a(s) função(ões) obrigatória(s)
1856       // de acordo com o tipo de acompanhamento
1857 
1858       List<TipoFuncAcompTpfa> funcaoAcompanhamentoObrigatoria = new ArrayList<TipoFuncAcompTpfa>();
1859       List<TipoFuncAcompTpfa> funcaoAcompanhamentoOpcional = new ArrayList<TipoFuncAcompTpfa>();
1860 
1861       TipoAcompanhamentoTa tipoAcompanhamento = (TipoAcompanhamentoTa) buscar(TipoAcompanhamentoTa.class, acompReferencia.getTipoAcompanhamentoTa().getCodTa());
1862 
1863       if (tipoAcompanhamento != null) {
1864 
1865         for (Iterator it = tipoAcompanhamento.getTipoAcompFuncAcompTafcs().iterator(); it.hasNext();) {
1866           TipoAcompFuncAcompTafc tafc = (TipoAcompFuncAcompTafc) it.next();
1867           if ("S".equalsIgnoreCase(tafc.getIndObrigatorio())) {
1868             funcaoAcompanhamentoObrigatoria.add(tafc.getTipoFuncAcompTpfa());
1869           }
1870           else if ("S".equalsIgnoreCase(tafc.getIndOpcional())) {
1871             funcaoAcompanhamentoOpcional.add(tafc.getTipoFuncAcompTpfa());
1872           }
1873         }
1874       }
1875 
1876       if (!funcaoAcompanhamentoObrigatoria.isEmpty() || !funcaoAcompanhamentoOpcional.isEmpty()) {
1877         Iterator itItens = itens.iterator();
1878         while (itItens.hasNext()) {
1879           ItemEstruturaIett iett = (ItemEstruturaIett) itItens.next();
1880 
1881           List<TipoFuncAcompTpfa> tpfaIett = new ArrayList<TipoFuncAcompTpfa>();
1882 
1883           if (iett.getItemEstUsutpfuacIettutfas() != null) {
1884             Iterator it = iett.getItemEstUsutpfuacIettutfas().iterator();
1885             while (it.hasNext()) {
1886               ItemEstUsutpfuacIettutfa iettutfa = (ItemEstUsutpfuacIettutfa) it.next();
1887 
1888               tpfaIett.add(iettutfa.getTipoFuncAcompTpfa());
1889             }
1890           }
1891 
1892           if (!funcaoAcompanhamentoObrigatoria.isEmpty()) {
1893             if (!tpfaIett.containsAll(funcaoAcompanhamentoObrigatoria)) {
1894               itItens.remove();
1895             }
1896 
1897             // como o item possui todas as funções de acompanhamento
1898             // obrigatórias ignorar a regra de opcionais
1899             continue;
1900           }
1901 
1902           if (!funcaoAcompanhamentoOpcional.isEmpty()) {
1903             boolean validacaoOpcionalOk = false;
1904             Iterator it = tpfaIett.iterator();
1905 
1906             while (it.hasNext()) {
1907               TipoFuncAcompTpfa tpfa = (TipoFuncAcompTpfa) it.next();
1908 
1909               if (funcaoAcompanhamentoOpcional.contains(tpfa)) {
1910                 validacaoOpcionalOk = true;
1911 
1912                 break;
1913               }
1914             }
1915 
1916             if (!validacaoOpcionalOk) {
1917               itItens.remove();
1918             }
1919           }
1920         }
1921       }
1922 
1923       if (acompReferencia.getCodAref() != null) {
1924         List itensBanco = new AcompReferenciaItemDao(request).getListaItensAcompanhamento(acompReferencia);
1925         if (itensBanco != null) {
1926           Iterator it = itensBanco.iterator();
1927           while (it.hasNext()) {
1928             ItemEstruturaIett itemBanco = (ItemEstruturaIett) it.next();
1929             if (!itens.contains(itemBanco))
1930               itens.add(itemBanco);
1931           }
1932         }
1933 
1934       }
1935 
1936       return itens;
1937     } catch (HibernateException e) {
1938       this.logger.error(e);
1939       throw new ECARException(e);
1940     }
1941 
1942   }
1943 
1944   /**
1945    * Método devolve duas listas para serem usadas na construção da tela de
1946    * seleção de Itens da Estrutura para Geração de Período de Referência. A
1947    * primiera com os itens que são selecionáveis, ou seja, permitem
1948    * acompanhamento) e outra com os que devem ser mostrados em tela para a
1949    * construção da hierarquia correta (inclui os selecionaveis). <br>
1950    * @author N/C, rogerio
1951    * @since N/C
1952    * @version 0.2, 19/03/2007
1953    * @param OrgaoOrg orgao
1954    * @param AcompReferenciaAref acompReferencia
1955    * @param Set gruposUsuario
1956    * @param String tipoAcesso
1957    * @param List listNiveis
1958    * @param List<TipoFuncAcompTpfa> listTpfa
1959    * @return List[]
1960    * @throws ECARException
1961    */
1962   public List[] getItensGerarAcompanhamento(OrgaoOrg orgao, AcompReferenciaAref acompReferencia, Set gruposUsuario, String tipoAcesso, List listNiveis) throws ECARException {
1963 
1964     ValidaPermissao validaPermissao = new ValidaPermissao();
1965     List[] retorno = new List[2];
1966 
1967     String indMonitoramento = "";
1968 
1969     if ("S".equals(acompReferencia.getTipoAcompanhamentoTa().getIndMonitoramentoTa()) && "N".equals(acompReferencia.getTipoAcompanhamentoTa().getIndNaoMonitoramentoTa())) {
1970       indMonitoramento = "S";
1971     }
1972     else if ("N".equals(acompReferencia.getTipoAcompanhamentoTa().getIndMonitoramentoTa()) && "S".equals(acompReferencia.getTipoAcompanhamentoTa().getIndNaoMonitoramentoTa())) {
1973       indMonitoramento = "N";
1974     }
1975 
1976     // Método exclui da lista de selecionáveis o itens que o usuário não tem
1977     // acesso
1978     List selecionaveis = getItensSelecionaveisGeracaoPeriodoReferencia(orgao, acompReferencia, listNiveis, indMonitoramento);
1979     /*
1980      * List selecionaveis = validaPermissao.removeItensSemAcessoElaboracaoAcomp(
1981      * getItensSelecionaveisGeracaoPeriodoReferencia(orgao, acompReferencia,
1982      * listNiveis, indMonitoramento), gruposUsuario, tipoAcesso,
1983      * acompReferencia.getTipoAcompanhamentoTa());
1984      */
1985 
1986     retorno[0] = getItensOrdenados(selecionaveis, acompReferencia.getTipoAcompanhamentoTa());
1987     retorno[1] = selecionaveis;
1988 
1989     return retorno;
1990   }
1991 
1992   /**
1993    * Ordena uma lista de objetos item estrutura, fazendo com que os itens no
1994    * mesmo nivel da hierarquia fiquem organizados alfabeticamente
1995    * @param itens
1996    */
1997   public void ordenaListaItemEstrutura(List itens) {
1998 
1999     Collections.sort(itens, new Comparator() {
2000       public int compare(Object o1, Object o2) {
2001         ItemEstruturaIett item1 = (ItemEstruturaIett) o1;
2002         ItemEstruturaIett item2 = (ItemEstruturaIett) o2;
2003         if (getAscendenteMaximo(item1).equals(getAscendenteMaximo(item2))) {
2004           if (item1.getNivelIett().intValue() == item2.getNivelIett().intValue()) {
2005             return item1.getNomeIett().compareToIgnoreCase(item2.getNomeIett());
2006           }
2007           else {
2008             return item1.getNivelIett().intValue() - item2.getNivelIett().intValue();
2009           }
2010         }
2011         else {
2012           if (item1.getNivelIett().intValue() == item2.getNivelIett().intValue()) {
2013             return item1.getNomeIett().compareToIgnoreCase(item2.getNomeIett());
2014           }
2015           else {
2016             return getAscendenteMaximo(item1).getNomeIett().compareToIgnoreCase(getAscendenteMaximo(item2).getNomeIett());
2017           }
2018         }
2019       }
2020     });
2021 
2022   }
2023 
2024   /**
2025    * Recebe uma lista de itens e adiciona na lista outros itens de modo a
2026    * completar a hierarquia necessária para apresentação da árvore de itens em
2027    * tela Se itemPai for utilizado, é montada a árvore até seu nível. Caso não
2028    * seja necessário passar itemPai = null
2029    * @param itens
2030    * @param itemPai
2031    * @return
2032    */
2033   public ArrayList getArvoreItens(List<ItemEstruturaIett> itens, ItemEstruturaIett itemPai) throws ECARException {
2034     Set<ItemEstruturaIett> retorno = new HashSet<ItemEstruturaIett>();
2035     for (ItemEstruturaIett item : itens) {
2036       List<ItemEstruturaIett> ascendentes = new ArrayList<ItemEstruturaIett>();
2037       if (itemPai != null) {
2038         ascendentes.addAll(getAscendentes(item, itemPai));
2039       }
2040       else {
2041         ascendentes.addAll(getAscendentes(item));
2042       }
2043       ascendentes.add(item);
2044       retorno.addAll(ascendentes);
2045     }
2046     return new ArrayList<ItemEstruturaIett>(retorno);
2047   }
2048 
2049   /**
2050    * @param itens
2051    * @param itemPai
2052    * @return List
2053    * @throws ECARException
2054    */
2055   public List getArvoreItensPesquisaEstrutura(List itens, ItemEstruturaIett itemPai) throws ECARException {
2056     List itensTemp = new ArrayList(itens);
2057 
2058     Set retorno = new HashSet();
2059     Iterator it = itens.iterator();
2060 
2061     while (it.hasNext()) {
2062       ItemEstruturaIett item = (ItemEstruturaIett) it.next();
2063 
2064       /*
2065        * Foi utilizado um refresh no item, pois quando utilizado com a pesquisa
2066        * na estrutura depois de passada a lista para montar a árvore, gerava
2067        * erro de lazy, alguns filhos já não estavam persistentes.
2068        */
2069       try {
2070         this.session.refresh(item);
2071       } catch (HibernateException e) {
2072         this.logger.error(e);
2073         throw new ECARException(e);
2074       }
2075 
2076       List ascendentes = new ArrayList();
2077 
2078       if (itemPai != null) {
2079         ascendentes.addAll(getAscendentes(item, itemPai));
2080       }
2081       else {
2082         ascendentes.addAll(getAscendentes(item));
2083       }
2084 
2085       ascendentes.add(item);
2086 
2087       retorno.addAll(ascendentes);
2088     }
2089 
2090     List itensParaExibicao = this.getItensOrdenadosPorSiglaIett(new ArrayList(retorno));
2091 
2092     boolean remover = true;
2093 
2094     while (remover) {
2095 
2096       remover = false;
2097       int maiorNivelSemOcorrencia = 0;
2098       Iterator itTodosItens = itensParaExibicao.iterator();
2099 
2100       while (itTodosItens.hasNext()) {
2101         ItemEstruturaIett iett = (ItemEstruturaIett) itTodosItens.next();
2102 
2103         int nivel = iett.getNivelIett().intValue();
2104 
2105         if (nivel > maiorNivelSemOcorrencia) {
2106           if (!itensTemp.contains(iett)) {
2107             maiorNivelSemOcorrencia = nivel;
2108           }
2109         }
2110       }
2111 
2112       // remover os itens do último nível que não apresentam a ocorrência
2113       itTodosItens = itensParaExibicao.iterator();
2114       while (itTodosItens.hasNext()) {
2115         ItemEstruturaIett iett = (ItemEstruturaIett) itTodosItens.next();
2116 
2117         if (iett.getNivelIett().intValue() == maiorNivelSemOcorrencia) {
2118           if (!itensTemp.contains(iett)) {
2119 
2120             boolean possuiFilhoComOcorrencia = false;
2121 
2122             Iterator itDescendentes = getDescendentes(iett, true).iterator();
2123 
2124             while (itDescendentes.hasNext()) {
2125               ItemEstruturaIett iettFilho = (ItemEstruturaIett) itDescendentes.next();
2126               if (itensTemp.contains(iettFilho)) {
2127                 possuiFilhoComOcorrencia = true;
2128                 break;
2129               }
2130             }
2131 
2132             if (!possuiFilhoComOcorrencia) {
2133               itTodosItens.remove();
2134               remover = true;
2135             }
2136           }
2137         }
2138       }
2139     }
2140 
2141     return itensParaExibicao;
2142   }
2143 
2144   /**
2145    * Devolve uma lista ordenada de nomes das imagens de nivel de planejamento.
2146    * @author felipev
2147    * @param item Item da estrutura
2148    * @return List lista de Strings que representam o nome da imagem
2149    */
2150   public List getNomeImgsNivelPlanejamentoItem(ItemEstruturaIett item) {
2151 
2152     List retorno = new ArrayList();
2153     List niveisAcesso = this.getNivelAcesso(item);
2154     if (niveisAcesso != null) {
2155       Iterator itNiveis = niveisAcesso.iterator();
2156       while (itNiveis.hasNext()) {
2157         SisAtributoSatb nivel = (SisAtributoSatb) itNiveis.next();
2158         /*
2159          * comentado por causa do bug 880 retorno.add("icon_" +
2160          * Util.retiraAcentuacao(nivel.getDescricaoSatb().toLowerCase()) +
2161          * ".png");
2162          */
2163         retorno.add(nivel.getAtribInfCompSatb()); // o nome da imagem está aqui
2164       }
2165     }
2166     return retorno;
2167   }
2168 
2169   /**
2170    * Devolve uma lista ordenada de nomes das imagens de nivel de planejamento,
2171    * agrupadas.<br>
2172    * Os nomes estão encapsulados utilizando o bean
2173    * NomeImgsNivelPlanejamentoBean.
2174    * @author garten, aleixo
2175    * @since N/I
2176    * @version 0.2 - 21/05/2007; 0.1 - N/I
2177    * @param item Item da estrutura
2178    * @return List lista de NomeImgsNivelPlanejamentoBean que contêm o nome e o
2179    *         title da imagem
2180    */
2181   public List getNomeImgsNivelPlanejamentoItemAgrupado(ItemEstruturaIett item) {
2182 
2183     /*
2184      * Especificação como consta no bug #880 Procedimentos da rotina que mostra
2185      * a imagem no relatório de acompanhamento: 1. Para cada registro de item da
2186      * estrutura selecionar todos os atributos do nivel de planejamento
2187      * relacionados; 2. Ordenar os atributos pelos 2 primeiros dígitos dentro de
2188      * cada item 3. Agrupar pelo primeiro dígito; 4. Montar o nome da imagem
2189      * (#nome) concatenando os demais caracteres no campo de informações
2190      * complementares (xxxxx) 5. Prever: Estratégico + Tático, Estratégico +
2191      * Operacional, Tático + Operacional e ainda Estratégico + Tático +
2192      * Operacional. 6. Montar os nomes das imagens com os caracteres "icon_",
2193      * mais o #nome, mais os caracteres ".PNG".
2194      */
2195 
2196     /*
2197      * algoritmo enquanto existir niveis de planejamento controlar os grupos. se
2198      * trocar de grupo, guarda o nome da imagem na lista nome da imagem <-
2199      * pedaço do nome contido em inf. complementares ex. 11est.png (est)
2200      * fim-enquanto
2201      */
2202 
2203     List retorno = new ArrayList();
2204     try {
2205       List niveisAcesso = this.getNivelAcesso(item);
2206       if (niveisAcesso != null && !niveisAcesso.isEmpty()) {
2207 
2208         String grupoAnterior = null;
2209         String grupoAtual = null;
2210         StringBuilder nomeImagem = null;
2211         StringBuilder titleImagem = null;
2212         String title = "";
2213         int ultimaVirgula = 0;
2214         int tamanho = 0;
2215 
2216         for (Iterator it = niveisAcesso.iterator(); it.hasNext();) {
2217           SisAtributoSatb atributo = (SisAtributoSatb) it.next();
2218           grupoAtual = atributo.getAtribInfCompSatb().substring(5, 6); // icon_x
2219           if (!grupoAtual.equals(grupoAnterior)) {
2220             if (grupoAnterior != null) {
2221               title = String.valueOf(titleImagem.toString()).trim();
2222               ultimaVirgula = title.lastIndexOf(',');
2223               tamanho = title.length() - 1;
2224               if (ultimaVirgula == tamanho) {
2225                 title = title.substring(0, ultimaVirgula);
2226               }
2227               NomeImgsNivelPlanejamentoBean nomeImgBean = new NomeImgsNivelPlanejamentoBean(nomeImagem.append(".png").toString(), title);
2228               retorno.add(nomeImgBean);
2229             }
2230 
2231             grupoAnterior = grupoAtual;
2232             nomeImagem = new StringBuilder("icon");
2233             titleImagem = new StringBuilder();
2234           }
2235 
2236           nomeImagem.append("_");
2237           nomeImagem.append(atributo.getAtribInfCompSatb().substring(7, atributo.getAtribInfCompSatb().indexOf('.'))); // {est
2238                                                                                                                        // |
2239                                                                                                                        // ope
2240                                                                                                                        // |
2241                                                                                                                        // tat
2242                                                                                                                        // |
2243                                                                                                                        // ...}
2244 
2245           titleImagem.append(atributo.getDescricaoSatb()).append(", ");
2246 
2247         }
2248 
2249         if (nomeImagem != null && titleImagem != null) {
2250           title = String.valueOf(titleImagem.toString()).trim();
2251           ultimaVirgula = title.lastIndexOf(',');
2252           tamanho = title.length() - 1;
2253           if (ultimaVirgula == tamanho) {
2254             title = title.substring(0, ultimaVirgula);
2255           }
2256           NomeImgsNivelPlanejamentoBean nomeImgBean = new NomeImgsNivelPlanejamentoBean(nomeImagem.append(".png").toString(), title);
2257           retorno.add(nomeImgBean);
2258         }
2259         else {
2260           NomeImgsNivelPlanejamentoBean nomeImgBean = new NomeImgsNivelPlanejamentoBean("", "");
2261           retorno.add(nomeImgBean);
2262         }
2263       }
2264     } catch (Exception e) {
2265       // retorno.add("erro.png");
2266       NomeImgsNivelPlanejamentoBean nomeImgBean = new NomeImgsNivelPlanejamentoBean("erro.png", "");
2267       retorno.add(nomeImgBean);
2268       // a exception foi tratada aqui para não ocorrer problema ao mostrar a
2269       // imagem
2270       this.logger.error("Não possível montar o nome da imagem: " + e.getMessage());
2271     }
2272 
2273     return retorno;
2274   }
2275 
2276   /**
2277    * Pesquisa na Estrutura, o método realiza a pesquisa em várias funções do
2278    * Item, somando todos os resultados encontrados num HashMap, indicando em
2279    * quais funções foi encontrado o parâmetro de pesquisa.
2280    * @param request
2281    * @param codUsu - código do usuário logado
2282    * @return
2283    * @throws ECARException
2284    */
2285   public HashMap pesquisarNaEstrutura(HttpServletRequest request, Long codUsu, ServletContext application) throws ECARException {
2286     HashMap itensMap = new HashMap();
2287     Mensagem properties = new Mensagem(application);
2288 
2289     // String opcaoPesquisa = Pagina.getParamStr(request, "opcaoPesquisa");
2290     String palavraChave = Pagina.getParamStr(request, "palavraChave").trim();
2291 
2292     /* Pesquisa nas funções da estrutura */
2293 
2294     /*
2295      * Sempre vai pesquisar na estrutura, pq a parte da pesquisa de informações
2296      * foi retirada da tela, referente ao Bug - 621.
2297      */
2298 
2299     // if("E".equals(opcaoPesquisa)){
2300     /*
2301      * A data também foi ignorada na tela de pesquisa, portanto na pesquisa
2302      * abaixo eu simplesmente passo como NULL para que na pesquisa a data seja
2303      * ignorada.
2304      */
2305     // Date data = Pagina.getParamDataBanco(request, "estData");
2306     String[] estruturas = request.getParameterValues("estruturaEtt");
2307     String todos = Pagina.getParamStr(request, "estTodos");
2308 
2309     // itensMap = montaMapPesquisaEstrutura(palavraChave, data, estruturas,
2310     // todos, codUsu, properties);
2311     itensMap = montaMapPesquisaEstrutura(request, palavraChave, null, estruturas, todos, codUsu, properties);
2312     // }
2313 
2314     /*
2315      * Pesquisa nas informações do portal --> Foi retirada da tela. Fica o
2316      * Comentário para posterior informação. if("I".equals(opcaoPesquisa)){ Date
2317      * dataIni = Pagina.getParamDataBanco(request, "infDataInicial"); Date
2318      * dataFim = Pagina.getParamDataBanco(request, "infDataFinal"); String[]
2319      * informacoes = request.getParameterValues("informacoes"); String todos =
2320      * Pagina.getParamStr(request, "infTodos"); itensMap =
2321      * montaMapPesquisaInformacoes(palavraChave, dataIni, dataFim, informacoes,
2322      * todos); }
2323      */
2324 
2325     Iterator it = itensMap.keySet().iterator();
2326     while (it.hasNext()) {
2327       ItemEstruturaIett item = (ItemEstruturaIett) it.next();
2328       try {
2329         session.refresh(item);
2330       } catch (HibernateException e) {
2331         this.logger.error(e);
2332         throw new ECARException(e);
2333       }
2334 
2335     }
2336 
2337     return itensMap;
2338   }
2339 
2340   /**
2341    * Método que recebe todos os resultados das pesquisas já utilizando-se de um
2342    * map e apenas adicionando a partir da primeira
2343    * @param palavraChave
2344    * @param data
2345    * @param estruturas
2346    * @param todos
2347    * @return
2348    * @throws ECARException
2349    */
2350   private HashMap montaMapPesquisaEstrutura(HttpServletRequest request, String palavraChave, Date data, String[] estruturas, String todos, Long codUsu, Mensagem properties) throws ECARException {
2351     HashMap itensMap = new HashMap();
2352 
2353     /* Strings que formarão o select para cada funcao */
2354     String select = "select item from ItemEstruturaIett as item ";
2355     select = select + " left join fetch item.itemEstruturaIetts ";
2356 
2357     String where = "";
2358     boolean flag = false;
2359 
2360     if (estruturas.length > 0) {
2361       if (!"todos".equals(todos)) {
2362         where = " where item.estruturaEtt.codEtt in (";
2363         flag = true;
2364         for (int i = 0; i < estruturas.length; i++) {
2365           where = where + estruturas[i];
2366           if ((i + 1) < estruturas.length)
2367             where = where + ",";
2368         }
2369         where = where + ")";
2370       }
2371     }
2372 
2373     if (flag) {
2374       where = where + " and item.indAtivoIett = 'S' ";
2375     }
2376     else {
2377       where = where + " where item.indAtivoIett = 'S' ";
2378     }
2379 
2380     boolean pesquisaAvancada = ("A".equals(Pagina.getParamStr(request, "tipoPesquisa"))) ? true : false;
2381 
2382     /*
2383      * Inicio das pesquisas montando o MAP a partir da lista (resultado da
2384      * pesquisa)
2385      */
2386 
2387     if (pesquisaAvancada) {
2388       // Ação
2389       atualizaMapItens(request, itensMap, pesquisaEstruturaAcao(select, where, palavraChave), properties.getMensagem("item.funcao.acao"), "");
2390 
2391       // Anexos
2392       atualizaMapItens(request, itensMap, pesquisaEstruturaAnexo(select, where, palavraChave), properties.getMensagem("item.funcao.anexo"), "");
2393 
2394       // Beneficiários
2395       atualizaMapItens(request, itensMap, pesquisaEstruturaBeneficiario(select, where, palavraChave), properties.getMensagem("item.funcao.beneficiario"), "");
2396 
2397       // Critérios
2398       atualizaMapItens(request, itensMap, pesquisaEstruturaCriterio(select, where, palavraChave), properties.getMensagem("item.funcao.criterio"), "");
2399 
2400       // Dados Básicos
2401       atualizaMapItens(request, itensMap, pesquisaEstruturaDadosBasicos(select, where, palavraChave, data, pesquisaAvancada), "", "Dados Básicos");
2402 
2403       // Entidades
2404       atualizaMapItens(request, itensMap, pesquisaEstruturaEntidade(select, where, palavraChave, data), properties.getMensagem("item.funcao.entidade"), "");
2405 
2406       // Fonte de Rescurso e Recurso
2407       atualizaMapItens(request, itensMap, pesquisaEstruturaFonteRecurso(select, where, palavraChave), properties.getMensagem("item.funcao.fonteRecurso"), "");
2408 
2409       // Localização
2410       atualizaMapItens(request, itensMap, pesquisaEstruturaLocalizacao(select, where, palavraChave), properties.getMensagem("item.funcao.localizacao"), "");
2411 
2412       // Marcadores
2413       atualizaMapItens(request, itensMap, pesquisaEstruturaMarcador(select, where, palavraChave, codUsu, pesquisaAvancada), "", "Marcadores");
2414 
2415       // Pontos Críticos
2416       atualizaMapItens(request, itensMap, pesquisaEstruturaPontoCritico(select, where, palavraChave), properties.getMensagem("item.funcao.pontoCritico"), "");
2417     }
2418     else {
2419       // Dados Básicos
2420       atualizaMapItens(request, itensMap, pesquisaEstruturaDadosBasicos(select, where, palavraChave, data, pesquisaAvancada), "", "Dados Básicos");
2421     }
2422 
2423     /*
2424      * fim das pesquisas
2425      * ************************************************************
2426      */
2427 
2428     return itensMap;
2429   }
2430 
2431   /**
2432    * Método que recebe o MAP e atualiza a partir da lista passada da pesquisa
2433    * Detalhe, se nomeFixo != "", utiliza método que busca o nome da função no
2434    * banco senão utiliza o nomeFixo
2435    * @param itensMap
2436    * @param lista
2437    * @param funcao
2438    * @param nomeFixo
2439    */
2440   private void atualizaMapItens(HttpServletRequest request, HashMap itensMap, List lista, String funcao, String nomeFixo) throws ECARException {
2441     ValidaPermissao validaPermissao = new ValidaPermissao();
2442     if (lista.size() > 0) {
2443       Iterator it = lista.iterator();
2444 
2445       // correção do bug #1575
2446       // Obtem o bean de seguranca para verificar se o usuário tem acesso a um
2447       // determinado item, utilizando as
2448       // funções definidas na classe de permissões.
2449       // Se o usuário puder acessar o item, ele é incluído na lista, cc não.
2450       // Essa abordagem parece melhor do que testar os itens apenas na página,
2451       // pois pode ocorrer de gastar tempo
2452       // incluindo itens na lista sem considerar permissões e depois não poder
2453       // mostrar os itens porque o usuário não tem acesso.
2454       SegurancaECAR seguranca = (SegurancaECAR) request.getSession().getAttribute("seguranca");
2455 
2456       while (it.hasNext()) {
2457         ItemEstruturaIett item = (ItemEstruturaIett) it.next();
2458 
2459         // somente inclui o item na lista se o usuário tem permissoes
2460         validaPermissao.permissoesItem(item, seguranca.getUsuario(), seguranca.getGruposAcesso());
2461         if (validaPermissao.permissaoConsultarItem()) {
2462           Set colecao = new HashSet();
2463           ItemFuncaoLink funcaoLink = new ItemFuncaoLink();
2464 
2465           if (!"".equals(nomeFixo)) {
2466             funcaoLink.setNome(nomeFixo);
2467 
2468             if ("Dados Básicos".equals(nomeFixo))
2469               funcaoLink.setLink("../dadosGerais/frm_con.jsp?codIett=" + item.getCodIett().toString());
2470             else
2471               /* TODO Definir link de marcadores na pesquisa de estrutura */
2472               funcaoLink.setLink("marcadores=" + item.getCodIett().toString());
2473           }
2474           else {
2475             EstruturaFuncaoEttf estruturaFuncao = new EstruturaFuncaoEttf();
2476 
2477             estruturaFuncao = (EstruturaFuncaoEttf) new EstruturaFuncaoDao(request).getLabelFuncao(item.getEstruturaEtt(), Long.valueOf(funcao));
2478 
2479             if (estruturaFuncao != null) {
2480               funcaoLink.setNome(estruturaFuncao.getLabelEttf());
2481               funcaoLink.setLink("../" + estruturaFuncao.getFuncaoFun().getLinkFuncaoFun() + "?codAba=" + estruturaFuncao.getFuncaoFun().getCodFun() + "&codIett=" + item.getCodIett());
2482 
2483             }
2484             else {
2485               funcaoLink.setNome("Dados Básicos");
2486               funcaoLink.setLink("../dadosGerais/frm_con.jsp?codIett=" + item.getCodIett().toString());
2487             }
2488           }
2489           if (!itensMap.containsKey(item)) {
2490             colecao.add(funcaoLink);
2491             itensMap.put(item, colecao);
2492           }
2493           else {
2494             colecao.addAll((Collection) itensMap.get(item));
2495             colecao.add(funcaoLink);
2496             itensMap.put(item, colecao);
2497           }
2498         }
2499       }
2500     }
2501   }
2502 
2503   /**
2504    * Realiza a pesquisa na Estrutura do item em itemEstrutAcaoIetta
2505    * @param itensMap
2506    * @param select
2507    * @param where
2508    * @param palavraChave
2509    * @throws ECARException
2510    */
2511   private List pesquisaEstruturaAcao(String select, String where, String palavraChave) throws ECARException {
2512     try {
2513       String joinFuncao = " left join item.itemEstrutAcaoIettas as acao";
2514       String whereFuncao = "";
2515 
2516       if (!"".equals(where))
2517         whereFuncao = " and";
2518       else
2519         whereFuncao = " where";
2520       whereFuncao = whereFuncao + " upper( acao.descricaoIetta ) like :palavraChave and acao.indAtivoIetta = 'S' ";
2521 
2522       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2523       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2524       return query.list();
2525 
2526     } catch (HibernateException e) {
2527       this.logger.error(e);
2528       throw new ECARException();
2529     }
2530   }
2531 
2532   /**
2533    * Realiza a pesquisa na Estrutura do item em itemEstrutUploadIettup
2534    * @param itensMap
2535    * @param select
2536    * @param where
2537    * @param palavraChave
2538    * @throws ECARException
2539    */
2540   private List pesquisaEstruturaAnexo(String select, String where, String palavraChave) throws ECARException {
2541     try {
2542       String joinFuncao = " left join item.itemEstrutUploadIettups as anexo";
2543       String whereFuncao = "";
2544 
2545       if (!"".equals(where))
2546         whereFuncao = " and";
2547       else
2548         whereFuncao = " where";
2549       whereFuncao = whereFuncao + " ( upper( anexo.nomeOriginalIettup ) like :palavraChave or";
2550       whereFuncao = whereFuncao + " upper( anexo.descricaoIettup ) like :palavraChave ) and anexo.indAtivoIettup = 'S' ";
2551 
2552       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2553       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2554       return query.list();
2555 
2556     } catch (HibernateException e) {
2557       this.logger.error(e);
2558       throw new ECARException();
2559     }
2560   }
2561 
2562   /**
2563    * Realiza a pesquisa na Estrutura do item em itemEstrtBenefIettb
2564    * @param itensMap
2565    * @param select
2566    * @param where
2567    * @param palavraChave
2568    * @throws ECARException
2569    */
2570   private List pesquisaEstruturaBeneficiario(String select, String where, String palavraChave) throws ECARException {
2571     try {
2572       String joinFuncao = " left join item.itemEstrtBenefIettbs as beneficiario";
2573       String whereFuncao = "";
2574 
2575       if (!"".equals(where))
2576         whereFuncao = " and";
2577       else
2578         whereFuncao = " where";
2579       whereFuncao = whereFuncao + " ( upper( beneficiario.comentarioIettb ) like :palavraChave or";
2580       whereFuncao = whereFuncao + " upper( beneficiario.beneficiarioBnf.nomeBnf ) like :palavraChave )";
2581 
2582       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2583       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2584       return query.list();
2585     } catch (HibernateException e) {
2586       this.logger.error(e);
2587       throw new ECARException();
2588     }
2589   }
2590 
2591   /**
2592    * Realiza a pesquisa na Estrutura do item em itemEstrutCriterioIettc
2593    * @param itensMap
2594    * @param select
2595    * @param where
2596    * @param palavraChave
2597    * @throws ECARException
2598    */
2599   private List pesquisaEstruturaCriterio(String select, String where, String palavraChave) throws ECARException {
2600     try {
2601       String joinFuncao = " left join item.itemEstrutCriterioIettcs as criterio";
2602       String whereFuncao = "";
2603 
2604       if (!"".equals(where))
2605         whereFuncao = " and";
2606       else
2607         whereFuncao = " where";
2608       whereFuncao = whereFuncao + " upper( criterio.criterioCri.descricaoCri ) like :palavraChave";
2609 
2610       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2611       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2612       return query.list();
2613     } catch (HibernateException e) {
2614       this.logger.error(e);
2615       throw new ECARException();
2616     }
2617   }
2618 
2619   /**
2620    * Realiza a pesquisa na Estrutura do item em
2621    * @param itensMap
2622    * @param select
2623    * @param where
2624    * @param palavraChave
2625    * @throws ECARException
2626    */
2627   private List pesquisaEstruturaDadosBasicos(String select, String where, String palavraChave, Date data, boolean pesquisaAvancada) throws ECARException {
2628     try {
2629       String joinFuncao = " left join item.areaAre as area";
2630       joinFuncao = joinFuncao + " left join item.subAreaSare as subArea";
2631       joinFuncao = joinFuncao + " left join item.orgaoOrgByCodOrgaoResponsavel1Iett as orgao1";
2632       joinFuncao = joinFuncao + " left join item.orgaoOrgByCodOrgaoResponsavel2Iett as orgao2";
2633 
2634       if (pesquisaAvancada) {
2635         joinFuncao = joinFuncao + " left join item.itemEstrutUsuarioIettusesByCodIett as editorLeitor";
2636       }
2637 
2638       joinFuncao = joinFuncao + " left join item.itemEstUsutpfuacIettutfas as funcaoAcomp";
2639       joinFuncao = joinFuncao + " left join funcaoAcomp.usuarioUsu as usuario";
2640 
2641       String whereFuncao = "";
2642 
2643       if (!"".equals(where))
2644         whereFuncao = " and";
2645       else
2646         whereFuncao = " where";
2647 
2648       whereFuncao = whereFuncao + " ( upper( item.nomeIett ) like :palavraChave or";
2649       whereFuncao = whereFuncao + " upper( item.siglaIett ) like :palavraChave or";
2650       whereFuncao = whereFuncao + " upper( item.descricaoIett ) like :palavraChave or";
2651       // whereFuncao = whereFuncao +
2652       // " upper( item.unidadeMedia ) like :palavraChave or";
2653       whereFuncao = whereFuncao + " upper( item.objetivoGeralIett ) like :palavraChave or";
2654       whereFuncao = whereFuncao + " upper( item.objetivoEspecificoIett ) like :palavraChave or";
2655       whereFuncao = whereFuncao + " upper( item.origemIett ) like :palavraChave or";
2656       whereFuncao = whereFuncao + " upper( item.beneficiosIett ) like :palavraChave or";
2657 
2658       /* Area */
2659       whereFuncao = whereFuncao + " upper( area.nomeAre ) like :palavraChave or";
2660 
2661       /* Sub-Area */
2662       whereFuncao = whereFuncao + " upper( subArea.nomeSare ) like :palavraChave or";
2663 
2664       /* Órgão resp 1 */
2665       whereFuncao = whereFuncao + " upper( orgao1.descricaoOrg ) like :palavraChave or";
2666       whereFuncao = whereFuncao + " upper( orgao1.siglaOrg ) like :palavraChave or";
2667 
2668       /* Órgão resp 2 */
2669       whereFuncao = whereFuncao + " upper( orgao2.descricaoOrg ) like :palavraChave or";
2670       whereFuncao = whereFuncao + " upper( orgao2.siglaOrg ) like :palavraChave";
2671 
2672       if (pesquisaAvancada) {
2673         /* Editor Leitor */
2674         whereFuncao = whereFuncao + " or upper( editorLeitor.usuarioUsu.nomeUsu ) like :palavraChave";
2675       }
2676 
2677       /* Função de Acompanhamento */
2678       whereFuncao = whereFuncao + " or upper( usuario.nomeUsu ) like :palavraChave";
2679 
2680       if (data != null) {
2681         whereFuncao = whereFuncao + " or ( item.dataInicioIett <= :data";
2682         whereFuncao = whereFuncao + " and item.dataTerminoIett >= :data )";
2683         whereFuncao = whereFuncao + " or item.dataInicioMonitoramentoIett = :data";
2684       }
2685 
2686       // Incluir somente ativos
2687       whereFuncao = whereFuncao + " and area.indAtivoAre = 'S'";
2688       whereFuncao = whereFuncao + " and subArea.indAtivoSare = 'S'";
2689       whereFuncao = whereFuncao + " and orgao1.indAtivoOrg = 'S'";
2690       whereFuncao = whereFuncao + " and orgao2.indAtivoOrg = 'S'";
2691 
2692       whereFuncao = whereFuncao + " )";
2693 
2694       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2695       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2696 
2697       if (data != null) {
2698         query.setDate("data", data);
2699       }
2700 
2701       return query.list();
2702     } catch (HibernateException e) {
2703       this.logger.error(e);
2704       throw new ECARException();
2705     }
2706   }
2707 
2708   /**
2709    * Realiza a pesquisa na Estrutura do item em ItemEstrutEntidadeIette
2710    * @param itensMap
2711    * @param select
2712    * @param where
2713    * @param palavraChave
2714    * @throws ECARException
2715    */
2716   private List pesquisaEstruturaEntidade(String select, String where, String palavraChave, Date data) throws ECARException {
2717     try {
2718       String joinFuncao = " left join item.itemEstrutEntidadeIettes as entidade";
2719       String whereFuncao = "";
2720 
2721       if (!"".equals(where))
2722         whereFuncao = " and";
2723       else
2724         whereFuncao = " where";
2725 
2726       whereFuncao = whereFuncao + " ( upper( entidade.descricaoIette ) like :palavraChave or";
2727       whereFuncao = whereFuncao + " upper( entidade.entidadeEnt.nomeEnt ) like :palavraChave or";
2728       whereFuncao = whereFuncao + " upper( entidade.entidadeEnt.siglaEnt ) like :palavraChave";
2729 
2730       if (data != null) {
2731         whereFuncao = whereFuncao + " or ( entidade.dataInicioIette <= :data";
2732         whereFuncao = whereFuncao + " and entidade.dataFimIette >= :data )";
2733       }
2734 
2735       whereFuncao = whereFuncao + " )";
2736 
2737       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2738       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2739 
2740       if (data != null) {
2741         query.setDate("data", data);
2742       }
2743 
2744       return query.list();
2745     } catch (HibernateException e) {
2746       this.logger.error(e);
2747       throw new ECARException();
2748     }
2749   }
2750 
2751   /**
2752    * Realiza a pesquisa na Estrutura do item em EfIettFonteTotEfieft ->
2753    * ItemFonteRecurso EfItemEstPrevisaoEfieps -> ItemRecurso
2754    * @param itensMap
2755    * @param select
2756    * @param where
2757    * @param palavraChave
2758    * @throws ECARException
2759    */
2760   private List pesquisaEstruturaFonteRecurso(String select, String where, String palavraChave) throws ECARException {
2761     try {
2762       String joinFuncao = " left join item.efIettFonteTotEfiefts as fonteRecurso";
2763       joinFuncao = joinFuncao + " left join item.efItemEstPrevisaoEfieps as recurso";
2764       String whereFuncao = "";
2765 
2766       if (!"".equals(where))
2767         whereFuncao = " and";
2768       else
2769         whereFuncao = " where";
2770       whereFuncao = whereFuncao + " ( upper( fonteRecurso.fonteRecursoFonr.nomeFonr ) like :palavraChave or";
2771       whereFuncao = whereFuncao + " upper( recurso.recursoRec.nomeRec ) like :palavraChave or";
2772       whereFuncao = whereFuncao + " upper( recurso.recursoRec.siglaRec ) like :palavraChave ) and";
2773       whereFuncao = whereFuncao + " fonteRecurso.indAtivoEfieft = 'S' and ";
2774       whereFuncao = whereFuncao + " recurso.indAtivoEfiep = 'S' ";
2775 
2776       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2777       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2778       return query.list();
2779     } catch (HibernateException e) {
2780       this.logger.error(e);
2781       throw new ECARException();
2782     }
2783   }
2784 
2785   /**
2786    * Realiza a pesquisa na Estrutura do item em ItemEstrutLocalIettl
2787    * @param itensMap
2788    * @param select
2789    * @param where
2790    * @param palavraChave
2791    * @throws ECARException
2792    */
2793   private List pesquisaEstruturaLocalizacao(String select, String where, String palavraChave) throws ECARException {
2794     try {
2795       String joinFuncao = " left join item.itemEstrutLocalIettls as local";
2796       String whereFuncao = "";
2797 
2798       if (!"".equals(where))
2799         whereFuncao = " and";
2800       else
2801         whereFuncao = " where";
2802       whereFuncao = whereFuncao + " ( upper( local.localItemLit.identificacaoLit ) like :palavraChave or";
2803       whereFuncao = whereFuncao + " upper( local.localItemLit.localGrupoLgp.identificacaoLgp ) like :palavraChave )";
2804 
2805       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2806       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2807       return query.list();
2808     } catch (HibernateException e) {
2809       this.logger.error(e);
2810       throw new ECARException();
2811     }
2812   }
2813 
2814   /**
2815    * Realiza a pesquisa na Estrutura do item em ItemEstrutLocalIettl
2816    * @param itensMap
2817    * @param select
2818    * @param where
2819    * @param palavraChave
2820    * @throws ECARException
2821    */
2822   private List pesquisaEstruturaMarcador(String select, String where, String palavraChave, Long codUsu, boolean pesquisaAvancada) throws ECARException {
2823     try {
2824       String joinFuncao = " left join item.itemEstrutMarcadorIettms as marcador";
2825 
2826       if (pesquisaAvancada) {
2827         joinFuncao = joinFuncao + " left join marcador.usuarioUsu as usuario";
2828       }
2829 
2830       String whereFuncao = "";
2831 
2832       if (!"".equals(where))
2833         whereFuncao = " and";
2834       else
2835         whereFuncao = " where";
2836       whereFuncao = whereFuncao + " upper( marcador.descricaoIettm ) like :palavraChave";
2837 
2838       if (pesquisaAvancada) {
2839         whereFuncao = whereFuncao + " and usuario.codUsu = :codUsu";
2840       }
2841 
2842       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2843       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2844 
2845       if (pesquisaAvancada) {
2846         query.setLong("codUsu", codUsu.longValue());
2847       }
2848 
2849       return query.list();
2850     } catch (HibernateException e) {
2851       this.logger.error(e);
2852       throw new ECARException();
2853     }
2854   }
2855 
2856   /**
2857    * Realiza a pesquisa na Estrutura do item em ItemEstrutLocalIettl
2858    * @param itensMap
2859    * @param select
2860    * @param where
2861    * @param palavraChave
2862    * @throws ECARException
2863    */
2864   private List pesquisaEstruturaPontoCritico(String select, String where, String palavraChave) throws ECARException {
2865     try {
2866       String joinFuncao = " left join item.pontoCriticoPtcs as pontoCritico";
2867       joinFuncao = joinFuncao + " left join pontoCritico.apontamentoApts as apontamento";
2868       String whereFuncao = "";
2869 
2870       if (!"".equals(where))
2871         whereFuncao = " and";
2872       else
2873         whereFuncao = " where";
2874       whereFuncao = whereFuncao + " ( upper( pontoCritico.descricaoPtc ) like :palavraChave or";
2875       whereFuncao = whereFuncao + " upper( pontoCritico.descricaoSolucaoPtc ) like :palavraChave or";
2876       whereFuncao = whereFuncao + " upper( apontamento.textoApt ) like :palavraChave ) and ";
2877       whereFuncao = whereFuncao + " pontoCritico.indAtivoPtc = 'S'";
2878 
2879       Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
2880       query.setString("palavraChave", "%" + palavraChave.toUpperCase() + "%");
2881       return query.list();
2882     } catch (HibernateException e) {
2883       this.logger.error(e);
2884       throw new ECARException();
2885     }
2886   }
2887 
2888   /**
2889    * Altera um item estrutura quando clicar em Ativar/Retirar Monitoramento
2890    * @param request
2891    * @param usuarioLogado
2892    * @return ItemEstruturaIett
2893    */
2894   public ItemEstruturaIett alterarMonitoramento(HttpServletRequest request, UsuarioUsu usuarioLogado, HistoricoIett historico) throws ECARException {
2895     Transaction tx = null;
2896 
2897     try {
2898       ArrayList objetos = new ArrayList();
2899       super.inicializarLogBean();
2900 
2901       tx = session.beginTransaction();
2902 
2903       ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIett")));
2904       String indMonitoramentoAnterior = itemEstrutura.getIndMonitoramentoIett();
2905 
2906       ItemEstruturaIett old = (ItemEstruturaIett) itemEstrutura.clone();
2907       /*** Historico ***/
2908       historico.gerarHistorico(old);
2909       /*** Historico ***/
2910 
2911       itemEstrutura.setIndMonitoramentoIett(Pagina.getParamStr(request, "indMonitoramentoIett"));
2912       itemEstrutura.setUsuarioUsuByCodUsuUltManutIett(usuarioLogado);
2913       itemEstrutura.setDataUltManutencaoIett(Data.getDataAtual());
2914 
2915       // se o usuario escolheu ativar/desativar todos os itens filhos
2916       if ("S".equals(Pagina.getParamStr(request, "ativarRetirarMonitoramentoItensFilho"))) {
2917         if (indMonitoramentoAnterior != null && !indMonitoramentoAnterior.equals(itemEstrutura.getIndMonitoramentoIett())) {
2918           this.propagarMonitoramento(itemEstrutura, historico);
2919         }
2920       }
2921 
2922       session.update(itemEstrutura);
2923       objetos.add(itemEstrutura);
2924 
2925       tx.commit();
2926 
2927       if (super.logBean != null) {
2928         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
2929         super.logBean.setOperacao("ALT");
2930         Iterator itObj = objetos.iterator();
2931 
2932         while (itObj.hasNext()) {
2933           super.logBean.setObj(itObj.next());
2934           super.loggerAuditoria.info(logBean.toString());
2935         }
2936       }
2937 
2938       return itemEstrutura;
2939     } catch (HibernateException e) {
2940       e.printStackTrace();
2941       if (tx != null)
2942         try {
2943           tx.rollback();
2944         } catch (HibernateException r) {
2945           this.logger.error(r);
2946           throw new ECARException("erro.hibernateException");
2947         }
2948       this.logger.error(e);
2949       throw new ECARException("erro.hibernateException");
2950     }
2951   }
2952 
2953   /**
2954    * Altera um item estrutura quando clicar em Liberar/Bloquear Planejamento
2955    * @param request
2956    * @param usuarioLogado
2957    * @return ItemEstruturaIett
2958    */
2959   public ItemEstruturaIett alterarPlanejamento(HttpServletRequest request, UsuarioUsu usuarioLogado, HistoricoIett historico) throws ECARException {
2960     Transaction tx = null;
2961 
2962     try {
2963       ArrayList objetos = new ArrayList();
2964       super.inicializarLogBean();
2965 
2966       tx = session.beginTransaction();
2967 
2968       ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIett")));
2969       String indBloqPlanejamentoAnterior = itemEstrutura.getIndBloqPlanejamentoIett();
2970 
2971       ItemEstruturaIett old = (ItemEstruturaIett) itemEstrutura.clone();
2972 
2973       /*** Historico ***/
2974       historico.gerarHistorico(old);
2975       /*** Historico ***/
2976 
2977       itemEstrutura.setIndBloqPlanejamentoIett(Pagina.getParamStr(request, "indBloqPlanejamentoIett"));
2978 
2979       // se o usuario escolheu bloquear/desbloquear todos os itens filhos
2980       if ("S".equals(Pagina.getParamStr(request, "bloquearDesbloquearPlanejamentoItensFilho"))) {
2981         if (indBloqPlanejamentoAnterior != null && !indBloqPlanejamentoAnterior.equals(itemEstrutura.getIndBloqPlanejamentoIett())) {
2982           this.propagarPlanejamento(itemEstrutura, historico);
2983         }
2984       }
2985       session.update(itemEstrutura);
2986       objetos.add(itemEstrutura);
2987 
2988       tx.commit();
2989 
2990       if (super.logBean != null) {
2991         super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
2992         super.logBean.setOperacao("ALT");
2993         Iterator itObj = objetos.iterator();
2994 
2995         while (itObj.hasNext()) {
2996           super.logBean.setObj(itObj.next());
2997           super.loggerAuditoria.info(logBean.toString());
2998         }
2999       }
3000 
3001       return itemEstrutura;
3002     } catch (HibernateException e) {
3003       if (tx != null)
3004         try {
3005           tx.rollback();
3006         } catch (HibernateException r) {
3007           this.logger.error(r);
3008           throw new ECARException("erro.hibernateException");
3009         }
3010       this.logger.error(e);
3011       throw new ECARException("erro.hibernateException");
3012     }
3013   }
3014 
3015   /**
3016    * Propagar Liberar/Bloquear Planejamento para os itens filhos de um item
3017    * (indBloqPlanejamentoIett)
3018    * @param itemEstruturaAtual ItemEstruturaIett contendo os dados a serem
3019    *          propagados
3020    */
3021   private void propagarPlanejamento(ItemEstruturaIett itemEstruturaAtual, HistoricoIett historico) throws ECARException {
3022     try {
3023       List iettFilhos = this.getDescendentes(itemEstruturaAtual, false);
3024 
3025       for (Iterator it = iettFilhos.iterator(); it.hasNext();) {
3026         ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
3027 
3028         ItemEstruturaIett old = (ItemEstruturaIett) itemEstruturaFilho.clone();
3029 
3030         /*** Historico ***/
3031         historico.gerarHistorico(old);
3032         /*** Historico ***/
3033 
3034         itemEstruturaFilho.setIndBloqPlanejamentoIett(itemEstruturaAtual.getIndBloqPlanejamentoIett());
3035         itemEstruturaFilho.setUsuarioUsuByCodUsuUltManutIett(itemEstruturaAtual.getUsuarioUsuByCodUsuUltManutIett());
3036         itemEstruturaFilho.setDataUltManutencaoIett(Data.getDataAtual());
3037       }
3038     } catch (Exception e) {
3039       this.logger.error(e);
3040       throw new ECARException("erro.hibernateException");
3041     }
3042   }
3043 
3044   /**
3045    * Propagar Ativar/Retirar Monitoramento para os itens filhos de um item
3046    * (indMonitoramentoIett)
3047    * @param itemEstruturaAtual ItemEstruturaIett contendo os dados a serem
3048    *          propagados
3049    */
3050   private void propagarMonitoramento(ItemEstruturaIett itemEstruturaAtual, HistoricoIett historico) throws ECARException {
3051     try {
3052       List iettFilhos = this.getDescendentes(itemEstruturaAtual, false);
3053 
3054       for (Iterator it = iettFilhos.iterator(); it.hasNext();) {
3055         ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
3056         ItemEstruturaIett old = (ItemEstruturaIett) itemEstruturaFilho.clone();
3057         /*** Historico ***/
3058         historico.gerarHistorico(old);
3059         /*** Historico ***/
3060 
3061         itemEstruturaFilho.setIndMonitoramentoIett(itemEstruturaAtual.getIndMonitoramentoIett());
3062         itemEstruturaFilho.setUsuarioUsuByCodUsuUltManutIett(itemEstruturaAtual.getUsuarioUsuByCodUsuUltManutIett());
3063         itemEstruturaFilho.setDataUltManutencaoIett(Data.getDataAtual());
3064       }
3065     } catch (Exception e) {
3066       this.logger.error(e);
3067       throw new ECARException("erro.hibernateException");
3068     }
3069   }
3070 
3071   /**
3072    * Ordenar uma lista de itens pelo campo SiglaIett (utilizado para
3073    * visualização como número do item), para cada nível da estrutura Obs: Se a
3074    * sigla for nula será ordenado pelo nome do item <b>Importante: Este método
3075    * só deve ser usado para ordenar os itens do relatório do PPA. Para ordenar
3076    * outros itens, utilize o método getItensOrdenados();</b>
3077    * @param itens
3078    * @return List de itens ordenado pelo campo SiglaIett
3079    */
3080 
3081   /*
3082    * Este método só é usado para os itens do Relatório de Apêndices do PPA.
3083    */
3084   public List getItensOrdenadosPorSiglaIett(List itens) throws ECARException {
3085     List listRetorno = new ArrayList();
3086     List listOrdenacaoIett = new ArrayList();
3087 
3088     Iterator it = itens.iterator();
3089     while (it.hasNext()) {
3090       ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
3091       OrdenacaoIett ord = new OrdenacaoIett();
3092 
3093       ord.setIett(iett);
3094 
3095       List ascendentes = new ArrayList(this.getAscendentes(iett));
3096 
3097       if (ascendentes != null && ascendentes.size() > 0) {
3098         String niveis = "";
3099         Iterator itAux = ascendentes.iterator();
3100 
3101         while (itAux.hasNext()) {
3102           ItemEstruturaIett iettAux = (ItemEstruturaIett) itAux.next();
3103 
3104           if (iettAux.getSiglaIett() != null) {
3105             niveis += iettAux.getSiglaIett();
3106           }
3107           else {
3108             niveis += iettAux.getNomeIett();
3109           }
3110         }
3111 
3112         if (iett.getSiglaIett() != null) {
3113           ord.setCampoOrdenar(niveis + iett.getSiglaIett());
3114         }
3115         else {
3116           ord.setCampoOrdenar(niveis + iett.getNomeIett());
3117         }
3118       }
3119       else {
3120         if (iett.getSiglaIett() != null) {
3121           ord.setCampoOrdenar(iett.getSiglaIett());
3122         }
3123         else {
3124           ord.setCampoOrdenar(iett.getNomeIett());
3125         }
3126       }
3127 
3128       if (ord.getCampoOrdenar() == null) {
3129         ord.setCampoOrdenar("");
3130       }
3131 
3132       listOrdenacaoIett.add(ord);
3133     }
3134 
3135     Collections.sort(listOrdenacaoIett, new Comparator() {
3136       public int compare(Object o1, Object o2) {
3137         OrdenacaoIett ord1 = (OrdenacaoIett) o1;
3138         OrdenacaoIett ord2 = (OrdenacaoIett) o2;
3139 
3140         return ord1.getCampoOrdenar().compareToIgnoreCase(ord2.getCampoOrdenar());
3141       }
3142     });
3143 
3144     it = listOrdenacaoIett.iterator();
3145 
3146     while (it.hasNext()) {
3147       OrdenacaoIett ord = (OrdenacaoIett) it.next();
3148 
3149       listRetorno.add(ord.getIett());
3150     }
3151 
3152     return listRetorno;
3153   }
3154 
3155   /**
3156    * Ordena os itens de acordo com o que foi definido nas configurações de tipo
3157    * de Acompanhamento.
3158    * @param List itens
3159    * @param TipoAcompanhamentoTa tipoAcomp
3160    * @return List
3161    * @throws ECARException
3162    */
3163   public List getItensOrdenados(List itens, TipoAcompanhamentoTa tipoAcomp) throws ECARException {
3164     List listRetorno = new ArrayList();
3165 
3166     EstruturaAtributoDao estruturaAtributoDao = new EstruturaAtributoDao(null);
3167 
3168     /*
3169      * 1) Pegar qual os campos de ordenação que é apresentado em cada estrutura.
3170      * Ordenar campos da estrutura (EstruturaAtributo) pela sequencia de
3171      * apresentação (seqApresListagemTelaEttat) e pegar o primeiro campo que
3172      * possuir Listagem Impressa Relação (indRelacaoImpressaEttat) = "S". Se uma
3173      * estrutura não estiver apresentada neste filtro informado, assume que o
3174      * Primeiro Atributo Valido desta estrutura é o CodIett.
3175      */
3176     List estruturasAtributos = estruturaAtributoDao.getAtributosValidoEstruturas(tipoAcomp);
3177 
3178     // Descubro o maior length dos campos dos itens para preencher com ZEROS
3179     // para ordenação.
3180     int tamanho = this.getTamanhoMaximoAtributoEstruturaItem(estruturasAtributos, itens, tipoAcomp);
3181 
3182     for (Iterator it = itens.iterator(); it.hasNext();) {
3183       ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
3184 
3185       if (iett.getIndAtivoIett() != null && !Dominios.SIM.equals(iett.getIndAtivoIett())) {
3186         it.remove();
3187       }
3188     }
3189 
3190     // montar a árvore completa de itens
3191     List listItensComPais = new ArrayList(this.getArvoreItens(itens, null));
3192 
3193     // montar os objetos OrdenacaoIett
3194     List listNiveis = new ArrayList();
3195     List listOrdenacaoIett = new ArrayList();
3196     Iterator itItens = listItensComPais.iterator();
3197     while (itItens.hasNext()) {
3198       ItemEstruturaIett iett = (ItemEstruturaIett) itItens.next();
3199 
3200       if (iett.getIndAtivoIett() != null && !Dominios.SIM.equals(iett.getIndAtivoIett())) {
3201         continue;
3202       }
3203 
3204       OrdenacaoIett ord = new OrdenacaoIett();
3205 
3206       ord.setIett(iett);
3207 
3208       if (!listNiveis.contains(iett.getNivelIett())) {
3209         listNiveis.add(iett.getNivelIett());
3210       }
3211 
3212       ord.setCampoOrdenar(this.getValorAtributoEstruturaItem(estruturasAtributos, iett, tamanho, tipoAcomp));
3213 
3214       if (ord.getCampoOrdenar() == null) {
3215         ord.setCampoOrdenar("");
3216       }
3217 
3218       listOrdenacaoIett.add(ord);
3219     }
3220 
3221     // ordenar a lista de níveis: 1, 2, 3, ... n
3222     Collections.sort(listNiveis, new Comparator() {
3223       public int compare(Object o1, Object o2) {
3224         Integer ord1 = (Integer) o1;
3225         Integer ord2 = (Integer) o2;
3226 
3227         return ord1.compareTo(ord2);
3228       }
3229     });
3230 
3231     // Gerar uma lista de itens para cada nível
3232     List listOrdenacaoPorNivel = new ArrayList();
3233     Iterator itNiveis = listNiveis.iterator();
3234     while (itNiveis.hasNext()) {
3235       Integer nivel = (Integer) itNiveis.next();
3236 
3237       OrdenacaoPorNivel opn = new OrdenacaoPorNivel();
3238       opn.setNivel(nivel);
3239       opn.setOrdenacaoIett(new ArrayList());
3240 
3241       itItens = listOrdenacaoIett.iterator();
3242       while (itItens.hasNext()) {
3243         OrdenacaoIett ord = (OrdenacaoIett) itItens.next();
3244 
3245         if (nivel.equals(ord.getIett().getNivelIett())) {
3246           opn.getOrdenacaoIett().add(ord);
3247         }
3248       }
3249       listOrdenacaoPorNivel.add(opn);
3250     }
3251 
3252     // ordenar a lista de OrdenacaoPorNivel, aplicando regra de ordenamento
3253     itNiveis = listOrdenacaoPorNivel.iterator();
3254     while (itNiveis.hasNext()) {
3255       OrdenacaoPorNivel opn = (OrdenacaoPorNivel) itNiveis.next();
3256 
3257       Collections.sort(opn.getOrdenacaoIett(), new Comparator() {
3258         public int compare(Object o1, Object o2) {
3259           OrdenacaoIett ord1 = (OrdenacaoIett) o1;
3260           OrdenacaoIett ord2 = (OrdenacaoIett) o2;
3261 
3262           return ord1.getCampoOrdenar().compareToIgnoreCase(ord2.getCampoOrdenar());
3263         }
3264       });
3265     }
3266 
3267     // organizar os itens de acordo com a hierarquia de
3268     // pai/filho/neto/bisneto/etc a partir dos itens do primeiro nível
3269     List itensOrganizados = new ArrayList();
3270     if (!listOrdenacaoPorNivel.isEmpty()) {
3271       OrdenacaoPorNivel opn = (OrdenacaoPorNivel) listOrdenacaoPorNivel.get(0);
3272 
3273       itNiveis = opn.getOrdenacaoIett().iterator();
3274       while (itNiveis.hasNext()) {
3275         OrdenacaoIett ord = (OrdenacaoIett) itNiveis.next();
3276 
3277         List listIettAux = getItemFilhoOrdenacaoPorNivel(ord.getIett(), listOrdenacaoPorNivel);
3278         itensOrganizados.addAll(listIettAux);
3279       }
3280     }
3281 
3282     Iterator it = itensOrganizados.iterator();
3283 
3284     while (it.hasNext()) {
3285       ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
3286 
3287       AtributoEstruturaListagemItens atEstListagem = new AtributoEstruturaListagemItens();
3288       atEstListagem.setDescricao(estruturaAtributoDao.getDescricaoItemByAtributo(iett, tipoAcomp));
3289       atEstListagem.setItem(iett);
3290 
3291       listRetorno.add(atEstListagem);
3292     }
3293 
3294     return listRetorno;
3295   }
3296 
3297   /**
3298    * Obter próximo item filho de um item e seus netos/bisnetos/etc a partir de
3299    * uma lista de OrdenacaoPorNivel
3300    * @param iett
3301    * @param listOrdenacaoPorNivel
3302    * @return List de Iett
3303    * @throws ECARException
3304    */
3305   private List getItemFilhoOrdenacaoPorNivel(ItemEstruturaIett iett, List listOrdenacaoPorNivel) throws ECARException {
3306     List retorno = new ArrayList();
3307 
3308     retorno.add(iett);
3309 
3310     Iterator it = listOrdenacaoPorNivel.iterator();
3311     while (it.hasNext()) {
3312       OrdenacaoPorNivel opn = (OrdenacaoPorNivel) it.next();
3313 
3314       Iterator itItens = opn.getOrdenacaoIett().iterator();
3315       while (itItens.hasNext()) {
3316         OrdenacaoIett ord = (OrdenacaoIett) itItens.next();
3317 
3318         if (iett.equals(ord.getIett().getItemEstruturaIett())) {
3319           retorno.addAll(getItemFilhoOrdenacaoPorNivel(ord.getIett(), listOrdenacaoPorNivel));
3320         }
3321 
3322       }
3323     }
3324 
3325     return retorno;
3326   }
3327 
3328   /**
3329    * completa para ordenação
3330    * @param valor
3331    * @param tamanho
3332    * @return String
3333    */
3334   private String completarParaOrdenacao(String valor, int tamanho) {
3335     String completar = "E";
3336     try {
3337       Long dummy = Long.valueOf(valor); // se conseguiu transformar, é número -
3338                                         // completar zeros à esquerda
3339     } catch (NumberFormatException e) {
3340       // ATENÇÃO: Não é necesário lancar exceção aqui
3341 
3342       // não conseguiu transformar, não é número - completar zeros à direita
3343       completar = "D";
3344     }
3345     return Util.completarCaracteres(valor, "0", tamanho, completar);
3346   }
3347 
3348   /**
3349    * Retorna o valor do atributo da estrutura.
3350    * @param atributosEstruturas
3351    * @param iett
3352    * @return
3353    * @throws ECARException
3354    */
3355   private String getValorAtributoEstruturaItem(List atributosEstruturas, ItemEstruturaIett iett, int tamanho, TipoAcompanhamentoTa ta) throws ECARException {
3356     StringBuilder retorno = new StringBuilder("");
3357     if (atributosEstruturas != null && !atributosEstruturas.isEmpty()) {
3358       Iterator it = atributosEstruturas.iterator();
3359       while (it.hasNext()) {
3360         AtributoEstruturaBean aeBean = (AtributoEstruturaBean) it.next();
3361         if (iett.getEstruturaEtt().equals(aeBean.getEstrutura())) {
3362           String campo = this.getValorAtributoItemEstrutura(iett, aeBean.getAtributo().getAtributosAtb().getNomeAtb(), aeBean.getAtributo().getAtributosAtb().getNomeFkAtb()).trim();
3363           /*
3364            * Verificação ref mantis 9959: Se for um campo que consiga converter
3365            * para data, então deve-se gerar uma string com yyyyMMdd para que a
3366            * ordenação fique correta. Se não conseguir converter para data, é
3367            * outro tipo de campo. Então fica como está.
3368            */
3369           Date data = Data.parseDate(campo, "dd/MM/yyyy");
3370           if (data != null) { // É campo data!
3371             // Conseguiu converter para objeto Date!!!
3372             int d = Data.getDia(data);
3373             int m = Data.getMes(data) + 1;
3374             int a = Data.getAno(data);
3375             String dia = (d < 10) ? "0" + String.valueOf(d) : String.valueOf(d);
3376             String mes = (m < 10) ? "0" + String.valueOf(m) : String.valueOf(m);
3377             String ano = String.valueOf(a);
3378 
3379             campo = ano + mes + dia;
3380           }
3381 
3382           retorno.append(this.completarParaOrdenacao(campo, tamanho));
3383         }
3384       }
3385     }
3386 
3387     if ("".equals(retorno.toString())) {
3388       // Se não houver configuração, lançar exceção!!!!!!!!!!!!!!!!
3389 
3390       StringBuilder msg = new StringBuilder("Não foi possível obter a configuração de atributo na estrutura.");
3391       if (ta != null) {
3392         msg.append(" Tipo de acompanhamento: " + ta.getDescricaoTa() + ".");
3393       }
3394       msg.append(" Efetue a configuração da Estrutura: " + iett.getEstruturaEtt().getNomeEtt());
3395 
3396       throw new ECARException(msg.toString());
3397     }
3398     else {
3399       return retorno.toString();
3400     }
3401 
3402   }
3403 
3404   /**
3405    * Percorre a lista de itens verificando qual o atributo tem o maior length
3406    * para ser usado no método de ordenação.
3407    * @param estruturasAtributos
3408    * @param itens
3409    * @param ta
3410    * @return
3411    * @throws ECARException
3412    */
3413   private int getTamanhoMaximoAtributoEstruturaItem(List estruturasAtributos, List itens, TipoAcompanhamentoTa ta) throws ECARException {
3414 
3415     int retorno = 0;
3416 
3417     for (Iterator iter = itens.iterator(); iter.hasNext();) {
3418       ItemEstruturaIett iett = (ItemEstruturaIett) iter.next();
3419 
3420       String strAux = this.getValorAtributoEstruturaItem(estruturasAtributos, iett, -1, ta);
3421       if (strAux.length() > retorno) {
3422         retorno = strAux.length();
3423       }
3424     }
3425     return retorno;
3426   }
3427 
3428   /*
3429    * private int getTamanhoMaximoAtributoEstruturaItem(List estruturasAtributos,
3430    * List itens) throws ECARException{ Iterator it = itens.iterator(); int
3431    * retorno = 0; while(it.hasNext()) { ItemEstruturaIett iett =
3432    * (ItemEstruturaIett) it.next(); List ascendentes = new
3433    * ArrayList(this.getAscendentes(iett)); if(ascendentes != null &&
3434    * ascendentes.size() > 0) { Iterator itAux = ascendentes.iterator(); while
3435    * (itAux.hasNext()) { ItemEstruturaIett iettAux = (ItemEstruturaIett)
3436    * itAux.next(); String strAux =
3437    * this.getValorAtributoEstruturaItem(estruturasAtributos, iettAux);
3438    * if(strAux.length() > retorno){ retorno = strAux.length(); } } } else {
3439    * String strAux = this.getValorAtributoEstruturaItem(estruturasAtributos,
3440    * iett); if(strAux.length() > retorno){ retorno = strAux.length(); } } }
3441    * return retorno; }
3442    */
3443 
3444   /**
3445    * Verifica se o item possui uma determinada situacao nas listas de códigos de
3446    * situacoes.
3447    * @param itemEstrutura
3448    * @param idSituacoes
3449    * @return boolean
3450    * @throws ECARException
3451    */
3452   public boolean verificarSituacao(ItemEstruturaIett itemEstrutura, List idSituacoes) throws ECARException {
3453 
3454     if (itemEstrutura != null && itemEstrutura.getSituacaoSit() != null && idSituacoes != null && idSituacoes.size() > 0) {
3455 
3456       for (Iterator itSituacoes = idSituacoes.iterator(); itSituacoes.hasNext();) {
3457         String codSit = (String) itSituacoes.next();
3458         if (codSit.equals(itemEstrutura.getSituacaoSit().getCodSit().toString()))
3459           return true;
3460       }
3461 
3462     }
3463     return false;
3464   }
3465 
3466   /**
3467    * Filtra uma lista de ItemEstruturaIetts
3468    * @param listaIett
3469    * @param codOrgao
3470    * @param criteriosCom
3471    * @param criteriosSem
3472    * @param situacoes
3473    * @param revisao - utilize "S" para filtrar só os itens que possuem revisão
3474    * @param submitPPA - utilize "S" para filtrar só os itens que possuem PPA
3475    * @return List
3476    * @throws ECARException
3477    */
3478   public List filtrarRelatorioItemEstrutura(List listaIett, Long codOrgao, List criteriosCom, List criteriosSem, List situacoes, String revisao, String submitPPA) throws ECARException {
3479     ItemEstruturaCriterioDao itemCriterioDao = new ItemEstruturaCriterioDao(request);
3480     SisAtributoDao sisAtributoDao = new SisAtributoDao(request);
3481 
3482     Iterator itIetts = listaIett.iterator();
3483     while (itIetts.hasNext()) {
3484       ItemEstruturaIett iett = (ItemEstruturaIett) itIetts.next();
3485 
3486       /* Verificando itens com revisão... */
3487       if ("S".equals(revisao)) {
3488         if (!(iett.getItemEstruturarevisaoIettrevs() != null && iett.getItemEstruturarevisaoIettrevs().size() > 0)) {
3489           itIetts.remove();
3490           continue;
3491         }
3492       }
3493 
3494       /* Verificando itens com PPA */
3495       if ("S".equals(submitPPA)) {
3496 
3497         boolean possuiNivelPPA = false;
3498         List niveisPlanejamento = getNivelAcessoById(iett);
3499         Iterator itNiveis = niveisPlanejamento.iterator();
3500 
3501         while (itNiveis.hasNext()) {
3502           Long codSatb = (Long) itNiveis.next();
3503           SisAtributoSatb nivel = (SisAtributoSatb) sisAtributoDao.buscar(SisAtributoSatb.class, codSatb);
3504 
3505           if (nivel != null && "PPA".equals(nivel.getDescricaoSatb())) {// Não
3506                                                                         // foi
3507                                                                         // usado
3508                                                                         // o
3509                                                                         // codSatb
3510                                                                         // para
3511                                                                         // testar
3512                                                                         // devido
3513                                                                         // às
3514                                                                         // diferenças
3515                                                                         // de
3516                                                                         // códigos
3517                                                                         // em
3518                                                                         // Produção
3519                                                                         // e
3520                                                                         // Desenvolvimento
3521             possuiNivelPPA = true;
3522             break;
3523           }
3524         }
3525 
3526         if (!possuiNivelPPA) {
3527           itIetts.remove();
3528           continue;
3529         }
3530       }
3531 
3532       /* Verificando Órgãos... */
3533       if (codOrgao != null) {
3534         if (iett.getOrgaoOrgByCodOrgaoResponsavel1Iett() != null) {
3535           if (!codOrgao.equals(iett.getOrgaoOrgByCodOrgaoResponsavel1Iett().getCodOrg())) {
3536             itIetts.remove();
3537             continue;
3538           }
3539         }
3540       }
3541 
3542       /* Verificando Critérios... */
3543       if ((criteriosCom != null && criteriosCom.size() > 0) || (criteriosSem != null && criteriosSem.size() > 0)) {
3544         if (!itemCriterioDao.verificarCriterio(iett, criteriosCom, criteriosSem)) {
3545           itIetts.remove();
3546           continue;
3547         }
3548       }
3549 
3550       /* Verificando Situações... */
3551       if (situacoes != null && situacoes.size() > 0) {
3552         if (!this.verificarSituacao(iett, situacoes)) {
3553           itIetts.remove();
3554           continue;
3555         }
3556       }
3557     }
3558 
3559     return listaIett;
3560   }
3561 
3562   /**
3563    * Retorna itens filtrados pela listagem de criterios
3564    * @param itens
3565    * @param idCriteriosCom
3566    * @param idCriteriosSem
3567    * @return
3568    * @throws ECARException
3569    */
3570   public List filtrarItensPorCriterio(ArrayList<ItemEstruturaIettPPA> itens, ArrayList<String> idCriteriosCom, ArrayList<String> idCriteriosSem) throws ECARException {
3571     final ItemEstruturaCriterioDao itemCriterioDao = new ItemEstruturaCriterioDao(request);
3572 
3573     List tmp = itens;
3574     for (Iterator iter = tmp.iterator(); iter.hasNext();) {
3575       ItemEstruturaIett item = (ItemEstruturaIett) iter.next();
3576 
3577       if (!itemCriterioDao.verificarCriterio(item, idCriteriosCom, idCriteriosSem)) {
3578         iter.remove();
3579         continue;
3580       }
3581 
3582     }
3583 
3584     return tmp;
3585 
3586   }
3587 
3588   /**
3589    * Retorna uma Lista de todos os ItemEstruraRevisaoIettrev de um
3590    * ItemEstruturaIett ordenados por Data
3591    * @param codIett
3592    * @return
3593    * @throws ECARException
3594    */
3595   public List getItemEstruturaRevisaoIettrevOrderByData(Long codIett) throws ECARException {
3596     try {
3597       StringBuilder qry = new StringBuilder("select iettRev").append(" from ItemEstruturarevisaoIettrev as iettRev").append(" where iettRev.itemEstruturaIettrev.codIett = :codigo").append(" order by iettRev.dataInclusaoIettrev");
3598 
3599       Query q = this.session.createQuery(qry.toString());
3600       q.setLong("codigo", codIett.longValue());
3601 
3602       return q.list();
3603     } catch (HibernateException e) {
3604       this.logger.error(e);
3605       throw new ECARException("erro.hibernateException");
3606     }
3607   }
3608 
3609   /**
3610    * Recupera Itens de programa para o relatorio PPA
3611    * @param periodoIni Data de inicio para geracao do relatorio
3612    * @param periodoFim Data de termino para geracao do relatorio
3613    * @param nivelIett Nivel estrutura.
3614    * @return Listagem de Itens de Programa <ItemEstruturaIett>
3615    * @throws ECARException
3616    */
3617   public List getItensPPA(String periodoIni, String periodoFim) throws ECARException {
3618     try {
3619       SisAtributoDao sisAtributoDao = new SisAtributoDao(request);
3620       List retorno = new ArrayList();
3621       StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett").append(" where ")
3622       // " iett.nivelIett = :nivelProduto and" +
3623       .append(" iett.dataInicioIett >= :dataIni").append(" and iett.indAtivoIett = 'S'").append(" and (iett.dataTerminoIett is null or iett.dataTerminoIett <= :dataFim)");
3624 
3625       Query q = this.session.createQuery(qry.toString());
3626 
3627       Date dataIni = Data.parseDate("01/01/" + periodoIni);
3628       Date dataFim = Data.parseDate("31/12/" + periodoFim);
3629 
3630       // q.setInteger("nivelProduto", 4);
3631       q.setDate("dataIni", dataIni);
3632       q.setDate("dataFim", dataFim);
3633 
3634       List itens = new ArrayList(q.list());
3635       if (itens != null && itens.size() > 0) {
3636         Iterator itRet = itens.iterator();
3637         while (itRet.hasNext()) {
3638           ItemEstruturaIett iett = (ItemEstruturaIett) itRet.next();
3639 
3640           boolean possuiNivelPPA = false;
3641           List niveisPlanejamento = getNivelAcessoById(iett);
3642           Iterator itNiveis = niveisPlanejamento.iterator();
3643 
3644           while (itNiveis.hasNext()) {
3645             Long codSatb = (Long) itNiveis.next();
3646             SisAtributoSatb nivel = (SisAtributoSatb) sisAtributoDao.buscar(SisAtributoSatb.class, codSatb);
3647             // Não foi usado o codSatb para testar devido às diferenças de
3648             // códigos em Produção e Desenvolvimento
3649             if (nivel != null && "PPA".equals(nivel.getDescricaoSatb())) {
3650               possuiNivelPPA = true;
3651               break;
3652             }
3653           }
3654           if (possuiNivelPPA) {
3655             retorno.add(iett);
3656           }
3657         }
3658       }
3659       return getItensOrdenadosPorSiglaIett(getArvoreItens(retorno, null));
3660     } catch (HibernateException e) {
3661       this.logger.error(e);
3662       throw new ECARException("erro.hibernateException");
3663     }
3664   }
3665 
3666   public List getItensByEstruturaOrdenadosPorItemPai(Long codEstrutura, List codItensPais) throws ECARException {
3667 
3668     try {
3669       StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett").append(" where ").append(" iett.indAtivoIett = 'S' and ").append(" iett.estruturaEtt.codEtt = :codEtt and (");
3670 
3671       Iterator codItensPaisIt = codItensPais.iterator();
3672 
3673       while (codItensPaisIt.hasNext()) {
3674         Long codPai = (Long) codItensPaisIt.next();
3675         qry.append(" iett.itemEstruturaIett.codIett = " + codPai + " or");
3676       }
3677 
3678       StringBuilder newQry = new StringBuilder(qry.substring(0, qry.length() - 2));
3679       newQry.append(")");
3680 
3681       newQry.append(" order by iett.itemEstruturaIett.codIett, iett.nomeIett");
3682 
3683       Query q = this.session.createQuery(newQry.toString());
3684 
3685       q.setLong("codEtt", codEstrutura.longValue());
3686 
3687       return q.list();
3688 
3689     } catch (HibernateException e) {
3690       this.logger.error(e);
3691       throw new ECARException("erro.hibernateException");
3692     }
3693   }
3694 
3695   public List getItensByEstrutura(Long codEstrutura) throws ECARException {
3696     try {
3697       StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett").append(" where ").append(" iett.indAtivoIett = 'S' and ").append(" iett.estruturaEtt.codEtt = :codEtt").append(" order by iett.itemEstruturaIett.codIett, iett.nomeIett");
3698 
3699       Query q = this.session.createQuery(qry.toString());
3700 
3701       q.setLong("codEtt", codEstrutura.longValue());
3702 
3703       return q.list();
3704 
3705     } catch (HibernateException e) {
3706       this.logger.error(e);
3707       throw new ECARException("erro.hibernateException");
3708     }
3709   }
3710 
3711   public List getItensByEstruturaPPA(Long codEstrutura) throws ECARException {
3712     try {
3713       StringBuilder qry = new StringBuilder("from ItemEstruturaIettPPA as iett").append(" where ").append(" iett.indAtivoIett = 'S' and ").append(" iett.estruturaEtt.codEtt = :codEtt").append(" order by iett.nomeIett  ");
3714 
3715       Query q = this.session.createQuery(qry.toString());
3716       q.setLong("codEtt", codEstrutura.longValue());
3717 
3718       return q.list();
3719 
3720     } catch (HibernateException e) {
3721       this.logger.error(e);
3722       throw new ECARException("erro.hibernateException");
3723     }
3724   }
3725 
3726   /**
3727    * Listar somente itens com revisão.
3728    * @return List
3729    * @throws ECARException
3730    */
3731 
3732   /*
3733    * Este método só é usado nos Relatório dos Apêndices do PPA
3734    */
3735   public List getArvoreItensIettComRevisao(String tipoApendice, String periodoIni, String periodoFim) throws ECARException {
3736     try {
3737       SisAtributoDao sisAtributoDao = new SisAtributoDao(request);
3738       List retorno = new ArrayList();
3739       StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett").append(" where ")
3740       // " iett.nivelIett = :nivelProduto and" +
3741       .append(" iett.indAtivoIett = 'S'").append(" and iett.dataInicioIett >= :dataIni").append(" and (iett.dataTerminoIett is null or iett.dataTerminoIett <= :dataFim)");
3742 
3743       Query q = this.session.createQuery(qry.toString());
3744 
3745       Date dataIni = Data.parseDate("01/01/" + periodoIni);
3746       Date dataFim = Data.parseDate("31/12/" + periodoFim);
3747 
3748       // q.setInteger("nivelProduto", 4);
3749       q.setDate("dataIni", dataIni);
3750       q.setDate("dataFim", dataFim);
3751 
3752       List itens = new ArrayList(q.list());
3753       if (itens != null && itens.size() > 0) {
3754         Iterator itRet = itens.iterator();
3755         while (itRet.hasNext()) {
3756           ItemEstruturaIett iett = (ItemEstruturaIett) itRet.next();
3757 
3758           boolean possuiNivelPPA = false;
3759           List niveisPlanejamento = getNivelAcessoById(iett);
3760           Iterator itNiveis = niveisPlanejamento.iterator();
3761 
3762           while (itNiveis.hasNext()) {
3763             Long codSatb = (Long) itNiveis.next();
3764             SisAtributoSatb nivel = (SisAtributoSatb) sisAtributoDao.buscar(SisAtributoSatb.class, codSatb);
3765 
3766             if (nivel != null && "PPA".equals(nivel.getDescricaoSatb())) {// Não
3767                                                                           // foi
3768                                                                           // usado
3769                                                                           // o
3770                                                                           // codSatb
3771                                                                           // para
3772                                                                           // testar
3773                                                                           // devido
3774                                                                           // às
3775                                                                           // diferenças
3776                                                                           // de
3777                                                                           // códigos
3778                                                                           // em
3779                                                                           // Produção
3780                                                                           // e
3781                                                                           // Desenvolvimento
3782               possuiNivelPPA = true;
3783               break;
3784             }
3785           }
3786           if (possuiNivelPPA) {
3787             retorno.add(iett);
3788           }
3789         }
3790       }
3791       /*
3792        * Esta parte foi comentada pois, ref. mantis 5042, o sistema buscará
3793        * todos os campos na estrutura normal dos itens do eCAr,
3794        * segmentoCategoria.setSegmentoCategTpAcessSgts(new HashSet());
3795        * if(!segmentoCategoria
3796        * .getSegmentoCategTpAcessSgts().contains(atributo)){
3797        * segmentoCategoria.getSegmentoCategTpAcessSgts().add(atributo); }
3798        * ignorando portanto a tabela revisão. List itens = new
3799        * ArrayList(q.list()); if(itens != null && itens.size() > 0){ Iterator
3800        * itRet = itens.iterator(); while(itRet.hasNext()){ ItemEstruturaIett
3801        * iett = (ItemEstruturaIett) itRet.next(); List itensRev = new
3802        * ArrayList(iett.getItemEstruturarevisaoIettrevs()); Iterator itRev =
3803        * itensRev.iterator(); while(itRev.hasNext()){
3804        * ItemEstruturarevisaoIettrev iettRev = (ItemEstruturarevisaoIettrev)
3805        * itRev.next(); if("apendice2".equals(tipoApendice)){
3806        * //if("I".equals(iettRev.getSituacaoIettrev()) ||
3807        * "A".equals(iettRev.getSituacaoIettrev())){
3808        * if(!"E".equals(iettRev.getSituacaoIettrev())){ retorno.add(iett);
3809        * break;arg0 } } else if("apendice3".equals(tipoApendice)){
3810        * if("E".equals(iettRev.getSituacaoIettrev())){ retorno.add(iett); break;
3811        * } } } } }
3812        */
3813 
3814       return getItensOrdenadosPorSiglaIett(getArvoreItens(retorno, null));
3815     } catch (HibernateException e) {
3816       this.logger.error(e);
3817       throw new ECARException("erro.hibernateException");
3818     }
3819   }
3820 
3821   /**
3822    * Retorna lista de Itens da Estrutura de acordo com a data dataTerminoIett,
3823    * dataInicioIett, dataR1, dataR2, dataR3, dataR4, dataR5. <br>
3824    * @author rogerio
3825    * @version 0.1, 09/02/2007
3826    * @param dataLimiteStr
3827    * @return List
3828    * @throws ECARException
3829    */
3830   public List listarItemEstruturaPorDataLimite(String dataLimiteStr) throws ECARException {
3831     List list = null;
3832 
3833     try {
3834       Query query = session.createQuery(" from ItemEstruturaIett " + " where indAtivoIett = 'S' and dataTerminoIett = :data or dataInicioIett = :data " + " or dataR1 = :data or dataR2 = :data or dataR3 = :data " + " or dataR4 = :data or dataR5 = :data ");
3835 
3836       Date data = Data.parseDate(dataLimiteStr);
3837       query.setDate("data", data);
3838 
3839       list = query.list();
3840     } catch (HibernateException e) {
3841       this.logger.error(e);
3842       throw new ECARException("erro.hibernateException");
3843     }
3844 
3845     return list;
3846   } // fim listarItemEstruturaPorDataLimite
3847 
3848   /**
3849    * Retorna lista de Itens da Estrutura de um determinado nível
3850    * @author cristiano
3851    * @version 0.1, 13/02/2007
3852    * @param int nivel
3853    * @return List
3854    * @throws ECARException
3855    */
3856   public List listarItemEstruturaPorNivel(int nivel) throws ECARException {
3857     Query query = session.createQuery(" from ItemEstruturaIett where nivelIett = :nivel and indAtivoIett = 'S'");
3858 
3859     query.setInteger("nivel", nivel);
3860 
3861     return query.list();
3862   }
3863 
3864   /**
3865    * Método que verifica se um item possui itens filhos com indicador de etapas
3866    * de nível superior na estrutura.
3867    * @author aleixo
3868    * @version 0.2 - 26/03/2007, 0.1 - 21/03/2007
3869    * @param ItemEstruturaIett item - Item a ser verificado
3870    * @return boolean
3871    */
3872   public boolean verificaItemPossuiEtapas(ItemEstruturaIett item) {
3873     return !this.getEtapasIett(item).isEmpty();
3874   }
3875 
3876   /**
3877    * Retorna uma lista com as etapas de um item.<br>
3878    * Etapas de um item são os itens filhos de um item que possuem indicador de
3879    * etapa de nível superior na estrutura.
3880    * @author aleixo
3881    * @version 0.1, 22/03/2007
3882    * @param ItemEstruturaIett item
3883    * @return List
3884    */
3885   public List getEtapasIett(ItemEstruturaIett item) {
3886     List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
3887 
3888     if (item.getItemEstruturaIetts() != null) {
3889       /*
3890        * Aqui, pegar somente as etapas que são filhos de 1ª geração do item
3891        * (somentes os filhos do item), ignorando os outros descendentes do item
3892        * (.getDescendentes()), como filhos dos filhos, ou filhos dos filhos dos
3893        * filhos, etc...;
3894        */
3895 
3896       for (Iterator itEtapas = item.getItemEstruturaIetts().iterator(); itEtapas.hasNext();) {
3897         ItemEstruturaIett iettFilho = (ItemEstruturaIett) itEtapas.next();
3898 
3899         if ("S".equals(iettFilho.getEstruturaEtt().getIndEtapaNivelSuperiorEtt())) {
3900           retorno.add(iettFilho);
3901         }
3902       }
3903     }
3904     return retorno;
3905   }
3906 
3907   /**
3908    * Retorna uma lista de {@link ItemWebServiceBean} para os WebSerices,
3909    * utilizando SQL Nativo.
3910    * @author aleixo
3911    * @version 0.1 - 05/04/2007
3912    * @param Long[] codigos - Este parâmetro possui 2 utilizações:<br>
3913    *          Se buscarEstrutura = true, este parâmetro é um Array dos
3914    *          <b>códigos da estrutura dos itens</b> a serem buscados.<br>
3915    *          Se buscarEstrutura = false, este parâmetro é um Array dos
3916    *          <b>códigos dos itens</b> a serem buscados.<br>
3917    * <br>
3918    * @param boolean buscarFilhos - Sendo:<br>
3919    *        &nbsp;&nbsp;&nbsp;<b>true</b>: Retorna a lista de itens filhos do
3920    *        bean ({@link ItemWebServiceBean}.itensFilhos) recursivamente (para
3921    *        cada filho, seta uma lista dos filhos e assim sucessivamente).<br>
3922    *        &nbsp;&nbsp;&nbsp;<b>false</b>: Retorna a lista de itens filhos do
3923    *        bean ({@link ItemWebServiceBean}.itensFilhos) vazia.
3924    * @param boolean buscaEstrutura - Sendo:<br>
3925    *        &nbsp;&nbsp;&nbsp;<b>true</b>: Retorna a lista de itens da(s)
3926    *        estrutura(s) informada(s) no primeiro parâmetro (codigos).<br>
3927    *        &nbsp;&nbsp;&nbsp;<b>false</b>: Retorna a lista de itens dos códigos
3928    *        informados.
3929    * @return List
3930    */
3931   public List getIettToWebService(Long[] codigos, boolean buscarFilhos, boolean buscarEstrutura) {
3932     List<ItemWebServiceBean> retorno = new ArrayList<ItemWebServiceBean>();
3933 
3934     try {
3935 
3936       if (codigos == null || (codigos != null && codigos.length < 1))
3937         return retorno;
3938 
3939       // Seleciono os itens pedidos no banco de dados.
3940 
3941       StringBuilder select = new StringBuilder();
3942 
3943       select.append("select item.cod_iett, ");
3944       select.append("item.nome_iett, ");
3945       select.append("item.ind_ativo_iett, ");
3946       select.append("item.data_inicio_iett, ");
3947       select.append("item.data_termino_iett, ");
3948       select.append("orgao.descricao_org, ");
3949       select.append("orgao.sigla_org ");
3950       select.append("from tb_item_estrutura_iett item ");
3951 
3952       // Utilizando "left join" para que exiba os dados, mesmo que não exista a
3953       // relação orgao -> item
3954       select.append(" left join tb_orgao_org orgao");
3955       select.append(" on orgao.cod_org = item.cod_orgao_responsavel1_iett");
3956 
3957       if (buscarEstrutura) {
3958         select.append(" where item.cod_ett ");
3959       }
3960       else {
3961         select.append(" where item.cod_iett ");
3962       }
3963 
3964       select.append(" in (");
3965 
3966       // Montando lista de codigos com virgulas para ser usado na cláusula IN do
3967       // select.
3968       String cods = "";
3969       int ultimaPosicao = codigos.length - 1;
3970       for (int i = 0; i < codigos.length; i++) {
3971         Long codigo = codigos[i];
3972         cods += codigo.toString();
3973         if (i != ultimaPosicao) {
3974           cods += ", ";
3975         }
3976       }
3977       select.append(cods + ")");
3978 
3979       SQLQuery q = this.session.createSQLQuery(select.toString());
3980 
3981       List objects = q.list();
3982 
3983       // Com a lista obtida, percorro a lista para popular os beans... retornar
3984 
3985       Iterator itObj = objects.iterator();
3986       while (itObj.hasNext()) {
3987         Object[] item = (Object[]) itObj.next();
3988         /*
3989          * item é um array de Object, onde: posição | Conteudo
3990          * ---------------------------------------- 0 | codIett 1 | nomeIett 2 |
3991          * indAtivoIett 3 | dataInicioIett 4 | dataTerminoIett 5 | nomeCliente 6
3992          * | siglaCliente
3993          */
3994 
3995         ItemWebServiceBean iwsBean = new ItemWebServiceBean();
3996 
3997         Long codItem = item[0] != null ? Long.valueOf(item[0].toString()) : null;
3998         String nomeItem = item[1] != null ? item[1].toString() : null;
3999         String indAtivo = item[2] != null ? item[2].toString() : null;
4000 
4001         Date dataInicial = null;
4002         if (item[3] != null)
4003           dataInicial = Data.parseDate(item[3].toString(), "yyyy-mm-dd hh:mm:ss.S");
4004 
4005         Date dataFinal = null;
4006         if (item[4] != null)
4007           dataFinal = Data.parseDate(item[4].toString(), "yyyy-mm-dd hh:mm:ss.S");
4008 
4009         // Setando dados referentes ao item
4010         iwsBean.setCodItem(codItem);
4011         iwsBean.setNomeItem(nomeItem);
4012         iwsBean.setIndAtivo(indAtivo);
4013         iwsBean.setDataInicial(dataInicial);
4014         iwsBean.setDataFinal(dataFinal);
4015 
4016         // Setando dados referentes ao Orgão/Cliente
4017         String nomeCliente = item[5] != null ? item[5].toString() : null;
4018         String siglaCliente = item[6] != null ? item[6].toString() : null;
4019         iwsBean.setNomeCliente(nomeCliente);
4020         iwsBean.setSiglaCliente(siglaCliente);
4021 
4022         // Setando coleção de itens filhos
4023         ArrayList filhos = new ArrayList();
4024         if (buscarFilhos && codItem != null) {
4025           List codFilhos = this.getItensFilhosWebService(codItem);
4026           Iterator itFilhos = codFilhos.iterator();
4027 
4028           Long[] codigosFilhos = new Long[codFilhos.size()];
4029           int i = 0;
4030           while (itFilhos.hasNext()) {
4031             Object codFilho = (Object) itFilhos.next();
4032             if (codFilho != null) {
4033               Long codFilhoLong = Long.valueOf(codFilho.toString());
4034               codigosFilhos[i] = codFilhoLong;
4035               i++;
4036             }
4037           }
4038           /*
4039            * Para os filhos, passo buscaEstrutura = false, para que busque os
4040            * filhos pelos códigos dos filhos, e não pelo código da estrutura dos
4041            * filhos.
4042            */
4043           filhos.addAll(this.getIettToWebService(codigosFilhos, buscarFilhos, false));
4044         }
4045         iwsBean.setItensFilhos(filhos);
4046 
4047         // Setando dados referentes ao nível de planejamento/Fase
4048         ArrayList<IndicativoItemWebServiceBean> indicativos = new ArrayList<IndicativoItemWebServiceBean>();
4049         List codNiveis = this.getNivelIettWebService(codItem);
4050         Iterator itCodNiveis = codNiveis.iterator();
4051         while (itCodNiveis.hasNext()) {
4052           Object[] o = (Object[]) itCodNiveis.next();
4053 
4054           IndicativoItemWebServiceBean indicativoBean = new IndicativoItemWebServiceBean();
4055 
4056           indicativoBean.setCodIndicativo((o[0] != null) ? Long.valueOf(o[0].toString()) : null);
4057           indicativoBean.setDescricaoIndicativo((o[1] != null) ? o[1].toString() : null);
4058 
4059           indicativos.add(indicativoBean);
4060         }
4061         iwsBean.setIndicativoItem(indicativos);
4062         retorno.add(iwsBean);
4063       }
4064     } catch (Exception e) {
4065       e.printStackTrace();
4066     }
4067 
4068     return retorno;
4069   }
4070 
4071   /**
4072    * Retorna os códigos dos itens filhos de um item, utilizando SQL Nativo.
4073    * @author aleixo
4074    * @version 0.1 - 09/04/2007
4075    * @param Long codIett - código do item
4076    * @return List
4077    */
4078   private List getItensFilhosWebService(Long codIett) {
4079     StringBuilder select = new StringBuilder();
4080 
4081     select.append("select cod_iett from tb_item_estrutura_iett ");
4082     select.append(" where  cod_iett_pai = " + codIett.toString());
4083     SQLQuery q = this.session.createSQLQuery(select.toString());
4084 
4085     List objects = q.list();
4086 
4087     if (objects != null && !objects.isEmpty())
4088       return objects;
4089     return new ArrayList();
4090   }
4091 
4092   /**
4093    * Retorna uma lista o código e a descrição do nível de planejamento/fase.,
4094    * utilizando SQL Nativo<br>
4095    * código = posição [0]<br>
4096    * descrição = posicao [1].
4097    * @author aleixo
4098    * @version 0.1 - 09/04/2007
4099    * @param Long codIett - código do item.
4100    * @return List
4101    */
4102   private ArrayList getNivelIettWebService(Long codIett) {
4103     StringBuilder select = new StringBuilder();
4104 
4105     select.append("select atb.cod_satb, atb.descricao_satb from tb_item_estrutura_nivel_iettn nivel, tb_sis_atributo_satb atb ");
4106     select.append(" where  nivel.cod_iett = " + codIett.toString());
4107     select.append(" and atb.cod_satb = nivel.cod_atb");
4108     SQLQuery q = this.session.createSQLQuery(select.toString());
4109 
4110     ArrayList objects = (ArrayList) q.list();
4111 
4112     if (objects != null && !objects.isEmpty())
4113       return objects;
4114 
4115     return new ArrayList();
4116   }
4117 
4118   /**
4119    * Retorna uma lista de itens ItemWSMinBean, que contém apenas o código
4120    * (sigla) e a descrição (nome) de cada item.<br>
4121    * Se codigo != null: Retorna dados de apenas um item. Se codigo == null ou
4122    * vazio: Retorna dados de todos os itens. Se nivel != null: Filtra itens de
4123    * determinado(s) nível(is) de estrutura(s). Se nivel == null ou vazio:
4124    * Considera todos os níveis de estrutura.
4125    * @author aleixo
4126    * @since 29/05/2007
4127    * @param String codigo.
4128    * @param Long[] niveis.
4129    * @return List
4130    */
4131   public List listIettToWSMin(String codigo, Long[] niveis) {
4132     List<ItemWSMinBean> retorno = new ArrayList<ItemWSMinBean>();
4133 
4134     // Seleciono os itens pedidos no banco de dados.
4135 
4136     StringBuilder select = new StringBuilder();
4137 
4138     select.append("select item.sigla_iett, item.nome_iett ");
4139     select.append("from tb_item_estrutura_iett item ");
4140 
4141     boolean where = false;
4142     if (codigo != null && !"".equals(codigo.trim())) {
4143       where = true;
4144       select.append(" where item.sigla_iett = :codigo");
4145     }
4146 
4147     if (niveis != null && niveis.length > 0) {
4148       select.append(!where ? " where " : " and ");
4149 
4150       select.append(" item.cod_ett in (");
4151 
4152       String strNiveis = "";
4153       int ultimaPosicao = niveis.length - 1;
4154       for (int i = 0; i < niveis.length; i++) {
4155         Long nivel = niveis[i];
4156         strNiveis += nivel.toString();
4157         if (i != ultimaPosicao) {
4158           strNiveis += ", ";
4159         }
4160       }
4161 
4162       select.append(strNiveis + ")");
4163     }
4164 
4165     select.append(" order by item.sigla_iett");
4166 
4167     SQLQuery q = this.session.createSQLQuery(select.toString());
4168 
4169     if (codigo != null && !"".equals(codigo.trim())) {
4170       q.setString("codigo", codigo);
4171     }
4172 
4173     List objects = q.list();
4174 
4175     if (objects != null && !objects.isEmpty()) {
4176       for (Iterator it = objects.iterator(); it.hasNext();) {
4177         Object[] o = (Object[]) it.next();
4178         /*
4179          * item é um array de Object, onde: posição | Conteudo
4180          * ---------------------------------------- 0 | siglaIett 1 | nomeIett
4181          */
4182 
4183         ItemWSMinBean item = new ItemWSMinBean();
4184 
4185         item.setCodItem((o[0] != null) ? o[0].toString() : "");
4186         item.setNomeItem((o[1] != null) ? o[1].toString() : "");
4187         retorno.add(item);
4188       }
4189     }
4190     return retorno;
4191   }
4192 
4193   /**
4194    * Retorna um item de determinada sigla em uma estrutura.<br>
4195    * Caso estrutura seja nula, a pesquisa é feita em todas as estruturas.
4196    * @author aleixo
4197    * @since 27/07/2007
4198    * @param sigla
4199    * @param estrutura
4200    * @return ItemEstruturaIett
4201    */
4202   public ItemEstruturaIett getIettBySigla(String sigla, EstruturaEtt estrutura) throws ECARException {
4203     try {
4204       StringBuilder s = new StringBuilder();
4205       s.append("select iett from ItemEstruturaIett iett where iett.siglaIett = :sigla and iett.indAtivoIett = 'S'");
4206 
4207       if (estrutura != null) {
4208         s.append(" and iett.estruturaEtt.codEtt = :estrutura");
4209       }
4210 
4211       Query q = this.session.createQuery(s.toString());
4212 
4213       q.setString("sigla", sigla);
4214 
4215       if (estrutura != null) {
4216         q.setLong("estrutura", estrutura.getCodEtt().longValue());
4217       }
4218 
4219       q.setMaxResults(1);
4220 
4221       Object o = q.uniqueResult();
4222 
4223       return (o != null) ? (ItemEstruturaIett) o : null;
4224 
4225     } catch (Exception e) {
4226       this.logger.error(e);
4227       throw new ECARException(e);
4228     }
4229   }
4230 
4231   /**
4232    * Retorna os Itens de Estrutura que podem ser selecionados de acordo com a
4233    * Sala de Situação.<br>
4234    * @author
4235    * @since
4236    * @param listaItensSelecionaveis
4237    * @param ta Tipo de Acompanhamento onde está definido Sala de Situação
4238    * @return List Lista com os itens de estrutura selecionáveis filtrados pela
4239    *         Sala de Situação
4240    */
4241   public List getItensSelecionaveisFiltradosPorAtributo(List listaItensSelecionaveis, TipoAcompanhamentoTa ta) throws ECARException {
4242 
4243     List listaRetorno = new ArrayList();
4244     List listaIettPai = new ArrayList();
4245     EstruturaAtributoDao estruturaAtributoDao = new EstruturaAtributoDao(request);
4246 
4247     ConfiguracaoDao configuracaoDao = new ConfiguracaoDao(request);
4248 
4249     try {
4250 
4251       boolean tipoAcompPossuiNivelPlanejamento = false;
4252 
4253       if (ta.getSisAtributoSatbs() != null && ta.getSisAtributoSatbs().size() > 0) {
4254 
4255         Iterator itSisAtributosTa = ta.getSisAtributoSatbs().iterator();
4256 
4257         while (itSisAtributosTa.hasNext()) {
4258 
4259           SisAtributoSatb sisAtributo = (SisAtributoSatb) itSisAtributosTa.next();
4260 
4261           // Se for nivel de planejamento
4262           if (sisAtributo.getSisGrupoAtributoSga().equals(configuracaoDao.getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan())) {
4263 
4264             tipoAcompPossuiNivelPlanejamento = true;
4265             break;
4266           }
4267         }
4268       }
4269 
4270       if (listaItensSelecionaveis != null && listaItensSelecionaveis.size() > 0 && tipoAcompPossuiNivelPlanejamento) {
4271 
4272         // if (ta.getSisAtributoSatbs() != null &&
4273         // ta.getSisAtributoSatbs().size() > 0){
4274         //	    		
4275         // Iterator itSisAtributosTA = ta.getSisAtributoSatbs().iterator();
4276         //	    			
4277         // ConfiguracaoDao configuracaoDao = new ConfiguracaoDao(null);
4278         // boolean tipoAcompPossuiNivelPlanejamento = false;
4279         //	    			
4280         // while (itSisAtributosTA.hasNext()){
4281         //	    				
4282         // SisAtributoSatb sisAtb = (SisAtributoSatb) itSisAtributosTA.next();
4283         //	    				
4284         // if
4285         // (sisAtb.getSisGrupoAtributoSga().equals(configuracaoDao.getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan())){
4286         // tipoAcompPossuiNivelPlanejamento = true;
4287         // break;
4288         // }
4289         // }
4290 
4291         // if (tipoAcompPossuiNivelPlanejamento){
4292 
4293         Iterator itListaItensSelecionaveis = listaItensSelecionaveis.iterator();
4294 
4295         // percorre a lista de itens selecionaveis
4296         while (itListaItensSelecionaveis.hasNext()) {
4297 
4298           AtributoEstruturaListagemItens atbList = (AtributoEstruturaListagemItens) itListaItensSelecionaveis.next();
4299           ItemEstruturaIett iett = atbList.getItem();
4300 
4301           if (iett.getItemEstruturaNivelIettns() != null && iett.getItemEstruturaNivelIettns().size() > 0) {
4302             Iterator itListaAtributoItemEstrutura = iett.getItemEstruturaNivelIettns().iterator();
4303 
4304             // percorre a lista de atributos de cada item de estrutura
4305             while (itListaAtributoItemEstrutura.hasNext()) {
4306               SisAtributoSatb nivel = (SisAtributoSatb) itListaAtributoItemEstrutura.next();
4307 
4308               if (nivel.getSisGrupoAtributoSga().equals(configuracaoDao.getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan()) && ta.getSisAtributoSatbs().contains(nivel)) {
4309                 if (atbList.getItem().getItemEstruturaIett() != null && !listaIettPai.contains(atbList.getItem().getItemEstruturaIett())) {
4310                   Iterator itListaRetorno = listaRetorno.iterator();
4311                   boolean achou = false;
4312                   while (itListaRetorno.hasNext()) {
4313                     AtributoEstruturaListagemItens atbEstruturaListagemItens = (AtributoEstruturaListagemItens) itListaRetorno.next();
4314                     if (atbEstruturaListagemItens.getItem().equals(atbList.getItem().getItemEstruturaIett())) {
4315                       achou = true;
4316                     }
4317                   }
4318                   if (!achou) {
4319                     AtributoEstruturaListagemItens atEstListagem = new AtributoEstruturaListagemItens();
4320                     atEstListagem.setDescricao(estruturaAtributoDao.getDescricaoItemByAtributo(atbList.getItem().getItemEstruturaIett(), ta));
4321                     atEstListagem.setItem(atbList.getItem().getItemEstruturaIett());
4322                     listaRetorno.add(atEstListagem);
4323                     listaIettPai.add(atbList.getItem().getItemEstruturaIett());
4324                   }
4325                 }
4326                 listaRetorno.add(atbList);
4327               }
4328             }
4329           }
4330 
4331         } // fim do while
4332 
4333         return listaRetorno;
4334       }// fim do if
4335       else {
4336         return listaItensSelecionaveis;
4337       }
4338 
4339       // return listaRetorno;
4340 
4341     } catch (Exception e) {
4342       this.logger.error(e);
4343       throw new ECARException(e);
4344     }
4345 
4346   }
4347 
4348   /**
4349    * Ordena os itens de acordo com o que foi definido nas configurações de tipo
4350    * de Acompanhamento. Funciona da mesma maneira do que "getItensOrdenados" só
4351    * que não acrescenta os pais à lista.
4352    * @param List itens
4353    * @param TipoAcompanhamentoTa tipoAcomp
4354    * @return List
4355    * @throws ECARException
4356    * @author José André
4357    */
4358   public List getItensOrdenadosSemPai(List itens, TipoAcompanhamentoTa tipoAcomp) throws ECARException {
4359     List listRetorno = new ArrayList();
4360 
4361     EstruturaAtributoDao estruturaAtributoDao = new EstruturaAtributoDao(null);
4362 
4363     /*
4364      * 1) Pegar qual os campos de ordenação que é apresentado em cada estrutura.
4365      * Ordenar campos da estrutura (EstruturaAtributo) pela sequencia de
4366      * apresentação (seqApresListagemTelaEttat) e pegar o primeiro campo que
4367      * possuir Listagem Impressa Relação (indRelacaoImpressaEttat) = "S". Se uma
4368      * estrutura não estiver apresentada neste filtro informado, assume que o
4369      * Primeiro Atributo Valido desta estrutura é o CodIett.
4370      */
4371     List estruturasAtributos = estruturaAtributoDao.getAtributosValidoEstruturas(tipoAcomp);
4372 
4373     // Descubro o maior length dos campos dos itens para preencher com ZEROS
4374     // para ordenação.
4375     int tamanho = this.getTamanhoMaximoAtributoEstruturaItem(estruturasAtributos, itens, tipoAcomp);
4376 
4377     for (Iterator it = itens.iterator(); it.hasNext();) {
4378       ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
4379 
4380       if (iett.getIndAtivoIett() != null && !Dominios.SIM.equals(iett.getIndAtivoIett())) {
4381         it.remove();
4382       }
4383     }
4384 
4385     // montar a árvore completa de itens
4386     // List listItensComPais = new ArrayList(this.getArvoreItens(itens, null));
4387 
4388     // montar os objetos OrdenacaoIett
4389     List listNiveis = new ArrayList();
4390     List listOrdenacaoIett = new ArrayList();
4391     Iterator itItens = itens.iterator();
4392     while (itItens.hasNext()) {
4393       ItemEstruturaIett iett = (ItemEstruturaIett) itItens.next();
4394 
4395       if (iett.getIndAtivoIett() != null && !Dominios.SIM.equals(iett.getIndAtivoIett())) {
4396         continue;
4397       }
4398 
4399       OrdenacaoIett ord = new OrdenacaoIett();
4400 
4401       ord.setIett(iett);
4402 
4403       if (!listNiveis.contains(iett.getNivelIett())) {
4404         listNiveis.add(iett.getNivelIett());
4405       }
4406 
4407       ord.setCampoOrdenar(this.getValorAtributoEstruturaItem(estruturasAtributos, iett, tamanho, tipoAcomp));
4408 
4409       if (ord.getCampoOrdenar() == null) {
4410         ord.setCampoOrdenar("");
4411       }
4412 
4413       listOrdenacaoIett.add(ord);
4414     }
4415 
4416     // ordenar a lista de níveis: 1, 2, 3, ... n
4417     Collections.sort(listNiveis, new Comparator() {
4418       public int compare(Object o1, Object o2) {
4419         Integer ord1 = (Integer) o1;
4420         Integer ord2 = (Integer) o2;
4421 
4422         return ord1.compareTo(ord2);
4423       }
4424     });
4425 
4426     // Gerar uma lista de itens para cada nível
4427     List listOrdenacaoPorNivel = new ArrayList();
4428     Iterator itNiveis = listNiveis.iterator();
4429     while (itNiveis.hasNext()) {
4430       Integer nivel = (Integer) itNiveis.next();
4431 
4432       OrdenacaoPorNivel opn = new OrdenacaoPorNivel();
4433       opn.setNivel(nivel);
4434       opn.setOrdenacaoIett(new ArrayList());
4435 
4436       itItens = listOrdenacaoIett.iterator();
4437       while (itItens.hasNext()) {
4438         OrdenacaoIett ord = (OrdenacaoIett) itItens.next();
4439 
4440         if (nivel.equals(ord.getIett().getNivelIett())) {
4441           opn.getOrdenacaoIett().add(ord);
4442         }
4443       }
4444       listOrdenacaoPorNivel.add(opn);
4445     }
4446 
4447     // ordenar a lista de OrdenacaoPorNivel, aplicando regra de ordenamento
4448     itNiveis = listOrdenacaoPorNivel.iterator();
4449     while (itNiveis.hasNext()) {
4450       OrdenacaoPorNivel opn = (OrdenacaoPorNivel) itNiveis.next();
4451 
4452       Collections.sort(opn.getOrdenacaoIett(), new Comparator() {
4453         public int compare(Object o1, Object o2) {
4454           OrdenacaoIett ord1 = (OrdenacaoIett) o1;
4455           OrdenacaoIett ord2 = (OrdenacaoIett) o2;
4456 
4457           return ord1.getCampoOrdenar().compareToIgnoreCase(ord2.getCampoOrdenar());
4458         }
4459       });
4460     }
4461 
4462     // organizar os itens de acordo com a hierarquia de
4463     // pai/filho/neto/bisneto/etc a partir dos itens do primeiro nível
4464     List itensOrganizados = new ArrayList();
4465     if (!listOrdenacaoPorNivel.isEmpty()) {
4466       OrdenacaoPorNivel opn = (OrdenacaoPorNivel) listOrdenacaoPorNivel.get(0);
4467 
4468       itNiveis = opn.getOrdenacaoIett().iterator();
4469       while (itNiveis.hasNext()) {
4470         OrdenacaoIett ord = (OrdenacaoIett) itNiveis.next();
4471 
4472         List listIettAux = getItemFilhoOrdenacaoPorNivel(ord.getIett(), listOrdenacaoPorNivel);
4473         itensOrganizados.addAll(listIettAux);
4474       }
4475     }
4476 
4477     Iterator it = itensOrganizados.iterator();
4478 
4479     while (it.hasNext()) {
4480       ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
4481 
4482       AtributoEstruturaListagemItens atEstListagem = new AtributoEstruturaListagemItens();
4483       atEstListagem.setDescricao(estruturaAtributoDao.getDescricaoItemByAtributo(iett, tipoAcomp));
4484       atEstListagem.setItem(iett);
4485 
4486       listRetorno.add(atEstListagem);
4487     }
4488 
4489     return listRetorno;
4490 
4491   }
4492 
4493   /**
4494    * Retorna os SisAtributos do grupo e do Iett passados.<br>
4495    * @author
4496    * @since 27/07/2008
4497    * @param iett
4498    * @param codSisGrupoAtributo
4499    * @return List
4500    */
4501   public List getSisAtributosIett(ItemEstruturaIett iett, Long codSisGrupoAtributo) {
4502     List listaRetorno = new ArrayList();
4503     if (iett.getItemEstruturaSisAtributoIettSatbs() != null) {
4504       Iterator it = iett.getItemEstruturaSisAtributoIettSatbs().iterator();
4505       while (it.hasNext()) {
4506         ItemEstruturaSisAtributoIettSatb iettSatb = (ItemEstruturaSisAtributoIettSatb) it.next();
4507         if (iettSatb.getSisAtributoSatb().getSisGrupoAtributoSga().getCodSga().equals(codSisGrupoAtributo)) {
4508           listaRetorno.add(iettSatb.getSisAtributoSatb());
4509         }
4510       }
4511     }
4512 
4513     return listaRetorno;
4514 
4515   }
4516 
4517   /**
4518    * Retorna os ItemEstruturaSisAtributoIettSatbs do grupo e do Iett passados.<br>
4519    * @author
4520    * @since 27/07/2008
4521    * @param codSisGrupoAtributo
4522    * @return List
4523    */
4524   public List getItemEstruturaSisAtributoIettSatbsIett(ItemEstruturaIett iett, Long codSisGrupoAtributo) {
4525     List listaRetorno = new ArrayList();
4526     if (iett.getItemEstruturaSisAtributoIettSatbs() != null) {
4527       Iterator it = iett.getItemEstruturaSisAtributoIettSatbs().iterator();
4528       while (it.hasNext()) {
4529         ItemEstruturaSisAtributoIettSatb iettSatb = (ItemEstruturaSisAtributoIettSatb) it.next();
4530         if (iettSatb.getSisAtributoSatb().getSisGrupoAtributoSga().getCodSga().equals(codSisGrupoAtributo)) {
4531           listaRetorno.add(iettSatb);
4532         }
4533       }
4534     }
4535 
4536     return listaRetorno;
4537 
4538   }
4539 
4540   /**
4541    * Extrai de uma colection ordenada os filhos imediatos do itemEstrutura
4542    * passado.
4543    * @param itemEstrutura
4544    * @param colecaoItens
4545    * @return Lista com os descendentes imediatos
4546    */
4547   public List<AtributoEstruturaListagemItens> recuperaDescendentesImediatos(ItemEstruturaIett itemEstrutura, List<AtributoEstruturaListagemItens> colecaoItens) {
4548     List<AtributoEstruturaListagemItens> retornoList = new ArrayList<AtributoEstruturaListagemItens>();
4549     AtributoEstruturaListagemItens atEstListagem = null;
4550     ItemEstruturaIett item = null;
4551     Iterator colecaoItensIt = colecaoItens.iterator();
4552 
4553     while (colecaoItensIt.hasNext()) {
4554       atEstListagem = (AtributoEstruturaListagemItens) colecaoItensIt.next();
4555       item = atEstListagem.getItem();
4556 
4557       if (item.getCodIett().equals(itemEstrutura.getCodIett())) {
4558         while (colecaoItensIt.hasNext()) {
4559           atEstListagem = (AtributoEstruturaListagemItens) colecaoItensIt.next();
4560           item = atEstListagem.getItem();
4561           if (item.getNivelIett() == itemEstrutura.getNivelIett() + 1)
4562             retornoList.add(atEstListagem);
4563           if (item.getNivelIett() <= itemEstrutura.getNivelIett())
4564             break;
4565         }
4566         break;
4567       }
4568     }
4569 
4570     return retornoList;
4571   }
4572 
4573   /**
4574    * Verifica em uma colection ordenada se determinado itemEstrutura passado tem
4575    * filhos.
4576    * @param itemEstrutura
4577    * @param colecaoItens
4578    * @return Lista com os descendentes imediatos
4579    */
4580   public boolean existeDescendentesImediatos(ItemEstruturaIett itemEstrutura, List<AtributoEstruturaListagemItens> colecaoItens) {
4581     boolean retorno = false;
4582     AtributoEstruturaListagemItens atEstListagem = null;
4583     ItemEstruturaIett item = null;
4584     Iterator colecaoItensIt = colecaoItens.iterator();
4585 
4586     while (colecaoItensIt.hasNext()) {
4587       atEstListagem = (AtributoEstruturaListagemItens) colecaoItensIt.next();
4588       item = atEstListagem.getItem();
4589 
4590       if (item.getCodIett().equals(itemEstrutura.getCodIett())) {
4591         if (colecaoItensIt.hasNext()) {
4592           atEstListagem = (AtributoEstruturaListagemItens) colecaoItensIt.next();
4593           item = atEstListagem.getItem();
4594           if (item.getNivelIett() == itemEstrutura.getNivelIett() + 1)
4595             retorno = true;
4596         }
4597         break;
4598       }
4599     }
4600 
4601     return retorno;
4602   }
4603 
4604   /**
4605    * Verificar se o usuario eh funcao de acompanhamento com permissao de editar
4606    * o campo mesmo que ele esteja bloqueado para planejamento
4607    */
4608   public boolean podeEditarAtributoBloqueadoNaEstrutura(ItemEstruturaIett itemEstrutura, ObjetoEstrutura atributo, UsuarioUsu usuario, Set gruposAcesso) {
4609     List funcoesAcompanhamenoDoUsuario = null;
4610 
4611     try {
4612       funcoesAcompanhamenoDoUsuario = new TipoFuncAcompDao(null).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura, usuario, gruposAcesso);
4613       Set liberadoParaFuncoesAcompanhamento = atributo.iGetLibTipoFuncAcompTpfas();
4614 
4615       for (Iterator<TipoFuncAcompTpfa> itFuncaosAcompDoUsuario = funcoesAcompanhamenoDoUsuario.iterator(); itFuncaosAcompDoUsuario.hasNext();) {
4616         TipoFuncAcompTpfa funcaoAcompDoUsuario = (TipoFuncAcompTpfa) itFuncaosAcompDoUsuario.next();
4617 
4618         if (liberadoParaFuncoesAcompanhamento != null && liberadoParaFuncoesAcompanhamento.contains(funcaoAcompDoUsuario)) {
4619           return true; // pode editar o campo
4620         }
4621 
4622       }
4623 
4624     } catch (ECARException e) {
4625       e.printStackTrace();
4626     }
4627 
4628     return false;
4629   }
4630 
4631   private boolean podeEditarAtributoBloqueadoNaEstrutura(ItemEstruturaIett itemEstrutura, ObjetoEstrutura atributo, List funcoesAcompanhamenoDoUsuario) {
4632 
4633     Set liberadoParaFuncoesAcompanhamento = atributo.iGetLibTipoFuncAcompTpfas();
4634 
4635     for (Iterator<TipoFuncAcompTpfa> itFuncaosAcompDoUsuario = funcoesAcompanhamenoDoUsuario.iterator(); itFuncaosAcompDoUsuario.hasNext();) {
4636       TipoFuncAcompTpfa funcaoAcompDoUsuario = (TipoFuncAcompTpfa) itFuncaosAcompDoUsuario.next();
4637 
4638       if (liberadoParaFuncoesAcompanhamento != null && liberadoParaFuncoesAcompanhamento.contains(funcaoAcompDoUsuario)) {
4639         return true; // pode editar o campo
4640       }
4641 
4642     }
4643 
4644     return false;
4645   }
4646 
4647 }