RevisaoItemEstrutura xref

View Javadoc

1   /*
2    * Created on 19/05/2006
3    *
4    */
5   package ecar.servlet.relatorio;
6   
7   import java.util.ArrayList;
8   import java.util.Collections;
9   import java.util.Comparator;
10  import java.util.Date;
11  import java.util.Iterator;
12  import java.util.List;
13  import java.util.Set;
14  
15  import javax.servlet.http.HttpServletRequest;
16  
17  import comum.database.Dao;
18  import comum.util.Data;
19  import comum.util.Pagina;
20  import comum.util.Util;
21  import comum.util.XmlBuilder;
22  
23  import ecar.bean.AtributoEstruturaListagemItens;
24  import ecar.bean.TotalizadorRelatorios;
25  import ecar.dao.ConfiguracaoDao;
26  import ecar.dao.EstruturaDao;
27  import ecar.dao.EstruturaFuncaoDao;
28  import ecar.dao.FuncaoDao;
29  import ecar.dao.IettIndResulRevIettrrDAO;
30  import ecar.dao.ItemEstruturaCriterioDao;
31  import ecar.dao.ItemEstruturaDao;
32  import ecar.dao.SituacaoDao;
33  import ecar.exception.ECARException;
34  import ecar.login.SegurancaECAR;
35  import ecar.pojo.ConfiguracaoCfg;
36  import ecar.pojo.CriterioCri;
37  import ecar.pojo.EstruturaEtt;
38  import ecar.pojo.EstruturaFuncaoEttf;
39  import ecar.pojo.EstruturaFuncaoEttfPK;
40  import ecar.pojo.FuncaoFun;
41  import ecar.pojo.IettIndResulRevIettrr;
42  import ecar.pojo.ItemEstFisicoRevIettfr;
43  import ecar.pojo.ItemEstLocalRevIettlr;
44  import ecar.pojo.ItemEstruturaIett;
45  import ecar.pojo.ItemEstruturarevisaoIettrev;
46  import ecar.pojo.ObjetoEstrutura;
47  import ecar.pojo.OrgaoOrg;
48  import ecar.pojo.SituacaoSit;
49  import ecar.pojo.UsuarioUsu;
50  
51  /**
52   * @author aleixo
53   *
54   */
55  public class RevisaoItemEstrutura extends AbstractServletReportXmlXsl {
56  
57      /**
58  	 * 
59  	 */
60  	private static final long serialVersionUID = 2395457474744685932L;
61  	private EstruturaDao estruturaDao;
62  	private ItemEstruturaDao itemEstruturaDao;
63  	private ItemEstruturaCriterioDao itemCriterioDao;
64  	private FuncaoDao funcaoDao;
65  	private SituacaoDao situacaoDao;
66  	private EstruturaFuncaoDao estruturaFuncaoDao;
67  	private SegurancaECAR seguranca = null;
68  	private List itensMarcados;
69  	private List idsEstrutura;
70  	private List totalizadores;
71  	private OrgaoOrg orgaoResponsavel;
72  	private String orgaoEscolhido = "";
73  	private boolean imprimirEstrutura;
74  	private String codEttEscolhida; 
75  	private long codIettPai;
76  	private EstruturaEtt estruturaEscolhida;
77  	
78  	/**
79  	 * Gera XML.<br>
80  	 * 
81  	 * @author N/C
82       * @since N/C
83       * @version N/C
84  	 * @param HttpServletRequest request
85  	 * @return StringBuffer
86  	 * @throws ECARException
87  	 */
88  	public StringBuffer getXml(HttpServletRequest request) throws ECARException{
89  
90  		XmlBuilder builder = new XmlBuilder();
91          estruturaDao = new EstruturaDao(request);
92          itemEstruturaDao = new ItemEstruturaDao(request);
93          itemCriterioDao = new ItemEstruturaCriterioDao(request);
94          estruturaFuncaoDao = new EstruturaFuncaoDao(request);
95          funcaoDao = new FuncaoDao(request);
96          situacaoDao = new SituacaoDao(request);
97          seguranca = (SegurancaECAR)request.getSession().getAttribute("seguranca");
98  		itensMarcados = new ArrayList();
99          idsEstrutura = new ArrayList();
100         totalizadores = new ArrayList();
101     	orgaoResponsavel = new OrgaoOrg();
102         
103     	imprimirEstrutura = ("S".equals(Pagina.getParamStr(request, "imprimirEstrutura"))) ? true : false;
104     	codEttEscolhida = Pagina.getParamStr(request, "codEttImprimir");
105     	codIettPai = Pagina.getParamLong(request, "codIettPaiImprimir");
106 
107     	ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(request);
108         ItemEstruturaIett item = new ItemEstruturaIett();
109         
110         if(!imprimirEstrutura){
111         	item = (ItemEstruturaIett) itemEstruturaDao.buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIett")));
112         }
113         else {
114         	estruturaEscolhida = (EstruturaEtt) estruturaDao.buscar(EstruturaEtt.class, Long.valueOf(codEttEscolhida)); 
115         }
116 
117         String datahora = Data.parseDateHour(new Date()).substring(0,16); //este método retorna dd/mm/aaaa hh:mm:ss:ssss. Faço Substring para poder pegar só "dd/mm/aaaa hh:mm"
118         ConfiguracaoCfg config = new ConfiguracaoDao(null).getConfiguracao();
119         String titulo = config.getTituloSistema();//Pagina.getParamStr(request, "titulo_sistema");
120         String tituloItens = "";
121         String cabecalho = "Itens de Revisão da Estrutura do " + titulo;
122         
123         
124     	//Verifica se é para filtrar por Critérios
125     	String criteriosCom = Pagina.getParamStr(request, "criteriosIncluidosCom");
126     	String criteriosSem = Pagina.getParamStr(request, "criteriosIncluidosSem");
127     	String[] criteriosParaFiltrarCom = (!"".equals(criteriosCom.trim())) ? criteriosCom.split("\\|") : new String[] {};
128     	String[] criteriosParaFiltrarSem = (!"".equals(criteriosSem.trim())) ? criteriosSem.split("\\|") : new String[] {};
129 
130     	List listaCriteriosCom = new ArrayList();					
131     	List listaCriteriosSem = new ArrayList();					
132 
133     	for(int i = 0; i < criteriosParaFiltrarCom.length; i++){
134     		listaCriteriosCom.add(criteriosParaFiltrarCom[i]);
135     	}
136         
137     	for(int i = 0; i < criteriosParaFiltrarSem.length; i++){
138     		listaCriteriosSem.add(criteriosParaFiltrarSem[i]);
139     	}
140 
141     	//Pegando as situacoes que foram selecionados como filtro
142     	String situacoes = Pagina.getParamStr(request, "situacoesIncluidas");
143     	String[] situacoesParaFiltrar = (!"".equals(situacoes.trim())) ? situacoes.split("\\|") : new String[] {};
144 
145     	List listaSituacoes = new ArrayList();					
146 
147     	for(int i = 0; i < situacoesParaFiltrar.length; i++){
148     		listaSituacoes.add(situacoesParaFiltrar[i]);
149     	}        
150     	
151     	//Pegando o órgão selecionado
152     	Dao dao = new Dao();
153 		String orgao =  request.getParameter("codOrgaoSelecionado");
154         
155     	if(!"".equals(orgao) && orgao != null){
156     		orgaoResponsavel = (OrgaoOrg) dao.buscar(OrgaoOrg.class, Long.valueOf(orgao));
157     	}
158     	
159     	orgaoEscolhido = (orgaoResponsavel.getCodOrg() != null) ? orgaoResponsavel.getSiglaOrg() : "Todos os Órgãos";
160         
161         if("T".equals(Pagina.getParamStr(request, "todosCheck"))){
162         	tituloItens = "Todos";
163         }
164         else if("M".equals(Pagina.getParamStr(request, "todosCheck"))){
165         	tituloItens = "Monitorados";
166         }
167         else if("N".equals(Pagina.getParamStr(request, "todosCheck"))){
168         	tituloItens = "Não Monitorados";
169         }
170         else {
171         	tituloItens = "Conforme Relação Informada Pelo Usuário";
172         }
173         
174         builder.addNode("relatorio", 
175         		"titulo=\"" + builder.normalize(cabecalho) + "\"" +
176         		" datahora=\"" + datahora + "\"");
177         
178         /* Imprime a capa*/
179         geraXMLCapa(builder, titulo, tituloItens, orgaoEscolhido, listaCriteriosCom, listaCriteriosSem, listaSituacoes);
180 
181         if(!imprimirEstrutura){
182         	itensMarcados.add(item.getCodIett().toString());
183         }
184         
185         String[] itensMarcadosNaPagina = request.getParameterValues("itemFilho");
186         
187         if(itensMarcadosNaPagina != null){
188             for(int i = 0; i < itensMarcadosNaPagina.length; i++){
189             	itensMarcados.add(itensMarcadosNaPagina[i]);
190             }
191         }
192 
193         /* Imprime o relatório do Item Principal */ 
194         geraXMLItem(builder, item, orgao, listaCriteriosCom, listaCriteriosSem, listaSituacoes);
195             
196         geraXMLTotalizador(builder);
197         
198         builder.closeNode("relatorio");
199 
200         return builder.toStringBuffer();
201     }
202     
203 	/**
204 	 * Gera capa xml.<br>
205 	 * 
206 	 * @author N/C
207      * @since N/C
208      * @version N/C
209 	 * @param XmlBuilder builder
210 	 * @param String titulo
211 	 * @param String tituloItens
212 	 * @param String orgao
213 	 * @param List listaCriteriosCom
214 	 * @param List listaCriteriosSem
215 	 * @param List listaSituacoes
216 	 * @throws ECARException
217 	 */
218     public void geraXMLCapa(XmlBuilder builder, String titulo, String tituloItens, String orgao, 
219     		List listaCriteriosCom, List listaCriteriosSem, List listaSituacoes) throws ECARException{
220         builder.addNode("capa",
221         		"titulo=\"" + builder.normalize(titulo) + "\"" +
222         		" tituloItens=\"" + builder.normalize(tituloItens) + "\"" +
223         		" orgao=\"" + builder.normalize(orgao) + "\"");
224         
225     	FuncaoFun criterioFun = funcaoDao.getFuncao(Long.valueOf("6")); // 6 = Critérios
226     	
227     	if(criterioFun != null && 
228     			(listaCriteriosCom != null && listaCriteriosCom.size() > 0
229     			|| listaCriteriosSem != null && listaCriteriosSem.size() > 0)){
230         	builder.addNode("filtros", "tipo=\"" + builder.normalize(criterioFun.getLabelPadraoFun()) + "\"" +
231         					" estilo=\"CS\""); //CS --> Monta tabela com colunas de Com/Sem
232 	        
233         	if(listaCriteriosCom != null && listaCriteriosCom.size() > 0){
234 	        	Iterator itCriterios = listaCriteriosCom.iterator();
235 		        while(itCriterios.hasNext()){
236 		        	String id = (String) itCriterios.next();
237 		        	CriterioCri criterio = (CriterioCri) itemCriterioDao.buscar(CriterioCri.class, Long.valueOf(id));
238 		        	
239 		        	if(criterio != null){
240 		        		builder.addClosedNode("filtro", " valor=\"" + builder.normalize(criterio.getDescricaoCri()) + "\" tipo=\"C\"");
241 		        	}
242 		        }
243         	}
244         	
245         	if(listaCriteriosSem != null && listaCriteriosSem.size() > 0){
246 	        	Iterator itCriterios = listaCriteriosSem.iterator();
247 		        while(itCriterios.hasNext()){
248 		        	String id = (String) itCriterios.next();
249 		        	CriterioCri criterio = (CriterioCri) itemCriterioDao.buscar(CriterioCri.class, Long.valueOf(id));
250 		        	
251 		        	if(criterio != null){
252 		        		builder.addClosedNode("filtro", " valor=\"" + builder.normalize(criterio.getDescricaoCri()) + "\" tipo=\"S\"");
253 		        	}
254 		        }
255         	}
256 	        
257         	builder.closeNode("filtros");
258     	}
259     	
260     	if(listaSituacoes != null && listaSituacoes.size() > 0){
261         	builder.addNode("filtros", "tipo=\"" + builder.normalize("Situações") + "\"" +
262 			" estilo=\"SI\""); //SI --> Simples, Sem colunas de Com/Sem
263         	
264         	Iterator itSituacoes = listaSituacoes.iterator();
265         	while(itSituacoes.hasNext()){
266         		String id = (String) itSituacoes.next();
267         		SituacaoSit situacao = (SituacaoSit) situacaoDao.buscar(SituacaoSit.class, Long.valueOf(id)); 
268         		if(situacao != null){
269         			builder.addClosedNode("filtro", " valor=\"" + builder.normalize(situacao.getDescricaoSit()) + "\" tipo=\"N\"");
270         		}
271         	}
272         	builder.closeNode("filtros");
273     	}
274         
275         builder.closeNode("capa");
276     }
277 
278     /**
279      * Gera item xml.<br>
280      * 
281      * @author N/C
282      * @since N/C
283      * @version N/C
284      * @param XmlBuilder builder
285      * @param ItemEstruturaIett item
286      * @param String orgao
287      * @param List listaCriteriosCom
288      * @param List listaCriteriosSem
289      * @param List listaSituacoes
290      * @throws ECARException
291      */
292     public void geraXMLItem(XmlBuilder builder, ItemEstruturaIett item, String orgao, List listaCriteriosCom, 
293     		List listaCriteriosSem, List listaSituacoes) throws ECARException{
294         builder.addNode("item");
295 
296         /*
297         if(!imprimirEstrutura){
298 	        geraXMLHierarquia(builder, item);
299 	        
300 	        boolean mostrarDados = false;
301 	        
302 	        if("".equals(orgao) || orgao == null){ //Todos
303 	        	mostrarDados = true;
304 	        }
305 	        //Para o relatório de Revisão, pegar sempre OrgaoResponsavel2
306 	        else if (orgao != null && item.getOrgaoOrgByCodOrgaoResponsavel2Iett() != null && orgao.equals(item.getOrgaoOrgByCodOrgaoResponsavel2Iett().getCodOrg().toString())){
307 	        	mostrarDados = true;
308 	        }
309 	        
310 	        if (!itensMarcados.contains(item.getCodIett().toString())){
311 	        	mostrarDados = false;
312 	        }
313 	        
314 	        if(mostrarDados){
315 	        	
316 	        	List revisoes = itemEstruturaDao.getItemEstruturaRevisaoIettrevOrderByData(item.getCodIett());
317 	        	
318 	        	if(revisoes != null && revisoes.size() > 0){
319 	        		Iterator itItemRevisao = revisoes.iterator();
320 	        		while(itItemRevisao.hasNext()){
321 	        			ItemEstruturarevisaoIettrev itemRevisao = (ItemEstruturarevisaoIettrev) itItemRevisao.next();
322 	        			geraXMLDadosBasicos(builder, itemRevisao);
323 	        			geraXMLFuncoes(builder, itemRevisao);
324 	        		}
325 	        	}
326 	        }
327         }*/
328         
329        	geraXMLFilhosPorOrgao(builder, item, orgao, listaCriteriosCom, listaCriteriosSem, listaSituacoes);
330        
331         builder.closeNode("item");
332     }
333     
334     /**
335      * Gera funções xml.<br>
336      * 
337      * @author N/C
338      * @since N/C
339      * @version N/C
340      * @param XmlBuilder builder
341      * @param ItemEstruturarevisaoIettrev itemRevisao
342      * @throws ECARException
343      */
344     public void geraXMLFuncoes(XmlBuilder builder, ItemEstruturarevisaoIettrev itemRevisao) throws ECARException{
345     	String funcaoAtual = "";
346     	try {
347 	    	boolean mostrouIndicadorResultado = false;
348 	    	boolean exibirQuantidadesPrevistas = false;
349 	    	
350 	    	Set funcoes = itemRevisao.getEstruturaEttrev().getEstruturaFuncaoEttfs();
351 	        List funcoesParalela = new ArrayList(funcoes);
352 	    	
353 	        Iterator itFuncoes = funcoes.iterator();
354 	        while(itFuncoes.hasNext()){
355 	            EstruturaFuncaoEttf estruturaFuncao = (EstruturaFuncaoEttf) itFuncoes.next();
356 	            funcaoAtual = estruturaFuncao.getLabelEttf();
357 	
358 	            boolean mostraDados = false;
359 	            if("S".equals(estruturaFuncao.getIndRevisaoEttf())){
360 	                mostraDados = true;
361 	            }
362 	
363 	            if(mostraDados){
364 	
365 	            	String funcao = Util.primeiraLetraToUpperCase(estruturaFuncao.getFuncaoFun().getNomeFun());
366 	            	if ("Quantidades_Previstas".equals(funcao)){
367 	            		exibirQuantidadesPrevistas = true;
368 	            		if (!mostrouIndicadorResultado){
369 	            			mostrouIndicadorResultado = true;
370 	            			EstruturaFuncaoEttf funcaoPai = this.buscarFuncaoPai(itemRevisao, Long.valueOf("14")); //Indicadores de Resultado
371 	                		if(funcaoPai != null){
372 	                			this.geraXMLIndicadores_Resultado(builder, itemRevisao, funcaoPai.getLabelEttf(), exibirQuantidadesPrevistas);
373 	                		}
374 	            		}
375 	            	}
376 	            	else if ("Indicadores_Resultado".equals(funcao)){
377 	        			if(!mostrouIndicadorResultado){
378 	        				mostrouIndicadorResultado = true;
379 	           				exibirQuantidadesPrevistas = this.verificarFuncao("Quantidades_Previstas", funcoesParalela);
380 	        				this.geraXMLIndicadores_Resultado(builder, itemRevisao, estruturaFuncao.getLabelEttf(), exibirQuantidadesPrevistas);
381 	        			}
382 	        			else {
383 	        				continue;
384 	        			}
385 	        		}
386 	            	else if ("Localizacao".equals(funcao)){
387 	            		this.geraXMLLocalizacao(builder, itemRevisao, estruturaFuncao.getLabelEttf());
388 	            	}
389 	            }
390 	        } 
391 
392     	} catch(Exception e){
393     		this.logger.error(e);
394     		throw new ECARException("Erro na criação do Relatório: Funções - " + funcaoAtual);
395     	}
396     }
397     
398     /**
399      * Gera hierarquia xml.<br>
400      * 
401      * @author N/C
402      * @since N/C
403      * @version N/C
404      * @param XmlBuilder builder
405      * @param ItemEstruturaIett item
406      * @throws ECARException
407      */
408     public void geraXMLHierarquia(XmlBuilder builder, ItemEstruturaIett item) throws ECARException{
409         try{
410             builder.addNode("hierarquia");
411             ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(null);
412     	    List pais = itemEstruturaDao.getAscendentes(item);
413     	    Iterator it = pais.iterator();
414     	    while(it.hasNext()){
415     	        ItemEstruturaIett pai = (ItemEstruturaIett) it.next();
416 				String nomeNivel = pai.getNomeIett();
417 				if(pai.getSiglaIett() != null && !"".equals(pai.getSiglaIett()))
418 					nomeNivel = pai.getSiglaIett() + " - " + nomeNivel;
419 				builder.addClosedNode("nivel", "estrutura=\"" + builder.normalize(pai.getEstruturaEtt().getNomeEtt()) + ":\" nomeNivel=\"" + builder.normalize(nomeNivel) + "\"");
420 				
421 				this.incrementarTotalizador(pai.getEstruturaEtt().getCodEtt(), pai.getEstruturaEtt().getNomeEtt() + ":");
422     	    }
423 			String nomeNivel = item.getNomeIett();
424 			if(item.getSiglaIett() != null && !"".equals(item.getSiglaIett()))
425 				nomeNivel = item.getSiglaIett() + " - " + nomeNivel;
426 			builder.addClosedNode("nivel", "estrutura=\"" + builder.normalize(item.getEstruturaEtt().getNomeEtt()) + ":\" nomeNivel=\"" + builder.normalize(nomeNivel) + "\"");
427     	    
428 			this.incrementarTotalizador(item.getEstruturaEtt().getCodEtt(), item.getEstruturaEtt().getNomeEtt() + ":");
429 			
430     	    builder.closeNode("hierarquia");
431         } catch(Exception e){
432         	this.logger.error(e);
433             throw new ECARException("Erro na criação do Relatório: Hierarquia de Itens");
434         }
435     }
436 
437     /**
438      * Gera dados basicos xml.<br>
439      * 
440      * @author N/C
441      * @since N/C
442      * @version N/C
443      * @param XmlBuilder builder
444      * @param ItemEstruturarevisaoIettrev itemRevisao
445      * @throws ECARException
446      */
447     public void geraXMLDadosBasicos(XmlBuilder builder, ItemEstruturarevisaoIettrev itemRevisao) throws ECARException{
448         try{
449             /* DADOS BÁSICOS */
450             builder.addNode("dadosBasicos");
451             
452             //Situação é um dado fixo e obrigatório em cadastroItens/revisao/form.jsp
453             String situacao = "";
454             if("A".equals(itemRevisao.getSituacaoIettrev()))
455 	            situacao = "Alteração";
456             else if ("I".equals(itemRevisao.getSituacaoIettrev()))
457             	situacao = "Inclusão";
458             else if ("E".equals(itemRevisao.getSituacaoIettrev()))
459             	situacao = "Exclusão";
460             else if ("S".equals(itemRevisao.getSituacaoIettrev()))
461             	situacao = "Sem Modificação";
462             
463             if (situacao != null && !"".equals(situacao.trim()))
464 	            builder.addClosedNode(descobreTipo("situacaoIettrev"), 
465 	            		"label=\"" + builder.normalize("Situação") + ": \"" + 
466 	            		" valor=\"" + builder.normalize(situacao) + "\"");
467             
468             List dados = estruturaDao.getAtributosEstruturaRevisao(itemRevisao.getEstruturaEttrev());
469             if(dados.size() > 0){
470                 Iterator itDados = dados.iterator();
471                 while(itDados.hasNext()){
472                     ObjetoEstrutura estruturaAtributo = (ObjetoEstrutura) itDados.next();
473 
474                     if(estruturaAtributo != null){
475 	                    String nomeAtributo = estruturaAtributo.iGetNome();  
476 	                    String valor = estruturaAtributo.iGetValor(itemRevisao);
477 	                    String tipoAtributo = descobreTipo(nomeAtributo);
478 	                    
479 	                    valor = Util.normalizaCaracterMarcador(valor);
480 	                    
481 	                    if(valor != null && !"".equals(valor.trim()))
482 	                    	builder.addClosedNode(tipoAtributo, "label=\"" + builder.normalize(estruturaAtributo.iGetLabel()) + ": \"" + " valor=\"" + builder.normalize(valor) + "\"");
483                     }
484                 }
485             }
486             //Justificativa SEMPRE mostra
487             if (itemRevisao.getJustificativaIettrev() != null && !"".equals(itemRevisao.getJustificativaIettrev().trim()))
488 	            builder.addClosedNode(descobreTipo("justificativaIettrev"), 
489 	            		"label=\"" + builder.normalize("Justificativa") + ": \"" + 
490 	            		" valor=\"" + builder.normalize(Util.normalizaCaracterMarcador(itemRevisao.getJustificativaIettrev())) + "\"");
491 
492             builder.closeNode("dadosBasicos");
493         } catch(Exception e){
494         	this.logger.error(e);
495             throw new ECARException("Erro na criação do relatório: Dados Básicos");               
496         }
497     }
498 
499     /**
500      * Gera localização xml.<br>
501      * 
502      * @author N/C
503      * @since N/C
504      * @version N/C
505      * @param XmlBuilder builder
506      * @param ItemEstruturarevisaoIettrev itemRevisao
507      * @param String label
508      * @throws ECARException
509      */
510     public void geraXMLLocalizacao(XmlBuilder builder, ItemEstruturarevisaoIettrev itemRevisao, String label) throws ECARException{
511         try{
512             if(itemRevisao != null && itemRevisao.getItemEstLocalRevIettlrs() != null 
513             		&& itemRevisao.getItemEstLocalRevIettlrs().size() > 0){
514                 boolean first = true;
515                 
516                 List locais = new ArrayList(itemRevisao.getItemEstLocalRevIettlrs());
517                 Collections.sort(locais,
518 						new Comparator() {
519 			        		public int compare(Object o1, Object o2) {
520 			        		    return ( (ItemEstLocalRevIettlr)o1 ).getLocalItemLit().getIdentificacaoLit().compareToIgnoreCase( ( (ItemEstLocalRevIettlr)o2 ).getLocalItemLit().getIdentificacaoLit() );
521 			        		}
522 			    		} );                 
523                 
524                 Iterator it = locais.iterator();
525                 while(it.hasNext()){
526                     ItemEstLocalRevIettlr local = (ItemEstLocalRevIettlr) it.next();                   
527                     
528                     if(first){
529                         builder.addNode("localizacao", "label=\"" + builder.normalize(label) + "\" abrangencia=\"" + builder.normalize(local.getLocalItemLit().getLocalGrupoLgp().getIdentificacaoLgp()) + "\"");
530                         first = false;
531                     }
532                     builder.addAndCloseNode("local", builder.normalize(Pagina.trocaNull(local.getLocalItemLit().getIdentificacaoLit())));
533                 }        
534                 if(locais != null && locais.size() > 0)
535                 	builder.closeNode("localizacao");                    
536             }
537         } catch (Exception e){
538         	this.logger.error(e);
539             throw new ECARException("Erro na criação do relatório: " + label);               
540         }        
541     }
542 
543     /**
544      * Gera indicadores de resultado xml.<br>
545      * 
546      * @author N/C
547      * @since N/C
548      * @version N/C
549      * @param XmlBuilder builder
550      * @param ItemEstruturarevisaoIettrev itemRevisao
551      * @param String label
552      * @param boolean mostrarQuantidades
553      * @throws ECARException
554      */
555     public void geraXMLIndicadores_Resultado(XmlBuilder builder, ItemEstruturarevisaoIettrev itemRevisao, 
556     		String label, boolean mostrarQuantidades) throws ECARException{
557         try{
558         	List indicadores = new ArrayList(itemRevisao.getIettIndResulRevIettrrs());
559             if(indicadores != null && indicadores.size() > 0){
560                 builder.addNode("indicadoresResultado", "label=\"" + label + "\"");
561                 Iterator itIndicadores = indicadores.iterator();        
562                 while(itIndicadores.hasNext()){
563                 	IettIndResulRevIettrr indicador = (IettIndResulRevIettrr) itIndicadores.next();
564                     //ItemEstrtIndResulIettr indicador = (ItemEstrtIndResulIettr) itIndicadores.next();
565 /*                    String projecoes = "";
566                     String totalizacoes = "";
567                 	
568                     if("S".equals(indicador.getIndProjecaoIettrr()))
569                         projecoes = "Sim";
570                     if("N".equals(indicador.getIndProjecaoIettrr()))
571                         projecoes = "Não";
572                     double total = 0;
573                     if("S".equals(indicador.getIndAcumulavelIettrr())){
574                         totalizacoes = "Sim";
575                         total = new IettIndResulRevIettrrDAO(null).getSomaQuantidades(indicador);
576                     }   
577                                         
578                     if("N".equals(indicador.getIndAcumulavelIettrr())){                    
579                         totalizacoes = "Não";                
580                     }
581 */                     
582                 	String nome = "não informado";
583                 	String unidade = "";
584                 	String projecoes = "";
585                 	String totalizacoes = "";
586                 	String valorFinal = "";
587                     String strTotal = "";
588                 	
589                 	if(indicador.getItemEstrtIndResulIettr() != null){
590                 		nome = indicador.getItemEstrtIndResulIettr().getNomeIettir();
591                 		unidade = indicador.getItemEstrtIndResulIettr().getUnidMedidaIettr();
592                 		
593                         if("S".equals(indicador.getItemEstrtIndResulIettr().getIndProjecaoIettr()))
594                             projecoes = "Sim";
595                         if("N".equals(indicador.getItemEstrtIndResulIettr().getIndProjecaoIettr()))
596                             projecoes = "Não";
597                         
598                         if("S".equals(indicador.getItemEstrtIndResulIettr().getIndAcumulavelIettr())){
599                             totalizacoes = "Sim";
600                         }   
601                         else {
602                         	if("M".equals(indicador.getItemEstrtIndResulIettr().getIndValorFinalIettr()))
603                         		valorFinal = "Maior";
604                         	else if("U".equals(indicador.getItemEstrtIndResulIettr().getIndValorFinalIettr()))
605                         		valorFinal = "Último";
606                         	else if("N".equals(indicador.getItemEstrtIndResulIettr().getIndValorFinalIettr()))
607                         		valorFinal = "Não se aplica";
608                         }
609                         
610                     	strTotal = new IettIndResulRevIettrrDAO(null).getSomaQuantidadePrevista(indicador);
611                                            
612                         if("N".equals(indicador.getItemEstrtIndResulIettr().getIndAcumulavelIettr())){                    
613                             totalizacoes = "Não";                
614                         }                    
615 
616                         
617                 	}
618                     builder.addNode("indicador", "nome=\"" + builder.normalize(nome) + "\"" +
619 //                    		" descricao=\"" + builder.normalize(Pagina.trocaNull(indicador.getDescricaoIettirr())) + "\"" +
620                     		" unidade=\"" + builder.normalize(unidade) + "\"" +
621                     		" totalizacoes=\"" + builder.normalize(totalizacoes) + "\"" +
622                     		" valorFinal=\"" + builder.normalize(valorFinal) + "\"" + 
623                     		" projecoes=\"" + builder.normalize(projecoes) + "\"" +
624                     		" total = \"" + builder.normalize(strTotal) + "\"" +
625                     		"");
626                     
627                     if(mostrarQuantidades){
628                     	List exercicios = new ArrayList(indicador.getItemEstFisicoRevIettfrs());
629                     	
630                     	Collections.sort(exercicios,
631 							new Comparator() {
632 				        		public int compare(Object o1, Object o2) {
633 				        		    return ( (ItemEstFisicoRevIettfr)o1 ).getExercicioExe().getDescricaoExe().compareToIgnoreCase( ( (ItemEstFisicoRevIettfr)o2 ).getExercicioExe().getDescricaoExe() );
634 				        		}
635 				    		} );
636                     	
637 	                    Iterator it = exercicios.iterator();                
638 	                    while(it.hasNext()){
639 	                        ItemEstFisicoRevIettfr exercicio = (ItemEstFisicoRevIettfr) it.next();
640 	                        builder.addClosedNode("exercicio", "descricao=\"" + builder.normalize(Pagina.trocaNull(exercicio.getExercicioExe().getDescricaoExe())) + "\" quantidade=\"" + Pagina.trocaNullNumeroSemDecimal(exercicio.getQtdPrevistaIettfr().toString()) + "\"");
641 	                    }
642                     }
643                     builder.closeNode("indicador");
644                 }        
645                 builder.closeNode("indicadoresResultado");                    
646             }
647         } catch(Exception e){
648         	this.logger.error(e);
649             throw new ECARException("Erro na criação do relatório: " + label);            
650         }
651     }    
652       
653     
654     /***
655      * Gera filhos por orgão xml.<br>
656      * 
657      * @author N/C
658      * @since N/C
659      * @version N/C
660      * @param XmlBuilder builder
661      * @param ItemEstruturaIett item
662      * @param String orgao
663      * @param List listaCriteriosCom
664      * @param List listaCriteriosSem
665      * @param List listaSituacoes
666      * @throws ECARException
667      */
668     public void geraXMLFilhosPorOrgao(XmlBuilder builder, ItemEstruturaIett item, String orgao, 
669     		List listaCriteriosCom, List listaCriteriosSem, List listaSituacoes) throws ECARException{
670         try{
671         	UsuarioUsu usuarioLogado = seguranca.getUsuario();
672         	Set gruposUsuario = seguranca.getGruposAcesso();        	
673         	
674             //Set filhos = item.getItemEstruturaIetts();
675             ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(null);
676             List filhos = new ArrayList();
677             
678             if(!imprimirEstrutura){
679             	filhos.addAll(itemEstruturaDao.getDescendentesComPermissoesOrdenado(item, usuarioLogado, gruposUsuario));
680             }
681             else {
682             	filhos.addAll(itemEstruturaDao.getDescendentesComPermissoesOrdenadoByEstrutura(estruturaEscolhida, codIettPai, usuarioLogado, gruposUsuario));
683             }
684         	
685             List itensTemp = new ArrayList(itemEstruturaDao.filtrarRelatorioItemEstrutura(filhos, orgaoResponsavel.getCodOrg(), listaCriteriosCom, listaCriteriosSem, listaSituacoes, "S", "N"));
686 
687             filhos.clear();
688         	//filhos.addAll(itemEstruturaDao.getArvoreItens(itensTemp, null));
689         	filhos.addAll(itensTemp);
690          
691         	Iterator it;
692         	if(!imprimirEstrutura){
693 	        	//remover os itens superiores ao nível atual
694 	    		it = filhos.iterator();
695 	    		while(it.hasNext()) {
696 	    			ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
697 	    			
698 	    			if(iett.getNivelIett().intValue() <= item.getNivelIett().intValue()) {
699 	    				it.remove();
700 	    			}
701 	    		}
702         	}
703         	
704         	// ordenar os itens pela sigla
705         	itensTemp = new ArrayList(filhos);
706         	filhos.clear();
707         	//filhos.addAll(itemEstruturaDao.getItensOrdenadosPorSiglaIett(itensTemp));
708         	//filhos.addAll(itemEstruturaDao.getItensOrdenados(itensTemp));
709         	List atributosListagem = new ArrayList(itemEstruturaDao.getItensOrdenados(itensTemp, null));
710         	Iterator itAtrList = atributosListagem.iterator();
711         	while(itAtrList.hasNext()){
712         		AtributoEstruturaListagemItens atList = (AtributoEstruturaListagemItens) itAtrList.next();
713         		filhos.add(atList.getItem());	
714         	}
715             
716             //if(filhos != null && filhos.size() > 0){
717         	if(atributosListagem != null && atributosListagem.size() > 0){
718                 //it = filhos.iterator();
719         		it = atributosListagem.iterator();
720                 while(it.hasNext()){
721                 	
722                     //ItemEstruturaIett itemFilho = (ItemEstruturaIett) it.next();
723                 	AtributoEstruturaListagemItens atbList = (AtributoEstruturaListagemItens) it.next();
724                 	ItemEstruturaIett itemFilho = atbList.getItem();
725 					
726                     String nomeNivelItem = builder.normalize(itemFilho.getEstruturaEtt().getNomeEtt()) + ": ";
727 					String nomeItem = " ";
728 					String itemSelecionado = "S";
729 
730 					/*
731 					if(itemFilho.getSiglaIett() != null && !"".equals(itemFilho.getSiglaIett()))
732 						nomeItem += itemFilho.getSiglaIett() + " - ";
733 					
734 					nomeItem += builder.normalize(itemFilho.getNomeIett());
735 					*/
736 					nomeItem = " " + ("".equals(atbList.getDescricao().trim()) ? itemFilho.getNomeIett() : atbList.getDescricao());
737 					
738 					if (!itensMarcados.contains(itemFilho.getCodIett().toString()))
739 						itemSelecionado = "N";
740 					
741 					builder.addNode("filho", "nomeNivel=\"" + builder.normalize(nomeNivelItem) + "\" nome=\"" + nomeItem + "\" " +
742                                     " nivel=\"" + itemFilho.getNivelIett().intValue() + "\"" +
743                                     " itemSelecionado=\"" + builder.normalize(itemSelecionado) + "\"");
744 
745 					builder.closeNode("filho");
746 
747 					this.incrementarTotalizador(itemFilho.getEstruturaEtt().getCodEtt(), nomeNivelItem);
748 					
749                     boolean mostrarDados = false;
750                     
751                     if("".equals(orgao) || orgao == null){ //Todos
752                     	mostrarDados = true;
753                     }
754                     //Para relatório de Revisao, pegar sempre OrgaoResponsavel2
755                     else if (orgao != null && itemFilho.getOrgaoOrgByCodOrgaoResponsavel2Iett() != null && orgao.equals(itemFilho.getOrgaoOrgByCodOrgaoResponsavel2Iett().getCodOrg().toString())){
756                     	mostrarDados = true;
757                     }
758                     
759                     if (!itensMarcados.contains(itemFilho.getCodIett().toString())){
760                     	mostrarDados = false;
761                     }
762                     
763                     if(mostrarDados){
764 
765                     	List revisoes = itemEstruturaDao.getItemEstruturaRevisaoIettrevOrderByData(itemFilho.getCodIett());
766 
767                     	if(revisoes != null && revisoes.size() > 0){
768                     		Iterator itItemRevisao = revisoes.iterator();
769                     		while(itItemRevisao.hasNext()){
770                     			ItemEstruturarevisaoIettrev itemRevisao = (ItemEstruturarevisaoIettrev) itItemRevisao.next();
771                     			geraXMLDadosBasicos(builder, itemRevisao);
772                     			geraXMLFuncoes(builder, itemRevisao);
773                     		}
774                     	}
775                     }
776                 }    
777             }            
778         } catch(Exception e){
779         	this.logger.error(e);
780             throw new ECARException("Erro na criação do relatório: Listagem de Itens Filho");
781         }            
782     }
783 
784     /**
785      * Gera totalizador xml.<br>
786      * 
787      * @author N/C
788      * @since N/C
789      * @version N/C
790      * @param XmlBuilder builder
791      * @throws ECARException
792      */
793     public void geraXMLTotalizador(XmlBuilder builder) throws ECARException{
794         try{
795         	int total = 0;
796         	builder.addNode("totalizadores");        	
797             Iterator itTotalizadores = totalizadores.iterator();
798             while(itTotalizadores.hasNext()){
799             	TotalizadorRelatorios tr = (TotalizadorRelatorios) itTotalizadores.next();
800             	String nome = tr.getEstrutura();
801             	String valor = "" + tr.getTotal();
802             	total += tr.getTotal();
803             	builder.addClosedNode("totalizador",
804             			"nome=\"" + builder.normalize(nome) + "\"" +
805             			" valor=\"" + builder.normalize(valor) + "\"");
806             }        	
807         	builder.addClosedNode("total", 
808         			"nome=\"Total:\"" +
809         			" valor=\"" + builder.normalize(String.valueOf(total)) + "\"");
810             builder.closeNode("totalizadores");
811         } catch(Exception e){
812         	this.logger.error(e);
813             throw new ECARException("Erro na criação do relatório: Totalizadores");
814         }            
815     }
816 
817     /**
818      * Descobre o tipo.<br>
819      * 
820      * @author N/C
821      * @since N/C
822      * @version N/C
823      * @param String nomeAtb
824      * @return String
825      */
826     private String descobreTipo(String nomeAtb) {
827        
828     	if("objetivoGeralIett".equals(nomeAtb) 
829     		|| "objetivoEspecificoIett".equals(nomeAtb)
830         	|| "beneficiosIett".equals(nomeAtb)
831         	|| "descricaoIett".equals(nomeAtb)
832         	|| "descricaoR1".equals(nomeAtb)
833         	|| "descricaoR2".equals(nomeAtb)
834         	|| "descricaoR3".equals(nomeAtb)
835             || "descricaoR4".equals(nomeAtb)
836             || "descricaoR5".equals(nomeAtb)
837         )
838             return "atributo2";
839         else
840             return "atributo1";
841     }
842 
843     /**
844      * Pega o nome do arquivo xsl.<br>
845      * 
846      * @author N/C
847      * @since N/C
848      * @version N/C
849      * @return String
850      */
851     public String getXslFileName() {
852         return "revisaoEstrutura.xsl";
853     }
854   
855     /**
856      * Pega o erro de pagina.<br>
857      * 
858      * @author N/C
859      * @since N/C
860      * @version N/C
861      * @param HttpServletRequest request
862      * @param String mensagem
863      * @return String
864      */
865     public String getErrorPage(HttpServletRequest request, String mensagem){        
866         String errorPage = "frm_rel.jsp?codIett=" + Pagina.getParamStr(request, "codIett") + "&msgOperacao=" + mensagem + "&codAba="+Pagina.getParamStr(request, "codAba"); 
867         return errorPage;
868     }
869 
870     /**
871      * Busca Função Pai.<br>
872      * 
873      * @author N/C
874      * @since N/C
875      * @version N/C
876      * @param ItemEstruturarevisaoIettrev item
877      * @param Long codigo
878      * @return EstruturaFuncaoEttf
879      * @throws ECARException
880      */
881     private EstruturaFuncaoEttf buscarFuncaoPai(ItemEstruturarevisaoIettrev item, Long codigo) throws ECARException {
882 		EstruturaFuncaoEttfPK chave = new EstruturaFuncaoEttfPK();
883 		chave.setCodEtt(item.getEstruturaEttrev().getCodEtt());
884 		chave.setCodFun(codigo);
885 		EstruturaFuncaoEttf funcaoPai = (EstruturaFuncaoEttf) this.estruturaFuncaoDao.buscar(EstruturaFuncaoEttf.class, chave);
886 		
887 		return funcaoPai;    	
888     }
889     
890     /**
891      * Verifica Função.<br>
892      * 
893      * @author N/C
894      * @since N/C
895      * @version N/C
896      * @param String funcao
897      * @param List funcoes
898      * @return boolean
899      */
900     private boolean verificarFuncao(String funcao, List funcoes){
901 		Iterator itFuncoes = funcoes.iterator();
902 		boolean retorno = false;
903 		while(itFuncoes.hasNext()){
904 			EstruturaFuncaoEttf funcaoParalela = (EstruturaFuncaoEttf) itFuncoes.next();
905 			if(funcao.equals(funcaoParalela.getFuncaoFun().getNomeFun())){
906                 if("S".equals(funcaoParalela.getIndRevisaoEttf())){
907                 	retorno = true;
908                 	break;
909                 }
910 			}
911 		}
912     	return retorno;
913     }
914     
915     /**
916      * Incrementa totalizador.<br>
917      * 
918      * @author N/C
919      * @since N/C
920      * @version N/C
921      * @param Long idEstrutura
922      * @param String nomeEstrutura
923      */
924     private void incrementarTotalizador(Long idEstrutura, String nomeEstrutura){
925     	if(!idsEstrutura.contains(idEstrutura)){
926     		TotalizadorRelatorios totalizador = new TotalizadorRelatorios();
927     		totalizador.setId(idEstrutura);
928     		totalizador.setEstrutura(nomeEstrutura);
929     		totalizador.setTotal(1);
930     		
931     		idsEstrutura.add(idEstrutura);
932     		totalizadores.add(totalizador);
933     	}
934     	else {
935     		Iterator itTotalizadores = totalizadores.iterator();
936     		while(itTotalizadores.hasNext()){
937     	   		TotalizadorRelatorios totalizador = (TotalizadorRelatorios) itTotalizadores.next();
938     	   	    
939     	   		if(idEstrutura.equals(totalizador.getId())){
940     	   			totalizador.incrementeTotal();
941     	   			break;
942     	   	    }
943     		}
944     	}
945     }
946 }